@subwallet/extension-base 1.3.40-0 → 1.3.42-0

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

@@ -18,6 +18,7 @@ export declare class BalanceService implements StoppableServiceInterface {
     stopPromiseHandler: PromiseHandler<void>;
     status: ServiceStatus;
     private isReload;
+    get isStarted(): boolean;
     private readonly detectAccountBalanceStore;
     private readonly balanceDetectSubject;
     private readonly intervalTime;
@@ -87,6 +88,7 @@ export declare class BalanceService implements StoppableServiceInterface {
     private _unsubscribeBalance;
     /** Subscribe balance subscription */
     runSubscribeBalances(): Promise<void>;
+    refreshBalanceForAddress(address: string, chain: string, asset: string, extrinsicType?: ExtrinsicType): Promise<void>;
     /** Unsubscribe balance subscription */
     runUnsubscribeBalances(): void;
     /** Reload balance subscription */

package/services/balance-service/index.js

@@ -32,6 +32,9 @@ export class BalanceService {
   stopPromiseHandler = createPromiseHandler();
   status = ServiceStatus.NOT_INITIALIZED;
   isReload = false;
+  get isStarted() {
+    return this.status === ServiceStatus.STARTED;
+  }
   detectAccountBalanceStore = new DetectAccountBalanceStore();
   balanceDetectSubject = new BehaviorSubject({});
   intervalTime = 3 * 60 * 1000;
@@ -57,7 +60,7 @@ export class BalanceService {
     this.status = ServiceStatus.INITIALIZED;
 
     // Start service
-    await this.start();
+    // await this.start(); // Commented out to avoid auto start when app not fully initialized
 
     // Handle events
     this.state.eventService.onLazy(this.handleEvents.bind(this));
@@ -143,7 +146,7 @@ export class BalanceService {
     }
     if (needReload) {
       addLazy('reloadBalanceByEvents', () => {
-        if (!this.isReload) {
+        if (!this.isReload && this.isStarted) {
           this.runSubscribeBalances().catch(console.error);
         }
       }, lazyTime, undefined, true);
@@ -194,8 +197,9 @@ export class BalanceService {
       const substrateApiMap = this.state.chainService.getSubstrateApiMap();
       const tonApiMap = this.state.chainService.getTonApiMap();
       const cardanoApiMap = this.state.chainService.getCardanoApiMap();
+      const bitcoinApiMap = this.state.chainService.getBitcoinApiMap();
       let unsub = noop;
-      unsub = subscribeBalance([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, result => {
+      unsub = subscribeBalance([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, bitcoinApiMap, result => {
         const rs = result[0];
         let value;
         switch (balanceType) {
@@ -366,13 +370,14 @@ export class BalanceService {
     const substrateApiMap = this.state.chainService.getSubstrateApiMap();
     const tonApiMap = this.state.chainService.getTonApiMap();
     const cardanoApiMap = this.state.chainService.getCardanoApiMap();
+    const bitcoinApiMap = this.state.chainService.getBitcoinApiMap();
     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, cardanoApiMap, result => {
+    const unsub = subscribeBalance(addresses, activeChainSlugs, assets, assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, bitcoinApiMap, result => {
       !cancel && this.setBalanceItem(result);
     }, ExtrinsicType.TRANSFER_BALANCE);
     const unsub2 = this.state.subscribeMantaPayBalance();
@@ -382,6 +387,29 @@ export class BalanceService {
       unsub2 && unsub2();
     };
   }
+  async refreshBalanceForAddress(address, chain, asset, extrinsicType) {
+    // Check if address and chain are valid
+    const chainInfoMap = this.state.chainService.getChainInfoMap();
+    if (!chainInfoMap[chain]) {
+      console.warn(`Chain ${chain} is not supported`);
+      return;
+    }
+
+    // Get necessary data
+    const assetMap = this.state.chainService.getAssetRegistry();
+    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 bitcoinApiMap = this.state.chainService.getBitcoinApiMap();
+    return new Promise(resolve => {
+      const unsub = subscribeBalance([address], [chain], [asset], assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, bitcoinApiMap, result => {
+        this.setBalanceItem(result);
+        unsub();
+        resolve();
+      }, extrinsicType || ExtrinsicType.TRANSFER_BALANCE);
+    });
+  }
 
   /** Unsubscribe balance subscription */
   runUnsubscribeBalances() {

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

@@ -0,0 +1,14 @@
+import { _BitcoinApi } from '@subwallet/extension-base/services/chain-service/types';
+import { FeeInfo, TransactionFee } from '@subwallet/extension-base/types';
+import { Network, Psbt } from 'bitcoinjs-lib';
+export interface TransferBitcoinProps extends TransactionFee {
+    bitcoinApi: _BitcoinApi;
+    chain: string;
+    from: string;
+    feeInfo: FeeInfo;
+    to: string;
+    transferAll: boolean;
+    value: string;
+    network: Network;
+}
+export declare function createBitcoinTransaction(params: TransferBitcoinProps): Promise<[Psbt, string, string | undefined]>;

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

@@ -0,0 +1,112 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { _BITCOIN_CHAIN_SLUG, _BITCOIN_NAME, _BITCOIN_TESTNET_NAME } from '@subwallet/extension-base/services/chain-service/constants';
+import { combineBitcoinFee, determineUtxosForSpend, determineUtxosForSpendAll, getTransferableBitcoinUtxos } from '@subwallet/extension-base/utils';
+import { BitcoinAddressType } from '@subwallet/keyring/types';
+import { getBitcoinAddressInfo } from '@subwallet/keyring/utils';
+import { keyring } from '@subwallet/ui-keyring';
+import BigN from 'bignumber.js';
+import { Psbt } from 'bitcoinjs-lib';
+export async function createBitcoinTransaction(params) {
+  const {
+    bitcoinApi,
+    chain,
+    feeCustom: _feeCustom,
+    feeInfo: _feeInfo,
+    feeOption,
+    from,
+    network,
+    to,
+    transferAll,
+    value
+  } = params;
+  const feeCustom = _feeCustom;
+  const feeInfo = _feeInfo;
+  const bitcoinFee = combineBitcoinFee(feeInfo, feeOption, feeCustom);
+  const utxos = await getTransferableBitcoinUtxos(bitcoinApi, from);
+  try {
+    const amountValue = parseFloat(value);
+    const determineUtxosArgs = {
+      amount: amountValue,
+      feeRate: bitcoinFee.feeRate,
+      recipient: to,
+      sender: from,
+      utxos
+    };
+    const {
+      fee,
+      inputs,
+      isCustomFeeRate,
+      outputs,
+      size
+    } = transferAll ? determineUtxosForSpendAll(determineUtxosArgs) : determineUtxosForSpend(determineUtxosArgs);
+    const pair = keyring.getPair(from);
+    const tx = new Psbt({
+      network
+    });
+    let transferAmount = new BigN(0);
+    for (const input of inputs) {
+      const addressInfo = getBitcoinAddressInfo(pair.address);
+      if (addressInfo.type === BitcoinAddressType.p2pkh || addressInfo.type === BitcoinAddressType.p2sh) {
+        // BIP-44 (Legacy)
+        const hex = await bitcoinApi.api.getTxHex(input.txid);
+        tx.addInput({
+          hash: input.txid,
+          index: input.vout,
+          nonWitnessUtxo: Buffer.from(hex, 'hex')
+        });
+      } else if (addressInfo.type === BitcoinAddressType.p2wpkh) {
+        // BIP-84 (Native SegWit)
+        tx.addInput({
+          hash: input.txid,
+          index: input.vout,
+          witnessUtxo: {
+            script: pair.bitcoin.output,
+            value: input.value
+          }
+        });
+      } else if (addressInfo.type === BitcoinAddressType.p2tr) {
+        // BIP-86 (Taproot)
+        tx.addInput({
+          hash: input.txid,
+          index: input.vout,
+          witnessUtxo: {
+            script: pair.bitcoin.output,
+            value: input.value // UTXO value in satoshis
+          },
+
+          tapInternalKey: pair.bitcoin.internalPubkey // X-only public key (32 bytes)
+        });
+      } else {
+        throw new Error(`Unsupported address type: ${addressInfo.type}`);
+      }
+    }
+    for (const output of outputs) {
+      tx.addOutput({
+        address: output.address || from,
+        value: output.value
+      });
+      if (output.address === to) {
+        transferAmount = transferAmount.plus(output.value);
+      }
+    }
+    const customFeeRate = fee / size;
+    const customFeeRateResult = isCustomFeeRate ? customFeeRate.toString() : undefined;
+    return [tx, transferAmount.toString(), customFeeRateResult];
+  } catch (e) {
+    if (e instanceof TransactionError) {
+      throw e;
+    }
+    console.warn('Failed to create Bitcoin transaction:', e);
+    throw new Error(`You don’t have enough BTC (${convertChainToSymbol(chain)}) for the transaction. Lower your BTC amount and try again`);
+  }
+}
+function convertChainToSymbol(chain) {
+  if (chain === _BITCOIN_CHAIN_SLUG) {
+    return _BITCOIN_NAME;
+  } else {
+    return _BITCOIN_TESTNET_NAME;
+  }
+}

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

@@ -108,6 +108,8 @@ export const createSubstrateExtrinsic = async ({
         transfer = api.tx.balances.transfer(to, new BN(value));
       }
     }
+  } else if (_TRANSFER_CHAIN_GROUP.truth.includes(networkKey)) {
+    transfer = api.tx.assetManager.transfer(to, _getTokenOnChainInfo(tokenInfo), value);
   }
   return [transfer, transferAmount || value];
 };

package/services/balance-service/transfer/xcm/index.js

@@ -128,19 +128,25 @@ export const createXcmExtrinsicV2 = async request => {
 export const dryRunXcmExtrinsicV2 = async request => {
   try {
     const dryRunResult = await dryRunXcm(request);
-    const originDryRunResult = dryRunResult.origin;
-    if (originDryRunResult.success) {
-      const destinationDryRunResult = dryRunResult.destination;
-      if (destinationDryRunResult.success) {
-        return true;
+    const originDryRunRs = dryRunResult.origin;
+    if (originDryRunRs.success) {
+      const {
+        assetHub,
+        bridgeHub,
+        destination
+      } = dryRunResult;
+      if ((assetHub === null || assetHub === void 0 ? void 0 : assetHub.success) === false || (bridgeHub === null || bridgeHub === void 0 ? void 0 : bridgeHub.success) === false || (destination === null || destination === void 0 ? void 0 : destination.success) === false) {
+        if ((destination === null || destination === void 0 ? void 0 : destination.success) === false) {
+          // pass dry-run in these cases
+          return isChainNotSupportDryRun(destination.failureReason) || isChainNotSupportPolkadotApi(destination.failureReason);
+        }
+        return false;
       }
-
-      // pass dry-run in these cases
-      return isChainNotSupportDryRun(destinationDryRunResult.failureReason) || isChainNotSupportPolkadotApi(destinationDryRunResult.failureReason);
+      return true;
     }
 
     // pass dry-run in these cases
-    return isChainNotSupportDryRun(originDryRunResult.failureReason) || isChainNotSupportPolkadotApi(originDryRunResult.failureReason);
+    return isChainNotSupportDryRun(originDryRunRs.failureReason) || isChainNotSupportPolkadotApi(originDryRunRs.failureReason);
   } catch (e) {
     return false;
   }

package/services/balance-service/transfer/xcm/utils.d.ts

@@ -14,6 +14,8 @@ export declare type DryRunNodeResult = DryRunNodeSuccess | DryRunNodeFailure;
 export declare type DryRunResult = {
     origin: DryRunNodeResult;
     destination?: DryRunNodeResult;
+    assetHub?: DryRunNodeResult;
+    bridgeHub?: DryRunNodeResult;
 };
 interface GetXcmFeeRequest {
     sender: string;

package/services/balance-service/transfer/xcm/utils.js

@@ -2,14 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { fetchParaSpellChainMap } from '@subwallet/extension-base/constants/paraspell-chain-map';
+import { ProxyServiceRoute } from '@subwallet/extension-base/types/environment';
+import { fetchFromProxyService } from '@subwallet/extension-base/utils';
 import { assert, compactToU8a, isHex, u8aConcat, u8aEq } from '@polkadot/util';
-const paraSpellEndpoint = 'https://api.lightspell.xyz/v3';
+const version = '/v3';
 const paraSpellApi = {
-  buildXcm: `${paraSpellEndpoint}/x-transfer`,
-  dryRunXcm: `${paraSpellEndpoint}/dry-run`,
-  feeXcm: `${paraSpellEndpoint}/xcm-fee`
+  buildXcm: `${version}/x-transfer`,
+  dryRunXcm: `${version}/dry-run`,
+  feeXcm: `${version}/xcm-fee`
 };
-const paraSpellKey = process.env.PARASPELL_API_KEY || '';
 function txHexToSubmittableExtrinsic(api, hex) {
   try {
     assert(isHex(hex), 'Expected a hex-encoded call');
@@ -86,13 +87,12 @@ export async function buildXcm(request) {
     to: paraSpellChainMap[destinationChain.slug],
     currency: createParaSpellCurrency(psAssetType, psAssetValue, sendingValue)
   };
-  const response = await fetch(paraSpellApi.buildXcm, {
+  const response = await fetchFromProxyService(ProxyServiceRoute.PARASPELL, paraSpellApi.buildXcm, {
     method: 'POST',
     body: JSON.stringify(bodyData),
     headers: {
       'Content-Type': 'application/json',
-      Accept: 'application/json',
-      'X-API-KEY': paraSpellKey
+      Accept: 'application/json'
     }
   });
   if (!response.ok) {
@@ -126,13 +126,12 @@ export async function dryRunXcm(request) {
     to: paraSpellChainMap[destinationChain.slug],
     currency: createParaSpellCurrency(psAssetType, psAssetValue, sendingValue)
   };
-  const response = await fetch(paraSpellApi.dryRunXcm, {
+  const response = await fetchFromProxyService(ProxyServiceRoute.PARASPELL, paraSpellApi.dryRunXcm, {
     method: 'POST',
     body: JSON.stringify(bodyData),
     headers: {
       'Content-Type': 'application/json',
-      Accept: 'application/json',
-      'X-API-KEY': paraSpellKey
+      Accept: 'application/json'
     }
   });
   if (!response.ok) {
@@ -170,13 +169,12 @@ export async function estimateXcmFee(request) {
     to: paraSpellChainMap[toChainInfo.slug],
     currency: createParaSpellCurrency(psAssetType, psAssetValue, value)
   };
-  const response = await fetch(paraSpellApi.feeXcm, {
+  const response = await fetchFromProxyService(ProxyServiceRoute.PARASPELL, paraSpellApi.feeXcm, {
     method: 'POST',
     body: JSON.stringify(bodyData),
     headers: {
       'Content-Type': 'application/json',
-      Accept: 'application/json',
-      'X-API-KEY': paraSpellKey
+      Accept: 'application/json'
     }
   });
   if (!response.ok) {

package/services/base/types.d.ts

@@ -5,6 +5,8 @@ export declare enum ServiceStatus {
     INITIALIZED = "initialized",
     STARTED = "started",
     STARTING = "starting",
+    STARTED_FULL = "started_full",
+    STARTING_FULL = "starting_full",
     STOPPED = "stopped",
     STOPPING = "stopping"
 }

package/services/base/types.js

@@ -10,6 +10,8 @@ export let ServiceStatus;
   ServiceStatus["INITIALIZED"] = "initialized";
   ServiceStatus["STARTED"] = "started";
   ServiceStatus["STARTING"] = "starting";
+  ServiceStatus["STARTED_FULL"] = "started_full";
+  ServiceStatus["STARTING_FULL"] = "starting_full";
   ServiceStatus["STOPPED"] = "stopped";
   ServiceStatus["STOPPING"] = "stopping";
 })(ServiceStatus || (ServiceStatus = {}));

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

@@ -21,6 +21,7 @@ export declare const _BALANCE_CHAIN_GROUP: {
     centrifuge: string[];
     supportBridged: string[];
     bittensor: string[];
+    moonbeam: string[];
 };
 export declare const _BALANCE_TOKEN_GROUP: {
     crab: string[];
@@ -71,6 +72,7 @@ export declare const _TRANSFER_CHAIN_GROUP: {
     pendulum: string[];
     centrifuge: string[];
     disable_transfer: string[];
+    truth: string[];
 };
 export declare const _BALANCE_PARSING_CHAIN_GROUP: {
     bobabeam: string[];
@@ -94,9 +96,14 @@ export declare const EVM_REFORMAT_DECIMALS: {
     acala: string[];
 };
 export declare const LATEST_CHAIN_DATA_FETCHING_INTERVAL = 120000;
+export declare const _BITCOIN_CHAIN_SLUG = "bitcoin";
+export declare const _BITCOIN_TESTNET_CHAIN_SLUG = "bitcoinTestnet";
+export declare const _BITCOIN_NAME = "Bitcoin";
+export declare const _BITCOIN_TESTNET_NAME = "Bitcoin Testnet";
 export declare const _CHAIN_INFO_SRC: string;
 export declare const _CHAIN_ASSET_SRC: string;
 export declare const _ASSET_REF_SRC: string;
 export declare const _MULTI_CHAIN_ASSET_SRC: string;
 export declare const _CHAIN_LOGO_MAP_SRC: string;
 export declare const _ASSET_LOGO_MAP_SRC: string;
+export declare const _BTC_SERVICE_TOKEN: string;

package/services/chain-service/constants.js

@@ -30,12 +30,13 @@ export const _BALANCE_CHAIN_GROUP = {
   genshiro: ['genshiro_testnet', 'genshiro'],
   equilibrium_parachain: ['equilibrium_parachain'],
   bifrost: ['bifrost', 'acala', 'karura', 'acala_testnet', 'pioneer', 'bitcountry', 'bifrost_dot', 'hydradx_main', 'hydradx_rococo', 'pendulum', 'amplitude', 'continuum_network', 'truth_network', 'jamton'],
-  statemine: ['statemine', 'astar', 'shiden', 'statemint', 'moonbeam', 'moonbase', 'moonriver', 'crabParachain', 'darwinia2', 'parallel', 'calamari', 'manta_network', 'rococo_assethub', 'liberlandTest', 'liberland', 'dentnet', 'pangolin', 'crust', 'phala', 'shibuya', 'dbcchain', 'westend_assethub'],
+  statemine: ['statemine', 'astar', 'shiden', 'statemint', 'crabParachain', 'darwinia2', 'parallel', 'calamari', 'manta_network', 'rococo_assethub', 'liberlandTest', 'liberland', 'dentnet', 'pangolin', 'crust', 'phala', 'shibuya', 'dbcchain', 'westend_assethub', 'chainflip_assethub'],
   kusama: ['kusama', 'kintsugi', 'kintsugi_test', 'interlay', 'acala', 'statemint', 'karura', 'bifrost'],
   // perhaps there are some runtime updates
   centrifuge: ['centrifuge'],
   supportBridged: ['rococo_assethub', 'statemint', 'statemine', 'polimec'],
-  bittensor: ['bittensor', 'bittensor_testnet']
+  bittensor: ['bittensor', 'bittensor_testnet'],
+  moonbeam: ['moonbeam', 'moonriver', 'moonbase']
 };
 export const _BALANCE_TOKEN_GROUP = {
   crab: ['CKTON', 'PKTON'],
@@ -254,13 +255,14 @@ 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', 'westend_assethub'],
+  statemine: ['statemint', 'statemine', 'darwinia2', 'astar', 'shiden', 'shibuya', 'parallel', 'liberland', 'liberlandTest', 'dentnet', 'dbcchain', 'westend_assethub', 'chainflip_assethub'],
   riochain: ['riochain'],
   sora_substrate: ['sora_substrate'],
   avail: ['kate', 'goldberg_testnet'],
   pendulum: ['pendulum', 'amplitude', 'amplitude_test', 'hydradx_main', 'bifrost', 'bifrost_dot', 'jamton'],
   centrifuge: ['centrifuge'],
-  disable_transfer: ['crab', 'pangolin']
+  disable_transfer: ['crab', 'pangolin'],
+  truth: ['truth_network']
 };
 export const _BALANCE_PARSING_CHAIN_GROUP = {
   bobabeam: ['bobabeam', 'bobabase']
@@ -301,9 +303,14 @@ export const LATEST_CHAIN_DATA_FETCHING_INTERVAL = 120000;
 
 // TODO: review
 const TARGET_BRANCH = process.env.NODE_ENV !== 'production' ? 'koni-dev' : 'master';
+export const _BITCOIN_CHAIN_SLUG = 'bitcoin';
+export const _BITCOIN_TESTNET_CHAIN_SLUG = 'bitcoinTestnet';
+export const _BITCOIN_NAME = 'Bitcoin';
+export const _BITCOIN_TESTNET_NAME = 'Bitcoin Testnet';
 export const _CHAIN_INFO_SRC = `https://raw.githubusercontent.com/Koniverse/SubWallet-Chain/${TARGET_BRANCH}/packages/chain-list/src/data/ChainInfo.json`;
 export const _CHAIN_ASSET_SRC = `https://raw.githubusercontent.com/Koniverse/SubWallet-Chain/${TARGET_BRANCH}/packages/chain-list/src/data/ChainAsset.json`;
 export const _ASSET_REF_SRC = `https://raw.githubusercontent.com/Koniverse/SubWallet-Chain/${TARGET_BRANCH}/packages/chain-list/src/data/AssetRef.json`;
 export const _MULTI_CHAIN_ASSET_SRC = `https://raw.githubusercontent.com/Koniverse/SubWallet-Chain/${TARGET_BRANCH}/packages/chain-list/src/data/MultiChainAsset.json`;
 export const _CHAIN_LOGO_MAP_SRC = `https://raw.githubusercontent.com/Koniverse/SubWallet-Chain/${TARGET_BRANCH}/packages/chain-list/src/data/ChainLogoMap.json`;
-export const _ASSET_LOGO_MAP_SRC = `https://raw.githubusercontent.com/Koniverse/SubWallet-Chain/${TARGET_BRANCH}/packages/chain-list/src/data/AssetLogoMap.json`;
+export const _ASSET_LOGO_MAP_SRC = `https://raw.githubusercontent.com/Koniverse/SubWallet-Chain/${TARGET_BRANCH}/packages/chain-list/src/data/AssetLogoMap.json`;
+export const _BTC_SERVICE_TOKEN = process.env.BTC_SERVICE_TOKEN || '';

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

@@ -3,10 +3,6 @@ import { _ApiOptions } from '@subwallet/extension-base/services/chain-service/ha
 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;
@@ -18,11 +14,11 @@ export declare class CardanoApi implements _CardanoApi {
     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 fetchCardano;
     private updateConnectionStatus;
     get isReady(): Promise<_CardanoApi>;
     updateApiUrl(apiUrl: string): Promise<void>;

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

@@ -3,13 +3,16 @@
 
 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 { ProxyServiceRoute } from '@subwallet/extension-base/types/environment';
+import { createPromiseHandler, fetchFromProxyService } 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 const API_KEY = {
+//   mainnet: process.env.BLOCKFROST_API_KEY_MAIN || '',
+//   testnet: process.env.BLOCKFROST_API_KEY_PREP || ''
+// };
+
 export class CardanoApi {
   // private api: BlockFrostAPI;
 
@@ -25,7 +28,6 @@ export class CardanoApi {
     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();
@@ -37,6 +39,9 @@ export class CardanoApi {
   get connectionStatus() {
     return this.connectionStatusSubject.getValue();
   }
+  fetchCardano(path, options) {
+    return fetchFromProxyService(ProxyServiceRoute.CARDANO, path, options, this.isTestnet);
+  }
   updateConnectionStatus(status) {
     const isConnected = status === _ChainConnectionStatus.CONNECTED;
     if (isConnected !== this.isApiConnectedSubject.value) {
@@ -107,12 +112,9 @@ export class CardanoApi {
   }
   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 path = `/addresses/${address}`;
+      const response = await this.fetchCardano(path, {
+        method: 'GET'
       });
       const addressBalance = await response.json();
       return addressBalance.amount;
@@ -123,13 +125,10 @@ export class CardanoApi {
   }
   async getUtxos(address, page, limit) {
     try {
-      let url = this.isTestnet ? `https://cardano-preprod.blockfrost.io/api/v0/addresses/${address}/utxos` : `https://cardano-mainnet.blockfrost.io/api/v0/addresses/${address}/utxos`;
-      url += `?page=${page}&count=${limit}`;
-      const response = await fetch(url, {
-        method: 'GET',
-        headers: {
-          Project_id: this.projectId
-        }
+      let path = `/addresses/${address}/utxos`;
+      path += `?page=${page}&count=${limit}`;
+      const response = await this.fetchCardano(path, {
+        method: 'GET'
       });
       const utxos = await response.json();
       return utxos;
@@ -140,12 +139,9 @@ export class CardanoApi {
   }
   async getSpecificUtxo(txHash) {
     try {
-      const url = this.isTestnet ? `https://cardano-preprod.blockfrost.io/api/v0/txs/${txHash}/utxos` : `https://cardano-mainnet.blockfrost.io/api/v0/txs/${txHash}/utxos`;
-      const response = await fetch(url, {
-        method: 'GET',
-        headers: {
-          Project_id: this.projectId
-        }
+      const path = `/txs/${txHash}/utxos`;
+      const response = await this.fetchCardano(path, {
+        method: 'GET'
       });
       const utxo = await response.json();
       return utxo;
@@ -156,11 +152,10 @@ export class CardanoApi {
   }
   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, {
+      const path = '/tx/submit';
+      const response = await this.fetchCardano(path, {
         method: 'POST',
         headers: {
-          Project_id: this.projectId,
           'Content-Type': 'application/cbor'
         },
         body: cborToBytes(tx)
@@ -180,12 +175,9 @@ export class CardanoApi {
   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 path = `/txs/${txHash}`;
+      const response = await this.fetchCardano(path, {
+        method: 'GET'
       });
       const txInfo = await response.json();
       if (txInfo.block && txInfo.hash && txInfo.index >= 0) {

package/services/chain-service/handler/bitcoin/BitcoinApi.d.ts

@@ -0,0 +1,31 @@
+import { BitcoinApiStrategy } from '@subwallet/extension-base/services/chain-service/handler/bitcoin/strategy/types';
+import { PromiseHandler } from '@subwallet/extension-base/utils/promise';
+import { BehaviorSubject } from 'rxjs';
+import { _ApiOptions } from '../../handler/types';
+import { _BitcoinApi, _ChainConnectionStatus } from '../../types';
+export declare class BitcoinApi implements _BitcoinApi {
+    chainSlug: string;
+    apiUrl: string;
+    apiError?: string;
+    apiRetry: number;
+    readonly isApiConnectedSubject: BehaviorSubject<boolean>;
+    readonly connectionStatusSubject: BehaviorSubject<_ChainConnectionStatus>;
+    isApiReady: boolean;
+    isApiReadyOnce: boolean;
+    isReadyHandler: PromiseHandler<_BitcoinApi>;
+    providerName: string;
+    api: BitcoinApiStrategy;
+    constructor(chainSlug: string, apiUrl: string, { providerName }?: _ApiOptions);
+    get isApiConnected(): boolean;
+    private createApiStrategy;
+    get connectionStatus(): _ChainConnectionStatus;
+    private updateConnectionStatus;
+    get isReady(): Promise<_BitcoinApi>;
+    updateApiUrl(apiUrl: string): Promise<void>;
+    recoverConnect(): Promise<void>;
+    connect(): void;
+    disconnect(): Promise<void>;
+    destroy(): Promise<void>;
+    onConnect(): void;
+    onDisconnect(): void;
+}