@subwallet/extension-base 0.8.4-0 → 1.0.1

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

@@ -0,0 +1,145 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCrowdloanFundsStatus = getCrowdloanFundsStatus;
+exports.subscribeAcalaContributeInterval = void 0;
+exports.subscribeCrowdloan = subscribeCrowdloan;
+var _chainList = require("@subwallet/chain-list");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/constants");
+var _typeRegistry = _interopRequireDefault(require("@subwallet/extension-base/koni/api/dotsama/typeRegistry"));
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _axios = _interopRequireDefault(require("axios"));
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function getRPCCrowdloan(parentAPI, paraId, hexAddresses, paraState, callback) {
+  const unsubPromise = parentAPI.api.derive.crowdloan.ownContributions(paraId, hexAddresses, result => {
+    let contribute = new _util.BN(0);
+    Object.values(result).forEach(item => {
+      contribute = contribute.add(item.toBn());
+    });
+    const rs = {
+      state: _KoniTypes.APIItemState.READY,
+      paraState,
+      contribute: contribute.toString()
+    };
+    callback(rs);
+  });
+  return () => {
+    unsubPromise.then(unsub => {
+      unsub();
+    }).catch(console.error);
+  };
+}
+const subscribeAcalaContributeInterval = (polkadotAddresses, paraState, callback) => {
+  const acalaContributionApi = 'https://api.polkawallet.io/acala-distribution-v2/crowdloan?account=';
+  const getContributeInfo = () => {
+    Promise.all(polkadotAddresses.map(polkadotAddress => {
+      return _axios.default.get(`${acalaContributionApi}${polkadotAddress}`);
+    })).then(resList => {
+      let contribute = new _util.BN(0);
+      resList.forEach(res => {
+        var _res$data$data, _res$data$data$acala, _res$data$data$acala$;
+        if (res.status !== 200) {
+          console.warn('Failed to get Acala, Karura crowdloan contribute');
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument
+        contribute = contribute.add(new _util.BN(((_res$data$data = res.data.data) === null || _res$data$data === void 0 ? void 0 : (_res$data$data$acala = _res$data$data.acala) === null || _res$data$data$acala === void 0 ? void 0 : (_res$data$data$acala$ = _res$data$data$acala[0]) === null || _res$data$data$acala$ === void 0 ? void 0 : _res$data$data$acala$.totalDOTLocked) || '0'));
+      });
+      const rs = {
+        state: _KoniTypes.APIItemState.READY,
+        paraState,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
+        contribute: contribute.toString()
+      };
+      callback(rs);
+    }).catch(console.error);
+  };
+  getContributeInfo();
+  const interval = setInterval(getContributeInfo, _constants.ACALA_REFRESH_CROWDLOAN_INTERVAL);
+  return () => {
+    clearInterval(interval);
+  };
+};
+exports.subscribeAcalaContributeInterval = subscribeAcalaContributeInterval;
+async function getCrowdloanFundsStatus(api) {
+  const leases = await api.query.slots.leases.keys();
+  const leasesParaIds = leases.map(_ref => {
+    let {
+      args: [paraId]
+    } = _ref;
+    return paraId.toString();
+  });
+  const rs = await api.query.crowdloan.funds.entries();
+  const newRaise = await api.query.crowdloan.newRaise();
+  const newRaiseParaIds = newRaise.toJSON().map(p => p.toString());
+  return rs.reduce((stateMap, _ref2) => {
+    let [{
+      args: [paraId]
+    }, fundData] = _ref2;
+    const paraStr = paraId.toString();
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    // const item = fundData.unwrap() as PolkadotRuntimeCommonCrowdloanFundInfo;
+
+    if (leasesParaIds.indexOf(paraStr) > -1) {
+      stateMap[paraStr] = _KoniTypes.CrowdloanParaState.COMPLETED;
+    }
+    if (newRaiseParaIds.indexOf(paraStr) > -1) {
+      stateMap[paraStr] = _KoniTypes.CrowdloanParaState.ONGOING;
+    }
+    return stateMap;
+  }, {});
+}
+
+// Get All crowdloan
+async function subscribeCrowdloan(addresses, substrateApiMap, callback, chainInfoMap) {
+  const unsubMap = {};
+  if (Object.keys(substrateApiMap).includes(_chainList.COMMON_CHAIN_SLUGS.KUSAMA) && Object.keys(substrateApiMap).includes(_chainList.COMMON_CHAIN_SLUGS.POLKADOT)) {
+    const polkadotAPI = await substrateApiMap[_chainList.COMMON_CHAIN_SLUGS.POLKADOT].isReady;
+    const polkadotFundsStatusMap = await getCrowdloanFundsStatus(polkadotAPI.api);
+    const kusamaAPI = await substrateApiMap[_chainList.COMMON_CHAIN_SLUGS.KUSAMA].isReady;
+    const kusamaFundsStatusMap = await getCrowdloanFundsStatus(kusamaAPI.api);
+
+    // TODO: find all crowdloan valid networks: parachains, in-crowdloan, crowdloan but failed
+
+    const substrateAddresses = (0, _utils2.categoryAddresses)(addresses)[0];
+    const hexAddresses = substrateAddresses.map(address => {
+      return _typeRegistry.default.createType('AccountId', address).toHex();
+    });
+    Object.entries(chainInfoMap).forEach(_ref3 => {
+      let [networkKey, chainInfo] = _ref3;
+      if ((0, _utils._isSubstrateParachain)(chainInfo)) {
+        const parentChain = (0, _utils._getSubstrateRelayParent)(chainInfo);
+        const crowdloanCb = rs => {
+          callback(networkKey, rs);
+        };
+        const paraId = (0, _utils._getSubstrateParaId)(chainInfo);
+        if (paraId <= -1 || addresses.length === 0 || parentChain.length === 0) {
+          return;
+        }
+        if (networkKey === _chainList.COMMON_CHAIN_SLUGS.ACALA) {
+          const acalaAddresses = substrateAddresses.map(address => (0, _utils2.reformatAddress)(address, (0, _utils._getChainSubstrateAddressPrefix)(chainInfo), (0, _utils._isChainEvmCompatible)(chainInfo)));
+          unsubMap.acala = subscribeAcalaContributeInterval(acalaAddresses, polkadotFundsStatusMap[paraId], crowdloanCb);
+        } else if (parentChain === _chainList.COMMON_CHAIN_SLUGS.POLKADOT && polkadotFundsStatusMap[paraId]) {
+          unsubMap[networkKey] = getRPCCrowdloan(polkadotAPI, paraId, hexAddresses, polkadotFundsStatusMap[paraId], crowdloanCb);
+        } else if (parentChain === _chainList.COMMON_CHAIN_SLUGS.KUSAMA && kusamaFundsStatusMap[paraId]) {
+          unsubMap[networkKey] = getRPCCrowdloan(kusamaAPI, paraId, hexAddresses, kusamaFundsStatusMap[paraId], crowdloanCb);
+        }
+      }
+    });
+  }
+  return () => {
+    Object.values(unsubMap).forEach(unsub => {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+      unsub && unsub();
+    });
+  };
+}

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

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseSubstrateTransaction = void 0;
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @polkadot/extension-koni-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const formatArgs = callInstance => {
+  const paramArgKvArray = [];
+  const {
+    args,
+    meta
+  } = callInstance;
+  for (let i = 0; i < meta.args.length; i++) {
+    let argument;
+    if (args[i].toRawType().startsWith('AccountId')) {
+      argument = args[i].toString();
+    } else if (args[i].toRawType().startsWith('Vec<Call>')) {
+      argument = JSON.stringify(args[i].toHuman(false));
+    } else if (args[i].toRawType().startsWith('Vec')) {
+      // toString is nicer than toHuman here because
+      // toHuman tends to concatenate long strings and would hide data
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-return
+      argument = args[i].map(v => v.toString());
+    } else {
+      // toHuman takes care of the balance formating
+      // with the right chain unit
+      argument = JSON.stringify(args[i].toHuman());
+    }
+    const argName = meta.args[i].name.toHuman();
+    paramArgKvArray.push({
+      argName,
+      argValue: argument
+    });
+  }
+  return paramArgKvArray;
+};
+const parseSubstrateTransaction = (data, apiPromise) => {
+  const registry = apiPromise.registry;
+  const payload = registry.createType('ExtrinsicPayload', (0, _util.hexToU8a)(data));
+  const nonce = payload.nonce.toNumber();
+  const tip = payload.tip.toNumber();
+  const specVer = payload.specVersion.toNumber();
+  const _era = payload.era;
+  let era = _era.toString();
+  if (_era.isMortalEra) {
+    era = {
+      period: _era.asMortalEra.period.toNumber(),
+      phase: _era.asMortalEra.phase.toNumber()
+    };
+  }
+  const _method = payload.method.toString();
+  const call = registry.createType('Call', _method);
+  const sectionMethod = `${call.section}.${call.method}`;
+  const result = [];
+  const firstArg = call.args[0];
+  const baseInfo = {
+    era: era,
+    tip: tip,
+    nonce: nonce,
+    specVersion: specVer
+  };
+
+  // that's a batch
+  if (firstArg !== null && firstArg !== void 0 && firstArg.toRawType().startsWith('Vec<Call>')) {
+    result.push({
+      args: undefined,
+      methodName: sectionMethod
+    });
+    firstArg.forEach(c => {
+      registry.createType('Call', c);
+      result.push({
+        args: formatArgs(c),
+        methodName: `${c.section}.${c.method}`
+      });
+    });
+  } else {
+    try {
+      result.push({
+        args: formatArgs(call),
+        methodName: sectionMethod
+      });
+    } catch (e) {
+      return {
+        ...baseInfo,
+        message: 'Unable to decode method',
+        method: _method
+      };
+    }
+  }
+  return {
+    ...baseInfo,
+    method: result,
+    message: ''
+  };
+};
+exports.parseSubstrateTransaction = parseSubstrateTransaction;

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

@@ -0,0 +1,164 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.checkReferenceCount = checkReferenceCount;
+exports.checkSupportTransfer = checkSupportTransfer;
+exports.createTransferExtrinsic = void 0;
+var _wasm = require("@subwallet/extension-base/koni/api/tokens/wasm");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function isRefCount(accountInfo) {
+  return !!accountInfo.refcount;
+}
+async function checkReferenceCount(networkKey, address, substrateApiMap, chainInfo) {
+  const apiProps = await substrateApiMap[networkKey].isReady;
+  const api = apiProps.api;
+  if ((0, _utils._isChainEvmCompatible)(chainInfo)) {
+    return false;
+  }
+
+  // @ts-ignore
+  const accountInfo = await api.query.system.account(address);
+  return accountInfo ? isRefCount(accountInfo) ? !accountInfo.refcount.isZero() : !accountInfo.consumers.isZero() : false;
+}
+async function checkSupportTransfer(networkKey, tokenInfo, substrateApiMap, chainInfo) {
+  const substrateApi = await substrateApiMap[networkKey].isReady;
+  if (!tokenInfo) {
+    return {
+      supportTransfer: false,
+      supportTransferAll: false
+    };
+  }
+  if ((0, _utils._isChainEvmCompatible)(chainInfo)) {
+    return {
+      supportTransfer: true,
+      supportTransferAll: true
+    };
+  }
+  if (_constants._TRANSFER_NOT_SUPPORTED_CHAINS.includes(networkKey)) {
+    return {
+      supportTransfer: false,
+      supportTransferAll: false
+    };
+  }
+  const api = substrateApi.api;
+  const isTxCurrenciesSupported = !!api && !!api.tx && !!api.tx.currencies;
+  const isTxBalancesSupported = !!api && !!api.tx && !!api.tx.balances;
+  const isTxTokensSupported = !!api && !!api.tx && !!api.tx.tokens;
+  const isTxEqBalancesSupported = !!api && !!api.tx && !!api.tx.eqBalances;
+  const result = {
+    supportTransfer: false,
+    supportTransferAll: false
+  };
+  if (!(isTxCurrenciesSupported || isTxBalancesSupported || isTxTokensSupported || isTxEqBalancesSupported)) {
+    return result;
+  }
+  if ((0, _utils._isTokenWasmSmartContract)(tokenInfo) && api.query.contracts) {
+    // for PSP tokens
+    return {
+      supportTransfer: true,
+      supportTransferAll: true
+    };
+  }
+  if (_constants._TRANSFER_CHAIN_GROUP.acala.includes(networkKey) && !(0, _utils._isNativeToken)(tokenInfo) && isTxCurrenciesSupported) {
+    result.supportTransfer = true;
+    result.supportTransferAll = false;
+  } else if (_constants._TRANSFER_CHAIN_GROUP.kintsugi.includes(networkKey) && !(0, _utils._isNativeToken)(tokenInfo) && isTxTokensSupported) {
+    result.supportTransfer = true;
+    result.supportTransferAll = true;
+  } else if (_constants._TRANSFER_CHAIN_GROUP.genshiro.includes(networkKey) && !(0, _utils._isNativeToken)(tokenInfo) && isTxEqBalancesSupported) {
+    result.supportTransfer = true;
+    result.supportTransferAll = false;
+  } else if (_constants._TRANSFER_CHAIN_GROUP.crab.includes(networkKey) && _constants._BALANCE_TOKEN_GROUP.crab.includes(tokenInfo.symbol)) {
+    result.supportTransfer = true;
+    result.supportTransferAll = true;
+  } else if (isTxBalancesSupported && (0, _utils._isNativeToken)(tokenInfo)) {
+    result.supportTransfer = true;
+    result.supportTransferAll = true;
+  } else if (_constants._TRANSFER_CHAIN_GROUP.bitcountry.includes(networkKey) && !(0, _utils._isNativeToken)(tokenInfo) && _constants._BALANCE_TOKEN_GROUP.bitcountry.includes(tokenInfo.symbol)) {
+    result.supportTransfer = true;
+    result.supportTransferAll = true;
+  } else if (_constants._TRANSFER_CHAIN_GROUP.statemine.includes(networkKey) && !(0, _utils._isNativeToken)(tokenInfo)) {
+    result.supportTransfer = true;
+    result.supportTransferAll = true;
+  }
+  return result;
+}
+const createTransferExtrinsic = async _ref => {
+  var _transfer;
+  let {
+    from,
+    networkKey,
+    substrateApi,
+    to,
+    tokenInfo,
+    transferAll,
+    value
+  } = _ref;
+  const api = substrateApi.api;
+
+  // @ts-ignore
+  let transfer = null;
+  const isTxCurrenciesSupported = !!api && !!api.tx && !!api.tx.currencies;
+  const isTxBalancesSupported = !!api && !!api.tx && !!api.tx.balances;
+  const isTxTokensSupported = !!api && !!api.tx && !!api.tx.tokens;
+  const isTxEqBalancesSupported = !!api && !!api.tx && !!api.tx.eqBalances;
+  let transferAmount; // for PSP-22 tokens, might be deprecated in the future
+
+  if ((0, _utils._isTokenWasmSmartContract)(tokenInfo) && api.query.contracts) {
+    const contractPromise = (0, _wasm.getPSP22ContractPromise)(api, (0, _utils._getContractAddressOfToken)(tokenInfo));
+    const transferQuery = await contractPromise.query['psp22::transfer'](from, {
+      gasLimit: -1
+    }, to, value, {});
+    const gasLimit = transferQuery.gasRequired.toString();
+    transfer = contractPromise.tx['psp22::transfer']({
+      gasLimit
+    }, to, value, {});
+    transferAmount = value;
+  } else if (_constants._TRANSFER_CHAIN_GROUP.acala.includes(networkKey) && !(0, _utils._isNativeToken)(tokenInfo) && isTxCurrenciesSupported) {
+    if (transferAll) {
+      // currently Acala, Karura, Acala testnet do not have transfer all method for sub token
+    } else if (value) {
+      transfer = api.tx.currencies.transfer(to, (0, _utils._getTokenOnChainInfo)(tokenInfo), value);
+    }
+  } else if (_constants._TRANSFER_CHAIN_GROUP.kintsugi.includes(networkKey) && !(0, _utils._isNativeToken)(tokenInfo) && isTxTokensSupported) {
+    if (transferAll) {
+      transfer = api.tx.tokens.transferAll(to, (0, _utils._getTokenOnChainInfo)(tokenInfo), false);
+    } else if (value) {
+      transfer = api.tx.tokens.transfer(to, (0, _utils._getTokenOnChainInfo)(tokenInfo), new _util.BN(value));
+    }
+  } else if (_constants._TRANSFER_CHAIN_GROUP.genshiro.includes(networkKey) && !(0, _utils._isNativeToken)(tokenInfo) && isTxEqBalancesSupported) {
+    if (transferAll) {
+      // currently genshiro_testnet, genshiro, equilibrium_parachain do not have transfer all method for tokens
+    } else if (value) {
+      transfer = api.tx.eqBalances.transfer((0, _utils._getTokenOnChainAssetId)(tokenInfo), to, value);
+    }
+  } else if (!(0, _utils._isNativeToken)(tokenInfo) && (_constants._TRANSFER_CHAIN_GROUP.crab.includes(networkKey) || _constants._BALANCE_TOKEN_GROUP.crab.includes(tokenInfo.symbol))) {
+    if (transferAll) {
+      transfer = api.tx.kton.transferAll(to, false);
+    } else if (value) {
+      transfer = api.tx.kton.transfer(to, new _util.BN(value));
+    }
+  } else if (_constants._TRANSFER_CHAIN_GROUP.bitcountry.includes(networkKey) && !(0, _utils._isNativeToken)(tokenInfo)) {
+    transfer = api.tx.currencies.transfer(to, (0, _utils._getTokenOnChainInfo)(tokenInfo), value);
+  } else if (_constants._TRANSFER_CHAIN_GROUP.statemine.includes(networkKey) && !(0, _utils._isNativeToken)(tokenInfo)) {
+    transfer = api.tx.assets.transfer((0, _utils._getTokenOnChainAssetId)(tokenInfo), to, value);
+  } else if (isTxBalancesSupported && (0, _utils._isNativeToken)(tokenInfo)) {
+    if (transferAll) {
+      transfer = api.tx.balances.transferAll(to, false);
+    } else if (value) {
+      transfer = api.tx.balances.transfer(to, new _util.BN(value));
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+  console.log('transfer extrinsic: ', (_transfer = transfer) === null || _transfer === void 0 ? void 0 : _transfer.toHex());
+  return [transfer, transferAmount || value];
+};
+exports.createTransferExtrinsic = createTransferExtrinsic;

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

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _create = require("@polkadot/types/create");
+// Copyright 2017-2022 @polkadot/react-api authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const registry = new _create.TypeRegistry();
+var _default = registry;
+exports.default = _default;

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

@@ -0,0 +1,153 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AcalaNftApi = 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-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const acalaExternalBaseUrl = 'https://apps.acala.network/portfolio/nft/';
+class AcalaNftApi extends _nft.BaseNftApi {
+  // eslint-disable-next-line no-useless-constructor
+  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 (0, _config.getRandomIpfsGateway)() + input;
+    }
+    return (0, _config.getRandomIpfsGateway)() + input.split('ipfs://')[1];
+  }
+
+  /**
+   * Retrieve id of NFTs
+   *
+   * @returns the array of NFT Ids
+   * @param addresses
+   */
+  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.keys(address);
+      if (resp) {
+        for (const key of resp) {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+          const data = key.toHuman();
+          assetIds.push({
+            classId: data[1],
+            tokenId: this.parseTokenId(data[2])
+          });
+        }
+      }
+    }));
+    return assetIds;
+  }
+  async getCollectionDetails(collectionId) {
+    if (!this.substrateApi) {
+      return null;
+    }
+    const metadataCollection = (await this.substrateApi.api.query.ormlNFT.classes(collectionId)).toHuman();
+    if (!(metadataCollection !== null && metadataCollection !== void 0 && metadataCollection.metadata)) {
+      return null;
+    }
+    const data = await getMetadata(metadataCollection === null || metadataCollection === void 0 ? void 0 : metadataCollection.metadata);
+    return {
+      ...data,
+      image: this.parseUrl(data.image)
+    };
+  }
+  async getTokenDetails(assetId) {
+    if (!this.substrateApi) {
+      return null;
+    }
+    return (await this.substrateApi.api.query.ormlNFT.tokens(assetId.classId, assetId.tokenId)).toHuman();
+  }
+  async handleNft(address, params) {
+    // const start = performance.now();
+    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(parseInt(parsedClassId))]);
+        const parsedNft = {
+          id: parsedTokenId,
+          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,
+          externalUrl: acalaExternalBaseUrl + parsedClassId,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+          image: tokenInfo && tokenInfo.image ? this.parseUrl(tokenInfo === null || tokenInfo === void 0 ? void 0 : tokenInfo.image) : collectionMeta === null || collectionMeta === void 0 ? void 0 : collectionMeta.image,
+          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: collectionMeta === null || collectionMeta === void 0 ? void 0 : collectionMeta.image
+        };
+        params.updateItem(this.chain, parsedNft, address);
+        params.updateCollection(this.chain, parsedCollection);
+        // params.updateReady(true);
+      }));
+    } catch (e) {
+      console.error('Failed to fetch acala nft', e);
+    }
+  }
+  async handleNfts(params) {
+    await Promise.all(this.addresses.map(address => this.handleNft(address, params)));
+  }
+  async fetchNfts(params) {
+    try {
+      await this.connect();
+      await this.handleNfts(params);
+    } catch (e) {
+      return 0;
+    }
+    return 1;
+  }
+}
+exports.AcalaNftApi = AcalaNftApi;
+const headers = {
+  'Content-Type': 'application/json'
+};
+const getMetadata = metadataUrl => {
+  let url = metadataUrl;
+  if (!metadataUrl) {
+    return null;
+  }
+  url = (0, _config.getRandomIpfsGateway)() + metadataUrl + '/metadata.json';
+  return (0, _crossFetch.default)(url, {
+    method: 'GET',
+    headers
+  }).then(res => res.json());
+};