@liquidium/client 0.3.4 → 0.4.0

package/dist/index.cjs

@@ -32,11 +32,7 @@ var SupplyAction = {
 var OutflowType = {
   borrow: "borrow",
   feeClaim: "feeClaim",
-  withdraw: "withdraw"
-};
-var InflowSubmitType = {
-  DEPOSIT: "DEPOSIT",
-  REPAY: "REPAY"
+  withdrawal: "withdrawal"
 };
 
 // src/core/config.ts
@@ -1370,8 +1366,8 @@ function mapCanisterWalletToWallet(canisterWallet) {
       );
   }
 }
-var KNOWN_ASSET_TAGS = ["BTC", "SOL", "USDC", "USDT"];
-var KNOWN_CHAIN_TAGS = ["BTC", "ETH", "SOL"];
+var KNOWN_ASSET_TAGS = ["BTC", "USDC", "USDT"];
+var KNOWN_CHAIN_TAGS = ["BTC", "ETH"];
 function extractVariantTag(variant, knownTags) {
   const [key] = Object.keys(variant);
   if (!key) {
@@ -1684,49 +1680,24 @@ function decodeLoanCreatedEvent(payload) {
 }
 
 // src/core/sdk-api-paths.ts
-var SDK_API_VERSION = {
-  activities: "v1",
-  history: "v1",
-  inflow: "v1",
-  instantLoans: "v1"
-};
+var SDK_API_V1_PATH = "/v1";
+var SDK_API_V2_PATH = "/v2";
 var SdkApiQueryParam = {
   cursor: "cursor",
   from: "from",
+  filter: "filter",
   limit: "limit",
   market: "market",
+  operations: "operations",
   poolId: "poolId",
   profileId: "profileId",
-  state: "state",
-  statuses: "statuses",
-  to: "to",
-  types: "types"
+  states: "states",
+  to: "to"
 };
-var ACTIVITIES = `/${SDK_API_VERSION.activities}/activities`;
-var HISTORY_POOL = `/${SDK_API_VERSION.history}/history/pool`;
-var HISTORY_POOL_CONFIG = `/${SDK_API_VERSION.history}/history/pool-config`;
-var HISTORY_RATES = `/${SDK_API_VERSION.history}/history/rates`;
-var HISTORY_USERS = `/${SDK_API_VERSION.history}/history/users`;
-var INFLOW = `/${SDK_API_VERSION.inflow}/inflow`;
-var INSTANT_LOANS = `/${SDK_API_VERSION.instantLoans}/instant-loans`;
-function buildHistoryPoolPath(poolId, query) {
-  const base = `${HISTORY_POOL}/${encodeURIComponent(poolId)}`;
-  const qs = query.toString();
-  return qs ? `${base}?${qs}` : base;
-}
-function buildHistoryPoolConfigPath(poolId, cursor) {
-  const base = `${HISTORY_POOL_CONFIG}/${encodeURIComponent(poolId)}`;
-  if (!cursor) {
-    return base;
-  }
-  const query = new URLSearchParams({ [SdkApiQueryParam.cursor]: cursor });
-  return `${base}?${query.toString()}`;
-}
-function buildHistoryRatesPath(poolId, query) {
-  const base = `${HISTORY_RATES}/${encodeURIComponent(poolId)}`;
-  const qs = query.toString();
-  return qs ? `${base}?${qs}` : base;
-}
+var ACTIVITIES = `${SDK_API_V2_PATH}/activities`;
+var HISTORY_USERS = `${SDK_API_V2_PATH}/history/users`;
+var INFLOW = `${SDK_API_V2_PATH}/inflow`;
+var INSTANT_LOANS = `${SDK_API_V1_PATH}/instant-loans`;
 function buildHistoryUserTransactionsPath(user, query) {
   const base = `${HISTORY_USERS}/${encodeURIComponent(user)}/transactions`;
   const qs = query.toString();
@@ -1741,8 +1712,8 @@ function buildActivitiesPath(request) {
   const query = new URLSearchParams({
     [SdkApiQueryParam.profileId]: request.profileId
   });
-  if (request.state) {
-    query.set(SdkApiQueryParam.state, request.state);
+  if (request.filter) {
+    query.set(SdkApiQueryParam.filter, request.filter);
   }
   return `${ACTIVITIES}?${query.toString()}`;
 }
@@ -1800,12 +1771,6 @@ function parseBigInt(value, label) {
     );
   }
 }
-function parseOptionalBigInt(value, label) {
-  if (value === void 0) {
-    return void 0;
-  }
-  return parseBigInt(value, label);
-}
 
 // src/modules/instant-loans/ref-code.ts
 var REF_LENGTH = 6;
@@ -1876,28 +1841,8 @@ var ActivityFilter = {
   completed: "completed",
   all: "all"
 };
-var ActivityDirection = {
-  inflow: "inflow",
-  outflow: "outflow"
-};
-var ActivityKind = {
-  deposit: "deposit",
-  repayment: "repayment",
-  borrow: "borrow",
-  withdraw: "withdraw"
-};
-var ActivityStatus = {
-  requested: "requested",
-  pending: "pending",
-  detected: "detected",
-  processing: "processing",
-  sent: "sent",
-  confirmed: "confirmed",
-  failed: "failed"
-};
 
 // src/modules/activities/activities.ts
-var PRE_TERMINAL_ETH_ACTIVITY_ID_PREFIX = "pre_terminal_eth_";
 var ActivitiesModule = class {
   constructor(apiClient, canisterContext) {
     this.apiClient = apiClient;
@@ -1906,11 +1851,11 @@ var ActivitiesModule = class {
   apiClient;
   canisterContext;
   /**
-   * Lists profile activities. Defaults to all activities.
+   * Lists profile activities. Defaults to active activities.
    *
    * Uses the Liquidium SDK API.
    *
-   * @param request - Profile id or instant-loan short reference plus optional state filter.
+   * @param request - Profile id or instant-loan short reference plus optional lifecycle filter.
    * @returns Activities owned by the resolved profile.
    */
   async list(request) {
@@ -1919,7 +1864,7 @@ var ActivitiesModule = class {
     const response = await apiClient.get(
       buildActivitiesPath({
         profileId,
-        state: request.filter ?? ActivityFilter.all
+        filter: request.filter ?? ActivityFilter.active
       })
     );
     return response.activities.map(mapActivity);
@@ -2000,76 +1945,48 @@ function mapInstantLoanLookupError(error) {
   return new LiquidiumError(LiquidiumErrorCode.INTERNAL, key);
 }
 function mapActivity(wire) {
-  const { amount, stage, status, topUp: topUpWire, ...activity } = wire;
-  const effectiveStage = stage ?? deriveActivityStage(wire);
-  const topUp = activity.direction === ActivityDirection.inflow && topUpWire ? mapActivityTopUp(topUpWire) : void 0;
-  if (activity.direction === ActivityDirection.inflow) {
-    return {
-      ...activity,
-      direction: ActivityDirection.inflow,
-      kind: mapInflowActivityKind(activity.kind),
-      status: mapInflowActivityStatus(
-        mapActivityStatus(status, effectiveStage)
-      ),
-      ...topUp ? { topUp } : {},
-      amount: parseBigInt(amount, "activity amount")
-    };
-  }
-  return {
-    ...activity,
-    direction: ActivityDirection.outflow,
-    kind: mapOutflowActivityKind(activity.kind),
-    status: mapOutflowActivityStatus(mapActivityStatus(status, effectiveStage)),
-    amount: parseBigInt(amount, "activity amount")
+  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
   };
-}
-function mapInflowActivityKind(kind) {
-  if (kind === "deposit" || kind === "repayment") {
-    return kind;
-  }
-  throw new LiquidiumError(
-    LiquidiumErrorCode.INTERNAL,
-    `Invalid inflow activity kind: ${kind}`
-  );
-}
-function mapOutflowActivityKind(kind) {
-  if (kind === "borrow" || kind === "withdraw") {
-    return kind;
+  if (isInflowOperation(wire.status.operation)) {
+    const activity = {
+      ...activityBase,
+      status: wire.status
+    };
+    if (wire.txids) {
+      activity.txids = wire.txids;
+    }
+    if (wire.topUp) {
+      activity.topUp = mapActivityTopUp(wire.topUp);
+    }
+    return activity;
   }
-  throw new LiquidiumError(
-    LiquidiumErrorCode.INTERNAL,
-    `Invalid outflow activity kind: ${kind}`
-  );
-}
-function mapInflowActivityStatus(status) {
-  if (status !== "sent") {
-    return status;
+  if (isOutflowOperation(wire.status.operation)) {
+    const activity = {
+      ...activityBase,
+      status: wire.status
+    };
+    if (wire.txids) {
+      activity.txids = wire.txids;
+    }
+    return activity;
   }
   throw new LiquidiumError(
     LiquidiumErrorCode.INTERNAL,
-    `Invalid inflow activity status: ${status}`
+    `Invalid activity operation: ${wire.status.operation}`
   );
 }
-function mapOutflowActivityStatus(status) {
-  if (status !== "detected" && status !== "processing") {
-    return status;
-  }
-  throw new LiquidiumError(
-    LiquidiumErrorCode.INTERNAL,
-    `Invalid outflow activity status: ${status}`
-  );
+function isInflowOperation(operation) {
+  return operation === "deposit" || operation === "repayment";
 }
-function mapActivityStatus(status, stage) {
-  if (status !== "pending") {
-    return status;
-  }
-  if (stage === "deposited") {
-    return "detected";
-  }
-  if (stage === "confirmed" || stage === "finalising" || stage === "pending") {
-    return "processing";
-  }
-  return "pending";
+function isOutflowOperation(operation) {
+  return operation === "borrow" || operation === "withdrawal";
 }
 function mapActivityTopUp(wire) {
   return {
@@ -2085,24 +2002,6 @@ function mapActivityTopUp(wire) {
     )
   };
 }
-function deriveActivityStage(wire) {
-  if (wire.id.startsWith(PRE_TERMINAL_ETH_ACTIVITY_ID_PREFIX) && wire.direction === ActivityDirection.inflow && wire.chain === Chain.ETH) {
-    return "deposited";
-  }
-  return void 0;
-}
-
-// src/core/rates.ts
-var RATE_SCALE = 1000000000000000000000000000n;
-var RATE_DECIMALS = BigInt(RATE_SCALE.toString().length - 1);
-
-// src/modules/history/types.ts
-var UserHistoryStatus = {
-  requested: "requested",
-  pending: "pending",
-  confirmed: "confirmed",
-  failed: "failed"
-};
 
 // src/modules/history/history.ts
 var HistoryModule = class {
@@ -2120,154 +2019,41 @@ var HistoryModule = class {
     return this.apiClient;
   }
   /**
-   * Returns paginated rate and utilization history for a pool.
-   *
-   * @param poolId - The pool principal text.
-   * @param window - Optional time window with from/to timestamps and limit.
-   * @returns A page of pool rate history entries and the next cursor when more results are available.
-   */
-  async getPoolHistory(poolId, window = {}) {
-    const apiClient = this.requireApi();
-    const query = createHistoryWindowQuery(window);
-    const requestPath = buildHistoryPoolPath(poolId, query);
-    const response = await apiClient.get(requestPath);
-    return {
-      items: response.items.map((item) => ({
-        date: item.date,
-        rateDecimals: RATE_DECIMALS,
-        avgBorrowRate: parseBigInt(item.avgBorrowRate, "pool borrow rate"),
-        avgLendRate: parseBigInt(item.avgLendRate, "pool lend rate"),
-        avgUtilizationRate: parseBigInt(
-          item.avgUtilizationRate,
-          "pool utilization rate"
-        )
-      })),
-      nextCursor: response.nextCursor
-    };
-  }
-  /**
-   * Returns paginated configuration change history for a pool.
-   *
-   * @param poolId - The pool principal text.
-   * @param cursor - An optional pagination cursor from a previous response.
-   * @returns A page of pool configuration changes and the next cursor when more results are available.
-   */
-  async getPoolConfigHistory(poolId, cursor) {
-    const apiClient = this.requireApi();
-    const requestPath = buildHistoryPoolConfigPath(poolId, cursor);
-    const response = await apiClient.get(requestPath);
-    return {
-      items: response.items.map((item) => ({
-        type: item.type,
-        poolId: item.poolId,
-        asset: item.asset,
-        chain: item.chain,
-        timestamp: item.timestamp,
-        totalSupply: parseBigInt(item.totalSupply, "pool history totalSupply"),
-        totalDebt: parseBigInt(item.totalDebt, "pool history totalDebt"),
-        supplyCap: parseOptionalBigInt(
-          item.supplyCap,
-          "pool history supplyCap"
-        ),
-        borrowCap: parseOptionalBigInt(
-          item.borrowCap,
-          "pool history borrowCap"
-        ),
-        maxLtv: parseBigInt(item.maxLtv, "pool history maxLtv"),
-        liquidationThreshold: parseBigInt(
-          item.liquidationThreshold,
-          "pool history liquidationThreshold"
-        ),
-        liquidationBonus: parseBigInt(
-          item.liquidationBonus,
-          "pool history liquidationBonus"
-        ),
-        protocolLiquidationFee: parseBigInt(
-          item.protocolLiquidationFee,
-          "pool history protocolLiquidationFee"
-        ),
-        reserveFactor: parseBigInt(
-          item.reserveFactor,
-          "pool history reserveFactor"
-        ),
-        baseRate: parseBigInt(item.baseRate, "pool history baseRate"),
-        optimalUtilizationRate: parseBigInt(
-          item.optimalUtilizationRate,
-          "pool history optimalUtilizationRate"
-        ),
-        rateSlopeBefore: parseBigInt(
-          item.rateSlopeBefore,
-          "pool history rateSlopeBefore"
-        ),
-        rateSlopeAfter: parseBigInt(
-          item.rateSlopeAfter,
-          "pool history rateSlopeAfter"
-        ),
-        lendingIndex: parseBigInt(
-          item.lendingIndex,
-          "pool history lendingIndex"
-        ),
-        borrowIndex: parseBigInt(item.borrowIndex, "pool history borrowIndex"),
-        sameAssetBorrowing: item.sameAssetBorrowing,
-        frozen: item.frozen
-      })),
-      nextCursor: response.nextCursor
-    };
-  }
-  /**
-   * Returns borrow rate history for a pool.
+   * Returns transaction history for a user.
    *
-   * @param poolId - The pool principal text.
-   * @param window - Optional time window with from/to timestamps and limit.
-   * @returns Paginated APY samples.
+   * @param user - The Liquidium profile principal text.
+   * @param filters - Optional pool, operation, state, time range, and pagination filters.
+   * @returns Paginated user history entries.
    */
-  async getBorrowRateHistory(poolId, window = {}) {
-    const apiClient = this.requireApi();
-    const query = createHistoryWindowQuery(window);
-    const requestPath = buildHistoryRatesPath(poolId, query);
-    const response = await apiClient.get(requestPath);
-    return {
-      items: response.items.map((item) => ({
-        date: item.date,
-        rateDecimals: RATE_DECIMALS,
-        avgRate: parseBigInt(item.avgRate, "borrow rate")
-      })),
-      nextCursor: response.nextCursor
-    };
-  }
-  async getUserTransactionHistory(user, marketOrFilters, filters = {}) {
+  async getUserTransactionHistory(user, filters = {}) {
     const apiClient = this.requireApi();
-    const normalizedFilters = normalizeTransactionHistoryFilters(
-      marketOrFilters,
-      filters
-    );
     const query = new URLSearchParams();
-    if (normalizedFilters.cursor) {
-      query.set(SdkApiQueryParam.cursor, normalizedFilters.cursor);
+    if (filters.cursor) {
+      query.set(SdkApiQueryParam.cursor, filters.cursor);
     }
-    if (normalizedFilters.market) {
-      query.set(SdkApiQueryParam.market, normalizedFilters.market);
+    if (filters.market) {
+      query.set(SdkApiQueryParam.market, filters.market);
     }
-    if (normalizedFilters.poolId) {
-      query.set(SdkApiQueryParam.poolId, normalizedFilters.poolId);
+    if (filters.poolId) {
+      query.set(SdkApiQueryParam.poolId, filters.poolId);
     }
-    if (normalizedFilters.types?.length) {
-      query.set(SdkApiQueryParam.types, normalizedFilters.types.join(","));
+    if (filters.operations?.length) {
+      query.set(SdkApiQueryParam.operations, filters.operations.join(","));
     }
-    if (normalizedFilters.statuses?.length) {
+    if (filters.states?.length) {
       query.set(
-        SdkApiQueryParam.statuses,
-        normalizedFilters.statuses.map(mapHistoryStatusToApi).join(",")
+        SdkApiQueryParam.states,
+        createHistoryStateFilterParam(filters.states)
       );
     }
-    if (normalizedFilters.from) {
-      query.set(SdkApiQueryParam.from, normalizedFilters.from);
+    if (filters.from) {
+      query.set(SdkApiQueryParam.from, filters.from);
     }
-    if (normalizedFilters.to) {
-      query.set(SdkApiQueryParam.to, normalizedFilters.to);
+    if (filters.to) {
+      query.set(SdkApiQueryParam.to, filters.to);
     }
-    if (normalizedFilters.limit !== void 0) {
-      query.set(SdkApiQueryParam.limit, String(normalizedFilters.limit));
+    if (filters.limit !== void 0) {
+      query.set(SdkApiQueryParam.limit, String(filters.limit));
     }
     const requestPath = buildHistoryUserTransactionsPath(user, query);
     const response = await apiClient.get(requestPath);
@@ -2276,30 +2062,33 @@ var HistoryModule = class {
       nextCursor: response.nextCursor
     };
   }
-  async getLiquidationHistory(user, marketOrFilters, filters = {}) {
+  /**
+   * Returns liquidation history for a user.
+   *
+   * @param user - The Liquidium profile principal text.
+   * @param filters - Optional pool, time range, and pagination filters.
+   * @returns Paginated liquidation history entries.
+   */
+  async getLiquidationHistory(user, filters = {}) {
     const apiClient = this.requireApi();
-    const normalizedFilters = normalizeLiquidationHistoryFilters(
-      marketOrFilters,
-      filters
-    );
     const query = new URLSearchParams();
-    if (normalizedFilters.cursor) {
-      query.set(SdkApiQueryParam.cursor, normalizedFilters.cursor);
+    if (filters.cursor) {
+      query.set(SdkApiQueryParam.cursor, filters.cursor);
     }
-    if (normalizedFilters.market) {
-      query.set(SdkApiQueryParam.market, normalizedFilters.market);
+    if (filters.market) {
+      query.set(SdkApiQueryParam.market, filters.market);
     }
-    if (normalizedFilters.poolId) {
-      query.set(SdkApiQueryParam.poolId, normalizedFilters.poolId);
+    if (filters.poolId) {
+      query.set(SdkApiQueryParam.poolId, filters.poolId);
     }
-    if (normalizedFilters.from) {
-      query.set(SdkApiQueryParam.from, normalizedFilters.from);
+    if (filters.from) {
+      query.set(SdkApiQueryParam.from, filters.from);
     }
-    if (normalizedFilters.to) {
-      query.set(SdkApiQueryParam.to, normalizedFilters.to);
+    if (filters.to) {
+      query.set(SdkApiQueryParam.to, filters.to);
     }
-    if (normalizedFilters.limit !== void 0) {
-      query.set(SdkApiQueryParam.limit, String(normalizedFilters.limit));
+    if (filters.limit !== void 0) {
+      query.set(SdkApiQueryParam.limit, String(filters.limit));
     }
     const requestPath = buildHistoryUserLiquidationsPath(user, query);
     const response = await apiClient.get(requestPath);
@@ -2312,77 +2101,59 @@ var HistoryModule = class {
 function mapUserTransactionHistoryEntry(item) {
   return {
     id: item.id,
-    type: mapUserTransactionHistoryType(item.type),
     amount: parseBigInt(item.amount, "history user amount"),
     poolId: item.poolId,
     timestamp: item.timestamp,
-    status: mapHistoryStatusFromApi(item.status),
+    status: item.status,
     txids: item.txids
   };
 }
 function mapUserLiquidationHistoryEntry(item) {
-  if (item.type !== "liquidation") {
+  if (item.status.operation !== "liquidation" || item.status.state !== "completed") {
     throw new LiquidiumError(
       LiquidiumErrorCode.INTERNAL,
-      `Invalid liquidation history type: ${item.type}`
+      `Invalid liquidation history status: ${item.status.state}`
     );
   }
   return {
     id: item.id,
-    type: "liquidation",
     amount: parseBigInt(item.amount, "history user amount"),
     poolId: item.poolId,
     timestamp: item.timestamp,
-    status: mapLiquidationHistoryStatus(item.status),
+    status: item.status,
     txids: item.txids
   };
 }
-function mapUserTransactionHistoryType(type) {
-  if (type !== "liquidation") {
-    return type;
-  }
-  throw new LiquidiumError(
-    LiquidiumErrorCode.INTERNAL,
-    "Transaction history response included a liquidation entry"
-  );
-}
-function mapLiquidationHistoryStatus(status) {
-  const mappedStatus = mapHistoryStatusFromApi(status);
-  if (mappedStatus === UserHistoryStatus.confirmed) {
-    return mappedStatus;
-  }
-  throw new LiquidiumError(
-    LiquidiumErrorCode.INTERNAL,
-    `Invalid liquidation history status: ${status}`
-  );
-}
-function createHistoryWindowQuery(window) {
-  const query = new URLSearchParams();
-  if (window.cursor) query.set(SdkApiQueryParam.cursor, window.cursor);
-  if (window.from) query.set(SdkApiQueryParam.from, window.from);
-  if (window.to) query.set(SdkApiQueryParam.to, window.to);
-  if (window.limit !== void 0) {
-    query.set(SdkApiQueryParam.limit, String(window.limit));
+function createHistoryStateFilterParam(states) {
+  for (const state of states) {
+    validateHistoryStateFilter(state);
   }
-  return query;
+  return [...new Set(states)].join(",");
 }
-function normalizeTransactionHistoryFilters(marketOrFilters, filters) {
-  if (typeof marketOrFilters === "string") {
-    return { ...filters, market: marketOrFilters };
-  }
-  return { ...marketOrFilters ?? {}, ...filters };
-}
-function normalizeLiquidationHistoryFilters(marketOrFilters, filters) {
-  if (typeof marketOrFilters === "string") {
-    return { ...filters, market: marketOrFilters };
+function validateHistoryStateFilter(state) {
+  switch (state) {
+    case "action_required":
+    case "confirming":
+    case "processing":
+    case "completed":
+    case "failed":
+      return;
+    default:
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        `History state filter is not supported: ${state}`
+      );
   }
-  return { ...marketOrFilters ?? {}, ...filters };
 }
-function mapHistoryStatusFromApi(status) {
-  return status.toLowerCase();
-}
-function mapHistoryStatusToApi(status) {
-  return status.toUpperCase();
+
+// src/core/status.ts
+function createLiquidiumStatus(params) {
+  return {
+    operation: params.operation,
+    state: params.state,
+    confirmations: params.confirmations ?? null,
+    requiredConfirmations: params.requiredConfirmations ?? null
+  };
 }
 
 // src/core/utils/api-response-parsers.ts
@@ -3979,20 +3750,11 @@ function getChainForInstantLoanAsset(asset) {
   return asset;
 }
 
-// src/modules/instant-loans/types.ts
-var InstantLoanStatus = {
-  awaitingDeposit: "awaiting_deposit",
-  depositDetected: "deposit_detected",
-  active: "active",
-  settling: "settling",
-  closed: "closed",
-  expired: "expired"
-};
-
 // src/modules/instant-loans/instant-loans.ts
 var REPAYMENT_BUFFER_SECONDS = 86400n;
-var RATE_SCALE2 = 10n ** 27n;
+var RATE_SCALE = 10n ** 27n;
 var SECONDS_PER_YEAR = 31536000n;
+var MILLISECONDS_PER_SECOND3 = 1e3;
 var ETH_STABLECOIN_INFLOW_FEE_FALLBACK = 1500000n;
 var INSTANT_LOAN_MIN_SLIPPAGE_BUFFER_BPS = 200n;
 var INSTANT_LOAN_FIND_QUERY_MAX_LENGTH = 256;
@@ -4004,14 +3766,16 @@ var INSTANT_LOAN_ASSETS = [
   Asset.USDT
 ];
 var InstantLoansModule = class {
-  constructor(canisterContext, apiClient, lending, positions) {
+  constructor(canisterContext, apiClient, activities, lending, positions) {
     this.canisterContext = canisterContext;
     this.apiClient = apiClient;
+    this.activities = activities;
     this.lending = lending;
     this.positions = positions;
   }
   canisterContext;
   apiClient;
+  activities;
   lending;
   positions;
   /**
@@ -4211,7 +3975,8 @@ var InstantLoansModule = class {
     const response = await apiClient.get(
       buildInstantLoanFindPath({ query })
     );
-    return (response.candidates ?? response.loans ?? []).map(mapCandidateWire);
+    const candidates = "candidates" in response ? response.candidates : response.loans;
+    return candidates.map(mapCandidateWire);
   }
   async getLoanRecord(loanId) {
     try {
@@ -4250,6 +4015,7 @@ var InstantLoansModule = class {
       borrowAmount: record.borrow_amount,
       borrowDestination: accountFromCanister(record.borrow_destination),
       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,
@@ -4278,7 +4044,8 @@ var InstantLoansModule = class {
       repayTarget,
       collateralPosition,
       borrowPosition,
-      borrowPoolRate
+      borrowPoolRate,
+      activeActivities
     ] = await Promise.all([
       resolveSupplyTarget(this.canisterContext, {
         profileId,
@@ -4294,7 +4061,8 @@ var InstantLoansModule = class {
       }),
       this.positions.getPosition(profileId, collateralPoolId),
       this.positions.getPosition(profileId, borrowPoolId),
-      this.positions.market.getPoolRate(borrowPoolId)
+      this.positions.market.getPoolRate(borrowPoolId),
+      this.activities.list({ profileId, filter: ActivityFilter.active })
     ]);
     const totalDebtAmount = calculateTotalDebtAmount(borrowPosition);
     const interestBufferAmount = calculateInterestBufferAmount(
@@ -4311,8 +4079,12 @@ var InstantLoansModule = class {
     const borrowedDecimals = borrowPosition?.borrowedDecimals ?? getAssetNativeDecimals(borrowAsset);
     const debtInterestAmount = borrowPosition?.debtInterest ?? 0n;
     const status = deriveInstantLoanStatus({
+      started: input.started,
+      depositDetectedTimestamp: input.depositDetectedTimestamp,
+      expiryTimestamp: input.expiryTimestamp,
       collateralAmount: currentCollateralAmount,
-      totalDebtAmount
+      totalDebtAmount,
+      activeActivities
     });
     const initialDeposit = await this.createInitialDepositQuote({
       collateralAmount,
@@ -4464,7 +4236,7 @@ function calculateInterestBufferAmount(borrowPosition, annualBorrowRate) {
   if (totalDebtAmount <= 0n || annualBorrowRate <= 0n) {
     return 0n;
   }
-  const interestBuffer = totalDebtAmount * annualBorrowRate * REPAYMENT_BUFFER_SECONDS / RATE_SCALE2 / SECONDS_PER_YEAR;
+  const interestBuffer = totalDebtAmount * annualBorrowRate * REPAYMENT_BUFFER_SECONDS / RATE_SCALE / SECONDS_PER_YEAR;
   return interestBuffer > 1n ? interestBuffer : 1n;
 }
 function calculateTotalDebtAmount(borrowPosition) {
@@ -4474,13 +4246,75 @@ function calculateTotalDebtAmount(borrowPosition) {
   return borrowPosition.borrowed + borrowPosition.debtInterest;
 }
 function deriveInstantLoanStatus(input) {
+  const activeActivityStatus = deriveActiveInstantLoanActivityStatus(input);
+  if (activeActivityStatus) {
+    return activeActivityStatus;
+  }
   if (input.totalDebtAmount > 0n) {
-    return InstantLoanStatus.active;
+    return createLiquidiumStatus({
+      operation: "repayment",
+      state: "active"
+    });
+  }
+  if (input.started) {
+    return createLiquidiumStatus({
+      operation: "repayment",
+      state: "completed"
+    });
+  }
+  if (isInstantLoanDepositExpired(input)) {
+    return createLiquidiumStatus({
+      operation: "deposit",
+      state: "expired"
+    });
   }
   if (input.collateralAmount > 0n) {
-    return InstantLoanStatus.depositDetected;
+    return createLiquidiumStatus({
+      operation: "deposit",
+      state: "processing"
+    });
+  }
+  if (input.depositDetectedTimestamp !== null) {
+    return createLiquidiumStatus({
+      operation: "deposit",
+      state: "confirming"
+    });
+  }
+  return createLiquidiumStatus({
+    operation: "deposit",
+    state: "action_required"
+  });
+}
+function deriveActiveInstantLoanActivityStatus(input) {
+  if (!input.started) {
+    return findActiveActivityStatus(input.activeActivities, "deposit");
+  }
+  const borrowStatus = findActiveActivityStatus(
+    input.activeActivities,
+    "borrow"
+  );
+  if (borrowStatus) {
+    return borrowStatus;
+  }
+  return findActiveActivityStatus(input.activeActivities, "repayment");
+}
+function findActiveActivityStatus(activities, operation) {
+  const activity = activities.find(
+    (candidate) => candidate.status.operation === operation
+  );
+  return activity?.status ?? null;
+}
+function isInstantLoanDepositExpired(input) {
+  if (input.started || input.depositDetectedTimestamp === null) {
+    return false;
+  }
+  if (input.expiryTimestamp === null) {
+    return false;
   }
-  return InstantLoanStatus.awaitingDeposit;
+  return input.expiryTimestamp <= getCurrentUnixTimestampSeconds();
+}
+function getCurrentUnixTimestampSeconds() {
+  return BigInt(Math.floor(Date.now() / MILLISECONDS_PER_SECOND3));
 }
 function deriveDepositExpiryTimestamp(input) {
   if (input.depositDetectedTimestamp === null) {
@@ -4929,6 +4763,28 @@ function accountTypeToString(accountType) {
   }
 }
 
+// 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;
+function roundInflowFeeEstimate(request, totalFee) {
+  if (totalFee <= 0n) {
+    return 0n;
+  }
+  if (isEthStablecoin(request.asset, request.chain)) {
+    return roundUpToNearest(
+      totalFee,
+      ETH_STABLECOIN_INFLOW_FEE_ROUND_UP_TO_NEAREST_10_CENTS
+    );
+  }
+  if (request.asset === Asset.BTC && request.chain === Chain.BTC) {
+    return roundUpToNearest(totalFee, BTC_INFLOW_FEE_ROUND_UP_TO_NEAREST_SATS);
+  }
+  return totalFee;
+}
+function roundUpToNearest(amount, roundingUnit) {
+  return ceilDivBigint(amount, roundingUnit) * roundingUnit;
+}
+
 // src/core/utils/retry.ts
 var MIN_ATTEMPTS = 1;
 var MIN_INITIAL_RETRY_DELAY_MS = 0;
@@ -4980,835 +4836,966 @@ function assertValidRetryOptions(options) {
   }
 }
 
-// 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;
-function roundInflowFeeEstimate(request, totalFee) {
-  if (totalFee <= 0n) {
-    return 0n;
+// src/modules/lending/_internal/supply-flow.ts
+var SUBMIT_INFLOW_MAX_ATTEMPTS = 4;
+var SUBMIT_INFLOW_INITIAL_RETRY_DELAY_MS = 1500;
+var SUBMIT_INFLOW_RETRY_BACKOFF_MULTIPLIER = 2;
+var ETH_APPROVAL_POLL_INTERVAL_MS = 2e3;
+var ETH_APPROVAL_MAX_POLLS = 30;
+var SupplyFlowExecutor = class {
+  constructor(params) {
+    this.params = params;
   }
-  if (isEthStablecoin(request.asset, request.chain)) {
-    return roundUpToNearest(
-      totalFee,
-      ETH_STABLECOIN_INFLOW_FEE_ROUND_UP_TO_NEAREST_10_CENTS
+  params;
+  async create(request) {
+    const target = await resolveSupplyTarget(
+      this.params.canisterContext,
+      request
     );
-  }
-  if (request.asset === Asset.BTC && request.chain === Chain.BTC) {
-    return roundUpToNearest(totalFee, BTC_INFLOW_FEE_ROUND_UP_TO_NEAREST_SATS);
-  }
-  return totalFee;
-}
-function roundUpToNearest(amount, roundingUnit) {
-  return ceilDivBigint(amount, roundingUnit) * roundingUnit;
-}
-function mapCanisterOutflowDetails(outflow) {
-  const rawOutflowType = getVariantKey(outflow.outflow_type);
-  return {
-    id: outflow.id,
-    outflowType: normalizeOutflowType(rawOutflowType),
-    outflowRef: outflow.outflow_ref[0],
-    txid: outflow.txid[0],
-    amount: outflow.amount,
-    receiver: mapCanisterAccountType(outflow.receiver)
-  };
-}
-function mapCanisterAccountType(receiver) {
-  if ("Native" in receiver) {
-    return {
-      type: "Native",
-      account: receiver.Native.toText()
+    const instruction = {
+      poolId: request.poolId,
+      asset: target.asset,
+      chain: target.chain,
+      action: request.action,
+      target
     };
-  }
-  if ("AccountIdentifier" in receiver) {
+    const mechanism = resolveSupplyMechanism({
+      asset: instruction.asset,
+      chain: instruction.chain,
+      requestedMechanism: request.mechanism
+    });
+    const defaultSubmitInflowRequest = getDefaultSubmitInflowRequest({
+      action: request.action,
+      chain: mechanism === SupplyPlanType.contractInteraction ? Chain.ETH : instruction.chain
+    });
+    let txid;
+    switch (mechanism) {
+      case SupplyPlanType.transfer:
+        if (request.walletAdapter) {
+          txid = await this.sendAndSubmitNativeSupplyInflow({
+            request,
+            instruction,
+            defaultSubmitInflowRequest
+          });
+        }
+        break;
+      case SupplyPlanType.contractInteraction:
+        txid = await this.executeContractSupply({
+          request,
+          instruction,
+          defaultSubmitInflowRequest
+        });
+        break;
+    }
     return {
-      type: "AccountIdentifier",
-      account: receiver.AccountIdentifier
+      type: mechanism,
+      target: instruction.target,
+      txid,
+      status: createLiquidiumStatus({
+        operation: mapSupplyActionToStatusOperation(request.action),
+        state: txid ? "confirming" : "action_required"
+      }),
+      submit: async (submitRequest) => {
+        return await this.submitSupplyFlowInflow({
+          instruction,
+          mechanism,
+          defaultSubmitInflowRequest,
+          submitRequest
+        });
+      }
     };
   }
-  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 {
-    type: "External",
-    account: receiver.External
-  };
-}
-function normalizeOptionalSubaccount2(subaccount) {
-  if (!subaccount) {
-    return void 0;
-  }
-  return subaccount instanceof Uint8Array ? subaccount : Uint8Array.from(subaccount);
-}
-function normalizeOutflowType(rawOutflowType) {
-  switch (rawOutflowType) {
-    case "Withdraw":
-      return OutflowType.withdraw;
-    case "Borrow":
-      return OutflowType.borrow;
-    case "FeeClaim":
-      return OutflowType.feeClaim;
-    default:
-      throw new LiquidiumError(
-        LiquidiumErrorCode.INTERNAL,
-        `Unsupported outflow type: ${rawOutflowType}`
-      );
-  }
-}
-function mapWalletChainToLendingChain(chain) {
-  switch (chain) {
-    case Chain.BTC:
-      return { BTC: null };
-    case Chain.ETH:
-      return { ETH: null };
-  }
-}
-
-// src/modules/lending/lending.ts
-var SUBMIT_INFLOW_MAX_ATTEMPTS = 4;
-var SUBMIT_INFLOW_INITIAL_RETRY_DELAY_MS = 1500;
-var SUBMIT_INFLOW_RETRY_BACKOFF_MULTIPLIER = 2;
-var ETH_APPROVAL_POLL_INTERVAL_MS = 2e3;
-var ETH_APPROVAL_MAX_POLLS = 30;
-var LendingModule = class {
-  constructor(canisterContext, apiClient, evmReadClient) {
-    this.canisterContext = canisterContext;
-    this.apiClient = apiClient;
-    this.evmReadClient = evmReadClient;
+  async getEvmSupplyContext(request) {
+    const selectedPool = await this.params.getPoolById(request.poolId);
+    return await this.getEvmSupplyContextForPool({
+      request,
+      asset: selectedPool.asset,
+      chain: selectedPool.chain
+    });
   }
-  canisterContext;
-  apiClient;
-  evmReadClient;
-  /**
-   * Prepares a withdraw action that can be signed and submitted later.
-   *
-   * Use this when you need explicit control over signing and submission.
-   *
-   * @param request - Profile, pool, amount (pool asset base units), outflow address, and signer wallet.
-   * @returns A signable {@link WithdrawAction} with `submit` wired to the canister.
-   */
-  async prepareWithdraw(request) {
-    const destinationAccount = request.receiverAddress.trim();
-    const signerAccount = normalizeEvmAddress(
-      request.signerWalletAddress.trim()
+  async getEvmSupplyContextForPool(params) {
+    const { request, asset, chain } = params;
+    const evmReadClient = this.requireEvmReadClient(
+      "EVM supply context requires an EVM RPC URL or public client"
     );
-    if (!destinationAccount) {
+    const walletAddress = normalizeAndValidateEvmAddress(
+      request.walletAddress,
+      "Invalid EVM wallet address"
+    );
+    if (request.amount <= 0n) {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
-        "Withdraw requires a custom outflow account"
+        "EVM supply context requires a positive amount"
       );
     }
-    if (!signerAccount) {
+    if (!isEthStablecoin(asset, chain)) {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
-        "Withdraw requires a signer account"
+        `EVM supply context only supports ETH stablecoin pools, received ${asset} on ${chain}`
       );
     }
-    const receiverAddress = await this.normalizeOutflowReceiverAddress({
-      poolId: request.poolId,
-      receiverAddress: destinationAccount
+    const tokenAddress = getEthStablecoinContractAddress(asset);
+    const spenderAddress = CK_ETH_DEPOSIT_CONTRACT_ADDRESS;
+    const [allowance, balance] = await Promise.all([
+      readErc20Allowance({
+        evmReadClient,
+        tokenAddress,
+        ownerAddress: walletAddress,
+        spenderAddress
+      }),
+      readErc20Balance({
+        evmReadClient,
+        tokenAddress,
+        ownerAddress: walletAddress
+      })
+    ]);
+    const approvalStrategy = getApprovalStrategy({
+      allowance,
+      amount: request.amount
     });
-    const lendingActor = createLendingActor(this.canisterContext);
-    try {
-      const expiryTimestamp = computeExpiryTimestampFromNow();
-      const nonce = await lendingActor.get_nonce(signerAccount);
-      const withdrawRequestData = {
-        profileId: request.profileId,
-        poolId: request.poolId,
-        amount: request.amount,
-        receiverAddress,
-        signerWalletAddress: signerAccount,
-        expiryTimestamp
-      };
-      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 },
-            expiry_timestamp: expiryTimestamp
-          },
-          nonce
-        ),
-        data: withdrawRequestData,
-        submit: async (signatureInfo) => {
-          return await this.submitWithdraw(withdrawRequestData, signatureInfo);
-        }
-      };
-    } catch (error) {
-      if (error instanceof LiquidiumError) {
-        throw error;
-      }
-      throw mapCanisterCallErrorToLiquidiumError("get_nonce", error);
-    }
-  }
-  async submitWithdraw(request, signatureInfo) {
-    try {
-      const result = await createLendingActor(this.canisterContext).withdraw(
-        principal.Principal.fromText(request.profileId),
-        {
-          data: {
-            expiry_timestamp: request.expiryTimestamp,
-            account: { External: request.receiverAddress },
-            pool_id: principal.Principal.fromText(request.poolId),
-            amount: request.amount
-          },
-          signature_info: {
-            Wallet: {
-              signature: normalizeWalletSignature(
-                signatureInfo.signature,
-                signatureInfo.chain
-              ),
-              chain: mapWalletChainToLendingChain(signatureInfo.chain),
-              account: request.signerWalletAddress
-            }
-          }
-        }
-      );
-      if ("Err" in result) {
-        throw mapLendingProtocolErrorToLiquidiumError(result.Err);
-      }
-      return mapExpectedOutflowDetails(
-        mapCanisterOutflowDetails(result.Ok),
-        OutflowType.withdraw,
-        "withdraw"
-      );
-    } catch (error) {
-      if (error instanceof LiquidiumError) {
-        throw error;
-      }
-      throw mapCanisterCallErrorToLiquidiumError("withdraw", error);
-    }
-  }
-  /**
-   * Creates a withdraw outflow using the provided wallet adapter.
-   *
-   * This is the convenience form of `prepareWithdraw(...)` plus execution.
-   *
-   * @param params - Withdraw request fields plus `signerChain` and `signerWalletAdapter`.
-   * @returns The canister {@link OutflowDetails} for the completed withdraw.
-   */
-  async withdraw(params) {
-    const action = await this.prepareWithdraw(params);
-    return await executeWith({
-      walletAdapter: params.signerWalletAdapter,
-      chain: params.signerChain,
-      account: action.account
-    })(action);
+    return {
+      profileId: request.profileId,
+      poolId: request.poolId,
+      walletAddress,
+      action: request.action,
+      asset,
+      chain: Chain.ETH,
+      amount: request.amount.toString(),
+      tokenAddress,
+      spenderAddress,
+      depositContractAddress: CK_ETH_DEPOSIT_CONTRACT_ADDRESS,
+      balance: balance.toString(),
+      allowance: allowance.toString(),
+      requiresApproval: approvalStrategy !== EvmSupplyApprovalStrategy.none,
+      approvalStrategy
+    };
   }
-  /**
-   * Prepares a borrow action that can be signed and submitted later.
-   *
-   * Use this when you need explicit control over signing and submission.
-   *
-   * @param request - Profile, pool, amount (borrow asset base units), outflow address, and signer wallet.
-   * @returns A signable {@link BorrowAction} with `submit` wired to the canister.
-   */
-  async prepareBorrow(request) {
-    const destinationAccount = request.receiverAddress.trim();
-    const signerAccount = normalizeEvmAddress(
-      request.signerWalletAddress.trim()
-    );
-    if (!destinationAccount) {
+  async sendAndSubmitNativeSupplyInflow(params) {
+    const { request, instruction, defaultSubmitInflowRequest } = params;
+    if (instruction.target.type !== "nativeAddress") {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
-        "Borrow requires a custom outflow account"
+        "Wallet-executed supply requires a native-address target"
       );
     }
-    if (!signerAccount) {
+    if (!request.walletAdapter) {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
-        "Borrow requires a signer account"
+        "Wallet-executed supply requires a wallet adapter"
       );
     }
-    if (request.amount <= 0n) {
+    const account = request.account?.trim();
+    if (!account) {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
-        "Borrow amount must be greater than 0"
+        "Wallet-executed transfer supply requires an account"
       );
     }
-    const selectedPool = await this.getPoolById(request.poolId);
-    const selectedAsset = selectedPool.asset;
-    const minimumBorrowAmountError = getBorrowAmountMinimumValidationError({
-      amount: request.amount,
-      asset: selectedAsset
-    });
-    if (minimumBorrowAmountError) {
+    if (!request.amount || request.amount <= 0n) {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
-        minimumBorrowAmountError.message
+        "Wallet-executed supply requires a positive amount"
       );
     }
-    const receiverAddress = normalizeExternalAddress({
-      address: destinationAccount,
-      asset: selectedAsset,
-      chain: selectedPool.chain
+    const txid = await this.sendNativeSupplyTransaction({
+      walletAdapter: request.walletAdapter,
+      chain: instruction.chain,
+      toAddress: instruction.target.address,
+      amount: request.amount,
+      senderAccount: account,
+      asset: instruction.asset,
+      action: request.action
     });
-    const lendingActor = createLendingActor(this.canisterContext);
-    try {
-      const expiryTimestamp = computeExpiryTimestampFromNow();
-      const nonce = await lendingActor.get_nonce(signerAccount);
-      const borrowRequestData = {
-        profileId: request.profileId,
-        poolId: request.poolId,
-        amount: request.amount,
-        receiverAddress,
-        signerWalletAddress: signerAccount,
-        expiryTimestamp
-      };
+    if (shouldSubmitInflow({ instruction, mechanism: SupplyPlanType.transfer })) {
+      try {
+        await this.submitInflowWithRetry(txid, defaultSubmitInflowRequest);
+      } catch {
+      }
+    }
+    return txid;
+  }
+  async submitSupplyFlowInflow(params) {
+    if (!shouldSubmitInflow(params)) {
       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 },
-            expiry_timestamp: expiryTimestamp
-          },
-          nonce
-        ),
-        data: borrowRequestData,
-        submit: async (signatureInfo) => {
-          return await this.submitBorrow(borrowRequestData, signatureInfo);
-        }
+        txid: params.submitRequest.txid
       };
-    } catch (error) {
-      if (error instanceof LiquidiumError) {
-        throw error;
-      }
-      throw mapCanisterCallErrorToLiquidiumError("get_nonce", error);
     }
+    const defaultSubmitInflowRequest = params.defaultSubmitInflowRequest;
+    if (!defaultSubmitInflowRequest) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        "Supply flow submit requires an inflow operation"
+      );
+    }
+    return await this.params.submitInflow({
+      ...defaultSubmitInflowRequest,
+      ...params.submitRequest
+    });
   }
-  async submitBorrow(request, signatureInfo) {
+  async executeContractSupply(params) {
+    const { request, instruction, defaultSubmitInflowRequest } = params;
+    if (instruction.target.type !== "icrcAccount" || instruction.chain !== Chain.ETH) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        "Contract-interaction supply is only supported for ETH ICRC-account targets"
+      );
+    }
+    const walletAddressInput = request.account?.trim();
+    if (!walletAddressInput) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        "Contract-interaction supply requires an account"
+      );
+    }
+    const walletAddress = normalizeAndValidateEvmAddress(
+      walletAddressInput,
+      "Invalid EVM wallet address"
+    );
+    if (!request.amount || request.amount <= 0n) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        "Contract-interaction supply requires a positive amount"
+      );
+    }
+    const walletAdapter = request.walletAdapter;
+    if (!walletAdapter?.sendEthTransaction) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        "Contract-interaction supply requires an ETH wallet adapter"
+      );
+    }
+    this.params.requireApi();
+    this.requireEvmReadClient(
+      "Contract-interaction supply requires an EVM RPC URL or public client"
+    );
+    const evmSupplyContext = await this.getEvmSupplyContextForPool({
+      request: {
+        profileId: request.profileId,
+        poolId: request.poolId,
+        walletAddress,
+        amount: request.amount,
+        action: request.action
+      },
+      asset: instruction.asset,
+      chain: instruction.chain
+    });
+    const supplyAmount = BigInt(evmSupplyContext.amount);
+    if (BigInt(evmSupplyContext.balance) < supplyAmount) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.INSUFFICIENT_FUNDS,
+        `Insufficient ${evmSupplyContext.asset} balance for ${request.action}`
+      );
+    }
+    if (evmSupplyContext.approvalStrategy === EvmSupplyApprovalStrategy.resetThenApproveMax) {
+      await this.sendEthContractTransaction(
+        walletAdapter,
+        walletAddress,
+        createApproveTransaction({
+          tokenAddress: evmSupplyContext.tokenAddress,
+          spenderAddress: evmSupplyContext.spenderAddress,
+          amount: 0n
+        }),
+        `supply-${request.action}-approve-reset`
+      );
+      await this.waitForExpectedAllowance({
+        walletAddress,
+        tokenAddress: evmSupplyContext.tokenAddress,
+        spenderAddress: evmSupplyContext.spenderAddress,
+        amount: supplyAmount,
+        expectation: "zero"
+      });
+    }
+    if (evmSupplyContext.approvalStrategy !== EvmSupplyApprovalStrategy.none) {
+      await this.sendEthContractTransaction(
+        walletAdapter,
+        walletAddress,
+        createApproveTransaction({
+          tokenAddress: evmSupplyContext.tokenAddress,
+          spenderAddress: evmSupplyContext.spenderAddress,
+          amount: MAX_UINT256
+        }),
+        `supply-${request.action}-approve-max`
+      );
+      await this.waitForExpectedAllowance({
+        walletAddress,
+        tokenAddress: evmSupplyContext.tokenAddress,
+        spenderAddress: evmSupplyContext.spenderAddress,
+        amount: supplyAmount,
+        expectation: "sufficient"
+      });
+    }
+    const depositTxid = await this.sendEthContractTransaction(
+      walletAdapter,
+      walletAddress,
+      createDepositErc20Transaction({
+        depositContractAddress: evmSupplyContext.depositContractAddress,
+        tokenAddress: evmSupplyContext.tokenAddress,
+        amount: supplyAmount,
+        poolId: request.poolId,
+        profileId: request.profileId,
+        destinationAccount: instruction.target.account,
+        action: request.action
+      }),
+      `supply-${request.action}-deposit-erc20`
+    );
     try {
-      const result = await createLendingActor(
-        this.canisterContext
-      ).borrow_assets(principal.Principal.fromText(request.profileId), {
-        data: {
-          expiry_timestamp: request.expiryTimestamp,
-          account: { External: request.receiverAddress },
-          pool_id: principal.Principal.fromText(request.poolId),
-          amount: request.amount
-        },
-        signature_info: {
-          Wallet: {
-            signature: normalizeWalletSignature(
-              signatureInfo.signature,
-              signatureInfo.chain
-            ),
-            chain: mapWalletChainToLendingChain(signatureInfo.chain),
-            account: request.signerWalletAddress
-          }
+      await this.submitInflowWithRetry(depositTxid, defaultSubmitInflowRequest);
+    } catch {
+    }
+    return depositTxid;
+  }
+  async sendNativeSupplyTransaction(params) {
+    switch (params.chain) {
+      case Chain.BTC: {
+        if (!params.walletAdapter.sendBtcTransaction) {
+          throw new LiquidiumError(
+            LiquidiumErrorCode.VALIDATION_ERROR,
+            "BTC wallet adapter does not support transaction sending"
+          );
         }
-      });
-      if ("Err" in result) {
-        throw mapLendingProtocolErrorToLiquidiumError(result.Err);
+        return await params.walletAdapter.sendBtcTransaction({
+          chain: Chain.BTC,
+          toAddress: params.toAddress,
+          amountSats: params.amount,
+          account: params.senderAccount,
+          actionType: `supply-${params.action}`,
+          transferMode: TransferMode.native
+        });
       }
-      return mapExpectedOutflowDetails(
-        mapCanisterOutflowDetails(result.Ok),
-        OutflowType.borrow,
-        "borrow_assets"
-      );
-    } catch (error) {
-      if (error instanceof LiquidiumError) {
-        throw error;
+      case Chain.ETH: {
+        if (!params.walletAdapter.sendEthTransaction) {
+          throw new LiquidiumError(
+            LiquidiumErrorCode.VALIDATION_ERROR,
+            "ETH wallet adapter does not support transaction sending"
+          );
+        }
+        if (isEthStablecoin(params.asset, params.chain)) {
+          return await params.walletAdapter.sendEthTransaction({
+            chain: Chain.ETH,
+            account: params.senderAccount,
+            actionType: `supply-${params.action}`,
+            transferMode: TransferMode.native,
+            transaction: createTransferErc20Transaction({
+              tokenAddress: getEthStablecoinContractAddress(params.asset),
+              recipientAddress: params.toAddress,
+              amount: params.amount
+            })
+          });
+        }
+        return await params.walletAdapter.sendEthTransaction({
+          chain: Chain.ETH,
+          account: params.senderAccount,
+          actionType: `supply-${params.action}`,
+          transferMode: TransferMode.native,
+          transaction: {
+            to: params.toAddress,
+            value: params.amount.toString()
+          }
+        });
       }
-      throw mapCanisterCallErrorToLiquidiumError("borrow_assets", error);
+      default:
+        throw new LiquidiumError(
+          LiquidiumErrorCode.VALIDATION_ERROR,
+          `Native-address wallet execution is not supported for ${params.chain}`
+        );
     }
   }
-  /**
-   * Creates a borrow outflow using the provided wallet adapter.
-   *
-   * This is the convenience form of `prepareBorrow(...)` plus execution.
-   *
-   * @param params - Borrow request fields plus `signerChain` and `signerWalletAdapter`.
-   * @returns The lending canister receipt as {@link OutflowDetails}.
-   *
-   * @remarks
-   * `id` is always present. `txid` may be missing on the first response; the SDK does not
-   * poll for it. Use history or app-level polling if you need the chain transaction id.
-   */
-  async borrow(params) {
-    const action = await this.prepareBorrow(params);
-    return await executeWith({
-      walletAdapter: params.signerWalletAdapter,
-      chain: params.signerChain,
-      account: action.account
-    })(action);
-  }
-  /**
-   * Resolves a supply target for a deposit or repayment and optionally broadcasts it.
-   *
-   * Transfer mode can return manual broadcast instructions when wallet fields are
-   * omitted. Contract-interaction mode always requires `walletAdapter`, `account`,
-   * and `amount` because it must prepare and submit approval/deposit calls.
-   *
-   * The SDK does not poll for inflow status. When a `txid` is returned, it is the
-   * caller's responsibility to track confirmation state using their own polling.
-   *
-   * @returns A {@link SupplyFlow} receipt with `type`, `target`, `submit`, and
-   *   an optional `txid` present when the SDK broadcast for you.
-   */
-  async supply(request) {
-    const target = await resolveSupplyTarget(this.canisterContext, request);
-    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
+  async submitInflowWithRetry(txid, extraRequest) {
+    if (!extraRequest) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        "Inflow submission requires an operation"
+      );
+    }
+    await retryWithBackoff({
+      execute: async () => {
+        await this.params.submitInflow({ txid, ...extraRequest });
+      },
+      maxAttempts: SUBMIT_INFLOW_MAX_ATTEMPTS,
+      initialRetryDelayMs: SUBMIT_INFLOW_INITIAL_RETRY_DELAY_MS,
+      backoffMultiplier: SUBMIT_INFLOW_RETRY_BACKOFF_MULTIPLIER,
+      shouldRetryError: isRetriableInflowSubmitError
     });
-    const defaultSubmitInflowRequest = getDefaultSubmitInflowRequest({
-      action: request.action,
-      chain: mechanism === SupplyPlanType.contractInteraction ? Chain.ETH : instruction.chain
+  }
+  async sendEthContractTransaction(walletAdapter, walletAddress, request, actionType) {
+    if (!walletAdapter.sendEthTransaction) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        "ETH wallet adapter does not support transaction sending"
+      );
+    }
+    return await walletAdapter.sendEthTransaction({
+      chain: Chain.ETH,
+      account: walletAddress,
+      actionType,
+      transferMode: TransferMode.native,
+      transaction: request
     });
-    let txid;
-    switch (mechanism) {
-      case SupplyPlanType.transfer:
-        if (request.walletAdapter) {
-          txid = await this.sendAndSubmitNativeSupplyInflow({
-            request,
-            instruction,
-            defaultSubmitInflowRequest
-          });
-        }
-        break;
-      case SupplyPlanType.contractInteraction:
-        txid = await this.executeContractSupply({
-          request,
-          instruction,
-          defaultSubmitInflowRequest
+  }
+  async waitForExpectedAllowance(params) {
+    const evmReadClient = this.requireEvmReadClient(
+      "Contract-interaction supply requires an EVM RPC URL or public client"
+    );
+    let lastPollingError;
+    for (let pollIndex = 0; pollIndex < ETH_APPROVAL_MAX_POLLS; pollIndex += 1) {
+      try {
+        const allowance = await readErc20Allowance({
+          evmReadClient,
+          tokenAddress: params.tokenAddress,
+          ownerAddress: params.walletAddress,
+          spenderAddress: params.spenderAddress
         });
-        break;
+        const matchesExpectation = params.expectation === "zero" ? allowance === 0n : allowance >= params.amount;
+        if (matchesExpectation) {
+          return;
+        }
+      } catch (error) {
+        lastPollingError = error;
+      }
+      await delay(ETH_APPROVAL_POLL_INTERVAL_MS);
     }
+    const lastPollingErrorMessage = getUnknownErrorMessage(lastPollingError);
+    throw new LiquidiumError(
+      LiquidiumErrorCode.SERVICE_UNAVAILABLE,
+      lastPollingErrorMessage ? `Timed out waiting for ${params.expectation} ETH allowance update. Last polling error: ${lastPollingErrorMessage}` : `Timed out waiting for ${params.expectation} ETH allowance update`
+    );
+  }
+  requireEvmReadClient(message) {
+    if (!this.params.evmReadClient) {
+      throw new LiquidiumError(LiquidiumErrorCode.VALIDATION_ERROR, message);
+    }
+    return this.params.evmReadClient;
+  }
+};
+async function readErc20Allowance(params) {
+  const allowance = await params.evmReadClient.readContract({
+    address: params.tokenAddress,
+    abi: ERC20_ABI,
+    functionName: "allowance",
+    args: [
+      params.ownerAddress,
+      params.spenderAddress
+    ]
+  });
+  return BigInt(allowance);
+}
+async function readErc20Balance(params) {
+  const balance = await params.evmReadClient.readContract({
+    address: params.tokenAddress,
+    abi: ERC20_ABI,
+    functionName: "balanceOf",
+    args: [params.ownerAddress]
+  });
+  return BigInt(balance);
+}
+function getApprovalStrategy(params) {
+  if (params.allowance >= params.amount) {
+    return EvmSupplyApprovalStrategy.none;
+  }
+  if (params.allowance === 0n) {
+    return EvmSupplyApprovalStrategy.approveMax;
+  }
+  return EvmSupplyApprovalStrategy.resetThenApproveMax;
+}
+async function delay(timeoutMs) {
+  await new Promise((resolve) => setTimeout(resolve, timeoutMs));
+}
+function isRetriableInflowSubmitError(error) {
+  if (!(error instanceof LiquidiumError)) {
+    return false;
+  }
+  return error.code === LiquidiumErrorCode.SERVICE_UNAVAILABLE;
+}
+function getUnknownErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return null;
+}
+function getDefaultSubmitInflowRequest(params) {
+  if (params.chain !== Chain.BTC && params.chain !== Chain.ETH) {
+    return void 0;
+  }
+  return {
+    chain: params.chain,
+    operation: mapSupplyActionToStatusOperation(params.action)
+  };
+}
+function mapSupplyActionToStatusOperation(action) {
+  return action === SupplyAction.repayment ? "repayment" : "deposit";
+}
+function shouldSubmitInflow(params) {
+  if (params.mechanism !== SupplyPlanType.transfer) {
+    return true;
+  }
+  return !isEthStablecoin(params.instruction.asset, params.instruction.chain);
+}
+function mapCanisterOutflowDetails(outflow) {
+  const rawOutflowType = getVariantKey(outflow.outflow_type);
+  return {
+    id: outflow.id,
+    outflowType: normalizeOutflowType(rawOutflowType),
+    outflowRef: outflow.outflow_ref[0],
+    txid: outflow.txid[0],
+    amount: outflow.amount,
+    receiver: mapCanisterAccountType(outflow.receiver)
+  };
+}
+function mapCanisterAccountType(receiver) {
+  if ("Native" in receiver) {
     return {
-      type: mechanism,
-      target: instruction.target,
-      txid,
-      submit: async (submitRequest) => {
-        return await this.submitSupplyFlowInflow({
-          instruction,
-          mechanism,
-          defaultSubmitInflowRequest,
-          submitRequest
-        });
-      }
+      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 {
+    type: "External",
+    account: receiver.External
+  };
+}
+function normalizeOptionalSubaccount2(subaccount) {
+  if (!subaccount) {
+    return void 0;
+  }
+  return subaccount instanceof Uint8Array ? subaccount : Uint8Array.from(subaccount);
+}
+function normalizeOutflowType(rawOutflowType) {
+  switch (rawOutflowType) {
+    case "Withdraw":
+      return OutflowType.withdrawal;
+    case "Borrow":
+      return OutflowType.borrow;
+    case "FeeClaim":
+      return OutflowType.feeClaim;
+    default:
+      throw new LiquidiumError(
+        LiquidiumErrorCode.INTERNAL,
+        `Unsupported outflow type: ${rawOutflowType}`
+      );
+  }
+}
+function mapWalletChainToLendingChain(chain) {
+  switch (chain) {
+    case Chain.BTC:
+      return { BTC: null };
+    case Chain.ETH:
+      return { ETH: null };
+  }
+}
+
+// src/modules/lending/lending.ts
+var LendingModule = class {
+  constructor(canisterContext, apiClient, evmReadClient) {
+    this.canisterContext = canisterContext;
+    this.apiClient = apiClient;
+    this.evmReadClient = evmReadClient;
+  }
+  canisterContext;
+  apiClient;
+  evmReadClient;
   /**
-   * Fetches ERC-20 supply planning data with the configured EVM read client.
+   * Prepares a withdraw action that can be signed and submitted later.
    *
-   * Requires `evmRpcUrl` or `evmPublicClient` on the client. Used internally by
-   * contract-interaction `supply`.
+   * Use this when you need explicit control over signing and submission.
    *
-   * @param request - Profile, pool, wallet, amount (token base units), and action.
-   * @returns Locally computed {@link EvmSupplyContext} for approvals and deposit.
+   * @param request - Profile, pool, amount (pool asset base units), outflow address, and signer wallet.
+   * @returns A signable {@link WithdrawAction} with `submit` wired to the canister.
    */
-  async getEvmSupplyContext(request) {
-    const selectedPool = await this.getPoolById(request.poolId);
-    return await this.getEvmSupplyContextForPool({
-      request,
-      asset: selectedPool.asset,
-      chain: selectedPool.chain
-    });
-  }
-  async getEvmSupplyContextForPool(params) {
-    const { request, asset, chain } = params;
-    const evmReadClient = this.requireEvmReadClient(
-      "EVM supply context requires an EVM RPC URL or public client"
-    );
-    const walletAddress = normalizeAndValidateEvmAddress(
-      request.walletAddress,
-      "Invalid EVM wallet address"
+  async prepareWithdraw(request) {
+    const destinationAccount = request.receiverAddress.trim();
+    const signerAccount = normalizeEvmAddress(
+      request.signerWalletAddress.trim()
     );
-    if (request.amount <= 0n) {
+    if (!destinationAccount) {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
-        "EVM supply context requires a positive amount"
+        "Withdraw requires a custom outflow account"
       );
     }
-    if (!isEthStablecoin(asset, chain)) {
+    if (!signerAccount) {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
-        `EVM supply context only supports ETH stablecoin pools, received ${asset} on ${chain}`
+        "Withdraw requires a signer account"
       );
     }
-    const tokenAddress = getEthStablecoinContractAddress(asset);
-    const spenderAddress = CK_ETH_DEPOSIT_CONTRACT_ADDRESS;
-    const [allowance, balance] = await Promise.all([
-      readErc20Allowance({
-        evmReadClient,
-        tokenAddress,
-        ownerAddress: walletAddress,
-        spenderAddress
-      }),
-      readErc20Balance({
-        evmReadClient,
-        tokenAddress,
-        ownerAddress: walletAddress
-      })
-    ]);
-    const approvalStrategy = getApprovalStrategy({
-      allowance,
-      amount: request.amount
-    });
-    return {
-      success: true,
-      profileId: request.profileId,
+    const receiverAddress = await this.normalizeOutflowReceiverAddress({
       poolId: request.poolId,
-      walletAddress,
-      action: request.action,
-      asset,
-      chain: Chain.ETH,
-      amount: request.amount.toString(),
-      tokenAddress,
-      spenderAddress,
-      depositContractAddress: CK_ETH_DEPOSIT_CONTRACT_ADDRESS,
-      balance: balance.toString(),
-      allowance: allowance.toString(),
-      requiresApproval: approvalStrategy !== EvmSupplyApprovalStrategy.none,
-      approvalStrategy
-    };
-  }
-  /**
-   * Returns the read-only deposit address for an ETH stablecoin 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.
-   *
-   * @param request - Profile, pool, asset, and supply action.
-   * @returns The EVM deposit address for the derived account.
-   */
-  async getDepositAddress(request) {
-    if (!isEthStablecoin(request.asset, Chain.ETH)) {
-      throw new LiquidiumError(
-        LiquidiumErrorCode.VALIDATION_ERROR,
-        "getDepositAddress is only supported for ETH stablecoins"
-      );
-    }
-    const tokenAddress = getEthStablecoinContractAddress(request.asset);
-    const subaccount = encodeInflowSubaccount({
-      action: request.action,
-      principal: principal.Principal.fromText(request.profileId)
+      receiverAddress: destinationAccount
     });
-    const result = await createDepositAccountsActor(
-      this.canisterContext
-    ).get_deposit_address(
-      {
-        owner: principal.Principal.fromText(request.poolId),
-        subaccount: [subaccount]
-      },
-      [tokenAddress]
-    );
-    if ("Err" in result) {
-      throw mapDepositAccountErrorToLiquidiumError(result.Err);
-    }
-    return result.Ok;
-  }
-  /**
-   * Estimates the network/deposit fee for an inflow target.
-   *
-   * ETH stablecoin deposit-address estimates are served by the deposit-address
-   * canister. BTC estimates include the ckBTC minter deposit fee and 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 (isEthStablecoin(request.asset, request.chain)) {
-      const result = await createDepositAccountsActor(
-        this.canisterContext
-      ).estimate_deposit_fee([getEthStablecoinContractAddress(request.asset)]);
-      if ("Err" in result) {
-        throw mapDepositAccountErrorToLiquidiumError(result.Err);
-      }
-      return {
-        totalFee: roundInflowFeeEstimate(request, result.Ok)
+    const lendingActor = createLendingActor(this.canisterContext);
+    try {
+      const expiryTimestamp = computeExpiryTimestampFromNow();
+      const nonce = await lendingActor.get_nonce(signerAccount);
+      const withdrawRequestData = {
+        profileId: request.profileId,
+        poolId: request.poolId,
+        amount: request.amount,
+        receiverAddress,
+        signerWalletAddress: signerAccount,
+        expiryTimestamp
       };
-    }
-    if (request.asset === Asset.BTC && request.chain === Chain.BTC) {
-      const estimate = await this.estimateBtcInflowFee();
       return {
-        totalFee: roundInflowFeeEstimate(request, estimate.totalFee)
+        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 },
+            expiry_timestamp: expiryTimestamp
+          },
+          nonce
+        ),
+        data: withdrawRequestData,
+        submit: async (signatureInfo) => {
+          return await this.submitWithdraw(withdrawRequestData, signatureInfo);
+        }
       };
+    } catch (error) {
+      if (error instanceof LiquidiumError) {
+        throw error;
+      }
+      throw mapCanisterCallErrorToLiquidiumError("get_nonce", error);
     }
-    throw new LiquidiumError(
-      LiquidiumErrorCode.VALIDATION_ERROR,
-      `Inflow fee estimates are not supported for ${request.asset} on ${request.chain}`
-    );
-  }
-  async estimateBtcInflowFee() {
-    const [minterFee, ledgerFee] = await Promise.all([
-      createCkBtcMinterActor(this.canisterContext).get_deposit_fee(),
-      createCkBtcLedgerActor(this.canisterContext).icrc1_fee()
-    ]);
-    return { totalFee: minterFee + ledgerFee };
   }
-  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"
-      );
-    }
-    if (!request.walletAdapter) {
-      throw new LiquidiumError(
-        LiquidiumErrorCode.VALIDATION_ERROR,
-        "Wallet-executed supply requires a wallet adapter"
-      );
-    }
-    const account = request.account?.trim();
-    if (!account) {
-      throw new LiquidiumError(
-        LiquidiumErrorCode.VALIDATION_ERROR,
-        "Wallet-executed transfer supply requires an account"
-      );
-    }
-    if (!request.amount || request.amount <= 0n) {
-      throw new LiquidiumError(
-        LiquidiumErrorCode.VALIDATION_ERROR,
-        "Wallet-executed supply requires a positive amount"
+  async submitWithdraw(request, signatureInfo) {
+    try {
+      const result = await createLendingActor(this.canisterContext).withdraw(
+        principal.Principal.fromText(request.profileId),
+        {
+          data: {
+            expiry_timestamp: request.expiryTimestamp,
+            account: { External: request.receiverAddress },
+            pool_id: principal.Principal.fromText(request.poolId),
+            amount: request.amount
+          },
+          signature_info: {
+            Wallet: {
+              signature: normalizeWalletSignature(
+                signatureInfo.signature,
+                signatureInfo.chain
+              ),
+              chain: mapWalletChainToLendingChain(signatureInfo.chain),
+              account: request.signerWalletAddress
+            }
+          }
+        }
       );
+      if ("Err" in result) {
+        throw mapLendingProtocolErrorToLiquidiumError(result.Err);
+      }
+      return mapExpectedOutflowDetails(
+        mapCanisterOutflowDetails(result.Ok),
+        OutflowType.withdrawal,
+        "withdraw"
+      );
+    } catch (error) {
+      if (error instanceof LiquidiumError) {
+        throw error;
+      }
+      throw mapCanisterCallErrorToLiquidiumError("withdraw", error);
     }
-    const txid = await this.sendNativeSupplyTransaction({
-      walletAdapter: request.walletAdapter,
-      chain: instruction.chain,
-      toAddress: instruction.target.address,
-      amount: request.amount,
-      senderAccount: account,
-      asset: instruction.asset,
-      action: request.action
-    });
-    if (shouldSubmitInflow({ instruction, mechanism: SupplyPlanType.transfer })) {
-      await this.submitInflowWithRetry(txid, defaultSubmitInflowRequest);
-    }
-    return txid;
   }
-  async submitSupplyFlowInflow(params) {
-    if (!shouldSubmitInflow(params)) {
-      return { success: true, txid: params.submitRequest.txid };
-    }
-    return await this.submitInflow({
-      ...params.defaultSubmitInflowRequest,
-      ...params.submitRequest
-    });
+  /**
+   * Creates a withdraw outflow using the provided wallet adapter.
+   *
+   * This is the convenience form of `prepareWithdraw(...)` plus execution.
+   *
+   * @param params - Withdraw request fields plus `signerChain` and `signerWalletAdapter`.
+   * @returns The canister {@link OutflowDetails} for the completed withdraw.
+   */
+  async withdraw(params) {
+    const action = await this.prepareWithdraw(params);
+    return await executeWith({
+      walletAdapter: params.signerWalletAdapter,
+      chain: params.signerChain,
+      account: action.account
+    })(action);
   }
-  async executeContractSupply(params) {
-    const { request, instruction, defaultSubmitInflowRequest } = params;
-    if (instruction.target.type !== "icrcAccount" || instruction.chain !== Chain.ETH) {
+  /**
+   * Prepares a borrow action that can be signed and submitted later.
+   *
+   * Use this when you need explicit control over signing and submission.
+   *
+   * @param request - Profile, pool, amount (borrow asset base units), outflow address, and signer wallet.
+   * @returns A signable {@link BorrowAction} with `submit` wired to the canister.
+   */
+  async prepareBorrow(request) {
+    const destinationAccount = request.receiverAddress.trim();
+    const signerAccount = normalizeEvmAddress(
+      request.signerWalletAddress.trim()
+    );
+    if (!destinationAccount) {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
-        "Contract-interaction supply is only supported for ETH ICRC-account targets"
+        "Borrow requires a custom outflow account"
       );
     }
-    const walletAddressInput = request.account?.trim();
-    if (!walletAddressInput) {
+    if (!signerAccount) {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
-        "Contract-interaction supply requires an account"
+        "Borrow requires a signer account"
       );
     }
-    const walletAddress = normalizeAndValidateEvmAddress(
-      walletAddressInput,
-      "Invalid EVM wallet address"
-    );
-    if (!request.amount || request.amount <= 0n) {
+    if (request.amount <= 0n) {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
-        "Contract-interaction supply requires a positive amount"
+        "Borrow amount must be greater than 0"
       );
     }
-    const walletAdapter = request.walletAdapter;
-    if (!walletAdapter?.sendEthTransaction) {
+    const selectedPool = await this.getPoolById(request.poolId);
+    const selectedAsset = selectedPool.asset;
+    const minimumBorrowAmountError = getBorrowAmountMinimumValidationError({
+      amount: request.amount,
+      asset: selectedAsset
+    });
+    if (minimumBorrowAmountError) {
       throw new LiquidiumError(
         LiquidiumErrorCode.VALIDATION_ERROR,
-        "Contract-interaction supply requires an ETH wallet adapter"
+        minimumBorrowAmountError.message
       );
     }
-    this.requireApi();
-    this.requireEvmReadClient(
-      "Contract-interaction supply requires an EVM RPC URL or public client"
-    );
-    const evmSupplyContext = await this.getEvmSupplyContextForPool({
-      request: {
+    const receiverAddress = normalizeExternalAddress({
+      address: destinationAccount,
+      asset: selectedAsset,
+      chain: selectedPool.chain
+    });
+    const lendingActor = createLendingActor(this.canisterContext);
+    try {
+      const expiryTimestamp = computeExpiryTimestampFromNow();
+      const nonce = await lendingActor.get_nonce(signerAccount);
+      const borrowRequestData = {
         profileId: request.profileId,
         poolId: request.poolId,
-        walletAddress,
         amount: request.amount,
-        action: request.action
-      },
-      asset: instruction.asset,
-      chain: instruction.chain
-    });
-    const supplyAmount = BigInt(evmSupplyContext.amount);
-    if (BigInt(evmSupplyContext.balance) < supplyAmount) {
-      throw new LiquidiumError(
-        LiquidiumErrorCode.INSUFFICIENT_FUNDS,
-        `Insufficient ${evmSupplyContext.asset} balance for ${request.action}`
-      );
+        receiverAddress,
+        signerWalletAddress: signerAccount,
+        expiryTimestamp
+      };
+      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 },
+            expiry_timestamp: expiryTimestamp
+          },
+          nonce
+        ),
+        data: borrowRequestData,
+        submit: async (signatureInfo) => {
+          return await this.submitBorrow(borrowRequestData, signatureInfo);
+        }
+      };
+    } catch (error) {
+      if (error instanceof LiquidiumError) {
+        throw error;
+      }
+      throw mapCanisterCallErrorToLiquidiumError("get_nonce", error);
     }
-    if (evmSupplyContext.approvalStrategy === EvmSupplyApprovalStrategy.resetThenApproveMax) {
-      await this.sendEthContractTransaction(
-        walletAdapter,
-        walletAddress,
-        createApproveTransaction({
-          tokenAddress: evmSupplyContext.tokenAddress,
-          spenderAddress: evmSupplyContext.spenderAddress,
-          amount: 0n
-        }),
-        `supply-${request.action}-approve-reset`
-      );
-      await this.waitForExpectedAllowance({
-        walletAddress,
-        tokenAddress: evmSupplyContext.tokenAddress,
-        spenderAddress: evmSupplyContext.spenderAddress,
-        amount: supplyAmount,
-        expectation: "zero"
+  }
+  async submitBorrow(request, signatureInfo) {
+    try {
+      const result = await createLendingActor(
+        this.canisterContext
+      ).borrow_assets(principal.Principal.fromText(request.profileId), {
+        data: {
+          expiry_timestamp: request.expiryTimestamp,
+          account: { External: request.receiverAddress },
+          pool_id: principal.Principal.fromText(request.poolId),
+          amount: request.amount
+        },
+        signature_info: {
+          Wallet: {
+            signature: normalizeWalletSignature(
+              signatureInfo.signature,
+              signatureInfo.chain
+            ),
+            chain: mapWalletChainToLendingChain(signatureInfo.chain),
+            account: request.signerWalletAddress
+          }
+        }
       });
-    }
-    if (evmSupplyContext.approvalStrategy !== EvmSupplyApprovalStrategy.none) {
-      await this.sendEthContractTransaction(
-        walletAdapter,
-        walletAddress,
-        createApproveTransaction({
-          tokenAddress: evmSupplyContext.tokenAddress,
-          spenderAddress: evmSupplyContext.spenderAddress,
-          amount: MAX_UINT256
-        }),
-        `supply-${request.action}-approve-max`
+      if ("Err" in result) {
+        throw mapLendingProtocolErrorToLiquidiumError(result.Err);
+      }
+      return mapExpectedOutflowDetails(
+        mapCanisterOutflowDetails(result.Ok),
+        OutflowType.borrow,
+        "borrow_assets"
+      );
+    } catch (error) {
+      if (error instanceof LiquidiumError) {
+        throw error;
+      }
+      throw mapCanisterCallErrorToLiquidiumError("borrow_assets", error);
+    }
+  }
+  /**
+   * Creates a borrow outflow using the provided wallet adapter.
+   *
+   * This is the convenience form of `prepareBorrow(...)` plus execution.
+   *
+   * @param params - Borrow request fields plus `signerChain` and `signerWalletAdapter`.
+   * @returns The lending canister receipt as {@link OutflowDetails}.
+   *
+   * @remarks
+   * `id` is always present. `txid` may be missing on the first response; the SDK does not
+   * poll for it. Use history or app-level polling if you need the chain transaction id.
+   */
+  async borrow(params) {
+    const action = await this.prepareBorrow(params);
+    return await executeWith({
+      walletAdapter: params.signerWalletAdapter,
+      chain: params.signerChain,
+      account: action.account
+    })(action);
+  }
+  /**
+   * Resolves a supply target for a deposit or repayment and optionally broadcasts it.
+   *
+   * Transfer mode can return manual broadcast instructions when wallet fields are
+   * omitted. Contract-interaction mode always requires `walletAdapter`, `account`,
+   * and `amount` because it must prepare and submit approval/deposit calls.
+   *
+   * The SDK does not poll for inflow status. When a `txid` is returned, it is the
+   * caller's responsibility to track confirmation state using their own polling.
+   *
+   * @returns A {@link SupplyFlow} receipt with `type`, `target`, `submit`, and
+   *   an optional `txid` present when the SDK broadcast for you.
+   */
+  async supply(request) {
+    return await this.createSupplyFlowExecutor().create(request);
+  }
+  /**
+   * Fetches ERC-20 supply planning data with the configured EVM read client.
+   *
+   * Requires `evmRpcUrl` or `evmPublicClient` on the client. Used internally by
+   * contract-interaction `supply`.
+   *
+   * @param request - Profile, pool, wallet, amount (token base units), and action.
+   * @returns Locally computed {@link EvmSupplyContext} for approvals and deposit.
+   */
+  async getEvmSupplyContext(request) {
+    return await this.createSupplyFlowExecutor().getEvmSupplyContext(request);
+  }
+  /**
+   * Returns the read-only deposit address for an ETH stablecoin 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.
+   *
+   * @param request - Profile, pool, asset, and supply action.
+   * @returns The EVM deposit address for the derived account.
+   */
+  async getDepositAddress(request) {
+    if (!isEthStablecoin(request.asset, Chain.ETH)) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        "getDepositAddress is only supported for ETH stablecoins"
       );
-      await this.waitForExpectedAllowance({
-        walletAddress,
-        tokenAddress: evmSupplyContext.tokenAddress,
-        spenderAddress: evmSupplyContext.spenderAddress,
-        amount: supplyAmount,
-        expectation: "sufficient"
-      });
     }
-    const depositTxid = await this.sendEthContractTransaction(
-      walletAdapter,
-      walletAddress,
-      createDepositErc20Transaction({
-        depositContractAddress: evmSupplyContext.depositContractAddress,
-        tokenAddress: evmSupplyContext.tokenAddress,
-        amount: supplyAmount,
-        poolId: request.poolId,
-        profileId: request.profileId,
-        destinationAccount: instruction.target.account,
-        action: request.action
-      }),
-      `supply-${request.action}-deposit-erc20`
+    const tokenAddress = getEthStablecoinContractAddress(request.asset);
+    const subaccount = encodeInflowSubaccount({
+      action: request.action,
+      principal: principal.Principal.fromText(request.profileId)
+    });
+    const result = await createDepositAccountsActor(
+      this.canisterContext
+    ).get_deposit_address(
+      {
+        owner: principal.Principal.fromText(request.poolId),
+        subaccount: [subaccount]
+      },
+      [tokenAddress]
     );
-    try {
-      await this.submitInflowWithRetry(depositTxid, defaultSubmitInflowRequest);
-    } catch {
+    if ("Err" in result) {
+      throw mapDepositAccountErrorToLiquidiumError(result.Err);
     }
-    return depositTxid;
+    return result.Ok;
   }
-  async sendNativeSupplyTransaction(params) {
-    switch (params.chain) {
-      case Chain.BTC: {
-        if (!params.walletAdapter.sendBtcTransaction) {
-          throw new LiquidiumError(
-            LiquidiumErrorCode.VALIDATION_ERROR,
-            "BTC wallet adapter does not support transaction sending"
-          );
-        }
-        return await params.walletAdapter.sendBtcTransaction({
-          chain: Chain.BTC,
-          toAddress: params.toAddress,
-          amountSats: params.amount,
-          account: params.senderAccount,
-          actionType: `supply-${params.action}`,
-          transferMode: TransferMode.native
-        });
-      }
-      case Chain.ETH: {
-        if (!params.walletAdapter.sendEthTransaction) {
-          throw new LiquidiumError(
-            LiquidiumErrorCode.VALIDATION_ERROR,
-            "ETH wallet adapter does not support transaction sending"
-          );
-        }
-        if (isEthStablecoin(params.asset, params.chain)) {
-          return await params.walletAdapter.sendEthTransaction({
-            chain: Chain.ETH,
-            account: params.senderAccount,
-            actionType: `supply-${params.action}`,
-            transferMode: TransferMode.native,
-            transaction: createTransferErc20Transaction({
-              tokenAddress: getEthStablecoinContractAddress(params.asset),
-              recipientAddress: params.toAddress,
-              amount: params.amount
-            })
-          });
-        }
-        return await params.walletAdapter.sendEthTransaction({
-          chain: Chain.ETH,
-          account: params.senderAccount,
-          actionType: `supply-${params.action}`,
-          transferMode: TransferMode.native,
-          transaction: {
-            to: params.toAddress,
-            value: params.amount.toString()
-          }
-        });
+  /**
+   * Estimates the network/deposit fee for an inflow target.
+   *
+   * ETH stablecoin deposit-address estimates are served by the deposit-address
+   * canister. BTC estimates include the ckBTC minter deposit fee and 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 (isEthStablecoin(request.asset, request.chain)) {
+      const result = await createDepositAccountsActor(
+        this.canisterContext
+      ).estimate_deposit_fee([getEthStablecoinContractAddress(request.asset)]);
+      if ("Err" in result) {
+        throw mapDepositAccountErrorToLiquidiumError(result.Err);
       }
-      default:
-        throw new LiquidiumError(
-          LiquidiumErrorCode.VALIDATION_ERROR,
-          `Native-address wallet execution is not supported for ${params.chain}`
-        );
+      return {
+        totalFee: roundInflowFeeEstimate(request, result.Ok)
+      };
+    }
+    if (request.asset === Asset.BTC && request.chain === Chain.BTC) {
+      const estimate = await this.estimateBtcInflowFee();
+      return {
+        totalFee: roundInflowFeeEstimate(request, estimate.totalFee)
+      };
     }
+    throw new LiquidiumError(
+      LiquidiumErrorCode.VALIDATION_ERROR,
+      `Inflow fee estimates are not supported for ${request.asset} on ${request.chain}`
+    );
   }
-  async submitInflowWithRetry(txid, extraRequest) {
-    await retryWithBackoff({
-      execute: async () => {
-        await this.submitInflow({ txid, ...extraRequest });
-      },
-      maxAttempts: SUBMIT_INFLOW_MAX_ATTEMPTS,
-      initialRetryDelayMs: SUBMIT_INFLOW_INITIAL_RETRY_DELAY_MS,
-      backoffMultiplier: SUBMIT_INFLOW_RETRY_BACKOFF_MULTIPLIER,
-      shouldRetryError: isRetriableInflowSubmitError
-    });
+  async estimateBtcInflowFee() {
+    const [minterFee, ledgerFee] = await Promise.all([
+      createCkBtcMinterActor(this.canisterContext).get_deposit_fee(),
+      createCkBtcLedgerActor(this.canisterContext).icrc1_fee()
+    ]);
+    return { totalFee: minterFee + ledgerFee };
   }
   /**
    * Submits an inflow transaction id for faster indexing.
    *
    * Uses the Liquidium SDK API.
    *
-   * @param request - Broadcast `txid` plus optional `chain` and inflow `type`.
+   * @param request - Broadcast `txid` plus inflow `operation` and optional `chain`.
    * @returns Acknowledgement including the submitted `txid`.
    */
   async submitInflow(request) {
     const apiClient = this.requireApi();
-    return await apiClient.post(
-      SdkApiPath.inflow,
-      request
-    );
+    const response = await apiClient.post(SdkApiPath.inflow, request);
+    return {
+      txid: response.txid
+    };
   }
   /**
    * Returns whether borrowing is currently disabled by the protocol.
@@ -5839,11 +5826,16 @@ var LendingModule = class {
     }
     return this.apiClient;
   }
-  requireEvmReadClient(message) {
-    if (!this.evmReadClient) {
-      throw new LiquidiumError(LiquidiumErrorCode.VALIDATION_ERROR, message);
-    }
-    return this.evmReadClient;
+  createSupplyFlowExecutor() {
+    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(
@@ -5869,80 +5861,7 @@ var LendingModule = class {
       chain: selectedPool.chain
     });
   }
-  async sendEthContractTransaction(walletAdapter, walletAddress, request, actionType) {
-    if (!walletAdapter.sendEthTransaction) {
-      throw new LiquidiumError(
-        LiquidiumErrorCode.VALIDATION_ERROR,
-        "ETH wallet adapter does not support transaction sending"
-      );
-    }
-    return await walletAdapter.sendEthTransaction({
-      chain: Chain.ETH,
-      account: walletAddress,
-      actionType,
-      transferMode: TransferMode.native,
-      transaction: request
-    });
-  }
-  async waitForExpectedAllowance(params) {
-    const evmReadClient = this.requireEvmReadClient(
-      "Contract-interaction supply requires an EVM RPC URL or public client"
-    );
-    let lastPollingError;
-    for (let pollIndex = 0; pollIndex < ETH_APPROVAL_MAX_POLLS; pollIndex += 1) {
-      try {
-        const allowance = await readErc20Allowance({
-          evmReadClient,
-          tokenAddress: params.tokenAddress,
-          ownerAddress: params.walletAddress,
-          spenderAddress: params.spenderAddress
-        });
-        const matchesExpectation = params.expectation === "zero" ? allowance === 0n : allowance >= params.amount;
-        if (matchesExpectation) {
-          return;
-        }
-      } catch (error) {
-        lastPollingError = error;
-      }
-      await delay(ETH_APPROVAL_POLL_INTERVAL_MS);
-    }
-    const lastPollingErrorMessage = getUnknownErrorMessage(lastPollingError);
-    throw new LiquidiumError(
-      LiquidiumErrorCode.SERVICE_UNAVAILABLE,
-      lastPollingErrorMessage ? `Timed out waiting for ${params.expectation} ETH allowance update. Last polling error: ${lastPollingErrorMessage}` : `Timed out waiting for ${params.expectation} ETH allowance update`
-    );
-  }
 };
-async function readErc20Allowance(params) {
-  const allowance = await params.evmReadClient.readContract({
-    address: params.tokenAddress,
-    abi: ERC20_ABI,
-    functionName: "allowance",
-    args: [
-      params.ownerAddress,
-      params.spenderAddress
-    ]
-  });
-  return BigInt(allowance);
-}
-async function readErc20Balance(params) {
-  const balance = await params.evmReadClient.readContract({
-    address: params.tokenAddress,
-    abi: ERC20_ABI,
-    functionName: "balanceOf",
-    args: [params.ownerAddress]
-  });
-  return BigInt(balance);
-}
-function getApprovalStrategy(params) {
-  if (params.allowance >= params.amount) {
-    return EvmSupplyApprovalStrategy.none;
-  }
-  if (params.allowance === 0n) {
-    return EvmSupplyApprovalStrategy.approveMax;
-  }
-  return EvmSupplyApprovalStrategy.resetThenApproveMax;
-}
 function mapExpectedOutflowDetails(details, expectedOutflowType, operation) {
   if (details.outflowType !== expectedOutflowType) {
     throw new LiquidiumError(
@@ -5950,42 +5869,22 @@ function mapExpectedOutflowDetails(details, expectedOutflowType, operation) {
       `${operation} returned unexpected outflow type ${details.outflowType}`
     );
   }
-  return details;
-}
-async function delay(timeoutMs) {
-  await new Promise((resolve) => setTimeout(resolve, timeoutMs));
-}
-function isRetriableInflowSubmitError(error) {
-  if (!(error instanceof LiquidiumError)) {
-    return false;
-  }
-  return error.code === LiquidiumErrorCode.SERVICE_UNAVAILABLE;
-}
-function getUnknownErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  return null;
-}
-function getDefaultSubmitInflowRequest(params) {
-  if (params.chain !== Chain.BTC && params.chain !== Chain.ETH) {
-    return void 0;
-  }
   return {
-    chain: params.chain,
-    type: params.action === SupplyAction.repayment ? InflowSubmitType.REPAY : InflowSubmitType.DEPOSIT
+    ...details,
+    status: createLiquidiumStatus({
+      operation: mapOutflowTypeToStatusOperation(expectedOutflowType),
+      state: details.txid ? "confirming" : "processing"
+    })
   };
 }
-function shouldSubmitInflow(params) {
-  if (params.mechanism !== SupplyPlanType.transfer) {
-    return true;
-  }
-  return !isEthStablecoin(params.instruction.asset, params.instruction.chain);
+function mapOutflowTypeToStatusOperation(outflowType) {
+  return outflowType;
 }
 
+// src/core/rates.ts
+var RATE_SCALE2 = 1000000000000000000000000000n;
+var RATE_DECIMALS = BigInt(RATE_SCALE2.toString().length - 1);
+
 // src/modules/market/mappers.ts
 var DECIMAL_BASE = 10;
 var PAIR_SEPARATOR = "_";
@@ -6064,16 +5963,18 @@ var MarketModule = class {
   canisterContext;
   apiClient;
   /**
-   * Lists all pools with their current rates.
+   * Lists SDK-supported pools with their current rates.
    *
-   * @returns All configured lending pools enriched with their current rate data.
+   * Unsupported asset or chain variants returned by the canister are omitted.
+   *
+   * @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();
-      const decodedPools = rawPools.map(decodeFlexiblePool).filter((pool) => pool !== null);
+      const decodedPools = decodeSupportedFlexiblePools(rawPools);
       return await Promise.all(
         decodedPools.map(async (pool) => {
           const poolRate = await flexibleActor.get_pool_rate(pool.principal);
@@ -6180,6 +6081,17 @@ var MarketModule = class {
     }
   }
 };
+function decodeSupportedFlexiblePools(rawPools) {
+  const decodedPools = [];
+  for (const rawPool of rawPools) {
+    const decodedPool = decodeFlexiblePool(rawPool);
+    if (!decodedPool) {
+      continue;
+    }
+    decodedPools.push(decodedPool);
+  }
+  return decodedPools;
+}
 
 // src/modules/positions/mappers.ts
 var USD_VALUE_SCALE_DECIMALS = 27n;
@@ -6510,6 +6422,7 @@ var LiquidiumClient = class {
     this.instantLoans = new InstantLoansModule(
       this.canisterContext,
       this.apiClient,
+      this.activities,
       this.lending,
       this.positions
     );
@@ -6533,18 +6446,13 @@ function resolveEvmReadClient(config) {
 
 exports.AccountsModule = AccountsModule;
 exports.ActivitiesModule = ActivitiesModule;
-exports.ActivityDirection = ActivityDirection;
 exports.ActivityFilter = ActivityFilter;
-exports.ActivityKind = ActivityKind;
-exports.ActivityStatus = ActivityStatus;
 exports.Asset = Asset;
 exports.CK_ETH_DEPOSIT_CONTRACT_ADDRESS = CK_ETH_DEPOSIT_CONTRACT_ADDRESS;
 exports.Chain = Chain;
 exports.Environment = Environment;
 exports.EvmSupplyApprovalStrategy = EvmSupplyApprovalStrategy;
 exports.HistoryModule = HistoryModule;
-exports.InflowSubmitType = InflowSubmitType;
-exports.InstantLoanStatus = InstantLoanStatus;
 exports.InstantLoansModule = InstantLoansModule;
 exports.LendingModule = LendingModule;
 exports.LiquidiumClient = LiquidiumClient;
@@ -6558,13 +6466,13 @@ exports.QuoteModule = QuoteModule;
 exports.QuoteValidationErrorCode = QuoteValidationErrorCode;
 exports.QuoteWarningCode = QuoteWarningCode;
 exports.RATE_DECIMALS = RATE_DECIMALS;
-exports.RATE_SCALE = RATE_SCALE;
+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.UserHistoryStatus = UserHistoryStatus;
+exports.WalletActionKind = WalletActionKind;
 exports.WalletExecutionKind = WalletExecutionKind;
 exports.createTransferErc20Transaction = createTransferErc20Transaction;
 exports.executeWith = executeWith;