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

package/services/balance-service/index.js

@@ -10,6 +10,8 @@ import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
 import { _getChainNativeTokenSlug, _isPureEvmChain } from '@subwallet/extension-base/services/chain-service/utils';
 import DetectAccountBalanceStore from '@subwallet/extension-base/stores/DetectAccountBalance';
 import { addLazy, createPromiseHandler, isAccountAll, waitTimeout } from '@subwallet/extension-base/utils';
+import { getKeypairTypeByAddress } from '@subwallet/keyring';
+import { EthereumKeypairTypes, SubstrateKeypairTypes } from '@subwallet/keyring/types';
 import keyring from '@subwallet/ui-keyring';
 import { t } from 'i18next';
 import { BehaviorSubject } from 'rxjs';
@@ -38,7 +40,7 @@ export class BalanceService {
    */
   constructor(state) {
     this.state = state;
-    this.balanceMap = new BalanceMapImpl();
+    this.balanceMap = new BalanceMapImpl(state);
   }
 
   /** Init service */
@@ -61,7 +63,7 @@ export class BalanceService {
   /** Restore balance map */
   async loadData() {
     const backupBalanceData = await this.state.dbService.getStoredBalance();
-    this.balanceMap.updateBalanceItems(backupBalanceData, true);
+    this.balanceMap.updateBalanceItems(backupBalanceData, ALL_ACCOUNT_KEY);
   }
 
   /** Start service */
@@ -127,7 +129,7 @@ export 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;
       }
@@ -187,8 +189,9 @@ export 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 = noop;
-      unsub = subscribeBalance([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, result => {
+      unsub = subscribeBalance([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, result => {
         const rs = result[0];
         if (rs.tokenSlug === tSlug) {
           hasError = false;
@@ -281,10 +284,12 @@ export class BalanceService {
         this.balanceUpdateCache.push(balance);
       }
       addLazy('updateBalanceStore', () => {
-        const isAllAccount = isAccountAll(this.state.keyringService.currentAccount.address);
-        this.balanceMap.updateBalanceItems(this.balanceUpdateCache, isAllAccount);
-        if (isAllAccount) {
-          this.balanceUpdateCache = [...this.balanceUpdateCache, ...Object.values(this.balanceMap.map[ALL_ACCOUNT_KEY])];
+        const proxyId = this.state.keyringService.context.currentAccount.proxyId;
+        const isUnifiedAccount = this.state.keyringService.context.isUnifiedAccount(proxyId);
+        const isAll = 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 = [];
@@ -312,7 +317,7 @@ export 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;
     }
@@ -324,13 +329,14 @@ export 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 = subscribeBalance(addresses, activeChainSlugs, assets, assetMap, chainInfoMap, substrateApiMap, evmApiMap, result => {
+    const unsub = subscribeBalance(addresses, activeChainSlugs, assets, assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, result => {
       !cancel && this.setBalanceItem(result);
     }, ExtrinsicType.TRANSFER_BALANCE);
     const unsub2 = this.state.subscribeMantaPayBalance();
@@ -362,10 +368,16 @@ export 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 = getKeypairTypeByAddress(address);
+      const typeValid = [...SubstrateKeypairTypes, ...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 = [];

package/services/balance-service/transfer/token.d.ts

@@ -1,5 +1,5 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
-import { _EvmApi, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import { _EvmApi, _SubstrateApi, _TonApi } from '@subwallet/extension-base/services/chain-service/types';
 import BigN from 'bignumber.js';
 import { SubmittableExtrinsic } from '@polkadot/api/promise/types';
 interface CreateTransferExtrinsicProps {
@@ -12,5 +12,5 @@ interface CreateTransferExtrinsicProps {
     tokenInfo: _ChainAsset;
 }
 export declare const createTransferExtrinsic: ({ from, networkKey, substrateApi, to, tokenInfo, transferAll, value }: CreateTransferExtrinsicProps) => Promise<[SubmittableExtrinsic | null, string]>;
-export declare const getTransferMockTxFee: (address: string, chainInfo: _ChainInfo, tokenInfo: _ChainAsset, api: _SubstrateApi | _EvmApi) => Promise<BigN>;
+export declare const getTransferMockTxFee: (address: string, chainInfo: _ChainInfo, tokenInfo: _ChainAsset, api: _SubstrateApi | _EvmApi | _TonApi) => Promise<BigN>;
 export {};

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

@@ -5,10 +5,14 @@ import { GearApi } from '@gear-js/api';
 import { _AssetType } from '@subwallet/chain-list/types';
 import { getPSP22ContractPromise } from '@subwallet/extension-base/koni/api/contract-handler/wasm';
 import { getWasmContractGasLimit } from '@subwallet/extension-base/koni/api/contract-handler/wasm/utils';
+import { estimateTonTxFee } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/utils';
 import { _TRANSFER_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
-import { _getContractAddressOfToken, _getTokenOnChainAssetId, _getTokenOnChainInfo, _getXcmAssetMultilocation, _isBridgedToken, _isChainEvmCompatible, _isNativeToken, _isTokenGearSmartContract, _isTokenTransferredByEvm, _isTokenWasmSmartContract } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getContractAddressOfToken, _getTokenOnChainAssetId, _getTokenOnChainInfo, _getXcmAssetMultilocation, _isBridgedToken, _isChainEvmCompatible, _isChainTonCompatible, _isNativeToken, _isTokenGearSmartContract, _isTokenTransferredByEvm, _isTokenTransferredByTon, _isTokenWasmSmartContract } from '@subwallet/extension-base/services/chain-service/utils';
 import { calculateGasFeeParams } from '@subwallet/extension-base/services/fee-service/utils';
 import { getGRC20ContractPromise, getVFTContractPromise } from '@subwallet/extension-base/utils';
+import { keyring } from '@subwallet/ui-keyring';
+import { internal } from '@ton/core';
+import { Address } from '@ton/ton';
 import BigN from 'bignumber.js';
 import { BN, u8aToHex } from '@polkadot/util';
 import { decodeAddress } from '@polkadot/util-crypto';
@@ -126,6 +130,19 @@ export const getTransferMockTxFee = async (address, chainInfo, tokenInfo, api) =
       } else {
         estimatedFee = new BigN(priority.gasPrice).multipliedBy(gasLimit);
       }
+    } else if (_isChainTonCompatible(chainInfo) && _isTokenTransferredByTon(tokenInfo)) {
+      const mockWalletContract = keyring.getPair(address).ton.currentContract;
+      const tonApi = api;
+      const maxBlance = await tonApi.getBalance(Address.parse(address));
+      const mockMessage = internal({
+        to: address,
+        // anyAddress
+        value: maxBlance,
+        // estimate value
+        bounce: false // anyMode
+      });
+
+      estimatedFee = new BigN((await estimateTonTxFee(tonApi, [mockMessage], mockWalletContract)).toString());
     } else {
       var _paymentInfo$partialF;
       const substrateApi = api;

package/services/balance-service/transfer/ton-transfer.d.ts

@@ -0,0 +1,25 @@
+import { _ChainAsset } from '@subwallet/chain-list/types';
+import { _TonApi } from '@subwallet/extension-base/services/chain-service/types';
+import { MessageRelaxed } from '@ton/core';
+interface TonTransactionConfigProps {
+    tokenInfo: _ChainAsset;
+    from: string;
+    to: string;
+    networkKey: string;
+    value: string;
+    transferAll: boolean;
+    tonApi: _TonApi;
+}
+export interface TonTransactionConfig {
+    from: string;
+    to: string;
+    networkKey: string;
+    value: string;
+    messagePayload: string;
+    messages: MessageRelaxed[];
+    estimateFee: string;
+    seqno: number;
+    transferAll: boolean;
+}
+export declare function createTonTransaction({ from, networkKey, to, tokenInfo, tonApi, transferAll, value }: TonTransactionConfigProps): Promise<[TonTransactionConfig | null, string]>;
+export {};

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

@@ -0,0 +1,127 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { INIT_FEE_JETTON_TRANSFER, TON_OPCODES } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/consts';
+import { cellToBase64Str, estimateTonTxFee, getWalletQueryId, messageRelaxedToCell } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/utils';
+import { _getContractAddressOfToken, _isJettonToken, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { keyring } from '@subwallet/ui-keyring';
+import { beginCell, fromNano, internal, toNano } from '@ton/core';
+import { Address, JettonMaster } from '@ton/ton';
+export async function createTonTransaction({
+  from,
+  networkKey,
+  to,
+  tokenInfo,
+  tonApi,
+  transferAll,
+  value
+}) {
+  if (_isNativeToken(tokenInfo)) {
+    return createTonNativeTransaction({
+      from,
+      to,
+      networkKey,
+      tokenInfo,
+      value: value || '0',
+      transferAll: transferAll,
+      tonApi
+    });
+  }
+  if (_isJettonToken(tokenInfo)) {
+    return createJettonTransaction({
+      from,
+      to,
+      networkKey,
+      tokenInfo,
+      value: value || '0',
+      transferAll: transferAll,
+      tonApi
+    });
+  }
+  return [null, value];
+}
+async function createTonNativeTransaction({
+  from,
+  networkKey,
+  to,
+  tonApi,
+  transferAll,
+  value
+}) {
+  const walletContract = keyring.getPair(from).ton.currentContract;
+  const contract = tonApi.open(walletContract);
+  const seqno = await contract.getSeqno();
+  const messages = internal({
+    to: to,
+    value: fromNano(value),
+    bounce: false // todo: check and update the send bounced logic
+  });
+
+  const messagePayload = cellToBase64Str(messageRelaxedToCell(messages));
+  const estimateExternalFee = await 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({
+  from,
+  networkKey,
+  to,
+  tokenInfo,
+  tonApi,
+  transferAll,
+  value
+}) {
+  const walletContract = keyring.getPair(from).ton.currentContract;
+  const sendertonAddress = Address.parse(from);
+  const destinationAddress = Address.parse(to);
+  const contract = tonApi.open(walletContract);
+  const seqno = await contract.getSeqno();
+
+  // retrieve jetton info
+  const jettonContractAddress = Address.parse(_getContractAddressOfToken(tokenInfo));
+  const jettonMasterContract = tonApi.open(JettonMaster.create(jettonContractAddress));
+  const jettonWalletAddress = await jettonMasterContract.getWalletAddress(sendertonAddress);
+  const messageBody = beginCell().storeUint(TON_OPCODES.JETTON_TRANSFER, 32) // opcode for jetton transfer
+  .storeUint(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 = internal({
+    to: jettonWalletAddress,
+    // JettonWallet of sender
+    value: toNano(INIT_FEE_JETTON_TRANSFER),
+    // set this for fee, excess later
+    bounce: true,
+    // todo: check and update the send bounced logic
+    body: messageBody
+  });
+  const messagePayload = cellToBase64Str(messageRelaxedToCell(messages));
+  const estimateExternalFee = await estimateTonTxFee(tonApi, [messages], walletContract);
+  const estimateFee = toNano(INIT_FEE_JETTON_TRANSFER) > estimateExternalFee ? toNano(INIT_FEE_JETTON_TRANSFER) : estimateExternalFee;
+  const transactionObject = {
+    from,
+    to,
+    networkKey,
+    value,
+    messagePayload,
+    messages: [messages],
+    estimateFee: estimateFee.toString(),
+    seqno,
+    transferAll
+  };
+  return [transactionObject, transactionObject.value];
+}

package/services/buy-service/index.js

@@ -1,9 +1,13 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { AccountChainType } from '@subwallet/extension-base/types';
 import { fetchStaticData } from '@subwallet/extension-base/utils/fetchStaticData';
 import { BehaviorSubject } from 'rxjs';
 import { DEFAULT_SERVICE_INFO } from "./constants/index.js";
+const convertSupportType = support => {
+  return support === 'ETHEREUM' ? AccountChainType.ETHEREUM : AccountChainType.SUBSTRATE;
+};
 export default class BuyService {
   #state;
   buyTokensSubject = new BehaviorSubject({});
@@ -29,7 +33,7 @@ export default class BuyService {
         serviceInfo: {
           ...DEFAULT_SERVICE_INFO
         },
-        support: datum.support,
+        support: convertSupportType(datum.support),
         services: [],
         slug: datum.slug,
         symbol: datum.symbol,

package/services/buy-service/types.d.ts

@@ -1,4 +1,4 @@
-import { BuyService, BuyTokenInfo, SupportService } from '@subwallet/extension-base/types';
+import { BuyService, OnrampAccountSupportType, SupportService } from '@subwallet/extension-base/types';
 interface _BuyTokenInfo {
     serviceInfo: Record<string, BuyService & {
         isSuspended: boolean;
@@ -6,7 +6,7 @@ interface _BuyTokenInfo {
     network: string;
     slug: string;
     symbol: string;
-    support: BuyTokenInfo['support'];
+    support: OnrampAccountSupportType;
 }
 interface _BuyServiceInfo {
     id: number;

package/services/chain-service/constants.js

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

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

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

package/services/chain-service/handler/TonApi.d.ts

@@ -0,0 +1,52 @@
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { AccountState, TxByMsgResponse } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/types';
+import { _ApiOptions } from '@subwallet/extension-base/services/chain-service/handler/types';
+import { _ChainConnectionStatus, _TonApi } from '@subwallet/extension-base/services/chain-service/types';
+import { PromiseHandler } from '@subwallet/extension-base/utils';
+import { TonWalletContract } from '@subwallet/keyring/types';
+import { Cell } from '@ton/core';
+import { Address, Contract, OpenedContract } from '@ton/ton';
+import { BehaviorSubject } from 'rxjs';
+export declare class TonApi implements _TonApi {
+    chainSlug: string;
+    private api;
+    apiUrl: string;
+    apiError?: string;
+    apiRetry: number;
+    readonly isApiConnectedSubject: BehaviorSubject<boolean>;
+    readonly connectionStatusSubject: BehaviorSubject<_ChainConnectionStatus>;
+    isApiReady: boolean;
+    isApiReadyOnce: boolean;
+    isReadyHandler: PromiseHandler<_TonApi>;
+    providerName: string;
+    constructor(chainSlug: string, apiUrl: string, { providerName }: _ApiOptions);
+    get isApiConnected(): boolean;
+    get connectionStatus(): _ChainConnectionStatus;
+    private updateConnectionStatus;
+    get isReady(): Promise<_TonApi>;
+    updateApiUrl(apiUrl: string): Promise<void>;
+    recoverConnect(): Promise<void>;
+    private createProvider;
+    private getJsonRpc;
+    connect(): void;
+    disconnect(): Promise<void>;
+    destroy(): Promise<void>;
+    onConnect(): void;
+    onDisconnect(): void;
+    getBalance(address: Address): Promise<bigint>;
+    open<T extends Contract>(src: T): OpenedContract<T>;
+    estimateExternalMessageFee(walletContract: TonWalletContract, body: Cell, isInit: boolean, ignoreSignature?: boolean): Promise<{
+        '@type': "query.fees";
+        source_fees: {
+            '@type': "fees";
+            in_fwd_fee: number;
+            storage_fee: number;
+            gas_fee: number;
+            fwd_fee: number;
+        };
+    }>;
+    sendTonTransaction(boc: string): Promise<string>;
+    getTxByInMsg(extMsgHash: string): Promise<TxByMsgResponse>;
+    getStatusByExtMsgHash(extMsgHash: string, extrinsicType?: ExtrinsicType): Promise<[boolean, string]>;
+    getAccountState(address: string): Promise<AccountState>;
+}

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

@@ -0,0 +1,204 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { TON_CENTER_API_KEY, TON_OPCODES } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/consts';
+import { getJettonTxStatus, retry } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/utils';
+import { _ChainConnectionStatus } from '@subwallet/extension-base/services/chain-service/types';
+import { createPromiseHandler } from '@subwallet/extension-base/utils';
+import { TonClient } from '@ton/ton';
+import { BehaviorSubject } from 'rxjs';
+export class TonApi {
+  apiRetry = 0;
+  isApiConnectedSubject = new BehaviorSubject(false);
+  connectionStatusSubject = new BehaviorSubject(_ChainConnectionStatus.DISCONNECTED);
+  isApiReady = false;
+  isApiReadyOnce = false;
+  constructor(chainSlug, apiUrl, {
+    providerName
+  }) {
+    this.chainSlug = chainSlug;
+    this.apiUrl = apiUrl;
+    this.providerName = providerName || 'unknown';
+    this.api = this.createProvider(apiUrl);
+    this.isReadyHandler = createPromiseHandler();
+    this.connect();
+  }
+  get isApiConnected() {
+    return this.isApiConnectedSubject.getValue();
+  }
+  get connectionStatus() {
+    return this.connectionStatusSubject.getValue();
+  }
+  updateConnectionStatus(status) {
+    const isConnected = status === _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 TonClient({
+      endpoint: this.getJsonRpc(this.apiUrl),
+      apiKey: TON_CENTER_API_KEY
+    });
+  }
+  async recoverConnect() {
+    await this.disconnect();
+    this.connect();
+    await this.isReadyHandler.promise;
+  }
+  createProvider(apiUrl) {
+    return new TonClient({
+      endpoint: this.getJsonRpc(apiUrl),
+      apiKey: TON_CENTER_API_KEY
+    });
+  }
+  getJsonRpc(url) {
+    return `${url}/jsonRPC`;
+  }
+  connect() {
+    this.updateConnectionStatus(_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(_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(_ChainConnectionStatus.CONNECTED);
+  }
+  onDisconnect() {
+    this.updateConnectionStatus(_ChainConnectionStatus.DISCONNECTED);
+    if (this.isApiConnected) {
+      console.warn(`Disconnected from ${this.chainSlug} of ${this.apiUrl}`);
+      this.isApiReady = false;
+      this.isReadyHandler = createPromiseHandler();
+    }
+  }
+
+  // Util functions
+
+  async getBalance(address) {
+    return await this.api.getBalance(address);
+  }
+  open(src) {
+    return this.api.open(src);
+  }
+  estimateExternalMessageFee(walletContract, body, isInit, ignoreSignature = 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': 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': TON_CENTER_API_KEY
+      }
+    });
+    return await resp.json();
+  }
+  async getStatusByExtMsgHash(extMsgHash, extrinsicType) {
+    return 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 === 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 === TON_OPCODES.JETTON_TRANSFER ? await 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': TON_CENTER_API_KEY
+      }
+    });
+    const accountStateInfo = await resp.json();
+    if (accountStateInfo.ok) {
+      return accountStateInfo.result;
+    }
+    return 'unknown';
+  }
+}

package/services/chain-service/handler/TonChainHandler.d.ts

@@ -0,0 +1,17 @@
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { AbstractChainHandler } from '@subwallet/extension-base/services/chain-service/handler/AbstractChainHandler';
+import { TonApi } from '@subwallet/extension-base/services/chain-service/handler/TonApi';
+import { _ApiOptions } from '@subwallet/extension-base/services/chain-service/handler/types';
+export declare class TonChainHandler extends AbstractChainHandler {
+    private tonApiMap;
+    constructor(parent?: ChainService);
+    getTonApiMap(): Record<string, TonApi>;
+    getTonApiByChain(chain: string): TonApi;
+    getApiByChain(chain: string): TonApi;
+    setTonApi(chain: string, tonApi: TonApi): void;
+    initApi(chainSlug: string, apiUrl: string, { onUpdateStatus, providerName }?: Omit<_ApiOptions, 'metadata'>): Promise<TonApi>;
+    recoverApi(chain: string): Promise<void>;
+    destroyTonApi(chain: string): void;
+    sleep(): Promise<void>;
+    wakeUp(): Promise<void>;
+}