import FungibleToken from 0xf233dcee88fe0abe import NonFungibleToken from 0x1d7e57aa55817448 import MetadataViews from 0x1d7e57aa55817448 import FiatToken from 0xb19436aae4d94622 import NFTCatalog from 0x49a7cda3a1eecc29 import Flowty from 0x5c57f79c6694797f import TopShot from 0x0b2a3299cc857e29 import HybridCustody from 0xd8a7e05a7ac670c0 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<&FiatToken.Vault{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 <- TopShot.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: FiatToken.VaultStoragePath) ?? panic("Cannot borrow vault from acct storage") self.paymentVault <- vault.withdraw(amount: self.listing.getDetails().getTotalPayment()) self.tokenReceiver = acct.getCapability<&FiatToken.Vault{FungibleToken.Receiver}>(FiatToken.VaultReceiverPubPath) } 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<&FiatToken.Vault{FungibleToken.Receiver}>(FiatToken.VaultReceiverPubPath) } 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