import FungibleToken from 0x9a0766d93b6608b7 import NonFungibleToken from 0x631e88ae7f1d7c20 import MetadataViews from 0x631e88ae7f1d7c20 import FlowToken from 0x7e60df042a9c0868 import NFTCatalog from 0x324c34e1c517e4db import Flowty from 0xe1d43e0cfc237807 import FlowtyTestNFT from 0xd9c02cdacccb25ab import HybridCustody from 0x294e44e1ec6993c6 transaction(listingResourceID: UInt64, flowtyStorefrontAddress: Address, ftPrivatePathIdentifier: String, nftReceiverAddress: Address, ftProviderAddress: Address) { let paymentVault: @FungibleToken.Vault let storefront: &Flowty.FlowtyStorefront{Flowty.FlowtyStorefrontPublic} let listing: &Flowty.Listing{Flowty.ListingPublic} let tokenReceiver: Capability<&{FungibleToken.Receiver}> let nftReceiver: Capability<&{NonFungibleToken.CollectionPublic}> prepare(acct: AuthAccount) { if(acct.borrow<&Flowty.FlowtyStorefront>(from: Flowty.FlowtyStorefrontStoragePath) == nil) { log("Setup Account NFT storefront sorage paths") // Create a new empty .Storefront let storefront <- Flowty.createStorefront() as! @Flowty.FlowtyStorefront // save it to the account acct.save(<-storefront, to: Flowty.FlowtyStorefrontStoragePath) // create a public capability for the .Storefront acct.unlink(Flowty.FlowtyStorefrontPublicPath) acct.link<&Flowty.FlowtyStorefront{Flowty.FlowtyStorefrontPublic}>(Flowty.FlowtyStorefrontPublicPath, target: Flowty.FlowtyStorefrontStoragePath) } self.storefront = getAccount(flowtyStorefrontAddress) .getCapability<&Flowty.FlowtyStorefront{Flowty.FlowtyStorefrontPublic}>( Flowty.FlowtyStorefrontPublicPath ) .borrow() ?? panic("Could not borrow FlowtyStorefront from provided address") self.listing = self.storefront.borrowListing(listingResourceID: listingResourceID) ?? panic("No Listing with that ID in FlowtyStorefront. Already funded or delisted.") let nft = self.listing.borrowNFT() 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.borrow<&NonFungibleToken.Collection>(from: storageCollectionPath) == nil { // create a new Collection let collection <- FlowtyTestNFT.createEmptyCollection() // Put the new Collection in storage acct.save(<-collection, to: storageCollectionPath) // create a public capability for the collection acct.link<&{NonFungibleToken.CollectionPublic, NonFungibleToken.Receiver, MetadataViews.ResolverCollection}>(publicCollectionPath, target: storageCollectionPath) } if !acct.getCapability<&{NonFungibleToken.CollectionPublic}>(publicCollectionPath)!.check() { acct.unlink(publicCollectionPath) acct.link<&{NonFungibleToken.CollectionPublic, NonFungibleToken.Receiver, MetadataViews.ResolverCollection}>(publicCollectionPath, target: storageCollectionPath) } self.nftReceiver = acct.getCapability<&{NonFungibleToken.CollectionPublic}>(publicCollectionPath) } else { let manager = acct.borrow<&HybridCustody.Manager>(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).getCapability<&{NonFungibleToken.CollectionPublic}>(publicCollectionPath) } assert(self.nftReceiver.borrow() != nil, message: "Missing or mis-typed NFT Collection") if ftProviderAddress == acct.address { let vault = acct.borrow<&{FungibleToken.Provider}>(from: /storage/flowTokenVault) ?? panic("Cannot borrow vault from acct storage") self.paymentVault <- vault.withdraw(amount: self.listing.getDetails().getTotalPayment()) self.tokenReceiver = acct.getCapability<&{FungibleToken.Receiver}>(/public/flowTokenReceiver) } else { let manager = acct.borrow<&HybridCustody.Manager>(from: HybridCustody.ManagerStoragePath) ?? panic("Missing or mis-typed HybridCustody Manager") let child = manager.borrowAccount(addr: ftProviderAddress) ?? panic("no child account with that address") let tokenProviderPrivatePath = PrivatePath(identifier: ftPrivatePathIdentifier) ?? panic("no private path found") let ftProviderCap = child.getCapability(path: tokenProviderPrivatePath, type: Type<&{FungibleToken.Provider}>()) ?? panic("no ft provider found") let tokenProvider = ftProviderCap as! Capability<&{FungibleToken.Provider}> 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).getCapability<&{FungibleToken.Receiver}>(/public/flowTokenReceiver) } 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