@exponent-labs/exponent-sdk 0.9.0 → 0.9.2

package/src/exponentVaults/loopscale-client.ts

@@ -1,1373 +0,0 @@
-import {
-  type AccountMeta,
-  type Commitment,
-  type Finality,
-  type SendOptions,
-  type Signer,
-  ComputeBudgetProgram,
-  Connection,
-  PublicKey,
-  SystemProgram,
-  TransactionInstruction,
-  TransactionMessage,
-  VersionedMessage,
-  VersionedTransaction,
-} from "@solana/web3.js"
-
-import { LOOPSCALE_DISCRIMINATORS, LOOPSCALE_PROGRAM_ID } from "./policyBuilders"
-import { type LoopscaleInstruction, LoopscaleAction, loopscaleAction, createVaultSyncTransaction } from "./vault-interaction"
-
-// ============================================================================
-// Constants
-// ============================================================================
-
-const LOOPSCALE_API_BASE_URL = "https://tars.loopscale.com/v1"
-const BS_AUTH = new PublicKey("CyNKPfqsSLAejjZtEeNG3pR4SkPhSPHXdGhuNTyudrNs")
-const ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL")
-
-// ============================================================================
-// Types — Config
-// ============================================================================
-
-export interface LoopscaleClientConfig {
-  connection: Connection
-  /** Wallet address sent as `user-wallet` / `payer` header to the Loopscale API. */
-  userWallet: PublicKey | string
-  /** Loopscale API base URL (default: https://tars.loopscale.com/v1). */
-  baseUrl?: string
-  /** Known bs_auth public key (default: CyNKPf...). */
-  bsAuth?: PublicKey
-  /** Use Luke's batch-based MPC endpoint for co-signing (default: true). */
-  useMpcCoSign?: boolean
-  /** Log request/response details to console. */
-  debug?: boolean
-}
-
-// ============================================================================
-// Types — API params
-// ============================================================================
-
-export interface LoopscaleQuoteParams {
-  durationType: number
-  duration: number
-  principal: PublicKey | string
-  collateral: (PublicKey | string)[]
-  limit?: number
-  offset?: number
-}
-
-export interface LoopscaleCreateStrategyParams {
-  principalMint: PublicKey | string
-  lender: PublicKey | string
-  amount: bigint | number
-  originationsEnabled?: boolean
-  liquidityBuffer?: number
-  interestFee?: number
-  originationFee?: number
-  originationCap?: number
-  collateralTerms?: Array<{
-    apy: number
-    indices: Array<{ collateralIndex: number; durationIndex: number }>
-  }>
-  marketInformation?: PublicKey | string
-  externalYieldSourceArgs?: TxnExternalYieldSourceArgs
-}
-
-export interface LoopscaleDepositStrategyParams {
-  strategy: PublicKey | string
-  amount: bigint | number
-}
-
-export interface LoopscaleWithdrawStrategyParams {
-  strategy: PublicKey | string
-  amount: bigint | number
-  withdrawAll: boolean
-}
-
-export interface LoopscaleCloseStrategyParams {
-  strategy: PublicKey | string
-}
-
-export interface ExternalYieldSourceParams {
-  newExternalYieldSource: number
-}
-
-export interface TxnExternalYieldSourceArgs extends ExternalYieldSourceParams {
-  createExternalYieldAccount: boolean
-}
-
-export interface StrategyDuration {
-  duration: number
-  durationType: number
-}
-
-export interface AddCollateralArgs {
-  durationsAndApys?: Record<string, string>
-  externalMarketInformationAddress?: string
-  marketInformation?: Record<string, unknown>
-}
-
-export interface RemoveCollateralArgs {
-  durations: StrategyDuration[]
-  removeFromMarketInformation: boolean
-}
-
-export interface CollateralParamsUpdateArgs {
-  ltvUpdate?: Record<string, unknown>
-  apyUpdate?: Record<string, string>
-}
-
-export interface CollateralAllocationUpdateArgs {
-  assetIdentifier: string
-  maxAllocationPct: string
-}
-
-export interface StrategyCollateralUpdates {
-  addCollateral?: Record<string, AddCollateralArgs>
-  removeCollateral?: Record<string, RemoveCollateralArgs>
-  updateCollateral?: Record<string, CollateralParamsUpdateArgs>
-  updateAssetAllocation?: CollateralAllocationUpdateArgs[]
-}
-
-export interface EditStrategySettingsArgs {
-  originationsEnabled?: boolean
-  liquidityBuffer?: number
-  interestFee?: number
-  originationFee?: number
-  principalFee?: number
-  originationCap?: number
-  externalYieldSource?: ExternalYieldSourceParams
-}
-
-export interface LoopscaleUpdateStrategyParams {
-  strategy: PublicKey | string
-  collateralTerms?: StrategyCollateralUpdates
-  updateParams?: EditStrategySettingsArgs
-}
-
-export interface LoopscaleBorrowPrincipalParams {
-  /** Borrower / vault address (also the payer for ATA creation). */
-  borrower: PublicKey | string
-  /** Existing loan with collateral already deposited. */
-  loan: PublicKey | string
-  /** Strategy supplying principal liquidity. */
-  strategy: PublicKey | string
-  /** MarketInformation account for the borrow strategy. */
-  marketInformation: PublicKey | string
-  /** Mint of the borrowed asset. */
-  principalMint: PublicKey | string
-  /** Amount of principal to borrow (lamports). */
-  amount: bigint | number
-  /** Duration index (0=1day, 1=1week, 2=1month, 3=3months, 4=5min). */
-  durationIndex: number
-  /** Byte buffer consumed by sync_risk_matrices + validate_loan_health. */
-  assetIndexGuidance: number[]
-  /** Oracle remaining accounts for health check (MarketInformation + oracle pubkeys). */
-  healthCheckAccounts: AccountMeta[]
-  expectedApy?: bigint | number
-  /** Expected liquidation thresholds per collateral index [5 entries]. */
-  expectedLqt?: number[]
-  /** Keep result as wSOL instead of unwrapping (default: false). */
-  skipSolUnwrap?: boolean
-}
-
-export interface LoopscaleRepayLoanParams {
-  loan: PublicKey | string
-  repayParams: Array<{
-    amount: bigint | number
-    ledgerIndex: number
-    repayAll: boolean
-  }>
-  collateralWithdrawalParams?: Array<{
-    amount: bigint | number
-    collateralMint: PublicKey | string
-  }>
-  closeIfPossible?: boolean
-}
-
-export interface LoopscaleCloseLoanParams {
-  loan: PublicKey | string
-}
-
-export interface LoopscaleCreateLoanParams {
-  borrower: PublicKey | string
-  depositCollateral: Array<{
-    collateralAmount: bigint | number
-    collateralAssetData: { Spl: { mint: string } } | { Orca: { positionMint: string; whirlpool: string } }
-  }>
-  principalRequested: Array<{
-    ledgerIndex: number
-    principalAmount: bigint | number
-    principalMint: PublicKey | string
-    strategy: PublicKey | string
-    durationIndex: number
-    expectedLoanValues?: { expectedApy?: number; expectedLqt?: number[] }
-  }>
-  assetIndexGuidance?: number[]
-  loanNonce?: string
-  isLoop?: boolean
-}
-
-export interface LoopscaleApiBorrowPrincipalParams {
-  loan: PublicKey | string
-  borrowParams: {
-    amount: bigint | number
-    durationIndex: number
-    expectedLoanValues?: { expectedApy?: number; expectedLqt?: number[] }
-  }
-  strategy: PublicKey | string
-  refinanceParams?: { ledgerIndex: number; durationIndex: number }
-  isLoop?: boolean
-}
-
-export interface LoopscaleDepositCollateralParams {
-  loan: PublicKey | string
-  depositMint: PublicKey | string
-  amount: bigint | number
-  assetType: number
-  assetIdentifier: PublicKey | string
-  assetIndexGuidance?: number[]
-  expectedLoanValues?: { expectedApy?: number; expectedLqt?: number[] }
-}
-
-export interface LoopscaleWithdrawCollateralParams {
-  loan: PublicKey | string
-  collateralMint: PublicKey | string
-  amount: bigint | number
-  collateralIndex: number
-  expectedLoanValues?: { expectedApy?: number; expectedLqt?: number[] }
-  assetIndexGuidance?: number[]
-}
-
-export interface LoopscaleRefinanceLoanParams {
-  loan: PublicKey | string
-  oldStrategy: PublicKey | string
-  newStrategy: PublicKey | string
-  refinanceParams: { ledgerIndex: number; durationIndex: number }
-}
-
-// ── Data query types ──
-
-export interface LoopscaleMaxQuoteParams {
-  durationType: number
-  duration: number
-  principalMint: PublicKey | string
-  collateralFilter: Array<{
-    amount: bigint | number
-    assetData: { Spl: { mint: string } } | { Orca: { positionMint: string; whirlpool: string } }
-  }>
-}
-
-export interface LoopscaleMaxQuote {
-  apy: number
-  strategy: string
-  collateralIdentifier: string
-  ltv: number
-  lqt: number
-  amount: number
-}
-
-export interface LoopscaleLoanInfoParams {
-  loanAddresses?: string[]
-  lenders?: string[]
-  borrowers?: string[]
-  filterType?: number
-  principalMints?: string[]
-  collateralMints?: string[]
-  orderFundingType?: number
-  page?: number
-  pageSize?: number
-  sortDirection?: number
-  sortType?: number
-  assetTypes?: number
-  excludeCollateralIdentifiers?: string[]
-  excludePrincipalMints?: string[]
-}
-
-export interface LoopscaleLoanInfoResponse {
-  totalCount: number
-  loanInfos: Array<{
-    loan: { address: string; loanStatus: number; borrower: string; startTime: number; [key: string]: unknown }
-    loanType: number
-    ledgers: Array<{ ledgerIndex: number; strategy: string; principalMint: string; principalDue: number; interestOutstanding: number; apy: number; endTime: number; [key: string]: unknown }>
-    collateral: Array<{ assetMint: string; amount: number; assetType: number; [key: string]: unknown }>
-    [key: string]: unknown
-  }>
-}
-
-export interface LoopscaleGetStrategiesParams {
-  userAddress?: string
-  addresses?: string[]
-  principalMints?: string[]
-  page?: number
-  pageSize?: number
-}
-
-export interface LoopscaleStrategyInfoResponse {
-  strategies: Array<{
-    strategy: { address: string; principalMint: string; tokenBalance: number; currentDeployedAmount: number; outstandingInterestAmount: number; [key: string]: unknown }
-    externalYieldInfo?: { apy: number }
-  }>
-  total: number
-}
-
-export interface LoopscaleCollateralHoldersParams {
-  mints: string[]
-  pdas?: boolean
-}
-
-export interface LoopscaleCollateralHolder {
-  collateralMint: string
-  totalDeposits: number
-  userDeposits: Record<string, number>
-}
-
-export interface LoopscaleHistoricalCollateralHoldersParams {
-  mint: string
-  rangeStart?: number
-  rangeEnd?: number
-  pdas?: boolean
-}
-
-export interface LoopscaleHistoricalCollateralHolder {
-  collateralMint: string
-  rangeStart: number
-  rangeEnd: number
-  userDepositSeconds: Record<string, number>
-}
-
-export interface LoopscaleVaultDepositorsParams {
-  vaultAddresses?: string[]
-  principalMints?: string[]
-}
-
-export interface LoopscaleVaultDepositor {
-  vaultAddress: string
-  userDeposits: Array<{ userAddress: string; amountSupplied: string }>
-}
-
-export interface LoopscaleVaultInfoParams {
-  vaultAddresses?: string[]
-  vaultIdentifiers?: string[]
-  principalMints?: string[]
-  includeRewards?: boolean
-  page: number
-  pageSize: number
-}
-
-export interface LoopscaleVaultInfoResponse {
-  lendVaults: Array<{
-    vault: { address: string; vaultIdentifier: string; principalMint: string; lpMint: string }
-    vaultMetadata: { name: string; description: string; managerName: string; depositCap: number }
-    vaultStrategy: { strategy: { address: string; tokenBalance: number; currentDeployedAmount: number; [key: string]: unknown } }
-    [key: string]: unknown
-  }>
-  total: number
-}
-
-export interface LoopscaleLoopInfoParams {
-  loopVaults?: string[]
-  tags?: string[]
-}
-
-export interface LoopscaleLoopVaultInfo {
-  collateralMint: string
-  principalMint: string
-  collateralDeposited: number
-  collateralApyPct: number
-  maxLeverage: number
-  name: string
-  maxLeveragedApyPct: number
-  principalAmountAvailable: number
-  [key: string]: unknown
-}
-
-// ============================================================================
-// Types — Results
-// ============================================================================
-
-export interface LoopscaleGeneratedInstruction {
-  name: LoopscaleInstructionName | null
-  instruction: TransactionInstruction
-}
-
-export interface LoopscaleGeneratedInstructionBundle {
-  transaction: VersionedTransaction
-  instructions: TransactionInstruction[]
-  loopscaleInstructions: LoopscaleGeneratedInstruction[]
-}
-
-export interface LoopscaleTxResult {
-  /** Loopscale instructions wrapped via loopscaleAction.* — ready for createVaultSyncTransaction. */
-  syncActions: LoopscaleInstruction[]
-  /** Non-Loopscale instructions that belong outside the sync tx (compute budget, etc.). */
-  topLevelInstructions: TransactionInstruction[]
-  /** Raw decompiled bundle. */
-  raw: LoopscaleGeneratedInstructionBundle
-}
-
-export interface LoopscaleStrategyBatch {
-  /** Loopscale instructions wrapped via loopscaleAction.* — ready for createVaultSyncTransaction. */
-  syncActions: LoopscaleInstruction[]
-  /** Non-Loopscale instructions that belong outside the sync tx (compute budget, oracles, etc.). */
-  topLevelInstructions: TransactionInstruction[]
-  /** Setup instructions returned by Loopscale that should not be wrapped in the sync tx. */
-  setupInstructions: TransactionInstruction[]
-  /** Raw decompiled batch. */
-  raw: LoopscaleGeneratedInstructionBundle
-}
-
-export interface LoopscaleStrategyBatchesResult {
-  batches: LoopscaleStrategyBatch[]
-}
-
-export interface LoopscaleStrategyResult extends LoopscaleStrategyBatchesResult {
-  strategyAddress: PublicKey
-  noncePublicKey: PublicKey
-}
-
-export interface LoopscaleUpdateStrategyResult extends LoopscaleStrategyBatchesResult {}
-
-export interface LoopscaleCreateLoanResult extends LoopscaleTxResult {
-  loanAddress: PublicKey
-}
-
-export interface VaultExecutionContext {
-  owner: PublicKey
-  vaultPda: PublicKey
-  signer: PublicKey
-  signers: Signer[]
-  vaultAddress?: PublicKey
-  accountIndex?: number
-  policyPda?: PublicKey
-  constraintIndices?: number[]
-  leadingAccounts?: PublicKey[] | AccountMeta[]
-  preHookAccounts?: PublicKey[] | AccountMeta[]
-  postHookAccounts?: PublicKey[] | AccountMeta[]
-  squadsProgram?: PublicKey
-  addressLookupTableAccounts?: import("@solana/web3.js").AddressLookupTableAccount[]
-  prependInstructions?: TransactionInstruction[]
-  sendOptions?: SendOptions
-  commitment?: Commitment
-}
-
-export interface BatchExecutionResult {
-  batchIndex: number
-  signature: string
-  logs: string[] | null
-  error: unknown
-}
-
-export interface ExecutionResult {
-  error: unknown
-  results: BatchExecutionResult[]
-}
-
-export interface ClassifiedInstructions {
-  /** Loopscale instructions to wrap in sync tx. */
-  loopscale: LoopscaleGeneratedInstruction[]
-  /** Compute budget, oracles, etc. for outer tx. */
-  topLevel: TransactionInstruction[]
-  /** ATA creation etc. — safe to skip. */
-  setup: TransactionInstruction[]
-}
-
-export interface LoopscaleQuote {
-  apy: number
-  ltv: number
-  liquidationThreshold: number
-  maxPrincipalAvailable: number
-  strategy?: string
-  [key: string]: unknown
-}
-
-// ============================================================================
-// Discriminator helpers
-// ============================================================================
-
-type LoopscaleInstructionName =
-  | "createLoan"
-  | "depositCollateral"
-  | "borrowPrincipal"
-  | "repayPrincipal"
-  | "withdrawCollateral"
-  | "closeLoan"
-  | "updateWeightMatrix"
-  | "lockLoan"
-  | "unlockLoan"
-  | "createStrategy"
-  | "depositStrategy"
-  | "withdrawStrategy"
-  | "closeStrategy"
-  | "updateStrategy"
-  | "refinanceLedger"
-
-const DISCRIMINATOR_HEX_TO_NAME = new Map<string, LoopscaleInstructionName>(
-  Object.entries(LOOPSCALE_DISCRIMINATORS).map(([name, buf]) => [
-    Buffer.from(buf).toString("hex"),
-    name as LoopscaleInstructionName,
-  ]),
-)
-
-const NAME_TO_ACTION_WRAPPER: Record<LoopscaleInstructionName, (ix: TransactionInstruction) => LoopscaleInstruction> = {
-  createLoan: (ix) => loopscaleAction.createLoan({ instruction: ix }),
-  depositCollateral: (ix) => loopscaleAction.depositCollateral({ instruction: ix }),
-  borrowPrincipal: (ix) => loopscaleAction.borrowPrincipal({ instruction: ix }),
-  repayPrincipal: (ix) => loopscaleAction.repayPrincipal({ instruction: ix }),
-  withdrawCollateral: (ix) => loopscaleAction.withdrawCollateral({ instruction: ix }),
-  closeLoan: (ix) => loopscaleAction.closeLoan({ instruction: ix }),
-  updateWeightMatrix: (ix) => loopscaleAction.updateWeightMatrix({ instruction: ix }),
-  createStrategy: (ix) => loopscaleAction.createStrategy({ instruction: ix }),
-  depositStrategy: (ix) => loopscaleAction.depositStrategy({ instruction: ix }),
-  withdrawStrategy: (ix) => loopscaleAction.withdrawStrategy({ instruction: ix }),
-  closeStrategy: (ix) => loopscaleAction.closeStrategy({ instruction: ix }),
-  updateStrategy: (ix) => loopscaleAction.updateStrategy({ instruction: ix }),
-  lockLoan: (ix) => loopscaleAction.lockLoan({ instruction: ix }),
-  unlockLoan: (ix) => loopscaleAction.unlockLoan({ instruction: ix }),
-  refinanceLedger: (ix) => loopscaleAction.refinanceLedger({ instruction: ix }),
-}
-
-interface LoopscaleLegacyTransactionEntry {
-  message: string
-  signatures: Array<{ publicKey: string; signature: string }>
-}
-
-// ============================================================================
-// Internal helpers
-// ============================================================================
-
-function toBase58(value: PublicKey | string): string {
-  return typeof value === "string" ? value : value.toBase58()
-}
-
-function toSafeNumber(value: bigint | number, field: string): number {
-  if (typeof value === "bigint") {
-    if (value < 0n) throw new Error(`${field} must be non-negative`)
-    if (value > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error(`${field} too large for JSON integer`)
-    return Number(value)
-  }
-  if (!Number.isInteger(value) || value < 0) throw new Error(`${field} must be a non-negative integer`)
-  return value
-}
-
-function isEmptySignature(sig: Uint8Array): boolean {
-  return sig.every((b) => b === 0)
-}
-
-function identifyInstruction(ix: TransactionInstruction): LoopscaleInstructionName | null {
-  if (!ix.programId.equals(LOOPSCALE_PROGRAM_ID)) return null
-  const hex = Buffer.from(ix.data).subarray(0, 8).toString("hex")
-  return DISCRIMINATOR_HEX_TO_NAME.get(hex) ?? null
-}
-
-async function decompileInstructions(
-  connection: Connection,
-  transaction: VersionedTransaction,
-): Promise<TransactionInstruction[]> {
-  const lookupTableAccounts = await Promise.all(
-    transaction.message.addressTableLookups.map(async (lookup) => {
-      const result = await connection.getAddressLookupTable(lookup.accountKey)
-      if (!result.value) {
-        throw new Error(`Missing lookup table ${lookup.accountKey.toBase58()}`)
-      }
-      return result.value
-    }),
-  )
-  return TransactionMessage.decompile(transaction.message, { addressLookupTableAccounts: lookupTableAccounts }).instructions
-}
-
-function buildTxFromLegacyEntry(entry: {
-  message: string
-  signatures: Array<{ publicKey: string; signature: string }>
-}): VersionedTransaction {
-  const message = VersionedMessage.deserialize(Buffer.from(entry.message, "base64"))
-  const tx = new VersionedTransaction(message)
-  const signerKeys = message.staticAccountKeys.slice(0, message.header.numRequiredSignatures)
-
-  for (const sig of entry.signatures) {
-    const pubkey = new PublicKey(sig.publicKey)
-    const sigBytes = Buffer.from(sig.signature, "base64")
-    if (sigBytes.length !== 64) throw new Error(`Invalid signature for ${pubkey.toBase58()}`)
-    const idx = signerKeys.findIndex((k) => k.equals(pubkey))
-    if (idx >= 0) tx.signatures[idx] = new Uint8Array(sigBytes)
-  }
-  return tx
-}
-
-function mergeInputSignatures(
-  resultTx: VersionedTransaction,
-  inputTx: VersionedTransaction,
-): VersionedTransaction {
-  const signerKeys = resultTx.message.staticAccountKeys.slice(0, resultTx.message.header.numRequiredSignatures)
-  const inputKeys = inputTx.message.staticAccountKeys
-  const inputNumSigners = inputTx.message.header.numRequiredSignatures
-
-  for (let i = 0; i < inputNumSigners; i++) {
-    const inputSig = inputTx.signatures[i]
-    if (isEmptySignature(inputSig)) continue
-    const resultIdx = signerKeys.findIndex((key) => key.equals(inputKeys[i]))
-    if (resultIdx < 0) continue
-    if (isEmptySignature(resultTx.signatures[resultIdx])) {
-      resultTx.signatures[resultIdx] = inputSig
-    }
-  }
-  return resultTx
-}
-
-function ensureMessageMatches(a: VersionedTransaction, b: VersionedTransaction): void {
-  const am = Buffer.from(a.message.serialize())
-  const bm = Buffer.from(b.message.serialize())
-  if (!am.equals(bm)) {
-    throw new Error("Loopscale returned a different transaction message; refusing to merge")
-  }
-}
-
-// ============================================================================
-// LoopscaleClient
-// ============================================================================
-
-export class LoopscaleClient {
-  private readonly connection: Connection
-  private readonly baseUrl: string
-  private readonly userWallet: string
-  private readonly bsAuth: PublicKey
-  private readonly useMpcCoSign: boolean
-  private readonly debug: boolean
-  private vaultCtx: VaultExecutionContext | null = null
-
-  constructor(config: LoopscaleClientConfig) {
-    this.connection = config.connection
-    this.baseUrl = config.baseUrl ?? LOOPSCALE_API_BASE_URL
-    this.userWallet = toBase58(config.userWallet)
-    this.bsAuth = config.bsAuth ?? BS_AUTH
-    this.useMpcCoSign = config.useMpcCoSign ?? true
-    this.debug = config.debug ?? false
-  }
-
-  // ── Vault execution context ──
-
-  setVaultContext(ctx: VaultExecutionContext): void {
-    this.vaultCtx = ctx
-  }
-
-  private requireVaultContext(): VaultExecutionContext {
-    if (!this.vaultCtx) {
-      throw new Error("LoopscaleClient: call setVaultContext() before executeBatches/executeSyncTx")
-    }
-    return this.vaultCtx
-  }
-
-  async executeBatches(batches: LoopscaleStrategyBatch[]): Promise<ExecutionResult> {
-    const ctx = this.requireVaultContext()
-    const commitment = ctx.commitment ?? "confirmed"
-    const results: BatchExecutionResult[] = []
-
-    for (const [batchIndex, batch] of batches.entries()) {
-      const result = batch.syncActions.length === 0
-        ? await this.executePrebuiltBatch(batch, batchIndex, commitment)
-        : await this.executeSyncBatch(batch, batchIndex, ctx, commitment)
-
-      results.push(result)
-      if (result.error) {
-        return { error: result.error, results }
-      }
-    }
-
-    return { error: null, results }
-  }
-
-  async executeSyncTx(syncActions: LoopscaleInstruction[]): Promise<BatchExecutionResult> {
-    const ctx = this.requireVaultContext()
-    const commitment = ctx.commitment ?? "confirmed"
-    return this.executeSyncBatch(
-      { syncActions, topLevelInstructions: [], setupInstructions: [] },
-      0, ctx, commitment,
-    )
-  }
-
-  private async executePrebuiltBatch(
-    batch: LoopscaleStrategyBatch,
-    batchIndex: number,
-    commitment: Commitment,
-  ): Promise<BatchExecutionResult> {
-    const ctx = this.requireVaultContext()
-    const tx = batch.raw.transaction
-    const signerKeys = tx.message.staticAccountKeys.slice(0, tx.message.header.numRequiredSignatures)
-    const available = new Map(ctx.signers.map((s) => [s.publicKey.toBase58(), s]))
-    const local = signerKeys.map((k) => available.get(k.toBase58())).filter((s): s is Signer => Boolean(s))
-
-    if (local.length > 0) tx.sign(local)
-
-    const missing = signerKeys.filter((_, i) => tx.signatures[i]?.every((b) => b === 0))
-    if (missing.length > 0) {
-      throw new Error(`batch ${batchIndex + 1}: missing signer(s): ${missing.map((k) => k.toBase58()).join(", ")}`)
-    }
-
-    return { batchIndex, ...(await this.sendAndConfirm(tx, ctx.sendOptions, { commitment })) }
-  }
-
-  private async executeSyncBatch(
-    batch: Pick<LoopscaleStrategyBatch, "syncActions" | "topLevelInstructions" | "setupInstructions">,
-    batchIndex: number,
-    ctx: VaultExecutionContext,
-    commitment: Commitment,
-  ): Promise<BatchExecutionResult> {
-    const syncResult = await createVaultSyncTransaction({
-      instructions: batch.syncActions,
-      owner: ctx.owner,
-      connection: this.connection,
-      policyPda: ctx.policyPda,
-      vaultPda: ctx.vaultPda,
-      signer: ctx.signer,
-      accountIndex: ctx.accountIndex,
-      constraintIndices: ctx.constraintIndices,
-      vaultAddress: ctx.vaultAddress,
-      leadingAccounts: ctx.leadingAccounts,
-      preHookAccounts: ctx.preHookAccounts,
-      postHookAccounts: ctx.postHookAccounts,
-      squadsProgram: ctx.squadsProgram,
-    })
-
-    if (syncResult.setupInstructions.length > 0) {
-      throw new Error(`batch ${batchIndex + 1}: unexpected sync setupInstructions (${syncResult.setupInstructions.length})`)
-    }
-
-    const { blockhash, lastValidBlockHeight } = await this.connection.getLatestBlockhash(commitment)
-    const msg = new TransactionMessage({
-      payerKey: ctx.signers[0]!.publicKey,
-      recentBlockhash: blockhash,
-      instructions: [
-        ...(ctx.prependInstructions ?? []),
-        ...batch.topLevelInstructions,
-        ...syncResult.preInstructions,
-        syncResult.instruction,
-        ...syncResult.postInstructions,
-      ],
-    }).compileToV0Message(ctx.addressLookupTableAccounts ?? [])
-
-    let tx = new VersionedTransaction(msg)
-    tx.sign([...ctx.signers, ...syncResult.signers])
-    tx = await this.coSign(tx)
-
-    return {
-      batchIndex,
-      ...(await this.sendAndConfirm(tx, ctx.sendOptions, { commitment, blockhash, lastValidBlockHeight })),
-    }
-  }
-
-  private async sendAndConfirm(
-    tx: VersionedTransaction,
-    sendOptions: SendOptions | undefined,
-    confirmation: { commitment: Commitment; blockhash?: string; lastValidBlockHeight?: number },
-  ): Promise<{ signature: string; logs: string[] | null; error: unknown }> {
-    const signature = await this.connection.sendTransaction(tx, sendOptions)
-
-    if (confirmation.blockhash && confirmation.lastValidBlockHeight !== undefined) {
-      try {
-        await this.connection.confirmTransaction({
-          signature,
-          blockhash: confirmation.blockhash,
-          lastValidBlockHeight: confirmation.lastValidBlockHeight,
-        }, confirmation.commitment)
-      } catch (err) {
-        if (this.debug) console.warn(`[LoopscaleClient] confirmTransaction failed for ${signature}:`, err)
-      }
-    } else {
-      for (let attempt = 0; attempt < 60; attempt += 1) {
-        const statuses = await this.connection.getSignatureStatuses([signature])
-        const s = statuses.value[0]
-        if (s?.err || s?.confirmationStatus === "confirmed" || s?.confirmationStatus === "finalized") break
-        await new Promise((r) => setTimeout(r, 1_000))
-      }
-    }
-
-    const finality: Finality = confirmation.commitment === "finalized" ? "finalized" : "confirmed"
-    for (let attempt = 0; attempt < 20; attempt += 1) {
-      const txResult = await this.connection.getTransaction(signature, {
-        commitment: finality,
-        maxSupportedTransactionVersion: 0,
-      })
-      if (txResult) {
-        return { signature, logs: txResult.meta?.logMessages ?? null, error: txResult.meta?.err ?? null }
-      }
-      await new Promise((r) => setTimeout(r, 500))
-    }
-
-    return { signature, logs: null, error: `Transaction ${signature} not found after confirmation timeout` }
-  }
-
-  // ── Data ──
-
-  async getQuotes(params: LoopscaleQuoteParams): Promise<LoopscaleQuote[]> {
-    const body = {
-      durationType: params.durationType,
-      duration: params.duration,
-      principal: toBase58(params.principal),
-      collateral: params.collateral.map(toBase58),
-      limit: params.limit ?? 10,
-      offset: params.offset ?? 0,
-    }
-    return this.post<LoopscaleQuote[]>("/markets/quote", body, { "user-wallet": this.userWallet })
-  }
-
-  async getMaxQuote(params: LoopscaleMaxQuoteParams): Promise<LoopscaleMaxQuote[]> {
-    const body = {
-      durationType: params.durationType,
-      duration: params.duration,
-      principalMint: toBase58(params.principalMint),
-      collateralFilter: params.collateralFilter.map((f) => ({
-        amount: toSafeNumber(f.amount, "amount"),
-        assetData: f.assetData,
-      })),
-    }
-    return this.post<LoopscaleMaxQuote[]>("/markets/quote/max", body, { "user-wallet": this.userWallet })
-  }
-
-  async getLoanInfo(params: LoopscaleLoanInfoParams): Promise<LoopscaleLoanInfoResponse> {
-    return this.post<LoopscaleLoanInfoResponse>("/markets/loans/info", params, { "user-wallet": this.userWallet })
-  }
-
-  async getStrategies(params: LoopscaleGetStrategiesParams): Promise<LoopscaleStrategyInfoResponse> {
-    return this.post<LoopscaleStrategyInfoResponse>("/markets/strategy/infos", params, { "user-wallet": this.userWallet })
-  }
-
-  async getCollateralHolders(params: LoopscaleCollateralHoldersParams): Promise<LoopscaleCollateralHolder[]> {
-    return this.post<LoopscaleCollateralHolder[]>("/markets/collateral/holders", params)
-  }
-
-  async getHistoricalCollateralHolders(params: LoopscaleHistoricalCollateralHoldersParams): Promise<LoopscaleHistoricalCollateralHolder[]> {
-    return this.post<LoopscaleHistoricalCollateralHolder[]>("/markets/collateral/holders/historical", params)
-  }
-
-  async getVaultDepositors(params: LoopscaleVaultDepositorsParams): Promise<LoopscaleVaultDepositor[]> {
-    return this.post<LoopscaleVaultDepositor[]>("/markets/lending_vaults/deposits", params)
-  }
-
-  async getVaultInfo(params: LoopscaleVaultInfoParams): Promise<LoopscaleVaultInfoResponse> {
-    return this.post<LoopscaleVaultInfoResponse>("/markets/lending_vaults/info", params)
-  }
-
-  async getLoopInfo(params: LoopscaleLoopInfoParams): Promise<Record<string, LoopscaleLoopVaultInfo>> {
-    return this.post<Record<string, LoopscaleLoopVaultInfo>>("/markets/loop/info", params)
-  }
-
-  // ── Strategy (LENDER side) ──
-
-  async createStrategy(params: LoopscaleCreateStrategyParams): Promise<LoopscaleStrategyResult> {
-    const lender = toBase58(params.lender)
-    const body: Record<string, unknown> = {
-      principalMint: toBase58(params.principalMint),
-      lender,
-      amount: toSafeNumber(params.amount, "amount"),
-    }
-    if (params.originationsEnabled !== undefined) body.originationsEnabled = params.originationsEnabled
-    if (params.liquidityBuffer !== undefined) body.liquidityBuffer = params.liquidityBuffer
-    if (params.interestFee !== undefined) body.interestFee = params.interestFee
-    if (params.originationFee !== undefined) body.originationFee = params.originationFee
-    if (params.originationCap !== undefined) body.originationCap = params.originationCap
-    if (params.collateralTerms) body.collateralTerms = params.collateralTerms
-    if (params.marketInformation) body.marketInformation = toBase58(params.marketInformation)
-    if (params.externalYieldSourceArgs) body.externalYieldSourceArgs = params.externalYieldSourceArgs
-
-    const entries = await this.post<LoopscaleLegacyTransactionEntry[]>(
-      "/markets/strategy/create", body, { payer: this.userWallet },
-    )
-
-    if (!Array.isArray(entries) || entries.length === 0) {
-      throw new Error("Loopscale strategy/create returned no transactions")
-    }
-
-    const batches = await this.parseStrategyBatches(entries)
-    const createBatch = batches.find((batch) => batch.raw.loopscaleInstructions.some((g) => g.name === "createStrategy"))
-    const createIx = createBatch?.raw.loopscaleInstructions.find((g) => g.name === "createStrategy")
-    if (!createIx) throw new Error("Loopscale strategy/create did not return a createStrategy instruction")
-    const strategyAddress = createIx.instruction.keys[3]?.pubkey
-    const noncePublicKey = createIx.instruction.keys[2]?.pubkey
-    if (!strategyAddress || !noncePublicKey) {
-      throw new Error("Invalid createStrategy account layout from API")
-    }
-
-    if (this.debug) {
-      console.log(`[LoopscaleClient] createStrategy: strategy=${strategyAddress.toBase58()}, batches=${batches.length}`)
-    }
-
-    return { batches, strategyAddress, noncePublicKey }
-  }
-
-  async depositStrategy(params: LoopscaleDepositStrategyParams): Promise<LoopscaleTxResult> {
-    const body = {
-      strategy: toBase58(params.strategy),
-      amount: toSafeNumber(params.amount, "amount"),
-    }
-    return this.fetchAndClassifySingleTx("/markets/strategy/deposit", body, {
-      "User-Wallet": this.userWallet,
-      payer: this.userWallet,
-    })
-  }
-
-  async withdrawStrategy(params: LoopscaleWithdrawStrategyParams): Promise<LoopscaleTxResult> {
-    const body = {
-      strategy: toBase58(params.strategy),
-      amount: toSafeNumber(params.amount, "amount"),
-      withdrawAll: params.withdrawAll,
-    }
-    return this.fetchAndClassifySingleTx("/markets/strategy/withdraw", body, {
-      "User-Wallet": this.userWallet,
-      payer: this.userWallet,
-    })
-  }
-
-  async closeStrategy(params: LoopscaleCloseStrategyParams): Promise<LoopscaleTxResult> {
-    const strategy = toBase58(params.strategy)
-    return this.fetchAndClassifySingleTx(`/markets/strategy/close/${strategy}`, undefined, {
-      payer: this.userWallet,
-    })
-  }
-
-  async updateStrategy(params: LoopscaleUpdateStrategyParams): Promise<LoopscaleUpdateStrategyResult> {
-    const body: Record<string, unknown> = { strategy: toBase58(params.strategy) }
-    if (params.collateralTerms) body.collateralTerms = params.collateralTerms
-    if (params.updateParams) body.updateParams = params.updateParams
-
-    const entries = await this.post<LoopscaleLegacyTransactionEntry[]>(
-      "/markets/strategy/update", body, { "User-Wallet": this.userWallet, payer: this.userWallet },
-    )
-
-    if (!Array.isArray(entries) || entries.length === 0) {
-      throw new Error("Loopscale strategy/update returned no transactions")
-    }
-
-    const batches = await this.parseStrategyBatches(entries)
-
-    if (this.debug) {
-      console.log(`[LoopscaleClient] updateStrategy: batches=${batches.length}`)
-    }
-
-    return { batches }
-  }
-
-  // ── Loan (BORROWER side) ──
-
-  /**
-   * Build a standalone borrow_principal instruction (no lock/unlock needed).
-   * Requires collateral to already be deposited in the loan.
-   */
-  buildBorrowPrincipalInstruction(params: LoopscaleBorrowPrincipalParams): TransactionInstruction {
-    const borrower = new PublicKey(toBase58(params.borrower))
-    const loan = new PublicKey(toBase58(params.loan))
-    const strategy = new PublicKey(toBase58(params.strategy))
-    const marketInformation = new PublicKey(toBase58(params.marketInformation))
-    const principalMint = new PublicKey(toBase58(params.principalMint))
-    const amount = typeof params.amount === "bigint" ? params.amount : BigInt(params.amount)
-
-    const guidance = params.assetIndexGuidance
-    const duration = params.durationIndex
-    const expectedApy = params.expectedApy !== undefined
-      ? (typeof params.expectedApy === "bigint" ? params.expectedApy : BigInt(params.expectedApy))
-      : 0n
-    const expectedLqt = params.expectedLqt ?? [0, 0, 0, 0, 0]
-    const skipSolUnwrap = params.skipSolUnwrap ?? false
-
-    // Serialize instruction data: discriminator + amount + guidance_vec + duration + expected_loan_values + skip_sol_unwrap
-    const dataSize = 8 + 8 + 4 + guidance.length + 1 + 8 + 20 + 1
-    const data = Buffer.alloc(dataSize)
-    let offset = 0
-    Buffer.from(LOOPSCALE_DISCRIMINATORS.borrowPrincipal).copy(data, 0); offset += 8
-    data.writeBigUInt64LE(amount, offset); offset += 8
-    data.writeUInt32LE(guidance.length, offset); offset += 4
-    for (const b of guidance) { data.writeUInt8(b, offset); offset += 1 }
-    data.writeUInt8(duration, offset); offset += 1
-    data.writeBigUInt64LE(expectedApy, offset); offset += 8
-    for (let i = 0; i < 5; i++) { data.writeUInt32LE(expectedLqt[i] ?? 0, offset); offset += 4 }
-    data.writeUInt8(skipSolUnwrap ? 1 : 0, offset); offset += 1
-
-    const TOKEN_PROGRAM_ID = new PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA")
-    const [borrowerTa] = PublicKey.findProgramAddressSync(
-      [borrower.toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), principalMint.toBuffer()],
-      ASSOCIATED_TOKEN_PROGRAM_ID,
-    )
-    const [strategyTa] = PublicKey.findProgramAddressSync(
-      [strategy.toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), principalMint.toBuffer()],
-      ASSOCIATED_TOKEN_PROGRAM_ID,
-    )
-    const eventAuthority = PublicKey.findProgramAddressSync(
-      [Buffer.from("__event_authority")],
-      LOOPSCALE_PROGRAM_ID,
-    )[0]
-
-    const ix = new TransactionInstruction({
-      programId: LOOPSCALE_PROGRAM_ID,
-      keys: [
-        { pubkey: this.bsAuth, isSigner: true, isWritable: false },
-        { pubkey: borrower, isSigner: true, isWritable: true },
-        { pubkey: borrower, isSigner: true, isWritable: false },
-        { pubkey: loan, isSigner: false, isWritable: true },
-        { pubkey: strategy, isSigner: false, isWritable: true },
-        { pubkey: marketInformation, isSigner: false, isWritable: true },
-        { pubkey: principalMint, isSigner: false, isWritable: false },
-        { pubkey: borrowerTa, isSigner: false, isWritable: true },
-        { pubkey: strategyTa, isSigner: false, isWritable: true },
-        { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
-        { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
-        { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-        { pubkey: eventAuthority, isSigner: false, isWritable: false },
-        { pubkey: LOOPSCALE_PROGRAM_ID, isSigner: false, isWritable: false },
-        ...params.healthCheckAccounts,
-      ],
-      data,
-    })
-
-    return ix
-  }
-
-  /**
-   * Build a standalone borrow_principal wrapped as a LoopscaleInstruction for sync tx.
-   * Requires collateral to already be deposited in the loan.
-   */
-  buildBorrowPrincipalAction(params: LoopscaleBorrowPrincipalParams): LoopscaleInstruction {
-    return loopscaleAction.borrowPrincipal({ instruction: this.buildBorrowPrincipalInstruction(params) })
-  }
-
-  async repayLoan(params: LoopscaleRepayLoanParams): Promise<LoopscaleTxResult> {
-    const body: Record<string, unknown> = {
-      loan: toBase58(params.loan),
-      repayParams: params.repayParams.map((p) => ({
-        amount: toSafeNumber(p.amount, "repayAmount"),
-        ledgerIndex: p.ledgerIndex,
-        repayAll: p.repayAll,
-      })),
-      collateralWithdrawalParams: (params.collateralWithdrawalParams ?? []).map((p) => ({
-        amount: toSafeNumber(p.amount, "withdrawAmount"),
-        collateralMint: toBase58(p.collateralMint),
-      })),
-    }
-    if (params.closeIfPossible !== undefined) body.closeIfPossible = params.closeIfPossible
-
-    return this.fetchAndClassifyWrappedTx("/markets/creditbook/repay", body, { "user-wallet": this.userWallet })
-  }
-
-  async closeLoan(params: LoopscaleCloseLoanParams): Promise<LoopscaleTxResult> {
-    const body = { loan: toBase58(params.loan) }
-    return this.fetchAndClassifyWrappedTx("/markets/creditbook/close_loan", body, { "user-wallet": this.userWallet })
-  }
-
-  async createLoan(params: LoopscaleCreateLoanParams): Promise<LoopscaleCreateLoanResult> {
-    const body: Record<string, unknown> = {
-      borrower: toBase58(params.borrower),
-      depositCollateral: params.depositCollateral.map((c) => ({
-        collateralAmount: toSafeNumber(c.collateralAmount, "collateralAmount"),
-        collateralAssetData: c.collateralAssetData,
-      })),
-      principalRequested: params.principalRequested.map((p) => ({
-        ledgerIndex: p.ledgerIndex,
-        principalAmount: toSafeNumber(p.principalAmount, "principalAmount"),
-        principalMint: toBase58(p.principalMint),
-        strategy: toBase58(p.strategy),
-        durationIndex: p.durationIndex,
-        expectedLoanValues: p.expectedLoanValues ?? { expectedApy: 0, expectedLqt: [0, 0, 0, 0, 0] },
-      })),
-    }
-    if (params.assetIndexGuidance) body.assetIndexGuidance = params.assetIndexGuidance
-    if (params.loanNonce) body.loanNonce = params.loanNonce
-    if (params.isLoop !== undefined) body.isLoop = params.isLoop
-
-    const headers = { payer: this.userWallet }
-
-    const data = await this.post<{
-      transaction: { message: string; signatures: Array<{ publicKey: string; signature: string }> }
-      loanAddress: string
-    }>("/markets/creditbook/create", body, headers)
-
-    const tx = buildTxFromLegacyEntry(data.transaction)
-    const instructions = await decompileInstructions(this.connection, tx)
-    const classified = this.classifyInstructions(instructions)
-    const syncActions = this.buildSyncActions(classified.loopscale)
-    const raw = this.buildRawBundle(tx, instructions, classified.loopscale)
-    const loanAddress = new PublicKey(data.loanAddress)
-
-    if (this.debug) {
-      console.log(`[LoopscaleClient] createLoan: loan=${loanAddress.toBase58()}, syncActions=${syncActions.length}`)
-    }
-
-    return { syncActions, topLevelInstructions: classified.topLevel, raw, loanAddress }
-  }
-
-  async apiBorrowPrincipal(params: LoopscaleApiBorrowPrincipalParams): Promise<LoopscaleTxResult> {
-    const borrowParams: Record<string, unknown> = {
-      amount: toSafeNumber(params.borrowParams.amount, "amount"),
-      duration: params.borrowParams.durationIndex,
-    }
-    if (params.borrowParams.expectedLoanValues) {
-      borrowParams.expectedLoanValues = params.borrowParams.expectedLoanValues
-    }
-    const body: Record<string, unknown> = {
-      loan: toBase58(params.loan),
-      borrowParams,
-      strategy: toBase58(params.strategy),
-    }
-    if (params.refinanceParams) body.refinanceParams = params.refinanceParams
-    if (params.isLoop !== undefined) body.isLoop = params.isLoop
-
-    return this.fetchAndClassifySingleTx("/markets/creditbook/borrow", body, { payer: this.userWallet })
-  }
-
-  async depositCollateral(params: LoopscaleDepositCollateralParams): Promise<LoopscaleTxResult> {
-    const body: Record<string, unknown> = {
-      loan: toBase58(params.loan),
-      depositMint: toBase58(params.depositMint),
-      amount: toSafeNumber(params.amount, "amount"),
-      assetType: params.assetType,
-      assetIdentifier: toBase58(params.assetIdentifier),
-    }
-    if (params.assetIndexGuidance) body.assetIndexGuidance = params.assetIndexGuidance
-    if (params.expectedLoanValues) body.expectedLoanValues = params.expectedLoanValues
-
-    return this.fetchAndClassifySingleTx("/markets/creditbook/collateral/deposit", body, {
-      "user-wallet": this.userWallet,
-      payer: this.userWallet,
-    })
-  }
-
-  async withdrawCollateral(params: LoopscaleWithdrawCollateralParams): Promise<LoopscaleTxResult> {
-    const body: Record<string, unknown> = {
-      loan: toBase58(params.loan),
-      collateralMint: toBase58(params.collateralMint),
-      amount: toSafeNumber(params.amount, "amount"),
-      collateralIndex: params.collateralIndex,
-    }
-    if (params.expectedLoanValues) body.expectedLoanValues = params.expectedLoanValues
-    if (params.assetIndexGuidance) body.assetIndexGuidance = params.assetIndexGuidance
-
-    return this.fetchAndClassifySingleTx("/markets/creditbook/collateral/withdraw", body, {
-      "user-wallet": this.userWallet,
-      payer: this.userWallet,
-    })
-  }
-
-  async refinanceLoan(params: LoopscaleRefinanceLoanParams): Promise<LoopscaleTxResult> {
-    const body = {
-      loan: toBase58(params.loan),
-      oldStrategy: toBase58(params.oldStrategy),
-      newStrategy: toBase58(params.newStrategy),
-      refinanceParams: params.refinanceParams,
-    }
-    return this.fetchAndClassifyWrappedTx("/markets/creditbook/refinance", body, {
-      "user-wallet": this.userWallet,
-    })
-  }
-
-  // ── Co-signing ──
-
-  async coSign(transaction: VersionedTransaction): Promise<VersionedTransaction> {
-    const serializedTx = Buffer.from(transaction.serialize()).toString("base64")
-    const serializedMsg = Buffer.from(transaction.message.serialize()).toString("base64")
-
-    if (this.useMpcCoSign) {
-      const body = {
-        batches: [{
-          transactions: [{
-            identifier: "loopscale-cosign",
-            transaction: serializedTx,
-            transactionType: 1,
-          }],
-        }],
-      }
-
-      const data = await this.post<{
-        batches: Array<{ transactions: Array<{ identifier: string; transaction: string; transactionType: number }> }>
-      }>("/mpc/txns/gen", body)
-
-      const txEntry = data.batches?.[0]?.transactions?.[0]
-      if (!txEntry) throw new Error("Loopscale MPC co-signing returned no transaction")
-
-      const resultTx = VersionedTransaction.deserialize(Buffer.from(txEntry.transaction, "base64"))
-      ensureMessageMatches(resultTx, transaction)
-      return mergeInputSignatures(resultTx, transaction)
-    }
-
-    // Legacy endpoint
-    const body = [{ transaction: serializedTx, message: serializedMsg }]
-    const entries = await this.post<Array<{ message: string; signatures: Array<{ publicKey: string; signature: string }> }>>(
-      "/markets/txn/gen", body, { "user-wallet": this.userWallet },
-    )
-
-    if (!entries?.[0]) throw new Error("Loopscale co-signing returned no entries")
-    const resultTx = buildTxFromLegacyEntry(entries[0])
-    ensureMessageMatches(resultTx, transaction)
-    return mergeInputSignatures(resultTx, transaction)
-  }
-
-  // ── Instruction helpers ──
-
-  classifyInstructions(instructions: TransactionInstruction[]): ClassifiedInstructions {
-    const loopscale: LoopscaleGeneratedInstruction[] = []
-    const topLevel: TransactionInstruction[] = []
-    const setup: TransactionInstruction[] = []
-
-    for (const ix of instructions) {
-      if (ix.programId.equals(LOOPSCALE_PROGRAM_ID)) {
-        loopscale.push({ name: identifyInstruction(ix), instruction: ix })
-      } else if (ix.programId.equals(ComputeBudgetProgram.programId)) {
-        topLevel.push(ix)
-      } else if (ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
-        setup.push(ix)
-      } else {
-        // Oracle feeds, system program, etc. — top level
-        topLevel.push(ix)
-      }
-    }
-
-    return { loopscale, topLevel, setup }
-  }
-
-  static identifyInstruction(ix: TransactionInstruction): LoopscaleInstructionName | null {
-    return identifyInstruction(ix)
-  }
-
-  // ── Private helpers ──
-
-  private buildSyncActions(loopscaleIxs: LoopscaleGeneratedInstruction[]): LoopscaleInstruction[] {
-    return loopscaleIxs
-      .filter((g) => g.name !== null)
-      .map((g) => {
-        const wrapper = NAME_TO_ACTION_WRAPPER[g.name!]
-        return wrapper(g.instruction)
-      })
-  }
-
-  private buildRawBundle(
-    transaction: VersionedTransaction,
-    instructions: TransactionInstruction[],
-    loopscaleInstructions: LoopscaleGeneratedInstruction[],
-  ): LoopscaleGeneratedInstructionBundle {
-    return { transaction, instructions, loopscaleInstructions }
-  }
-
-  private toSingleTxResult(batch: LoopscaleStrategyBatch): LoopscaleTxResult {
-    return {
-      syncActions: batch.syncActions,
-      topLevelInstructions: batch.topLevelInstructions,
-      raw: batch.raw,
-    }
-  }
-
-  private async parseTransactionEntry(entry: LoopscaleLegacyTransactionEntry): Promise<LoopscaleStrategyBatch> {
-    const tx = buildTxFromLegacyEntry(entry)
-    const instructions = await decompileInstructions(this.connection, tx)
-    const classified = this.classifyInstructions(instructions)
-    const syncActions = this.buildSyncActions(classified.loopscale)
-    const raw = this.buildRawBundle(tx, instructions, classified.loopscale)
-
-    return {
-      syncActions,
-      topLevelInstructions: classified.topLevel,
-      setupInstructions: classified.setup,
-      raw,
-    }
-  }
-
-  private async parseStrategyBatches(entries: LoopscaleLegacyTransactionEntry[]): Promise<LoopscaleStrategyBatch[]> {
-    return Promise.all(entries.map((entry) => this.parseTransactionEntry(entry)))
-  }
-
-  private async fetchAndClassifyWrappedTx(
-    path: string,
-    body: unknown,
-    headers: Record<string, string>,
-  ): Promise<LoopscaleTxResult> {
-    const data = await this.post<{
-      transactions: LoopscaleLegacyTransactionEntry[]
-      expectedLoanInfo?: unknown
-    }>(path, body, headers)
-
-    if (!data.transactions?.length) {
-      throw new Error(`Loopscale ${path} returned no transactions`)
-    }
-
-    if (data.transactions.length > 1) {
-      throw new Error(
-        `Loopscale ${path} returned ${data.transactions.length} transactions — expected 1. ` +
-        `Multi-transaction responses (e.g. from setupIxs) are not supported.`,
-      )
-    }
-
-    const batch = await this.parseTransactionEntry(data.transactions[0])
-
-    if (this.debug) {
-      console.log(
-        `[LoopscaleClient] ${path}: syncActions=${batch.syncActions.length}, topLevel=${batch.topLevelInstructions.length}`,
-      )
-    }
-
-    return this.toSingleTxResult(batch)
-  }
-
-  private async fetchAndClassifySingleTx(
-    path: string,
-    body: unknown,
-    headers: Record<string, string>,
-  ): Promise<LoopscaleTxResult> {
-    const entry = await this.post<LoopscaleLegacyTransactionEntry>(
-      path, body, headers,
-    )
-
-    const batch = await this.parseTransactionEntry(entry)
-
-    if (this.debug) {
-      console.log(
-        `[LoopscaleClient] ${path}: syncActions=${batch.syncActions.length}, topLevel=${batch.topLevelInstructions.length}`,
-      )
-    }
-
-    return this.toSingleTxResult(batch)
-  }
-
-  private async post<T>(
-    path: string,
-    body?: unknown,
-    extraHeaders?: Record<string, string>,
-  ): Promise<T> {
-    const url = `${this.baseUrl}${path}`
-    const headers: Record<string, string> = {
-      "Content-Type": "application/json",
-      ...extraHeaders,
-    }
-
-    if (this.debug) {
-      console.log(`\n[LoopscaleClient] POST ${url}`)
-      if (body) console.log(`  body: ${JSON.stringify(body, null, 2).split("\n").slice(0, 10).join("\n")}...`)
-    }
-
-    let response: Response | undefined
-    const maxRetries = 3
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      response = await fetch(url, {
-        method: "POST",
-        headers,
-        body: body !== undefined ? JSON.stringify(body) : undefined,
-      })
-
-      if (response.status === 429 && attempt < maxRetries) {
-        const delay = 2000 * (attempt + 1)
-        if (this.debug) console.log(`  RATE LIMITED (429), retrying in ${delay}ms (attempt ${attempt + 1}/${maxRetries})...`)
-        await new Promise((r) => setTimeout(r, delay))
-        continue
-      }
-      break
-    }
-
-    if (!response!.ok) {
-      const text = await response!.text()
-      if (this.debug) console.log(`  ERROR ${response!.status}: ${text}`)
-      throw new Error(`Loopscale API ${path} failed (${response!.status}): ${text}`)
-    }
-
-    const data = await response!.json() as T
-
-    if (this.debug) {
-      console.log(`  OK ${response!.status}`)
-    }
-
-    return data
-  }
-}