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

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;
@@ -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>;

package/services/chain-service/index.js

@@ -4,6 +4,7 @@
 import { AssetLogoMap, AssetRefMap, ChainAssetMap, ChainInfoMap, ChainLogoMap, MultiChainAssetMap } from '@subwallet/chain-list';
 import { _AssetRefPath, _AssetType, _ChainStatus, _SubstrateChainType } from '@subwallet/chain-list/types';
 import { _DEFAULT_ACTIVE_CHAINS, _ZK_ASSET_PREFIX, LATEST_CHAIN_DATA_FETCHING_INTERVAL } from '@subwallet/extension-base/services/chain-service/constants';
+import { CardanoChainHandler } from '@subwallet/extension-base/services/chain-service/handler/CardanoChainHandler';
 import { EvmChainHandler } from '@subwallet/extension-base/services/chain-service/handler/EvmChainHandler';
 import { MantaPrivateHandler } from '@subwallet/extension-base/services/chain-service/handler/manta/MantaPrivateHandler';
 import { SubstrateChainHandler } from '@subwallet/extension-base/services/chain-service/handler/SubstrateChainHandler';
@@ -68,6 +69,7 @@ export class ChainService {
     this.substrateChainHandler = new SubstrateChainHandler(this);
     this.evmChainHandler = new EvmChainHandler(this);
     this.tonChainHandler = new TonChainHandler(this);
+    this.cardanoChainHandler = new CardanoChainHandler(this);
     this.logger = createLogger('chain-service');
   }
   get value() {
@@ -141,6 +143,12 @@ export class ChainService {
   getTonApiMap() {
     return this.tonChainHandler.getTonApiMap();
   }
+  getCardanoApi(slug) {
+    return this.cardanoChainHandler.getCardanoApiByChain(slug);
+  }
+  getCardanoApiMap() {
+    return this.cardanoChainHandler.getCardanoApiMap();
+  }
   getChainCurrentProviderByKey(slug) {
     const providerName = this.getChainStateByKey(slug).currentProvider;
     const providerMap = this.getChainInfoByKey(slug).providers;
@@ -719,6 +727,15 @@ export class ChainService {
       });
       this.tonChainHandler.setTonApi(chainInfo.slug, chainApi);
     }
+    if (chainInfo.cardanoInfo !== null && chainInfo.cardanoInfo !== undefined) {
+      const isTestnet = chainInfo.isTestnet;
+      const chainApi = await this.cardanoChainHandler.initApi(chainInfo.slug, endpoint, {
+        isTestnet,
+        providerName,
+        onUpdateStatus
+      });
+      this.cardanoChainHandler.setCardanoApi(chainInfo.slug, chainApi);
+    }
   }
   destroyApiForChain(chainInfo) {
     if (chainInfo.substrateInfo !== null) {
@@ -730,6 +747,9 @@ export class ChainService {
     if (chainInfo.tonInfo !== null) {
       this.tonChainHandler.destroyTonApi(chainInfo.slug);
     }
+    if (chainInfo.cardanoInfo !== null) {
+      this.cardanoChainHandler.destroyCardanoApi(chainInfo.slug);
+    }
   }
   async enableChain(chainSlug) {
     const chainInfo = this.getChainInfoByKey(chainSlug);
@@ -1000,7 +1020,7 @@ export class ChainService {
             deprecatedChainMap[storedSlug] = duplicatedDefaultSlug;
             deprecatedChains.push(storedSlug);
           } else {
-            var _storedChainInfo$bitc;
+            var _storedChainInfo$bitc, _storedChainInfo$card;
             mergedChainInfoMap[storedSlug] = {
               slug: storedSlug,
               name: storedChainInfo.name,
@@ -1010,6 +1030,7 @@ export class ChainService {
               substrateInfo: storedChainInfo.substrateInfo,
               bitcoinInfo: (_storedChainInfo$bitc = storedChainInfo.bitcoinInfo) !== null && _storedChainInfo$bitc !== void 0 ? _storedChainInfo$bitc : null,
               tonInfo: storedChainInfo.tonInfo,
+              cardanoInfo: (_storedChainInfo$card = storedChainInfo.cardanoInfo) !== null && _storedChainInfo$card !== void 0 ? _storedChainInfo$card : null,
               isTestnet: storedChainInfo.isTestnet,
               chainStatus: storedChainInfo.chainStatus,
               icon: storedChainInfo.icon,
@@ -1028,7 +1049,7 @@ export class ChainService {
             this.updateChainConnectionStatus(storedSlug, _ChainConnectionStatus.DISCONNECTED);
           }
         } else {
-          var _storedChainInfo$bitc2;
+          var _storedChainInfo$bitc2, _storedChainInfo$card2;
           // added chain from patch
           mergedChainInfoMap[storedSlug] = {
             slug: storedSlug,
@@ -1038,6 +1059,7 @@ export class ChainService {
             substrateInfo: storedChainInfo.substrateInfo,
             bitcoinInfo: (_storedChainInfo$bitc2 = storedChainInfo.bitcoinInfo) !== null && _storedChainInfo$bitc2 !== void 0 ? _storedChainInfo$bitc2 : null,
             tonInfo: storedChainInfo.tonInfo,
+            cardanoInfo: (_storedChainInfo$card2 = storedChainInfo.cardanoInfo) !== null && _storedChainInfo$card2 !== void 0 ? _storedChainInfo$card2 : null,
             isTestnet: storedChainInfo.isTestnet,
             chainStatus: storedChainInfo.chainStatus,
             icon: storedChainInfo.icon,
@@ -1207,6 +1229,7 @@ export class ChainService {
     let substrateInfo = null;
     let evmInfo = null;
     const tonInfo = null;
+    const cardanoInfo = null;
     if (params.chainSpec.genesisHash !== '') {
       substrateInfo = {
         crowdloanFunds: params.chainSpec.crowdloanFunds || null,
@@ -1245,6 +1268,7 @@ export class ChainService {
       evmInfo,
       bitcoinInfo: null,
       tonInfo,
+      cardanoInfo,
       isTestnet: false,
       chainStatus: _ChainStatus.ACTIVE,
       icon: '',
@@ -1356,6 +1380,7 @@ export class ChainService {
         // TODO: EVM chain might have WS provider
         if (provider.startsWith('http')) {
           // todo: handle validate ton provider
+          // todo: handle validate cardano provider
 
           // HTTP provider is EVM by default
           api = await this.evmChainHandler.initApi('custom', provider);
@@ -1572,15 +1597,12 @@ export class ChainService {
   refreshEvmApi(slug) {
     this.evmChainHandler.recoverApi(slug).catch(console.error);
   }
-  refreshTonApi(slug) {
-    this.tonChainHandler.recoverApi(slug).catch(console.error);
-  }
   async stopAllChainApis() {
-    await Promise.all([this.substrateChainHandler.sleep(), this.evmChainHandler.sleep(), this.tonChainHandler.sleep()]);
+    await Promise.all([this.substrateChainHandler.sleep(), this.evmChainHandler.sleep(), this.tonChainHandler.sleep(), this.cardanoChainHandler.sleep()]);
     this.stopCheckLatestChainData();
   }
   async resumeAllChainApis() {
-    await Promise.all([this.substrateChainHandler.wakeUp(), this.evmChainHandler.wakeUp(), this.tonChainHandler.wakeUp()]);
+    await Promise.all([this.substrateChainHandler.wakeUp(), this.evmChainHandler.wakeUp(), this.tonChainHandler.wakeUp(), this.cardanoChainHandler.wakeUp()]);
     this.checkLatestData();
   }
   async initAssetSettings() {

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

@@ -1,5 +1,6 @@
 import type { ApiInterfaceRx } from '@polkadot/api/types';
 import { _AssetRef, _AssetType, _ChainAsset, _ChainInfo, _CrowdloanFund } from '@subwallet/chain-list/types';
+import { CardanoBalanceItem } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/cardano/types';
 import { AccountState, TxByMsgResponse } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/types';
 import { _CHAIN_VALIDATION_ERROR } from '@subwallet/extension-base/services/chain-service/handler/types';
 import { TonWalletContract } from '@subwallet/keyring/types';
@@ -107,7 +108,7 @@ export interface _EvmApi extends _ChainBaseApi {
 export interface _TonApi extends _ChainBaseApi, _TonUtilsApi {
     isReady: Promise<_TonApi>;
 }
-export interface _TonUtilsApi {
+interface _TonUtilsApi {
     getBalance(address: Address): Promise<bigint>;
     open<T extends Contract>(src: T): OpenedContract<T>;
     estimateExternalMessageFee(walletContract: TonWalletContract, body: Cell, isInit: boolean, ignoreSignature?: boolean): Promise<EstimateExternalMessageFee>;
@@ -116,6 +117,12 @@ export interface _TonUtilsApi {
     getStatusByExtMsgHash(extMsgHash: string): Promise<[boolean, string]>;
     getAccountState(address: string): Promise<AccountState>;
 }
+export interface _CardanoApi extends _ChainBaseApi, _CardanoUtilsApi {
+    isReady: Promise<_CardanoApi>;
+}
+interface _CardanoUtilsApi {
+    getBalanceMap(address: string): Promise<CardanoBalanceItem[]>;
+}
 export interface EstimateExternalMessageFee {
     source_fees: {
         in_fwd_fee: number;
@@ -179,3 +186,4 @@ export interface _ValidateCustomAssetResponse extends _SmartContractTokenInfo {
 export declare const _FUNGIBLE_CONTRACT_STANDARDS: _AssetType[];
 export declare const _NFT_CONTRACT_STANDARDS: _AssetType[];
 export declare const _SMART_CONTRACT_STANDARDS: _AssetType[];
+export {};

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

@@ -11,6 +11,7 @@ export declare function _isEqualSmartContractAsset(asset1: _ChainAsset, asset2:
 export declare function _isPureEvmChain(chainInfo: _ChainInfo): boolean;
 export declare function _isPureSubstrateChain(chainInfo: _ChainInfo): boolean;
 export declare function _isPureTonChain(chainInfo: _ChainInfo): boolean;
+export declare function _isPureCardanoChain(chainInfo: _ChainInfo): boolean;
 export declare function _getOriginChainOfAsset(assetSlug: string): string;
 export declare function _getContractAddressOfToken(tokenInfo: _ChainAsset): string;
 /**
@@ -30,6 +31,7 @@ export declare function _isTokenTransferredByEvm(tokenInfo: _ChainAsset): boolea
 export declare function _checkSmartContractSupportByChain(chainInfo: _ChainInfo, contractType: _AssetType): boolean;
 export declare function _isJettonToken(tokenInfo: _ChainAsset): boolean;
 export declare function _isTokenTransferredByTon(tokenInfo: _ChainAsset): boolean;
+export declare function _isTokenTransferredByCardano(tokenInfo: _ChainAsset): boolean;
 export declare function _getTokenOnChainAssetId(tokenInfo: _ChainAsset): string;
 export declare function _getTokenOnChainInfo(tokenInfo: _ChainAsset): Record<string, any>;
 export declare function _isBridgedToken(tokenInfo: _ChainAsset): boolean;
@@ -37,6 +39,7 @@ export declare function _getTokenMinAmount(tokenInfo: _ChainAsset): string;
 export declare function _isChainEvmCompatible(chainInfo: _ChainInfo): boolean;
 export declare function _isChainBitcoinCompatible(chainInfo: _ChainInfo): boolean;
 export declare function _isChainTonCompatible(chainInfo: _ChainInfo): boolean;
+export declare function _isChainCardanoCompatible(chainInfo: _ChainInfo): boolean;
 export declare function _isNativeToken(tokenInfo: _ChainAsset): boolean;
 export declare function _isNativeTokenBySlug(tokenSlug: string): boolean;
 export declare function _isSmartContractToken(tokenInfo: _ChainAsset): boolean;
@@ -65,6 +68,7 @@ export declare function _getChainNativeTokenSlug(chainInfo: _ChainInfo): string;
 export declare function _isLocalToken(tokenInfo: _ChainAsset): boolean;
 export declare function _isTokenEvmSmartContract(tokenInfo: _ChainAsset): boolean;
 export declare function _isTokenTonSmartContract(tokenInfo: _ChainAsset): boolean;
+export declare function _isCIP26Token(tokenInfo: _ChainAsset): boolean;
 export declare function _isTokenWasmSmartContract(tokenInfo: _ChainAsset): boolean;
 export declare function _isAssetSmartContractNft(assetInfo: _ChainAsset): boolean;
 export declare function _isTokenGearSmartContract(tokenInfo: _ChainAsset): boolean;

package/services/chain-service/utils/index.js

@@ -48,13 +48,16 @@ export function _isEqualSmartContractAsset(asset1, asset2) {
   return false;
 }
 export function _isPureEvmChain(chainInfo) {
-  return !!chainInfo.evmInfo && !chainInfo.substrateInfo && !chainInfo.tonInfo;
+  return !!chainInfo.evmInfo && !chainInfo.substrateInfo && !chainInfo.tonInfo && !chainInfo.cardanoInfo;
 }
 export function _isPureSubstrateChain(chainInfo) {
-  return !chainInfo.evmInfo && !!chainInfo.substrateInfo && !chainInfo.tonInfo;
+  return !chainInfo.evmInfo && !!chainInfo.substrateInfo && !chainInfo.tonInfo && !chainInfo.cardanoInfo;
 }
 export function _isPureTonChain(chainInfo) {
-  return !chainInfo.evmInfo && !chainInfo.substrateInfo && !!chainInfo.tonInfo;
+  return !chainInfo.evmInfo && !chainInfo.substrateInfo && !!chainInfo.tonInfo && !chainInfo.cardanoInfo;
+}
+export function _isPureCardanoChain(chainInfo) {
+  return !chainInfo.evmInfo && !chainInfo.substrateInfo && !chainInfo.tonInfo && !!chainInfo.cardanoInfo;
 }
 export function _getOriginChainOfAsset(assetSlug) {
   if (assetSlug.startsWith(_CUSTOM_PREFIX)) {
@@ -107,6 +110,9 @@ export function _isJettonToken(tokenInfo) {
 export function _isTokenTransferredByTon(tokenInfo) {
   return _isJettonToken(tokenInfo) || _isNativeToken(tokenInfo);
 }
+export function _isTokenTransferredByCardano(tokenInfo) {
+  return _isCIP26Token(tokenInfo) || _isNativeToken(tokenInfo);
+}
 
 // Utils for balance functions
 export function _getTokenOnChainAssetId(tokenInfo) {
@@ -133,6 +139,9 @@ export function _isChainBitcoinCompatible(chainInfo) {
 export function _isChainTonCompatible(chainInfo) {
   return !!chainInfo.tonInfo;
 }
+export function _isChainCardanoCompatible(chainInfo) {
+  return !!chainInfo.cardanoInfo;
+}
 export function _isNativeToken(tokenInfo) {
   return tokenInfo.assetType === _AssetType.NATIVE;
 }
@@ -252,11 +261,12 @@ export function _getTokenTypesSupportedByChain(chainInfo) {
   return result;
 }
 export function _getChainNativeTokenBasicInfo(chainInfo) {
+  const defaultTokenInfo = {
+    symbol: '',
+    decimals: -1
+  };
   if (!chainInfo) {
-    return {
-      symbol: '',
-      decimals: -1
-    };
+    return defaultTokenInfo;
   }
   if (chainInfo.substrateInfo) {
     // substrate by default
@@ -274,11 +284,13 @@ export function _getChainNativeTokenBasicInfo(chainInfo) {
       symbol: chainInfo.tonInfo.symbol,
       decimals: chainInfo.tonInfo.decimals
     };
+  } else if (chainInfo.cardanoInfo) {
+    return {
+      symbol: chainInfo.cardanoInfo.symbol,
+      decimals: chainInfo.cardanoInfo.decimals
+    };
   }
-  return {
-    symbol: '',
-    decimals: -1
-  };
+  return defaultTokenInfo;
 }
 export function _getChainNativeTokenSlug(chainInfo) {
   if (_isCustomChain(chainInfo.slug)) {
@@ -296,6 +308,9 @@ export function _isTokenTonSmartContract(tokenInfo) {
   return [_AssetType.TEP74].includes(tokenInfo.assetType); // add TEP-62 when supporting
 }
 
+export function _isCIP26Token(tokenInfo) {
+  return [_AssetType.CIP26].includes(tokenInfo.assetType);
+}
 export function _isTokenWasmSmartContract(tokenInfo) {
   return [_AssetType.PSP22, _AssetType.PSP34].includes(tokenInfo.assetType);
 }
@@ -384,6 +399,9 @@ export function _getBlockExplorerFromChain(chainInfo) {
   if (_isPureEvmChain(chainInfo)) {
     var _chainInfo$evmInfo5;
     blockExplorer = chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$evmInfo5 = chainInfo.evmInfo) === null || _chainInfo$evmInfo5 === void 0 ? void 0 : _chainInfo$evmInfo5.blockExplorer;
+  } else if (_isPureCardanoChain(chainInfo)) {
+    var _chainInfo$cardanoInf;
+    blockExplorer = chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$cardanoInf = chainInfo.cardanoInfo) === null || _chainInfo$cardanoInf === void 0 ? void 0 : _chainInfo$cardanoInf.blockExplorer;
   } else {
     var _chainInfo$substrateI18;
     blockExplorer = chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$substrateI18 = chainInfo.substrateInfo) === null || _chainInfo$substrateI18 === void 0 ? void 0 : _chainInfo$substrateI18.blockExplorer;
@@ -551,6 +569,9 @@ export const _chainInfoToChainType = chainInfo => {
   if (_isChainTonCompatible(chainInfo)) {
     return AccountChainType.TON;
   }
+  if (_isChainCardanoCompatible(chainInfo)) {
+    return AccountChainType.CARDANO;
+  }
   if (_isChainBitcoinCompatible(chainInfo)) {
     return AccountChainType.BITCOIN;
   }

package/services/chain-service/utils/patch.js

@@ -5,7 +5,7 @@ const PRODUCTION_BRANCHES = ['master', 'webapp', 'webapp-dev'];
 const branchName = process.env.BRANCH_NAME || 'subwallet-dev';
 const fetchDomain = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'https://chain-list-assets.subwallet.app' : 'https://dev.sw-chain-list-assets.pages.dev';
 const fetchFile = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'list.json' : 'preview.json';
-const ChainListVersion = '0.2.99'; // update this when build chainlist
+const ChainListVersion = '0.2.101'; // update this when build chainlist
 
 // todo: move this interface to chainlist
 

package/services/earning-service/handlers/liquid-staking/bifrost-manta.js

@@ -124,7 +124,7 @@ export default class BifrostMantaLiquidStakingPoolHandler extends BifrostLiquidS
     const chainApi = await this.substrateApi.isReady;
     const derivativeTokenSlug = this.derivativeAssets[0];
     const derivativeTokenInfo = this.state.getAssetBySlug(derivativeTokenSlug);
-    const extrinsic = chainApi.api.tx.vtokenMinting.redeem(_getTokenOnChainInfo(derivativeTokenInfo), amount);
+    const extrinsic = chainApi.api.tx.vtokenMinting.redeem(null, _getTokenOnChainInfo(derivativeTokenInfo), amount);
     return [ExtrinsicType.UNSTAKE_VMANTA, extrinsic];
   }
 

package/services/earning-service/handlers/liquid-staking/bifrost.js

@@ -286,7 +286,7 @@ export default class BifrostLiquidStakingPoolHandler extends BaseLiquidStakingPo
     const chainApi = await this.substrateApi.isReady;
     const derivativeTokenSlug = this.derivativeAssets[0];
     const derivativeTokenInfo = this.state.getAssetBySlug(derivativeTokenSlug);
-    const extrinsic = chainApi.api.tx.vtokenMinting.redeem(_getTokenOnChainInfo(derivativeTokenInfo), amount);
+    const extrinsic = chainApi.api.tx.vtokenMinting.redeem(null, _getTokenOnChainInfo(derivativeTokenInfo), amount);
     return [ExtrinsicType.UNSTAKE_VDOT, extrinsic];
   }