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

package/services/balance-service/helpers/subscribe/cardano/index.js

@@ -0,0 +1,57 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { _AssetType } from '@subwallet/chain-list/types';
+import { APIItemState } from '@subwallet/extension-base/background/KoniTypes';
+import { ASTAR_REFRESH_BALANCE_INTERVAL } from '@subwallet/extension-base/constants';
+import { getCardanoAssetId } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/cardano/utils';
+import { filterAssetsByChainAndType, reformatAddress } from '@subwallet/extension-base/utils';
+async function getBalanceMap(addresses, cardanoApi, isTestnet) {
+  const addressBalanceMap = {};
+  for (const address of addresses) {
+    addressBalanceMap[address] = await cardanoApi.getBalanceMap(isTestnet ? reformatAddress(address, 0) : address);
+  }
+  return addressBalanceMap;
+}
+export function subscribeCardanoBalance(params) {
+  const {
+    addresses,
+    assetMap,
+    callback,
+    cardanoApi,
+    chainInfo
+  } = params;
+  const chain = chainInfo.slug;
+  const isTestnet = chainInfo.isTestnet;
+  const tokens = filterAssetsByChainAndType(assetMap, chain, [_AssetType.NATIVE, _AssetType.CIP26]);
+  function getBalance() {
+    getBalanceMap(addresses, cardanoApi, isTestnet).then(addressBalanceMap => {
+      Object.values(tokens).forEach(tokenInfo => {
+        const id = getCardanoAssetId(tokenInfo);
+        const balances = addresses.map(address => {
+          var _addressBalanceMap$ad;
+          if (!addressBalanceMap[address]) {
+            return '0';
+          }
+          return ((_addressBalanceMap$ad = addressBalanceMap[address].find(asset => asset.unit === id)) === null || _addressBalanceMap$ad === void 0 ? void 0 : _addressBalanceMap$ad.quantity) || '0';
+        });
+        const items = balances.map((balance, index) => {
+          return {
+            address: addresses[index],
+            tokenSlug: tokenInfo.slug,
+            free: balance,
+            locked: '0',
+            // todo: research cardano lock balance
+            state: APIItemState.READY
+          };
+        });
+        callback(items);
+      });
+    }).catch(e => console.error('Error while fetching cardano balance', e));
+  }
+  const interval = setInterval(getBalance, ASTAR_REFRESH_BALANCE_INTERVAL);
+  getBalance();
+  return () => {
+    clearInterval(interval);
+  };
+}

package/services/balance-service/helpers/subscribe/cardano/types.d.ts

@@ -0,0 +1,34 @@
+export interface CardanoAddressBalance {
+    address: string;
+    amount: CardanoBalanceItem[];
+    stake_address: string;
+    type: string;
+    script: boolean;
+}
+export interface CardanoBalanceItem {
+    unit: string;
+    quantity: string;
+}
+export interface CardanoTxJson {
+    body: {
+        inputs: CardanoTxInput[];
+        outputs: CardanoTxOutput[];
+        fee: string;
+        ttl: string;
+    };
+    witness_set: any;
+    is_valid: any;
+    auxiliary_data: any;
+}
+export interface CardanoTxOutput {
+    address: string;
+    amount: {
+        coin: string;
+        multiasset: Record<string, Record<string, string>>;
+    };
+}
+interface CardanoTxInput {
+    transaction_id: string;
+    index: number;
+}
+export {};

package/services/balance-service/helpers/subscribe/cardano/types.js

@@ -0,0 +1 @@
+export {};

package/services/balance-service/helpers/subscribe/cardano/utils.d.ts

@@ -0,0 +1,15 @@
+import { _ChainAsset } from '@subwallet/chain-list/types';
+export declare function getCardanoAssetId(chainAsset: _ChainAsset): string;
+export declare function getCardanoTxFee(payload: string): bigint;
+export declare function getAdaBelongUtxo(payload: string, receiverAddress: string): bigint;
+export declare const cborToBytes: (hex: string) => Uint8Array;
+export declare function retryCardanoTxStatus(fn: () => Promise<boolean>, options: {
+    retries: number;
+    delay: number;
+}): Promise<boolean>;
+export interface CardanoAssetMetadata {
+    cardanoId: string;
+    policyId: string;
+    nameHex: string;
+}
+export declare function splitCardanoId(id: string): CardanoAssetMetadata;

package/services/balance-service/helpers/subscribe/cardano/utils.js

@@ -0,0 +1,62 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { Transaction } from '@emurgo/cardano-serialization-lib-nodejs';
+export function getCardanoAssetId(chainAsset) {
+  var _chainAsset$metadata;
+  return (_chainAsset$metadata = chainAsset.metadata) === null || _chainAsset$metadata === void 0 ? void 0 : _chainAsset$metadata.cardanoId;
+}
+export function getCardanoTxFee(payload) {
+  return BigInt(Transaction.from_hex(payload).body().fee().to_str());
+}
+export function getAdaBelongUtxo(payload, receiverAddress) {
+  const txOutputsRaw = Transaction.from_hex(payload).body().outputs().to_json();
+  const txOutputs = JSON.parse(txOutputsRaw);
+  const receiverUtxo = txOutputs.find(utxo => utxo.address === receiverAddress); // must has utxo to receiver
+
+  // @ts-ignore
+  return BigInt(receiverUtxo.amount.coin);
+}
+export const cborToBytes = hex => {
+  if (hex.length % 2 === 0 && /^[0-9A-F]*$/i.test(hex)) {
+    return Buffer.from(hex, 'hex');
+  }
+  return Buffer.from(hex, 'utf-8');
+};
+export async function retryCardanoTxStatus(fn, options) {
+  let lastError;
+  for (let i = 0; i < options.retries; i++) {
+    try {
+      return await fn();
+    } catch (e) {
+      if (e instanceof Error) {
+        lastError = e;
+      }
+
+      // todo: improve the timeout tx
+      await new Promise(resolve => setTimeout(resolve, options.delay)); // wait for delay period, then recall the fn()
+    }
+  }
+
+  console.error('Cardano transaction timeout', lastError); // throw only last error, in case no successful result from fn()
+
+  return false;
+}
+export function splitCardanoId(id) {
+  if (id === 'lovelace') {
+    return {
+      cardanoId: id,
+      policyId: '',
+      nameHex: ''
+    };
+  }
+  if (!id || id.length < 56) {
+    throw new Error('The cardano native asset policy id must has 28 bytes in length.');
+  } else {
+    return {
+      cardanoId: id,
+      policyId: id.slice(0, 56),
+      nameHex: id.slice(56)
+    };
+  }
+}

package/services/balance-service/helpers/subscribe/index.d.ts

@@ -1,6 +1,6 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
-import { _EvmApi, _SubstrateApi, _TonApi } from '@subwallet/extension-base/services/chain-service/types';
+import { _CardanoApi, _EvmApi, _SubstrateApi, _TonApi } from '@subwallet/extension-base/services/chain-service/types';
 import { AccountJson, BalanceItem } from '@subwallet/extension-base/types';
 /**
  * @function getAccountJsonByAddress
@@ -12,4 +12,4 @@ import { AccountJson, BalanceItem } from '@subwallet/extension-base/types';
  * @returns {AccountJson|null}  - Account info or null if not found
  */
 export declare const getAccountJsonByAddress: (address: string) => AccountJson | null;
-export declare function subscribeBalance(addresses: string[], chains: string[], tokens: string[], _chainAssetMap: Record<string, _ChainAsset>, _chainInfoMap: Record<string, _ChainInfo>, substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>, tonApiMap: Record<string, _TonApi>, callback: (rs: BalanceItem[]) => void, extrinsicType?: ExtrinsicType): () => void;
+export declare function subscribeBalance(addresses: string[], chains: string[], tokens: string[], _chainAssetMap: Record<string, _ChainAsset>, _chainInfoMap: Record<string, _ChainInfo>, substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>, tonApiMap: Record<string, _TonApi>, cardanoApiMap: Record<string, _CardanoApi>, callback: (rs: BalanceItem[]) => void, extrinsicType?: ExtrinsicType): () => void;

package/services/balance-service/helpers/subscribe/index.js

@@ -3,8 +3,9 @@
 
 import { _AssetType } from '@subwallet/chain-list/types';
 import { APIItemState } from '@subwallet/extension-base/background/KoniTypes';
-import { _getSubstrateGenesisHash, _isChainBitcoinCompatible, _isChainEvmCompatible, _isChainTonCompatible, _isPureEvmChain, _isPureTonChain } from '@subwallet/extension-base/services/chain-service/utils';
-import { categoryAddresses, filterAssetsByChainAndType, pairToAccount } from '@subwallet/extension-base/utils';
+import { subscribeCardanoBalance } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/cardano';
+import { _getSubstrateGenesisHash, _isChainBitcoinCompatible, _isChainCardanoCompatible, _isChainEvmCompatible, _isChainTonCompatible, _isPureCardanoChain, _isPureEvmChain, _isPureTonChain } from '@subwallet/extension-base/services/chain-service/utils';
+import { filterAssetsByChainAndType, getAddressesByChainTypeMap, pairToAccount } from '@subwallet/extension-base/utils';
 import keyring from '@subwallet/ui-keyring';
 import { subscribeTonBalance } from "./ton/ton.js";
 import { subscribeEVMBalance } from "./evm.js";
@@ -37,16 +38,19 @@ export const getAccountJsonByAddress = address => {
 const filterAddress = (addresses, chainInfo) => {
   const {
     bitcoin,
+    cardano,
     evm,
     substrate,
     ton
-  } = categoryAddresses(addresses);
+  } = getAddressesByChainTypeMap(addresses);
   if (_isChainEvmCompatible(chainInfo)) {
-    return [evm, [...bitcoin, ...substrate, ...ton]];
+    return [evm, [...bitcoin, ...substrate, ...ton, ...cardano]];
   } else if (_isChainBitcoinCompatible(chainInfo)) {
-    return [bitcoin, [...evm, ...substrate, ...ton]];
+    return [bitcoin, [...evm, ...substrate, ...ton, ...cardano]];
   } else if (_isChainTonCompatible(chainInfo)) {
-    return [ton, [...bitcoin, ...evm, ...substrate]];
+    return [ton, [...bitcoin, ...evm, ...substrate, ...cardano]];
+  } else if (_isChainCardanoCompatible(chainInfo)) {
+    return [cardano, [...bitcoin, ...evm, ...substrate, ...ton]];
   } else {
     const fetchList = [];
     const unfetchList = [];
@@ -72,11 +76,11 @@ const filterAddress = (addresses, chainInfo) => {
         fetchList.push(address);
       }
     });
-    return [fetchList, [...unfetchList, ...bitcoin, ...evm, ...ton]];
+    return [fetchList, [...unfetchList, ...bitcoin, ...evm, ...ton, ...cardano]];
   }
 };
 const handleUnsupportedOrPendingAddresses = (addresses, chainSlug, chainAssetMap, state, callback) => {
-  const tokens = filterAssetsByChainAndType(chainAssetMap, chainSlug, [_AssetType.NATIVE, _AssetType.ERC20, _AssetType.PSP22, _AssetType.LOCAL, _AssetType.GRC20, _AssetType.VFT]);
+  const tokens = filterAssetsByChainAndType(chainAssetMap, chainSlug, [_AssetType.NATIVE, _AssetType.ERC20, _AssetType.PSP22, _AssetType.LOCAL, _AssetType.GRC20, _AssetType.VFT, _AssetType.TEP74, _AssetType.CIP26]);
   const now = new Date().getTime();
   Object.values(tokens).forEach(token => {
     const items = addresses.map(address => ({
@@ -92,7 +96,7 @@ const handleUnsupportedOrPendingAddresses = (addresses, chainSlug, chainAssetMap
 };
 
 // main subscription, use for multiple chains, multiple addresses and multiple tokens
-export function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, callback, extrinsicType) {
+export function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, callback, extrinsicType) {
   // Filter chain and token
   const chainAssetMap = Object.fromEntries(Object.entries(_chainAssetMap).filter(([token]) => tokens.includes(token)));
   const chainInfoMap = Object.fromEntries(Object.entries(_chainInfoMap).filter(([chain]) => chains.includes(chain)));
@@ -124,6 +128,16 @@ export function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _cha
         tonApi
       });
     }
+    const cardanoApi = cardanoApiMap[chainSlug];
+    if (_isPureCardanoChain(chainInfo)) {
+      return subscribeCardanoBalance({
+        addresses: useAddresses,
+        assetMap: chainAssetMap,
+        callback,
+        chainInfo,
+        cardanoApi
+      });
+    }
 
     // If the chain is not ready, return pending state
     if (!substrateApiMap[chainSlug].isApiReady) {

package/services/balance-service/helpers/subscribe/ton/utils.d.ts

@@ -10,7 +10,7 @@ import { Buffer } from 'buffer';
 export declare function getJettonMasterContract(tonApi: _TonApi, contractAddress: string): OpenedContract<JettonMaster>;
 export declare function getJettonWalletContract(jettonMasterContract: OpenedContract<JettonMaster>, tonApi: _TonApi, ownerAddress: string): Promise<OpenedContract<JettonWallet>>;
 export declare function externalMessage(contract: TonWalletContract, seqno: number, body: Cell): Cell;
-export declare function retry<T>(fn: () => Promise<T>, options: {
+export declare function retryTonTxStatus<T>(fn: () => Promise<T>, options: {
     retries: number;
     delay: number;
 }): Promise<T>;

package/services/balance-service/helpers/subscribe/ton/utils.js

@@ -23,7 +23,7 @@ export function externalMessage(contract, seqno, body) {
     body: body
   }))).endCell();
 }
-export async function retry(fn, options) {
+export async function retryTonTxStatus(fn, options) {
   let lastError;
   for (let i = 0; i < options.retries; i++) {
     try {

package/services/balance-service/index.js

@@ -191,8 +191,9 @@ export class BalanceService {
       const evmApiMap = this.state.chainService.getEvmApiMap();
       const substrateApiMap = this.state.chainService.getSubstrateApiMap();
       const tonApiMap = this.state.chainService.getTonApiMap();
+      const cardanoApiMap = this.state.chainService.getCardanoApiMap();
       let unsub = noop;
-      unsub = subscribeBalance([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, result => {
+      unsub = subscribeBalance([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, result => {
         const rs = result[0];
         let value;
         switch (balanceType) {
@@ -362,13 +363,14 @@ export class BalanceService {
     const evmApiMap = this.state.chainService.getEvmApiMap();
     const substrateApiMap = this.state.chainService.getSubstrateApiMap();
     const tonApiMap = this.state.chainService.getTonApiMap();
+    const cardanoApiMap = this.state.chainService.getCardanoApiMap();
     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, tonApiMap, result => {
+    const unsub = subscribeBalance(addresses, activeChainSlugs, assets, assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, result => {
       !cancel && this.setBalanceItem(result);
     }, ExtrinsicType.TRANSFER_BALANCE);
     const unsub2 = this.state.subscribeMantaPayBalance();

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

@@ -0,0 +1,24 @@
+import { _ChainAsset } from '@subwallet/chain-list/types';
+import { _CardanoApi } from '@subwallet/extension-base/services/chain-service/types';
+export interface CardanoTransactionConfigProps {
+    tokenInfo: _ChainAsset;
+    nativeTokenInfo: _ChainAsset;
+    from: string;
+    to: string;
+    networkKey: string;
+    value: string;
+    transferAll: boolean;
+    cardanoTtlOffset: number;
+    cardanoApi: _CardanoApi;
+}
+export interface CardanoTransactionConfig {
+    from: string;
+    to: string;
+    networkKey: string;
+    value: string;
+    transferAll: boolean;
+    cardanoTtlOffset: number;
+    estimateCardanoFee: string;
+    cardanoPayload: string;
+}
+export declare function createCardanoTransaction(params: CardanoTransactionConfigProps): Promise<[CardanoTransactionConfig | null, string]>;

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/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>;
+}