API tools faq
paste
aacoimbra

full contract

aacoimbra
Dec 29th, 2023
1,173
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 29.39 KB | None | 0 0
raw download clone embed print report
  1. // import NonFungibleToken from 0x631e88ae7f1d7c20
  2. // import MetadataViews from 0x631e88ae7f1d7c20
  3. // import FungibleToken from 0x9a0766d93b6608b7
  4. // import PRNG from 0x2bf5575475144be3
  5.  
  6. import "NonFungibleToken"
  7. import "MetadataViews"
  8. import "FungibleToken"
  9. // import "PRNG"
  10.  
  11. pub contract BBCollectables: NonFungibleToken {
  12.  
  13.     // pub let network: String
  14.  
  15.     pub event ContractInitialized()
  16.  
  17.     pub event CardCreated(cardID: UInt32, metadata: {String:String})
  18.     pub event PackCreated(packID: UInt32)
  19.  
  20.     pub event CardAddedToPack(packID: UInt32, cardID: UInt32)
  21.     pub event CardRetiredFromPack(packID: UInt32, cardID: UInt32, numCards: UInt32)
  22.     pub event CardUnretiredFromPack(packID: UInt32, cardID: UInt32, numCards: UInt32)
  23.  
  24.     pub event PackLocked(packID: UInt32)
  25.     pub event PackUnlocked(packID: UInt32)
  26.  
  27.     pub event BlockPackMint(packID: UInt32)
  28.  
  29.    
  30.     pub event TicketMinted(packID: UInt32, serialNumber: UInt32)
  31.     pub event TicketSpent(id: UInt64, packID: UInt32, serialNumber: UInt32, content: [UInt32])
  32.     pub event TicketDestroyed(id: UInt64)
  33.  
  34.     pub event BBNftMinted(BBNftID: UInt64, cardID: UInt32, packID: UInt32, serialNumber: UInt32)
  35.     pub event BBNftDestroyed(id: UInt64)
  36.  
  37.  
  38.     pub event Withdraw(id: UInt64, from: Address?)
  39.  
  40.     pub event Deposit(id: UInt64, to: Address?)
  41.  
  42.     pub let NftCollectionStoragePath: StoragePath
  43.     pub let NftCollectionPublicPath: PublicPath
  44.     pub let AdminStoragePath: StoragePath
  45.  
  46.     pub var cardDatas: {UInt32: Card}
  47.     access(self) var packDatas: {UInt32: PackData}
  48.     pub var packs: @{UInt32: Pack}
  49.  
  50.     pub var nextCardID: UInt32
  51.     pub var nextPackID: UInt32
  52.  
  53.     pub var totalSupply: UInt64
  54.  
  55.  
  56.     pub struct Card {
  57.  
  58.         pub let cardID: UInt32
  59.  
  60.         // pub let categories: [String]
  61.  
  62.         pub let metadata: {String: String}
  63.  
  64.         init(metadata: {String: String}) {
  65.             pre {
  66.                 metadata.length != 0: "New Card metadata cannot be empty"
  67.             }
  68.             self.cardID = BBCollectables.nextCardID
  69.             // self.categories = categories
  70.             self.metadata = metadata
  71.         }
  72.     }
  73.  
  74.     pub struct PackData {
  75.  
  76.         pub let packID: UInt32
  77.  
  78.         pub let name: String
  79.  
  80.         pub let rarityDistribution: {String: UInt256}
  81.  
  82.         init(name: String, rarityDistribution: {String: UInt256}) {
  83.             pre {
  84.                 name.length > 0: "New Pack name cannot be empty"
  85.             }
  86.             self.packID = BBCollectables.nextPackID
  87.             self.name = name
  88.             self.rarityDistribution = rarityDistribution
  89.         }
  90.     }
  91.  
  92.     pub resource Pack {
  93.  
  94.         pub let name: String
  95.  
  96.         pub let packID: UInt32
  97.  
  98.         access(contract) var rarityDistribution: {String: UInt256}
  99.  
  100.         access(contract) var cards: [UInt32]
  101.  
  102.         access(contract) var retired: {UInt32: Bool}
  103.  
  104.         pub var locked: Bool
  105.  
  106.         access(contract) var ticketsMinted: UInt32
  107.  
  108.         access(contract) var ticketsSpent: UInt32
  109.  
  110.         access(contract) var ticketsDestroyed: UInt32
  111.  
  112.         access(contract) var mintCapPerCard: {UInt32: UInt32}
  113.  
  114.         access(contract) var numberMintedPerCard: {UInt32: UInt32}
  115.  
  116.         access(contract) var numberDestroyedPerCard: {UInt32: UInt32}
  117.  
  118.         pub var cardsAvailableByRarity: {String: [UInt32]}
  119.  
  120.         init(name: String, rarityDistribution: {String: UInt256}) {
  121.             self.name = name
  122.             self.packID = BBCollectables.nextPackID
  123.             self.rarityDistribution = rarityDistribution
  124.             self.cards = []
  125.             self.retired = {}
  126.             self.locked = false
  127.             self.ticketsMinted = 0
  128.             self.ticketsSpent = 0
  129.             self.ticketsDestroyed = 0
  130.             self.mintCapPerCard = {}
  131.             self.numberMintedPerCard = {}
  132.             self.numberDestroyedPerCard = {}
  133.             self.cardsAvailableByRarity = {}
  134.  
  135.             for rarity in rarityDistribution.keys {
  136.                 self.cardsAvailableByRarity[rarity] = []
  137.             }
  138.  
  139.             BBCollectables.packDatas[self.packID] = PackData(name: name, rarityDistribution: rarityDistribution)
  140.         }
  141.  
  142.         pub fun addCard(cardID: UInt32, mintCap: UInt32) {
  143.  
  144.             pre {
  145.                 BBCollectables.cardDatas[cardID] != nil: "Cannot add the Card to Pack: Card doesn't exist."
  146.                 !self.locked: "Cannot add the Card to the Pack after the Pack has been locked."
  147.                 self.numberMintedPerCard[cardID] == nil: "The Card has already beed added to the Pack."
  148.                 self.rarityDistribution[BBCollectables.getCardMetaDataByField(cardID: cardID, field: "rarity")!] != nil: "The Card rarity not included in pack."
  149.                 mintCap >= 0: "'maxCount' parameter must be 0 or higher."
  150.             }
  151.  
  152.  
  153.             self.cards.append(cardID)
  154.  
  155.             self.retired[cardID] = false
  156.  
  157.             self.mintCapPerCard[cardID] = mintCap
  158.  
  159.             self.numberMintedPerCard[cardID] = 0
  160.  
  161.             self.numberDestroyedPerCard[cardID] = 0
  162.            
  163.             self.cardsAvailableByRarity[BBCollectables.getCardMetaDataByField(cardID: cardID, field: "rarity")!]!.append(cardID)
  164.  
  165.             emit CardAddedToPack(packID: self.packID, cardID: cardID)
  166.         }
  167.  
  168.         pub fun addCards(cardIDs: [UInt32], mintCaps: [UInt32]) {
  169.            
  170.             var i = 0
  171.             while i < cardIDs.length {
  172.                 self.addCard(cardID: cardIDs[i], mintCap: mintCaps[i])
  173.                 i = i + 1
  174.             }
  175.                
  176.         }
  177.        
  178.  
  179.         pub fun retireCard(cardID: UInt32) {
  180.             pre {
  181.                 self.retired[cardID] != nil: "Cannot retire the Card: Card doesn't exist in this Pack!"
  182.                 self.retired[cardID] == false: "Cannot retire the Card: Card already retired!"
  183.                 !self.locked: "Cannot retire card: This Pack is locked."
  184.             }
  185.  
  186.             let cardRarity = BBCollectables.getCardMetaDataByField(cardID: cardID, field: "rarity")!
  187.  
  188.             var index: UInt16 = 0
  189.             for value in self.cardsAvailableByRarity[cardRarity]! {
  190.                 if value == cardID {
  191.                 self.cardsAvailableByRarity[cardRarity]!.remove(at: index)
  192.                 }
  193.                 index = index + 1
  194.             }
  195.            
  196.  
  197.             if !self.retired[cardID]! {
  198.                 self.retired[cardID] = true
  199.  
  200.                 emit CardRetiredFromPack(packID: self.packID, cardID: cardID, numCards: self.numberMintedPerCard[cardID]!)
  201.             }
  202.         }
  203.  
  204.         pub fun unretireCard(cardID: UInt32) {
  205.             pre {
  206.                 self.retired[cardID] != nil: "Cannot unretire the Card: Card doesn't exist in this Pack!"
  207.                 self.retired[cardID] == true: "Cannot unretire the Card: Card must be retired!"
  208.                 self.numberMintedPerCard[cardID]! < self.mintCapPerCard[cardID]! || self.mintCapPerCard[cardID]! == 0: "Cannot unretire the Card: Card has reached it's maximum mint cap!"
  209.                 !self.locked: "Cannot retire card: This Pack is locked."
  210.             }
  211.  
  212.             let cardRarity = BBCollectables.getCardMetaDataByField(cardID: cardID, field: "rarity")!
  213.  
  214.             self.cardsAvailableByRarity[cardRarity]!.insert(at: self.cardsAvailableByRarity[cardRarity]!.length - 1, cardID)
  215.  
  216.             if self.retired[cardID]! {
  217.                 self.retired[cardID] = false
  218.  
  219.                 emit CardUnretiredFromPack(packID: self.packID, cardID: cardID, numCards: self.numberMintedPerCard[cardID]!)
  220.             }
  221.         }
  222.  
  223.         pub fun retireAll() {
  224.             for card in self.cards {
  225.                 self.retireCard(cardID: card)
  226.             }
  227.         }
  228.  
  229.         pub fun lock() {
  230.             if !self.locked {
  231.                 self.locked = true
  232.                 emit PackLocked(packID: self.packID)
  233.             }
  234.         }
  235.  
  236.         pub fun unlock() {
  237.             if self.locked {
  238.                 self.locked = false
  239.                 emit PackUnlocked(packID: self.packID)
  240.             }
  241.         }
  242.  
  243.         pub fun spentTicketCount() {
  244.             self.ticketsSpent = self.ticketsSpent +1
  245.         }
  246.  
  247.         pub fun destroyedTicketCount() {
  248.             self.ticketsDestroyed = self.ticketsDestroyed +1
  249.         }
  250.  
  251.  
  252.         pub fun mintBBNft(cardID: UInt32): @NFT {
  253.             pre {
  254.                 self.retired[cardID] != nil: "Cannot mint the Card: This Card doesn't exist."
  255.                 !self.retired[cardID]!: "Cannot mint the Card from this Pack: This Card has been retired."
  256.                 self.numberMintedPerCard[cardID]! < self.mintCapPerCard[cardID]! || self.mintCapPerCard[cardID]! == 0: "Card has reached the maximum mint cap."
  257.             }
  258.  
  259.             let numInCard = self.numberMintedPerCard[cardID]!
  260.  
  261.             let newBBNft: @NFT <- create NFT(cardID: cardID,
  262.                                               packID: self.packID,
  263.                                               timestamp: getCurrentBlock().timestamp,
  264.                                               packIndex: UInt32(self.cards.firstIndex(of: cardID)!),
  265.                                               serialNumber: numInCard +1
  266.                                               )
  267.            
  268.             self.numberMintedPerCard[cardID] = numInCard +1
  269.  
  270.             if self.numberMintedPerCard[cardID]! >= self.mintCapPerCard[cardID]! && self.mintCapPerCard[cardID]! > 0 {
  271.                 self.retireCard(cardID: cardID)
  272.             }
  273.  
  274.             return <-newBBNft
  275.         }
  276.  
  277.         pub fun destroyBBNft(cardID: UInt32) {
  278.             self.numberDestroyedPerCard[cardID] = self.numberDestroyedPerCard[cardID]! +1
  279.         }
  280.  
  281.         pub fun batchMintBBNft(cardID: UInt32, quantity: UInt64): @Collection {
  282.             let newCollection <- create Collection()
  283.  
  284.             var i: UInt64 = 0
  285.             while i < quantity {
  286.                 newCollection.deposit(token: <-self.mintBBNft(cardID: cardID))
  287.                 i = i +1
  288.             }
  289.  
  290.             return <-newCollection
  291.         }
  292.  
  293.         pub fun getRarityDistribution(): {String: UInt256} {
  294.             return self.rarityDistribution
  295.         }
  296.  
  297.         pub fun getCards(): [UInt32] {
  298.             return self.cards
  299.         }
  300.  
  301.         pub fun getRetired(): {UInt32: Bool} {
  302.             return self.retired
  303.         }
  304.  
  305.         pub fun getNumMintedPerCard(): {UInt32: UInt32} {
  306.             return self.numberMintedPerCard
  307.         }
  308.     }
  309.  
  310.     pub struct QueryPackData {
  311.         pub let packID: UInt32
  312.         pub let name: String
  313.         pub var locked: Bool
  314.         access(self) var rarityDistribution: {String: UInt256}
  315.         access(self) var cards: [UInt32]
  316.         access(self) var retired: {UInt32: Bool}
  317.         access(self) var cardsAvailableByRarity: {String: [UInt32]}
  318.         access(contract) var ticketsMinted: UInt32
  319.         access(contract) var ticketsSpent: UInt32
  320.         access(contract) var ticketsDestroyed: UInt32
  321.         access(self) var mintCapPerCard: {UInt32: UInt32}
  322.         access(self) var numberMintedPerCard: {UInt32: UInt32}
  323.         access(self) var numberDestroyedPerCard: {UInt32: UInt32}
  324.        
  325.  
  326.         init(packID: UInt32) {
  327.             pre {
  328.                 BBCollectables.packs[packID] != nil: "The Pack with the provided ID does not exist"
  329.             }
  330.  
  331.             let pack= (&BBCollectables.packs[packID] as &Pack?)!
  332.             let packData = BBCollectables.packDatas[packID]!
  333.  
  334.             self.packID = packID
  335.             self.name = packData.name
  336.             self.locked = pack.locked
  337.             self.rarityDistribution = pack.rarityDistribution
  338.             self.cards = pack.cards
  339.             self.retired = pack.retired
  340.             self.cardsAvailableByRarity = pack.cardsAvailableByRarity
  341.             self.ticketsMinted = pack.ticketsMinted
  342.             self.ticketsSpent = pack.ticketsSpent
  343.             self.ticketsDestroyed = pack.ticketsDestroyed
  344.             self.mintCapPerCard = pack.mintCapPerCard
  345.             self.numberMintedPerCard = pack.numberMintedPerCard
  346.             self.numberDestroyedPerCard = pack.numberDestroyedPerCard
  347.         }
  348.  
  349.         pub fun getRarityDistribution(): {String: UInt256} {
  350.             return self.rarityDistribution
  351.         }
  352.  
  353.         pub fun getCards(): [UInt32] {
  354.             return self.cards
  355.         }
  356.  
  357.         pub fun getRetired(): {UInt32: Bool} {
  358.             return self.retired
  359.         }
  360.  
  361.         pub fun getcardsAvailableByRarity(): {String: [UInt32]} {
  362.             return self.cardsAvailableByRarity
  363.         }
  364.  
  365.         pub fun getTicketsMinted(): UInt32 {
  366.             return self.ticketsMinted
  367.         }
  368.  
  369.         pub fun getTicketsSpent(): UInt32 {
  370.             return self.ticketsSpent
  371.         }
  372.  
  373.         pub fun getNumberMintedPerCard(): {UInt32: UInt32} {
  374.             return self.numberMintedPerCard
  375.         }
  376.  
  377.         pub fun getNumberDestroyedPerCard(): {UInt32: UInt32} {
  378.             return self.numberDestroyedPerCard
  379.         }
  380.     }
  381.  
  382.     pub struct BBNftData {
  383.  
  384.         pub let cardID: UInt32
  385.  
  386.         pub let packID: UInt32
  387.  
  388.         pub let timestamp: UFix64
  389.  
  390.         pub let packIndex: UInt32
  391.  
  392.         pub let serialNumber: UInt32
  393.  
  394.  
  395.         init(cardID: UInt32, packID: UInt32, timestamp: UFix64, packIndex:UInt32, serialNumber: UInt32) {
  396.             self.cardID = cardID
  397.             self.packID = packID
  398.             self.timestamp = timestamp
  399.             self.packIndex = packIndex
  400.             self.serialNumber = serialNumber
  401.         }
  402.  
  403.     }
  404.  
  405.     pub struct BBNftMetadataView {
  406.  
  407.         pub let name : String?
  408.         pub let description: String?
  409.         pub let rarity: String?
  410.         pub let media: String?
  411.  
  412.         pub let cardID: UInt32?
  413.         pub let packID: UInt32?
  414.         pub let timestamp: UFix64?
  415.         pub let packIndex: UInt32?
  416.         pub let serialNumber: UInt32?
  417.  
  418.         init(
  419.             name: String?,
  420.             description: String?,
  421.             rarity: String?,
  422.             media: String?,
  423.  
  424.             cardID: UInt32?,
  425.             packID: UInt32?,
  426.             timestamp: UFix64?,
  427.             packIndex: UInt32?,
  428.             serialNumber: UInt32?,
  429.            
  430.         ) {
  431.             self.name = name
  432.             self.description = description
  433.             self.rarity = rarity
  434.             self.media = media
  435.  
  436.             self.cardID = cardID
  437.             self.packID = packID
  438.             self.timestamp = timestamp
  439.             self.packIndex = packIndex
  440.             self.serialNumber = serialNumber
  441.         }
  442.     }
  443.  
  444.     pub resource NFT: NonFungibleToken.INFT, MetadataViews.Resolver {
  445.  
  446.         pub let id: UInt64
  447.         pub let data: BBNftData
  448.  
  449.         init(cardID: UInt32, packID: UInt32, timestamp: UFix64, packIndex: UInt32, serialNumber: UInt32) {
  450.  
  451.             BBCollectables.totalSupply = BBCollectables.totalSupply +1
  452.  
  453.             self.id = BBCollectables.totalSupply
  454.  
  455.             self.data = BBNftData(cardID: cardID, packID: packID, timestamp: timestamp, packIndex: packIndex, serialNumber: serialNumber)
  456.  
  457.             emit BBNftMinted(BBNftID: self.id, cardID: cardID, packID: self.data.packID, serialNumber: self.data.serialNumber)
  458.         }
  459.  
  460.         destroy() {
  461.             BBCollectables.packs[self.data.packID]?.destroyBBNft(cardID: self.data.cardID)
  462.             emit BBNftDestroyed(id: self.id)
  463.         }
  464.  
  465.         pub fun name(): String {
  466.             let cardName: String = BBCollectables.getCardMetaDataByField(cardID: self.data.cardID, field: "name") ?? ""
  467.             return cardName
  468.         }
  469.  
  470.         pub fun description(): String {
  471.             let packName: String = BBCollectables.getPackName(packID: self.data.packID) ?? ""
  472.             let serialNumber: String = self.data.serialNumber.toString()
  473.             return "A series "
  474.                 .concat(packName)
  475.                 .concat(" BBNft with serial number ")
  476.                 .concat(serialNumber)
  477.         }
  478.  
  479.         pub fun getCardURL(): String {
  480.  
  481.             return "https://media.BBCollectables.bite.blue/".concat("testnet").concat("/cards/").concat(BBCollectables.getCardMetaDataByField(cardID: self.data.cardID, field: "media")!).concat("/carta.png")
  482.            
  483.             // return BBCollectables.getCardMetaDataByField(cardID: self.data.cardID, field: "media")!
  484.         }
  485.  
  486.         pub fun mapCardData(dict: {String: AnyStruct}) : {String: AnyStruct} {      
  487.             let cardMetadata = BBCollectables.getCardMetaData(cardID: self.data.cardID) ?? {}
  488.             for name in cardMetadata.keys {
  489.                 let value = cardMetadata[name] ?? ""
  490.                 if value != "" {
  491.                     dict.insert(key: name, value)
  492.                 }
  493.             }
  494.             return dict
  495.         }
  496.  
  497.         pub fun getViews(): [Type] {
  498.             return [
  499.                 Type<MetadataViews.Display>(),
  500.                 Type<BBNftMetadataView>(),
  501.                 Type<MetadataViews.ExternalURL>(),
  502.                 Type<MetadataViews.NFTCollectionData>(),
  503.                 Type<MetadataViews.NFTCollectionDisplay>(),
  504.                 Type<MetadataViews.Serial>(),
  505.                 Type<MetadataViews.Traits>(),
  506.                 Type<MetadataViews.Medias>()
  507.             ]
  508.         }
  509.  
  510.         pub fun resolveView(_ view: Type): AnyStruct? {
  511.             switch view {
  512.                 case Type<MetadataViews.Display>():
  513.                     return MetadataViews.Display(
  514.                         name: self.name(),
  515.                         description: self.description(),
  516.                         thumbnail: MetadataViews.HTTPFile(url: self.getCardURL())
  517.                     )
  518.                 case Type<BBNftMetadataView>():
  519.                     return BBNftMetadataView(
  520.                         name: BBCollectables.getCardMetaDataByField(cardID: self.data.cardID, field: "name"),
  521.                         description: BBCollectables.getCardMetaDataByField(cardID: self.data.cardID, field: "cardDescription"),
  522.                         rarity: BBCollectables.getCardMetaDataByField(cardID: self.data.cardID, field: "rarity"),
  523.                         media: self.getCardURL(),
  524.                        
  525.                         cardID: self.data.cardID,
  526.                         packID: self.data.packID,
  527.                         timestamp: self.data.timestamp,
  528.                         packIndex: self.data.packIndex,
  529.                         serialNumber: self.data.serialNumber,
  530.                     )
  531.                    
  532.                 case Type<MetadataViews.ExternalURL>():
  533.                     return MetadataViews.ExternalURL(self.getCardURL())
  534.  
  535.                 case Type<MetadataViews.NFTCollectionData>():
  536.                     return MetadataViews.NFTCollectionData(
  537.                         storagePath: /storage/BBNFTCollection,
  538.                         publicPath: /public/BBNFTCollection,
  539.                         providerPath: /private/BBNFTCollection,
  540.                         publicCollection: Type<&BBCollectables.Collection{NonFungibleToken.CollectionPublic}>(),
  541.                         publicLinkedType: Type<&BBCollectables.Collection{NonFungibleToken.Receiver,NonFungibleToken.CollectionPublic,MetadataViews.ResolverCollection}>(),
  542.                         providerLinkedType: Type<&BBCollectables.Collection{NonFungibleToken.Provider,NonFungibleToken.Receiver,NonFungibleToken.CollectionPublic,MetadataViews.ResolverCollection}>(),
  543.                         createEmptyCollectionFunction: (fun (): @NonFungibleToken.Collection {
  544.                             return <-BBCollectables.createEmptyCollection()
  545.                         })
  546.                     )
  547.  
  548.                 case Type<MetadataViews.NFTCollectionDisplay>():
  549.                     let bannerImage = MetadataViews.Media(
  550.                         file: MetadataViews.HTTPFile(
  551.                             url: "https://media.BBCollectables.bite.blue/testnet/branding/BB-banner.svg"
  552.                         ),
  553.                         mediaType: "image/svg"
  554.                     )
  555.                     let squareImage = MetadataViews.Media(
  556.                         file: MetadataViews.HTTPFile(
  557.                             url: "https://media.BBCollectables.bite.blue/testnet/branding/BB-logopack-04.svg"
  558.                         ),
  559.                         mediaType: "image/svg"
  560.                     )
  561.  
  562.                     return MetadataViews.NFTCollectionDisplay(
  563.                         name: "Organiser Collectables Collection",
  564.                         description: "Uma experiência de outro planeta. 🪐",
  565.                         externalURL: MetadataViews.ExternalURL("https://www.bluebite.tech/"),
  566.                         squareImage: squareImage,
  567.                         bannerImage: bannerImage,
  568.                         socials: {
  569.                             "instagram": MetadataViews.ExternalURL("https://www.instagram.com/richmond_fc/")
  570.                         }
  571.                     )
  572.  
  573.                 case Type<MetadataViews.Serial>():
  574.                     return MetadataViews.Serial(
  575.                         UInt64(self.data.serialNumber)
  576.                     )
  577.  
  578.                 case Type<MetadataViews.Traits>():
  579.                     // sports radar team id
  580.                     let excludedNames: [String] = ["timestamp"]
  581.                     // non play specific traits
  582.                     let traitDictionary: {String: AnyStruct} = {
  583.                         "packName": BBCollectables.getPackName(packID: self.data.packID)
  584.                     }
  585.                     // add play specific data
  586.                     let fullDictionary = self.mapCardData(dict: traitDictionary)
  587.                     return MetadataViews.dictToTraits(dict: fullDictionary, excludedNames: excludedNames)
  588.  
  589.                 case Type<MetadataViews.Medias>():
  590.                     return MetadataViews.Medias(
  591.                         items: [
  592.                             MetadataViews.Media(
  593.                                 file: MetadataViews.HTTPFile(
  594.                                     url: self.getCardURL()
  595.                                 ),
  596.                                 mediaType: "image/png"
  597.                             )
  598.                         ]
  599.                     )
  600.             }
  601.  
  602.             return nil
  603.         }
  604.  
  605.        
  606.     }
  607.  
  608.     // pub struct PackTicketData{
  609.  
  610.     //     pub let packID: UInt32
  611.  
  612.     //     pub let serialNumber: UInt32
  613.  
  614.     //     init(packID: UInt32, serialNumber: UInt32) {
  615.     //         self.packID = packID
  616.     //         self.serialNumber = serialNumber
  617.     //     }
  618.     // }
  619.  
  620.     pub resource Admin {
  621.  
  622.         pub fun createCard( metadata: {String: String}): UInt32 {
  623.  
  624.             pre {
  625.                 metadata.containsKey("rarity") == true: "Metadata missing rarity field"
  626.                 metadata.containsKey("name") == true: "Metadata missing name field"
  627.                 metadata.containsKey("description") == true: "Metadata missing description field"
  628.                 metadata.containsKey("date") == true: "Metadata missing date field"
  629.             }
  630.  
  631.             for value in BBCollectables.cardDatas.values {
  632.                 if value.metadata["name"] == metadata["name"] {
  633.                     return 0
  634.                 }
  635.             }
  636.  
  637.             var newCard = Card( metadata: metadata)
  638.  
  639.             let newID = newCard.cardID
  640.  
  641.             BBCollectables.nextCardID = BBCollectables.nextCardID +1
  642.  
  643.             emit CardCreated(cardID: newCard.cardID, metadata: newCard.metadata)
  644.  
  645.             BBCollectables.cardDatas[newID] = newCard
  646.  
  647.             return newID
  648.         }
  649.  
  650.         pub fun createPack(name: String, rarityDistribution: {String: UInt256}): UInt32 {
  651.  
  652.             var newPack <- create Pack(name: name, rarityDistribution: rarityDistribution)
  653.  
  654.             BBCollectables.nextPackID = BBCollectables.nextPackID +1
  655.  
  656.             let newID = newPack.packID
  657.  
  658.             emit PackCreated(packID: newPack.packID)
  659.  
  660.             BBCollectables.packs[newID] <-! newPack
  661.  
  662.             return newID
  663.         }
  664.  
  665.         pub fun borrowPack(packID: UInt32): &Pack {
  666.             pre {
  667.                 BBCollectables.packs[packID] != nil: "Cannot borrow Pack: The Pack doesn't exist"
  668.             }
  669.            
  670.             return (&BBCollectables.packs[packID] as &Pack?)!
  671.         }
  672.  
  673.         pub fun createNewAdmin(): @Admin {
  674.             return <-create Admin()
  675.         }
  676.     }
  677.  
  678.     pub resource Collection: NonFungibleToken.Provider, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic, MetadataViews.ResolverCollection {
  679.  
  680.         pub var ownedNFTs: @{UInt64: NonFungibleToken.NFT}
  681.  
  682.         init() {
  683.             self.ownedNFTs <- {}
  684.         }
  685.  
  686.         pub fun withdraw(withdrawID: UInt64): @NonFungibleToken.NFT {
  687.  
  688.             let token <- self.ownedNFTs.remove(key: withdrawID)
  689.                 ?? panic("Cannot withdraw: Card does not exist in the collection")
  690.  
  691.             emit Withdraw(id: token.id, from: self.owner?.address)
  692.            
  693.             return <-token
  694.         }
  695.  
  696.         pub fun batchWithdraw(ids: [UInt64]): @NonFungibleToken.Collection {
  697.             var batchCollection <- create Collection()
  698.            
  699.             for id in ids {
  700.                 batchCollection.deposit(token: <-self.withdraw(withdrawID: id))
  701.             }
  702.            
  703.             return <-batchCollection
  704.         }
  705.         pub fun deposit(token: @NonFungibleToken.NFT) {
  706.            
  707.  
  708.             let token <- token as! @BBCollectables.NFT
  709.  
  710.             let id = token.id
  711.  
  712.             let oldToken <- self.ownedNFTs[id] <- token
  713.  
  714.             if self.owner?.address != nil {
  715.                 emit Deposit(id: id, to: self.owner?.address)
  716.             }
  717.  
  718.             destroy oldToken
  719.         }
  720.  
  721.         pub fun batchDeposit(tokens: @NonFungibleToken.Collection) {
  722.  
  723.             let keys = tokens.getIDs()
  724.  
  725.             for key in keys {
  726.                 self.deposit(token: <-tokens.withdraw(withdrawID: key))
  727.             }
  728.  
  729.             destroy tokens
  730.         }
  731.  
  732.         pub fun getIDs(): [UInt64] {
  733.             return self.ownedNFTs.keys
  734.         }
  735.  
  736.         pub fun borrowNFT(id: UInt64): &NonFungibleToken.NFT {
  737.             return (&self.ownedNFTs[id] as &NonFungibleToken.NFT?)!
  738.         }
  739.  
  740.         pub fun borrowBBNft(id: UInt64): &BBCollectables.NFT? {
  741.             if self.ownedNFTs[id] != nil {
  742.                 let ref = (&self.ownedNFTs[id] as auth &NonFungibleToken.NFT?)!
  743.                 return ref as! &BBCollectables.NFT
  744.             } else {
  745.                 return nil
  746.             }
  747.         }
  748.  
  749.         pub fun borrowViewResolver(id: UInt64): &AnyResource{MetadataViews.Resolver} {
  750.             let nft = (&self.ownedNFTs[id] as auth &NonFungibleToken.NFT?)!
  751.             let BBNFT = nft as! &BBCollectables.NFT
  752.             return BBNFT as &AnyResource{MetadataViews.Resolver}
  753.         }
  754.  
  755.         destroy() {
  756.             destroy self.ownedNFTs
  757.         }
  758.     }
  759.  
  760.     pub fun createEmptyCollection(): @NonFungibleToken.Collection {
  761.         return <-create BBCollectables.Collection()
  762.     }
  763.  
  764.  
  765.     pub fun getAllCards(): {UInt32: BBCollectables.Card} {
  766.         return BBCollectables.cardDatas
  767.     }
  768.  
  769.     pub fun getCardMetaData(cardID: UInt32): {String: String}? {
  770.         return self.cardDatas[cardID]?.metadata
  771.     }
  772.  
  773.     pub fun getCardMetaDataByField(cardID: UInt32, field: String): String? {
  774.         if let card = BBCollectables.cardDatas[cardID] {
  775.             return card.metadata[field]
  776.         } else {
  777.             return nil
  778.         }
  779.     }
  780.  
  781.     pub fun getPackData(packID: UInt32): QueryPackData? {
  782.         if BBCollectables.packs[packID] == nil {
  783.             return nil
  784.         } else {
  785.             return QueryPackData(packID: packID)
  786.         }
  787.     }
  788.  
  789.     pub fun getPackName(packID: UInt32): String? {
  790.         return BBCollectables.packDatas[packID]?.name
  791.     }
  792.  
  793.     pub fun getPackIDsByName(packName: String): [UInt32]? {
  794.         var packIDs: [UInt32] = []
  795.  
  796.         for packData in BBCollectables.packDatas.values {
  797.             if packName == packData.name {
  798.  
  799.                 packIDs.append(packData.packID)
  800.             }
  801.         }
  802.  
  803.         if packIDs.length == 0 {
  804.             return nil
  805.         } else {
  806.             return packIDs
  807.         }
  808.     }
  809.  
  810.     pub fun getCardsInPack(packID: UInt32): [UInt32]? {
  811.  
  812.         return BBCollectables.packs[packID]?.cards
  813.     }
  814.  
  815.     pub fun getRarityDistributionOfPack(packID: UInt32): {String: UInt256}? {
  816.  
  817.         return BBCollectables.packs[packID]?.rarityDistribution
  818.     }
  819.  
  820.     pub fun isPackLocked(packID: UInt32): Bool? {
  821.         return BBCollectables.packs[packID]?.locked
  822.     }
  823.  
  824.  
  825.     init() {
  826.  
  827.         // self.network = "testnet"
  828.  
  829.         self.cardDatas = {}
  830.         self.packDatas = {}
  831.         self.packs <- {}
  832.         self.nextCardID = 1
  833.         self.nextPackID = 1
  834.         self.totalSupply = 0
  835.  
  836.         self.NftCollectionStoragePath = /storage/BBNFTCollection
  837.         self.NftCollectionPublicPath = /public/BBNFTCollection
  838.         self.AdminStoragePath = /storage/BBAdmin
  839.  
  840.         self.account.save<@Collection>(<- create Collection(), to: self.NftCollectionStoragePath)
  841.  
  842.         self.account.link<&BBCollectables.Collection{NonFungibleToken.CollectionPublic, MetadataViews.ResolverCollection}>(self.NftCollectionPublicPath, target: self.NftCollectionStoragePath)
  843.  
  844.         let adminResource: @BBCollectables.Admin <- create Admin()
  845.  
  846.         adminResource.createPack(name: "Coleção 2024", rarityDistribution: { "comum": 50, "raro": 30,"épico":16, "lendário": 4})
  847.  
  848.         self.account.save<@Admin>(<- adminResource, to: self.AdminStoragePath)
  849.  
  850.         emit ContractInitialized()
  851.  
  852.        
  853.     }
  854. }
  855.  
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!