@subwallet/extension-base 1.3.41-0 → 1.3.43-0

package/services/rune-service/index.js

@@ -0,0 +1,97 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { SWError } from '@subwallet/extension-base/background/errors/SWError';
+import { _BTC_SERVICE_TOKEN } from '@subwallet/extension-base/services/chain-service/constants';
+import { BaseApiRequestStrategy } from '@subwallet/extension-base/strategy/api-request-strategy';
+import { BaseApiRequestContext } from '@subwallet/extension-base/strategy/api-request-strategy/context/base';
+import { getRequest } from '@subwallet/extension-base/strategy/api-request-strategy/utils';
+const BITCOIN_API_URL = 'https://btc-api.koni.studio';
+const BITCOIN_API_URL_TEST = 'https://api-testnet.openbit.app';
+export class RunesService extends BaseApiRequestStrategy {
+  constructor(url) {
+    const context = new BaseApiRequestContext();
+    super(context);
+    this.baseUrl = url;
+  }
+  headers = {
+    'Content-Type': 'application/json',
+    Authorization: `Bearer ${_BTC_SERVICE_TOKEN}`
+  };
+  isRateLimited() {
+    return false;
+  }
+  getUrl(path) {
+    return `${this.baseUrl}/${path}`;
+  }
+  getAddressRunesInfo(address, params) {
+    return this.addRequest(async () => {
+      const _rs = await getRequest(this.getUrl(`rune/address/${address}`), params, this.headers);
+      const rs = await _rs.json();
+      if (rs.status_code !== 200) {
+        throw new SWError('RuneScanService.getAddressRunesInfo', rs.message);
+      }
+      return rs.result;
+    }, 1);
+  }
+
+  // * Deprecated
+  getRuneCollectionsByBatch(params) {
+    return this.addRequest(async () => {
+      const url = this.getUrl('rune');
+      const rs = await getRequest(url, params);
+      if (rs.status !== 200) {
+        throw new SWError('RuneScanService.getRuneCollectionsByBatch', await rs.text());
+      }
+      return await rs.json();
+    }, 1);
+  }
+
+  // * Deprecated
+  getAddressRuneTxs(address, params) {
+    return this.addRequest(async () => {
+      const url = this.getUrl(`address/${address}/txs`);
+      const rs = await getRequest(url, params);
+      if (rs.status !== 200) {
+        throw new SWError('RuneScanService.getAddressRuneTxs', await rs.text());
+      }
+      return await rs.json();
+    }, 0);
+  }
+  getRuneMetadata(runeid) {
+    return this.addRequest(async () => {
+      const _rs = await getRequest(this.getUrl(`rune/metadata/${runeid}`), undefined, this.headers);
+      const rs = await _rs.json();
+      if (rs.status_code !== 200) {
+        throw new SWError('RuneScanService.getRuneMetadata', rs.message);
+      }
+      return rs.result;
+    }, 0);
+  }
+  getAddressRuneUtxos(address) {
+    return this.addRequest(async () => {
+      const _rs = await getRequest(this.getUrl(`rune/address/${address}/rune/utxo`), undefined, this.headers);
+      const rs = await _rs.json();
+      if (rs.status_code !== 200) {
+        throw new SWError('RuneScanService.getAddressRuneUtxos', rs.message);
+      }
+      return rs.result;
+    }, 0);
+  }
+
+  // Singleton
+
+  static getInstance(isTestnet = false) {
+    if (isTestnet) {
+      if (!RunesService.testnet) {
+        RunesService.testnet = new RunesService(BITCOIN_API_URL_TEST);
+      }
+      return RunesService.testnet;
+    } else {
+      if (!RunesService.mainnet) {
+        RunesService.mainnet = new RunesService(BITCOIN_API_URL);
+      }
+      return RunesService.mainnet;
+    }
+  }
+}

package/services/transaction-service/helpers/index.d.ts

@@ -1,11 +1,13 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
 import { CardanoTransactionConfig } from '@subwallet/extension-base/services/balance-service/transfer/cardano-transfer';
 import { TonTransactionConfig } from '@subwallet/extension-base/services/balance-service/transfer/ton-transfer';
-import { SWTransactionBase } from '@subwallet/extension-base/services/transaction-service/types';
+import { SWTransaction, SWTransactionBase } from '@subwallet/extension-base/services/transaction-service/types';
+import { Psbt } from 'bitcoinjs-lib';
 import { SubmittableExtrinsic } from '@polkadot/api/promise/types';
 export declare const getTransactionId: (chainType: string, chain: string, isInternal: boolean, isWalletConnect?: boolean) => string;
 export declare const getValidationId: (chainType: string, chain: string) => string;
 export declare const isSubstrateTransaction: (tx: SWTransactionBase['transaction']) => tx is SubmittableExtrinsic;
 export declare const isTonTransaction: (tx: SWTransactionBase['transaction']) => tx is TonTransactionConfig;
 export declare const isCardanoTransaction: (tx: SWTransactionBase['transaction']) => tx is CardanoTransactionConfig;
+export declare const isBitcoinTransaction: (tx: SWTransaction['transaction']) => tx is Psbt;
 export declare const getBaseTransactionInfo: (transaction: SWTransactionBase, chainInfoMap: Record<string, _ChainInfo>) => string;

package/services/transaction-service/helpers/index.js

@@ -21,6 +21,11 @@ export const isCardanoTransaction = tx => {
   const cardanoTransactionConfig = tx;
   return cardanoTransactionConfig.cardanoPayload !== null && cardanoTransactionConfig.cardanoPayload !== undefined;
 };
+
+// TODO: [Review] this function
+export const isBitcoinTransaction = tx => {
+  return 'data' in tx && Array.isArray(tx.data.inputs);
+};
 const typeName = type => {
   switch (type) {
     case ExtrinsicType.TRANSFER_BALANCE:

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

@@ -1,16 +1,12 @@
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
-import { SWDutchTransactionInput, SWPermitTransactionInput, SWTransactionBase, SWTransactionInput, SWTransactionResponse, TransactionEmitter } from '@subwallet/extension-base/services/transaction-service/types';
+import { SWDutchTransactionInput, SWPermitTransactionInput, SWTransactionBase, SWTransactionInput, SWTransactionResponse, TransactionEmitter, TransactionEventResponse } from '@subwallet/extension-base/services/transaction-service/types';
 import { BaseStepType, BriefProcessStep, ProcessStep, ProcessTransactionData } from '@subwallet/extension-base/types';
 import { BehaviorSubject } from 'rxjs';
 import { TransactionConfig } from 'web3-core';
 import { HexString } from '@polkadot/util/types';
 export default class TransactionService {
     private readonly state;
-    private readonly eventService;
-    private readonly historyService;
-    private readonly notificationService;
-    private readonly chainService;
     private readonly watchTransactionSubscribes;
     private aliveProcessMap;
     private readonly transactionSubject;
@@ -40,6 +36,7 @@ export default class TransactionService {
     addDutchTransaction(inputTransaction: SWDutchTransactionInput): TransactionEmitter;
     generateBeforeHandleResponseErrors(errors: TransactionError[]): SWTransactionResponse;
     handleTransaction(transaction: SWTransactionInput): Promise<SWTransactionResponse>;
+    handleTransactionAfterConfirmation(transaction: SWTransactionInput): Promise<SWTransactionResponse>;
     handlePermitTransaction(transaction: SWPermitTransactionInput): Promise<SWTransactionResponse>;
     handleDutchTransaction(transaction: SWDutchTransactionInput): Promise<SWTransactionResponse>;
     private sendTransaction;
@@ -63,6 +60,8 @@ export default class TransactionService {
     private signAndSendSubstrateTransaction;
     private signAndSendTonTransaction;
     private signAndSendCardanoTransaction;
+    emitterEventTransaction: (emitter: TransactionEmitter, eventData: TransactionEventResponse, chain: string, payload: string) => void;
+    private signAndSendBitcoinTransaction;
     private handleTransactionTimeout;
     private handlePostEarningTransaction;
     createProcessIfNeed(process: ProcessTransactionData): Promise<void>;

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,32 @@ 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);
+    if (!transactionInput.skipFeeRecalculation) {
+      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 +188,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(),
@@ -300,6 +302,73 @@ export default class TransactionService {
     'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
     return validatedTransaction;
   }
+  async handleTransactionAfterConfirmation(transaction) {
+    const validatedTransaction = await this.validateTransaction(transaction);
+    const stopByErrors = validatedTransaction.errors.length > 0;
+    const stopByWarnings = validatedTransaction.warnings.length > 0 && !validatedTransaction.ignoreWarnings;
+    if (stopByErrors || stopByWarnings) {
+      // @ts-ignore
+      'transaction' in validatedTransaction && delete validatedTransaction.transaction;
+      'additionalValidator' in validatedTransaction && delete validatedTransaction.additionalValidator;
+      'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
+      return validatedTransaction;
+    }
+    validatedTransaction.warnings = [];
+    const transactionsSubject = this.transactions;
+    const emitter = new EventEmitter();
+
+    // Fill transaction default info
+    const transactionUpdated = this.fillTransactionDefaultInfo(validatedTransaction);
+
+    // Add Transaction
+    transactionsSubject[transactionUpdated.id] = {
+      ...transactionUpdated,
+      emitterTransaction: emitter
+    };
+    this.transactionSubject.next({
+      ...transactionsSubject
+    });
+    emitter.on('success', data => {
+      validatedTransaction.id = data.id;
+      validatedTransaction.extrinsicHash = data.extrinsicHash;
+      this.handlePostProcessing(data.id);
+      this.onSuccess(data);
+    });
+    emitter.on('signed', data => {
+      validatedTransaction.id = data.id;
+      validatedTransaction.extrinsicHash = data.extrinsicHash;
+      this.onSigned(data);
+    });
+    emitter.on('error', data => {
+      if (data.errors.length > 0) {
+        validatedTransaction.errors.push(...data.errors);
+      }
+      this.onFailed({
+        ...data,
+        errors: [...data.errors, new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]
+      });
+    });
+    emitter.on('send', data => {
+      this.onSend(data);
+    });
+    emitter.on('extrinsicHash', data => {
+      this.onHasTransactionHash(data);
+    });
+    emitter.on('timeout', data => {
+      this.onTimeOut({
+        ...data,
+        errors: [...data.errors, new TransactionError(BasicTxErrorType.TIMEOUT)]
+      });
+    });
+
+    // @ts-ignore
+    'transaction' in validatedTransaction && delete validatedTransaction.transaction;
+    'additionalValidator' in validatedTransaction && delete validatedTransaction.additionalValidator;
+    'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
+    return {
+      ...validatedTransaction
+    };
+  }
   async handlePermitTransaction(transaction) {
     var _transaction$step;
     const transactionId = getTransactionId(transaction.chainType, transaction.chain, true);
@@ -410,7 +479,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 +738,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 +1125,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 +1181,7 @@ export default class TransactionService {
   onSuccess({
     blockHash,
     blockNumber,
+    blockTime,
     extrinsicHash,
     id
   }) {
@@ -1107,7 +1196,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 +1270,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 +1291,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 +1954,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,
+      address,
+      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;
@@ -56,6 +60,7 @@ export interface SWTransactionInput extends SwInputBase, Partial<Pick<SWTransact
     isTransferLocalTokenAndPayThatTokenAsFee?: boolean;
     resolveOnDone?: boolean;
     skipFeeValidation?: boolean;
+    skipFeeRecalculation?: boolean;
 }
 export interface SWPermitTransactionInput extends Omit<SWTransactionInput, 'transaction'> {
     transaction?: SWPermitTransaction['transaction'] | null;
@@ -66,6 +71,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 +87,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;
+}