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

package/services/balance-service/BalanceMapImpl.js

@@ -2,11 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
+import { AccountProxyType } from '@subwallet/extension-base/types';
 import { isAccountAll } from '@subwallet/extension-base/utils';
 import { BehaviorSubject } from 'rxjs';
 import { groupBalance } from "./helpers/index.js";
 export class BalanceMapImpl {
-  constructor(_map = {}) {
+  constructor(state, _map = {}) {
+    this.state = state;
     this._map = _map;
     this._mapSubject = new BehaviorSubject(_map);
   }
@@ -24,9 +26,9 @@ export 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);
   }
@@ -41,11 +43,11 @@ export 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 => {
@@ -57,21 +59,45 @@ export class BalanceMapImpl {
     });
     this.triggerChange();
   }
-  computeAllAccountBalance() {
-    const allAccountBalanceInfo = {};
-    const allAccountBalance = {};
-    Object.keys(this._map).filter(a => !isAccountAll(a)).forEach(address => {
-      Object.keys(this._map[address]).forEach(tokenSlug => {
-        if (!allAccountBalance[tokenSlug]) {
-          allAccountBalance[tokenSlug] = [];
+  computeBalance(_proxyId) {
+    const isAll = isAccountAll(_proxyId);
+    const compoundMap = {};
+    const accountProxies = this.state.keyringService.context.accounts;
+    const unifiedAccountsMap = Object.values(accountProxies).filter(value => value.accountType === AccountProxyType.UNIFIED).reduce((rs, value) => {
+      rs[value.id] = value.accounts.map(account => account.address);
+      return rs;
+    }, {});
+    const revertUnifiedAccountsMap = Object.entries(unifiedAccountsMap).reduce((rs, [proxyId, accounts]) => {
+      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 => !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(ALL_ACCOUNT_KEY);
+      proxyId && addItemToMap(proxyId);
     });
-    Object.entries(allAccountBalance).forEach(([tokenSlug, balanceItems]) => {
-      allAccountBalanceInfo[tokenSlug] = groupBalance(balanceItems, ALL_ACCOUNT_KEY, tokenSlug);
+    Object.entries(compoundMap).forEach(([compoundKey, balanceMap]) => {
+      const rs = {};
+      Object.entries(balanceMap).forEach(([tokenSlug, balanceItems]) => {
+        rs[tokenSlug] = groupBalance(balanceItems, compoundKey, tokenSlug);
+      });
+      this._map[compoundKey] = rs;
     });
-    this._map[ALL_ACCOUNT_KEY] = allAccountBalanceInfo;
   }
 
   // Remove balance items buy address or tokenSlug

package/services/balance-service/helpers/subscribe/index.d.ts

@@ -1,8 +1,7 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
-import { AccountJson } from '@subwallet/extension-base/background/types';
-import { _EvmApi, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
-import { BalanceItem } from '@subwallet/extension-base/types';
+import { _EvmApi, _SubstrateApi, _TonApi } from '@subwallet/extension-base/services/chain-service/types';
+import { AccountJson, BalanceItem } from '@subwallet/extension-base/types';
 /**
  * @function getAccountJsonByAddress
  * @desc Get account info by address
@@ -13,4 +12,4 @@ import { BalanceItem } from '@subwallet/extension-base/types';
  * @returns {AccountJson|null}  - Account info or null if not found
  */
 export declare const getAccountJsonByAddress: (address: string) => AccountJson | null;
-export declare function subscribeBalance(addresses: string[], chains: string[], tokens: string[], _chainAssetMap: Record<string, _ChainAsset>, _chainInfoMap: Record<string, _ChainInfo>, substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>, callback: (rs: BalanceItem[]) => void, extrinsicType?: ExtrinsicType): () => void;
+export declare function subscribeBalance(addresses: string[], chains: string[], tokens: string[], _chainAssetMap: Record<string, _ChainAsset>, _chainInfoMap: Record<string, _ChainInfo>, substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>, tonApiMap: Record<string, _TonApi>, callback: (rs: BalanceItem[]) => void, extrinsicType?: ExtrinsicType): () => void;

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

@@ -3,9 +3,10 @@
 
 import { _AssetType } from '@subwallet/chain-list/types';
 import { APIItemState } from '@subwallet/extension-base/background/KoniTypes';
-import { _getSubstrateGenesisHash, _isChainEvmCompatible, _isPureEvmChain } from '@subwallet/extension-base/services/chain-service/utils';
-import { categoryAddresses, filterAssetsByChainAndType } from '@subwallet/extension-base/utils';
+import { _getSubstrateGenesisHash, _isChainBitcoinCompatible, _isChainEvmCompatible, _isChainTonCompatible, _isPureEvmChain, _isPureTonChain } from '@subwallet/extension-base/services/chain-service/utils';
+import { categoryAddresses, filterAssetsByChainAndType, pairToAccount } from '@subwallet/extension-base/utils';
 import keyring from '@subwallet/ui-keyring';
+import { subscribeTonBalance } from "./ton/ton.js";
 import { subscribeEVMBalance } from "./evm.js";
 import { subscribeSubstrateBalance } from "./substrate/index.js";
 
@@ -22,11 +23,7 @@ export const getAccountJsonByAddress = address => {
   try {
     const pair = keyring.getPair(address);
     if (pair) {
-      return {
-        address: pair.address,
-        type: pair.type,
-        ...pair.meta
-      };
+      return pairToAccount(pair);
     } else {
       return null;
     }
@@ -38,14 +35,22 @@ export const getAccountJsonByAddress = address => {
 
 /** Filter addresses to subscribe by chain info */
 const filterAddress = (addresses, chainInfo) => {
-  const isEvmChain = _isChainEvmCompatible(chainInfo);
-  const [substrateAddresses, evmAddresses] = categoryAddresses(addresses);
-  if (isEvmChain) {
-    return [evmAddresses, substrateAddresses];
+  const {
+    bitcoin,
+    evm,
+    substrate,
+    ton
+  } = categoryAddresses(addresses);
+  if (_isChainEvmCompatible(chainInfo)) {
+    return [evm, [...bitcoin, ...substrate, ...ton]];
+  } else if (_isChainBitcoinCompatible(chainInfo)) {
+    return [bitcoin, [...evm, ...substrate, ...ton]];
+  } else if (_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) {
@@ -67,7 +72,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) => {
@@ -87,7 +92,7 @@ const handleUnsupportedOrPendingAddresses = (addresses, chainSlug, chainAssetMap
 };
 
 // main subscription, use for multiple chains, multiple addresses and multiple tokens
-export function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _chainInfoMap, substrateApiMap, evmApiMap, callback, extrinsicType) {
+export function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, callback, extrinsicType) {
   // Filter chain and token
   const chainAssetMap = Object.fromEntries(Object.entries(_chainAssetMap).filter(([token]) => tokens.includes(token)));
   const chainInfoMap = Object.fromEntries(Object.entries(_chainInfoMap).filter(([chain]) => chains.includes(chain)));
@@ -109,10 +114,17 @@ export function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _cha
         evmApi
       });
     }
-    const substrateApi = await substrateApiMap[chainSlug].isReady;
-    if (!substrateApi.isApiReady) {
-      handleUnsupportedOrPendingAddresses(useAddresses, chainSlug, chainAssetMap, APIItemState.PENDING, callback);
+    const tonApi = tonApiMap[chainSlug];
+    if (_isPureTonChain(chainInfo)) {
+      return subscribeTonBalance({
+        addresses: useAddresses,
+        assetMap: chainAssetMap,
+        callback,
+        chainInfo,
+        tonApi
+      });
     }
+    const substrateApi = await substrateApiMap[chainSlug].isReady;
     return subscribeSubstrateBalance(useAddresses, chainInfo, chainAssetMap, substrateApi, evmApi, callback, extrinsicType);
   });
   return () => {

package/services/balance-service/helpers/subscribe/ton/consts.d.ts

@@ -0,0 +1,18 @@
+export declare const WORKCHAIN = 0;
+export declare const INIT_FEE_JETTON_TRANSFER = "0.1";
+export declare enum TON_OPCODES {
+    JETTON_TRANSFER = 260734629,
+    NFT_TRANSFER = 1607220500,
+    STONFI_SWAP = 630424929
+}
+export declare const SW_QUERYID_HEX = 536937731;
+export declare const EXTRA_TON_ESTIMATE_FEE: bigint;
+export declare const TON_CENTER_API_KEY = "078f715c911784eb4c8d2d545da3ce5db5d07996452bb2246e0a0071c66b87e9";
+export declare enum SendMode {
+    CARRY_ALL_REMAINING_BALANCE = 128,
+    CARRY_ALL_REMAINING_INCOMING_VALUE = 64,
+    DESTROY_ACCOUNT_IF_ZERO = 32,
+    PAY_GAS_SEPARATELY = 1,
+    IGNORE_ERRORS = 2,
+    NONE = 0
+}

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

@@ -0,0 +1,28 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export const WORKCHAIN = 0;
+export const INIT_FEE_JETTON_TRANSFER = '0.1';
+export let 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 || (TON_OPCODES = {}));
+export const SW_QUERYID_HEX = 0x20010503;
+export 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';
+export const TON_CENTER_API_KEY = '078f715c911784eb4c8d2d545da3ce5db5d07996452bb2246e0a0071c66b87e9'; // alibaba
+
+export let 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 || (SendMode = {}));

package/services/balance-service/helpers/subscribe/ton/ton.d.ts

@@ -0,0 +1,3 @@
+import { SubscribeTonPalletBalance } from '@subwallet/extension-base/types';
+export declare function subscribeJettonBalanceInterval({ addresses, assetMap, callback, chainInfo, tonApi }: SubscribeTonPalletBalance): () => void;
+export declare function subscribeTonBalance(params: SubscribeTonPalletBalance): () => void;

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

@@ -0,0 +1,111 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { _AssetType } from '@subwallet/chain-list/types';
+import { APIItemState } from '@subwallet/extension-base/background/KoniTypes';
+import { ASTAR_REFRESH_BALANCE_INTERVAL, SUB_TOKEN_REFRESH_BALANCE_INTERVAL } from '@subwallet/extension-base/constants';
+import { getJettonMasterContract, getJettonWalletContract } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/utils';
+import { _getContractAddressOfToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { filterAssetsByChainAndType } from '@subwallet/extension-base/utils';
+import { Address } from '@ton/core';
+export function subscribeJettonBalanceInterval({
+  addresses,
+  assetMap,
+  callback,
+  chainInfo,
+  tonApi
+}) {
+  const chain = chainInfo.slug;
+  const tokenList = filterAssetsByChainAndType(assetMap, chain, [_AssetType.TEP74]);
+  const jettonMasterContractMap = {};
+  Object.entries(tokenList).forEach(([slug, tokenInfo]) => {
+    jettonMasterContractMap[slug] = getJettonMasterContract(tonApi, _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 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: APIItemState.READY
+          };
+        });
+        callback(items);
+      } catch (err) {
+        console.log(tokenInfo.slug, err);
+      }
+    });
+  };
+  getJettonBalances();
+  const interval = setInterval(getJettonBalances, SUB_TOKEN_REFRESH_BALANCE_INTERVAL);
+  return () => {
+    clearInterval(interval);
+  };
+}
+async function getTonBalance(addresses, tonApi) {
+  return await Promise.all(addresses.map(async address => {
+    try {
+      const tonAddress = Address.parse(address);
+      return await tonApi.getBalance(tonAddress);
+    } catch (e) {
+      return BigInt(0);
+    }
+  }));
+}
+export function subscribeTonBalance(params) {
+  var _Object$values$;
+  const {
+    addresses,
+    assetMap,
+    callback,
+    chainInfo,
+    tonApi
+  } = params;
+  const chain = chainInfo.slug;
+  const nativeTokenInfo = filterAssetsByChainAndType(assetMap, chain, [_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: 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: APIItemState.READY,
+          free: '0',
+          locked: '0'
+        };
+      });
+    }).then(items => callback(items)).catch(console.error);
+  }
+  getBalance();
+  const interval = setInterval(getBalance, ASTAR_REFRESH_BALANCE_INTERVAL);
+  const unsub2 = subscribeJettonBalanceInterval(params);
+  return () => {
+    clearInterval(interval);
+    unsub2 && unsub2();
+  };
+}

package/services/balance-service/helpers/subscribe/ton/types.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { Cell } from '@ton/core';
+export declare type Signer = (message: Cell) => Promise<Buffer>;
+export interface TxByMsgResponse {
+    transactions: TxDetailInfo[];
+}
+export declare type AccountState = 'uninitialized' | 'active' | 'frozen' | 'unknown';
+interface TxDetailInfo {
+    hash: string;
+    description: {
+        compute_ph: {
+            success: boolean;
+        };
+        action: {
+            success: boolean;
+        };
+    };
+    in_msg: Msg;
+    out_msgs: Msg[];
+}
+interface Msg {
+    hash: string;
+    bounced: boolean;
+    opcode: string;
+}
+export {};

package/services/balance-service/helpers/subscribe/ton/utils.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import { TxByMsgResponse } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/types';
+import { TonTransactionConfig } from '@subwallet/extension-base/services/balance-service/transfer/ton-transfer';
+import { TonApi } from '@subwallet/extension-base/services/chain-service/handler/TonApi';
+import { _TonApi } from '@subwallet/extension-base/services/chain-service/types';
+import { TonWalletContract } from '@subwallet/keyring/types';
+import { Address, Cell, MessageRelaxed } from '@ton/core';
+import { JettonMaster, JettonWallet, OpenedContract } from '@ton/ton';
+import { Buffer } from 'buffer';
+export declare function getJettonMasterContract(tonApi: _TonApi, contractAddress: string): OpenedContract<JettonMaster>;
+export declare function getJettonWalletContract(jettonMasterContract: OpenedContract<JettonMaster>, tonApi: _TonApi, ownerAddress: string): Promise<OpenedContract<JettonWallet>>;
+export declare function externalMessage(contract: TonWalletContract, seqno: number, body: Cell): Cell;
+export declare function retry<T>(fn: () => Promise<T>, options: {
+    retries: number;
+    delay: number;
+}): Promise<T>;
+export declare function getMessageTxStatus(txByMsgInfo: TxByMsgResponse): boolean;
+export declare function getNativeTonTxStatus(tonApi: TonApi, internalMsgHash: string): Promise<boolean>;
+export declare function getJettonTxStatus(tonApi: TonApi, jettonTransferMsgHash: string): Promise<boolean>;
+export declare function estimateTonTxFee(tonApi: _TonApi, messages: MessageRelaxed[], walletContract: TonWalletContract, _seqno?: number): Promise<bigint>;
+export declare function messageRelaxedToCell(message: MessageRelaxed): Cell;
+export declare function cellToBase64Str(cell: Cell): string;
+export declare function getWalletQueryId(): bigint;
+export declare function isBounceableAddress(address: string): boolean;
+export declare function tonAddressInfo(address: string): {
+    isBounceable: boolean;
+    isTestOnly: boolean;
+    address: Address;
+} | undefined;
+export declare function getTonSendMode(isTransferAll: boolean): number;
+export declare function getTransferCellPromise(walletContract: TonWalletContract, signer: (message: Cell) => Promise<Buffer>, payload: TonTransactionConfig, seqno: number, messages: MessageRelaxed[]): Promise<Cell>;
+export declare function getTransferCell(walletContract: TonWalletContract, secretKey: Buffer, seqno: number, messages: MessageRelaxed[]): Cell;

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

@@ -0,0 +1,159 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { EXTRA_TON_ESTIMATE_FEE, SendMode, SW_QUERYID_HEX } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/consts';
+import { Address, beginCell, storeMessage, storeMessageRelaxed } from '@ton/core';
+import { external, JettonMaster, JettonWallet, WalletContractV3R1, WalletContractV3R2, WalletContractV4, WalletContractV5R1 } from '@ton/ton';
+import { Buffer } from 'buffer';
+import nacl from 'tweetnacl';
+export function getJettonMasterContract(tonApi, contractAddress) {
+  const masterAddress = Address.parse(contractAddress);
+  return tonApi.open(JettonMaster.create(masterAddress));
+}
+export async function getJettonWalletContract(jettonMasterContract, tonApi, ownerAddress) {
+  const walletAddress = Address.parse(ownerAddress);
+  const jettonWalletAddress = await jettonMasterContract.getWalletAddress(walletAddress);
+  return tonApi.open(JettonWallet.create(jettonWalletAddress));
+}
+export function externalMessage(contract, seqno, body) {
+  return beginCell().storeWritable(storeMessage(external({
+    to: contract.address,
+    init: seqno === 0 ? contract.init : undefined,
+    // contract init for first transaction.
+    body: body
+  }))).endCell();
+}
+export 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()
+}
+
+export 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
+export async function getNativeTonTxStatus(tonApi, internalMsgHash) {
+  const internalTxInfoRaw = await tonApi.getTxByInMsg(internalMsgHash);
+  return getMessageTxStatus(internalTxInfoRaw);
+}
+export 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;
+}
+export 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.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) + EXTRA_TON_ESTIMATE_FEE;
+}
+export function messageRelaxedToCell(message) {
+  return beginCell().store(storeMessageRelaxed(message)).endCell();
+}
+export function cellToBase64Str(cell) {
+  return cell.toBoc().toString('base64');
+}
+export function getWalletQueryId() {
+  const swSignal = SW_QUERYID_HEX.toString(16);
+  const swSignalBuffer = Buffer.from(swSignal, 'hex');
+  const randomBuffer = nacl.randomBytes(4);
+  const buffer = Buffer.concat([swSignalBuffer, randomBuffer]);
+  return BigInt('0x' + buffer.toString('hex'));
+}
+export function isBounceableAddress(address) {
+  return Address.isFriendly(address) ? Address.parseFriendly(address).isBounceable : true;
+}
+export function tonAddressInfo(address) {
+  return Address.isFriendly(address) ? Address.parseFriendly(address) : undefined;
+}
+export function getTonSendMode(isTransferAll) {
+  return isTransferAll ? SendMode.CARRY_ALL_REMAINING_BALANCE : SendMode.PAY_GAS_SEPARATELY + SendMode.IGNORE_ERRORS;
+}
+const isVersionv3r1 = walletContract => {
+  return walletContract instanceof WalletContractV3R1;
+};
+const isVersionv3r2 = walletContract => {
+  return walletContract instanceof WalletContractV3R2;
+};
+const isVersionv4 = walletContract => {
+  return walletContract instanceof WalletContractV4;
+};
+const isVersionv5r1 = walletContract => {
+  return walletContract instanceof WalletContractV5R1;
+};
+export 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;
+}
+export 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;
+}