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

package/services/request-service/handler/BitcoinRequestHandler.js

@@ -4,10 +4,8 @@
 import { BitcoinProviderError } from '@subwallet/extension-base/background/errors/BitcoinProviderError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { BitcoinProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
-import { createBitcoinTransaction } from '@subwallet/extension-base/services/balance-service/transfer/bitcoin-transfer';
 import { BasicTxErrorType } from '@subwallet/extension-base/types';
 import { createPromiseHandler } from '@subwallet/extension-base/utils';
-import { getId } from '@subwallet/extension-base/utils/getId';
 import { isInternalRequest } from '@subwallet/extension-base/utils/request';
 import keyring from '@subwallet/ui-keyring';
 import { Psbt } from 'bitcoinjs-lib';
@@ -19,7 +17,6 @@ export default class BitcoinRequestHandler {
   #requestService;
   #chainService;
   #transactionService;
-  #feeService;
   #logger;
   confirmationsQueueSubjectBitcoin = new BehaviorSubject({
     bitcoinSignatureRequest: {},
@@ -29,10 +26,9 @@ export default class BitcoinRequestHandler {
     bitcoinSignPsbtRequest: {}
   });
   confirmationsPromiseMap = {};
-  constructor(requestService, chainService, feeService, transactionService) {
+  constructor(requestService, chainService, transactionService) {
     this.#requestService = requestService;
     this.#chainService = chainService;
-    this.#feeService = feeService;
     this.#transactionService = transactionService;
     this.#logger = createLogger('BitcoinRequestHandler');
   }
@@ -51,7 +47,7 @@ export default class BitcoinRequestHandler {
     const confirmationType = confirmations[type];
     const payloadJson = JSON.stringify(payload);
     const isInternal = isInternalRequest(url);
-    if (['bitcoinSignatureRequest', 'bitcoinSendTransactionRequest', 'bitcoinSendTransactionRequestAfterConfirmation'].includes(type)) {
+    if (['bitcoinSignatureRequest', 'bitcoinSendTransactionRequest', 'bitcoinSendTransactionRequestAfterConfirmation', 'bitcoinSignPsbtRequest'].includes(type)) {
       const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
       if (isAlwaysRequired) {
         this.#requestService.keyringService.lock();
@@ -110,10 +106,9 @@ export default class BitcoinRequestHandler {
   }
   signMessageBitcoin(confirmation) {
     const {
-      account,
+      address,
       payload
     } = confirmation.payload;
-    const address = account.address;
     const pair = keyring.getPair(address);
     if (pair.isLocked) {
       keyring.unlockPair(pair.address);
@@ -146,10 +141,9 @@ export default class BitcoinRequestHandler {
   signTransactionBitcoin(request) {
     // Extract necessary information from the BitcoinSendTransactionRequest
     const {
-      account,
+      address,
       hashPayload
     } = request.payload;
-    const address = account.address;
     const pair = keyring.getPair(address);
 
     // Unlock the pair if it is locked
@@ -169,59 +163,25 @@ export default class BitcoinRequestHandler {
     const {
       chain,
       emitterTransaction,
-      feeCustom,
-      feeOption,
       id
     } = transaction;
     const {
-      from,
-      to,
-      value
+      from
     } = transaction.data;
+    const {
+      promise,
+      reject,
+      resolve
+    } = createPromiseHandler();
     if (!emitterTransaction) {
       throw new BitcoinProviderError(BitcoinProviderErrorType.INTERNAL_ERROR);
     }
-    const chainInfo = this.#chainService.getChainInfoByKey(chain);
-    const bitcoinApi = this.#chainService.getBitcoinApi(chain);
     const eventData = {
       id,
       errors: [],
       warnings: [],
       extrinsicHash: id
     };
-    const network = chainInfo.isTestnet ? bitcoin.networks.testnet : bitcoin.networks.bitcoin;
-    const feeInfo = await this.#feeService.subscribeChainFee(getId(), chain, 'bitcoin');
-    const [psbt] = await createBitcoinTransaction({
-      bitcoinApi,
-      chain,
-      from,
-      feeCustom,
-      feeOption,
-      feeInfo,
-      to,
-      transferAll: false,
-      value: value || '0',
-      network
-    });
-    const pair = keyring.getPair(from);
-
-    // Unlock the pair if it is locked
-    if (pair.isLocked) {
-      keyring.unlockPair(pair.address);
-    }
-
-    // Finalize all inputs in the Psbt
-
-    // Sign the Psbt using the pair's bitcoin object
-    const signedTransaction = pair.bitcoin.signTransaction(psbt, psbt.txInputs.map((v, i) => i));
-    signedTransaction.finalizeAllInputs();
-    const signature = signedTransaction.extractTransaction().toHex();
-    this.#transactionService.emitterEventTransaction(emitterTransaction, eventData, chainInfo.slug, signature);
-    const {
-      promise,
-      reject,
-      resolve
-    } = createPromiseHandler();
     emitterTransaction.on('extrinsicHash', data => {
       if (!data.extrinsicHash) {
         reject(BitcoinProviderErrorType.INTERNAL_ERROR);
@@ -232,34 +192,56 @@ export default class BitcoinRequestHandler {
     emitterTransaction.on('error', error => {
       reject(error);
     });
+    try {
+      const chainInfo = this.#chainService.getChainInfoByKey(chain);
+      const psbt = transaction.transaction;
+      const pair = keyring.getPair(from);
+
+      // Unlock the pair if it is locked
+      if (pair.isLocked) {
+        keyring.unlockPair(pair.address);
+      }
+
+      // Finalize all inputs in the Psbt
+      // Sign the Psbt using the pair's bitcoin object
+      const signedTransaction = pair.bitcoin.signTransaction(psbt, psbt.txInputs.map((v, i) => i));
+      signedTransaction.finalizeAllInputs();
+      const signature = signedTransaction.extractTransaction().toHex();
+      this.#transactionService.emitterEventTransaction(emitterTransaction, eventData, chainInfo.slug, signature);
+    } catch (e) {
+      emitterTransaction.emit('error', {
+        ...eventData,
+        errors: [new TransactionError(BasicTxErrorType.INTERNAL_ERROR, e.message)]
+      });
+    }
     return promise;
   }
   async signPsbt(request) {
     // Extract necessary information from the BitcoinSendTransactionRequest
     const {
-      account,
+      address,
       payload
     } = request.payload;
     const {
       allowedSighash,
+      autoFinalized = true,
       broadcast,
-      psbt,
+      network,
+      psbt: psbtHex,
       signAtIndex
     } = payload;
     const transaction = this.#transactionService.getTransaction(request.id);
+    const bitcoinNetwork = network === 'bitcoinTestnet' ? bitcoin.networks.testnet : bitcoin.networks.bitcoin;
+    const psbt = bitcoin.Psbt.fromHex(psbtHex, {
+      network: bitcoinNetwork
+    });
     let eventData = {
       id: request.id,
       errors: [],
       warnings: [],
       extrinsicHash: request.id
     };
-
-    // todo: validate type of the account
-
-    if (Object.keys(account).length === 0) {
-      throw new BitcoinProviderError(BitcoinProviderErrorType.INVALID_PARAMS, 'Please connect to Wallet to try this request');
-    }
-    const pair = keyring.getPair(account.address);
+    const pair = keyring.getPair(address);
 
     // Unlock the pair if it is locked
     if (pair.isLocked) {
@@ -287,8 +269,10 @@ export default class BitcoinRequestHandler {
       throw new Error('Unable to sign');
     }
     if (!broadcast) {
-      for (const index of signAtIndexGenerate) {
-        psptSignedTransaction.finalizeInput(index);
+      if (autoFinalized) {
+        for (const index of signAtIndexGenerate) {
+          psptSignedTransaction.finalizeInput(index);
+        }
       }
       return {
         psbt: psptSignedTransaction.toHex()
@@ -313,6 +297,9 @@ export default class BitcoinRequestHandler {
     }
     const chainInfo = this.#chainService.getChainInfoByKey(chain);
     try {
+      if (!autoFinalized) {
+        throw new Error('Unable to send transaction without autoFinalized');
+      }
       psptSignedTransaction.finalizeAllInputs();
     } catch (e) {
       emitterTransaction.emit('error', {

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

@@ -1,7 +1,6 @@
 import { AuthRequestV2, ConfirmationDefinitions, ConfirmationDefinitionsBitcoin, ConfirmationDefinitionsCardano, ConfirmationDefinitionsTon, ConfirmationsQueue, ConfirmationsQueueBitcoin, ConfirmationsQueueCardano, ConfirmationsQueueItemOptions, ConfirmationsQueueTon, ConfirmationType, ConfirmationTypeBitcoin, ConfirmationTypeCardano, ConfirmationTypeTon, RequestConfirmationComplete, RequestConfirmationCompleteBitcoin, RequestConfirmationCompleteCardano, RequestConfirmationCompleteTon } from '@subwallet/extension-base/background/KoniTypes';
 import { AccountAuthType, AuthorizeRequest, MetadataRequest, RequestAuthorizeTab, RequestSign, ResponseSigning, SigningRequest } from '@subwallet/extension-base/background/types';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
-import FeeService from '@subwallet/extension-base/services/fee-service/service';
 import { KeyringService } from '@subwallet/extension-base/services/keyring-service';
 import SettingService from '@subwallet/extension-base/services/setting-service/SettingService';
 import TransactionService from '@subwallet/extension-base/services/transaction-service';
@@ -14,7 +13,7 @@ export default class RequestService {
     #private;
     readonly settingService: SettingService;
     readonly keyringService: KeyringService;
-    constructor(chainService: ChainService, settingService: SettingService, keyringService: KeyringService, feeService: FeeService, transactionService: TransactionService);
+    constructor(chainService: ChainService, settingService: SettingService, keyringService: KeyringService, transactionService: TransactionService);
     get numAllRequests(): number;
     updateIconV2(shouldClose?: boolean): void;
     getAddressList(value?: boolean): Record<string, boolean>;

package/services/request-service/index.js

@@ -20,7 +20,7 @@ export default class RequestService {
   #notSupportWCRequestHandler;
 
   // Common
-  constructor(chainService, settingService, keyringService, feeService, transactionService) {
+  constructor(chainService, settingService, keyringService, transactionService) {
     this.#chainService = chainService;
     this.settingService = settingService;
     this.keyringService = keyringService;
@@ -31,7 +31,7 @@ export default class RequestService {
     this.#evmRequestHandler = new EvmRequestHandler(this);
     this.#tonRequestHandler = new TonRequestHandler(this);
     this.#cardanoRequestHandler = new CardanoRequestHandler(this);
-    this.#bitcoinRequestHandler = new BitcoinRequestHandler(this, this.#chainService, feeService, transactionService);
+    this.#bitcoinRequestHandler = new BitcoinRequestHandler(this, this.#chainService, transactionService);
     this.#connectWCRequestHandler = new ConnectWCRequestHandler(this);
     this.#notSupportWCRequestHandler = new NotSupportWCRequestHandler(this);
 

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

@@ -36,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;

package/services/transaction-service/index.js

@@ -119,7 +119,9 @@ export default class TransactionService {
     const isNonNativeTokenPayFee = tokenPayFeeSlug && !_isNativeTokenBySlug(tokenPayFeeSlug);
     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
@@ -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);
@@ -1923,7 +1992,7 @@ export default class TransactionService {
     const payload = {
       payload: undefined,
       payloadJson: undefined,
-      account,
+      address,
       canSign: true,
       hashPayload: tx.toHex(),
       id

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

@@ -60,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;

package/types/balance/transfer.d.ts

@@ -1,6 +1,5 @@
 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;
@@ -21,6 +20,9 @@ export interface ResponseSubscribeTransfer {
 export interface RequestSubmitTransferWithId extends RequestSubmitTransfer {
     id?: string;
 }
+export interface ResponseSubscribeTransferConfirmation extends Omit<ResponseSubscribeTransfer, 'maxTransferable'> {
+    error?: string;
+}
 export interface RequestSubmitTransfer extends BaseRequestSign, TransactionFee {
     chain: string;
     from: string;
@@ -39,5 +41,5 @@ export interface RequestSubmitSignPsbtTransfer extends BaseRequestSign {
     txInput: PsbtTransactionArg[];
     txOutput: PsbtTransactionArg[];
     tokenSlug: string;
-    psbt: Psbt;
+    psbt: string;
 }

package/types/buy.d.ts

@@ -4,7 +4,7 @@ export interface BuyService {
     symbol: string;
 }
 export declare type SupportService = 'transak' | 'banxa' | 'coinbase' | 'moonpay' | 'onramper' | 'meld';
-export declare type OnrampAccountSupportType = 'ETHEREUM' | 'SUBSTRATE';
+export declare type OnrampAccountSupportType = 'ETHEREUM' | 'SUBSTRATE' | 'TON' | 'CARDANO';
 export interface BuyTokenInfo {
     network: string;
     symbol: string;

package/utils/auth.js

@@ -2,14 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { getKeypairTypeByAddress } from '@subwallet/keyring';
-import { CardanoKeypairTypes, EthereumKeypairTypes, SubstrateKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
+import { BitcoinKeypairTypes, CardanoKeypairTypes, EthereumKeypairTypes, SubstrateKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
 export const isAddressValidWithAuthType = (address, accountAuthTypes) => {
   const keypairType = getKeypairTypeByAddress(address);
   const validTypes = {
     evm: EthereumKeypairTypes,
     substrate: SubstrateKeypairTypes,
     ton: TonKeypairTypes,
-    cardano: CardanoKeypairTypes
+    cardano: CardanoKeypairTypes,
+    bitcoin: BitcoinKeypairTypes
   };
   return !!(accountAuthTypes !== null && accountAuthTypes !== void 0 && accountAuthTypes.some(authType => {
     var _validTypes$authType;