import Swap from 0x15f55a75d7843780 import Utils from 0x15f55a75d7843780 import MetadataViews from 0x1d7e57aa55817448 import NonFungibleToken from 0x1d7e57aa55817448 import FungibleToken from 0xf233dcee88fe0abe import FungibleTokenCatalog from 0x9066631feda9e518 import DapperWalletRestrictions from 0x2d4cebdb9eca6f49 import DapperWalletCollections from 0x42a54b4f70e7dc81 // v1 transaction() { let leftUserOffer: Swap.UserOffer let rightUserOffer: Swap.UserOffer let leftCollectionReceiverCapabilities: {String: Capability<&{NonFungibleToken.Receiver}>} let leftCollectionProviderCapabilities: {String: Capability<&{NonFungibleToken.Provider}>} let leftFeeProviderCapabilities: {String: Capability<&{FungibleToken.Provider, FungibleToken.Balance}>} let leftUserAccount: AuthAccount prepare(signer: AuthAccount) { let unsupportedVaultError = "unsupported vault for " let missingProviderError = "missing or invalid provider capability for " let providerLinkFailedError = "unable to create private link to collection provider for " let nonDapperError = "you cannot trade with a non dapper wallet for " let sameTypeNftError = "your trading partner must have at least one NFT of type " let tradingDisabledError = "trading disabled for " self.leftUserAccount = signer let normalizeNfts = fun (_ inputNfts: { String: [UInt64] }): [String] { let identifiers: [String] = [] inputNfts.forEachKey(fun (key: String): Bool { identifiers.append(key.concat(".").concat(inputNfts[key]![0]!.toString())) return true }) return identifiers } let leftCollectionDataMap = Utils.getNFTCollectionData(ownerAddress: signer.address, nftIdentifiers: normalizeNfts({"A.edf9df96c92f4595.Pinnacle.NFT": [189116000633877]})) let rightCollectionDataMap = Utils.getNFTCollectionData(ownerAddress: 0xa858439730e6e5aa, nftIdentifiers: normalizeNfts({"A.edf9df96c92f4595.Pinnacle.NFT": [1454570390]})) let mapNfts = fun (ownerAddress: Address, _ inputNfts: { String: [UInt64] }): [Swap.ProposedTradeAsset] { let proposedNfts: [Swap.ProposedTradeAsset] = [] inputNfts.forEachKey(fun (key: String): Bool { for nftID in inputNfts[key]! { proposedNfts.append(Swap.ProposedTradeAsset( nftID: nftID, type: key, collectionData: leftCollectionDataMap[key] ?? rightCollectionDataMap[key] ?? panic("no collection data for: ".concat(key)) )) } return true }) return proposedNfts } let getRestrictions = fun (_ nfts: [Swap.ProposedTradeAsset]): { Type: DapperWalletRestrictions.TypeConfig } { let res: { Type: DapperWalletRestrictions.TypeConfig } = { } for nft in nfts { if (res.containsKey(nft.type)) { continue } let config = DapperWalletRestrictions.getConfig(nft.type) if (config == nil) { continue } res.insert(key: nft.type, config!) } return res } let anyHasRestriction = fun (_ restrictions: [DapperWalletRestrictions.TypeConfig], _ key: String, _ value: Bool): Bool { for restriction in restrictions { if (restriction.flags[key] == value) { return true } } return false } let validateRestrictions = fun (_ restrictions: { Type: DapperWalletRestrictions.TypeConfig }, _ otherRestrictions: { Type: DapperWalletRestrictions.TypeConfig }): Void { restrictions.forEachKey(fun (type: Type): Bool { let restriction = restrictions[type]! assert(restriction.flags["CAN_TRADE"] != false, message: tradingDisabledError.concat(type.identifier)) // other side must have at least one NFT with the same restriction assert(restriction.flags["CAN_TRADE_EXTERNAL"] != false || anyHasRestriction(otherRestrictions.values, "CAN_TRADE_EXTERNAL", false), message: nonDapperError.concat(type.identifier)) // other side must have at least one restricted NFT of the same type assert(restriction.flags["CAN_TRADE_DIFF_NFT"] != false || otherRestrictions[type] != nil, message: sameTypeNftError.concat(type.identifier)) // other side must have at least one NFT with the same restriction assert(restriction.flags["CAN_WITHDRAW"] != false || anyHasRestriction(otherRestrictions.values, "CAN_WITHDRAW", false), message: nonDapperError.concat(type.identifier)) return true }) } let leftProposedNfts: [Swap.ProposedTradeAsset] = mapNfts(ownerAddress: signer.address, {"A.edf9df96c92f4595.Pinnacle.NFT": [189116000633877]}) let rightProposedNfts: [Swap.ProposedTradeAsset] = mapNfts(ownerAddress: 0xa858439730e6e5aa, {"A.edf9df96c92f4595.Pinnacle.NFT": [1454570390]}) let initializedTypes: [Type] = [] let initializeCollections = fun (signer: AuthAccount, _ inputNfts: [Swap.ProposedTradeAsset]): Void { for nft in inputNfts { if (initializedTypes.contains(nft.type)) { continue } let contractType = Utils.getIdentifierContractType(identifier: nft.type.identifier) assert(DapperWalletCollections.containsType(contractType), message: "NFT type not allowed: ".concat(nft.type.identifier)) let collectionData = leftCollectionDataMap[nft.type.identifier] ?? rightCollectionDataMap[nft.type.identifier] ?? panic("collection data lookup failed for: ".concat(nft.type.identifier)) if (signer.getCapability<&{NonFungibleToken.CollectionPublic,NonFungibleToken.Receiver}>(collectionData.publicPath).borrow() != nil) { initializedTypes.append(nft.type) continue } if (signer.borrow<&AnyResource>(from: collectionData.storagePath) == nil) { signer.save(<-collectionData.createEmptyCollection(), to: collectionData.storagePath) } if (signer.getCapability<&{NonFungibleToken.CollectionPublic,NonFungibleToken.Receiver}>(collectionData.publicPath).borrow() == nil) { signer.unlink(collectionData.publicPath) signer.link<&{NonFungibleToken.CollectionPublic,NonFungibleToken.Receiver,MetadataViews.ResolverCollection}>(collectionData.publicPath, target: collectionData.storagePath) } initializedTypes.append(nft.type) } } initializeCollections(signer: signer, leftProposedNfts) initializeCollections(signer: signer, rightProposedNfts) let leftRestrictedTypes = getRestrictions(leftProposedNfts) let rightRestrictedTypes = getRestrictions(rightProposedNfts) validateRestrictions(leftRestrictedTypes, rightRestrictedTypes) validateRestrictions(rightRestrictedTypes, leftRestrictedTypes) self.leftFeeProviderCapabilities = { } if false { let vaultType = CompositeType("") ?? panic(unsupportedVaultError.concat("")) let entry = FungibleTokenCatalog.getVaultForType(vaultType: vaultType) ?? panic(unsupportedVaultError.concat("")) let feePrivatePath = entry.privatePath ?? panic(unsupportedVaultError.concat("")) var feeProvider = signer.getCapability<&{FungibleToken.Provider, FungibleToken.Balance}>(feePrivatePath) if (feeProvider == nil || !feeProvider.check()) { let vaultRef = signer.borrow<&{FungibleToken.Provider}>(from: entry.storagePath) ?? panic("Unable to find vault") signer.unlink(feePrivatePath) feeProvider = signer.link<&{FungibleToken.Provider, FungibleToken.Balance}>(feePrivatePath, target: entry.storagePath)! } self.leftFeeProviderCapabilities[entry.type.identifier] = feeProvider } self.leftUserOffer = Swap.UserOffer(userAddress: signer.address, proposedNfts: leftProposedNfts, metadata: nil) self.rightUserOffer = Swap.UserOffer(userAddress: 0xa858439730e6e5aa, proposedNfts: rightProposedNfts, metadata: nil) self.leftCollectionReceiverCapabilities = { } let partnerPublicAccount: PublicAccount = getAccount(0xa858439730e6e5aa) for partnerProposedNft in self.rightUserOffer.proposedNfts { if (self.leftCollectionReceiverCapabilities[partnerProposedNft.type.identifier] == nil) { if (signer.type(at: partnerProposedNft.collectionData.storagePath) != nil) { let receiverCapability = signer.getCapability<&{NonFungibleToken.Receiver}>(partnerProposedNft.collectionData.publicPath) if (receiverCapability.check()) { self.leftCollectionReceiverCapabilities[partnerProposedNft.type.identifier] = receiverCapability continue } } panic(missingProviderError.concat(partnerProposedNft.type.identifier)) } } self.leftCollectionProviderCapabilities = { } for proposedNft in self.leftUserOffer.proposedNfts { if (self.leftCollectionProviderCapabilities[proposedNft.type.identifier] == nil) { if (signer.getCapability<&{NonFungibleToken.Provider}>(proposedNft.collectionData.providerPath).borrow() == nil) { signer.unlink(proposedNft.collectionData.providerPath) signer.link<&{NonFungibleToken.Provider}>(proposedNft.collectionData.providerPath, target: proposedNft.collectionData.storagePath) } let providerCapability = signer.getCapability<&{NonFungibleToken.Provider}>(proposedNft.collectionData.providerPath) if (providerCapability.check()) { self.leftCollectionProviderCapabilities[proposedNft.type.identifier] = providerCapability continue } panic(providerLinkFailedError.concat(proposedNft.type.identifier)) } } } execute { let storedType = self.leftUserAccount.type(at: Swap.SwapCollectionStoragePath) if (storedType != nil && storedType != Type<@Swap.SwapCollection>()) { let oldCollection <- self.leftUserAccount.load<@AnyResource>(from: Swap.SwapCollectionStoragePath) destroy oldCollection } if (self.leftUserAccount.type(at: Swap.SwapCollectionStoragePath) == nil) { let newCollection <- Swap.createEmptySwapCollection() self.leftUserAccount.save(<-newCollection, to: Swap.SwapCollectionStoragePath) } if (self.leftUserAccount.getCapability<&{Swap.SwapCollectionPublic}>(Swap.SwapCollectionPublicPath).borrow() == nil) { self.leftUserAccount.unlink(Swap.SwapCollectionPublicPath) self.leftUserAccount.link<&{Swap.SwapCollectionPublic}>(Swap.SwapCollectionPublicPath, target: Swap.SwapCollectionStoragePath) } if (self.leftUserAccount.getCapability<&{Swap.SwapCollectionManager}>(Swap.SwapCollectionPrivatePath).borrow() == nil) { self.leftUserAccount.unlink(Swap.SwapCollectionPrivatePath) self.leftUserAccount.link<&{Swap.SwapCollectionManager}>(Swap.SwapCollectionPrivatePath, target: Swap.SwapCollectionStoragePath) } let swapCollectionManagerCapability = self.leftUserAccount.getCapability<&{Swap.SwapCollectionManager}>(Swap.SwapCollectionPrivatePath) assert(swapCollectionManagerCapability.check(), message: "Got invalid SwapCollectionManager capability") let swapCollectionManager = swapCollectionManagerCapability.borrow()! swapCollectionManager.createProposal( leftUserOffer: self.leftUserOffer, rightUserOffer: self.rightUserOffer, leftUserCapabilities: Swap.UserCapabilities( collectionReceiverCapabilities: self.leftCollectionReceiverCapabilities, collectionProviderCapabilities: self.leftCollectionProviderCapabilities, feeProviderCapabilities: self.leftFeeProviderCapabilities, extraCapabilities: nil ), expirationOffsetMinutes: 120.00000000, metadata: {"environmentId": ""} ) } }

Transaction