@subwallet/extension-base 1.2.15-0 → 1.2.17-0

package/cjs/utils/gear/vft.js

@@ -0,0 +1,173 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VftService = exports.VFT = void 0;
+var _api = require("@gear-js/api");
+var _sailsJs = require("sails-js");
+var _types = require("@polkadot/types");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class VFT {
+  constructor(api) {
+    let programId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '0x';
+    this.api = api;
+    this.programId = programId;
+    const types = {};
+    this.registry = new _types.TypeRegistry();
+    this.registry.setKnownTypes({
+      types
+    });
+    this.registry.register(types);
+    this.service = new VftService(this);
+  }
+  newCtorFromCode(code, name, symbol, decimals) {
+    const builder = new _sailsJs.TransactionBuilder(this.api, this.registry, 'upload_program', ['New', name, symbol, decimals], '(String, String, String, u8)', 'String', code);
+    this.programId = builder.programId;
+    return builder;
+  }
+  newCtorFromCodeId(codeId, name, symbol, decimals) {
+    const builder = new _sailsJs.TransactionBuilder(this.api, this.registry, 'create_program', ['New', name, symbol, decimals], '(String, String, String, u8)', 'String', codeId);
+    this.programId = builder.programId;
+    return builder;
+  }
+}
+exports.VFT = VFT;
+class VftService {
+  constructor(_program) {
+    this._program = _program;
+  }
+  approve(spender, value) {
+    if (!this._program.programId) {
+      throw new Error('Program ID is not set');
+    }
+    return new _sailsJs.TransactionBuilder(this._program.api, this._program.registry, 'send_message', ['Vft', 'Approve', spender, value], '(String, String, [u8;32], U256)', 'bool', this._program.programId);
+  }
+  transfer(to, value) {
+    if (!this._program.programId) {
+      throw new Error('Program ID is not set');
+    }
+    return new _sailsJs.TransactionBuilder(this._program.api, this._program.registry, 'send_message', ['Vft', 'Transfer', to, value], '(String, String, [u8;32], U256)', 'bool', this._program.programId);
+  }
+  transferFrom(from, to, value) {
+    if (!this._program.programId) {
+      throw new Error('Program ID is not set');
+    }
+    return new _sailsJs.TransactionBuilder(this._program.api, this._program.registry, 'send_message', ['Vft', 'TransferFrom', from, to, value], '(String, String, [u8;32], [u8;32], U256)', 'bool', this._program.programId);
+  }
+  async allowance(owner, spender, originAddress, value, atBlock) {
+    const payload = this._program.registry.createType('(String, String, [u8;32], [u8;32])', ['Vft', 'Allowance', owner, spender]).toHex();
+    const reply = await this._program.api.message.calculateReply({
+      destination: this._program.programId,
+      origin: (0, _api.decodeAddress)(originAddress),
+      payload,
+      value: value || 0,
+      gasLimit: this._program.api.blockGasLimit.toBigInt(),
+      at: atBlock
+    });
+    const result = this._program.registry.createType('(String, String, U256)', reply.payload);
+    return result[2].toBigInt();
+  }
+  async balanceOf(account, originAddress, value, atBlock) {
+    const payload = this._program.registry.createType('(String, String, [u8;32])', ['Vft', 'BalanceOf', account]).toHex();
+    const reply = await this._program.api.message.calculateReply({
+      destination: this._program.programId,
+      origin: (0, _api.decodeAddress)(originAddress),
+      payload,
+      value: value || 0,
+      gasLimit: this._program.api.blockGasLimit.toBigInt(),
+      at: atBlock
+    });
+    const result = this._program.registry.createType('(String, String, U256)', reply.payload);
+    return result[2].toBigInt();
+  }
+  async decimals(originAddress, value, atBlock) {
+    const payload = this._program.registry.createType('(String, String)', ['Vft', 'Decimals']).toHex();
+    const reply = await this._program.api.message.calculateReply({
+      destination: this._program.programId,
+      origin: (0, _api.decodeAddress)(originAddress),
+      payload,
+      value: value || 0,
+      gasLimit: this._program.api.blockGasLimit.toBigInt(),
+      at: atBlock
+    });
+    const result = this._program.registry.createType('(String, String, u8)', reply.payload);
+    return result[2].toNumber();
+  }
+  async name(originAddress, value, atBlock) {
+    const payload = this._program.registry.createType('(String, String)', ['Vft', 'Name']).toHex();
+    const reply = await this._program.api.message.calculateReply({
+      destination: this._program.programId,
+      origin: (0, _api.decodeAddress)(originAddress),
+      payload,
+      value: value || 0,
+      gasLimit: this._program.api.blockGasLimit.toBigInt(),
+      at: atBlock
+    });
+    const result = this._program.registry.createType('(String, String, String)', reply.payload);
+    return result[2].toString();
+  }
+  async symbol(originAddress, value, atBlock) {
+    const payload = this._program.registry.createType('(String, String)', ['Vft', 'Symbol']).toHex();
+    const reply = await this._program.api.message.calculateReply({
+      destination: this._program.programId,
+      origin: (0, _api.decodeAddress)(originAddress),
+      payload,
+      value: value || 0,
+      gasLimit: this._program.api.blockGasLimit.toBigInt(),
+      at: atBlock
+    });
+    const result = this._program.registry.createType('(String, String, String)', reply.payload);
+    return result[2].toString();
+  }
+  async totalSupply(originAddress, value, atBlock) {
+    const payload = this._program.registry.createType('(String, String)', ['Vft', 'TotalSupply']).toHex();
+    const reply = await this._program.api.message.calculateReply({
+      destination: this._program.programId,
+      origin: (0, _api.decodeAddress)(originAddress),
+      payload,
+      value: value || 0,
+      gasLimit: this._program.api.blockGasLimit.toBigInt(),
+      at: atBlock
+    });
+    const result = this._program.registry.createType('(String, String, U256)', reply.payload);
+    return result[2].toBigInt();
+  }
+  subscribeToApprovalEvent(callback) {
+    return this._program.api.gearEvents.subscribeToGearEvent('UserMessageSent', _ref => {
+      let {
+        data: {
+          message
+        }
+      } = _ref;
+      if (!message.source.eq(this._program.programId) || !message.destination.eq(_sailsJs.ZERO_ADDRESS)) {
+        return;
+      }
+      const payload = message.payload.toHex();
+      if ((0, _sailsJs.getServiceNamePrefix)(payload) === 'Vft' && (0, _sailsJs.getFnNamePrefix)(payload) === 'Approval') {
+        // eslint-disable-next-line node/no-callback-literal,@typescript-eslint/no-floating-promises
+        callback(this._program.registry.createType('(String, String, {"owner":"[u8;32]","spender":"[u8;32]","value":"U256"})', message.payload)[2].toJSON());
+      }
+    });
+  }
+  subscribeToTransferEvent(callback) {
+    return this._program.api.gearEvents.subscribeToGearEvent('UserMessageSent', _ref2 => {
+      let {
+        data: {
+          message
+        }
+      } = _ref2;
+      if (!message.source.eq(this._program.programId) || !message.destination.eq(_sailsJs.ZERO_ADDRESS)) {
+        return;
+      }
+      const payload = message.payload.toHex();
+      if ((0, _sailsJs.getServiceNamePrefix)(payload) === 'Service' && (0, _sailsJs.getFnNamePrefix)(payload) === 'Transfer') {
+        // eslint-disable-next-line node/no-callback-literal,@typescript-eslint/no-floating-promises
+        callback(this._program.registry.createType('(String, String, {"from":"[u8;32]","to":"[u8;32]","value":"U256"})', message.payload)[2].toJSON());
+      }
+    });
+  }
+}
+exports.VftService = VftService;

package/cjs/utils/metadata.js

@@ -3,46 +3,57 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getShortMetadata = exports.getMetadataHash = exports._isRuntimeUpdated = void 0;
+exports.getShortMetadata = exports.calculateMetadataHash = exports.cacheMetadata = exports._isRuntimeUpdated = void 0;
+var _typesKnown = require("@polkadot/types-known");
+var _util = require("@polkadot/util");
+var _merkleizeMetadata2 = require("@polkadot-api/merkleize-metadata");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-const LEDGER_API_URL = 'https://ledger-api.subwallet.app';
-const createUrl = path => `${LEDGER_API_URL}/${path}`;
 const _isRuntimeUpdated = signedExtensions => {
   return signedExtensions ? signedExtensions.includes('CheckMetadataHash') : false;
 };
 exports._isRuntimeUpdated = _isRuntimeUpdated;
-const getMetadataHash = async chain => {
-  const data = {
-    id: chain
-  };
-  const resp = await fetch(createUrl('node/metadata/hash'), {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json'
-    },
-    body: JSON.stringify(data)
-  });
-  const rs = await resp.json();
-  return rs.metadataHash;
+const calculateMetadataHash = (extraInfo, metadataV15) => {
+  const _merkleizeMetadata = (0, _merkleizeMetadata2.merkleizeMetadata)(metadataV15, extraInfo);
+  return (0, _util.u8aToHex)(_merkleizeMetadata.digest());
 };
-exports.getMetadataHash = getMetadataHash;
-const getShortMetadata = async (chain, blob) => {
-  const data = {
-    chain: {
-      id: chain
-    },
-    txBlob: blob
-  };
-  const resp = await fetch(createUrl('transaction/metadata'), {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json'
-    },
-    body: JSON.stringify(data)
-  });
-  const rs = await resp.json();
-  return rs.txMetadata;
+exports.calculateMetadataHash = calculateMetadataHash;
+const getShortMetadata = (blob, extraInfo, metadata) => {
+  const _merkleizeMetadata = (0, _merkleizeMetadata2.merkleizeMetadata)(metadata, extraInfo);
+  return (0, _util.u8aToHex)(_merkleizeMetadata.getProofForExtrinsicPayload(blob));
 };
-exports.getShortMetadata = getShortMetadata;
+exports.getShortMetadata = getShortMetadata;
+const cacheMetadata = (chain, substrateApi, chainService) => {
+  // Update metadata to database with async methods
+  substrateApi.api.isReady.then(async api => {
+    const currentSpecVersion = api.runtimeVersion.specVersion.toString();
+    const specName = api.runtimeVersion.specName.toString();
+    const genesisHash = api.genesisHash.toHex();
+    const metadata = await (chainService === null || chainService === void 0 ? void 0 : chainService.getMetadata(chain));
+
+    // Avoid date existed metadata
+    if (metadata && metadata.specVersion === currentSpecVersion && metadata.genesisHash === genesisHash) {
+      return;
+    }
+    const systemChain = await api.rpc.system.chain();
+    // const _metadata: Option<OpaqueMetadata> = await api.call.metadata.metadataAtVersion(15);
+    // const metadataHex = _metadata.isSome ? _metadata.unwrap().toHex().slice(2) : ''; // Need unwrap to create metadata object
+    let hexV15;
+    const metadataV15 = await api.call.metadata.metadataAtVersion(15);
+    if (!metadataV15.isEmpty) {
+      hexV15 = metadataV15.unwrap().toHex();
+    }
+    chainService === null || chainService === void 0 ? void 0 : chainService.upsertMetadata(chain, {
+      chain: chain,
+      genesisHash: genesisHash,
+      specName: specName,
+      specVersion: currentSpecVersion,
+      hexValue: api.runtimeMetadata.toHex(),
+      types: (0, _typesKnown.getSpecTypes)(api.registry, systemChain, api.runtimeVersion.specName, api.runtimeVersion.specVersion),
+      userExtensions: (0, _typesKnown.getSpecExtensions)(api.registry, systemChain, api.runtimeVersion.specName),
+      hexV15
+    }).catch(console.error);
+  }).catch(console.error);
+};
+exports.cacheMetadata = cacheMetadata;

package/constants/staking.js

@@ -13,6 +13,7 @@ export const PREDEFINED_EARNING_POOL = {
   kusama: [80],
   vara_network: [62, 29, 50],
   aleph: [82],
-  availTuringTest: [11]
+  availTuringTest: [11],
+  avail_mainnet: [4]
 };
 export const MAX_NOMINATIONS = '16';

package/koni/api/staking/bonding/utils.d.ts

@@ -162,6 +162,7 @@ export declare function getSupportedDaysByHistoryDepth(erasPerDay: number, maxSu
 export declare function getRelayValidatorPointsMap(eraRewardMap: Record<string, PalletStakingEraRewardPoints>): Record<string, BigNumber>;
 export declare function getRelayTopValidatorByPoints(validatorPointsList: Record<string, BigNumber>): string[];
 export declare function getRelayBlockedValidatorList(validators: any[]): string[];
+export declare function getRelayWaitingValidatorList(validators: any[]): string[];
 export declare function getRelayEraRewardMap(eraRewardPointArray: Codec[], startEraForPoints: number): Record<string, PalletStakingEraRewardPoints>;
 export declare function getRelayMaxNominations(substrateApi: _SubstrateApi): Promise<string>;
 export declare const getMinStakeErrorMessage: (chainInfo: _ChainInfo, bnMinStake: BN) => string;

package/koni/api/staking/bonding/utils.js

@@ -393,6 +393,20 @@ export function getRelayBlockedValidatorList(validators) {
   }
   return blockValidatorList;
 }
+export function getRelayWaitingValidatorList(validators) {
+  const waitingValidators = [];
+  for (const validator of validators) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    const validatorAddress = validator[0].toHuman()[0];
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    const validatorPrefs = validator[1].toHuman();
+    const isBlocked = validatorPrefs.blocked;
+    if (!isBlocked) {
+      waitingValidators.push(validatorAddress);
+    }
+  }
+  return waitingValidators;
+}
 export function getRelayEraRewardMap(eraRewardPointArray, startEraForPoints) {
   const eraRewardMap = {};
   for (const item of eraRewardPointArray) {

package/koni/background/handlers/Extension.d.ts

@@ -219,6 +219,8 @@ export default class KoniExtension {
     private subscribeMantaPayConfig;
     private subscribeMantaPaySyncState;
     private findRawMetadata;
+    private calculateMetadataHash;
+    private shortenMetadata;
     private resolveDomainByAddress;
     private resolveAddressByDomain;
     private addInjects;

package/koni/background/handlers/Extension.js

@@ -3632,7 +3632,7 @@ export default class KoniExtension {
     };
   }
 
-  /// Metadata
+  /* Metadata */
 
   async findRawMetadata({
     genesisHash
@@ -3650,6 +3650,26 @@ export default class KoniExtension {
       userExtensions
     };
   }
+  async calculateMetadataHash({
+    chain
+  }) {
+    const hash = await this.#koniState.calculateMetadataHash(chain);
+    return {
+      metadataHash: hash || ''
+    };
+  }
+  async shortenMetadata({
+    chain,
+    txBlob
+  }) {
+    const shorten = await this.#koniState.shortenMetadata(chain, txBlob);
+    return {
+      txMetadata: shorten || ''
+    };
+  }
+
+  /* Metadata */
+
   async resolveDomainByAddress(request) {
     const chainApi = this.#koniState.getSubstrateApi(request.chain);
     return await resolveAzeroDomainToAddress(request.domain, request.chain, chainApi.api);
@@ -4587,6 +4607,10 @@ export default class KoniExtension {
       // Metadata
       case 'pri(metadata.find)':
         return this.findRawMetadata(request);
+      case 'pri(metadata.hash)':
+        return this.calculateMetadataHash(request);
+      case 'pri(metadata.transaction.shorten)':
+        return this.shortenMetadata(request);
 
       /* Campaign */
       case 'pri(campaign.banner.subscribe)':

package/koni/background/handlers/State.d.ts

@@ -258,6 +258,8 @@ export default class KoniState {
         types: Record<string, string | Record<string, string>>;
         userExtensions: import("@polkadot/types/extrinsic/signedExtensions/types").ExtDef | undefined;
     }>;
+    calculateMetadataHash(chain: string): Promise<string | undefined>;
+    shortenMetadata(chain: string, txBlob: string): Promise<string | undefined>;
     getCrowdloanContributions({ address, page, relayChain }: RequestCrowdloanContributions): Promise<import("../../../services/subscan-service/types").CrowdloanContributionsResponse>;
 }
 export {};

package/koni/background/handlers/State.js

@@ -1789,7 +1789,8 @@ export default class KoniState {
     return (_this$chainService34 = this.chainService) === null || _this$chainService34 === void 0 ? void 0 : (_this$chainService34$ = _this$chainService34.mantaPay) === null || _this$chainService34$ === void 0 ? void 0 : _this$chainService34$.subscribeSyncState();
   }
 
-  // Metadata
+  /* Metadata */
+
   async findMetadata(hash) {
     const metadata = await this.chainService.getMetadataByHash(hash);
     return {
@@ -1799,6 +1800,15 @@ export default class KoniState {
       userExtensions: metadata === null || metadata === void 0 ? void 0 : metadata.userExtensions
     };
   }
+  async calculateMetadataHash(chain) {
+    return this.chainService.calculateMetadataHash(chain);
+  }
+  async shortenMetadata(chain, txBlob) {
+    return this.chainService.shortenMetadata(chain, txBlob);
+  }
+
+  /* Metadata */
+
   getCrowdloanContributions({
     address,
     page,

package/package.json

@@ -17,7 +17,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "1.2.15-0",
+  "version": "1.2.17-0",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -559,6 +559,11 @@
       "require": "./cjs/services/balance-service/helpers/subscribe/substrate/equilibrium.js",
       "default": "./services/balance-service/helpers/subscribe/substrate/equilibrium.js"
     },
+    "./services/balance-service/helpers/subscribe/substrate/gear": {
+      "types": "./services/balance-service/helpers/subscribe/substrate/gear.d.ts",
+      "require": "./cjs/services/balance-service/helpers/subscribe/substrate/gear.js",
+      "default": "./services/balance-service/helpers/subscribe/substrate/gear.js"
+    },
     "./services/balance-service/transfer/smart-contract": {
       "types": "./services/balance-service/transfer/smart-contract.d.ts",
       "require": "./cjs/services/balance-service/transfer/smart-contract.js",
@@ -1881,11 +1886,21 @@
       "require": "./cjs/utils/gear/index.js",
       "default": "./utils/gear/index.js"
     },
+    "./utils/gear/combine": {
+      "types": "./utils/gear/combine.d.ts",
+      "require": "./cjs/utils/gear/combine.js",
+      "default": "./utils/gear/combine.js"
+    },
     "./utils/gear/grc20": {
       "types": "./utils/gear/grc20.d.ts",
       "require": "./cjs/utils/gear/grc20.js",
       "default": "./utils/gear/grc20.js"
     },
+    "./utils/gear/vft": {
+      "types": "./utils/gear/vft.d.ts",
+      "require": "./cjs/utils/gear/vft.js",
+      "default": "./utils/gear/vft.js"
+    },
     "./utils/getId": {
       "types": "./utils/getId.d.ts",
       "require": "./cjs/utils/getId.js",
@@ -1969,11 +1984,12 @@
     "@ethereumjs/tx": "^5.1.0",
     "@ethersproject/abi": "^5.7.0",
     "@galacticcouncil/sdk": "^2.1.0",
-    "@gear-js/api": "^0.37.2",
+    "@gear-js/api": "^0.38.1",
     "@json-rpc-tools/utils": "^1.7.6",
     "@metamask/safe-event-emitter": "^2.0.0",
     "@metaverse-network-sdk/type-definitions": "^0.0.1-13",
     "@oak-foundation/types": "^0.0.23",
+    "@polkadot-api/merkleize-metadata": "^1.1.0",
     "@polkadot/api": "^11.0.3",
     "@polkadot/api-base": "^10.11.2",
     "@polkadot/api-contract": "^11.0.3",
@@ -1993,11 +2009,11 @@
     "@reduxjs/toolkit": "^1.9.1",
     "@sora-substrate/type-definitions": "^1.17.7",
     "@substrate/connect": "^0.8.9",
-    "@subwallet/chain-list": "0.2.74",
-    "@subwallet/extension-base": "^1.2.15-0",
-    "@subwallet/extension-chains": "^1.2.15-0",
-    "@subwallet/extension-dapp": "^1.2.15-0",
-    "@subwallet/extension-inject": "^1.2.15-0",
+    "@subwallet/chain-list": "0.2.75",
+    "@subwallet/extension-base": "^1.2.17-0",
+    "@subwallet/extension-chains": "^1.2.17-0",
+    "@subwallet/extension-dapp": "^1.2.17-0",
+    "@subwallet/extension-inject": "^1.2.17-0",
     "@subwallet/keyring": "^0.1.5",
     "@subwallet/ui-keyring": "^0.1.5",
     "@walletconnect/keyvaluestorage": "^1.1.1",
@@ -2026,7 +2042,7 @@
     "moment": "^2.29.4",
     "protobufjs": "^7.2.4",
     "rxjs": "^7.8.1",
-    "sails-js": "^0.1.3",
+    "sails-js": "^0.1.6",
     "uuid": "^9.0.0",
     "web3": "^1.10.0",
     "web3-core": "^1.10.0",

package/packageInfo.js

@@ -7,5 +7,5 @@ export const packageInfo = {
   name: '@subwallet/extension-base',
   path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto',
   type: 'esm',
-  version: '1.2.15-0'
+  version: '1.2.17-0'
 };

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

@@ -82,7 +82,7 @@ export function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _cha
     const chainSlug = chainInfo.slug;
     const [useAddresses, notSupportAddresses] = filterAddress(addresses, chainInfo);
     if (notSupportAddresses.length) {
-      const tokens = filterAssetsByChainAndType(chainAssetMap, chainSlug, [_AssetType.NATIVE, _AssetType.ERC20, _AssetType.PSP22, _AssetType.LOCAL, _AssetType.GRC20]);
+      const tokens = filterAssetsByChainAndType(chainAssetMap, chainSlug, [_AssetType.NATIVE, _AssetType.ERC20, _AssetType.PSP22, _AssetType.LOCAL, _AssetType.GRC20, _AssetType.VFT]);
       const now = new Date().getTime();
       Object.values(tokens).forEach(token => {
         const items = notSupportAddresses.map(address => ({

package/services/balance-service/helpers/subscribe/substrate/gear.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="filesystem" />
+import { SubscribeSubstratePalletBalance } from '@subwallet/extension-base/types';
+export declare const subscribeGRC20Balance: ({ addresses, assetMap, callback, chainInfo, substrateApi }: SubscribeSubstratePalletBalance) => VoidCallback;
+export declare const subscribeVftBalance: ({ addresses, assetMap, callback, chainInfo, substrateApi }: SubscribeSubstratePalletBalance) => VoidCallback;

package/services/balance-service/helpers/subscribe/substrate/gear.js

@@ -0,0 +1,123 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { GearApi } from '@gear-js/api';
+import { _AssetType } from '@subwallet/chain-list/types';
+import { APIItemState } from '@subwallet/extension-base/background/KoniTypes';
+import { SUB_TOKEN_REFRESH_BALANCE_INTERVAL } from '@subwallet/extension-base/constants';
+import { _getContractAddressOfToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { filterAssetsByChainAndType, getGRC20ContractPromise, getVFTContractPromise } from '@subwallet/extension-base/utils';
+import { noop, u8aToHex } from '@polkadot/util';
+import { decodeAddress } from '@polkadot/util-crypto';
+export const subscribeGRC20Balance = ({
+  addresses,
+  assetMap,
+  callback,
+  chainInfo,
+  substrateApi
+}) => {
+  if (!(substrateApi instanceof GearApi)) {
+    console.warn('Cannot subscribe GRC20 balance without GearApi instance');
+    return noop;
+  }
+  const chain = chainInfo.slug;
+  const grc20ContractMap = {};
+  const tokenList = filterAssetsByChainAndType(assetMap, chain, [_AssetType.GRC20]);
+  Object.entries(tokenList).forEach(([slug, tokenInfo]) => {
+    grc20ContractMap[slug] = getGRC20ContractPromise(substrateApi, _getContractAddressOfToken(tokenInfo));
+  });
+  const getTokenBalances = () => {
+    Object.values(tokenList).map(async tokenInfo => {
+      try {
+        const contract = grc20ContractMap[tokenInfo.slug];
+        const balances = await Promise.all(addresses.map(async address => {
+          try {
+            const actor = u8aToHex(decodeAddress(address));
+            const _balanceOf = await contract.service.balanceOf(actor, address);
+            return {
+              address: address,
+              tokenSlug: tokenInfo.slug,
+              free: _balanceOf.toString(10),
+              locked: '0',
+              state: APIItemState.READY
+            };
+          } catch (err) {
+            console.error(`Error on get balance of account ${address} for token ${tokenInfo.slug}`, err);
+            return {
+              address: address,
+              tokenSlug: tokenInfo.slug,
+              free: '0',
+              locked: '0',
+              state: APIItemState.READY
+            };
+          }
+        }));
+        callback(balances);
+      } catch (err) {
+        console.warn(tokenInfo.slug, err); // TODO: error createType
+      }
+    });
+  };
+
+  getTokenBalances();
+  const interval = setInterval(getTokenBalances, SUB_TOKEN_REFRESH_BALANCE_INTERVAL);
+  return () => {
+    clearInterval(interval);
+  };
+};
+export const subscribeVftBalance = ({
+  addresses,
+  assetMap,
+  callback,
+  chainInfo,
+  substrateApi
+}) => {
+  if (!(substrateApi instanceof GearApi)) {
+    console.warn('Cannot subscribe VFT balance without GearApi instance');
+    return noop;
+  }
+  const chain = chainInfo.slug;
+  const vftContractMap = {};
+  const tokenList = filterAssetsByChainAndType(assetMap, chain, [_AssetType.VFT]);
+  Object.entries(tokenList).forEach(([slug, tokenInfo]) => {
+    vftContractMap[slug] = getVFTContractPromise(substrateApi, _getContractAddressOfToken(tokenInfo));
+  });
+  const getTokenBalances = () => {
+    Object.values(tokenList).map(async tokenInfo => {
+      try {
+        const contract = vftContractMap[tokenInfo.slug];
+        const balances = await Promise.all(addresses.map(async address => {
+          try {
+            const actor = u8aToHex(decodeAddress(address));
+            const _balanceOf = await contract.service.balanceOf(actor, address);
+            return {
+              address: address,
+              tokenSlug: tokenInfo.slug,
+              free: _balanceOf.toString(10),
+              locked: '0',
+              state: APIItemState.READY
+            };
+          } catch (err) {
+            console.error(`Error on get balance of account ${address} for token ${tokenInfo.slug}`, err);
+            return {
+              address: address,
+              tokenSlug: tokenInfo.slug,
+              free: '0',
+              locked: '0',
+              state: APIItemState.READY
+            };
+          }
+        }));
+        callback(balances);
+      } catch (err) {
+        console.warn(tokenInfo.slug, err); // TODO: error createType
+      }
+    });
+  };
+
+  getTokenBalances();
+  const interval = setInterval(getTokenBalances, SUB_TOKEN_REFRESH_BALANCE_INTERVAL);
+  return () => {
+    clearInterval(interval);
+  };
+};