NFT Catalog

The NFT Catalog is an on chain registry listing NFT collections that exists on Flow which adhere to the NFT metadata standard. This empowers dApp developers to easily build on top of and discover interoperable NFT collections on Flow.

Live Site

Checkout the catalog site to submit your NFT collection both on testnet and mainnet.

Contract Addresses

NFTCatalog.cdc: This contract contains the NFT Catalog

Network	Address
Mainnet	0x49a7cda3a1eecc29
Testnet	0x324c34e1c517e4db

NFTRetrieval.cdc: This contract contains helper functions to make it easier to discover NFTs within accounts and from the catalog

Network	Address
Mainnet	0x49a7cda3a1eecc29
Testnet	0x324c34e1c517e4db

Submitting a Collection to the NFT Catalog

Visit here
Enter the address containing the NFT contract which contains the collection and select the contract.

Enter the storage path where the NFTs are stored and enter an address that holds a sample NFT or log in if you have access to an account that owns the NFT.
The application will verify that your NFT collection implements the required Metadata views.
1. The required metadata views include…
  1. NFT Display
    1. How to display an individual NFT part of the collection
  2. External URL
    1. A website for the NFT collection
  3. Collection Data
    1. Information needed to store and retrieve an NFT
  4. Collection Display
    1. How to display information about the NFT collection the NFT belongs to
  5. Royalties
    1. Any royalties that should be accounted for during marketplace transactions
2. You can find sample implementations of all these views in this example NFT contract.
3. If you are not implementing a view, the app will communicate this and you can update your NFT contract and try resubmitting.
Submit proposal transaction to the NFT catalog by entering a unique url safe identifier for the collection and a message including any additional context (like contact information).

Once submitted you can view all proposals here to track the review of your NFT.

If you would like to make a proposal manually, you may submit the following transaction with all parameters filled in: https://github.com/dapperlabs/nft-catalog/blob/main/cadence/transactions/propose_nft_to_catalog.cdc

Proposals should be reviewed and approved within a few days. Reasons for a proposal being rejected may include:

Providing duplicate path or name information of an existing collection on the catalog
Providing a not url safe or inaccurate name as the identifier

Using the Catalog (For marketplaces and other NFT applications)

All of the below examples use the catalog in mainnet, you may replace the imports to the testnet address when using the testnet network.

Example 1 - Retrieve all NFT collections on the catalog


_12import NFTCatalog from 0x49a7cda3a1eecc29
_12
_12/*
_12	The catalog is returned as a `String: NFTCatalogMetadata`
_12	The key string is intended to be a unique identifier for a specific collection.
_12	The NFTCatalogMetadata contains collection-level views corresponding to each
_12	collection identifier.
_12*/
_12access(all) fun main(): {String : NFTCatalog.NFTCatalogMetadata} {
_12    return NFTCatalog.getCatalog()
_12
_12}

Example 2 - Retrieve all collection names in the catalog


_10import NFTCatalog from 0x49a7cda3a1eecc29
_10
_10access(all) fun main(): [String] {
_10		let catalog: {String : NFTCatalog.NFTCatalogMetadata} = NFTCatalog.getCatalog()
_10		let catalogNames: [String] = []
_10		for collectionIdentifier in catalog.keys {
_10			catalogNames.append(catalog[collectionIdentifier]!.collectionDisplay.name)
_10    }
_10    return catalogNames
_10}

Example 3 - Retrieve NFT collections and counts owned by an account


_29import MetadataViews from 0x1d7e57aa55817448
_29import NFTCatalog from 0x49a7cda3a1eecc29
_29import NFTRetrieval from 0x49a7cda3a1eecc29
_29
_29access(all) fun main(ownerAddress: Address) : {String : Number} {
_29    let catalog = NFTCatalog.getCatalog()
_29    let account = getAuthAccount(ownerAddress)
_29    let items : {String : Number} = {}
_29
_29    for key in catalog.keys {
_29        let value = catalog[key]!
_29        let tempPathStr = "catalog".concat(key)
_29        let tempPublicPath = PublicPath(identifier: tempPathStr)!
_29        account.link<&{MetadataViews.ResolverCollection}>(
_29            tempPublicPath,
_29            target: value.collectionData.storagePath
_29        )
_29        let collectionCap = account.getCapability<&AnyResource{MetadataViews.ResolverCollection}>(tempPublicPath)
_29        if !collectionCap.check() {
_29            continue
_29        }
_29        let count = NFTRetrieval.getNFTCountFromCap(collectionIdentifier : key, collectionCap : collectionCap)
_29        if count != 0 {
_29            items[key] = count
_29        }
_29    }
_29
_29    return items
_29}

Sample Response...


_10{
_10    "schmoes_prelaunch_token": 1
_10}

Example 4 - Retrieve all NFTs including metadata owned by an account


_116import MetadataViews from 0x1d7e57aa55817448
_116import NFTCatalog from 0x49a7cda3a1eecc29
_116import NFTRetrieval from 0x49a7cda3a1eecc29
_116
_116access(all) struct NFT {
_116    access(all) let id : UInt64
_116    access(all) let name : String
_116    access(all) let description : String
_116    access(all) let thumbnail : String
_116    access(all) let externalURL : String
_116    access(all) let storagePath : StoragePath
_116    access(all) let publicPath : PublicPath
_116    access(all) let privatePath: PrivatePath
_116    access(all) let publicLinkedType: Type
_116    access(all) let privateLinkedType: Type
_116    access(all) let collectionName : String
_116    access(all) let collectionDescription: String
_116    access(all) let collectionSquareImage : String
_116    access(all) let collectionBannerImage : String
_116    access(all) let royalties: [MetadataViews.Royalty]
_116
_116    init(
_116            id: UInt64,
_116            name : String,
_116            description : String,
_116            thumbnail : String,
_116            externalURL : String,
_116            storagePath : StoragePath,
_116            publicPath : PublicPath,
_116            privatePath : PrivatePath,
_116            publicLinkedType : Type,
_116            privateLinkedType : Type,
_116						collectionIdentifier: String,
_116            collectionName : String,
_116            collectionDescription : String,
_116            collectionSquareImage : String,
_116            collectionBannerImage : String,
_116            royalties : [MetadataViews.Royalty]
_116    ) {
_116        self.id = id
_116        self.name = name
_116        self.description = description
_116        self.thumbnail = thumbnail
_116        self.externalURL = externalURL
_116        self.storagePath = storagePath
_116        self.publicPath = publicPath
_116        self.privatePath = privatePath
_116        self.publicLinkedType = publicLinkedType
_116        self.privateLinkedType = privateLinkedType
_116				self.collectionIdentifier = collectionIdentifier
_116        self.collectionName = collectionName
_116        self.collectionDescription = collectionDescription
_116        self.collectionSquareImage = collectionSquareImage
_116        self.collectionBannerImage = collectionBannerImage
_116        self.royalties = royalties
_116    }
_116}
_116
_116access(all) fun main(ownerAddress: Address) : { String : [NFT] } {
_116    let catalog = NFTCatalog.getCatalog()
_116    let account = getAuthAccount(ownerAddress)
_116    let items : [NFTRetrieval.BaseNFTViewsV1] = []
_116
_116    let data : {String : [NFT] } = {}
_116
_116    for key in catalog.keys {
_116        let value = catalog[key]!
_116        let tempPathStr = "catalog".concat(key)
_116        let tempPublicPath = PublicPath(identifier: tempPathStr)!
_116        account.link<&{MetadataViews.ResolverCollection}>(
_116            tempPublicPath,
_116            target: value.collectionData.storagePath
_116        )
_116        let collectionCap = account.getCapability<&AnyResource{MetadataViews.ResolverCollection}>(tempPublicPath)
_116        if !collectionCap.check() {
_116            continue
_116        }
_116        let views = NFTRetrieval.getNFTViewsFromCap(collectionIdentifier : key, collectionCap : collectionCap)
_116
_116        let items : [NFT] = []
_116        for view in views {
_116            let displayView = view.display
_116            let externalURLView = view.externalURL
_116            let collectionDataView = view.collectionData
_116            let collectionDisplayView = view.collectionDisplay
_116            let royaltyView = view.royalties
_116            if (displayView == nil || externalURLView == nil || collectionDataView == nil || collectionDisplayView == nil || royaltyView == nil) {
_116                // This NFT does not have the proper views implemented. Skipping....
_116                continue
_116            }
_116
_116            items.append(
_116                NFT(
_116                    id: view.id,
_116                    name : displayView!.name,
_116                    description : displayView!.description,
_116                    thumbnail : displayView!.thumbnail.uri(),
_116                    externalURL : externalURLView!.url,
_116                    storagePath : collectionDataView!.storagePath,
_116                    publicPath : collectionDataView!.publicPath,
_116                    privatePath : collectionDataView!.providerPath,
_116                    publicLinkedType : collectionDataView!.publicLinkedType,
_116                    privateLinkedType : collectionDataView!.providerLinkedType,
_116										collectionIdentifier: key,
_116                    collectionName : collectionDisplayView!.name,
_116                    collectionDescription : collectionDisplayView!.description,
_116                    collectionSquareImage : collectionDisplayView!.squareImage.file.uri(),
_116                    collectionBannerImage : collectionDisplayView!.bannerImage.file.uri(),
_116                    royalties : royaltyView!.getRoyalties()
_116                )
_116            )
_116        }
_116        data[key] = items
_116    }
_116    return data
_116}

Sample Response...


_23{
_23    "FlovatarComponent": [],
_23    "schmoes_prelaunch_token": [
_23        s.aa16be98aac20e8073f923261531cbbdfae1464f570f5be796b57cdc97656248.NFT(
_23            id: 1006,
_23            name: "Schmoes Pre Launch Token #1006",
_23            description: "",
_23            thumbnail: "https://gateway.pinata.cloud/ipfs/QmXQ1iBke5wjcjYG22ACVXsCvtMJKEkwFiMf96UChP8uJq",
_23            externalURL: "https://schmoes.io",
_23            storagePath: /storage/SchmoesPreLaunchTokenCollection,
_23            publicPath: /public/SchmoesPreLaunchTokenCollection,
_23            privatePath: /private/SchmoesPreLaunchTokenCollection,
_23            publicLinkedType: Type<&A.6c4fe48768523577.SchmoesPreLaunchToken.Collection{A.1d7e57aa55817448.NonFungibleToken.CollectionPublic,A.  1d7e57aa55817448.NonFungibleToken.Receiver,A.1d7e57aa55817448.MetadataViews.ResolverCollection}>(),
_23            privateLinkedType: Type<&A.6c4fe48768523577.SchmoesPreLaunchToken.Collection{A.1d7e57aa55817448.NonFungibleToken.CollectionPublic,A.1d7e57aa55817448.NonFungibleToken.Provider,A.1d7e57aa55817448.MetadataViews.ResolverCollection}>(),
_23            collectionName: "Schmoes Pre Launch Token",
_23            collectionDescription: "",
_23            collectionSquareImage: "https://gateway.pinata.cloud/ipfs/QmXQ1iBke5wjcjYG22ACVXsCvtMJKEkwFiMf96UChP8uJq",
_23            collectionBannerImage: "https://gateway.pinata.cloud/ipfs/QmXQ1iBke5wjcjYG22ACVXsCvtMJKEkwFiMf96UChP8uJq",
_23            royalties: []
_23        )
_23    ],
_23    "Flovatar": []
_23}

Example 5 - Retrieve all NFTs including metadata owned by an account for large wallets

For Wallets that have a lot of NFTs you may run into memory issues. The common pattern to get around this for now is to retrieve just the ID's in a wallet by calling the following script


_33import MetadataViews from 0x1d7e57aa55817448
_33import NFTCatalog from 0x49a7cda3a1eecc29
_33import NFTRetrieval from 0x49a7cda3a1eecc29
_33
_33access(all) fun main(ownerAddress: Address) : {String : [UInt64]} {
_33    let catalog = NFTCatalog.getCatalog()
_33    let account = getAuthAccount(ownerAddress)
_33
_33    let items : {String : [UInt64]} = {}
_33
_33    for key in catalog.keys {
_33        let value = catalog[key]!
_33        let tempPathStr = "catalogIDs".concat(key)
_33        let tempPublicPath = PublicPath(identifier: tempPathStr)!
_33        account.link<&{MetadataViews.ResolverCollection}>(
_33            tempPublicPath,
_33            target: value.collectionData.storagePath
_33        )
_33
_33        let collectionCap = account.getCapability<&AnyResource{MetadataViews.ResolverCollection}>(tempPublicPath)
_33        if !collectionCap.check() {
_33            continue
_33        }
_33
_33        let ids = NFTRetrieval.getNFTIDsFromCap(collectionIdentifier : key, collectionCap : collectionCap)
_33
_33        if ids.length > 0 {
_33            items[key] = ids
_33        }
_33    }
_33    return items
_33
_33}

and then use the ids to retrieve the full metadata for only those ids by calling the following script and passing in a map of collectlionIdentifer -> [ids]


_120import MetadataViews from 0x1d7e57aa55817448
_120import NFTCatalog from 0x49a7cda3a1eecc29
_120import NFTRetrieval from 0x49a7cda3a1eecc29
_120
_120access(all) struct NFT {
_120    access(all) let id : UInt64
_120    access(all) let name : String
_120    access(all) let description : String
_120    access(all) let thumbnail : String
_120    access(all) let externalURL : String
_120    access(all) let storagePath : StoragePath
_120    access(all) let publicPath : PublicPath
_120    access(all) let privatePath: PrivatePath
_120    access(all) let publicLinkedType: Type
_120    access(all) let privateLinkedType: Type
_120    access(all) let collectionName : String
_120    access(all) let collectionDescription: String
_120    access(all) let collectionSquareImage : String
_120    access(all) let collectionBannerImage : String
_120    access(all) let royalties: [MetadataViews.Royalty]
_120
_120    init(
_120            id: UInt64,
_120            name : String,
_120            description : String,
_120            thumbnail : String,
_120            externalURL : String,
_120            storagePath : StoragePath,
_120            publicPath : PublicPath,
_120            privatePath : PrivatePath,
_120            publicLinkedType : Type,
_120            privateLinkedType : Type,
_120            collectionName : String,
_120            collectionDescription : String,
_120            collectionSquareImage : String,
_120            collectionBannerImage : String,
_120            royalties : [MetadataViews.Royalty]
_120    ) {
_120        self.id = id
_120        self.name = name
_120        self.description = description
_120        self.thumbnail = thumbnail
_120        self.externalURL = externalURL
_120        self.storagePath = storagePath
_120        self.publicPath = publicPath
_120        self.privatePath = privatePath
_120        self.publicLinkedType = publicLinkedType
_120        self.privateLinkedType = privateLinkedType
_120        self.collectionName = collectionName
_120        self.collectionDescription = collectionDescription
_120        self.collectionSquareImage = collectionSquareImage
_120        self.collectionBannerImage = collectionBannerImage
_120        self.royalties = royalties
_120    }
_120}
_120
_120access(all) fun main(ownerAddress: Address, collections: {String : [UInt64]}) : {String : [NFT] } {
_120    let data : {String : [NFT] } = {}
_120
_120    let catalog = NFTCatalog.getCatalog()
_120    let account = getAuthAccount(ownerAddress)
_120    for collectionIdentifier in collections.keys {
_120        if catalog.containsKey(collectionIdentifier) {
_120            let value = catalog[collectionIdentifier]!
_120            let tempPathStr = "catalog".concat(collectionIdentifier)
_120            let tempPublicPath = PublicPath(identifier: tempPathStr)!
_120            account.link<&{MetadataViews.ResolverCollection}>(
_120                tempPublicPath,
_120                target: value.collectionData.storagePath
_120            )
_120
_120            let collectionCap = account.getCapability<&AnyResource{MetadataViews.ResolverCollection}>(tempPublicPath)
_120
_120            if !collectionCap.check() {
_120                return data
_120            }
_120
_120            let views = NFTRetrieval.getNFTViewsFromIDs(collectionIdentifier : collectionIdentifier, ids: collections[collectionIdentifier]!, collectionCap : collectionCap)
_120
_120            let items : [NFT] = []
_120
_120            for view in views {
_120                    let displayView = view.display
_120                    let externalURLView = view.externalURL
_120                    let collectionDataView = view.collectionData
_120                    let collectionDisplayView = view.collectionDisplay
_120                    let royaltyView = view.royalties
_120                    if (displayView == nil || externalURLView == nil || collectionDataView == nil || collectionDisplayView == nil || royaltyView == nil) {
_120                        // Bad NFT. Skipping....
_120                        continue
_120                    }
_120
_120                    items.append(
_120                        NFT(
_120                            id: view.id,
_120                            name : displayView!.name,
_120                            description : displayView!.description,
_120                            thumbnail : displayView!.thumbnail.uri(),
_120                            externalURL : externalURLView!.url,
_120                            storagePath : collectionDataView!.storagePath,
_120                            publicPath : collectionDataView!.publicPath,
_120                            privatePath : collectionDataView!.providerPath,
_120                            publicLinkedType : collectionDataView!.publicLinkedType,
_120                            privateLinkedType : collectionDataView!.providerLinkedType,
_120                            collectionName : collectionDisplayView!.name,
_120                            collectionDescription : collectionDisplayView!.description,
_120                            collectionSquareImage : collectionDisplayView!.squareImage.file.uri(),
_120                            collectionBannerImage : collectionDisplayView!.bannerImage.file.uri(),
_120                            royalties : royaltyView!.getRoyalties()
_120                        )
_120                    )
_120                }
_120
_120                data[collectionIdentifier] = items
_120        }
_120    }
_120
_120
_120    return data
_120}

Example 6 - Retrieve all MetadataViews for NFTs in a wallet

If you're looking for some MetadataViews that aren't in the core view list you can leverage this script to grab all the views each NFT supports. Note: You lose some typing here but get more data.


_68import MetadataViews from 0x1d7e57aa55817448
_68import NFTCatalog from 0x49a7cda3a1eecc29
_68import NFTRetrieval from 0x49a7cda3a1eecc29
_68
_68access(all) struct NFTCollectionData {
_68    access(all) let storagePath : StoragePath
_68    access(all) let publicPath : PublicPath
_68    access(all) let privatePath: PrivatePath
_68    access(all) let publicLinkedType: Type
_68    access(all) let privateLinkedType: Type
_68
_68    init(
_68            storagePath : StoragePath,
_68            publicPath : PublicPath,
_68            privatePath : PrivatePath,
_68            publicLinkedType : Type,
_68            privateLinkedType : Type,
_68    ) {
_68        self.storagePath = storagePath
_68        self.publicPath = publicPath
_68        self.privatePath = privatePath
_68        self.publicLinkedType = publicLinkedType
_68        self.privateLinkedType = privateLinkedType
_68    }
_68}
_68
_68access(all) fun main(ownerAddress: Address) : { String : {String : AnyStruct} }  {
_68    let catalog = NFTCatalog.getCatalog()
_68    let account = getAuthAccount(ownerAddress)
_68    let items : [MetadataViews.NFTView] = []
_68
_68    let data : { String : {String : AnyStruct} } = {}
_68
_68    for key in catalog.keys {
_68        let value = catalog[key]!
_68        let tempPathStr = "catalog".concat(key)
_68        let tempPublicPath = PublicPath(identifier: tempPathStr)!
_68        account.link<&{MetadataViews.ResolverCollection}>(
_68            tempPublicPath,
_68            target: value.collectionData.storagePath
_68        )
_68        let collectionCap = account.getCapability<&AnyResource{MetadataViews.ResolverCollection}>(tempPublicPath)
_68        if !collectionCap.check() {
_68            continue
_68        }
_68
_68        var views = NFTRetrieval.getAllMetadataViewsFromCap(collectionIdentifier : key, collectionCap : collectionCap)
_68
_68        if views.keys.length == 0 {
_68            continue
_68        }
_68
_68        // Cadence doesn't support function return types, lets manually get rid of it
_68        let nftCollectionDisplayView = views[Type<MetadataViews.NFTCollectionData>().identifier] as! MetadataViews.NFTCollectionData?
_68        let collectionDataView = NFTCollectionData(
_68                    storagePath : nftCollectionDisplayView!.storagePath,
_68                    publicPath : nftCollectionDisplayView!.publicPath,
_68                    privatePath : nftCollectionDisplayView!.providerPath,
_68                    publicLinkedType : nftCollectionDisplayView!.publicLinkedType,
_68                    privateLinkedType : nftCollectionDisplayView!.providerLinkedType,
_68        )
_68        views.insert(key: Type<MetadataViews.NFTCollectionData>().identifier, collectionDataView)
_68
_68        data[key] = views
_68    }
_68
_68    return data
_68}

Example 7 - Setup a user’s account to receive a specific collection

Run the following script to retrieve some collection-level information for an NFT collection identifier from the catalog


_58import MetadataViews from 0x1d7e57aa55817448
_58import NFTCatalog from 0x49a7cda3a1eecc29
_58import NFTRetrieval from 0x49a7cda3a1eecc29
_58
_58access(all) struct NFTCollection {
_58    access(all) let storagePath : StoragePath
_58    access(all) let publicPath : PublicPath
_58    access(all) let privatePath: PrivatePath
_58    access(all) let publicLinkedType: Type
_58    access(all) let privateLinkedType: Type
_58    access(all) let collectionName : String
_58    access(all) let collectionDescription: String
_58    access(all) let collectionSquareImage : String
_58    access(all) let collectionBannerImage : String
_58
_58    init(
_58            storagePath : StoragePath,
_58            publicPath : PublicPath,
_58            privatePath : PrivatePath,
_58            publicLinkedType : Type,
_58            privateLinkedType : Type,
_58            collectionName : String,
_58            collectionDescription : String,
_58            collectionSquareImage : String,
_58            collectionBannerImage : String
_58    ) {
_58        self.storagePath = storagePath
_58        self.publicPath = publicPath
_58        self.privatePath = privatePath
_58        self.publicLinkedType = publicLinkedType
_58        self.privateLinkedType = privateLinkedType
_58        self.collectionName = collectionName
_58        self.collectionDescription = collectionDescription
_58        self.collectionSquareImage = collectionSquareImage
_58        self.collectionBannerImage = collectionBannerImage
_58    }
_58}
_58
_58access(all) fun main(collectionIdentifier : String) : NFT? {
_58        let catalog = NFTCatalog.getCatalog()
_58
_58        assert(catalog.containsKey(collectionIdentifier), message: "Invalid Collection")
_58
_58              return NFTCollection(
_58                  storagePath : collectionDataView!.storagePath,
_58                  publicPath : collectionDataView!.publicPath,
_58                  privatePath : collectionDataView!.providerPath,
_58                  publicLinkedType : collectionDataView!.publicLinkedType,
_58                  privateLinkedType : collectionDataView!.providerLinkedType,
_58                  collectionName : collectionDisplayView!.name,
_58                  collectionDescription : collectionDisplayView!.description,
_58                  collectionSquareImage : collectionDisplayView!.squareImage.file.uri(),
_58                  collectionBannerImage : collectionDisplayView!.bannerImage.file.uri()
_58              )
_58          }
_58
_58        panic("Invalid Token ID")
_58}

This script result can then be used to form a transaction by inserting the relevant variables from above into a transaction template like the following:


_26import NonFungibleToken from 0x1d7e57aa55817448
_26import MetadataViews from 0x1d7e57aa55817448
_26{ADDITIONAL_IMPORTS}
_26
_26transaction {
_26
_26    prepare(signer: AuthAccount) {
_26        // Create a new empty collection
_26        let collection <- {CONTRACT_NAME}.createEmptyCollection()
_26
_26        // save it to the account
_26        signer.save(<-collection, to: {STORAGE_PATH})
_26
_26        // create a public capability for the collection
_26        signer.link<&{PUBLIC_LINKED_TYPE}>(
_26            {PUBLIC_PATH},
_26            target: {STORAGE_PATH}
_26        )
_26
_26				// create a private capability for the collection
_26        signer.link<&{PRIVATE_LINKED_TYPE}>(
_26            {PRIVATE_PATH},
_26            target: {STORAGE_PATH}
_26        )
_26    }
_26}

Developer Usage

1. Install the Flow CLI

2. Install Node

3. Clone the project


_10git clone --depth=1 https://github.com/onflow/nft-catalog.git

4. Install packages

Run npm install in the root of the project

5. Run Test Suite

Run npm test in the root of the project

Cadence Generation

Using the NFT Catalog, you can generate common scripts and transactions to be run against the Flow Blockchain to support your application.

Generate from Javascript

Installation


_10npm install @onflow/fcl
_10npm install flow-catalog


_10yarn add @onflow/fcl
_10yarn add flow-catalog

Usage

1. Retrieve a list of transactions available for code generation: NOTE: In order to properly bootstrap the method, you will need to run and await on the getAddressMaps() method, passing it into all of the methods as shown below.


_10import { getAddressMaps, scripts } from "flow-catalog";
_10import * as fcl from "@onflow/fcl"
_10
_10const main = async () => {
_10    const addressMap = await getAddressMaps();
_10    console.log(await scripts.getSupportedGeneratedTransactions(addressMap));
_10};
_10
_10main();

2. Provide a Catalog collection identifier to generate code


_15const getTemplatedTransactionCode = async function() {
_15  const catalogAddressMap = await getAddressMaps()
_15  const result = await cadence.scripts.genTx({
_15
_15    /*
_15        'CollectionInitialization' is one of the available transactions from step 1.
_15        'Flunks' is the collection identifier in this case
_15        'Flow' is a fungible token identifier (if applicable to the transaction being used)
_15    */
_15
_15    args: ['CollectionInitialization', 'Flunks', 'flow'],
_15    addressMap: catalogAddressMap
_15  })
_15  return result
_15}

3. Use the generated code in a transaction


_10const txId = await fcl.mutate({
_10  cadence: await getTemplatedTransactionCode()[0],
_10  limit: 9999,
_10  args: (arg: any, t: any) => []
_10});
_10const transaction = await fcl.tx(txId).onceSealed()
_10return transaction

Generate from non-Javascript environments

Cadence scripts and transactions can be generated directly on-chain via scripts. You will need to be able to run cadence scripts to continue.

1. Retrieve a list of transactions available for code generation

Run the following script to retrieve available code generation methods: https://github.com/dapperlabs/nft-catalog/blob/main/cadence/scripts/get_supported_generated_transactions.cdc

2. Provide a catalog collection identifier to generate code

You may use the following script to generate code: https://github.com/dapperlabs/nft-catalog/blob/main/cadence/scripts/gen_tx.cdc

For example, from the CLI this may be run like the following: flow -n mainnet scripts execute ./get_tx.cdc CollectionInitialization Flunks flow

In the above example, CollectionInitialization is one of the supported transactions returned from step 1, Flunks is the name of an entry on the catalog (https://www.flow-nft-catalog.com/catalog/mainnet/Flunks), and flow is a fungible token identifier.

NPM Module

We exposed an interface to the catalog via a consumable NPM module. This library will expose a number of methods that can be called to interact with the catalog.

Methods

Method signatures and their associating parameters/responses can be found in the cadence/ folder of this repo.

Scripts


_20checkForRecommendedV1Views
_20genTx
_20getAllNftsInAccount
_20getExamplenftCollectionLength
_20getExamplenftType
_20getNftCatalog
_20getNftCatalogProposals
_20getNftCollectionsForNftType
_20getNftIdsInAccount
_20getNftInAccount
_20getNftInAccountFromPath
_20getNftMetadataForCollectionIdentifier
_20getNftProposalForId
_20getNftsCountInAccount
_20getNftsInAccount
_20getNftsInAccountFromIds
_20getNftsInAccountFromPath
_20getSupportedGeneratedTransactions
_20hasAdminProxy
_20isCatalogAdmin

Transactions


_17addToNftCatalog
_17addToNftCatalogAdmin
_17approveNftCatalogProposal
_17mintExampleNft
_17mintNonstandardNft
_17proposeNftToCatalog
_17rejectNftCatalogProposal
_17removeFromNftCatalog
_17removeNftCatalogProposal
_17sendAdminCapabilityToProxy
_17setupExamplenftCollection
_17setupNftCatalogAdminProxy
_17setupNonstandardnftCollection
_17setupStorefront
_17transferExamplenft
_17updateNftCatalogEntry
_17withdrawNftProposalFromCatalog

Installation


_10npm install flow-catalog


_10yarn add flow-catalog

Usage

Methods can be imported as follows, all nested methods live under the scripts or transactions variable.

NOTE: In order to properly bootstrap the method, you will need to run and await on the getAddressMaps() method, passing it into all of the methods as shown below.


_10import { getAddressMaps, scripts } from "flow-catalog";
_10
_10const main = async () => {
_10    const addressMap = await getAddressMaps();
_10    console.log(await scripts.getNftCatalog(addressMap));
_10};
_10
_10main();

The response of any method is a tuple-array, with the first element being the result, and the second being the error (if applicable).

For example, the result of the method above would look like -


_20[
_20  {
_20    BILPlayerCollection: {
_20      contractName: 'Player',
_20      contractAddress: '0x9e6cdb88e34fa1f3',
_20      nftType: [Object],
_20      collectionData: [Object],
_20      collectionDisplay: [Object]
_20    },
_20    ...
_20    SoulMadeComponent: {
_20      contractName: 'SoulMadeComponent',
_20      contractAddress: '0x421c19b7dc122357',
_20      nftType: [Object],
_20      collectionData: [Object],
_20      collectionDisplay: [Object]
_20    }
_20  },
_20  null
_20]

License

The works in these files:

are under the Unlicense.

Live Site​

Contract Addresses​

Submitting a Collection to the NFT Catalog​

Using the Catalog (For marketplaces and other NFT applications)​

Developer Usage​

1. Install the Flow CLI​

2. Install Node​

3. Clone the project​

4. Install packages​

5. Run Test Suite​

Cadence Generation​

Generate from Javascript​

Installation​

Usage​

Generate from non-Javascript environments​

NPM Module​

Methods​

Scripts​

Transactions​

Installation​

Usage​

License​

Live Site

Contract Addresses

Submitting a Collection to the NFT Catalog

Using the Catalog (For marketplaces and other NFT applications)

Developer Usage

1. Install the Flow CLI

2. Install Node

3. Clone the project

4. Install packages

5. Run Test Suite

Cadence Generation

Generate from Javascript

Installation

Usage

Generate from non-Javascript environments

NPM Module

Methods

Scripts

Transactions

Installation

Usage

License