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

package/cjs/core/logic-validation/request.js

@@ -14,11 +14,16 @@ exports.validateTypedSignMessageDataV3V4 = validateTypedSignMessageDataV3V4;
 exports.validationAuthCardanoMiddleware = validationAuthCardanoMiddleware;
 exports.validationAuthMiddleware = validationAuthMiddleware;
 exports.validationAuthWCMiddleware = validationAuthWCMiddleware;
+exports.validationBitcoinConnectMiddleware = validationBitcoinConnectMiddleware;
+exports.validationBitcoinSendTransactionMiddleware = validationBitcoinSendTransactionMiddleware;
+exports.validationBitcoinSignMessageMiddleware = validationBitcoinSignMessageMiddleware;
+exports.validationBitcoinSignPsbtMiddleware = validationBitcoinSignPsbtMiddleware;
 exports.validationCardanoSignDataMiddleware = validationCardanoSignDataMiddleware;
 exports.validationConnectMiddleware = validationConnectMiddleware;
 exports.validationEvmDataTransactionMiddleware = validationEvmDataTransactionMiddleware;
 exports.validationEvmSignMessageMiddleware = validationEvmSignMessageMiddleware;
 var _ethSigUtil = require("@metamask/eth-sig-util");
+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 _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
@@ -29,8 +34,10 @@ var _cardano = require("@subwallet/extension-base/utils/cardano");
 var _parseTransaction = require("@subwallet/extension-base/utils/eth/parseTransaction");
 var _getId = require("@subwallet/extension-base/utils/getId");
 var _keyring = require("@subwallet/keyring");
+var _utils2 = require("@subwallet/keyring/utils");
+var _validate = require("@subwallet/keyring/utils/address/validate");
 var _uiKeyring = require("@subwallet/ui-keyring");
-var _utils2 = require("@walletconnect/utils");
+var _utils3 = require("@walletconnect/utils");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _bn = _interopRequireDefault(require("bn.js"));
 var _i18next = require("i18next");
@@ -172,6 +179,9 @@ async function validationAuthMiddleware(koni, url, payload) {
         if (!authInfo || !authInfo.isAllowed || !authInfo.isAllowedMap[payload.pair.address]) {
           return handleAuthError(payload, 'Account not in allowed list', 'dApp', errors);
         }
+        if (payload.pair.meta.noPublicKey) {
+          return handleAuthError(payload, (0, _i18next.t)('This account is not supported for this action'), 'dApp', errors);
+        }
         payload.authInfo = authInfo;
       }
     } catch (e) {
@@ -180,6 +190,8 @@ async function validationAuthMiddleware(koni, url, payload) {
   }
   return payload;
 }
+
+// ====== EVM ======
 async function validationConnectMiddleware(koni, url, payload) {
   let currentChain;
   let autoActiveChain = false;
@@ -521,7 +533,7 @@ function validationAuthWCMiddleware(koni, url, payload, topic) {
   } = payload;
   if (!topic) {
     payload.errorPosition = 'dApp';
-    errors.push(new Error((0, _utils2.getSdkError)('UNAUTHORIZED_EXTEND_REQUEST').message));
+    errors.push(new Error((0, _utils3.getSdkError)('UNAUTHORIZED_EXTEND_REQUEST').message));
   } else {
     const requestSession = koni.walletConnectService.getSession(topic);
     let sessionAccounts = [];
@@ -601,6 +613,11 @@ async function validationAuthCardanoMiddleware(koni, url, payload) {
   }
   return payload;
 }
+
+// ====== EVM ======
+
+// ====== Cardano ======
+
 async function validationCardanoSignDataMiddleware(koni, url, payload_) {
   const {
     address,
@@ -657,11 +674,298 @@ async function validationCardanoSignDataMiddleware(koni, url, payload_) {
   });
   return promise;
 }
+
+// ====== Cardano ======
+
+// ====== Bitcoin ======
+
+async function validationBitcoinConnectMiddleware(koni, url, payload) {
+  const {
+    authInfo,
+    errors,
+    networkKey
+  } = payload;
+  let autoActiveChain = false;
+  const handleError = message_ => {
+    payload.errorPosition = 'ui';
+    payload.confirmationType = 'errorConnectNetwork';
+    const [message, name] = convertErrorMessage(message_);
+    const error = new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, message, undefined, name);
+    console.error(error);
+    errors.push(error);
+  };
+  if (url && authInfo) {
+    if (authInfo !== null && authInfo !== void 0 && authInfo.isAllowed) {
+      autoActiveChain = true;
+    }
+  }
+  const currentBitcoinNetwork = koni.requestService.getDAppChainInfo({
+    autoActive: autoActiveChain,
+    accessType: 'bitcoin',
+    defaultChain: networkKey,
+    url
+  });
+  if (currentBitcoinNetwork) {
+    const chainStatus = koni.getChainStateByKey(networkKey);
+    const chainInfo = koni.getChainInfo(networkKey);
+    if (!chainStatus.active) {
+      try {
+        await koni.chainService.enableChain(networkKey);
+      } catch (e) {
+        handleError('Can not active chain: ' + chainInfo.name);
+      }
+    }
+  } else {
+    handleError('This network is currently not supported');
+  }
+  return {
+    ...payload,
+    networkKey: (currentBitcoinNetwork === null || currentBitcoinNetwork === void 0 ? void 0 : currentBitcoinNetwork.slug) || networkKey,
+    errors
+  };
+}
+async function validationBitcoinSignMessageMiddleware(koni, url, payload_) {
+  const {
+    address,
+    errors,
+    pair: pair_
+  } = payload_;
+  const message = payload_.payloadAfterValidated;
+  const {
+    promise,
+    resolve
+  } = (0, _utils.createPromiseHandler)();
+  const handleError = message_ => {
+    payload_.errorPosition = 'ui';
+    payload_.confirmationType = 'bitcoinSignatureRequest';
+    const [message, name] = convertErrorMessage(message_);
+    const error = new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.INVALID_PARAMS, message, undefined, name);
+    console.error(error);
+    errors.push(error);
+  };
+  if (address === '' || !message) {
+    handleError((0, _i18next.t)('not found address or payload to sign'));
+  }
+  if (!(0, _validate.isBitcoinAddress)(address)) {
+    handleError((0, _i18next.t)('Invalid bitcoin address'));
+  }
+  const pair = pair_ || _uiKeyring.keyring.getPair(address);
+  if (!pair) {
+    handleError((0, _i18next.t)('Unable to find account'));
+  }
+  const hashPayload = '';
+  let canSign = false;
+  if (!(pair !== null && pair !== void 0 && pair.meta.isExtneral)) {
+    canSign = true;
+  }
+  const payloadAfterValidated = {
+    address,
+    payload: message,
+    payloadJson: message,
+    hashPayload,
+    canSign,
+    id: ''
+  };
+  resolve({
+    ...payload_,
+    errors,
+    payloadAfterValidated
+  });
+  return promise;
+}
+async function validationBitcoinSignPsbtMiddleware(koni, url, payload_) {
+  const {
+    errors,
+    networkKey,
+    pair: pair_
+  } = payload_;
+  const psbtParams = payload_.payloadAfterValidated;
+  const {
+    address,
+    allowedSighash,
+    autoFinalized,
+    broadcast,
+    psbt,
+    signAtIndex
+  } = payload_.payloadAfterValidated;
+  const {
+    promise,
+    resolve
+  } = (0, _utils.createPromiseHandler)();
+  const handleError = message_ => {
+    payload_.errorPosition = 'ui';
+    payload_.confirmationType = 'bitcoinSignPsbtRequest';
+    const [message, name] = convertErrorMessage(message_);
+    const error = new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.INVALID_PARAMS, message, undefined, name);
+    console.error(error);
+    errors.push(error);
+  };
+  if (!(psbtParams.network === 'mainnet' || psbtParams.network === 'testnet')) {
+    handleError((0, _i18next.t)('Network to try this request is must be mainnet or testnet'));
+  }
+  if (!networkKey) {
+    handleError((0, _i18next.t)('Network unavailable. Please switch network or manually add network to wallet'));
+  }
+  if (!psbt || !address) {
+    handleError((0, _i18next.t)('Not found payload to sign'));
+  }
+  if (!(0, _util.isHex)(`0x${psbt}`)) {
+    handleError((0, _i18next.t)('Psbt to be signed must be hex-encoded'));
+  }
+  if (!(0, _validate.isBitcoinAddress)(address)) {
+    handleError((0, _i18next.t)('Not found address'));
+  }
+  const addressInfo = (0, _utils2.getBitcoinAddressInfo)(address);
+  if (psbtParams.network !== addressInfo.network) {
+    handleError((0, _i18next.t)('The account or the network is not matched'));
+  }
+  const payload = {
+    broadcast: !!broadcast,
+    network: networkKey,
+    signAtIndex: (0, _util.isArray)(signAtIndex) && signAtIndex.length === 0 ? undefined : signAtIndex,
+    address,
+    allowedSighash,
+    autoFinalized
+  };
+  const hashPayload = '';
+  const pair = pair_ || _uiKeyring.keyring.getPair(address);
+  const canSign = !(pair !== null && pair !== void 0 && pair.meta.isExternal);
+  const signPayload = {
+    address,
+    payload,
+    hashPayload,
+    canSign
+  };
+  resolve({
+    ...payload_,
+    errors,
+    payloadAfterValidated: signPayload
+  });
+  return promise;
+}
+async function validationBitcoinSendTransactionMiddleware(koni, url, payload_) {
+  var _transactionParams$re, _transactionParams$re2;
+  const {
+    address,
+    errors,
+    networkKey,
+    pair: pair_
+  } = payload_;
+  const transactionParams = payload_.payloadAfterValidated;
+  const {
+    promise,
+    resolve
+  } = (0, _utils.createPromiseHandler)();
+  const senderAccountInfo = (0, _utils2.getBitcoinAddressInfo)(address);
+  const handleError = message_ => {
+    payload_.errorPosition = 'ui';
+    payload_.confirmationType = 'bitcoinSendTransactionRequestAfterConfirmation';
+    const [message, name] = convertErrorMessage(message_);
+    const error = new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.INVALID_PARAMS, message, undefined, name);
+    console.error(error);
+    errors.push(error);
+  };
+  const autoFormatNumber = val => {
+    if (typeof val === 'string' && val.startsWith('0x')) {
+      return new _bignumber.default(val.replace('0x', ''), 16).toString();
+    } else if (typeof val === 'number') {
+      return val.toString();
+    }
+    return val;
+  };
+  if (transactionParams.network !== senderAccountInfo.network) {
+    handleError((0, _i18next.t)('The account or the network is not matched'));
+  }
+  if (!((_transactionParams$re = transactionParams.recipients) !== null && _transactionParams$re !== void 0 && _transactionParams$re.length)) {
+    handleError((0, _i18next.t)('please provide the recipient and the amount'));
+  }
+  if (((_transactionParams$re2 = transactionParams.recipients) === null || _transactionParams$re2 === void 0 ? void 0 : _transactionParams$re2.length) > 1) {
+    handleError((0, _i18next.t)("we don't support multiple recipients yet. Please provide only one for now."));
+  }
+  if (transactionParams.recipients.filter(_ref => {
+    let {
+      address,
+      amount
+    } = _ref;
+    return !address || !amount;
+  }).length > 0) {
+    throw new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.INVALID_PARAMS);
+  }
+  const recipientAccountInfo = (0, _utils2.getBitcoinAddressInfo)(transactionParams.recipients[0].address);
+  if (recipientAccountInfo.network !== transactionParams.network) {
+    handleError((0, _i18next.t)('invalid recipient address'));
+  }
+  if (transactionParams.recipients.length !== 1) {
+    handleError((0, _i18next.t)('receiving address must be a single account'));
+  }
+  if (address === transactionParams.recipients[0].address) {
+    handleError((0, _i18next.t)('must be different from sending address'));
+  }
+  const pair = pair_ || _uiKeyring.keyring.getPair(address);
+  if (!pair) {
+    handleError((0, _i18next.t)('unable to find account'));
+  }
+  const tokenInfo = koni.getNativeTokenInfo(networkKey);
+  let freeBalance = {
+    decimals: 0,
+    symbol: 'BTC',
+    value: '0'
+  };
+  let totalValue = new _bignumber.default('0');
+  try {
+    freeBalance = await koni.balanceService.getTransferableBalance(address, networkKey, tokenInfo.slug);
+  } catch (e) {
+    const message = e.message;
+    if (message.toLowerCase().includes((0, _i18next.t)('please enable network'))) {
+      const chainInfo = koni.chainService.getChainInfoByKey(networkKey);
+      payload_.errorPosition = 'ui';
+      payload_.confirmationType = 'bitcoinSendTransactionRequestAfterConfirmation';
+      const [message, name] = [(0, _i18next.t)('Enable {{chain}} network on the extension and try again', {
+        replace: {
+          chain: chainInfo.name
+        }
+      }), (0, _i18next.t)('Network not enabled')];
+      const error = new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.INVALID_PARAMS, message, undefined, name);
+      console.error(error);
+      errors.push(error);
+    } else {
+      handleError(message);
+    }
+  }
+  const to = transactionParams.recipients.map(value => {
+    const amount = autoFormatNumber(value.amount);
+    totalValue = totalValue.plus(amount);
+    return {
+      ...value,
+      amount
+    };
+  });
+  if (new _bignumber.default(freeBalance.value).lte(totalValue)) {
+    handleError((0, _i18next.t)('insufficient balance'));
+  }
+  const sendTransactionRequest = {
+    networkKey,
+    address,
+    canSign: !pair.meta.isExternal,
+    value: totalValue.toString(),
+    to,
+    tokenSlug: tokenInfo.slug
+  };
+  resolve({
+    ...payload_,
+    errors,
+    payloadAfterValidated: sendTransactionRequest
+  });
+  return promise;
+}
+
+// ====== Bitcoin ======
+
 function convertErrorMessage(message_, name) {
   const message = message_.toLowerCase();
 
   // Network error
-  if (message.includes('connection error') || message.includes('connection not open') || message.includes('connection timeout') || message.includes('can not active chain') || message.includes('invalid json rpc')) {
+  if (message.includes('connection error') || message.includes('connection not open') || message.includes('connection timeout') || message.includes('can not active chain') || message.includes('invalid json rpc') || message.includes('internet connection')) {
     return [(0, _i18next.t)('Re-enable the network or change RPC on the extension and try again'), (0, _i18next.t)('Unstable network connection')];
   }
   if (message.includes('network is currently not supported')) {
@@ -696,6 +1000,15 @@ function convertErrorMessage(message_, name) {
   if (message.includes('the sender address must be the ethereum address type')) {
     return [(0, _i18next.t)('The sender address must be the ethereum address type'), (0, _i18next.t)('Invalid address type')];
   }
+  if (message.includes('the sender address must be the ethereum address type')) {
+    return [(0, _i18next.t)('The sender address must be the bitcoin address type'), (0, _i18next.t)('Invalid address type')];
+  }
+  if (message.includes('account or the network is not matched')) {
+    return [(0, _i18next.t)('The account does not match the selected network'), (0, _i18next.t)('Invalid address type')];
+  }
+  if (message.includes('receiving address must be a single account')) {
+    return [(0, _i18next.t)('The receiving address must be a single account'), (0, _i18next.t)('Invalid recipient address')];
+  }
   if (message.includes('insufficient balance') || message.includes('insufficient funds')) {
     return [(0, _i18next.t)('Insufficient balance on the sender address. Top up your balance and try again'), (0, _i18next.t)('Unable to sign transaction')];
   }

package/cjs/core/logic-validation/transfer.js

@@ -328,6 +328,11 @@ async function estimateFeeForTransaction(validationResponse, transaction, chainI
   } = (0, _utils3._getChainNativeTokenBasicInfo)(chainInfo);
   estimateFee.decimals = decimals;
   estimateFee.symbol = symbol;
+  const {
+    address,
+    feeCustom,
+    feeOption
+  } = validationResponse;
   if (transaction) {
     try {
       if ((0, _helpers.isSubstrateTransaction)(transaction)) {
@@ -337,13 +342,28 @@ async function estimateFeeForTransaction(validationResponse, transaction, chainI
         estimateFee.value = transaction.estimateFee; // todo: might need to update logic estimate fee inside for future actions excluding normal transfer Ton and Jetton
       } else if ((0, _helpers.isCardanoTransaction)(transaction)) {
         estimateFee.value = transaction.estimateCardanoFee;
+      } else if ((0, _helpers.isBitcoinTransaction)(transaction)) {
+        const feeCombine = (0, _utils5.combineBitcoinFee)(feeInfo, feeOption, feeCustom);
+        const recipients = [];
+        for (const txOutput of transaction.txOutputs) {
+          txOutput.address && recipients.push(txOutput.address);
+        }
+
+        // TODO: Need review
+        const sizeInfo = (0, _utils5.getSizeInfo)({
+          inputLength: transaction.inputCount,
+          recipients: recipients,
+          sender: address
+        });
+        estimateFee.value = Math.ceil(feeCombine.feeRate * sizeInfo.txVBytes).toString();
       } else {
-        const gasLimit = transaction.gas || (await evmApi.api.eth.estimateGas(transaction));
+        const _transaction = transaction;
+        const gasLimit = _transaction.gas || (await evmApi.api.eth.estimateGas(_transaction));
         const feeCombine = (0, _utils5.combineEthFee)(feeInfo, validationResponse.feeOption, validationResponse.feeCustom);
-        if (transaction.maxFeePerGas) {
-          estimateFee.value = new _bignumber.default(transaction.maxFeePerGas.toString()).multipliedBy(gasLimit).toFixed(0);
-        } else if (transaction.gasPrice) {
-          estimateFee.value = new _bignumber.default(transaction.gasPrice.toString()).multipliedBy(gasLimit).toFixed(0);
+        if (_transaction.maxFeePerGas) {
+          estimateFee.value = new _bignumber.default(_transaction.maxFeePerGas.toString()).multipliedBy(gasLimit).toFixed(0);
+        } else if (_transaction.gasPrice) {
+          estimateFee.value = new _bignumber.default(_transaction.gasPrice.toString()).multipliedBy(gasLimit).toFixed(0);
         } else {
           if (feeCombine.maxFeePerGas) {
             const maxFee = new _bignumber.default(feeCombine.maxFeePerGas); // TODO: Need review

package/cjs/core/types.js

@@ -15,6 +15,7 @@ exports.ValidationCondition = ValidationCondition;
   ValidationCondition["IS_VALID_SUBSTRATE_ADDRESS_FORMAT"] = "IS_VALID_SUBSTRATE_ADDRESS_FORMAT";
   ValidationCondition["IS_VALID_TON_ADDRESS_FORMAT"] = "IS_VALID_TON_ADDRESS_FORMAT";
   ValidationCondition["IS_VALID_CARDANO_ADDRESS_FORMAT"] = "IS_VALID_CARDANO_ADDRESS_FORMAT";
+  ValidationCondition["IS_VALID_BITCOIN_ADDRESS_FORMAT"] = "IS_VALID_BITCOIN_ADDRESS_FORMAT";
   ValidationCondition["IS_NOT_DUPLICATE_ADDRESS"] = "IS_NOT_DUPLICATE_ADDRESS";
   ValidationCondition["IS_SUPPORT_LEDGER_ACCOUNT"] = "IS_SUPPORT_LEDGER_ACCOUNT";
 })(ValidationCondition || (exports.ValidationCondition = ValidationCondition = {}));

package/cjs/core/utils.js

@@ -10,6 +10,7 @@ exports._isNotNull = _isNotNull;
 exports._isSufficientToken = void 0;
 exports._isSupportLedgerAccount = _isSupportLedgerAccount;
 exports._isValidAddressForEcosystem = _isValidAddressForEcosystem;
+exports._isValidBitcoinAddressFormat = _isValidBitcoinAddressFormat;
 exports._isValidCardanoAddressFormat = _isValidCardanoAddressFormat;
 exports._isValidSubstrateAddressFormat = _isValidSubstrateAddressFormat;
 exports._isValidTonAddressFormat = _isValidTonAddressFormat;
@@ -23,6 +24,7 @@ var _utils = require("@subwallet/extension-base/services/balance-service/helpers
 var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
 var _utils3 = require("@subwallet/extension-base/utils");
 var _keyring = require("@subwallet/keyring");
+var _utils4 = require("@subwallet/keyring/utils");
 var _utilCrypto = require("@polkadot/util-crypto");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
@@ -73,7 +75,7 @@ function _isValidAddressForEcosystem(validateRecipientParams) {
     toAddress
   } = validateRecipientParams;
   if (!(0, _utils3.isAddressAndChainCompatible)(toAddress, destChainInfo)) {
-    if ((0, _utils2._isChainEvmCompatible)(destChainInfo) || (0, _utils2._isChainSubstrateCompatible)(destChainInfo) || (0, _utils2._isChainTonCompatible)(destChainInfo) || (0, _utils2._isChainCardanoCompatible)(destChainInfo)) {
+    if ((0, _utils2._isChainEvmCompatible)(destChainInfo) || (0, _utils2._isChainSubstrateCompatible)(destChainInfo) || (0, _utils2._isChainTonCompatible)(destChainInfo) || (0, _utils2._isChainCardanoCompatible)(destChainInfo) || (0, _utils2._isChainBitcoinCompatible)(destChainInfo)) {
       return 'Recipient address must be the same type as sender address';
     }
     return 'Unknown chain type';
@@ -114,6 +116,18 @@ function _isValidCardanoAddressFormat(validateRecipientParams) {
   }
   return '';
 }
+function _isValidBitcoinAddressFormat(validateRecipientParams) {
+  var _destChainInfo$bitcoi;
+  const {
+    destChainInfo,
+    toAddress
+  } = validateRecipientParams;
+  const addressInfo = (0, _utils4.validateBitcoinAddress)(toAddress) ? (0, _utils4.getBitcoinAddressInfo)(toAddress) : null;
+  if ((addressInfo === null || addressInfo === void 0 ? void 0 : addressInfo.network) !== ((_destChainInfo$bitcoi = destChainInfo.bitcoinInfo) === null || _destChainInfo$bitcoi === void 0 ? void 0 : _destChainInfo$bitcoi.bitcoinNetwork)) {
+    return `Recipient address must be a valid ${destChainInfo.name} address`;
+  }
+  return '';
+}
 function _isNotDuplicateAddress(validateRecipientParams) {
   const {
     fromAddress,