@subwallet/extension-base 1.3.21-0 → 1.3.23-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/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/constants.js

@@ -102,7 +102,10 @@ export const _STAKING_ERA_LENGTH_MAP = {
   polkadex: 24,
   avail_mainnet: 24,
   cere: 24,
-  analog_timechain: 12
+  analog_timechain: 12,
+  muse_testnet: 25 * 6 / 60 / 60,
+  // 25 blocks per session
+  mythos: 24
 };
 export const _EXPECTED_BLOCK_TIME = {
   // in seconds
@@ -135,7 +138,9 @@ export const _EXPECTED_BLOCK_TIME = {
   enjin_relaychain: 6,
   availTuringTest: 20,
   avail_mainnet: 20,
-  dentnet: 3
+  dentnet: 3,
+  muse_testnet: 6,
+  mythos: 6
 };
 export const _PARACHAIN_INFLATION_DISTRIBUTION = {
   moonbeam: {
@@ -248,7 +253,7 @@ export const _TRANSFER_CHAIN_GROUP = {
   genshiro: ['genshiro_testnet', 'genshiro', 'equilibrium_parachain'],
   // crab: ['crab', 'pangolin'],
   bitcountry: ['pioneer', 'bitcountry'],
-  statemine: ['statemint', 'statemine', 'darwinia2', 'astar', 'shiden', 'shibuya', 'parallel', 'liberland', 'liberlandTest', 'dentnet', 'dbcchain'],
+  statemine: ['statemint', 'statemine', 'darwinia2', 'astar', 'shiden', 'shibuya', 'parallel', 'liberland', 'liberlandTest', 'dentnet', 'dbcchain', 'westend_assethub'],
   riochain: ['riochain'],
   sora_substrate: ['sora_substrate'],
   avail: ['kate', 'goldberg_testnet'],

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/SubstrateChainHandler.js

@@ -263,7 +263,7 @@ export class SubstrateChainHandler extends AbstractChainHandler {
     onUpdateStatus,
     providerName
   } = {}) {
-    var _this$parent2;
+    var _this$parent2, _this$parent3;
     const existed = this.substrateApiMap[chainSlug];
     const updateMetadata = substrateApi => {
       // Update metadata to database with async methods
@@ -281,7 +281,8 @@ export class SubstrateChainHandler extends AbstractChainHandler {
       updateMetadata(existed);
       return existed;
     }
-    const metadata = await ((_this$parent2 = this.parent) === null || _this$parent2 === void 0 ? void 0 : _this$parent2.getMetadata(chainSlug));
+    const useMetadata = await ((_this$parent2 = this.parent) === null || _this$parent2 === void 0 ? void 0 : _this$parent2.isUseMetadataToCreateApi(chainSlug));
+    const metadata = useMetadata === false ? undefined : await ((_this$parent3 = this.parent) === null || _this$parent3 === void 0 ? void 0 : _this$parent3.getMetadata(chainSlug));
     const apiObject = new SubstrateApi(chainSlug, apiUrl, {
       providerName,
       metadata,

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;
@@ -142,7 +145,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>;
@@ -169,4 +171,5 @@ export declare class ChainService {
     getSubscanChainMap(reverse?: boolean): Record<string, string>;
     get detectBalanceChainSlugMap(): Record<string, string>;
     getFeeTokensByChain(chainSlug: string): string[];
+    isUseMetadataToCreateApi(chain: string): Promise<boolean>;
 }