@subwallet/extension-base 0.8.1-wr → 0.8.1-wr2x

package/koni/api/nft/bit.country/index.d.ts

@@ -0,0 +1,12 @@
+import { BaseNftApi, HandleNftParams } from '@subwallet/extension-base/koni/api/nft/nft';
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+export declare class BitCountryNftApi extends BaseNftApi {
+    constructor(api: _SubstrateApi | null, addresses: string[], chain: string);
+    parseUrl(input: string): string | undefined;
+    private getNfts;
+    private getTokenDetails;
+    private getCollectionDetails;
+    fetchNfts(params: HandleNftParams): Promise<number>;
+    handleNft(address: string, params: HandleNftParams): Promise<void>;
+    handleNfts(params: HandleNftParams): Promise<void>;
+}

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

@@ -0,0 +1,124 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { BIT_COUNTRY_SERVER } from '@subwallet/extension-base/koni/api/nft/config';
+import { BaseNftApi } from '@subwallet/extension-base/koni/api/nft/nft';
+import { isUrl } from '@subwallet/extension-base/utils';
+import fetch from 'cross-fetch';
+export class BitCountryNftApi extends BaseNftApi {
+  constructor(api, addresses, chain) {
+    super(chain, api, addresses);
+  }
+  parseUrl(input) {
+    if (!input || input.length === 0) {
+      return undefined;
+    }
+    if (isUrl(input)) {
+      return input;
+    }
+    if (!input.includes('ipfs://')) {
+      return BIT_COUNTRY_SERVER + input;
+    }
+    return 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 fetch(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 fetch(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) {
+        // params.updateReady(true);
+        params.updateNftIds(this.chain, address);
+        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);
+      }));
+
+      params.updateCollectionIds(this.chain, address, Object.keys(collectionNftIds));
+      Object.entries(collectionNftIds).forEach(([collectionId, nftIds]) => params.updateNftIds(this.chain, address, collectionId, nftIds));
+    } 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)));
+  }
+}

package/koni/api/nft/config.d.ts

@@ -0,0 +1,57 @@
+export declare const SINGULAR_V1_ENDPOINT = "https://singular.rmrk-api.xyz/api/account-rmrk1/";
+export declare const SINGULAR_V2_ENDPOINT = "https://singular.rmrk-api.xyz/api/account/";
+export declare const KANARIA_ENDPOINT = "https://kanaria.rmrk.app/api/rmrk2/";
+export declare const RMRK_PINATA_SERVER = "https://rmrk.mypinata.cloud/ipfs/";
+export declare const SINGULAR_V1_COLLECTION_ENDPOINT = "https://singular.rmrk.app/api/rmrk1/collection/";
+export declare const SINGULAR_V2_COLLECTION_ENDPOINT = "https://singular.app/api/rmrk2/collection/";
+export declare const KANARIA_EXTERNAL_SERVER = "https://kanaria.rmrk.app/catalogue/";
+export declare const CLOUDFLARE_PINATA_SERVER = "https://cloudflare-ipfs.com/ipfs/";
+export declare const BIT_COUNTRY_SERVER = "https://ipfs-cdn.bit.country/";
+export declare const BIT_COUNTRY_THUMBNAIL_RESOLVER = "https://res.cloudinary.com/ddftctzph/image/upload/c_scale,q_100,w_250/production-ipfs/asset/";
+export declare const CF_IPFS_GATEWAY = "https://cf-ipfs.com/ipfs/";
+export declare const PINATA_IPFS_GATEWAY = "https://gateway.pinata.cloud/ipfs/";
+export declare const UNIQUE_SCAN_ENDPOINT = "https://explorer-api.unique.network/v1/graphql";
+export declare const QUARTZ_SCAN_ENDPOINT = "https://hasura-quartz.unique.network/v1/graphql";
+export declare const UNIQUE_IPFS_GATEWAY = "https://ipfs.unique.network/ipfs/";
+export declare const NFT_STORAGE_GATEWAY = "https://nftstorage.link/ipfs/";
+export declare const IPFS_IO_GATEWAY = "https://ipfs.io/ipfs/";
+export declare const GATEWAY_IPFS_IO = "https://gateway.ipfs.io/ipfs/";
+export declare const DWEB_LINK = "https://dweb.link/ipfs/";
+export declare const IPFS_GATEWAY_CLOUD = "https://ipfs-gateway.cloud/ipfs/";
+export declare const IPFS_FLEEK = "https://ipfs.fleek.co/ipfs/";
+export declare const IPFS_TELOS_MIAMI = "https://ipfs.telos.miami/ipfs";
+export declare enum SUPPORTED_NFT_NETWORKS {
+    karura = "karura",
+    acala = "acala",
+    kusama = "kusama",
+    statemine = "statemine",
+    unique_network = "unique_network",
+    quartz = "quartz",
+    bitcountry = "bitcountry",
+    pioneer = "pioneer"
+}
+export declare enum SUPPORTED_TRANSFER_EVM_CHAIN_NAME {
+    moonbeam = "moonbeam",
+    moonbase = "moonbase",
+    astarEvm = "astarEvm",
+    moonriver = "moonriver",
+    shiden = "shiden",
+    shibuya = "shibuya"
+}
+export declare const SUPPORTED_TRANSFER_EVM_CHAIN: string[];
+export declare const TRANSFER_CHAIN_ID: {
+    [x: string]: number;
+};
+export declare enum SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME {
+    statemine = "statemine",
+    acala = "acala",
+    karura = "karura",
+    kusama = "kusama",
+    uniqueNft = "unique_network",
+    quartz = "quartz",
+    opal = "opal",
+    statemint = "statemint",
+    bitcountry = "bitcountry",
+    pioneer = "pioneer"
+}
+export declare function getRandomIpfsGateway(): string;

package/koni/api/nft/config.js

@@ -0,0 +1,110 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export const SINGULAR_V1_ENDPOINT = 'https://singular.rmrk-api.xyz/api/account-rmrk1/';
+export const SINGULAR_V2_ENDPOINT = 'https://singular.rmrk-api.xyz/api/account/';
+export const KANARIA_ENDPOINT = 'https://kanaria.rmrk.app/api/rmrk2/';
+export const RMRK_PINATA_SERVER = 'https://rmrk.mypinata.cloud/ipfs/';
+export const SINGULAR_V1_COLLECTION_ENDPOINT = 'https://singular.rmrk.app/api/rmrk1/collection/';
+export const SINGULAR_V2_COLLECTION_ENDPOINT = 'https://singular.app/api/rmrk2/collection/';
+export const KANARIA_EXTERNAL_SERVER = 'https://kanaria.rmrk.app/catalogue/';
+export const CLOUDFLARE_PINATA_SERVER = 'https://cloudflare-ipfs.com/ipfs/';
+export const BIT_COUNTRY_SERVER = 'https://ipfs-cdn.bit.country/';
+export const BIT_COUNTRY_THUMBNAIL_RESOLVER = 'https://res.cloudinary.com/ddftctzph/image/upload/c_scale,q_100,w_250/production-ipfs/asset/';
+export const CF_IPFS_GATEWAY = 'https://cf-ipfs.com/ipfs/';
+export const PINATA_IPFS_GATEWAY = 'https://gateway.pinata.cloud/ipfs/';
+export const UNIQUE_SCAN_ENDPOINT = 'https://explorer-api.unique.network/v1/graphql';
+export const QUARTZ_SCAN_ENDPOINT = 'https://hasura-quartz.unique.network/v1/graphql';
+export const UNIQUE_IPFS_GATEWAY = 'https://ipfs.unique.network/ipfs/';
+export const NFT_STORAGE_GATEWAY = 'https://nftstorage.link/ipfs/';
+export const IPFS_IO_GATEWAY = 'https://ipfs.io/ipfs/';
+export const GATEWAY_IPFS_IO = 'https://gateway.ipfs.io/ipfs/';
+export const DWEB_LINK = 'https://dweb.link/ipfs/';
+export const IPFS_GATEWAY_CLOUD = 'https://ipfs-gateway.cloud/ipfs/';
+export const IPFS_FLEEK = 'https://ipfs.fleek.co/ipfs/';
+export const IPFS_TELOS_MIAMI = 'https://ipfs.telos.miami/ipfs';
+export let 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 || (SUPPORTED_NFT_NETWORKS = {}));
+export let 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 || (SUPPORTED_TRANSFER_EVM_CHAIN_NAME = {}));
+export 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];
+export 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
+};
+export let 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 || (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);
+export 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/koni/api/nft/evm_nft/index.d.ts

@@ -0,0 +1,13 @@
+import { _ChainAsset } from '@subwallet/chain-list/types';
+import { BaseNftApi, HandleNftParams } from '@subwallet/extension-base/koni/api/nft/nft';
+import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
+export declare class EvmNftApi extends BaseNftApi {
+    evmContracts: _ChainAsset[];
+    constructor(evmApi: _EvmApi | null, addresses: string[], chain: string);
+    setSmartContractNfts(evmContracts: _ChainAsset[]): void;
+    parseUrl(input: string): string | undefined;
+    private parseMetadata;
+    private getItemsByCollection;
+    handleNfts(params: HandleNftParams): Promise<void>;
+    fetchNfts(params: HandleNftParams): Promise<number>;
+}

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

@@ -0,0 +1,164 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { _AssetType } from '@subwallet/chain-list/types';
+import { getRandomIpfsGateway } from '@subwallet/extension-base/koni/api/nft/config';
+import { BaseNftApi } from '@subwallet/extension-base/koni/api/nft/nft';
+import { _ERC721_ABI } from '@subwallet/extension-base/services/chain-service/helper';
+import { _getContractAddressOfToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { isUrl } from '@subwallet/extension-base/utils';
+import fetch from 'cross-fetch';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+export class EvmNftApi extends 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 (isUrl(input)) {
+      return input;
+    }
+    if (input.includes('ipfs://')) {
+      return getRandomIpfsGateway() + input.split('ipfs://')[1];
+    }
+    return 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 = _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(_ERC721_ABI, smartContract);
+    let ownItem = false;
+    let collectionImage;
+    await Promise.all(this.addresses.map(async address => {
+      if (!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) {
+        // nftParams.updateReady(true);
+        nftParams.updateNftIds(this.chain, address, smartContract, nftIds);
+        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 fetch(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 = _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);
+      }
+      nftParams.updateNftIds(this.chain, address, smartContract, nftIds);
+    }));
+    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;
+  }
+}

package/koni/api/nft/index.d.ts

@@ -0,0 +1,22 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { NftCollection, NftItem } from '@subwallet/extension-base/background/KoniTypes';
+import { BaseNftApi } from '@subwallet/extension-base/koni/api/nft/nft';
+import { _EvmApi, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+export declare class NftHandler {
+    chainInfoMap: Record<string, _ChainInfo>;
+    addresses: string[];
+    smartContractNfts: _ChainAsset[];
+    substrateApiMap: Record<string, _SubstrateApi>;
+    evmApiMap: Record<string, _EvmApi>;
+    handlers: BaseNftApi[];
+    total: number;
+    needSetupApi: boolean;
+    setChainInfoMap(chainInfoMap: Record<string, _ChainInfo>): void;
+    setWeb3ApiMap(web3ApiMap: Record<string, _EvmApi>): void;
+    setDotSamaApiMap(dotSamaAPIMap: Record<string, _SubstrateApi>): void;
+    setAddresses(addresses: string[]): void;
+    private setupNftContracts;
+    private setupApi;
+    handleNfts(nftContracts: _ChainAsset[], updateItem: (chain: string, data: NftItem, owner: string) => void, updateCollection: (chain: string, data: NftCollection) => void, updateIds: (chain: string, owner: string, collectionId?: string, nftIds?: string[]) => void, updateCollectionIds: (chain: string, address: string, collectionIds?: string[]) => void): Promise<void>;
+    parseAssetId(id: string): string;
+}

package/koni/api/nft/index.js

@@ -0,0 +1,143 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { AcalaNftApi } from '@subwallet/extension-base/koni/api/nft/acala_nft';
+import { BitCountryNftApi } from '@subwallet/extension-base/koni/api/nft/bit.country';
+import { EvmNftApi } from '@subwallet/extension-base/koni/api/nft/evm_nft';
+import { KaruraNftApi } from '@subwallet/extension-base/koni/api/nft/karura_nft';
+import { RmrkNftApi } from '@subwallet/extension-base/koni/api/nft/rmrk_nft';
+import StatemineNftApi from '@subwallet/extension-base/koni/api/nft/statemine_nft';
+import UniqueNftApi from '@subwallet/extension-base/koni/api/nft/unique_nft';
+import { WasmNftApi } from '@subwallet/extension-base/koni/api/nft/wasm_nft';
+import { _NFT_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
+import { _isChainSupportEvmNft, _isChainSupportNativeNft, _isChainSupportWasmNft } from '@subwallet/extension-base/services/chain-service/utils';
+import { categoryAddresses } from '@subwallet/extension-base/utils';
+function createSubstrateNftApi(chain, substrateApi, addresses) {
+  const [substrateAddresses] = categoryAddresses(addresses);
+  if (_NFT_CHAIN_GROUP.acala.includes(chain)) {
+    return new AcalaNftApi(substrateApi, substrateAddresses, chain);
+  } else if (_NFT_CHAIN_GROUP.karura.includes(chain)) {
+    return new KaruraNftApi(substrateApi, substrateAddresses, chain);
+  } else if (_NFT_CHAIN_GROUP.rmrk.includes(chain)) {
+    return new RmrkNftApi(substrateAddresses, chain);
+  } else if (_NFT_CHAIN_GROUP.statemine.includes(chain)) {
+    return new StatemineNftApi(substrateApi, substrateAddresses, chain);
+  } else if (_NFT_CHAIN_GROUP.unique_network.includes(chain)) {
+    return new UniqueNftApi(substrateApi, substrateAddresses, chain);
+  } else if (_NFT_CHAIN_GROUP.bitcountry.includes(chain)) {
+    return new BitCountryNftApi(substrateApi, substrateAddresses, chain);
+  }
+  return null;
+}
+function createWasmNftApi(chain, apiProps, addresses) {
+  const [substrateAddresses] = categoryAddresses(addresses);
+  return new WasmNftApi(apiProps, substrateAddresses, chain);
+}
+function createWeb3NftApi(chain, evmApi, addresses) {
+  const [, evmAddresses] = categoryAddresses(addresses);
+  return new EvmNftApi(evmApi, evmAddresses, chain);
+}
+export 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] = 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 EvmNftApi || handler instanceof 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] = categoryAddresses(this.addresses);
+        Object.entries(this.chainInfoMap).forEach(([chain, chainInfo]) => {
+          if (_isChainSupportNativeNft(chainInfo)) {
+            if (this.substrateApiMap[chain]) {
+              const handler = createSubstrateNftApi(chain, this.substrateApiMap[chain], substrateAddresses);
+              if (handler) {
+                this.handlers.push(handler);
+              }
+            }
+          }
+          if (_isChainSupportEvmNft(chainInfo)) {
+            if (this.evmApiMap[chain]) {
+              const handler = createWeb3NftApi(chain, this.evmApiMap[chain], evmAddresses);
+              if (handler) {
+                this.handlers.push(handler);
+              }
+            }
+          }
+          if (_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, updateIds, updateCollectionIds) {
+    this.setupApi();
+    this.setupNftContracts(nftContracts);
+    await Promise.all(this.handlers.map(async handler => {
+      await handler.fetchNfts({
+        updateItem,
+        updateCollection,
+        updateNftIds: updateIds,
+        updateCollectionIds
+      });
+    }));
+  }
+  parseAssetId(id) {
+    const numberId = parseInt(id);
+    return numberId.toString();
+  }
+}

package/koni/api/nft/karura_nft/index.d.ts

@@ -0,0 +1,18 @@
+import { BaseNftApi, HandleNftParams } from '@subwallet/extension-base/koni/api/nft/nft';
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+export declare class KaruraNftApi extends BaseNftApi {
+    constructor(api: _SubstrateApi | null, addresses: string[], chain: string);
+    parseUrl(input: string): string | undefined;
+    /**
+     * Retrieve id of NFTs
+     *
+     * @returns the array of NFT Ids
+     * @param addresses
+     */
+    private getNfts;
+    private getCollectionDetails;
+    private getTokenDetails;
+    handleNft(address: string, params: HandleNftParams): Promise<void>;
+    handleNfts(params: HandleNftParams): Promise<void>;
+    fetchNfts(params: HandleNftParams): Promise<number>;
+}