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

package/services/transaction-service/index.js

@@ -11,7 +11,7 @@ import { _getAssetDecimals, _getAssetSymbol, _getChainNativeTokenBasicInfo, _get
 import { EXTENSION_REQUEST_URL } from '@subwallet/extension-base/services/request-service/constants';
 import { TRANSACTION_TIMEOUT } from '@subwallet/extension-base/services/transaction-service/constants';
 import { parseLiquidStakingEvents, parseLiquidStakingFastUnstakeEvents, parseTransferEventLogs, parseXcmEventLogs } from '@subwallet/extension-base/services/transaction-service/event-parser';
-import { getBaseTransactionInfo, getTransactionId, isCardanoTransaction, isSubstrateTransaction, isTonTransaction } from '@subwallet/extension-base/services/transaction-service/helpers';
+import { getBaseTransactionInfo, getTransactionId, isBitcoinTransaction, isCardanoTransaction, isSubstrateTransaction, isTonTransaction } from '@subwallet/extension-base/services/transaction-service/helpers';
 import { getExplorerLink, parseTransactionData } from '@subwallet/extension-base/services/transaction-service/utils';
 import { isWalletConnectRequest } from '@subwallet/extension-base/services/wallet-connect-service/helpers';
 import { BasicTxErrorType, StepStatus, YieldPoolType } from '@subwallet/extension-base/types';
@@ -39,10 +39,6 @@ export default class TransactionService {
   }
   constructor(state) {
     this.state = state;
-    this.eventService = state.eventService;
-    this.historyService = state.historyService;
-    this.notificationService = state.notificationService;
-    this.chainService = state.chainService;
   }
   get allTransactions() {
     return Object.values(this.transactions);
@@ -74,6 +70,7 @@ export default class TransactionService {
       additionalValidator,
       address,
       chain,
+      chainType,
       extrinsicType
     } = validationResponse;
     const chainInfo = this.state.chainService.getChainInfoByKey(chain);
@@ -103,27 +100,30 @@ export default class TransactionService {
     const evmApi = this.state.chainService.getEvmApi(chainInfo.slug);
     const tonApi = this.state.chainService.getTonApi(chainInfo.slug);
     const cardanoApi = this.state.chainService.getCardanoApi(chainInfo.slug);
+    const bitcoinApi = this.state.chainService.getBitcoinApi(chainInfo.slug);
     // todo: should split into isEvmTx && isNoEvmApi. Because other chains type also has no Evm Api. Same to all blockchain.
     // todo: refactor check evmTransaction.
-    const isNoEvmApi = transaction && !isSubstrateTransaction(transaction) && !isTonTransaction(transaction) && !isCardanoTransaction(transaction) && !evmApi;
+    const isNoEvmApi = transaction && !isSubstrateTransaction(transaction) && !isTonTransaction(transaction) && !isCardanoTransaction(transaction) && !isBitcoinTransaction(transaction) && !evmApi;
     const isNoTonApi = transaction && isTonTransaction(transaction) && !tonApi;
     const isNoCardanoApi = transaction && isCardanoTransaction(transaction) && !cardanoApi;
-    if (isNoEvmApi || isNoTonApi || isNoCardanoApi) {
+    const isNoBitcoinApi = transaction && isBitcoinTransaction(transaction) && !bitcoinApi;
+    if (isNoEvmApi || isNoTonApi || isNoCardanoApi || isNoBitcoinApi) {
       validationResponse.errors.push(new TransactionError(BasicTxErrorType.CHAIN_DISCONNECTED, undefined));
     }
 
     // Estimate fee for transaction
     const id = getId();
-    const feeInfo = await this.state.feeService.subscribeChainFee(id, chain, 'evm');
+    const feeInfo = await this.state.feeService.subscribeChainFee(id, chain, chainType);
     const nativeTokenInfo = this.state.chainService.getNativeTokenInfo(chain);
     const tokenPayFeeSlug = transactionInput.tokenPayFeeSlug;
     const isNonNativeTokenPayFee = tokenPayFeeSlug && !_isNativeTokenBySlug(tokenPayFeeSlug);
-    const nonNativeTokenPayFeeInfo = isNonNativeTokenPayFee ? this.chainService.getAssetBySlug(tokenPayFeeSlug) : undefined;
+    const nonNativeTokenPayFeeInfo = isNonNativeTokenPayFee ? this.state.chainService.getAssetBySlug(tokenPayFeeSlug) : undefined;
     const priceMap = (await this.state.priceService.getPrice()).priceMap;
     validationResponse.estimateFee = await estimateFeeForTransaction(validationResponse, transaction, chainInfo, evmApi, substrateApi, priceMap, feeInfo, nativeTokenInfo, nonNativeTokenPayFeeInfo, transactionInput.isTransferLocalTokenAndPayThatTokenAsFee);
     const chainInfoMap = this.state.chainService.getChainInfoMap();
 
     // Check account signing transaction
+
     checkSigningAccountForTransaction(validationResponse, chainInfoMap);
     const nativeTokenAvailable = await this.state.balanceService.getTransferableBalance(address, chain, nativeTokenInfo.slug, extrinsicType);
 
@@ -186,7 +186,7 @@ export default class TransactionService {
   }
   fillTransactionDefaultInfo(transaction) {
     const isInternal = !transaction.url;
-    const transactionId = getTransactionId(transaction.chainType, transaction.chain, isInternal, isWalletConnectRequest(transaction.id));
+    const transactionId = transaction.id || getTransactionId(transaction.chainType, transaction.chain, isInternal, isWalletConnectRequest(transaction.id));
     return {
       ...transaction,
       createdAt: new Date().getTime(),
@@ -410,7 +410,7 @@ export default class TransactionService {
   }
   async sendTransaction(transaction) {
     // Send Transaction
-    const emitter = await (transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : transaction.chainType === 'evm' ? this.signAndSendEvmTransaction(transaction) : transaction.chainType === 'cardano' ? this.signAndSendCardanoTransaction(transaction) : this.signAndSendTonTransaction(transaction));
+    const emitter = await (transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : transaction.chainType === 'evm' ? this.signAndSendEvmTransaction(transaction) : transaction.chainType === 'cardano' ? this.signAndSendCardanoTransaction(transaction) : transaction.chainType === 'ton' ? this.signAndSendTonTransaction(transaction) : this.signAndSendBitcoinTransaction(transaction));
     const {
       eventsHandler,
       step
@@ -669,6 +669,7 @@ export default class TransactionService {
       extrinsicHash: transaction.extrinsicHash,
       time: transaction.createdAt,
       fee: transaction.estimateFee,
+      blockTime: undefined,
       blockNumber: 0,
       // Will be added in next step
       blockHash: '',
@@ -1055,6 +1056,24 @@ export default class TransactionService {
     if ([ExtrinsicType.STAKING_JOIN_POOL, ExtrinsicType.STAKING_BOND, ExtrinsicType.JOIN_YIELD_POOL, ExtrinsicType.MINT_LDOT, ExtrinsicType.MINT_QDOT, ExtrinsicType.MINT_SDOT, ExtrinsicType.MINT_STDOT, ExtrinsicType.MINT_VDOT, ExtrinsicType.MINT_VMANTA].includes(transaction.extrinsicType)) {
       this.handlePostEarningTransaction(id);
     }
+
+    // Trigger balance update for Bitcoin transactions after receiving extrinsicHash
+    if (ExtrinsicType.TRANSFER_BALANCE && transaction.chainType === 'bitcoin') {
+      const balanceService = this.state.balanceService;
+      const inputData = parseTransactionData(transaction.data);
+      try {
+        const sender = keyring.getPair(inputData.from);
+        balanceService.refreshBalanceForAddress(sender.address, transaction.chain, inputData.tokenSlug, transaction.extrinsicType).catch(error => console.error('Failed to run balance subscription:', error));
+      } catch (e) {
+        console.error(e);
+      }
+      try {
+        const recipient = keyring.getPair(inputData.to);
+        balanceService.refreshBalanceForAddress(recipient.address, transaction.chain, inputData.tokenSlug, transaction.extrinsicType).catch(error => console.error('Failed to run balance subscription:', error));
+      } catch (e) {
+        console.error(e);
+      }
+    }
   }
   handlePostProcessing(id) {
     // must be done after success/failure to make sure the transaction is finalized
@@ -1093,6 +1112,7 @@ export default class TransactionService {
   onSuccess({
     blockHash,
     blockNumber,
+    blockTime,
     extrinsicHash,
     id
   }) {
@@ -1107,7 +1127,8 @@ export default class TransactionService {
       extrinsicHash,
       status: ExtrinsicStatus.SUCCESS,
       blockNumber: blockNumber || 0,
-      blockHash: blockHash || ''
+      blockHash: blockHash || '',
+      blockTime
     }).catch(console.error);
     const info = isHex(extrinsicHash) ? extrinsicHash : getBaseTransactionInfo(transaction, this.state.chainService.getChainInfoMap());
     this.state.notificationService.notify({
@@ -1180,14 +1201,14 @@ export default class TransactionService {
         errors,
         extrinsicHash
       });
-      this.historyService.updateHistoryByExtrinsicHash(transaction.extrinsicHash, {
+      this.state.historyService.updateHistoryByExtrinsicHash(transaction.extrinsicHash, {
         extrinsicHash: extrinsicHash || transaction.extrinsicHash,
         status: nextStatus,
         blockNumber: blockNumber || 0,
         blockHash: blockHash || ''
       }).catch(console.error);
-      const info = isHex(transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash) ? transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash : getBaseTransactionInfo(transaction, this.chainService.getChainInfoMap());
-      this.notificationService.notify({
+      const info = isHex(transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash) ? transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash : getBaseTransactionInfo(transaction, this.state.chainService.getChainInfoMap());
+      this.state.notificationService.notify({
         type: NotificationType.ERROR,
         title: t('Transaction timed out'),
         message: t('Transaction {{info}} timed out', {
@@ -1201,7 +1222,7 @@ export default class TransactionService {
         notifyViaBrowser: true
       });
     }
-    this.eventService.emit('transaction.timeout', transaction);
+    this.state.eventService.emit('transaction.timeout', transaction);
   }
   generateHashPayload(chain, transaction) {
     const chainInfo = this.state.chainService.getChainInfoByKey(chain);
@@ -1864,6 +1885,104 @@ export default class TransactionService {
     });
     return emitter;
   }
+  emitterEventTransaction = (emitter, eventData, chain, payload) => {
+    // Emit signed event
+    emitter.emit('signed', eventData);
+    // Add start info
+    emitter.emit('send', eventData);
+    const event = this.state.chainService.getBitcoinApi(chain).api.sendRawTransaction(payload);
+    event.on('extrinsicHash', txHash => {
+      eventData.extrinsicHash = txHash;
+      emitter.emit('extrinsicHash', eventData);
+    });
+    event.on('success', transactionStatus => {
+      console.log(transactionStatus);
+      eventData.blockHash = transactionStatus.block_hash || undefined;
+      eventData.blockNumber = transactionStatus.block_height || undefined;
+      eventData.blockTime = transactionStatus.block_time ? transactionStatus.block_time * 1000 : undefined;
+      emitter.emit('success', eventData);
+    });
+    event.on('error', error => {
+      eventData.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SEND, error));
+      emitter.emit('error', eventData);
+    });
+  };
+  signAndSendBitcoinTransaction({
+    address,
+    chain,
+    id,
+    transaction,
+    url
+  }) {
+    const tx = transaction;
+    // const bitcoinApi = this.state.chainService.getBitcoinApi(chain);
+    // const chainInfo = this.state.chainService.getChainInfoByKey(chain);
+
+    const accountPair = keyring.getPair(address);
+    const account = pairToAccount(accountPair);
+    const payload = {
+      payload: undefined,
+      payloadJson: undefined,
+      account,
+      canSign: true,
+      hashPayload: tx.toHex(),
+      id
+    };
+    const emitter = new EventEmitter();
+    const eventData = {
+      id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: id
+    };
+    const isInjected = !!account.isInjected;
+    // const isExternal = !!account.isExternal;
+
+    if (isInjected) {
+      throw new TransactionError(BasicTxErrorType.UNSUPPORTED);
+    } else {
+      this.state.requestService.addConfirmationBitcoin(id, url || EXTENSION_REQUEST_URL, 'bitcoinSendTransactionRequest', payload, {}).then(({
+        isApproved,
+        payload
+      }) => {
+        if (isApproved) {
+          if (!payload) {
+            throw new Error('Bad signature');
+          }
+
+          // Emit signed event
+          emitter.emit('signed', eventData);
+          // Add start info
+          emitter.emit('send', eventData);
+          const bitcoinApi = this.state.chainService.getBitcoinApi(chain);
+          const event = bitcoinApi.api.sendRawTransaction(payload);
+          event.on('extrinsicHash', txHash => {
+            eventData.extrinsicHash = txHash;
+            emitter.emit('extrinsicHash', eventData);
+          });
+          event.on('success', transactionStatus => {
+            eventData.blockHash = transactionStatus.block_hash || undefined;
+            eventData.blockNumber = transactionStatus.block_height || undefined;
+            eventData.blockTime = transactionStatus.block_time ? transactionStatus.block_time * 1000 : undefined;
+            emitter.emit('success', eventData);
+          });
+          event.on('error', error => {
+            eventData.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SEND, error));
+            emitter.emit('error', eventData);
+          });
+        } else {
+          this.removeTransaction(id);
+          eventData.errors.push(new TransactionError(BasicTxErrorType.USER_REJECT_REQUEST));
+          emitter.emit('error', eventData);
+        }
+      }).catch(e => {
+        this.removeTransaction(id);
+        eventData.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SIGN, e.message));
+        emitter.emit('error', eventData);
+      });
+    }
+    return emitter;
+  }
   handleTransactionTimeout(emitter, eventData) {
     const timeout = setTimeout(() => {
       const transaction = this.getTransaction(eventData.id);

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

@@ -3,11 +3,12 @@ import { SignTypedDataMessageV3V4 } from '@subwallet/extension-base/core/logic-v
 import { TonTransactionConfig } from '@subwallet/extension-base/services/balance-service/transfer/ton-transfer';
 import { UniswapOrderInfo } from '@subwallet/extension-base/services/swap-service/handler/uniswap-handler';
 import { BaseRequestSign, BriefProcessStep, ProcessTransactionData, TransactionFee } from '@subwallet/extension-base/types';
+import { Psbt } from 'bitcoinjs-lib';
 import EventEmitter from 'eventemitter3';
 import { TransactionConfig } from 'web3-core';
 import { SubmittableExtrinsic } from '@polkadot/api/promise/types';
 import { EventRecord } from '@polkadot/types/interfaces';
-export interface SWTransactionBase extends ValidateTransactionResponse, Partial<Pick<BaseRequestSign, 'ignoreWarnings'>>, TransactionFee {
+export interface SWTransactionBase extends ValidateTransactionResponse, Partial<Pick<BaseRequestSign, 'ignoreWarnings'>>, TransactionFee, SWTransactionEmitter {
     id: string;
     url?: string;
     isInternal: boolean;
@@ -31,7 +32,7 @@ export interface SWTransactionBase extends ValidateTransactionResponse, Partial<
     step?: BriefProcessStep;
 }
 export interface SWTransaction extends SWTransactionBase {
-    transaction: SubmittableExtrinsic | TransactionConfig | TonTransactionConfig;
+    transaction: SubmittableExtrinsic | TransactionConfig | TonTransactionConfig | Psbt;
 }
 export interface SWPermitTransaction extends SWTransactionBase {
     transaction: SignTypedDataMessageV3V4;
@@ -45,6 +46,9 @@ export interface SWDutchTransaction extends SWTransactionBase {
 export interface SWTransactionResult extends Omit<SWTransactionBase, 'transaction' | 'additionalValidator' | 'eventsHandler' | 'process'> {
     process?: ProcessTransactionData;
 }
+export interface SWTransactionEmitter {
+    emitterTransaction?: TransactionEmitter;
+}
 declare type SwInputBase = Pick<SWTransactionBase, 'address' | 'url' | 'data' | 'extrinsicType' | 'chain' | 'chainType' | 'ignoreWarnings' | 'transferNativeAmount'> & Partial<Pick<SWTransactionBase, 'additionalValidator' | 'eventsHandler'>>;
 export interface SWTransactionInput extends SwInputBase, Partial<Pick<SWTransactionBase, 'estimateFee' | 'signAfterCreate' | 'isPassConfirmation' | 'step' | 'errorOnTimeOut' | 'xcmFeeDryRun'>>, TransactionFee {
     id?: string;
@@ -66,6 +70,11 @@ export interface SWDutchTransactionInput extends Omit<SWTransactionInput, 'trans
 export declare type SWTransactionResponse = SwInputBase & Pick<SWTransactionBase, 'warnings' | 'errors'> & Partial<Pick<SWTransactionBase, 'id' | 'extrinsicHash' | 'status' | 'estimateFee' | 'xcmFeeDryRun'>> & TransactionFee & {
     processId?: string;
 };
+export declare type BitcoinTransactionData = {
+    data: Psbt;
+    dataBase64: string;
+    dataToHex: string;
+};
 export declare type ValidateTransactionResponseInput = SWTransactionInput;
 export declare type TransactionEmitter = EventEmitter<TransactionEventMap>;
 export interface TransactionEventResponse extends ValidateTransactionResponse {
@@ -77,6 +86,7 @@ export interface TransactionEventResponse extends ValidateTransactionResponse {
     eventLogs?: EventRecord[];
     nonce?: number;
     startBlock?: number;
+    blockTime?: number;
 }
 export interface TransactionEventMap {
     send: (response: TransactionEventResponse) => void;

package/services/transaction-service/utils.js

@@ -1,7 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { _getBlockExplorerFromChain, _isChainTestNet, _isPureCardanoChain, _isPureEvmChain } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getBlockExplorerFromChain, _isChainTestNet, _isPureBitcoinChain, _isPureCardanoChain, _isPureEvmChain } from '@subwallet/extension-base/services/chain-service/utils';
 import { CHAIN_FLIP_MAINNET_EXPLORER, CHAIN_FLIP_TESTNET_EXPLORER, SIMPLE_SWAP_EXPLORER } from '@subwallet/extension-base/services/swap-service/utils';
 import { hexAddPrefix, isHex, u8aToHex } from '@polkadot/util';
 import { decodeAddress } from '@polkadot/util-crypto';
@@ -28,8 +28,8 @@ function getBlockExplorerAccountRoute(explorerLink) {
   if (explorerLink.includes('statescan.io')) {
     return '#/accounts';
   }
-  if (explorerLink.includes('explorer.zkverify.io')) {
-    return 'account';
+  if (explorerLink.includes('explorer.gen6.app')) {
+    return '#/accounts';
   }
   if (explorerLink.includes('astral.autonomys')) {
     return 'accounts';
@@ -40,7 +40,7 @@ function getBlockExplorerAccountRoute(explorerLink) {
   return 'address';
 }
 function getBlockExplorerTxRoute(chainInfo) {
-  if (_isPureEvmChain(chainInfo)) {
+  if (_isPureEvmChain(chainInfo) || _isPureBitcoinChain(chainInfo)) {
     return 'tx';
   }
   if (_isPureCardanoChain(chainInfo)) {
@@ -49,6 +49,9 @@ function getBlockExplorerTxRoute(chainInfo) {
   if (['aventus', 'deeper_network'].includes(chainInfo.slug)) {
     return 'transaction';
   }
+  if (['gen6_public'].includes(chainInfo.slug)) {
+    return '#/extrinsics';
+  }
   const explorerLink = _getBlockExplorerFromChain(chainInfo);
   if (explorerLink && explorerLink.includes('statescan.io')) {
     return '#/extrinsics';

package/strategy/api-request-strategy/context/base.d.ts

@@ -0,0 +1,15 @@
+import { ApiRequestContext } from '@subwallet/extension-base/strategy/api-request-strategy/types';
+export declare class BaseApiRequestContext implements ApiRequestContext {
+    callRate: number;
+    limitRate: number;
+    intervalCheck: number;
+    maxRetry: number;
+    private rollbackRateTime;
+    private timeoutRollbackRate;
+    constructor(options?: {
+        limitRate?: number;
+        intervalCheck?: number;
+        maxRetry?: number;
+    });
+    reduceLimitRate(): void;
+}

package/strategy/api-request-strategy/context/base.js

@@ -0,0 +1,24 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export class BaseApiRequestContext {
+  callRate = 2; // limit per interval check
+  limitRate = 2; // max rate per interval check
+  intervalCheck = 1000; // interval check in ms
+  maxRetry = 9; // interval check in ms
+  rollbackRateTime = 30 * 1000; // rollback rate time in ms
+  timeoutRollbackRate = undefined;
+  constructor(options) {
+    this.callRate = (options === null || options === void 0 ? void 0 : options.limitRate) || this.callRate;
+    this.limitRate = (options === null || options === void 0 ? void 0 : options.limitRate) || this.limitRate;
+    this.intervalCheck = (options === null || options === void 0 ? void 0 : options.intervalCheck) || this.intervalCheck;
+    this.maxRetry = (options === null || options === void 0 ? void 0 : options.maxRetry) || this.maxRetry;
+  }
+  reduceLimitRate() {
+    clearTimeout(this.timeoutRollbackRate);
+    this.callRate = Math.ceil(this.limitRate / 2);
+    this.timeoutRollbackRate = setTimeout(() => {
+      this.callRate = this.limitRate;
+    }, this.rollbackRateTime);
+  }
+}

package/strategy/api-request-strategy/index.d.ts

@@ -0,0 +1,15 @@
+import { ApiRequest, ApiRequestContext, ApiRequestStrategy } from './types';
+export declare abstract class BaseApiRequestStrategy implements ApiRequestStrategy {
+    private nextId;
+    private isRunning;
+    private requestMap;
+    private context;
+    private processInterval;
+    private getId;
+    protected constructor(context: ApiRequestContext);
+    addRequest<T>(run: ApiRequest<T>['run'], ordinal: number): Promise<T>;
+    abstract isRateLimited(error: Error): boolean;
+    private process;
+    stop(): void;
+    setContext(context: ApiRequestContext): void;
+}

package/strategy/api-request-strategy/index.js

@@ -0,0 +1,83 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { SWError } from '@subwallet/extension-base/background/errors/SWError';
+export class BaseApiRequestStrategy {
+  nextId = 0;
+  isRunning = false;
+  requestMap = {};
+  processInterval = undefined;
+  getId() {
+    return this.nextId++;
+  }
+  constructor(context) {
+    this.context = context;
+  }
+  addRequest(run, ordinal) {
+    const newId = this.getId();
+    return new Promise((resolve, reject) => {
+      this.requestMap[newId] = {
+        id: newId,
+        status: 'pending',
+        retry: -1,
+        ordinal,
+        run,
+        resolve,
+        reject
+      };
+      if (!this.isRunning) {
+        this.process();
+      }
+    });
+  }
+  process() {
+    this.stop();
+    this.isRunning = true;
+    const maxRetry = this.context.maxRetry;
+    const interval = setInterval(() => {
+      const remainingRequests = Object.values(this.requestMap);
+      if (remainingRequests.length === 0) {
+        this.isRunning = false;
+        clearInterval(interval);
+        return;
+      }
+
+      // Get first this.limit requests base on id
+      const requests = remainingRequests.filter(request => request.status !== 'running').sort((a, b) => a.id - b.id).sort((a, b) => a.ordinal - b.ordinal).slice(0, this.context.callRate);
+
+      // Start requests
+      requests.forEach(request => {
+        request.status = 'running';
+        request.run().then(rs => {
+          request.resolve(rs);
+        }).catch(e => {
+          const isRateLimited = this.isRateLimited(e);
+
+          // Limit rate
+          if (isRateLimited) {
+            if (request.retry < maxRetry) {
+              request.status = 'pending';
+              request.retry++;
+              this.context.reduceLimitRate();
+            } else {
+              // Reject request
+              request.reject(new SWError('MAX_RETRY', String(e)));
+            }
+          } else {
+            request.reject(new SWError('UNKNOWN', String(e)));
+          }
+        });
+      });
+    }, this.context.intervalCheck);
+    this.processInterval = interval;
+  }
+  stop() {
+    clearInterval(this.processInterval);
+    this.processInterval = undefined;
+  }
+  setContext(context) {
+    this.stop();
+    this.context = context;
+    this.process();
+  }
+}

package/strategy/api-request-strategy/types.d.ts

@@ -0,0 +1,22 @@
+export interface ApiRequestContext {
+    callRate: number;
+    limitRate: number;
+    intervalCheck: number;
+    maxRetry: number;
+    reduceLimitRate: () => void;
+}
+export interface ApiRequestStrategy {
+    addRequest: <T>(run: ApiRequest<T>['run'], ordinal: number) => Promise<T>;
+    setContext: (context: ApiRequestContext) => void;
+    stop: () => void;
+}
+export interface ApiRequest<T> {
+    id: number;
+    retry: number;
+    /** Serve smaller first  */
+    ordinal: number;
+    status: 'pending' | 'running';
+    run: () => Promise<any>;
+    resolve: (value: any) => T;
+    reject: (error?: any) => void;
+}

package/strategy/api-request-strategy/types.js

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

package/strategy/api-request-strategy/utils/index.d.ts

@@ -0,0 +1,2 @@
+export declare const postRequest: (url: string, body: any, headers?: Record<string, string>, jsonBody?: boolean) => Promise<Response>;
+export declare const getRequest: (url: string, params?: Record<string, string>, headers?: Record<string, string>) => Promise<Response>;

package/strategy/api-request-strategy/utils/index.js

@@ -0,0 +1,23 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import fetch from 'cross-fetch';
+export const postRequest = (url, body, headers, jsonBody = true) => {
+  return fetch(url, {
+    method: 'POST',
+    headers: headers || {
+      'Content-Type': 'application/json'
+    },
+    body: jsonBody ? JSON.stringify(body) : body
+  });
+};
+export const getRequest = (url, params, headers) => {
+  const queryString = params ? Object.keys(params).map(key => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`).join('&') : '';
+  const _url = `${url}?${queryString}`;
+  return fetch(_url, {
+    method: 'GET',
+    headers: headers || {
+      'Content-Type': 'application/json'
+    }
+  });
+};

package/types/account/info/keyring.d.ts

@@ -116,7 +116,7 @@ export declare enum AccountChainType {
     CARDANO = "cardano"
 }
 export declare const ACCOUNT_CHAIN_TYPE_ORDINAL_MAP: Record<string, number>;
-export declare const SUPPORTED_ACCOUNT_CHAIN_TYPES: string[];
+export declare const SUPPORTED_ACCOUNT_CHAIN_TYPES: AccountChainType[];
 export declare enum AccountActions {
     DERIVE = "DERIVE",
     EXPORT_MNEMONIC = "EXPORT_MNEMONIC",

package/types/account/info/keyring.js

@@ -74,7 +74,7 @@ export const ACCOUNT_CHAIN_TYPE_ORDINAL_MAP = {
   [AccountChainType.CARDANO]: 4,
   [AccountChainType.BITCOIN]: 5
 };
-export const SUPPORTED_ACCOUNT_CHAIN_TYPES = ['substrate', 'ethereum', 'ton', 'cardano'];
+export const SUPPORTED_ACCOUNT_CHAIN_TYPES = [AccountChainType.SUBSTRATE, AccountChainType.ETHEREUM, AccountChainType.TON, AccountChainType.CARDANO, AccountChainType.BITCOIN];
 export let AccountActions;
 
 /**

package/types/balance/index.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="bn.js" />
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { _BalanceMetadata, APIItemState, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
-import { _CardanoApi, _EvmApi, _SubstrateApi, _TonApi } from '@subwallet/extension-base/services/chain-service/types';
+import { _BitcoinApi, _CardanoApi, _EvmApi, _SubstrateApi, _TonApi } from '@subwallet/extension-base/services/chain-service/types';
 import { BN } from '@polkadot/util';
 export interface TokenBalanceRaw {
     reserved: BN;
@@ -55,3 +55,6 @@ export interface SubscribeTonPalletBalance extends SubscribeBasePalletBalance {
 export interface SusbcribeCardanoPalletBalance extends SubscribeBasePalletBalance {
     cardanoApi: _CardanoApi;
 }
+export interface SusbcribeBitcoinPalletBalance extends SubscribeBasePalletBalance {
+    bitcoinApi: _BitcoinApi;
+}

package/types/balance/transfer.d.ts

@@ -1,7 +1,10 @@
+import { PsbtTransactionArg } from '@subwallet/extension-base/background/KoniTypes';
 import { BaseRequestSign } from '@subwallet/extension-base/types';
+import { Psbt } from 'bitcoinjs-lib';
 import { FeeChainType, FeeDetail, TransactionFee } from '../fee';
 export interface RequestSubscribeTransfer extends TransactionFee {
     address: string;
+    to?: string;
     chain: string;
     value: string;
     token: string;
@@ -15,6 +18,9 @@ export interface ResponseSubscribeTransfer {
     feePercentageSpecialCase?: number;
     error?: string;
 }
+export interface RequestSubmitTransferWithId extends RequestSubmitTransfer {
+    id?: string;
+}
 export interface RequestSubmitTransfer extends BaseRequestSign, TransactionFee {
     chain: string;
     from: string;
@@ -24,3 +30,14 @@ export interface RequestSubmitTransfer extends BaseRequestSign, TransactionFee {
     value: string;
     transferBounceable?: boolean;
 }
+export interface RequestSubmitSignPsbtTransfer extends BaseRequestSign {
+    id: string;
+    chain: string;
+    from: string;
+    to: string;
+    value: string;
+    txInput: PsbtTransactionArg[];
+    txOutput: PsbtTransactionArg[];
+    tokenSlug: string;
+    psbt: Psbt;
+}