@hobba-io/core 0.1.0

package/src/idl.ts

@@ -0,0 +1,7 @@
+// Authoritative Hobba IDL for all consumers (app AnchorProvider, core's own
+// buildHobbaProgram, scripts). Regenerate with `anchor idl build` and copy into
+// src/idl/hobba.json — app/public/hobba.json is a served duplicate kept only
+// for external fetchers and must be refreshed from this copy.
+import idl from "./idl/hobba.json";
+
+export const HOBBA_IDL = idl;

package/src/index.ts

@@ -0,0 +1,21 @@
+// Public surface of @hobba/core — shared on-chain logic consumed by both the
+// Next app and the embeddable widget. `executeDepositBorrow` is the main flow;
+// `executeAction` manages existing positions; `getPosition`/`getLimits` are the
+// headless reads. Lender routing (JupLend default, Kamino for existing Kamino
+// users) happens inside the execute/read functions.
+export * from "./constants";
+export * from "./pdas";
+export * from "./amountUtils";
+export * from "./transactionBuilder";
+export * from "./wallet";
+export { buildHobbaProgram } from "./program";
+export * from "./executeDepositBorrow";
+export * from "./executeAction";
+export * from "./marketConfig";
+export * from "./userState";
+export * from "./position";
+export * from "./positionMetrics";
+export * from "./quote";
+export * from "./limits";
+export * from "./txHelpers";
+export * from "./errors";

package/src/juplend/accountResolvers.ts

@@ -0,0 +1,207 @@
+import { PublicKey, SystemProgram, AccountMeta } from "@solana/web3.js";
+import { TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync } from "@solana/spl-token";
+import {
+  JUPLEND_PROGRAM,
+  USDC_MINT,
+  ATA_PROGRAM_ID,
+} from "../constants";
+import { deriveProgramConfigPda } from "../pdas";
+
+interface JuplendUserPdas {
+  userStatePda: PublicKey;
+  allowlistEntryPda: PublicKey;
+  obligationPda: PublicKey; // = position PDA for JupLend
+  userMetadataPda: PublicKey;
+  userCollateralAta: PublicKey;
+  userUsdcAta: PublicKey;
+  pdaCollateralAta: PublicKey;
+  pdaUsdcAta: PublicKey;
+}
+
+const [programConfigPda] = deriveProgramConfigPda();
+
+export function getJuplendDepositAccounts(owner: PublicKey, pdas: JuplendUserPdas, collateralMint: PublicKey) {
+  return {
+    owner,
+    userState: pdas.userStatePda,
+    userSourceLiquidity: pdas.userCollateralAta,
+    pdaSourceLiquidity: pdas.pdaCollateralAta,
+    supplyTokenMint: collateralMint,
+    tokenProgram: TOKEN_PROGRAM_ID,
+    associatedTokenProgram: ATA_PROGRAM_ID,
+    systemProgram: SystemProgram.programId,
+    programConfig: programConfigPda,
+    allowlistEntry: pdas.allowlistEntryPda,
+    collateralMint,
+  };
+}
+
+/// Returns JupLend deposit lender accounts as AccountMeta[] for remaining_accounts.
+/// Layout: [pda_borrow_token_account, juplend_program, ...juplend_operate_accounts]
+export function getJuplendDepositLenderAccounts(
+  pdas: JuplendUserPdas,
+): AccountMeta[] {
+  return [
+    { pubkey: pdas.pdaUsdcAta, isSigner: false, isWritable: true },
+    { pubkey: JUPLEND_PROGRAM, isSigner: false, isWritable: false },
+  ];
+}
+
+/// Named accounts for combined JupLend deposit+borrow (single operate CPI).
+/// vaultConfig and position are named accounts on this handler (the program
+/// splices them back into the operate list via build_operate_accounts); pass
+/// the operate list's index-0 (vault_config) and index-5 (position) entries.
+export function getJuplendDepositBorrowAccounts(
+  owner: PublicKey,
+  pdas: JuplendUserPdas,
+  collateralMint: PublicKey,
+  vaultConfig: PublicKey,
+  position: PublicKey,
+) {
+  return {
+    owner,
+    userState: pdas.userStatePda,
+    collateralMint,
+    userCollateralAta: pdas.userCollateralAta,
+    pdaCollateralAta: pdas.pdaCollateralAta,
+    pdaUsdcAta: pdas.pdaUsdcAta,
+    userUsdcAta: pdas.userUsdcAta,
+    usdcMint: USDC_MINT,
+    tokenProgram: TOKEN_PROGRAM_ID,
+    associatedTokenProgram: ATA_PROGRAM_ID,
+    systemProgram: SystemProgram.programId,
+    programConfig: programConfigPda,
+    allowlistEntry: pdas.allowlistEntryPda,
+    vaultConfig,
+    position,
+  };
+}
+
+/// Remaining accounts for combined deposit+borrow: [juplend_program, ...operate_accounts].
+/// Skips the two duplicated ATAs from the deposit/borrow single-side layouts.
+export function getJuplendDepositBorrowLenderAccounts(): AccountMeta[] {
+  return [{ pubkey: JUPLEND_PROGRAM, isSigner: false, isWritable: false }];
+}
+
+// Matches surfpool-test.ts testJuplendBorrow accounts exactly
+export function getJuplendBorrowAccounts(
+  owner: PublicKey,
+  pdas: JuplendUserPdas,
+  collateralMint: PublicKey,
+  hasVaultShares: boolean = false,
+  vaultAccounts?: {
+    vault: PublicKey;
+    sharesMint: PublicKey;
+    sharesAta: PublicKey;
+  }
+) {
+  const va = vaultAccounts;
+  // Canonical ATA of the placeholder shares mint (the wallet pubkey), so the
+  // program's pda_shares_ata == ATA(user_state, shares_mint) check holds when no vault is used.
+  const placeholderSharesAta = getAssociatedTokenAddressSync(owner, pdas.userStatePda, true);
+  return {
+    owner,
+    userState: pdas.userStatePda,
+    collateralMint,
+    pdaUsdcAta: pdas.pdaUsdcAta,
+    userUsdcAta: pdas.userUsdcAta,
+    tokenProgram: TOKEN_PROGRAM_ID,
+    systemProgram: SystemProgram.programId,
+    vault: hasVaultShares && va ? va.vault : owner,
+    sharesMint: hasVaultShares && va ? va.sharesMint : owner,
+    pdaSharesAta: hasVaultShares && va ? va.sharesAta : placeholderSharesAta,
+    sharesTokenProgram: hasVaultShares ? TOKEN_PROGRAM_ID : SystemProgram.programId,
+    usdcMint: USDC_MINT,
+    programConfig: programConfigPda,
+    allowlistEntry: pdas.allowlistEntryPda,
+  };
+}
+
+/// Returns JupLend lender accounts as AccountMeta[] for remaining_accounts.
+/// Layout: [pda_source_liquidity, juplend_program, ...juplend_operate_accounts]
+export function getJuplendBorrowLenderAccounts(
+  pdas: JuplendUserPdas,
+): AccountMeta[] {
+  return [
+    { pubkey: pdas.pdaCollateralAta, isSigner: false, isWritable: true },
+    { pubkey: JUPLEND_PROGRAM, isSigner: false, isWritable: false },
+  ];
+}
+
+// Matches surfpool-test.ts testJuplendRepay accounts exactly
+export function getJuplendRepayAccounts(owner: PublicKey, pdas: JuplendUserPdas, collateralMint: PublicKey) {
+  return {
+    owner,
+    userState: pdas.userStatePda,
+    userUsdcAta: pdas.userUsdcAta,
+    pdaUsdcAta: pdas.pdaUsdcAta,
+    tokenProgram: TOKEN_PROGRAM_ID,
+    programConfig: programConfigPda,
+    allowlistEntry: pdas.allowlistEntryPda,
+    collateralMint,
+  };
+}
+
+/// Returns JupLend repay lender accounts as AccountMeta[] for remaining_accounts.
+/// Layout: [pda_source_liquidity, juplend_program, ...juplend_operate_accounts]
+export function getJuplendRepayLenderAccounts(
+  pdas: JuplendUserPdas,
+): AccountMeta[] {
+  return [
+    { pubkey: pdas.pdaCollateralAta, isSigner: false, isWritable: true },
+    { pubkey: JUPLEND_PROGRAM, isSigner: false, isWritable: false },
+  ];
+}
+
+/// Returns PrepareWithdraw named accounts for JupLend users.
+/// Matches the shared PrepareWithdraw Anchor struct.
+export function getJuplendPrepareWithdrawAccounts(
+  owner: PublicKey,
+  pdas: JuplendUserPdas,
+  collateralMint: PublicKey,
+  vaultAccounts: {
+    vault: PublicKey;
+    sharesMint: PublicKey;
+    sharesAta: PublicKey;
+  }
+) {
+  const va = vaultAccounts;
+  return {
+    owner,
+    userState: pdas.userStatePda,
+    collateralMint,
+    programConfig: programConfigPda,
+    allowlistEntry: pdas.allowlistEntryPda,
+    pdaUsdcAta: pdas.pdaUsdcAta,
+    vault: va.vault,
+    sharesMint: va.sharesMint,
+    pdaSharesAta: va.sharesAta,
+    sharesTokenProgram: TOKEN_PROGRAM_ID,
+    usdcMint: USDC_MINT,
+    tokenProgram: TOKEN_PROGRAM_ID,
+  };
+}
+
+export function getJuplendWithdrawAccounts(owner: PublicKey, pdas: JuplendUserPdas, collateralMint: PublicKey) {
+  return {
+    owner,
+    userState: pdas.userStatePda,
+    pdaDestinationAta: pdas.pdaCollateralAta,
+    userDestinationAta: pdas.userCollateralAta,
+    tokenProgram: TOKEN_PROGRAM_ID,
+    programConfig: programConfigPda,
+    allowlistEntry: pdas.allowlistEntryPda,
+    collateralMint,
+  };
+}
+
+/// Returns JupLend withdraw lender accounts as AccountMeta[] for remaining_accounts.
+/// Layout: [pda_borrow_token_account, juplend_program, ...juplend_operate_accounts]
+export function getJuplendWithdrawLenderAccounts(
+  pdas: JuplendUserPdas,
+): AccountMeta[] {
+  return [
+    { pubkey: pdas.pdaUsdcAta, isSigner: false, isWritable: true },
+    { pubkey: JUPLEND_PROGRAM, isSigner: false, isWritable: false },
+  ];
+}

package/src/juplend/operateRemaining.ts

@@ -0,0 +1,81 @@
+import { PublicKey, SystemProgram } from "@solana/web3.js";
+import {
+  JUPLEND_PROGRAM,
+  JUPLEND_VAULT_CONFIG,
+  JUPLEND_VAULT_STATE,
+  JUPLEND_ORACLE,
+  JUPLEND_SUPPLY_RESERVES_LIQUIDITY,
+  JUPLEND_BORROW_RESERVES_LIQUIDITY,
+  JUPLEND_VAULT_SUPPLY_POSITION,
+  JUPLEND_VAULT_BORROW_POSITION,
+  JUPLEND_SUPPLY_RATE_MODEL,
+  JUPLEND_BORROW_RATE_MODEL,
+  JUPLEND_VAULT_SUPPLY_TOKEN_ACCOUNT,
+  JUPLEND_VAULT_BORROW_TOKEN_ACCOUNT,
+  JUPLEND_LIQUIDITY,
+  JUPLEND_LIQUIDITY_PROGRAM,
+  JUPLEND_ORACLE_PROGRAM,
+  JUPLEND_ORACLE_SOURCE,
+  JUPLEND_BRANCH,
+  JUPLEND_TICK_0,
+  JUPLEND_TICK_1,
+  JUPLEND_NEW_BRANCH,
+  ATA_PROGRAM_ID,
+  CBBTC_MINT,
+  USDC_MINT,
+} from "../constants";
+import { TOKEN_PROGRAM_ID } from "@solana/spl-token";
+
+interface OperateRemainingResult {
+  remaining: { pubkey: PublicKey; isSigner: boolean; isWritable: boolean }[];
+}
+
+// Fallback hardcoded remaining accounts for JupLend operate
+// Used when SDK fails (e.g., on new positions)
+export function buildFallbackOperateRemaining(
+  position: PublicKey,
+  positionTokenAccount: PublicKey,
+  currentTick: PublicKey,
+  finalTick: PublicKey,
+  currentTickId: PublicKey,
+  finalTickId: PublicKey
+): OperateRemainingResult {
+  return {
+    remaining: [
+      { pubkey: JUPLEND_VAULT_CONFIG, isSigner: false, isWritable: true },
+      { pubkey: JUPLEND_VAULT_STATE, isSigner: false, isWritable: true },
+      { pubkey: CBBTC_MINT, isSigner: false, isWritable: false },
+      { pubkey: USDC_MINT, isSigner: false, isWritable: false },
+      { pubkey: JUPLEND_ORACLE, isSigner: false, isWritable: false },
+      { pubkey: position, isSigner: false, isWritable: true },
+      { pubkey: positionTokenAccount, isSigner: false, isWritable: false },
+      { pubkey: currentTick, isSigner: false, isWritable: true },
+      { pubkey: finalTick, isSigner: false, isWritable: true },
+      { pubkey: currentTickId, isSigner: false, isWritable: true },
+      { pubkey: finalTickId, isSigner: false, isWritable: true },
+      { pubkey: JUPLEND_NEW_BRANCH, isSigner: false, isWritable: true },
+      { pubkey: JUPLEND_SUPPLY_RESERVES_LIQUIDITY, isSigner: false, isWritable: true },
+      { pubkey: JUPLEND_BORROW_RESERVES_LIQUIDITY, isSigner: false, isWritable: true },
+      { pubkey: JUPLEND_VAULT_SUPPLY_POSITION, isSigner: false, isWritable: true },
+      { pubkey: JUPLEND_VAULT_BORROW_POSITION, isSigner: false, isWritable: true },
+      { pubkey: JUPLEND_SUPPLY_RATE_MODEL, isSigner: false, isWritable: true },
+      { pubkey: JUPLEND_BORROW_RATE_MODEL, isSigner: false, isWritable: true },
+      { pubkey: JUPLEND_VAULT_SUPPLY_TOKEN_ACCOUNT, isSigner: false, isWritable: true },
+      { pubkey: JUPLEND_VAULT_BORROW_TOKEN_ACCOUNT, isSigner: false, isWritable: true },
+      { pubkey: JUPLEND_PROGRAM, isSigner: false, isWritable: false }, // supply claim (none)
+      { pubkey: JUPLEND_PROGRAM, isSigner: false, isWritable: false }, // borrow claim (none)
+      { pubkey: JUPLEND_LIQUIDITY, isSigner: false, isWritable: true },
+      { pubkey: JUPLEND_LIQUIDITY_PROGRAM, isSigner: false, isWritable: true },
+      { pubkey: JUPLEND_ORACLE_PROGRAM, isSigner: false, isWritable: false },
+      { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: ATA_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+      // Variable remaining: oracle source, branch, tick arrays
+      { pubkey: JUPLEND_ORACLE_SOURCE, isSigner: false, isWritable: false },
+      { pubkey: JUPLEND_BRANCH, isSigner: false, isWritable: true },
+      { pubkey: JUPLEND_TICK_0, isSigner: false, isWritable: true },
+      { pubkey: JUPLEND_TICK_1, isSigner: false, isWritable: true },
+    ],
+  };
+}

package/src/juplend/positionInit.ts

@@ -0,0 +1,86 @@
+import { PublicKey, SystemProgram, SYSVAR_RENT_PUBKEY, SYSVAR_INSTRUCTIONS_PUBKEY, AccountMeta } from "@solana/web3.js";
+import { TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import {
+  JUPLEND_PROGRAM,
+  JUPLEND_VAULT_CONFIG,
+  JUPLEND_VAULT_STATE,
+  METAPLEX_PROGRAM,
+  ATA_PROGRAM_ID,
+} from "../constants";
+import { deriveDepositConfigPda, deriveOriginConfigPda, deriveProgramConfigPda, deriveUserOriginPda } from "../pdas";
+const [programConfigPda] = deriveProgramConfigPda();
+const [JUPLEND_VAULT_ADMIN] = PublicKey.findProgramAddressSync(
+  [Buffer.from("vault_admin")],
+  JUPLEND_PROGRAM
+);
+
+// Matches surfpool-test.ts createJuplendPosition accounts exactly
+export function getCreateJuplendPositionAccounts(
+  owner: PublicKey,
+  userStatePda: PublicKey,
+  positionPda: PublicKey,
+  positionMintPda: PublicKey,
+  positionTokenAccount: PublicKey,
+  positionMetadata: PublicKey,
+  allowlistEntryPda: PublicKey,
+  collateralMint: PublicKey,
+  vaultState: PublicKey = JUPLEND_VAULT_STATE
+) {
+  return {
+    owner,
+    userStatePda,  // IDL name is "user_state_pda"
+    position: positionPda,
+    positionMint: positionMintPda,
+    positionTokenAccount,
+    positionMetadata,
+    juplendVaultAdmin: JUPLEND_VAULT_ADMIN,
+    juplendVaultState: vaultState,
+    juplendProgram: JUPLEND_PROGRAM,
+    metadataProgram: METAPLEX_PROGRAM,
+    tokenProgram: TOKEN_PROGRAM_ID,
+    associatedTokenProgram: ATA_PROGRAM_ID,
+    instructionSysvar: SYSVAR_INSTRUCTIONS_PUBKEY,
+    programConfig: programConfigPda,
+    allowlistEntry: allowlistEntryPda,
+    collateralMint,
+    rent: SYSVAR_RENT_PUBKEY,
+    systemProgram: SystemProgram.programId,
+  };
+}
+
+// Matches surfpool-test.ts initializeUser accounts exactly
+export function getInitializeUserJuplendAccounts(
+  owner: PublicKey,
+  userStatePda: PublicKey,
+  allowlistEntryPda: PublicKey,
+  collateralMint: PublicKey,
+  origin: number = 0,
+) {
+  return {
+    owner,
+    userState: userStatePda,
+    collateralMint,
+    systemProgram: SystemProgram.programId,
+    programConfig: programConfigPda,
+    allowlistEntry: allowlistEntryPda,
+    depositConfig: deriveDepositConfigPda(collateralMint)[0],
+    // Per-wallet origin registration; created on the wallet's first init,
+    // later inits keep the stored origin (the origin arg is then ignored).
+    userOrigin: deriveUserOriginPda(owner)[0],
+    // Seeded by the `origin` instruction arg — always pass explicitly rather
+    // than relying on Anchor's IDL auto-resolution.
+    originConfig: deriveOriginConfigPda(origin)[0],
+  };
+}
+
+/// Returns JupLend initialize_user lender accounts as AccountMeta[] for remaining_accounts.
+/// Layout: [position, juplend_vault_config]
+export function getJuplendInitializeUserLenderAccounts(
+  positionPda: PublicKey,
+  vaultConfig: PublicKey = JUPLEND_VAULT_CONFIG
+): AccountMeta[] {
+  return [
+    { pubkey: positionPda, isSigner: false, isWritable: false },
+    { pubkey: vaultConfig, isSigner: false, isWritable: false },
+  ];
+}

package/src/juplend/positionParser.ts

@@ -0,0 +1,41 @@
+import BN from "bn.js";
+
+// JupLend position account layout (from SDK decode):
+// 8 (discriminator) + 2 (vaultId) + 4 (nftId) + 32 (positionMint) + 1 (isSupplyOnlyPosition)
+// offset 47: tick (i32 LE, 4 bytes)
+// offset 51: tickId (u32 LE, 4 bytes)
+// offset 55: supplyAmount (u64 LE, 8 bytes) — supply shares
+// offset 63: dustDebtAmount (u64 LE, 8 bytes) — debt in micro-USDC (approx)
+// Total: 71 bytes
+
+export function parseJuplendPosition(data: Buffer): {
+  collateral: number; // satoshis
+  debt: number;       // micro-USDC
+  tick: number;
+  supplyAmount: number;      // raw supply shares
+  dustDebtAmount: number;    // raw dust debt
+} {
+  if (data.length < 71) {
+    return { collateral: 0, debt: 0, tick: 0, supplyAmount: 0, dustDebtAmount: 0 };
+  }
+
+  const tick = data.readInt32LE(47);
+
+  // Read u64 values using BN (avoids JS Number precision issues for large u64)
+  const supplyBn = new BN(data.slice(55, 63), "le");
+  const dustDebtBn = new BN(data.slice(63, 71), "le");
+
+  const supplyAmount = supplyBn.toNumber();
+  const dustDebtAmount = dustDebtBn.toNumber();
+
+  return {
+    // Raw values for exchange rate conversion (done in hook with vault state)
+    supplyAmount,
+    dustDebtAmount,
+    // Debt: dustDebtAmount is approximately micro-USDC
+    debt: dustDebtAmount,
+    // Collateral: needs exchange rate conversion (set to 0, computed in hook)
+    collateral: 0,
+    tick,
+  };
+}

package/src/juplend/sdkApi.ts

@@ -0,0 +1,112 @@
+import { PublicKey, TransactionInstruction, SystemProgram } from "@solana/web3.js";
+import { ATA_PROGRAM_ID } from "../constants";
+
+interface SdkRemainingEntry {
+  pubkey: string;
+  writable: boolean;
+}
+
+interface SdkOtherIx {
+  programId: string;
+  keys: { pubkey: string; isSigner: boolean; isWritable: boolean }[];
+  data: string; // base64
+}
+
+export interface SdkOperateResponse {
+  remaining: SdkRemainingEntry[];
+  variableRemaining: SdkRemainingEntry[];
+  otherIxs: SdkOtherIx[];
+  currentTick: string;
+  finalTick: string;
+  currentTickValue: number | null;
+  finalTickValue: number | null;
+}
+
+export interface SdkOperateRequest {
+  vaultId: number;
+  positionId: number;
+  colAmount: string;
+  debtAmount: string;
+  signerPda: string;
+}
+
+export async function fetchOperateContext(
+  params: SdkOperateRequest,
+  apiBaseUrl: string = "",
+): Promise<SdkOperateResponse> {
+  const base = apiBaseUrl.replace(/\/+$/, "");
+  const resp = await fetch(`${base}/api/juplend-operate`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(params),
+  });
+  if (!resp.ok) {
+    const errData = await resp.json().catch(() => ({ error: "SDK API failed" }));
+    throw new Error(errData.error || `SDK API returned ${resp.status}`);
+  }
+  return resp.json();
+}
+
+// Deserialize SDK remaining accounts into AccountMeta[]
+// The API returns 27 fixed entries; caller adds ATA_PROGRAM + SystemProgram, then variable remaining
+export function deserializeRemaining(
+  sdkResp: SdkOperateResponse
+): { pubkey: PublicKey; isSigner: boolean; isWritable: boolean }[] {
+  const fixed = sdkResp.remaining.map((a) => ({
+    pubkey: new PublicKey(a.pubkey),
+    isSigner: false,
+    isWritable: a.writable,
+  }));
+
+  fixed.push({ pubkey: ATA_PROGRAM_ID, isSigner: false, isWritable: false });
+  fixed.push({ pubkey: SystemProgram.programId, isSigner: false, isWritable: false });
+
+  const variable = sdkResp.variableRemaining.map((a) => ({
+    pubkey: new PublicKey(a.pubkey),
+    isSigner: false,
+    isWritable: a.writable,
+  }));
+
+  return [...fixed, ...variable];
+}
+
+// Known JupLend instruction discriminators that the deployed program supports
+const KNOWN_JUPLEND_DISCS = new Set([
+  "160d3e8d4959b21d", // InitTick
+  "386e79a998f156b7", // InitTickIdLiquidation
+]);
+const JUPLEND_PROGRAM_STR = "jupr81YtYssSyPt8jbnGuiWon5f6x9TcDEFxYe3Bdzi";
+
+// Deserialize otherIxs (initTick, initBranch, etc.) and replace signerPda with actual payer.
+// Filters out unrecognized JupLend instructions that cause InstructionFallbackNotFound.
+export function deserializeOtherIxs(
+  sdkResp: SdkOperateResponse,
+  signerPda: PublicKey,
+  actualPayer: PublicKey
+): TransactionInstruction[] {
+  const signerStr = signerPda.toBase58();
+  return sdkResp.otherIxs
+    .filter((ix) => {
+      // Keep non-JupLend instructions as-is
+      if (ix.programId !== JUPLEND_PROGRAM_STR) return true;
+      // Log ALL JupLend instruction discriminators for debugging
+      const disc = Buffer.from(ix.data, "base64").subarray(0, 8).toString("hex");
+      console.log("[otherIxs] JupLend instruction disc:", disc, KNOWN_JUPLEND_DISCS.has(disc) ? "(known)" : "(UNKNOWN — filtering out)");
+      if (!KNOWN_JUPLEND_DISCS.has(disc)) return false;
+      return true;
+    })
+    .map((ix) =>
+      new TransactionInstruction({
+        programId: new PublicKey(ix.programId),
+        keys: ix.keys.map((k) => {
+          const isSigner = k.pubkey === signerStr;
+          return {
+            pubkey: isSigner ? actualPayer : new PublicKey(k.pubkey),
+            isSigner: isSigner ? true : k.isSigner,
+            isWritable: k.isWritable,
+          };
+        }),
+        data: Buffer.from(ix.data, "base64"),
+      })
+    );
+}

package/src/juplend/tickMath.ts

@@ -0,0 +1,82 @@
+/**
+ * JupLend tick ↔ debt fixed-point math (ported from the JupLend SDK).
+ * Pure BN math, browser-safe; shared by /api/juplend-position and any
+ * script that needs debt-from-tick without an RPC tick fetch.
+ */
+import BN from "bn.js";
+
+export const JUPLEND_MIN_TICK = -16383;
+export const JUPLEND_MAX_TICK_VALUE = 16383;
+
+/**
+ * Tick ratio as an X48 fixed-point BN (scaled by 2^48).
+ * debtRaw = ratioX48 * (colRaw + 1) >> 48 + 1
+ */
+export function getRatioAtTick(tick: number): BN {
+  if (tick < JUPLEND_MIN_TICK || tick > JUPLEND_MAX_TICK_VALUE) {
+    throw new Error(`Tick ${tick} out of range [${JUPLEND_MIN_TICK}, ${JUPLEND_MAX_TICK_VALUE}]`);
+  }
+
+  const FACTORS: BN[] = [
+    new BN("18446744073709551616"), // FACTOR00 = 2^64
+    new BN("18419115400608638658"),
+    new BN("18391528108445969703"),
+    new BN("18336477419114433396"),
+    new BN("18226869890870665593"),
+    new BN("18009616477100071088"),
+    new BN("17582847377087825313"),
+    new BN("16759408633341240198"),
+    new BN("15226414841393184936"),
+    new BN("12568272644527235157"),
+    new BN("8563108841104354677"),
+    new BN("3975055583337633975"),
+    new BN("856577552520149366"),
+    new BN("39775317560084773"),
+    new BN("85764505686420"),
+    new BN("398745188"),
+  ];
+
+  function mulShift64(n0: BN, n1: BN): BN {
+    const product = n0.mul(n1);
+    return product.shrn(64);
+  }
+
+  const absTick = Math.abs(tick);
+  let factor = FACTORS[0];
+  if (absTick & 1) factor = FACTORS[1];
+  if (absTick & 2) factor = mulShift64(factor, FACTORS[2]);
+  if (absTick & 4) factor = mulShift64(factor, FACTORS[3]);
+  if (absTick & 8) factor = mulShift64(factor, FACTORS[4]);
+  if (absTick & 16) factor = mulShift64(factor, FACTORS[5]);
+  if (absTick & 32) factor = mulShift64(factor, FACTORS[6]);
+  if (absTick & 64) factor = mulShift64(factor, FACTORS[7]);
+  if (absTick & 128) factor = mulShift64(factor, FACTORS[8]);
+  if (absTick & 256) factor = mulShift64(factor, FACTORS[9]);
+  if (absTick & 512) factor = mulShift64(factor, FACTORS[10]);
+  if (absTick & 1024) factor = mulShift64(factor, FACTORS[11]);
+  if (absTick & 2048) factor = mulShift64(factor, FACTORS[12]);
+  if (absTick & 4096) factor = mulShift64(factor, FACTORS[13]);
+  if (absTick & 8192) factor = mulShift64(factor, FACTORS[14]);
+  if (absTick & 16384) factor = mulShift64(factor, FACTORS[15]);
+
+  let precision = new BN(0);
+  if (tick > 0) {
+    const maxU128 = new BN(2).pow(new BN(128)).subn(1);
+    factor = maxU128.div(factor);
+    if (!factor.mod(new BN(65536)).isZero()) {
+      precision = new BN(1);
+    }
+  }
+
+  return factor.shrn(16).add(precision);
+}
+
+/**
+ * Debt (in borrow shares) implied by a position's tick and collateral shares.
+ * Returns 0 at/below MIN_TICK (no debt).
+ */
+export function debtFromTick(colRaw: BN, tick: number): BN {
+  if (tick <= JUPLEND_MIN_TICK) return new BN(0);
+  const ratio = getRatioAtTick(tick);
+  return ratio.mul(colRaw.addn(1)).shrn(48).addn(1);
+}