@exponent-labs/exponent-sdk 0.9.0 → 0.9.2

package/src/exponentVaults/vaultTransactionBuilder.ts

@@ -1,20 +1,28 @@
 import {
+  AddressLookupTableProgram,
   Connection,
   PublicKey,
   TransactionInstruction,
   TransactionMessage,
   VersionedTransaction,
   AddressLookupTableAccount,
-  AddressLookupTableProgram,
   ComputeBudgetProgram,
-  SystemProgram,
 } from "@solana/web3.js"
 import type * as web3 from "@solana/web3.js"
 import type { ExponentPrices } from "@exponent-labs/exponent-vaults-fetcher"
 import type { ExponentVault } from "./vault"
-import { LoopscaleClient } from "./loopscale-client"
-import { createVaultSyncTransaction, type VaultInstruction } from "./vault-interaction"
+import { LoopscaleClient } from "./loopscale"
+import type { LoopscaleTransactionResponse } from "./loopscale"
+import {
+  buildSetupStatePriceRefreshInstructions,
+  createVaultSyncTransactions,
+  createStrategySetupContext,
+  type VaultInstruction,
+} from "./vault-interaction"
 import { SQUADS_PROGRAM_ID } from "./syncTransaction"
+import { LOCAL_ENV } from "../environment"
+
+const SCOPE_PROGRAM_ID = new PublicKey("HFn8GnPADiny6XqUoWE8uRPPxb29ikn4yTuPa9MF2fWJ")
 
 // ============================================================================
 // Types
@@ -46,6 +54,20 @@ export interface StepOptions {
   priorityFee?: number
 }
 
+/** Label-only options for raw Loopscale response steps. */
+export interface LoopscaleStepOptions {
+  /** Human-readable label for this Loopscale step. Auto-generated if omitted. */
+  label?: string
+}
+
+/** Optional Loopscale client config used by the builder for preparation and MPC co-signing. */
+export interface VaultTransactionBuilderLoopscaleConfig {
+  /** Override the Loopscale API base URL. */
+  baseUrl?: string
+  /** Enable verbose Loopscale request/response logging. */
+  debug?: boolean
+}
+
 /**
  * Configuration for creating a {@link VaultTransactionBuilder}.
  *
@@ -55,8 +77,8 @@ export interface StepOptions {
  *   vault,                            // loaded ExponentVault instance
  *   connection,                       // Solana RPC connection
  *   signer: manager.publicKey,        // strategy manager's public key
- *   vaultPda: squadsVault,            // Squads vault PDA
- *   pricesAccount,                    // fetched ExponentPrices for oracle refresh
+ *   autoManagePositions: true,        // optional, defaults to true
+ *   pricesAccount,                    // optional prefetched ExponentPrices snapshot
  * })
  * ```
  */
@@ -67,57 +89,55 @@ export interface VaultTransactionBuilderConfig {
   connection: Connection
   /** The strategy manager's public key. Used as the signer for policy matching and as the fee payer. */
   signer: PublicKey
-  /** The Squads multisig vault PDA that owns the strategy's assets. */
-  vaultPda: PublicKey
+  /** Optional vault PDA override. Defaults to `vault.state.squadsVault`. */
+  vaultPda?: PublicKey
+  /** Optional extra lookup tables to include alongside the vault-managed tables. */
+  lookupTableAddresses?: PublicKey[]
   /**
-   * Fetched `ExponentPrices` account snapshot.
+   * Fetched `ExponentPrices` account snapshot (optional).
    *
-   * Used to build price refresh instructions (via `vault.ixsUpdateStrategyVaultPrices()`).
-   * The price refresh transaction is always emitted as the first TransactionSet, ensuring
-   * oracle prices are fresh when the sync transaction executes in the same slot.
-   *
-   * Fetch this via `ExponentVaultsFetcher.fetchPricesDeserialized()` before creating the builder.
+   * When provided, the builder reuses this snapshot to assemble same-transaction
+   * `UpdatePrice` instructions for any setup or sync transaction that can hit
+   * AUM recalculation. When omitted, the builder fetches the current prices
+   * account automatically.
    */
-  pricesAccount: ExponentPrices
+  pricesAccount?: ExponentPrices
   /** Default compute unit limit for all steps (default: 1,400,000). Override per-step via {@link StepOptions}. */
   computeUnitLimit?: number
   /** Default heap frame allocation in bytes for all steps (default: 262,144 = 256 KB). Override per-step via {@link StepOptions}. */
   heapFrameBytes?: number
+  /** Automatically manage new Kamino/CLMM/yield position tracking for manager flows. Defaults to `true`. */
+  autoManagePositions?: boolean
   /** Squads program ID override. Defaults to the standard Squads V4 program. */
   squadsProgram?: PublicKey
-  /**
-   * Compute budget overrides for the price refresh transaction.
-   *
-   * The price refresh tx runs oracle update instructions which are typically lighter
-   * than sync transactions. You can lower the CU limit here to save on fees, or
-   * set a priority fee to ensure the refresh lands quickly.
-   *
-   * @example
-   * ```ts
-   * VaultTransactionBuilder.create({
-   *   // ...
-   *   priceRefreshOptions: { computeUnitLimit: 600_000, priorityFee: 100 },
-   * })
-   * ```
-   */
-  priceRefreshOptions?: StepOptions
+  /** Optional Loopscale client config used when preparing and co-signing Loopscale transactions. */
+  loopscale?: VaultTransactionBuilderLoopscaleConfig
 }
 
-interface StepConfig {
-  label: string
-  instructions: VaultInstruction[]
-  isLoopscale: boolean
-  options: StepOptions
-}
+type StepConfig =
+  | {
+    kind: "instructions"
+    label: string
+    instructions: VaultInstruction[]
+    options: StepOptions
+  }
+  | {
+    kind: "loopscale-response"
+    label: string
+    response: LoopscaleTransactionResponse
+    options: LoopscaleStepOptions
+  }
 
 /**
  * A group of instructions that will be assembled into a single VersionedTransaction.
  *
- * The builder produces an ordered array of TransactionSets: price refresh first,
- * then optional setup transactions, then one sync transaction per step.
+ * The builder produces an ordered array of TransactionSets: optional setup
+ * transactions, then one sync transaction per step. Same-transaction Exponent
+ * price refreshes are injected directly into any set that can hit AUM
+ * recalculation.
  */
 export interface TransactionSet {
-  /** Human-readable label identifying this transaction (e.g. "price-refresh", "step-1", "step-1-setup"). */
+  /** Human-readable label identifying this transaction (e.g. "step-1", "step-1-setup"). */
   label: string
   /** All instructions in execution order, including compute budget instructions. */
   instructions: TransactionInstruction[]
@@ -125,121 +145,73 @@ export interface TransactionSet {
   signers: web3.Signer[]
   /** Address lookup table addresses that should be loaded for this transaction's V0 message. */
   addressLookupTableAddresses: PublicKey[]
+  /** Whether this transaction needs Loopscale MPC co-signing before broadcast. */
+  coSignWithLoopscale?: boolean
 }
 
 /**
- * Options for {@link VaultTransactionBuildResult.sendJitoBundle}.
+ * Options for {@link VaultTransactionBuildResult.send}.
  */
-export interface JitoBundleSendOptions {
-  /** Keypair signers. The first signer is used as the fee payer and Jito tip payer. */
+export interface SendOptions {
+  /** Keypair signers. The first signer is used as the fee payer. */
   signers: web3.Signer[]
-  /** Jito tip amount in lamports. Appended as a transfer instruction to the last transaction. */
-  tipLamports: number
-  /** Commitment level for bundle confirmation (default: "confirmed"). */
+  /** Commitment level for transaction confirmation (default: "confirmed"). */
   commitment?: web3.Commitment
-  /** Jito auth key for authenticated block engine endpoints. */
-  jitoAuthKey?: string
-  /**
-   * Custom send function that replaces the default Jito bundle send.
-   *
-   * Receives signed (and co-signed) VersionedTransactions and their labels.
-   * Must return an array of transaction signatures in the same order.
-   * Use this for Surfpool, local validators, or any non-Jito send flow.
-   *
-   * @example
-   * ```ts
-   * result.sendJitoBundle({
-   *   signers: [manager],
-   *   tipLamports: 0,
-   *   customSend: async (txs, labels) => {
-   *     return Promise.all(txs.map(tx => surfpool.sendTransaction(tx)))
-   *   },
-   * })
-   * ```
-   */
-  customSend?: (transactions: VersionedTransaction[], labels: string[]) => Promise<string[]>
 }
 
-/** Result from {@link VaultTransactionBuildResult.sendJitoBundle}. */
-export interface JitoBundleResult {
+/** Result from {@link VaultTransactionBuildResult.send}. */
+export interface SendResult {
   /** Transaction signatures in the same order as the TransactionSets. */
   signatures: string[]
-  /** Jito bundle ID. Empty string if using customSend or if the mainnet endpoint did not return one. */
-  bundleId: string
+  /**
+   * Non-null when an ephemeral address lookup table was created to fit all
+   * accounts into the transactions. The caller can deactivate and close it
+   * to reclaim rent when they no longer need it.
+   *
+   * Cleanup requires two steps (Solana constraint):
+   * 1. `AddressLookupTableProgram.deactivateLookupTable({ lookupTable: address, authority })`
+   * 2. After ~one epoch, `AddressLookupTableProgram.closeLookupTable({ lookupTable: address, authority, recipient: authority })`
+   */
+  ephemeralAlt: { address: PublicKey; authority: PublicKey } | null
 }
 
 /**
  * The result of calling {@link VaultTransactionBuilder.build}.
  *
- * Contains the assembled TransactionSets and provides `sendJitoBundle()` to send them.
- * Inspect `transactionSets` to review instructions before sending.
- *
- * Price refresh and sync transactions must land in the same slot — use `sendJitoBundle()`
- * for atomic same-slot execution via Jito, or `customSend` for testing environments.
+ * Contains the assembled TransactionSets and a `send()` method for sequential execution.
+ * Loopscale co-signing is handled automatically.
  *
  * @example
  * ```ts
  * const result = await builder.build()
  *
  * // Inspect
- * console.log(result.labels)  // ["price-refresh", "step-1", "loopscale-step-2"]
- *
- * // Send as Jito bundle
- * await result.sendJitoBundle({ signers: [manager], tipLamports: 10_000 })
+ * console.log(result.labels)  // ["step-1", "loopscale-step-2"]
  *
- * // Or for testing (Surfpool, local validator):
- * await result.sendJitoBundle({
- *   signers: [manager], tipLamports: 0,
- *   customSend: async (txs) => surfpool.sendAll(txs),
- * })
+ * // Send sequentially
+ * await result.send({ signers: [manager] })
  * ```
  */
 export interface VaultTransactionBuildResult {
-  /** Ordered TransactionSets: price refresh (index 0), then setup + sync per step. */
+  /** Ordered TransactionSets: setup + sync per step, with same-tx price refresh injected as needed. */
   transactionSets: TransactionSet[]
   /** Deduplicated address lookup table addresses across all TransactionSets. */
   lookupTableAddresses: PublicKey[]
   /** Labels for each TransactionSet, in order. */
   labels: string[]
   /**
-   * Sign all transactions, append a Jito tip to the last one, and send as an atomic Jito bundle.
+   * Send transactions sequentially via regular RPC.
    *
-   * All transactions share the same blockhash and are executed in the same slot.
-   * Loopscale steps are automatically co-signed via an internally created LoopscaleClient.
-   * Non-Loopscale steps are signed normally.
+   * Each transaction is built, signed (and co-signed for Loopscale steps),
+   * sent via `connection.sendTransaction()`, and confirmed before proceeding
+   * to the next one. Suitable for most operations.
    *
-   * Use `customSend` for testing environments where Jito is not available.
+   * **Note:** Does not guarantee atomicity — if a later transaction fails,
+   * earlier ones have already landed.
    */
-  sendJitoBundle(options: JitoBundleSendOptions): Promise<JitoBundleResult>
+  send(options: SendOptions): Promise<SendResult>
 }
 
-// ============================================================================
-// Jito constants
-// ============================================================================
-
-const JITO_TIP_ADDRESSES = [
-  new PublicKey("96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5"),
-  new PublicKey("HFqU5x63VTqvQss8hp11i4wVV8bD44PvwucfZ2bU7gRe"),
-  new PublicKey("Cw8CFyM9FkoMi7K7Crf6HNQqf4uEMzpKw6QNghXLvLkY"),
-  new PublicKey("ADaUMid9yfUytqMBgopwjb2DTLSokTSzL1zt6iGPaS49"),
-  new PublicKey("DfXygSm4jCyNCybVYYK6DwvWqjKee8pbDmJGcLWNDXjh"),
-  new PublicKey("ADuUkR4vqLUMWXxW9gh6D6L8pMSawimctcNZ5pGwDcEt"),
-  new PublicKey("DttWaMuVvTiduZRnguLF7jNxTgiMBZ1hyAumKUiL2KRL"),
-  new PublicKey("3AVi9Tg9Uo68tJfuvoKvqKNWKkC5wPdSSdeBnizKZ6jT"),
-]
-
-const JITO_REGIONAL_URLS = [
-  "https://amsterdam.mainnet.block-engine.jito.wtf",
-  "https://frankfurt.mainnet.block-engine.jito.wtf",
-  "https://ny.mainnet.block-engine.jito.wtf",
-  "https://tokyo.mainnet.block-engine.jito.wtf",
-]
-
-const JITO_MAINNET_URL = "https://mainnet.block-engine.jito.wtf"
-const JITO_BUNDLES_PATH = "/api/v1/bundles"
-const JITO_MAX_RETRIES = 10
-const JITO_RETRY_DELAY_MS = 1000
-
 // ============================================================================
 // VaultTransactionBuilder
 // ============================================================================
@@ -248,42 +220,44 @@ const JITO_RETRY_DELAY_MS = 1000
  * Orchestrates strategy vault transaction construction.
  *
  * Replaces the per-recipe boilerplate of manually assembling compute budgets,
- * price refresh instructions, sync transaction wrapping, ALT gathering, and
- * setup transaction splitting.
+ * sync transaction wrapping, ALT gathering, setup transaction splitting, and
+ * forward-looking Kamino/CLMM/yield position tracking.
  *
- * **Lifecycle:** create → add actions → build → sendJitoBundle
+ * **Lifecycle:** create → add actions → build → send()
  *
  * @example Single action
  * ```ts
  * const result = await VaultTransactionBuilder
- *   .create({ vault, connection, signer: manager.publicKey, vaultPda, pricesAccount })
+ *   .create({ vault, connection, signer: manager.publicKey })
  *   .addActions([clmmAction.buyPt({ market, ptOutMin, syInMax })])
  *   .build()
  *
- * await result.sendJitoBundle({ signers: [manager], tipLamports: 10_000 })
+ * await result.send({ signers: [manager] })
  * ```
  *
  * @example Multi-step — each addActions() becomes its own sync transaction
  * ```ts
  * const result = await VaultTransactionBuilder
- *   .create({ vault, connection, signer: manager.publicKey, vaultPda, pricesAccount })
+ *   .create({ vault, connection, signer: manager.publicKey })
  *   .addActions([kaminoAction.deposit("MAIN", "USDC", amount)])   // sync tx 1
  *   .addActions([kaminoAction.borrow("MAIN", "SOL", amount)])     // sync tx 2
  *   .build()
  *
- * await result.sendJitoBundle({ signers: [manager], tipLamports: 10_000 })
+ * await result.send({ signers: [manager] })
  * ```
  *
  * @example Mixed Kamino + Loopscale — co-signing handled automatically
  * ```ts
+ * const loopscaleDeposit = await loopscale.depositStrategy({ ... })
+ *
  * const result = await VaultTransactionBuilder
- *   .create({ vault, connection, signer: manager.publicKey, vaultPda, pricesAccount })
+ *   .create({ vault, connection, signer: manager.publicKey })
  *   .addActions([kaminoAction.deposit(...)])                        // signed normally
- *   .addLoopscaleActions([loopscaleAction.createStrategy({ ... })]) // co-signed automatically
+ *   .addLoopscaleResponse(loopscaleDeposit)                         // co-signed automatically
  *   .build()
  *
- * // sendJitoBundle auto-creates a LoopscaleClient and co-signs Loopscale steps
- * await result.sendJitoBundle({ signers: [manager], tipLamports: 10_000 })
+ * // send() auto-creates a LoopscaleClient for Loopscale co-signing
+ * await result.send({ signers: [manager] })
  * ```
  */
 export class VaultTransactionBuilder {
@@ -298,7 +272,7 @@ export class VaultTransactionBuilder {
   /**
    * Create a new builder instance.
    *
-   * @param config - Builder configuration including the vault, connection, signer, and prices.
+   * @param config - Builder configuration including the vault, connection, and signer.
    * @returns A new {@link VaultTransactionBuilder} ready for action chaining.
    */
   static create(config: VaultTransactionBuilderConfig): VaultTransactionBuilder {
@@ -331,30 +305,29 @@ export class VaultTransactionBuilder {
   addActions(instructions: VaultInstruction[], options?: StepOptions): this {
     this.stepCounter++
     const label = options?.label ?? `step-${this.stepCounter}`
-    this.steps.push({ label, instructions: [...instructions], isLoopscale: false, options: options ?? {} })
+    this.steps.push({ kind: "instructions", label, instructions: [...instructions], options: options ?? {} })
     return this
   }
 
   /**
-   * Add Loopscale vault instructions as a new step.
+   * Add a raw Loopscale response as a new step.
    *
-   * Each call creates a separate Squads sync transaction, marked for Loopscale co-signing.
-   * At send time, these steps are automatically co-signed via an internally created
-   * LoopscaleClient — no separate configuration needed.
+   * The builder will flatten the response into manager-facing transactions,
+   * preserving Loopscale-signed segments while keeping local setup/top-level
+   * transactions outside the Loopscale signing domain.
    *
-   * **Warning:** Passing multiple Loopscale actions in a single array packs them into one
-   * sync transaction. This can exceed the 1232-byte limit — the builder will throw at
-   * build time if oversized. Loopscale transactions are particularly account-heavy;
-   * prefer one action per call.
+   * @param response - Raw Loopscale response returned by {@link LoopscaleClient}.
+   * Only `label` is supported for Loopscale steps. Compute overrides are
+   * preserved on the raw Loopscale response and are not applied by the
+   * builder.
    *
-   * @param instructions - Array of Loopscale VaultInstruction descriptors (from loopscaleAction).
-   * @param options - Optional per-step compute budget overrides and label.
+   * @param options - Optional step label.
    * @returns `this` for chaining.
    */
-  addLoopscaleActions(instructions: VaultInstruction[], options?: StepOptions): this {
+  addLoopscaleResponse(response: LoopscaleTransactionResponse, options?: LoopscaleStepOptions): this {
     this.stepCounter++
     const label = options?.label ?? `loopscale-step-${this.stepCounter}`
-    this.steps.push({ label, instructions: [...instructions], isLoopscale: true, options: options ?? {} })
+    this.steps.push({ kind: "loopscale-response", label, response, options: options ?? {} })
     return this
   }
 
@@ -362,51 +335,145 @@ export class VaultTransactionBuilder {
    * Build TransactionSets from the configured steps.
    *
    * Produces an ordered array of TransactionSets:
-   * 1. **Price refresh** (index 0) — oracle price update instructions
-   * 2. **Setup transactions** — token account creation (only if needed)
-   * 3. **Sync transactions** — one per step, wrapped in Squads sync transaction
+   * 1. **Setup transactions** — token account creation / builder-managed setup (only if needed)
+   * 2. **Sync transactions** — one per step, wrapped in Squads sync transaction
+   *
+   * Same-transaction `UpdatePrice` instructions are injected directly into any
+   * setup or sync set that can hit AUM recalculation.
    *
-   * The price refresh must land in the same slot as the sync transactions.
-   * Use `result.sendJitoBundle()` for atomic same-slot execution.
+   * Use `result.send()` for sequential execution.
    *
-   * @returns A {@link VaultTransactionBuildResult} with TransactionSets and a sendJitoBundle method.
+   * @returns A {@link VaultTransactionBuildResult} with TransactionSets and a send method.
    * @throws If no steps have been configured (call addActions first).
    * @throws If any assembled transaction exceeds the 1232-byte Solana packet limit.
    */
   async build(): Promise<VaultTransactionBuildResult> {
     if (this.steps.length === 0) {
-      throw new Error("No steps configured. Call addActions() or addLoopscaleActions() before build().")
+      throw new Error("No steps configured. Call addActions() or addLoopscaleResponse() before build().")
     }
 
-    const { vault, connection, signer, vaultPda, pricesAccount } = this.config
+    const { vault, connection, signer, pricesAccount } = this.config
+    const vaultPda = this.config.vaultPda ?? vault.state.squadsVault
+    const extraLookupTableAddresses = this.config.lookupTableAddresses ?? []
+    const autoManagePositions = this.config.autoManagePositions ?? true
     const squadsProgram = this.config.squadsProgram ?? SQUADS_PROGRAM_ID
     const defaultCU = this.config.computeUnitLimit ?? 1_400_000
     const defaultHeap = this.config.heapFrameBytes ?? 256 * 1024
 
-    // 1. Price refresh TransactionSet
-    const priceOpts = this.config.priceRefreshOptions ?? {}
-    const priceIxs = await vault.ixsUpdateStrategyVaultPrices(pricesAccount)
-    const priceSet: TransactionSet = {
-      label: priceOpts.label ?? "price-refresh",
-      instructions: buildComputeBudgetIxs(
-        priceOpts.computeUnitLimit ?? defaultCU,
-        priceOpts.heapFrameBytes ?? defaultHeap,
-        priceOpts.priorityFee,
-      ).concat(priceIxs),
-      signers: [],
-      addressLookupTableAddresses: vault.state.addressLookupTable
-        ? [vault.state.addressLookupTable]
-        : [],
-    }
-
-    // 2. Per-step sync TransactionSets
-    const transactionSets: TransactionSet[] = [priceSet]
+    const transactionSets: TransactionSet[] = []
     const allAltAddresses = new Set<string>(
-      priceSet.addressLookupTableAddresses.map((a) => a.toBase58()),
+      [
+        ...(vault.state.addressLookupTable ? [vault.state.addressLookupTable.toBase58()] : []),
+        ...extraLookupTableAddresses.map((address) => address.toBase58()),
+      ],
     )
 
+    // Share a single setup context across all steps so that tracked accounts,
+    // positions, and orderbooks carry over — preventing duplicate setup txs.
+    const sharedSetupContext = createStrategySetupContext({
+      connection,
+      env: LOCAL_ENV,
+      owner: vaultPda,
+      signer,
+      vaultAddress: vault.selfAddress,
+      vaultPda,
+      accountIndex: 0,
+      squadsProgram,
+      autoManagePositions,
+      pricesAccount,
+    })
+    let loopscaleClient: LoopscaleClient | undefined
+
     for (const step of this.steps) {
-      const syncResult = await createVaultSyncTransaction({
+      if (step.kind === "loopscale-response") {
+        loopscaleClient ??= createBuilderLoopscaleClient({
+          connection,
+          vaultPda,
+          loopscale: this.config.loopscale,
+        })
+
+        const preparedTransactions = await loopscaleClient.prepareVaultTransactions({
+          response: step.response,
+          context: {
+            connection,
+            signer,
+            vaultPda,
+            vaultAddress: vault.selfAddress,
+            squadsProgram,
+          },
+        })
+        const stepPriceRefreshIxs = await buildSetupStatePriceRefreshInstructions(sharedSetupContext)
+
+        for (const [preparedIndex, preparedTransaction] of preparedTransactions.entries()) {
+          const txLabel = preparedTransactions.length === 1
+            ? step.label
+            : `${step.label}-${preparedIndex + 1}`
+
+          if (preparedTransaction.setupInstructions.length > 0) {
+            const setupAltAddresses = mergeAddressLookupTableAddresses(
+              extraLookupTableAddresses,
+              vault.state.addressLookupTable ? [vault.state.addressLookupTable] : [],
+            )
+            const setupSet: TransactionSet = {
+              label: `${txLabel}-setup`,
+              instructions: [
+                ComputeBudgetProgram.setComputeUnitLimit({ units: defaultCU }),
+                ...preparedTransaction.setupInstructions,
+              ],
+              signers: [],
+              addressLookupTableAddresses: setupAltAddresses,
+              coSignWithLoopscale: false,
+            }
+            if (touchesManagedVaultPrograms(setupSet.instructions, vault.programId, squadsProgram)) {
+              setupSet.instructions = insertAfterLeadingComputeBudgetAndScopeInstructions(
+                setupSet.instructions,
+                stepPriceRefreshIxs,
+              )
+            }
+            transactionSets.push(setupSet)
+            for (const alt of setupSet.addressLookupTableAddresses) {
+              allAltAddresses.add(alt.toBase58())
+            }
+          }
+
+          const shouldInjectLocalLoopscalePriceRefresh = (
+            !preparedTransaction.requiresLoopscaleCoSign
+            && touchesManagedVaultPrograms(preparedTransaction.instructions, vault.programId, squadsProgram)
+          )
+          const loopscaleSet: TransactionSet = {
+            label: txLabel,
+            instructions: preparedTransaction.instructions,
+            signers: preparedTransaction.signers,
+            addressLookupTableAddresses: shouldInjectLocalLoopscalePriceRefresh
+              ? mergeAddressLookupTableAddresses(
+                preparedTransaction.addressLookupTableAddresses,
+                extraLookupTableAddresses,
+                vault.state.addressLookupTable ? [vault.state.addressLookupTable] : [],
+              )
+              : mergeAddressLookupTableAddresses(
+                preparedTransaction.addressLookupTableAddresses,
+                extraLookupTableAddresses,
+              ),
+            coSignWithLoopscale: preparedTransaction.requiresLoopscaleCoSign,
+          }
+          if (shouldInjectLocalLoopscalePriceRefresh) {
+            loopscaleSet.instructions = insertAfterLeadingComputeBudgetAndScopeInstructions(
+              loopscaleSet.instructions,
+              stepPriceRefreshIxs,
+            )
+          }
+          transactionSets.push(loopscaleSet)
+
+          for (const alt of loopscaleSet.addressLookupTableAddresses) {
+            allAltAddresses.add(alt.toBase58())
+          }
+        }
+        continue
+      }
+
+      const stepCU = step.options.computeUnitLimit ?? defaultCU
+      const stepHeap = step.options.heapFrameBytes ?? defaultHeap
+      const syncResults = await createVaultSyncTransactions({
         instructions: step.instructions,
         owner: vaultPda,
         connection,
@@ -414,215 +481,219 @@ export class VaultTransactionBuilder {
         signer,
         vaultAddress: vault.selfAddress,
         squadsProgram,
+        autoManagePositions,
+        setupContext: sharedSetupContext,
       })
 
-      if (syncResult.setupInstructions.length > 0) {
-        transactionSets.push({
-          label: `${step.label}-setup`,
+      const stepPriceRefreshIxs = await buildSetupStatePriceRefreshInstructions(sharedSetupContext)
+
+      for (const [syncIndex, syncResult] of syncResults.entries()) {
+        const txLabel = syncResults.length === 1
+          ? step.label
+          : `${step.label}-${syncIndex + 1}`
+
+        if (syncResult.setupInstructions.length > 0) {
+          const setupSet: TransactionSet = {
+            label: `${txLabel}-setup`,
+            instructions: [
+              ComputeBudgetProgram.setComputeUnitLimit({ units: defaultCU }),
+              ...syncResult.setupInstructions,
+            ],
+            signers: [],
+            addressLookupTableAddresses: mergeAddressLookupTableAddresses(
+              syncResult.addressLookupTableAddresses,
+              extraLookupTableAddresses,
+              vault.state.addressLookupTable ? [vault.state.addressLookupTable] : [],
+            ),
+            coSignWithLoopscale: false,
+          }
+          if (shouldInjectPriceRefresh(setupSet, vault.programId, squadsProgram)) {
+            setupSet.instructions = insertAfterLeadingComputeBudgetAndScopeInstructions(
+              setupSet.instructions,
+              stepPriceRefreshIxs,
+            )
+          }
+          transactionSets.push(setupSet)
+          for (const alt of setupSet.addressLookupTableAddresses) {
+            allAltAddresses.add(alt.toBase58())
+          }
+        }
+
+        const syncSet: TransactionSet = {
+          label: txLabel,
           instructions: [
-            ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 }),
-            ...syncResult.setupInstructions,
+            ...buildComputeBudgetIxs(stepCU, stepHeap, step.options.priorityFee),
+            ...syncResult.preInstructions,
+            syncResult.instruction,
+            ...syncResult.postInstructions,
           ],
-          signers: [],
-          addressLookupTableAddresses: [],
-        })
-      }
-
-      const stepCU = step.options.computeUnitLimit ?? defaultCU
-      const stepHeap = step.options.heapFrameBytes ?? defaultHeap
-
-      const syncSet: TransactionSet = {
-        label: step.label,
-        instructions: [
-          ...buildComputeBudgetIxs(stepCU, stepHeap, step.options.priorityFee),
-          ...syncResult.preInstructions,
-          syncResult.instruction,
-          ...syncResult.postInstructions,
-        ],
-        signers: syncResult.signers,
-        addressLookupTableAddresses: [
-          ...syncResult.addressLookupTableAddresses,
-          ...(vault.state.addressLookupTable ? [vault.state.addressLookupTable] : []),
-        ],
-      }
-      transactionSets.push(syncSet)
+          signers: syncResult.signers,
+          addressLookupTableAddresses: mergeAddressLookupTableAddresses(
+            syncResult.addressLookupTableAddresses,
+            extraLookupTableAddresses,
+            vault.state.addressLookupTable ? [vault.state.addressLookupTable] : [],
+          ),
+          coSignWithLoopscale: false,
+        }
+        if (shouldInjectPriceRefresh(syncSet, vault.programId, squadsProgram)) {
+          syncSet.instructions = insertAfterLeadingComputeBudgetAndScopeInstructions(
+            syncSet.instructions,
+            stepPriceRefreshIxs,
+          )
+        }
+        transactionSets.push(syncSet)
 
-      for (const alt of syncSet.addressLookupTableAddresses) {
-        allAltAddresses.add(alt.toBase58())
+        for (const alt of syncSet.addressLookupTableAddresses) {
+          allAltAddresses.add(alt.toBase58())
+        }
       }
     }
 
     const lookupTableAddresses = [...allAltAddresses].map((a) => new PublicKey(a))
 
-    // Validate transaction sizes — catch oversized txs early with a clear error
-    const altAccounts = await resolveAltAccounts(connection, lookupTableAddresses)
-    for (const txSet of transactionSets) {
-      const txAltAccounts = altAccounts.filter((alt) =>
-        txSet.addressLookupTableAddresses.some((addr) => addr.equals(alt.key)),
-      )
-      try {
-        const testMsg = new TransactionMessage({
-          payerKey: signer,
-          recentBlockhash: "1".repeat(44),
-          instructions: txSet.instructions,
-        }).compileToV0Message(txAltAccounts)
-        const testTx = new VersionedTransaction(testMsg)
-        const serialized = testTx.serialize()
-        if (serialized.length > 1232) {
-          throw new Error(
-            `Transaction "${txSet.label}" is oversized (${serialized.length} bytes, limit 1232). ` +
-            `This usually means too many actions were packed into a single addActions() call. ` +
-            `Split them into separate addActions() calls so each gets its own sync transaction.`,
-          )
-        }
-      } catch (e) {
-        if (e instanceof Error && e.message.includes("oversized")) throw e
+    // Resolve the vault's persistent ALT to determine which account keys it
+    // already covers. Any keys NOT covered will need an ephemeral ALT.
+    const persistentAltAccounts = await resolveAltAccounts(connection, lookupTableAddresses)
+    const persistentAltKeys = new Set<string>()
+    for (const alt of persistentAltAccounts) {
+      for (const addr of alt.state.addresses) {
+        persistentAltKeys.add(addr.toBase58())
       }
     }
 
+    // Collect every unique account key referenced by any transaction set.
+    const allUniqueKeys = collectUniqueAccountKeys(transactionSets, signer)
+    const ephemeralAltEntries = allUniqueKeys.filter((k) => !persistentAltKeys.has(k.toBase58()))
+
+    // Validate transaction sizes. When an ephemeral ALT will be created,
+    // skip validation here — send() will validate after ALT activation.
+    if (ephemeralAltEntries.length === 0) {
+      validateTransactionSizes(transactionSets, persistentAltAccounts, signer)
+    }
+
     const labels = transactionSets.map((ts) => ts.label)
 
-    // Capture state for sendJitoBundle closure
+    // Capture state for send() closure
     const closedConnection = connection
     const closedSigner = signer
+    const closedVaultPda = vaultPda
     const closedLookupTableAddresses = lookupTableAddresses
-    const closedSteps = this.steps
+    const closedLoopscaleConfig = this.config.loopscale
 
     return {
       transactionSets,
       lookupTableAddresses,
       labels,
 
-      async sendJitoBundle(options: JitoBundleSendOptions): Promise<JitoBundleResult> {
+      async send(options: SendOptions): Promise<SendResult> {
+        const commitment = options.commitment ?? "confirmed"
+        const payer = options.signers[0]
+
+        // ── Ephemeral ALT creation ───────────────────────────────────────
+        let ephemeralAlt: { address: PublicKey; authority: PublicKey } | null = null
+        let ephemeralAltAccount: AddressLookupTableAccount | undefined
+
+        if (ephemeralAltEntries.length > 0) {
+          const slot = await closedConnection.getSlot("processed")
+          const recentSlot = Math.max(slot - 1, 0)
+          const [createIx, altAddress] = AddressLookupTableProgram.createLookupTable({
+            authority: payer.publicKey,
+            payer: payer.publicKey,
+            recentSlot,
+          })
+
+          // Chunk extend instructions — each can hold ~20 addresses safely
+          const extendChunks = chunkArray(ephemeralAltEntries, 20)
+          const extendIxs = extendChunks.map((chunk) =>
+            AddressLookupTableProgram.extendLookupTable({
+              lookupTable: altAddress,
+              authority: payer.publicKey,
+              payer: payer.publicKey,
+              addresses: chunk,
+            }),
+          )
+
+          // Send create + first extend in one transaction
+          const altSetupIxs: TransactionInstruction[] = [createIx, extendIxs[0]!]
+          await sendAndConfirmTransaction(closedConnection, altSetupIxs, [payer], commitment)
+
+          // Send remaining extend chunks if any
+          for (let i = 1; i < extendIxs.length; i++) {
+            await sendAndConfirmTransaction(closedConnection, [extendIxs[i]!], [payer], commitment)
+          }
+
+          // Wait for ALT entries to become active (usable in the slot AFTER extension)
+          await waitForSlotAdvance(closedConnection, slot, "processed")
+
+          // Resolve the ephemeral ALT account for use in transactions
+          const resolved = await closedConnection.getAddressLookupTable(altAddress)
+          if (!resolved.value) {
+            throw new Error(`Ephemeral ALT ${altAddress.toBase58()} not found after creation`)
+          }
+          ephemeralAltAccount = resolved.value
+          ephemeralAlt = { address: altAddress, authority: payer.publicKey }
+        }
+
+        // ── Resolve all ALT accounts (persistent + ephemeral) ────────────
         const resolvedAltAccounts = await resolveAltAccounts(closedConnection, closedLookupTableAddresses)
-        const { blockhash, lastValidBlockHeight } = await closedConnection.getLatestBlockhash()
+        if (ephemeralAltAccount) {
+          resolvedAltAccounts.push(ephemeralAltAccount)
+        }
+
+        // If we skipped build-time validation, validate now with the full ALT set
+        if (ephemeralAltEntries.length > 0) {
+          validateTransactionSizes(transactionSets, resolvedAltAccounts, closedSigner, ephemeralAltAccount)
+        }
 
-        // Auto-create LoopscaleClient if any step needs co-signing
-        const hasLoopscale = closedSteps.some((s) => s.isLoopscale)
+        // ── Auto-create LoopscaleClient if any step needs co-signing ─────
+        const hasLoopscale = transactionSets.some((txSet) => txSet.coSignWithLoopscale)
         let loopscaleClient: LoopscaleClient | undefined
         if (hasLoopscale) {
-          loopscaleClient = new LoopscaleClient({
+          loopscaleClient = createBuilderLoopscaleClient({
             connection: closedConnection,
-            userWallet: closedSigner,
+            vaultPda: closedVaultPda,
+            loopscale: closedLoopscaleConfig,
           })
         }
 
-        const allTxs: VersionedTransaction[] = []
-        for (let i = 0; i < transactionSets.length; i++) {
-          const txSet = transactionSets[i]
-          const isLast = i === transactionSets.length - 1
-
-          const instructions = [...txSet.instructions]
-          if (isLast && options.tipLamports > 0) {
-            instructions.push(createJitoTipIx(options.tipLamports, options.signers[0].publicKey))
-          }
+        // ── Send transactions ────────────────────────────────────────────
+        const signatures: string[] = []
+        for (const txSet of transactionSets) {
+          const { blockhash, lastValidBlockHeight } = await closedConnection.getLatestBlockhash()
 
+          // Include the ephemeral ALT for every transaction set
           const txAltAccounts = resolvedAltAccounts.filter((alt) =>
-            txSet.addressLookupTableAddresses.some((addr) => addr.equals(alt.key)),
+            txSet.addressLookupTableAddresses.some((addr) => addr.equals(alt.key))
+            || (ephemeralAltAccount && alt.key.equals(ephemeralAltAccount.key)),
           )
 
           const msg = new TransactionMessage({
-            payerKey: options.signers[0].publicKey,
+            payerKey: payer.publicKey,
             recentBlockhash: blockhash,
-            instructions,
+            instructions: txSet.instructions,
           }).compileToV0Message(txAltAccounts)
 
           let tx = new VersionedTransaction(msg)
-
-          // Co-sign Loopscale steps, sign everything else normally
-          const step = closedSteps.find((s) => s.label === txSet.label)
-          if (step?.isLoopscale && loopscaleClient) {
+          if (txSet.coSignWithLoopscale && loopscaleClient) {
             tx.sign([...options.signers, ...txSet.signers])
             tx = await loopscaleClient.coSign(tx)
           } else {
             tx.sign([...options.signers, ...txSet.signers])
           }
 
-          allTxs.push(tx)
-        }
-
-        // Custom send escape hatch (for testing)
-        if (options.customSend) {
-          const sigs = await options.customSend(allTxs, labels)
-          return { signatures: sigs, bundleId: "" }
-        }
-
-        const serialized = allTxs.map((tx) => Buffer.from(tx.serialize()))
-        const result = await sendJitoBundleRpc(serialized, options.jitoAuthKey)
-
-        const commitment = options.commitment ?? "confirmed"
-        if (result.signatures.length > 0) {
+          const sig = await closedConnection.sendTransaction(tx)
           await closedConnection.confirmTransaction(
-            { signature: result.signatures[0], blockhash, lastValidBlockHeight },
+            { signature: sig, blockhash, lastValidBlockHeight },
             commitment,
-          ).catch(() => {})
+          )
+          signatures.push(sig)
         }
 
-        return result
+        return { signatures, ephemeralAlt }
       },
-    }
-  }
-}
-
-// ============================================================================
-// bundleForJito — standalone utility
-// ============================================================================
 
-/**
- * Package TransactionSets into Jito-compatible unsigned VersionedTransactions.
- *
- * All transactions share the same blockhash and a Jito tip instruction is appended
- * to the last transaction. The returned transactions are **unsigned** — the caller
- * is responsible for signing (useful for web app flows where a wallet adapter handles signing).
- *
- * For a fully managed sign-and-send flow, use {@link VaultTransactionBuildResult.sendJitoBundle} instead.
- *
- * @param transactionSets - Ordered TransactionSets from `builder.build()`.
- * @param params.connection - Solana RPC connection for ALT resolution and blockhash fetching.
- * @param params.payer - Public key of the fee payer (used in the V0 message header).
- * @param params.tipLamports - Jito tip amount in lamports, appended to the last transaction.
- * @param params.lookupTableAddresses - All ALT addresses from the build result.
- * @returns Unsigned VersionedTransactions ready for wallet signing.
- */
-export async function bundleForJito(
-  transactionSets: TransactionSet[],
-  params: {
-    connection: Connection
-    payer: PublicKey
-    tipLamports: number
-    lookupTableAddresses: PublicKey[]
-  },
-): Promise<VersionedTransaction[]> {
-  const { connection, payer, tipLamports, lookupTableAddresses } = params
-
-  const altAccounts = await resolveAltAccounts(connection, lookupTableAddresses)
-  const { blockhash } = await connection.getLatestBlockhash()
-
-  const transactions: VersionedTransaction[] = []
-
-  for (let i = 0; i < transactionSets.length; i++) {
-    const txSet = transactionSets[i]
-    const isLast = i === transactionSets.length - 1
-
-    const instructions = [...txSet.instructions]
-    if (isLast && tipLamports > 0) {
-      instructions.push(createJitoTipIx(tipLamports, payer))
     }
-
-    const txAltAccounts = altAccounts.filter((alt) =>
-      txSet.addressLookupTableAddresses.some((addr) => addr.equals(alt.key)),
-    )
-
-    const messageV0 = new TransactionMessage({
-      payerKey: payer,
-      recentBlockhash: blockhash,
-      instructions,
-    }).compileToV0Message(txAltAccounts)
-
-    transactions.push(new VersionedTransaction(messageV0))
   }
-
-  return transactions
 }
 
 // ============================================================================
@@ -645,6 +716,91 @@ function buildComputeBudgetIxs(
   return ixs
 }
 
+function insertAfterLeadingComputeBudgetAndScopeInstructions(
+  instructions: TransactionInstruction[],
+  extraInstructions: TransactionInstruction[],
+): TransactionInstruction[] {
+  if (extraInstructions.length === 0) {
+    return instructions
+  }
+
+  let insertIndex = 0
+  while (
+    insertIndex < instructions.length
+    && instructions[insertIndex]?.programId.equals(ComputeBudgetProgram.programId)
+  ) {
+    insertIndex += 1
+  }
+
+  while (
+    insertIndex < instructions.length
+    && instructions[insertIndex]?.programId.equals(SCOPE_PROGRAM_ID)
+  ) {
+    insertIndex += 1
+  }
+
+  return [
+    ...instructions.slice(0, insertIndex),
+    ...extraInstructions,
+    ...instructions.slice(insertIndex),
+  ]
+}
+
+function shouldInjectPriceRefresh(
+  txSet: TransactionSet,
+  programId: PublicKey,
+  squadsProgram: PublicKey,
+): boolean {
+  if (!txSet.label.endsWith("-setup")) {
+    return true
+  }
+
+  return txSet.instructions.some((instruction) =>
+    instruction.programId.equals(programId) || instruction.programId.equals(squadsProgram),
+  )
+}
+
+function touchesManagedVaultPrograms(
+  instructions: TransactionInstruction[],
+  programId: PublicKey,
+  squadsProgram: PublicKey,
+): boolean {
+  return instructions.some((instruction) =>
+    instruction.programId.equals(programId) || instruction.programId.equals(squadsProgram),
+  )
+}
+
+function mergeAddressLookupTableAddresses(
+  ...addressGroups: Array<readonly PublicKey[]>
+): PublicKey[] {
+  const seen = new Set<string>()
+  const merged: PublicKey[] = []
+
+  for (const group of addressGroups) {
+    for (const address of group) {
+      const key = address.toBase58()
+      if (seen.has(key)) continue
+      seen.add(key)
+      merged.push(address)
+    }
+  }
+
+  return merged
+}
+
+function createBuilderLoopscaleClient(params: {
+  connection: Connection
+  vaultPda: PublicKey
+  loopscale?: VaultTransactionBuilderLoopscaleConfig
+}): LoopscaleClient {
+  return new LoopscaleClient({
+    connection: params.connection,
+    userWallet: params.vaultPda,
+    baseUrl: params.loopscale?.baseUrl,
+    debug: params.loopscale?.debug,
+  })
+}
+
 /** Fetch and resolve AddressLookupTableAccounts from on-chain, filtering nulls. */
 async function resolveAltAccounts(
   connection: Connection,
@@ -658,128 +814,120 @@ async function resolveAltAccounts(
     .filter((v): v is AddressLookupTableAccount => v !== null)
 }
 
-/** Create a Jito tip transfer instruction to a random tip address. */
-function createJitoTipIx(tipLamports: number, payer: PublicKey): TransactionInstruction {
-  const tipReceiver = JITO_TIP_ADDRESSES[Math.floor(Math.random() * JITO_TIP_ADDRESSES.length)]
-  return SystemProgram.transfer({
-    fromPubkey: payer,
-    toPubkey: tipReceiver,
-    lamports: BigInt(Math.floor(tipLamports)),
-  })
-}
-
-// ── Jito bundle sending ──
-
-type JitoRpcResponse = { result?: string; error?: unknown }
+/** Collect all unique account keys referenced across all transaction sets. */
+function collectUniqueAccountKeys(
+  transactionSets: TransactionSet[],
+  signer: PublicKey,
+): PublicKey[] {
+  const seen = new Set<string>()
+  const keys: PublicKey[] = []
 
-/**
- * Send a bundle of serialized transactions to Jito block engine endpoints.
- * Fans out to regional endpoints (best-effort) and retries the mainnet endpoint.
- */
-async function sendJitoBundleRpc(
-  serializedTransactions: Buffer[],
-  authKey?: string,
-): Promise<JitoBundleResult> {
-  if (serializedTransactions.length > 5) {
-    throw new Error("Jito bundles support at most 5 transactions")
+  const add = (pubkey: PublicKey) => {
+    const str = pubkey.toBase58()
+    if (!seen.has(str)) {
+      seen.add(str)
+      keys.push(pubkey)
+    }
   }
 
-  const signatures = serializedTransactions.map((tx) => {
-    const vtx = VersionedTransaction.deserialize(tx)
-    return Buffer.from(vtx.signatures[0]).toString("base64")
-  })
-
-  const requestBody = {
-    jsonrpc: "2.0",
-    id: 1,
-    method: "sendBundle",
-    params: [serializedTransactions.map((tx) => tx.toString("base64")), { encoding: "base64" }],
+  add(signer)
+  for (const txSet of transactionSets) {
+    for (const ix of txSet.instructions) {
+      add(ix.programId)
+      for (const key of ix.keys) {
+        add(key.pubkey)
+      }
+    }
   }
 
-  const headers: Record<string, string> = { "Content-Type": "application/json" }
-  if (authKey) headers["x-jito-auth"] = authKey
-
-  // Fan out to regional endpoints (best-effort, don't await)
-  const regionalPromises = JITO_REGIONAL_URLS.map((url) =>
-    fetch(`${url}${JITO_BUNDLES_PATH}`, { method: "POST", headers, body: JSON.stringify(requestBody) })
-      .catch(() => {}),
-  )
-  Promise.allSettled(regionalPromises)
+  return keys
+}
 
-  // Retry mainnet endpoint
-  for (let attempt = 0; attempt < JITO_MAX_RETRIES; attempt++) {
+/** Validate that every transaction set can serialize within the 1232-byte limit. */
+function validateTransactionSizes(
+  transactionSets: TransactionSet[],
+  altAccounts: AddressLookupTableAccount[],
+  signer: PublicKey,
+  extraAlt?: AddressLookupTableAccount,
+): void {
+  for (const txSet of transactionSets) {
+    const txAltAccounts = altAccounts.filter((alt) =>
+      txSet.addressLookupTableAddresses.some((addr) => addr.equals(alt.key)),
+    )
+    if (extraAlt && !txAltAccounts.some((a) => a.key.equals(extraAlt.key))) {
+      txAltAccounts.push(extraAlt)
+    }
     try {
-      const response = await fetch(`${JITO_MAINNET_URL}${JITO_BUNDLES_PATH}`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(requestBody),
-      })
-
-      const data = (await response.json().catch(() => undefined)) as JitoRpcResponse | undefined
-
-      if (response.ok && !data?.error && typeof data?.result === "string") {
-        return { bundleId: data.result, signatures }
+      const testMsg = new TransactionMessage({
+        payerKey: signer,
+        recentBlockhash: PublicKey.default.toBase58(),
+        instructions: txSet.instructions,
+      }).compileToV0Message(txAltAccounts)
+      const testTx = new VersionedTransaction(testMsg)
+      const serialized = testTx.serialize()
+      if (serialized.length > 1232) {
+        throw new Error(
+          `Transaction "${txSet.label}" is oversized (${serialized.length} bytes, limit 1232). ` +
+          `This usually means too many actions were packed into a single addActions() call. ` +
+          `Split them into separate addActions() calls so each gets its own sync transaction.`,
+        )
       }
-
-      if (response.status === 400) {
-        return { bundleId: "", signatures }
+    } catch (e) {
+      if (e instanceof Error) {
+        const ixCount = txSet.instructions.length
+        const altCount = txAltAccounts.length
+        const accountCount = txSet.instructions.reduce((sum, ix) => sum + ix.keys.length, 0)
+        throw new Error(
+          `Transaction "${txSet.label}" failed to serialize: ${e.message}. ` +
+          `Transaction has ${ixCount} instructions, ${accountCount} account keys, ` +
+          `and ${altCount} address lookup table(s). ` +
+          `Try splitting actions into separate addActions() calls.`,
+        )
       }
-    } catch {}
-
-    await new Promise((r) => setTimeout(r, JITO_RETRY_DELAY_MS))
+      throw e
+    }
   }
-
-  return { bundleId: "", signatures }
 }
 
-// ── ALT auto-extension (reserved for future use) ──
+/** Split an array into chunks of the given size. */
+function chunkArray<T>(arr: T[], size: number): T[][] {
+  const chunks: T[][] = []
+  for (let i = 0; i < arr.length; i += size) {
+    chunks.push(arr.slice(i, i + size))
+  }
+  return chunks
+}
 
-/**
- * Auto-extend an address lookup table with all unique accounts from the given instructions.
- * Batches in groups of 30 addresses (Solana limit per extend instruction).
- * Waits 2 seconds after extension for ALT propagation.
- *
- * @internal Not currently wired into any flow. Reserved for when ALT management
- * needs to be handled by the builder (e.g., oversized Loopscale transactions).
- */
-async function autoExtendAlt(
+/** Build, sign, send, and confirm a simple transaction. */
+async function sendAndConfirmTransaction(
   connection: Connection,
-  lookupTable: PublicKey,
-  authority: web3.Signer,
   instructions: TransactionInstruction[],
-): Promise<void> {
-  const seen = new Set<string>()
-  const addresses: PublicKey[] = []
-  for (const ix of instructions) {
-    for (const key of [ix.programId, ...ix.keys.map((k) => k.pubkey)]) {
-      const keyStr = key.toBase58()
-      if (!seen.has(keyStr)) {
-        seen.add(keyStr)
-        addresses.push(key)
-      }
-    }
-  }
-
-  for (let i = 0; i < addresses.length; i += 30) {
-    const batch = addresses.slice(i, i + 30)
-    const extendIx = AddressLookupTableProgram.extendLookupTable({
-      payer: authority.publicKey,
-      authority: authority.publicKey,
-      lookupTable,
-      addresses: batch,
-    })
-
-    const { blockhash } = await connection.getLatestBlockhash()
-    const msg = new TransactionMessage({
-      payerKey: authority.publicKey,
-      recentBlockhash: blockhash,
-      instructions: [extendIx],
-    }).compileToV0Message()
+  signers: web3.Signer[],
+  commitment: web3.Commitment,
+): Promise<string> {
+  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash(commitment)
+  const msg = new TransactionMessage({
+    payerKey: signers[0]!.publicKey,
+    recentBlockhash: blockhash,
+    instructions,
+  }).compileToV0Message()
+  const tx = new VersionedTransaction(msg)
+  tx.sign(signers)
+  const sig = await connection.sendTransaction(tx)
+  await connection.confirmTransaction({ signature: sig, blockhash, lastValidBlockHeight }, commitment)
+  return sig
+}
 
-    const tx = new VersionedTransaction(msg)
-    tx.sign([authority])
-    await connection.sendRawTransaction(tx.serialize())
+/** Poll until the current slot advances past the target slot. */
+async function waitForSlotAdvance(
+  connection: Connection,
+  targetSlot: number,
+  commitment: web3.Commitment = "processed",
+): Promise<void> {
+  for (let i = 0; i < 60; i++) {
+    const currentSlot = await connection.getSlot(commitment)
+    if (currentSlot > targetSlot) return
+    await new Promise((r) => setTimeout(r, 400))
   }
-
-  await new Promise((r) => setTimeout(r, 2000))
+  throw new Error("Timed out waiting for slot to advance after ephemeral ALT creation")
 }