@liquidium/client 0.5.1 → 0.6.0-rc.1

package/dist/index.js

@@ -5,8 +5,8 @@ import { Principal } from '@icp-sdk/core/principal';
 import { base64, base64nopad } from '@scure/base';
 import { idlLabelToId } from '@icp-sdk/core/candid';
 import { decodeIcrcAccount, encodeIcrcAccount } from '@icp-sdk/canisters/ledger/icrc';
-import { AccountIdentifier, SubAccount } from '@icp-sdk/canisters/ledger/icp';
 import { validate, Network } from 'bitcoin-address-validation';
+import { AccountIdentifier, SubAccount } from '@icp-sdk/canisters/ledger/icp';
 
 // src/client.ts
 
@@ -86,6 +86,7 @@ var Environment = {
 };
 var Asset = {
   BTC: "BTC",
+  ETH: "ETH",
   ICP: "ICP",
   USDC: "USDC",
   USDT: "USDT"
@@ -100,9 +101,9 @@ function isAssetIdentifier(identifier) {
     case Chain.BTC:
       return identifier.asset === Asset.BTC;
     case Chain.ETH:
-      return identifier.asset === Asset.USDC || identifier.asset === Asset.USDT;
+      return identifier.asset === Asset.ETH || 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;
+      return identifier.asset === Asset.BTC || identifier.asset === Asset.ETH || identifier.asset === Asset.ICP || identifier.asset === Asset.USDC || identifier.asset === Asset.USDT;
     default:
       return false;
   }
@@ -125,6 +126,7 @@ var MAINNET_CANISTER_IDS = {
   lending: "hyk4r-jqaaa-aaaar-qb4ca-cai",
   pools: {
     btc: "hkmli-faaaa-aaaar-qb4ba-cai",
+    eth: "qcg7y-syaaa-aaaar-qb75q-cai",
     usdt: "hnnn4-iyaaa-aaaar-qb4bq-cai",
     usdc: "6sna2-oiaaa-aaaar-qb66q-cai",
     icp: "r2pk3-4yaaa-aaaar-qb7zq-cai"
@@ -143,6 +145,7 @@ var SUPPORTED_CANISTER_ID_OVERRIDE_KEYS = /* @__PURE__ */ new Set([
 ]);
 var SUPPORTED_POOL_CANISTER_ID_OVERRIDE_KEYS = /* @__PURE__ */ new Set([
   "btc",
+  "eth",
   "usdt",
   "usdc",
   "icp"
@@ -193,6 +196,8 @@ var CK_CANISTER_IDS = {
   BTC: {
     minter: "mqygn-kiaaa-aaaar-qaadq-cai",
     ledger: "mxzaz-hqaaa-aaaar-qaada-cai"},
+  ETH: {
+    ledger: "ss2fx-dyaaa-aaaar-qacoq-cai"},
   USDT: {
     ledger: "cngnf-vqaaa-aaaar-qag4q-cai"},
   USDC: {
@@ -431,6 +436,7 @@ var idlFactory = ({ IDL }) => {
   });
   const Assets = IDL.Variant({
     "BTC": IDL.Null,
+    "ETH": IDL.Null,
     "ICP": IDL.Null,
     "SOL": IDL.Null,
     "USDC": IDL.Null,
@@ -1014,6 +1020,16 @@ var ERC20_ABI = [
   }
 ];
 var CK_DEPOSIT_ABI = [
+  {
+    inputs: [
+      { internalType: "bytes32", name: "principal", type: "bytes32" },
+      { internalType: "bytes32", name: "subaccount", type: "bytes32" }
+    ],
+    name: "depositEth",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
   {
     inputs: [
       { internalType: "address", name: "erc20Address", type: "address" },
@@ -1397,7 +1413,7 @@ function mapCanisterWalletToWallet(canisterWallet) {
       );
   }
 }
-var KNOWN_ASSET_TAGS = ["BTC", "ICP", "USDC", "USDT"];
+var KNOWN_ASSET_TAGS = ["BTC", "ETH", "ICP", "USDC", "USDT"];
 var KNOWN_CHAIN_TAGS = ["BTC", "ETH", "ICP"];
 function extractVariantTag(variant, knownTags) {
   const [key] = Object.keys(variant);
@@ -2223,28 +2239,7 @@ function createTransferErc20Transaction(params) {
   };
 }
 function createDepositErc20Transaction(params) {
-  const expectedDestinationAccount = encodeIcrcAccount({
-    owner: Principal.fromText(params.poolId),
-    subaccount: encodeInflowSubaccount({
-      action: params.action,
-      principal: Principal.fromText(params.profileId)
-    })
-  });
-  if (params.destinationAccount !== expectedDestinationAccount) {
-    throw new LiquidiumError(
-      LiquidiumErrorCode.VALIDATION_ERROR,
-      "ETH supply destination account does not match the expected inflow account"
-    );
-  }
-  const principalBytes32 = encodePrincipalToBytes32(
-    Principal.fromText(params.poolId)
-  );
-  const subaccountHex = encodeBytes32Hex(
-    encodeInflowSubaccount({
-      action: params.action,
-      principal: Principal.fromText(params.profileId)
-    })
-  );
+  const { principalBytes32, subaccountHex } = createDepositAccountContext(params);
   return {
     to: params.depositContractAddress,
     data: encodeFunctionData({
@@ -2259,6 +2254,40 @@ function createDepositErc20Transaction(params) {
     })
   };
 }
+function createDepositEthTransaction(params) {
+  const { principalBytes32, subaccountHex } = createDepositAccountContext(params);
+  return {
+    to: params.depositContractAddress,
+    data: encodeFunctionData({
+      abi: CK_DEPOSIT_ABI,
+      functionName: "depositEth",
+      args: [principalBytes32, subaccountHex]
+    }),
+    value: params.amount.toString()
+  };
+}
+function createDepositAccountContext(params) {
+  const inflowSubaccount = encodeInflowSubaccount({
+    action: params.action,
+    principal: Principal.fromText(params.profileId)
+  });
+  const expectedDestinationAccount = encodeIcrcAccount({
+    owner: Principal.fromText(params.poolId),
+    subaccount: inflowSubaccount
+  });
+  if (params.destinationAccount !== expectedDestinationAccount) {
+    throw new LiquidiumError(
+      LiquidiumErrorCode.VALIDATION_ERROR,
+      "ETH supply destination account does not match the expected inflow account"
+    );
+  }
+  return {
+    principalBytes32: encodePrincipalToBytes32(
+      Principal.fromText(params.poolId)
+    ),
+    subaccountHex: encodeBytes32Hex(inflowSubaccount)
+  };
+}
 function encodePrincipalToBytes32(principal) {
   const principalBytes = principal.toUint8Array();
   if (principalBytes.length > 29) {
@@ -2278,12 +2307,59 @@ function encodeBytes32Hex(bytes) {
     (byte) => byte.toString(16).padStart(2, "0")
   ).join("")}`;
 }
+var BTC_MAINNET_ADDRESS_ERROR = "Address must be a valid mainnet BTC address";
+var EVM_ADDRESS_ERROR = "Address must be a valid EVM address";
+var ADDRESS_CHAIN_MISMATCH_ERROR = "Address chain must match asset";
+function normalizeExternalAddress(params) {
+  if (params.asset === Asset.BTC) {
+    if (params.chain !== Chain.BTC) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.INVALID_ADDRESS,
+        ADDRESS_CHAIN_MISMATCH_ERROR
+      );
+    }
+    if (!validate(params.address, Network.mainnet)) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.INVALID_ADDRESS,
+        BTC_MAINNET_ADDRESS_ERROR
+      );
+    }
+    return params.address;
+  }
+  if (isEvmAsset(params.asset)) {
+    if (params.chain !== Chain.ETH) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.INVALID_ADDRESS,
+        ADDRESS_CHAIN_MISMATCH_ERROR
+      );
+    }
+    if (!isAddress(params.address)) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.INVALID_ADDRESS,
+        EVM_ADDRESS_ERROR
+      );
+    }
+    return getAddress(params.address);
+  }
+  return params.address;
+}
+function normalizeAndValidateEvmAddress(address, errorMessage) {
+  if (!isAddress(address)) {
+    throw new LiquidiumError(LiquidiumErrorCode.INVALID_ADDRESS, errorMessage);
+  }
+  return getAddress(address);
+}
+function isEvmAsset(asset) {
+  return asset === Asset.ETH || asset === Asset.USDC || asset === Asset.USDT;
+}
 
 // src/core/borrow-minimums.ts
 var MINIMUM_BTC_BORROW_AMOUNT_SATS = 5100n;
+var MINIMUM_ETH_BORROW_AMOUNT_WEI = 5000000000000000n;
 var MINIMUM_STABLECOIN_BORROW_AMOUNT_BASE_UNITS = 1000000n;
 var MIN_BORROW_AMOUNTS_BY_ASSET = {
   [Asset.BTC]: MINIMUM_BTC_BORROW_AMOUNT_SATS,
+  [Asset.ETH]: MINIMUM_ETH_BORROW_AMOUNT_WEI,
   [Asset.USDC]: MINIMUM_STABLECOIN_BORROW_AMOUNT_BASE_UNITS,
   [Asset.USDT]: MINIMUM_STABLECOIN_BORROW_AMOUNT_BASE_UNITS
 };
@@ -3177,6 +3253,13 @@ function getPoolLedgerAssetRoute(params) {
       chain: params.chain
     };
   }
+  if (params.asset === Asset.ETH && (params.chain === Chain.ETH || params.chain === Chain.ICP)) {
+    return {
+      ledgerCanisterId: CK_CANISTER_IDS.ETH.ledger,
+      asset: Asset.ETH,
+      chain: params.chain
+    };
+  }
   if (params.asset === Asset.USDT && (params.chain === Chain.ETH || params.chain === Chain.ICP)) {
     return {
       ledgerCanisterId: CK_CANISTER_IDS.USDT.ledger,
@@ -3251,9 +3334,11 @@ function createLiquidiumStatus(params) {
 
 // src/core/withdraw-minimums.ts
 var MINIMUM_BTC_WITHDRAW_AMOUNT_SATS = 5000n;
+var MINIMUM_ETH_WITHDRAW_AMOUNT_WEI = 5000000000000000n;
 var MINIMUM_STABLECOIN_WITHDRAW_AMOUNT_BASE_UNITS = 1000000n;
 var MIN_WITHDRAW_AMOUNTS_BY_ASSET = {
   [Asset.BTC]: MINIMUM_BTC_WITHDRAW_AMOUNT_SATS,
+  [Asset.ETH]: MINIMUM_ETH_WITHDRAW_AMOUNT_WEI,
   [Asset.USDC]: MINIMUM_STABLECOIN_WITHDRAW_AMOUNT_BASE_UNITS,
   [Asset.USDT]: MINIMUM_STABLECOIN_WITHDRAW_AMOUNT_BASE_UNITS
 };
@@ -3390,7 +3475,7 @@ function resolveSupplyMechanism(params) {
   if (params.mechanism !== SupplyPlanType.contractInteraction) {
     return SupplyPlanType.transfer;
   }
-  if (params.identifier.chain === Chain.ETH && (params.identifier.asset === Asset.USDC || params.identifier.asset === Asset.USDT)) {
+  if (params.identifier.chain === Chain.ETH && (params.identifier.asset === Asset.ETH || params.identifier.asset === Asset.USDC || params.identifier.asset === Asset.USDT)) {
     return SupplyPlanType.contractInteraction;
   }
   throw new LiquidiumError(
@@ -3413,6 +3498,12 @@ function getEthStablecoinContractAddress(asset) {
     `ETH stablecoin contract address is not configured for ${asset}`
   );
 }
+function getEthDepositTokenAddress(asset) {
+  if (asset === Asset.ETH) {
+    return [];
+  }
+  return [getEthStablecoinContractAddress(asset)];
+}
 function mapDepositAccountErrorToLiquidiumError(error) {
   if ("InvalidEvmAddress" in error) {
     return new LiquidiumError(
@@ -3476,7 +3567,7 @@ function resolveSupplyAssetIdentifier(params) {
       return { asset: Asset.BTC, chain: Chain.ICP };
     }
   }
-  if ((params.asset === Asset.USDC || params.asset === Asset.USDT) && params.poolChain === Chain.ETH) {
+  if ((params.asset === Asset.ETH || params.asset === Asset.USDC || params.asset === Asset.USDT) && params.poolChain === Chain.ETH) {
     if (params.transferChain === Chain.ETH) {
       return { asset: params.asset, chain: Chain.ETH };
     }
@@ -3494,7 +3585,6 @@ function resolveSupplyAssetIdentifier(params) {
 }
 async function getChainAddressSupplyTarget(canisterContext, profileId, request) {
   if (request.chain === Chain.ETH) {
-    const tokenAddress = getEthStablecoinContractAddress(request.asset);
     const subaccount2 = encodeInflowSubaccount({
       action: request.action,
       principal: Principal.fromText(profileId)
@@ -3506,17 +3596,21 @@ async function getChainAddressSupplyTarget(canisterContext, profileId, request)
         owner: Principal.fromText(request.poolId),
         subaccount: [subaccount2]
       },
-      [tokenAddress]
+      getEthDepositTokenAddress(request.asset)
     );
     if ("Err" in result) {
       throw mapDepositAccountErrorToLiquidiumError(result.Err);
     }
+    const address2 = normalizeAndValidateEvmAddress(
+      result.Ok,
+      "Deposit address canister returned an invalid EVM address"
+    );
     return {
       poolId: request.poolId,
       asset: request.asset,
       chain: request.chain,
       action: request.action,
-      address: result.Ok
+      address: address2
     };
   }
   const configuredBtcPoolId = canisterContext.canisterIds.pools.btc;
@@ -3595,50 +3689,38 @@ function roundInflowFeeEstimate(request, totalFee) {
 function roundUpToNearest(amount, roundingUnit) {
   return ceilDivBigint(amount, roundingUnit) * roundingUnit;
 }
-var BTC_MAINNET_ADDRESS_ERROR = "Address must be a valid mainnet BTC address";
-var EVM_ADDRESS_ERROR = "Address must be a valid EVM address";
-var ADDRESS_CHAIN_MISMATCH_ERROR = "Address chain must match asset";
-function normalizeExternalAddress(params) {
-  if (params.asset === Asset.BTC) {
-    if (params.chain !== Chain.BTC) {
-      throw new LiquidiumError(
-        LiquidiumErrorCode.INVALID_ADDRESS,
-        ADDRESS_CHAIN_MISMATCH_ERROR
-      );
-    }
-    if (!validate(params.address, Network.mainnet)) {
-      throw new LiquidiumError(
-        LiquidiumErrorCode.INVALID_ADDRESS,
-        BTC_MAINNET_ADDRESS_ERROR
-      );
-    }
-    return params.address;
-  }
-  if (isEthStablecoin2(params.asset)) {
-    if (params.chain !== Chain.ETH) {
-      throw new LiquidiumError(
-        LiquidiumErrorCode.INVALID_ADDRESS,
-        ADDRESS_CHAIN_MISMATCH_ERROR
-      );
-    }
-    if (!isAddress(params.address)) {
-      throw new LiquidiumError(
-        LiquidiumErrorCode.INVALID_ADDRESS,
-        EVM_ADDRESS_ERROR
-      );
-    }
-    return getAddress(params.address);
+
+// src/core/deposit-minimums.ts
+var MINIMUM_BTC_DEPOSIT_AMOUNT_SATS = 5100n;
+var MINIMUM_ETH_DEPOSIT_AMOUNT_WEI = 5000000000000000n;
+var MINIMUM_ICP_DEPOSIT_AMOUNT_E8S = 10000n;
+var MINIMUM_STABLECOIN_DEPOSIT_AMOUNT_BASE_UNITS = 1000000n;
+var MIN_DEPOSIT_AMOUNTS_BY_ASSET = {
+  [Asset.BTC]: MINIMUM_BTC_DEPOSIT_AMOUNT_SATS,
+  [Asset.ETH]: MINIMUM_ETH_DEPOSIT_AMOUNT_WEI,
+  [Asset.ICP]: MINIMUM_ICP_DEPOSIT_AMOUNT_E8S,
+  [Asset.USDC]: MINIMUM_STABLECOIN_DEPOSIT_AMOUNT_BASE_UNITS,
+  [Asset.USDT]: MINIMUM_STABLECOIN_DEPOSIT_AMOUNT_BASE_UNITS
+};
+function getMinimumDepositAmount(asset) {
+  if (!isMinimumDepositAsset(asset)) {
+    return 0n;
   }
-  return params.address;
+  return MIN_DEPOSIT_AMOUNTS_BY_ASSET[asset];
 }
-function normalizeAndValidateEvmAddress(address, errorMessage) {
-  if (!isAddress(address)) {
-    throw new LiquidiumError(LiquidiumErrorCode.INVALID_ADDRESS, errorMessage);
+function getDepositAmountMinimumValidationError(params) {
+  const minimumAmount = getMinimumDepositAmount(params.asset);
+  if (minimumAmount <= 0n || params.amount >= minimumAmount) {
+    return null;
   }
-  return getAddress(address);
+  return {
+    asset: params.asset,
+    minimumAmount,
+    message: `Deposit amount must be at least ${minimumAmount} base units for ${params.asset}`
+  };
 }
-function isEthStablecoin2(asset) {
-  return asset === Asset.USDC || asset === Asset.USDT;
+function isMinimumDepositAsset(asset) {
+  return Object.hasOwn(MIN_DEPOSIT_AMOUNTS_BY_ASSET, asset);
 }
 
 // src/core/utils/retry.ts
@@ -3705,7 +3787,13 @@ var SupplyFlowExecutor = class {
   params;
   async create(request) {
     const requestedMechanism = request.mechanism ?? null;
-    if (requestedMechanism === null && request.walletAdapter === void 0 && (request.account !== void 0 || request.amount !== void 0)) {
+    if (requestedMechanism !== null && requestedMechanism !== SupplyPlanType.transfer && requestedMechanism !== SupplyPlanType.contractInteraction) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        `Unsupported supply mechanism: ${String(requestedMechanism)}`
+      );
+    }
+    if (requestedMechanism !== SupplyPlanType.contractInteraction && 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"
@@ -3715,6 +3803,13 @@ var SupplyFlowExecutor = class {
       this.params.canisterContext,
       request.poolId
     );
+    if (request.amount !== void 0) {
+      validateDepositMinimum({
+        action: request.action,
+        amount: request.amount,
+        asset: selectedPool.asset
+      });
+    }
     const target = await resolveSupplyTargetForPool(
       this.params.canisterContext,
       {
@@ -3779,6 +3874,11 @@ var SupplyFlowExecutor = class {
       this.params.canisterContext,
       request.poolId
     );
+    validateDepositMinimum({
+      action: request.action,
+      amount: request.amount,
+      asset: selectedPool.asset
+    });
     return await this.getEvmSupplyContextForPool({
       request,
       asset: selectedPool.asset,
@@ -3850,13 +3950,17 @@ var SupplyFlowExecutor = class {
         "Wallet-executed supply requires a wallet adapter"
       );
     }
-    const account = request.account?.trim();
-    if (!account) {
+    const accountInput = request.account?.trim();
+    if (!accountInput) {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
         "Wallet-executed transfer supply requires an account"
       );
     }
+    const senderAccount = target.chain === Chain.ETH ? normalizeAndValidateEvmAddress(
+      accountInput,
+      "Invalid EVM wallet address"
+    ) : accountInput;
     if (!request.amount || request.amount <= 0n) {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
@@ -3872,14 +3976,14 @@ var SupplyFlowExecutor = class {
         to: decodeIcrcAccountAddress(target.address).account,
         amount: request.amount
       },
-      senderAccount: account,
+      senderAccount,
       action: request.action
     }) : await this.sendChainAddressSupplyTransaction({
       walletAdapter: request.walletAdapter,
       chain: target.chain,
       toAddress: target.address,
       amount: request.amount,
-      senderAccount: account,
+      senderAccount,
       asset: target.asset,
       action: request.action
     });
@@ -3911,10 +4015,10 @@ var SupplyFlowExecutor = class {
   }
   async executeContractSupply(params) {
     const { request, target, defaultSubmitInflowRequest } = params;
-    if (!isEthStablecoin(target.asset, target.chain)) {
+    if (target.chain !== Chain.ETH || target.asset !== Asset.ETH && !isEthStablecoin(target.asset, target.chain)) {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
-        "Contract-interaction supply is only supported for ETH stablecoin targets"
+        "Contract-interaction supply is only supported for native ETH and ETH stablecoin targets"
       );
     }
     const walletAddressInput = request.account?.trim();
@@ -3934,6 +4038,12 @@ var SupplyFlowExecutor = class {
         "Contract-interaction supply requires a positive amount"
       );
     }
+    if (request.amount > MAX_UINT256) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        "Contract-interaction supply amount exceeds uint256 maximum"
+      );
+    }
     const walletAdapter = request.walletAdapter;
     if (!walletAdapter?.sendEthTransaction) {
       throw new LiquidiumError(
@@ -3942,6 +4052,26 @@ var SupplyFlowExecutor = class {
       );
     }
     this.params.requireApi();
+    if (target.asset === Asset.ETH) {
+      const depositTxid2 = await this.sendEthContractTransaction(
+        walletAdapter,
+        walletAddress,
+        createDepositEthTransaction({
+          depositContractAddress: CK_ETH_DEPOSIT_CONTRACT_ADDRESS,
+          amount: request.amount,
+          poolId: request.poolId,
+          profileId: request.profileId,
+          destinationAccount: target.address,
+          action: request.action
+        }),
+        `supply-${request.action}-deposit-eth`
+      );
+      await this.registerContractSupplyInflow(
+        depositTxid2,
+        defaultSubmitInflowRequest
+      );
+      return depositTxid2;
+    }
     this.requireEvmReadClient(
       "Contract-interaction supply requires an EVM RPC URL or public client"
     );
@@ -4015,11 +4145,17 @@ var SupplyFlowExecutor = class {
       }),
       `supply-${request.action}-deposit-erc20`
     );
+    await this.registerContractSupplyInflow(
+      depositTxid,
+      defaultSubmitInflowRequest
+    );
+    return depositTxid;
+  }
+  async registerContractSupplyInflow(txid, defaultSubmitInflowRequest) {
     try {
-      await this.submitInflowWithRetry(depositTxid, defaultSubmitInflowRequest);
+      await this.submitInflowWithRetry(txid, defaultSubmitInflowRequest);
     } catch {
     }
-    return depositTxid;
   }
   async sendChainAddressSupplyTransaction(params) {
     switch (params.chain) {
@@ -4039,6 +4175,12 @@ var SupplyFlowExecutor = class {
         });
       }
       case Chain.ETH: {
+        if (params.amount > MAX_UINT256) {
+          throw new LiquidiumError(
+            LiquidiumErrorCode.VALIDATION_ERROR,
+            "ETH transfer amount exceeds uint256 maximum"
+          );
+        }
         if (!params.walletAdapter.sendEthTransaction) {
           throw new LiquidiumError(
             LiquidiumErrorCode.VALIDATION_ERROR,
@@ -4228,6 +4370,22 @@ function isContractInteractionSupplyRequest(request) {
 function mapSupplyActionToStatusOperation(action) {
   return action === SupplyAction.repayment ? "repayment" : "deposit";
 }
+function validateDepositMinimum(params) {
+  if (params.action !== SupplyAction.deposit) {
+    return;
+  }
+  const minimumDepositAmountError = getDepositAmountMinimumValidationError({
+    amount: params.amount,
+    asset: params.asset
+  });
+  if (!minimumDepositAmountError) {
+    return;
+  }
+  throw new LiquidiumError(
+    LiquidiumErrorCode.VALIDATION_ERROR,
+    minimumDepositAmountError.message
+  );
+}
 function shouldSubmitInflow(params) {
   if (params.mechanism !== SupplyPlanType.transfer) {
     return true;
@@ -4758,7 +4916,7 @@ var LendingModule = class {
     return await this.createSupplyFlowExecutor().getEvmSupplyContext(request);
   }
   /**
-   * Returns the read-only deposit address for an ETH stablecoin inflow target.
+   * Returns the read-only deposit address for an ETH-chain inflow target.
    *
    * This is a query call that does not create or mutate state. Use it when you
    * need the deposit address without hitting the authorization-gated update path.
@@ -4767,13 +4925,22 @@ var LendingModule = class {
    * @returns The EVM deposit address for the derived account.
    */
   async getDepositAddress(request) {
-    if (!isEthStablecoin(request.asset, Chain.ETH)) {
+    if (request.asset !== Asset.ETH && !isEthStablecoin(request.asset, Chain.ETH)) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        "getDepositAddress is only supported for ETH-chain assets"
+      );
+    }
+    const selectedPool = await getPoolById(
+      this.canisterContext,
+      request.poolId
+    );
+    if (selectedPool.asset !== request.asset || selectedPool.chain !== Chain.ETH) {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
-        "getDepositAddress is only supported for ETH stablecoins"
+        `Deposit address asset ${request.asset} does not match pool ${request.poolId}`
       );
     }
-    const tokenAddress = getEthStablecoinContractAddress(request.asset);
     const subaccount = encodeInflowSubaccount({
       action: request.action,
       principal: Principal.fromText(request.profileId)
@@ -4785,17 +4952,20 @@ var LendingModule = class {
         owner: Principal.fromText(request.poolId),
         subaccount: [subaccount]
       },
-      [tokenAddress]
+      getEthDepositTokenAddress(request.asset)
     );
     if ("Err" in result) {
       throw mapDepositAccountErrorToLiquidiumError(result.Err);
     }
-    return result.Ok;
+    return normalizeAndValidateEvmAddress(
+      result.Ok,
+      "Deposit address canister returned an invalid EVM address"
+    );
   }
   /**
    * Estimates the network/deposit fee for an inflow target.
    *
-   * ETH stablecoin deposit-address estimates are served by the deposit-address
+   * ETH-chain 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.
    *
@@ -4809,10 +4979,10 @@ var LendingModule = class {
         totalFee: roundInflowFeeEstimate(request, ledgerFee)
       };
     }
-    if (isEthStablecoin(request.asset, request.chain)) {
+    if (request.chain === Chain.ETH && (request.asset === Asset.ETH || isEthStablecoin(request.asset, request.chain))) {
       const result = await createDepositAccountsActor(
         this.canisterContext
-      ).estimate_deposit_fee([getEthStablecoinContractAddress(request.asset)]);
+      ).estimate_deposit_fee(getEthDepositTokenAddress(request.asset));
       if ("Err" in result) {
         throw mapDepositAccountErrorToLiquidiumError(result.Err);
       }
@@ -4986,6 +5156,7 @@ var RATE_DECIMALS = BigInt(RATE_SCALE.toString().length - 1);
 // src/core/utils/asset-decimals.ts
 var ASSET_NATIVE_DECIMALS = {
   BTC: 8n,
+  ETH: 18n,
   ICP: 8n,
   USDC: 6n,
   USDT: 6n,
@@ -5075,6 +5246,7 @@ function formatPrice(price, decimals) {
 var ZERO_POOL_RATE = [0n, 0n, 0n];
 var BACKING_POOL_CHAIN_BY_ASSET = {
   [Asset.BTC]: Chain.BTC,
+  [Asset.ETH]: Chain.ETH,
   [Asset.ICP]: Chain.ICP,
   [Asset.USDC]: Chain.ETH,
   [Asset.USDT]: Chain.ETH
@@ -5965,12 +6137,14 @@ var REPAYMENT_BUFFER_SECONDS = 86400n;
 var RATE_SCALE2 = 10n ** 27n;
 var SECONDS_PER_YEAR = 31536000n;
 var MILLISECONDS_PER_SECOND3 = 1e3;
+var ETH_NATIVE_INFLOW_FEE_FALLBACK_WEI = 250000000000000n;
 var ETH_STABLECOIN_INFLOW_FEE_FALLBACK = 1500000n;
 var SIMPLE_LOAN_MIN_SLIPPAGE_BUFFER_BPS = 200n;
 var SIMPLE_LOAN_FIND_QUERY_MAX_LENGTH = 256;
 var SIMPLE_LOAN_WIRE_CONTEXT = "simple loan";
 var SIMPLE_LOAN_ASSETS = [
   Asset.BTC,
+  Asset.ETH,
   Asset.ICP,
   Asset.USDC,
   Asset.USDT
@@ -6401,7 +6575,7 @@ var SimpleLoansModule = class {
       const target = input.targets[chain];
       if (!target) continue;
       assertTargetAsset(target, input.asset);
-      const inflowFee = await this.lending.estimateInflowFee(target);
+      const inflowFee = await this.estimateInitialDepositInflowFee(target);
       targets[chain] = {
         amount: input.collateralAmount + inflowFee.totalFee,
         inflowFeeAmount: inflowFee.totalFee,
@@ -6417,6 +6591,24 @@ var SimpleLoansModule = class {
       expiryTimestamp: input.expiryTimestamp
     };
   }
+  async estimateInitialDepositInflowFee(target) {
+    try {
+      const fee = await this.lending.estimateInflowFee(target);
+      if (shouldUseNativeEthInflowFeeFallback(target, fee.totalFee)) {
+        return {
+          totalFee: getRepaymentInflowFeeFallback(target.asset, target.chain)
+        };
+      }
+      return fee;
+    } catch (error) {
+      if (target.asset !== Asset.ETH || target.chain !== Chain.ETH) {
+        throw error;
+      }
+      return {
+        totalFee: getRepaymentInflowFeeFallback(target.asset, target.chain)
+      };
+    }
+  }
   async resolveSimpleLoanInflowTargets(request) {
     const selectedPool = await getPoolById(
       this.canisterContext,
@@ -6467,6 +6659,12 @@ var SimpleLoansModule = class {
   async estimateRepaymentInflowFee(target) {
     try {
       const fee = await this.lending.estimateInflowFee(target);
+      if (shouldUseNativeEthInflowFeeFallback(target, fee.totalFee)) {
+        return {
+          totalFee: getRepaymentInflowFeeFallback(target.asset, target.chain),
+          estimateAvailable: false
+        };
+      }
       return { totalFee: fee.totalFee, estimateAvailable: true };
     } catch {
       return {
@@ -6542,11 +6740,17 @@ var SimpleLoansModule = class {
   }
 };
 function getRepaymentInflowFeeFallback(asset, chain) {
+  if (chain === Chain.ETH && asset === Asset.ETH) {
+    return ETH_NATIVE_INFLOW_FEE_FALLBACK_WEI;
+  }
   if (chain === "ETH" && (asset === "USDT" || asset === "USDC")) {
     return ETH_STABLECOIN_INFLOW_FEE_FALLBACK;
   }
   return 0n;
 }
+function shouldUseNativeEthInflowFeeFallback(target, totalFee) {
+  return totalFee <= 0n && target.asset === Asset.ETH && target.chain === Chain.ETH;
+}
 function assertTargetAsset(target, expectedAsset) {
   if (target.asset === expectedAsset) {
     return;
@@ -6664,6 +6868,16 @@ function validateCreateRequest(request) {
       "Simple loan collateral amount must be greater than zero"
     );
   }
+  const collateralMinimumError = getDepositAmountMinimumValidationError({
+    amount: request.collateral.amount,
+    asset: request.collateral.asset
+  });
+  if (collateralMinimumError) {
+    throw new LiquidiumError(
+      LiquidiumErrorCode.VALIDATION_ERROR,
+      collateralMinimumError.message
+    );
+  }
   if (request.borrow.amount <= 0n) {
     throw new LiquidiumError(
       LiquidiumErrorCode.VALIDATION_ERROR,
@@ -6696,7 +6910,7 @@ function inferSimpleLoanDeliveryChain(destination, asset) {
   if (asset === Asset.BTC) {
     return Chain.BTC;
   }
-  if (asset === Asset.USDC || asset === Asset.USDT) {
+  if (asset === Asset.ETH || asset === Asset.USDC || asset === Asset.USDT) {
     return Chain.ETH;
   }
   return Chain.ICP;
@@ -7229,6 +7443,6 @@ function resolveEvmReadClient(config) {
   });
 }
 
-export { AccountsModule, ActivitiesModule, ActivityFilter, Asset, CK_ETH_DEPOSIT_CONTRACT_ADDRESS, Chain, Environment, EvmSupplyApprovalStrategy, HistoryModule, LendingModule, LiquidiumAccountType, LiquidiumClient, LiquidiumError, LiquidiumErrorCode, MIN_BORROW_AMOUNTS_BY_ASSET, MIN_WITHDRAW_AMOUNTS_BY_ASSET, MarketModule, OutflowType, PositionsModule, QuoteModule, QuoteValidationErrorCode, QuoteWarningCode, RATE_DECIMALS, RATE_SCALE, SimpleLoanCreatedError, SimpleLoansModule, SupplyAction, SupplyPlanType, USDC_CONTRACT_ADDRESS, USDT_CONTRACT_ADDRESS, WalletActionKind, WalletExecutionKind, createTransferErc20Transaction, executeWith, getMinimumBorrowAmount, getMinimumWithdrawAmount, intFromPublicId, isAssetIdentifier, publicIdFromInt };
+export { AccountsModule, ActivitiesModule, ActivityFilter, Asset, CK_ETH_DEPOSIT_CONTRACT_ADDRESS, Chain, Environment, EvmSupplyApprovalStrategy, HistoryModule, LendingModule, LiquidiumAccountType, LiquidiumClient, LiquidiumError, LiquidiumErrorCode, MIN_BORROW_AMOUNTS_BY_ASSET, MIN_DEPOSIT_AMOUNTS_BY_ASSET, MIN_WITHDRAW_AMOUNTS_BY_ASSET, MarketModule, OutflowType, PositionsModule, QuoteModule, QuoteValidationErrorCode, QuoteWarningCode, RATE_DECIMALS, RATE_SCALE, SimpleLoanCreatedError, SimpleLoansModule, SupplyAction, SupplyPlanType, USDC_CONTRACT_ADDRESS, USDT_CONTRACT_ADDRESS, WalletActionKind, WalletExecutionKind, createTransferErc20Transaction, executeWith, getMinimumBorrowAmount, getMinimumDepositAmount, getMinimumWithdrawAmount, intFromPublicId, isAssetIdentifier, publicIdFromInt };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map