@liquidium/client 0.2.1 → 0.3.1

package/dist/index.js

@@ -2,6 +2,7 @@ import { encodeFunctionData, createPublicClient, http, isAddress, getAddress } f
 import { mainnet } from 'viem/chains';
 import { Actor, HttpAgent } from '@icp-sdk/core/agent';
 import { Principal } from '@icp-sdk/core/principal';
+import { idlLabelToId } from '@icp-sdk/core/candid';
 import { encodeIcrcAccount } from '@dfinity/ledger-icrc';
 import { Principal as Principal$1 } from '@dfinity/principal';
 import { validate, Network } from 'bitcoin-address-validation';
@@ -1305,17 +1306,35 @@ function mapCanisterWalletToWallet(canisterWallet) {
       );
   }
 }
-var idlFactory2 = ({ IDL }) => {
+var KNOWN_ASSET_TAGS = ["BTC", "SOL", "USDC", "USDT"];
+var KNOWN_CHAIN_TAGS = ["BTC", "ETH", "SOL"];
+function extractVariantTag(variant, knownTags) {
+  const [key] = Object.keys(variant);
+  if (!key) {
+    return null;
+  }
+  if (knownTags.includes(key)) {
+    return key;
+  }
+  const hashMatch = /^_(\d+)_$/.exec(key);
+  if (!hashMatch) {
+    return null;
+  }
+  const hash = Number(hashMatch[1]);
+  for (const tag of knownTags) {
+    if (idlLabelToId(tag) === hash) {
+      return tag;
+    }
+  }
+  return null;
+}
+
+// src/core/canisters/instant-loans/flexible-actor.ts
+var flexibleInstantLoansIdlFactory = ({ IDL }) => {
   const AccountType = IDL.Variant({
     Native: IDL.Principal,
     External: IDL.Text
   });
-  const Assets = IDL.Variant({
-    BTC: IDL.Null,
-    SOL: IDL.Null,
-    USDC: IDL.Null,
-    USDT: IDL.Null
-  });
   const SignatureVerificationError = IDL.Variant({
     InvalidEthSignature: IDL.Null,
     UnsupportedChain: IDL.Null,
@@ -1386,13 +1405,13 @@ var idlFactory2 = ({ IDL }) => {
   });
   const CreateLoanRequest = IDL.Record({
     borrow_destination: AccountType,
-    lend_asset: Assets,
+    lend_asset: IDL.Unknown,
     borrow_amount: IDL.Nat,
     lend_pool_id: IDL.Principal,
     refund_destination: AccountType,
     ltv_max_bps: IDL.Nat64,
     borrow_pool_id: IDL.Principal,
-    borrow_asset: Assets,
+    borrow_asset: IDL.Unknown,
     ltv_timer_s: IDL.Nat64
   });
   const CreateLoanResponse = IDL.Record({
@@ -1408,7 +1427,7 @@ var idlFactory2 = ({ IDL }) => {
     LoanCreated: IDL.Record({
       loan_id: IDL.Nat,
       borrow_destination: AccountType,
-      lend_asset: Assets,
+      lend_asset: IDL.Unknown,
       borrow_amount: IDL.Nat,
       lend_pool_id: IDL.Principal,
       refund_destination: AccountType,
@@ -1416,7 +1435,7 @@ var idlFactory2 = ({ IDL }) => {
       ltv_timer_s: IDL.Nat64,
       lending_profile: IDL.Principal,
       borrow_pool_id: IDL.Principal,
-      borrow_asset: Assets
+      borrow_asset: IDL.Unknown
     }),
     FullLendWithdrawalRequested: IDL.Record({
       loan_id: IDL.Nat,
@@ -1467,7 +1486,7 @@ var idlFactory2 = ({ IDL }) => {
     authorisation: AuthorisationType,
     borrow_destination: AccountType,
     started: IDL.Bool,
-    lend_asset: Assets,
+    lend_asset: IDL.Unknown,
     created_at: IDL.Nat64,
     schema_version: IDL.Nat16,
     borrow_amount: IDL.Nat,
@@ -1478,7 +1497,7 @@ var idlFactory2 = ({ IDL }) => {
     lending_profile: IDL.Principal,
     expires_at: IDL.Opt(IDL.Nat64),
     borrow_pool_id: IDL.Principal,
-    borrow_asset: Assets,
+    borrow_asset: IDL.Unknown,
     deposit_detected_ts: IDL.Opt(IDL.Nat64)
   });
   const LoanResult = IDL.Variant({ Ok: Loan, Err: InstantLoansError });
@@ -1506,7 +1525,7 @@ var idlFactory2 = ({ IDL }) => {
     list_warmed_profiles: IDL.Func([], [IDL.Vec(WarmedProfile)], ["query"])
   });
 };
-function createInstantLoansActor(canisterContext) {
+function createFlexibleInstantLoansActor(canisterContext) {
   const canisterId = canisterContext.canisterIds.instantLoans;
   if (!canisterId) {
     throw new LiquidiumError(
@@ -1514,10 +1533,84 @@ function createInstantLoansActor(canisterContext) {
       "Instant loans canister ID is not configured"
     );
   }
-  return Actor.createActor(idlFactory2, {
-    agent: canisterContext.agent,
-    canisterId
-  });
+  return Actor.createActor(
+    flexibleInstantLoansIdlFactory,
+    {
+      agent: canisterContext.agent,
+      canisterId
+    }
+  );
+}
+function decodeFlexibleInstantLoanRecord(record) {
+  const lend_asset = extractVariantTag(record.lend_asset, KNOWN_ASSET_TAGS);
+  const borrow_asset = extractVariantTag(record.borrow_asset, KNOWN_ASSET_TAGS);
+  if (!lend_asset || !borrow_asset) {
+    return null;
+  }
+  return {
+    id: record.id,
+    authorisation: record.authorisation,
+    borrow_destination: record.borrow_destination,
+    started: record.started,
+    lend_asset,
+    created_at: record.created_at,
+    schema_version: record.schema_version,
+    borrow_amount: record.borrow_amount,
+    lend_pool_id: record.lend_pool_id,
+    refund_destination: record.refund_destination,
+    ltv_max_bps: record.ltv_max_bps,
+    ltv_timer_s: record.ltv_timer_s,
+    lending_profile: record.lending_profile,
+    borrow_pool_id: record.borrow_pool_id,
+    borrow_asset,
+    expires_at: record.expires_at,
+    deposit_detected_ts: record.deposit_detected_ts
+  };
+}
+function decodeFlexibleHeadlessLoanEvent(event) {
+  if ("LoanCreated" in event.event_type) {
+    const decoded = decodeLoanCreatedEvent(event.event_type.LoanCreated);
+    if (!decoded) {
+      return null;
+    }
+    return {
+      id: event.id,
+      schema_version: event.schema_version,
+      timestamp: event.timestamp,
+      event_type: decoded
+    };
+  }
+  return {
+    id: event.id,
+    schema_version: event.schema_version,
+    timestamp: event.timestamp,
+    event_type: event.event_type
+  };
+}
+function decodeLoanCreatedEvent(payload) {
+  const lend_asset = extractVariantTag(payload.lend_asset, KNOWN_ASSET_TAGS);
+  const borrow_asset = extractVariantTag(
+    payload.borrow_asset,
+    KNOWN_ASSET_TAGS
+  );
+  if (!lend_asset || !borrow_asset) {
+    return null;
+  }
+  return {
+    LoanCreated: {
+      loan_id: payload.loan_id,
+      borrow_destination: payload.borrow_destination,
+      lend_asset,
+      borrow_amount: payload.borrow_amount,
+      lend_pool_id: payload.lend_pool_id,
+      refund_destination: payload.refund_destination,
+      ltv_max_bps: payload.ltv_max_bps,
+      ltv_timer_s: payload.ltv_timer_s,
+      lending_profile: payload.lending_profile,
+      borrow_pool_id: payload.borrow_pool_id,
+      borrow_asset
+    }
+  };
 }
 
 // src/core/sdk-api-paths.ts
@@ -1591,9 +1684,9 @@ function buildActivityStatusPath(request) {
     request.id
   )}/status?${query.toString()}`;
 }
-function buildInstantLoanAddressLookupPath(request) {
-  const query = new URLSearchParams({ address: request.address });
-  return `${INSTANT_LOANS}/address?${query.toString()}`;
+function buildInstantLoanFindPath(request) {
+  const query = new URLSearchParams({ query: request.query });
+  return `${INSTANT_LOANS}/find?${query.toString()}`;
 }
 function buildInstantLoanCollateralHintPath(request) {
   return `${INSTANT_LOANS}/${encodeURIComponent(
@@ -1807,7 +1900,7 @@ var ActivitiesModule = class {
       );
     }
     try {
-      const result = await createInstantLoansActor(
+      const result = await createFlexibleInstantLoansActor(
         this.canisterContext
       ).get_loan(loanId);
       if ("Err" in result) {
@@ -2222,6 +2315,41 @@ function mapHistoryStatusToApi(status) {
   return status.toUpperCase();
 }
 
+// src/core/utils/api-response-parsers.ts
+var MILLISECONDS_PER_SECOND2 = 1e3;
+function parseNonEmptyApiString(value, field) {
+  if (!value) {
+    throwInvalidApiResponseField(field);
+  }
+  return value;
+}
+function parseUnsignedApiBigint(value, field) {
+  if (!value || !/^\d+$/.test(value)) {
+    throwInvalidApiResponseField(field);
+  }
+  return BigInt(value);
+}
+function parseIsoApiTimestampToUnixSeconds(value, field) {
+  const timestamp = parseNonEmptyApiString(value, field);
+  const timestampMilliseconds = Date.parse(timestamp);
+  if (!Number.isFinite(timestampMilliseconds)) {
+    throwInvalidApiResponseField(field);
+  }
+  return BigInt(Math.floor(timestampMilliseconds / MILLISECONDS_PER_SECOND2));
+}
+function parseApiStringUnion(value, allowedValues, field) {
+  if (value !== void 0 && allowedValues.includes(value)) {
+    return value;
+  }
+  throwInvalidApiResponseField(field);
+}
+function throwInvalidApiResponseField(field) {
+  throw new LiquidiumError(
+    LiquidiumErrorCode.VALIDATION_ERROR,
+    `Invalid ${field.context} ${field.label}`
+  );
+}
+
 // src/core/utils/asset-decimals.ts
 var ASSET_NATIVE_DECIMALS = {
   BTC: 8n,
@@ -2241,7 +2369,7 @@ function getAssetNativeDecimals(asset) {
 }
 
 // src/generated/canisters/ck-btc-minter/declaration.js
-var idlFactory3 = ({ IDL }) => {
+var idlFactory2 = ({ IDL }) => {
   const Mode = IDL.Variant({
     "RestrictedTo": IDL.Vec(IDL.Principal),
     "DepositsRestrictedTo": IDL.Vec(IDL.Principal),
@@ -2621,14 +2749,14 @@ var idlFactory3 = ({ IDL }) => {
 // src/core/canisters/ckbtc/minter.ts
 function createCkBtcMinterActor(canisterContext) {
   const canisterId = CK_CANISTER_IDS.btcMinter;
-  return Actor.createActor(idlFactory3, {
+  return Actor.createActor(idlFactory2, {
     agent: canisterContext.agent,
     canisterId
   });
 }
 
 // src/generated/canisters/deposit-accounts/deposit_accounts.did.js
-var idlFactory4 = ({ IDL }) => {
+var idlFactory3 = ({ IDL }) => {
   const DepositAccountErrors = IDL.Variant({
     "Busy": IDL.Null,
     "NotFound": IDL.Null,
@@ -2848,7 +2976,7 @@ function createDepositAccountsActor(canisterContext) {
       "ETH deposit canister ID is not configured"
     );
   }
-  return Actor.createActor(idlFactory4, {
+  return Actor.createActor(idlFactory3, {
     agent: canisterContext.agent,
     canisterId
   });
@@ -3613,6 +3741,14 @@ var RATE_SCALE2 = 10n ** 27n;
 var SECONDS_PER_YEAR = 31536000n;
 var ETH_STABLECOIN_INFLOW_FEE_FALLBACK = 1500000n;
 var INSTANT_LOAN_MIN_SLIPPAGE_BUFFER_BPS = 200n;
+var INSTANT_LOAN_FIND_QUERY_MAX_LENGTH = 256;
+var INSTANT_LOAN_WIRE_CONTEXT = "instant loan";
+var INSTANT_LOAN_ASSETS = [
+  Asset.BTC,
+  Asset.SOL,
+  Asset.USDC,
+  Asset.USDT
+];
 var InstantLoansModule = class {
   constructor(canisterContext, apiClient, lending, positions) {
     this.canisterContext = canisterContext;
@@ -3669,7 +3805,19 @@ var InstantLoansModule = class {
       borrowDestination,
       refundDestination
     });
-    return await this.mapLoanWire(response.loan);
+    const loanId = parseUnsignedApiBigint(response.loan.loanId, {
+      context: INSTANT_LOAN_WIRE_CONTEXT,
+      label: "loan ID"
+    });
+    const collateralAmount = parseUnsignedApiBigint(
+      response.loan.collateral.amountHint,
+      {
+        context: INSTANT_LOAN_WIRE_CONTEXT,
+        label: "collateral amount"
+      }
+    );
+    const record = await this.getLoanRecord(loanId);
+    return await this.mapLoanRecord(record, collateralAmount);
   }
   /**
    * Resolves canonical canister state by loan id or short reference.
@@ -3682,21 +3830,30 @@ var InstantLoansModule = class {
    */
   async get(request) {
     const loanId = "loanId" in request ? request.loanId : decodeRef(request.ref);
-    try {
-      const result = await createInstantLoansActor(
-        this.canisterContext
-      ).get_loan(loanId);
-      if ("Err" in result) {
-        throw mapInstantLoansErrorToLiquidiumError(result.Err);
-      }
-      const collateralAmount = await this.getCollateralAmountHint(loanId);
-      return await this.mapLoanRecord(result.Ok, collateralAmount);
-    } catch (error) {
-      if (error instanceof LiquidiumError) {
-        throw error;
-      }
-      throw mapCanisterCallErrorToLiquidiumError("get_loan", error);
-    }
+    const record = await this.getLoanRecord(loanId);
+    const collateralAmount = await this.getCollateralAmountHint(loanId);
+    return await this.mapLoanRecord(record, collateralAmount);
+  }
+  /**
+   * Finds instant loans by short reference, numeric loan id string, address, or transaction id.
+   *
+   * Search returns lightweight matches. Call `get({ loanId })` or `get({ ref })`
+   * when the user selects a match and you need hydrated loan state.
+   *
+   * @param query - Short reference, address, transaction id/hash, or numeric loan id string.
+   * @returns Matching loan ids and references from the search index.
+   */
+  async find(query) {
+    const validatedQuery = validateInstantLoanFindQuery(query);
+    const candidates = await this.findCandidateLoansByQuery(validatedQuery);
+    return uniqueInstantLoanFindCandidates(candidates).map((candidate) => ({
+      loanId: candidate.loanId,
+      ref: candidate.ref,
+      createdAt: candidate.createdAt,
+      collateral: candidate.collateral,
+      borrow: candidate.borrow,
+      profileId: candidate.profileId
+    }));
   }
   /**
    * Returns the active instant-loans canister config via direct query.
@@ -3705,7 +3862,7 @@ var InstantLoansModule = class {
    */
   async getConfig() {
     try {
-      const config = await createInstantLoansActor(
+      const config = await createFlexibleInstantLoansActor(
         this.canisterContext
       ).get_config();
       return {
@@ -3723,10 +3880,11 @@ var InstantLoansModule = class {
    */
   async getEvent(eventId) {
     try {
-      const event = await createInstantLoansActor(
+      const event = await createFlexibleInstantLoansActor(
         this.canisterContext
       ).get_event(eventId);
-      return event[0] ? mapInstantLoanEvent(event[0]) : null;
+      const decoded = event[0] ? decodeFlexibleHeadlessLoanEvent(event[0]) : null;
+      return decoded ? mapInstantLoanEvent(decoded) : null;
     } catch (error) {
       throw mapCanisterCallErrorToLiquidiumError("get_event", error);
     }
@@ -3739,10 +3897,10 @@ var InstantLoansModule = class {
    */
   async listEvents(request) {
     try {
-      const events = await createInstantLoansActor(
+      const events = await createFlexibleInstantLoansActor(
         this.canisterContext
       ).list_events(request.start, request.limit);
-      return events.map(([, event]) => mapInstantLoanEvent(event));
+      return events.map(([, event]) => decodeFlexibleHeadlessLoanEvent(event)).filter((event) => event !== null).map((event) => mapInstantLoanEvent(event));
     } catch (error) {
       throw mapCanisterCallErrorToLiquidiumError("list_events", error);
     }
@@ -3754,7 +3912,7 @@ var InstantLoansModule = class {
    */
   async listAccessList() {
     try {
-      const principals = await createInstantLoansActor(
+      const principals = await createFlexibleInstantLoansActor(
         this.canisterContext
       ).list_access_list();
       return principals.map((principal) => principal.toText());
@@ -3769,7 +3927,7 @@ var InstantLoansModule = class {
    */
   async countWarmedProfiles() {
     try {
-      return await createInstantLoansActor(
+      return await createFlexibleInstantLoansActor(
         this.canisterContext
       ).count_warmed_profiles();
     } catch (error) {
@@ -3786,7 +3944,7 @@ var InstantLoansModule = class {
    */
   async listWarmedProfiles() {
     try {
-      const profiles = await createInstantLoansActor(
+      const profiles = await createFlexibleInstantLoansActor(
         this.canisterContext
       ).list_warmed_profiles();
       return profiles.map(mapWarmedProfile);
@@ -3794,30 +3952,36 @@ var InstantLoansModule = class {
       throw mapCanisterCallErrorToLiquidiumError("list_warmed_profiles", error);
     }
   }
-  /**
-   * Finds candidate loans associated with an address through the Liquidium SDK
-   * API. Returns discovery candidates only; call `get(...)` to hydrate canister state.
-   *
-   * Candidates are useful for recovery flows where the user knows a borrow or
-   * refund address but not the loan reference.
-   *
-   * @param address - Borrow or refund address to search for.
-   * @returns Lightweight loan candidates associated with the address.
-   */
-  async findByAddress(address) {
-    const trimmedAddress = address.trim();
-    if (!trimmedAddress) {
-      throw new LiquidiumError(
-        LiquidiumErrorCode.VALIDATION_ERROR,
-        "Address lookup requires a non-empty address"
-      );
-    }
-    const apiClient = this.requireApi("Instant loan address lookup");
+  async findCandidateLoansByQuery(query) {
+    const apiClient = this.requireApi("Instant loan find");
     const response = await apiClient.get(
-      buildInstantLoanAddressLookupPath({ address: trimmedAddress })
+      buildInstantLoanFindPath({ query })
     );
     return (response.candidates ?? response.loans ?? []).map(mapCandidateWire);
   }
+  async getLoanRecord(loanId) {
+    try {
+      const result = await createFlexibleInstantLoansActor(
+        this.canisterContext
+      ).get_loan(loanId);
+      if ("Err" in result) {
+        throw mapInstantLoansErrorToLiquidiumError(result.Err);
+      }
+      const decoded = decodeFlexibleInstantLoanRecord(result.Ok);
+      if (!decoded) {
+        throw new LiquidiumError(
+          LiquidiumErrorCode.POOL_NOT_FOUND,
+          `Instant loan ${loanId.toString()} uses an unsupported asset`
+        );
+      }
+      return decoded;
+    } catch (error) {
+      if (error instanceof LiquidiumError) {
+        throw error;
+      }
+      throw mapCanisterCallErrorToLiquidiumError("get_loan", error);
+    }
+  }
   async mapLoanRecord(record, collateralAmount) {
     return await this.hydrateLoan({
       loanId: record.id,
@@ -3827,41 +3991,26 @@ var InstantLoansModule = class {
       collateralPoolId: record.lend_pool_id.toText(),
       collateralAmount,
       borrowPoolId: record.borrow_pool_id.toText(),
-      collateralAsset: getVariantKey(record.lend_asset),
-      borrowAsset: getVariantKey(record.borrow_asset),
+      collateralAsset: record.lend_asset,
+      borrowAsset: record.borrow_asset,
       borrowAmount: record.borrow_amount,
       borrowDestination: accountFromCanister(record.borrow_destination),
-      refundDestination: accountFromCanister(record.refund_destination)
+      refundDestination: accountFromCanister(record.refund_destination),
+      depositDetectedTimestamp: record.deposit_detected_ts[0] ?? null,
+      expiryTimestamp: record.expires_at[0] ?? deriveDepositExpiryTimestamp({
+        depositDetectedTimestamp: record.deposit_detected_ts[0] ?? null,
+        depositWindowSeconds: record.ltv_timer_s
+      })
     });
   }
   async getCollateralAmountHint(loanId) {
-    const apiClient = this.requireApi("Instant loan lookup");
+    const apiClient = this.requireApi("Instant loan collateral hint");
     const response = await apiClient.get(
       buildInstantLoanCollateralHintPath({ loanId })
     );
-    return parseBigintWire(response.collateralAmountHint, "collateral amount");
-  }
-  async mapLoanWire(loan) {
-    const loanId = parseBigintWire(loan.loanId, "loan ID");
-    return await this.hydrateLoan({
-      loanId,
-      profileId: loan.profileId,
-      ltvMaxBps: parseBigintWire(loan.ltvMaxBps, "max LTV"),
-      depositWindowSeconds: parseBigintWire(
-        loan.depositWindowSeconds,
-        "deposit window"
-      ),
-      collateralPoolId: loan.collateral.poolId,
-      collateralAmount: parseBigintWire(
-        loan.collateral.amountHint,
-        "collateral amount"
-      ),
-      borrowPoolId: loan.borrow.poolId,
-      collateralAsset: loan.collateral.asset,
-      borrowAsset: loan.borrow.asset,
-      borrowAmount: parseBigintWire(loan.borrow.amount, "borrow amount"),
-      borrowDestination: accountFromWire(loan.borrow.destination),
-      refundDestination: accountFromWire(loan.refundDestination)
+    return parseUnsignedApiBigint(response.collateralAmountHint, {
+      context: INSTANT_LOAN_WIRE_CONTEXT,
+      label: "collateral amount"
     });
   }
   async hydrateLoan(input) {
@@ -3915,7 +4064,9 @@ var InstantLoansModule = class {
       collateralAmount,
       decimals: collateralDecimals,
       asset: collateralAsset,
-      target: depositTarget
+      target: depositTarget,
+      detectedTimestamp: input.depositDetectedTimestamp,
+      expiryTimestamp: input.expiryTimestamp
     });
     const repayment = {
       amount: repaymentAmount,
@@ -3979,7 +4130,9 @@ var InstantLoansModule = class {
       inflowFeeAmount: inflowFee.totalFee,
       asset: input.asset,
       chain: input.target.chain,
-      target: input.target
+      target: input.target,
+      detectedTimestamp: input.detectedTimestamp,
+      expiryTimestamp: input.expiryTimestamp
     };
   }
   async estimateRepaymentInflowFee(asset, chain) {
@@ -4075,6 +4228,12 @@ function deriveInstantLoanStatus(input) {
   }
   return InstantLoanStatus.awaitingDeposit;
 }
+function deriveDepositExpiryTimestamp(input) {
+  if (input.depositDetectedTimestamp === null) {
+    return null;
+  }
+  return input.depositDetectedTimestamp + input.depositWindowSeconds;
+}
 function validateCreateRequest(request) {
   if (request.collateralAmount <= 0n) {
     throw new LiquidiumError(
@@ -4123,18 +4282,6 @@ function accountFromCanister(account) {
   }
   return { type: "External", address: account.External };
 }
-function accountFromWire(account) {
-  if ("Native" in account) {
-    return { type: "Native", principal: account.Native };
-  }
-  if ("External" in account) {
-    return { type: "External", address: account.External };
-  }
-  if (account.type === "Native") {
-    return { type: "Native", principal: account.principal };
-  }
-  return { type: "External", address: account.address };
-}
 function mapInstantLoanEvent(event) {
   return {
     id: event.id,
@@ -4150,7 +4297,7 @@ function mapInstantLoanEventType(eventType) {
       type: "LoanCreated",
       loanId: event.loan_id,
       borrowDestination: accountFromCanister(event.borrow_destination),
-      collateralAsset: assetFromCanister(event.lend_asset),
+      collateralAsset: event.lend_asset,
       borrowAmount: event.borrow_amount,
       collateralPoolId: event.lend_pool_id.toText(),
       refundDestination: accountFromCanister(event.refund_destination),
@@ -4158,7 +4305,7 @@ function mapInstantLoanEventType(eventType) {
       depositWindowSeconds: event.ltv_timer_s,
       profileId: event.lending_profile.toText(),
       borrowPoolId: event.borrow_pool_id.toText(),
-      borrowAsset: assetFromCanister(event.borrow_asset)
+      borrowAsset: event.borrow_asset
     };
   }
   if ("FullLendWithdrawalRequested" in eventType) {
@@ -4236,9 +4383,6 @@ function authorizationFromCanister(authorization) {
     address: authorization.EthSignature.address
   };
 }
-function assetFromCanister(asset) {
-  return getVariantKey(asset);
-}
 function legFromCanister(leg) {
   return getVariantKey(leg);
 }
@@ -4253,55 +4397,80 @@ function decodeRef(ref) {
     );
   }
 }
-function mapCandidateWire(wire) {
-  const loanId = parseBigintWire(wire.loanId ?? wire.loan_id, "loan ID");
-  const ref = wire.ref ?? wire.short_ref ?? publicIdFromInt(loanId);
-  const createdAt = wire.createdAt ?? wire.created_at;
-  return {
-    loanId,
-    ref,
-    profileId: requiredString(
-      wire.profileId ?? wire.lending_profile,
-      "profile ID"
-    ),
-    ...createdAt ? { createdAt: new Date(createdAt) } : {},
-    collateralPoolId: requiredString(
-      wire.collateralPoolId ?? wire.lend_pool_ic_id,
-      "collateral pool ID"
-    ),
-    borrowPoolId: requiredString(
-      wire.borrowPoolId ?? wire.borrow_pool_ic_id,
-      "borrow pool ID"
-    ),
-    collateralAsset: requiredString(
-      wire.collateralAsset ?? wire.lend_asset,
-      "collateral asset"
-    ),
-    borrowAsset: requiredString(
-      wire.borrowAsset ?? wire.borrow_asset,
-      "borrow asset"
-    ),
-    collateralAmount: parseBigintWire(
-      wire.collateralAmount,
-      "collateral amount"
-    )
-  };
-}
-function parseBigintWire(value, label) {
-  if (!value || !/^\d+$/.test(value)) {
+function validateInstantLoanFindQuery(query) {
+  if (typeof query !== "string") {
     throw new LiquidiumError(
       LiquidiumErrorCode.VALIDATION_ERROR,
-      `Invalid instant loan ${label}`
+      "Instant loan find query must be a string"
     );
   }
-  return BigInt(value);
+  const trimmedQuery = query.trim();
+  if (!trimmedQuery) {
+    throw new LiquidiumError(
+      LiquidiumErrorCode.VALIDATION_ERROR,
+      "Instant loan find query must be non-empty"
+    );
+  }
+  if (trimmedQuery.length > INSTANT_LOAN_FIND_QUERY_MAX_LENGTH) {
+    throw new LiquidiumError(
+      LiquidiumErrorCode.VALIDATION_ERROR,
+      `Instant loan find query must be at most ${INSTANT_LOAN_FIND_QUERY_MAX_LENGTH.toString()} characters`
+    );
+  }
+  return trimmedQuery;
 }
-function requiredString(value, label) {
-  if (value?.trim()) return value;
-  throw new LiquidiumError(
-    LiquidiumErrorCode.VALIDATION_ERROR,
-    `Missing instant loan ${label}`
-  );
+function uniqueInstantLoanFindCandidates(candidates) {
+  const candidatesByLoanId = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    if (!candidatesByLoanId.has(candidate.loanId)) {
+      candidatesByLoanId.set(candidate.loanId, candidate);
+    }
+  }
+  return [...candidatesByLoanId.values()];
+}
+function mapCandidateWire(wire) {
+  return {
+    loanId: parseUnsignedApiBigint(wire.loan_id, {
+      context: INSTANT_LOAN_WIRE_CONTEXT,
+      label: "loan ID"
+    }),
+    ref: parseNonEmptyApiString(wire.short_ref, {
+      context: INSTANT_LOAN_WIRE_CONTEXT,
+      label: "short reference"
+    }),
+    createdAt: parseIsoApiTimestampToUnixSeconds(wire.created_at, {
+      context: INSTANT_LOAN_WIRE_CONTEXT,
+      label: "creation timestamp"
+    }),
+    collateral: {
+      poolId: parseNonEmptyApiString(wire.lend_pool_ic_id, {
+        context: INSTANT_LOAN_WIRE_CONTEXT,
+        label: "lend pool ID"
+      }),
+      asset: parseApiStringUnion(wire.lend_asset, INSTANT_LOAN_ASSETS, {
+        context: INSTANT_LOAN_WIRE_CONTEXT,
+        label: "lend asset"
+      }),
+      amount: parseUnsignedApiBigint(wire.collateral_amount, {
+        context: INSTANT_LOAN_WIRE_CONTEXT,
+        label: "collateral amount"
+      })
+    },
+    borrow: {
+      poolId: parseNonEmptyApiString(wire.borrow_pool_ic_id, {
+        context: INSTANT_LOAN_WIRE_CONTEXT,
+        label: "borrow pool ID"
+      }),
+      asset: parseApiStringUnion(wire.borrow_asset, INSTANT_LOAN_ASSETS, {
+        context: INSTANT_LOAN_WIRE_CONTEXT,
+        label: "borrow asset"
+      })
+    },
+    profileId: parseNonEmptyApiString(wire.profile, {
+      context: INSTANT_LOAN_WIRE_CONTEXT,
+      label: "profile ID"
+    })
+  };
 }
 function mapInstantLoansErrorToLiquidiumError(error) {
   const [key, payload] = Object.entries(error)[0];
@@ -4441,12 +4610,12 @@ function encodeBytes32Hex(bytes) {
     (byte) => byte.toString(16).padStart(2, "0")
   ).join("")}`;
 }
-var idlFactory5 = ({ IDL }) => IDL.Service({
+var idlFactory4 = ({ IDL }) => IDL.Service({
   icrc1_fee: IDL.Func([], [IDL.Nat], ["query"])
 });
 function createCkBtcLedgerActor(canisterContext) {
   const canisterId = CK_CANISTER_IDS.btcLedger;
-  return Actor.createActor(idlFactory5, {
+  return Actor.createActor(idlFactory4, {
     agent: canisterContext.agent,
     canisterId
   });
@@ -5513,21 +5682,203 @@ function shouldSubmitInflow(params) {
   }
   return !isEthStablecoin(params.instruction.asset, params.instruction.chain);
 }
+var flexibleLendingIdlFactory = ({ IDL }) => {
+  const PoolRecord = IDL.Record({
+    principal: IDL.Principal,
+    asset: IDL.Unknown,
+    chain: IDL.Unknown,
+    total_supply_at_last_sync: IDL.Nat,
+    total_debt_at_last_sync: IDL.Nat,
+    supply_cap: IDL.Opt(IDL.Nat),
+    borrow_cap: IDL.Opt(IDL.Nat),
+    max_ltv: IDL.Nat64,
+    liquidation_threshold: IDL.Nat64,
+    liquidation_bonus: IDL.Nat64,
+    protocol_liquidation_fee: IDL.Nat64,
+    reserve_factor: IDL.Nat64,
+    base_rate: IDL.Nat,
+    optimal_utilization_rate: IDL.Nat,
+    rate_slope_before: IDL.Nat,
+    rate_slope_after: IDL.Nat,
+    lending_index: IDL.Nat,
+    borrow_index: IDL.Nat,
+    same_asset_borrowing: IDL.Opt(IDL.Bool),
+    frozen: IDL.Bool,
+    last_updated: IDL.Opt(IDL.Nat64)
+  });
+  const BorrowingPowerRecord = IDL.Record({
+    max_borrowable_usd: IDL.Nat,
+    weighted_max_ltv: IDL.Nat
+  });
+  const PositionRecord = IDL.Record({
+    asset: IDL.Unknown,
+    total_debt_interest: IDL.Nat,
+    borrow_index_snapshot: IDL.Nat,
+    lending_index_snapshot: IDL.Nat,
+    debt_scaled: IDL.Nat,
+    total_earned_interest: IDL.Nat,
+    deposit_scaled: IDL.Nat,
+    pool_id: IDL.Principal,
+    unpaid_debt_interest: IDL.Nat,
+    last_update: IDL.Nat64,
+    user_profile: IDL.Principal
+  });
+  const UserStatsRecord = IDL.Record({
+    debt: IDL.Nat,
+    collateral: IDL.Nat,
+    acumulated_interest: IDL.Nat,
+    borrowing_power: BorrowingPowerRecord,
+    positions: IDL.Vec(PositionRecord),
+    weighted_liquidation_threshold: IDL.Nat
+  });
+  const PositionViewRecord = IDL.Record({
+    lending_index_now: IDL.Nat,
+    interest_since_snapshot: IDL.Nat,
+    asset: IDL.Unknown,
+    total_debt_interest: IDL.Nat,
+    borrow_index_snapshot: IDL.Nat,
+    debt_native_now: IDL.Nat,
+    borrow_index_now: IDL.Nat,
+    lending_index_snapshot: IDL.Nat,
+    debt_scaled: IDL.Nat,
+    total_earned_interest: IDL.Nat,
+    deposit_scaled: IDL.Nat,
+    earned_since_snapshot: IDL.Nat,
+    deposited_native_now: IDL.Nat,
+    pool_id: IDL.Principal,
+    last_update: IDL.Nat64,
+    user_profile: IDL.Principal
+  });
+  return IDL.Service({
+    list_pools: IDL.Func([], [IDL.Vec(PoolRecord)], ["query"]),
+    get_pool_rate: IDL.Func(
+      [IDL.Principal],
+      [IDL.Opt(IDL.Tuple(IDL.Nat, IDL.Nat, IDL.Nat))],
+      ["query"]
+    ),
+    get_health_factor: IDL.Func(
+      [IDL.Principal],
+      [IDL.Nat, UserStatsRecord],
+      ["query"]
+    ),
+    get_profile_stats: IDL.Func([IDL.Principal], [UserStatsRecord], ["query"]),
+    get_position: IDL.Func(
+      [IDL.Principal, IDL.Principal],
+      [IDL.Opt(PositionViewRecord)],
+      ["query"]
+    )
+  });
+};
+function createFlexibleLendingActor(canisterContext) {
+  const canisterId = canisterContext.canisterIds.lending;
+  if (!canisterId) {
+    throw new LiquidiumError(
+      LiquidiumErrorCode.SERVICE_UNAVAILABLE,
+      "Lending canister ID is not configured"
+    );
+  }
+  return Actor.createActor(flexibleLendingIdlFactory, {
+    agent: canisterContext.agent,
+    canisterId
+  });
+}
+function decodeFlexiblePool(pool) {
+  const asset = extractVariantTag(pool.asset, KNOWN_ASSET_TAGS);
+  const chain = extractVariantTag(pool.chain, KNOWN_CHAIN_TAGS);
+  if (!asset || !chain) {
+    return null;
+  }
+  return {
+    principal: pool.principal,
+    asset,
+    chain,
+    total_supply_at_last_sync: pool.total_supply_at_last_sync,
+    total_debt_at_last_sync: pool.total_debt_at_last_sync,
+    supply_cap: pool.supply_cap,
+    borrow_cap: pool.borrow_cap,
+    max_ltv: pool.max_ltv,
+    liquidation_threshold: pool.liquidation_threshold,
+    liquidation_bonus: pool.liquidation_bonus,
+    protocol_liquidation_fee: pool.protocol_liquidation_fee,
+    reserve_factor: pool.reserve_factor,
+    base_rate: pool.base_rate,
+    optimal_utilization_rate: pool.optimal_utilization_rate,
+    rate_slope_before: pool.rate_slope_before,
+    rate_slope_after: pool.rate_slope_after,
+    lending_index: pool.lending_index,
+    borrow_index: pool.borrow_index,
+    same_asset_borrowing: pool.same_asset_borrowing,
+    frozen: pool.frozen,
+    last_updated: pool.last_updated
+  };
+}
+function decodeFlexiblePosition(position) {
+  const asset = extractVariantTag(position.asset, KNOWN_ASSET_TAGS);
+  if (!asset) {
+    return null;
+  }
+  return {
+    asset,
+    total_debt_interest: position.total_debt_interest,
+    borrow_index_snapshot: position.borrow_index_snapshot,
+    lending_index_snapshot: position.lending_index_snapshot,
+    debt_scaled: position.debt_scaled,
+    total_earned_interest: position.total_earned_interest,
+    deposit_scaled: position.deposit_scaled,
+    pool_id: position.pool_id,
+    unpaid_debt_interest: position.unpaid_debt_interest,
+    last_update: position.last_update,
+    user_profile: position.user_profile
+  };
+}
+function decodeFlexiblePositionView(view) {
+  const asset = extractVariantTag(view.asset, KNOWN_ASSET_TAGS);
+  if (!asset) {
+    return null;
+  }
+  return {
+    lending_index_now: view.lending_index_now,
+    interest_since_snapshot: view.interest_since_snapshot,
+    asset,
+    total_debt_interest: view.total_debt_interest,
+    borrow_index_snapshot: view.borrow_index_snapshot,
+    debt_native_now: view.debt_native_now,
+    borrow_index_now: view.borrow_index_now,
+    lending_index_snapshot: view.lending_index_snapshot,
+    debt_scaled: view.debt_scaled,
+    total_earned_interest: view.total_earned_interest,
+    deposit_scaled: view.deposit_scaled,
+    earned_since_snapshot: view.earned_since_snapshot,
+    deposited_native_now: view.deposited_native_now,
+    pool_id: view.pool_id,
+    last_update: view.last_update,
+    user_profile: view.user_profile
+  };
+}
+function decodeFlexibleUserStats(stats) {
+  return {
+    debt: stats.debt,
+    collateral: stats.collateral,
+    acumulated_interest: stats.acumulated_interest,
+    borrowing_power: stats.borrowing_power,
+    positions: stats.positions.map(decodeFlexiblePosition).filter((position) => position !== null),
+    weighted_liquidation_threshold: stats.weighted_liquidation_threshold
+  };
+}
 
 // src/modules/market/mappers.ts
 var DECIMAL_BASE = 10;
 var PAIR_SEPARATOR = "_";
 var USDT_SYMBOL = "USDT";
-function mapLendingPoolRecordToPool(pool, rate) {
-  const asset = getVariantKey(pool.asset);
+function mapDecodedPoolToPool(pool, rate) {
   const totalSupply = pool.total_supply_at_last_sync;
   const totalDebt = pool.total_debt_at_last_sync;
   const availableLiquidity = totalSupply > totalDebt ? totalSupply - totalDebt : 0n;
   return {
     id: pool.principal.toString(),
-    asset,
-    chain: getVariantKey(pool.chain),
-    decimals: getAssetNativeDecimals(asset),
+    asset: pool.asset,
+    chain: pool.chain,
+    decimals: getAssetNativeDecimals(pool.asset),
     frozen: pool.frozen,
     totalSupply,
     totalDebt,
@@ -5600,13 +5951,14 @@ var MarketModule = class {
   async listPools() {
     void this.apiClient;
     try {
-      const lendingActor = createLendingActor(this.canisterContext);
-      const lendingPools = await lendingActor.list_pools();
+      const flexibleActor = createFlexibleLendingActor(this.canisterContext);
+      const rawPools = await flexibleActor.list_pools();
+      const decodedPools = rawPools.map(decodeFlexiblePool).filter((pool) => pool !== null);
       return await Promise.all(
-        lendingPools.map(async (pool) => {
-          const poolRate = await lendingActor.get_pool_rate(pool.principal);
+        decodedPools.map(async (pool) => {
+          const poolRate = await flexibleActor.get_pool_rate(pool.principal);
           const resolvedPoolRate = poolRate[0] ?? ZERO_POOL_RATE;
-          return mapLendingPoolRecordToPool(pool, resolvedPoolRate);
+          return mapDecodedPoolToPool(pool, resolvedPoolRate);
         })
       );
     } catch (error) {
@@ -5711,12 +6063,11 @@ var MarketModule = class {
 
 // src/modules/positions/mappers.ts
 var USD_VALUE_SCALE_DECIMALS = 27n;
-function mapPositionViewToPosition(view) {
-  const asset = getVariantKey(view.asset);
-  const nativeDecimals = getAssetNativeDecimals(asset);
+function mapDecodedPositionViewToPosition(view) {
+  const nativeDecimals = getAssetNativeDecimals(view.asset);
   return {
     poolId: view.pool_id.toText(),
-    asset,
+    asset: view.asset,
     deposited: view.deposited_native_now,
     depositedDecimals: nativeDecimals,
     borrowed: view.debt_native_now,
@@ -5733,15 +6084,18 @@ function mapBorrowingPowerRecordToBorrowingPower(record) {
     maxBorrowableUsdDecimals: USD_VALUE_SCALE_DECIMALS
   };
 }
-function mapUserStatsRecordToUserStats(record) {
+function mapDecodedUserStatsToUserStats(stats) {
+  return mapUserStatsLikeToUserStats(stats);
+}
+function mapUserStatsLikeToUserStats(stats) {
   return {
-    debt: record.debt,
+    debt: stats.debt,
     debtDecimals: USD_VALUE_SCALE_DECIMALS,
-    collateral: record.collateral,
+    collateral: stats.collateral,
     collateralDecimals: USD_VALUE_SCALE_DECIMALS,
-    weightedLiquidationThreshold: record.weighted_liquidation_threshold,
+    weightedLiquidationThreshold: stats.weighted_liquidation_threshold,
     borrowingPower: mapBorrowingPowerRecordToBorrowingPower(
-      record.borrowing_power
+      stats.borrowing_power
     )
   };
 }
@@ -5765,14 +6119,18 @@ var PositionsModule = class {
    */
   async getPosition(profileId, poolId) {
     try {
-      const result = await createLendingActor(
+      const result = await createFlexibleLendingActor(
         this.canisterContext
       ).get_position(Principal.fromText(profileId), Principal.fromText(poolId));
       const view = result[0];
       if (!view) {
         return null;
       }
-      return mapPositionViewToPosition(view);
+      const decodedView = decodeFlexiblePositionView(view);
+      if (!decodedView) {
+        return null;
+      }
+      return mapDecodedPositionViewToPosition(decodedView);
     } catch (error) {
       if (error instanceof LiquidiumError) {
         throw error;
@@ -5788,15 +6146,16 @@ var PositionsModule = class {
    */
   async listPositions(profileId) {
     try {
-      const actor = createLendingActor(this.canisterContext);
+      const actor = createFlexibleLendingActor(this.canisterContext);
       const profilePrincipal = Principal.fromText(profileId);
       const stats = await actor.get_profile_stats(profilePrincipal);
+      const decodedStats = decodeFlexibleUserStats(stats);
       const positionViews = await Promise.all(
-        stats.positions.map(
+        decodedStats.positions.map(
           (position) => actor.get_position(profilePrincipal, position.pool_id)
         )
       );
-      return positionViews.map((result) => result[0]).filter((view) => view !== void 0).map(mapPositionViewToPosition);
+      return positionViews.map((result) => result[0]).filter((view) => view !== void 0).map(decodeFlexiblePositionView).filter((view) => view !== null).map(mapDecodedPositionViewToPosition);
     } catch (error) {
       if (error instanceof LiquidiumError) {
         throw error;
@@ -5812,12 +6171,14 @@ var PositionsModule = class {
    */
   async getHealthFactor(profileId) {
     try {
-      const [healthFactor, userStatsRecord] = await createLendingActor(
+      const [healthFactor, userStatsRecord] = await createFlexibleLendingActor(
         this.canisterContext
       ).get_health_factor(Principal.fromText(profileId));
       return {
         healthFactor,
-        userStats: mapUserStatsRecordToUserStats(userStatsRecord)
+        userStats: mapDecodedUserStatsToUserStats(
+          decodeFlexibleUserStats(userStatsRecord)
+        )
       };
     } catch (error) {
       if (error instanceof LiquidiumError) {
@@ -5834,10 +6195,10 @@ var PositionsModule = class {
    */
   async getUserStats(profileId) {
     try {
-      const result = await createLendingActor(
+      const result = await createFlexibleLendingActor(
         this.canisterContext
       ).get_profile_stats(Principal.fromText(profileId));
-      return mapUserStatsRecordToUserStats(result);
+      return mapDecodedUserStatsToUserStats(decodeFlexibleUserStats(result));
     } catch (error) {
       if (error instanceof LiquidiumError) {
         throw error;
@@ -5906,7 +6267,7 @@ var PositionsModule = class {
           pool,
           priceUsd,
           suppliedUsd: nativeAmountToUsdScaled(
-            position.deposited + position.earnedInterest,
+            position.deposited,
             position.depositedDecimals,
             priceUsd
           ),
@@ -5941,6 +6302,24 @@ var PositionsModule = class {
     const buffered = rawDebt * (BPS_SCALE + bufferBps) / BPS_SCALE;
     return { amount: buffered, decimals: position.borrowedDecimals };
   }
+  /**
+   * Returns the current full withdraw amount for a position.
+   *
+   * `Position.deposited` already reflects the current supplied balance at the
+   * latest lending index; do not add `earnedInterest` to this amount.
+   * Pass `amount` to withdraw calls and use `decimals` for display formatting.
+   *
+   * @param profileId - The Liquidium profile principal text.
+   * @param poolId - The pool principal text.
+   * @returns Full withdraw amount in the supplied asset's base units.
+   */
+  async getFullWithdrawAmount(profileId, poolId) {
+    const position = await this.getPosition(profileId, poolId);
+    if (!position) {
+      return { amount: 0n, decimals: 0n };
+    }
+    return { amount: position.deposited, decimals: position.depositedDecimals };
+  }
 };
 function nativeAmountToUsdScaled(amount, nativeDecimals, priceUsd) {
   if (amount <= 0n || priceUsd <= 0) {