@liquidium/client 0.1.2 → 0.2.1

package/dist/index.js

@@ -1,9 +1,10 @@
-import { encodeFunctionData, isAddress, getAddress, createPublicClient, http } from 'viem';
+import { encodeFunctionData, createPublicClient, http, isAddress, getAddress } from 'viem';
 import { mainnet } from 'viem/chains';
 import { Actor, HttpAgent } from '@icp-sdk/core/agent';
 import { Principal } from '@icp-sdk/core/principal';
 import { encodeIcrcAccount } from '@dfinity/ledger-icrc';
 import { Principal as Principal$1 } from '@dfinity/principal';
+import { validate, Network } from 'bitcoin-address-validation';
 
 // src/client.ts
 
@@ -57,7 +58,8 @@ function resolveCanisterIds(environment = DEFAULT_ENVIRONMENT, overrides) {
 }
 var DEFAULT_TIMEOUT_MS = 3e4;
 var CK_CANISTER_IDS = {
-  btcMinter: "mqygn-kiaaa-aaaar-qaadq-cai"};
+  btcMinter: "mqygn-kiaaa-aaaar-qaadq-cai",
+  btcLedger: "mxzaz-hqaaa-aaaar-qaada-cai"};
 
 // src/core/errors.ts
 var LiquidiumErrorCode = {
@@ -1593,6 +1595,11 @@ function buildInstantLoanAddressLookupPath(request) {
   const query = new URLSearchParams({ address: request.address });
   return `${INSTANT_LOANS}/address?${query.toString()}`;
 }
+function buildInstantLoanCollateralHintPath(request) {
+  return `${INSTANT_LOANS}/${encodeURIComponent(
+    request.loanId.toString()
+  )}/collateral-hint`;
+}
 var SdkApiPath = {
   inflow: INFLOW,
   instantLoans: INSTANT_LOANS
@@ -2215,6 +2222,24 @@ function mapHistoryStatusToApi(status) {
   return status.toUpperCase();
 }
 
+// src/core/utils/asset-decimals.ts
+var ASSET_NATIVE_DECIMALS = {
+  BTC: 8n,
+  USDC: 6n,
+  USDT: 6n,
+  SOL: 9n
+};
+function getAssetNativeDecimals(asset) {
+  const decimals = ASSET_NATIVE_DECIMALS[asset];
+  if (decimals === void 0) {
+    throw new LiquidiumError(
+      LiquidiumErrorCode.VALIDATION_ERROR,
+      `Native decimals are not configured for asset: ${asset}`
+    );
+  }
+  return decimals;
+}
+
 // src/generated/canisters/ck-btc-minter/declaration.js
 var idlFactory3 = ({ IDL }) => {
   const Mode = IDL.Variant({
@@ -3080,6 +3105,39 @@ function assertSupportsIcrcAccountInflowTarget(asset) {
   );
 }
 
+// src/core/borrow-minimums.ts
+var MIN_BORROW_AMOUNTS_BY_ASSET = {
+  BTC: 5100n,
+  // 5,100 sats = 0.000051 BTC
+  USDC: 1000000n,
+  // 1 USDC
+  USDT: 1000000n
+  // 1 USDT
+};
+function getMinimumBorrowAmount(asset) {
+  if (!isMinimumBorrowAsset(asset)) {
+    return 0n;
+  }
+  return MIN_BORROW_AMOUNTS_BY_ASSET[asset];
+}
+function getBorrowAmountMinimumValidationError(params) {
+  const minimumAmount = getMinimumBorrowAmount(params.asset);
+  if (minimumAmount <= 0n || params.amount >= minimumAmount) {
+    return null;
+  }
+  return {
+    asset: params.asset,
+    minimumAmount,
+    message: formatMinimumBorrowAmountMessage(params.asset, minimumAmount)
+  };
+}
+function formatMinimumBorrowAmountMessage(asset, minimumAmount) {
+  return `Borrow amount must be at least ${minimumAmount} base units for ${asset}`;
+}
+function isMinimumBorrowAsset(asset) {
+  return Object.hasOwn(MIN_BORROW_AMOUNTS_BY_ASSET, asset);
+}
+
 // src/modules/quote/types.ts
 var QuoteValidationErrorCode = /* @__PURE__ */ ((QuoteValidationErrorCode2) => {
   QuoteValidationErrorCode2["INVALID_LTV"] = "INVALID_LTV";
@@ -3102,7 +3160,6 @@ var BASIS_POINTS_DENOMINATOR = 10000n;
 var BPS_PER_PERCENT = 100n;
 var MIN_LTV_BPS = 0n;
 var HIGH_LTV_WARNING_THRESHOLD_BPS = 8000n;
-var MIN_BORROW_AMOUNT_BASE_UNITS = 5000n;
 var INTERNAL_USD_DECIMAL_PLACES = 8;
 var PRICE_SCALE_DECIMAL_PLACES = 8;
 var QuoteModule = class {
@@ -3160,11 +3217,12 @@ var QuoteModule = class {
         message: `Price not available for collateral asset: ${collateralPool.asset}`
       });
     }
-    if (request.borrowAmount <= 0n) {
-      validationErrors.push({
-        code: "BORROW_AMOUNT_TOO_LOW" /* BORROW_AMOUNT_TOO_LOW */,
-        message: "Borrow amount must be greater than 0"
-      });
+    const borrowAmountError = createBorrowAmountValidationError({
+      amount: request.borrowAmount,
+      asset: borrowPool.asset
+    });
+    if (borrowAmountError) {
+      validationErrors.push(borrowAmountError);
     }
     if (request.collateralAmount <= 0n) {
       validationErrors.push({
@@ -3286,16 +3344,12 @@ var QuoteModule = class {
         message: `Price not available for collateral asset: ${collateralAsset}`
       });
     }
-    if (borrowAmount < 0n) {
-      validationErrors.push({
-        code: "BORROW_AMOUNT_TOO_LOW" /* BORROW_AMOUNT_TOO_LOW */,
-        message: `Borrow amount must be non-negative`
-      });
-    } else if (borrowAmount < MIN_BORROW_AMOUNT_BASE_UNITS) {
-      validationErrors.push({
-        code: "BORROW_AMOUNT_TOO_LOW" /* BORROW_AMOUNT_TOO_LOW */,
-        message: `Borrow amount must be at least ${MIN_BORROW_AMOUNT_BASE_UNITS} base units`
-      });
+    const borrowAmountError = createBorrowAmountValidationError({
+      amount: borrowAmount,
+      asset: borrowAsset
+    });
+    if (borrowAmountError) {
+      validationErrors.push(borrowAmountError);
     }
     if (targetLtvBps <= MIN_LTV_BPS) {
       validationErrors.push({
@@ -3418,6 +3472,22 @@ function createQuoteResult(params) {
     warnings: params.warnings
   };
 }
+function createBorrowAmountValidationError(params) {
+  if (params.amount <= 0n) {
+    return {
+      code: "BORROW_AMOUNT_TOO_LOW" /* BORROW_AMOUNT_TOO_LOW */,
+      message: "Borrow amount must be greater than 0"
+    };
+  }
+  const minimumBorrowAmountError = getBorrowAmountMinimumValidationError(params);
+  if (!minimumBorrowAmountError) {
+    return null;
+  }
+  return {
+    code: "BORROW_AMOUNT_TOO_LOW" /* BORROW_AMOUNT_TOO_LOW */,
+    message: minimumBorrowAmountError.message
+  };
+}
 function computeUsdInternalFromBaseUnits(params) {
   const { amountBaseUnits, priceScaled, assetDecimalPlaces } = params;
   const scaleDiff = INTERNAL_USD_DECIMAL_PLACES - PRICE_SCALE_DECIMAL_PLACES;
@@ -3460,6 +3530,82 @@ function formatBpsAsPercent(bps) {
   const padded = fractional.toString().padStart(2, "0").replace(/0+$/, "");
   return `${whole}.${padded}`;
 }
+var BTC_MAINNET_ADDRESS_ERROR = "Address must be a valid mainnet BTC address";
+var EVM_ADDRESS_ERROR = "Address must be a valid EVM address";
+var ADDRESS_CHAIN_MISMATCH_ERROR = "Address chain must match asset";
+function normalizeExternalAddress(params) {
+  if (params.asset === Asset.BTC) {
+    if (params.chain !== Chain.BTC) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.INVALID_ADDRESS,
+        ADDRESS_CHAIN_MISMATCH_ERROR
+      );
+    }
+    if (!validate(params.address, Network.mainnet)) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.INVALID_ADDRESS,
+        BTC_MAINNET_ADDRESS_ERROR
+      );
+    }
+    return params.address;
+  }
+  if (isEthStablecoin2(params.asset)) {
+    if (params.chain !== Chain.ETH) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.INVALID_ADDRESS,
+        ADDRESS_CHAIN_MISMATCH_ERROR
+      );
+    }
+    if (!isAddress(params.address)) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.INVALID_ADDRESS,
+        EVM_ADDRESS_ERROR
+      );
+    }
+    return getAddress(params.address);
+  }
+  return params.address;
+}
+function normalizeAndValidateEvmAddress(address, errorMessage) {
+  if (!isAddress(address)) {
+    throw new LiquidiumError(LiquidiumErrorCode.INVALID_ADDRESS, errorMessage);
+  }
+  return getAddress(address);
+}
+function isEthStablecoin2(asset) {
+  return asset === Asset.USDC || asset === Asset.USDT;
+}
+
+// src/modules/instant-loans/_internal/address-validation.ts
+function validateInstantLoanBorrowDestination(address, asset) {
+  return normalizeExternalAddress({
+    address,
+    asset,
+    chain: getChainForInstantLoanAsset(asset)
+  });
+}
+function validateInstantLoanRefundDestination(address, asset) {
+  return normalizeExternalAddress({
+    address,
+    asset,
+    chain: getChainForInstantLoanAsset(asset)
+  });
+}
+function getChainForInstantLoanAsset(asset) {
+  if (asset === Asset.BTC) return Chain.BTC;
+  if (asset === Asset.USDC || asset === Asset.USDT) return Chain.ETH;
+  return asset;
+}
+
+// src/modules/instant-loans/types.ts
+var InstantLoanStatus = {
+  awaitingDeposit: "awaiting_deposit",
+  depositDetected: "deposit_detected",
+  active: "active",
+  settling: "settling",
+  closed: "closed",
+  expired: "expired"
+};
 
 // src/modules/instant-loans/instant-loans.ts
 var REPAYMENT_BUFFER_SECONDS = 86400n;
@@ -3480,7 +3626,7 @@ var InstantLoansModule = class {
   positions;
   /**
    * Creates a profileless instant loan and returns canonical canister state plus
-   * deposit/repay targets for the generated lending profile.
+   * generated initial-deposit and repayment quote targets.
    *
    * Choose `collateralPoolId` and `borrowPoolId` from
    * `client.market.listPools()`, convert UI amounts to base units with the
@@ -3493,10 +3639,22 @@ var InstantLoansModule = class {
    * SDK maps it to the canister's internal `ltv_timer_s` field.
    *
    * @param request - Pool ids, assets, base-unit amounts, LTV limit, timeout, and destinations.
-   * @returns Hydrated loan state plus generated deposit and repayment targets.
+   * @returns Hydrated loan state plus generated initial-deposit and repayment quote targets.
    */
   async create(request) {
     validateCreateRequest(request);
+    const borrowDestination = {
+      External: validateInstantLoanBorrowDestination(
+        addressFromAccountInput(request.borrowDestination),
+        request.borrowAsset
+      )
+    };
+    const refundDestination = {
+      External: validateInstantLoanRefundDestination(
+        addressFromAccountInput(request.refundDestination),
+        request.collateralAsset
+      )
+    };
     const apiClient = this.requireApi("Instant loan creation");
     await this.validateInstantLoanLtvPolicy(request);
     const response = await apiClient.post(SdkApiPath.instantLoans, {
@@ -3508,17 +3666,10 @@ var InstantLoansModule = class {
       borrowAmount: request.borrowAmount.toString(),
       ltvMaxBps: request.ltvMaxBps.toString(),
       depositWindowSeconds: request.depositWindowSeconds.toString(),
-      borrowDestination: accountWireFromInput(request.borrowDestination),
-      refundDestination: accountWireFromInput(request.refundDestination)
+      borrowDestination,
+      refundDestination
     });
-    const loan = await this.mapLoanWire(response.loan);
-    return {
-      ...loan,
-      collateral: {
-        ...loan.collateral,
-        amount: request.collateralAmount
-      }
-    };
+    return await this.mapLoanWire(response.loan);
   }
   /**
    * Resolves canonical canister state by loan id or short reference.
@@ -3527,7 +3678,7 @@ var InstantLoansModule = class {
    * from the instant-loans canister.
    *
    * @param request - Canister loan id or short public reference.
-   * @returns Hydrated loan state plus generated deposit and repayment targets.
+   * @returns Hydrated loan state plus generated initial-deposit and repayment quote targets.
    */
   async get(request) {
     const loanId = "loanId" in request ? request.loanId : decodeRef(request.ref);
@@ -3538,7 +3689,8 @@ var InstantLoansModule = class {
       if ("Err" in result) {
         throw mapInstantLoansErrorToLiquidiumError(result.Err);
       }
-      return await this.mapLoanRecord(result.Ok);
+      const collateralAmount = await this.getCollateralAmountHint(loanId);
+      return await this.mapLoanRecord(result.Ok, collateralAmount);
     } catch (error) {
       if (error instanceof LiquidiumError) {
         throw error;
@@ -3661,25 +3813,34 @@ var InstantLoansModule = class {
       );
     }
     const apiClient = this.requireApi("Instant loan address lookup");
-    const response = await apiClient.get(buildInstantLoanAddressLookupPath({ address: trimmedAddress }));
+    const response = await apiClient.get(
+      buildInstantLoanAddressLookupPath({ address: trimmedAddress })
+    );
     return (response.candidates ?? response.loans ?? []).map(mapCandidateWire);
   }
-  async mapLoanRecord(record) {
+  async mapLoanRecord(record, collateralAmount) {
     return await this.hydrateLoan({
       loanId: record.id,
       profileId: record.lending_profile.toText(),
       ltvMaxBps: record.ltv_max_bps,
       depositWindowSeconds: record.ltv_timer_s,
       collateralPoolId: record.lend_pool_id.toText(),
+      collateralAmount,
       borrowPoolId: record.borrow_pool_id.toText(),
       collateralAsset: getVariantKey(record.lend_asset),
       borrowAsset: getVariantKey(record.borrow_asset),
       borrowAmount: record.borrow_amount,
       borrowDestination: accountFromCanister(record.borrow_destination),
-      refundDestination: accountFromCanister(record.refund_destination),
-      started: record.started
+      refundDestination: accountFromCanister(record.refund_destination)
     });
   }
+  async getCollateralAmountHint(loanId) {
+    const apiClient = this.requireApi("Instant loan lookup");
+    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({
@@ -3691,6 +3852,10 @@ var InstantLoansModule = class {
         "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,
@@ -3735,54 +3900,64 @@ var InstantLoansModule = class {
     );
     const repaymentInflowFee = totalDebtAmount > 0n ? await this.estimateRepaymentInflowFee(borrowAsset, repayTarget.chain) : { totalFee: 0n, estimateAvailable: false };
     const repaymentAmount = totalDebtAmount + interestBufferAmount + repaymentInflowFee.totalFee;
-    const collateralAmount = collateralPosition?.deposited ?? 0n;
-    const collateralDecimals = collateralPosition?.depositedDecimals ?? 0n;
+    const currentCollateralAmount = collateralPosition?.deposited ?? 0n;
+    const collateralAmount = input.collateralAmount;
+    const collateralDecimals = collateralPosition?.depositedDecimals ?? getAssetNativeDecimals(collateralAsset);
     const collateralInterestAmount = collateralPosition?.earnedInterest ?? 0n;
     const borrowedAmount = borrowPosition?.borrowed ?? 0n;
-    const borrowedDecimals = borrowPosition?.borrowedDecimals ?? 0n;
+    const borrowedDecimals = borrowPosition?.borrowedDecimals ?? getAssetNativeDecimals(borrowAsset);
     const debtInterestAmount = borrowPosition?.debtInterest ?? 0n;
     const status = deriveInstantLoanStatus({
-      collateralAmount,
-      started: input.started,
+      collateralAmount: currentCollateralAmount,
       totalDebtAmount
     });
+    const initialDeposit = await this.createInitialDepositQuote({
+      collateralAmount,
+      decimals: collateralDecimals,
+      asset: collateralAsset,
+      target: depositTarget
+    });
+    const repayment = {
+      amount: repaymentAmount,
+      decimals: borrowedDecimals,
+      debtAmount: totalDebtAmount,
+      interestBufferAmount,
+      interestBufferSeconds: REPAYMENT_BUFFER_SECONDS,
+      inflowFeeAmount: repaymentInflowFee.totalFee,
+      inflowFeeEstimateAvailable: repaymentInflowFee.estimateAvailable,
+      asset: borrowAsset,
+      chain: repayTarget.chain,
+      target: repayTarget
+    };
     return {
       loanId: input.loanId,
       ref: publicIdFromInt(input.loanId),
       status,
       profileId,
-      ltvMaxBps: input.ltvMaxBps,
-      depositWindowSeconds: input.depositWindowSeconds,
+      terms: {
+        ltvMaxBps: input.ltvMaxBps,
+        depositWindowSeconds: input.depositWindowSeconds
+      },
       collateral: {
         poolId: collateralPoolId,
         asset: collateralAsset,
         chain: depositTarget.chain,
+        decimals: collateralDecimals,
         amount: collateralAmount
       },
       borrow: {
         poolId: borrowPoolId,
         asset: borrowAsset,
         chain: repayTarget.chain,
+        decimals: borrowedDecimals,
         amount: input.borrowAmount,
         destination: input.borrowDestination
       },
       refundDestination: input.refundDestination,
-      depositTarget,
-      repayTarget,
-      repayment: {
-        amount: repaymentAmount,
-        decimals: borrowedDecimals,
-        debtAmount: totalDebtAmount,
-        interestBufferAmount,
-        interestBufferSeconds: REPAYMENT_BUFFER_SECONDS,
-        inflowFeeAmount: repaymentInflowFee.totalFee,
-        inflowFeeEstimateAvailable: repaymentInflowFee.estimateAvailable,
-        asset: borrowAsset,
-        chain: repayTarget.chain,
-        target: repayTarget
-      },
+      initialDeposit,
+      repayment,
       position: {
-        collateralAmount,
+        collateralAmount: currentCollateralAmount,
         collateralDecimals,
         collateralInterestAmount,
         borrowedAmount,
@@ -3792,6 +3967,21 @@ var InstantLoansModule = class {
       }
     };
   }
+  async createInitialDepositQuote(input) {
+    const inflowFee = await this.lending.estimateInflowFee({
+      asset: input.asset,
+      chain: input.target.chain
+    });
+    return {
+      amount: input.collateralAmount + inflowFee.totalFee,
+      decimals: input.decimals,
+      collateralAmount: input.collateralAmount,
+      inflowFeeAmount: inflowFee.totalFee,
+      asset: input.asset,
+      chain: input.target.chain,
+      target: input.target
+    };
+  }
   async estimateRepaymentInflowFee(asset, chain) {
     try {
       const fee = await this.lending.estimateInflowFee({
@@ -3878,15 +4068,12 @@ function calculateTotalDebtAmount(borrowPosition) {
 }
 function deriveInstantLoanStatus(input) {
   if (input.totalDebtAmount > 0n) {
-    return "active";
+    return InstantLoanStatus.active;
   }
   if (input.collateralAmount > 0n) {
-    return input.started ? "settling" : "deposit_detected";
+    return InstantLoanStatus.depositDetected;
   }
-  if (input.started) {
-    return "closed";
-  }
-  return "awaiting_deposit";
+  return InstantLoanStatus.awaitingDeposit;
 }
 function validateCreateRequest(request) {
   if (request.collateralAmount <= 0n) {
@@ -3920,7 +4107,7 @@ function throwLtvCalculationError(error) {
     error?.message ?? "Unable to calculate instant loan LTV"
   );
 }
-function accountWireFromInput(account) {
+function addressFromAccountInput(account) {
   const address = typeof account === "string" ? account.trim() : account.address.trim();
   if (!address) {
     throw new LiquidiumError(
@@ -3928,7 +4115,7 @@ function accountWireFromInput(account) {
       "Instant loan account address must be non-empty"
     );
   }
-  return { External: address };
+  return address;
 }
 function accountFromCanister(account) {
   if ("Native" in account) {
@@ -4094,19 +4281,20 @@ function mapCandidateWire(wire) {
       wire.borrowAsset ?? wire.borrow_asset,
       "borrow asset"
     ),
-    collateralAmountHint: parseBigintWire(
-      wire.collateralAmountHint ?? wire.min_deposit_hint,
-      "collateral amount hint"
+    collateralAmount: parseBigintWire(
+      wire.collateralAmount,
+      "collateral amount"
     )
   };
 }
 function parseBigintWire(value, label) {
-  if (typeof value === "bigint") return value;
-  if (typeof value === "string" && /^\d+$/.test(value)) return BigInt(value);
-  throw new LiquidiumError(
-    LiquidiumErrorCode.VALIDATION_ERROR,
-    `Invalid instant loan ${label}`
-  );
+  if (!value || !/^\d+$/.test(value)) {
+    throw new LiquidiumError(
+      LiquidiumErrorCode.VALIDATION_ERROR,
+      `Invalid instant loan ${label}`
+    );
+  }
+  return BigInt(value);
 }
 function requiredString(value, label) {
   if (value?.trim()) return value;
@@ -4177,15 +4365,6 @@ function formatBpsAsPercent2(value) {
   const fractionalPart = (absoluteValue % 100n).toString().padStart(2, "0");
   return `${sign}${wholePart.toString()}.${fractionalPart}%`;
 }
-
-// src/modules/instant-loans/types.ts
-var InstantLoanStatus = {
-  awaitingDeposit: "awaiting_deposit",
-  depositDetected: "deposit_detected",
-  active: "active",
-  settling: "settling",
-  closed: "closed"
-};
 function createApproveTransaction(params) {
   return {
     to: params.tokenAddress,
@@ -4262,6 +4441,16 @@ function encodeBytes32Hex(bytes) {
     (byte) => byte.toString(16).padStart(2, "0")
   ).join("")}`;
 }
+var idlFactory5 = ({ IDL }) => IDL.Service({
+  icrc1_fee: IDL.Func([], [IDL.Nat], ["query"])
+});
+function createCkBtcLedgerActor(canisterContext) {
+  const canisterId = CK_CANISTER_IDS.btcLedger;
+  return Actor.createActor(idlFactory5, {
+    agent: canisterContext.agent,
+    canisterId
+  });
+}
 
 // src/core/canisters/lending/messages.ts
 function createBorrowAssetMessage(request, nonce) {
@@ -4344,6 +4533,28 @@ function assertValidRetryOptions(options) {
   }
 }
 
+// src/modules/lending/_internal/inflow-fee-rounding.ts
+var ETH_STABLECOIN_INFLOW_FEE_ROUND_UP_TO_NEAREST_10_CENTS = 100000n;
+var BTC_INFLOW_FEE_ROUND_UP_TO_NEAREST_SATS = 500n;
+function roundInflowFeeEstimate(request, totalFee) {
+  if (totalFee <= 0n) {
+    return 0n;
+  }
+  if (isEthStablecoin(request.asset, request.chain)) {
+    return roundUpToNearest(
+      totalFee,
+      ETH_STABLECOIN_INFLOW_FEE_ROUND_UP_TO_NEAREST_10_CENTS
+    );
+  }
+  if (request.asset === Asset.BTC && request.chain === Chain.BTC) {
+    return roundUpToNearest(totalFee, BTC_INFLOW_FEE_ROUND_UP_TO_NEAREST_SATS);
+  }
+  return totalFee;
+}
+function roundUpToNearest(amount, roundingUnit) {
+  return ceilDivBigint(amount, roundingUnit) * roundingUnit;
+}
+
 // src/modules/lending/mappers.ts
 function mapCanisterOutflowDetails(outflow) {
   const rawOutflowType = getVariantKey(outflow.outflow_type);
@@ -4432,6 +4643,10 @@ var LendingModule = class {
         "Withdraw requires a signer account"
       );
     }
+    const receiverAddress = await this.normalizeOutflowReceiverAddress({
+      poolId: request.poolId,
+      receiverAddress: destinationAccount
+    });
     const lendingActor = createLendingActor(this.canisterContext);
     try {
       const expiryTimestamp = computeExpiryTimestampFromNow();
@@ -4440,7 +4655,7 @@ var LendingModule = class {
         profileId: request.profileId,
         poolId: request.poolId,
         amount: request.amount,
-        receiverAddress: destinationAccount,
+        receiverAddress,
         signerWalletAddress: signerAccount,
         expiryTimestamp
       };
@@ -4454,7 +4669,7 @@ var LendingModule = class {
           {
             pool_id: request.poolId,
             amount: request.amount.toString(),
-            account: { type: "External", data: destinationAccount },
+            account: { type: "External", data: receiverAddress },
             expiry_timestamp: expiryTimestamp
           },
           nonce
@@ -4547,6 +4762,29 @@ var LendingModule = class {
         "Borrow requires a signer account"
       );
     }
+    if (request.amount <= 0n) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        "Borrow amount must be greater than 0"
+      );
+    }
+    const selectedPool = await this.getPoolById(request.poolId);
+    const selectedAsset = getVariantKey(selectedPool.asset);
+    const minimumBorrowAmountError = getBorrowAmountMinimumValidationError({
+      amount: request.amount,
+      asset: selectedAsset
+    });
+    if (minimumBorrowAmountError) {
+      throw new LiquidiumError(
+        LiquidiumErrorCode.VALIDATION_ERROR,
+        minimumBorrowAmountError.message
+      );
+    }
+    const receiverAddress = normalizeExternalAddress({
+      address: destinationAccount,
+      asset: selectedAsset,
+      chain: getVariantKey(selectedPool.chain)
+    });
     const lendingActor = createLendingActor(this.canisterContext);
     try {
       const expiryTimestamp = computeExpiryTimestampFromNow();
@@ -4555,7 +4793,7 @@ var LendingModule = class {
         profileId: request.profileId,
         poolId: request.poolId,
         amount: request.amount,
-        receiverAddress: destinationAccount,
+        receiverAddress,
         signerWalletAddress: signerAccount,
         expiryTimestamp
       };
@@ -4569,7 +4807,7 @@ var LendingModule = class {
           {
             pool_id: request.poolId,
             amount: request.amount.toString(),
-            account: { type: "External", data: destinationAccount },
+            account: { type: "External", data: receiverAddress },
             expiry_timestamp: expiryTimestamp
           },
           nonce
@@ -4818,10 +5056,10 @@ var LendingModule = class {
    * Estimates the network/deposit fee for an inflow target.
    *
    * ETH stablecoin deposit-address estimates are served by the deposit-address
-   * canister. BTC estimates are not exposed by this SDK yet and return zero.
+   * canister. BTC estimates include the ckBTC minter deposit fee and ledger fee.
    *
    * @param request - Asset and chain pair to estimate for.
-   * @returns Total fee estimate in the asset's base units.
+   * @returns Total fee estimate rounded up in the asset's base units.
    */
   async estimateInflowFee(request) {
     if (isEthStablecoin(request.asset, request.chain)) {
@@ -4831,16 +5069,28 @@ var LendingModule = class {
       if ("Err" in result) {
         throw mapDepositAccountErrorToLiquidiumError(result.Err);
       }
-      return { totalFee: result.Ok };
+      return {
+        totalFee: roundInflowFeeEstimate(request, result.Ok)
+      };
     }
     if (request.asset === Asset.BTC && request.chain === Chain.BTC) {
-      return { totalFee: 0n };
+      const estimate = await this.estimateBtcInflowFee();
+      return {
+        totalFee: roundInflowFeeEstimate(request, estimate.totalFee)
+      };
     }
     throw new LiquidiumError(
       LiquidiumErrorCode.VALIDATION_ERROR,
       `Inflow fee estimates are not supported for ${request.asset} on ${request.chain}`
     );
   }
+  async estimateBtcInflowFee() {
+    const [minterFee, ledgerFee] = await Promise.all([
+      createCkBtcMinterActor(this.canisterContext).get_deposit_fee(),
+      createCkBtcLedgerActor(this.canisterContext).icrc1_fee()
+    ]);
+    return { totalFee: minterFee + ledgerFee };
+  }
   async sendAndSubmitNativeSupplyInflow(params) {
     const { request, instruction, defaultSubmitInflowRequest } = params;
     if (instruction.target.type !== "nativeAddress") {
@@ -5133,6 +5383,14 @@ var LendingModule = class {
     }
     return selectedPool;
   }
+  async normalizeOutflowReceiverAddress(params) {
+    const selectedPool = await this.getPoolById(params.poolId);
+    return normalizeExternalAddress({
+      address: params.receiverAddress,
+      asset: getVariantKey(selectedPool.asset),
+      chain: getVariantKey(selectedPool.chain)
+    });
+  }
   async sendEthContractTransaction(walletAdapter, walletAddress, request, actionType) {
     if (!walletAdapter.sendEthTransaction) {
       throw new LiquidiumError(
@@ -5207,12 +5465,6 @@ function getApprovalStrategy(params) {
   }
   return EvmSupplyApprovalStrategy.resetThenApproveMax;
 }
-function normalizeAndValidateEvmAddress(address, errorMessage) {
-  if (!isAddress(address)) {
-    throw new LiquidiumError(LiquidiumErrorCode.INVALID_ADDRESS, errorMessage);
-  }
-  return getAddress(address);
-}
 function mapExpectedOutflowDetails(details, expectedOutflowType, operation) {
   if (details.outflowType !== expectedOutflowType) {
     throw new LiquidiumError(
@@ -5262,24 +5514,6 @@ function shouldSubmitInflow(params) {
   return !isEthStablecoin(params.instruction.asset, params.instruction.chain);
 }
 
-// src/core/utils/asset-decimals.ts
-var ASSET_NATIVE_DECIMALS = {
-  BTC: 8n,
-  USDC: 6n,
-  USDT: 6n,
-  SOL: 9n
-};
-function getAssetNativeDecimals(asset) {
-  const decimals = ASSET_NATIVE_DECIMALS[asset];
-  if (decimals === void 0) {
-    throw new LiquidiumError(
-      LiquidiumErrorCode.VALIDATION_ERROR,
-      `Native decimals are not configured for asset: ${asset}`
-    );
-  }
-  return decimals;
-}
-
 // src/modules/market/mappers.ts
 var DECIMAL_BASE = 10;
 var PAIR_SEPARATOR = "_";
@@ -5798,6 +6032,6 @@ function resolveEvmReadClient(config) {
   });
 }
 
-export { AccountsModule, ActivitiesModule, ActivityDirection, ActivityFilter, ActivityKind, ActivityStatus, Asset, CK_ETH_DEPOSIT_CONTRACT_ADDRESS, Chain, Environment, EvmSupplyApprovalStrategy, HistoryModule, InflowSubmitType, InstantLoanStatus, InstantLoansModule, LendingModule, LiquidiumClient, LiquidiumError, LiquidiumErrorCode, MarketModule, OutflowType, PositionsModule, QuoteModule, QuoteValidationErrorCode, QuoteWarningCode, RATE_DECIMALS, RATE_SCALE, SupplyAction, SupplyPlanType, TransferMode, USDC_CONTRACT_ADDRESS, USDT_CONTRACT_ADDRESS, UserHistoryStatus, WalletExecutionKind, createTransferErc20Transaction, executeWith, intFromPublicId, publicIdFromInt };
+export { AccountsModule, ActivitiesModule, ActivityDirection, ActivityFilter, ActivityKind, ActivityStatus, Asset, CK_ETH_DEPOSIT_CONTRACT_ADDRESS, Chain, Environment, EvmSupplyApprovalStrategy, HistoryModule, InflowSubmitType, InstantLoanStatus, InstantLoansModule, LendingModule, LiquidiumClient, LiquidiumError, LiquidiumErrorCode, MIN_BORROW_AMOUNTS_BY_ASSET, MarketModule, OutflowType, PositionsModule, QuoteModule, QuoteValidationErrorCode, QuoteWarningCode, RATE_DECIMALS, RATE_SCALE, SupplyAction, SupplyPlanType, TransferMode, USDC_CONTRACT_ADDRESS, USDT_CONTRACT_ADDRESS, UserHistoryStatus, WalletExecutionKind, createTransferErc20Transaction, executeWith, getMinimumBorrowAmount, intFromPublicId, publicIdFromInt };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map