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

package/cjs/koni/background/handlers/State.js

@@ -43,6 +43,7 @@ var _storage = require("@subwallet/extension-base/storage");
 var _types2 = require("@subwallet/extension-base/types");
 var _utils3 = require("@subwallet/extension-base/utils");
 var _promise = require("@subwallet/extension-base/utils/promise");
+var _subwalletApiSdk = _interopRequireDefault(require("@subwallet/subwallet-api-sdk"));
 var _uiKeyring = require("@subwallet/ui-keyring");
 var _bn = _interopRequireDefault(require("bn.js"));
 var _i18next = require("i18next");
@@ -90,6 +91,8 @@ class KoniState {
   waitStarting = null;
   constructor() {
     let providers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    // Init subwallet api sdk
+    _subwalletApiSdk.default.init(_constants.BACKEND_API_URL);
     this.providers = providers;
     this.eventService = new _eventService.EventService();
     this.dbService = new _DatabaseService.default(this.eventService);
@@ -731,6 +734,12 @@ class KoniState {
   getTonApi(networkKey) {
     return this.chainService.getTonApi(networkKey);
   }
+  getCardanoApiMap() {
+    return this.chainService.getCardanoApiMap();
+  }
+  getCardanoApi(networkKey) {
+    return this.chainService.getCardanoApi(networkKey);
+  }
   getApiMap() {
     return {
       substrate: this.chainService.getSubstrateApiMap(),
@@ -1017,12 +1026,18 @@ class KoniState {
   getConfirmationsQueueSubjectTon() {
     return this.requestService.confirmationsQueueSubjectTon;
   }
+  getConfirmationsQueueSubjectCardano() {
+    return this.requestService.confirmationsQueueSubjectCardano;
+  }
   async completeConfirmation(request) {
     return await this.requestService.completeConfirmation(request);
   }
   async completeConfirmationTon(request) {
     return await this.requestService.completeConfirmationTon(request);
   }
+  async completeConfirmationCardano(request) {
+    return await this.requestService.completeConfirmationCardano(request);
+  }
   async onMV3Update() {
     const migrationStatus = await _storage.SWStorage.instance.getItem('mv3_migration');
     if (!migrationStatus || migrationStatus !== 'done') {

package/cjs/packageInfo.js

@@ -13,6 +13,6 @@ const packageInfo = {
   name: '@subwallet/extension-base',
   path: typeof __dirname === 'string' ? __dirname : 'auto',
   type: 'cjs',
-  version: '1.3.22-0'
+  version: '1.3.23-0'
 };
 exports.packageInfo = packageInfo;

package/cjs/services/balance-service/helpers/subscribe/cardano/consts.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULT_CARDANO_TTL_OFFSET = void 0;
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const DEFAULT_CARDANO_TTL_OFFSET = 2 * 60 * 60 * 1000; // 2 hours
+exports.DEFAULT_CARDANO_TTL_OFFSET = DEFAULT_CARDANO_TTL_OFFSET;

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

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.subscribeCardanoBalance = subscribeCardanoBalance;
+var _types = require("@subwallet/chain-list/types");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/constants");
+var _utils = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/cardano/utils");
+var _utils2 = require("@subwallet/extension-base/utils");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+async function getBalanceMap(addresses, cardanoApi, isTestnet) {
+  const addressBalanceMap = {};
+  for (const address of addresses) {
+    addressBalanceMap[address] = await cardanoApi.getBalanceMap(isTestnet ? (0, _utils2.reformatAddress)(address, 0) : address);
+  }
+  return addressBalanceMap;
+}
+function subscribeCardanoBalance(params) {
+  const {
+    addresses,
+    assetMap,
+    callback,
+    cardanoApi,
+    chainInfo
+  } = params;
+  const chain = chainInfo.slug;
+  const isTestnet = chainInfo.isTestnet;
+  const tokens = (0, _utils2.filterAssetsByChainAndType)(assetMap, chain, [_types._AssetType.NATIVE, _types._AssetType.CIP26]);
+  function getBalance() {
+    getBalanceMap(addresses, cardanoApi, isTestnet).then(addressBalanceMap => {
+      Object.values(tokens).forEach(tokenInfo => {
+        const id = (0, _utils.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: _KoniTypes.APIItemState.READY
+          };
+        });
+        callback(items);
+      });
+    }).catch(e => console.error('Error while fetching cardano balance', e));
+  }
+  const interval = setInterval(getBalance, _constants.ASTAR_REFRESH_BALANCE_INTERVAL);
+  getBalance();
+  return () => {
+    clearInterval(interval);
+  };
+}

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

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cborToBytes = void 0;
+exports.getAdaBelongUtxo = getAdaBelongUtxo;
+exports.getCardanoAssetId = getCardanoAssetId;
+exports.getCardanoTxFee = getCardanoTxFee;
+exports.retryCardanoTxStatus = retryCardanoTxStatus;
+exports.splitCardanoId = splitCardanoId;
+var _cardanoSerializationLibNodejs = require("@emurgo/cardano-serialization-lib-nodejs");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function getCardanoAssetId(chainAsset) {
+  var _chainAsset$metadata;
+  return (_chainAsset$metadata = chainAsset.metadata) === null || _chainAsset$metadata === void 0 ? void 0 : _chainAsset$metadata.cardanoId;
+}
+function getCardanoTxFee(payload) {
+  return BigInt(_cardanoSerializationLibNodejs.Transaction.from_hex(payload).body().fee().to_str());
+}
+function getAdaBelongUtxo(payload, receiverAddress) {
+  const txOutputsRaw = _cardanoSerializationLibNodejs.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);
+}
+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');
+};
+exports.cborToBytes = cborToBytes;
+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;
+}
+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/cjs/services/balance-service/helpers/subscribe/index.js

@@ -8,6 +8,7 @@ exports.getAccountJsonByAddress = void 0;
 exports.subscribeBalance = subscribeBalance;
 var _types = require("@subwallet/chain-list/types");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _cardano = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/cardano");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _utils2 = require("@subwallet/extension-base/utils");
 var _uiKeyring = _interopRequireDefault(require("@subwallet/ui-keyring"));
@@ -45,16 +46,19 @@ exports.getAccountJsonByAddress = getAccountJsonByAddress;
 const filterAddress = (addresses, chainInfo) => {
   const {
     bitcoin,
+    cardano,
     evm,
     substrate,
     ton
-  } = (0, _utils2.categoryAddresses)(addresses);
+  } = (0, _utils2.getAddressesByChainTypeMap)(addresses);
   if ((0, _utils._isChainEvmCompatible)(chainInfo)) {
-    return [evm, [...bitcoin, ...substrate, ...ton]];
+    return [evm, [...bitcoin, ...substrate, ...ton, ...cardano]];
   } else if ((0, _utils._isChainBitcoinCompatible)(chainInfo)) {
-    return [bitcoin, [...evm, ...substrate, ...ton]];
+    return [bitcoin, [...evm, ...substrate, ...ton, ...cardano]];
   } else if ((0, _utils._isChainTonCompatible)(chainInfo)) {
-    return [ton, [...bitcoin, ...evm, ...substrate]];
+    return [ton, [...bitcoin, ...evm, ...substrate, ...cardano]];
+  } else if ((0, _utils._isChainCardanoCompatible)(chainInfo)) {
+    return [cardano, [...bitcoin, ...evm, ...substrate, ...ton]];
   } else {
     const fetchList = [];
     const unfetchList = [];
@@ -80,11 +84,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 = (0, _utils2.filterAssetsByChainAndType)(chainAssetMap, chainSlug, [_types._AssetType.NATIVE, _types._AssetType.ERC20, _types._AssetType.PSP22, _types._AssetType.LOCAL, _types._AssetType.GRC20, _types._AssetType.VFT]);
+  const tokens = (0, _utils2.filterAssetsByChainAndType)(chainAssetMap, chainSlug, [_types._AssetType.NATIVE, _types._AssetType.ERC20, _types._AssetType.PSP22, _types._AssetType.LOCAL, _types._AssetType.GRC20, _types._AssetType.VFT, _types._AssetType.TEP74, _types._AssetType.CIP26]);
   const now = new Date().getTime();
   Object.values(tokens).forEach(token => {
     const items = addresses.map(address => ({
@@ -100,7 +104,7 @@ const handleUnsupportedOrPendingAddresses = (addresses, chainSlug, chainAssetMap
 };
 
 // main subscription, use for multiple chains, multiple addresses and multiple tokens
-function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, callback, extrinsicType) {
+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(_ref => {
     let [token] = _ref;
@@ -138,6 +142,16 @@ function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _chainInfoM
         tonApi
       });
     }
+    const cardanoApi = cardanoApiMap[chainSlug];
+    if ((0, _utils._isPureCardanoChain)(chainInfo)) {
+      return (0, _cardano.subscribeCardanoBalance)({
+        addresses: useAddresses,
+        assetMap: chainAssetMap,
+        callback,
+        chainInfo,
+        cardanoApi
+      });
+    }
 
     // If the chain is not ready, return pending state
     if (!substrateApiMap[chainSlug].isApiReady) {

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

@@ -18,7 +18,7 @@ exports.getTransferCellPromise = getTransferCellPromise;
 exports.getWalletQueryId = getWalletQueryId;
 exports.isBounceableAddress = isBounceableAddress;
 exports.messageRelaxedToCell = messageRelaxedToCell;
-exports.retry = retry;
+exports.retryTonTxStatus = retryTonTxStatus;
 exports.tonAddressInfo = tonAddressInfo;
 var _consts = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/consts");
 var _core = require("@ton/core");
@@ -45,7 +45,7 @@ function externalMessage(contract, seqno, body) {
     body: body
   }))).endCell();
 }
-async function retry(fn, options) {
+async function retryTonTxStatus(fn, options) {
   let lastError;
   for (let i = 0; i < options.retries; i++) {
     try {

package/cjs/services/balance-service/index.js

@@ -200,8 +200,9 @@ 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 = _util.noop;
-      unsub = (0, _helpers.subscribeBalance)([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, result => {
+      unsub = (0, _helpers.subscribeBalance)([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, result => {
         const rs = result[0];
         let value;
         switch (balanceType) {
@@ -371,13 +372,14 @@ 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 = (0, _helpers.subscribeBalance)(addresses, activeChainSlugs, assets, assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, result => {
+    const unsub = (0, _helpers.subscribeBalance)(addresses, activeChainSlugs, assets, assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, result => {
       !cancel && this.setBalanceItem(result);
     }, _KoniTypes.ExtrinsicType.TRANSFER_BALANCE);
     const unsub2 = this.state.subscribeMantaPayBalance();

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

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCardanoTransaction = createCardanoTransaction;
+var csl = _interopRequireWildcard(require("@emurgo/cardano-serialization-lib-nodejs"));
+var _types = require("@subwallet/chain-list/types");
+var _utils = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/cardano/utils");
+var _subwalletApiSdk = require("@subwallet/subwallet-api-sdk");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+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 === _types._AssetType.NATIVE;
+  const isSelfTransfer = from === to;
+  if (!cardanoId) {
+    throw new Error('Missing token policy id metadata');
+  }
+  const payload = await _subwalletApiSdk.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 = (0, _utils.getCardanoTxFee)(payload);
+  const adaBelongToCnaUtxo = isNativeTransfer || isSelfTransfer ? BigInt(0) : (0, _utils.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 = (0, _utils.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 === _types._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 === _types._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 === _types._AssetType.NATIVE) {
+    if (receiverOutput.amount.coin === amount) {
+      return;
+    }
+    throw new Error('Transaction has invalid transfer amount information');
+  }
+  if (assetType === _types._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/cjs/services/balance-service/transfer/token.js

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getTransferMockTxFee = exports.createTransferExtrinsic = void 0;
+exports.getTransferMockTxFee = exports.createSubstrateExtrinsic = void 0;
 var _api = require("@gear-js/api");
 var _types = require("@subwallet/chain-list/types");
 var _wasm = require("@subwallet/extension-base/koni/api/contract-handler/wasm");
@@ -23,7 +23,7 @@ var _utilCrypto = require("@polkadot/util-crypto");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-const createTransferExtrinsic = async _ref => {
+const createSubstrateExtrinsic = async _ref => {
   var _tokenInfo$metadata;
   let {
     from,
@@ -119,7 +119,7 @@ const createTransferExtrinsic = async _ref => {
   }
   return [transfer, transferAmount || value];
 };
-exports.createTransferExtrinsic = createTransferExtrinsic;
+exports.createSubstrateExtrinsic = createSubstrateExtrinsic;
 const getTransferMockTxFee = async (address, chainInfo, tokenInfo, api) => {
   try {
     let estimatedFee;
@@ -157,7 +157,7 @@ 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/cjs/services/chain-service/handler/CardanoApi.js

@@ -0,0 +1,176 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CardanoApi = exports.API_KEY = void 0;
+var _utils = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/cardano/utils");
+var _types = require("@subwallet/extension-base/services/chain-service/types");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _rxjs = require("rxjs");
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const API_KEY = {
+  mainnet: process.env.BLOCKFROST_API_KEY_MAIN || '',
+  testnet: process.env.BLOCKFROST_API_KEY_PREP || ''
+};
+exports.API_KEY = API_KEY;
+class CardanoApi {
+  // private api: BlockFrostAPI;
+
+  apiRetry = 0;
+  isApiConnectedSubject = new _rxjs.BehaviorSubject(false);
+  connectionStatusSubject = new _rxjs.BehaviorSubject(_types._ChainConnectionStatus.DISCONNECTED);
+  isApiReady = false;
+  isApiReadyOnce = false;
+  constructor(chainSlug, apiUrl, _ref) {
+    let {
+      isTestnet,
+      providerName
+    } = _ref;
+    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 = (0, _utils2.createPromiseHandler)();
+    this.connect();
+  }
+  get isApiConnected() {
+    return this.isApiConnectedSubject.getValue();
+  }
+  get connectionStatus() {
+    return this.connectionStatusSubject.getValue();
+  }
+  updateConnectionStatus(status) {
+    const isConnected = status === _types._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(_types._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(_types._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(_types._ChainConnectionStatus.CONNECTED);
+  }
+  onDisconnect() {
+    this.updateConnectionStatus(_types._ChainConnectionStatus.DISCONNECTED);
+    if (this.isApiConnected) {
+      console.warn(`Disconnected from ${this.chainSlug} of ${this.apiUrl}`);
+      this.isApiReady = false;
+      this.isReadyHandler = (0, _utils2.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: (0, _utils.cborToBytes)(tx)
+      });
+      const hash = (await response.text()).replace(/^"|"$/g, '');
+      if ((0, _util.isHex)((0, _util.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 (0, _utils.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
+    });
+  }
+}
+exports.CardanoApi = CardanoApi;