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

package/core/logic-validation/request.js

@@ -2,23 +2,26 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { typedSignatureHash } from '@metamask/eth-sig-util';
+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 { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
-import { CardanoProviderErrorType, EvmProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { BitcoinProviderErrorType, CardanoProviderErrorType, EvmProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
 import { BasicTxErrorType } from '@subwallet/extension-base/types';
 import { BN_ZERO, combineEthFee, createPromiseHandler, isSameAddress, reformatAddress, stripUrl, wait } from '@subwallet/extension-base/utils';
 import { validateAddressNetwork } from '@subwallet/extension-base/utils/cardano';
 import { isContractAddress, parseContractInput } from '@subwallet/extension-base/utils/eth/parseTransaction';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import { isCardanoAddress, isCardanoBaseAddress, isCardanoRewardAddress, isSubstrateAddress } from '@subwallet/keyring';
+import { getBitcoinAddressInfo } from '@subwallet/keyring/utils';
+import { isBitcoinAddress } from '@subwallet/keyring/utils/address/validate';
 import { keyring } from '@subwallet/ui-keyring';
 import { getSdkError } from '@walletconnect/utils';
 import BigN from 'bignumber.js';
 import BN from 'bn.js';
 import { t } from 'i18next';
 import Joi from 'joi';
-import { isString } from '@polkadot/util';
+import { isArray, isHex, isString } from '@polkadot/util';
 import { isEthereumAddress } from '@polkadot/util-crypto';
 export const joiValidate = Joi.object({
   types: Joi.object().pattern(Joi.string(),
@@ -151,6 +154,9 @@ export 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, t('This account is not supported for this action'), 'dApp', errors);
+        }
         payload.authInfo = authInfo;
       }
     } catch (e) {
@@ -159,6 +165,8 @@ export async function validationAuthMiddleware(koni, url, payload) {
   }
   return payload;
 }
+
+// ====== EVM ======
 export async function validationConnectMiddleware(koni, url, payload) {
   let currentChain;
   let autoActiveChain = false;
@@ -580,6 +588,11 @@ export async function validationAuthCardanoMiddleware(koni, url, payload) {
   }
   return payload;
 }
+
+// ====== EVM ======
+
+// ====== Cardano ======
+
 export async function validationCardanoSignDataMiddleware(koni, url, payload_) {
   const {
     address,
@@ -636,11 +649,295 @@ export async function validationCardanoSignDataMiddleware(koni, url, payload_) {
   });
   return promise;
 }
+
+// ====== Cardano ======
+
+// ====== Bitcoin ======
+
+export 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(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
+  };
+}
+export async function validationBitcoinSignMessageMiddleware(koni, url, payload_) {
+  const {
+    address,
+    errors,
+    pair: pair_
+  } = payload_;
+  const message = payload_.payloadAfterValidated;
+  const {
+    promise,
+    resolve
+  } = createPromiseHandler();
+  const handleError = message_ => {
+    payload_.errorPosition = 'ui';
+    payload_.confirmationType = 'bitcoinSignatureRequest';
+    const [message, name] = convertErrorMessage(message_);
+    const error = new BitcoinProviderError(BitcoinProviderErrorType.INVALID_PARAMS, message, undefined, name);
+    console.error(error);
+    errors.push(error);
+  };
+  if (address === '' || !message) {
+    handleError(t('not found address or payload to sign'));
+  }
+  if (!isBitcoinAddress(address)) {
+    handleError(t('Invalid bitcoin address'));
+  }
+  const pair = pair_ || keyring.getPair(address);
+  if (!pair) {
+    handleError(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;
+}
+export 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
+  } = createPromiseHandler();
+  const handleError = message_ => {
+    payload_.errorPosition = 'ui';
+    payload_.confirmationType = 'bitcoinSignPsbtRequest';
+    const [message, name] = convertErrorMessage(message_);
+    const error = new BitcoinProviderError(BitcoinProviderErrorType.INVALID_PARAMS, message, undefined, name);
+    console.error(error);
+    errors.push(error);
+  };
+  if (!(psbtParams.network === 'mainnet' || psbtParams.network === 'testnet')) {
+    handleError(t('Network to try this request is must be mainnet or testnet'));
+  }
+  if (!networkKey) {
+    handleError(t('Network unavailable. Please switch network or manually add network to wallet'));
+  }
+  if (!psbt || !address) {
+    handleError(t('Not found payload to sign'));
+  }
+  if (!isHex(`0x${psbt}`)) {
+    handleError(t('Psbt to be signed must be hex-encoded'));
+  }
+  if (!isBitcoinAddress(address)) {
+    handleError(t('Not found address'));
+  }
+  const addressInfo = getBitcoinAddressInfo(address);
+  if (psbtParams.network !== addressInfo.network) {
+    handleError(t('The account or the network is not matched'));
+  }
+  const payload = {
+    broadcast: !!broadcast,
+    network: networkKey,
+    signAtIndex: isArray(signAtIndex) && signAtIndex.length === 0 ? undefined : signAtIndex,
+    address,
+    allowedSighash,
+    autoFinalized
+  };
+  const hashPayload = '';
+  const pair = pair_ || 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;
+}
+export 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
+  } = createPromiseHandler();
+  const senderAccountInfo = getBitcoinAddressInfo(address);
+  const handleError = message_ => {
+    payload_.errorPosition = 'ui';
+    payload_.confirmationType = 'bitcoinSendTransactionRequestAfterConfirmation';
+    const [message, name] = convertErrorMessage(message_);
+    const error = new BitcoinProviderError(BitcoinProviderErrorType.INVALID_PARAMS, message, undefined, name);
+    console.error(error);
+    errors.push(error);
+  };
+  const autoFormatNumber = val => {
+    if (typeof val === 'string' && val.startsWith('0x')) {
+      return new BigN(val.replace('0x', ''), 16).toString();
+    } else if (typeof val === 'number') {
+      return val.toString();
+    }
+    return val;
+  };
+  if (transactionParams.network !== senderAccountInfo.network) {
+    handleError(t('The account or the network is not matched'));
+  }
+  if (!((_transactionParams$re = transactionParams.recipients) !== null && _transactionParams$re !== void 0 && _transactionParams$re.length)) {
+    handleError(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(t("we don't support multiple recipients yet. Please provide only one for now."));
+  }
+  if (transactionParams.recipients.filter(({
+    address,
+    amount
+  }) => !address || !amount).length > 0) {
+    throw new BitcoinProviderError(BitcoinProviderErrorType.INVALID_PARAMS);
+  }
+  const recipientAccountInfo = getBitcoinAddressInfo(transactionParams.recipients[0].address);
+  if (recipientAccountInfo.network !== transactionParams.network) {
+    handleError(t('invalid recipient address'));
+  }
+  if (transactionParams.recipients.length !== 1) {
+    handleError(t('receiving address must be a single account'));
+  }
+  if (address === transactionParams.recipients[0].address) {
+    handleError(t('must be different from sending address'));
+  }
+  const pair = pair_ || keyring.getPair(address);
+  if (!pair) {
+    handleError(t('unable to find account'));
+  }
+  const tokenInfo = koni.getNativeTokenInfo(networkKey);
+  let freeBalance = {
+    decimals: 0,
+    symbol: 'BTC',
+    value: '0'
+  };
+  let totalValue = new BigN('0');
+  try {
+    freeBalance = await koni.balanceService.getTransferableBalance(address, networkKey, tokenInfo.slug);
+  } catch (e) {
+    const message = e.message;
+    if (message.toLowerCase().includes(t('please enable network'))) {
+      const chainInfo = koni.chainService.getChainInfoByKey(networkKey);
+      payload_.errorPosition = 'ui';
+      payload_.confirmationType = 'bitcoinSendTransactionRequestAfterConfirmation';
+      const [message, name] = [t('Enable {{chain}} network on the extension and try again', {
+        replace: {
+          chain: chainInfo.name
+        }
+      }), t('Network not enabled')];
+      const error = new BitcoinProviderError(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 BigN(freeBalance.value).lte(totalValue)) {
+    handleError(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 ======
+
 export 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 [t('Re-enable the network or change RPC on the extension and try again'), t('Unstable network connection')];
   }
   if (message.includes('network is currently not supported')) {
@@ -675,6 +972,15 @@ export function convertErrorMessage(message_, name) {
   if (message.includes('the sender address must be the ethereum address type')) {
     return [t('The sender address must be the ethereum address type'), t('Invalid address type')];
   }
+  if (message.includes('the sender address must be the ethereum address type')) {
+    return [t('The sender address must be the bitcoin address type'), t('Invalid address type')];
+  }
+  if (message.includes('account or the network is not matched')) {
+    return [t('The account does not match the selected network'), t('Invalid address type')];
+  }
+  if (message.includes('receiving address must be a single account')) {
+    return [t('The receiving address must be a single account'), t('Invalid recipient address')];
+  }
   if (message.includes('insufficient balance') || message.includes('insufficient funds')) {
     return [t('Insufficient balance on the sender address. Top up your balance and try again'), t('Unable to sign transaction')];
   }

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

@@ -126,6 +126,8 @@ export default class KoniExtension {
     private approveSpending;
     private makeTransfer;
     private makeCrossChainTransfer;
+    private makeBitcoinDappTransferConfirmation;
+    private makePsbtTransferAfterConfirmation;
     private getTokensCanPayFee;
     private getAmountForPair;
     private evmNftSubmitTransaction;
@@ -145,6 +147,7 @@ export default class KoniExtension {
     private getAddressTransferableBalance;
     private getAddressTotalBalance;
     private subscribeMaxTransferable;
+    private subscribeTransferableWhenConfirmation;
     private subscribeAddressTransferableBalance;
     private substrateNftSubmitTransaction;
     private enableChains;