@subwallet/extension-base 1.1.34-0 → 1.1.35-beta.0

package/cjs/koni/api/dotsama/balance.js

@@ -0,0 +1,464 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.subscribeBalance = subscribeBalance;
+exports.subscribeEVMBalance = subscribeEVMBalance;
+exports.subscribeSubstrateBalance = subscribeSubstrateBalance;
+var _types = require("@subwallet/chain-list/types");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/constants");
+var _balance = require("@subwallet/extension-base/koni/api/tokens/evm/balance");
+var _web = require("@subwallet/extension-base/koni/api/tokens/evm/web3");
+var _wasm = require("@subwallet/extension-base/koni/api/tokens/wasm");
+var _utils = require("@subwallet/extension-base/koni/api/tokens/wasm/utils");
+var _handlers = require("@subwallet/extension-base/koni/background/handlers");
+var _constants2 = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils3 = require("@subwallet/extension-base/utils");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+// main subscription
+function subscribeBalance(addresses, chainInfoMap, substrateApiMap, evmApiMap, callback) {
+  const [substrateAddresses, evmAddresses] = (0, _utils3.categoryAddresses)(addresses);
+
+  // Looping over each chain
+  const unsubList = Object.entries(chainInfoMap).map(async _ref => {
+    let [chainSlug, chainInfo] = _ref;
+    const useAddresses = (0, _utils2._isChainEvmCompatible)(chainInfo) ? evmAddresses : substrateAddresses;
+    if ((0, _utils2._isPureEvmChain)(chainInfo)) {
+      const nativeTokenInfo = _handlers.state.getNativeTokenInfo(chainSlug);
+      return subscribeEVMBalance(chainSlug, useAddresses, evmApiMap, callback, nativeTokenInfo);
+    }
+    if (!useAddresses || useAddresses.length === 0 || _constants2._PURE_EVM_CHAINS.indexOf(chainSlug) > -1) {
+      const fungibleTokensByChain = _handlers.state.chainService.getFungibleTokensByChain(chainSlug, true);
+      const now = new Date().getTime();
+      Object.values(fungibleTokensByChain).map(token => {
+        return {
+          tokenSlug: token.slug,
+          free: '0',
+          locked: '0',
+          state: _KoniTypes.APIItemState.READY,
+          timestamp: now
+        };
+      }).forEach(callback);
+      return undefined;
+    }
+    const networkAPI = await substrateApiMap[chainSlug].isReady;
+    return subscribeSubstrateBalance(useAddresses, chainInfo, chainSlug, networkAPI, evmApiMap, callback);
+  });
+  return () => {
+    unsubList.forEach(subProm => {
+      subProm.then(unsub => {
+        unsub && unsub();
+      }).catch(console.error);
+    });
+  };
+}
+async function subscribeSubstrateBalance(addresses, chainInfo, chain, networkAPI, evmApiMap, callBack) {
+  let unsubNativeToken;
+  if (!_constants2._BALANCE_CHAIN_GROUP.kintsugi.includes(chain) && !_constants2._BALANCE_CHAIN_GROUP.genshiro.includes(chain) && !_constants2._BALANCE_CHAIN_GROUP.equilibrium_parachain.includes(chain)) {
+    unsubNativeToken = await subscribeWithSystemAccountPallet(addresses, chainInfo, networkAPI.api, callBack);
+  }
+  let unsubLocalToken;
+  let unsubEvmContractToken;
+  let unsubWasmContractToken;
+  try {
+    if (_constants2._BALANCE_CHAIN_GROUP.bifrost.includes(chain)) {
+      unsubLocalToken = await subscribeTokensAccountsPallet(addresses, chain, networkAPI.api, callBack);
+    } else if (_constants2._BALANCE_CHAIN_GROUP.kintsugi.includes(chain)) {
+      unsubLocalToken = await subscribeTokensAccountsPallet(addresses, chain, networkAPI.api, callBack, true);
+    } else if (_constants2._BALANCE_CHAIN_GROUP.statemine.includes(chain)) {
+      unsubLocalToken = await subscribeAssetsAccountPallet(addresses, chain, networkAPI.api, callBack);
+    } else if (_constants2._BALANCE_CHAIN_GROUP.genshiro.includes(chain)) {
+      unsubLocalToken = await subscribeEqBalanceAccountPallet(addresses, chain, networkAPI.api, callBack, true);
+    } else if (_constants2._BALANCE_CHAIN_GROUP.equilibrium_parachain.includes(chain)) {
+      unsubLocalToken = await subscribeEquilibriumTokenBalance(addresses, chain, networkAPI.api, callBack, true);
+    } else if (_constants2._BALANCE_CHAIN_GROUP.centrifuge.includes(chain)) {
+      unsubLocalToken = await subscribeOrmlTokensPallet(addresses, chain, networkAPI.api, callBack);
+    }
+    if ((0, _utils2._isChainEvmCompatible)(chainInfo)) {
+      unsubEvmContractToken = subscribeERC20Interval(addresses, chain, evmApiMap, callBack);
+    }
+    if ((0, _utils2._checkSmartContractSupportByChain)(chainInfo, _types._AssetType.PSP22)) {
+      // Get sub-token for substrate-based chains
+      unsubWasmContractToken = subscribePSP22Balance(addresses, chain, networkAPI.api, callBack);
+    }
+  } catch (err) {
+    console.warn(err);
+  }
+  return () => {
+    unsubNativeToken && unsubNativeToken();
+    unsubLocalToken && unsubLocalToken();
+    unsubEvmContractToken && unsubEvmContractToken();
+    unsubWasmContractToken && unsubWasmContractToken();
+  };
+}
+
+// handler according to different logic
+async function subscribeWithSystemAccountPallet(addresses, chainInfo, networkAPI, callBack) {
+  const chainNativeTokenSlug = (0, _utils2._getChainNativeTokenSlug)(chainInfo);
+  const unsub = await networkAPI.query.system.account.multi(addresses, async balances => {
+    let [total, reserved, miscFrozen, feeFrozen] = [new _util.BN(0), new _util.BN(0), new _util.BN(0), new _util.BN(0)];
+    let pooledStakingBalance = _util.BN_ZERO;
+    if ((0, _utils2._isSubstrateRelayChain)(chainInfo) && networkAPI.query.nominationPools) {
+      var _networkAPI$query$nom;
+      const poolMemberDatas = await ((_networkAPI$query$nom = networkAPI.query.nominationPools.poolMembers) === null || _networkAPI$query$nom === void 0 ? void 0 : _networkAPI$query$nom.multi(addresses));
+      if (poolMemberDatas) {
+        for (const _poolMemberData of poolMemberDatas) {
+          const poolMemberData = _poolMemberData.toPrimitive();
+          if (poolMemberData) {
+            const pooledBalance = new _util.BN(poolMemberData.points.toString());
+            pooledStakingBalance = pooledStakingBalance.add(pooledBalance);
+            Object.entries(poolMemberData.unbondingEras).forEach(_ref2 => {
+              let [, amount] = _ref2;
+              pooledStakingBalance = pooledStakingBalance.add(new _util.BN(amount));
+            });
+          }
+        }
+      }
+    }
+    balances.forEach(balance => {
+      var _balance$data, _balance$data$free, _balance$data2, _balance$data2$reserv, _balance$data3, _balance$data3$miscFr, _balance$data4, _balance$data4$frozen, _balance$data5, _balance$data5$feeFro;
+      total = total.add(((_balance$data = balance.data) === null || _balance$data === void 0 ? void 0 : (_balance$data$free = _balance$data.free) === null || _balance$data$free === void 0 ? void 0 : _balance$data$free.toBn()) || new _util.BN(0)); // reserved is seperated
+      reserved = reserved.add(((_balance$data2 = balance.data) === null || _balance$data2 === void 0 ? void 0 : (_balance$data2$reserv = _balance$data2.reserved) === null || _balance$data2$reserv === void 0 ? void 0 : _balance$data2$reserv.toBn()) || new _util.BN(0));
+      // @ts-ignore
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+      miscFrozen = miscFrozen.add(((_balance$data3 = balance.data) === null || _balance$data3 === void 0 ? void 0 : (_balance$data3$miscFr = _balance$data3.miscFrozen) === null || _balance$data3$miscFr === void 0 ? void 0 : _balance$data3$miscFr.toBn()) || (balance === null || balance === void 0 ? void 0 : (_balance$data4 = balance.data) === null || _balance$data4 === void 0 ? void 0 : (_balance$data4$frozen = _balance$data4.frozen) === null || _balance$data4$frozen === void 0 ? void 0 : _balance$data4$frozen.toBn()) || new _util.BN(0)); // TODO: update frozen
+      feeFrozen = feeFrozen.add(((_balance$data5 = balance.data) === null || _balance$data5 === void 0 ? void 0 : (_balance$data5$feeFro = _balance$data5.feeFrozen) === null || _balance$data5$feeFro === void 0 ? void 0 : _balance$data5$feeFro.toBn()) || new _util.BN(0));
+    });
+    let locked = reserved.add(miscFrozen);
+    total = total.add(reserved); // total = free + reserved
+
+    if (pooledStakingBalance.gt(_util.BN_ZERO)) {
+      total = total.add(pooledStakingBalance);
+      locked = locked.add(pooledStakingBalance);
+    }
+    const free = total.sub(locked);
+    callBack({
+      tokenSlug: chainNativeTokenSlug,
+      free: free.gte(_util.BN_ZERO) ? free.toString() : '0',
+      locked: locked.toString(),
+      state: _KoniTypes.APIItemState.READY,
+      substrateInfo: {
+        miscFrozen: miscFrozen.toString(),
+        reserved: reserved.toString(),
+        feeFrozen: feeFrozen.toString()
+      }
+    });
+  });
+  return () => {
+    unsub();
+  };
+}
+function subscribeERC20Interval(addresses, chain, evmApiMap, callBack) {
+  let tokenList = {};
+  const erc20ContractMap = {};
+  const getTokenBalances = () => {
+    Object.values(tokenList).map(async tokenInfo => {
+      let free = new _util.BN(0);
+      try {
+        const contract = erc20ContractMap[tokenInfo.slug];
+        const balanceList = await Promise.all(addresses.map(address => {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+          return contract.methods.balanceOf(address).call();
+        }));
+        free = (0, _utils3.sumBN)(balanceList.map(balance => new _util.BN(balance || 0)));
+        callBack({
+          tokenSlug: tokenInfo.slug,
+          free: free.toString(),
+          locked: '0',
+          state: _KoniTypes.APIItemState.READY
+        });
+      } catch (err) {
+        console.log(tokenInfo.slug, err);
+      }
+    });
+  };
+  tokenList = _handlers.state.getAssetByChainAndAsset(chain, [_types._AssetType.ERC20]);
+  Object.entries(tokenList).forEach(_ref3 => {
+    let [slug, tokenInfo] = _ref3;
+    erc20ContractMap[slug] = (0, _web.getERC20Contract)(chain, (0, _utils2._getContractAddressOfToken)(tokenInfo), evmApiMap);
+  });
+  getTokenBalances();
+  const interval = setInterval(getTokenBalances, _constants.SUB_TOKEN_REFRESH_BALANCE_INTERVAL);
+  return () => {
+    clearInterval(interval);
+  };
+}
+function subscribePSP22Balance(addresses, chain, api, callBack) {
+  let tokenList = {};
+  const psp22ContractMap = {};
+  const getTokenBalances = () => {
+    Object.values(tokenList).map(async tokenInfo => {
+      let free = new _util.BN(0);
+      try {
+        const contract = psp22ContractMap[tokenInfo.slug];
+        const balances = await Promise.all(addresses.map(async address => {
+          var _balanceOf$output;
+          const _balanceOf = await contract.query['psp22::balanceOf'](address, {
+            gasLimit: (0, _utils.getDefaultWeightV2)(api)
+          }, address);
+          const balanceObj = _balanceOf === null || _balanceOf === void 0 ? void 0 : (_balanceOf$output = _balanceOf.output) === null || _balanceOf$output === void 0 ? void 0 : _balanceOf$output.toPrimitive();
+          return _balanceOf.output ? balanceObj.ok || balanceObj.Ok : '0';
+        }));
+        free = (0, _utils3.sumBN)(balances.map(bal => new _util.BN(bal || 0)));
+        callBack({
+          tokenSlug: tokenInfo.slug,
+          free: free.toString(),
+          locked: '0',
+          state: _KoniTypes.APIItemState.READY
+        });
+      } catch (err) {
+        console.warn(tokenInfo.slug, err); // TODO: error createType
+      }
+    });
+  };
+
+  tokenList = _handlers.state.getAssetByChainAndAsset(chain, [_types._AssetType.PSP22]);
+  Object.entries(tokenList).forEach(_ref4 => {
+    let [slug, tokenInfo] = _ref4;
+    psp22ContractMap[slug] = (0, _wasm.getPSP22ContractPromise)(api, (0, _utils2._getContractAddressOfToken)(tokenInfo));
+  });
+  getTokenBalances();
+  const interval = setInterval(getTokenBalances, _constants.SUB_TOKEN_REFRESH_BALANCE_INTERVAL);
+  return () => {
+    clearInterval(interval);
+  };
+}
+async function subscribeEquilibriumTokenBalance(addresses, chain, api, callBack, includeNativeToken) {
+  const tokenTypes = includeNativeToken ? [_types._AssetType.NATIVE, _types._AssetType.LOCAL] : [_types._AssetType.LOCAL];
+  const tokenMap = _handlers.state.getAssetByChainAndAsset(chain, tokenTypes);
+  const unsub = await api.query.system.account.multi(addresses, balances => {
+    // Equilibrium customizes the SystemAccount pallet
+    Object.values(tokenMap).forEach(tokenInfo => {
+      const assetId = (0, _utils2._getTokenOnChainAssetId)(tokenInfo);
+      let tokenFreeBalance = _util.BN_ZERO;
+      for (const balance of balances) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+        const balancesData = JSON.parse(balance.data.toString());
+        const balanceList = balancesData.v0.balance;
+
+        // @ts-ignore
+        const freeTokenBalance = balanceList.find(data => data[0] === parseInt(assetId));
+        const bnFreeTokenBalance = freeTokenBalance ? new _util.BN(new _bignumber.default(freeTokenBalance[1].positive).toString()) : _util.BN_ZERO;
+        tokenFreeBalance = tokenFreeBalance.add(bnFreeTokenBalance);
+      }
+      const tokenBalance = {
+        free: tokenFreeBalance.toString(),
+        locked: '0',
+        // Equilibrium doesn't show locked balance
+        state: _KoniTypes.APIItemState.READY,
+        tokenSlug: tokenInfo.slug
+      };
+      callBack(tokenBalance);
+    });
+  });
+  return () => {
+    unsub();
+  };
+}
+
+// eslint-disable-next-line @typescript-eslint/require-await
+async function subscribeEqBalanceAccountPallet(addresses, chain, api, callBack, includeNativeToken) {
+  const tokenTypes = includeNativeToken ? [_types._AssetType.NATIVE, _types._AssetType.LOCAL] : [_types._AssetType.LOCAL];
+  const tokenMap = _handlers.state.getAssetByChainAndAsset(chain, tokenTypes);
+  const unsubList = Object.values(tokenMap).map(async tokenInfo => {
+    try {
+      const assetId = (0, _utils2._getTokenOnChainAssetId)(tokenInfo);
+      const unsub = await api.query.eqBalances.account.multi(addresses.map(address => [address, [assetId]]), balances => {
+        const tokenBalance = {
+          free: (0, _utils3.sumBN)(balances.map(b => b.asPositive)).toString(),
+          locked: '0',
+          // Equilibrium doesn't show locked balance
+          state: _KoniTypes.APIItemState.READY,
+          tokenSlug: tokenInfo.slug
+        };
+        callBack(tokenBalance);
+      });
+      return unsub;
+    } catch (err) {
+      console.warn(err);
+      return undefined;
+    }
+  });
+  return () => {
+    unsubList.forEach(subProm => {
+      subProm.then(unsub => {
+        unsub && unsub();
+      }).catch(console.error);
+    });
+  };
+}
+
+// eslint-disable-next-line @typescript-eslint/require-await
+async function subscribeOrmlTokensPallet(addresses, chain, api, callBack) {
+  const tokenTypes = [_types._AssetType.LOCAL];
+  const tokenMap = _handlers.state.getAssetByChainAndAsset(chain, tokenTypes);
+  const unsubList = Object.values(tokenMap).map(async tokenInfo => {
+    try {
+      const onChainInfo = (0, _utils2._getTokenOnChainInfo)(tokenInfo);
+
+      // Get Token Balance
+      // @ts-ignore
+      const unsub = await api.query.ormlTokens.accounts.multi(addresses.map(address => [address, onChainInfo]), balances => {
+        const tokenBalance = {
+          reserved: (0, _utils3.sumBN)(balances.map(b => b.reserved || new _util.BN(0))),
+          frozen: (0, _utils3.sumBN)(balances.map(b => b.frozen || new _util.BN(0))),
+          free: (0, _utils3.sumBN)(balances.map(b => b.free || new _util.BN(0))) // free is actually total balance
+        };
+
+        // free balance = total balance - frozen misc
+        // locked balance = reserved + frozen misc
+        const freeBalance = tokenBalance.free.sub(tokenBalance.frozen);
+        const lockedBalance = tokenBalance.frozen.add(tokenBalance.reserved);
+        callBack({
+          tokenSlug: tokenInfo.slug,
+          state: _KoniTypes.APIItemState.READY,
+          free: freeBalance.toString(),
+          locked: lockedBalance.toString(),
+          substrateInfo: {
+            reserved: tokenBalance.reserved.toString(),
+            miscFrozen: tokenBalance.frozen.toString()
+          }
+        });
+      });
+      return unsub;
+    } catch (err) {
+      console.warn(err);
+      return undefined;
+    }
+  });
+  return () => {
+    unsubList.forEach(subProm => {
+      subProm.then(unsub => {
+        unsub && unsub();
+      }).catch(console.error);
+    });
+  };
+}
+async function subscribeTokensAccountsPallet(addresses, chain, api, callBack, includeNativeToken) {
+  const tokenTypes = includeNativeToken ? [_types._AssetType.NATIVE, _types._AssetType.LOCAL] : [_types._AssetType.LOCAL];
+  const tokenMap = _handlers.state.getAssetByChainAndAsset(chain, tokenTypes);
+  const unsubList = await Promise.all(Object.values(tokenMap).map(async tokenInfo => {
+    try {
+      const onChainInfo = (0, _utils2._getTokenOnChainInfo)(tokenInfo);
+      const assetId = (0, _utils2._getTokenOnChainAssetId)(tokenInfo);
+
+      // Get Token Balance
+      // @ts-ignore
+      return await api.query.tokens.accounts.multi(addresses.map(address => [address, onChainInfo || assetId]), balances => {
+        const tokenBalance = {
+          reserved: (0, _utils3.sumBN)(balances.map(b => b.reserved || new _util.BN(0))),
+          frozen: (0, _utils3.sumBN)(balances.map(b => b.frozen || new _util.BN(0))),
+          free: (0, _utils3.sumBN)(balances.map(b => b.free || new _util.BN(0))) // free is actually total balance
+        };
+
+        // free balance = total balance - frozen misc
+        // locked balance = reserved + frozen misc
+        const freeBalance = tokenBalance.free.sub(tokenBalance.frozen);
+        const lockedBalance = tokenBalance.frozen.add(tokenBalance.reserved);
+        callBack({
+          tokenSlug: tokenInfo.slug,
+          state: _KoniTypes.APIItemState.READY,
+          free: freeBalance.toString(),
+          locked: lockedBalance.toString(),
+          substrateInfo: {
+            reserved: tokenBalance.reserved.toString(),
+            miscFrozen: tokenBalance.frozen.toString()
+          }
+        });
+      });
+    } catch (err) {
+      console.warn(err);
+    }
+    return undefined;
+  }));
+  return () => {
+    unsubList.forEach(unsub => {
+      unsub && unsub();
+    });
+  };
+}
+async function subscribeAssetsAccountPallet(addresses, chain, api, callBack) {
+  const tokenMap = _handlers.state.getAssetByChainAndAsset(chain, [_types._AssetType.LOCAL]);
+  Object.values(tokenMap).forEach(token => {
+    if (_constants2._MANTA_ZK_CHAIN_GROUP.includes(token.originChain) && token.symbol.startsWith(_constants2._ZK_ASSET_PREFIX)) {
+      delete tokenMap[token.slug];
+    }
+  });
+  const unsubList = await Promise.all(Object.values(tokenMap).map(async tokenInfo => {
+    try {
+      const assetIndex = (0, _utils2._getTokenOnChainAssetId)(tokenInfo);
+
+      // Get Token Balance
+      return await api.query.assets.account.multi(addresses.map(address => [assetIndex, address]), balances => {
+        let total = new _util.BN(0);
+        let frozen = new _util.BN(0);
+        balances.forEach(b => {
+          // @ts-ignore
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-assignment
+          const bdata = b === null || b === void 0 ? void 0 : b.toHuman();
+          if (bdata) {
+            // @ts-ignore
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument
+            const addressBalance = new _util.BN(String(bdata === null || bdata === void 0 ? void 0 : bdata.balance).replaceAll(',', '') || '0');
+
+            // @ts-ignore
+            if (bdata !== null && bdata !== void 0 && bdata.isFrozen) {
+              frozen = frozen.add(addressBalance);
+            } else {
+              total = total.add(addressBalance);
+            }
+          }
+        });
+        const free = total.sub(frozen);
+        callBack({
+          tokenSlug: tokenInfo.slug,
+          free: free.toString(),
+          locked: frozen.toString(),
+          state: _KoniTypes.APIItemState.READY,
+          substrateInfo: {
+            miscFrozen: frozen.toString(),
+            reserved: '0'
+          }
+        });
+      });
+    } catch (err) {
+      console.warn(err);
+    }
+    return undefined;
+  }));
+  return () => {
+    unsubList.forEach(unsub => {
+      unsub && unsub();
+    });
+  };
+}
+function subscribeEVMBalance(chain, addresses, evmApiMap, callback, tokenInfo) {
+  const balanceItem = {
+    tokenSlug: tokenInfo.slug,
+    state: _KoniTypes.APIItemState.PENDING,
+    free: '0',
+    locked: '0'
+  };
+  function getBalance() {
+    (0, _balance.getEVMBalance)(chain, addresses, evmApiMap).then(balances => {
+      balanceItem.free = (0, _utils3.sumBN)(balances.map(b => new _util.BN(b || '0'))).toString();
+      balanceItem.state = _KoniTypes.APIItemState.READY;
+      callback(balanceItem);
+    }).catch(console.warn);
+  }
+  getBalance();
+  const interval = setInterval(getBalance, _constants.ASTAR_REFRESH_BALANCE_INTERVAL);
+  const unsub2 = subscribeERC20Interval(addresses, chain, evmApiMap, callback);
+  return () => {
+    clearInterval(interval);
+    unsub2 && unsub2();
+  };
+}

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

@@ -33,8 +33,12 @@ exports.BIT_COUNTRY_IPFS_SERVER = BIT_COUNTRY_IPFS_SERVER;
 const BIT_COUNTRY_LAND_ESTATE_METADATA_API = 'https://pioneer-api.bit.country/metadata/landTokenUriPioneer';
 exports.BIT_COUNTRY_LAND_ESTATE_METADATA_API = BIT_COUNTRY_LAND_ESTATE_METADATA_API;
 const BIT_COUNTRY_THUMBNAIL_RESOLVER = 'https://res.cloudinary.com/ddftctzph/image/upload/c_scale,q_100,w_250/production-ipfs/asset/';
+
+// XOrigin
 exports.BIT_COUNTRY_THUMBNAIL_RESOLVER = BIT_COUNTRY_THUMBNAIL_RESOLVER;
 const CF_IPFS_GATEWAY = 'https://cf-ipfs.com/ipfs/';
+
+// XOrigin
 exports.CF_IPFS_GATEWAY = CF_IPFS_GATEWAY;
 const PINATA_IPFS_GATEWAY = 'https://gateway.pinata.cloud/ipfs/';
 exports.PINATA_IPFS_GATEWAY = PINATA_IPFS_GATEWAY;
@@ -47,14 +51,22 @@ const VARA_SCAN_ENDPOINT = 'https://nft-explorer.vara-network.io/graphql';
 // GATEWAY
 exports.VARA_SCAN_ENDPOINT = VARA_SCAN_ENDPOINT;
 const UNIQUE_IPFS_GATEWAY = 'https://ipfs.unique.network/ipfs/';
+
+// XOrigin
 exports.UNIQUE_IPFS_GATEWAY = UNIQUE_IPFS_GATEWAY;
 const NFT_STORAGE_GATEWAY = 'https://nftstorage.link/ipfs/';
 exports.NFT_STORAGE_GATEWAY = NFT_STORAGE_GATEWAY;
 const IPFS_W3S_LINK = 'https://w3s.link/ipfs/';
+
+// XOrigin
 exports.IPFS_W3S_LINK = IPFS_W3S_LINK;
 const GATEWAY_IPFS_IO = 'https://gateway.ipfs.io/ipfs/';
+
+// XOrigin
 exports.GATEWAY_IPFS_IO = GATEWAY_IPFS_IO;
 const IPFS_IO = 'https://ipfs.io/ipfs/';
+
+// XOrigin
 exports.IPFS_IO = IPFS_IO;
 const DWEB_LINK = 'https://dweb.link/ipfs/';
 exports.DWEB_LINK = DWEB_LINK;
@@ -122,26 +134,8 @@ exports.SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME = SUPPORTED_TRANSFER_SUBSTRATE_C
   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: CF_IPFS_GATEWAY,
-  weight: 4
-}, {
   provider: CLOUDFLARE_PINATA_SERVER,
   weight: 10
-}, {
-  provider: PINATA_IPFS_GATEWAY,
-  weight: 1 // Rate limit too low
-}, {
-  provider: DWEB_LINK,
-  weight: 5
-}, {
-  provider: GATEWAY_IPFS_IO,
-  weight: 5
-}, {
-  provider: IPFS_IO,
-  weight: 5
-}, {
-  provider: NFT_STORAGE_GATEWAY,
-  weight: 50
 }];
 if (isFirefox) {
   RANDOM_IPFS_GATEWAY_SETTING.push({
@@ -149,18 +143,34 @@ if (isFirefox) {
     weight: 5000
   });
 }
-if (!_utils.RuntimeInfo.protocol || _utils.RuntimeInfo.protocol && !_utils.RuntimeInfo.protocol.startsWith('http')) {
+if (!_utils.RuntimeInfo.protocol || !_utils.RuntimeInfo.protocol.startsWith('http') || _utils.RuntimeInfo.protocol.startsWith('https')) {
   RANDOM_IPFS_GATEWAY_SETTING.push({
     provider: IPFS_FLEEK,
     weight: 4
-  });
-  RANDOM_IPFS_GATEWAY_SETTING.push({
+  }, {
     provider: IPFS_GATEWAY_4EVERLAND,
     weight: 2
-  });
-  RANDOM_IPFS_GATEWAY_SETTING.push({
+  }, {
     provider: IPFS_W3S_LINK,
     weight: 1
+  }, {
+    provider: CF_IPFS_GATEWAY,
+    weight: 4
+  }, {
+    provider: PINATA_IPFS_GATEWAY,
+    weight: 1 // Rate limit too low
+  }, {
+    provider: NFT_STORAGE_GATEWAY,
+    weight: 50
+  }, {
+    provider: GATEWAY_IPFS_IO,
+    weight: 5
+  }, {
+    provider: DWEB_LINK,
+    weight: 5
+  }, {
+    provider: IPFS_IO,
+    weight: 5
   });
 }
 const RANDOM_IPFS_GATEWAY_TOTAL_WEIGHT = RANDOM_IPFS_GATEWAY_SETTING.reduce((value, item) => value + item.weight, 0);

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

@@ -9,6 +9,7 @@ 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 _ordinal_nft = _interopRequireDefault(require("@subwallet/extension-base/koni/api/nft/ordinal_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"));
@@ -50,6 +51,9 @@ function createWeb3NftApi(chain, evmApi, addresses) {
   const [, evmAddresses] = (0, _utils2.categoryAddresses)(addresses);
   return new _evm_nft.EvmNftApi(evmApi, evmAddresses, chain);
 }
+const createOrdinalApi = (chain, subscanChain, addresses) => {
+  return new _ordinal_nft.default(addresses, chain, subscanChain);
+};
 class NftHandler {
   // General settings
   chainInfoMap = {};
@@ -130,6 +134,16 @@ class NftHandler {
               }
             }
           }
+          if ((0, _utils._isSupportOrdinal)(chain)) {
+            var _chainInfo$extraInfo;
+            const subscanChain = (_chainInfo$extraInfo = chainInfo.extraInfo) === null || _chainInfo$extraInfo === void 0 ? void 0 : _chainInfo$extraInfo.subscanSlug;
+            if (subscanChain) {
+              const handler = createOrdinalApi(chain, subscanChain, substrateAddresses);
+              if (handler && !this.handlers.includes(handler)) {
+                this.handlers.push(handler);
+              }
+            }
+          }
         });
         this.needSetupApi = false;
       }

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.BaseNftApi = void 0;
-var _config = require("@subwallet/extension-base/koni/api/nft/config");
 var _utils = require("@subwallet/extension-base/utils");
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
@@ -71,27 +70,7 @@ class BaseNftApi {
     return tokenId;
   }
   parseUrl(input) {
-    if (!input || input.length === 0) {
-      return undefined;
-    }
-    if ((0, _utils.isUrl)(input)) {
-      return input;
-    }
-    if ((0, _utils.isUrl)(input) || input.includes('https://') || input.includes('http')) {
-      return input;
-    }
-    if (input.startsWith('/ipfs/')) {
-      return (0, _config.getRandomIpfsGateway)() + input.split('/ipfs/')[1];
-    }
-    if (!input.includes('ipfs://') && !input.includes('ipfs://ipfs/')) {
-      // just the IPFS hash
-      return (0, _config.getRandomIpfsGateway)() + input;
-    }
-    if (input.includes('ipfs://') && !input.includes('ipfs://ipfs/')) {
-      // starts with ipfs://
-      return (0, _config.getRandomIpfsGateway)() + input.split('ipfs://')[1];
-    }
-    return (0, _config.getRandomIpfsGateway)() + input.split('ipfs://ipfs/')[1]; // starts with ipfs://ipfs/
+    return (0, _utils.baseParseIPFSUrl)(input);
   }
 
   // Subclass implements this function to parse data into prop result

package/cjs/koni/api/nft/ordinal_nft/constants.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GET_EXTRINSIC_PARAMS_API = exports.GET_EVENT_LIST_API = exports.BASE_FETCH_ORDINAL_EVENT_DATA = void 0;
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const GET_EVENT_LIST_API = 'https://{{chain}}.api.subscan.io/api/v2/scan/events';
+exports.GET_EVENT_LIST_API = GET_EVENT_LIST_API;
+const GET_EXTRINSIC_PARAMS_API = 'https://{{chain}}.api.subscan.io/api/scan/extrinsic/params';
+exports.GET_EXTRINSIC_PARAMS_API = GET_EXTRINSIC_PARAMS_API;
+const BASE_FETCH_ORDINAL_EVENT_DATA = {
+  event_id: 'Remarked',
+  module: 'system',
+  order: 'desc',
+  success: true,
+  row: 100
+};
+exports.BASE_FETCH_ORDINAL_EVENT_DATA = BASE_FETCH_ORDINAL_EVENT_DATA;