@xyo-network/crypto-nft-collection-witness-plugin 2.78.0 → 2.78.2

package/src/lib/getNftCollectionMetadata.ts

@@ -1,12 +1,19 @@
-import { Auth, SDK } from '@infura/sdk'
+import { Interface } from '@ethersproject/abi'
 import { NftCollectionMetadata } from '@xyo-network/crypto-nft-collection-payload-plugin'
-import { toTokenType } from '@xyo-network/crypto-nft-payload-plugin'
+import { ERC721Enumerable__factory, ERC1155__factory } from '@xyo-network/open-zeppelin-typechain'
+import { constants } from 'ethers'
 
+import { getProviderFromEnv } from './getProvider'
 import { nonEvaluableContractAddresses } from './nonEvaluableContractAddresses'
 
-type ContractAddressOptions = {
-  contractAddress: string
-  cursor?: string
+export function getInterfaceID(contractInterface: Interface) {
+  let interfaceID = constants.Zero
+  const functions: string[] = Object.keys(contractInterface.functions)
+  for (let i = 0; i < functions.length; i++) {
+    interfaceID = interfaceID.xor(contractInterface.getSighash(functions[i]))
+  }
+
+  return interfaceID.toHexString()
 }
 
 export const getNftCollectionMetadata = async (
@@ -18,21 +25,34 @@ export const getNftCollectionMetadata = async (
    * The chain ID (1 = Ethereum Mainnet, 4 = Rinkeby, etc.) of the chain to search for NFTs on
    */
   chainId: number,
-  // /**
-  //  * The ethers provider to use to search for NFTs
-  //  */
-  // provider: ExternalProvider | JsonRpcFetchFunc,
-  /**
-   * The private key of the wallet to use to search for NFTs
-   */
-  privateKey: string,
 ): Promise<Omit<NftCollectionMetadata, 'total'>> => {
   if (nonEvaluableContractAddresses.includes(contractAddress.toUpperCase())) {
     throw new Error(`Unable to evaluate collection with contractAddress: ${contractAddress}`)
   }
-  const sdk = new SDK(new Auth({ chainId, privateKey, projectId: process.env.INFURA_PROJECT_ID, secretId: process.env.INFURA_PROJECT_SECRET }))
-  const opts: ContractAddressOptions = { contractAddress }
-  const { name, symbol, tokenType } = await sdk.api.getContractMetadata(opts)
-  const type = toTokenType(tokenType)
-  return { address: contractAddress, chainId, name, symbol, type }
+  const provider = getProviderFromEnv(chainId)
+  const contract721 = ERC721Enumerable__factory.connect(contractAddress, provider)
+  const contract1155 = ERC1155__factory.connect(contractAddress, provider)
+  let name: string = ''
+  try {
+    name = await contract721.name()
+  } catch (ex) {
+    const error = ex as Error
+    console.log(`name: ${error.message}`)
+  }
+  let symbol: string = ''
+  try {
+    symbol = await contract721.symbol()
+  } catch (ex) {
+    const error = ex as Error
+    console.log(`symbol: ${error.message}`)
+  }
+  let is1155: boolean = false
+  try {
+    is1155 = await contract1155.supportsInterface(getInterfaceID(ERC1155__factory.getInterface(ERC1155__factory.abi)))
+  } catch (ex) {
+    const error = ex as Error
+    console.log(`is1155: ${error.message}`)
+    is1155 = false
+  }
+  return { address: contractAddress, chainId, name, symbol, type: is1155 ? 'ERC1155' : 'ERC721' }
 }

package/src/lib/getNftCollectionNfts.ts

@@ -1,11 +1,34 @@
-import { Auth, SDK } from '@infura/sdk'
-import { NftInfo, NftInfoFields, NftSchema, toTokenType } from '@xyo-network/crypto-nft-payload-plugin'
+import { AxiosJson } from '@xyo-network/axios'
+import { NftInfo, NftMetadata, NftSchema, toTokenType } from '@xyo-network/crypto-nft-payload-plugin'
+import { ERC721Enumerable__factory, ERC721URIStorage__factory, ERC1155Supply__factory } from '@xyo-network/open-zeppelin-typechain'
 
+import { getNftCollectionMetadata } from './getNftCollectionMetadata'
+import { getProviderFromEnv } from './getProvider'
 import { nonEvaluableContractAddresses } from './nonEvaluableContractAddresses'
 
-type ContractAddressOptions = {
-  contractAddress: string
-  cursor?: string
+const ipfsGateway = '5d7b6582.beta.decentralnetworkservices.com'
+
+/**
+ * Returns the equivalent IPFS gateway URL for the supplied URL.
+ * @param urlToCheck The URL to check
+ * @returns If the supplied URL is an IPFS URL, it converts the URL to the
+ * equivalent IPFS gateway URL. Otherwise, returns the original URL.
+ */
+export const checkIpfsUrl = (urlToCheck: string, ipfsGateway: string) => {
+  const url = new URL(urlToCheck)
+  let protocol = url.protocol
+  let host = url.host
+  let path = url.pathname
+  const query = url.search
+  if (protocol === 'ipfs:') {
+    protocol = 'https:'
+    host = ipfsGateway
+    path = url.host === 'ipfs' ? `ipfs${path}` : `ipfs/${url.host}${path}`
+    const root = `${protocol}//${host}/${path}`
+    return query?.length > 0 ? `${root}?${query}` : root
+  } else {
+    return urlToCheck
+  }
 }
 
 export const getNftCollectionNfts = async (
@@ -17,14 +40,6 @@ export const getNftCollectionNfts = async (
    * The chain ID (1 = Ethereum Mainnet, 4 = Rinkeby, etc.) of the chain to search for NFTs on
    */
   chainId: number,
-  // /**
-  //  * The ethers provider to use to search for NFTs
-  //  */
-  // provider: ExternalProvider | JsonRpcFetchFunc,
-  /**
-   * The private key of the wallet to use to search for NFTs
-   */
-  privateKey: string,
   /**
    * The maximum number of NFTs to return. Configurable to prevent
    * large wallets from exhausting Infura API credits. Ideally a
@@ -35,22 +50,38 @@ export const getNftCollectionNfts = async (
   if (nonEvaluableContractAddresses.includes(contractAddress.toUpperCase())) {
     throw new Error(`Unable to evaluate collection with contractAddress: ${contractAddress}`)
   }
-  const sdk = new SDK(new Auth({ chainId, privateKey, projectId: process.env.INFURA_PROJECT_ID, secretId: process.env.INFURA_PROJECT_SECRET }))
-  const nfts: NftInfoFields[] = []
-  let cursor: string | undefined = undefined
-  do {
-    const opts: ContractAddressOptions = { contractAddress, cursor }
-    const { cursor: nextCursor, pageSize, total, assets } = await sdk.api.getNFTsForCollection(opts)
-    const batch: NftInfoFields[] = assets.slice(0, Math.min(pageSize, total - nfts.length)).map((asset) => {
-      const { contract: address, type: tokenType, ...rest } = asset
-      const type = toTokenType(tokenType)
-      return { address, chainId, type, ...rest }
-    })
-    nfts.push(...batch)
-    cursor = nextCursor
-    if (nfts.length >= total || !cursor) break
-  } while (nfts.length < maxNfts)
-  return nfts.map((nft) => {
-    return { ...nft, schema: NftSchema }
-  })
+  const axios = new AxiosJson({ timeout: 2000 })
+  const provider = getProviderFromEnv(chainId)
+  const enumerable = ERC721Enumerable__factory.connect(contractAddress, provider)
+  const storage = ERC721URIStorage__factory.connect(contractAddress, provider)
+  const supply1155 = ERC1155Supply__factory.connect(contractAddress, provider)
+  const result: NftInfo[] = []
+  const { type: nftType } = await getNftCollectionMetadata(contractAddress, chainId)
+
+  for (let i = 0; i < maxNfts; i++) {
+    const tokenId = (await enumerable.tokenByIndex(i)).toHexString()
+    const supply = nftType === toTokenType('ERC11155') ? (await supply1155.totalSupply(tokenId)).toHexString() : '0x01'
+    const metadataUri = await storage.tokenURI(tokenId)
+    const checkedMetaDataUri = checkIpfsUrl(metadataUri, ipfsGateway)
+    let metadata: NftMetadata | undefined = undefined
+    try {
+      metadata = (await axios.get(checkedMetaDataUri)).data
+    } catch (ex) {
+      const error = ex as Error
+      console.error(error.message)
+    }
+
+    const info: NftInfo = {
+      address: contractAddress,
+      chainId,
+      metadata,
+      metadataUri,
+      schema: NftSchema,
+      supply,
+      tokenId,
+      type: nftType,
+    }
+    result.push(info)
+  }
+  return result
 }

package/src/lib/getProvider.ts

@@ -0,0 +1,17 @@
+import { InfuraProvider, WebSocketProvider } from '@ethersproject/providers'
+
+export const getProviderFromEnv = (chainId: string | number = 'homestead') => {
+  const infuraWssUri = process.env.INFURA_WSS_URI
+  const infuraProvider = new InfuraProvider('homestead', {
+    projectId: process.env.INFURA_PROJECT_ID,
+    projectSecret: process.env.INFURA_PROJECT_SECRET,
+  })
+
+  const infuraWebsocketProvider = infuraWssUri ? new WebSocketProvider(infuraWssUri, chainId) : undefined
+
+  const quickNodeUri = process.env.QUICKNODE_WSS_URI
+  const quickNodeProvider = quickNodeUri ? new WebSocketProvider(quickNodeUri, chainId) : undefined
+
+  const provider = infuraWebsocketProvider ?? infuraProvider ?? infuraWebsocketProvider ?? quickNodeProvider ?? infuraProvider
+  return provider
+}