@subwallet/extension-base 1.3.42-0 → 1.3.44-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");
@@ -113,7 +116,7 @@ class KoniState {
     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.feeService, this.transactionService);
+    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);
@@ -1043,6 +1046,8 @@ class KoniState {
       });
     });
   }
+
+  // Cardano
   async cardanoGetBalance(id, url, address) {
     const authInfoMap = await this.getAuthList();
     const authInfo = authInfoMap[(0, _utils3.stripUrl)(url)];
@@ -1265,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;
   }
@@ -1359,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);
@@ -1505,9 +1697,9 @@ class KoniState {
     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
@@ -1821,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.42-0'
+  version: '1.3.44-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;
 }

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

@@ -12,7 +12,18 @@ var _constants = require("./constants");
 // SPDX-License-Identifier: Apache-2.0
 
 const convertSupportType = support => {
-  return support === 'ETHEREUM' ? _types.AccountChainType.ETHEREUM : _types.AccountChainType.SUBSTRATE;
+  switch (support) {
+    case 'ETHEREUM':
+      return _types.AccountChainType.ETHEREUM;
+    case 'SUBSTRATE':
+      return _types.AccountChainType.SUBSTRATE;
+    case 'CARDANO':
+      return _types.AccountChainType.CARDANO;
+    case 'TON':
+      return _types.AccountChainType.TON;
+    default:
+      return null;
+  }
 };
 class BuyService {
   #state;
@@ -35,11 +46,15 @@ class BuyService {
     const data = await (0, _fetchStaticData.fetchStaticData)('buy-token-configs');
     const result = {};
     for (const datum of data) {
+      const support = convertSupportType(datum.support);
+      if (!support) {
+        continue;
+      }
       const temp = {
         serviceInfo: {
           ..._constants.DEFAULT_SERVICE_INFO
         },
-        support: convertSupportType(datum.support),
+        support,
         services: [],
         slug: datum.slug,
         symbol: datum.symbol,

package/cjs/services/earning-service/handlers/native-staking/para-chain.js

@@ -433,6 +433,10 @@ class ParaNativeStakingPoolHandler extends _basePara.default {
     const apiPromise = await this.substrateApi.isReady;
     const binaryAmount = new _util.BN(amount);
     const selectedCollatorInfo = selectedValidators[0];
+    const {
+      address: selectedCollatorAddress,
+      nominatorCount: selectedCollatorNominatorCount
+    } = selectedCollatorInfo;
 
     // eslint-disable-next-line @typescript-eslint/require-await
     const compoundResult = async extrinsic => {
@@ -447,8 +451,17 @@ class ParaNativeStakingPoolHandler extends _basePara.default {
       }];
     };
     if (!positionInfo) {
-      const extrinsic = apiPromise.api.tx.parachainStaking.delegate(selectedCollatorInfo.address, binaryAmount, new _util.BN(selectedCollatorInfo.nominatorCount), 0);
-      return compoundResult(extrinsic);
+      var _apiPromise$api;
+      const isTxSupportedDelegate = !!((_apiPromise$api = apiPromise.api) !== null && _apiPromise$api !== void 0 && _apiPromise$api.tx.parachainStaking.delegate);
+      if (isTxSupportedDelegate) {
+        const extrinsic = apiPromise.api.tx.parachainStaking.delegate(selectedCollatorAddress, binaryAmount, new _util.BN(selectedCollatorNominatorCount), 0);
+        return compoundResult(extrinsic);
+      } else {
+        var _apiPromise$api$query, _apiPromise$api$query2;
+        const autoCompoundingDelegation = await ((_apiPromise$api$query = apiPromise.api.query) === null || _apiPromise$api$query === void 0 ? void 0 : (_apiPromise$api$query2 = _apiPromise$api$query.parachainStaking) === null || _apiPromise$api$query2 === void 0 ? void 0 : _apiPromise$api$query2.autoCompoundingDelegations(selectedCollatorAddress));
+        const extrinsic = apiPromise.api.tx.parachainStaking.delegateWithAutoCompound(selectedCollatorAddress, binaryAmount, 100, new _util.BN(selectedCollatorNominatorCount), new _util.BN(autoCompoundingDelegation.length), 0);
+        return compoundResult(extrinsic);
+      }
     }
     const {
       bondedValidators,
@@ -456,10 +469,19 @@ class ParaNativeStakingPoolHandler extends _basePara.default {
     } = (0, _utils.getBondedValidators)(positionInfo.nominations);
     const parsedSelectedCollatorAddress = (0, _utils3.reformatAddress)(selectedCollatorInfo.address, 0);
     if (!bondedValidators.includes(parsedSelectedCollatorAddress)) {
-      const extrinsic = apiPromise.api.tx.parachainStaking.delegate(selectedCollatorInfo.address, binaryAmount, new _util.BN(selectedCollatorInfo.nominatorCount), nominationCount);
-      return compoundResult(extrinsic);
+      var _apiPromise$api2;
+      const isTxSupportedDelegate = !!((_apiPromise$api2 = apiPromise.api) !== null && _apiPromise$api2 !== void 0 && _apiPromise$api2.tx.parachainStaking.delegate);
+      if (isTxSupportedDelegate) {
+        const extrinsic = apiPromise.api.tx.parachainStaking.delegate(selectedCollatorAddress, binaryAmount, new _util.BN(selectedCollatorNominatorCount), nominationCount);
+        return compoundResult(extrinsic);
+      } else {
+        var _apiPromise$api$query3, _apiPromise$api$query4;
+        const autoCompoundingDelegation = await ((_apiPromise$api$query3 = apiPromise.api.query) === null || _apiPromise$api$query3 === void 0 ? void 0 : (_apiPromise$api$query4 = _apiPromise$api$query3.parachainStaking) === null || _apiPromise$api$query4 === void 0 ? void 0 : _apiPromise$api$query4.autoCompoundingDelegations(selectedCollatorAddress));
+        const extrinsic = apiPromise.api.tx.parachainStaking.delegateWithAutoCompound(selectedCollatorAddress, binaryAmount, 100, new _util.BN(selectedCollatorNominatorCount), new _util.BN(autoCompoundingDelegation.length), nominationCount);
+        return compoundResult(extrinsic);
+      }
     } else {
-      const extrinsic = apiPromise.api.tx.parachainStaking.delegatorBondMore(selectedCollatorInfo.address, binaryAmount);
+      const extrinsic = apiPromise.api.tx.parachainStaking.delegatorBondMore(selectedCollatorAddress, binaryAmount);
       return compoundResult(extrinsic);
     }
   }

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

@@ -12,6 +12,7 @@ var _Authorize = _interopRequireDefault(require("@subwallet/extension-base/store
 var _utils2 = require("@subwallet/extension-base/utils");
 var _getId = require("@subwallet/extension-base/utils/getId");
 var _keyring = require("@subwallet/keyring");
+var _validate = require("@subwallet/keyring/utils/address/validate");
 var _rxjs = require("rxjs");
 var _utilCrypto = require("@polkadot/util-crypto");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
@@ -179,6 +180,18 @@ class AuthRequestHandler {
         }
       }
     }
+    if (options.accessType === 'bitcoin') {
+      const bitcoinChains = Object.values(chainInfoMaps).filter(_utils._isChainBitcoinCompatible);
+      chainInfo = (defaultChain ? chainInfoMaps[defaultChain] : chainInfoMaps.bitcoin) || bitcoinChains[0]; // auto active cardano mainnet chain, because dont support switch network yet
+
+      if (options.autoActive) {
+        var _chainInfo5;
+        if (!needEnableChains.includes((_chainInfo5 = chainInfo) === null || _chainInfo5 === void 0 ? void 0 : _chainInfo5.slug)) {
+          var _chainInfo6;
+          needEnableChains.push((_chainInfo6 = chainInfo) === null || _chainInfo6 === void 0 ? void 0 : _chainInfo6.slug);
+        }
+      }
+    }
     needEnableChains = needEnableChains.filter(slug => {
       var _chainStateMap$slug;
       return !((_chainStateMap$slug = chainStateMap[slug]) !== null && _chainStateMap$slug !== void 0 && _chainStateMap$slug.active);
@@ -230,6 +243,9 @@ class AuthRequestHandler {
           if ((0, _keyring.isCardanoAddress)(a) && !accountAuthTypes.includes('cardano')) {
             return true;
           }
+          if ((0, _validate.isBitcoinAddress)(a) && !accountAuthTypes.includes('bitcoin')) {
+            return true;
+          }
           return false;
         });
         backupAllowed.forEach(acc => {
@@ -384,6 +400,8 @@ class AuthRequestHandler {
           list.push(...allowedListByRequestType.filter(a => (0, _keyring.isTonAddress)(a)));
         } else if (accountAuthType === 'cardano') {
           list.push(...allowedListByRequestType.filter(a => (0, _keyring.isCardanoAddress)(a)));
+        } else if (accountAuthType === 'bitcoin') {
+          list.push(...allowedListByRequestType.filter(a => (0, _validate.isBitcoinAddress)(a)));
         }
         return list;
       }, []);