@hobba-io/core 0.1.0

package/src/transactionBuilder.ts

@@ -0,0 +1,324 @@
+import {
+  Connection,
+  TransactionInstruction,
+  Transaction,
+  TransactionMessage,
+  VersionedTransaction,
+  ComputeBudgetProgram,
+  PublicKey,
+  AddressLookupTableAccount,
+} from "@solana/web3.js";
+import { isTickError } from "./juplend/tickUtils";
+import type { HobbaSigner } from "./wallet";
+
+/** Poll-based confirmation — avoids WebSocket dependency */
+async function pollConfirmation(
+  connection: Connection,
+  signature: string,
+  lastValidBlockHeight: number,
+  timeoutMs: number = 60_000
+): Promise<void> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const { value } = await connection.getSignatureStatuses([signature]);
+      const status = value[0];
+      if (status) {
+        if (status.err) throw new Error(`Transaction failed: ${JSON.stringify(status.err)}`);
+        if (status.confirmationStatus === "confirmed" || status.confirmationStatus === "finalized") return;
+      }
+    } catch (e: any) {
+      // Ignore RPC errors (429 etc.) and keep polling
+      console.warn("[pollConfirmation] RPC error, retrying:", e.message?.slice(0, 80));
+    }
+    await new Promise((r) => setTimeout(r, 2_000));
+  }
+  throw new Error(`Transaction not confirmed within ${timeoutMs / 1000}s. Check: https://solscan.io/tx/${signature}`);
+}
+
+export async function sendLegacyTx(
+  connection: Connection,
+  instructions: TransactionInstruction[],
+  wallet: HobbaSigner,
+  computeUnits?: number
+): Promise<string> {
+  if (!wallet.publicKey || !wallet.signTransaction) {
+    throw new Error("Wallet not connected");
+  }
+
+  const tx = new Transaction();
+
+  if (computeUnits) {
+    tx.add(ComputeBudgetProgram.setComputeUnitLimit({ units: computeUnits }));
+  }
+  tx.add(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 100_000 }));
+
+  for (const ix of instructions) {
+    tx.add(ix);
+  }
+
+  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+  tx.recentBlockhash = blockhash;
+  tx.feePayer = wallet.publicKey;
+
+  const signed = await wallet.signTransaction(tx);
+  const sig = await connection.sendRawTransaction(signed.serialize(), {
+    skipPreflight: false,
+  });
+
+  await pollConfirmation(connection, sig, lastValidBlockHeight);
+  return sig;
+}
+
+export async function sendVersionedTx(
+  connection: Connection,
+  instructions: TransactionInstruction[],
+  wallet: HobbaSigner,
+  lutAddresses: PublicKey[],
+  computeUnits?: number,
+  skipSimulation?: boolean,
+  // If supplied, called when pre-sign simulation fails with a JupLend tick error
+  // (VaultInvalidTick / VaultTickMismatch / VaultTickHasDebtNotFound). Should return
+  // a fresh instruction list (typically by re-fetching the SDK operate context) or
+  // null to surface the original error.
+  rebuildOnTickError?: () => Promise<TransactionInstruction[] | null>
+): Promise<string> {
+  if (!wallet.publicKey || !wallet.signTransaction) {
+    throw new Error("Wallet not connected");
+  }
+
+  const budgetIxs = [
+    ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 100_000 }),
+    ...(computeUnits ? [ComputeBudgetProgram.setComputeUnitLimit({ units: computeUnits })] : []),
+  ];
+  const allInstructions = [...budgetIxs, ...instructions];
+
+  // Load lookup tables
+  const lookupTables: AddressLookupTableAccount[] = [];
+  for (const lutAddress of lutAddresses) {
+    try {
+      const lutAccount = await connection.getAddressLookupTable(lutAddress);
+      if (lutAccount.value) {
+        lookupTables.push(lutAccount.value);
+      } else {
+        console.warn(`[tx] LUT ${lutAddress.toBase58()} returned null (not found on RPC)`);
+      }
+    } catch (e: any) {
+      console.warn(`[tx] LUT ${lutAddress.toBase58()} fetch failed: ${e?.message || e}`);
+    }
+  }
+
+  if (lookupTables.length === 0 && lutAddresses.length > 0) {
+    throw new Error("LUT not found or not yet activated");
+  }
+
+  const INIT_TICK_DISC = "160d3e8d4959b21d";
+  const INIT_TICK_ID_LIQ_DISC = "386e79a998f156b7";
+  const JUPLEND_PROGRAM = "jupr81YtYssSyPt8jbnGuiWon5f6x9TcDEFxYe3Bdzi";
+  const MAX_TX_SIZE = 1232;
+
+  const isInitTickIx = (ix: TransactionInstruction) => {
+    if (ix.programId.toBase58() !== JUPLEND_PROGRAM) return false;
+    const disc = Buffer.from(ix.data).subarray(0, 8).toString("hex");
+    return disc === INIT_TICK_DISC || disc === INIT_TICK_ID_LIQ_DISC;
+  };
+
+  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+  let finalInstructions = allInstructions;
+
+  const tryBuild = (ixs: TransactionInstruction[]): { tx: VersionedTransaction; size: number } | null => {
+    try {
+      const msg = new TransactionMessage({
+        payerKey: wallet.publicKey!,
+        recentBlockhash: blockhash,
+        instructions: ixs,
+      }).compileToV0Message(lookupTables);
+      const tx = new VersionedTransaction(msg);
+      const size = tx.serialize().length;
+      return { tx, size };
+    } catch (e: any) {
+      if (String(e?.message || e).includes("overruns Uint8Array")) return null;
+      throw e;
+    }
+  };
+
+  let built = tryBuild(finalInstructions);
+  // If TX doesn't fit (build threw or over MAX_TX_SIZE), strip InitTick/InitTickIdLiq (retry path re-adds if simulation says missing)
+  if (!built || built.size > MAX_TX_SIZE) {
+    const stripped = finalInstructions.filter(ix => !isInitTickIx(ix));
+    if (stripped.length < finalInstructions.length) {
+      console.log(`[tx] TX too large (${built?.size ?? "overflow"}), stripping ${finalInstructions.length - stripped.length} InitTick instructions`);
+      finalInstructions = stripped;
+      built = tryBuild(finalInstructions);
+    }
+  }
+  if (!built) {
+    throw new Error(`Transaction too large even after stripping InitTick. Try splitting deposit/borrow or contact support.`);
+  }
+  const versionedTx = built.tx;
+
+  // Pre-simulate to catch errors before opening wallet popup
+  let txToSign = versionedTx;
+  if (skipSimulation) {
+    const signed = await wallet.signTransaction(versionedTx);
+    const sig = await connection.sendRawTransaction(signed.serialize(), { skipPreflight: true });
+    await pollConfirmation(connection, sig, lastValidBlockHeight);
+    return sig;
+  }
+  const simResult = await connection.simulateTransaction(versionedTx, {
+    sigVerify: false,
+    replaceRecentBlockhash: true,
+  });
+  if (simResult.value.err) {
+    if (simResult.value.logs) {
+      console.log("[simulation] Full logs:");
+      simResult.value.logs.forEach((l, i) => console.log(`  ${i}: ${l}`));
+    }
+
+    const logs = simResult.value.logs || [];
+    const logBlob = logs.join("\n");
+
+    // JupLend tick race: SDK-computed tick PDAs no longer match on-chain state.
+    // Recover by re-fetching the SDK operate context and rebuilding the ix list,
+    // then re-simulating with fresh ticks. Single wallet popup at the end.
+    // Retry up to 3 times — vault state can shift again between SDK refetch and
+    // the rebuilt simulation, especially for withdraw paths that touch tick_has_debt arrays.
+    let tickRebuildSucceeded = false;
+    if (rebuildOnTickError && isTickError(logBlob)) {
+      const MAX_REBUILD_ATTEMPTS = 3;
+      let lastErrJson = "";
+      let lastLogs = "";
+      for (let attempt = 0; attempt < MAX_REBUILD_ATTEMPTS && !tickRebuildSucceeded; attempt++) {
+        console.log(`[simulation] JupLend tick error — rebuilding from fresh SDK context (attempt ${attempt + 1}/${MAX_REBUILD_ATTEMPTS})`);
+        const rebuilt = await rebuildOnTickError();
+        if (!rebuilt) break;
+        let rebuiltIxs = [...budgetIxs, ...rebuilt];
+        // Strip any init-tick ixs that won't fit; the SDK already filters missing ones
+        let candidate = tryBuild(rebuiltIxs);
+        if (!candidate || candidate.size > MAX_TX_SIZE) {
+          const stripped = rebuiltIxs.filter(ix => !isInitTickIx(ix));
+          candidate = tryBuild(stripped);
+          if (candidate) rebuiltIxs = stripped;
+        }
+        if (!candidate) break;
+        const retrySim = await connection.simulateTransaction(candidate.tx, {
+          sigVerify: false,
+          replaceRecentBlockhash: true,
+        });
+        if (!retrySim.value.err) {
+          finalInstructions = rebuiltIxs;
+          txToSign = candidate.tx;
+          tickRebuildSucceeded = true;
+          break;
+        }
+        lastErrJson = JSON.stringify(retrySim.value.err);
+        lastLogs = retrySim.value.logs?.slice(-10).join("\n") || "";
+        const retryBlob = (retrySim.value.logs || []).join("\n");
+        // If the new error isn't a tick error, no point retrying
+        if (!isTickError(retryBlob)) {
+          throw new Error(`Simulation failed after tick rebuild: ${lastErrJson}\n${lastLogs}`);
+        }
+      }
+      if (!tickRebuildSucceeded) {
+        throw new Error(`Simulation failed after ${MAX_REBUILD_ATTEMPTS} tick rebuild attempts: ${lastErrJson}\n${lastLogs}`);
+      }
+    }
+
+    if (tickRebuildSucceeded) {
+      // fall through to signing below with the rebuilt instructions
+    } else {
+    // If an InitTick/InitTickIdLiquidation failed (already exists, or unrecognized discriminator),
+    // strip those instructions and retry the simulation.
+    const hasAlreadyInUse = logs.some(l => l.includes("already in use"));
+    const hasFallbackNotFound = logs.some(l =>
+      l.includes("InstructionFallbackNotFound") || l.includes("custom program error: 0x65")
+    );
+    if (hasAlreadyInUse || hasFallbackNotFound) {
+      // Strip problematic JupLend instructions:
+      // - "already in use": InitTick accounts already exist
+      // - "FallbackNotFound": SDK generated an instruction the program doesn't recognize
+      const filtered = finalInstructions.filter(ix => {
+        if (ix.programId.toBase58() !== JUPLEND_PROGRAM) return true;
+        // Keep known-good InitTick instructions, strip everything else from JupLend
+        if (isInitTickIx(ix)) {
+          // Strip InitTick only if accounts already exist
+          return !hasAlreadyInUse;
+        }
+        // Strip unrecognized JupLend instructions (causes FallbackNotFound)
+        return !hasFallbackNotFound;
+      });
+      if (filtered.length < finalInstructions.length) {
+        console.log("[simulation] Retrying without initTick instructions");
+        finalInstructions = filtered;
+        const retryMsg = new TransactionMessage({
+          payerKey: wallet.publicKey,
+          recentBlockhash: blockhash,
+          instructions: finalInstructions,
+        }).compileToV0Message(lookupTables);
+        txToSign = new VersionedTransaction(retryMsg);
+        const retryResult = await connection.simulateTransaction(txToSign, {
+          sigVerify: false,
+          replaceRecentBlockhash: true,
+        });
+        if (retryResult.value.err) {
+          const retryLogs = retryResult.value.logs?.slice(-10).join("\n") || "";
+          throw new Error(`Simulation failed: ${JSON.stringify(retryResult.value.err)}\n${retryLogs}`);
+        }
+      } else {
+        const logStr = logs.slice(-10).join("\n");
+        throw new Error(`Simulation failed: ${JSON.stringify(simResult.value.err)}\n${logStr}`);
+      }
+    } else {
+      const logStr = logs.slice(-10).join("\n");
+      throw new Error(`Simulation failed: ${JSON.stringify(simResult.value.err)}\n${logStr}`);
+    }
+    } // close tickRebuildSucceeded else
+  }
+
+  // Rebuild with fresh blockhash — the original may be stale after simulation + wallet delay.
+  // Extract instructions from the compiled message and recompile with fresh blockhash.
+  const { blockhash: freshHash } = await connection.getLatestBlockhash();
+  const freshMsg = new TransactionMessage({
+    payerKey: wallet.publicKey,
+    recentBlockhash: freshHash,
+    instructions: txToSign === versionedTx ? finalInstructions : finalInstructions,
+  }).compileToV0Message(lookupTables);
+  const freshTx = new VersionedTransaction(freshMsg);
+
+  const signed = await wallet.signTransaction(freshTx);
+  const rawTx = signed.serialize();
+
+  const sig = await connection.sendRawTransaction(rawTx, {
+    skipPreflight: true,
+  });
+
+  // Poll for confirmation, re-sending periodically in case the TX was dropped
+  const start = Date.now();
+  const TIMEOUT_MS = 60_000;
+  const RESEND_INTERVAL_MS = 4_000;
+  let lastResend = Date.now();
+
+  while (Date.now() - start < TIMEOUT_MS) {
+    try {
+      const { value } = await connection.getSignatureStatuses([sig]);
+      const status = value[0];
+      if (status) {
+        if (status.err) throw new Error(`Transaction failed: ${JSON.stringify(status.err)}`);
+        if (status.confirmationStatus === "confirmed" || status.confirmationStatus === "finalized") return sig;
+      }
+    } catch (e: any) {
+      console.warn("[confirm] RPC error, retrying:", e.message?.slice(0, 80));
+    }
+
+    // Re-send TX periodically in case it was dropped
+    if (Date.now() - lastResend > RESEND_INTERVAL_MS) {
+      try {
+        await connection.sendRawTransaction(rawTx, { skipPreflight: true });
+        lastResend = Date.now();
+      } catch {}
+    }
+
+    await new Promise((r) => setTimeout(r, 2_000));
+  }
+  throw new Error(`Transaction not confirmed within ${TIMEOUT_MS / 1000}s. Check: https://solscan.io/tx/${sig}`);
+}

package/src/txHelpers.ts

@@ -0,0 +1,107 @@
+import { Connection, PublicKey, SystemProgram, TransactionInstruction } from "@solana/web3.js";
+import {
+  createAssociatedTokenAccountInstruction,
+  createSyncNativeInstruction,
+  NATIVE_MINT,
+} from "@solana/spl-token";
+import BN from "bn.js";
+import type { deriveUserTokenAccounts } from "./pdas";
+import type { VaultInfo } from "./vault/vaultAccounts";
+
+export type UserTokenAccounts = Awaited<ReturnType<typeof deriveUserTokenAccounts>>;
+
+export type SafeGetAccountInfo = (
+  addr: PublicKey,
+) => Promise<Awaited<ReturnType<Connection["getAccountInfo"]>>>;
+
+export function makeSafeGetAccountInfo(connection: Connection): SafeGetAccountInfo {
+  return async (addr: PublicKey) => {
+    try {
+      return await connection.getAccountInfo(addr);
+    } catch {
+      return null;
+    }
+  };
+}
+
+/** Build wSOL wrapping instructions (create ATA if missing → transfer → sync). */
+export async function buildWrapSolIxs(
+  owner: PublicKey,
+  wsolAta: PublicKey,
+  lamports: BN,
+  safeGetAccountInfo: SafeGetAccountInfo,
+): Promise<TransactionInstruction[]> {
+  const ixs: TransactionInstruction[] = [];
+  const ataInfo = await safeGetAccountInfo(wsolAta);
+  if (!ataInfo) {
+    ixs.push(createAssociatedTokenAccountInstruction(owner, wsolAta, owner, NATIVE_MINT));
+  }
+  ixs.push(
+    SystemProgram.transfer({
+      fromPubkey: owner,
+      toPubkey: wsolAta,
+      lamports: BigInt(lamports.toString()),
+    }),
+    createSyncNativeInstruction(wsolAta),
+  );
+  return ixs;
+}
+
+/** Shares ATA (owned by the UserState PDA) for the given yield vault. */
+export function getSharesAtaForVault(vaultType: string, tokens: UserTokenAccounts): PublicKey {
+  switch (vaultType) {
+    case "prime":
+      return tokens.pdaPrimeSharesAta;
+    case "rockawayRWA":
+      return tokens.pdaRockawaySharesAta;
+    case "perena":
+      return tokens.pdaPerenaSharesAta;
+    default:
+      return tokens.pdaSharesAta; // allez
+  }
+}
+
+/** Fetch a LUT address from the Hobba backend; null when not configured. */
+export async function fetchMarketLut(
+  apiBaseUrl: string,
+  market: string,
+): Promise<PublicKey | null> {
+  try {
+    const resp = await fetch(`${apiBaseUrl}/api/lut?market=${market}`);
+    const data = await resp.json();
+    return data.address ? new PublicKey(data.address) : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Resolve LUTs for a vault, fetching from the backend + per-vault constant. */
+export async function resolveVaultLuts(
+  apiBaseUrl: string,
+  vi: VaultInfo,
+  extraLuts?: PublicKey[],
+): Promise<PublicKey[]> {
+  const luts: PublicKey[] = [];
+  const seen = new Set<string>();
+  const addLut = (pk: PublicKey) => {
+    const key = pk.toBase58();
+    if (!seen.has(key) && !pk.equals(PublicKey.default)) {
+      seen.add(key);
+      luts.push(pk);
+    }
+  };
+  if (vi.provider === "perena") {
+    const lut = await fetchMarketLut(apiBaseUrl, "perena");
+    if (lut) addLut(lut);
+  } else {
+    // Vault LUT from the backend (batch accounts for the kvault CPI) …
+    const lut = await fetchMarketLut(apiBaseUrl, "vault");
+    if (lut) addLut(lut);
+    // … plus the per-vault constant LUT as fallback.
+    if (!vi.lookupTable.equals(PublicKey.default)) addLut(vi.lookupTable);
+  }
+  if (extraLuts) {
+    for (const l of extraLuts) addLut(l);
+  }
+  return luts;
+}

package/src/userState.ts

@@ -0,0 +1,91 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import {
+  CBBTC_MINT,
+  DEPOSITED_TO_VAULT_OFFSET,
+  CURRENT_VAULT_OFFSET,
+  COLLATERAL_MINT_OFFSET,
+  ALLEZ_USDC_VAULT,
+  USDC_PRIME_VAULT,
+  ROCKAWAY_RWA_VAULT,
+  PERENA_VAULT_STATE,
+} from "./constants";
+import { deriveUserStatePda } from "./pdas";
+
+export type CurrentVaultType = "allez" | "prime" | "rockawayRWA" | "perena" | "none";
+
+export interface UserStateData {
+  owner: PublicKey;
+  obligation: PublicKey;
+  lendingMarket: PublicKey;
+  lendingProvider: number; // 0 = Kamino, 1 = JupLend
+  depositedToVault: number; // USDC lamports
+  currentVault: PublicKey;
+  currentVaultType: CurrentVaultType;
+  collateralMint: PublicKey;
+}
+
+/**
+ * Parse a Hobba UserState account buffer. Lifted verbatim from the app's
+ * useUserState hook so the app, the widget, and headless integrators share one
+ * layout definition.
+ */
+export function parseUserStateData(data: Buffer): UserStateData {
+  const owner = new PublicKey(data.slice(9, 41));
+  const obligation = new PublicKey(data.slice(41, 73));
+  const lendingMarket = new PublicKey(data.slice(73, 105));
+  const lendingProvider = data[105];
+
+  let depositedToVault = 0;
+  if (data.length >= DEPOSITED_TO_VAULT_OFFSET + 8) {
+    depositedToVault = new BN(
+      data.slice(DEPOSITED_TO_VAULT_OFFSET, DEPOSITED_TO_VAULT_OFFSET + 8),
+      "le",
+    ).toNumber();
+  }
+
+  let currentVault = PublicKey.default;
+  let currentVaultType: CurrentVaultType = "none";
+  if (data.length >= CURRENT_VAULT_OFFSET + 32) {
+    currentVault = new PublicKey(data.slice(CURRENT_VAULT_OFFSET, CURRENT_VAULT_OFFSET + 32));
+    if (!currentVault.equals(PublicKey.default)) {
+      if (currentVault.equals(ALLEZ_USDC_VAULT)) currentVaultType = "allez";
+      else if (currentVault.equals(USDC_PRIME_VAULT)) currentVaultType = "prime";
+      else if (currentVault.equals(ROCKAWAY_RWA_VAULT)) currentVaultType = "rockawayRWA";
+      else if (currentVault.equals(PERENA_VAULT_STATE)) currentVaultType = "perena";
+    }
+  }
+
+  let collateralMint = CBBTC_MINT; // default for older accounts
+  if (data.length >= COLLATERAL_MINT_OFFSET + 32) {
+    collateralMint = new PublicKey(
+      data.slice(COLLATERAL_MINT_OFFSET, COLLATERAL_MINT_OFFSET + 32),
+    );
+    if (collateralMint.equals(PublicKey.default)) {
+      collateralMint = CBBTC_MINT;
+    }
+  }
+
+  return {
+    owner,
+    obligation,
+    lendingMarket,
+    lendingProvider,
+    depositedToVault,
+    currentVault,
+    currentVaultType,
+    collateralMint,
+  };
+}
+
+/** Fetch + parse the UserState for (owner, collateral mint). Null when none exists. */
+export async function fetchUserState(
+  connection: Connection,
+  owner: PublicKey,
+  collateralMint: PublicKey,
+): Promise<UserStateData | null> {
+  const [pda] = deriveUserStatePda(owner, collateralMint);
+  const info = await connection.getAccountInfo(pda);
+  if (!info) return null;
+  return parseUserStateData(info.data as Buffer);
+}