@liquidium/client 0.6.0 → 0.7.1

package/dist/index.js

@@ -45,6 +45,7 @@ var LiquidiumErrorCode = {
   WITHDRAW_TOO_LOW: "WITHDRAW_TOO_LOW",
   REPAYMENT_EXCEEDS_DEBT: "REPAYMENT_EXCEEDS_DEBT",
   INVALID_ADDRESS: "INVALID_ADDRESS",
+  CONTRACT_DESTINATION_UNSUPPORTED: "CONTRACT_DESTINATION_UNSUPPORTED",
   DEPOSIT_ADDRESS_ERROR: "DEPOSIT_ADDRESS_ERROR",
   // Transport
   NETWORK_ERROR: "NETWORK_ERROR",
@@ -1053,8 +1054,11 @@ function normalizeEvmAddress(address) {
 // src/core/utils/time.ts
 var MILLISECONDS_PER_SECOND = 1e3;
 var SIGNATURE_VALIDITY_5_MINUTES_IN_SECONDS = 5n * 60n;
+function getCurrentUnixTimestampSeconds() {
+  return BigInt(Math.floor(Date.now() / MILLISECONDS_PER_SECOND));
+}
 function computeExpiryTimestampFromNow(signatureValidityInSeconds = SIGNATURE_VALIDITY_5_MINUTES_IN_SECONDS) {
-  return BigInt(Math.floor(Date.now() / MILLISECONDS_PER_SECOND)) + signatureValidityInSeconds;
+  return getCurrentUnixTimestampSeconds() + signatureValidityInSeconds;
 }
 
 // src/core/utils/variant.ts
@@ -1274,6 +1278,31 @@ var AccountsModule = class {
       throw mapCanisterCallErrorToLiquidiumError("get_wallet_profile", error);
     }
   }
+  /**
+   * Checks whether a profile is registered with the protocol.
+   *
+   * Production profile registration always links an initial wallet, and the
+   * protocol prevents removal of a profile's final wallet. This method uses
+   * that invariant because the current canister API has no direct existence
+   * query.
+   *
+   * @param profileId - The Liquidium profile principal text.
+   * @returns `true` when the profile has at least one linked wallet.
+   */
+  async profileExists(profileId) {
+    try {
+      const profilePrincipal = parseProfilePrincipal(profileId);
+      const wallets = await createLendingActor(
+        this.canisterContext
+      ).get_profile_wallets(profilePrincipal);
+      return wallets.length > 0;
+    } catch (error) {
+      if (error instanceof LiquidiumError) {
+        throw error;
+      }
+      throw mapCanisterCallErrorToLiquidiumError("get_profile_wallets", error);
+    }
+  }
   /**
    * Returns the current nonce for a wallet address.
    *
@@ -1379,6 +1408,17 @@ var AccountsModule = class {
 function normalizeProfileAccount(account) {
   return normalizeEvmAddress(account);
 }
+function parseProfilePrincipal(profileId) {
+  try {
+    return Principal.fromText(profileId);
+  } catch (error) {
+    throw new LiquidiumError(
+      LiquidiumErrorCode.VALIDATION_ERROR,
+      `Invalid profile id: ${profileId}`,
+      error
+    );
+  }
+}
 function createInitializeAccountMessage(expiryTimestamp, nonce) {
   return `Liquidium: Initialize Account
 
@@ -1742,19 +1782,29 @@ var SdkApiQueryParam = {
   to: "to"
 };
 var ACTIVITIES = `${SDK_API_V2_PATH}/activities`;
+var HISTORY_ACTIVITIES = `${SDK_API_V2_PATH}/history/activities`;
 var HISTORY_USERS = `${SDK_API_V2_PATH}/history/users`;
 var INFLOW = `${SDK_API_V2_PATH}/inflow`;
 var SIMPLE_LOANS = `${SDK_API_V1_PATH}/instant-loans`;
-function buildHistoryUserTransactionsPath(user, query) {
-  const base = `${HISTORY_USERS}/${encodeURIComponent(user)}/transactions`;
+function buildEthereumAddressBytecodePath(request) {
+  return `${SDK_API_V2_PATH}/ethereum/addresses/${encodeURIComponent(
+    request.address
+  )}/bytecode`;
+}
+function buildHistoryUserTransactionsPath(profileId, query) {
+  const base = `${HISTORY_USERS}/${encodeURIComponent(profileId)}/transactions`;
   const qs = query.toString();
   return qs ? `${base}?${qs}` : base;
 }
-function buildHistoryUserLiquidationsPath(user, query) {
-  const base = `${HISTORY_USERS}/${encodeURIComponent(user)}/liquidations`;
+function buildHistoryUserLiquidationsPath(profileId, query) {
+  const base = `${HISTORY_USERS}/${encodeURIComponent(profileId)}/liquidations`;
   const qs = query.toString();
   return qs ? `${base}?${qs}` : base;
 }
+function buildProtocolActivityPath(query) {
+  const qs = query.toString();
+  return qs ? `${HISTORY_ACTIVITIES}?${qs}` : HISTORY_ACTIVITIES;
+}
 function buildActivitiesPath(request) {
   const query = new URLSearchParams({
     [SdkApiQueryParam.profileId]: request.profileId
@@ -2053,6 +2103,9 @@ function mapActivityTopUp(wire) {
 }
 
 // src/modules/history/history.ts
+var MIN_HISTORY_LIMIT = 1;
+var MAX_USER_HISTORY_LIMIT = 200;
+var MAX_PROTOCOL_ACTIVITY_LIMIT = 100;
 var HistoryModule = class {
   constructor(apiClient) {
     this.apiClient = apiClient;
@@ -2070,11 +2123,11 @@ var HistoryModule = class {
   /**
    * Returns transaction history for a user.
    *
-   * @param user - The Liquidium profile principal text.
+   * @param profileId - The Liquidium profile principal text.
    * @param filters - Optional pool, operation, state, time range, and pagination filters.
    * @returns Paginated user history entries.
    */
-  async getUserTransactionHistory(user, filters = {}) {
+  async getUserTransactionHistory(profileId, filters = {}) {
     const apiClient = this.requireApi();
     const query = new URLSearchParams();
     if (filters.cursor) {
@@ -2102,9 +2155,10 @@ var HistoryModule = class {
       query.set(SdkApiQueryParam.to, filters.to);
     }
     if (filters.limit !== void 0) {
+      validateHistoryLimit(filters.limit, MAX_USER_HISTORY_LIMIT);
       query.set(SdkApiQueryParam.limit, String(filters.limit));
     }
-    const requestPath = buildHistoryUserTransactionsPath(user, query);
+    const requestPath = buildHistoryUserTransactionsPath(profileId, query);
     const response = await apiClient.get(requestPath);
     return {
       items: response.items.map(mapUserTransactionHistoryEntry),
@@ -2114,11 +2168,11 @@ var HistoryModule = class {
   /**
    * Returns liquidation history for a user.
    *
-   * @param user - The Liquidium profile principal text.
+   * @param profileId - The Liquidium profile principal text.
    * @param filters - Optional pool, time range, and pagination filters.
    * @returns Paginated liquidation history entries.
    */
-  async getLiquidationHistory(user, filters = {}) {
+  async getLiquidationHistory(profileId, filters = {}) {
     const apiClient = this.requireApi();
     const query = new URLSearchParams();
     if (filters.cursor) {
@@ -2137,16 +2191,52 @@ var HistoryModule = class {
       query.set(SdkApiQueryParam.to, filters.to);
     }
     if (filters.limit !== void 0) {
+      validateHistoryLimit(filters.limit, MAX_USER_HISTORY_LIMIT);
       query.set(SdkApiQueryParam.limit, String(filters.limit));
     }
-    const requestPath = buildHistoryUserLiquidationsPath(user, query);
+    const requestPath = buildHistoryUserLiquidationsPath(profileId, query);
     const response = await apiClient.get(requestPath);
     return {
       items: response.items.map(mapUserLiquidationHistoryEntry),
       nextCursor: response.nextCursor
     };
   }
+  /**
+   * Returns recent protocol-wide lending activity across all users.
+   *
+   * @param filters - Optional pool, operation, and limit filters.
+   * @returns Recent confirmed lending activity entries.
+   */
+  async getProtocolActivity(filters = {}) {
+    const apiClient = this.requireApi();
+    const query = new URLSearchParams();
+    if (filters.poolId) {
+      query.set(SdkApiQueryParam.poolId, filters.poolId);
+    }
+    if (filters.operations?.length) {
+      query.set(SdkApiQueryParam.operations, filters.operations.join(","));
+    }
+    if (filters.limit !== void 0) {
+      validateHistoryLimit(filters.limit, MAX_PROTOCOL_ACTIVITY_LIMIT);
+      query.set(SdkApiQueryParam.limit, String(filters.limit));
+    }
+    const requestPath = buildProtocolActivityPath(query);
+    const response = await apiClient.get(requestPath);
+    return response.items.map(mapProtocolActivityEntry);
+  }
 };
+function mapProtocolActivityEntry(item) {
+  return {
+    id: item.id,
+    operation: item.operation,
+    poolId: item.poolId,
+    asset: item.asset,
+    decimals: item.decimals,
+    amount: parseBigInt(item.amount, "protocol activity amount"),
+    timestamp: item.timestamp,
+    txids: item.txids
+  };
+}
 function mapUserTransactionHistoryEntry(item) {
   return {
     id: item.id,
@@ -2169,7 +2259,12 @@ function mapUserLiquidationHistoryEntry(item) {
     amount: parseBigInt(item.amount, "history user amount"),
     poolId: item.poolId,
     timestamp: item.timestamp,
-    status: item.status,
+    status: {
+      operation: "liquidation",
+      state: "completed",
+      confirmations: null,
+      requiredConfirmations: null
+    },
     txids: item.txids
   };
 }
@@ -2194,6 +2289,15 @@ function validateHistoryStateFilter(state) {
       );
   }
 }
+function validateHistoryLimit(limit, maximumLimit) {
+  if (Number.isInteger(limit) && limit >= MIN_HISTORY_LIMIT && limit <= maximumLimit) {
+    return;
+  }
+  throw new LiquidiumError(
+    LiquidiumErrorCode.VALIDATION_ERROR,
+    `History limit must be an integer between ${MIN_HISTORY_LIMIT} and ${maximumLimit}`
+  );
+}
 
 // src/core/utils/inflow-subaccount.ts
 var INFLOW_DEPOSIT_PREFIX = 1;
@@ -3243,6 +3347,71 @@ function accountTypeToString(accountType) {
       return `Principal:${accountType.data}`;
   }
 }
+var EMPTY_EVM_BYTECODE = "0x";
+var LAST_ETHEREUM_MAINNET_PRECOMPILE_ADDRESS = 0x11n;
+var CONTRACT_DESTINATION_UNSUPPORTED_MESSAGE = "Contract addresses are not supported for native ETH withdrawals or borrowing";
+var RESERVED_DESTINATION_MESSAGE = "Ethereum outflow destination must not be the zero address or a precompile";
+async function guardEthereumOutflowDestination({
+  address,
+  apiClient,
+  asset,
+  chain,
+  evmReadClient
+}) {
+  if (chain !== Chain.ETH) {
+    return;
+  }
+  const normalizedAddress = getAddress(address);
+  if (BigInt(normalizedAddress) <= LAST_ETHEREUM_MAINNET_PRECOMPILE_ADDRESS) {
+    throw new LiquidiumError(
+      LiquidiumErrorCode.INVALID_ADDRESS,
+      RESERVED_DESTINATION_MESSAGE
+    );
+  }
+  if (asset !== Asset.ETH) {
+    return;
+  }
+  if (evmReadClient?.chain?.id === mainnet.id && evmReadClient.getCode) {
+    let bytecode;
+    try {
+      bytecode = await evmReadClient.getCode({
+        address: normalizedAddress
+      });
+    } catch {
+      return;
+    }
+    if (bytecode === void 0 || bytecode === EMPTY_EVM_BYTECODE) {
+      return;
+    }
+    if (typeof bytecode !== "string" || !/^0x(?:[0-9a-fA-F]{2})*$/.test(bytecode)) {
+      return;
+    }
+    throw new LiquidiumError(
+      LiquidiumErrorCode.CONTRACT_DESTINATION_UNSUPPORTED,
+      CONTRACT_DESTINATION_UNSUPPORTED_MESSAGE
+    );
+  }
+  if (!apiClient) {
+    return;
+  }
+  let response;
+  try {
+    response = await apiClient.get(
+      buildEthereumAddressBytecodePath({ address: normalizedAddress })
+    );
+  } catch {
+    return;
+  }
+  if (!response || typeof response !== "object" || !("hasDeployedBytecode" in response) || typeof response.hasDeployedBytecode !== "boolean") {
+    return;
+  }
+  if (response.hasDeployedBytecode) {
+    throw new LiquidiumError(
+      LiquidiumErrorCode.CONTRACT_DESTINATION_UNSUPPORTED,
+      CONTRACT_DESTINATION_UNSUPPORTED_MESSAGE
+    );
+  }
+}
 
 // src/core/pool-ledger-assets.ts
 function getPoolLedgerAssetRoute(params) {
@@ -4625,6 +4794,13 @@ var LendingModule = class {
       poolChain: selectedPool.chain,
       destinationChain: request.chain
     });
+    await guardEthereumOutflowDestination({
+      address: receiver.address,
+      apiClient: this.apiClient,
+      asset: selectedAsset,
+      chain: request.chain,
+      evmReadClient: this.evmReadClient
+    });
     const lendingActor = createLendingActor(this.canisterContext);
     try {
       const expiryTimestamp = computeExpiryTimestampFromNow();
@@ -4643,7 +4819,9 @@ var LendingModule = class {
       };
       const withdrawSubmissionData = {
         ...withdrawActionData,
-        receiverAccount: receiver.canisterAccount
+        asset: selectedAsset,
+        receiverAccount: receiver.canisterAccount,
+        receiverAddress: receiver.address
       };
       return {
         kind: WalletActionKind.createWithdraw,
@@ -4675,6 +4853,13 @@ var LendingModule = class {
     }
   }
   async submitWithdraw(request, signatureInfo) {
+    await guardEthereumOutflowDestination({
+      address: request.receiverAddress,
+      apiClient: this.apiClient,
+      asset: request.asset,
+      chain: request.chain,
+      evmReadClient: this.evmReadClient
+    });
     try {
       const result = await createLendingActor(this.canisterContext).withdraw(
         Principal.fromText(request.profileId),
@@ -4779,6 +4964,13 @@ var LendingModule = class {
       poolChain: selectedPool.chain,
       destinationChain: request.chain
     });
+    await guardEthereumOutflowDestination({
+      address: receiver.address,
+      apiClient: this.apiClient,
+      asset: selectedAsset,
+      chain: request.chain,
+      evmReadClient: this.evmReadClient
+    });
     await this.guardBorrowSameAssetPolicy({
       profileId: request.profileId,
       pool: selectedPool
@@ -4801,7 +4993,9 @@ var LendingModule = class {
       };
       const borrowSubmissionData = {
         ...borrowActionData,
-        receiverAccount: receiver.canisterAccount
+        asset: selectedAsset,
+        receiverAccount: receiver.canisterAccount,
+        receiverAddress: receiver.address
       };
       return {
         kind: WalletActionKind.createBorrow,
@@ -4830,6 +5024,13 @@ var LendingModule = class {
     }
   }
   async submitBorrow(request, signatureInfo) {
+    await guardEthereumOutflowDestination({
+      address: request.receiverAddress,
+      apiClient: this.apiClient,
+      asset: request.asset,
+      chain: request.chain,
+      evmReadClient: this.evmReadClient
+    });
     try {
       const result = await createLendingActor(
         this.canisterContext
@@ -5149,9 +5350,78 @@ function mapOutflowTypeToStatusOperation(outflowType) {
   return outflowType;
 }
 
+// src/core/asset-metadata.ts
+var ASSET_METADATA = {
+  [Asset.BTC]: {
+    symbol: Asset.BTC,
+    displayName: "Bitcoin"
+  },
+  [Asset.ETH]: {
+    symbol: Asset.ETH,
+    displayName: "Ethereum"
+  },
+  [Asset.ICP]: {
+    symbol: Asset.ICP,
+    displayName: "Internet Computer"
+  },
+  [Asset.USDC]: {
+    symbol: Asset.USDC,
+    displayName: "USD Coin"
+  },
+  [Asset.USDT]: {
+    symbol: Asset.USDT,
+    displayName: "Tether USD"
+  }
+};
+function getAssetMetadata(asset) {
+  return ASSET_METADATA[asset];
+}
+
 // src/core/rates.ts
 var RATE_SCALE = 1000000000000000000000000000n;
 var RATE_DECIMALS = BigInt(RATE_SCALE.toString().length - 1);
+var INTEREST_YEAR_365_DAYS_SECONDS = 31536000n;
+var SUPPLY_COMPOUNDING_INTERVAL_15_SECONDS = 15n;
+function estimateBorrowApy(borrowApr) {
+  return estimateCompoundedApy(borrowApr, 1n);
+}
+function estimateSupplyApy(supplyApr) {
+  return estimateCompoundedApy(
+    supplyApr,
+    SUPPLY_COMPOUNDING_INTERVAL_15_SECONDS
+  );
+}
+function estimateCompoundedApy(apr, compoundingIntervalSeconds) {
+  if (apr < 0n) {
+    throw new RangeError("APR cannot be negative");
+  }
+  if (apr === 0n) {
+    return 0n;
+  }
+  const periodsPerYear = INTEREST_YEAR_365_DAYS_SECONDS / compoundingIntervalSeconds;
+  const ratePerPeriod = apr * compoundingIntervalSeconds / INTEREST_YEAR_365_DAYS_SECONDS;
+  const annualGrowth = fixedPointPow(
+    RATE_SCALE + ratePerPeriod,
+    periodsPerYear
+  );
+  return annualGrowth - RATE_SCALE;
+}
+function fixedPointPow(base, exponent) {
+  let remainingExponent = exponent;
+  let currentBase = base;
+  let result = RATE_SCALE;
+  while (remainingExponent > 0n) {
+    if (remainingExponent % 2n === 1n) {
+      result = fixedPointMultiply(result, currentBase);
+    }
+    currentBase = fixedPointMultiply(currentBase, currentBase);
+    remainingExponent /= 2n;
+  }
+  return result;
+}
+function fixedPointMultiply(left, right) {
+  return (left * right + RATE_SCALE / 2n) / RATE_SCALE;
+}
 
 // src/core/utils/asset-decimals.ts
 var ASSET_NATIVE_DECIMALS = {
@@ -5178,12 +5448,14 @@ var DECIMAL_BASE = 10;
 var PAIR_SEPARATOR = "_";
 var USDT_SYMBOL = "USDT";
 function mapDecodedPoolToPool(pool, rate) {
+  const assetMetadata = getAssetMetadata(pool.asset);
   const totalSupply = pool.total_supply_at_last_sync * pool.lending_index / RATE_SCALE;
   const totalDebt = pool.total_debt_at_last_sync * pool.borrow_index / RATE_SCALE;
   const availableLiquidity = totalSupply > totalDebt ? totalSupply - totalDebt : 0n;
   return {
     id: pool.principal.toString(),
     asset: pool.asset,
+    displayName: assetMetadata.displayName,
     chain: pool.chain,
     decimals: getAssetNativeDecimals(pool.asset),
     frozen: pool.frozen,
@@ -5199,7 +5471,9 @@ function mapDecodedPoolToPool(pool, rate) {
     reserveFactor: pool.reserve_factor,
     rateDecimals: RATE_DECIMALS,
     lendingRate: rate[1],
+    estimatedLendingApy: estimateSupplyApy(rate[1]),
     borrowingRate: rate[0],
+    estimatedBorrowingApy: estimateBorrowApy(rate[0]),
     utilizationRate: rate[2],
     baseRate: pool.base_rate,
     optimalUtilizationRate: pool.optimal_utilization_rate,
@@ -5233,7 +5507,9 @@ function mapGetPoolRateResponseToPoolRate(rate) {
   return {
     rateDecimals: RATE_DECIMALS,
     borrowRate: rate[0],
+    estimatedBorrowApy: estimateBorrowApy(rate[0]),
     lendRate: rate[1],
+    estimatedLendApy: estimateSupplyApy(rate[1]),
     utilizationRate: rate[2]
   };
 }
@@ -5287,15 +5563,32 @@ var MarketModule = class {
     }
   }
   /**
-   * Returns the latest asset prices reported by the protocol.
+   * Returns the current cached asset prices reported by the protocol.
    *
-   * @returns The latest protocol price map keyed by market asset symbol.
+   * @returns The current protocol price map keyed by market asset symbol.
    */
   async getAssetPrices() {
+    return (await this.getAssetPriceSnapshot()).prices;
+  }
+  /**
+   * Returns protocol prices with the time at which the SDK completed the fetch.
+   *
+   * `fetchedAt` is an SDK retrieval time, not an oracle observation timestamp.
+   * The current lending canister price response does not expose the underlying
+   * oracle timestamp.
+   *
+   * @returns Protocol prices and their SDK fetch timestamp.
+   */
+  async getAssetPriceSnapshot() {
     try {
-      return mapGetPricesResponseToAssetPrices(
+      const prices = mapGetPricesResponseToAssetPrices(
         await createLendingActor(this.canisterContext).get_prices()
       );
+      const fetchedAtUnixSeconds = getCurrentUnixTimestampSeconds();
+      return {
+        prices,
+        fetchedAt: fetchedAtUnixSeconds
+      };
     } catch (error) {
       if (error instanceof LiquidiumError) {
         throw error;
@@ -5397,6 +5690,10 @@ function decodeSupportedFlexiblePools(rawPools) {
   return decodedPools;
 }
 
+// src/modules/positions/health-factor.ts
+var HEALTH_FACTOR_SCALE = 1000n;
+var HEALTH_FACTOR_DECIMALS = 3n;
+
 // src/modules/positions/mappers.ts
 var USD_VALUE_SCALE_DECIMALS = 27n;
 function mapDecodedPositionViewToPosition(view) {
@@ -5525,11 +5822,13 @@ var PositionsModule = class {
       const [healthFactor, userStatsRecord] = await createFlexibleLendingActor(
         this.canisterContext
       ).get_health_factor(Principal.fromText(profileId));
+      const userStats = mapDecodedUserStatsToUserStats(
+        decodeFlexibleUserStats(userStatsRecord)
+      );
       return {
-        healthFactor,
-        userStats: mapDecodedUserStatsToUserStats(
-          decodeFlexibleUserStats(userStatsRecord)
-        )
+        healthFactor: userStats.debt === 0n ? null : healthFactor,
+        healthFactorDecimals: HEALTH_FACTOR_DECIMALS,
+        userStats
       };
     } catch (error) {
       if (error instanceof LiquidiumError) {
@@ -5569,7 +5868,7 @@ var PositionsModule = class {
    * @returns Derived position summary for the requested profile.
    */
   async getUserPositionSummary(profileId) {
-    const { healthFactor, userStats } = await this.getHealthFactor(profileId);
+    const { healthFactor, healthFactorDecimals, userStats } = await this.getHealthFactor(profileId);
     const collateral = userStats.collateral;
     const debt = userStats.debt;
     const maxBorrowableUsd = userStats.borrowingPower.maxBorrowableUsd;
@@ -5585,7 +5884,8 @@ var PositionsModule = class {
       currentLtvBps,
       weightedMaxLtvBps: userStats.borrowingPower.weightedMaxLtv,
       weightedLiquidationThresholdBps: userStats.weightedLiquidationThreshold,
-      healthFactor
+      healthFactor,
+      healthFactorDecimals
     };
   }
   /**
@@ -6869,9 +7169,9 @@ function isSimpleLoanDepositExpired(input) {
   if (input.expiryTimestamp === null) {
     return false;
   }
-  return input.expiryTimestamp <= getCurrentUnixTimestampSeconds();
+  return input.expiryTimestamp <= getCurrentUnixTimestampSeconds2();
 }
-function getCurrentUnixTimestampSeconds() {
+function getCurrentUnixTimestampSeconds2() {
   return BigInt(Math.floor(Date.now() / MILLISECONDS_PER_SECOND3));
 }
 function deriveDepositExpiryTimestamp(input) {
@@ -7472,6 +7772,6 @@ function resolveEvmReadClient(config) {
   });
 }
 
-export { AccountsModule, ActivitiesModule, ActivityFilter, Asset, CK_ETH_DEPOSIT_CONTRACT_ADDRESS, Chain, Environment, EvmSupplyApprovalStrategy, HistoryModule, LendingModule, LiquidiumAccountType, LiquidiumClient, LiquidiumError, LiquidiumErrorCode, MIN_BORROW_AMOUNTS_BY_ASSET, MIN_DEPOSIT_AMOUNTS_BY_ASSET, MIN_WITHDRAW_AMOUNTS_BY_ASSET, MarketModule, OutflowType, PositionsModule, QuoteModule, QuoteValidationErrorCode, QuoteWarningCode, RATE_DECIMALS, RATE_SCALE, SimpleLoanCreatedError, SimpleLoansModule, SupplyAction, SupplyPlanType, USDC_CONTRACT_ADDRESS, USDT_CONTRACT_ADDRESS, WalletActionKind, WalletExecutionKind, createTransferErc20Transaction, executeWith, getMinimumBorrowAmount, getMinimumDepositAmount, getMinimumWithdrawAmount, intFromPublicId, isAssetIdentifier, publicIdFromInt };
+export { ASSET_METADATA, AccountsModule, ActivitiesModule, ActivityFilter, Asset, CK_ETH_DEPOSIT_CONTRACT_ADDRESS, Chain, Environment, EvmSupplyApprovalStrategy, HEALTH_FACTOR_DECIMALS, HEALTH_FACTOR_SCALE, HistoryModule, INTEREST_YEAR_365_DAYS_SECONDS, LendingModule, LiquidiumAccountType, LiquidiumClient, LiquidiumError, LiquidiumErrorCode, MIN_BORROW_AMOUNTS_BY_ASSET, MIN_DEPOSIT_AMOUNTS_BY_ASSET, MIN_WITHDRAW_AMOUNTS_BY_ASSET, MarketModule, OutflowType, PositionsModule, QuoteModule, QuoteValidationErrorCode, QuoteWarningCode, RATE_DECIMALS, RATE_SCALE, SUPPLY_COMPOUNDING_INTERVAL_15_SECONDS, SimpleLoanCreatedError, SimpleLoansModule, SupplyAction, SupplyPlanType, USDC_CONTRACT_ADDRESS, USDT_CONTRACT_ADDRESS, WalletActionKind, WalletExecutionKind, createTransferErc20Transaction, estimateBorrowApy, estimateSupplyApy, executeWith, getAssetMetadata, getMinimumBorrowAmount, getMinimumDepositAmount, getMinimumWithdrawAmount, intFromPublicId, isAssetIdentifier, publicIdFromInt };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map