@liquidium/client 0.4.0 → 0.5.0-rc.0

package/dist/index.cjs

@@ -6,60 +6,12 @@ var agent = require('@icp-sdk/core/agent');
 var principal = require('@icp-sdk/core/principal');
 var base = require('@scure/base');
 var candid = require('@icp-sdk/core/candid');
+var icp = require('@icp-sdk/canisters/ledger/icp');
 var icrc = require('@icp-sdk/canisters/ledger/icrc');
 var bitcoinAddressValidation = require('bitcoin-address-validation');
 
 // src/client.ts
 
-// src/core/types.ts
-var Environment = {
-  mainnet: "mainnet"
-};
-var Asset = {
-  BTC: "BTC",
-  SOL: "SOL",
-  USDC: "USDC",
-  USDT: "USDT"
-};
-var Chain = {
-  BTC: "BTC",
-  ETH: "ETH"
-};
-var SupplyAction = {
-  deposit: "deposit",
-  repayment: "repayment"
-};
-var OutflowType = {
-  borrow: "borrow",
-  feeClaim: "feeClaim",
-  withdrawal: "withdrawal"
-};
-
-// src/core/config.ts
-var MAINNET_HOST = "https://icp-api.io";
-var DEFAULT_API_BASE_URL = "https://app.liquidium.fi/api/sdk";
-var DEFAULT_ENVIRONMENT = Environment.mainnet;
-var MAINNET_CANISTER_IDS = {
-  lending: "hyk4r-jqaaa-aaaar-qb4ca-cai",
-  btcPool: "hkmli-faaaa-aaaar-qb4ba-cai",
-  ercPool: "hnnn4-iyaaa-aaaar-qb4bq-cai",
-  ethDeposit: "z5jz7-nyaaa-aaaar-qb6pq-cai",
-  instantLoans: "u5rm3-niaaa-aaaar-qb7eq-cai"
-};
-var CANISTER_IDS_BY_ENVIRONMENT = {
-  mainnet: MAINNET_CANISTER_IDS
-};
-function resolveHost(override) {
-  return override ?? MAINNET_HOST;
-}
-function resolveCanisterIds(environment = DEFAULT_ENVIRONMENT, overrides) {
-  return { ...CANISTER_IDS_BY_ENVIRONMENT[environment], ...overrides };
-}
-var DEFAULT_TIMEOUT_MS = 3e4;
-var CK_CANISTER_IDS = {
-  btcMinter: "mqygn-kiaaa-aaaar-qaadq-cai",
-  btcLedger: "mxzaz-hqaaa-aaaar-qaada-cai"};
-
 // src/core/errors.ts
 var LiquidiumErrorCode = {
   // Protocol errors
@@ -130,6 +82,127 @@ var LiquidiumError = class extends Error {
   }
 };
 
+// src/core/types.ts
+var Environment = {
+  mainnet: "mainnet"
+};
+var Asset = {
+  BTC: "BTC",
+  ICP: "ICP",
+  USDC: "USDC",
+  USDT: "USDT"
+};
+var Chain = {
+  BTC: "BTC",
+  ETH: "ETH",
+  ICP: "ICP"
+};
+function isAssetIdentifier(identifier) {
+  switch (identifier.chain) {
+    case Chain.BTC:
+      return identifier.asset === Asset.BTC;
+    case Chain.ETH:
+      return identifier.asset === Asset.USDC || identifier.asset === Asset.USDT;
+    case Chain.ICP:
+      return identifier.asset === Asset.BTC || identifier.asset === Asset.ICP || identifier.asset === Asset.USDC || identifier.asset === Asset.USDT;
+    default:
+      return false;
+  }
+}
+var SupplyAction = {
+  deposit: "deposit",
+  repayment: "repayment"
+};
+var OutflowType = {
+  borrow: "borrow",
+  feeClaim: "feeClaim",
+  withdrawal: "withdrawal"
+};
+
+// src/core/config.ts
+var MAINNET_HOST = "https://icp-api.io";
+var DEFAULT_API_BASE_URL = "https://app.liquidium.fi/api/sdk";
+var DEFAULT_ENVIRONMENT = Environment.mainnet;
+var MAINNET_CANISTER_IDS = {
+  lending: "hyk4r-jqaaa-aaaar-qb4ca-cai",
+  pools: {
+    btc: "hkmli-faaaa-aaaar-qb4ba-cai",
+    usdt: "hnnn4-iyaaa-aaaar-qb4bq-cai",
+    usdc: "6sna2-oiaaa-aaaar-qb66q-cai",
+    icp: "r2pk3-4yaaa-aaaar-qb7zq-cai"
+  },
+  ethDeposit: "z5jz7-nyaaa-aaaar-qb6pq-cai",
+  instantLoans: "u5rm3-niaaa-aaaar-qb7eq-cai"
+};
+var CANISTER_IDS_BY_ENVIRONMENT = {
+  mainnet: MAINNET_CANISTER_IDS
+};
+var SUPPORTED_CANISTER_ID_OVERRIDE_KEYS = /* @__PURE__ */ new Set([
+  "lending",
+  "pools",
+  "ethDeposit",
+  "instantLoans"
+]);
+var SUPPORTED_POOL_CANISTER_ID_OVERRIDE_KEYS = /* @__PURE__ */ new Set([
+  "btc",
+  "usdt",
+  "usdc",
+  "icp"
+]);
+function resolveHost(override) {
+  return override ?? MAINNET_HOST;
+}
+function resolveCanisterIds(environment = DEFAULT_ENVIRONMENT, overrides) {
+  const defaults = CANISTER_IDS_BY_ENVIRONMENT[environment];
+  validateCanisterIdOverrides(overrides);
+  const pools = {
+    ...defaults.pools,
+    ...overrides?.pools
+  };
+  return {
+    lending: overrides?.lending ?? defaults.lending,
+    pools,
+    ethDeposit: overrides?.ethDeposit ?? defaults.ethDeposit,
+    instantLoans: overrides?.instantLoans ?? defaults.instantLoans
+  };
+}
+function validateCanisterIdOverrides(overrides) {
+  if (!overrides) {
+    return;
+  }
+  for (const key of Object.keys(overrides)) {
+    if (!SUPPORTED_CANISTER_ID_OVERRIDE_KEYS.has(key)) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        `Unsupported canisterIds override: ${key}`
+      );
+    }
+  }
+  if (!overrides.pools) {
+    return;
+  }
+  for (const key of Object.keys(overrides.pools)) {
+    if (!SUPPORTED_POOL_CANISTER_ID_OVERRIDE_KEYS.has(key)) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        `Unsupported canisterIds.pools override: ${key}`
+      );
+    }
+  }
+}
+var DEFAULT_TIMEOUT_MS = 3e4;
+var CK_CANISTER_IDS = {
+  BTC: {
+    minter: "mqygn-kiaaa-aaaar-qaadq-cai",
+    ledger: "mxzaz-hqaaa-aaaar-qaada-cai"},
+  USDT: {
+    ledger: "cngnf-vqaaa-aaaar-qag4q-cai"},
+  USDC: {
+    ledger: "xevnm-gaaaa-aaaar-qafnq-cai"},
+  ICP: {
+    ledger: "ryjl3-tyaaa-aaaaa-aaaba-cai"}
+};
+
 // src/core/transports/api-client.ts
 var DOM_EXCEPTION_ABORT_ERROR_NAME = "AbortError";
 var HTTP_HEADER_CONTENT_TYPE = "content-type";
@@ -983,14 +1056,8 @@ function getVariantKey(variant) {
 }
 
 // src/core/wallet-actions.ts
-var TransferMode = {
-  ck: "ck",
-  native: "native"
-};
 var WalletExecutionKind = {
-  sendEthTransaction: "send-eth-transaction",
-  signMessage: "sign-message",
-  signPsbt: "sign-psbt"
+  signMessage: "sign-message"
 };
 var WalletActionKind = {
   createAccount: "create-account",
@@ -1019,8 +1086,7 @@ function executeWith(options) {
           chain: options.chain,
           message: action.message,
           account: options.account ?? action.account,
-          actionType: action.actionType,
-          transferMode: action.transferMode
+          actionType: action.actionType
         });
         return action.submit({
           signature,
@@ -1028,38 +1094,6 @@ function executeWith(options) {
           account: options.account ?? action.account
         });
       }
-      case WalletExecutionKind.signPsbt: {
-        if (!options.walletAdapter.signPsbt) {
-          throw new LiquidiumError(
-            LiquidiumErrorCode.VALIDATION_ERROR,
-            "Wallet adapter does not support PSBT signing"
-          );
-        }
-        const signedPsbtBase64 = await options.walletAdapter.signPsbt({
-          chain: Chain.BTC,
-          psbtBase64: action.psbtBase64,
-          account: options.account ?? action.account,
-          actionType: action.actionType,
-          transferMode: action.transferMode
-        });
-        return action.submit({ signedPsbtBase64 });
-      }
-      case WalletExecutionKind.sendEthTransaction: {
-        if (!options.walletAdapter.sendEthTransaction) {
-          throw new LiquidiumError(
-            LiquidiumErrorCode.VALIDATION_ERROR,
-            "Wallet adapter does not support ETH transaction sending"
-          );
-        }
-        const txHash = await options.walletAdapter.sendEthTransaction({
-          chain: Chain.ETH,
-          transaction: action.transaction,
-          account: options.account ?? action.account,
-          actionType: action.actionType,
-          transferMode: action.transferMode
-        });
-        return action.submit({ txHash });
-      }
       default:
         throw new LiquidiumError(
           LiquidiumErrorCode.VALIDATION_ERROR,
@@ -1275,7 +1309,6 @@ var AccountsModule = class {
         kind: WalletActionKind.createAccount,
         executionKind: WalletExecutionKind.signMessage,
         actionType: WalletActionKind.createAccount,
-        transferMode: TransferMode.native,
         account: normalizedAccount,
         message: createInitializeAccountMessage(expiryTimestamp, nonce),
         data: {
@@ -1366,8 +1399,8 @@ function mapCanisterWalletToWallet(canisterWallet) {
       );
   }
 }
-var KNOWN_ASSET_TAGS = ["BTC", "USDC", "USDT"];
-var KNOWN_CHAIN_TAGS = ["BTC", "ETH"];
+var KNOWN_ASSET_TAGS = ["BTC", "ICP", "USDC", "USDT"];
+var KNOWN_CHAIN_TAGS = ["BTC", "ETH", "ICP"];
 function extractVariantTag(variant, knownTags) {
   const [key] = Object.keys(variant);
   if (!key) {
@@ -1946,17 +1979,14 @@ function mapInstantLoanLookupError(error) {
 }
 function mapActivity(wire) {
   const amount = parseBigInt(wire.amount, "activity amount");
-  const activityBase = {
-    id: wire.id,
-    poolId: wire.poolId,
-    asset: wire.asset,
-    chain: wire.chain,
-    amount,
-    timestampMs: wire.timestampMs
-  };
   if (isInflowOperation(wire.status.operation)) {
     const activity = {
-      ...activityBase,
+      id: wire.id,
+      poolId: wire.poolId,
+      asset: wire.asset,
+      chain: wire.chain,
+      amount,
+      timestampMs: wire.timestampMs,
       status: wire.status
     };
     if (wire.txids) {
@@ -1969,7 +1999,12 @@ function mapActivity(wire) {
   }
   if (isOutflowOperation(wire.status.operation)) {
     const activity = {
-      ...activityBase,
+      id: wire.id,
+      poolId: wire.poolId,
+      asset: wire.asset,
+      chain: wire.chain,
+      amount,
+      timestampMs: wire.timestampMs,
       status: wire.status
     };
     if (wire.txids) {
@@ -2145,6 +2180,72 @@ function validateHistoryStateFilter(state) {
       );
   }
 }
+var LiquidiumAccountType = {
+  ChainAddress: "ChainAddress",
+  IcPrincipal: "IcPrincipal",
+  IcpAccountIdentifier: "IcpAccountIdentifier",
+  IcrcAccount: "IcrcAccount"
+};
+function createIcrcAccount(params) {
+  return {
+    type: "IcrcAccount",
+    owner: params.owner.toText(),
+    subaccount: params.subaccount,
+    address: icrc.encodeIcrcAccount({
+      owner: params.owner,
+      subaccount: params.subaccount
+    })
+  };
+}
+function mapCanisterAccountToLiquidiumAccount(account) {
+  if ("Native" in account) {
+    return { type: "IcPrincipal", address: account.Native.toText() };
+  }
+  if ("AccountIdentifier" in account) {
+    return {
+      type: "IcpAccountIdentifier",
+      address: account.AccountIdentifier
+    };
+  }
+  if ("Icrc" in account) {
+    const subaccount = normalizeOptionalSubaccount(account.Icrc.subaccount[0]);
+    return {
+      type: "IcrcAccount",
+      owner: account.Icrc.owner.toText(),
+      subaccount,
+      address: icrc.encodeIcrcAccount({
+        owner: account.Icrc.owner,
+        subaccount
+      })
+    };
+  }
+  return { type: "ChainAddress", address: account.External };
+}
+function decodeIcrcAccountAddress(address) {
+  const decoded = icrc.decodeIcrcAccount(address);
+  const owner = principal.Principal.fromText(decoded.owner.toText());
+  const subaccount = decoded.subaccount ? Uint8Array.from(decoded.subaccount) : void 0;
+  return {
+    owner,
+    subaccount,
+    account: createIcrcAccount({ owner, subaccount })
+  };
+}
+function encodeIcpAccountIdentifier(params) {
+  return icp.AccountIdentifier.fromPrincipal({
+    principal: params.owner,
+    subAccount: params.subaccount ? icp.SubAccount.fromBytes(params.subaccount) : void 0
+  }).toHex();
+}
+function normalizeIcpAccountIdentifier(address) {
+  return icp.AccountIdentifier.fromHex(address).toHex();
+}
+function normalizeOptionalSubaccount(subaccount) {
+  if (!subaccount) {
+    return void 0;
+  }
+  return subaccount instanceof Uint8Array ? subaccount : Uint8Array.from(subaccount);
+}
 
 // src/core/status.ts
 function createLiquidiumStatus(params) {
@@ -2194,6 +2295,7 @@ function throwInvalidApiResponseField(field) {
 // src/core/utils/asset-decimals.ts
 var ASSET_NATIVE_DECIMALS = {
   BTC: 8n,
+  ICP: 8n,
   USDC: 6n,
   USDT: 6n,
   SOL: 9n
@@ -2589,7 +2691,7 @@ var idlFactory2 = ({ IDL }) => {
 
 // src/core/canisters/ckbtc/minter.ts
 function createCkBtcMinterActor(canisterContext) {
-  const canisterId = CK_CANISTER_IDS.btcMinter;
+  const canisterId = CK_CANISTER_IDS.BTC.minter;
   return agent.Actor.createActor(idlFactory2, {
     agent: canisterContext.agent,
     canisterId
@@ -3040,55 +3142,43 @@ var EvmSupplyApprovalStrategy = {
 };
 
 // src/modules/lending/_internal/supply-targets.ts
-async function resolveSupplyTarget(canisterContext, request) {
-  const selectedPool = await getPoolById(canisterContext, request.poolId);
-  const asset = selectedPool.asset;
-  const chain = selectedPool.chain;
+async function resolveSupplyTargetForPool(canisterContext, request, selectedPool) {
+  const identifier = resolveSupplyAssetIdentifier({
+    asset: selectedPool.asset,
+    poolChain: selectedPool.chain,
+    transferChain: request.chain ?? selectedPool.chain
+  });
   const mechanism = resolveSupplyMechanism({
-    asset,
-    chain,
-    requestedMechanism: request.mechanism
+    identifier,
+    mechanism: request.mechanism
   });
-  switch (mechanism) {
-    case SupplyPlanType.transfer:
-      return await getNativeAddressSupplyTarget(
-        canisterContext,
-        request.profileId,
-        {
-          poolId: request.poolId,
-          asset,
-          chain,
-          action: request.action
-        }
-      );
-    case SupplyPlanType.contractInteraction:
-      return getIcrcAccountSupplyTarget(request.profileId, {
-        poolId: request.poolId,
-        asset,
-        chain,
-        action: request.action
-      });
+  const targetRequest = {
+    ...identifier,
+    poolId: request.poolId,
+    action: request.action
+  };
+  if (mechanism === SupplyPlanType.contractInteraction) {
+    return getIcrcAccountSupplyTarget(request.profileId, targetRequest);
   }
+  if (identifier.chain === Chain.ICP) {
+    return identifier.asset === Asset.ICP ? getIcpLedgerSupplyTarget(request.profileId, targetRequest) : getIcrcAccountSupplyTarget(request.profileId, targetRequest);
+  }
+  return await getChainAddressSupplyTarget(
+    canisterContext,
+    request.profileId,
+    targetRequest
+  );
 }
 function resolveSupplyMechanism(params) {
-  if (params.asset === Asset.BTC && params.chain === Chain.BTC) {
-    if (params.requestedMechanism === SupplyPlanType.contractInteraction) {
-      throw new LiquidiumError(
-        LiquidiumErrorCode.VALIDATION_ERROR,
-        "Contract-interaction supply is not supported for BTC on BTC"
-      );
-    }
+  if (params.mechanism !== SupplyPlanType.contractInteraction) {
     return SupplyPlanType.transfer;
   }
-  if (isEthStablecoin(params.asset, params.chain)) {
-    if (params.requestedMechanism) {
-      return params.requestedMechanism;
-    }
-    return SupplyPlanType.transfer;
+  if (params.identifier.chain === Chain.ETH && (params.identifier.asset === Asset.USDC || params.identifier.asset === Asset.USDT)) {
+    return SupplyPlanType.contractInteraction;
   }
   throw new LiquidiumError(
     LiquidiumErrorCode.VALIDATION_ERROR,
-    `No supply mechanism is configured for ${params.asset} on ${params.chain}`
+    `Contract-interaction supply is not supported for ${params.identifier.asset} on ${params.identifier.chain}`
   );
 }
 function isEthStablecoin(asset, chain) {
@@ -3160,9 +3250,33 @@ async function getPoolById(canisterContext, poolId) {
   }
   return decodedPool;
 }
-async function getNativeAddressSupplyTarget(canisterContext, profileId, request) {
-  assertSupportsNativeAddressInflowTarget(request.asset, request.chain);
-  if (isEthStablecoin(request.asset, request.chain)) {
+function resolveSupplyAssetIdentifier(params) {
+  if (params.asset === Asset.BTC && params.poolChain === Chain.BTC) {
+    if (params.transferChain === Chain.BTC) {
+      return { asset: Asset.BTC, chain: Chain.BTC };
+    }
+    if (params.transferChain === Chain.ICP) {
+      return { asset: Asset.BTC, chain: Chain.ICP };
+    }
+  }
+  if ((params.asset === Asset.USDC || params.asset === Asset.USDT) && params.poolChain === Chain.ETH) {
+    if (params.transferChain === Chain.ETH) {
+      return { asset: params.asset, chain: Chain.ETH };
+    }
+    if (params.transferChain === Chain.ICP) {
+      return { asset: params.asset, chain: Chain.ICP };
+    }
+  }
+  if (params.asset === Asset.ICP && params.poolChain === Chain.ICP && params.transferChain === Chain.ICP) {
+    return { asset: Asset.ICP, chain: Chain.ICP };
+  }
+  throw new LiquidiumError(
+    LiquidiumErrorCode.VALIDATION_ERROR,
+    `Supply is not supported for ${params.asset} pool on ${params.poolChain} using ${params.transferChain}`
+  );
+}
+async function getChainAddressSupplyTarget(canisterContext, profileId, request) {
+  if (request.chain === Chain.ETH) {
     const tokenAddress = getEthStablecoinContractAddress(request.asset);
     const subaccount2 = encodeInflowSubaccount({
       action: request.action,
@@ -3181,7 +3295,6 @@ async function getNativeAddressSupplyTarget(canisterContext, profileId, request)
       throw mapDepositAccountErrorToLiquidiumError(result.Err);
     }
     return {
-      type: "nativeAddress",
       poolId: request.poolId,
       asset: request.asset,
       chain: request.chain,
@@ -3189,11 +3302,11 @@ async function getNativeAddressSupplyTarget(canisterContext, profileId, request)
       address: result.Ok
     };
   }
-  const configuredBtcPoolId = canisterContext.canisterIds.btcPool;
+  const configuredBtcPoolId = canisterContext.canisterIds.pools.btc;
   if (request.poolId !== configuredBtcPoolId) {
     throw new LiquidiumError(
       LiquidiumErrorCode.VALIDATION_ERROR,
-      `Native BTC inflow targets require the configured BTC pool ${configuredBtcPoolId}, received ${request.poolId}`
+      `Chain-address BTC inflow targets require the configured BTC pool ${configuredBtcPoolId}, received ${request.poolId}`
     );
   }
   const subaccount = encodeInflowSubaccount({
@@ -3206,66 +3319,51 @@ async function getNativeAddressSupplyTarget(canisterContext, profileId, request)
       subaccount: [subaccount]
     }
   );
-  return {
-    type: "nativeAddress",
-    poolId: request.poolId,
-    asset: request.asset,
-    chain: request.chain,
-    action: request.action,
-    address
-  };
+  return { ...request, address };
 }
 function getIcrcAccountSupplyTarget(profileId, request) {
-  assertSupportsIcrcAccountInflowTarget(request.asset);
+  const account = createInflowIcrcAccount(profileId, request);
+  return { ...request, address: account.address };
+}
+function getIcpLedgerSupplyTarget(profileId, request) {
   const poolPrincipal = principal.Principal.fromText(request.poolId);
   const subaccount = encodeInflowSubaccount({
     action: request.action,
     principal: principal.Principal.fromText(profileId)
   });
+  const account = createIcrcAccount({
+    owner: poolPrincipal,
+    subaccount
+  });
   return {
-    type: "icrcAccount",
     poolId: request.poolId,
-    asset: request.asset,
-    chain: request.chain,
+    asset: Asset.ICP,
+    chain: Chain.ICP,
     action: request.action,
-    owner: poolPrincipal.toText(),
-    subaccount,
-    account: icrc.encodeIcrcAccount({
+    address: account.address,
+    icpAccountIdentifier: encodeIcpAccountIdentifier({
       owner: poolPrincipal,
       subaccount
     })
   };
 }
-function assertSupportsNativeAddressInflowTarget(asset, chain) {
-  if (asset === Asset.BTC && chain === Chain.BTC) {
-    return;
-  }
-  if (isEthStablecoin(asset, chain)) {
-    return;
-  }
-  throw new LiquidiumError(
-    LiquidiumErrorCode.VALIDATION_ERROR,
-    `Native address inflow targets are not supported for ${asset} on ${chain}`
-  );
-}
-function assertSupportsIcrcAccountInflowTarget(asset) {
-  if (asset === Asset.BTC || asset === Asset.USDT || asset === Asset.USDC) {
-    return;
-  }
-  throw new LiquidiumError(
-    LiquidiumErrorCode.VALIDATION_ERROR,
-    `ICRC account inflow targets are not supported for ${asset}`
-  );
+function createInflowIcrcAccount(profileId, request) {
+  return createIcrcAccount({
+    owner: principal.Principal.fromText(request.poolId),
+    subaccount: encodeInflowSubaccount({
+      action: request.action,
+      principal: principal.Principal.fromText(profileId)
+    })
+  });
 }
 
 // src/core/borrow-minimums.ts
+var MINIMUM_BTC_BORROW_AMOUNT_SATS = 5100n;
+var MINIMUM_STABLECOIN_BORROW_AMOUNT_BASE_UNITS = 1000000n;
 var MIN_BORROW_AMOUNTS_BY_ASSET = {
-  BTC: 5100n,
-  // 5,100 sats = 0.000051 BTC
-  USDC: 1000000n,
-  // 1 USDC
-  USDT: 1000000n
-  // 1 USDT
+  [Asset.BTC]: MINIMUM_BTC_BORROW_AMOUNT_SATS,
+  [Asset.USDC]: MINIMUM_STABLECOIN_BORROW_AMOUNT_BASE_UNITS,
+  [Asset.USDT]: MINIMUM_STABLECOIN_BORROW_AMOUNT_BASE_UNITS
 };
 function getMinimumBorrowAmount(asset) {
   if (!isMinimumBorrowAsset(asset)) {
@@ -3730,25 +3828,20 @@ function isEthStablecoin2(asset) {
 }
 
 // src/modules/instant-loans/_internal/address-validation.ts
-function validateInstantLoanBorrowDestination(address, asset) {
+function validateInstantLoanBorrowDestination(address, asset, chain) {
   return normalizeExternalAddress({
     address,
     asset,
-    chain: getChainForInstantLoanAsset(asset)
+    chain
   });
 }
-function validateInstantLoanRefundDestination(address, asset) {
+function validateInstantLoanRefundDestination(address, asset, chain) {
   return normalizeExternalAddress({
     address,
     asset,
-    chain: getChainForInstantLoanAsset(asset)
+    chain
   });
 }
-function getChainForInstantLoanAsset(asset) {
-  if (asset === Asset.BTC) return Chain.BTC;
-  if (asset === Asset.USDC || asset === Asset.USDT) return Chain.ETH;
-  return asset;
-}
 
 // src/modules/instant-loans/instant-loans.ts
 var REPAYMENT_BUFFER_SECONDS = 86400n;
@@ -3761,10 +3854,32 @@ var INSTANT_LOAN_FIND_QUERY_MAX_LENGTH = 256;
 var INSTANT_LOAN_WIRE_CONTEXT = "instant loan";
 var INSTANT_LOAN_ASSETS = [
   Asset.BTC,
-  Asset.SOL,
+  Asset.ICP,
   Asset.USDC,
   Asset.USDT
 ];
+var INSTANT_LOAN_CHAINS = [
+  Chain.BTC,
+  Chain.ETH,
+  Chain.ICP
+];
+var ICP_ACCOUNT_IDENTIFIER_HEX_LENGTH = 64;
+var InstantLoanCreatedError = class extends Error {
+  code = "INSTANT_LOAN_HYDRATION_FAILED";
+  loanId;
+  ref;
+  cause;
+  constructor(loanId, cause) {
+    const ref = publicIdFromInt(loanId);
+    super(
+      `Instant loan ${ref} was created, but its enriched state could not be loaded`
+    );
+    this.name = "InstantLoanCreatedError";
+    this.loanId = loanId;
+    this.ref = ref;
+    this.cause = cause;
+  }
+};
 var InstantLoansModule = class {
   constructor(canisterContext, apiClient, activities, lending, positions) {
     this.canisterContext = canisterContext;
@@ -3787,37 +3902,39 @@ var InstantLoansModule = class {
    * selected pool decimals, and call `client.quote.calculateLtv(...)` before
    * creation to block invalid LTV input.
    *
-   * `borrowDestination` receives the borrowed asset after the loan starts.
-   * `refundDestination` receives collateral refunds or withdrawals. Use
+   * `borrow.destination` receives the borrowed asset after the loan starts.
+   * `refund.destination` receives collateral refunds or withdrawals. Use
    * `depositWindowSeconds` for the user-facing collateral deposit timeout; the
    * SDK maps it to the canister's internal `ltv_timer_s` field.
    *
-   * @param request - Pool ids, assets, base-unit amounts, LTV limit, timeout, and destinations.
+   * @param request - Collateral, borrow, refund, LTV limit, timeout, and inflow options.
    * @returns Hydrated loan state plus generated initial-deposit and repayment quote targets.
    */
   async create(request) {
     validateCreateRequest(request);
-    const borrowDestination = {
-      External: validateInstantLoanBorrowDestination(
-        addressFromAccountInput(request.borrowDestination),
-        request.borrowAsset
-      )
-    };
-    const refundDestination = {
-      External: validateInstantLoanRefundDestination(
-        addressFromAccountInput(request.refundDestination),
-        request.collateralAsset
-      )
-    };
+    const borrowDestination = resolveInstantLoanDestination({
+      destination: request.borrow.destination,
+      asset: request.borrow.asset,
+      role: "borrow",
+      chain: request.borrow.chain,
+      normalizeExternalDestination: validateInstantLoanBorrowDestination
+    });
+    const refundDestination = resolveInstantLoanDestination({
+      destination: request.refund.destination,
+      asset: request.collateral.asset,
+      role: "refund",
+      chain: request.refund.chain,
+      normalizeExternalDestination: validateInstantLoanRefundDestination
+    });
     const apiClient = this.requireApi("Instant loan creation");
     await this.validateInstantLoanLtvPolicy(request);
     const response = await apiClient.post(SdkApiPath.instantLoans, {
-      collateralPoolId: request.collateralPoolId,
-      borrowPoolId: request.borrowPoolId,
-      collateralAsset: request.collateralAsset,
-      borrowAsset: request.borrowAsset,
-      collateralAmount: request.collateralAmount.toString(),
-      borrowAmount: request.borrowAmount.toString(),
+      collateralPoolId: request.collateral.poolId,
+      borrowPoolId: request.borrow.poolId,
+      collateralAsset: request.collateral.asset,
+      borrowAsset: request.borrow.asset,
+      collateralAmount: request.collateral.amount.toString(),
+      borrowAmount: request.borrow.amount.toString(),
       ltvMaxBps: request.ltvMaxBps.toString(),
       depositWindowSeconds: request.depositWindowSeconds.toString(),
       borrowDestination,
@@ -3827,15 +3944,21 @@ var InstantLoansModule = class {
       context: INSTANT_LOAN_WIRE_CONTEXT,
       label: "loan ID"
     });
-    const collateralAmount = parseUnsignedApiBigint(
-      response.loan.collateral.amountHint,
-      {
-        context: INSTANT_LOAN_WIRE_CONTEXT,
-        label: "collateral amount"
-      }
-    );
-    const record = await this.getLoanRecord(loanId);
-    return await this.mapLoanRecord(record, collateralAmount);
+    try {
+      const collateralAmount = parseUnsignedApiBigint(
+        response.loan.collateral.amountHint,
+        {
+          context: INSTANT_LOAN_WIRE_CONTEXT,
+          label: "collateral amount"
+        }
+      );
+      const record = await this.getLoanRecord(loanId);
+      return await this.mapLoanRecord(record, collateralAmount, {
+        borrowChain: request.borrow.chain
+      });
+    } catch (cause) {
+      throw new InstantLoanCreatedError(loanId, cause);
+    }
   }
   /**
    * Resolves canonical canister state by loan id or short reference.
@@ -4001,7 +4124,16 @@ var InstantLoansModule = class {
       throw mapCanisterCallErrorToLiquidiumError("get_loan", error);
     }
   }
-  async mapLoanRecord(record, collateralAmount) {
+  async mapLoanRecord(record, collateralAmount, chainOptions = {}) {
+    const borrowDestination = accountFromCanister(record.borrow_destination);
+    const collateralAsset = parseInstantLoanAsset(
+      record.lend_asset,
+      "collateral asset"
+    );
+    const borrowAsset = parseInstantLoanAsset(
+      record.borrow_asset,
+      "borrow asset"
+    );
     return await this.hydrateLoan({
       loanId: record.id,
       profileId: record.lending_profile.toText(),
@@ -4010,17 +4142,18 @@ var InstantLoansModule = class {
       collateralPoolId: record.lend_pool_id.toText(),
       collateralAmount,
       borrowPoolId: record.borrow_pool_id.toText(),
-      collateralAsset: record.lend_asset,
-      borrowAsset: record.borrow_asset,
+      collateralAsset,
+      borrowAsset,
       borrowAmount: record.borrow_amount,
-      borrowDestination: accountFromCanister(record.borrow_destination),
+      borrowDestination,
       refundDestination: accountFromCanister(record.refund_destination),
       started: record.started,
       depositDetectedTimestamp: record.deposit_detected_ts[0] ?? null,
       expiryTimestamp: record.expires_at[0] ?? deriveDepositExpiryTimestamp({
         depositDetectedTimestamp: record.deposit_detected_ts[0] ?? null,
         depositWindowSeconds: record.ltv_timer_s
-      })
+      }),
+      borrowChain: chainOptions.borrowChain ?? inferInstantLoanDeliveryChain(borrowDestination, borrowAsset)
     });
   }
   async getCollateralAmountHint(loanId) {
@@ -4040,24 +4173,22 @@ var InstantLoansModule = class {
     const collateralAsset = input.collateralAsset;
     const borrowAsset = input.borrowAsset;
     const [
-      depositTarget,
-      repayTarget,
+      depositTargetSet,
+      repaymentTargetSet,
       collateralPosition,
       borrowPosition,
       borrowPoolRate,
       activeActivities
     ] = await Promise.all([
-      resolveSupplyTarget(this.canisterContext, {
+      this.resolveInstantLoanInflowTargets({
         profileId,
         poolId: collateralPoolId,
-        action: SupplyAction.deposit,
-        mechanism: SupplyPlanType.transfer
+        action: SupplyAction.deposit
       }),
-      resolveSupplyTarget(this.canisterContext, {
+      this.resolveInstantLoanInflowTargets({
         profileId,
         poolId: borrowPoolId,
-        action: SupplyAction.repayment,
-        mechanism: SupplyPlanType.transfer
+        action: SupplyAction.repayment
       }),
       this.positions.getPosition(profileId, collateralPoolId),
       this.positions.getPosition(profileId, borrowPoolId),
@@ -4069,8 +4200,6 @@ var InstantLoansModule = class {
       borrowPosition,
       borrowPoolRate.borrowRate
     );
-    const repaymentInflowFee = totalDebtAmount > 0n ? await this.estimateRepaymentInflowFee(borrowAsset, repayTarget.chain) : { totalFee: 0n, estimateAvailable: false };
-    const repaymentAmount = totalDebtAmount + interestBufferAmount + repaymentInflowFee.totalFee;
     const currentCollateralAmount = collateralPosition?.deposited ?? 0n;
     const collateralAmount = input.collateralAmount;
     const collateralDecimals = collateralPosition?.depositedDecimals ?? getAssetNativeDecimals(collateralAsset);
@@ -4090,22 +4219,28 @@ var InstantLoansModule = class {
       collateralAmount,
       decimals: collateralDecimals,
       asset: collateralAsset,
-      target: depositTarget,
+      targets: depositTargetSet.targets,
       detectedTimestamp: input.depositDetectedTimestamp,
       expiryTimestamp: input.expiryTimestamp
     });
+    const repaymentTargets = await this.createRepaymentTargetQuotes({
+      baseRepaymentAmount: totalDebtAmount + interestBufferAmount,
+      asset: borrowAsset,
+      targets: repaymentTargetSet.targets
+    });
     const repayment = {
-      amount: repaymentAmount,
       decimals: borrowedDecimals,
       debtAmount: totalDebtAmount,
       interestBufferAmount,
       interestBufferSeconds: REPAYMENT_BUFFER_SECONDS,
-      inflowFeeAmount: repaymentInflowFee.totalFee,
-      inflowFeeEstimateAvailable: repaymentInflowFee.estimateAvailable,
       asset: borrowAsset,
-      chain: repayTarget.chain,
-      target: repayTarget
+      targets: repaymentTargets
     };
+    const borrowIdentifier = getInstantLoanAssetIdentifier(
+      borrowAsset,
+      input.borrowChain,
+      "borrow"
+    );
     return {
       loanId: input.loanId,
       ref: publicIdFromInt(input.loanId),
@@ -4116,16 +4251,14 @@ var InstantLoansModule = class {
         depositWindowSeconds: input.depositWindowSeconds
       },
       collateral: {
-        poolId: collateralPoolId,
         asset: collateralAsset,
-        chain: depositTarget.chain,
+        poolId: collateralPoolId,
         decimals: collateralDecimals,
         amount: collateralAmount
       },
       borrow: {
+        ...borrowIdentifier,
         poolId: borrowPoolId,
-        asset: borrowAsset,
-        chain: repayTarget.chain,
         decimals: borrowedDecimals,
         amount: input.borrowAmount,
         destination: input.borrowDestination
@@ -4145,32 +4278,81 @@ var InstantLoansModule = class {
     };
   }
   async createInitialDepositQuote(input) {
-    const inflowFee = await this.lending.estimateInflowFee({
-      asset: input.asset,
-      chain: input.target.chain
-    });
+    const targets = {};
+    for (const chain of INSTANT_LOAN_CHAINS) {
+      const target = input.targets[chain];
+      if (!target) continue;
+      assertTargetAsset(target, input.asset);
+      const inflowFee = await this.lending.estimateInflowFee(target);
+      targets[chain] = {
+        amount: input.collateralAmount + inflowFee.totalFee,
+        inflowFeeAmount: inflowFee.totalFee,
+        target
+      };
+    }
     return {
-      amount: input.collateralAmount + inflowFee.totalFee,
       decimals: input.decimals,
       collateralAmount: input.collateralAmount,
-      inflowFeeAmount: inflowFee.totalFee,
       asset: input.asset,
-      chain: input.target.chain,
-      target: input.target,
+      targets,
       detectedTimestamp: input.detectedTimestamp,
       expiryTimestamp: input.expiryTimestamp
     };
   }
-  async estimateRepaymentInflowFee(asset, chain) {
+  async resolveInstantLoanInflowTargets(request) {
+    const selectedPool = await getPoolById(
+      this.canisterContext,
+      request.poolId
+    );
+    const baseRequest = {
+      profileId: request.profileId,
+      poolId: request.poolId,
+      action: request.action,
+      mechanism: SupplyPlanType.transfer
+    };
+    const poolChainTarget = await resolveSupplyTargetForPool(
+      this.canisterContext,
+      baseRequest,
+      selectedPool
+    );
+    const poolChain = poolChainTarget.chain;
+    const targets = {
+      [poolChain]: poolChainTarget
+    };
+    if (poolChain === Chain.ICP) {
+      return { targets };
+    }
+    const icpTarget = await resolveSupplyTargetForPool(
+      this.canisterContext,
+      { ...baseRequest, chain: Chain.ICP },
+      selectedPool
+    );
+    targets[Chain.ICP] = icpTarget;
+    return { targets };
+  }
+  async createRepaymentTargetQuotes(input) {
+    const quotes = {};
+    for (const chain of INSTANT_LOAN_CHAINS) {
+      const target = input.targets[chain];
+      if (!target) continue;
+      assertTargetAsset(target, input.asset);
+      const repaymentInflowFee = input.baseRepaymentAmount > 0n ? await this.estimateRepaymentInflowFee(target) : { totalFee: 0n, estimateAvailable: false };
+      quotes[chain] = {
+        amount: input.baseRepaymentAmount + repaymentInflowFee.totalFee,
+        inflowFeeAmount: repaymentInflowFee.totalFee,
+        inflowFeeEstimateAvailable: repaymentInflowFee.estimateAvailable,
+        target
+      };
+    }
+    return quotes;
+  }
+  async estimateRepaymentInflowFee(target) {
     try {
-      const fee = await this.lending.estimateInflowFee({
-        asset,
-        chain
-      });
+      const fee = await this.lending.estimateInflowFee(target);
       return { totalFee: fee.totalFee, estimateAvailable: true };
     } catch {
       return {
-        totalFee: getRepaymentInflowFeeFallback(asset, chain),
+        totalFee: getRepaymentInflowFeeFallback(target.asset, target.chain),
         estimateAvailable: false
       };
     }
@@ -4206,10 +4388,10 @@ var InstantLoansModule = class {
     ]);
     const ltvCalculation = new QuoteModule().calculateLtv(
       {
-        borrowAmount: request.borrowAmount,
-        borrowPoolId: request.borrowPoolId,
-        collateralAmount: request.collateralAmount,
-        collateralPoolId: request.collateralPoolId
+        borrowAmount: request.borrow.amount,
+        borrowPoolId: request.borrow.poolId,
+        collateralAmount: request.collateral.amount,
+        collateralPoolId: request.collateral.poolId
       },
       pools,
       assetPrices
@@ -4231,6 +4413,15 @@ function getRepaymentInflowFeeFallback(asset, chain) {
   }
   return 0n;
 }
+function assertTargetAsset(target, expectedAsset) {
+  if (target.asset === expectedAsset) {
+    return;
+  }
+  throw new LiquidiumError(
+    LiquidiumErrorCode.INTERNAL,
+    `Instant loan pool target asset ${target.asset} does not match ${expectedAsset}`
+  );
+}
 function calculateInterestBufferAmount(borrowPosition, annualBorrowRate) {
   const totalDebtAmount = calculateTotalDebtAmount(borrowPosition);
   if (totalDebtAmount <= 0n || annualBorrowRate <= 0n) {
@@ -4323,13 +4514,23 @@ function deriveDepositExpiryTimestamp(input) {
   return input.depositDetectedTimestamp + input.depositWindowSeconds;
 }
 function validateCreateRequest(request) {
-  if (request.collateralAmount <= 0n) {
+  getInstantLoanAssetIdentifier(
+    request.borrow.asset,
+    request.borrow.chain,
+    "borrow"
+  );
+  getInstantLoanAssetIdentifier(
+    request.collateral.asset,
+    request.refund.chain,
+    "refund"
+  );
+  if (request.collateral.amount <= 0n) {
     throw new LiquidiumError(
       LiquidiumErrorCode.VALIDATION_ERROR,
       "Instant loan collateral amount must be greater than zero"
     );
   }
-  if (request.borrowAmount <= 0n) {
+  if (request.borrow.amount <= 0n) {
     throw new LiquidiumError(
       LiquidiumErrorCode.VALIDATION_ERROR,
       "Instant loan borrow amount must be greater than zero"
@@ -4354,45 +4555,200 @@ function throwLtvCalculationError(error) {
     error?.message ?? "Unable to calculate instant loan LTV"
   );
 }
-function addressFromAccountInput(account) {
-  const address = typeof account === "string" ? account.trim() : account.address.trim();
-  if (!address) {
+function inferInstantLoanDeliveryChain(destination, asset) {
+  if (destination.type !== "ChainAddress") {
+    return Chain.ICP;
+  }
+  if (asset === Asset.BTC) {
+    return Chain.BTC;
+  }
+  if (asset === Asset.USDC || asset === Asset.USDT) {
+    return Chain.ETH;
+  }
+  return Chain.ICP;
+}
+function resolveInstantLoanDestination(params) {
+  getInstantLoanAssetIdentifier(params.asset, params.chain, params.role);
+  if (typeof params.destination === "string") {
+    return resolveInstantLoanStringDestination({
+      destination: params.destination,
+      asset: params.asset,
+      role: params.role,
+      chain: params.chain,
+      normalizeExternalDestination: params.normalizeExternalDestination
+    });
+  }
+  assertInstantLoanDestinationTypeMatchesChain({
+    destinationType: params.destination.type,
+    asset: params.asset,
+    role: params.role,
+    chain: params.chain
+  });
+  switch (params.destination.type) {
+    case "ChainAddress":
+      assertExternalInstantLoanDestinationSupported(params.asset);
+      return {
+        External: params.normalizeExternalDestination(
+          normalizeInstantLoanDestinationAddress(params.destination.address),
+          params.asset,
+          params.chain
+        )
+      };
+    case "IcPrincipal":
+      return {
+        Native: normalizeInstantLoanPrincipal(
+          normalizeInstantLoanDestinationAddress(params.destination.address)
+        )
+      };
+    case "IcpAccountIdentifier":
+      return parseAccountIdentifierInstantLoanDestination(
+        normalizeInstantLoanDestinationAddress(params.destination.address)
+      );
+    case "IcrcAccount":
+      return parseIcrcInstantLoanDestination(
+        normalizeInstantLoanDestinationAddress(params.destination.address)
+      );
+  }
+}
+function resolveInstantLoanStringDestination(params) {
+  const address = normalizeInstantLoanDestinationAddress(params.destination);
+  if (params.chain === Chain.ICP && params.asset !== Asset.ICP) {
+    try {
+      return parsePrincipalInstantLoanDestination(address);
+    } catch {
+      throwInvalidCkInstantLoanDestination(params.role);
+    }
+  }
+  if (params.chain !== Chain.ICP) {
+    assertExternalInstantLoanDestinationSupported(params.asset);
+    return {
+      External: params.normalizeExternalDestination(
+        address,
+        params.asset,
+        params.chain
+      )
+    };
+  }
+  for (const parser of [
+    parseAccountIdentifierInstantLoanDestination,
+    parsePrincipalInstantLoanDestination,
+    parseIcrcInstantLoanDestination
+  ]) {
+    try {
+      return parser(address);
+    } catch {
+    }
+  }
+  throwInvalidIcpInstantLoanDestination();
+}
+function getInstantLoanAssetIdentifier(asset, chain, role) {
+  const identifier = { asset, chain };
+  if (isAssetIdentifier(identifier)) {
+    return identifier;
+  }
+  throw new LiquidiumError(
+    LiquidiumErrorCode.VALIDATION_ERROR,
+    `${chain} instant loan ${role} delivery is not supported for ${asset}`
+  );
+}
+function assertInstantLoanDestinationTypeMatchesChain(params) {
+  if (params.chain === Chain.ICP && params.asset !== Asset.ICP) {
+    if (params.destinationType === "IcPrincipal") {
+      return;
+    }
+    throwInvalidCkInstantLoanDestination(params.role);
+  }
+  if (params.chain === Chain.ICP && params.asset === Asset.ICP) {
+    if (params.destinationType !== "ChainAddress") {
+      return;
+    }
+    throwInvalidIcpInstantLoanDestination();
+  }
+  if (params.destinationType === "ChainAddress") {
+    return;
+  }
+  if (params.destinationType === "IcPrincipal") {
     throw new LiquidiumError(
       LiquidiumErrorCode.VALIDATION_ERROR,
-      "Instant loan account address must be non-empty"
+      `${params.chain} instant loan ${params.role} destination must be an external chain address for ${params.asset}`
     );
   }
-  return address;
+  throw new LiquidiumError(
+    LiquidiumErrorCode.VALIDATION_ERROR,
+    `${params.asset} instant loan ${params.role} destination only supports ChainAddress or IcPrincipal destinations`
+  );
 }
-function accountFromCanister(account) {
-  if ("Native" in account) {
-    return { type: "Native", principal: account.Native.toText() };
+function throwInvalidCkInstantLoanDestination(role) {
+  throw new LiquidiumError(
+    LiquidiumErrorCode.VALIDATION_ERROR,
+    `ICP instant loan ${role} destination must be an IC principal`
+  );
+}
+function assertExternalInstantLoanDestinationSupported(asset) {
+  if (asset !== Asset.ICP) {
+    return;
   }
-  if ("AccountIdentifier" in account) {
-    return {
-      type: "AccountIdentifier",
-      address: account.AccountIdentifier
-    };
+  throwInvalidIcpInstantLoanDestination();
+}
+function throwInvalidIcpInstantLoanDestination() {
+  throw new LiquidiumError(
+    LiquidiumErrorCode.INVALID_ADDRESS,
+    "ICP instant loan destination must be an IC principal, ICP account identifier, or ICRC account"
+  );
+}
+function parsePrincipalInstantLoanDestination(address) {
+  return { Native: normalizeInstantLoanPrincipal(address) };
+}
+function parseAccountIdentifierInstantLoanDestination(address) {
+  if (address.length !== ICP_ACCOUNT_IDENTIFIER_HEX_LENGTH) {
+    throw new LiquidiumError(
+      LiquidiumErrorCode.INVALID_ADDRESS,
+      "Invalid ICP account identifier"
+    );
   }
-  if ("Icrc" in account) {
-    const subaccount = normalizeOptionalSubaccount(account.Icrc.subaccount[0]);
-    return {
-      type: "Icrc",
-      owner: account.Icrc.owner.toText(),
-      subaccount,
-      address: icrc.encodeIcrcAccount({
-        owner: account.Icrc.owner,
-        subaccount
-      })
-    };
+  try {
+    return { AccountIdentifier: normalizeIcpAccountIdentifier(address) };
+  } catch {
+    throw new LiquidiumError(
+      LiquidiumErrorCode.INVALID_ADDRESS,
+      "Invalid ICP account identifier"
+    );
   }
-  return { type: "External", address: account.External };
 }
-function normalizeOptionalSubaccount(subaccount) {
-  if (!subaccount) {
-    return void 0;
+function parseIcrcInstantLoanDestination(address) {
+  let decoded;
+  try {
+    decoded = decodeIcrcAccountAddress(address);
+  } catch {
+    throw new LiquidiumError(
+      LiquidiumErrorCode.INVALID_ADDRESS,
+      "Invalid instant loan ICRC destination"
+    );
   }
-  return subaccount instanceof Uint8Array ? subaccount : Uint8Array.from(subaccount);
+  return { Icrc: decoded.account.address };
+}
+function normalizeInstantLoanPrincipal(address) {
+  try {
+    return principal.Principal.fromText(address).toText();
+  } catch {
+    throw new LiquidiumError(
+      LiquidiumErrorCode.INVALID_ADDRESS,
+      "Invalid instant loan IC principal destination"
+    );
+  }
+}
+function normalizeInstantLoanDestinationAddress(address) {
+  const trimmedAddress = address.trim();
+  if (!trimmedAddress) {
+    throw new LiquidiumError(
+      LiquidiumErrorCode.VALIDATION_ERROR,
+      "Instant loan account address must be non-empty"
+    );
+  }
+  return trimmedAddress;
+}
+function accountFromCanister(account) {
+  return mapCanisterAccountToLiquidiumAccount(account);
 }
 function mapInstantLoanEvent(event) {
   return {
@@ -4409,7 +4765,10 @@ function mapInstantLoanEventType(eventType) {
       type: "LoanCreated",
       loanId: event.loan_id,
       borrowDestination: accountFromCanister(event.borrow_destination),
-      collateralAsset: event.lend_asset,
+      collateralAsset: parseInstantLoanAsset(
+        event.lend_asset,
+        "event collateral asset"
+      ),
       borrowAmount: event.borrow_amount,
       collateralPoolId: event.lend_pool_id.toText(),
       refundDestination: accountFromCanister(event.refund_destination),
@@ -4417,7 +4776,10 @@ function mapInstantLoanEventType(eventType) {
       depositWindowSeconds: event.ltv_timer_s,
       profileId: event.lending_profile.toText(),
       borrowPoolId: event.borrow_pool_id.toText(),
-      borrowAsset: event.borrow_asset
+      borrowAsset: parseInstantLoanAsset(
+        event.borrow_asset,
+        "event borrow asset"
+      )
     };
   }
   if ("FullLendWithdrawalRequested" in eventType) {
@@ -4584,6 +4946,12 @@ function mapCandidateWire(wire) {
     })
   };
 }
+function parseInstantLoanAsset(value, label) {
+  return parseApiStringUnion(value, INSTANT_LOAN_ASSETS, {
+    context: INSTANT_LOAN_WIRE_CONTEXT,
+    label
+  });
+}
 function mapInstantLoansErrorToLiquidiumError(error) {
   const [key, payload] = Object.entries(error)[0];
   switch (key) {
@@ -4725,11 +5093,25 @@ function encodeBytes32Hex(bytes) {
 var idlFactory4 = ({ IDL }) => IDL.Service({
   icrc1_fee: IDL.Func([], [IDL.Nat], ["query"])
 });
-function createCkBtcLedgerActor(canisterContext) {
-  const canisterId = CK_CANISTER_IDS.btcLedger;
+function createIcrcLedgerActor(params) {
+  if (!params.canisterId) {
+    throw new LiquidiumError(
+      LiquidiumErrorCode.SERVICE_UNAVAILABLE,
+      `${params.ledgerName} ledger canister ID is not configured`
+    );
+  }
   return agent.Actor.createActor(idlFactory4, {
-    agent: canisterContext.agent,
-    canisterId
+    agent: params.canisterContext.agent,
+    canisterId: params.canisterId
+  });
+}
+
+// src/core/canisters/ckbtc/ledger.ts
+function createCkBtcLedgerActor(canisterContext) {
+  return createIcrcLedgerActor({
+    canisterContext,
+    canisterId: CK_CANISTER_IDS.BTC.ledger,
+    ledgerName: "ckBTC"
   });
 }
 
@@ -4758,11 +5140,83 @@ function accountTypeToString(accountType) {
   switch (accountType.type) {
     case "External":
       return `Address:${accountType.data}`;
+    case "Icrc":
+      return `Icrc:${accountType.data}`;
+    case "AccountIdentifier":
+      return `AccountId:${accountType.data}`;
     case "Native":
       return `Principal:${accountType.data}`;
   }
 }
 
+// src/core/pool-ledger-assets.ts
+function getPoolLedgerAssetRoute(params) {
+  if (params.asset === Asset.BTC && (params.chain === Chain.BTC || params.chain === Chain.ICP)) {
+    return {
+      ledgerCanisterId: CK_CANISTER_IDS.BTC.ledger,
+      asset: Asset.BTC,
+      chain: params.chain
+    };
+  }
+  if (params.asset === Asset.USDT && (params.chain === Chain.ETH || params.chain === Chain.ICP)) {
+    return {
+      ledgerCanisterId: CK_CANISTER_IDS.USDT.ledger,
+      asset: Asset.USDT,
+      chain: params.chain
+    };
+  }
+  if (params.asset === Asset.USDC && (params.chain === Chain.ETH || params.chain === Chain.ICP)) {
+    return {
+      ledgerCanisterId: CK_CANISTER_IDS.USDC.ledger,
+      asset: Asset.USDC,
+      chain: params.chain
+    };
+  }
+  if (params.asset === Asset.ICP && params.chain === Chain.ICP) {
+    return {
+      ledgerCanisterId: CK_CANISTER_IDS.ICP.ledger,
+      asset: Asset.ICP,
+      chain: Chain.ICP
+    };
+  }
+  throw new LiquidiumError(
+    LiquidiumErrorCode.VALIDATION_ERROR,
+    `IC ledger transfers are not supported for ${params.asset} on ${params.chain}`
+  );
+}
+
+// src/core/withdraw-minimums.ts
+var MINIMUM_BTC_WITHDRAW_AMOUNT_SATS = 5000n;
+var MINIMUM_STABLECOIN_WITHDRAW_AMOUNT_BASE_UNITS = 1000000n;
+var MIN_WITHDRAW_AMOUNTS_BY_ASSET = {
+  [Asset.BTC]: MINIMUM_BTC_WITHDRAW_AMOUNT_SATS,
+  [Asset.USDC]: MINIMUM_STABLECOIN_WITHDRAW_AMOUNT_BASE_UNITS,
+  [Asset.USDT]: MINIMUM_STABLECOIN_WITHDRAW_AMOUNT_BASE_UNITS
+};
+function getMinimumWithdrawAmount(asset) {
+  if (!isMinimumWithdrawAsset(asset)) {
+    return 0n;
+  }
+  return MIN_WITHDRAW_AMOUNTS_BY_ASSET[asset];
+}
+function getWithdrawAmountMinimumValidationError(params) {
+  const minimumAmount = getMinimumWithdrawAmount(params.asset);
+  if (minimumAmount <= 0n || params.amount >= minimumAmount) {
+    return null;
+  }
+  return {
+    asset: params.asset,
+    minimumAmount,
+    message: formatMinimumWithdrawAmountMessage(params.asset, minimumAmount)
+  };
+}
+function formatMinimumWithdrawAmountMessage(asset, minimumAmount) {
+  return `Withdraw amount must be at least ${minimumAmount} base units for ${asset}`;
+}
+function isMinimumWithdrawAsset(asset) {
+  return Object.hasOwn(MIN_WITHDRAW_AMOUNTS_BY_ASSET, asset);
+}
+
 // src/modules/lending/_internal/inflow-fee-rounding.ts
 var ETH_STABLECOIN_INFLOW_FEE_ROUND_UP_TO_NEAREST_10_CENTS = 100000n;
 var BTC_INFLOW_FEE_ROUND_UP_TO_NEAREST_SATS = 500n;
@@ -4848,48 +5302,61 @@ var SupplyFlowExecutor = class {
   }
   params;
   async create(request) {
-    const target = await resolveSupplyTarget(
+    const requestedMechanism = request.mechanism ?? null;
+    if (requestedMechanism === null && request.walletAdapter === void 0 && (request.account !== void 0 || request.amount !== void 0)) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        "Wallet-executed supply requires walletAdapter, account, and amount"
+      );
+    }
+    const selectedPool = await getPoolById(
       this.params.canisterContext,
-      request
+      request.poolId
     );
-    const instruction = {
-      poolId: request.poolId,
-      asset: target.asset,
-      chain: target.chain,
-      action: request.action,
-      target
-    };
-    const mechanism = resolveSupplyMechanism({
-      asset: instruction.asset,
-      chain: instruction.chain,
-      requestedMechanism: request.mechanism
-    });
+    const target = await resolveSupplyTargetForPool(
+      this.params.canisterContext,
+      {
+        profileId: request.profileId,
+        poolId: request.poolId,
+        action: request.action,
+        mechanism: requestedMechanism,
+        chain: request.chain
+      },
+      selectedPool
+    );
+    const mechanism = requestedMechanism === SupplyPlanType.contractInteraction ? SupplyPlanType.contractInteraction : SupplyPlanType.transfer;
     const defaultSubmitInflowRequest = getDefaultSubmitInflowRequest({
       action: request.action,
-      chain: mechanism === SupplyPlanType.contractInteraction ? Chain.ETH : instruction.chain
+      chain: mechanism === SupplyPlanType.contractInteraction ? Chain.ETH : target.chain
     });
     let txid;
     switch (mechanism) {
       case SupplyPlanType.transfer:
-        if (request.walletAdapter) {
-          txid = await this.sendAndSubmitNativeSupplyInflow({
+        if (isWalletTransferSupplyRequest(request)) {
+          txid = await this.sendAndSubmitTransferSupplyInflow({
             request,
-            instruction,
+            target,
             defaultSubmitInflowRequest
           });
         }
         break;
       case SupplyPlanType.contractInteraction:
+        if (!isContractInteractionSupplyRequest(request)) {
+          throw new LiquidiumError(
+            LiquidiumErrorCode.VALIDATION_ERROR,
+            "Contract-interaction supply requires contract-interaction request fields"
+          );
+        }
         txid = await this.executeContractSupply({
           request,
-          instruction,
+          target,
           defaultSubmitInflowRequest
         });
         break;
     }
     return {
       type: mechanism,
-      target: instruction.target,
+      target,
       txid,
       status: createLiquidiumStatus({
         operation: mapSupplyActionToStatusOperation(request.action),
@@ -4897,7 +5364,7 @@ var SupplyFlowExecutor = class {
       }),
       submit: async (submitRequest) => {
         return await this.submitSupplyFlowInflow({
-          instruction,
+          target,
           mechanism,
           defaultSubmitInflowRequest,
           submitRequest
@@ -4906,7 +5373,10 @@ var SupplyFlowExecutor = class {
     };
   }
   async getEvmSupplyContext(request) {
-    const selectedPool = await this.params.getPoolById(request.poolId);
+    const selectedPool = await getPoolById(
+      this.params.canisterContext,
+      request.poolId
+    );
     return await this.getEvmSupplyContextForPool({
       request,
       asset: selectedPool.asset,
@@ -4970,14 +5440,8 @@ var SupplyFlowExecutor = class {
       approvalStrategy
     };
   }
-  async sendAndSubmitNativeSupplyInflow(params) {
-    const { request, instruction, defaultSubmitInflowRequest } = params;
-    if (instruction.target.type !== "nativeAddress") {
-      throw new LiquidiumError(
-        LiquidiumErrorCode.VALIDATION_ERROR,
-        "Wallet-executed supply requires a native-address target"
-      );
-    }
+  async sendAndSubmitTransferSupplyInflow(params) {
+    const { request, target, defaultSubmitInflowRequest } = params;
     if (!request.walletAdapter) {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
@@ -4997,16 +5461,27 @@ var SupplyFlowExecutor = class {
         "Wallet-executed supply requires a positive amount"
       );
     }
-    const txid = await this.sendNativeSupplyTransaction({
+    const txid = target.chain === Chain.ICP ? await this.sendIcrcSupplyTransaction({
+      walletAdapter: request.walletAdapter,
+      asset: target.asset,
+      chain: target.chain,
+      transfer: {
+        ledgerCanisterId: getPoolLedgerAssetRoute(target).ledgerCanisterId,
+        to: decodeIcrcAccountAddress(target.address).account,
+        amount: request.amount
+      },
+      senderAccount: account,
+      action: request.action
+    }) : await this.sendChainAddressSupplyTransaction({
       walletAdapter: request.walletAdapter,
-      chain: instruction.chain,
-      toAddress: instruction.target.address,
+      chain: target.chain,
+      toAddress: target.address,
       amount: request.amount,
       senderAccount: account,
-      asset: instruction.asset,
+      asset: target.asset,
       action: request.action
     });
-    if (shouldSubmitInflow({ instruction, mechanism: SupplyPlanType.transfer })) {
+    if (shouldSubmitInflow({ target, mechanism: SupplyPlanType.transfer })) {
       try {
         await this.submitInflowWithRetry(txid, defaultSubmitInflowRequest);
       } catch {
@@ -5033,11 +5508,11 @@ var SupplyFlowExecutor = class {
     });
   }
   async executeContractSupply(params) {
-    const { request, instruction, defaultSubmitInflowRequest } = params;
-    if (instruction.target.type !== "icrcAccount" || instruction.chain !== Chain.ETH) {
+    const { request, target, defaultSubmitInflowRequest } = params;
+    if (!isEthStablecoin(target.asset, target.chain)) {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
-        "Contract-interaction supply is only supported for ETH ICRC-account targets"
+        "Contract-interaction supply is only supported for ETH stablecoin targets"
       );
     }
     const walletAddressInput = request.account?.trim();
@@ -5076,8 +5551,8 @@ var SupplyFlowExecutor = class {
         amount: request.amount,
         action: request.action
       },
-      asset: instruction.asset,
-      chain: instruction.chain
+      asset: target.asset,
+      chain: target.chain
     });
     const supplyAmount = BigInt(evmSupplyContext.amount);
     if (BigInt(evmSupplyContext.balance) < supplyAmount) {
@@ -5133,7 +5608,7 @@ var SupplyFlowExecutor = class {
         amount: supplyAmount,
         poolId: request.poolId,
         profileId: request.profileId,
-        destinationAccount: instruction.target.account,
+        destinationAccount: target.address,
         action: request.action
       }),
       `supply-${request.action}-deposit-erc20`
@@ -5144,7 +5619,7 @@ var SupplyFlowExecutor = class {
     }
     return depositTxid;
   }
-  async sendNativeSupplyTransaction(params) {
+  async sendChainAddressSupplyTransaction(params) {
     switch (params.chain) {
       case Chain.BTC: {
         if (!params.walletAdapter.sendBtcTransaction) {
@@ -5158,8 +5633,7 @@ var SupplyFlowExecutor = class {
           toAddress: params.toAddress,
           amountSats: params.amount,
           account: params.senderAccount,
-          actionType: `supply-${params.action}`,
-          transferMode: TransferMode.native
+          actionType: `supply-${params.action}`
         });
       }
       case Chain.ETH: {
@@ -5174,7 +5648,6 @@ var SupplyFlowExecutor = class {
             chain: Chain.ETH,
             account: params.senderAccount,
             actionType: `supply-${params.action}`,
-            transferMode: TransferMode.native,
             transaction: createTransferErc20Transaction({
               tokenAddress: getEthStablecoinContractAddress(params.asset),
               recipientAddress: params.toAddress,
@@ -5186,7 +5659,6 @@ var SupplyFlowExecutor = class {
           chain: Chain.ETH,
           account: params.senderAccount,
           actionType: `supply-${params.action}`,
-          transferMode: TransferMode.native,
           transaction: {
             to: params.toAddress,
             value: params.amount.toString()
@@ -5196,10 +5668,32 @@ var SupplyFlowExecutor = class {
       default:
         throw new LiquidiumError(
           LiquidiumErrorCode.VALIDATION_ERROR,
-          `Native-address wallet execution is not supported for ${params.chain}`
+          `Chain-address wallet execution is not supported for ${params.chain}`
         );
     }
   }
+  async sendIcrcSupplyTransaction(params) {
+    if (!params.walletAdapter.sendIcrcTransfer) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        "ICRC wallet adapter does not support ledger transfers"
+      );
+    }
+    const route = getPoolLedgerAssetRoute({
+      asset: params.asset,
+      chain: params.chain
+    });
+    return await params.walletAdapter.sendIcrcTransfer({
+      chain: Chain.ICP,
+      asset: route.asset,
+      transfer: {
+        ...params.transfer,
+        ledgerCanisterId: route.ledgerCanisterId
+      },
+      account: params.senderAccount,
+      actionType: `supply-${params.action}`
+    });
+  }
   async submitInflowWithRetry(txid, extraRequest) {
     if (!extraRequest) {
       throw new LiquidiumError(
@@ -5228,7 +5722,6 @@ var SupplyFlowExecutor = class {
       chain: Chain.ETH,
       account: walletAddress,
       actionType,
-      transferMode: TransferMode.native,
       transaction: request
     });
   }
@@ -5317,13 +5810,19 @@ function getUnknownErrorMessage(error) {
 }
 function getDefaultSubmitInflowRequest(params) {
   if (params.chain !== Chain.BTC && params.chain !== Chain.ETH) {
-    return void 0;
+    return null;
   }
   return {
     chain: params.chain,
     operation: mapSupplyActionToStatusOperation(params.action)
   };
 }
+function isWalletTransferSupplyRequest(request) {
+  return request.mechanism !== SupplyPlanType.contractInteraction && request.walletAdapter !== void 0;
+}
+function isContractInteractionSupplyRequest(request) {
+  return request.mechanism === SupplyPlanType.contractInteraction;
+}
 function mapSupplyActionToStatusOperation(action) {
   return action === SupplyAction.repayment ? "repayment" : "deposit";
 }
@@ -5331,7 +5830,10 @@ function shouldSubmitInflow(params) {
   if (params.mechanism !== SupplyPlanType.transfer) {
     return true;
   }
-  return !isEthStablecoin(params.instruction.asset, params.instruction.chain);
+  if (params.target.chain === Chain.ICP) {
+    return false;
+  }
+  return !isEthStablecoin(params.target.asset, params.target.chain);
 }
 function mapCanisterOutflowDetails(outflow) {
   const rawOutflowType = getVariantKey(outflow.outflow_type);
@@ -5345,41 +5847,31 @@ function mapCanisterOutflowDetails(outflow) {
   };
 }
 function mapCanisterAccountType(receiver) {
-  if ("Native" in receiver) {
-    return {
-      type: "Native",
-      account: receiver.Native.toText()
-    };
-  }
-  if ("AccountIdentifier" in receiver) {
-    return {
-      type: "AccountIdentifier",
-      account: receiver.AccountIdentifier
-    };
-  }
-  if ("Icrc" in receiver) {
-    const subaccount = normalizeOptionalSubaccount2(receiver.Icrc.subaccount[0]);
-    return {
-      type: "Icrc",
-      owner: receiver.Icrc.owner.toText(),
-      subaccount,
-      account: icrc.encodeIcrcAccount({
-        owner: receiver.Icrc.owner,
-        subaccount
-      })
-    };
+  return mapCanisterAccountToLiquidiumAccount(receiver);
+}
+function parseOutflowDestination(params) {
+  const destination = normalizeOutflowDestinationInput(params.destination);
+  const parsedAccount = destination.type ? parseOutflowDestinationWithHint(destination) : parseOutflowDestinationAutomatically(destination.address);
+  assertDestinationTypeSupportedByChain({
+    accountType: parsedAccount.accountType,
+    poolChain: params.poolChain,
+    destinationChain: params.destinationChain
+  });
+  if (parsedAccount.accountType !== "ChainAddress") {
+    return parsedAccount;
   }
+  const externalAddress = normalizeExternalAddress({
+    address: parsedAccount.address,
+    asset: params.asset,
+    chain: params.destinationChain
+  });
   return {
-    type: "External",
-    account: receiver.External
+    address: externalAddress,
+    accountType: "ChainAddress",
+    canisterAccount: { External: externalAddress },
+    messageAccount: { type: "External", data: externalAddress }
   };
 }
-function normalizeOptionalSubaccount2(subaccount) {
-  if (!subaccount) {
-    return void 0;
-  }
-  return subaccount instanceof Uint8Array ? subaccount : Uint8Array.from(subaccount);
-}
 function normalizeOutflowType(rawOutflowType) {
   switch (rawOutflowType) {
     case "Withdraw":
@@ -5402,6 +5894,117 @@ function mapWalletChainToLendingChain(chain) {
     case Chain.ETH:
       return { ETH: null };
   }
+  throw new LiquidiumError(
+    LiquidiumErrorCode.VALIDATION_ERROR,
+    `Message signing is not supported for ${String(chain)}`
+  );
+}
+function normalizeOutflowDestinationInput(destination) {
+  if (typeof destination === "string") {
+    return { address: destination, type: null };
+  }
+  return destination;
+}
+function parseOutflowDestinationWithHint(destination) {
+  try {
+    switch (destination.type) {
+      case "ChainAddress":
+        return parseExternalDestination(destination.address);
+      case "IcPrincipal":
+        return parseIcPrincipalDestination(destination.address);
+      case "IcrcAccount":
+        return parseIcrcDestination(destination.address);
+      case "IcpAccountIdentifier":
+        return parseAccountIdentifierDestination(destination.address);
+      default:
+        throw new LiquidiumError(
+          LiquidiumErrorCode.VALIDATION_ERROR,
+          `Unsupported outflow account type: ${String(destination.type)}`
+        );
+    }
+  } catch (error) {
+    if (error instanceof LiquidiumError) {
+      throw error;
+    }
+    throw new LiquidiumError(
+      LiquidiumErrorCode.INVALID_ADDRESS,
+      `Invalid ${destination.type} outflow destination`
+    );
+  }
+}
+function parseOutflowDestinationAutomatically(address) {
+  const parsers = [
+    parseAccountIdentifierDestination,
+    parseIcPrincipalDestination,
+    parseIcrcDestination
+  ];
+  for (const parser of parsers) {
+    try {
+      return parser(address);
+    } catch {
+    }
+  }
+  return parseExternalDestination(address);
+}
+function parseExternalDestination(address) {
+  return {
+    address,
+    accountType: "ChainAddress",
+    canisterAccount: { External: address },
+    messageAccount: { type: "External", data: address }
+  };
+}
+function parseIcPrincipalDestination(address) {
+  const principal$1 = principal.Principal.fromText(address);
+  const principalText = principal$1.toText();
+  return {
+    address: principalText,
+    accountType: "IcPrincipal",
+    canisterAccount: { Native: principal$1 },
+    messageAccount: { type: "Native", data: principalText }
+  };
+}
+function parseIcrcDestination(address) {
+  const decoded = decodeIcrcAccountAddress(address);
+  return {
+    address: decoded.account.address,
+    accountType: "IcrcAccount",
+    canisterAccount: {
+      Icrc: {
+        owner: decoded.owner,
+        subaccount: decoded.subaccount ? [decoded.subaccount] : []
+      }
+    },
+    messageAccount: { type: "Icrc", data: decoded.account.address }
+  };
+}
+function parseAccountIdentifierDestination(address) {
+  const accountIdentifier = normalizeIcpAccountIdentifier(address);
+  return {
+    address: accountIdentifier,
+    accountType: "IcpAccountIdentifier",
+    canisterAccount: { AccountIdentifier: accountIdentifier },
+    messageAccount: { type: "AccountIdentifier", data: accountIdentifier }
+  };
+}
+function assertDestinationTypeSupportedByChain(params) {
+  if (params.poolChain === Chain.BTC || params.poolChain === Chain.ETH) {
+    if (params.destinationChain === params.poolChain && params.accountType === "ChainAddress") {
+      return;
+    }
+    if (params.destinationChain === Chain.ICP && params.accountType === "IcPrincipal") {
+      return;
+    }
+  }
+  if (params.poolChain === Chain.ICP && params.destinationChain === Chain.ICP) {
+    if (params.accountType === "IcpAccountIdentifier" || params.accountType === "IcrcAccount" || params.accountType === "IcPrincipal") {
+      return;
+    }
+  }
+  throw new LiquidiumError(
+    LiquidiumErrorCode.VALIDATION_ERROR,
+    "Target pool does not support this address type"
+  );
 }
 
 // src/modules/lending/lending.ts
@@ -5423,56 +6026,86 @@ var LendingModule = class {
    * @returns A signable {@link WithdrawAction} with `submit` wired to the canister.
    */
   async prepareWithdraw(request) {
-    const destinationAccount = request.receiverAddress.trim();
+    const destination = resolveOutflowDestinationInput({
+      receiver: request.receiver,
+      errorMessage: "Withdraw requires a custom outflow account"
+    });
     const signerAccount = normalizeEvmAddress(
       request.signerWalletAddress.trim()
     );
-    if (!destinationAccount) {
+    if (!signerAccount) {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
-        "Withdraw requires a custom outflow account"
+        "Withdraw requires a signer account"
       );
     }
-    if (!signerAccount) {
+    if (request.amount <= 0n) {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
-        "Withdraw requires a signer account"
+        "Withdraw amount must be greater than 0"
       );
     }
-    const receiverAddress = await this.normalizeOutflowReceiverAddress({
-      poolId: request.poolId,
-      receiverAddress: destinationAccount
+    const selectedPool = await getPoolById(
+      this.canisterContext,
+      request.poolId
+    );
+    const selectedAsset = selectedPool.asset;
+    const minimumWithdrawAmountError = getWithdrawAmountMinimumValidationError({
+      amount: request.amount,
+      asset: selectedAsset
+    });
+    if (minimumWithdrawAmountError) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        minimumWithdrawAmountError.message
+      );
+    }
+    const receiver = parseOutflowDestination({
+      destination,
+      asset: selectedAsset,
+      poolChain: selectedPool.chain,
+      destinationChain: request.chain
     });
     const lendingActor = createLendingActor(this.canisterContext);
     try {
       const expiryTimestamp = computeExpiryTimestampFromNow();
       const nonce = await lendingActor.get_nonce(signerAccount);
-      const withdrawRequestData = {
+      const withdrawActionData = {
         profileId: request.profileId,
         poolId: request.poolId,
         amount: request.amount,
-        receiverAddress,
+        chain: request.chain,
+        receiver: {
+          address: receiver.address,
+          type: receiver.accountType
+        },
         signerWalletAddress: signerAccount,
         expiryTimestamp
       };
+      const withdrawSubmissionData = {
+        ...withdrawActionData,
+        receiverAccount: receiver.canisterAccount
+      };
       return {
         kind: WalletActionKind.createWithdraw,
         executionKind: WalletExecutionKind.signMessage,
         actionType: WalletActionKind.createWithdraw,
-        transferMode: TransferMode.native,
         account: signerAccount,
         message: createWithdrawAssetMessage(
           {
             pool_id: request.poolId,
             amount: request.amount.toString(),
-            account: { type: "External", data: receiverAddress },
+            account: receiver.messageAccount,
             expiry_timestamp: expiryTimestamp
           },
           nonce
         ),
-        data: withdrawRequestData,
+        data: withdrawActionData,
         submit: async (signatureInfo) => {
-          return await this.submitWithdraw(withdrawRequestData, signatureInfo);
+          return await this.submitWithdraw(
+            withdrawSubmissionData,
+            signatureInfo
+          );
         }
       };
     } catch (error) {
@@ -5489,7 +6122,7 @@ var LendingModule = class {
         {
           data: {
             expiry_timestamp: request.expiryTimestamp,
-            account: { External: request.receiverAddress },
+            account: request.receiverAccount,
             pool_id: principal.Principal.fromText(request.poolId),
             amount: request.amount
           },
@@ -5545,16 +6178,13 @@ var LendingModule = class {
    * @returns A signable {@link BorrowAction} with `submit` wired to the canister.
    */
   async prepareBorrow(request) {
-    const destinationAccount = request.receiverAddress.trim();
+    const destination = resolveOutflowDestinationInput({
+      receiver: request.receiver,
+      errorMessage: "Borrow requires a custom outflow account"
+    });
     const signerAccount = normalizeEvmAddress(
       request.signerWalletAddress.trim()
     );
-    if (!destinationAccount) {
-      throw new LiquidiumError(
-        LiquidiumErrorCode.VALIDATION_ERROR,
-        "Borrow requires a custom outflow account"
-      );
-    }
     if (!signerAccount) {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
@@ -5567,7 +6197,10 @@ var LendingModule = class {
         "Borrow amount must be greater than 0"
       );
     }
-    const selectedPool = await this.getPoolById(request.poolId);
+    const selectedPool = await getPoolById(
+      this.canisterContext,
+      request.poolId
+    );
     const selectedAsset = selectedPool.asset;
     const minimumBorrowAmountError = getBorrowAmountMinimumValidationError({
       amount: request.amount,
@@ -5579,41 +6212,49 @@ var LendingModule = class {
         minimumBorrowAmountError.message
       );
     }
-    const receiverAddress = normalizeExternalAddress({
-      address: destinationAccount,
+    const receiver = parseOutflowDestination({
+      destination,
       asset: selectedAsset,
-      chain: selectedPool.chain
+      poolChain: selectedPool.chain,
+      destinationChain: request.chain
     });
     const lendingActor = createLendingActor(this.canisterContext);
     try {
       const expiryTimestamp = computeExpiryTimestampFromNow();
       const nonce = await lendingActor.get_nonce(signerAccount);
-      const borrowRequestData = {
+      const borrowActionData = {
         profileId: request.profileId,
         poolId: request.poolId,
         amount: request.amount,
-        receiverAddress,
+        chain: request.chain,
+        receiver: {
+          address: receiver.address,
+          type: receiver.accountType
+        },
         signerWalletAddress: signerAccount,
         expiryTimestamp
       };
+      const borrowSubmissionData = {
+        ...borrowActionData,
+        receiverAccount: receiver.canisterAccount
+      };
       return {
         kind: WalletActionKind.createBorrow,
         executionKind: WalletExecutionKind.signMessage,
         actionType: WalletActionKind.createBorrow,
-        transferMode: TransferMode.native,
         account: signerAccount,
         message: createBorrowAssetMessage(
           {
             pool_id: request.poolId,
             amount: request.amount.toString(),
-            account: { type: "External", data: receiverAddress },
+            account: receiver.messageAccount,
             expiry_timestamp: expiryTimestamp
           },
           nonce
         ),
-        data: borrowRequestData,
+        data: borrowActionData,
         submit: async (signatureInfo) => {
-          return await this.submitBorrow(borrowRequestData, signatureInfo);
+          return await this.submitBorrow(borrowSubmissionData, signatureInfo);
         }
       };
     } catch (error) {
@@ -5630,7 +6271,7 @@ var LendingModule = class {
       ).borrow_assets(principal.Principal.fromText(request.profileId), {
         data: {
           expiry_timestamp: request.expiryTimestamp,
-          account: { External: request.receiverAddress },
+          account: request.receiverAccount,
           pool_id: principal.Principal.fromText(request.poolId),
           amount: request.amount
         },
@@ -5748,11 +6389,18 @@ var LendingModule = class {
    *
    * ETH stablecoin deposit-address estimates are served by the deposit-address
    * canister. BTC estimates include the ckBTC minter deposit fee and ledger fee.
+   * ICP-chain estimates return the corresponding ICRC ledger fee.
    *
    * @param request - Asset and chain pair to estimate for.
    * @returns Total fee estimate rounded up in the asset's base units.
    */
   async estimateInflowFee(request) {
+    if (request.chain === Chain.ICP) {
+      const ledgerFee = await this.estimateIcrcLedgerFee(request);
+      return {
+        totalFee: roundInflowFeeEstimate(request, ledgerFee)
+      };
+    }
     if (isEthStablecoin(request.asset, request.chain)) {
       const result = await createDepositAccountsActor(
         this.canisterContext
@@ -5782,6 +6430,14 @@ var LendingModule = class {
     ]);
     return { totalFee: minterFee + ledgerFee };
   }
+  async estimateIcrcLedgerFee(request) {
+    const route = getInflowFeeLedgerAssetRoute(request);
+    return await createIcrcLedgerActor({
+      canisterContext: this.canisterContext,
+      canisterId: route.ledgerCanisterId,
+      ledgerName: `${request.asset} ${request.chain}`
+    }).icrc1_fee();
+  }
   /**
    * Submits an inflow transaction id for faster indexing.
    *
@@ -5791,6 +6447,12 @@ var LendingModule = class {
    * @returns Acknowledgement including the submitted `txid`.
    */
   async submitInflow(request) {
+    if (request.chain !== void 0 && request.chain !== Chain.BTC && request.chain !== Chain.ETH) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        `Inflow submission is not supported for ${String(request.chain)}`
+      );
+    }
     const apiClient = this.requireApi();
     const response = await apiClient.post(SdkApiPath.inflow, request);
     return {
@@ -5830,38 +6492,39 @@ var LendingModule = class {
     return new SupplyFlowExecutor({
       canisterContext: this.canisterContext,
       evmReadClient: this.evmReadClient,
-      getPoolById: async (poolId) => await this.getPoolById(poolId),
       requireApi: () => {
         this.requireApi();
       },
       submitInflow: async (request) => await this.submitInflow(request)
     });
   }
-  async getPoolById(poolId) {
-    const pools = await createFlexibleLendingActor(
-      this.canisterContext
-    ).list_pools();
-    const selectedPool = pools.find(
-      (pool) => pool.principal.toText() === poolId
+};
+function getInflowFeeLedgerAssetRoute(request) {
+  if (request.chain !== Chain.ICP) {
+    throw new LiquidiumError(
+      LiquidiumErrorCode.VALIDATION_ERROR,
+      `IC ledger inflow fees are not supported for ${request.asset} on ${request.chain}`
     );
-    const decodedPool = selectedPool ? decodeFlexiblePool(selectedPool) : null;
-    if (!decodedPool) {
-      throw new LiquidiumError(
-        LiquidiumErrorCode.POOL_NOT_FOUND,
-        `Pool not found: ${poolId}`
-      );
-    }
-    return decodedPool;
   }
-  async normalizeOutflowReceiverAddress(params) {
-    const selectedPool = await this.getPoolById(params.poolId);
-    return normalizeExternalAddress({
-      address: params.receiverAddress,
-      asset: selectedPool.asset,
-      chain: selectedPool.chain
-    });
+  return getPoolLedgerAssetRoute(request);
+}
+function resolveOutflowDestinationInput(params) {
+  const receiver = params.receiver;
+  const address = typeof receiver === "string" ? receiver.trim() : receiver.address.trim();
+  if (!address) {
+    throw new LiquidiumError(
+      LiquidiumErrorCode.VALIDATION_ERROR,
+      params.errorMessage
+    );
   }
-};
+  if (typeof receiver === "string") {
+    return address;
+  }
+  return {
+    address,
+    type: receiver.type
+  };
+}
 function mapExpectedOutflowDetails(details, expectedOutflowType, operation) {
   if (details.outflowType !== expectedOutflowType) {
     throw new LiquidiumError(
@@ -5955,13 +6618,17 @@ function formatPrice(price, decimals) {
 
 // src/modules/market/market.ts
 var ZERO_POOL_RATE = [0n, 0n, 0n];
+var BACKING_POOL_CHAIN_BY_ASSET = {
+  [Asset.BTC]: Chain.BTC,
+  [Asset.ICP]: Chain.ICP,
+  [Asset.USDC]: Chain.ETH,
+  [Asset.USDT]: Chain.ETH
+};
 var MarketModule = class {
-  constructor(canisterContext, apiClient) {
+  constructor(canisterContext) {
     this.canisterContext = canisterContext;
-    this.apiClient = apiClient;
   }
   canisterContext;
-  apiClient;
   /**
    * Lists SDK-supported pools with their current rates.
    *
@@ -5970,7 +6637,6 @@ var MarketModule = class {
    * @returns Supported lending pools enriched with their current rate data.
    */
   async listPools() {
-    void this.apiClient;
     try {
       const flexibleActor = createFlexibleLendingActor(this.canisterContext);
       const rawPools = await flexibleActor.list_pools();
@@ -6015,15 +6681,26 @@ var MarketModule = class {
     }
   }
   /**
-   * Resolves a single pool for the given asset and chain pair.
+   * Resolves a single backing pool for the given Chain + Asset identifier.
+   *
+   * Native and chain-key identifiers share a pool. For example, both
+   * `ETH/USDT` and `ICP/USDT` resolve to the USDT lending pool.
    *
    * @param query - The market asset and chain pair to match.
    * @returns The single pool that matches the requested asset and chain.
    */
   async findPool(query) {
+    const identifier = { chain: query.chain, asset: query.asset };
+    if (!isAssetIdentifier(identifier)) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        `Unsupported asset identifier: ${identifier.chain}/${identifier.asset}`
+      );
+    }
     const pools = await this.listPools();
+    const backingPoolChain = BACKING_POOL_CHAIN_BY_ASSET[identifier.asset];
     const matchedPools = pools.filter(
-      (pool) => pool.asset === query.asset && pool.chain === query.chain
+      (pool) => pool.asset === identifier.asset && pool.chain === backingPoolChain
     );
     if (matchedPools.length === 0) {
       throw new LiquidiumError(
@@ -6412,7 +7089,7 @@ var LiquidiumClient = class {
       this.apiClient,
       this.evmReadClient
     );
-    this.market = new MarketModule(this.canisterContext, this.apiClient);
+    this.market = new MarketModule(this.canisterContext);
     this.positions = new PositionsModule(this.canisterContext, this.market);
     this.activities = new ActivitiesModule(
       this.apiClient,
@@ -6453,12 +7130,15 @@ exports.Chain = Chain;
 exports.Environment = Environment;
 exports.EvmSupplyApprovalStrategy = EvmSupplyApprovalStrategy;
 exports.HistoryModule = HistoryModule;
+exports.InstantLoanCreatedError = InstantLoanCreatedError;
 exports.InstantLoansModule = InstantLoansModule;
 exports.LendingModule = LendingModule;
+exports.LiquidiumAccountType = LiquidiumAccountType;
 exports.LiquidiumClient = LiquidiumClient;
 exports.LiquidiumError = LiquidiumError;
 exports.LiquidiumErrorCode = LiquidiumErrorCode;
 exports.MIN_BORROW_AMOUNTS_BY_ASSET = MIN_BORROW_AMOUNTS_BY_ASSET;
+exports.MIN_WITHDRAW_AMOUNTS_BY_ASSET = MIN_WITHDRAW_AMOUNTS_BY_ASSET;
 exports.MarketModule = MarketModule;
 exports.OutflowType = OutflowType;
 exports.PositionsModule = PositionsModule;
@@ -6469,7 +7149,6 @@ exports.RATE_DECIMALS = RATE_DECIMALS;
 exports.RATE_SCALE = RATE_SCALE2;
 exports.SupplyAction = SupplyAction;
 exports.SupplyPlanType = SupplyPlanType;
-exports.TransferMode = TransferMode;
 exports.USDC_CONTRACT_ADDRESS = USDC_CONTRACT_ADDRESS;
 exports.USDT_CONTRACT_ADDRESS = USDT_CONTRACT_ADDRESS;
 exports.WalletActionKind = WalletActionKind;
@@ -6477,7 +7156,9 @@ exports.WalletExecutionKind = WalletExecutionKind;
 exports.createTransferErc20Transaction = createTransferErc20Transaction;
 exports.executeWith = executeWith;
 exports.getMinimumBorrowAmount = getMinimumBorrowAmount;
+exports.getMinimumWithdrawAmount = getMinimumWithdrawAmount;
 exports.intFromPublicId = intFromPublicId;
+exports.isAssetIdentifier = isAssetIdentifier;
 exports.publicIdFromInt = publicIdFromInt;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map