@subwallet/extension-base 0.8.3-2 → 1.0.1

package/koni/api/staking/paraChain.js

@@ -0,0 +1,216 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { APIItemState, StakingType } from '@subwallet/extension-base/background/KoniTypes';
+import { _STAKING_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
+import { _getChainNativeTokenBasicInfo } from '@subwallet/extension-base/services/chain-service/utils';
+import { reformatAddress } from '@subwallet/extension-base/utils';
+import { BN, BN_ZERO } from '@polkadot/util';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+function getSingleStakingAmplitude(parentApi, address, networks, chain, callback) {
+  return parentApi.api.queryMulti([[parentApi.api.query.parachainStaking.delegatorState, address], [parentApi.api.query.parachainStaking.unstaking, address]], ([_delegatorState, _unstaking]) => {
+    const _stakingData = _delegatorState.toHuman();
+    const _unstakingData = _unstaking.toHuman();
+    let _activeBalance = '0';
+    if (_stakingData !== null) {
+      _activeBalance = _stakingData.amount || _stakingData.total;
+      _activeBalance = _activeBalance.replaceAll(',', '');
+    }
+    const activeBalance = new BN(_activeBalance);
+    let unstakingBalance = BN_ZERO;
+    if (_unstakingData !== null) {
+      Object.values(_unstakingData).forEach(_unstakingAmount => {
+        const bnUnstakingAmount = new BN(_unstakingAmount.replaceAll(',', ''));
+        unstakingBalance = unstakingBalance.add(bnUnstakingAmount);
+      });
+    }
+    const totalBalance = activeBalance.add(unstakingBalance);
+    const {
+      symbol
+    } = _getChainNativeTokenBasicInfo(networks[chain]);
+    const stakingItem = {
+      name: networks[chain].name,
+      chain: chain,
+      balance: totalBalance.toString(),
+      activeBalance: activeBalance.toString(),
+      unlockingBalance: unstakingBalance.toString(),
+      nativeToken: symbol,
+      unit: symbol,
+      state: APIItemState.READY,
+      type: StakingType.NOMINATED,
+      address
+    };
+    callback(chain, stakingItem);
+  });
+}
+function getMultiStakingAmplitude(parentApi, useAddresses, networks, chain, callback) {
+  return parentApi.api.query.parachainStaking.delegatorState.multi(useAddresses, async ledgers => {
+    if (ledgers) {
+      const _unstakingStates = await parentApi.api.query.parachainStaking.unstaking.multi(useAddresses);
+      for (let i = 0; i < ledgers.length; i++) {
+        const ledger = ledgers[i];
+        const _unstakingData = _unstakingStates[i].toHuman();
+        const owner = reformatAddress(useAddresses[i], 42);
+        const _stakingData = ledger.toHuman();
+        let _activeBalance = '0';
+        if (_stakingData !== null) {
+          _activeBalance = _stakingData.amount || _stakingData.total;
+          _activeBalance = _activeBalance.replaceAll(',', '');
+        }
+        const activeBalance = new BN(_activeBalance);
+        let unstakingBalance = BN_ZERO;
+        if (_unstakingData !== null) {
+          Object.values(_unstakingData).forEach(_unstakingAmount => {
+            const bnUnstakingAmount = new BN(_unstakingAmount.replaceAll(',', ''));
+            unstakingBalance = unstakingBalance.add(bnUnstakingAmount);
+          });
+        }
+        const totalBalance = activeBalance.add(unstakingBalance);
+        const {
+          symbol
+        } = _getChainNativeTokenBasicInfo(networks[chain]);
+        const stakingItem = {
+          name: networks[chain].name,
+          chain: chain,
+          balance: totalBalance.toString(),
+          activeBalance: activeBalance.toString(),
+          unlockingBalance: unstakingBalance.toString(),
+          nativeToken: symbol,
+          unit: symbol,
+          state: APIItemState.READY,
+          type: StakingType.NOMINATED,
+          address: owner
+        };
+        callback(chain, stakingItem);
+      }
+    }
+  });
+}
+export function getAmplitudeStakingOnChain(parentApi, useAddresses, networks, chain, callback) {
+  if (useAddresses.length === 1) {
+    return getSingleStakingAmplitude(parentApi, useAddresses[0], networks, chain, callback);
+  }
+  return getMultiStakingAmplitude(parentApi, useAddresses, networks, chain, callback);
+}
+export async function getAmplitudeUnclaimedStakingReward(substrateApiMap, addresses, networks, chains) {
+  if (chains.length === 0) {
+    return [];
+  }
+  const useAddresses = [];
+  addresses.forEach(address => {
+    if (!isEthereumAddress(address)) {
+      useAddresses.push(address);
+    }
+  });
+  const unclaimedRewardList = [];
+  await Promise.all(chains.map(async chain => {
+    if (_STAKING_CHAIN_GROUP.amplitude.includes(chain) && !_STAKING_CHAIN_GROUP.kilt.includes(chain)) {
+      const networkInfo = networks[chain];
+      const apiProps = await substrateApiMap[chain].isReady;
+      await Promise.all(useAddresses.map(async address => {
+        const _unclaimedReward = await apiProps.api.query.parachainStaking.rewards(address);
+        const unclaimedReward = _unclaimedReward.toString();
+        const rewardItem = {
+          chain,
+          name: networkInfo.name,
+          state: APIItemState.READY,
+          type: StakingType.NOMINATED,
+          address: reformatAddress(address, 42),
+          unclaimedReward
+        };
+        unclaimedRewardList.push(rewardItem);
+      }));
+    }
+  }));
+  return unclaimedRewardList;
+}
+export function getParaStakingOnChain(parentApi, useAddresses, networks, chain, callback) {
+  const {
+    symbol
+  } = _getChainNativeTokenBasicInfo(networks[chain]);
+  return parentApi.api.query.parachainStaking.delegatorState.multi(useAddresses, ledgers => {
+    if (ledgers) {
+      for (let i = 0; i < ledgers.length; i++) {
+        const ledger = ledgers[i];
+        const owner = reformatAddress(useAddresses[i], 42);
+        const data = ledger.toHuman();
+        if (data !== null) {
+          let _totalBalance = data.total;
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          let _unlockingBalance = data.lessTotal ? data.lessTotal : data.requests.lessTotal;
+          _totalBalance = _totalBalance.replaceAll(',', '');
+          _unlockingBalance = _unlockingBalance.replaceAll(',', '');
+          const totalBalance = new BN(_totalBalance);
+          const unlockingBalance = new BN(_unlockingBalance);
+          const activeBalance = totalBalance.sub(unlockingBalance);
+          const stakingItem = {
+            name: networks[chain].name,
+            chain: chain,
+            balance: totalBalance.toString(),
+            activeBalance: activeBalance.toString(),
+            unlockingBalance: unlockingBalance.toString(),
+            nativeToken: symbol,
+            unit: symbol,
+            state: APIItemState.READY,
+            type: StakingType.NOMINATED,
+            address: owner
+          };
+          callback(chain, stakingItem);
+        } else {
+          const stakingItem = {
+            name: networks[chain].name,
+            chain: chain,
+            balance: '0',
+            activeBalance: '0',
+            unlockingBalance: '0',
+            nativeToken: symbol,
+            unit: symbol,
+            state: APIItemState.READY,
+            type: StakingType.NOMINATED,
+            address: owner
+          };
+          callback(chain, stakingItem);
+        }
+      }
+    }
+  });
+}
+export function getAstarStakingOnChain(parentApi, useAddresses, networks, chain, callback) {
+  const {
+    symbol
+  } = _getChainNativeTokenBasicInfo(networks[chain]);
+  return parentApi.api.query.dappsStaking.ledger.multi(useAddresses, ledgers => {
+    if (ledgers) {
+      for (let i = 0; i < ledgers.length; i++) {
+        let bnUnlockingBalance = BN_ZERO;
+        const owner = reformatAddress(useAddresses[i], 42);
+        const ledger = ledgers[i];
+        const data = ledger.toHuman();
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        const unlockingChunks = data.unbondingInfo.unlockingChunks;
+        const _totalStake = data.locked;
+        for (const chunk of unlockingChunks) {
+          const bnChunk = new BN(chunk.amount.replaceAll(',', ''));
+          bnUnlockingBalance = bnUnlockingBalance.add(bnChunk);
+        }
+        const bnTotalStake = new BN(_totalStake.replaceAll(',', ''));
+        const bnActiveStake = bnTotalStake.sub(bnUnlockingBalance);
+        const stakingItem = {
+          name: networks[chain].name,
+          chain: chain,
+          balance: bnTotalStake.toString(),
+          activeBalance: bnActiveStake.toString(),
+          unlockingBalance: bnUnlockingBalance.toString(),
+          nativeToken: symbol,
+          unit: symbol,
+          state: APIItemState.READY,
+          type: StakingType.NOMINATED,
+          address: owner
+        };
+
+        // eslint-disable-next-line node/no-callback-literal
+        callback(chain, stakingItem);
+      }
+    }
+  });
+}

package/koni/api/staking/relayChain.d.ts

@@ -0,0 +1,6 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { StakingItem, StakingRewardItem } from '@subwallet/extension-base/background/KoniTypes';
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+export declare function getRelayStakingOnChain(substrateApi: _SubstrateApi, useAddresses: string[], chainInfoMap: Record<string, _ChainInfo>, chain: string, callback: (networkKey: string, rs: StakingItem) => void): import("@polkadot/api-base/types").UnsubscribePromise;
+export declare function getRelayPoolingOnChain(parentApi: _SubstrateApi, useAddresses: string[], networks: Record<string, _ChainInfo>, chain: string, callback: (networkKey: string, rs: StakingItem) => void): import("@polkadot/api-base/types").UnsubscribePromise;
+export declare function getNominationPoolReward(addresses: string[], chainInfoMap: Record<string, _ChainInfo>, substrateApiMap: Record<string, _SubstrateApi>): Promise<StakingRewardItem[]>;

package/koni/api/staking/relayChain.js

@@ -0,0 +1,161 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { APIItemState, StakingType } from '@subwallet/extension-base/background/KoniTypes';
+import { _getChainNativeTokenBasicInfo } from '@subwallet/extension-base/services/chain-service/utils';
+import { reformatAddress } from '@subwallet/extension-base/utils';
+import { BN } from '@polkadot/util';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+export function getRelayStakingOnChain(substrateApi, useAddresses, chainInfoMap, chain, callback) {
+  var _substrateApi$api$que;
+  const {
+    symbol
+  } = _getChainNativeTokenBasicInfo(chainInfoMap[chain]);
+  return (_substrateApi$api$que = substrateApi.api.query.staking) === null || _substrateApi$api$que === void 0 ? void 0 : _substrateApi$api$que.ledger.multi(useAddresses, ledgers => {
+    let unit = '';
+    if (ledgers) {
+      for (let i = 0; i < ledgers.length; i++) {
+        const ledger = ledgers[i];
+        const owner = reformatAddress(useAddresses[i], 42) || undefined;
+        const data = ledger.toHuman();
+        if (data && data.active) {
+          const _totalBalance = data.total;
+          const _activeBalance = data.active;
+          let bnUnlockingBalance = new BN(0);
+          data.unlocking.forEach(({
+            value
+          }) => {
+            value = value.split(' ')[0];
+            const _unlockingBalance = value.replaceAll(',', '');
+            bnUnlockingBalance = bnUnlockingBalance.add(new BN(_unlockingBalance));
+          });
+          let amount = _totalBalance ? _totalBalance.split(' ')[0] : '';
+          amount = amount.replaceAll(',', '');
+          unit = _totalBalance ? _totalBalance.split(' ')[1] : '';
+          const bnTotalBalance = new BN(amount);
+          amount = _activeBalance ? _activeBalance.split(' ')[0] : '';
+          amount = amount.replaceAll(',', '');
+          unit = _activeBalance ? _activeBalance.split(' ')[1] : '';
+          const bnActiveBalance = new BN(amount);
+          const stakingItem = {
+            name: chainInfoMap[chain].name,
+            chain: chain,
+            balance: bnTotalBalance.toString(),
+            activeBalance: bnActiveBalance.toString(),
+            unlockingBalance: bnUnlockingBalance.toString(),
+            nativeToken: symbol,
+            unit: unit || symbol,
+            state: APIItemState.READY,
+            type: StakingType.NOMINATED,
+            address: owner
+          };
+          callback(chain, stakingItem);
+        } else {
+          const stakingItem = {
+            name: chainInfoMap[chain].name,
+            chain: chain,
+            balance: '0',
+            activeBalance: '0',
+            unlockingBalance: '0',
+            nativeToken: symbol,
+            unit: unit || symbol,
+            state: APIItemState.READY,
+            type: StakingType.NOMINATED,
+            address: owner
+          };
+          callback(chain, stakingItem);
+        }
+      }
+    }
+  });
+}
+export function getRelayPoolingOnChain(parentApi, useAddresses, networks, chain, callback) {
+  var _parentApi$api$query, _parentApi$api$query$;
+  const {
+    symbol
+  } = _getChainNativeTokenBasicInfo(networks[chain]);
+  return (_parentApi$api$query = parentApi.api.query) === null || _parentApi$api$query === void 0 ? void 0 : (_parentApi$api$query$ = _parentApi$api$query.nominationPools) === null || _parentApi$api$query$ === void 0 ? void 0 : _parentApi$api$query$.poolMembers.multi(useAddresses, ledgers => {
+    if (ledgers) {
+      for (let i = 0; i < ledgers.length; i++) {
+        const ledger = ledgers[i];
+        const owner = reformatAddress(useAddresses[i], 42);
+        const data = ledger.toHuman();
+        if (data !== null) {
+          const bondedBalance = data.points;
+          const unbondedBalance = data.unbondingEras;
+          let unlockingBalance = new BN(0);
+          let totalBalance = new BN(0);
+          Object.entries(unbondedBalance).forEach(([era, value]) => {
+            const bnUnbondedBalance = new BN(value.replaceAll(',', ''));
+            unlockingBalance = unlockingBalance.add(bnUnbondedBalance);
+          });
+          const bnBondedBalance = new BN(bondedBalance.replaceAll(',', ''));
+          totalBalance = totalBalance.add(bnBondedBalance).add(unlockingBalance);
+          const stakingItem = {
+            name: networks[chain].name,
+            chain: chain,
+            balance: totalBalance.toString(),
+            activeBalance: bnBondedBalance.toString(),
+            unlockingBalance: unlockingBalance.toString(),
+            nativeToken: symbol,
+            unit: symbol,
+            state: APIItemState.READY,
+            type: StakingType.POOLED,
+            address: owner
+          };
+          callback(chain, stakingItem);
+        } else {
+          const stakingItem = {
+            name: networks[chain].name,
+            chain: chain,
+            balance: '0',
+            activeBalance: '0',
+            unlockingBalance: '0',
+            nativeToken: symbol,
+            unit: symbol,
+            state: APIItemState.READY,
+            type: StakingType.POOLED,
+            address: owner
+          };
+          callback(chain, stakingItem);
+        }
+      }
+    }
+  });
+}
+export async function getNominationPoolReward(addresses, chainInfoMap, substrateApiMap) {
+  const targetNetworks = [];
+  const validAddresses = [];
+  Object.keys(chainInfoMap).forEach(key => {
+    targetNetworks.push(key);
+  });
+  addresses.forEach(address => {
+    if (!isEthereumAddress(address)) {
+      validAddresses.push(address);
+    }
+  });
+  const rewardList = [];
+  try {
+    await Promise.all(targetNetworks.map(async networkKey => {
+      const substrateApi = await substrateApiMap[networkKey].isReady;
+      await Promise.all(validAddresses.map(async address => {
+        var _substrateApi$api$cal, _substrateApi$api$cal2;
+        const _unclaimedReward = await ((_substrateApi$api$cal = substrateApi.api.call) === null || _substrateApi$api$cal === void 0 ? void 0 : (_substrateApi$api$cal2 = _substrateApi$api$cal.nominationPoolsApi) === null || _substrateApi$api$cal2 === void 0 ? void 0 : _substrateApi$api$cal2.pendingRewards(address));
+        if (_unclaimedReward) {
+          rewardList.push({
+            address: address,
+            chain: networkKey,
+            unclaimedReward: _unclaimedReward.toString(),
+            name: chainInfoMap[networkKey].name,
+            state: APIItemState.READY,
+            type: StakingType.POOLED
+          });
+        }
+      }));
+    }));
+  } catch (e) {
+    console.error('Error fetching unclaimed reward for nomination pool', e);
+    return rewardList;
+  }
+  return rewardList;
+}

package/koni/api/staking/subsquidStaking.d.ts

@@ -0,0 +1,3 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { StakingRewardItem } from '@subwallet/extension-base/background/KoniTypes';
+export declare const getAllSubsquidStaking: (accounts: string[], chainInfoMap: Record<string, _ChainInfo>) => Promise<StakingRewardItem[]>;

package/koni/api/staking/subsquidStaking.js

@@ -0,0 +1,101 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { APIItemState, StakingType } from '@subwallet/extension-base/background/KoniTypes';
+import { INDEXER_SUPPORTED_STAKING_CHAINS, SUBSQUID_ENDPOINTS } from '@subwallet/extension-base/koni/api/staking/config';
+import { _getChainSubstrateAddressPrefix, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { reformatAddress } from '@subwallet/extension-base/utils';
+import axios from 'axios';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+const getSubsquidQuery = (account, chain) => {
+  if (chain === 'moonbeam' || chain === 'moonriver' || chain === 'astar') {
+    return `
+    query MyQuery {
+      stakerById(id: "${account}") {
+        totalReward
+        activeBond
+        rewards(limit: 1, orderBy: blockNumber_DESC) {
+          amount
+        }
+      }
+    }`;
+  }
+  return `
+  query MyQuery {
+    stakerById(id: "${account}") {
+      totalReward
+      totalSlash
+      activeBond
+      rewards(limit: 1, orderBy: blockNumber_DESC) {
+        amount
+      }
+    }
+  }`;
+};
+const getSubsquidStaking = async (accounts, chain, chainInfoMap) => {
+  try {
+    const result = [];
+    await Promise.all(accounts.map(async account => {
+      if (_isChainEvmCompatible(chainInfoMap[chain]) && isEthereumAddress(account) || !_isChainEvmCompatible(chainInfoMap[chain]) && !isEthereumAddress(account)) {
+        const parsedAccount = reformatAddress(account, _getChainSubstrateAddressPrefix(chainInfoMap[chain]));
+        const stakingRewardItem = {
+          chain: chain,
+          name: chainInfoMap[chain].name,
+          state: APIItemState.READY,
+          type: StakingType.NOMINATED,
+          address: reformatAddress(account, 42)
+        };
+        const resp = await axios({
+          url: SUBSQUID_ENDPOINTS[chain],
+          method: 'post',
+          data: {
+            query: getSubsquidQuery(parsedAccount, chain)
+          }
+        });
+        if (resp.status === 200) {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          const respData = resp.data.data;
+          const rewardItem = respData.stakerById;
+          if (rewardItem) {
+            const latestReward = rewardItem.rewards[0];
+            if (rewardItem.totalReward) {
+              stakingRewardItem.totalReward = rewardItem.totalReward;
+            }
+            if (rewardItem.totalSlash) {
+              stakingRewardItem.totalSlash = rewardItem.totalSlash;
+            }
+            if (latestReward && latestReward.amount) {
+              stakingRewardItem.latestReward = latestReward.amount;
+            }
+          }
+        }
+        if (stakingRewardItem.totalReward && parseFloat(stakingRewardItem.totalReward) > 0) {
+          result.push(stakingRewardItem);
+        }
+      }
+    }));
+    return result;
+  } catch (e) {
+    console.error(`error getting ${chain} staking reward from subsquid`, e);
+    return [];
+  }
+};
+export const getAllSubsquidStaking = async (accounts, chainInfoMap) => {
+  let rewardList = [];
+  const filteredNetworks = [];
+  Object.values(chainInfoMap).forEach(network => {
+    if (INDEXER_SUPPORTED_STAKING_CHAINS.includes(network.slug)) {
+      filteredNetworks.push(network.slug);
+    }
+  });
+  try {
+    await Promise.all(filteredNetworks.map(async network => {
+      const rewardItems = await getSubsquidStaking(accounts, network, chainInfoMap);
+      rewardList = rewardList.concat(rewardItems);
+    }));
+  } catch (e) {
+    console.error('Error fetching staking reward from SubSquid', e);
+    return rewardList;
+  }
+  return rewardList;
+};

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

@@ -0,0 +1,2 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+export declare function parseStakingBalance(balance: number, chain: string, network: Record<string, _ChainInfo>): number;

package/koni/api/staking/utils.js

@@ -0,0 +1,11 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { _getChainNativeTokenBasicInfo } from '@subwallet/extension-base/services/chain-service/utils';
+import { toUnit } from '@subwallet/extension-base/utils';
+export function parseStakingBalance(balance, chain, network) {
+  const {
+    decimals
+  } = _getChainNativeTokenBasicInfo(network[chain]);
+  return toUnit(balance, decimals);
+}

package/koni/api/subquery/__generated__/DotSamaHistory.d.ts

@@ -0,0 +1,58 @@
+export interface DotSamaHistory_historyElements_nodes {
+    __typename: "HistoryElement";
+    id: string;
+    blockNumber: number;
+    extrinsicIdx: number | null;
+    extrinsicHash: string | null;
+    timestamp: any;
+    address: string;
+    reward: any | null;
+    extrinsic: any | null;
+    transfer: any | null;
+}
+export interface DotSamaHistory_historyElements {
+    __typename: "HistoryElementsConnection";
+    /**
+     * A list of `HistoryElement` objects.
+     */
+    nodes: (DotSamaHistory_historyElements_nodes | null)[];
+}
+export interface DotSamaHistory_transfers_nodes {
+    __typename: "SubsquidTransfersElement";
+    from: {
+        id: string;
+    };
+    to: {
+        id: string;
+    };
+    asset: {
+        amount: string;
+    };
+    success: boolean | false;
+    fee: string;
+    id: string;
+    blockNumber: number;
+    extrinsicHash: string | null;
+    timestamp: any;
+    address: string;
+    reward: any | null;
+    extrinsic: any | null;
+    transfer: any | null;
+}
+export interface DotSamaHistory_transfers {
+    __typename: "SubsquidTransfersConnection";
+    /**
+     * A list of `HistoryElement` objects.
+     */
+    transfers: (DotSamaHistory_transfers_nodes | null)[];
+}
+export interface DotSamaHistory {
+    /**
+     * Reads and enables pagination through a set of `HistoryElement`.
+     */
+    historyElements: DotSamaHistory_historyElements | null;
+}
+export interface DotSamaHistoryVariables {
+    last?: number | null;
+    address?: string | null;
+}

package/koni/api/subquery/__generated__/DotSamaHistory.js

@@ -0,0 +1 @@
+export {};

package/koni/api/subquery/subquery.d.ts

@@ -0,0 +1,2 @@
+import { ApolloClient } from '@apollo/client';
+export declare function newApolloClient(uri: string): ApolloClient<import("@apollo/client").NormalizedCacheObject>;

package/koni/api/subquery/subquery.js

@@ -0,0 +1,14 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ApolloClient, createHttpLink, InMemoryCache } from '@apollo/client';
+import fetch from 'cross-fetch';
+export function newApolloClient(uri) {
+  return new ApolloClient({
+    cache: new InMemoryCache(),
+    link: createHttpLink({
+      uri: uri,
+      fetch: fetch
+    })
+  });
+}

package/koni/api/tokens/evm/balance.d.ts

@@ -0,0 +1,2 @@
+import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
+export declare function getEVMBalance(networkKey: string, addresses: string[], evmApiMap: Record<string, _EvmApi>): Promise<string[]>;

package/koni/api/tokens/evm/balance.js

@@ -0,0 +1,9 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export async function getEVMBalance(networkKey, addresses, evmApiMap) {
+  const web3Api = evmApiMap[networkKey];
+  return await Promise.all(addresses.map(async address => {
+    return await web3Api.api.eth.getBalance(address);
+  }));
+}

package/koni/api/tokens/evm/transfer.d.ts

@@ -0,0 +1,17 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { ExternalRequestPromise, HandleBasicTx, TransactionResponse } from '@subwallet/extension-base/background/KoniTypes';
+import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
+import { TransactionConfig, TransactionReceipt } from 'web3-core';
+interface HandleTransferBalanceResultProps {
+    callback: HandleBasicTx;
+    changeValue: string;
+    networkKey: string;
+    receipt: TransactionReceipt;
+    response: TransactionResponse;
+    updateState?: (promise: Partial<ExternalRequestPromise>) => void;
+}
+export declare const handleTransferBalanceResult: ({ callback, changeValue, networkKey, receipt, response, updateState }: HandleTransferBalanceResultProps) => void;
+export declare function getEVMTransactionObject(chainInfo: _ChainInfo, to: string, value: string, transferAll: boolean, evmApiMap: Record<string, _EvmApi>): Promise<[TransactionConfig, string]>;
+export declare function getERC20TransactionObject(assetAddress: string, chainInfo: _ChainInfo, from: string, to: string, value: string, transferAll: boolean, evmApiMap: Record<string, _EvmApi>): Promise<[TransactionConfig, string]>;
+export declare function getERC721Transaction(web3Api: _EvmApi, contractAddress: string, senderAddress: string, recipientAddress: string, tokenId: string): Promise<TransactionConfig>;
+export {};