@subwallet/extension-base 0.8.3-2 → 1.0.1

package/cjs/koni/api/nft/bit.country/index.js

@@ -0,0 +1,127 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BitCountryNftApi = void 0;
+var _config = require("@subwallet/extension-base/koni/api/nft/config");
+var _nft = require("@subwallet/extension-base/koni/api/nft/nft");
+var _utils = require("@subwallet/extension-base/utils");
+var _crossFetch = _interopRequireDefault(require("cross-fetch"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+class BitCountryNftApi extends _nft.BaseNftApi {
+  constructor(api, addresses, chain) {
+    super(chain, api, addresses);
+  }
+  parseUrl(input) {
+    if (!input || input.length === 0) {
+      return undefined;
+    }
+    if ((0, _utils.isUrl)(input)) {
+      return input;
+    }
+    if (!input.includes('ipfs://')) {
+      return _config.BIT_COUNTRY_SERVER + input;
+    }
+    return _config.BIT_COUNTRY_SERVER + input.split('ipfs://')[1];
+  }
+  async getNfts(addresses) {
+    if (!this.substrateApi) {
+      return [];
+    }
+    const assetIds = [];
+    await Promise.all(addresses.map(async address => {
+      // @ts-ignore
+      const resp = await this.substrateApi.api.query.ormlNFT.tokensByOwner.entries(address);
+      for (const item of resp) {
+        const data = item[0].toHuman();
+        assetIds.push({
+          classId: this.parseTokenId(data[1]),
+          tokenId: this.parseTokenId(data[2]),
+          owner: address
+        });
+      }
+    }));
+    return assetIds;
+  }
+  async getTokenDetails(assetId) {
+    if (!this.substrateApi) {
+      return null;
+    }
+    const onChainMeta = (await this.substrateApi.api.query.ormlNFT.tokens(assetId.classId, assetId.tokenId)).toHuman();
+    if (!onChainMeta.metadata) {
+      return null;
+    }
+    return await (0, _crossFetch.default)(_config.BIT_COUNTRY_SERVER + onChainMeta.metadata).then(resp => resp.json());
+  }
+  async getCollectionDetails(collectionId) {
+    if (!this.substrateApi) {
+      return null;
+    }
+    const metadataCollection = (await this.substrateApi.api.query.ormlNFT.classes(collectionId)).toHuman();
+    if (!metadataCollection.metadata) {
+      return null;
+    }
+    return await (0, _crossFetch.default)(_config.BIT_COUNTRY_SERVER + metadataCollection.metadata).then(resp => resp.json());
+  }
+  async fetchNfts(params) {
+    try {
+      await this.connect();
+      await this.handleNfts(params);
+    } catch (e) {
+      return 0;
+    }
+    return 1;
+  }
+  async handleNft(address, params) {
+    const assetIds = await this.getNfts([address]);
+    try {
+      if (!assetIds || assetIds.length === 0) {
+        return;
+      }
+      const collectionNftIds = {};
+      await Promise.all(assetIds.map(async assetId => {
+        const parsedClassId = this.parseTokenId(assetId.classId);
+        const parsedTokenId = this.parseTokenId(assetId.tokenId);
+        if (collectionNftIds[parsedClassId]) {
+          collectionNftIds[parsedClassId].push(parsedTokenId);
+        } else {
+          collectionNftIds[parsedClassId] = [parsedTokenId];
+        }
+        const [tokenInfo, collectionMeta] = await Promise.all([this.getTokenDetails(assetId), this.getCollectionDetails(parsedClassId)]);
+        const parsedNft = {
+          id: parsedTokenId,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          name: tokenInfo === null || tokenInfo === void 0 ? void 0 : tokenInfo.name,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
+          description: tokenInfo && tokenInfo.description ? tokenInfo.description : collectionMeta === null || collectionMeta === void 0 ? void 0 : collectionMeta.description,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+          image: tokenInfo && tokenInfo.image_url ? this.parseUrl(tokenInfo === null || tokenInfo === void 0 ? void 0 : tokenInfo.image_url) : this.parseUrl(collectionMeta === null || collectionMeta === void 0 ? void 0 : collectionMeta.image_url),
+          collectionId: parsedClassId,
+          chain: this.chain,
+          owner: address
+        };
+        const parsedCollection = {
+          collectionId: parsedClassId,
+          chain: this.chain,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
+          collectionName: collectionMeta === null || collectionMeta === void 0 ? void 0 : collectionMeta.name,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
+          image: this.parseUrl(collectionMeta === null || collectionMeta === void 0 ? void 0 : collectionMeta.image_url)
+        };
+        params.updateItem(this.chain, parsedNft, address);
+        params.updateCollection(this.chain, parsedCollection);
+        // params.updateReady(true);
+      }));
+    } catch (e) {
+      console.error('Failed to fetch bit.country nft', e);
+    }
+  }
+  async handleNfts(params) {
+    await Promise.all(this.addresses.map(address => this.handleNft(address, params)));
+  }
+}
+exports.BitCountryNftApi = BitCountryNftApi;

package/cjs/koni/api/nft/config.js

@@ -0,0 +1,144 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UNIQUE_SCAN_ENDPOINT = exports.UNIQUE_IPFS_GATEWAY = exports.TRANSFER_CHAIN_ID = exports.SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME = exports.SUPPORTED_TRANSFER_EVM_CHAIN_NAME = exports.SUPPORTED_TRANSFER_EVM_CHAIN = exports.SUPPORTED_NFT_NETWORKS = exports.SINGULAR_V2_ENDPOINT = exports.SINGULAR_V2_COLLECTION_ENDPOINT = exports.SINGULAR_V1_ENDPOINT = exports.SINGULAR_V1_COLLECTION_ENDPOINT = exports.RMRK_PINATA_SERVER = exports.QUARTZ_SCAN_ENDPOINT = exports.PINATA_IPFS_GATEWAY = exports.NFT_STORAGE_GATEWAY = exports.KANARIA_EXTERNAL_SERVER = exports.KANARIA_ENDPOINT = exports.IPFS_TELOS_MIAMI = exports.IPFS_IO_GATEWAY = exports.IPFS_GATEWAY_CLOUD = exports.IPFS_FLEEK = exports.GATEWAY_IPFS_IO = exports.DWEB_LINK = exports.CLOUDFLARE_PINATA_SERVER = exports.CF_IPFS_GATEWAY = exports.BIT_COUNTRY_THUMBNAIL_RESOLVER = exports.BIT_COUNTRY_SERVER = void 0;
+exports.getRandomIpfsGateway = getRandomIpfsGateway;
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const SINGULAR_V1_ENDPOINT = 'https://singular.rmrk-api.xyz/api/account-rmrk1/';
+exports.SINGULAR_V1_ENDPOINT = SINGULAR_V1_ENDPOINT;
+const SINGULAR_V2_ENDPOINT = 'https://singular.rmrk-api.xyz/api/account/';
+exports.SINGULAR_V2_ENDPOINT = SINGULAR_V2_ENDPOINT;
+const KANARIA_ENDPOINT = 'https://kanaria.rmrk.app/api/rmrk2/';
+exports.KANARIA_ENDPOINT = KANARIA_ENDPOINT;
+const RMRK_PINATA_SERVER = 'https://rmrk.mypinata.cloud/ipfs/';
+exports.RMRK_PINATA_SERVER = RMRK_PINATA_SERVER;
+const SINGULAR_V1_COLLECTION_ENDPOINT = 'https://singular.rmrk.app/api/rmrk1/collection/';
+exports.SINGULAR_V1_COLLECTION_ENDPOINT = SINGULAR_V1_COLLECTION_ENDPOINT;
+const SINGULAR_V2_COLLECTION_ENDPOINT = 'https://singular.app/api/rmrk2/collection/';
+exports.SINGULAR_V2_COLLECTION_ENDPOINT = SINGULAR_V2_COLLECTION_ENDPOINT;
+const KANARIA_EXTERNAL_SERVER = 'https://kanaria.rmrk.app/catalogue/';
+exports.KANARIA_EXTERNAL_SERVER = KANARIA_EXTERNAL_SERVER;
+const CLOUDFLARE_PINATA_SERVER = 'https://cloudflare-ipfs.com/ipfs/';
+exports.CLOUDFLARE_PINATA_SERVER = CLOUDFLARE_PINATA_SERVER;
+const BIT_COUNTRY_SERVER = 'https://ipfs-cdn.bit.country/';
+exports.BIT_COUNTRY_SERVER = BIT_COUNTRY_SERVER;
+const BIT_COUNTRY_THUMBNAIL_RESOLVER = 'https://res.cloudinary.com/ddftctzph/image/upload/c_scale,q_100,w_250/production-ipfs/asset/';
+exports.BIT_COUNTRY_THUMBNAIL_RESOLVER = BIT_COUNTRY_THUMBNAIL_RESOLVER;
+const CF_IPFS_GATEWAY = 'https://cf-ipfs.com/ipfs/';
+exports.CF_IPFS_GATEWAY = CF_IPFS_GATEWAY;
+const PINATA_IPFS_GATEWAY = 'https://gateway.pinata.cloud/ipfs/';
+exports.PINATA_IPFS_GATEWAY = PINATA_IPFS_GATEWAY;
+const UNIQUE_SCAN_ENDPOINT = 'https://explorer-api.unique.network/v1/graphql';
+exports.UNIQUE_SCAN_ENDPOINT = UNIQUE_SCAN_ENDPOINT;
+const QUARTZ_SCAN_ENDPOINT = 'https://hasura-quartz.unique.network/v1/graphql';
+exports.QUARTZ_SCAN_ENDPOINT = QUARTZ_SCAN_ENDPOINT;
+const UNIQUE_IPFS_GATEWAY = 'https://ipfs.unique.network/ipfs/';
+exports.UNIQUE_IPFS_GATEWAY = UNIQUE_IPFS_GATEWAY;
+const NFT_STORAGE_GATEWAY = 'https://nftstorage.link/ipfs/';
+exports.NFT_STORAGE_GATEWAY = NFT_STORAGE_GATEWAY;
+const IPFS_IO_GATEWAY = 'https://ipfs.io/ipfs/';
+exports.IPFS_IO_GATEWAY = IPFS_IO_GATEWAY;
+const GATEWAY_IPFS_IO = 'https://gateway.ipfs.io/ipfs/';
+exports.GATEWAY_IPFS_IO = GATEWAY_IPFS_IO;
+const DWEB_LINK = 'https://dweb.link/ipfs/';
+exports.DWEB_LINK = DWEB_LINK;
+const IPFS_GATEWAY_CLOUD = 'https://ipfs-gateway.cloud/ipfs/';
+exports.IPFS_GATEWAY_CLOUD = IPFS_GATEWAY_CLOUD;
+const IPFS_FLEEK = 'https://ipfs.fleek.co/ipfs/';
+exports.IPFS_FLEEK = IPFS_FLEEK;
+const IPFS_TELOS_MIAMI = 'https://ipfs.telos.miami/ipfs';
+exports.IPFS_TELOS_MIAMI = IPFS_TELOS_MIAMI;
+let SUPPORTED_NFT_NETWORKS;
+exports.SUPPORTED_NFT_NETWORKS = SUPPORTED_NFT_NETWORKS;
+(function (SUPPORTED_NFT_NETWORKS) {
+  SUPPORTED_NFT_NETWORKS["karura"] = "karura";
+  SUPPORTED_NFT_NETWORKS["acala"] = "acala";
+  SUPPORTED_NFT_NETWORKS["kusama"] = "kusama";
+  SUPPORTED_NFT_NETWORKS["statemine"] = "statemine";
+  SUPPORTED_NFT_NETWORKS["unique_network"] = "unique_network";
+  SUPPORTED_NFT_NETWORKS["quartz"] = "quartz";
+  SUPPORTED_NFT_NETWORKS["bitcountry"] = "bitcountry";
+  SUPPORTED_NFT_NETWORKS["pioneer"] = "pioneer";
+})(SUPPORTED_NFT_NETWORKS || (exports.SUPPORTED_NFT_NETWORKS = SUPPORTED_NFT_NETWORKS = {}));
+let SUPPORTED_TRANSFER_EVM_CHAIN_NAME;
+exports.SUPPORTED_TRANSFER_EVM_CHAIN_NAME = SUPPORTED_TRANSFER_EVM_CHAIN_NAME;
+(function (SUPPORTED_TRANSFER_EVM_CHAIN_NAME) {
+  SUPPORTED_TRANSFER_EVM_CHAIN_NAME["moonbeam"] = "moonbeam";
+  SUPPORTED_TRANSFER_EVM_CHAIN_NAME["moonbase"] = "moonbase";
+  SUPPORTED_TRANSFER_EVM_CHAIN_NAME["astarEvm"] = "astarEvm";
+  SUPPORTED_TRANSFER_EVM_CHAIN_NAME["moonriver"] = "moonriver";
+  SUPPORTED_TRANSFER_EVM_CHAIN_NAME["shiden"] = "shiden";
+  SUPPORTED_TRANSFER_EVM_CHAIN_NAME["shibuya"] = "shibuya";
+})(SUPPORTED_TRANSFER_EVM_CHAIN_NAME || (exports.SUPPORTED_TRANSFER_EVM_CHAIN_NAME = SUPPORTED_TRANSFER_EVM_CHAIN_NAME = {}));
+const SUPPORTED_TRANSFER_EVM_CHAIN = [SUPPORTED_TRANSFER_EVM_CHAIN_NAME.moonbase, SUPPORTED_TRANSFER_EVM_CHAIN_NAME.moonbeam, SUPPORTED_TRANSFER_EVM_CHAIN_NAME.moonriver, SUPPORTED_TRANSFER_EVM_CHAIN_NAME.astarEvm, SUPPORTED_TRANSFER_EVM_CHAIN_NAME.shiden, SUPPORTED_TRANSFER_EVM_CHAIN_NAME.shibuya];
+exports.SUPPORTED_TRANSFER_EVM_CHAIN = SUPPORTED_TRANSFER_EVM_CHAIN;
+const TRANSFER_CHAIN_ID = {
+  [SUPPORTED_TRANSFER_EVM_CHAIN_NAME.moonbase]: 1287,
+  [SUPPORTED_TRANSFER_EVM_CHAIN_NAME.moonbeam]: 1284,
+  [SUPPORTED_TRANSFER_EVM_CHAIN_NAME.moonriver]: 1285,
+  [SUPPORTED_TRANSFER_EVM_CHAIN_NAME.astarEvm]: 592,
+  [SUPPORTED_TRANSFER_EVM_CHAIN_NAME.shiden]: 336,
+  [SUPPORTED_TRANSFER_EVM_CHAIN_NAME.shibuya]: 81
+};
+exports.TRANSFER_CHAIN_ID = TRANSFER_CHAIN_ID;
+let SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME;
+exports.SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME = SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME;
+(function (SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME) {
+  SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME["statemine"] = "statemine";
+  SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME["acala"] = "acala";
+  SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME["karura"] = "karura";
+  SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME["kusama"] = "kusama";
+  SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME["uniqueNft"] = "unique_network";
+  SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME["quartz"] = "quartz";
+  SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME["opal"] = "opal";
+  SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME["statemint"] = "statemint";
+  SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME["bitcountry"] = "bitcountry";
+  SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME["pioneer"] = "pioneer";
+})(SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME || (exports.SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME = SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME = {}));
+const RANDOM_IPFS_GATEWAY_SETTING = [{
+  provider: IPFS_IO_GATEWAY,
+  weight: 0 // Not stable
+}, {
+  provider: NFT_STORAGE_GATEWAY,
+  weight: 50
+}, {
+  provider: CF_IPFS_GATEWAY,
+  weight: 4
+}, {
+  provider: CLOUDFLARE_PINATA_SERVER,
+  weight: 10
+}, {
+  provider: PINATA_IPFS_GATEWAY,
+  weight: 1 // Rate limit too low
+}, {
+  provider: GATEWAY_IPFS_IO,
+  weight: 5
+}, {
+  provider: DWEB_LINK,
+  weight: 5
+}, {
+  provider: IPFS_GATEWAY_CLOUD,
+  weight: 0 // Deceptive site warning
+}, {
+  provider: IPFS_FLEEK,
+  weight: 4
+}, {
+  provider: IPFS_TELOS_MIAMI,
+  weight: 0
+}];
+const RANDOM_IPFS_GATEWAY_TOTAL_WEIGHT = RANDOM_IPFS_GATEWAY_SETTING.reduce((value, item) => value + item.weight, 0);
+function getRandomIpfsGateway() {
+  const weighedItems = [];
+  let currentItem = 0;
+  while (currentItem < RANDOM_IPFS_GATEWAY_SETTING.length) {
+    for (let i = 0; i < RANDOM_IPFS_GATEWAY_SETTING[currentItem].weight; i++) {
+      weighedItems[weighedItems.length] = RANDOM_IPFS_GATEWAY_SETTING[currentItem].provider;
+    }
+    currentItem++;
+  }
+  return weighedItems[Math.floor(Math.random() * RANDOM_IPFS_GATEWAY_TOTAL_WEIGHT)];
+}

package/cjs/koni/api/nft/evm_nft/index.js

@@ -0,0 +1,169 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EvmNftApi = void 0;
+var _types = require("@subwallet/chain-list/types");
+var _config = require("@subwallet/extension-base/koni/api/nft/config");
+var _nft = require("@subwallet/extension-base/koni/api/nft/nft");
+var _helper = require("@subwallet/extension-base/services/chain-service/helper");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _crossFetch = _interopRequireDefault(require("cross-fetch"));
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class EvmNftApi extends _nft.BaseNftApi {
+  evmContracts = [];
+  constructor(evmApi, addresses, chain) {
+    super(chain, undefined, addresses);
+    this.evmApi = evmApi;
+    this.isEthereum = true;
+  }
+  setSmartContractNfts(evmContracts) {
+    this.evmContracts = evmContracts;
+  }
+  parseUrl(input) {
+    if (!input) {
+      return undefined;
+    }
+    if ((0, _utils2.isUrl)(input)) {
+      return input;
+    }
+    if (input.includes('ipfs://')) {
+      return (0, _config.getRandomIpfsGateway)() + input.split('ipfs://')[1];
+    }
+    return (0, _config.getRandomIpfsGateway)() + input.split('ipfs://ipfs/')[1];
+  }
+  parseMetadata(data) {
+    const traitList = data.traits ? data.traits : data.attributes;
+    const propertiesMap = {};
+    if (traitList) {
+      traitList.forEach(traitMap => {
+        propertiesMap[traitMap.trait_type] = {
+          value: traitMap.value
+          // rarity: traitMap.trait_count / itemTotal
+        };
+      });
+    }
+
+    // extra fields
+    if (data.dna) {
+      propertiesMap.dna = {
+        value: data.dna
+      };
+    }
+
+    // if (data.compiler) {
+    //   propertiesMap.compiler = {
+    //     value: data.compiler as string
+    //   };
+    // }
+
+    return {
+      name: data.name,
+      image: data.image_url ? this.parseUrl(data.image_url) : this.parseUrl(data.image),
+      description: data.description,
+      properties: propertiesMap,
+      externalUrl: data.external_url,
+      chain: this.chain
+    };
+  }
+  async getItemsByCollection(tokenInfo, collectionName, nftParams) {
+    if (!this.evmApi) {
+      return;
+    }
+    const smartContract = (0, _utils._getContractAddressOfToken)(tokenInfo);
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-assignment
+    const contract = new this.evmApi.api.eth.Contract(_helper._ERC721_ABI, smartContract);
+    let ownItem = false;
+    let collectionImage;
+    await Promise.all(this.addresses.map(async address => {
+      if (!(0, _utilCrypto.isEthereumAddress)(address)) {
+        return;
+      }
+      const nftIds = [];
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+      const balance = await contract.methods.balanceOf(address).call();
+      if (Number(balance) === 0) {
+        return;
+      }
+      const itemIndexes = [];
+      for (let i = 0; i < Number(balance); i++) {
+        itemIndexes.push(i);
+      }
+      try {
+        await Promise.all(itemIndexes.map(async i => {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+          const tokenId = await contract.methods.tokenOfOwnerByIndex(address, i).call();
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+          const tokenURI = await contract.methods.tokenURI(tokenId).call();
+          const detailUrl = this.parseUrl(tokenURI);
+          const nftId = tokenId.toString();
+          nftIds.push(nftId);
+          if (detailUrl) {
+            try {
+              const resp = await (0, _crossFetch.default)(detailUrl);
+              const itemDetail = resp && resp.ok && (await resp.json());
+              if (!itemDetail) {
+                console.warn((resp === null || resp === void 0 ? void 0 : resp.statusText) || `Cannot fetch NFT id [${nftId}] from Web3.`);
+                return;
+              }
+              const parsedItem = this.parseMetadata(itemDetail);
+              parsedItem.collectionId = smartContract;
+              parsedItem.id = nftId;
+              parsedItem.owner = address;
+              parsedItem.type = _types._AssetType.ERC721;
+              parsedItem.originAsset = tokenInfo.slug;
+              if (parsedItem) {
+                if (parsedItem.image) {
+                  collectionImage = parsedItem.image;
+                }
+                nftParams.updateItem(this.chain, parsedItem, address);
+                ownItem = true;
+              }
+            } catch (e) {
+              console.error(`error parsing item for ${this.chain} nft`, e);
+            }
+          }
+        }));
+      } catch (e) {
+        console.error('evm nft error', e);
+      }
+    }));
+    if (ownItem) {
+      const nftCollection = {
+        collectionId: smartContract,
+        collectionName,
+        image: collectionImage || undefined,
+        chain: this.chain,
+        originAsset: tokenInfo.slug
+      };
+      nftParams.updateCollection(this.chain, nftCollection);
+      // nftParams.updateReady(true);
+    }
+  }
+
+  async handleNfts(params) {
+    if (!this.evmContracts || this.evmContracts.length === 0) {
+      return;
+    }
+    await Promise.all(this.evmContracts.map(async tokenInfo => {
+      return await this.getItemsByCollection(tokenInfo, tokenInfo.name, params);
+    }));
+  }
+  async fetchNfts(params) {
+    try {
+      await this.handleNfts(params);
+    } catch (e) {
+      return 0;
+    }
+    return 1;
+  }
+}
+exports.EvmNftApi = EvmNftApi;

package/cjs/koni/api/nft/index.js

@@ -0,0 +1,150 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NftHandler = void 0;
+var _acala_nft = require("@subwallet/extension-base/koni/api/nft/acala_nft");
+var _bit = require("@subwallet/extension-base/koni/api/nft/bit.country");
+var _evm_nft = require("@subwallet/extension-base/koni/api/nft/evm_nft");
+var _karura_nft = require("@subwallet/extension-base/koni/api/nft/karura_nft");
+var _rmrk_nft = require("@subwallet/extension-base/koni/api/nft/rmrk_nft");
+var _statemine_nft = _interopRequireDefault(require("@subwallet/extension-base/koni/api/nft/statemine_nft"));
+var _unique_nft = _interopRequireDefault(require("@subwallet/extension-base/koni/api/nft/unique_nft"));
+var _wasm_nft = require("@subwallet/extension-base/koni/api/nft/wasm_nft");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/utils");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+function createSubstrateNftApi(chain, substrateApi, addresses) {
+  const [substrateAddresses] = (0, _utils2.categoryAddresses)(addresses);
+  if (_constants._NFT_CHAIN_GROUP.acala.includes(chain)) {
+    return new _acala_nft.AcalaNftApi(substrateApi, substrateAddresses, chain);
+  } else if (_constants._NFT_CHAIN_GROUP.karura.includes(chain)) {
+    return new _karura_nft.KaruraNftApi(substrateApi, substrateAddresses, chain);
+  } else if (_constants._NFT_CHAIN_GROUP.rmrk.includes(chain)) {
+    return new _rmrk_nft.RmrkNftApi(substrateAddresses, chain);
+  } else if (_constants._NFT_CHAIN_GROUP.statemine.includes(chain)) {
+    return new _statemine_nft.default(substrateApi, substrateAddresses, chain);
+  } else if (_constants._NFT_CHAIN_GROUP.unique_network.includes(chain)) {
+    return new _unique_nft.default(substrateApi, substrateAddresses, chain);
+  } else if (_constants._NFT_CHAIN_GROUP.bitcountry.includes(chain)) {
+    return new _bit.BitCountryNftApi(substrateApi, substrateAddresses, chain);
+  }
+  return null;
+}
+function createWasmNftApi(chain, apiProps, addresses) {
+  const [substrateAddresses] = (0, _utils2.categoryAddresses)(addresses);
+  return new _wasm_nft.WasmNftApi(apiProps, substrateAddresses, chain);
+}
+function createWeb3NftApi(chain, evmApi, addresses) {
+  const [, evmAddresses] = (0, _utils2.categoryAddresses)(addresses);
+  return new _evm_nft.EvmNftApi(evmApi, evmAddresses, chain);
+}
+class NftHandler {
+  // General settings
+  chainInfoMap = {};
+  addresses = [];
+  smartContractNfts = [];
+
+  // Provider API needed
+  substrateApiMap = {};
+  evmApiMap = {};
+
+  // Logic handling
+  handlers = []; // 1 chain can have multiple handlers (to support multiple token standards)
+  total = 0;
+  needSetupApi = true;
+  setChainInfoMap(chainInfoMap) {
+    this.chainInfoMap = chainInfoMap;
+    this.needSetupApi = true;
+  }
+  setWeb3ApiMap(web3ApiMap) {
+    this.evmApiMap = web3ApiMap;
+    this.needSetupApi = true;
+  }
+  setDotSamaApiMap(dotSamaAPIMap) {
+    this.substrateApiMap = dotSamaAPIMap;
+    this.needSetupApi = true;
+  }
+  setAddresses(addresses) {
+    this.addresses = addresses;
+    const [substrateAddresses, evmAddresses] = (0, _utils2.categoryAddresses)(addresses);
+    for (const handler of this.handlers) {
+      const useAddresses = handler.isEthereum ? evmAddresses : substrateAddresses;
+      handler.setAddresses(useAddresses);
+    }
+  }
+  setupNftContracts(smartContractNfts) {
+    this.smartContractNfts = smartContractNfts;
+    for (const handler of this.handlers) {
+      if (handler instanceof _evm_nft.EvmNftApi || handler instanceof _wasm_nft.WasmNftApi) {
+        const filteredNfts = [];
+        for (const nft of smartContractNfts) {
+          if (nft.originChain === handler.chain) {
+            filteredNfts.push(nft);
+          }
+        }
+        handler.setSmartContractNfts(filteredNfts);
+      }
+    }
+  }
+  setupApi() {
+    try {
+      if (this.needSetupApi) {
+        // setup connections for first time use
+        this.handlers = [];
+        const [substrateAddresses, evmAddresses] = (0, _utils2.categoryAddresses)(this.addresses);
+        Object.entries(this.chainInfoMap).forEach(_ref => {
+          let [chain, chainInfo] = _ref;
+          if ((0, _utils._isChainSupportNativeNft)(chainInfo)) {
+            if (this.substrateApiMap[chain]) {
+              const handler = createSubstrateNftApi(chain, this.substrateApiMap[chain], substrateAddresses);
+              if (handler) {
+                this.handlers.push(handler);
+              }
+            }
+          }
+          if ((0, _utils._isChainSupportEvmNft)(chainInfo)) {
+            if (this.evmApiMap[chain]) {
+              const handler = createWeb3NftApi(chain, this.evmApiMap[chain], evmAddresses);
+              if (handler) {
+                this.handlers.push(handler);
+              }
+            }
+          }
+          if ((0, _utils._isChainSupportWasmNft)(chainInfo)) {
+            if (this.substrateApiMap[chain]) {
+              const handler = createWasmNftApi(chain, this.substrateApiMap[chain], substrateAddresses);
+              if (handler && !this.handlers.includes(handler)) {
+                this.handlers.push(handler);
+              }
+            }
+          }
+        });
+        this.needSetupApi = false;
+        // console.log(`${this.handlers.length} nft handlers connected`, this.handlers);
+      }
+    } catch (e) {
+      console.error('error setting up nft handlers', e);
+    }
+  }
+  async handleNfts(nftContracts, updateItem, updateCollection) {
+    this.setupApi();
+    this.setupNftContracts(nftContracts);
+    await Promise.all(this.handlers.map(async handler => {
+      await handler.fetchNfts({
+        updateItem,
+        updateCollection
+      });
+    }));
+  }
+  parseAssetId(id) {
+    const numberId = parseInt(id);
+    return numberId.toString();
+  }
+}
+exports.NftHandler = NftHandler;