@hobba-io/core 0.1.0

package/src/vault/vaultAccounts.ts

@@ -0,0 +1,365 @@
+import { Connection, PublicKey, SystemProgram, SYSVAR_INSTRUCTIONS_PUBKEY } from "@solana/web3.js";
+import { TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import BN from "bn.js";
+import {
+  KAMINO_LENDING_PROGRAM_ID,
+  KVAULT_PROGRAM_ID,
+  ALLEZ_USDC_VAULT,
+  ALLEZ_USDC_TOKEN_VAULT,
+  ALLEZ_USDC_VAULT_AUTHORITY,
+  ALLEZ_USDC_SHARES_MINT,
+  VAULT_LOOKUP_TABLE,
+  USDC_PRIME_VAULT,
+  USDC_PRIME_TOKEN_VAULT,
+  USDC_PRIME_VAULT_AUTHORITY,
+  USDC_PRIME_SHARES_MINT,
+  USDC_PRIME_LOOKUP_TABLE,
+  ROCKAWAY_RWA_VAULT,
+  ROCKAWAY_RWA_TOKEN_VAULT,
+  ROCKAWAY_RWA_VAULT_AUTHORITY,
+  ROCKAWAY_RWA_SHARES_MINT,
+  ROCKAWAY_RWA_LOOKUP_TABLE,
+  KVAULT_REMAINING_ACCOUNTS,
+  PRIME_BATCH_ACCOUNTS,
+  ROCKAWAY_BATCH_ACCOUNTS,
+  PERENA_PROGRAM_ID,
+  PERENA_VAULT_STATE,
+  PERENA_VAULT_AUTHORITY,
+  PERENA_POOL_CONFIG,
+  PERENA_VAULT_USDC_TRANSIT,
+  PERENA_VAULT_METADATA,
+  PERENA_FEE_COLLECTOR,
+  PERENA_MARGINFI_PROGRAM,
+  PERENA_MARGINFI_GROUP,
+  PERENA_MARGINFI_ACCOUNT,
+  PERENA_MARGINFI_BANK,
+  PERENA_MARGINFI_BANK_AUTHORITY,
+  PERENA_MARGINFI_BANK_LIQUIDITY_VAULT,
+  PERENA_MARGINFI_ORACLE,
+  STAR_USDC_MINT,
+  USDC_MINT,
+  VAULT_PROVIDER_KVAULT,
+  VAULT_PROVIDER_PERENA,
+} from "../constants";
+import { deriveKvaultEventAuthority, deriveMarketAuthority } from "../pdas";
+
+const [KVAULT_EVENT_AUTHORITY] = deriveKvaultEventAuthority();
+
+export type VaultType = "allez" | "prime" | "rockawayRWA" | "perena";
+
+export type VaultProvider = "kvault" | "perena";
+
+export interface VaultInfo {
+  vault: PublicKey;
+  tokenVault: PublicKey;
+  authority: PublicKey;
+  sharesMint: PublicKey;
+  lookupTable: PublicKey;
+  provider: VaultProvider;
+  batchAccounts: { pubkey: PublicKey; isSigner: boolean; isWritable: boolean }[];
+  withdrawFixed: { pubkey: PublicKey; isSigner: boolean; isWritable: boolean }[];
+}
+
+export function vaultProviderToU8(provider: VaultProvider): number {
+  return provider === "kvault" ? VAULT_PROVIDER_KVAULT : VAULT_PROVIDER_PERENA;
+}
+
+// Derive KVault global config PDA
+const [KVAULT_GLOBAL_CONFIG] = PublicKey.findProgramAddressSync(
+  [Buffer.from("global_config")],
+  KVAULT_PROGRAM_ID
+);
+
+/**
+ * Build KVault deposit vault_remaining:
+ * [token_vault, base_vault_authority, event_authority, kamino_program, kvault_program, ...batchAccounts]
+ */
+export function getKvaultDepositRemaining(vaultInfo: VaultInfo): AccountMeta[] {
+  return [
+    { pubkey: vaultInfo.tokenVault, isSigner: false, isWritable: true },
+    { pubkey: vaultInfo.authority, isSigner: false, isWritable: false },
+    { pubkey: KVAULT_EVENT_AUTHORITY, isSigner: false, isWritable: false },
+    { pubkey: KAMINO_LENDING_PROGRAM_ID, isSigner: false, isWritable: false },
+    { pubkey: KVAULT_PROGRAM_ID, isSigner: false, isWritable: false },
+    ...vaultInfo.batchAccounts,
+  ];
+}
+
+/**
+ * Build KVault withdraw vault_remaining:
+ * [kvault_global_config, token_vault, base_vault_authority, event_authority, kamino_program, kvault_program, ...withdrawFixed, ...batchAccounts]
+ */
+export function getKvaultWithdrawRemaining(vaultInfo: VaultInfo, withdrawFixed: AccountMeta[]): AccountMeta[] {
+  return [
+    { pubkey: KVAULT_GLOBAL_CONFIG, isSigner: false, isWritable: false },
+    { pubkey: vaultInfo.tokenVault, isSigner: false, isWritable: true },
+    { pubkey: vaultInfo.authority, isSigner: false, isWritable: false },
+    { pubkey: KVAULT_EVENT_AUTHORITY, isSigner: false, isWritable: false },
+    { pubkey: KAMINO_LENDING_PROGRAM_ID, isSigner: false, isWritable: false },
+    { pubkey: KVAULT_PROGRAM_ID, isSigner: false, isWritable: false },
+    ...withdrawFixed,
+    ...vaultInfo.batchAccounts,
+  ];
+}
+
+export function getVaultInfo(vaultType: VaultType): VaultInfo {
+  if (vaultType === "allez") {
+    return {
+      vault: ALLEZ_USDC_VAULT,
+      tokenVault: ALLEZ_USDC_TOKEN_VAULT,
+      authority: ALLEZ_USDC_VAULT_AUTHORITY,
+      sharesMint: ALLEZ_USDC_SHARES_MINT,
+      lookupTable: VAULT_LOOKUP_TABLE,
+      provider: "kvault",
+      batchAccounts: KVAULT_REMAINING_ACCOUNTS,
+      withdrawFixed: [], // resolved dynamically via resolveWithdrawFixed
+    };
+  } else if (vaultType === "prime") {
+    return {
+      vault: USDC_PRIME_VAULT,
+      tokenVault: USDC_PRIME_TOKEN_VAULT,
+      authority: USDC_PRIME_VAULT_AUTHORITY,
+      sharesMint: USDC_PRIME_SHARES_MINT,
+      lookupTable: USDC_PRIME_LOOKUP_TABLE,
+      provider: "kvault",
+      batchAccounts: PRIME_BATCH_ACCOUNTS,
+      withdrawFixed: [], // resolved dynamically via resolveWithdrawFixed
+    };
+  } else if (vaultType === "rockawayRWA") {
+    return {
+      vault: ROCKAWAY_RWA_VAULT,
+      tokenVault: ROCKAWAY_RWA_TOKEN_VAULT,
+      authority: ROCKAWAY_RWA_VAULT_AUTHORITY,
+      sharesMint: ROCKAWAY_RWA_SHARES_MINT,
+      lookupTable: ROCKAWAY_RWA_LOOKUP_TABLE,
+      provider: "kvault",
+      batchAccounts: ROCKAWAY_BATCH_ACCOUNTS,
+      withdrawFixed: [], // resolved dynamically via resolveWithdrawFixed
+    };
+  } else {
+    // Perena vault
+    return {
+      vault: PERENA_VAULT_STATE,
+      tokenVault: PERENA_VAULT_USDC_TRANSIT, // analogous to token vault
+      authority: PERENA_VAULT_AUTHORITY,
+      sharesMint: STAR_USDC_MINT,
+      lookupTable: PublicKey.default, // TODO: create Perena lookup table
+      provider: "perena",
+      batchAccounts: [], // Perena uses fixed accounts via getPerenaDepositAccounts/getPerenaWithdrawAccounts
+      withdrawFixed: [], // Perena uses fixed accounts via getPerenaWithdrawAccounts
+    };
+  }
+}
+
+// VaultState layout constants
+const ALLOC_STRATEGY_OFFSET = 312;
+const ALLOC_ENTRY_SIZE = 2160;
+const ALLOC_COUNT = 25;
+// ctokenAllocation at: reserve(32) + ctokenVault(32) + targetWeight(8) + tokenAllocCap(8) + ctokenVaultBump(8) + configPadding(127*8) = 1104
+const CTOKEN_ALLOC_OFFSET_IN_ENTRY = 32 + 32 + 8 + 8 + 8 + 127 * 8;
+
+type AccountMeta = { pubkey: PublicKey; isSigner: boolean; isWritable: boolean };
+
+/**
+ * Reads vault state on-chain, finds the allocation with the highest ctokenAllocation,
+ * reads that reserve to get lending_market / liquidity.supplyVault / collateral.mintPubkey,
+ * and returns the 11-account withdrawFixed array.
+ */
+export async function resolveWithdrawFixed(
+  connection: Connection,
+  vaultPubkey: PublicKey
+): Promise<AccountMeta[]> {
+  const vaultAcct = await connection.getAccountInfo(vaultPubkey);
+  if (!vaultAcct) throw new Error(`Vault account not found: ${vaultPubkey.toBase58()}`);
+
+  const data = vaultAcct.data;
+
+  let bestReserve: PublicKey | null = null;
+  let bestCtokenVault: PublicKey | null = null;
+  let bestAlloc = new BN(0);
+
+  for (let i = 0; i < ALLOC_COUNT; i++) {
+    const entryOffset = ALLOC_STRATEGY_OFFSET + i * ALLOC_ENTRY_SIZE;
+    if (entryOffset + ALLOC_ENTRY_SIZE > data.length) break;
+
+    const reserve = new PublicKey(data.slice(entryOffset, entryOffset + 32));
+    if (reserve.equals(PublicKey.default)) continue;
+
+    const ctokenVault = new PublicKey(data.slice(entryOffset + 32, entryOffset + 64));
+    const ctokenAlloc = new BN(
+      data.slice(
+        entryOffset + CTOKEN_ALLOC_OFFSET_IN_ENTRY,
+        entryOffset + CTOKEN_ALLOC_OFFSET_IN_ENTRY + 8
+      ),
+      "le"
+    );
+
+    if (ctokenAlloc.gt(bestAlloc)) {
+      bestAlloc = ctokenAlloc;
+      bestReserve = reserve;
+      bestCtokenVault = ctokenVault;
+    }
+  }
+
+  if (!bestReserve || !bestCtokenVault) {
+    throw new Error(`No non-empty allocation in vault ${vaultPubkey.toBase58()}`);
+  }
+
+  // Decode reserve to get lending_market, liquidity.supplyVault, collateral.mintPubkey.
+  // Manual offset reads (instead of klend-sdk Reserve.decode) so @hobba/core and the
+  // widget bundle carry no klend-sdk dependency. Layout traced from the klend borsh
+  // struct — same base offsets as kamino/obligationParser.ts:
+  //   8 disc + 8 version + 16 lastUpdate = 32 → lendingMarket (32 bytes)
+  //   ReserveLiquidity at 128: mintPubkey @128, supplyVault @160, feeVault @192
+  //   ReserveCollateral at 2560: mintPubkey @2560
+  const reserveAcct = await connection.getAccountInfo(bestReserve);
+  if (!reserveAcct) throw new Error(`Reserve not found: ${bestReserve.toBase58()}`);
+
+  const reserveData = reserveAcct.data;
+  const lendingMarket = new PublicKey(reserveData.slice(32, 64));
+  const liquiditySupply = new PublicKey(reserveData.slice(160, 192));
+  const collateralMint = new PublicKey(reserveData.slice(2560, 2592));
+  const [lendingMarketAuthority] = deriveMarketAuthority(lendingMarket);
+
+  return [
+    { pubkey: vaultPubkey, isSigner: false, isWritable: true },
+    { pubkey: bestReserve, isSigner: false, isWritable: true },
+    { pubkey: bestCtokenVault, isSigner: false, isWritable: true },
+    { pubkey: lendingMarket, isSigner: false, isWritable: false },
+    { pubkey: lendingMarketAuthority, isSigner: false, isWritable: false },
+    { pubkey: liquiditySupply, isSigner: false, isWritable: true },
+    { pubkey: collateralMint, isSigner: false, isWritable: true },
+    { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+    { pubkey: SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false },
+    { pubkey: KVAULT_EVENT_AUTHORITY, isSigner: false, isWritable: false },
+    { pubkey: KVAULT_PROGRAM_ID, isSigner: false, isWritable: false },
+  ];
+}
+
+export function identifyVaultType(vaultKey: PublicKey): VaultType | null {
+  if (vaultKey.equals(ALLEZ_USDC_VAULT)) return "allez";
+  if (vaultKey.equals(USDC_PRIME_VAULT)) return "prime";
+  if (vaultKey.equals(ROCKAWAY_RWA_VAULT)) return "rockawayRWA";
+  if (vaultKey.equals(PERENA_VAULT_STATE)) return "perena";
+  return null;
+}
+
+export function identifyVaultProvider(vaultKey: PublicKey): VaultProvider {
+  if (vaultKey.equals(PERENA_VAULT_STATE)) return "perena";
+  return "kvault";
+}
+
+/**
+ * Build the 16-account list for Perena deposit (mint_w_yielding_gen).
+ * These go into remaining_accounts when vault_provider = 1 (Perena).
+ * 15 instruction accounts + Perena program for CPI resolution.
+ * MarginFi accounts are omitted — Perena's crank will deploy capital later.
+ * This matches the Perena frontend behavior and avoids MarginFi ProtocolPaused errors.
+ */
+export function getPerenaDepositAccounts(
+  pdaKey: PublicKey,
+  pdaUsdcAta: PublicKey,
+  pdaStarAta: PublicKey,
+): AccountMeta[] {
+  return [
+    { pubkey: pdaKey, isSigner: false, isWritable: true },                    // 0: user/pda (signer set by CPI)
+    { pubkey: PERENA_VAULT_STATE, isSigner: false, isWritable: true },        // 1: vault_state
+    { pubkey: PERENA_VAULT_AUTHORITY, isSigner: false, isWritable: true },    // 2: vault_authority PDA
+    { pubkey: PERENA_POOL_CONFIG, isSigner: false, isWritable: false },       // 3: pool/config
+    { pubkey: USDC_MINT, isSigner: false, isWritable: false },                // 4: USDC mint
+    { pubkey: STAR_USDC_MINT, isSigner: false, isWritable: true },            // 5: star* mint
+    { pubkey: pdaUsdcAta, isSigner: false, isWritable: true },                // 6: user USDC account
+    { pubkey: pdaStarAta, isSigner: false, isWritable: true },                // 7: user star* account
+    { pubkey: PERENA_VAULT_USDC_TRANSIT, isSigner: false, isWritable: true }, // 8: vault USDC transit
+    { pubkey: PERENA_FEE_COLLECTOR, isSigner: false, isWritable: true },      // 9: team_state (fee collector)
+    { pubkey: PERENA_VAULT_METADATA, isSigner: false, isWritable: true },     // 10: perena vault metadata
+    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },  // 11: system program
+    { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },         // 12: token program
+    { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },         // 13: token program (duplicate)
+    { pubkey: new PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"), isSigner: false, isWritable: false }, // 14: ATA program
+    { pubkey: PERENA_PROGRAM_ID, isSigner: false, isWritable: false },        // 15: perena program (for CPI resolution)
+  ];
+}
+
+/**
+ * Build the 16-account list for Perena withdraw (burn_for_yielding_gen) WITHOUT
+ * MarginFi. Use this only as a fallback when MarginFi is paused — otherwise
+ * Perena can only pay out from its small USDC transit buffer and will fail
+ * with `insufficient funds` when that buffer is drained between crank runs.
+ *
+ * Prefer `getPerenaWithdrawAccountsWithMarginfi` for normal operation.
+ *
+ * 15 instruction accounts + Perena program for CPI resolution.
+ */
+export function getPerenaWithdrawAccounts(
+  pdaKey: PublicKey,
+  pdaUsdcAta: PublicKey,
+  pdaStarAta: PublicKey,
+): AccountMeta[] {
+  return [
+    { pubkey: pdaKey, isSigner: false, isWritable: true },                    // 0: user/pda (signer set by CPI)
+    { pubkey: PERENA_VAULT_STATE, isSigner: false, isWritable: true },        // 1: vault_state
+    { pubkey: PERENA_VAULT_AUTHORITY, isSigner: false, isWritable: true },    // 2: vault_authority PDA
+    { pubkey: PERENA_POOL_CONFIG, isSigner: false, isWritable: false },       // 3: pool/config
+    { pubkey: USDC_MINT, isSigner: false, isWritable: false },                // 4: USDC mint
+    { pubkey: STAR_USDC_MINT, isSigner: false, isWritable: true },            // 5: star* mint (burned)
+    { pubkey: pdaUsdcAta, isSigner: false, isWritable: true },                // 6: user USDC account (destination)
+    { pubkey: pdaStarAta, isSigner: false, isWritable: true },                // 7: user star* account (burned from)
+    { pubkey: PERENA_VAULT_USDC_TRANSIT, isSigner: false, isWritable: true }, // 8: vault USDC transit
+    { pubkey: PERENA_FEE_COLLECTOR, isSigner: false, isWritable: true },      // 9: fee collector
+    { pubkey: PERENA_VAULT_METADATA, isSigner: false, isWritable: true },     // 10: fee destination secondary
+    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },  // 11: system program
+    { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },         // 12: token program
+    { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },         // 13: token program (duplicate)
+    { pubkey: new PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"), isSigner: false, isWritable: false }, // 14: ATA program
+    { pubkey: PERENA_PROGRAM_ID, isSigner: false, isWritable: false },        // 15: perena program (for CPI resolution)
+  ];
+}
+
+/**
+ * Build the 24-account list for Perena withdraw (burn_for_yielding_gen) WITH
+ * MarginFi. This is the **default** for our flows: when the Perena USDC transit
+ * buffer is insufficient to cover the requested amount, Perena uses the
+ * MarginFi accounts to pull deployed capital back, so withdrawals don't fail.
+ *
+ * If MarginFi is paused (Perena's internal ProtocolPaused error), fall back to
+ * `getPerenaWithdrawAccounts` and retry after the next crank.
+ *
+ * 15 instruction accounts + 8 MarginFi (incl. oracle) + Perena program.
+ * MarginFi's LendingAccountWithdraw needs 1 oracle per active balance slot in
+ * Perena's marginfi account; Perena holds 2 balance slots, both USDC, so we
+ * pass the USDC oracle (position 22) and MarginFi reads it twice.
+ */
+export function getPerenaWithdrawAccountsWithMarginfi(
+  pdaKey: PublicKey,
+  pdaUsdcAta: PublicKey,
+  pdaStarAta: PublicKey,
+): AccountMeta[] {
+  const ATA_PROGRAM_ID = new PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+  return [
+    { pubkey: pdaKey, isSigner: false, isWritable: true },                         // 0:  user/pda
+    { pubkey: PERENA_VAULT_STATE, isSigner: false, isWritable: true },             // 1:  vault_state
+    { pubkey: PERENA_VAULT_AUTHORITY, isSigner: false, isWritable: true },         // 2:  vault_authority
+    { pubkey: PERENA_POOL_CONFIG, isSigner: false, isWritable: false },            // 3:  pool/config
+    { pubkey: USDC_MINT, isSigner: false, isWritable: false },                     // 4:  USDC mint
+    { pubkey: STAR_USDC_MINT, isSigner: false, isWritable: true },                 // 5:  star* mint (burned)
+    { pubkey: pdaUsdcAta, isSigner: false, isWritable: true },                     // 6:  user USDC dest
+    { pubkey: pdaStarAta, isSigner: false, isWritable: true },                     // 7:  user star* src
+    { pubkey: PERENA_VAULT_USDC_TRANSIT, isSigner: false, isWritable: true },      // 8:  USDC transit
+    { pubkey: PERENA_FEE_COLLECTOR, isSigner: false, isWritable: true },           // 9:  fee collector
+    { pubkey: PERENA_VAULT_METADATA, isSigner: false, isWritable: true },          // 10: fee secondary
+    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },       // 11: system program
+    { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },              // 12: token program
+    { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },              // 13: token program (dup)
+    { pubkey: ATA_PROGRAM_ID, isSigner: false, isWritable: false },                // 14: ATA program
+    { pubkey: PERENA_MARGINFI_PROGRAM, isSigner: false, isWritable: false },       // 15: marginfi program
+    { pubkey: PERENA_MARGINFI_GROUP, isSigner: false, isWritable: true },          // 16: marginfi group
+    { pubkey: PERENA_MARGINFI_ACCOUNT, isSigner: false, isWritable: true },        // 17: marginfi account
+    { pubkey: PERENA_MARGINFI_BANK, isSigner: false, isWritable: true },           // 18: marginfi bank
+    { pubkey: PERENA_MARGINFI_BANK_AUTHORITY, isSigner: false, isWritable: false },// 19: marginfi bank authority
+    { pubkey: PERENA_MARGINFI_BANK_LIQUIDITY_VAULT, isSigner: false, isWritable: true }, // 20: marginfi bank liquidity vault
+    { pubkey: PERENA_MARGINFI_BANK, isSigner: false, isWritable: true },           // 21: marginfi bank (oracle-paired bank for balance slot 1)
+    { pubkey: PERENA_MARGINFI_ORACLE, isSigner: false, isWritable: false },        // 22: marginfi USDC oracle
+    { pubkey: PERENA_PROGRAM_ID, isSigner: false, isWritable: false },             // 23: perena program (CPI resolution)
+  ];
+}

package/src/wallet.ts

@@ -0,0 +1,12 @@
+import type { PublicKey, Transaction, VersionedTransaction } from "@solana/web3.js";
+
+/**
+ * Minimal wallet capability the deposit/borrow flow needs: a public key plus the
+ * ability to sign a (legacy or versioned) transaction. Both the app's
+ * wallet-adapter `WalletContextState` and a raw injected provider (window.solana /
+ * window.solflare) structurally satisfy this, so neither consumer needs a cast.
+ */
+export interface HobbaSigner {
+  publicKey: PublicKey | null;
+  signTransaction?: <T extends Transaction | VersionedTransaction>(tx: T) => Promise<T>;
+}