@exponent-labs/exponent-sdk 0.9.0 → 0.9.2

package/build/exponentVaults/vaultTransactionBuilder.js

@@ -1,33 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.bundleForJito = exports.VaultTransactionBuilder = void 0;
+exports.VaultTransactionBuilder = void 0;
 const web3_js_1 = require("@solana/web3.js");
-const loopscale_client_1 = require("./loopscale-client");
+const loopscale_1 = require("./loopscale");
 const vault_interaction_1 = require("./vault-interaction");
 const syncTransaction_1 = require("./syncTransaction");
-// ============================================================================
-// Jito constants
-// ============================================================================
-const JITO_TIP_ADDRESSES = [
-    new web3_js_1.PublicKey("96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5"),
-    new web3_js_1.PublicKey("HFqU5x63VTqvQss8hp11i4wVV8bD44PvwucfZ2bU7gRe"),
-    new web3_js_1.PublicKey("Cw8CFyM9FkoMi7K7Crf6HNQqf4uEMzpKw6QNghXLvLkY"),
-    new web3_js_1.PublicKey("ADaUMid9yfUytqMBgopwjb2DTLSokTSzL1zt6iGPaS49"),
-    new web3_js_1.PublicKey("DfXygSm4jCyNCybVYYK6DwvWqjKee8pbDmJGcLWNDXjh"),
-    new web3_js_1.PublicKey("ADuUkR4vqLUMWXxW9gh6D6L8pMSawimctcNZ5pGwDcEt"),
-    new web3_js_1.PublicKey("DttWaMuVvTiduZRnguLF7jNxTgiMBZ1hyAumKUiL2KRL"),
-    new web3_js_1.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;
+const environment_1 = require("../environment");
+const SCOPE_PROGRAM_ID = new web3_js_1.PublicKey("HFn8GnPADiny6XqUoWE8uRPPxb29ikn4yTuPa9MF2fWJ");
 // ============================================================================
 // VaultTransactionBuilder
 // ============================================================================
@@ -35,42 +14,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] })
  * ```
  */
 class VaultTransactionBuilder {
@@ -83,7 +64,7 @@ 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) {
@@ -115,70 +96,143 @@ class VaultTransactionBuilder {
     addActions(instructions, options) {
         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, options) {
+    addLoopscaleResponse(response, options) {
         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;
     }
     /**
      * 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() {
         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 ?? syncTransaction_1.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 = {
-            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 = [priceSet];
-        const allAltAddresses = new Set(priceSet.addressLookupTableAddresses.map((a) => a.toBase58()));
+        const transactionSets = [];
+        const allAltAddresses = new Set([
+            ...(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 = (0, vault_interaction_1.createStrategySetupContext)({
+            connection,
+            env: environment_1.LOCAL_ENV,
+            owner: vaultPda,
+            signer,
+            vaultAddress: vault.selfAddress,
+            vaultPda,
+            accountIndex: 0,
+            squadsProgram,
+            autoManagePositions,
+            pricesAccount,
+        });
+        let loopscaleClient;
         for (const step of this.steps) {
-            const syncResult = await (0, vault_interaction_1.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 (0, vault_interaction_1.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 = {
+                            label: `${txLabel}-setup`,
+                            instructions: [
+                                web3_js_1.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 = {
+                        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 (0, vault_interaction_1.createVaultSyncTransactions)({
                 instructions: step.instructions,
                 owner: vaultPda,
                 connection,
@@ -186,171 +240,172 @@ class VaultTransactionBuilder {
                 signer,
                 vaultAddress: vault.selfAddress,
                 squadsProgram,
+                autoManagePositions,
+                setupContext: sharedSetupContext,
             });
-            if (syncResult.setupInstructions.length > 0) {
-                transactionSets.push({
-                    label: `${step.label}-setup`,
+            const stepPriceRefreshIxs = await (0, vault_interaction_1.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 = {
+                        label: `${txLabel}-setup`,
+                        instructions: [
+                            web3_js_1.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 = {
+                    label: txLabel,
                     instructions: [
-                        web3_js_1.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 = {
-                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);
-            for (const alt of syncSet.addressLookupTableAddresses) {
-                allAltAddresses.add(alt.toBase58());
+                    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());
+                }
             }
         }
         const lookupTableAddresses = [...allAltAddresses].map((a) => new web3_js_1.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 web3_js_1.TransactionMessage({
-                    payerKey: signer,
-                    recentBlockhash: "1".repeat(44),
-                    instructions: txSet.instructions,
-                }).compileToV0Message(txAltAccounts);
-                const testTx = new web3_js_1.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();
+        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) {
+            async send(options) {
+                const commitment = options.commitment ?? "confirmed";
+                const payer = options.signers[0];
+                // ── Ephemeral ALT creation ───────────────────────────────────────
+                let ephemeralAlt = null;
+                let ephemeralAltAccount;
+                if (ephemeralAltEntries.length > 0) {
+                    const slot = await closedConnection.getSlot("processed");
+                    const recentSlot = Math.max(slot - 1, 0);
+                    const [createIx, altAddress] = web3_js_1.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) => web3_js_1.AddressLookupTableProgram.extendLookupTable({
+                        lookupTable: altAddress,
+                        authority: payer.publicKey,
+                        payer: payer.publicKey,
+                        addresses: chunk,
+                    }));
+                    // Send create + first extend in one transaction
+                    const altSetupIxs = [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();
-                // Auto-create LoopscaleClient if any step needs co-signing
-                const hasLoopscale = closedSteps.some((s) => s.isLoopscale);
+                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 = transactionSets.some((txSet) => txSet.coSignWithLoopscale);
                 let loopscaleClient;
                 if (hasLoopscale) {
-                    loopscaleClient = new loopscale_client_1.LoopscaleClient({
+                    loopscaleClient = createBuilderLoopscaleClient({
                         connection: closedConnection,
-                        userWallet: closedSigner,
+                        vaultPda: closedVaultPda,
+                        loopscale: closedLoopscaleConfig,
                     });
                 }
-                const allTxs = [];
-                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));
-                    }
-                    const txAltAccounts = resolvedAltAccounts.filter((alt) => txSet.addressLookupTableAddresses.some((addr) => addr.equals(alt.key)));
+                // ── Send transactions ────────────────────────────────────────────
+                const signatures = [];
+                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))
+                        || (ephemeralAltAccount && alt.key.equals(ephemeralAltAccount.key)));
                     const msg = new web3_js_1.TransactionMessage({
-                        payerKey: options.signers[0].publicKey,
+                        payerKey: payer.publicKey,
                         recentBlockhash: blockhash,
-                        instructions,
+                        instructions: txSet.instructions,
                     }).compileToV0Message(txAltAccounts);
                     let tx = new web3_js_1.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 sig = await closedConnection.sendTransaction(tx);
+                    await closedConnection.confirmTransaction({ signature: sig, blockhash, lastValidBlockHeight }, commitment);
+                    signatures.push(sig);
                 }
-                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) {
-                    await closedConnection.confirmTransaction({ signature: result.signatures[0], blockhash, lastValidBlockHeight }, commitment).catch(() => { });
-                }
-                return result;
+                return { signatures, ephemeralAlt };
             },
         };
     }
 }
 exports.VaultTransactionBuilder = VaultTransactionBuilder;
 // ============================================================================
-// 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.
- */
-async function bundleForJito(transactionSets, params) {
-    const { connection, payer, tipLamports, lookupTableAddresses } = params;
-    const altAccounts = await resolveAltAccounts(connection, lookupTableAddresses);
-    const { blockhash } = await connection.getLatestBlockhash();
-    const transactions = [];
-    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 web3_js_1.TransactionMessage({
-            payerKey: payer,
-            recentBlockhash: blockhash,
-            instructions,
-        }).compileToV0Message(txAltAccounts);
-        transactions.push(new web3_js_1.VersionedTransaction(messageV0));
-    }
-    return transactions;
-}
-exports.bundleForJito = bundleForJito;
-// ============================================================================
 // Internal helpers
 // ============================================================================
 /** Build compute budget instructions: CU limit + heap frame + optional priority fee. */
@@ -364,6 +419,56 @@ function buildComputeBudgetIxs(computeUnitLimit, heapFrameBytes, priorityFee) {
     }
     return ixs;
 }
+function insertAfterLeadingComputeBudgetAndScopeInstructions(instructions, extraInstructions) {
+    if (extraInstructions.length === 0) {
+        return instructions;
+    }
+    let insertIndex = 0;
+    while (insertIndex < instructions.length
+        && instructions[insertIndex]?.programId.equals(web3_js_1.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, programId, squadsProgram) {
+    if (!txSet.label.endsWith("-setup")) {
+        return true;
+    }
+    return txSet.instructions.some((instruction) => instruction.programId.equals(programId) || instruction.programId.equals(squadsProgram));
+}
+function touchesManagedVaultPrograms(instructions, programId, squadsProgram) {
+    return instructions.some((instruction) => instruction.programId.equals(programId) || instruction.programId.equals(squadsProgram));
+}
+function mergeAddressLookupTableAddresses(...addressGroups) {
+    const seen = new Set();
+    const merged = [];
+    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) {
+    return new loopscale_1.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, addresses) {
     const results = await Promise.all(addresses.map((addr) => connection.getAddressLookupTable(addr)));
@@ -371,100 +476,93 @@ async function resolveAltAccounts(connection, addresses) {
         .map((r) => r.value)
         .filter((v) => v !== null);
 }
-/** Create a Jito tip transfer instruction to a random tip address. */
-function createJitoTipIx(tipLamports, payer) {
-    const tipReceiver = JITO_TIP_ADDRESSES[Math.floor(Math.random() * JITO_TIP_ADDRESSES.length)];
-    return web3_js_1.SystemProgram.transfer({
-        fromPubkey: payer,
-        toPubkey: tipReceiver,
-        lamports: BigInt(Math.floor(tipLamports)),
-    });
-}
-/**
- * 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, authKey) {
-    if (serializedTransactions.length > 5) {
-        throw new Error("Jito bundles support at most 5 transactions");
-    }
-    const signatures = serializedTransactions.map((tx) => {
-        const vtx = web3_js_1.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" }],
+/** Collect all unique account keys referenced across all transaction sets. */
+function collectUniqueAccountKeys(transactionSets, signer) {
+    const seen = new Set();
+    const keys = [];
+    const add = (pubkey) => {
+        const str = pubkey.toBase58();
+        if (!seen.has(str)) {
+            seen.add(str);
+            keys.push(pubkey);
+        }
     };
-    const headers = { "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);
-    // Retry mainnet endpoint
-    for (let attempt = 0; attempt < JITO_MAX_RETRIES; attempt++) {
-        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));
-            if (response.ok && !data?.error && typeof data?.result === "string") {
-                return { bundleId: data.result, signatures };
-            }
-            if (response.status === 400) {
-                return { bundleId: "", signatures };
+    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);
             }
         }
-        catch { }
-        await new Promise((r) => setTimeout(r, JITO_RETRY_DELAY_MS));
     }
-    return { bundleId: "", signatures };
+    return keys;
 }
-// ── ALT auto-extension (reserved for future use) ──
-/**
- * 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(connection, lookupTable, authority, instructions) {
-    const seen = new Set();
-    const addresses = [];
-    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);
+/** Validate that every transaction set can serialize within the 1232-byte limit. */
+function validateTransactionSizes(transactionSets, altAccounts, signer, extraAlt) {
+    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 testMsg = new web3_js_1.TransactionMessage({
+                payerKey: signer,
+                recentBlockhash: web3_js_1.PublicKey.default.toBase58(),
+                instructions: txSet.instructions,
+            }).compileToV0Message(txAltAccounts);
+            const testTx = new web3_js_1.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) {
+                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.`);
             }
+            throw e;
         }
     }
-    for (let i = 0; i < addresses.length; i += 30) {
-        const batch = addresses.slice(i, i + 30);
-        const extendIx = web3_js_1.AddressLookupTableProgram.extendLookupTable({
-            payer: authority.publicKey,
-            authority: authority.publicKey,
-            lookupTable,
-            addresses: batch,
-        });
-        const { blockhash } = await connection.getLatestBlockhash();
-        const msg = new web3_js_1.TransactionMessage({
-            payerKey: authority.publicKey,
-            recentBlockhash: blockhash,
-            instructions: [extendIx],
-        }).compileToV0Message();
-        const tx = new web3_js_1.VersionedTransaction(msg);
-        tx.sign([authority]);
-        await connection.sendRawTransaction(tx.serialize());
+}
+/** Split an array into chunks of the given size. */
+function chunkArray(arr, size) {
+    const chunks = [];
+    for (let i = 0; i < arr.length; i += size) {
+        chunks.push(arr.slice(i, i + size));
+    }
+    return chunks;
+}
+/** Build, sign, send, and confirm a simple transaction. */
+async function sendAndConfirmTransaction(connection, instructions, signers, commitment) {
+    const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash(commitment);
+    const msg = new web3_js_1.TransactionMessage({
+        payerKey: signers[0].publicKey,
+        recentBlockhash: blockhash,
+        instructions,
+    }).compileToV0Message();
+    const tx = new web3_js_1.VersionedTransaction(msg);
+    tx.sign(signers);
+    const sig = await connection.sendTransaction(tx);
+    await connection.confirmTransaction({ signature: sig, blockhash, lastValidBlockHeight }, commitment);
+    return sig;
+}
+/** Poll until the current slot advances past the target slot. */
+async function waitForSlotAdvance(connection, targetSlot, commitment = "processed") {
+    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");
 }
 //# sourceMappingURL=vaultTransactionBuilder.js.map