import Market from 0xc38aea683c0c4d38 import Eternal from 0xc38aea683c0c4d38 import ZelosAccountingToken from 0xc38aea683c0c4d38 import FungibleToken from 0xf233dcee88fe0abe import FlowStorageFees from 0xe467b9dd11fa00df import FlowToken from 0x1654653399040a61 // This transaction puts a moment owned by the user up for sale // Parameters: // // tokenReceiverPath: token capability for the account who will receive tokens for purchase // beneficiaryAccount: the Flow address of the account where a cut of the purchase will be sent // cutPercentage: how much in percentage the beneficiary will receive from the sale // momentID: ID of moment to be put on sale // price: price of moment transaction(tokenReceiverPath: PublicPath, beneficiaryAccount: Address, cutPercentage: UFix64, momentID: UInt64, price: UFix64) { // Local variables for the eternal collection and market sale collection objects let collectionRef: &Eternal.Collection let marketSaleCollectionRef: &Market.SaleCollection let vaultRef: &FlowToken.Vault let userAcct: AuthAccount prepare(acct: AuthAccount, admin: AuthAccount) { // check to see if a sale collection already exists if acct.borrow<&Market.SaleCollection>(from: /storage/eternalSaleCollection) == nil { // get the fungible token capabilities for the owner and beneficiary let ownerCapability = acct.getCapability(tokenReceiverPath) let beneficiaryCapability = getAccount(beneficiaryAccount).getCapability(tokenReceiverPath) // create a new sale collection let eternalSaleCollection <- Market.createSaleCollection(ftType: Type<@ZelosAccountingToken.Vault>(), ownerCapability: ownerCapability, beneficiaryCapability: beneficiaryCapability, cutPercentage: cutPercentage) // save it to storage acct.save(<-eternalSaleCollection, to: /storage/eternalSaleCollection) // create a public link to the sale collection acct.link<&Market.SaleCollection{Market.SalePublic}>(/public/eternalSaleCollection, target: /storage/eternalSaleCollection) } // borrow a reference to the seller's moment collection self.collectionRef = acct.borrow<&Eternal.Collection>(from: /storage/EternalMomentCollection) ?? panic("Could not borrow from MomentCollection in storage") // borrow a reference to the sale self.marketSaleCollectionRef = acct.borrow<&Market.SaleCollection>(from: /storage/eternalSaleCollection) ?? panic("Could not borrow from sale in storage") // borrow a reference to the admin's flow token vault self.vaultRef = admin.borrow<&FlowToken.Vault>(from: /storage/flowTokenVault) ?? panic("failed to borrow reference to admin vault") self.userAcct = acct } execute { // withdraw the moment to put up for sale let token <- self.collectionRef.withdraw(withdrawID: momentID) as! @Eternal.NFT // the the moment for sale self.marketSaleCollectionRef.listForSale(token: <-token, price: UFix64(price)) // Used to determine whether signer needs more storage fun returnFlowFromStorage(_ storage: UInt64): UFix64 { // safe convert UInt64 to UFix64 (without overflow) let f = UFix64(storage % 100000000 as UInt64) * 0.00000001 as UFix64 + UFix64(storage / 100000000 as UInt64) // decimal point correction. Megabytes to bytes have a conversion of 10^-6 while UFix64 minimum value is 10^-8 let storageMb = f * 100.0 as UFix64 let storage = FlowStorageFees.storageCapacityToFlow(storageMb) return storage } // Determine Storage Used by user and Total Capacity in their account var storageUsed = returnFlowFromStorage(self.userAcct.storageUsed) var storageTotal = returnFlowFromStorage(self.userAcct.storageCapacity) // if user has used more than their total capacity, increase total capacity if (storageUsed > storageTotal) { let difference = storageUsed - storageTotal // Withdraw storage fee let sentVault <- self.vaultRef.withdraw(amount: difference) // Deposit storage fee to recipient let receiver = self.userAcct.getCapability(/public/flowTokenReceiver) .borrow<&{FungibleToken.Receiver}>() ?? panic("failed to borrow reference to recipient vault") receiver.deposit(from: <-sentVault) } } }

Transaction