@liquidium/client 0.3.0 → 0.3.2

package/dist/index.cjs

@@ -4,6 +4,8 @@ var viem = require('viem');
 var chains = require('viem/chains');
 var agent = require('@icp-sdk/core/agent');
 var principal = require('@icp-sdk/core/principal');
+var base = require('@scure/base');
+var candid = require('@icp-sdk/core/candid');
 var ledgerIcrc = require('@dfinity/ledger-icrc');
 var principal$1 = require('@dfinity/principal');
 var bitcoinAddressValidation = require('bitcoin-address-validation');
@@ -1065,17 +1067,68 @@ function executeWith(options) {
     }
   };
 }
-
-// src/core/utils/signature.ts
+var HEX_PREFIX = "0x";
+var HEX_BYTE_CHAR_LENGTH = 2;
+var BASE64_PADDING = "=";
+function normalizeWalletSignature(signature, chain) {
+  switch (chain) {
+    case Chain.BTC:
+      return normalizeBtcSignature(signature);
+    case Chain.ETH:
+      return normalizeHexSignature(signature);
+  }
+}
 function normalizeHexSignature(signature) {
-  if (!signature.startsWith("0x")) {
+  if (!isPrefixedHex(signature)) {
     return signature;
   }
-  const signatureWithoutPrefix = signature.slice(2);
-  if (!/^[0-9a-fA-F]+$/.test(signatureWithoutPrefix)) {
-    return signature;
+  return signature.slice(HEX_PREFIX.length);
+}
+function normalizeBtcSignature(signature) {
+  const signatureWithoutPrefix = signature.startsWith(HEX_PREFIX) ? signature.slice(HEX_PREFIX.length) : signature;
+  if (isHexBytes(signatureWithoutPrefix)) {
+    return signatureWithoutPrefix;
+  }
+  if (signature.startsWith(HEX_PREFIX)) {
+    throw invalidBtcSignatureFormatError();
+  }
+  return bytesToUnprefixedHex(decodeBase64Signature(signature));
+}
+function isHexBytes(signature) {
+  return signature.length > 0 && signature.length % HEX_BYTE_CHAR_LENGTH === 0 && viem.isHex(`${HEX_PREFIX}${signature}`);
+}
+function decodeBase64Signature(signature) {
+  try {
+    const bytes = decodeBase64Bytes(signature);
+    if (bytes.length === 0) {
+      throw invalidBtcSignatureFormatError();
+    }
+    return bytes;
+  } catch (error) {
+    if (error instanceof LiquidiumError) {
+      throw error;
+    }
+    throw invalidBtcSignatureFormatError(error);
   }
-  return signatureWithoutPrefix;
+}
+function bytesToUnprefixedHex(bytes) {
+  return normalizeHexSignature(viem.bytesToHex(bytes));
+}
+function isPrefixedHex(signature) {
+  return signature.length > HEX_PREFIX.length && viem.isHex(signature);
+}
+function decodeBase64Bytes(signature) {
+  if (signature.includes(BASE64_PADDING)) {
+    return base.base64.decode(signature);
+  }
+  return base.base64nopad.decode(signature);
+}
+function invalidBtcSignatureFormatError(cause) {
+  return new LiquidiumError(
+    LiquidiumErrorCode.SIGNATURE_ERROR,
+    "BTC signature must be hex or base64-encoded bytes",
+    cause
+  );
 }
 
 // src/modules/accounts/mappers.ts
@@ -1093,7 +1146,10 @@ function mapCreateAccountRequestToRegisterProfileRequest(request) {
     },
     signature_info: {
       Wallet: {
-        signature: normalizeHexSignature(request.signatureInfo.signature),
+        signature: normalizeWalletSignature(
+          request.signatureInfo.signature,
+          request.signatureInfo.chain
+        ),
         chain: mapAccountChainToLendingChainVariant(
           request.signatureInfo.chain
         ),
@@ -1307,17 +1363,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 (candid.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,
@@ -1388,13 +1462,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({
@@ -1410,7 +1484,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,
@@ -1418,7 +1492,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,
@@ -1469,7 +1543,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,
@@ -1480,7 +1554,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 });
@@ -1508,7 +1582,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(
@@ -1516,10 +1590,84 @@ function createInstantLoansActor(canisterContext) {
       "Instant loans canister ID is not configured"
     );
   }
-  return agent.Actor.createActor(idlFactory2, {
-    agent: canisterContext.agent,
-    canisterId
-  });
+  return agent.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
@@ -1809,7 +1957,7 @@ var ActivitiesModule = class {
       );
     }
     try {
-      const result = await createInstantLoansActor(
+      const result = await createFlexibleInstantLoansActor(
         this.canisterContext
       ).get_loan(loanId);
       if ("Err" in result) {
@@ -2278,7 +2426,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),
@@ -2658,14 +2806,14 @@ var idlFactory3 = ({ IDL }) => {
 // src/core/canisters/ckbtc/minter.ts
 function createCkBtcMinterActor(canisterContext) {
   const canisterId = CK_CANISTER_IDS.btcMinter;
-  return agent.Actor.createActor(idlFactory3, {
+  return agent.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,
@@ -2885,7 +3033,7 @@ function createDepositAccountsActor(canisterContext) {
       "ETH deposit canister ID is not configured"
     );
   }
-  return agent.Actor.createActor(idlFactory4, {
+  return agent.Actor.createActor(idlFactory3, {
     agent: canisterContext.agent,
     canisterId
   });
@@ -3771,7 +3919,7 @@ var InstantLoansModule = class {
    */
   async getConfig() {
     try {
-      const config = await createInstantLoansActor(
+      const config = await createFlexibleInstantLoansActor(
         this.canisterContext
       ).get_config();
       return {
@@ -3789,10 +3937,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);
     }
@@ -3805,10 +3954,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);
     }
@@ -3820,7 +3969,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());
@@ -3835,7 +3984,7 @@ var InstantLoansModule = class {
    */
   async countWarmedProfiles() {
     try {
-      return await createInstantLoansActor(
+      return await createFlexibleInstantLoansActor(
         this.canisterContext
       ).count_warmed_profiles();
     } catch (error) {
@@ -3852,7 +4001,7 @@ var InstantLoansModule = class {
    */
   async listWarmedProfiles() {
     try {
-      const profiles = await createInstantLoansActor(
+      const profiles = await createFlexibleInstantLoansActor(
         this.canisterContext
       ).list_warmed_profiles();
       return profiles.map(mapWarmedProfile);
@@ -3869,13 +4018,20 @@ var InstantLoansModule = class {
   }
   async getLoanRecord(loanId) {
     try {
-      const result = await createInstantLoansActor(
+      const result = await createFlexibleInstantLoansActor(
         this.canisterContext
       ).get_loan(loanId);
       if ("Err" in result) {
         throw mapInstantLoansErrorToLiquidiumError(result.Err);
       }
-      return result.Ok;
+      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;
@@ -3892,8 +4048,8 @@ 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),
@@ -4198,7 +4354,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),
@@ -4206,7 +4362,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) {
@@ -4284,9 +4440,6 @@ function authorizationFromCanister(authorization) {
     address: authorization.EthSignature.address
   };
 }
-function assetFromCanister(asset) {
-  return getVariantKey(asset);
-}
 function legFromCanister(leg) {
   return getVariantKey(leg);
 }
@@ -4514,12 +4667,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 agent.Actor.createActor(idlFactory5, {
+  return agent.Actor.createActor(idlFactory4, {
     agent: canisterContext.agent,
     canisterId
   });
@@ -4772,7 +4925,10 @@ var LendingModule = class {
           },
           signature_info: {
             Wallet: {
-              signature: normalizeHexSignature(signatureInfo.signature),
+              signature: normalizeWalletSignature(
+                signatureInfo.signature,
+                signatureInfo.chain
+              ),
               chain: mapWalletChainToLendingChain(signatureInfo.chain),
               account: request.signerWalletAddress
             }
@@ -4910,7 +5066,10 @@ var LendingModule = class {
         },
         signature_info: {
           Wallet: {
-            signature: normalizeHexSignature(signatureInfo.signature),
+            signature: normalizeWalletSignature(
+              signatureInfo.signature,
+              signatureInfo.chain
+            ),
             chain: mapWalletChainToLendingChain(signatureInfo.chain),
             account: request.signerWalletAddress
           }
@@ -5586,21 +5745,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 agent.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,
@@ -5673,13 +6014,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) {
@@ -5784,12 +6126,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,
@@ -5806,15 +6147,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
     )
   };
 }
@@ -5838,14 +6182,18 @@ var PositionsModule = class {
    */
   async getPosition(profileId, poolId) {
     try {
-      const result = await createLendingActor(
+      const result = await createFlexibleLendingActor(
         this.canisterContext
       ).get_position(principal.Principal.fromText(profileId), principal.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;
@@ -5861,15 +6209,16 @@ var PositionsModule = class {
    */
   async listPositions(profileId) {
     try {
-      const actor = createLendingActor(this.canisterContext);
+      const actor = createFlexibleLendingActor(this.canisterContext);
       const profilePrincipal = principal.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;
@@ -5885,12 +6234,14 @@ var PositionsModule = class {
    */
   async getHealthFactor(profileId) {
     try {
-      const [healthFactor, userStatsRecord] = await createLendingActor(
+      const [healthFactor, userStatsRecord] = await createFlexibleLendingActor(
         this.canisterContext
       ).get_health_factor(principal.Principal.fromText(profileId));
       return {
         healthFactor,
-        userStats: mapUserStatsRecordToUserStats(userStatsRecord)
+        userStats: mapDecodedUserStatsToUserStats(
+          decodeFlexibleUserStats(userStatsRecord)
+        )
       };
     } catch (error) {
       if (error instanceof LiquidiumError) {
@@ -5907,10 +6258,10 @@ var PositionsModule = class {
    */
   async getUserStats(profileId) {
     try {
-      const result = await createLendingActor(
+      const result = await createFlexibleLendingActor(
         this.canisterContext
       ).get_profile_stats(principal.Principal.fromText(profileId));
-      return mapUserStatsRecordToUserStats(result);
+      return mapDecodedUserStatsToUserStats(decodeFlexibleUserStats(result));
     } catch (error) {
       if (error instanceof LiquidiumError) {
         throw error;