@subwallet/extension-base 1.2.31-0 → 1.2.33-0

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

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.BalanceMapImpl = void 0;
 var _constants = require("@subwallet/extension-base/constants");
+var _types = require("@subwallet/extension-base/types");
 var _utils = require("@subwallet/extension-base/utils");
 var _rxjs = require("rxjs");
 var _helpers = require("./helpers");
@@ -12,8 +13,9 @@ var _helpers = require("./helpers");
 // SPDX-License-Identifier: Apache-2.0
 
 class BalanceMapImpl {
-  constructor() {
-    let _map = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  constructor(state) {
+    let _map = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    this.state = state;
     this._map = _map;
     this._mapSubject = new _rxjs.BehaviorSubject(_map);
   }
@@ -31,9 +33,9 @@ class BalanceMapImpl {
     this._map[address] = data;
     this.triggerChange();
   }
-  triggerChange(computeAll) {
-    if (computeAll) {
-      this.computeAllAccountBalance();
+  triggerChange(proxyId) {
+    if (proxyId) {
+      this.computeBalance(proxyId);
     }
     this._mapSubject.next(this._map);
   }
@@ -49,11 +51,11 @@ class BalanceMapImpl {
     this._map[address][tokenSlug] = balanceItem;
     trigger && this.triggerChange();
   }
-  updateBalanceItems(balanceItems, computeAll) {
+  updateBalanceItems(balanceItems, proxyId) {
     balanceItems.forEach(balanceItem => {
       this.updateBalanceItem(balanceItem);
     });
-    this.triggerChange(computeAll);
+    this.triggerChange(proxyId);
   }
   removeBalanceItemByFilter(filter) {
     Object.keys(this._map).forEach(address => {
@@ -65,22 +67,48 @@ class BalanceMapImpl {
     });
     this.triggerChange();
   }
-  computeAllAccountBalance() {
-    const allAccountBalanceInfo = {};
-    const allAccountBalance = {};
-    Object.keys(this._map).filter(a => !(0, _utils.isAccountAll)(a)).forEach(address => {
-      Object.keys(this._map[address]).forEach(tokenSlug => {
-        if (!allAccountBalance[tokenSlug]) {
-          allAccountBalance[tokenSlug] = [];
+  computeBalance(_proxyId) {
+    const isAll = (0, _utils.isAccountAll)(_proxyId);
+    const compoundMap = {};
+    const accountProxies = this.state.keyringService.context.accounts;
+    const unifiedAccountsMap = Object.values(accountProxies).filter(value => value.accountType === _types.AccountProxyType.UNIFIED).reduce((rs, value) => {
+      rs[value.id] = value.accounts.map(account => account.address);
+      return rs;
+    }, {});
+    const revertUnifiedAccountsMap = Object.entries(unifiedAccountsMap).reduce((rs, _ref) => {
+      let [proxyId, accounts] = _ref;
+      if (isAll || proxyId === _proxyId) {
+        for (const account of accounts) {
+          rs[account] = proxyId;
         }
-        allAccountBalance[tokenSlug].push(this._map[address][tokenSlug]);
-      });
+      }
+      return rs;
+    }, {});
+    const proxyIds = Object.keys(unifiedAccountsMap);
+    Object.keys(this._map).filter(a => !(0, _utils.isAccountAll)(a) && !proxyIds.includes(a)).forEach(address => {
+      const addItemToMap = key => {
+        const unifiedAccountBalance = compoundMap[key] || {};
+        Object.keys(this._map[address]).forEach(tokenSlug => {
+          if (!unifiedAccountBalance[tokenSlug]) {
+            unifiedAccountBalance[tokenSlug] = [];
+          }
+          unifiedAccountBalance[tokenSlug].push(this._map[address][tokenSlug]);
+        });
+        compoundMap[key] = unifiedAccountBalance;
+      };
+      const proxyId = revertUnifiedAccountsMap[address];
+      isAll && addItemToMap(_constants.ALL_ACCOUNT_KEY);
+      proxyId && addItemToMap(proxyId);
     });
-    Object.entries(allAccountBalance).forEach(_ref => {
-      let [tokenSlug, balanceItems] = _ref;
-      allAccountBalanceInfo[tokenSlug] = (0, _helpers.groupBalance)(balanceItems, _constants.ALL_ACCOUNT_KEY, tokenSlug);
+    Object.entries(compoundMap).forEach(_ref2 => {
+      let [compoundKey, balanceMap] = _ref2;
+      const rs = {};
+      Object.entries(balanceMap).forEach(_ref3 => {
+        let [tokenSlug, balanceItems] = _ref3;
+        rs[tokenSlug] = (0, _helpers.groupBalance)(balanceItems, compoundKey, tokenSlug);
+      });
+      this._map[compoundKey] = rs;
     });
-    this._map[_constants.ALL_ACCOUNT_KEY] = allAccountBalanceInfo;
   }
 
   // Remove balance items buy address or tokenSlug

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

@@ -11,6 +11,7 @@ var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _utils2 = require("@subwallet/extension-base/utils");
 var _uiKeyring = _interopRequireDefault(require("@subwallet/ui-keyring"));
+var _ton = require("./ton/ton");
 var _evm = require("./evm");
 var _substrate = require("./substrate");
 // Copyright 2019-2022 @subwallet/extension-base
@@ -29,11 +30,7 @@ const getAccountJsonByAddress = address => {
   try {
     const pair = _uiKeyring.default.getPair(address);
     if (pair) {
-      return {
-        address: pair.address,
-        type: pair.type,
-        ...pair.meta
-      };
+      return (0, _utils2.pairToAccount)(pair);
     } else {
       return null;
     }
@@ -46,14 +43,22 @@ const getAccountJsonByAddress = address => {
 /** Filter addresses to subscribe by chain info */
 exports.getAccountJsonByAddress = getAccountJsonByAddress;
 const filterAddress = (addresses, chainInfo) => {
-  const isEvmChain = (0, _utils._isChainEvmCompatible)(chainInfo);
-  const [substrateAddresses, evmAddresses] = (0, _utils2.categoryAddresses)(addresses);
-  if (isEvmChain) {
-    return [evmAddresses, substrateAddresses];
+  const {
+    bitcoin,
+    evm,
+    substrate,
+    ton
+  } = (0, _utils2.categoryAddresses)(addresses);
+  if ((0, _utils._isChainEvmCompatible)(chainInfo)) {
+    return [evm, [...bitcoin, ...substrate, ...ton]];
+  } else if ((0, _utils._isChainBitcoinCompatible)(chainInfo)) {
+    return [bitcoin, [...evm, ...substrate, ...ton]];
+  } else if ((0, _utils._isChainTonCompatible)(chainInfo)) {
+    return [ton, [...bitcoin, ...evm, ...substrate]];
   } else {
     const fetchList = [];
     const unfetchList = [];
-    substrateAddresses.forEach(address => {
+    substrate.forEach(address => {
       const account = getAccountJsonByAddress(address);
       if (account) {
         if (account.isHardware) {
@@ -75,7 +80,7 @@ const filterAddress = (addresses, chainInfo) => {
         fetchList.push(address);
       }
     });
-    return [fetchList, [...unfetchList, ...evmAddresses]];
+    return [fetchList, [...unfetchList, ...bitcoin, ...evm, ...ton]];
   }
 };
 const handleUnsupportedOrPendingAddresses = (addresses, chainSlug, chainAssetMap, state, callback) => {
@@ -95,7 +100,7 @@ const handleUnsupportedOrPendingAddresses = (addresses, chainSlug, chainAssetMap
 };
 
 // main subscription, use for multiple chains, multiple addresses and multiple tokens
-function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _chainInfoMap, substrateApiMap, evmApiMap, callback, extrinsicType) {
+function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, callback, extrinsicType) {
   // Filter chain and token
   const chainAssetMap = Object.fromEntries(Object.entries(_chainAssetMap).filter(_ref => {
     let [token] = _ref;
@@ -123,10 +128,17 @@ function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _chainInfoM
         evmApi
       });
     }
-    const substrateApi = await substrateApiMap[chainSlug].isReady;
-    if (!substrateApi.isApiReady) {
-      handleUnsupportedOrPendingAddresses(useAddresses, chainSlug, chainAssetMap, _KoniTypes.APIItemState.PENDING, callback);
+    const tonApi = tonApiMap[chainSlug];
+    if ((0, _utils._isPureTonChain)(chainInfo)) {
+      return (0, _ton.subscribeTonBalance)({
+        addresses: useAddresses,
+        assetMap: chainAssetMap,
+        callback,
+        chainInfo,
+        tonApi
+      });
     }
+    const substrateApi = await substrateApiMap[chainSlug].isReady;
     return (0, _substrate.subscribeSubstrateBalance)(useAddresses, chainInfo, chainAssetMap, substrateApi, evmApi, callback, extrinsicType);
   });
   return () => {

package/cjs/services/balance-service/helpers/subscribe/ton/consts.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WORKCHAIN = exports.TON_OPCODES = exports.TON_CENTER_API_KEY = exports.SendMode = exports.SW_QUERYID_HEX = exports.INIT_FEE_JETTON_TRANSFER = exports.EXTRA_TON_ESTIMATE_FEE = void 0;
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const WORKCHAIN = 0;
+exports.WORKCHAIN = WORKCHAIN;
+const INIT_FEE_JETTON_TRANSFER = '0.1';
+exports.INIT_FEE_JETTON_TRANSFER = INIT_FEE_JETTON_TRANSFER;
+let TON_OPCODES;
+exports.TON_OPCODES = TON_OPCODES;
+(function (TON_OPCODES) {
+  TON_OPCODES[TON_OPCODES["JETTON_TRANSFER"] = 260734629] = "JETTON_TRANSFER";
+  TON_OPCODES[TON_OPCODES["NFT_TRANSFER"] = 1607220500] = "NFT_TRANSFER";
+  TON_OPCODES[TON_OPCODES["STONFI_SWAP"] = 630424929] = "STONFI_SWAP";
+})(TON_OPCODES || (exports.TON_OPCODES = TON_OPCODES = {}));
+const SW_QUERYID_HEX = 0x20010503;
+exports.SW_QUERYID_HEX = SW_QUERYID_HEX;
+const EXTRA_TON_ESTIMATE_FEE = BigInt(500);
+
+// todo: This is just free API for dev, remove this and set better RPC later
+// export const TON_CENTER_API_KEY = '98b3eaf42da2981d265bfa6aea2c8d390befb6f677f675fefd3b12201bdf1bc3';
+// export const TON_CENTER_API_KEY = '870ff97c30ad16dc4297bcac8bcf2243a4daffeba6c6d6c31553e342811e673a';
+exports.EXTRA_TON_ESTIMATE_FEE = EXTRA_TON_ESTIMATE_FEE;
+const TON_CENTER_API_KEY = '078f715c911784eb4c8d2d545da3ce5db5d07996452bb2246e0a0071c66b87e9'; // alibaba
+exports.TON_CENTER_API_KEY = TON_CENTER_API_KEY;
+let SendMode;
+exports.SendMode = SendMode;
+(function (SendMode) {
+  SendMode[SendMode["CARRY_ALL_REMAINING_BALANCE"] = 128] = "CARRY_ALL_REMAINING_BALANCE";
+  SendMode[SendMode["CARRY_ALL_REMAINING_INCOMING_VALUE"] = 64] = "CARRY_ALL_REMAINING_INCOMING_VALUE";
+  SendMode[SendMode["DESTROY_ACCOUNT_IF_ZERO"] = 32] = "DESTROY_ACCOUNT_IF_ZERO";
+  SendMode[SendMode["PAY_GAS_SEPARATELY"] = 1] = "PAY_GAS_SEPARATELY";
+  SendMode[SendMode["IGNORE_ERRORS"] = 2] = "IGNORE_ERRORS";
+  SendMode[SendMode["NONE"] = 0] = "NONE";
+})(SendMode || (exports.SendMode = SendMode = {}));

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

@@ -0,0 +1,120 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.subscribeJettonBalanceInterval = subscribeJettonBalanceInterval;
+exports.subscribeTonBalance = subscribeTonBalance;
+var _types = require("@subwallet/chain-list/types");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/constants");
+var _utils = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/utils");
+var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils3 = require("@subwallet/extension-base/utils");
+var _core = require("@ton/core");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function subscribeJettonBalanceInterval(_ref) {
+  let {
+    addresses,
+    assetMap,
+    callback,
+    chainInfo,
+    tonApi
+  } = _ref;
+  const chain = chainInfo.slug;
+  const tokenList = (0, _utils3.filterAssetsByChainAndType)(assetMap, chain, [_types._AssetType.TEP74]);
+  const jettonMasterContractMap = {};
+  Object.entries(tokenList).forEach(_ref2 => {
+    let [slug, tokenInfo] = _ref2;
+    jettonMasterContractMap[slug] = (0, _utils.getJettonMasterContract)(tonApi, (0, _utils2._getContractAddressOfToken)(tokenInfo));
+  });
+  const getJettonBalances = () => {
+    Object.values(tokenList).map(async tokenInfo => {
+      try {
+        const masterContract = jettonMasterContractMap[tokenInfo.slug];
+        const balances = await Promise.all(addresses.map(async address => {
+          try {
+            const jettonWalletContract = await (0, _utils.getJettonWalletContract)(masterContract, tonApi, address);
+            return await jettonWalletContract.getBalance();
+          } catch (e) {
+            console.error(`Error on get balance of account ${address} for token ${tokenInfo.slug}`, e);
+            return BigInt(0);
+          }
+        }));
+        const items = balances.map((balance, index) => {
+          return {
+            address: addresses[index],
+            tokenSlug: tokenInfo.slug,
+            free: balance.toString(),
+            locked: '0',
+            state: _KoniTypes.APIItemState.READY
+          };
+        });
+        callback(items);
+      } catch (err) {
+        console.log(tokenInfo.slug, err);
+      }
+    });
+  };
+  getJettonBalances();
+  const interval = setInterval(getJettonBalances, _constants.SUB_TOKEN_REFRESH_BALANCE_INTERVAL);
+  return () => {
+    clearInterval(interval);
+  };
+}
+async function getTonBalance(addresses, tonApi) {
+  return await Promise.all(addresses.map(async address => {
+    try {
+      const tonAddress = _core.Address.parse(address);
+      return await tonApi.getBalance(tonAddress);
+    } catch (e) {
+      return BigInt(0);
+    }
+  }));
+}
+function subscribeTonBalance(params) {
+  var _Object$values$;
+  const {
+    addresses,
+    assetMap,
+    callback,
+    chainInfo,
+    tonApi
+  } = params;
+  const chain = chainInfo.slug;
+  const nativeTokenInfo = (0, _utils3.filterAssetsByChainAndType)(assetMap, chain, [_types._AssetType.NATIVE]);
+  const nativeTokenSlug = ((_Object$values$ = Object.values(nativeTokenInfo)[0]) === null || _Object$values$ === void 0 ? void 0 : _Object$values$.slug) || '';
+  function getBalance() {
+    getTonBalance(addresses, tonApi).then(balances => {
+      return balances.map((balance, index) => {
+        return {
+          address: addresses[index],
+          tokenSlug: nativeTokenSlug,
+          state: _KoniTypes.APIItemState.READY,
+          free: balance.toString(),
+          locked: '0'
+        };
+      });
+    }).catch(e => {
+      console.error(`Error on get native balance with token ${nativeTokenSlug}`, e);
+      return addresses.map(address => {
+        return {
+          address: address,
+          tokenSlug: nativeTokenSlug,
+          state: _KoniTypes.APIItemState.READY,
+          free: '0',
+          locked: '0'
+        };
+      });
+    }).then(items => callback(items)).catch(console.error);
+  }
+  getBalance();
+  const interval = setInterval(getBalance, _constants.ASTAR_REFRESH_BALANCE_INTERVAL);
+  const unsub2 = subscribeJettonBalanceInterval(params);
+  return () => {
+    clearInterval(interval);
+    unsub2 && unsub2();
+  };
+}

package/cjs/services/balance-service/helpers/subscribe/ton/utils.js

@@ -0,0 +1,181 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cellToBase64Str = cellToBase64Str;
+exports.estimateTonTxFee = estimateTonTxFee;
+exports.externalMessage = externalMessage;
+exports.getJettonMasterContract = getJettonMasterContract;
+exports.getJettonTxStatus = getJettonTxStatus;
+exports.getJettonWalletContract = getJettonWalletContract;
+exports.getMessageTxStatus = getMessageTxStatus;
+exports.getNativeTonTxStatus = getNativeTonTxStatus;
+exports.getTonSendMode = getTonSendMode;
+exports.getTransferCell = getTransferCell;
+exports.getTransferCellPromise = getTransferCellPromise;
+exports.getWalletQueryId = getWalletQueryId;
+exports.isBounceableAddress = isBounceableAddress;
+exports.messageRelaxedToCell = messageRelaxedToCell;
+exports.retry = retry;
+exports.tonAddressInfo = tonAddressInfo;
+var _consts = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/consts");
+var _core = require("@ton/core");
+var _ton = require("@ton/ton");
+var _buffer = require("buffer");
+var _tweetnacl = _interopRequireDefault(require("tweetnacl"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function getJettonMasterContract(tonApi, contractAddress) {
+  const masterAddress = _core.Address.parse(contractAddress);
+  return tonApi.open(_ton.JettonMaster.create(masterAddress));
+}
+async function getJettonWalletContract(jettonMasterContract, tonApi, ownerAddress) {
+  const walletAddress = _core.Address.parse(ownerAddress);
+  const jettonWalletAddress = await jettonMasterContract.getWalletAddress(walletAddress);
+  return tonApi.open(_ton.JettonWallet.create(jettonWalletAddress));
+}
+function externalMessage(contract, seqno, body) {
+  return (0, _core.beginCell)().storeWritable((0, _core.storeMessage)((0, _ton.external)({
+    to: contract.address,
+    init: seqno === 0 ? contract.init : undefined,
+    // contract init for first transaction.
+    body: body
+  }))).endCell();
+}
+async function retry(fn, options) {
+  let lastError;
+  for (let i = 0; i < options.retries; i++) {
+    try {
+      return await fn();
+    } catch (e) {
+      if (e instanceof Error) {
+        lastError = e;
+      }
+      await new Promise(resolve => setTimeout(resolve, options.delay)); // wait for delay period, then recall the fn()
+    }
+  }
+
+  throw lastError; // throw only last error, in case no successful result from fn()
+}
+
+function getMessageTxStatus(txByMsgInfo) {
+  var _txDetailInfo$descrip, _txDetailInfo$descrip2, _txDetailInfo$descrip3, _txDetailInfo$descrip4, _txDetailInfo$descrip5, _txDetailInfo$descrip6, _txDetailInfo$out_msg, _txDetailInfo$out_msg2;
+  const txDetailInfo = txByMsgInfo.transactions[0];
+  const isCompute = (_txDetailInfo$descrip = (_txDetailInfo$descrip2 = txDetailInfo.description) === null || _txDetailInfo$descrip2 === void 0 ? void 0 : (_txDetailInfo$descrip3 = _txDetailInfo$descrip2.compute_ph) === null || _txDetailInfo$descrip3 === void 0 ? void 0 : _txDetailInfo$descrip3.success) !== null && _txDetailInfo$descrip !== void 0 ? _txDetailInfo$descrip : false;
+  const isAction = (_txDetailInfo$descrip4 = (_txDetailInfo$descrip5 = txDetailInfo.description) === null || _txDetailInfo$descrip5 === void 0 ? void 0 : (_txDetailInfo$descrip6 = _txDetailInfo$descrip5.action) === null || _txDetailInfo$descrip6 === void 0 ? void 0 : _txDetailInfo$descrip6.success) !== null && _txDetailInfo$descrip4 !== void 0 ? _txDetailInfo$descrip4 : false;
+  const isBounced = (_txDetailInfo$out_msg = (_txDetailInfo$out_msg2 = txDetailInfo.out_msgs[0]) === null || _txDetailInfo$out_msg2 === void 0 ? void 0 : _txDetailInfo$out_msg2.bounced) !== null && _txDetailInfo$out_msg !== void 0 ? _txDetailInfo$out_msg : false;
+  return isCompute && isAction && !isBounced;
+}
+
+// @ts-ignore
+async function getNativeTonTxStatus(tonApi, internalMsgHash) {
+  const internalTxInfoRaw = await tonApi.getTxByInMsg(internalMsgHash);
+  return getMessageTxStatus(internalTxInfoRaw);
+}
+async function getJettonTxStatus(tonApi, jettonTransferMsgHash) {
+  const jettonTransferTxInfoRaw = await tonApi.getTxByInMsg(jettonTransferMsgHash);
+  const status = getMessageTxStatus(jettonTransferTxInfoRaw);
+  if (status) {
+    var _jettonTransferTxInfo;
+    // Jetton Transfer success -> Check Jetton Internal Transfer
+    const jettonTransferTxInfo = jettonTransferTxInfoRaw.transactions[0];
+    const jettonInternalTransferHash = (_jettonTransferTxInfo = jettonTransferTxInfo.out_msgs[0]) === null || _jettonTransferTxInfo === void 0 ? void 0 : _jettonTransferTxInfo.hash;
+    const jettonInternalTransferTxInfoRaw = await tonApi.getTxByInMsg(jettonInternalTransferHash);
+    return getMessageTxStatus(jettonInternalTransferTxInfoRaw); // Jetton Internal Transfer success -> Receiver successfully receiver fund!
+  }
+
+  return false;
+}
+async function estimateTonTxFee(tonApi, messages, walletContract, _seqno) {
+  const contract = tonApi.open(walletContract);
+  const seqno = _seqno !== null && _seqno !== void 0 ? _seqno : await contract.getSeqno();
+  const isInit = seqno !== 0;
+  const similatedSecretKey = _buffer.Buffer.from(new Array(64));
+  const simulatedTxCell = getTransferCell(walletContract, similatedSecretKey, seqno, messages);
+  const estimateFeeInfo = await tonApi.estimateExternalMessageFee(walletContract, simulatedTxCell, isInit);
+  return BigInt(estimateFeeInfo.source_fees.gas_fee + estimateFeeInfo.source_fees.in_fwd_fee + estimateFeeInfo.source_fees.storage_fee + estimateFeeInfo.source_fees.fwd_fee) + _consts.EXTRA_TON_ESTIMATE_FEE;
+}
+function messageRelaxedToCell(message) {
+  return (0, _core.beginCell)().store((0, _core.storeMessageRelaxed)(message)).endCell();
+}
+function cellToBase64Str(cell) {
+  return cell.toBoc().toString('base64');
+}
+function getWalletQueryId() {
+  const swSignal = _consts.SW_QUERYID_HEX.toString(16);
+  const swSignalBuffer = _buffer.Buffer.from(swSignal, 'hex');
+  const randomBuffer = _tweetnacl.default.randomBytes(4);
+  const buffer = _buffer.Buffer.concat([swSignalBuffer, randomBuffer]);
+  return BigInt('0x' + buffer.toString('hex'));
+}
+function isBounceableAddress(address) {
+  return _core.Address.isFriendly(address) ? _core.Address.parseFriendly(address).isBounceable : true;
+}
+function tonAddressInfo(address) {
+  return _core.Address.isFriendly(address) ? _core.Address.parseFriendly(address) : undefined;
+}
+function getTonSendMode(isTransferAll) {
+  return isTransferAll ? _consts.SendMode.CARRY_ALL_REMAINING_BALANCE : _consts.SendMode.PAY_GAS_SEPARATELY + _consts.SendMode.IGNORE_ERRORS;
+}
+const isVersionv3r1 = walletContract => {
+  return walletContract instanceof _ton.WalletContractV3R1;
+};
+const isVersionv3r2 = walletContract => {
+  return walletContract instanceof _ton.WalletContractV3R2;
+};
+const isVersionv4 = walletContract => {
+  return walletContract instanceof _ton.WalletContractV4;
+};
+const isVersionv5r1 = walletContract => {
+  return walletContract instanceof _ton.WalletContractV5R1;
+};
+function getTransferCellPromise(walletContract, signer, payload, seqno, messages) {
+  let promise;
+  const params = {
+    signer,
+    sendMode: getTonSendMode(payload.transferAll),
+    seqno: seqno,
+    messages: messages
+  };
+  if (isVersionv3r1(walletContract)) {
+    promise = walletContract.createTransfer(params);
+  } else if (isVersionv3r2(walletContract)) {
+    promise = walletContract.createTransfer(params);
+  } else if (isVersionv4(walletContract)) {
+    promise = walletContract.createTransfer(params);
+  } else if (isVersionv5r1(walletContract)) {
+    promise = walletContract.createTransfer({
+      ...params,
+      sendMode: params.sendMode
+    });
+  } else {
+    throw new Error('Unknown wallet contract address');
+  }
+  return promise;
+}
+function getTransferCell(walletContract, secretKey, seqno, messages) {
+  let cell;
+  const params = {
+    secretKey,
+    seqno,
+    messages
+  };
+  if (isVersionv3r1(walletContract)) {
+    cell = walletContract.createTransfer(params);
+  } else if (isVersionv3r2(walletContract)) {
+    cell = walletContract.createTransfer(params);
+  } else if (isVersionv4(walletContract)) {
+    cell = walletContract.createTransfer(params);
+  } else if (isVersionv5r1(walletContract)) {
+    cell = walletContract.createTransfer({
+      ...params,
+      sendMode: params.sendMode
+    });
+  } else {
+    throw new Error('Unknown wallet contract address');
+  }
+  return cell;
+}

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

@@ -14,6 +14,8 @@ var _types = require("@subwallet/extension-base/services/base/types");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _DetectAccountBalance = _interopRequireDefault(require("@subwallet/extension-base/stores/DetectAccountBalance"));
 var _utils2 = require("@subwallet/extension-base/utils");
+var _keyring = require("@subwallet/keyring");
+var _types2 = require("@subwallet/keyring/types");
 var _uiKeyring = _interopRequireDefault(require("@subwallet/ui-keyring"));
 var _i18next = require("i18next");
 var _rxjs = require("rxjs");
@@ -44,7 +46,7 @@ class BalanceService {
    */
   constructor(state) {
     this.state = state;
-    this.balanceMap = new _BalanceMapImpl.BalanceMapImpl();
+    this.balanceMap = new _BalanceMapImpl.BalanceMapImpl(state);
   }
 
   /** Init service */
@@ -67,7 +69,7 @@ class BalanceService {
   /** Restore balance map */
   async loadData() {
     const backupBalanceData = await this.state.dbService.getStoredBalance();
-    this.balanceMap.updateBalanceItems(backupBalanceData, true);
+    this.balanceMap.updateBalanceItems(backupBalanceData, _constants.ALL_ACCOUNT_KEY);
   }
 
   /** Start service */
@@ -133,7 +135,7 @@ class BalanceService {
       }
     }
     events.forEach(event => {
-      if (event.type === 'account.remove') {
+      if (event.type === 'account.remove' || event.type === 'accountProxy.remove') {
         removedAddresses.push(event.data[0]);
         lazyTime = 1000;
       }
@@ -193,8 +195,9 @@ class BalanceService {
       const chainInfoMap = this.state.chainService.getChainInfoMap();
       const evmApiMap = this.state.chainService.getEvmApiMap();
       const substrateApiMap = this.state.chainService.getSubstrateApiMap();
+      const tonApiMap = this.state.chainService.getTonApiMap();
       let unsub = _util.noop;
-      unsub = (0, _helpers.subscribeBalance)([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, result => {
+      unsub = (0, _helpers.subscribeBalance)([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, result => {
         const rs = result[0];
         if (rs.tokenSlug === tSlug) {
           hasError = false;
@@ -287,10 +290,12 @@ class BalanceService {
         this.balanceUpdateCache.push(balance);
       }
       (0, _utils2.addLazy)('updateBalanceStore', () => {
-        const isAllAccount = (0, _utils2.isAccountAll)(this.state.keyringService.currentAccount.address);
-        this.balanceMap.updateBalanceItems(this.balanceUpdateCache, isAllAccount);
-        if (isAllAccount) {
-          this.balanceUpdateCache = [...this.balanceUpdateCache, ...Object.values(this.balanceMap.map[_constants.ALL_ACCOUNT_KEY])];
+        const proxyId = this.state.keyringService.context.currentAccount.proxyId;
+        const isUnifiedAccount = this.state.keyringService.context.isUnifiedAccount(proxyId);
+        const isAll = (0, _utils2.isAccountAll)(proxyId);
+        this.balanceMap.updateBalanceItems(this.balanceUpdateCache, isUnifiedAccount || isAll ? proxyId : undefined);
+        if (isUnifiedAccount || isAll) {
+          this.balanceUpdateCache = [...this.balanceUpdateCache, ...Object.values(this.balanceMap.map[proxyId])];
         }
         this.updateBalanceStore(this.balanceUpdateCache);
         this.balanceUpdateCache = [];
@@ -318,7 +323,7 @@ class BalanceService {
   async runSubscribeBalances() {
     await Promise.all([this.state.eventService.waitKeyringReady, this.state.eventService.waitChainReady]);
     this.runUnsubscribeBalances();
-    const addresses = this.state.getDecodedAddresses();
+    const addresses = this.state.keyringService.context.getDecodedAddresses();
     if (!addresses.length) {
       return;
     }
@@ -330,13 +335,14 @@ class BalanceService {
     const chainInfoMap = this.state.chainService.getChainInfoMap();
     const evmApiMap = this.state.chainService.getEvmApiMap();
     const substrateApiMap = this.state.chainService.getSubstrateApiMap();
+    const tonApiMap = this.state.chainService.getTonApiMap();
     const activeChainSlugs = Object.keys(this.state.getActiveChainInfoMap());
     const assetState = this.state.chainService.subscribeAssetSettings().value;
     const assets = Object.values(assetMap).filter(asset => {
       var _assetState$asset$slu;
       return activeChainSlugs.includes(asset.originChain) && ((_assetState$asset$slu = assetState[asset.slug]) === null || _assetState$asset$slu === void 0 ? void 0 : _assetState$asset$slu.visible);
     }).map(asset => asset.slug);
-    const unsub = (0, _helpers.subscribeBalance)(addresses, activeChainSlugs, assets, assetMap, chainInfoMap, substrateApiMap, evmApiMap, result => {
+    const unsub = (0, _helpers.subscribeBalance)(addresses, activeChainSlugs, assets, assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, result => {
       !cancel && this.setBalanceItem(result);
     }, _KoniTypes.ExtrinsicType.TRANSFER_BALANCE);
     const unsub2 = this.state.subscribeMantaPayBalance();
@@ -368,10 +374,16 @@ class BalanceService {
     this.setBalanceDetectCache(addresses);
     const assetMap = this.state.chainService.getAssetRegistry();
     const promiseList = addresses.map(address => {
-      return this.state.subscanService.getMultiChainBalance(address).catch(e => {
-        console.error(e);
+      const type = (0, _keyring.getKeypairTypeByAddress)(address);
+      const typeValid = [..._types2.SubstrateKeypairTypes, ..._types2.EthereumKeypairTypes].includes(type);
+      if (typeValid) {
+        return this.state.subscanService.getMultiChainBalance(address).catch(e => {
+          console.error(e);
+          return null;
+        });
+      } else {
         return null;
-      });
+      }
     });
     const needEnableChains = [];
     const needActiveTokens = [];