import FungibleToken from 0xf233dcee88fe0abe import NonFungibleToken from 0x1d7e57aa55817448 import MetadataViews from 0x1d7e57aa55817448 import NFTCatalog from 0x49a7cda3a1eecc29 import NFTStorefrontV2 from 0x3cdbb3d569211ff3 import HybridCustody from 0xd8a7e05a7ac670c0 import FungibleTokenMetadataViews from 0xf233dcee88fe0abe import ViewResolver from 0x1d7e57aa55817448 import AddressUtils from 0xa340dc0a4ec828ab /// Storefront purchase txn that can route nfts to a child, and take tokens from a child to pay transaction( storefrontAddress: Address, listingResourceID: UInt64, commissionRecipient: Address, collectionIdentifier: String, nftReceiverAddress: Address, ftProviderAddress: Address, ftProviderControllerID: UInt64 ) { let paymentVault: @{FungibleToken.Vault} let collection: &{NonFungibleToken.CollectionPublic} let storefront: &{NFTStorefrontV2.StorefrontPublic} let listing: &{NFTStorefrontV2.ListingPublic} var commissionRecipientCap: Capability<&{FungibleToken.Receiver}>? var collectionCap: Capability<&{NonFungibleToken.CollectionPublic}> let listingAcceptor: auth(NFTStorefrontV2.Acceptor) &{NFTStorefrontV2.PrivateListingAcceptor} prepare(acct: auth(Storage, Capabilities) &Account) { if acct.storage.borrow<&NFTStorefrontV2.Storefront>(from: NFTStorefrontV2.StorefrontStoragePath) == nil { let storefront <- NFTStorefrontV2.createStorefront() acct.storage.save(<-storefront, to: NFTStorefrontV2.StorefrontStoragePath) acct.capabilities.unpublish(NFTStorefrontV2.StorefrontPublicPath) acct.capabilities.publish( acct.capabilities.storage.issue<&{NFTStorefrontV2.StorefrontPublic}>(NFTStorefrontV2.StorefrontStoragePath), at: NFTStorefrontV2.StorefrontPublicPath ) } self.listingAcceptor = acct.storage.borrow(from: NFTStorefrontV2.StorefrontStoragePath) ?? panic("Buyer storefront is invalid") let value = NFTCatalog.getCatalogEntry(collectionIdentifier: collectionIdentifier) ?? panic("Provided collection is not in the NFT Catalog.") self.commissionRecipientCap = nil // Access the storefront public resource of the seller to purchase the listing. self.storefront = getAccount(storefrontAddress).capabilities.get<&{NFTStorefrontV2.StorefrontPublic}>(NFTStorefrontV2.StorefrontPublicPath).borrow() ?? panic("Could not borrow Storefront from provided address") // Borrow the listing self.listing = self.storefront.borrowListing(listingResourceID: listingResourceID) ?? panic("Listing not found") let listingDetails = self.listing.getDetails() let nftRef = self.listing.borrowNFT() ?? panic("nft not found") if nftReceiverAddress == acct.address { self.collectionCap = acct.capabilities.get<&{NonFungibleToken.CollectionPublic}>(value.collectionData.publicPath) // unlink and relink first, if it still isn't working, then we will try to save it! if !self.collectionCap.check() { if acct.storage.borrow<&AnyResource>(from: value.collectionData.storagePath) == nil { // pull the metdata resolver for this listing's nft and use it to configure this account's collection // if it is not already configured. let collectionData = nftRef.resolveView(Type())! as! MetadataViews.NFTCollectionData acct.storage.save(<- collectionData.createEmptyCollection(), to: value.collectionData.storagePath) } acct.capabilities.unpublish(value.collectionData.publicPath) acct.capabilities.publish( acct.capabilities.storage.issue<&{NonFungibleToken.CollectionPublic}>(value.collectionData.storagePath), at: value.collectionData.publicPath ) self.collectionCap = acct.capabilities.get<&{NonFungibleToken.CollectionPublic}>(value.collectionData.publicPath) } } else { // signer is the parent account and nftProvider is child Account // get the manager resource and borrow proxyAccount let manager = acct.storage.borrow(from: HybridCustody.ManagerStoragePath) ?? panic("manager does not exist") let childAcct = manager.borrowAccount(addr: nftReceiverAddress) ?? panic("nft receiver address is not a child account") self.collectionCap = getAccount(nftReceiverAddress).capabilities.get<&{NonFungibleToken.CollectionPublic}>(value.collectionData.publicPath) // We can't change child account links in any way } // Access the acct or child's NFT collection to store the purchased NFT. self.collection = self.collectionCap.borrow() ?? panic("Cannot borrow NFT collection receiver") let paymentTokenAddress = AddressUtils.parseAddress(listingDetails.salePaymentVaultType)! let paymentTokenContractName = listingDetails.salePaymentVaultType.identifier.split(separator: ".")[2] let paymentTokenContract = getAccount(paymentTokenAddress).contracts.borrow<&{ViewResolver}>(name: paymentTokenContractName) ?? panic("payment token does not implement ViewResolver") let ftVaultData = paymentTokenContract.resolveContractView(resourceType: listingDetails.salePaymentVaultType, viewType: Type())! as! FungibleTokenMetadataViews.FTVaultData // Access the vault of the buyer/child to pay the sale price of the listing. 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: listingDetails.salePrice) } else { // signer is the parent account and ftProvider is child Account // get the manager resource and borrow proxyAccount let manager = acct.storage.borrow(from: HybridCustody.ManagerStoragePath) ?? panic("manager does not exist") let childAcct = manager.borrowAccount(addr: ftProviderAddress) ?? panic("ftProvider account not found") let providerCap = childAcct.getCapability(controllerID: ftProviderControllerID, type: Type()) ?? panic("token provider not found for supplied child account address") let ftProvider = providerCap as! Capability let ftProviderVault = ftProvider.borrow() ?? panic("child account token vault could not be borrowed") self.paymentVault <- ftProviderVault.withdraw(amount: listingDetails.salePrice) } if commissionRecipient != nil && listingDetails.commissionAmount != 0.0 { // Access the capability to receive the commission. let _commissionRecipientCap = getAccount(commissionRecipient).capabilities.get<&{FungibleToken.Receiver}>(ftVaultData.receiverPath) assert(_commissionRecipientCap.check(), message: "Commission Recipient doesn't have token receiving capability") self.commissionRecipientCap = _commissionRecipientCap } else if listingDetails.commissionAmount == 0.0 { self.commissionRecipientCap = nil } else { panic("Commission recipient can not be empty when commission amount is non zero") } } execute { // Purchase the NFT let item <- self.listing.purchase( payment: <-self.paymentVault, commissionRecipient: self.commissionRecipientCap, privateListingAcceptor: self.listingAcceptor ) // Deposit the NFT in the buyer's collection. self.collection.deposit(token: <-item) } }

Transaction