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

package/koni/background/handlers/State.js

@@ -2,13 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import * as CardanoWasm from '@emurgo/cardano-serialization-lib-nodejs';
+import { BitcoinProviderError } from '@subwallet/extension-base/background/errors/BitcoinProviderError';
 import { CardanoProviderError } from '@subwallet/extension-base/background/errors/CardanoProviderError';
 import { EvmProviderError } from '@subwallet/extension-base/background/errors/EvmProviderError';
 import { withErrorLog } from '@subwallet/extension-base/background/handlers/helpers';
 import { isSubscriptionRunning, unsubscribe } from '@subwallet/extension-base/background/handlers/subscriptions';
-import { APIItemState, CardanoProviderErrorType, ChainType, EvmProviderErrorType, ExternalRequestPromiseStatus, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { APIItemState, BitcoinProviderErrorType, CardanoProviderErrorType, ChainType, EvmProviderErrorType, ExternalRequestPromiseStatus, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { BACKEND_API_URL, BACKEND_PRICE_HISTORY_URL, MANTA_PAY_BALANCE_INTERVAL, REMIND_EXPORT_ACCOUNT } from '@subwallet/extension-base/constants';
-import { convertErrorFormat, generateValidationProcess, validationAuthCardanoMiddleware, validationAuthMiddleware, validationAuthWCMiddleware, validationCardanoSignDataMiddleware, validationConnectMiddleware, validationEvmDataTransactionMiddleware, validationEvmSignMessageMiddleware } from '@subwallet/extension-base/core/logic-validation';
+import { convertErrorFormat, generateValidationProcess, validationAuthCardanoMiddleware, validationAuthMiddleware, validationAuthWCMiddleware, validationBitcoinConnectMiddleware, validationBitcoinSendTransactionMiddleware, validationBitcoinSignMessageMiddleware, validationBitcoinSignPsbtMiddleware, validationCardanoSignDataMiddleware, validationConnectMiddleware, validationEvmDataTransactionMiddleware, validationEvmSignMessageMiddleware } from '@subwallet/extension-base/core/logic-validation';
 import { BalanceService } from '@subwallet/extension-base/services/balance-service';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
 import BuyService from '@subwallet/extension-base/services/buy-service';
@@ -45,6 +46,8 @@ import { convertCardanoHexToBech32, validateAddressNetwork } from '@subwallet/ex
 import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
 import subwalletApiSdk from '@subwallet/subwallet-api-sdk';
 import { keyring } from '@subwallet/ui-keyring';
+import BigN from 'bignumber.js';
+import * as bitcoin from 'bitcoinjs-lib';
 import BN from 'bn.js';
 import { t } from 'i18next';
 import { Subject } from 'rxjs';
@@ -87,6 +90,7 @@ export default class KoniState {
   generalStatus = ServiceStatus.INITIALIZING;
   waitSleeping = null;
   waitStarting = null;
+  waitStartingFull = null;
   constructor(providers = {}) {
     // Init subwallet api sdk
     subwalletApiSdk.init({
@@ -97,11 +101,13 @@ export default class KoniState {
     this.eventService = new EventService();
     this.dbService = new DatabaseService(this.eventService);
     this.keyringService = new KeyringService(this);
+    this.feeService = new FeeService(this);
+    this.transactionService = new TransactionService(this);
     this.notificationService = new NotificationService();
     this.chainService = new ChainService(this.dbService, this.eventService);
     this.subscanService = SubscanService.getInstance();
     this.settingService = new SettingService();
-    this.requestService = new RequestService(this.chainService, this.settingService, this.keyringService);
+    this.requestService = new RequestService(this.chainService, this.settingService, this.keyringService, this.transactionService);
     this.priceService = new PriceService(this.dbService, this.eventService, this.chainService);
     this.balanceService = new BalanceService(this);
     this.historyService = new HistoryService(this.dbService, this.chainService, this.eventService, this.keyringService, this.subscanService);
@@ -111,9 +117,7 @@ export default class KoniState {
     this.campaignService = new CampaignService(this);
     this.mktCampaignService = new MktCampaignService(this);
     this.buyService = new BuyService(this);
-    this.transactionService = new TransactionService(this);
     this.earningService = new EarningService(this);
-    this.feeService = new FeeService(this);
     this.swapService = new SwapService(this);
     this.inappNotificationService = new InappNotificationService(this.dbService, this.keyringService, this.eventService, this.chainService);
     this.chainOnlineService = new ChainOnlineService(this.chainService, this.settingService, this.eventService, this.dbService);
@@ -123,7 +127,9 @@ export default class KoniState {
 
     // Init state
     if (targetIsWeb) {
-      this.init().catch(console.error);
+      this.init().then(() => {
+        this.wakeup(true).catch(console.error);
+      }).catch(console.error);
     }
   }
 
@@ -218,7 +224,8 @@ export default class KoniState {
     await this.earningService.init();
     await this.swapService.init();
     await this.inappNotificationService.init();
-    this.onReady();
+
+    // this.onReady();
     this.onAccountAdd();
     this.onAccountRemove();
 
@@ -230,6 +237,9 @@ export default class KoniState {
     this.chainService.subscribeChainInfoMap().subscribe(() => {
       this.afterChainServiceInit();
     });
+
+    // Mark app is ready
+    this.eventService.emit('general.init', true);
   }
   async initMantaPay(password) {
     var _this$chainService, _this$chainService$ma;
@@ -253,11 +263,6 @@ export default class KoniState {
       this.mantaPayConfigSubject.next(data);
     });
   }
-  onReady() {
-    // Todo: Need optimize in the future to, only run important services onetime to save resources
-    // Todo: If optimize must check activity of web-runner of mobile
-    this._start().catch(console.error);
-  }
   updateKeyringState(isReady = true, callback) {
     this.keyringService.updateKeyringState(isReady);
     callback && callback();
@@ -740,6 +745,9 @@ export default class KoniState {
   getCardanoApi(networkKey) {
     return this.chainService.getCardanoApi(networkKey);
   }
+  getBitcoinApi(networkKey) {
+    return this.chainService.getBitcoinApi(networkKey);
+  }
   getApiMap() {
     return {
       substrate: this.chainService.getSubstrateApiMap(),
@@ -1016,6 +1024,8 @@ export default class KoniState {
       });
     });
   }
+
+  // Cardano
   async cardanoGetBalance(id, url, address) {
     const authInfoMap = await this.getAuthList();
     const authInfo = authInfoMap[stripUrl(url)];
@@ -1236,6 +1246,186 @@ export default class KoniState {
     const cardanoApi = this.chainService.getCardanoApi(networkKey);
     return await cardanoApi.sendCardanoTxReturnHash(txHex);
   }
+
+  // Bitcoin
+  async bitcoinSign(id, url, method, params) {
+    const {
+      address,
+      message
+    } = params;
+    const payloadValidation = {
+      address,
+      type: 'bitcoin',
+      payloadAfterValidated: message,
+      errors: [],
+      networkKey: ''
+    };
+    const validationSteps = [validationAuthMiddleware, validationBitcoinSignMessageMiddleware];
+    const result = await generateValidationProcess(this, url, payloadValidation, validationSteps);
+    const errorsFormated = convertErrorFormat(result.errors);
+    const payloadAfterValidated = {
+      ...result.payloadAfterValidated,
+      errors: errorsFormated,
+      id
+    };
+    return this.requestService.addConfirmationBitcoin(id, url, 'bitcoinSignatureRequest', payloadAfterValidated, {}).then(({
+      isApproved,
+      payload
+    }) => {
+      if (isApproved) {
+        if (payload) {
+          return payload;
+        } else {
+          throw new BitcoinProviderError(BitcoinProviderErrorType.INVALID_PARAMS, t('Not found signature'));
+        }
+      } else {
+        throw new BitcoinProviderError(BitcoinProviderErrorType.USER_REJECTED_REQUEST);
+      }
+    });
+  }
+  async bitcoinSignPspt(id, url, params) {
+    const {
+      address,
+      network,
+      psbt
+    } = params;
+    const payloadValidation = {
+      address,
+      type: 'bitcoin',
+      payloadAfterValidated: params,
+      errors: [],
+      networkKey: network === 'mainnet' ? 'bitcoin' : 'bitcoinTestnet'
+    };
+    const validationSteps = [validationAuthMiddleware, validationBitcoinConnectMiddleware, validationBitcoinSignPsbtMiddleware];
+    const result = await generateValidationProcess(this, url, payloadValidation, validationSteps);
+    const errorsFormated = convertErrorFormat(result.errors);
+    const payloadAfterValidated = {
+      ...result.payloadAfterValidated,
+      errors: errorsFormated
+    };
+    const network_ = network === 'mainnet' ? bitcoin.networks.bitcoin : bitcoin.networks.testnet;
+    const psbtGenerate = bitcoin.Psbt.fromHex(psbt, {
+      network: network_
+    });
+    const isExistedInput = (inputs, address) => inputs.findIndex(({
+      address: address_
+    }) => isSameAddress(address, address_ || ''));
+    let to = '';
+    const tokenInfo = this.getNativeTokenInfo(result.networkKey);
+    let value = new BigN(0);
+    const totalBalance = await this.balanceService.getTotalBalance(address, result.networkKey, tokenInfo.slug);
+    let inputAmount = new BigN(0);
+    const psbtInputData = psbtGenerate.data.inputs.reduce((inputs, {
+      nonWitnessUtxo,
+      witnessUtxo
+    }, inputIndex) => {
+      let inputData = null;
+      if (witnessUtxo) {
+        inputData = {
+          address: bitcoin.address.fromOutputScript(witnessUtxo === null || witnessUtxo === void 0 ? void 0 : witnessUtxo.script, network_),
+          amount: witnessUtxo.value.toString()
+        };
+      } else if (nonWitnessUtxo) {
+        const txin = psbtGenerate.txInputs[inputIndex];
+        const txout = bitcoin.Transaction.fromBuffer(nonWitnessUtxo).outs[txin.index];
+        inputData = {
+          address: bitcoin.address.fromOutputScript(txout.script, network_),
+          amount: txout.value.toString()
+        };
+      }
+      if (inputData) {
+        inputs.push(inputData);
+        if (isSameAddress(address, inputData.address || '')) {
+          inputAmount = inputAmount.plus(new BigN(inputData.amount || '0'));
+        }
+      }
+      return inputs;
+    }, []);
+    if (new BigN(totalBalance.value).lt(inputAmount)) {
+      payloadAfterValidated.errors = [{
+        message: t('Insufficient balance'),
+        name: t('Unable to sign transaction')
+      }];
+    }
+    const psbtOutputData = psbtGenerate.txOutputs.map(output => {
+      let address = '';
+      try {
+        address = output.address || bitcoin.address.fromOutputScript(output.script, network_);
+      } catch (e) {
+        if (output.script.includes(bitcoin.opcodes.OP_RETURN)) {
+          address = 'OP_RETURN';
+        } else {
+          address = 'Unknown';
+        }
+      }
+      if (isExistedInput(psbtInputData, address) === -1) {
+        to = address;
+        value = value.plus(new BigN(output.value));
+      }
+      return {
+        address,
+        amount: output.value.toString()
+      };
+    });
+    payloadAfterValidated.payload = {
+      ...payloadAfterValidated.payload,
+      psbt,
+      tokenSlug: tokenInfo.slug,
+      value: value.toString(),
+      to,
+      txInput: psbtInputData,
+      txOutput: psbtOutputData
+    };
+    return this.requestService.addConfirmationBitcoin(id, url, 'bitcoinSignPsbtRequest', payloadAfterValidated, {}).then(({
+      isApproved,
+      payload
+    }) => {
+      if (isApproved) {
+        if (payload) {
+          return payload;
+        } else {
+          throw new BitcoinProviderError(BitcoinProviderErrorType.INVALID_PARAMS, t('Not found signature'));
+        }
+      } else {
+        throw new BitcoinProviderError(BitcoinProviderErrorType.USER_REJECTED_REQUEST);
+      }
+    });
+  }
+  async bitcoinSendTransaction(id, url, transactionParams) {
+    const payloadValidation = {
+      address: transactionParams.account,
+      type: 'bitcoin',
+      payloadAfterValidated: transactionParams,
+      errors: [],
+      networkKey: transactionParams.network === 'mainnet' ? 'bitcoin' : 'bitcoinTestnet'
+    };
+    const validationSteps = [validationAuthMiddleware, validationBitcoinConnectMiddleware, validationBitcoinSendTransactionMiddleware];
+    const result = await generateValidationProcess(this, url, payloadValidation, validationSteps);
+    const errorsFormated = convertErrorFormat(result.errors);
+    const requestPayload = {
+      ...result.payloadAfterValidated,
+      hashPayload: JSON.stringify(result.payloadAfterValidated),
+      from: transactionParams.account,
+      id,
+      errors: errorsFormated
+    };
+
+    // Custom handle this instead of general handler transaction
+    return this.requestService.addConfirmationBitcoin(id, url, 'bitcoinSendTransactionRequestAfterConfirmation', requestPayload, {}).then(({
+      isApproved,
+      payload
+    }) => {
+      if (isApproved) {
+        if (payload) {
+          return payload;
+        } else {
+          throw new BitcoinProviderError(BitcoinProviderErrorType.INVALID_PARAMS, t('Not found signature'));
+        }
+      } else {
+        throw new BitcoinProviderError(BitcoinProviderErrorType.USER_REJECTED_REQUEST);
+      }
+    });
+  }
   getConfirmationsQueueSubject() {
     return this.requestService.confirmationsQueueSubject;
   }
@@ -1245,6 +1435,9 @@ export default class KoniState {
   getConfirmationsQueueSubjectCardano() {
     return this.requestService.confirmationsQueueSubjectCardano;
   }
+  getConfirmationsQueueSubjectBitcoin() {
+    return this.requestService.confirmationsQueueSubjectBitcoin;
+  }
   async completeConfirmation(request) {
     return await this.requestService.completeConfirmation(request);
   }
@@ -1254,6 +1447,9 @@ export default class KoniState {
   async completeConfirmationCardano(request) {
     return await this.requestService.completeConfirmationCardano(request);
   }
+  async completeConfirmationBitcoin(request) {
+    return await this.requestService.completeConfirmationBitcoin(request);
+  }
   async onMV3Update() {
     const migrationStatus = await SWStorage.instance.getItem('mv3_migration');
     if (!migrationStatus || migrationStatus !== 'done') {
@@ -1404,8 +1600,12 @@ export default class KoniState {
     });
   }
   async sleep() {
+    // Wait for app initialized before sleep
+    await this.eventService.waitAppInitialized;
+
     // Wait starting finish before sleep to avoid conflict
     this.generalStatus === ServiceStatus.STARTING && this.waitStarting && (await this.waitStarting);
+    this.generalStatus === ServiceStatus.STARTING_FULL && this.waitStartingFull && (await this.waitStartingFull);
     this.eventService.emit('general.sleep', true);
 
     // Avoid sleep multiple times
@@ -1434,6 +1634,9 @@ export default class KoniState {
     this.waitSleeping = null;
   }
   async _start() {
+    // Wait for app initialized before start
+    await this.eventService.waitAppInitialized;
+
     // Wait sleep finish before start to avoid conflict
     this.generalStatus === ServiceStatus.STOPPING && this.waitSleeping && (await this.waitSleeping);
 
@@ -1459,15 +1662,37 @@ export default class KoniState {
     }
 
     // Start services
-    await Promise.all([this.cron.start(), this.subscription.start(), this.historyService.start(), this.priceService.start(), this.balanceService.start(), this.earningService.start(), this.swapService.start(), this.inappNotificationService.start()]);
+    this.eventService.emit('general.start', true);
 
     // Complete starting
-    starting.resolve();
     this.waitStarting = null;
     this.generalStatus = ServiceStatus.STARTED;
+    starting.resolve();
+  }
+  async _startFull() {
+    // Continue wait existed starting process
+    if (this.generalStatus === ServiceStatus.STARTING) {
+      await this.waitStarting;
+    }
+
+    // Always start full from start state
+    if (this.generalStatus !== ServiceStatus.STARTED) {
+      return;
+    }
+    this.generalStatus = ServiceStatus.STARTING_FULL;
+    const startingFull = createPromiseHandler();
+    this.waitStartingFull = startingFull.promise;
+    await Promise.all([this.cron.start(), this.subscription.start(), this.historyService.start(), this.priceService.start(), this.balanceService.start(), this.earningService.start(), this.swapService.start(), this.inappNotificationService.start()]);
+    this.eventService.emit('general.start_full', true);
+    this.waitStartingFull = null;
+    this.generalStatus = ServiceStatus.STARTED_FULL;
+    startingFull.resolve();
   }
-  async wakeup() {
+  async wakeup(fullWakeup = false) {
     await this._start();
+    if (fullWakeup) {
+      await this._startFull();
+    }
   }
   cancelSubscription(id) {
     if (isSubscriptionRunning(id)) {

package/koni/background/handlers/Tabs.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="chrome" />
-import { RequestAddPspToken } from '@subwallet/extension-base/background/KoniTypes';
+import { BitcoinRequestGetAddressesResult, RequestAddPspToken } from '@subwallet/extension-base/background/KoniTypes';
 import { MessageTypes, RequestTypes, ResponseTypes } from '@subwallet/extension-base/background/types';
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
 import { AuthUrlInfo, AuthUrls } from '@subwallet/extension-base/services/request-service/types';
@@ -42,7 +42,6 @@ export default class KoniTabs {
     private checkAndHandleProviderStatus;
     private getEvmProvider;
     private performWeb3Method;
-    canUseAccount(address: string, url: string): Promise<boolean>;
     private evmSign;
     evmSendTransaction(id: string, url: string, { params }: RequestArguments): Promise<string>;
     private handleEvmRequest;
@@ -60,5 +59,11 @@ export default class KoniTabs {
     private cardanoSignData;
     private cardanoSignTransaction;
     private cardanoSubmitTransaction;
+    isBitcoinPublicRequest(type: string, request: RequestArguments): boolean;
+    bitcoinGetAddresses(url: string): Promise<BitcoinRequestGetAddressesResult>;
+    private bitcoinSign;
+    private bitcoinSignPspt;
+    private bitcoinSendTransfer;
+    private handleBitcoinRequest;
     handle<TMessageType extends MessageTypes>(id: string, type: TMessageType, request: RequestTypes[TMessageType], url: string, port: chrome.runtime.Port): Promise<ResponseTypes[keyof ResponseTypes]>;
 }

package/koni/background/handlers/Tabs.js

@@ -3,11 +3,12 @@
 
 import * as CardanoWasm from '@emurgo/cardano-serialization-lib-nodejs';
 import { _AssetType } from '@subwallet/chain-list/types';
+import { BitcoinProviderError } from '@subwallet/extension-base/background/errors/BitcoinProviderError';
 import { CardanoProviderError } from '@subwallet/extension-base/background/errors/CardanoProviderError';
 import { EvmProviderError } from '@subwallet/extension-base/background/errors/EvmProviderError';
 import { withErrorLog } from '@subwallet/extension-base/background/handlers/helpers';
 import { createSubscription, unsubscribe } from '@subwallet/extension-base/background/handlers/subscriptions';
-import { CardanoProviderErrorType, EvmProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { BitcoinProviderErrorType, CardanoProviderErrorType, EvmProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
 import RequestBytesSign from '@subwallet/extension-base/background/RequestBytesSign';
 import RequestExtrinsicSign from '@subwallet/extension-base/background/RequestExtrinsicSign';
 import { ALL_ACCOUNT_KEY, CRON_GET_API_MAP_STATUS, MAX_COLLATERAL_AMOUNT, PERMISSIONS_TO_REVOKE } from '@subwallet/extension-base/constants';
@@ -18,11 +19,12 @@ import { _generateCustomProviderKey } from '@subwallet/extension-base/services/c
 import { hasSufficientCardanoValue } from '@subwallet/extension-base/services/request-service/helper';
 import { DEFAULT_CHAIN_PATROL_ENABLE } from '@subwallet/extension-base/services/setting-service/constants';
 import { convertCardanoAddressToHex, getEVMChainInfo, reformatAddress, stripUrl } from '@subwallet/extension-base/utils';
-import { CardanoKeypairTypes, EthereumKeypairTypes, SubstrateKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
+import { BitcoinKeypairTypes, CardanoKeypairTypes, EthereumKeypairTypes, SubstrateKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
+import { getBitcoinAddressInfo } from '@subwallet/keyring/utils';
 import { keyring } from '@subwallet/ui-keyring';
 import Web3 from 'web3';
 import { checkIfDenied } from '@polkadot/phishing';
-import { isArray, isNumber } from '@polkadot/util';
+import { hexStripPrefix, isArray, isNumber, u8aToHex } from '@polkadot/util';
 import { isEthereumAddress } from '@polkadot/util-crypto';
 function transformAccountsV2(accounts, anyType = false, authInfo, accountAuthTypes) {
   const accountSelected = authInfo ? authInfo.isAllowed ? Object.keys(authInfo.isAllowedMap).filter(address => authInfo.isAllowedMap[address]) : [] : [];
@@ -38,7 +40,8 @@ function transformAccountsV2(accounts, anyType = false, authInfo, accountAuthTyp
         evm: EthereumKeypairTypes,
         substrate: SubstrateKeypairTypes,
         ton: TonKeypairTypes,
-        cardano: CardanoKeypairTypes
+        cardano: CardanoKeypairTypes,
+        bitcoin: BitcoinKeypairTypes
       };
       const isValidTypes = accountAuthTypes.some(authType => {
         var _validTypes$authType;
@@ -911,10 +914,6 @@ export default class KoniTabs {
       });
     });
   }
-  async canUseAccount(address, url) {
-    const allowedAccounts = await this.getCurrentAccount(url, 'evm');
-    return !!allowedAccounts.find(acc => acc.toLowerCase() === address.toLowerCase());
-  }
   async evmSign(id, url, {
     method,
     params
@@ -1276,6 +1275,113 @@ export default class KoniTabs {
       throw new CardanoProviderError(CardanoProviderErrorType.INTERNAL_ERROR, 'Failed to submit transaction');
     }
   }
+
+  /// Bitcoin
+
+  isBitcoinPublicRequest(type, request) {
+    return type === 'bitcoin(request)' && ['getAddresses'].includes(request === null || request === void 0 ? void 0 : request.method);
+  }
+  async bitcoinGetAddresses(url) {
+    try {
+      const isCompleted = await this.#koniState.authorizeUrlV2(url, {
+        origin: url,
+        accountAuthTypes: ['bitcoin']
+      });
+      const result = [];
+      if (!isCompleted) {
+        return result;
+      }
+      const authInfo = await this.getAuthInfo(url);
+      if (!authInfo || !authInfo.isAllowedMap || !authInfo.isAllowed) {
+        return result;
+      }
+      const addressesAllowed = await this.getCurrentAccount(url, 'bitcoin');
+      const addressResults = [];
+      addressesAllowed.forEach(address => {
+        const pair = keyring.getPair(address);
+        if (pair.meta.noPublicKey) {
+          return;
+        }
+        const addressInfo = getBitcoinAddressInfo(address);
+        const item = {
+          address,
+          type: addressInfo.type,
+          isTestnet: addressInfo.network === 'testnet'
+        };
+        item.derivationPath = pair.meta.derivationPath;
+        item.publicKey = hexStripPrefix(u8aToHex(pair.publicKey));
+        if (pair.publicKey.length !== 32) {
+          item.tweakedPublicKey = hexStripPrefix(u8aToHex(pair.publicKey.slice(1, 33)));
+        }
+        addressResults.push(item);
+      });
+      return addressResults;
+    } catch (e) {
+      throw new BitcoinProviderError(BitcoinProviderErrorType.USER_REJECTED_REQUEST);
+    }
+  }
+  async bitcoinSign(id, url, {
+    method,
+    params
+  }) {
+    const signResult = await this.#koniState.bitcoinSign(id, url, method, params);
+    if (signResult) {
+      return signResult;
+    } else {
+      throw new BitcoinProviderError(BitcoinProviderErrorType.INVALID_PARAMS, 'Failed to sign message');
+    }
+  }
+  async bitcoinSignPspt(id, url, {
+    method,
+    params
+  }) {
+    const psbtParams = params;
+    const signResult = await this.#koniState.bitcoinSignPspt(id, url, psbtParams);
+    if (signResult) {
+      return signResult;
+    } else {
+      throw new BitcoinProviderError(BitcoinProviderErrorType.INVALID_PARAMS, 'Failed to sign message');
+    }
+  }
+  async bitcoinSendTransfer(id, url, {
+    params
+  }) {
+    const transactionParams = params;
+    const transactionHash = await this.#koniState.bitcoinSendTransaction(id, url, transactionParams);
+    if (!transactionHash) {
+      throw new BitcoinProviderError(BitcoinProviderErrorType.USER_REJECTED_REQUEST);
+    }
+    return {
+      txid: transactionHash
+    };
+  }
+  async handleBitcoinRequest(id, url, request, port) {
+    const {
+      method
+    } = request;
+    try {
+      switch (method) {
+        case 'getAddresses':
+          return await this.bitcoinGetAddresses(url);
+        case 'signMessage':
+          return await this.bitcoinSign(id, url, request);
+        case 'signPsbt':
+          return await this.bitcoinSignPspt(id, url, request);
+        case 'sendTransfer':
+          return await this.bitcoinSendTransfer(id, url, request);
+        default:
+          throw new Error(`Method ${method} is not supported by SubWalletBitcoin provider`);
+      }
+    } catch (e) {
+      // @ts-ignore
+      if (e.code) {
+        throw e;
+      } else {
+        console.error(e);
+        throw new BitcoinProviderError(BitcoinProviderErrorType.INTERNAL_ERROR, e === null || e === void 0 ? void 0 : e.toString());
+      }
+    }
+  }
   async handle(id, type, request, url, port) {
     if (type === 'pub(phishing.redirectIfDenied)') {
       return this.redirectIfPhishing(url);
@@ -1286,7 +1392,7 @@ export default class KoniTabs {
 
     // Wait for account ready and chain ready
     await Promise.all([this.#koniState.eventService.waitAccountReady, this.#koniState.eventService.waitChainReady]);
-    if (!['pub(authorize.tabV2)', 'pub(accounts.subscribeV2)'].includes(type) && !this.isEvmPublicRequest(type, request)) {
+    if (!['pub(authorize.tabV2)', 'pub(accounts.subscribeV2)'].includes(type) && !this.isEvmPublicRequest(type, request) && !this.isBitcoinPublicRequest(type, request)) {
       await this.#koniState.ensureUrlAuthorizedV2(url).catch(e => {
         if (type.startsWith('evm')) {
           throw new EvmProviderError(EvmProviderErrorType.INTERNAL_ERROR, e.message);
@@ -1357,6 +1463,10 @@ export default class KoniTabs {
         return await this.cardanoSignTransaction(id, url, request);
       case 'cardano(transaction.submit)':
         return await this.cardanoSubmitTransaction(id, url, request);
+
+      // Bitcoin
+      case 'bitcoin(request)':
+        return await this.handleBitcoinRequest(id, url, request, port);
       default:
         throw new Error(`Unable to handle message of type ${type}`);
     }