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

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

@@ -8,10 +8,8 @@ exports.default = void 0;
 var _BitcoinProviderError = require("@subwallet/extension-base/background/errors/BitcoinProviderError");
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
-var _bitcoinTransfer = require("@subwallet/extension-base/services/balance-service/transfer/bitcoin-transfer");
 var _types = require("@subwallet/extension-base/types");
 var _utils = require("@subwallet/extension-base/utils");
-var _getId = require("@subwallet/extension-base/utils/getId");
 var _request = require("@subwallet/extension-base/utils/request");
 var _uiKeyring = _interopRequireDefault(require("@subwallet/ui-keyring"));
 var bitcoin = _interopRequireWildcard(require("bitcoinjs-lib"));
@@ -27,7 +25,6 @@ class BitcoinRequestHandler {
   #requestService;
   #chainService;
   #transactionService;
-  #feeService;
   #logger;
   confirmationsQueueSubjectBitcoin = new _rxjs.BehaviorSubject({
     bitcoinSignatureRequest: {},
@@ -37,10 +34,9 @@ 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 = (0, _util.logger)('BitcoinRequestHandler');
   }
@@ -61,7 +57,7 @@ class BitcoinRequestHandler {
     const confirmationType = confirmations[type];
     const payloadJson = JSON.stringify(payload);
     const isInternal = (0, _request.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();
@@ -122,10 +118,9 @@ class BitcoinRequestHandler {
   }
   signMessageBitcoin(confirmation) {
     const {
-      account,
+      address,
       payload
     } = confirmation.payload;
-    const address = account.address;
     const pair = _uiKeyring.default.getPair(address);
     if (pair.isLocked) {
       _uiKeyring.default.unlockPair(pair.address);
@@ -158,10 +153,9 @@ class BitcoinRequestHandler {
   signTransactionBitcoin(request) {
     // Extract necessary information from the BitcoinSendTransactionRequest
     const {
-      account,
+      address,
       hashPayload
     } = request.payload;
-    const address = account.address;
     const pair = _uiKeyring.default.getPair(address);
 
     // Unlock the pair if it is locked
@@ -181,59 +175,25 @@ class BitcoinRequestHandler {
     const {
       chain,
       emitterTransaction,
-      feeCustom,
-      feeOption,
       id
     } = transaction;
     const {
-      from,
-      to,
-      value
+      from
     } = transaction.data;
+    const {
+      promise,
+      reject,
+      resolve
+    } = (0, _utils.createPromiseHandler)();
     if (!emitterTransaction) {
       throw new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.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((0, _getId.getId)(), chain, 'bitcoin');
-    const [psbt] = await (0, _bitcoinTransfer.createBitcoinTransaction)({
-      bitcoinApi,
-      chain,
-      from,
-      feeCustom,
-      feeOption,
-      feeInfo,
-      to,
-      transferAll: false,
-      value: value || '0',
-      network
-    });
-    const pair = _uiKeyring.default.getPair(from);
-
-    // Unlock the pair if it is locked
-    if (pair.isLocked) {
-      _uiKeyring.default.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
-    } = (0, _utils.createPromiseHandler)();
     emitterTransaction.on('extrinsicHash', data => {
       if (!data.extrinsicHash) {
         reject(_KoniTypes.BitcoinProviderErrorType.INTERNAL_ERROR);
@@ -244,34 +204,56 @@ class BitcoinRequestHandler {
     emitterTransaction.on('error', error => {
       reject(error);
     });
+    try {
+      const chainInfo = this.#chainService.getChainInfoByKey(chain);
+      const psbt = transaction.transaction;
+      const pair = _uiKeyring.default.getPair(from);
+
+      // Unlock the pair if it is locked
+      if (pair.isLocked) {
+        _uiKeyring.default.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.TransactionError(_types.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.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.INVALID_PARAMS, 'Please connect to Wallet to try this request');
-    }
-    const pair = _uiKeyring.default.getPair(account.address);
+    const pair = _uiKeyring.default.getPair(address);
 
     // Unlock the pair if it is locked
     if (pair.isLocked) {
@@ -299,8 +281,10 @@ 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()
@@ -325,6 +309,9 @@ 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/cjs/services/request-service/index.js

@@ -27,7 +27,7 @@ class RequestService {
   #notSupportWCRequestHandler;
 
   // Common
-  constructor(chainService, settingService, keyringService, feeService, transactionService) {
+  constructor(chainService, settingService, keyringService, transactionService) {
     this.#chainService = chainService;
     this.settingService = settingService;
     this.keyringService = keyringService;
@@ -38,7 +38,7 @@ class RequestService {
     this.#evmRequestHandler = new _handler.EvmRequestHandler(this);
     this.#tonRequestHandler = new _TonRequestHandler.default(this);
     this.#cardanoRequestHandler = new _CardanoRequestHandler.default(this);
-    this.#bitcoinRequestHandler = new _BitcoinRequestHandler.default(this, this.#chainService, feeService, transactionService);
+    this.#bitcoinRequestHandler = new _BitcoinRequestHandler.default(this, this.#chainService, transactionService);
     this.#connectWCRequestHandler = new _handler.ConnectWCRequestHandler(this);
     this.#notSupportWCRequestHandler = new _handler.NotSupportWCRequestHandler(this);
 

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

@@ -126,7 +126,9 @@ class TransactionService {
     const isNonNativeTokenPayFee = tokenPayFeeSlug && !(0, _utils2._isNativeTokenBySlug)(tokenPayFeeSlug);
     const nonNativeTokenPayFeeInfo = isNonNativeTokenPayFee ? this.state.chainService.getAssetBySlug(tokenPayFeeSlug) : undefined;
     const priceMap = (await this.state.priceService.getPrice()).priceMap;
-    validationResponse.estimateFee = await (0, _transfer.estimateFeeForTransaction)(validationResponse, transaction, chainInfo, evmApi, substrateApi, priceMap, feeInfo, nativeTokenInfo, nonNativeTokenPayFeeInfo, transactionInput.isTransferLocalTokenAndPayThatTokenAsFee);
+    if (!transactionInput.skipFeeRecalculation) {
+      validationResponse.estimateFee = await (0, _transfer.estimateFeeForTransaction)(validationResponse, transaction, chainInfo, evmApi, substrateApi, priceMap, feeInfo, nativeTokenInfo, nonNativeTokenPayFeeInfo, transactionInput.isTransferLocalTokenAndPayThatTokenAsFee);
+    }
     const chainInfoMap = this.state.chainService.getChainInfoMap();
 
     // Check account signing transaction
@@ -307,6 +309,73 @@ 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.default();
+
+    // 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.TransactionError(_types.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.TransactionError(_types.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 = (0, _helpers.getTransactionId)(transaction.chainType, transaction.chain, true);
@@ -1954,7 +2023,7 @@ class TransactionService {
     const payload = {
       payload: undefined,
       payloadJson: undefined,
-      account,
+      address,
       canSign: true,
       hashPayload: tx.toHex(),
       id

package/cjs/utils/auth.js

@@ -15,7 +15,8 @@ const isAddressValidWithAuthType = (address, accountAuthTypes) => {
     evm: _types.EthereumKeypairTypes,
     substrate: _types.SubstrateKeypairTypes,
     ton: _types.TonKeypairTypes,
-    cardano: _types.CardanoKeypairTypes
+    cardano: _types.CardanoKeypairTypes,
+    bitcoin: _types.BitcoinKeypairTypes
   };
   return !!(accountAuthTypes !== null && accountAuthTypes !== void 0 && accountAuthTypes.some(authType => {
     var _validTypes$authType;

package/core/logic-validation/recipientAddress.js

@@ -111,7 +111,13 @@ function runValidationFunctions(validateRecipientParams, validationFunctions) {
   return Promise.resolve();
 }
 export function validateRecipientAddress(validateRecipientParams) {
-  const conditions = getConditions(validateRecipientParams);
+  // TODO: Temporarily disable "Advanced address conversion" to prevent invalid token transfers.
+  //  Re-enable after related issues are fixed.
+  const prams = {
+    ...validateRecipientParams,
+    autoFormatValue: false
+  };
+  const conditions = getConditions(prams);
   const validationFunctions = getValidationFunctions(conditions);
-  return runValidationFunctions(validateRecipientParams, validationFunctions);
+  return runValidationFunctions(prams, validationFunctions);
 }

package/core/logic-validation/request.d.ts

@@ -1,4 +1,4 @@
-import { ConfirmationType, ConfirmationTypeCardano, ErrorValidation } from '@subwallet/extension-base/background/KoniTypes';
+import { ConfirmationType, ConfirmationTypeBitcoin, ConfirmationTypeCardano, ErrorValidation } from '@subwallet/extension-base/background/KoniTypes';
 import { AccountAuthType } from '@subwallet/extension-base/background/types';
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
 import { AuthUrlInfo } from '@subwallet/extension-base/services/request-service/types';
@@ -15,7 +15,7 @@ export interface PayloadValidated {
     method?: string;
     payloadAfterValidated: any;
     errorPosition?: 'dApp' | 'ui';
-    confirmationType?: ConfirmationType | ConfirmationTypeCardano;
+    confirmationType?: ConfirmationType | ConfirmationTypeCardano | ConfirmationTypeBitcoin;
     errors: Error[];
 }
 export declare type SignTypedDataMessageV3V4 = {
@@ -45,5 +45,9 @@ export declare function validationEvmSignMessageMiddleware(koni: KoniState, url:
 export declare function validationAuthWCMiddleware(koni: KoniState, url: string, payload: PayloadValidated, topic?: string): Promise<PayloadValidated>;
 export declare function validationAuthCardanoMiddleware(koni: KoniState, url: string, payload: PayloadValidated): Promise<PayloadValidated>;
 export declare function validationCardanoSignDataMiddleware(koni: KoniState, url: string, payload_: PayloadValidated): Promise<PayloadValidated>;
+export declare function validationBitcoinConnectMiddleware(koni: KoniState, url: string, payload: PayloadValidated): Promise<PayloadValidated>;
+export declare function validationBitcoinSignMessageMiddleware(koni: KoniState, url: string, payload_: PayloadValidated): Promise<PayloadValidated>;
+export declare function validationBitcoinSignPsbtMiddleware(koni: KoniState, url: string, payload_: PayloadValidated): Promise<PayloadValidated>;
+export declare function validationBitcoinSendTransactionMiddleware(koni: KoniState, url: string, payload_: PayloadValidated): Promise<PayloadValidated>;
 export declare function convertErrorMessage(message_: string, name?: string): string[];
 export declare function convertErrorFormat(errors: Error[]): ErrorValidation[];