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

package/background/KoniTypes.d.ts

@@ -7,7 +7,6 @@ import { RequestOptimalTransferProcess } from '@subwallet/extension-base/service
 import { CardanoBalanceItem } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/cardano/types';
 import { CardanoTransactionConfig } from '@subwallet/extension-base/services/balance-service/transfer/cardano-transfer';
 import { TonTransactionConfig } from '@subwallet/extension-base/services/balance-service/transfer/ton-transfer';
-import { BitcoinApiStrategy } from '@subwallet/extension-base/services/chain-service/handler/bitcoin/strategy/types';
 import { _CHAIN_VALIDATION_ERROR } from '@subwallet/extension-base/services/chain-service/handler/types';
 import { _ChainState, _EvmApi, _NetworkUpsertParams, _SubstrateApi, _ValidateCustomAssetRequest, _ValidateCustomAssetResponse, EnableChainParams, EnableMultiChainParams } from '@subwallet/extension-base/services/chain-service/types';
 import { TokenPayFeeInfo } from '@subwallet/extension-base/services/fee-service/interfaces';
@@ -18,15 +17,14 @@ import { CrowdloanContributionsResponse } from '@subwallet/extension-base/servic
 import { BitcoinTransactionData, SWTransactionResponse, SWTransactionResult } from '@subwallet/extension-base/services/transaction-service/types';
 import { WalletConnectNotSupportRequest, WalletConnectSessionRequest } from '@subwallet/extension-base/services/wallet-connect-service/types';
 import { AccountChainType, AccountJson, AccountsWithCurrentAddress, AddressJson, BalanceJson, BaseRequestSign, BuyServiceInfo, BuyTokenInfo, CommonOptimalTransferPath, CurrentAccountInfo, EarningRewardHistoryItem, EarningRewardJson, EarningStatus, HandleYieldStepParams, InternalRequestSign, LeavePoolAdditionalData, NominationPoolInfo, OptimalYieldPath, OptimalYieldPathParams, RequestAccountBatchExportV2, RequestAccountCreateSuriV2, RequestAccountNameValidate, RequestAccountProxyEdit, RequestAccountProxyForget, RequestBatchJsonGetAccountInfo, RequestBatchRestoreV2, RequestBounceableValidate, RequestChangeAllowOneSign, RequestChangeTonWalletContractVersion, RequestCheckCrossChainTransfer, RequestCheckPublicAndSecretKey, RequestCheckTransfer, RequestCrossChainTransfer, RequestDeriveCreateMultiple, RequestDeriveCreateV3, RequestDeriveValidateV2, RequestEarlyValidateYield, RequestEarningSlippage, RequestExportAccountProxyMnemonic, RequestGetAllTonWalletContractVersion, RequestGetAmountForPair, RequestGetDeriveAccounts, RequestGetDeriveSuggestion, RequestGetTokensCanPayFee, RequestGetYieldPoolTargets, RequestInputAccountSubscribe, RequestJsonGetAccountInfo, RequestJsonRestoreV2, RequestMetadataHash, RequestMnemonicCreateV2, RequestMnemonicValidateV2, RequestPrivateKeyValidateV2, RequestShortenMetadata, RequestStakeCancelWithdrawal, RequestStakeClaimReward, RequestSubmitProcessTransaction, RequestSubscribeProcessById, RequestTransfer, RequestUnlockDotCheckCanMint, RequestUnlockDotSubscribeMintedData, RequestYieldLeave, RequestYieldStepSubmit, RequestYieldWithdrawal, ResponseAccountBatchExportV2, ResponseAccountCreateSuriV2, ResponseAccountNameValidate, ResponseBatchJsonGetAccountInfo, ResponseCheckPublicAndSecretKey, ResponseDeriveValidateV2, ResponseEarlyValidateYield, ResponseExportAccountProxyMnemonic, ResponseGetAllTonWalletContractVersion, ResponseGetDeriveAccounts, ResponseGetDeriveSuggestion, ResponseGetYieldPoolTargets, ResponseInputAccountSubscribe, ResponseJsonGetAccountInfo, ResponseMetadataHash, ResponseMnemonicCreateV2, ResponseMnemonicValidateV2, ResponsePrivateKeyValidateV2, ResponseShortenMetadata, ResponseSubscribeProcessAlive, ResponseSubscribeProcessById, StorageDataInterface, SubmitYieldStepData, SubnetYieldPositionInfo, SwapPair, SwapQuoteResponse, SwapRequest, SwapRequestResult, SwapRequestV2, SwapSubmitParams, SwapTxData, TokenSpendingApprovalParams, UnlockDotTransactionNft, UnstakingStatus, ValidateSwapProcessParams, ValidateYieldProcessParams, YieldPoolInfo, YieldPoolType, YieldPositionInfo } from '@subwallet/extension-base/types';
-import { RequestSubmitSignPsbtTransfer, RequestSubmitTransfer, RequestSubmitTransferWithId, RequestSubscribeTransfer, ResponseSubscribeTransfer } from '@subwallet/extension-base/types/balance/transfer';
+import { RequestSubmitSignPsbtTransfer, RequestSubmitTransfer, RequestSubmitTransferWithId, RequestSubscribeTransfer, ResponseSubscribeTransfer, ResponseSubscribeTransferConfirmation } from '@subwallet/extension-base/types/balance/transfer';
 import { RequestClaimBridge } from '@subwallet/extension-base/types/bridge';
 import { GetNotificationParams, RequestIsClaimedPolygonBridge, RequestSwitchStatusParams } from '@subwallet/extension-base/types/notification';
 import { InjectedAccount, InjectedAccountWithMeta, MetadataDefBase } from '@subwallet/extension-inject/types';
-import { KeyringPair$Meta } from '@subwallet/keyring/types';
+import { BitcoinAddressType, KeyringPair$Meta } from '@subwallet/keyring/types';
 import { KeyringOptions } from '@subwallet/ui-keyring/options/types';
 import { KeyringAddress } from '@subwallet/ui-keyring/types';
 import { SessionTypes } from '@walletconnect/types/dist/types/sign-client/session';
-import { Psbt } from 'bitcoinjs-lib';
 import BN from 'bn.js';
 import { DexieExportJsonStructure } from 'dexie-export-import';
 import Web3 from 'web3';
@@ -886,9 +884,10 @@ export interface EvmSignRequest {
     canSign: boolean;
 }
 export interface BitcoinSignRequest {
-    account: AccountJson;
+    address: string;
     hashPayload: string;
     canSign: boolean;
+    errors?: ErrorValidation[];
 }
 export interface BitcoinRecipientTransactionParams {
     address: string;
@@ -899,16 +898,19 @@ export interface BitcoinSendTransactionParams {
     network: 'mainnet' | 'testnet';
     recipients: BitcoinRecipientTransactionParams[];
 }
+export interface BitcoinSendTransactionResult {
+    txid: string;
+}
 export interface PsbtTransactionArg {
     address?: string;
     amount?: string;
 }
-export interface BitcoinSignPsbtPayload extends Omit<BitcoinSignPsbtRawRequest, 'psbt'> {
+export interface BitcoinSignPsbtPayload extends Omit<BitcoinSignPsbtParams, 'psbt'> {
     txInput: PsbtTransactionArg[];
     txOutput: PsbtTransactionArg[];
     to: string;
     value: string;
-    psbt: Psbt;
+    psbt: string;
     tokenSlug: string;
 }
 declare enum SignatureHash {
@@ -918,13 +920,14 @@ declare enum SignatureHash {
     SINGLE = 3,
     ANYONECANPAY = 128
 }
-export interface BitcoinSignPsbtRawRequest {
+export interface BitcoinSignPsbtParams {
     psbt: string;
     allowedSighash?: SignatureHash[];
     signAtIndex?: number | number[];
     broadcast?: boolean;
+    autoFinalized?: boolean;
     network: string;
-    account: string;
+    address: string;
 }
 export interface TonSignRequest {
     account: AccountJson;
@@ -1026,17 +1029,29 @@ export interface CardanoTransactionDappConfig {
     id: string;
 }
 export declare type ResponseCardanoSignTransaction = Cbor;
-export declare type BitcoinSendTransactionRequest = BitcoinSignRequest;
+export declare type BitcoinSendTransactionRequest = BitcoinSignRequest & BitcoinTransactionConfig;
 export interface BitcoinSignatureRequest extends BitcoinSignRequest {
     id: string;
     payload: unknown;
     payloadJson: any;
 }
-export interface BitcoinAppState {
-    networkKey?: string;
-    isConnected?: boolean;
-    strategy?: BitcoinApiStrategy;
-    listenEvents?: string[];
+export declare type BitcoinDAppAddress = {
+    address: string;
+    publicKey?: string;
+    tweakedPublicKey?: string;
+    derivationPath?: string;
+    isTestnet?: boolean;
+    type: BitcoinAddressType;
+};
+export declare type BitcoinRequestGetAddressesResult = BitcoinDAppAddress[];
+export interface BitcoinSignMessageParams {
+    message: string;
+    address: string;
+}
+export interface BitcoinSignMessageResult {
+    signature: string;
+    message: string;
+    address: string;
 }
 export declare type TonSendTransactionRequest = TonTransactionConfig;
 export declare type CardanoSendTransactionRequest = CardanoTransactionConfig;
@@ -1062,12 +1077,7 @@ export interface BitcoinTransactionConfig {
     networkKey?: string;
     tokenSlug?: string;
 }
-export interface SignMessageBitcoinResult {
-    signature: string;
-    message: string;
-    address: string;
-}
-export interface SignPsbtBitcoinResult {
+export interface BitcoinSignPsbtResult {
     psbt: string;
     txid?: string;
 }
@@ -1129,11 +1139,11 @@ export interface ConfirmationDefinitionsCardano {
     cardanoWatchTransactionRequest: [ConfirmationsQueueItem<CardanoWatchTransactionRequest>, ConfirmationResult<string>];
 }
 export interface ConfirmationDefinitionsBitcoin {
-    bitcoinSignatureRequest: [ConfirmationsQueueItem<BitcoinSignatureRequest>, ConfirmationResult<SignMessageBitcoinResult>];
+    bitcoinSignatureRequest: [ConfirmationsQueueItem<BitcoinSignatureRequest>, ConfirmationResult<BitcoinSignMessageResult>];
     bitcoinSendTransactionRequest: [ConfirmationsQueueItem<BitcoinSendTransactionRequest>, ConfirmationResult<string>];
     bitcoinSendTransactionRequestAfterConfirmation: [ConfirmationsQueueItem<BitcoinSendTransactionRequest>, ConfirmationResult<string>];
     bitcoinWatchTransactionRequest: [ConfirmationsQueueItem<BitcoinWatchTransactionRequest>, ConfirmationResult<string>];
-    bitcoinSignPsbtRequest: [ConfirmationsQueueItem<BitcoinSignPsbtRequest>, ConfirmationResult<SignPsbtBitcoinResult>];
+    bitcoinSignPsbtRequest: [ConfirmationsQueueItem<BitcoinSignPsbtRequest>, ConfirmationResult<BitcoinSignPsbtResult>];
 }
 export declare type ConfirmationType = keyof ConfirmationDefinitions;
 export declare type ConfirmationTypeTon = keyof ConfirmationDefinitionsTon;
@@ -1920,6 +1930,7 @@ export interface KoniRequestSignatures {
     'pri(transaction.history.subscribe)': [RequestSubscribeHistory, ResponseSubscribeHistory, TransactionHistoryItem[]];
     'pri(transfer.getMaxTransferable)': [RequestMaxTransferable, AmountData];
     'pri(transfer.subscribe)': [RequestSubscribeTransfer, ResponseSubscribeTransfer, ResponseSubscribeTransfer];
+    'pri(transfer.confirmation.subscribe)': [RequestSubscribeTransfer, ResponseSubscribeTransferConfirmation, ResponseSubscribeTransferConfirmation];
     'pri(subscription.cancel)': [string, boolean];
     'pri(freeBalance.get)': [RequestFreeBalance, AmountData];
     'pri(freeBalance.subscribe)': [RequestFreeBalance, AmountDataWithId, AmountDataWithId];
@@ -1966,6 +1977,7 @@ export interface KoniRequestSignatures {
     'cardano(data.sign)': [RequestCardanoSignData, ResponseCardanoSignData];
     'cardano(transaction.sign)': [RequestCardanoSignTransaction, ResponseCardanoSignTransaction];
     'cardano(transaction.submit)': [Cbor, string];
+    'bitcoin(request)': [RequestArguments, unknown];
     'pri(evm.transaction.parse.input)': [RequestParseEvmContractInput, ResponseParseEvmContractInput];
     'pri(authorize.subscribe)': [null, AuthUrls, AuthUrls];
     'pri(signing.approve.passwordV2)': [RequestSigningApprovePasswordV2, boolean];

package/background/errors/BitcoinProviderError.d.ts

@@ -2,5 +2,5 @@ import { SWError } from '@subwallet/extension-base/background/errors/SWError';
 import { BitcoinProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
 export declare class BitcoinProviderError extends SWError {
     errorType: BitcoinProviderErrorType;
-    constructor(errorType: BitcoinProviderErrorType, errMessage?: string, data?: unknown);
+    constructor(errorType: BitcoinProviderErrorType, errMessage?: string, data?: unknown, name?: string);
 }

package/background/errors/BitcoinProviderError.js

@@ -35,13 +35,13 @@ const defaultErrorMap = {
   }
 };
 export class BitcoinProviderError extends SWError {
-  constructor(errorType, errMessage, data) {
+  constructor(errorType, errMessage, data, name) {
     const {
       code,
       message
     } = defaultErrorMap[errorType];
     const finalMessage = errMessage || t(message || '') || errorType;
-    super(errorType, finalMessage, code, data);
+    super(errorType, finalMessage, code, data, name);
     this.errorType = errorType;
   }
 }

package/background/types.d.ts

@@ -113,7 +113,7 @@ export interface TransportRequestMessage<TMessageType extends MessageTypes> {
     origin: 'page' | 'extension' | string;
     request: RequestTypes[TMessageType];
 }
-export declare type AccountAuthType = 'substrate' | 'evm' | 'ton' | 'cardano';
+export declare type AccountAuthType = 'substrate' | 'evm' | 'ton' | 'cardano' | 'bitcoin';
 export interface RequestAuthorizeTab {
     origin: string;
     accountAuthTypes?: AccountAuthType[];

package/cjs/background/errors/BitcoinProviderError.js

@@ -41,13 +41,13 @@ const defaultErrorMap = {
   }
 };
 class BitcoinProviderError extends _SWError.SWError {
-  constructor(errorType, errMessage, data) {
+  constructor(errorType, errMessage, data, name) {
     const {
       code,
       message
     } = defaultErrorMap[errorType];
     const finalMessage = errMessage || (0, _i18next.t)(message || '') || errorType;
-    super(errorType, finalMessage, code, data);
+    super(errorType, finalMessage, code, data, name);
     this.errorType = errorType;
   }
 }

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')];
   }