@subwallet/extension-base 1.3.41-0 → 1.3.43-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/core/logic-validation/transfer.d.ts

@@ -5,7 +5,7 @@ import { TransactionWarning } from '@subwallet/extension-base/background/warning
 import { FrameSystemAccountInfo } from '@subwallet/extension-base/core/substrate/types';
 import { _EvmApi, _SubstrateApi, _TonApi } from '@subwallet/extension-base/services/chain-service/types';
 import { OptionalSWTransaction, SWTransactionInput, SWTransactionResponse } from '@subwallet/extension-base/services/transaction-service/types';
-import { EvmFeeInfo } from '@subwallet/extension-base/types';
+import { FeeInfo } from '@subwallet/extension-base/types';
 import { KeyringPair } from '@subwallet/keyring/types';
 export declare function validateTransferRequest(tokenInfo: _ChainAsset, from: _Address, to: _Address, value: string | undefined, transferAll: boolean | undefined): TransactionError[];
 export declare function additionalValidateTransferForRecipient(sendingTokenInfo: _ChainAsset, nativeTokenInfo: _ChainAsset, extrinsicType: ExtrinsicType, receiverSendingTokenKeepAliveBalance: bigint, transferAmount: bigint, senderSendingTokenTransferable?: bigint, receiverSystemAccountInfo?: FrameSystemAccountInfo, isSendingTokenSufficient?: boolean): [TransactionWarning[], TransactionError[]];
@@ -13,7 +13,7 @@ export declare function validateXcmTransferRequest(destTokenInfo: _ChainAsset |
 export declare function checkSupportForFeature(validationResponse: SWTransactionResponse, blockedFeaturesList: string[], chainInfo: _ChainInfo): void;
 export declare function checkSupportForAction(validationResponse: SWTransactionResponse, blockedActionsMap: Record<ExtrinsicType, string[]>): void;
 export declare function checkSupportForTransaction(validationResponse: SWTransactionResponse, transaction: OptionalSWTransaction): void;
-export declare function estimateFeeForTransaction(validationResponse: SWTransactionResponse, transaction: OptionalSWTransaction, chainInfo: _ChainInfo, evmApi: _EvmApi, substrateApi: _SubstrateApi, priceMap: Record<string, number>, feeInfo: EvmFeeInfo, nativeTokenInfo: _ChainAsset, nonNativeTokenPayFeeInfo: _ChainAsset | undefined, isTransferLocalTokenAndPayThatTokenAsFee: boolean | undefined): Promise<FeeData>;
+export declare function estimateFeeForTransaction(validationResponse: SWTransactionResponse, transaction: OptionalSWTransaction, chainInfo: _ChainInfo, evmApi: _EvmApi, substrateApi: _SubstrateApi, priceMap: Record<string, number>, feeInfo: FeeInfo, nativeTokenInfo: _ChainAsset, nonNativeTokenPayFeeInfo: _ChainAsset | undefined, isTransferLocalTokenAndPayThatTokenAsFee: boolean | undefined): Promise<FeeData>;
 export declare function checkSigningAccountForTransaction(validationResponse: SWTransactionResponse, chainInfoMap: Record<string, _ChainInfo>): void;
 export declare function checkBalanceWithTransactionFee(validationResponse: SWTransactionResponse, transactionInput: SWTransactionInput, nativeTokenInfo: _ChainAsset, nativeTokenAvailable: AmountData): void;
 export declare function checkTonAddressBounceableAndAccountNotActive(tonApi: _TonApi, validationResponse: SWTransactionResponse): Promise<void>;

package/core/logic-validation/transfer.js

@@ -11,9 +11,9 @@ import { isBounceableAddress } from '@subwallet/extension-base/services/balance-
 import { _TRANSFER_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
 import { _getAssetDecimals, _getAssetPriceId, _getAssetSymbol, _getChainNativeTokenBasicInfo, _getContractAddressOfToken, _getTokenMinAmount, _isCIP26Token, _isNativeToken, _isNativeTokenBySlug, _isTokenEvmSmartContract, _isTokenTonSmartContract } from '@subwallet/extension-base/services/chain-service/utils';
 import { calculateToAmountByReservePool, FEE_COVERAGE_PERCENTAGE_SPECIAL_CASE } from '@subwallet/extension-base/services/fee-service/utils';
-import { isCardanoTransaction, isSubstrateTransaction, isTonTransaction } from '@subwallet/extension-base/services/transaction-service/helpers';
+import { isBitcoinTransaction, isCardanoTransaction, isSubstrateTransaction, isTonTransaction } from '@subwallet/extension-base/services/transaction-service/helpers';
 import { AccountSignMode, BasicTxErrorType, BasicTxWarningCode, TransferTxErrorType } from '@subwallet/extension-base/types';
-import { balanceFormatter, combineEthFee, formatNumber, pairToAccount } from '@subwallet/extension-base/utils';
+import { balanceFormatter, combineBitcoinFee, combineEthFee, formatNumber, getSizeInfo, pairToAccount } from '@subwallet/extension-base/utils';
 import { isCardanoAddress, isTonAddress } from '@subwallet/keyring';
 import { keyring } from '@subwallet/ui-keyring';
 import BigN from 'bignumber.js';
@@ -312,6 +312,11 @@ export async function estimateFeeForTransaction(validationResponse, transaction,
   } = _getChainNativeTokenBasicInfo(chainInfo);
   estimateFee.decimals = decimals;
   estimateFee.symbol = symbol;
+  const {
+    address,
+    feeCustom,
+    feeOption
+  } = validationResponse;
   if (transaction) {
     try {
       if (isSubstrateTransaction(transaction)) {
@@ -321,13 +326,28 @@ export async function estimateFeeForTransaction(validationResponse, transaction,
         estimateFee.value = transaction.estimateFee; // todo: might need to update logic estimate fee inside for future actions excluding normal transfer Ton and Jetton
       } else if (isCardanoTransaction(transaction)) {
         estimateFee.value = transaction.estimateCardanoFee;
+      } else if (isBitcoinTransaction(transaction)) {
+        const feeCombine = combineBitcoinFee(feeInfo, feeOption, feeCustom);
+        const recipients = [];
+        for (const txOutput of transaction.txOutputs) {
+          txOutput.address && recipients.push(txOutput.address);
+        }
+
+        // TODO: Need review
+        const sizeInfo = 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 = combineEthFee(feeInfo, validationResponse.feeOption, validationResponse.feeCustom);
-        if (transaction.maxFeePerGas) {
-          estimateFee.value = new BigN(transaction.maxFeePerGas.toString()).multipliedBy(gasLimit).toFixed(0);
-        } else if (transaction.gasPrice) {
-          estimateFee.value = new BigN(transaction.gasPrice.toString()).multipliedBy(gasLimit).toFixed(0);
+        if (_transaction.maxFeePerGas) {
+          estimateFee.value = new BigN(_transaction.maxFeePerGas.toString()).multipliedBy(gasLimit).toFixed(0);
+        } else if (_transaction.gasPrice) {
+          estimateFee.value = new BigN(_transaction.gasPrice.toString()).multipliedBy(gasLimit).toFixed(0);
         } else {
           if (feeCombine.maxFeePerGas) {
             const maxFee = new BigN(feeCombine.maxFeePerGas); // TODO: Need review

package/core/types.d.ts

@@ -8,6 +8,7 @@ export declare enum ValidationCondition {
     IS_VALID_SUBSTRATE_ADDRESS_FORMAT = "IS_VALID_SUBSTRATE_ADDRESS_FORMAT",
     IS_VALID_TON_ADDRESS_FORMAT = "IS_VALID_TON_ADDRESS_FORMAT",
     IS_VALID_CARDANO_ADDRESS_FORMAT = "IS_VALID_CARDANO_ADDRESS_FORMAT",
+    IS_VALID_BITCOIN_ADDRESS_FORMAT = "IS_VALID_BITCOIN_ADDRESS_FORMAT",
     IS_NOT_DUPLICATE_ADDRESS = "IS_NOT_DUPLICATE_ADDRESS",
     IS_SUPPORT_LEDGER_ACCOUNT = "IS_SUPPORT_LEDGER_ACCOUNT"
 }

package/core/types.js

@@ -9,6 +9,7 @@ export let 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 || (ValidationCondition = {}));

package/core/utils.d.ts

@@ -13,6 +13,7 @@ export declare function _isValidAddressForEcosystem(validateRecipientParams: Val
 export declare function _isValidSubstrateAddressFormat(validateRecipientParams: ValidateRecipientParams): string;
 export declare function _isValidTonAddressFormat(validateRecipientParams: ValidateRecipientParams): string;
 export declare function _isValidCardanoAddressFormat(validateRecipientParams: ValidateRecipientParams): string;
+export declare function _isValidBitcoinAddressFormat(validateRecipientParams: ValidateRecipientParams): string;
 export declare function _isNotDuplicateAddress(validateRecipientParams: ValidateRecipientParams): string;
 export declare function _isSupportLedgerAccount(validateRecipientParams: ValidateRecipientParams): string;
 export declare const _isSufficientToken: (tokenInfo: _ChainAsset, substrateApi: _SubstrateApi, sufficientChain: SufficientChainsDetails) => Promise<boolean>;

package/core/utils.js

@@ -5,9 +5,10 @@ import { _AssetType } from '@subwallet/chain-list/types';
 import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { BalanceAccountType } from '@subwallet/extension-base/core/substrate/types';
 import { tonAddressInfo } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/utils';
-import { _getTokenOnChainAssetId, _getXcmAssetMultilocation, _isBridgedToken, _isChainCardanoCompatible, _isChainEvmCompatible, _isChainSubstrateCompatible, _isChainTonCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getTokenOnChainAssetId, _getXcmAssetMultilocation, _isBridgedToken, _isChainBitcoinCompatible, _isChainCardanoCompatible, _isChainEvmCompatible, _isChainSubstrateCompatible, _isChainTonCompatible } from '@subwallet/extension-base/services/chain-service/utils';
 import { isAddressAndChainCompatible, isSameAddress, reformatAddress } from '@subwallet/extension-base/utils';
 import { isAddress, isCardanoTestnetAddress, isTonAddress } from '@subwallet/keyring';
+import { getBitcoinAddressInfo, validateBitcoinAddress } from '@subwallet/keyring/utils';
 import { isEthereumAddress } from '@polkadot/util-crypto';
 export function getStrictMode(type, extrinsicType) {
   if (type === BalanceAccountType.FrameSystemAccountInfo) {
@@ -55,7 +56,7 @@ export function _isValidAddressForEcosystem(validateRecipientParams) {
     toAddress
   } = validateRecipientParams;
   if (!isAddressAndChainCompatible(toAddress, destChainInfo)) {
-    if (_isChainEvmCompatible(destChainInfo) || _isChainSubstrateCompatible(destChainInfo) || _isChainTonCompatible(destChainInfo) || _isChainCardanoCompatible(destChainInfo)) {
+    if (_isChainEvmCompatible(destChainInfo) || _isChainSubstrateCompatible(destChainInfo) || _isChainTonCompatible(destChainInfo) || _isChainCardanoCompatible(destChainInfo) || _isChainBitcoinCompatible(destChainInfo)) {
       return 'Recipient address must be the same type as sender address';
     }
     return 'Unknown chain type';
@@ -96,6 +97,18 @@ export function _isValidCardanoAddressFormat(validateRecipientParams) {
   }
   return '';
 }
+export function _isValidBitcoinAddressFormat(validateRecipientParams) {
+  var _destChainInfo$bitcoi;
+  const {
+    destChainInfo,
+    toAddress
+  } = validateRecipientParams;
+  const addressInfo = validateBitcoinAddress(toAddress) ? 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 '';
+}
 export function _isNotDuplicateAddress(validateRecipientParams) {
   const {
     fromAddress,

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;
@@ -157,9 +160,11 @@ export default class KoniExtension {
     private subscribeConfirmations;
     private subscribeConfirmationsTon;
     private subscribeConfirmationsCardano;
+    private subscribeConfirmationsBitcoin;
     private completeConfirmation;
     private completeConfirmationTon;
     private completeConfirmationCardano;
+    private completeConfirmationBitcoin;
     private getNetworkJsonByChainId;
     private parseSubstrateTransaction;
     private parseEVMRLP;