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

package/koni/background/handlers/Extension.js

@@ -8,7 +8,7 @@ import { TransactionError } from '@subwallet/extension-base/background/errors/Tr
 import { withErrorLog } from '@subwallet/extension-base/background/handlers/helpers';
 import { createSubscription } from '@subwallet/extension-base/background/handlers/subscriptions';
 import { CampaignDataType, ChainType, ExternalRequestPromiseStatus, ExtrinsicType, MantaPayEnableMessage, StakingType } from '@subwallet/extension-base/background/KoniTypes';
-import { _SUPPORT_TOKEN_PAY_FEE_GROUP, ALL_ACCOUNT_KEY, LATEST_SESSION } from '@subwallet/extension-base/constants';
+import { _SUPPORT_TOKEN_PAY_FEE_GROUP, ALL_ACCOUNT_KEY, BTC_DUST_AMOUNT, LATEST_SESSION } from '@subwallet/extension-base/constants';
 import { additionalValidateTransferForRecipient, validateTransferRequest, validateXcmMinAmountToMythos, validateXcmTransferRequest } from '@subwallet/extension-base/core/logic-validation/transfer';
 import { _isSnowBridgeXcm } from '@subwallet/extension-base/core/substrate/xcm-parser';
 import { _isSufficientToken } from '@subwallet/extension-base/core/utils';
@@ -38,7 +38,7 @@ import { _isPosChainBridge, getClaimPosBridge } from '@subwallet/extension-base/
 import { estimateXcmFee } from '@subwallet/extension-base/services/balance-service/transfer/xcm/utils';
 import { _DEFAULT_MANTA_ZK_CHAIN, _MANTA_ZK_CHAIN_GROUP, _ZK_ASSET_PREFIX } from '@subwallet/extension-base/services/chain-service/constants';
 import { _ChainConnectionStatus } from '@subwallet/extension-base/services/chain-service/types';
-import { _getAssetDecimals, _getAssetSymbol, _getChainNativeTokenBasicInfo, _getContractAddressOfToken, _getEvmChainId, _isAssetSmartContractNft, _isChainEnabled, _isChainEvmCompatible, _isChainSubstrateCompatible, _isCustomAsset, _isLocalToken, _isMantaZkAsset, _isNativeToken, _isNativeTokenBySlug, _isPureEvmChain, _isTokenEvmSmartContract, _isTokenTransferredByBitcoin, _isTokenTransferredByCardano, _isTokenTransferredByEvm, _isTokenTransferredByTon } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getAssetDecimals, _getAssetSymbol, _getChainNativeTokenBasicInfo, _getContractAddressOfToken, _getEvmChainId, _isAssetSmartContractNft, _isChainBitcoinCompatible, _isChainEnabled, _isChainEvmCompatible, _isChainSubstrateCompatible, _isCustomAsset, _isLocalToken, _isMantaZkAsset, _isNativeToken, _isNativeTokenBySlug, _isPureEvmChain, _isTokenEvmSmartContract, _isTokenTransferredByBitcoin, _isTokenTransferredByCardano, _isTokenTransferredByEvm, _isTokenTransferredByTon } from '@subwallet/extension-base/services/chain-service/utils';
 import { calculateToAmountByReservePool } from '@subwallet/extension-base/services/fee-service/utils';
 import { batchExtrinsicSetFeeHydration, getAssetHubTokensCanPayFee, getHydrationTokensCanPayFee } from '@subwallet/extension-base/services/fee-service/utils/tokenPayFee';
 import { EXTENSION_REQUEST_URL } from '@subwallet/extension-base/services/request-service/constants';
@@ -47,11 +47,12 @@ import { isProposalExpired, isSupportWalletConnectChain, isSupportWalletConnectN
 import { SWStorage } from '@subwallet/extension-base/storage';
 import { AccountsStore } from '@subwallet/extension-base/stores';
 import { AccountSignMode, BasicTxErrorType, BasicTxWarningCode, CommonStepType, EarningProcessType, ProcessType, StakingTxErrorType, StepStatus, SwapFeeType, YieldPoolType, YieldStepType } from '@subwallet/extension-base/types';
-import { _analyzeAddress, calculateMaxTransferable, combineAllAccountProxy, createPromiseHandler, createTransactionFromRLP, detectTransferTxType, getAccountSignMode, isSameAddress, MODULE_SUPPORT, reformatAddress, signatureToHex, transformAccounts, transformAddresses, uniqueStringArray } from '@subwallet/extension-base/utils';
+import { _analyzeAddress, calculateMaxTransferable, combineAllAccountProxy, combineBitcoinFee, createPromiseHandler, createTransactionFromRLP, detectTransferTxType, filterUneconomicalUtxos, getAccountSignMode, getSizeInfo, getTransferableBitcoinUtxos, isSameAddress, MODULE_SUPPORT, reformatAddress, signatureToHex, transformAccounts, transformAddresses, uniqueStringArray } from '@subwallet/extension-base/utils';
 import { parseContractInput, parseEvmRlp } from '@subwallet/extension-base/utils/eth/parseTransaction';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import { getKeypairTypeByAddress, isAddress, isCardanoAddress, isSubstrateAddress, isTonAddress } from '@subwallet/keyring';
-import { CardanoKeypairTypes, EthereumKeypairTypes, SubstrateKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
+import { BitcoinKeypairTypes, CardanoKeypairTypes, EthereumKeypairTypes, SubstrateKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
+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';
@@ -566,7 +567,8 @@ export default class KoniExtension {
       evm: EthereumKeypairTypes,
       substrate: SubstrateKeypairTypes,
       ton: TonKeypairTypes,
-      cardano: CardanoKeypairTypes
+      cardano: CardanoKeypairTypes,
+      bitcoin: BitcoinKeypairTypes
     };
     return !!accountAuthTypes && accountAuthTypes.some(authType => {
       var _validTypes$authType;
@@ -668,7 +670,8 @@ export default class KoniExtension {
       substrate: 'substrateInfo',
       evm: 'evmInfo',
       cardano: 'cardanoInfo',
-      ton: 'tonInfo'
+      ton: 'tonInfo',
+      bitcoin: 'bitcoinInfo'
     };
     const typeInfoKey = typeInfoMap[authSwitchNetworkType];
     if (!typeInfoKey || !chainInfo[typeInfoKey]) {
@@ -1351,6 +1354,7 @@ export default class KoniExtension {
         if (transferAll) {
           inputData.value = transferAmount.value;
         }
+        console.log('PSPT transaction', transaction.toHex());
       } else {
         const substrateApi = this.#koniState.getSubstrateApi(chain);
         [transaction, transferAmount.value] = await createSubstrateExtrinsic({
@@ -1662,6 +1666,190 @@ export default class KoniExtension {
       eventsHandler: eventsHandler
     });
   }
+  async makeBitcoinDappTransferConfirmation(inputData) {
+    const {
+      chain,
+      feeCustom,
+      feeOption,
+      from,
+      id,
+      to,
+      tokenSlug,
+      transferAll,
+      value
+    } = inputData;
+    const transferTokenInfo = this.#koniState.chainService.getAssetBySlug(tokenSlug);
+    const errors = validateTransferRequest(transferTokenInfo, from, to, value, transferAll);
+    const warnings = [];
+    const chainInfo = this.#koniState.getChainInfo(chain);
+    const nativeTokenInfo = this.#koniState.getNativeTokenInfo(chain);
+    const nativeTokenSlug = nativeTokenInfo.slug;
+    const isTransferNativeToken = nativeTokenSlug === tokenSlug;
+    let chainType = ChainType.BITCOIN;
+    const tokenBaseAmount = {
+      value: '0',
+      symbol: transferTokenInfo.symbol,
+      decimals: transferTokenInfo.decimals || 0
+    };
+    const transferAmount = {
+      ...tokenBaseAmount
+    };
+    let transaction;
+    let overrideFeeCustom;
+    let calculatedBitcoinFeeRate;
+
+    // Get native token amount
+    const freeBalance = await this.getAddressTransferableBalance({
+      address: from,
+      networkKey: chain,
+      token: tokenSlug
+    });
+    const txVal = transferAll ? freeBalance.value : value || '0';
+    try {
+      if (_isChainBitcoinCompatible(chainInfo)) {
+        chainType = ChainType.BITCOIN;
+        const bitcoinApi = this.#koniState.getBitcoinApi(chain); // Get Bitcoin API map
+        const network = chainInfo.isTestnet ? bitcoin.networks.testnet : bitcoin.networks.bitcoin;
+        const feeInfo = await this.#koniState.feeService.subscribeChainFee(getId(), chain, 'bitcoin');
+        [transaction, transferAmount.value, calculatedBitcoinFeeRate] = await createBitcoinTransaction({
+          bitcoinApi,
+          chain,
+          from,
+          feeInfo,
+          to,
+          transferAll: transferAll,
+          value: txVal,
+          network: network
+        });
+        if (calculatedBitcoinFeeRate) {
+          const feeRate = parseFloat(calculatedBitcoinFeeRate);
+          if (!isNaN(feeRate)) {
+            overrideFeeCustom = {
+              feeRate
+            };
+          }
+        }
+      }
+    } catch (e) {
+      const error = e;
+      if (error.message.includes('transfer amount exceeds balance')) {
+        error.message = t('Insufficient balance');
+      }
+      throw error;
+    }
+    const transferNativeAmount = isTransferNativeToken ? transferAmount.value : '0';
+    return this.#koniState.transactionService.handleTransactionAfterConfirmation({
+      id,
+      errors,
+      warnings,
+      address: from,
+      chain: chain,
+      feeCustom: overrideFeeCustom || feeCustom,
+      feeOption: overrideFeeCustom ? 'custom' : feeOption,
+      chainType,
+      transferNativeAmount,
+      transaction,
+      data: inputData,
+      extrinsicType: isTransferNativeToken ? ExtrinsicType.TRANSFER_BALANCE : ExtrinsicType.TRANSFER_TOKEN,
+      ignoreWarnings: [],
+      isTransferAll: isTransferNativeToken ? transferAll : false,
+      edAsWarning: isTransferNativeToken
+    });
+  }
+  async makePsbtTransferAfterConfirmation(inputData_) {
+    var _txOutput$;
+    const {
+      chain,
+      from,
+      id,
+      psbt,
+      tokenSlug,
+      txInput,
+      txOutput,
+      value
+    } = inputData_;
+    let inputAmount = new BigN(0);
+    const transferTokenInfo = this.#koniState.chainService.getAssetBySlug(tokenSlug);
+    const totalUtxoInput = txInput.reduce((total, {
+      address,
+      amount
+    }) => {
+      if (!address || !amount) {
+        return total;
+      }
+      if (isSameAddress(address, from)) {
+        inputAmount = new BigN(amount);
+      }
+      return total.plus(new BigN(amount || 0));
+    }, new BigN(0));
+    const totalUtxoOutput = txOutput.reduce((total, {
+      address,
+      amount
+    }) => {
+      if (!address || !amount) {
+        return total;
+      }
+      return total.plus(new BigN(amount));
+    }, new BigN(0));
+    const estimateFeeValue = totalUtxoInput.minus(totalUtxoOutput).toString();
+    const errors = validateTransferRequest(transferTokenInfo, from, ((_txOutput$ = txOutput[0]) === null || _txOutput$ === void 0 ? void 0 : _txOutput$.address) || '', value, false);
+    const warnings = [];
+    const chainInfo = this.#koniState.getChainInfo(chain);
+    const {
+      decimals,
+      symbol
+    } = _getChainNativeTokenBasicInfo(chainInfo);
+    const estimateFee = {
+      symbol,
+      decimals,
+      value: estimateFeeValue,
+      tooHigh: false
+    };
+    const nativeTokenInfo = this.#koniState.getNativeTokenInfo(chain);
+    const nativeTokenSlug = nativeTokenInfo.slug;
+    const isTransferNativeToken = nativeTokenSlug === tokenSlug;
+    const chainType = ChainType.BITCOIN;
+    const bitcoinNetwork = chainInfo.isTestnet ? bitcoin.networks.testnet : bitcoin.networks.bitcoin;
+    const psbtGenerate = bitcoin.Psbt.fromHex(psbt, {
+      network: bitcoinNetwork
+    });
+    const tokenBaseAmount = {
+      value: inputData_.value,
+      symbol: transferTokenInfo.symbol,
+      decimals: transferTokenInfo.decimals || 0
+    };
+    const transferAmount = {
+      ...tokenBaseAmount
+    };
+
+    // Get native token amount
+    const freeBalance = await this.getAddressTransferableBalance({
+      address: from,
+      networkKey: chain,
+      token: tokenSlug
+    });
+    if (new BigN(freeBalance.value).lt(inputAmount)) {
+      throw new Error(t('Insufficient balance'));
+    }
+    const transferNativeAmount = isTransferNativeToken ? transferAmount.value : '0';
+    return this.#koniState.transactionService.handleTransactionAfterConfirmation({
+      id,
+      errors,
+      warnings,
+      address: from,
+      chain: chain,
+      estimateFee,
+      chainType,
+      transferNativeAmount,
+      transaction: psbtGenerate,
+      data: inputData_,
+      extrinsicType: isTransferNativeToken ? ExtrinsicType.TRANSFER_BALANCE : ExtrinsicType.TRANSFER_TOKEN,
+      ignoreWarnings: [],
+      isTransferAll: false,
+      edAsWarning: isTransferNativeToken,
+      skipFeeRecalculation: true
+    });
+  }
   async getTokensCanPayFee(request) {
     var _tokensHasBalanceInfo;
     const {
@@ -1982,6 +2170,135 @@ export default class KoniExtension {
     });
     return calculateMaxTransferable(id, _request, freeBalance, fee);
   }
+  async subscribeTransferableWhenConfirmation({
+    address,
+    chain,
+    feeCustom,
+    feeOption: _feeOptions,
+    to,
+    token,
+    value
+  }, id, port) {
+    const cb = createSubscription(id, port);
+    const freeBalanceSubject = new Subject();
+    const feeSubject = new Subject();
+    const feeType = 'bitcoin';
+    let error;
+    const convertData = async (freeBalance, fee, feeOption, feeCustom) => {
+      let estimatedFee = '0';
+      let feeOptions = null;
+      const amount = parseInt(value || '0');
+      const neededUtxos = [];
+      let sum = new BigN(0);
+      let sizeInfo = null;
+      try {
+        const _fee = fee;
+        const _feeCustom = feeCustom;
+        const combineFee = combineBitcoinFee(_fee, _feeOptions, _feeCustom);
+        const bitcoinApi = this.#koniState.chainService.getBitcoinApi(chain);
+        let utxos = await getTransferableBitcoinUtxos(bitcoinApi, address);
+        const recipients = [address, to || address];
+        utxos = utxos.sort((a, b) => b.value - a.value);
+        const filteredUtxos = filterUneconomicalUtxos({
+          utxos,
+          feeRate: combineFee.feeRate,
+          recipients,
+          sender: address
+        });
+        for (const utxo of filteredUtxos) {
+          sizeInfo = getSizeInfo({
+            inputLength: neededUtxos.length,
+            sender: address,
+            recipients
+          });
+          const currentValue = new BigN(amount).plus(Math.ceil(sizeInfo.txVBytes * combineFee.feeRate));
+          if (sum.gte(currentValue)) {
+            break;
+          }
+          sum = sum.plus(utxo.value);
+          neededUtxos.push(utxo);
+        }
+
+        // re calculate
+        sizeInfo = getSizeInfo({
+          inputLength: neededUtxos.length,
+          sender: address,
+          recipients
+        });
+        if (!sizeInfo) {
+          sizeInfo = getSizeInfo({
+            inputLength: utxos.length || 1,
+            sender: address,
+            recipients
+          });
+        }
+        estimatedFee = Math.ceil(sizeInfo.txVBytes * combineFee.feeRate).toString();
+        const amountLeft = sum.minus(amount).minus(new BigN(estimatedFee));
+        if (amountLeft.lte(0)) {
+          error = 'Insufficient balance';
+        } else {
+          const senderAddressInfo = getBitcoinAddressInfo(address);
+          const dustLimit = BTC_DUST_AMOUNT[senderAddressInfo.type] || 546;
+          if (amountLeft.lte(dustLimit)) {
+            sizeInfo = getSizeInfo({
+              inputLength: neededUtxos.length,
+              sender: address,
+              recipients: [to || address]
+            });
+            estimatedFee = sum.minus(amount).toString();
+          }
+        }
+        feeOptions = {
+          ...fee,
+          vSize: sizeInfo.txVBytes,
+          estimatedFee
+        };
+      } catch (e) {
+        feeOptions = {
+          ...fee,
+          estimatedFee,
+          vSize: 0
+        };
+        error = e.message || e;
+        console.warn('Unable to estimate fee', e);
+      }
+      return {
+        feeOptions: feeOptions,
+        feeType,
+        error,
+        id
+      };
+    };
+    const subscription = combineLatest({
+      freeBalance: freeBalanceSubject,
+      fee: feeSubject
+    }).subscribe({
+      next: ({
+        fee,
+        freeBalance
+      }) => {
+        convertData(freeBalance, fee, _feeOptions, feeCustom).then(cb).catch(console.error);
+      }
+    });
+    const [unsubBalance, freeBalance] = await this.#koniState.balanceService.subscribeBalance(address, chain, token, 'transferable', ExtrinsicType.TRANSFER_BALANCE, data => {
+      freeBalanceSubject.next(data); // Must be called after subscription
+    });
+
+    const fee = await this.#koniState.feeService.subscribeChainFee(id, chain, feeType, data => {
+      feeSubject.next(data); // Must be called after subscription
+    });
+
+    const unsub = () => {
+      subscription.unsubscribe();
+      unsubBalance();
+      this.#koniState.feeService.unsubscribeChainFee(id, chain, feeType);
+    };
+    this.createUnsubscriptionHandle(id, unsub);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return convertData(freeBalance, fee, _feeOptions, feeCustom);
+  }
   async subscribeAddressTransferableBalance({
     address,
     extrinsicType,
@@ -2850,6 +3167,7 @@ export default class KoniExtension {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const {
           additionalValidator,
+          emitterTransaction,
           eventsHandler,
           step,
           transaction,
@@ -4640,6 +4958,8 @@ export default class KoniExtension {
         return await this.updateAssetSetting(request);
       case 'pri(transfer.subscribe)':
         return this.subscribeMaxTransferable(request, id, port);
+      case 'pri(transfer.confirmation.subscribe)':
+        return this.subscribeTransferableWhenConfirmation(request, id, port);
       case 'pri(freeBalance.get)':
         return this.getAddressTransferableBalance(request);
       case 'pri(freeBalance.subscribe)':
@@ -4658,6 +4978,10 @@ export default class KoniExtension {
       /// Transfer
       case 'pri(accounts.transfer)':
         return await this.makeTransfer(request);
+      case 'pri(accounts.bitcoin.dapp.transfer.confirmation)':
+        return await this.makeBitcoinDappTransferConfirmation(request);
+      case 'pri(accounts.psbt.transfer.confirmation)':
+        return await this.makePsbtTransferAfterConfirmation(request);
       case 'pri(accounts.crossChainTransfer)':
         return await this.makeCrossChainTransfer(request);
       case 'pri(accounts.getOptimalTransferProcess)':

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

@@ -1,7 +1,7 @@
 /// <reference types="chrome" />
 import * as CardanoWasm from '@emurgo/cardano-serialization-lib-nodejs';
 import { _AssetRef, _AssetType, _ChainAsset, _ChainInfo, _MultiChainAsset } from '@subwallet/chain-list/types';
-import { AddTokenRequestExternal, AmountData, ApiMap, AuthRequestV2, ChainStakingMetadata, ConfirmationsQueue, ConfirmationsQueueBitcoin, ConfirmationsQueueCardano, ConfirmationsQueueTon, CrowdloanItem, CrowdloanJson, EvmSendTransactionParams, ExternalRequestPromise, MantaPayConfig, MantaPaySyncState, NftCollection, NftItem, NftJson, NominatorMetadata, RequestAccountExportPrivateKey, RequestCardanoSignData, RequestCardanoSignTransaction, RequestConfirmationComplete, RequestConfirmationCompleteBitcoin, RequestConfirmationCompleteCardano, RequestConfirmationCompleteTon, RequestCrowdloanContributions, RequestSettingsType, ResponseAccountExportPrivateKey, ResponseCardanoSignData, ResponseCardanoSignTransaction, ServiceInfo, SingleModeJson, StakingItem, StakingJson, StakingRewardItem, StakingRewardJson, StakingType, UiSettings } from '@subwallet/extension-base/background/KoniTypes';
+import { AddTokenRequestExternal, AmountData, ApiMap, AuthRequestV2, BitcoinSendTransactionParams, BitcoinSignMessageParams, BitcoinSignMessageResult, BitcoinSignPsbtParams, BitcoinSignPsbtResult, ChainStakingMetadata, ConfirmationsQueue, ConfirmationsQueueBitcoin, ConfirmationsQueueCardano, ConfirmationsQueueTon, CrowdloanItem, CrowdloanJson, EvmSendTransactionParams, ExternalRequestPromise, MantaPayConfig, MantaPaySyncState, NftCollection, NftItem, NftJson, NominatorMetadata, RequestAccountExportPrivateKey, RequestCardanoSignData, RequestCardanoSignTransaction, RequestConfirmationComplete, RequestConfirmationCompleteBitcoin, RequestConfirmationCompleteCardano, RequestConfirmationCompleteTon, RequestCrowdloanContributions, RequestSettingsType, ResponseAccountExportPrivateKey, ResponseCardanoSignData, ResponseCardanoSignTransaction, ServiceInfo, SingleModeJson, StakingItem, StakingJson, StakingRewardItem, StakingRewardJson, StakingType, UiSettings } from '@subwallet/extension-base/background/KoniTypes';
 import { RequestAuthorizeTab, RequestRpcSend, RequestRpcSubscribe, RequestRpcUnsubscribe, RequestSign, ResponseRpcListProviders, ResponseSigning } from '@subwallet/extension-base/background/types';
 import { EnvConfig } from '@subwallet/extension-base/constants';
 import { BalanceService } from '@subwallet/extension-base/services/balance-service';
@@ -222,6 +222,9 @@ export default class KoniState {
     cardanoSignData(id: string, url: string, params: RequestCardanoSignData, currentAddress: string): Promise<ResponseCardanoSignData>;
     cardanoSignTx(id: string, url: string, param: RequestCardanoSignTransaction, currentAddress: string): Promise<ResponseCardanoSignTransaction>;
     cardanoSubmitTx(id: string, url: string, txHex: string): Promise<string>;
+    bitcoinSign(id: string, url: string, method: string, params: BitcoinSignMessageParams): Promise<BitcoinSignMessageResult>;
+    bitcoinSignPspt(id: string, url: string, params: BitcoinSignPsbtParams): Promise<BitcoinSignPsbtResult>;
+    bitcoinSendTransaction(id: string, url: string, transactionParams: BitcoinSendTransactionParams): Promise<string | undefined>;
     getConfirmationsQueueSubject(): BehaviorSubject<ConfirmationsQueue>;
     getConfirmationsQueueSubjectTon(): BehaviorSubject<ConfirmationsQueueTon>;
     getConfirmationsQueueSubjectCardano(): BehaviorSubject<ConfirmationsQueueCardano>;

package/koni/background/handlers/State.js

@@ -2,13 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import * as CardanoWasm from '@emurgo/cardano-serialization-lib-nodejs';
+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 { withErrorLog } from '@subwallet/extension-base/background/handlers/helpers';
 import { isSubscriptionRunning, unsubscribe } from '@subwallet/extension-base/background/handlers/subscriptions';
-import { APIItemState, CardanoProviderErrorType, ChainType, EvmProviderErrorType, ExternalRequestPromiseStatus, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { APIItemState, BitcoinProviderErrorType, CardanoProviderErrorType, ChainType, EvmProviderErrorType, ExternalRequestPromiseStatus, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { BACKEND_API_URL, BACKEND_PRICE_HISTORY_URL, MANTA_PAY_BALANCE_INTERVAL, REMIND_EXPORT_ACCOUNT } from '@subwallet/extension-base/constants';
-import { convertErrorFormat, generateValidationProcess, validationAuthCardanoMiddleware, validationAuthMiddleware, validationAuthWCMiddleware, validationCardanoSignDataMiddleware, validationConnectMiddleware, validationEvmDataTransactionMiddleware, validationEvmSignMessageMiddleware } from '@subwallet/extension-base/core/logic-validation';
+import { convertErrorFormat, generateValidationProcess, validationAuthCardanoMiddleware, validationAuthMiddleware, validationAuthWCMiddleware, validationBitcoinConnectMiddleware, validationBitcoinSendTransactionMiddleware, validationBitcoinSignMessageMiddleware, validationBitcoinSignPsbtMiddleware, validationCardanoSignDataMiddleware, validationConnectMiddleware, validationEvmDataTransactionMiddleware, validationEvmSignMessageMiddleware } from '@subwallet/extension-base/core/logic-validation';
 import { BalanceService } from '@subwallet/extension-base/services/balance-service';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
 import BuyService from '@subwallet/extension-base/services/buy-service';
@@ -45,6 +46,8 @@ import { convertCardanoHexToBech32, validateAddressNetwork } from '@subwallet/ex
 import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
 import subwalletApiSdk from '@subwallet/subwallet-api-sdk';
 import { keyring } from '@subwallet/ui-keyring';
+import BigN from 'bignumber.js';
+import * as bitcoin from 'bitcoinjs-lib';
 import BN from 'bn.js';
 import { t } from 'i18next';
 import { Subject } from 'rxjs';
@@ -104,7 +107,7 @@ export default class KoniState {
     this.chainService = new ChainService(this.dbService, this.eventService);
     this.subscanService = SubscanService.getInstance();
     this.settingService = new SettingService();
-    this.requestService = new RequestService(this.chainService, this.settingService, this.keyringService, this.feeService, this.transactionService);
+    this.requestService = new RequestService(this.chainService, this.settingService, this.keyringService, this.transactionService);
     this.priceService = new PriceService(this.dbService, this.eventService, this.chainService);
     this.balanceService = new BalanceService(this);
     this.historyService = new HistoryService(this.dbService, this.chainService, this.eventService, this.keyringService, this.subscanService);
@@ -1021,6 +1024,8 @@ export default class KoniState {
       });
     });
   }
+
+  // Cardano
   async cardanoGetBalance(id, url, address) {
     const authInfoMap = await this.getAuthList();
     const authInfo = authInfoMap[stripUrl(url)];
@@ -1241,6 +1246,186 @@ export default class KoniState {
     const cardanoApi = this.chainService.getCardanoApi(networkKey);
     return await cardanoApi.sendCardanoTxReturnHash(txHex);
   }
+
+  // Bitcoin
+  async bitcoinSign(id, url, method, params) {
+    const {
+      address,
+      message
+    } = params;
+    const payloadValidation = {
+      address,
+      type: 'bitcoin',
+      payloadAfterValidated: message,
+      errors: [],
+      networkKey: ''
+    };
+    const validationSteps = [validationAuthMiddleware, validationBitcoinSignMessageMiddleware];
+    const result = await generateValidationProcess(this, url, payloadValidation, validationSteps);
+    const errorsFormated = convertErrorFormat(result.errors);
+    const payloadAfterValidated = {
+      ...result.payloadAfterValidated,
+      errors: errorsFormated,
+      id
+    };
+    return this.requestService.addConfirmationBitcoin(id, url, 'bitcoinSignatureRequest', payloadAfterValidated, {}).then(({
+      isApproved,
+      payload
+    }) => {
+      if (isApproved) {
+        if (payload) {
+          return payload;
+        } else {
+          throw new BitcoinProviderError(BitcoinProviderErrorType.INVALID_PARAMS, t('Not found signature'));
+        }
+      } else {
+        throw new BitcoinProviderError(BitcoinProviderErrorType.USER_REJECTED_REQUEST);
+      }
+    });
+  }
+  async bitcoinSignPspt(id, url, params) {
+    const {
+      address,
+      network,
+      psbt
+    } = params;
+    const payloadValidation = {
+      address,
+      type: 'bitcoin',
+      payloadAfterValidated: params,
+      errors: [],
+      networkKey: network === 'mainnet' ? 'bitcoin' : 'bitcoinTestnet'
+    };
+    const validationSteps = [validationAuthMiddleware, validationBitcoinConnectMiddleware, validationBitcoinSignPsbtMiddleware];
+    const result = await generateValidationProcess(this, url, payloadValidation, validationSteps);
+    const errorsFormated = convertErrorFormat(result.errors);
+    const payloadAfterValidated = {
+      ...result.payloadAfterValidated,
+      errors: errorsFormated
+    };
+    const network_ = network === 'mainnet' ? bitcoin.networks.bitcoin : bitcoin.networks.testnet;
+    const psbtGenerate = bitcoin.Psbt.fromHex(psbt, {
+      network: network_
+    });
+    const isExistedInput = (inputs, address) => inputs.findIndex(({
+      address: address_
+    }) => isSameAddress(address, address_ || ''));
+    let to = '';
+    const tokenInfo = this.getNativeTokenInfo(result.networkKey);
+    let value = new BigN(0);
+    const totalBalance = await this.balanceService.getTotalBalance(address, result.networkKey, tokenInfo.slug);
+    let inputAmount = new BigN(0);
+    const psbtInputData = psbtGenerate.data.inputs.reduce((inputs, {
+      nonWitnessUtxo,
+      witnessUtxo
+    }, inputIndex) => {
+      let inputData = null;
+      if (witnessUtxo) {
+        inputData = {
+          address: bitcoin.address.fromOutputScript(witnessUtxo === null || witnessUtxo === void 0 ? void 0 : witnessUtxo.script, network_),
+          amount: witnessUtxo.value.toString()
+        };
+      } else if (nonWitnessUtxo) {
+        const txin = psbtGenerate.txInputs[inputIndex];
+        const txout = bitcoin.Transaction.fromBuffer(nonWitnessUtxo).outs[txin.index];
+        inputData = {
+          address: bitcoin.address.fromOutputScript(txout.script, network_),
+          amount: txout.value.toString()
+        };
+      }
+      if (inputData) {
+        inputs.push(inputData);
+        if (isSameAddress(address, inputData.address || '')) {
+          inputAmount = inputAmount.plus(new BigN(inputData.amount || '0'));
+        }
+      }
+      return inputs;
+    }, []);
+    if (new BigN(totalBalance.value).lt(inputAmount)) {
+      payloadAfterValidated.errors = [{
+        message: t('Insufficient balance'),
+        name: t('Unable to sign transaction')
+      }];
+    }
+    const psbtOutputData = psbtGenerate.txOutputs.map(output => {
+      let address = '';
+      try {
+        address = output.address || bitcoin.address.fromOutputScript(output.script, network_);
+      } catch (e) {
+        if (output.script.includes(bitcoin.opcodes.OP_RETURN)) {
+          address = 'OP_RETURN';
+        } else {
+          address = 'Unknown';
+        }
+      }
+      if (isExistedInput(psbtInputData, address) === -1) {
+        to = address;
+        value = value.plus(new BigN(output.value));
+      }
+      return {
+        address,
+        amount: output.value.toString()
+      };
+    });
+    payloadAfterValidated.payload = {
+      ...payloadAfterValidated.payload,
+      psbt,
+      tokenSlug: tokenInfo.slug,
+      value: value.toString(),
+      to,
+      txInput: psbtInputData,
+      txOutput: psbtOutputData
+    };
+    return this.requestService.addConfirmationBitcoin(id, url, 'bitcoinSignPsbtRequest', payloadAfterValidated, {}).then(({
+      isApproved,
+      payload
+    }) => {
+      if (isApproved) {
+        if (payload) {
+          return payload;
+        } else {
+          throw new BitcoinProviderError(BitcoinProviderErrorType.INVALID_PARAMS, t('Not found signature'));
+        }
+      } else {
+        throw new BitcoinProviderError(BitcoinProviderErrorType.USER_REJECTED_REQUEST);
+      }
+    });
+  }
+  async bitcoinSendTransaction(id, url, transactionParams) {
+    const payloadValidation = {
+      address: transactionParams.account,
+      type: 'bitcoin',
+      payloadAfterValidated: transactionParams,
+      errors: [],
+      networkKey: transactionParams.network === 'mainnet' ? 'bitcoin' : 'bitcoinTestnet'
+    };
+    const validationSteps = [validationAuthMiddleware, validationBitcoinConnectMiddleware, validationBitcoinSendTransactionMiddleware];
+    const result = await generateValidationProcess(this, url, payloadValidation, validationSteps);
+    const errorsFormated = convertErrorFormat(result.errors);
+    const requestPayload = {
+      ...result.payloadAfterValidated,
+      hashPayload: JSON.stringify(result.payloadAfterValidated),
+      from: transactionParams.account,
+      id,
+      errors: errorsFormated
+    };
+
+    // Custom handle this instead of general handler transaction
+    return this.requestService.addConfirmationBitcoin(id, url, 'bitcoinSendTransactionRequestAfterConfirmation', requestPayload, {}).then(({
+      isApproved,
+      payload
+    }) => {
+      if (isApproved) {
+        if (payload) {
+          return payload;
+        } else {
+          throw new BitcoinProviderError(BitcoinProviderErrorType.INVALID_PARAMS, t('Not found signature'));
+        }
+      } else {
+        throw new BitcoinProviderError(BitcoinProviderErrorType.USER_REJECTED_REQUEST);
+      }
+    });
+  }
   getConfirmationsQueueSubject() {
     return this.requestService.confirmationsQueueSubject;
   }
@@ -1480,9 +1665,9 @@ export default class KoniState {
     this.eventService.emit('general.start', true);
 
     // Complete starting
-    starting.resolve();
     this.waitStarting = null;
     this.generalStatus = ServiceStatus.STARTED;
+    starting.resolve();
   }
   async _startFull() {
     // Continue wait existed starting process