@subwallet/extension-base 1.3.31-1 → 1.3.33-0

package/services/request-service/helper/index.js

@@ -1,6 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import * as CardanoWasm from '@emurgo/cardano-serialization-lib-nodejs';
 import { addMetadata } from '@subwallet/extension-chains';
 import { knownGenesis } from '@polkadot/networks/defaults';
 export const extractMetadata = store => {
@@ -41,4 +42,408 @@ export const extractMetadata = store => {
       def
     }) => addMetadata(def));
   });
-};
+};
+export const convertAssetToValue = amount => {
+  const value = CardanoWasm.Value.new(CardanoWasm.BigNum.from_str('0'));
+  const multiAsset = CardanoWasm.MultiAsset.new();
+  for (const item of amount) {
+    if (item.unit === 'lovelace') {
+      value.set_coin(CardanoWasm.BigNum.from_str(item.quantity));
+    } else {
+      const policyIdHex = item.unit.slice(0, 56);
+      const assetNameHex = item.unit.slice(56);
+      const scriptHash = CardanoWasm.ScriptHash.from_bytes(Buffer.from(policyIdHex, 'hex'));
+      const assetName = CardanoWasm.AssetName.new(Buffer.from(assetNameHex, 'hex'));
+      const quantity = CardanoWasm.BigNum.from_str(item.quantity);
+      let assets = multiAsset.get(scriptHash);
+      if (!assets) {
+        assets = CardanoWasm.Assets.new();
+      }
+      assets.insert(assetName, quantity);
+      multiAsset.insert(scriptHash, assets);
+    }
+  }
+  if (multiAsset.len() > 0) {
+    value.set_multiasset(multiAsset);
+  }
+  return value;
+};
+export const convertValueToAsset = value => {
+  var _value$multiasset;
+  const assets = [];
+  assets.push({
+    unit: 'lovelace',
+    quantity: value.coin().to_js_value()
+  });
+  const multiAssets = (_value$multiasset = value.multiasset()) === null || _value$multiasset === void 0 ? void 0 : _value$multiasset.keys();
+  if (multiAssets) {
+    for (let j = 0; j < multiAssets.len(); j++) {
+      var _value$multiasset2;
+      const policy = multiAssets.get(j);
+      const policyAssets = (_value$multiasset2 = value.multiasset()) === null || _value$multiasset2 === void 0 ? void 0 : _value$multiasset2.get(policy);
+      if (!policyAssets) {
+        continue;
+      }
+      const assetNames = policyAssets.keys();
+      for (let k = 0; k < assetNames.len(); k++) {
+        var _quantity$to_js_value;
+        const assetName = assetNames.get(k);
+        const quantity = policyAssets.get(assetName);
+        const assetUnit = `${policy.to_hex()}${assetName.to_hex()}`;
+        assets.push({
+          unit: assetUnit,
+          quantity: (_quantity$to_js_value = quantity === null || quantity === void 0 ? void 0 : quantity.to_js_value()) !== null && _quantity$to_js_value !== void 0 ? _quantity$to_js_value : '0',
+          policy: policy.to_hex(),
+          name: Buffer.from(assetName.to_hex(), 'hex').toString(),
+          fingerprint: `${policy.to_hex()}${assetName.to_hex()}`
+        });
+      }
+    }
+  }
+  return assets;
+};
+export const convertUtxoRawToUtxo = utxos => {
+  return utxos.map(utxo => {
+    const txHash = CardanoWasm.TransactionHash.from_bytes(Buffer.from(utxo.tx_hash, 'hex'));
+    const txIndex = utxo.output_index;
+    const input = CardanoWasm.TransactionInput.new(txHash, txIndex);
+    const value = convertAssetToValue(utxo.amount);
+    const txOutput = CardanoWasm.TransactionOutput.new(CardanoWasm.Address.from_bech32(utxo.address), value);
+    return CardanoWasm.TransactionUnspentOutput.new(input, txOutput);
+  });
+};
+export function getBalanceAddressMap(outputs) {
+  const acc = {};
+  for (let i = 0; i < outputs.len(); i++) {
+    const item = outputs.get(i);
+    const address = item.address().to_bech32();
+    if (!acc[address]) {
+      acc[address] = item.amount();
+    } else {
+      acc[address] = acc[address].checked_add(item.amount());
+    }
+  }
+  return acc;
+}
+
+/**
+ * Extracts all required key hashes from a list of certificates.
+ * Handles different certificate kinds: stake deregistration, delegation,
+ * pool registration, pool retirement, and MIR (move instantaneous rewards).
+ *
+ * Only processes key hash credentials (ignores script credentials).
+ *
+ * @param {Certificates} certificates - List of certificate objects from a transaction body.
+ * @returns {string[]} - An array of required key hashes in hex format.
+ */
+
+export function extractKeyHashFromCertificate(certificates) {
+  if (!certificates) {
+    return [];
+  }
+  const requiredKeyHashes = [];
+
+  // Helper: Extract key hash from stake credential (only if it's a public key)
+  const extractKeyHash = credential => {
+    if (credential.kind() === 0) {
+      var _credential$to_keyhas;
+      // kind === 0 => StakeCredential is a public key
+      return (_credential$to_keyhas = credential.to_keyhash()) === null || _credential$to_keyhas === void 0 ? void 0 : _credential$to_keyhas.to_hex();
+    }
+    return null;
+  };
+  for (let i = 0; i < certificates.len(); i++) {
+    const cert = certificates.get(i);
+    switch (cert.kind()) {
+      case 0:
+        {
+          // Stake Registration Certificate
+          // No key hash required here, just registration action
+          break;
+        }
+      case 1:
+        {
+          var _cert$as_stake_deregi;
+          // Stake Deregistration Certificate
+          const credential = (_cert$as_stake_deregi = cert.as_stake_deregistration()) === null || _cert$as_stake_deregi === void 0 ? void 0 : _cert$as_stake_deregi.stake_credential();
+          if (!credential) {
+            break;
+          }
+          const hash = extractKeyHash(credential);
+          if (hash) {
+            requiredKeyHashes.push(hash);
+          }
+          break;
+        }
+      case 2:
+        {
+          var _cert$as_stake_delega;
+          // Stake Delegation Certificate
+          const credential = (_cert$as_stake_delega = cert.as_stake_delegation()) === null || _cert$as_stake_delega === void 0 ? void 0 : _cert$as_stake_delega.stake_credential();
+          if (!credential) {
+            break;
+          }
+          const hash = extractKeyHash(credential);
+          if (hash) {
+            requiredKeyHashes.push(hash);
+          }
+          break;
+        }
+      case 3:
+        {
+          var _cert$as_pool_registr;
+          // Pool Registration Certificate
+          // Collect all pool owner key hashes
+          const owners = (_cert$as_pool_registr = cert.as_pool_registration()) === null || _cert$as_pool_registr === void 0 ? void 0 : _cert$as_pool_registr.pool_params().pool_owners();
+          if (!owners) {
+            break;
+          }
+          for (let j = 0; j < owners.len(); j++) {
+            const ownerKeyHash = owners.get(j).to_hex();
+            requiredKeyHashes.push(ownerKeyHash);
+          }
+          break;
+        }
+      case 4:
+        {
+          var _cert$as_pool_retirem;
+          // Pool Retirement Certificate
+          // The operator key hash is required to authorize retirement
+          const operator = (_cert$as_pool_retirem = cert.as_pool_retirement()) === null || _cert$as_pool_retirem === void 0 ? void 0 : _cert$as_pool_retirem.pool_keyhash().to_hex();
+          if (!operator) {
+            break;
+          }
+          requiredKeyHashes.push(operator);
+          break;
+        }
+      case 6:
+        {
+          var _cert$as_move_instant, _cert$as_move_instant2;
+          // Move Instantaneous Rewards Certificate
+          // Extract key hashes from reward receivers
+          const rewards = (_cert$as_move_instant = cert.as_move_instantaneous_rewards_cert()) === null || _cert$as_move_instant === void 0 ? void 0 : (_cert$as_move_instant2 = _cert$as_move_instant.move_instantaneous_reward().as_to_stake_creds()) === null || _cert$as_move_instant2 === void 0 ? void 0 : _cert$as_move_instant2.keys();
+          if (!rewards) {
+            break;
+          }
+          for (let j = 0; j < rewards.len(); j++) {
+            const hash = extractKeyHash(rewards.get(j));
+            if (hash) {
+              requiredKeyHashes.push(hash);
+            }
+          }
+          break;
+        }
+      default:
+        {
+          // Unknown or unsupported certificate kind — skip
+          break;
+        }
+    }
+  }
+  return requiredKeyHashes;
+}
+
+/**
+ * Extracts required key hashes from withdrawal entries.
+ * It processes only credentials of kind 0 (key hash based).
+ *
+ * @param {Withdrawals} withdrawals - The withdrawal map from a transaction body.
+ * @returns {string[]} - An array of required key hashes in hex format.
+ */
+
+export function extractKeyHashesFromWithdrawals(withdrawals) {
+  if (!withdrawals) {
+    return [];
+  }
+  const requiredKeyHashes = [];
+  const rewardAccounts = withdrawals.keys();
+  for (let i = 0; i < rewardAccounts.len(); i++) {
+    const stakeCred = rewardAccounts.get(i).payment_cred();
+
+    // Check if the credential is a key hash (not a script)
+    const keyHash = stakeCred.to_keyhash();
+    if (stakeCred.kind() === 0 && keyHash) {
+      const hexHash = Buffer.from(keyHash.to_bytes()).toString('hex');
+      requiredKeyHashes.push(hexHash);
+    }
+  }
+  return requiredKeyHashes;
+}
+
+/**
+ * Recursively extract all Ed25519 key hashes from a NativeScripts collection.
+ * Only processes `ScriptPubkey` entries (kind = 0), and traverses through nested scripts.
+ *
+ * @param {NativeScripts} scripts - A collection of native scripts.
+ * @returns {string[]} - An array of key hashes (hex-encoded) from all script_pubkey entries.
+ */
+
+export function extractKeyHashesFromScripts(scripts) {
+  if (!scripts) {
+    return [];
+  }
+  const keyHashes = [];
+  for (let i = 0; i < scripts.len(); i++) {
+    const script = scripts.get(i);
+    switch (script.kind()) {
+      case 0:
+        {
+          var _script$as_script_pub;
+          // ScriptPubkey
+          const pubkeyHash = (_script$as_script_pub = script.as_script_pubkey()) === null || _script$as_script_pub === void 0 ? void 0 : _script$as_script_pub.addr_keyhash();
+          if (!pubkeyHash) {
+            break;
+          }
+          const hexHash = pubkeyHash.to_hex();
+          keyHashes.push(hexHash);
+          break;
+        }
+      case 1:
+        {
+          var _script$as_script_all;
+          // ScriptAll
+          const nestedScripts = (_script$as_script_all = script.as_script_all()) === null || _script$as_script_all === void 0 ? void 0 : _script$as_script_all.native_scripts();
+          keyHashes.push(...extractKeyHashesFromScripts(nestedScripts));
+          break;
+        }
+      case 2:
+        {
+          var _script$as_script_any;
+          // ScriptAny
+          const nestedScripts = (_script$as_script_any = script.as_script_any()) === null || _script$as_script_any === void 0 ? void 0 : _script$as_script_any.native_scripts();
+          keyHashes.push(...extractKeyHashesFromScripts(nestedScripts));
+          break;
+        }
+      case 3:
+        {
+          var _script$as_script_n_o;
+          // ScriptNOfK
+          const nestedScripts = (_script$as_script_n_o = script.as_script_n_of_k()) === null || _script$as_script_n_o === void 0 ? void 0 : _script$as_script_n_o.native_scripts();
+          keyHashes.push(...extractKeyHashesFromScripts(nestedScripts));
+          break;
+        }
+      default:
+        // Unknown kind, skip
+        break;
+    }
+  }
+  return keyHashes;
+}
+
+/**
+ * Extract required key hashes from the RequiredSigners field in the transaction body.
+ * Each entry is an Ed25519 key hash that must sign the transaction.
+ *
+ * @param {Ed25519KeyHashes} requiredSigners - A list of required signer key hashes.
+ * @returns {string[]} - Array of hex-encoded Ed25519 key hashes.
+ */
+export function extractKeyHashesFromRequiredSigners(requiredSigners) {
+  if (!requiredSigners) {
+    return [];
+  }
+  const result = [];
+  for (let i = 0; i < requiredSigners.len(); i++) {
+    result.push(requiredSigners.get(i).to_hex());
+  }
+  return result;
+}
+
+/**
+ * Extract required key hashes from collateral inputs in a linear and readable flow.
+ *
+ * This function resolves UTXOs of each collateral input,
+ * attempts to extract the payment key hash from various supported address types,
+ * and returns an array of required signer key hashes in hex format.
+ *
+ * @param {TransactionInputs} collaterals - Collateral inputs used for script validation
+ * @param getSpecificUtxo
+ * @returns {Promise<string[]>} - Hex-encoded key hashes required to sign the transaction
+ */
+export async function extractKeyHashesFromCollaterals(collaterals, getSpecificUtxo) {
+  if (!collaterals || !getSpecificUtxo) {
+    return [];
+  }
+  const keyHashes = [];
+  for (let i = 0; i < collaterals.len(); i++) {
+    const collateral = collaterals.get(i);
+
+    // Resolve UTXO from tx_id + index
+    const txId = collateral.transaction_id().to_hex();
+    const utxo = await getSpecificUtxo(txId, collateral.index());
+    if (!utxo) {
+      continue;
+    }
+
+    // Load address object from UTXO
+    const address = CardanoWasm.Address.from_bech32(utxo.address);
+
+    // Try extracting payment key hash from different address types
+    const types = [CardanoWasm.BaseAddress, CardanoWasm.EnterpriseAddress, CardanoWasm.PointerAddress];
+    let extracted = false;
+    for (const Type of types) {
+      try {
+        var _Type$from_address;
+        const paymentCred = (_Type$from_address = Type.from_address(address)) === null || _Type$from_address === void 0 ? void 0 : _Type$from_address.payment_cred();
+        const keyHash = paymentCred === null || paymentCred === void 0 ? void 0 : paymentCred.to_keyhash();
+        if (keyHash) {
+          keyHashes.push(keyHash.to_hex());
+          extracted = true;
+          break;
+        }
+      } catch (_) {
+        // Skip to next type
+      }
+    }
+    if (!extracted) {
+      throw new Error('Unsupported collateral address type');
+    }
+  }
+  return keyHashes;
+}
+
+/// Check if valueA has sufficient value to cover valueB
+export function hasSufficientCardanoValue(valueA, valueB) {
+  const coinA = BigInt(valueA.coin().to_str());
+  const coinB = BigInt(valueB.coin().to_str());
+
+  // Check if ADA amount in valueA is less than required in valueB
+  if (coinA < coinB) {
+    return false;
+  }
+  const multiAssetB = valueB.multiasset();
+  if (!multiAssetB) {
+    return true;
+  } // No assets required in valueB
+
+  const multiAssetA = valueA.multiasset();
+  if (!multiAssetA) {
+    return false;
+  } // valueA has no assets but valueB requires them
+
+  const policyIds = multiAssetB.keys();
+  for (let i = 0; i < policyIds.len(); i++) {
+    const policyId = policyIds.get(i);
+    const assetsB = multiAssetB.get(policyId);
+    const assetsA = multiAssetA.get(policyId);
+    if (!assetsB) {
+      continue;
+    }
+    if (!assetsA) {
+      return false;
+    } // Required policy ID is missing in valueA
+
+    const assetNames = assetsB.keys();
+    for (let j = 0; j < assetNames.len(); j++) {
+      var _assetsB$get$to_str, _assetsB$get, _assetsA$get$to_str, _assetsA$get;
+      const assetName = assetNames.get(j);
+      const quantityB = BigInt((_assetsB$get$to_str = (_assetsB$get = assetsB.get(assetName)) === null || _assetsB$get === void 0 ? void 0 : _assetsB$get.to_str()) !== null && _assetsB$get$to_str !== void 0 ? _assetsB$get$to_str : '0');
+      const quantityA = BigInt((_assetsA$get$to_str = (_assetsA$get = assetsA.get(assetName)) === null || _assetsA$get === void 0 ? void 0 : _assetsA$get.to_str()) !== null && _assetsA$get$to_str !== void 0 ? _assetsA$get$to_str : '0');
+
+      // Check if asset quantity in valueA is less than required
+      if (quantityA < quantityB) {
+        return false;
+      }
+    }
+  }
+  return true;
+}

package/services/request-service/types.d.ts

@@ -19,9 +19,11 @@ export interface AuthUrlInfo {
     url: string;
     accountAuthTypes: AccountAuthType[];
     isAllowedMap: Record<string, boolean>;
-    currentEvmNetworkKey?: string;
+    currentNetworkMap: Partial<Record<AccountAuthType, string>>;
+    currentAccount?: string;
 }
 export interface AuthUrlInfoNeedMigration extends Omit<AuthUrlInfo, 'accountAuthTypes'> {
     accountAuthType?: AccountAuthType | 'both';
+    currentEvmNetworkKey?: string;
 }
 export declare type AuthUrls = Record<string, AuthUrlInfo>;

package/services/swap-service/handler/asset-hub/handler.js

@@ -159,7 +159,7 @@ export class AssetHubSwapHandler {
     const type = process.steps[currentStep].type;
     switch (type) {
       case CommonStepType.XCM:
-        return this.swapBaseHandler.handleBridgeStep(params);
+        return this.swapBaseHandler.handleBridgeStep(params, 'xcm');
       case SwapStepType.SWAP:
         return this.handleSubmitStep(params);
       default:

package/services/swap-service/handler/base-handler.d.ts

@@ -31,7 +31,9 @@ export declare class SwapBaseHandler {
     constructor({ balanceService, chainService, feeService, providerName, providerSlug }: SwapBaseHandlerInitParams);
     generateOptimalProcessV2(params: OptimalSwapPathParamsV2, genStepFuncList: GenSwapStepFuncV2[]): Promise<CommonOptimalSwapPath>;
     getBridgeStep(params: OptimalSwapPathParamsV2, stepIndex: number): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
-    handleBridgeStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    handleBridgeStep(params: SwapSubmitParams, type: string): Promise<SwapSubmitStepData>;
+    handleBridgeSubstrate(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    handleBridgeAcross(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     validateSetFeeTokenStep(params: ValidateSwapProcessParams, stepIndex: number): Promise<TransactionError[]>;
     private validateBridgeStep;
     private validateSwapStepV2;

package/services/swap-service/handler/base-handler.js

@@ -8,7 +8,8 @@ import { _isAccountActive } from '@subwallet/extension-base/core/substrate/syste
 import { _isAcrossBridgeXcm, _isSnowBridgeXcm, _isXcmWithinSameConsensus } from '@subwallet/extension-base/core/substrate/xcm-parser';
 import { _isSufficientToken } from '@subwallet/extension-base/core/utils';
 import { createXcmExtrinsicV2, dryRunXcmExtrinsicV2 } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
-import { _getAssetDecimals, _getAssetSymbol, _getChainNativeTokenSlug, _getTokenMinAmount, _isChainEvmCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { _isAcrossChainBridge, AcrossErrorMsg } from '@subwallet/extension-base/services/balance-service/transfer/xcm/acrossBridge';
+import { _getAssetDecimals, _getAssetOriginChain, _getAssetSymbol, _getChainNativeTokenSlug, _getTokenMinAmount, _isChainEvmCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { DEFAULT_EXCESS_AMOUNT_WEIGHT, FEE_RATE_MULTIPLIER } from '@subwallet/extension-base/services/swap-service/utils';
 import { BasicTxErrorType, SwapStepType, TransferTxErrorType } from '@subwallet/extension-base/types';
 import { CommonStepType, DEFAULT_FIRST_STEP, MOCK_STEP_FEE } from '@subwallet/extension-base/types/service-base';
@@ -18,6 +19,7 @@ import { getId } from '@subwallet/extension-base/utils/getId';
 import BigN from 'bignumber.js';
 import { t } from 'i18next';
 import { isEthereumAddress } from '@polkadot/util-crypto';
+import { createAcrossBridgeExtrinsic } from "../../balance-service/transfer/xcm/index.js";
 export class SwapBaseHandler {
   constructor({
     balanceService,
@@ -51,6 +53,10 @@ export class SwapBaseHandler {
       }
       return result;
     } catch (e) {
+      const errorMessage = e.message;
+      if (errorMessage.toLowerCase().startsWith(AcrossErrorMsg.AMOUNT_TOO_LOW) || errorMessage.toLowerCase().startsWith(AcrossErrorMsg.AMOUNT_TOO_HIGH)) {
+        throw new Error(errorMessage);
+      }
       return result;
     }
   }
@@ -184,7 +190,16 @@ export class SwapBaseHandler {
       return undefined;
     }
   }
-  async handleBridgeStep(params) {
+  async handleBridgeStep(params, type) {
+    if (type === 'xcm') {
+      return this.handleBridgeSubstrate(params);
+    }
+    if (type === 'across') {
+      return this.handleBridgeAcross(params);
+    }
+    throw Error('Not support this type');
+  }
+  async handleBridgeSubstrate(params) {
     const briefXcmStep = params.process.steps[params.currentStep].metadata;
     if (!briefXcmStep || !briefXcmStep.originTokenInfo || !briefXcmStep.destinationTokenInfo || !briefXcmStep.sendingValue) {
       throw new Error('XCM metadata error');
@@ -229,6 +244,49 @@ export class SwapBaseHandler {
       txData: xcmData
     };
   }
+  async handleBridgeAcross(params) {
+    const bridgeStep = params.process.steps[params.currentStep].metadata;
+    if (!bridgeStep || !bridgeStep.originTokenInfo || !bridgeStep.destinationTokenInfo || !bridgeStep.sendingValue) {
+      throw new Error('Bridge metadata error');
+    }
+    const originTokenInfo = bridgeStep.originTokenInfo;
+    const destinationTokenInfo = bridgeStep.destinationTokenInfo;
+    const originChain = this.chainService.getChainInfoByKey(originTokenInfo.originChain);
+    const destinationChain = this.chainService.getChainInfoByKey(destinationTokenInfo.originChain);
+    const evmApi = await this.chainService.getEvmApi(originTokenInfo.originChain).isReady;
+    const feeInfo = await this.feeService.subscribeChainFee(getId(), originTokenInfo.originChain, 'evm');
+    const sendingValue = bridgeStep.sendingValue;
+    const sender = bridgeStep.sender;
+    const recipient = bridgeStep.receiver;
+    const tx = await createAcrossBridgeExtrinsic({
+      originTokenInfo,
+      destinationTokenInfo,
+      originChain,
+      destinationChain,
+      evmApi,
+      feeInfo,
+      sendingValue,
+      sender,
+      recipient
+    });
+    const txData = {
+      originNetworkKey: originTokenInfo.originChain,
+      destinationNetworkKey: destinationTokenInfo.originChain,
+      from: sender,
+      to: recipient,
+      value: sendingValue,
+      tokenSlug: originTokenInfo.slug,
+      showExtraWarning: true
+    };
+    return {
+      txChain: originTokenInfo.originChain,
+      extrinsic: tx,
+      transferNativeAmount: _isNativeToken(originTokenInfo) ? bridgeStep.sendingValue : '0',
+      extrinsicType: ExtrinsicType.TRANSFER_XCM,
+      chainType: ChainType.EVM,
+      txData: txData
+    };
+  }
   async validateSetFeeTokenStep(params, stepIndex) {
     if (!params.selectedQuote) {
       return Promise.resolve([new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]);
@@ -261,27 +319,29 @@ export class SwapBaseHandler {
         }
       }))];
     }
+    const isAcrossBridge = _isAcrossChainBridge(_getAssetOriginChain(fromToken), _getAssetOriginChain(toToken));
+    if (!isAcrossBridge) {
+      // By here, we know that the user is receiving a valid amount of toToken
+      const toChainApi = this.chainService.getSubstrateApi(toToken.originChain);
+      const sufficientChain = this.chainService.value.sufficientChains;
+      if (!toChainApi) {
+        return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+      }
 
-    // By here, we know that the user is receiving a valid amount of toToken
-    const toChainApi = this.chainService.getSubstrateApi(toToken.originChain);
-    const sufficientChain = this.chainService.value.sufficientChains;
-    if (!toChainApi) {
-      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
-    }
-
-    // Only need to check if account is alive with the receiving toToken
-    const isToTokenSufficient = await _isSufficientToken(toToken, toChainApi, sufficientChain);
-    if (!isToTokenSufficient && !_isNativeToken(toToken)) {
-      // sending token cannot keep account alive, must check with native token
-      const toChainNativeTokenBalance = await this.balanceService.getTotalBalance(receiver, toToken.originChain, toChainNativeToken.slug, ExtrinsicType.TRANSFER_BALANCE);
-      if (!_isAccountActive(toChainNativeTokenBalance.metadata)) {
-        return [new TransactionError(TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, t('The recipient account has less than {{amount}} {{nativeSymbol}}, which can lead to your {{localSymbol}} being lost. Change recipient account and try again', {
-          replace: {
-            amount: toChainNativeTokenBalance.value,
-            nativeSymbol: toChainNativeToken.symbol,
-            localSymbol: toToken.symbol
-          }
-        }))];
+      // Only need to check if account is alive with the receiving toToken
+      const isToTokenSufficient = await _isSufficientToken(toToken, toChainApi, sufficientChain);
+      if (!isToTokenSufficient && !_isNativeToken(toToken)) {
+        // sending token cannot keep account alive, must check with native token
+        const toChainNativeTokenBalance = await this.balanceService.getTotalBalance(receiver, toToken.originChain, toChainNativeToken.slug, ExtrinsicType.TRANSFER_BALANCE);
+        if (!_isAccountActive(toChainNativeTokenBalance.metadata)) {
+          return [new TransactionError(TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, t('The recipient account has less than {{amount}} {{nativeSymbol}}, which can lead to your {{localSymbol}} being lost. Change recipient account and try again', {
+            replace: {
+              amount: toChainNativeTokenBalance.value,
+              nativeSymbol: toChainNativeToken.symbol,
+              localSymbol: toToken.symbol
+            }
+          }))];
+        }
       }
     }
     return [];

package/services/swap-service/handler/hydradx-handler.js

@@ -278,7 +278,7 @@ export class HydradxHandler {
       case CommonStepType.DEFAULT:
         return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
       case CommonStepType.XCM:
-        return this.swapBaseHandler.handleBridgeStep(params);
+        return this.swapBaseHandler.handleBridgeStep(params, 'xcm');
       case CommonStepType.SET_FEE_TOKEN:
         return this.handleSetFeeStep(params);
       case SwapStepType.SWAP:

package/services/swap-service/handler/uniswap-handler.d.ts

@@ -23,10 +23,15 @@ export declare class UniswapHandler implements SwapBaseInterface {
     get providerInfo(): import("@subwallet/extension-base/types").SwapProvider;
     generateOptimalProcessV2(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
     getApprovalStep(params: OptimalSwapPathParamsV2, stepIndex: number): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    getApproveSwap(params: OptimalSwapPathParamsV2): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    getApproveBridge(params: OptimalSwapPathParamsV2): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
     getPermitStep(params: OptimalSwapPathParamsV2, stepIndex: number): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
     getSubmitStep(params: OptimalSwapPathParamsV2, stepIndex: number): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    getBridgeStep(params: OptimalSwapPathParamsV2, stepIndex: number): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
     handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     private tokenApproveSpending;
+    private approveSpendingSwap;
+    private approveSpendingBridge;
     handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     handlePermitStep(params: SwapSubmitParams): {
         txChain: string;