About Flow FT && NFT token standard update

About FT and NFT token standard update

• This update and upgrade is only deployed in the testnet, and the new features need to be supported by a new spork.

• The existing FT contract does not force to upgrades, you can choose not to upgrade, which will not affect normal use.

• The Vault resources that have been initialized by the user do not need to be reinitialized. If the contract implementation upgrades the function, the resources that have been initialized by the user will be inherited automatically.

• In addition to basic FT information, resource information and type information will also be included (guess is in preparation for information aggregation display on-chain)

• Similar to NFTMetadataView, FTMetadataView also has the ability to display type extensions to support more Metadata types in the future.

• FungibleTokenSwitchboard, as an additional routing resource, preserves the FT Receiver resources under the user's account, and can receive multiple type of FT token through one resource as a router.

FungibleTokenMetadataViews

• FTDisplay contains the information, such as names, symbols, descriptions, external links, Logo links and some social account links needed for FT display, which can be understood as the basic information of Token.

• FTVaultData this contains the resource information of FTVault and some type information of the interface, as well as an initialization function createEmptyVault to create Vault.

pub fun getViews(): [Type] {
     return []
   }

pub fun resolveView(_ view: Type): AnyStruct? {
    return nil
  }

Note: the changes of FungibleToken are slightly different here. Because of the addition of the implementation function in the Balance interface type, it will cause problems with the existing resources that inherit FungibleToken.Balance in the network. (normally speaking, a contract that inherits FungibleToken.Balance but does not implement getViews and resolveView cannot be properly deployed.) During a discussion with B.T.Wood, he told me a recent update of Cadence, if you inherit the resources of the interface, even if you do not implement the methods defined by the interface. Cadence will uses the default method of the interface itself, so that the above problems do not occur. This feature will be updated in future spork.

 pub fun getViews(): [Type]{
     return [Type<FungibleTokenMetadataViews.FTView>(),
        Type<FungibleTokenMetadataViews.FTDisplay>(),
        Type<FungibleTokenMetadataViews.FTVaultData>()]
        }

FungibleTokenSwitchboard

 pub resource Switchboard: FungibleToken.Receiver, SwitchboardPublic {

        access(contract) var receiverCapabilities: {Type: Capability<&{FungibleToken.Receiver}>}
        //....

}

• addNewVault Add a new Vault route to Switchboard via Capability

• addNewVaultsByPath Batch add to Switchboard through the array of resource paths

• removeVault remove

  pub fun deposit(from: @FungibleToken.Vault) {
            // Get the capability from the ones stored at the switchboard
            let depositedVaultCapability = self
                .receiverCapabilities[from.getType()]
                ?? panic ("The deposited vault is not available on this switchboard")
            // Borrow the reference to the desired vault
            let vaultRef = depositedVaultCapability.borrow()
                ?? panic ("Can not borrow a reference to the the vault")
            vaultRef.deposit(from: <-from)
        }

• getVaultTypes get the Vault types that supports reception

• deposit as mention berfore

• the secure deposit function safeDeposit does not cause Panic even if it fails, but returns the @FungibleToken.Vault resource

• same as Deposit, receiving @FungibleToken.Vault resource

• will first determine whether receiverCapabilities has a receiving resource configured for the corresponding resource.

• if it is not found and the deposit amount is greater than zero, the event of deposit failure will be triggered and the input @ FungibleToken.Vault resource will be returned.

• otherwise, destroy the top-up resources directly and return nil

 pub fun safeDeposit(from: @FungibleToken.Vault): @FungibleToken.Vault? {
            // Try to get the proper vault capability from the switchboard
            // If the desired vault is present on the switchboard...
            if let depositedVaultCapability = self
                                        .receiverCapabilities[from.getType()] {
                // We try to borrow a reference to the vault from the capability
                // If we can borrow a reference to the vault...
                if let vaultRef =  depositedVaultCapability.borrow() {
                    // We deposit the funds on said vault
                    vaultRef.deposit(from: <-from.withdraw(amount: from.balance))
                }
            }
            // if deposit failed for some reason
            if from.balance > 0.0 {
                emit NotCompletedDeposit(type: from.getType(),
                                        amount: from.balance,
                                        switchboardOwner: self.owner?.address)
                return <-from
            }
            destroy from
            return nil
        }

NFT borrowNFTSafe

Summary