@subwallet/extension-base 1.3.31-0 → 1.3.32-0

package/cjs/services/request-service/handler/AuthRequestHandler.js

@@ -45,6 +45,13 @@ class AuthRequestHandler {
         value.accountAuthTypes = ['evm', 'substrate'];
         needUpdateAuthList = true;
       }
+      const existKeyEvmNetworkConnect = value.currentEvmNetworkKey;
+      if (existKeyEvmNetworkConnect) {
+        value.currentNetworkMap = {
+          evm: existKeyEvmNetworkConnect
+        };
+        needUpdateAuthList = true;
+      }
       acc[key] = {
         ...value
       };
@@ -158,6 +165,18 @@ class AuthRequestHandler {
         }
       }
     }
+    if (options.accessType === 'cardano') {
+      const cardanoChains = Object.values(chainInfoMaps).filter(_utils._isChainCardanoCompatible);
+      chainInfo = (defaultChain ? chainInfoMaps[defaultChain] : chainInfoMaps.cardano) || cardanoChains[0]; // auto active cardano mainnet chain, because dont support switch network yet
+
+      if (options.autoActive) {
+        var _chainInfo3;
+        if (!needEnableChains.includes((_chainInfo3 = chainInfo) === null || _chainInfo3 === void 0 ? void 0 : _chainInfo3.slug)) {
+          var _chainInfo4;
+          needEnableChains.push((_chainInfo4 = chainInfo) === null || _chainInfo4 === void 0 ? void 0 : _chainInfo4.slug);
+        }
+      }
+    }
     needEnableChains = needEnableChains.filter(slug => {
       var _chainStateMap$slug;
       return !((_chainStateMap$slug = chainStateMap[slug]) !== null && _chainStateMap$slug !== void 0 && _chainStateMap$slug.active);
@@ -206,20 +225,31 @@ class AuthRequestHandler {
           if ((0, _keyring.isTonAddress)(a) && !accountAuthTypes.includes('ton')) {
             return true;
           }
+          if ((0, _keyring.isCardanoAddress)(a) && !accountAuthTypes.includes('cardano')) {
+            return true;
+          }
           return false;
         });
         backupAllowed.forEach(acc => {
           isAllowedMap[acc] = true;
         });
       }
-      let defaultEvmNetworkKey;
+      const defaultNetworkMap = {};
       if (accountAuthTypes.includes('evm')) {
         const chainInfo = this.getDAppChainInfo({
           accessType: 'evm',
           autoActive: true,
           url
         });
-        defaultEvmNetworkKey = chainInfo === null || chainInfo === void 0 ? void 0 : chainInfo.slug;
+        defaultNetworkMap.evm = chainInfo === null || chainInfo === void 0 ? void 0 : chainInfo.slug;
+      }
+      if (accountAuthTypes.includes('cardano')) {
+        const chainInfo = this.getDAppChainInfo({
+          accessType: 'cardano',
+          autoActive: true,
+          url
+        });
+        defaultNetworkMap.cardano = chainInfo === null || chainInfo === void 0 ? void 0 : chainInfo.slug;
       }
       this.getAuthorize(value => {
         let authorizeList = {};
@@ -243,7 +273,7 @@ class AuthRequestHandler {
           origin,
           url,
           accountAuthTypes: [...new Set([...accountAuthTypes, ...((existed === null || existed === void 0 ? void 0 : existed.accountAuthTypes) || [])])],
-          currentEvmNetworkKey: existed ? existed.currentEvmNetworkKey : defaultEvmNetworkKey
+          currentNetworkMap: existed ? existed.currentNetworkMap : defaultNetworkMap
         };
         this.setAuthorize(authorizeList, () => {
           cb();
@@ -347,12 +377,14 @@ class AuthRequestHandler {
           list.push(...allowedListByRequestType.filter(a => (0, _keyring.isSubstrateAddress)(a)));
         } else if (accountAuthType === 'ton') {
           list.push(...allowedListByRequestType.filter(a => (0, _keyring.isTonAddress)(a)));
+        } else if (accountAuthType === 'cardano') {
+          list.push(...allowedListByRequestType.filter(a => (0, _keyring.isCardanoAddress)(a)));
         }
         return list;
       }, []);
       if (!confirmAnotherType && !request.reConfirm && allowedListByRequestType.length !== 0) {
         // Prevent appear confirmation popup
-        return false;
+        return true;
       }
     } else {
       // Auto auth for web app
@@ -368,7 +400,8 @@ class AuthRequestHandler {
           isAllowedMap,
           origin,
           url,
-          accountAuthTypes: _constants.ALL_ACCOUNT_AUTH_TYPES
+          accountAuthTypes: _constants.ALL_ACCOUNT_AUTH_TYPES,
+          currentNetworkMap: {}
         };
         this.setAuthorize(authList);
         return true;

package/cjs/services/request-service/handler/CardanoRequestHandler.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+var _cardanoSerializationLibNodejs = require("@emurgo/cardano-serialization-lib-nodejs");
 var _request = require("@subwallet/extension-base/utils/request");
 var _uiKeyring = require("@subwallet/ui-keyring");
 var _i18next = require("i18next");
@@ -18,7 +19,8 @@ class CardanoRequestHandler {
   confirmationsQueueSubjectCardano = new _rxjs.BehaviorSubject({
     cardanoSignatureRequest: {},
     cardanoSendTransactionRequest: {},
-    cardanoWatchTransactionRequest: {}
+    cardanoWatchTransactionRequest: {},
+    cardanoSignTransactionRequest: {}
   });
   confirmationsPromiseMap = {};
   constructor(requestService) {
@@ -122,9 +124,11 @@ class CardanoRequestHandler {
   async decorateResult(t, request, result) {
     if (result.payload === '') {
       if (t === 'cardanoSignatureRequest') {
-        // result.payload = await this.signMessage(request as ConfirmationDefinitions['evmSignatureRequest'][0]);
+        result.payload = this.signMessage(request);
       } else if (t === 'cardanoSendTransactionRequest') {
         result.payload = this.signTransactionCardano(request);
+      } else if (t === 'cardanoSignTransactionRequest') {
+        result.payload = this.signDappTransactionCardano(request);
       }
       if (t === 'cardanoSignatureRequest' || t === 'cardanoSendTransactionRequest') {
         const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
@@ -134,6 +138,17 @@ class CardanoRequestHandler {
       }
     }
   }
+  signMessage(confirmation) {
+    const {
+      address,
+      payload
+    } = confirmation.payload;
+    const pair = _uiKeyring.keyring.getPair(address);
+    if (pair.isLocked) {
+      _uiKeyring.keyring.unlockPair(pair.address);
+    }
+    return pair.cardano.signMessage(payload, true);
+  }
   signTransactionCardano(confirmation) {
     // alibaba
     const transaction = confirmation.payload;
@@ -145,7 +160,34 @@ class CardanoRequestHandler {
     if (pair.isLocked) {
       _uiKeyring.keyring.unlockPair(pair.address);
     }
-    return pair.cardano.sign(cardanoPayload);
+    return pair.cardano.signTransaction(cardanoPayload);
+  }
+  signDappTransactionCardano(confirmation) {
+    var _FixedTransaction$fro;
+    // alibaba
+    const transaction = confirmation.payload;
+    const {
+      addressRequireKeyTypes,
+      cardanoPayload,
+      from
+    } = transaction;
+    const vkeyWitnessesFinal = _cardanoSerializationLibNodejs.Vkeywitnesses.new();
+    const txWitnessSet = (_FixedTransaction$fro = _cardanoSerializationLibNodejs.FixedTransaction.from_hex(cardanoPayload).witness_set()) !== null && _FixedTransaction$fro !== void 0 ? _FixedTransaction$fro : _cardanoSerializationLibNodejs.TransactionWitnessSet.new();
+    const pair = _uiKeyring.keyring.getPair(from);
+    if (pair.isLocked) {
+      _uiKeyring.keyring.unlockPair(pair.address);
+    }
+    const keyTypes = [...new Set(addressRequireKeyTypes)];
+    const vKeyWitnessesHex = pair.cardano.signTransaction(cardanoPayload, {
+      needVkeywitness: true,
+      keyTypes
+    });
+    const vKeyWitnesses = _cardanoSerializationLibNodejs.Vkeywitnesses.from_hex(vKeyWitnessesHex);
+    for (let i = 0; i < vKeyWitnesses.len(); i++) {
+      vkeyWitnessesFinal.add(vKeyWitnesses.get(i));
+    }
+    txWitnessSet.set_vkeys(vkeyWitnessesFinal);
+    return txWitnessSet.to_hex();
   }
   resetWallet() {
     const confirmations = this.confirmationsQueueSubjectCardano.getValue();

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

@@ -3,9 +3,20 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.convertValueToAsset = exports.convertUtxoRawToUtxo = exports.convertAssetToValue = void 0;
+exports.extractKeyHashFromCertificate = extractKeyHashFromCertificate;
+exports.extractKeyHashesFromCollaterals = extractKeyHashesFromCollaterals;
+exports.extractKeyHashesFromRequiredSigners = extractKeyHashesFromRequiredSigners;
+exports.extractKeyHashesFromScripts = extractKeyHashesFromScripts;
+exports.extractKeyHashesFromWithdrawals = extractKeyHashesFromWithdrawals;
 exports.extractMetadata = void 0;
+exports.getBalanceAddressMap = getBalanceAddressMap;
+exports.hasSufficientCardanoValue = hasSufficientCardanoValue;
+var CardanoWasm = _interopRequireWildcard(require("@emurgo/cardano-serialization-lib-nodejs"));
 var _extensionChains = require("@subwallet/extension-chains");
 var _defaults = require("@polkadot/networks/defaults");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -55,4 +66,411 @@ const extractMetadata = store => {
     });
   });
 };
-exports.extractMetadata = extractMetadata;
+exports.extractMetadata = extractMetadata;
+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;
+};
+exports.convertAssetToValue = convertAssetToValue;
+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;
+};
+exports.convertValueToAsset = convertValueToAsset;
+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);
+  });
+};
+exports.convertUtxoRawToUtxo = convertUtxoRawToUtxo;
+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.
+ */
+
+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.
+ */
+
+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.
+ */
+
+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.
+ */
+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
+ */
+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
+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/cjs/services/swap-service/handler/asset-hub/handler.js

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