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

package/cjs/services/balance-service/transfer/token.js

@@ -9,10 +9,14 @@ var _api = require("@gear-js/api");
 var _types = require("@subwallet/chain-list/types");
 var _wasm = require("@subwallet/extension-base/koni/api/contract-handler/wasm");
 var _utils = require("@subwallet/extension-base/koni/api/contract-handler/wasm/utils");
+var _utils2 = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/utils");
 var _constants = require("@subwallet/extension-base/services/chain-service/constants");
-var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
-var _utils3 = require("@subwallet/extension-base/services/fee-service/utils");
-var _utils4 = require("@subwallet/extension-base/utils");
+var _utils3 = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils4 = require("@subwallet/extension-base/services/fee-service/utils");
+var _utils5 = require("@subwallet/extension-base/utils");
+var _uiKeyring = require("@subwallet/ui-keyring");
+var _core = require("@ton/core");
+var _ton = require("@ton/ton");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _util = require("@polkadot/util");
 var _utilCrypto = require("@polkadot/util-crypto");
@@ -44,15 +48,15 @@ const createTransferExtrinsic = async _ref => {
   const isTxAssetsSupported = !!api && !!api.tx && !!api.tx.assets;
   let transferAmount; // for PSP-22 tokens, might be deprecated in the future
 
-  if ((0, _utils2._isBridgedToken)(tokenInfo) && api.tx.foreignAssets) {
-    const onChainInfo = (0, _utils2._getTokenOnChainInfo)(tokenInfo) || (0, _utils2._getXcmAssetMultilocation)(tokenInfo);
+  if ((0, _utils3._isBridgedToken)(tokenInfo) && api.tx.foreignAssets) {
+    const onChainInfo = (0, _utils3._getTokenOnChainInfo)(tokenInfo) || (0, _utils3._getXcmAssetMultilocation)(tokenInfo);
     if (transferAll) {
       transfer = api.tx.foreignAssets.transfer(onChainInfo, to, value);
     } else {
       transfer = api.tx.foreignAssets.transferKeepAlive(onChainInfo, to, value);
     }
-  } else if ((0, _utils2._isTokenWasmSmartContract)(tokenInfo) && api.query.contracts) {
-    const contractPromise = (0, _wasm.getPSP22ContractPromise)(api, (0, _utils2._getContractAddressOfToken)(tokenInfo));
+  } else if ((0, _utils3._isTokenWasmSmartContract)(tokenInfo) && api.query.contracts) {
+    const contractPromise = (0, _wasm.getPSP22ContractPromise)(api, (0, _utils3._getContractAddressOfToken)(tokenInfo));
     // @ts-ignore
     const gasLimit = await (0, _utils.getWasmContractGasLimit)(api, from, 'psp22::transfer', contractPromise, {}, [from, value, {}]);
 
@@ -61,8 +65,8 @@ const createTransferExtrinsic = async _ref => {
       gasLimit
     }, to, value, {});
     transferAmount = value;
-  } else if ((0, _utils2._isTokenGearSmartContract)(tokenInfo) && api instanceof _api.GearApi) {
-    const contractPromise = tokenInfo.assetType === _types._AssetType.GRC20 ? (0, _utils4.getGRC20ContractPromise)(api, (0, _utils2._getContractAddressOfToken)(tokenInfo)) : (0, _utils4.getVFTContractPromise)(api, (0, _utils2._getContractAddressOfToken)(tokenInfo));
+  } else if ((0, _utils3._isTokenGearSmartContract)(tokenInfo) && api instanceof _api.GearApi) {
+    const contractPromise = tokenInfo.assetType === _types._AssetType.GRC20 ? (0, _utils5.getGRC20ContractPromise)(api, (0, _utils3._getContractAddressOfToken)(tokenInfo)) : (0, _utils5.getVFTContractPromise)(api, (0, _utils3._getContractAddressOfToken)(tokenInfo));
     const transaction = await contractPromise.service.transfer((0, _util.u8aToHex)((0, _utilCrypto.decodeAddress)(to)), value) // Create transfer transaction
     .withAccount(from) // Set sender account
     .calculateGas(); // Add account arg to extrinsic
@@ -70,9 +74,9 @@ const createTransferExtrinsic = async _ref => {
     transfer = transaction.extrinsic;
     transferAmount = value;
   } else if (_constants._TRANSFER_CHAIN_GROUP.acala.includes(networkKey)) {
-    if (!(0, _utils2._isNativeToken)(tokenInfo)) {
+    if (!(0, _utils3._isNativeToken)(tokenInfo)) {
       if (isTxCurrenciesSupported) {
-        transfer = api.tx.currencies.transfer(to, (0, _utils2._getTokenOnChainInfo)(tokenInfo), value);
+        transfer = api.tx.currencies.transfer(to, (0, _utils3._getTokenOnChainInfo)(tokenInfo), value);
       }
     } else {
       if (transferAll) {
@@ -83,23 +87,23 @@ const createTransferExtrinsic = async _ref => {
     }
   } else if (_constants._TRANSFER_CHAIN_GROUP.kintsugi.includes(networkKey) && isTxTokensSupported) {
     if (transferAll) {
-      transfer = api.tx.tokens.transferAll(to, (0, _utils2._getTokenOnChainInfo)(tokenInfo) || (0, _utils2._getTokenOnChainAssetId)(tokenInfo), false);
+      transfer = api.tx.tokens.transferAll(to, (0, _utils3._getTokenOnChainInfo)(tokenInfo) || (0, _utils3._getTokenOnChainAssetId)(tokenInfo), false);
     } else if (value) {
-      transfer = api.tx.tokens.transfer(to, (0, _utils2._getTokenOnChainInfo)(tokenInfo) || (0, _utils2._getTokenOnChainAssetId)(tokenInfo), new _util.BN(value));
+      transfer = api.tx.tokens.transfer(to, (0, _utils3._getTokenOnChainInfo)(tokenInfo) || (0, _utils3._getTokenOnChainAssetId)(tokenInfo), new _util.BN(value));
     }
-  } else if (_constants._TRANSFER_CHAIN_GROUP.pendulum.includes(networkKey) && isTxTokensSupported && !(0, _utils2._isNativeToken)(tokenInfo)) {
+  } else if (_constants._TRANSFER_CHAIN_GROUP.pendulum.includes(networkKey) && isTxTokensSupported && !(0, _utils3._isNativeToken)(tokenInfo)) {
     if (transferAll) {
-      transfer = api.tx.tokens.transferAll(to, (0, _utils2._getTokenOnChainInfo)(tokenInfo) || (0, _utils2._getTokenOnChainAssetId)(tokenInfo), false);
+      transfer = api.tx.tokens.transferAll(to, (0, _utils3._getTokenOnChainInfo)(tokenInfo) || (0, _utils3._getTokenOnChainAssetId)(tokenInfo), false);
     } else if (value) {
-      transfer = api.tx.tokens.transfer(to, (0, _utils2._getTokenOnChainInfo)(tokenInfo) || (0, _utils2._getTokenOnChainAssetId)(tokenInfo), new _util.BN(value));
+      transfer = api.tx.tokens.transfer(to, (0, _utils3._getTokenOnChainInfo)(tokenInfo) || (0, _utils3._getTokenOnChainAssetId)(tokenInfo), new _util.BN(value));
     }
-  } else if (_constants._TRANSFER_CHAIN_GROUP.bitcountry.includes(networkKey) && !(0, _utils2._isNativeToken)(tokenInfo)) {
-    transfer = api.tx.currencies.transfer(to, (0, _utils2._getTokenOnChainInfo)(tokenInfo), value);
-  } else if (_constants._TRANSFER_CHAIN_GROUP.statemine.includes(networkKey) && !(0, _utils2._isNativeToken)(tokenInfo)) {
-    transfer = api.tx.assets.transfer((0, _utils2._getTokenOnChainAssetId)(tokenInfo), to, value);
+  } else if (_constants._TRANSFER_CHAIN_GROUP.bitcountry.includes(networkKey) && !(0, _utils3._isNativeToken)(tokenInfo)) {
+    transfer = api.tx.currencies.transfer(to, (0, _utils3._getTokenOnChainInfo)(tokenInfo), value);
+  } else if (_constants._TRANSFER_CHAIN_GROUP.statemine.includes(networkKey) && !(0, _utils3._isNativeToken)(tokenInfo)) {
+    transfer = api.tx.assets.transfer((0, _utils3._getTokenOnChainAssetId)(tokenInfo), to, value);
   } else if (_constants._TRANSFER_CHAIN_GROUP.sora_substrate.includes(networkKey) && isTxAssetsSupported) {
-    transfer = api.tx.assets.transfer((0, _utils2._getTokenOnChainAssetId)(tokenInfo), to, value);
-  } else if (isTxBalancesSupported && (0, _utils2._isNativeToken)(tokenInfo)) {
+    transfer = api.tx.assets.transfer((0, _utils3._getTokenOnChainAssetId)(tokenInfo), to, value);
+  } else if (isTxBalancesSupported && (0, _utils3._isNativeToken)(tokenInfo)) {
     if (_constants._TRANSFER_CHAIN_GROUP.disable_transfer.includes(networkKey)) {
       return [null, transferAmount || value];
     }
@@ -119,7 +123,7 @@ exports.createTransferExtrinsic = createTransferExtrinsic;
 const getTransferMockTxFee = async (address, chainInfo, tokenInfo, api) => {
   try {
     let estimatedFee;
-    if ((0, _utils2._isChainEvmCompatible)(chainInfo) && (0, _utils2._isTokenTransferredByEvm)(tokenInfo)) {
+    if ((0, _utils3._isChainEvmCompatible)(chainInfo) && (0, _utils3._isTokenTransferredByEvm)(tokenInfo)) {
       const web3 = api;
       const transaction = {
         value: 0,
@@ -128,13 +132,26 @@ const getTransferMockTxFee = async (address, chainInfo, tokenInfo, api) => {
         from: address
       };
       const gasLimit = await web3.api.eth.estimateGas(transaction);
-      const priority = await (0, _utils3.calculateGasFeeParams)(web3, chainInfo.slug);
+      const priority = await (0, _utils4.calculateGasFeeParams)(web3, chainInfo.slug);
       if (priority.baseGasFee) {
         const maxFee = priority.maxFeePerGas;
         estimatedFee = maxFee.multipliedBy(gasLimit);
       } else {
         estimatedFee = new _bignumber.default(priority.gasPrice).multipliedBy(gasLimit);
       }
+    } else if ((0, _utils3._isChainTonCompatible)(chainInfo) && (0, _utils3._isTokenTransferredByTon)(tokenInfo)) {
+      const mockWalletContract = _uiKeyring.keyring.getPair(address).ton.currentContract;
+      const tonApi = api;
+      const maxBlance = await tonApi.getBalance(_ton.Address.parse(address));
+      const mockMessage = (0, _core.internal)({
+        to: address,
+        // anyAddress
+        value: maxBlance,
+        // estimate value
+        bounce: false // anyMode
+      });
+
+      estimatedFee = new _bignumber.default((await (0, _utils2.estimateTonTxFee)(tonApi, [mockMessage], mockWalletContract)).toString());
     } else {
       var _paymentInfo$partialF;
       const substrateApi = api;

package/cjs/services/balance-service/transfer/ton-transfer.js

@@ -0,0 +1,136 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTonTransaction = createTonTransaction;
+var _consts = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/consts");
+var _utils = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/utils");
+var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
+var _uiKeyring = require("@subwallet/ui-keyring");
+var _core = require("@ton/core");
+var _ton = require("@ton/ton");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+async function createTonTransaction(_ref) {
+  let {
+    from,
+    networkKey,
+    to,
+    tokenInfo,
+    tonApi,
+    transferAll,
+    value
+  } = _ref;
+  if ((0, _utils2._isNativeToken)(tokenInfo)) {
+    return createTonNativeTransaction({
+      from,
+      to,
+      networkKey,
+      tokenInfo,
+      value: value || '0',
+      transferAll: transferAll,
+      tonApi
+    });
+  }
+  if ((0, _utils2._isJettonToken)(tokenInfo)) {
+    return createJettonTransaction({
+      from,
+      to,
+      networkKey,
+      tokenInfo,
+      value: value || '0',
+      transferAll: transferAll,
+      tonApi
+    });
+  }
+  return [null, value];
+}
+async function createTonNativeTransaction(_ref2) {
+  let {
+    from,
+    networkKey,
+    to,
+    tonApi,
+    transferAll,
+    value
+  } = _ref2;
+  const walletContract = _uiKeyring.keyring.getPair(from).ton.currentContract;
+  const contract = tonApi.open(walletContract);
+  const seqno = await contract.getSeqno();
+  const messages = (0, _core.internal)({
+    to: to,
+    value: (0, _core.fromNano)(value),
+    bounce: false // todo: check and update the send bounced logic
+  });
+
+  const messagePayload = (0, _utils.cellToBase64Str)((0, _utils.messageRelaxedToCell)(messages));
+  const estimateExternalFee = await (0, _utils.estimateTonTxFee)(tonApi, [messages], walletContract);
+  const transactionObject = {
+    from,
+    to,
+    networkKey,
+    value: value,
+    messagePayload,
+    messages: [messages],
+    estimateFee: estimateExternalFee.toString(),
+    seqno,
+    transferAll
+  };
+  return [transactionObject, transactionObject.value];
+}
+async function createJettonTransaction(_ref3) {
+  let {
+    from,
+    networkKey,
+    to,
+    tokenInfo,
+    tonApi,
+    transferAll,
+    value
+  } = _ref3;
+  const walletContract = _uiKeyring.keyring.getPair(from).ton.currentContract;
+  const sendertonAddress = _ton.Address.parse(from);
+  const destinationAddress = _ton.Address.parse(to);
+  const contract = tonApi.open(walletContract);
+  const seqno = await contract.getSeqno();
+
+  // retrieve jetton info
+  const jettonContractAddress = _ton.Address.parse((0, _utils2._getContractAddressOfToken)(tokenInfo));
+  const jettonMasterContract = tonApi.open(_ton.JettonMaster.create(jettonContractAddress));
+  const jettonWalletAddress = await jettonMasterContract.getWalletAddress(sendertonAddress);
+  const messageBody = (0, _core.beginCell)().storeUint(_consts.TON_OPCODES.JETTON_TRANSFER, 32) // opcode for jetton transfer
+  .storeUint((0, _utils.getWalletQueryId)(), 64) // query id
+  .storeCoins(BigInt(value)) // jetton bigint amount
+  .storeAddress(destinationAddress).storeAddress(sendertonAddress) // response destination, who get remain token
+  .storeBit(0) // no custom payload
+  .storeCoins(BigInt(1)) // forward amount - if >0, will send notification message
+  .storeBit(0) // no forward payload
+  // .storeRef(forwardPayload)
+  .endCell();
+  const messages = (0, _core.internal)({
+    to: jettonWalletAddress,
+    // JettonWallet of sender
+    value: (0, _core.toNano)(_consts.INIT_FEE_JETTON_TRANSFER),
+    // set this for fee, excess later
+    bounce: true,
+    // todo: check and update the send bounced logic
+    body: messageBody
+  });
+  const messagePayload = (0, _utils.cellToBase64Str)((0, _utils.messageRelaxedToCell)(messages));
+  const estimateExternalFee = await (0, _utils.estimateTonTxFee)(tonApi, [messages], walletContract);
+  const estimateFee = (0, _core.toNano)(_consts.INIT_FEE_JETTON_TRANSFER) > estimateExternalFee ? (0, _core.toNano)(_consts.INIT_FEE_JETTON_TRANSFER) : estimateExternalFee;
+  const transactionObject = {
+    from,
+    to,
+    networkKey,
+    value,
+    messagePayload,
+    messages: [messages],
+    estimateFee: estimateFee.toString(),
+    seqno,
+    transferAll
+  };
+  return [transactionObject, transactionObject.value];
+}

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

@@ -4,12 +4,16 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+var _types = require("@subwallet/extension-base/types");
 var _fetchStaticData = require("@subwallet/extension-base/utils/fetchStaticData");
 var _rxjs = require("rxjs");
 var _constants = require("./constants");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+const convertSupportType = support => {
+  return support === 'ETHEREUM' ? _types.AccountChainType.ETHEREUM : _types.AccountChainType.SUBSTRATE;
+};
 class BuyService {
   #state;
   buyTokensSubject = new _rxjs.BehaviorSubject({});
@@ -35,7 +39,7 @@ class BuyService {
         serviceInfo: {
           ..._constants.DEFAULT_SERVICE_INFO
         },
-        support: datum.support,
+        support: convertSupportType(datum.support),
         services: [],
         slug: datum.slug,
         symbol: datum.symbol,

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

@@ -297,7 +297,7 @@ const _XCM_TYPE = {
   PR: `${_types._SubstrateChainType.PARACHAIN}-${_types._SubstrateChainType.RELAYCHAIN}` // UMP
 };
 exports._XCM_TYPE = _XCM_TYPE;
-const _DEFAULT_ACTIVE_CHAINS = [..._chainList._DEFAULT_CHAINS, 'vara_network'];
+const _DEFAULT_ACTIVE_CHAINS = [..._chainList._DEFAULT_CHAINS, 'vara_network', 'ton'];
 exports._DEFAULT_ACTIVE_CHAINS = _DEFAULT_ACTIVE_CHAINS;
 const EVM_PASS_CONNECT_STATUS = {
   arbitrum_one: ['*'],

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

@@ -215,6 +215,7 @@ class SubstrateApi {
     console.log(`Connected to ${this.chainSlug || ''} at ${this.apiUrl}`);
     if (this.isApiReadyOnce) {
       this.handleApiReady.resolve(this);
+      this.isApiReady = true;
     }
   }
   onDisconnect() {

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

@@ -0,0 +1,213 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TonApi = void 0;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _consts = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/consts");
+var _utils = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/utils");
+var _types = require("@subwallet/extension-base/services/chain-service/types");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _ton = require("@ton/ton");
+var _rxjs = require("rxjs");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class TonApi {
+  apiRetry = 0;
+  isApiConnectedSubject = new _rxjs.BehaviorSubject(false);
+  connectionStatusSubject = new _rxjs.BehaviorSubject(_types._ChainConnectionStatus.DISCONNECTED);
+  isApiReady = false;
+  isApiReadyOnce = false;
+  constructor(chainSlug, apiUrl, _ref) {
+    let {
+      providerName
+    } = _ref;
+    this.chainSlug = chainSlug;
+    this.apiUrl = apiUrl;
+    this.providerName = providerName || 'unknown';
+    this.api = this.createProvider(apiUrl);
+    this.isReadyHandler = (0, _utils2.createPromiseHandler)();
+    this.connect();
+  }
+  get isApiConnected() {
+    return this.isApiConnectedSubject.getValue();
+  }
+  get connectionStatus() {
+    return this.connectionStatusSubject.getValue();
+  }
+  updateConnectionStatus(status) {
+    const isConnected = status === _types._ChainConnectionStatus.CONNECTED;
+    if (isConnected !== this.isApiConnectedSubject.value) {
+      this.isApiConnectedSubject.next(isConnected);
+    }
+    if (status !== this.connectionStatusSubject.value) {
+      this.connectionStatusSubject.next(status);
+    }
+  }
+  get isReady() {
+    return this.isReadyHandler.promise;
+  }
+  async updateApiUrl(apiUrl) {
+    if (this.apiUrl === apiUrl) {
+      return;
+    }
+    await this.disconnect();
+
+    // Create new provider and api
+    this.apiUrl = apiUrl;
+    this.api = new _ton.TonClient({
+      endpoint: this.getJsonRpc(this.apiUrl),
+      apiKey: _consts.TON_CENTER_API_KEY
+    });
+  }
+  async recoverConnect() {
+    await this.disconnect();
+    this.connect();
+    await this.isReadyHandler.promise;
+  }
+  createProvider(apiUrl) {
+    return new _ton.TonClient({
+      endpoint: this.getJsonRpc(apiUrl),
+      apiKey: _consts.TON_CENTER_API_KEY
+    });
+  }
+  getJsonRpc(url) {
+    return `${url}/jsonRPC`;
+  }
+  connect() {
+    this.updateConnectionStatus(_types._ChainConnectionStatus.CONNECTING);
+    // There isn't a persistent network connection underlying TonClient. Cant check connection status.
+    // this.isApiReadyOnce = true;
+    this.onConnect();
+  }
+  async disconnect() {
+    this.onDisconnect();
+    this.updateConnectionStatus(_types._ChainConnectionStatus.DISCONNECTED);
+    return Promise.resolve();
+  }
+  destroy() {
+    // Todo: implement this in the future
+    return this.disconnect();
+  }
+  onConnect() {
+    if (!this.isApiConnected) {
+      console.log(`Connected to ${this.chainSlug} at ${this.apiUrl}`);
+      this.isApiReady = true;
+      if (this.isApiReadyOnce) {
+        this.isReadyHandler.resolve(this);
+      }
+    }
+    this.updateConnectionStatus(_types._ChainConnectionStatus.CONNECTED);
+  }
+  onDisconnect() {
+    this.updateConnectionStatus(_types._ChainConnectionStatus.DISCONNECTED);
+    if (this.isApiConnected) {
+      console.warn(`Disconnected from ${this.chainSlug} of ${this.apiUrl}`);
+      this.isApiReady = false;
+      this.isReadyHandler = (0, _utils2.createPromiseHandler)();
+    }
+  }
+
+  // Util functions
+
+  async getBalance(address) {
+    return await this.api.getBalance(address);
+  }
+  open(src) {
+    return this.api.open(src);
+  }
+  estimateExternalMessageFee(walletContract, body, isInit) {
+    let ignoreSignature = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+    const initCode = isInit ? null : walletContract.init.code;
+    const initData = isInit ? null : walletContract.init.data;
+    return this.api.estimateExternalMessageFee(walletContract.address, {
+      body: body,
+      ignoreSignature: ignoreSignature,
+      initCode: initCode,
+      initData: initData
+    });
+  }
+  async sendTonTransaction(boc) {
+    try {
+      const url = `${this.apiUrl}/api/v2/sendBocReturnHash`;
+      const resp = await fetch(url, {
+        method: 'POST',
+        headers: {
+          accept: 'application/json',
+          'Content-Type': 'application/json',
+          'X-API-KEY': _consts.TON_CENTER_API_KEY
+        },
+        body: JSON.stringify({
+          boc: boc
+        })
+      });
+      const extMsgInfo = await resp.json();
+      return extMsgInfo.result.hash;
+    } catch (error) {
+      console.error('Failed to send transaction with boc', boc);
+      throw error;
+    }
+  }
+  async getTxByInMsg(extMsgHash) {
+    const url = `${this.apiUrl}/api/v3/transactionsByMessage?msg_hash=${encodeURIComponent(extMsgHash)}&direction=in`;
+    const resp = await fetch(url, {
+      method: 'GET',
+      headers: {
+        accept: 'application/json',
+        'Content-Type': 'application/json',
+        'X-API-KEY': _consts.TON_CENTER_API_KEY
+      }
+    });
+    return await resp.json();
+  }
+  async getStatusByExtMsgHash(extMsgHash, extrinsicType) {
+    return (0, _utils.retry)(async () => {
+      var _externalTxInfo$out_m, _externalTxInfo$out_m2;
+      // retry many times to get transaction status and transaction hex
+      const externalTxInfoRaw = await this.getTxByInMsg(extMsgHash);
+      const externalTxInfo = externalTxInfoRaw.transactions[0];
+      const isExternalTxCompute = externalTxInfo.description.compute_ph.success;
+      const isExternalTxAction = externalTxInfo.description.action.success;
+      const base64Hex = externalTxInfo.hash;
+      const hex = '0x'.concat(Buffer.from(base64Hex, 'base64').toString('hex'));
+      if (!(isExternalTxCompute && isExternalTxAction)) {
+        return [false, hex];
+      }
+      if (extrinsicType === _KoniTypes.ExtrinsicType.TRANSFER_BALANCE) {
+        return [true, hex];
+      }
+
+      // get out msg info from tx
+      const internalMsgHash = (_externalTxInfo$out_m = externalTxInfo.out_msgs[0]) === null || _externalTxInfo$out_m === void 0 ? void 0 : _externalTxInfo$out_m.hash;
+      const opcode = parseInt(((_externalTxInfo$out_m2 = externalTxInfo.out_msgs[0]) === null || _externalTxInfo$out_m2 === void 0 ? void 0 : _externalTxInfo$out_m2.opcode) || '0');
+      if (internalMsgHash) {
+        // notice to update opcode check when supporting more transaction type in ton blockchain
+        const status = opcode === _consts.TON_OPCODES.JETTON_TRANSFER ? await (0, _utils.getJettonTxStatus)(this, internalMsgHash) : false;
+        return [status, hex];
+      }
+      throw new Error('Transaction not found');
+    }, {
+      retries: 10,
+      delay: 5000
+    });
+  }
+  async getAccountState(address) {
+    const url = `${this.apiUrl}/api/v2/getAddressState?address=${address}`;
+    const resp = await fetch(url, {
+      method: 'GET',
+      headers: {
+        accept: 'application/json',
+        'Content-Type': 'application/json',
+        'X-API-KEY': _consts.TON_CENTER_API_KEY
+      }
+    });
+    const accountStateInfo = await resp.json();
+    if (accountStateInfo.ok) {
+      return accountStateInfo.result;
+    }
+    return 'unknown';
+  }
+}
+exports.TonApi = TonApi;

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

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TonChainHandler = void 0;
+var _AbstractChainHandler = require("@subwallet/extension-base/services/chain-service/handler/AbstractChainHandler");
+var _TonApi = require("@subwallet/extension-base/services/chain-service/handler/TonApi");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class TonChainHandler extends _AbstractChainHandler.AbstractChainHandler {
+  tonApiMap = {};
+
+  // eslint-disable-next-line no-useless-constructor
+  constructor(parent) {
+    super(parent);
+  }
+  getTonApiMap() {
+    return this.tonApiMap;
+  }
+  getTonApiByChain(chain) {
+    return this.tonApiMap[chain];
+  }
+  getApiByChain(chain) {
+    return this.getTonApiByChain(chain);
+  }
+  setTonApi(chain, tonApi) {
+    this.tonApiMap[chain] = tonApi;
+  }
+  async initApi(chainSlug, apiUrl) {
+    let {
+      onUpdateStatus,
+      providerName
+    } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    const existed = this.getTonApiByChain(chainSlug);
+    if (existed) {
+      existed.connect();
+      if (apiUrl !== existed.apiUrl) {
+        existed.updateApiUrl(apiUrl).catch(console.error);
+      }
+      return existed;
+    }
+    const apiObject = new _TonApi.TonApi(chainSlug, apiUrl, {
+      providerName
+    });
+    apiObject.connectionStatusSubject.subscribe(this.handleConnection.bind(this, chainSlug));
+    apiObject.connectionStatusSubject.subscribe(onUpdateStatus);
+    return Promise.resolve(apiObject);
+  }
+  async recoverApi(chain) {
+    const existed = this.getTonApiByChain(chain);
+    if (existed && !existed.isApiReadyOnce) {
+      console.log(`Reconnect ${existed.providerName || existed.chainSlug} at ${existed.apiUrl}`);
+      return existed.recoverConnect();
+    }
+  }
+  destroyTonApi(chain) {
+    const tonApi = this.getTonApiByChain(chain);
+    tonApi === null || tonApi === void 0 ? void 0 : tonApi.destroy().catch(console.error);
+  }
+  async sleep() {
+    this.isSleeping = true;
+    this.cancelAllRecover();
+    await Promise.all(Object.values(this.getTonApiMap()).map(tonApi => {
+      return tonApi.disconnect().catch(console.error);
+    }));
+    return Promise.resolve();
+  }
+  wakeUp() {
+    var _this$parent;
+    this.isSleeping = false;
+    const activeChains = ((_this$parent = this.parent) === null || _this$parent === void 0 ? void 0 : _this$parent.getActiveChains()) || [];
+    for (const chain of activeChains) {
+      const tonApi = this.getTonApiByChain(chain);
+      tonApi === null || tonApi === void 0 ? void 0 : tonApi.connect();
+    }
+    return Promise.resolve();
+  }
+}
+exports.TonChainHandler = TonChainHandler;