How to extend Cadence resource model

How to extend Cadence resource model

Flowns intro

Cadence Resource model

• resources can only exist in one place

• the resource can not be copied

• resources must be explicitly destroyed

• Resources can be nested in resources (such as NFT's Collection)

• the movement of resources will carry the movement of sub-resources (just like an express box)

• Resources can be stored under the storage path of the account or in other resources

• Resources have a special type values as a identifier

What extensions have been made based on the resource model

• subdomains are stored in the main domain name resource

• Universal collection InBox for FT

• Universal collection InBox for NFT

• user-defined key-value storage on chain, etc.

• Subdomains

• Vaults Mapping

• Collections Mapping

Subdomain

// Subdomain resource
pub resource Subdomain: SubdomainPublic, SubdomainPrivate {
    pub let id: UInt64
    pub let name: String
    pub let nameHash: String
    pub let parent: String
    access(self) let addresses:  {UInt64: String} // address record of subdomain
    access(self) let texts: {String: String} // key-value storage of subdomain
}

// Domain resource
pub resource NFT: DomainPublic, DomainPrivate, NonFungibleToken.INFT, MetadataViews.Resolver{

    pub let id: UInt64
    pub let name: String
    pub let nameHash: String
    // mapping for store Subdomain resrouces. Key == name hash:  0x5d...50f98a Value == resource : @Subdomain
    access(self) var subdomains: @{String: Subdomain}

    // ...

    // Create subdomain
    pub fun createSubDomain(name: String){
     // ...
     let subdomain <- create Subdomain(
        id: self.subdomainCount,
        name: name,
        nameHash: nameHash,
        parent: self.getDomainName(),
        parentNameHash: self.nameHash
      )

      // move the created Subdomain to Domain.subdomains collection
      let oldSubdomain <- self.subdomains[nameHash] <- subdomain

      // ...
    }

    // Remove subdomain
    pub fun removeSubDomain(nameHash: String){
      // ..

      // move the subdomain from Domain.subdomains collection
      let oldToken <- self.subdomains.remove(key: nameHash) ?? panic("missing subdomain")

     // destroy the subdomain resource
    destroy oldToken
    }

}

The Inbox for FT and NFT

  // Domain resource
  pub resource NFT: DomainPublic, DomainPrivate, NonFungibleToken.INFT, MetadataViews.Resolver{
    // for user config key/value on-chain
    access(self) let texts: {String: String}
    // for user config addresses in Flow Ethereum Bitcoin etc...
    access(self) let addresses:  {UInt64: String}

    // FT vaults mapping
    access(self) var vaults: @{String: FungibleToken.Vault}
    // NFT collections mapping
    access(self) var collections: @{String: NonFungibleToken.Collection}

    // ...

  }

    // deposit FT token to Flowns domain
    pub fun depositVault(from: @FungibleToken.Vault, senderRef: &{FungibleToken.Receiver}?) {

      // get ft resource type identifier
      let typeKey = from.getType().identifier
      // add type whitelist check
      assert(FNSConfig.checkFTWhitelist(typeKey) == true, message: "FT type is not in inbox whitelist")
      let amount = from.balance
      let address = from.owner?.address

      // add vault resource if not init before
      if self.vaults[typeKey] == nil {
        self.vaults[typeKey] <-! from
      } else {
        // deposit to the corresponding vault
        let vault = (&self.vaults[typeKey] as &FungibleToken.Vault?)!

        vault.deposit(from: <- from)
      }
    }

    // withdraw FT from Flowns domain
    pub fun withdrawVault(key: String, amount: UFix64): @FungibleToken.Vault {
     // get Vault resource with type identifier key Eg: A.0ae53cb6e3f42a79.FlowToken.Vault
      let vaultRef = (&self.vaults[key] as &FungibleToken.Vault?)!
      let balance = vaultRef.balance
      var withdrawAmount = amount
      // withdraw all
      if amount == 0.0 {
        withdrawAmount = balance
      }
      // return withdraw Vault resource
      return <- vaultRef.withdraw(amount: withdrawAmount)
    }

    // add NFT collection to Flowns domain
    pub fun addCollection(collection: @NonFungibleToken.Collection) {

        // get collection type identifier
        let typeKey = collection.getType().identifier
        assert(FNSConfig.checkNFTWhitelist(typeKey) == true, message: "NFT type is not in inbox whitelist")

        // avoid the domain resource recursion
        if collection.isInstance(Type<@Domains.Collection>()) {
            panic("Do not nest domain resource")
        }

        if self.collections[typeKey] == nil {
            self.collections[typeKey] <-! collection
        } else {
            if collection.getIDs().length > 0 {
                panic("collection not empty ")
            }
            destroy collection
        }
    }


    // deposit NFT to Flowns domain
    pub fun depositNFT(key: String, token: @NonFungibleToken.NFT, senderRef: &{NonFungibleToken.CollectionPublic}?) {
      // ...
      assert(FNSConfig.checkNFTWhitelist(key) == true, message: "NFT type is not in inbox whitelist")

      let collectionRef = (&self.collections[key] as &NonFungibleToken.Collection?)!

      collectionRef.deposit(token: <- token)
    }

    // withdraw NFT from Flowns domain
    pub fun withdrawNFT(key: String, itemId: UInt64): @NonFungibleToken.NFT {
      // ...
      let collectionRef = (&self.collections[key] as &NonFungibleToken.Collection?)!

      return <- collectionRef.withdraw(withdrawID: itemId)
    }

Transaction fallback

// FT fallback script
transaction(amount: UFix64, recipient: Address) {

  // The Vault resource that holds the tokens that are being transfered
  let senderRef: &{FungibleToken.Receiver}
  let sentVault: @FungibleToken.Vault
  let sender: Add·ress

  prepare(signer: AuthAccount) {
    // Get a reference to the signer's stored vault
    let vaultRef = signer.borrow<&<Token>.Vault>(from: <Token>.VaultStoragePath)
      ?? panic("Could not borrow reference to the owner's Vault!")
    self.senderRef = signer.getCapability(<Token>.ReceiverPublicPath)
      .borrow<&{FungibleToken.Receiver}>()!
    self.sender = vaultRef.owner!.address
    // Withdraw tokens from the signer's stored vault
    self.sentVault <- vaultRef.withdraw(amount: amount)
  }

  execute {
    // Get the recipient's public account object
    let recipientAccount = getAccount(recipient)

    // Get a reference to the recipient's Receiver
    let receiverRef = recipientAccount.getCapability(<Token>.ReceiverPublicPath)
      .borrow<&{FungibleToken.Receiver}>()

    // Inbox fallback
    if receiverRef == nil {
        let collectionCap = recipientAccount.getCapability<&{Domains.CollectionPublic}>(Domains.CollectionPublicPath)
        let collection = collectionCap.borrow()!
        var defaultDomain: &{Domains.DomainPublic}? = nil

        let ids = collection.getIDs()

        if ids.length == 0 {
            panic("Recipient have no domain ")
        }

        defaultDomain = collection.borrowDomain(id: ids[0])!
           // check defualt domain
        for id in ids {
            let domain = collection.borrowDomain(id: id)!
            let isDefault = domain.getText(key: "isDefault")
            if isDefault == "true" {
            defaultDomain = domain
            }
        }
        // Deposit the withdrawn tokens in the recipient's domain inbox
        defaultDomain!.depositVault(from: <- self.sentVault, senderRef: self.senderRef)
    } else {
        // Deposit the withdrawn tokens in the recipient's receiver
        receiverRef!.deposit(from: <- self.sentVault)
    }
  }
}

// NFT fallback script
transaction(recipient: Address, withdrawID: UInt64) {
  prepare(signer: AuthAccount) {
    // get the recipients public account object
    let recipient = getAccount(recipient)

    // borrow a reference to the signer's NFT collection
    let collectionRef = signer
      .borrow<&NonFungibleToken.Collection>(from: <NFT>.CollectionStoragePath)
      ?? panic("Could not borrow a reference to the owner's collection")

    let senderRef = signer
      .getCapability(<NFT>.CollectionPublicPath)
      .borrow<&{NonFungibleToken.CollectionPublic}>()

    // borrow a public reference to the receivers collection
    let recipientRef = recipient
      .getCapability(<NFT>.CollectionPublicPath)
      .borrow<&{<NFT>.CollectionPublic}>()

    // Inbox fallback
    if recipientRef == nil {
        let collectionCap = recipient.getCapability<&{Domains.CollectionPublic}>(Domains.CollectionPublicPath)
        let collection = collectionCap.borrow()!
        var defaultDomain: &{Domains.DomainPublic}? = nil

        let ids = collection.getIDs()

        if ids.length == 0 {
            panic("Recipient have no domain ")
        }


	 defaultDomain = collection.borrowDomain(id: ids[0])!
      // check defualt Flowns domain
      for id in ids {
        let domain = collection.borrowDomain(id: id)!
        let isDefault = domain.getText(key: "isDefault")
        if isDefault == "true" {
          defaultDomain = domain
        }
      }
      let typeKey = collectionRef.getType().identifier

      let nft <- collectionRef.withdraw(withdrawID: withdrawID)
      if defaultDomain!.checkCollection(key: typeKey) == false {
        let collection <- <NFT>.createEmptyCollection()
        defaultDomain!.addCollection(collection: <- collection)
      }
      // deposite NFT to Flowns domain
        defaultDomain!.depositNFT(key: typeKey, token: <- nft, senderRef: senderRef )
      } else {
      // withdraw the NFT from the owner's collection
      let nft <- collectionRef.withdraw(withdrawID: withdrawID)
      // Deposit the NFT in the recipient's collection
      recipientRef!.deposit(token: <-nft)
    }
  }
}