@subwallet/extension-base 1.3.22-0 → 1.3.24-0

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

@@ -0,0 +1,114 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import * as csl from '@emurgo/cardano-serialization-lib-nodejs';
+import { _AssetType } from '@subwallet/chain-list/types';
+import { getAdaBelongUtxo, getCardanoTxFee, splitCardanoId } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/cardano/utils';
+import { subwalletApiSdk } from '@subwallet/subwallet-api-sdk';
+export async function createCardanoTransaction(params) {
+  var _tokenInfo$metadata;
+  const {
+    cardanoTtlOffset,
+    from,
+    networkKey,
+    to,
+    tokenInfo,
+    transferAll,
+    value
+  } = params;
+  const cardanoId = (_tokenInfo$metadata = tokenInfo.metadata) === null || _tokenInfo$metadata === void 0 ? void 0 : _tokenInfo$metadata.cardanoId;
+  const isNativeTransfer = tokenInfo.assetType === _AssetType.NATIVE;
+  const isSelfTransfer = from === to;
+  if (!cardanoId) {
+    throw new Error('Missing token policy id metadata');
+  }
+  const payload = await subwalletApiSdk.fetchUnsignedPayload({
+    tokenDecimals: params.tokenInfo.decimals || 0,
+    nativeTokenSymbol: params.nativeTokenInfo.symbol,
+    cardanoId,
+    from: params.from,
+    to: params.to,
+    value: params.value,
+    cardanoTtlOffset: params.cardanoTtlOffset
+  });
+  console.log('Build cardano payload successfully!', payload);
+  validatePayload(payload, params);
+  const fee = getCardanoTxFee(payload);
+  const adaBelongToCnaUtxo = isNativeTransfer || isSelfTransfer ? BigInt(0) : getAdaBelongUtxo(payload, to);
+  const tx = {
+    from,
+    to,
+    networkKey,
+    value,
+    transferAll,
+    cardanoTtlOffset,
+    estimateCardanoFee: (fee + adaBelongToCnaUtxo).toString(),
+    cardanoPayload: payload
+  };
+  return [tx, value];
+}
+function validatePayload(payload, params) {
+  var _params$tokenInfo$met;
+  const txInfo = JSON.parse(csl.Transaction.from_hex(payload).to_json());
+  const outputs = txInfo.body.outputs;
+  const cardanoId = (_params$tokenInfo$met = params.tokenInfo.metadata) === null || _params$tokenInfo$met === void 0 ? void 0 : _params$tokenInfo$met.cardanoId;
+  const assetType = params.tokenInfo.assetType;
+  const isSendSameAddress = params.from === params.to;
+  if (!cardanoId) {
+    throw new Error('Missing cardano id metadata');
+  }
+  const cardanoAssetMetadata = splitCardanoId(cardanoId);
+  if (isSendSameAddress) {
+    validateAllOutputsBelongToAddress(params.from, outputs);
+    validateExistOutputWithAmountSend(params.value, outputs, assetType, cardanoAssetMetadata);
+  } else {
+    const [outputsBelongToReceiver, outputsNotBelongToReceiver] = [outputs.filter(output => output.address === params.to), outputs.filter(output => output.address !== params.to)];
+    validateReceiverOutputsWithAmountSend(params.value, outputsBelongToReceiver, assetType, cardanoAssetMetadata);
+    validateAllOutputsBelongToAddress(params.from, outputsNotBelongToReceiver);
+  }
+}
+function validateAllOutputsBelongToAddress(address, outputs) {
+  const found = outputs.find(output => output.address !== address);
+  if (found) {
+    throw new Error('Transaction has invalid address information');
+  }
+}
+function validateExistOutputWithAmountSend(amount, outputs, assetType, cardanoAssetMetadata) {
+  if (assetType === _AssetType.NATIVE) {
+    const found = outputs.find(output => output.amount.coin === amount);
+    if (found) {
+      return;
+    }
+    throw new Error('Transaction has invalid transfer amount information');
+  }
+  if (assetType === _AssetType.CIP26) {
+    const found = outputs.find(output => {
+      var _output$amount$multia;
+      return amount === ((_output$amount$multia = output.amount.multiasset[cardanoAssetMetadata.policyId]) === null || _output$amount$multia === void 0 ? void 0 : _output$amount$multia[cardanoAssetMetadata.nameHex]);
+    });
+    if (found) {
+      return;
+    }
+    throw new Error('Transaction has invalid transfer amount information');
+  }
+  throw new Error('Invalid asset type!');
+}
+function validateReceiverOutputsWithAmountSend(amount, outputs, assetType, cardanoAssetMetadata) {
+  if (outputs.length !== 1) {
+    throw new Error('Transaction has invalid transfer amount information');
+  }
+  const receiverOutput = outputs[0];
+  if (assetType === _AssetType.NATIVE) {
+    if (receiverOutput.amount.coin === amount) {
+      return;
+    }
+    throw new Error('Transaction has invalid transfer amount information');
+  }
+  if (assetType === _AssetType.CIP26) {
+    if (receiverOutput.amount.multiasset[cardanoAssetMetadata.policyId][cardanoAssetMetadata.nameHex] === amount) {
+      return;
+    }
+    throw new Error('Transaction has invalid transfer amount information');
+  }
+  throw new Error('Invalid asset type!');
+}

package/services/balance-service/transfer/smart-contract.d.ts

@@ -9,9 +9,10 @@ interface TransferEvmProps extends TransactionFee {
     transferAll: boolean;
     value: string;
     evmApi: _EvmApi;
+    fallbackFee?: boolean;
 }
-export declare function getEVMTransactionObject({ chain, evmApi, feeCustom: _feeCustom, feeInfo: _feeInfo, feeOption, from, to, transferAll, value }: TransferEvmProps): Promise<[TransactionConfig, string]>;
-export declare function getERC20TransactionObject({ assetAddress, evmApi, feeCustom: _feeCustom, feeInfo: _feeInfo, feeOption, from, to, transferAll, value }: TransferERC20Props): Promise<[TransactionConfig, string]>;
+export declare function getEVMTransactionObject({ chain, evmApi, fallbackFee, feeCustom: _feeCustom, feeInfo: _feeInfo, feeOption, from, to, transferAll, value }: TransferEvmProps): Promise<[TransactionConfig, string, string]>;
+export declare function getERC20TransactionObject({ assetAddress, chain, evmApi, fallbackFee, feeCustom: _feeCustom, feeInfo: _feeInfo, feeOption, from, to, transferAll, value }: TransferERC20Props): Promise<[TransactionConfig, string, string]>;
 interface TransferERC20Props extends TransactionFee {
     assetAddress: string;
     chain: string;
@@ -21,6 +22,7 @@ interface TransferERC20Props extends TransactionFee {
     to: string;
     transferAll: boolean;
     value: string;
+    fallbackFee?: boolean;
 }
 export declare function getERC721Transaction(web3Api: _EvmApi, chain: string, contractAddress: string, senderAddress: string, recipientAddress: string, tokenId: string, _feeInfo: FeeInfo): Promise<TransactionConfig>;
 export declare function getPSP34TransferExtrinsic(substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null>;

package/services/balance-service/transfer/smart-contract.js

@@ -12,6 +12,7 @@ import { t } from 'i18next';
 export async function getEVMTransactionObject({
   chain,
   evmApi,
+  fallbackFee,
   feeCustom: _feeCustom,
   feeInfo: _feeInfo,
   feeOption,
@@ -23,13 +24,22 @@ export async function getEVMTransactionObject({
   const feeCustom = _feeCustom;
   const feeInfo = _feeInfo;
   const feeCombine = combineEthFee(feeInfo, feeOption, feeCustom);
+  let errorOnEstimateFee = '';
   const transactionObject = {
     to: to,
     value: value,
     from: from,
     ...feeCombine
   };
-  const gasLimit = await evmApi.api.eth.estimateGas(transactionObject);
+  const gasLimit = await evmApi.api.eth.estimateGas(transactionObject).catch(e => {
+    console.log('Cannot estimate fee with native transfer on', chain, e);
+    if (fallbackFee) {
+      errorOnEstimateFee = e.message;
+      return 21000;
+    } else {
+      throw Error('Unable to estimate fee for this transaction. Edit fee and try again.');
+    }
+  });
   transactionObject.gas = gasLimit;
   let estimateFee;
   if (feeCombine.maxFeePerGas) {
@@ -43,11 +53,13 @@ export async function getEVMTransactionObject({
     const numberReplace = 18 - 12;
     transactionObject.value = transactionObject.value.substring(0, transactionObject.value.length - 6) + new Array(numberReplace).fill('0').join('');
   }
-  return [transactionObject, transactionObject.value.toString()];
+  return [transactionObject, transactionObject.value.toString(), errorOnEstimateFee];
 }
 export async function getERC20TransactionObject({
   assetAddress,
+  chain,
   evmApi,
+  fallbackFee,
   feeCustom: _feeCustom,
   feeInfo: _feeInfo,
   feeOption,
@@ -60,6 +72,7 @@ export async function getERC20TransactionObject({
   const feeCustom = _feeCustom;
   let freeAmount = new BigN(0);
   let transferValue = value;
+  let errorOnEstimateFee = '';
   if (transferAll) {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
     const bal = await erc20Contract.methods.balanceOf(from).call();
@@ -74,6 +87,14 @@ export async function getERC20TransactionObject({
   // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
   const gasLimit = await erc20Contract.methods.transfer(to, transferValue).estimateGas({
     from
+  }).catch(e => {
+    console.log('Cannot estimate fee with token contract', assetAddress, chain, e);
+    if (fallbackFee) {
+      errorOnEstimateFee = e.message;
+      return 70000;
+    } else {
+      throw Error('Unable to estimate fee for this transaction. Edit fee and try again.');
+    }
   });
   const feeInfo = _feeInfo;
   const feeCombine = combineEthFee(feeInfo, feeOption, feeCustom);
@@ -89,7 +110,7 @@ export async function getERC20TransactionObject({
     transferValue = freeAmount.toFixed(0);
     transactionObject.data = generateTransferData(to, transferValue);
   }
-  return [transactionObject, transferValue];
+  return [transactionObject, transferValue, errorOnEstimateFee];
 }
 export async function getERC721Transaction(web3Api, chain, contractAddress, senderAddress, recipientAddress, tokenId, _feeInfo) {
   // eslint-disable-next-line @typescript-eslint/no-unsafe-argument

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

@@ -11,6 +11,6 @@ interface CreateTransferExtrinsicProps {
     transferAll: boolean;
     tokenInfo: _ChainAsset;
 }
-export declare const createTransferExtrinsic: ({ from, networkKey, substrateApi, to, tokenInfo, transferAll, value }: CreateTransferExtrinsicProps) => Promise<[SubmittableExtrinsic | null, string]>;
+export declare const createSubstrateExtrinsic: ({ 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 | _TonApi) => Promise<BigN>;
 export {};

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

@@ -16,7 +16,7 @@ import { Address } from '@ton/ton';
 import BigN from 'bignumber.js';
 import { BN, u8aToHex } from '@polkadot/util';
 import { decodeAddress } from '@polkadot/util-crypto';
-export const createTransferExtrinsic = async ({
+export const createSubstrateExtrinsic = async ({
   from,
   networkKey,
   substrateApi,
@@ -148,7 +148,7 @@ export const getTransferMockTxFee = async (address, chainInfo, tokenInfo, api) =
       var _paymentInfo$partialF;
       const substrateApi = api;
       const chainApi = await substrateApi.isReady;
-      const [mockTx] = await createTransferExtrinsic({
+      const [mockTx] = await createSubstrateExtrinsic({
         from: address,
         networkKey: chainInfo.slug,
         substrateApi: chainApi,

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

@@ -0,0 +1,38 @@
+import { CardanoBalanceItem } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/cardano/types';
+import { _ApiOptions } from '@subwallet/extension-base/services/chain-service/handler/types';
+import { _CardanoApi, _ChainConnectionStatus } from '@subwallet/extension-base/services/chain-service/types';
+import { PromiseHandler } from '@subwallet/extension-base/utils';
+import { BehaviorSubject } from 'rxjs';
+export declare const API_KEY: {
+    mainnet: string;
+    testnet: string;
+};
+export declare class CardanoApi implements _CardanoApi {
+    chainSlug: string;
+    apiUrl: string;
+    apiError?: string;
+    apiRetry: number;
+    readonly isApiConnectedSubject: BehaviorSubject<boolean>;
+    readonly connectionStatusSubject: BehaviorSubject<_ChainConnectionStatus>;
+    isApiReady: boolean;
+    isApiReadyOnce: boolean;
+    isReadyHandler: PromiseHandler<_CardanoApi>;
+    isTestnet: boolean;
+    private projectId;
+    providerName: string;
+    constructor(chainSlug: string, apiUrl: string, { isTestnet, providerName }: _ApiOptions);
+    get isApiConnected(): boolean;
+    get connectionStatus(): _ChainConnectionStatus;
+    private updateConnectionStatus;
+    get isReady(): Promise<_CardanoApi>;
+    updateApiUrl(apiUrl: string): Promise<void>;
+    recoverConnect(): Promise<void>;
+    connect(): void;
+    disconnect(): Promise<void>;
+    destroy(): Promise<void>;
+    onConnect(): void;
+    onDisconnect(): void;
+    getBalanceMap(address: string): Promise<CardanoBalanceItem[]>;
+    sendCardanoTxReturnHash(tx: string): Promise<string>;
+    getStatusByTxHash(txHash: string, ttl: number): Promise<boolean>;
+}

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

@@ -0,0 +1,167 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { cborToBytes, retryCardanoTxStatus } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/cardano/utils';
+import { _ChainConnectionStatus } from '@subwallet/extension-base/services/chain-service/types';
+import { createPromiseHandler } from '@subwallet/extension-base/utils';
+import { BehaviorSubject } from 'rxjs';
+import { hexAddPrefix, isHex } from '@polkadot/util';
+export const API_KEY = {
+  mainnet: process.env.BLOCKFROST_API_KEY_MAIN || '',
+  testnet: process.env.BLOCKFROST_API_KEY_PREP || ''
+};
+export class CardanoApi {
+  // private api: BlockFrostAPI;
+
+  apiRetry = 0;
+  isApiConnectedSubject = new BehaviorSubject(false);
+  connectionStatusSubject = new BehaviorSubject(_ChainConnectionStatus.DISCONNECTED);
+  isApiReady = false;
+  isApiReadyOnce = false;
+  constructor(chainSlug, apiUrl, {
+    isTestnet,
+    providerName
+  }) {
+    this.chainSlug = chainSlug;
+    this.apiUrl = apiUrl;
+    this.isTestnet = isTestnet !== null && isTestnet !== void 0 ? isTestnet : true;
+    this.projectId = isTestnet ? API_KEY.testnet : API_KEY.mainnet;
+    this.providerName = providerName || 'unknown';
+    // this.api = this.createProvider(isTestnet);
+    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();
+    this.apiUrl = apiUrl;
+    // this.api = this.createProvider();
+  }
+
+  async recoverConnect() {
+    await this.disconnect();
+    this.connect();
+    await this.isReadyHandler.promise;
+  }
+
+  // private createProvider (isTestnet = true): BlockFrostAPI {
+  //   const projectId = isTestnet ? API_KEY.testnet : API_KEY.mainnet;
+  //
+  //   return new BlockFrostAPI({
+  //     projectId
+  //   });
+  // }
+
+  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();
+    }
+  }
+  async getBalanceMap(address) {
+    try {
+      const url = this.isTestnet ? `https://cardano-preprod.blockfrost.io/api/v0/addresses/${address}` : `https://cardano-mainnet.blockfrost.io/api/v0/addresses/${address}`;
+      const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+          Project_id: this.projectId
+        }
+      });
+      const addressBalance = await response.json();
+      return addressBalance.amount;
+    } catch (e) {
+      console.error('Error on getting account balance', e);
+      return [];
+    }
+  }
+  async sendCardanoTxReturnHash(tx) {
+    try {
+      const url = this.isTestnet ? 'https://cardano-preprod.blockfrost.io/api/v0/tx/submit' : 'https://cardano-mainnet.blockfrost.io/api/v0/tx/submit';
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          Project_id: this.projectId,
+          'Content-Type': 'application/cbor'
+        },
+        body: cborToBytes(tx)
+      });
+      const hash = (await response.text()).replace(/^"|"$/g, '');
+      if (isHex(hexAddPrefix(hash))) {
+        return hash;
+      } else {
+        console.error('Error on submitting cardano tx');
+        return '';
+      }
+    } catch (e) {
+      console.error('Error on submitting cardano tx', e);
+      return '';
+    }
+  }
+  async getStatusByTxHash(txHash, ttl) {
+    const cronTime = 30000;
+    return retryCardanoTxStatus(async () => {
+      const url = this.isTestnet ? `https://cardano-preprod.blockfrost.io/api/v0/txs/${txHash}` : `https://cardano-mainnet.blockfrost.io/api/v0/txs/${txHash}`;
+      const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+          Project_id: this.projectId
+        }
+      });
+      const txInfo = await response.json();
+      if (txInfo.block && txInfo.hash && txInfo.index >= 0) {
+        return true;
+      }
+      throw new Error('Transaction not found');
+    }, {
+      retries: ttl / cronTime,
+      delay: cronTime
+    });
+  }
+}

package/services/chain-service/handler/CardanoChainHandler.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 { CardanoApi } from '@subwallet/extension-base/services/chain-service/handler/CardanoApi';
+import { _ApiOptions } from '@subwallet/extension-base/services/chain-service/handler/types';
+export declare class CardanoChainHandler extends AbstractChainHandler {
+    private cardanoApiMap;
+    constructor(parent?: ChainService);
+    getCardanoApiMap(): Record<string, CardanoApi>;
+    getCardanoApiByChain(chain: string): CardanoApi;
+    getApiByChain(chain: string): CardanoApi;
+    setCardanoApi(chain: string, cardanoApi: CardanoApi): void;
+    initApi(chainSlug: string, apiUrl: string, { isTestnet, onUpdateStatus, providerName }?: Omit<_ApiOptions, 'metadata'>): Promise<CardanoApi>;
+    recoverApi(chain: string): Promise<void>;
+    destroyCardanoApi(chain: string): void;
+    sleep(): Promise<void>;
+    wakeUp(): Promise<void>;
+}

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

@@ -0,0 +1,75 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { AbstractChainHandler } from '@subwallet/extension-base/services/chain-service/handler/AbstractChainHandler';
+import { CardanoApi } from '@subwallet/extension-base/services/chain-service/handler/CardanoApi';
+export class CardanoChainHandler extends AbstractChainHandler {
+  cardanoApiMap = {};
+
+  // eslint-disable-next-line no-useless-constructor
+  constructor(parent) {
+    super(parent);
+  }
+  getCardanoApiMap() {
+    return this.cardanoApiMap;
+  }
+  getCardanoApiByChain(chain) {
+    return this.cardanoApiMap[chain];
+  }
+  getApiByChain(chain) {
+    return this.getCardanoApiByChain(chain);
+  }
+  setCardanoApi(chain, cardanoApi) {
+    this.cardanoApiMap[chain] = cardanoApi;
+  }
+  async initApi(chainSlug, apiUrl, {
+    isTestnet,
+    onUpdateStatus,
+    providerName
+  } = {}) {
+    const existed = this.getCardanoApiByChain(chainSlug);
+    if (existed) {
+      existed.connect();
+      if (apiUrl !== existed.apiUrl) {
+        existed.updateApiUrl(apiUrl).catch(console.error);
+      }
+      return existed;
+    }
+    const apiObject = new CardanoApi(chainSlug, apiUrl, {
+      isTestnet,
+      providerName
+    });
+    apiObject.connectionStatusSubject.subscribe(this.handleConnection.bind(this, chainSlug));
+    apiObject.connectionStatusSubject.subscribe(onUpdateStatus);
+    return Promise.resolve(apiObject);
+  }
+  async recoverApi(chain) {
+    const existed = this.getCardanoApiByChain(chain);
+    if (existed && !existed.isApiReadyOnce) {
+      console.log(`Reconnect ${existed.providerName || existed.chainSlug} at ${existed.apiUrl}`);
+      return existed.recoverConnect();
+    }
+  }
+  destroyCardanoApi(chain) {
+    const cardanoApi = this.getCardanoApiByChain(chain);
+    cardanoApi === null || cardanoApi === void 0 ? void 0 : cardanoApi.destroy().catch(console.error);
+  }
+  async sleep() {
+    this.isSleeping = true;
+    this.cancelAllRecover();
+    await Promise.all(Object.values(this.getCardanoApiMap()).map(cardanoApi => {
+      return cardanoApi.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 cardanoApi = this.getCardanoApiByChain(chain);
+      cardanoApi === null || cardanoApi === void 0 ? void 0 : cardanoApi.connect();
+    }
+    return Promise.resolve();
+  }
+}

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

@@ -3,7 +3,7 @@
 
 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 { getJettonTxStatus, retryTonTxStatus } 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';
@@ -50,10 +50,7 @@ export class TonApi {
 
     // Create new provider and api
     this.apiUrl = apiUrl;
-    this.api = new TonClient({
-      endpoint: this.getJsonRpc(this.apiUrl),
-      apiKey: TON_CENTER_API_KEY
-    });
+    this.api = this.createProvider(apiUrl);
   }
   async recoverConnect() {
     await this.disconnect();
@@ -155,7 +152,7 @@ export class TonApi {
     return await resp.json();
   }
   async getStatusByExtMsgHash(extMsgHash, extrinsicType) {
-    return retry(async () => {
+    return retryTonTxStatus(async () => {
       var _externalTxInfo$out_m, _externalTxInfo$out_m2;
       // retry many times to get transaction status and transaction hex
       const externalTxInfoRaw = await this.getTxByInMsg(extMsgHash);

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

@@ -22,6 +22,7 @@ export interface _ApiOptions {
     metadata?: MetadataItem;
     onUpdateStatus?: (status: _ChainConnectionStatus) => void;
     externalApiPromise?: ApiPromise;
+    isTestnet?: boolean;
 }
 export declare enum _CHAIN_VALIDATION_ERROR {
     INVALID_INFO_TYPE = "invalidInfoType",

package/services/chain-service/index.d.ts

@@ -17,6 +17,7 @@ export declare class ChainService {
     private substrateChainHandler;
     private evmChainHandler;
     private tonChainHandler;
+    private cardanoChainHandler;
     private mantaChainHandler;
     refreshLatestChainDataTimeOut: NodeJS.Timer | undefined;
     get mantaPay(): MantaPrivateHandler | undefined;
@@ -54,6 +55,8 @@ export declare class ChainService {
     getSubstrateApiMap(): Record<string, _SubstrateApi>;
     getTonApi(slug: string): import("./handler/TonApi").TonApi;
     getTonApiMap(): Record<string, import("./handler/TonApi").TonApi>;
+    getCardanoApi(slug: string): import("./handler/CardanoApi").CardanoApi;
+    getCardanoApiMap(): Record<string, import("./handler/CardanoApi").CardanoApi>;
     getChainCurrentProviderByKey(slug: string): {
         endpoint: string;
         providerName: string;
@@ -69,6 +72,7 @@ export declare class ChainService {
     getMultiChainAssetMap(): Record<string, _MultiChainAsset>;
     getSmartContractTokens(): Record<string, _ChainAsset>;
     getAssetHubToken(): Record<string, _ChainAsset>;
+    getHydrationAssetIdMap(chain: string): Record<string, string>;
     getChainInfoMap(): Record<string, _ChainInfo>;
     setChainInfoMap(chainInfoMap: Record<string, _ChainInfo>): void;
     getEvmChainInfoMap(): Record<string, _ChainInfo>;
@@ -142,7 +146,6 @@ export declare class ChainService {
     private generateSlugForNativeToken;
     refreshSubstrateApi(slug: string): void;
     refreshEvmApi(slug: string): void;
-    refreshTonApi(slug: string): void;
     stopAllChainApis(): Promise<void>;
     resumeAllChainApis(): Promise<void>;
     initAssetSettings(): Promise<void>;