import FungibleToken from 0xf233dcee88fe0abe import NonFungibleToken from 0x1d7e57aa55817448 import ZelosAccountingToken from 0xc38aea683c0c4d38 import Eternal from 0xc38aea683c0c4d38 import Market from 0xc38aea683c0c4d38 import FlowStorageFees from 0xe467b9dd11fa00df import FlowToken from 0x1654653399040a61 import Shard from 0x82b54037a8f180cf // This transaction is for a buyer to purchase a moment or multiple moments that a seller has for sale in their collection // Parameters // Note: some array params must be in order. For example, the first element in sellerAddresses must // correspond to the first tokenID and first purchaseAmount. The only exception is shardIDs // which can be any length. // // sellerAddresses: the Flow address of the account issuing the sale of a moment // tokenIDs: the ID of the moment being purchased // purchaseAmounts: the amounts for which the buyer is paying for the moment; must not be less than the moment's price // shardIDs: the ID of the shard being given to the buyer (optional, can be left empty) transaction(sellerAddresses: [Address], tokenIDs: [UInt64], purchaseAmounts: [UFix64], shardIDs: [UInt64]) { let zatMinter: &ZelosAccountingToken.Administrator let adminVault: &FlowToken.Vault let adminShardCollection: &Shard.Collection let buyerAccount: AuthAccount let buyerCollection: &Eternal.Collection let buyerShardCollection: &Shard.Collection let buyerZATVault: &ZelosAccountingToken.Vault{FungibleToken.Provider} prepare(buyer: AuthAccount, admin: AuthAccount, minter: AuthAccount) { // Borrow a reference to the ZAT minter self.zatMinter = minter .borrow<&ZelosAccountingToken.Administrator>(from: /storage/zelosAccountingTokenAdmin) ?? panic("Signer is not the token admin") // Borrow a reference to the admin's flow token vault self.adminVault = admin .borrow<&FlowToken.Vault>(from: /storage/flowTokenVault) ?? panic("Failed to borrow reference to admin vault") // Borrow a reference to the admin's shard collection self.adminShardCollection = admin .borrow<&Shard.Collection>(from: /storage/EternalShardCollection) ?? panic("Could not borrow a reference to the admin shard collection") self.buyerAccount = buyer // Borrow a reference to the buyer's moment collection self.buyerCollection = buyer .borrow<&Eternal.Collection>(from: /storage/EternalMomentCollection) ?? panic("Could not borrow reference to the moment collection") // Create a shard collection if buyer does not have one if buyer.borrow<&Shard.Collection>(from: /storage/EternalShardCollection) == nil { // Create a new shard collection let buyerCollection <- Shard.createEmptyCollection() // Put the new collection in storage buyer.save(<-buyerCollection, to: /storage/EternalShardCollection) // Create a public capability for the collection buyer.link<&{Shard.ShardCollectionPublic}>(/public/EternalShardCollection, target: /storage/EternalShardCollection) } // Borrow a reference to the buyer's shard collection self.buyerShardCollection = buyer .borrow<&Shard.Collection>(from: /storage/EternalShardCollection) ?? panic("Could not borrow a reference to the shard collection") // Borrow a reference to the buyer's fungible token vault self.buyerZATVault = buyer .borrow<&ZelosAccountingToken.Vault{FungibleToken.Provider}>(from: /storage/zelosAccountingTokenVault)! } pre { sellerAddresses.length == tokenIDs.length && tokenIDs.length == purchaseAmounts.length } execute { // Function that determines if an account needs more storage (used for all buyers and sellers) fun returnFlowFromStorage(_ storage: UInt64): UFix64 { // Safe convert UInt64 to UFix64 (without overflow) let f = UFix64(storage % 100000000) * 0.00000001 + UFix64(storage / 100000000) // Decimal point correction. Megabytes to bytes have a conversion of 10^-6 while UFix64 minimum value is 10^-8 let storageMb = f * 100.0 let storage = FlowStorageFees.storageCapacityToFlow(storageMb) return storage } var index = 0 while index < sellerAddresses.length { // Get the seller's public account object let seller = getAccount(sellerAddresses[index]) let tokenID = tokenIDs[index] let purchaseAmount = purchaseAmounts[index] // Mint new tokens let minter <- self.zatMinter.createNewMinter(allowedAmount: purchaseAmount) let mintedTokens <- minter.mintTokens(amount: purchaseAmount) as! @ZelosAccountingToken.Vault destroy minter // Borrow a public reference to the seller's sale collection let sellerSaleCollection = seller .getCapability(/public/eternalSaleCollection) .borrow<&{Market.SalePublic}>() ?? panic("Could not borrow public sale reference") // Purchase the moment let purchasedMoment <- sellerSaleCollection.purchase(tokenID: tokenID, buyTokens: <-mintedTokens) // Deposit the purchased moment into the buyer's collection self.buyerCollection.deposit(token: <-purchasedMoment) // Determine Storage Used by the seller and Total Capacity in their account var sellerStorageUsed = returnFlowFromStorage(seller.storageUsed) var sellerStorageTotal = returnFlowFromStorage(seller.storageCapacity) // If user has used more than their total capacity, increase total capacity if (sellerStorageUsed > sellerStorageTotal) { let difference = sellerStorageUsed - sellerStorageTotal // Withdraw storage fee let sentVault <- self.adminVault.withdraw(amount: difference) // Deposit storage fee to seller let sellerReceiver = seller .getCapability(/public/flowTokenReceiver) .borrow<&{FungibleToken.Receiver}>() ?? panic("failed to borrow reference to recipient vault") sellerReceiver.deposit(from: <-sentVault) } index = index + 1 } // Deposit the shards into the buyer's collection for shardID in shardIDs { // Get shard from admin let transferShard <- self.adminShardCollection.withdraw(withdrawID: shardID) // Deposit the shard in the receivers collection self.buyerShardCollection.deposit(token: <-transferShard) } // Determine storage used by buyer and Total Capacity in their account var storageUsed = returnFlowFromStorage(self.buyerAccount.storageUsed) var storageTotal = returnFlowFromStorage(self.buyerAccount.storageCapacity) // If buyer has used more than their total capacity, increase total capacity if (storageUsed > storageTotal) { let difference = storageUsed - storageTotal // Withdraw storage fee let sentVault <- self.adminVault.withdraw(amount: difference) // Deposit storage fee to buyer let buyer = self.buyerAccount.getCapability(/public/flowTokenReceiver) .borrow<&{FungibleToken.Receiver}>() ?? panic("Failed to borrow reference to buyer vault") buyer.deposit(from: <-sentVault) } } }

CODE_ERROR

Transaction