@subwallet/extension-base 1.3.3-0 → 1.3.5-0

package/cjs/koni/background/handlers/State.js

@@ -23,6 +23,7 @@ var _eventService = require("@subwallet/extension-base/services/event-service");
 var _service2 = _interopRequireDefault(require("@subwallet/extension-base/services/fee-service/service"));
 var _utils2 = require("@subwallet/extension-base/services/fee-service/utils");
 var _historyService = require("@subwallet/extension-base/services/history-service");
+var _inappNotificationService = require("@subwallet/extension-base/services/inapp-notification-service");
 var _keyringService = require("@subwallet/extension-base/services/keyring-service");
 var _migrationService = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service"));
 var _mintCampaignService = _interopRequireDefault(require("@subwallet/extension-base/services/mint-campaign-service"));
@@ -110,6 +111,7 @@ class KoniState {
     this.earningService = new _service.default(this);
     this.feeService = new _service2.default(this);
     this.swapService = new _swapService.SwapService(this);
+    this.inappNotificationService = new _inappNotificationService.InappNotificationService(this.dbService, this.keyringService, this.eventService, this.chainService);
     this.subscription = new _subscription.KoniSubscription(this, this.dbService);
     this.cron = new _cron.KoniCron(this, this.subscription, this.dbService);
     this.logger = (0, _util.logger)('State');
@@ -212,6 +214,7 @@ class KoniState {
     await this.balanceService.init();
     await this.earningService.init();
     await this.swapService.init();
+    await this.inappNotificationService.init();
     this.onReady();
     this.onAccountAdd();
     this.onAccountRemove();
@@ -1200,7 +1203,7 @@ class KoniState {
     this.campaignService.stop();
     await Promise.all([this.cron.stop(), this.subscription.stop()]);
     await this.pauseAllNetworks(undefined, 'IDLE mode');
-    await Promise.all([this.historyService.stop(), this.priceService.stop(), this.balanceService.stop(), this.earningService.stop(), this.swapService.stop()]);
+    await Promise.all([this.historyService.stop(), this.priceService.stop(), this.balanceService.stop(), this.earningService.stop(), this.swapService.stop(), this.inappNotificationService.stop()]);
 
     // Complete sleeping
     sleeping.resolve();
@@ -1233,7 +1236,7 @@ class KoniState {
     }
 
     // Start services
-    await Promise.all([this.cron.start(), this.subscription.start(), this.historyService.start(), this.priceService.start(), this.balanceService.start(), this.earningService.start(), this.swapService.start()]);
+    await Promise.all([this.cron.start(), this.subscription.start(), this.historyService.start(), this.priceService.start(), this.balanceService.start(), this.earningService.start(), this.swapService.start(), this.inappNotificationService.start()]);
 
     // Complete starting
     starting.resolve();

package/cjs/packageInfo.js

@@ -13,6 +13,6 @@ const packageInfo = {
   name: '@subwallet/extension-base',
   path: typeof __dirname === 'string' ? __dirname : 'auto',
   type: 'cjs',
-  version: '1.3.3-0'
+  version: '1.3.5-0'
 };
 exports.packageInfo = packageInfo;

package/cjs/services/balance-service/helpers/process.js

@@ -21,8 +21,9 @@ function getDefaultTransferProcess() {
   };
 }
 async function getSnowbridgeTransferProcessFromEvm(address, evmApi, tokenInfo, amount) {
+  // todo: refactor, AvailBridge also go into this function
   if (![_chainList.COMMON_CHAIN_SLUGS.ETHEREUM, _chainList.COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA].includes(tokenInfo.originChain)) {
-    throw new Error('Snowbridge only has support for Ethereum');
+    throw new Error('Snowbridge or AvailBridge only has support for Ethereum');
   }
   const result = {
     totalFee: [_serviceBase.MOCK_STEP_FEE],

package/cjs/services/balance-service/helpers/subscribe/index.js

@@ -138,6 +138,11 @@ function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _chainInfoM
         tonApi
       });
     }
+
+    // If the chain is not ready, return pending state
+    if (!substrateApiMap[chainSlug].isApiReady) {
+      handleUnsupportedOrPendingAddresses(useAddresses, chainSlug, chainAssetMap, _KoniTypes.APIItemState.PENDING, callback);
+    }
     const substrateApi = await substrateApiMap[chainSlug].isReady;
     return (0, _substrate.subscribeSubstrateBalance)(useAddresses, chainInfo, chainAssetMap, substrateApi, evmApi, callback, extrinsicType);
   });

package/cjs/services/balance-service/index.js

@@ -199,7 +199,7 @@ class BalanceService {
       let unsub = _util.noop;
       unsub = (0, _helpers.subscribeBalance)([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, result => {
         const rs = result[0];
-        if (rs.tokenSlug === tSlug) {
+        if (rs.tokenSlug === tSlug && rs.state !== _KoniTypes.APIItemState.PENDING) {
           hasError = false;
           const balance = {
             value: rs.free,

package/cjs/services/balance-service/transfer/xcm/availBridge.js

@@ -0,0 +1,198 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AvailBridgeConfig = void 0;
+exports.getAvailBridgeExtrinsicFromAvail = getAvailBridgeExtrinsicFromAvail;
+exports.getAvailBridgeTxFromEth = getAvailBridgeTxFromEth;
+exports.getClaimTxOnAvail = getClaimTxOnAvail;
+exports.getClaimTxOnEthereum = getClaimTxOnEthereum;
+exports.isAvailChainBridge = isAvailChainBridge;
+var _chainList = require("@subwallet/chain-list");
+var _web = require("@subwallet/extension-base/koni/api/contract-handler/evm/web3");
+var _utils = require("@subwallet/extension-base/koni/api/contract-handler/utils");
+var _utils2 = require("@subwallet/extension-base/services/fee-service/utils");
+var _utils3 = require("@subwallet/extension-base/services/inapp-notification-service/utils");
+var _keyring = require("@subwallet/keyring");
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const AvailBridgeConfig = {
+  ASSET_ID: '0x0000000000000000000000000000000000000000000000000000000000000000',
+  ETHEREUM_DOMAIN: 2,
+  // todo: check if these config can change later
+  AVAIL_DOMAIN: 1
+};
+exports.AvailBridgeConfig = AvailBridgeConfig;
+async function getAvailBridgeTxFromEth(originChainInfo, sender, recipient, value, evmApi) {
+  var _priority$maxFeePerGa, _priority$maxPriority;
+  const availBridgeContractAddress = (0, _utils.getAvailBridgeGatewayContract)(originChainInfo.slug);
+  const ABI = getAvailBridgeAbi(originChainInfo.slug);
+  const availBridgeContract = (0, _web.getWeb3Contract)(availBridgeContractAddress, evmApi, ABI);
+  const _address = (0, _util.u8aToHex)((0, _keyring.decodeAddress)(recipient));
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+  const sendAvail = availBridgeContract.methods.sendAVAIL(_address, value);
+  const transferData = sendAvail.encodeABI();
+  const priority = await (0, _utils2.calculateGasFeeParams)(evmApi, evmApi.chainSlug);
+  const gasLimit = await sendAvail.estimateGas({
+    from: sender
+  });
+  return {
+    from: sender,
+    to: availBridgeContractAddress,
+    value: '0',
+    data: transferData,
+    gasPrice: priority.gasPrice,
+    maxFeePerGas: (_priority$maxFeePerGa = priority.maxFeePerGas) === null || _priority$maxFeePerGa === void 0 ? void 0 : _priority$maxFeePerGa.toString(),
+    maxPriorityFeePerGas: (_priority$maxPriority = priority.maxPriorityFeePerGas) === null || _priority$maxPriority === void 0 ? void 0 : _priority$maxPriority.toString(),
+    gas: gasLimit
+  };
+}
+async function getAvailBridgeExtrinsicFromAvail(recipient, sendingValue, substrateApi) {
+  const data = {
+    message: {
+      FungibleToken: {
+        assetId: AvailBridgeConfig.ASSET_ID,
+        amount: BigInt(sendingValue)
+      }
+    },
+    to: `${recipient.padEnd(66, '0')}`,
+    domain: AvailBridgeConfig.ETHEREUM_DOMAIN
+  };
+  const chainApi = await substrateApi.isReady;
+  return chainApi.api.tx.vector.sendMessage(data.message, data.to, data.domain);
+}
+async function getClaimTxOnAvail(notification, substrateApi) {
+  const chainApi = await substrateApi.isReady;
+  const chainSlug = chainApi.chainSlug;
+  const metadata = notification.metadata;
+  const lastestEthHeadSlot = await getLastestEthHeadSlot(chainSlug);
+  const lastestBlockHash = await getLastestBlockHash(chainSlug, lastestEthHeadSlot);
+  const proof = await getClaimProofOnAvail(chainSlug, lastestBlockHash, metadata.messageId);
+  return chainApi.api.tx.vector.execute(lastestEthHeadSlot, getAddressMessage(notification), proof.accountProof, proof.storageProof);
+}
+async function getLastestEthHeadSlot(chainSlug) {
+  try {
+    const api = getAvailBridgeApi(chainSlug);
+    const rawResponse = await fetch(`${api}/eth/head`);
+    const response = await rawResponse.json();
+    return response.slot;
+  } catch (e) {
+    console.error(e);
+    throw e;
+  }
+}
+async function getLastestBlockHash(chainSlug, slot) {
+  try {
+    const api = getAvailBridgeApi(chainSlug);
+    const rawResponse = await fetch(`${api}/beacon/slot/${slot}`);
+    const response = await rawResponse.json();
+    return response.blockHash;
+  } catch (e) {
+    console.error(e);
+    throw e;
+  }
+}
+async function getClaimProofOnAvail(chainSlug, blockHash, messageId) {
+  try {
+    const api = getAvailBridgeApi(chainSlug);
+    const rawResponse = await fetch(`${api}/avl/proof/${blockHash}/${messageId}`);
+    return await rawResponse.json();
+  } catch (e) {
+    console.error(e);
+    throw e;
+  }
+}
+async function getClaimProofOnEthereum(chainSlug, blockHash, transactionIndex) {
+  try {
+    const api = getAvailBridgeApi(chainSlug);
+    const rawResponse = await fetch(`${api}/eth/proof/${blockHash}?index=${transactionIndex}`);
+    return await rawResponse.json();
+  } catch (e) {
+    console.error(e);
+    throw e;
+  }
+}
+function getAvailBridgeApi(chainSlug) {
+  if (chainSlug === 'avail_mainnet' || chainSlug === _chainList.COMMON_CHAIN_SLUGS.ETHEREUM) {
+    // todo: add COMMON_CHAIN_SLUGS for AVAIL, AVAIL TURING
+    return _utils3.AVAIL_BRIDGE_API.AVAIL_MAINNET;
+  }
+  return _utils3.AVAIL_BRIDGE_API.AVAIL_TESTNET;
+}
+async function getClaimTxOnEthereum(chainSlug, notification, evmApi) {
+  var _priority$maxFeePerGa2, _priority$maxPriority2;
+  const availBridgeContractAddress = (0, _utils.getAvailBridgeGatewayContract)(chainSlug);
+  const ABI = getAvailBridgeAbi(chainSlug);
+  const availBridgeContract = (0, _web.getWeb3Contract)(availBridgeContractAddress, evmApi, ABI);
+  const metadata = notification.metadata;
+  const merkleProof = await getClaimProofOnEthereum(chainSlug, metadata.sourceBlockHash, metadata.sourceTransactionIndex);
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+  const transfer = availBridgeContract.methods.receiveAVAIL({
+    messageType: '0x02',
+    from: merkleProof.message.from,
+    to: merkleProof.message.to,
+    originDomain: merkleProof.message.originDomain,
+    destinationDomain: merkleProof.message.destinationDomain,
+    data: evmApi.api.eth.abi.encodeParameters([{
+      name: 'assetId',
+      type: 'bytes32'
+    }, {
+      name: 'amount',
+      type: 'uint256'
+    }], [merkleProof.message.message.fungibleToken.asset_id, BigInt(merkleProof.message.message.fungibleToken.amount)]),
+    messageId: merkleProof.message.id
+  }, {
+    dataRootProof: merkleProof.dataRootProof,
+    leafProof: merkleProof.leafProof,
+    rangeHash: merkleProof.rangeHash,
+    dataRootIndex: merkleProof.dataRootIndex,
+    blobRoot: merkleProof.blobRoot,
+    bridgeRoot: merkleProof.bridgeRoot,
+    leaf: merkleProof.leaf,
+    leafIndex: merkleProof.leafIndex
+  });
+  const transferData = transfer.encodeABI();
+  const gasLimit = await transfer.estimateGas({
+    from: metadata.receiverAddress
+  });
+  const priority = await (0, _utils2.calculateGasFeeParams)(evmApi, evmApi.chainSlug);
+  return {
+    from: metadata.receiverAddress,
+    to: availBridgeContractAddress,
+    value: '0',
+    data: transferData,
+    gasPrice: priority.gasPrice,
+    maxFeePerGas: (_priority$maxFeePerGa2 = priority.maxFeePerGas) === null || _priority$maxFeePerGa2 === void 0 ? void 0 : _priority$maxFeePerGa2.toString(),
+    maxPriorityFeePerGas: (_priority$maxPriority2 = priority.maxPriorityFeePerGas) === null || _priority$maxPriority2 === void 0 ? void 0 : _priority$maxPriority2.toString(),
+    gas: gasLimit
+  };
+}
+function getAddressMessage(notification) {
+  const metadata = notification.metadata;
+  return {
+    message: {
+      FungibleToken: {
+        assetId: AvailBridgeConfig.ASSET_ID,
+        amount: metadata.amount
+      }
+    },
+    from: `${metadata.depositorAddress.padEnd(66, '0')}`,
+    to: (0, _util.u8aToHex)((0, _keyring.decodeAddress)(metadata.receiverAddress)),
+    originDomain: AvailBridgeConfig.ETHEREUM_DOMAIN,
+    destinationDomain: AvailBridgeConfig.AVAIL_DOMAIN,
+    id: metadata.messageId
+  };
+}
+function getAvailBridgeAbi(chainSlug) {
+  if (chainSlug === _chainList.COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA) {
+    return _utils._AVAIL_TEST_BRIDGE_GATEWAY_ABI;
+  }
+  return _utils._AVAIL_BRIDGE_GATEWAY_ABI;
+}
+function isAvailChainBridge(chainSlug) {
+  return ['avail_mainnet', 'availTuringTest'].includes(chainSlug);
+}

package/cjs/services/balance-service/transfer/xcm/index.js

@@ -4,8 +4,9 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getXcmMockTxFee = exports.createXcmExtrinsic = exports.createSnowBridgeExtrinsic = void 0;
+exports.getXcmMockTxFee = exports.createXcmExtrinsic = exports.createSnowBridgeExtrinsic = exports.createAvailBridgeTxFromEth = exports.createAvailBridgeExtrinsicFromAvail = void 0;
 var _xcmParser = require("@subwallet/extension-base/core/substrate/xcm-parser");
+var _availBridge = require("@subwallet/extension-base/services/balance-service/transfer/xcm/availBridge");
 var _polkadotXcm = require("@subwallet/extension-base/services/balance-service/transfer/xcm/polkadotXcm");
 var _snowBridge = require("@subwallet/extension-base/services/balance-service/transfer/xcm/snowBridge");
 var _xcmPallet = require("@subwallet/extension-base/services/balance-service/transfer/xcm/xcmPallet");
@@ -33,6 +34,12 @@ const createSnowBridgeExtrinsic = async _ref => {
   if (!(0, _xcmParser._isSnowBridgeXcm)(originChainInfo, destinationChainInfo)) {
     throw new Error('This is not a valid SnowBridge transfer');
   }
+  if (!evmApi) {
+    throw Error('Evm API is not available');
+  }
+  if (!sender) {
+    throw Error('Sender is required');
+  }
   return (0, _snowBridge.getSnowBridgeEvmTransfer)(originTokenInfo, originChainInfo, destinationChainInfo, sender, recipient, sendingValue, evmApi);
 };
 exports.createSnowBridgeExtrinsic = createSnowBridgeExtrinsic;
@@ -47,6 +54,9 @@ const createXcmExtrinsic = async _ref2 => {
   } = _ref2;
   const originChainInfo = chainInfoMap[originTokenInfo.originChain];
   const destinationChainInfo = chainInfoMap[destinationTokenInfo.originChain];
+  if (!substrateApi) {
+    throw Error('Substrate API is not available');
+  }
   const chainApi = await substrateApi.isReady;
   const api = chainApi.api;
   const polkadotXcmSpecialCases = _constants._XCM_CHAIN_GROUP.polkadotXcmSpecialCases.includes(originChainInfo.slug) && (0, _utils._isNativeToken)(originTokenInfo);
@@ -59,24 +69,59 @@ const createXcmExtrinsic = async _ref2 => {
   return (0, _xTokens.getExtrinsicByXtokensPallet)(originTokenInfo, originChainInfo, destinationChainInfo, recipient, sendingValue, api);
 };
 exports.createXcmExtrinsic = createXcmExtrinsic;
+const createAvailBridgeTxFromEth = _ref3 => {
+  let {
+    chainInfoMap,
+    evmApi,
+    originTokenInfo,
+    recipient,
+    sender,
+    sendingValue
+  } = _ref3;
+  const originChainInfo = chainInfoMap[originTokenInfo.originChain];
+  if (!evmApi) {
+    throw Error('Evm API is not available');
+  }
+  if (!sender) {
+    throw Error('Sender is required');
+  }
+  return (0, _availBridge.getAvailBridgeTxFromEth)(originChainInfo, sender, recipient, sendingValue, evmApi);
+};
+exports.createAvailBridgeTxFromEth = createAvailBridgeTxFromEth;
+const createAvailBridgeExtrinsicFromAvail = async _ref4 => {
+  let {
+    recipient,
+    sendingValue,
+    substrateApi
+  } = _ref4;
+  if (!substrateApi) {
+    throw Error('Substrate API is not available');
+  }
+  return await (0, _availBridge.getAvailBridgeExtrinsicFromAvail)(recipient, sendingValue, substrateApi);
+};
+exports.createAvailBridgeExtrinsicFromAvail = createAvailBridgeExtrinsicFromAvail;
 const getXcmMockTxFee = async (substrateApi, chainInfoMap, originTokenInfo, destinationTokenInfo) => {
   try {
     var _paymentInfo$partialF;
     const destChainInfo = chainInfoMap[destinationTokenInfo.originChain];
     const originChainInfo = chainInfoMap[originTokenInfo.originChain];
-    const address = '5DRewsYzhJqZXU3SRaWy1FSt5iDr875ao91aw5fjrJmDG4Ap'; // todo: move this
+    const fakeAddress = '5DRewsYzhJqZXU3SRaWy1FSt5iDr875ao91aw5fjrJmDG4Ap'; // todo: move this
+    const substrateAddress = fakeAddress; // todo: move this
+    const evmAddress = (0, _util.u8aToHex)((0, _utilCrypto.addressToEvm)(fakeAddress)); // todo: move this
 
     // mock receiving account from sender
-    const recipient = !(0, _utilCrypto.isEthereumAddress)(address) && (0, _utils._isChainEvmCompatible)(destChainInfo) && !(0, _utils._isChainEvmCompatible)(originChainInfo) ? (0, _util.u8aToHex)((0, _utilCrypto.addressToEvm)(address)) : address;
+    const sender = (0, _utils._isChainEvmCompatible)(originChainInfo) ? evmAddress : substrateAddress;
+    const recipient = (0, _utils._isChainEvmCompatible)(destChainInfo) ? evmAddress : substrateAddress;
     const mockTx = await createXcmExtrinsic({
       chainInfoMap,
       destinationTokenInfo,
       originTokenInfo,
-      recipient: recipient,
+      sender,
+      recipient,
       sendingValue: '1000000000000000000',
       substrateApi
     });
-    const paymentInfo = await mockTx.paymentInfo(address);
+    const paymentInfo = await mockTx.paymentInfo(fakeAddress);
     return new _bignumber.default((paymentInfo === null || paymentInfo === void 0 ? void 0 : (_paymentInfo$partialF = paymentInfo.partialFee) === null || _paymentInfo$partialF === void 0 ? void 0 : _paymentInfo$partialF.toString()) || '0');
   } catch (e) {
     console.error('error mocking xcm tx fee', e);

package/cjs/services/chain-service/constants.js

@@ -65,7 +65,8 @@ const _NFT_CHAIN_GROUP = {
   bitcountry: ['bitcountry', 'pioneer', 'continuum_network'],
   vara: ['vara_network'],
   avail: ['avail_mainnet'],
-  ternoa: ['ternoa', 'ternoa_alphanet']
+  ternoa: ['ternoa', 'ternoa_alphanet'],
+  rari: ['rari']
 };
 
 // Staking--------------------------------------------------------------------------------------------------------------

package/cjs/services/chain-service/handler/EvmApi.js

@@ -80,15 +80,11 @@ class EvmApi {
   createIntervalCheckApi() {
     this.clearIntervalCheckApi();
     return setInterval(() => {
-      if (!this.ignoreNetListen) {
-        this.api.eth.net.isListening().then(() => {
-          this.onConnect();
-        }).catch(() => {
-          this.onDisconnect();
-        });
-      } else {
+      this.api.eth.getChainId().then(() => {
         this.onConnect();
-      }
+      }).catch(() => {
+        this.onDisconnect();
+      });
     }, 10000);
   }
   clearIntervalCheckApi() {
@@ -101,21 +97,16 @@ class EvmApi {
     this.updateConnectionStatus(_types._ChainConnectionStatus.CONNECTING);
 
     // Check if api is ready
-    if (!this.ignoreNetListen) {
-      this.api.eth.net.isListening().then(() => {
-        this.isApiReadyOnce = true;
-        this.onConnect();
-      }).catch(error => {
-        this.isApiReadyOnce = false;
-        this.isApiReady = false;
-        this.isReadyHandler.reject(error);
-        this.updateConnectionStatus(_types._ChainConnectionStatus.DISCONNECTED);
-        console.warn(`Can not connect to ${this.chainSlug} (EVM) at ${this.apiUrl}`);
-      });
-    } else {
+    this.api.eth.getChainId().then(() => {
       this.isApiReadyOnce = true;
       this.onConnect();
-    }
+    }).catch(error => {
+      this.isApiReadyOnce = false;
+      this.isApiReady = false;
+      this.isReadyHandler.reject(error);
+      this.updateConnectionStatus(_types._ChainConnectionStatus.DISCONNECTED);
+      console.warn(`Can not connect to ${this.chainSlug} (EVM) at ${this.apiUrl}`);
+    });
 
     // Interval to check connecting status
     this.intervalCheckApi = this.createIntervalCheckApi();

package/cjs/services/chain-service/handler/EvmChainHandler.js

@@ -118,7 +118,6 @@ class EvmChainHandler extends _AbstractChainHandler.AbstractChainHandler {
     const evmApi = this.getEvmApiByChain(originChain);
     try {
       if (tokenType === _types._AssetType.ERC721) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-member-access
         tokenContract = new evmApi.api.eth.Contract(_utils._ERC721_ABI, contractAddress);
         const [_name, _symbol] = await Promise.all([
         // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
@@ -128,7 +127,6 @@ class EvmChainHandler extends _AbstractChainHandler.AbstractChainHandler {
         name = _name;
         symbol = _symbol;
       } else {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-member-access
         tokenContract = new evmApi.api.eth.Contract(_utils._ERC20_ABI, contractAddress);
         const [_decimals, _symbol, _name] = await Promise.all([
         // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access

package/cjs/services/chain-service/handler/SubstrateChainHandler.js

@@ -114,6 +114,12 @@ class SubstrateChainHandler extends _AbstractChainHandler.AbstractChainHandler {
   }
   async getPsp22TokenInfo(apiPromise, contractAddress, contractCaller) {
     const tokenContract = new _apiContract.ContractPromise(apiPromise, _utils3._PSP22_ABI, contractAddress);
+    const tokenSmartContract = {
+      name: '',
+      decimals: -1,
+      symbol: '',
+      contractError: false
+    };
     const [nameResp, symbolResp, decimalsResp] = await Promise.all([tokenContract.query['psp22Metadata::tokenName'](contractCaller || contractAddress, {
       gasLimit: (0, _utils.getDefaultWeightV2)(apiPromise)
     }),
@@ -124,91 +130,118 @@ class SubstrateChainHandler extends _AbstractChainHandler.AbstractChainHandler {
       gasLimit: (0, _utils.getDefaultWeightV2)(apiPromise)
     })]);
     if (!(nameResp.result.isOk && symbolResp.result.isOk && decimalsResp.result.isOk) || !nameResp.output || !decimalsResp.output || !symbolResp.output) {
-      return ['', 1, '', true];
+      tokenSmartContract.contractError = true;
+      return tokenSmartContract;
     } else {
       var _symbolResp$output, _decimalsResp$output, _nameResp$output;
-      let contractError = false;
       const symbolObj = (_symbolResp$output = symbolResp.output) === null || _symbolResp$output === void 0 ? void 0 : _symbolResp$output.toHuman();
       const decimalsObj = (_decimalsResp$output = decimalsResp.output) === null || _decimalsResp$output === void 0 ? void 0 : _decimalsResp$output.toHuman();
       const nameObj = (_nameResp$output = nameResp.output) === null || _nameResp$output === void 0 ? void 0 : _nameResp$output.toHuman();
-      const name = nameResp.output ? nameObj.Ok || nameObj.ok : '';
-      const decimals = decimalsResp.output ? new _util.BN(decimalsObj.Ok || decimalsObj.ok).toNumber() : 0;
-      const symbol = decimalsResp.output ? symbolObj.Ok || symbolObj.ok : '';
-      if (!name || !symbol || typeof name === 'object' || typeof symbol === 'object') {
-        contractError = true;
+      tokenSmartContract.name = nameResp.output ? nameObj.Ok || nameObj.ok : '';
+      tokenSmartContract.decimals = decimalsResp.output ? new _util.BN(decimalsObj.Ok || decimalsObj.ok).toNumber() : 0;
+      tokenSmartContract.symbol = decimalsResp.output ? symbolObj.Ok || symbolObj.ok : '';
+      if (!tokenSmartContract.name || !tokenSmartContract.symbol || typeof tokenSmartContract.name === 'object' || typeof tokenSmartContract.symbol === 'object') {
+        tokenSmartContract.contractError = true;
       }
-      return [name, decimals, symbol, contractError];
+      return tokenSmartContract;
     }
   }
   async getPsp34TokenInfo(apiPromise, contractAddress, contractCaller) {
     const tokenContract = new _apiContract.ContractPromise(apiPromise, _utils3._PSP34_ABI, contractAddress);
+    const tokenSmartContract = {
+      name: '',
+      decimals: -1,
+      symbol: '',
+      contractError: false
+    };
     const collectionIdResp = await tokenContract.query['psp34::collectionId'](contractCaller || contractAddress, {
       gasLimit: (0, _utils.getDefaultWeightV2)(apiPromise)
     }); // read-only operation so no gas limit
 
     if (!collectionIdResp.result.isOk || !collectionIdResp.output) {
-      return ['', -1, '', true];
+      tokenSmartContract.contractError = true;
+      return tokenSmartContract;
     } else {
       var _collectionIdResp$out;
-      let contractError = false;
       const collectionIdDict = (_collectionIdResp$out = collectionIdResp.output) === null || _collectionIdResp$out === void 0 ? void 0 : _collectionIdResp$out.toHuman();
       if (collectionIdDict.Bytes === '') {
-        contractError = true;
+        tokenSmartContract.contractError = true;
       }
-      return ['', -1, '', contractError];
+      return tokenSmartContract;
     }
   }
-  async getGrc20TokenInfo(apiPromise, contractAddress) {
+  async getVaraFungibleTokenInfo(apiPromise, contractAddress, tokenType) {
+    const tokenSmartContract = {
+      name: '',
+      decimals: -1,
+      symbol: '',
+      contractError: false
+    };
     if (!(apiPromise instanceof _api.GearApi)) {
-      console.warn('Cannot subscribe GRC20 balance without GearApi instance');
-      return ['', -1, '', true];
+      if (tokenType === _types._AssetType.GRC20) {
+        console.warn('Cannot subscribe GRC20 balance without GearApi instance');
+      } else if (tokenType === _types._AssetType.VFT) {
+        console.warn('Cannot subscribe VFT balance without GearApi instance');
+      }
+      tokenSmartContract.contractError = true;
+      return tokenSmartContract;
     }
-    let contractError = false;
-    const tokenContract = (0, _utils2.getGRC20ContractPromise)(apiPromise, contractAddress);
+    const tokenContract = tokenType === _types._AssetType.GRC20 ? (0, _utils2.getGRC20ContractPromise)(apiPromise, contractAddress) : (0, _utils2.getVFTContractPromise)(apiPromise, contractAddress);
     const [nameRes, symbolRes, decimalsRes] = await Promise.all([tokenContract.service.name(_utils2.GEAR_DEFAULT_ADDRESS), tokenContract.service.symbol(_utils2.GEAR_DEFAULT_ADDRESS), tokenContract.service.decimals(_utils2.GEAR_DEFAULT_ADDRESS)]);
-    const decimals = typeof decimalsRes === 'string' ? parseInt(decimalsRes) : decimalsRes;
+    const decimals = parseInt(decimalsRes.toString());
+    tokenSmartContract.name = nameRes;
+    tokenSmartContract.decimals = decimals;
+    tokenSmartContract.symbol = symbolRes;
     if (!nameRes || !symbolRes) {
-      contractError = true;
+      tokenSmartContract.contractError = true;
     }
-    return [nameRes, decimals, symbolRes, contractError];
+    return tokenSmartContract;
   }
-  async getVftTokenInfo(apiPromise, contractAddress) {
-    if (!(apiPromise instanceof _api.GearApi)) {
-      console.warn('Cannot subscribe VFT balance without GearApi instance');
-      return ['', -1, '', true];
+  async getLocalTokenInfo(apiPromise, assetId) {
+    const _metadata = await apiPromise.query.assets.metadata(assetId);
+    const metadata = _metadata.toPrimitive();
+    let idError = false;
+    if (!metadata.name || !metadata.symbol) {
+      idError = true;
     }
-    let contractError = false;
-    const tokenContract = (0, _utils2.getVFTContractPromise)(apiPromise, contractAddress);
-    const [nameRes, symbolRes, decimalsRes] = await Promise.all([tokenContract.service.name(_utils2.GEAR_DEFAULT_ADDRESS), tokenContract.service.symbol(_utils2.GEAR_DEFAULT_ADDRESS), tokenContract.service.decimals(_utils2.GEAR_DEFAULT_ADDRESS)]);
-    const decimals = typeof decimalsRes === 'string' ? parseInt(decimalsRes) : decimalsRes;
-    if (!nameRes || !symbolRes) {
-      contractError = true;
-    }
-    return [nameRes, decimals, symbolRes, contractError];
+    return [metadata.name, metadata.decimals, metadata.symbol, idError];
   }
   async getSubstrateContractTokenInfo(contractAddress, tokenType, originChain, contractCaller) {
     // todo: improve this funtion later
 
-    let name = '';
-    let decimals = -1;
-    let symbol = '';
-    let contractError = false;
+    let tokenSmartContract = {
+      name: '',
+      decimals: -1,
+      symbol: '',
+      contractError: false
+    };
     const apiPromise = this.getSubstrateApiByChain(originChain).api;
     try {
       switch (tokenType) {
         case _types._AssetType.PSP22:
-          [name, decimals, symbol, contractError] = await this.getPsp22TokenInfo(apiPromise, contractAddress, contractCaller);
+          tokenSmartContract = await this.getPsp22TokenInfo(apiPromise, contractAddress, contractCaller);
           break;
         case _types._AssetType.PSP34:
-          [name, decimals, symbol, contractError] = await this.getPsp34TokenInfo(apiPromise, contractAddress, contractCaller);
+          tokenSmartContract = await this.getPsp34TokenInfo(apiPromise, contractAddress, contractCaller);
           break;
         case _types._AssetType.GRC20:
-          [name, decimals, symbol, contractError] = await this.getGrc20TokenInfo(apiPromise, contractAddress);
+          tokenSmartContract = await this.getVaraFungibleTokenInfo(apiPromise, contractAddress, tokenType);
           break;
         case _types._AssetType.VFT:
-          [name, decimals, symbol, contractError] = await this.getVftTokenInfo(apiPromise, contractAddress);
+          tokenSmartContract = await this.getVaraFungibleTokenInfo(apiPromise, contractAddress, tokenType);
           break;
       }
+      return tokenSmartContract;
+    } catch (e) {
+      this.logger.error(e);
+      tokenSmartContract.contractError = true;
+      return tokenSmartContract;
+    }
+  }
+  async getSubstrateAssetIdTokenInfo(assetId, originChain) {
+    const apiPromise = this.getSubstrateApiByChain(originChain).api;
+    try {
+      const [name, decimals, symbol, contractError] = await this.getLocalTokenInfo(apiPromise, assetId);
       return {
         name,
         decimals,