import FungibleToken from 0x9a0766d93b6608b7 import NonFungibleToken from 0x631e88ae7f1d7c20 import MetadataViews from 0x631e88ae7f1d7c20 import NFTCatalog from 0x324c34e1c517e4db import Flowty from 0xe1d43e0cfc237807 import HybridCustody from 0x294e44e1ec6993c6 import FungibleTokenMetadataViews from 0x9a0766d93b6608b7 import ViewResolver from 0x631e88ae7f1d7c20 import AddressUtils from 0x31ad40c07a2a9788 transaction( listingResourceID: UInt64, flowtyStorefrontAddress: Address, ftProviderControllerID: UInt64, nftReceiverAddress: Address, ftProviderAddress: Address ) { let paymentVault: @{FungibleToken.Vault} let storefront: &{Flowty.FlowtyStorefrontPublic} let listing: &{Flowty.ListingPublic} let tokenReceiver: Capability<&{FungibleToken.Receiver}> let nftReceiver: Capability<&{NonFungibleToken.CollectionPublic}> prepare(acct: auth(Capabilities, Storage) &Account) { if(acct.storage.borrow<&Flowty.FlowtyStorefront>(from: Flowty.FlowtyStorefrontStoragePath) == nil) { let storefront <- Flowty.createStorefront() acct.storage.save(<-storefront, to: Flowty.FlowtyStorefrontStoragePath) acct.capabilities.publish( acct.capabilities.storage.issue<&{Flowty.FlowtyStorefrontPublic}>(Flowty.FlowtyStorefrontStoragePath), at: Flowty.FlowtyStorefrontPublicPath ) } self.storefront = getAccount(flowtyStorefrontAddress).capabilities.get<&{Flowty.FlowtyStorefrontPublic}>(Flowty.FlowtyStorefrontPublicPath) .borrow() ?? panic("Could not borrow FlowtyStorefront from provided address") assert(self.storefront.getType() == Type<@Flowty.FlowtyStorefront>(), message: "unexpected storefront type") self.listing = self.storefront.borrowListing(listingResourceID: listingResourceID) ?? panic("No Listing with that ID in FlowtyStorefront. Already funded or delisted.") let details = self.listing.getDetails() let nft = self.listing.borrowNFT() ?? panic("failed to borrow listing nft") let nftType = nft.getType() let catalogIdentifiers = NFTCatalog.getCollectionsForType(nftTypeIdentifier: nftType.identifier) ?? panic("not found in catalog") var catalogIdentifier = "" for k in catalogIdentifiers.keys { if catalogIdentifiers[k] == true { catalogIdentifier = k break } } assert(catalogIdentifier != "", message: "no valid catalog identifier found") let catalogEntry = NFTCatalog.getCatalogEntry(collectionIdentifier: catalogIdentifier) ?? panic("catalog entry not found") let publicCollectionPath = catalogEntry.collectionData.publicPath let storageCollectionPath = catalogEntry.collectionData.storagePath if nftReceiverAddress == acct.address { // ensure collection exists if acct.storage.borrow<&{NonFungibleToken.Collection}>(from: storageCollectionPath) == nil { // create a new Collection let collection <- nft.createEmptyCollection() // Put the new Collection in storage acct.storage.save(<-collection, to: storageCollectionPath) } if !acct.capabilities.get<&{NonFungibleToken.CollectionPublic}>(publicCollectionPath).check() { acct.capabilities.unpublish(publicCollectionPath) acct.capabilities.publish( acct.capabilities.storage.issue<&{NonFungibleToken.CollectionPublic}>(storageCollectionPath), at: publicCollectionPath ) } self.nftReceiver = acct.capabilities.get<&{NonFungibleToken.CollectionPublic}>(publicCollectionPath)! } else { let manager = acct.storage.borrow(from: HybridCustody.ManagerStoragePath) ?? panic("Missing or mis-typed HybridCustody Manager") assert(manager.borrowAccount(addr: nftReceiverAddress) != nil, message: "No child account with that address") self.nftReceiver = getAccount(nftReceiverAddress).capabilities.get<&{NonFungibleToken.CollectionPublic}>(publicCollectionPath)! } assert(self.nftReceiver.borrow() != nil, message: "Missing or mis-typed NFT Collection") let ftAddress = AddressUtils.parseAddress(details.paymentVaultType)! let contractName = details.paymentVaultType.identifier.split(separator: ".")[2] let ftContract = getAccount(ftAddress).contracts.borrow<&{FungibleToken}>(name: contractName) ?? panic("could not borrow fungible token contract") let ftVaultData = ftContract.resolveContractView(resourceType: details.paymentVaultType, viewType: Type())! as! FungibleTokenMetadataViews.FTVaultData if ftProviderAddress == acct.address { let vault = acct.storage.borrow(from: ftVaultData.storagePath) ?? panic("Cannot borrow token vault from acct storage") self.paymentVault <- vault.withdraw(amount: self.listing.getDetails().getTotalPayment()) self.tokenReceiver = acct.capabilities.get<&{FungibleToken.Receiver}>(ftVaultData.receiverPath) } else { let manager = acct.storage.borrow(from: HybridCustody.ManagerStoragePath) ?? panic("Missing or mis-typed HybridCustody Manager") let child = manager.borrowAccount(addr: ftProviderAddress) ?? panic("no child account with that address") let ftProviderCap = child.getCapability(controllerID: ftProviderControllerID, type: Type()) ?? panic("no ft provider found") let tokenProvider = ftProviderCap as! Capability assert(tokenProvider.check(), message: "invalid provider capability") let ftProviderVault = tokenProvider.borrow() ?? panic("child account token vault could not be borrowed") self.paymentVault <- ftProviderVault.withdraw(amount: self.listing.getDetails().getTotalPayment()) self.tokenReceiver = getAccount(ftProviderAddress).capabilities.get<&{FungibleToken.Receiver}>(ftVaultData.receiverPath) } assert(self.tokenReceiver.borrow() != nil, message: "Missing or mis-typed token receiver") } execute { self.listing.fund( payment: <-self.paymentVault, lenderFungibleTokenReceiver: self.tokenReceiver, lenderNFTCollection: self.nftReceiver ) } }

Transaction