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

package/cjs/koni/background/handlers/State.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var CardanoWasm = _interopRequireWildcard(require("@emurgo/cardano-serialization-lib-nodejs"));
+var _BitcoinProviderError = require("@subwallet/extension-base/background/errors/BitcoinProviderError");
 var _CardanoProviderError = require("@subwallet/extension-base/background/errors/CardanoProviderError");
 var _EvmProviderError = require("@subwallet/extension-base/background/errors/EvmProviderError");
 var _helpers = require("@subwallet/extension-base/background/handlers/helpers");
@@ -49,6 +50,8 @@ var _cardano = require("@subwallet/extension-base/utils/cardano");
 var _promise = require("@subwallet/extension-base/utils/promise");
 var _subwalletApiSdk = _interopRequireDefault(require("@subwallet/subwallet-api-sdk"));
 var _uiKeyring = require("@subwallet/ui-keyring");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var bitcoin = _interopRequireWildcard(require("bitcoinjs-lib"));
 var _bn = _interopRequireDefault(require("bn.js"));
 var _i18next = require("i18next");
 var _rxjs = require("rxjs");
@@ -95,6 +98,7 @@ class KoniState {
   generalStatus = _types.ServiceStatus.INITIALIZING;
   waitSleeping = null;
   waitStarting = null;
+  waitStartingFull = null;
   constructor() {
     let providers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     // Init subwallet api sdk
@@ -106,11 +110,13 @@ class KoniState {
     this.eventService = new _eventService.EventService();
     this.dbService = new _DatabaseService.default(this.eventService);
     this.keyringService = new _keyringService.KeyringService(this);
+    this.feeService = new _service2.default(this);
+    this.transactionService = new _transactionService.default(this);
     this.notificationService = new _NotificationService.default();
     this.chainService = new _chainService.ChainService(this.dbService, this.eventService);
     this.subscanService = _subscanService.SubscanService.getInstance();
     this.settingService = new _SettingService.default();
-    this.requestService = new _requestService.default(this.chainService, this.settingService, this.keyringService);
+    this.requestService = new _requestService.default(this.chainService, this.settingService, this.keyringService, this.transactionService);
     this.priceService = new _priceService.PriceService(this.dbService, this.eventService, this.chainService);
     this.balanceService = new _balanceService.BalanceService(this);
     this.historyService = new _historyService.HistoryService(this.dbService, this.chainService, this.eventService, this.keyringService, this.subscanService);
@@ -120,9 +126,7 @@ class KoniState {
     this.campaignService = new _campaignService.default(this);
     this.mktCampaignService = new _mktCampaignService.default(this);
     this.buyService = new _buyService.default(this);
-    this.transactionService = new _transactionService.default(this);
     this.earningService = new _service.default(this);
-    this.feeService = new _service2.default(this);
     this.swapService = new _swapService.SwapService(this);
     this.inappNotificationService = new _inappNotificationService.InappNotificationService(this.dbService, this.keyringService, this.eventService, this.chainService);
     this.chainOnlineService = new _chainOnlineService.ChainOnlineService(this.chainService, this.settingService, this.eventService, this.dbService);
@@ -132,7 +136,9 @@ class KoniState {
 
     // Init state
     if (_utils3.targetIsWeb) {
-      this.init().catch(console.error);
+      this.init().then(() => {
+        this.wakeup(true).catch(console.error);
+      }).catch(console.error);
     }
   }
 
@@ -228,7 +234,8 @@ class KoniState {
     await this.earningService.init();
     await this.swapService.init();
     await this.inappNotificationService.init();
-    this.onReady();
+
+    // this.onReady();
     this.onAccountAdd();
     this.onAccountRemove();
 
@@ -240,6 +247,9 @@ 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;
@@ -263,11 +273,6 @@ 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() {
     let isReady = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
     let callback = arguments.length > 1 ? arguments[1] : undefined;
@@ -756,6 +761,9 @@ class KoniState {
   getCardanoApi(networkKey) {
     return this.chainService.getCardanoApi(networkKey);
   }
+  getBitcoinApi(networkKey) {
+    return this.chainService.getBitcoinApi(networkKey);
+  }
   getApiMap() {
     return {
       substrate: this.chainService.getSubstrateApiMap(),
@@ -1038,6 +1046,8 @@ class KoniState {
       });
     });
   }
+
+  // Cardano
   async cardanoGetBalance(id, url, address) {
     const authInfoMap = await this.getAuthList();
     const authInfo = authInfoMap[(0, _utils3.stripUrl)(url)];
@@ -1260,6 +1270,193 @@ 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 = [_logicValidation.validationAuthMiddleware, _logicValidation.validationBitcoinSignMessageMiddleware];
+    const result = await (0, _logicValidation.generateValidationProcess)(this, url, payloadValidation, validationSteps);
+    const errorsFormated = (0, _logicValidation.convertErrorFormat)(result.errors);
+    const payloadAfterValidated = {
+      ...result.payloadAfterValidated,
+      errors: errorsFormated,
+      id
+    };
+    return this.requestService.addConfirmationBitcoin(id, url, 'bitcoinSignatureRequest', payloadAfterValidated, {}).then(_ref9 => {
+      let {
+        isApproved,
+        payload
+      } = _ref9;
+      if (isApproved) {
+        if (payload) {
+          return payload;
+        } else {
+          throw new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.INVALID_PARAMS, (0, _i18next.t)('Not found signature'));
+        }
+      } else {
+        throw new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.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 = [_logicValidation.validationAuthMiddleware, _logicValidation.validationBitcoinConnectMiddleware, _logicValidation.validationBitcoinSignPsbtMiddleware];
+    const result = await (0, _logicValidation.generateValidationProcess)(this, url, payloadValidation, validationSteps);
+    const errorsFormated = (0, _logicValidation.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(_ref10 => {
+      let {
+        address: address_
+      } = _ref10;
+      return (0, _utils3.isSameAddress)(address, address_ || '');
+    });
+    let to = '';
+    const tokenInfo = this.getNativeTokenInfo(result.networkKey);
+    let value = new _bignumber.default(0);
+    const totalBalance = await this.balanceService.getTotalBalance(address, result.networkKey, tokenInfo.slug);
+    let inputAmount = new _bignumber.default(0);
+    const psbtInputData = psbtGenerate.data.inputs.reduce((inputs, _ref11, inputIndex) => {
+      let {
+        nonWitnessUtxo,
+        witnessUtxo
+      } = _ref11;
+      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 ((0, _utils3.isSameAddress)(address, inputData.address || '')) {
+          inputAmount = inputAmount.plus(new _bignumber.default(inputData.amount || '0'));
+        }
+      }
+      return inputs;
+    }, []);
+    if (new _bignumber.default(totalBalance.value).lt(inputAmount)) {
+      payloadAfterValidated.errors = [{
+        message: (0, _i18next.t)('Insufficient balance'),
+        name: (0, _i18next.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 _bignumber.default(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(_ref12 => {
+      let {
+        isApproved,
+        payload
+      } = _ref12;
+      if (isApproved) {
+        if (payload) {
+          return payload;
+        } else {
+          throw new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.INVALID_PARAMS, (0, _i18next.t)('Not found signature'));
+        }
+      } else {
+        throw new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.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 = [_logicValidation.validationAuthMiddleware, _logicValidation.validationBitcoinConnectMiddleware, _logicValidation.validationBitcoinSendTransactionMiddleware];
+    const result = await (0, _logicValidation.generateValidationProcess)(this, url, payloadValidation, validationSteps);
+    const errorsFormated = (0, _logicValidation.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(_ref13 => {
+      let {
+        isApproved,
+        payload
+      } = _ref13;
+      if (isApproved) {
+        if (payload) {
+          return payload;
+        } else {
+          throw new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.INVALID_PARAMS, (0, _i18next.t)('Not found signature'));
+        }
+      } else {
+        throw new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.USER_REJECTED_REQUEST);
+      }
+    });
+  }
   getConfirmationsQueueSubject() {
     return this.requestService.confirmationsQueueSubject;
   }
@@ -1269,6 +1466,9 @@ class KoniState {
   getConfirmationsQueueSubjectCardano() {
     return this.requestService.confirmationsQueueSubjectCardano;
   }
+  getConfirmationsQueueSubjectBitcoin() {
+    return this.requestService.confirmationsQueueSubjectBitcoin;
+  }
   async completeConfirmation(request) {
     return await this.requestService.completeConfirmation(request);
   }
@@ -1278,6 +1478,9 @@ 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 _storage.SWStorage.instance.getItem('mv3_migration');
     if (!migrationStatus || migrationStatus !== 'done') {
@@ -1348,11 +1551,11 @@ class KoniState {
       const subscription = this.keyringService.context.observable.currentAccount.subscribe(handleRemind);
     }
   }
-  async setStorageFromWS(_ref9) {
+  async setStorageFromWS(_ref14) {
     let {
       key,
       value
-    } = _ref9;
+    } = _ref14;
     try {
       const jsonData = JSON.stringify(value);
       await _storage.SWStorage.instance.setItem(key, jsonData);
@@ -1429,8 +1632,12 @@ class KoniState {
     });
   }
   async sleep() {
+    // Wait for app initialized before sleep
+    await this.eventService.waitAppInitialized;
+
     // Wait starting finish before sleep to avoid conflict
     this.generalStatus === _types.ServiceStatus.STARTING && this.waitStarting && (await this.waitStarting);
+    this.generalStatus === _types.ServiceStatus.STARTING_FULL && this.waitStartingFull && (await this.waitStartingFull);
     this.eventService.emit('general.sleep', true);
 
     // Avoid sleep multiple times
@@ -1459,6 +1666,9 @@ 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 === _types.ServiceStatus.STOPPING && this.waitSleeping && (await this.waitSleeping);
 
@@ -1484,15 +1694,38 @@ 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 = _types.ServiceStatus.STARTED;
+    starting.resolve();
+  }
+  async _startFull() {
+    // Continue wait existed starting process
+    if (this.generalStatus === _types.ServiceStatus.STARTING) {
+      await this.waitStarting;
+    }
+
+    // Always start full from start state
+    if (this.generalStatus !== _types.ServiceStatus.STARTED) {
+      return;
+    }
+    this.generalStatus = _types.ServiceStatus.STARTING_FULL;
+    const startingFull = (0, _promise.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 = _types.ServiceStatus.STARTED_FULL;
+    startingFull.resolve();
   }
   async wakeup() {
+    let fullWakeup = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
     await this._start();
+    if (fullWakeup) {
+      await this._startFull();
+    }
   }
   cancelSubscription(id) {
     if ((0, _subscriptions.isSubscriptionRunning)(id)) {
@@ -1780,12 +2013,12 @@ class KoniState {
 
   /* Metadata */
 
-  getCrowdloanContributions(_ref10) {
+  getCrowdloanContributions(_ref15) {
     let {
       address,
       page,
       relayChain
-    } = _ref10;
+    } = _ref15;
     return this.subscanService.getCrowdloanContributions(relayChain, address, page);
   }
 }

package/cjs/koni/background/handlers/Tabs.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = exports.chainPatrolCheckUrl = void 0;
 var CardanoWasm = _interopRequireWildcard(require("@emurgo/cardano-serialization-lib-nodejs"));
 var _types = require("@subwallet/chain-list/types");
+var _BitcoinProviderError = require("@subwallet/extension-base/background/errors/BitcoinProviderError");
 var _CardanoProviderError = require("@subwallet/extension-base/background/errors/CardanoProviderError");
 var _EvmProviderError = require("@subwallet/extension-base/background/errors/EvmProviderError");
 var _helpers = require("@subwallet/extension-base/background/handlers/helpers");
@@ -23,6 +24,7 @@ var _helper = require("@subwallet/extension-base/services/request-service/helper
 var _constants2 = require("@subwallet/extension-base/services/setting-service/constants");
 var _utils2 = require("@subwallet/extension-base/utils");
 var _types3 = require("@subwallet/keyring/types");
+var _utils3 = require("@subwallet/keyring/utils");
 var _uiKeyring = require("@subwallet/ui-keyring");
 var _web = _interopRequireDefault(require("web3"));
 var _phishing = require("@polkadot/phishing");
@@ -51,7 +53,8 @@ function transformAccountsV2(accounts) {
         evm: _types3.EthereumKeypairTypes,
         substrate: _types3.SubstrateKeypairTypes,
         ton: _types3.TonKeypairTypes,
-        cardano: _types3.CardanoKeypairTypes
+        cardano: _types3.CardanoKeypairTypes,
+        bitcoin: _types3.BitcoinKeypairTypes
       };
       const isValidTypes = accountAuthTypes.some(authType => {
         var _validTypes$authType;
@@ -952,10 +955,6 @@ 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, _ref19) {
     let {
       method,
@@ -1320,6 +1319,116 @@ class KoniTabs {
       throw new _CardanoProviderError.CardanoProviderError(_KoniTypes.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 = _uiKeyring.keyring.getPair(address);
+        if (pair.meta.noPublicKey) {
+          return;
+        }
+        const addressInfo = (0, _utils3.getBitcoinAddressInfo)(address);
+        const item = {
+          address,
+          type: addressInfo.type,
+          isTestnet: addressInfo.network === 'testnet'
+        };
+        item.derivationPath = pair.meta.derivationPath;
+        item.publicKey = (0, _util.hexStripPrefix)((0, _util.u8aToHex)(pair.publicKey));
+        if (pair.publicKey.length !== 32) {
+          item.tweakedPublicKey = (0, _util.hexStripPrefix)((0, _util.u8aToHex)(pair.publicKey.slice(1, 33)));
+        }
+        addressResults.push(item);
+      });
+      return addressResults;
+    } catch (e) {
+      throw new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.USER_REJECTED_REQUEST);
+    }
+  }
+  async bitcoinSign(id, url, _ref22) {
+    let {
+      method,
+      params
+    } = _ref22;
+    const signResult = await this.#koniState.bitcoinSign(id, url, method, params);
+    if (signResult) {
+      return signResult;
+    } else {
+      throw new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.INVALID_PARAMS, 'Failed to sign message');
+    }
+  }
+  async bitcoinSignPspt(id, url, _ref23) {
+    let {
+      method,
+      params
+    } = _ref23;
+    const psbtParams = params;
+    const signResult = await this.#koniState.bitcoinSignPspt(id, url, psbtParams);
+    if (signResult) {
+      return signResult;
+    } else {
+      throw new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.INVALID_PARAMS, 'Failed to sign message');
+    }
+  }
+  async bitcoinSendTransfer(id, url, _ref24) {
+    let {
+      params
+    } = _ref24;
+    const transactionParams = params;
+    const transactionHash = await this.#koniState.bitcoinSendTransaction(id, url, transactionParams);
+    if (!transactionHash) {
+      throw new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.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.BitcoinProviderError(_KoniTypes.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);
@@ -1330,7 +1439,7 @@ 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.EvmProviderError(_KoniTypes.EvmProviderErrorType.INTERNAL_ERROR, e.message);
@@ -1401,6 +1510,10 @@ 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}`);
     }

package/cjs/packageInfo.js

@@ -13,6 +13,6 @@ const packageInfo = {
   name: '@subwallet/extension-base',
   path: typeof __dirname === 'string' ? __dirname : 'auto',
   type: 'cjs',
-  version: '1.3.41-0'
+  version: '1.3.43-0'
 };
 exports.packageInfo = packageInfo;

package/cjs/page/bitcoin/index.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+// Copyright 2019-2022 @subwallet/extension authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const WALLET_NAME = 'SubWallet';
+const WALLET_VERSION = process.env.PKG_VERSION;
+class SubWalletBitcoinProvider {
+  name = WALLET_NAME;
+  version = WALLET_VERSION;
+  isSubWallet = true;
+  constructor(sendMessage) {
+    this.sendMessage = sendMessage;
+  }
+  async requestAccounts() {
+    return await this.request('getAccounts');
+  }
+  async getAccounts() {
+    return await this.request('getAccounts');
+  }
+  async signMessage(params) {
+    return await this.request('signMessage', params);
+  }
+  async signPsbt(params) {
+    return await this.request('signPsbt', params);
+  }
+  async sendTransfer(params) {
+    return await this.request('sendTransfer', params);
+  }
+  request(method, params) {
+    // Implement this method
+    return new Promise((resolve, reject) => {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      this.sendMessage('bitcoin(request)', {
+        method,
+        params
+      }).then(result => {
+        resolve(result);
+      }).catch(e => {
+        reject(e);
+      });
+    });
+  }
+  getProductInfo() {
+    return {
+      name: this.name,
+      version: this.version
+    };
+  }
+  get apis() {
+    return {
+      isSubWallet: this.isSubWallet,
+      request: (method, params) => this.request(method, params),
+      getAccounts: () => this.getAccounts(),
+      signMessage: params => this.signMessage(params),
+      signPsbt: params => this.signPsbt(params),
+      sendTransfer: params => this.sendTransfer(params),
+      requestAccounts: () => this.requestAccounts(),
+      getProductInfo: () => this.getProductInfo()
+    };
+  }
+}
+exports.default = SubWalletBitcoinProvider;

package/cjs/page/index.js

@@ -6,11 +6,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.enable = enable;
 exports.handleResponse = handleResponse;
+exports.initBitcoinProvider = initBitcoinProvider;
 exports.initCardanoProvider = initCardanoProvider;
 exports.initEvmProvider = initEvmProvider;
 exports.sendMessage = sendMessage;
 var _ProviderError = require("@subwallet/extension-base/background/errors/ProviderError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _bitcoin = _interopRequireDefault(require("@subwallet/extension-base/page/bitcoin"));
 var _cardano = _interopRequireDefault(require("@subwallet/extension-base/page/cardano"));
 var _evm = _interopRequireDefault(require("@subwallet/extension-base/page/evm"));
 var _substrate = _interopRequireDefault(require("@subwallet/extension-base/page/substrate"));
@@ -76,4 +78,7 @@ function initEvmProvider(version) {
 }
 function initCardanoProvider() {
   return new _cardano.default(sendMessage);
+}
+function initBitcoinProvider() {
+  return new _bitcoin.default(sendMessage).apis;
 }