@zcomb/programs-sdk 1.2.0 → 1.3.0

package/dist/utils.d.ts

@@ -1,6 +1,12 @@
 export interface TxOptions {
     includeCuBudget?: boolean;
     computeUnits?: number;
+    /**
+     * Pre-create conditional token ATAs before launch to avoid exceeding
+     * Solana's 64 instruction trace limit. Default: true for 3+ options.
+     * Set to false if you've already created ATAs or want to manage them manually.
+     */
+    ensureATAs?: boolean;
 }
 export declare function parseIdlBytes(value: string): Buffer;
 export declare function getIdlConstant(idl: {

package/dist/utils.js

@@ -25,4 +25,4 @@ function getIdlConstant(idl, name) {
     }
     return constant.value;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zcomb/programs-sdk",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "SDK for ZCombinator Programs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/futarchy/client.ts

@@ -15,7 +15,12 @@ import {
   TransactionMessage,
   VersionedTransaction,
 } from "@solana/web3.js";
-import { getAssociatedTokenAddressSync, TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import {
+  getAssociatedTokenAddressSync,
+  TOKEN_PROGRAM_ID,
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  createAssociatedTokenAccountIdempotentInstruction,
+} from "@solana/spl-token";
 import { PROGRAM_ID, SQUADS_PROGRAM_ID } from "./constants";
 import {
   Futarchy,
@@ -298,6 +303,14 @@ export class FutarchyClient {
     // Slice arrays to numOptions (fixed-size arrays from Rust include empty slots)
     const condBaseMints = vault.condBaseMints.slice(0, numOptions);
     const condQuoteMints = vault.condQuoteMints.slice(0, numOptions);
+
+    // Pre-create conditional ATAs for 3+ options to avoid exceeding the
+    // 64 instruction trace limit. Each ATA creation via vault deposit adds
+    // 5 inner instructions; with 4 options that's 40 extra instructions.
+    const shouldEnsureATAs = options?.ensureATAs ?? (numOptions >= 3);
+    if (shouldEnsureATAs) {
+      await this._createConditionalATAs(creator, condBaseMints, condQuoteMints);
+    }
     const pools = proposal.pools.slice(0, numOptions);
 
     // Derive all user conditional token ATAs
@@ -367,6 +380,69 @@ export class FutarchyClient {
     return { builder };
   }
 
+  /**
+   * Pre-creates all conditional token ATAs for a user before launching a proposal.
+   *
+   * This is REQUIRED for proposals with 3+ options to avoid exceeding Solana's
+   * max instruction trace length limit (64 instructions). The vault's deposit CPI
+   * creates ATAs on-the-fly, each requiring 5 inner instructions. For 4 options:
+   * 8 ATAs × 5 = 40 extra instructions, pushing the total over 64.
+   *
+   * Pre-creating ATAs eliminates this overhead, reducing the trace to ~32 instructions.
+   *
+   * @param creator - The user who will receive conditional tokens
+   * @param proposalPda - The proposal PDA (must be initialized but not launched)
+   * @returns Transaction signature
+   */
+  async ensureConditionalATAs(
+    creator: PublicKey,
+    proposalPda: PublicKey,
+  ): Promise<string> {
+    const proposal = await this.fetchProposal(proposalPda);
+    const vault = await this.vault.fetchVault(proposal.vault);
+    const condBaseMints = vault.condBaseMints.slice(0, proposal.numOptions);
+    const condQuoteMints = vault.condQuoteMints.slice(0, proposal.numOptions);
+    return this._createConditionalATAs(creator, condBaseMints, condQuoteMints);
+  }
+
+  /**
+   * Internal helper to create conditional ATAs given mint arrays.
+   * Used by both ensureConditionalATAs and launchProposal to avoid redundant fetches.
+   */
+  private async _createConditionalATAs(
+    creator: PublicKey,
+    condBaseMints: PublicKey[],
+    condQuoteMints: PublicKey[],
+  ): Promise<string> {
+    const provider = this.program.provider as AnchorProvider;
+
+    // Build ATA creation instructions (idempotent - won't fail if exists)
+    const instructions: TransactionInstruction[] = [];
+    for (let i = 0; i < condBaseMints.length; i++) {
+      const userCondBaseAta = getAssociatedTokenAddressSync(condBaseMints[i], creator);
+      const userCondQuoteAta = getAssociatedTokenAddressSync(condQuoteMints[i], creator);
+
+      instructions.push(
+        createAssociatedTokenAccountIdempotentInstruction(
+          creator,
+          userCondBaseAta,
+          creator,
+          condBaseMints[i]
+        ),
+        createAssociatedTokenAccountIdempotentInstruction(
+          creator,
+          userCondQuoteAta,
+          creator,
+          condQuoteMints[i]
+        )
+      );
+    }
+
+    // Send transaction
+    const tx = new Transaction().add(...instructions);
+    return provider.sendAndConfirm(tx);
+  }
+
   async finalizeProposal(signer: PublicKey, proposalPda: PublicKey, options?: TxOptions) {
     const proposal = await this.fetchProposal(proposalPda);
     const vault = await this.vault.fetchVault(proposal.vault);
@@ -455,7 +531,206 @@ export class FutarchyClient {
       remainingAccounts
     ).preInstructions(this.maybeAddComputeBudget(options));
 
-    return { builder };
+    return { builder, numOptions };
+  }
+
+  /**
+   * Creates an Address Lookup Table for redemption operations.
+   * Required for proposals with 3+ options to avoid exceeding transaction size limits.
+   *
+   * @param creator - The user redeeming (creator of proposal or liquidity provider)
+   * @param proposalPda - The proposal PDA
+   * @returns ALT address
+   */
+  async createRedemptionALT(
+    creator: PublicKey,
+    proposalPda: PublicKey,
+  ): Promise<{ altAddress: PublicKey }> {
+    const provider = this.program.provider as AnchorProvider;
+    const proposal = await this.fetchProposal(proposalPda);
+    const vault = await this.vault.fetchVault(proposal.vault);
+    const numOptions = proposal.numOptions;
+
+    const { winningIdx } = parseProposalState(proposal.state);
+    if (winningIdx === null) {
+      throw new Error("Proposal not finalized");
+    }
+
+    const addresses: PublicKey[] = [
+      // Programs
+      this.programId,
+      this.vault.programId,
+      this.amm.programId,
+      SystemProgram.programId,
+      TOKEN_PROGRAM_ID,
+      ASSOCIATED_TOKEN_PROGRAM_ID,
+      // Core accounts
+      proposalPda,
+      proposal.vault,
+      proposal.moderator,
+      vault.baseMint.address,
+      vault.quoteMint.address,
+      // Winning pool and reserves
+      proposal.pools[winningIdx],
+      // Vault token accounts
+      getAssociatedTokenAddressSync(vault.baseMint.address, proposal.vault, true),
+      getAssociatedTokenAddressSync(vault.quoteMint.address, proposal.vault, true),
+      // Creator's base/quote ATAs
+      getAssociatedTokenAddressSync(vault.baseMint.address, creator),
+      getAssociatedTokenAddressSync(vault.quoteMint.address, creator),
+    ];
+
+    // Winning pool reserves
+    const [reserveA] = deriveReservePDA(proposal.pools[winningIdx], vault.condQuoteMints[winningIdx], this.amm.programId);
+    const [reserveB] = deriveReservePDA(proposal.pools[winningIdx], vault.condBaseMints[winningIdx], this.amm.programId);
+    addresses.push(reserveA, reserveB);
+
+    // Per-option accounts (conditional mints and user ATAs)
+    for (let i = 0; i < numOptions; i++) {
+      addresses.push(
+        vault.condBaseMints[i],
+        vault.condQuoteMints[i],
+        getAssociatedTokenAddressSync(vault.condBaseMints[i], creator),
+        getAssociatedTokenAddressSync(vault.condQuoteMints[i], creator),
+      );
+    }
+
+    // Get recent slot for ALT creation
+    const slot = await provider.connection.getSlot("finalized");
+
+    const [createIx, altAddress] = AddressLookupTableProgram.createLookupTable({
+      authority: creator,
+      payer: creator,
+      recentSlot: slot,
+    });
+
+    // Create ALT
+    const createTx = new Transaction().add(createIx);
+    createTx.recentBlockhash = (await provider.connection.getLatestBlockhash()).blockhash;
+    createTx.feePayer = creator;
+    const signedTx = await provider.wallet.signTransaction(createTx);
+    const sig = await provider.connection.sendRawTransaction(signedTx.serialize(), {
+      skipPreflight: true,
+    });
+    await provider.connection.confirmTransaction(sig, "confirmed");
+
+    // Extend ALT with addresses
+    const CHUNK_SIZE = 20;
+    for (let i = 0; i < addresses.length; i += CHUNK_SIZE) {
+      const chunk = addresses.slice(i, i + CHUNK_SIZE);
+      const extendIx = AddressLookupTableProgram.extendLookupTable({
+        payer: creator,
+        authority: creator,
+        lookupTable: altAddress,
+        addresses: chunk,
+      });
+      const extendTx = new Transaction().add(extendIx);
+      await provider.sendAndConfirm(extendTx);
+    }
+
+    return { altAddress };
+  }
+
+  /**
+   * Builds a versioned transaction for redeeming liquidity with ALT.
+   * Required for proposals with 3+ options to avoid exceeding transaction size limits.
+   *
+   * @param creator - The user redeeming
+   * @param proposalPda - The proposal PDA
+   * @param altAddress - Optional ALT address (will be created if not provided for 3+ options)
+   * @returns Unsigned versioned transaction, ALT address, and number of options
+   */
+  async redeemLiquidityVersioned(
+    creator: PublicKey,
+    proposalPda: PublicKey,
+    altAddress?: PublicKey,
+  ): Promise<{ versionedTx: VersionedTransaction; altAddress: PublicKey; numOptions: number }> {
+    const provider = this.program.provider as AnchorProvider;
+    const { builder, numOptions } = await this.redeemLiquidity(creator, proposalPda);
+
+    // Create ALT if not provided and needed
+    let altPubkey = altAddress;
+    let verifiedALT: AddressLookupTableAccount | null = null;
+
+    if (!altPubkey && numOptions >= 3) {
+      console.log(`  Creating redemption ALT for ${numOptions} options...`);
+      const result = await this.createRedemptionALT(creator, proposalPda);
+      altPubkey = result.altAddress;
+      console.log(`  ✓ Redemption ALT created: ${altPubkey.toBase58()}`);
+
+      // Wait for ALT to be fully available with all addresses
+      // Use longer delays after extending to ensure propagation
+      console.log(`  Waiting for ALT propagation...`);
+      const expectedAddresses = 18 + (numOptions * 4); // Base accounts + per-option accounts
+      let attempts = 0;
+
+      // Initial delay after extension
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      while (attempts < 30) {
+        const altAccount = await provider.connection.getAddressLookupTable(altPubkey, {
+          commitment: 'confirmed',
+        });
+        if (altAccount.value) {
+          const addressCount = altAccount.value.state.addresses.length;
+          console.log(`  Attempt ${attempts + 1}: ALT has ${addressCount}/${expectedAddresses} addresses`);
+          if (addressCount >= expectedAddresses) {
+            verifiedALT = altAccount.value;
+            console.log(`  ✓ ALT verified with ${addressCount} addresses`);
+            break;
+          }
+        }
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        attempts++;
+      }
+
+      if (!verifiedALT) {
+        throw new Error(`ALT failed to populate with expected ${expectedAddresses} addresses after ${attempts} attempts`);
+      }
+    }
+
+    if (!altPubkey) {
+      throw new Error("ALT address required for multi-option redemption");
+    }
+
+    // Fetch ALT if we don't have it verified already
+    if (!verifiedALT) {
+      verifiedALT = await this.fetchALT(altPubkey);
+    }
+
+    // Build instruction
+    const instruction = await builder.instruction();
+    const computeBudgetIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 500_000 });
+
+    // Get fresh blockhash
+    const { blockhash } = await provider.connection.getLatestBlockhash();
+
+    // Build versioned transaction using the verified ALT (no re-fetch)
+    const versionedTx = this.buildVersionedTxWithALT(
+      creator,
+      [computeBudgetIx, instruction],
+      verifiedALT,
+      blockhash,
+    );
+
+    // Return the versioned transaction for the caller to sign and send
+    // This allows the caller to use their own signing mechanism (e.g., keypair.sign)
+    return { versionedTx, altAddress: altPubkey, numOptions };
+  }
+
+  /**
+   * Helper to send a signed versioned transaction.
+   */
+  async sendVersionedTransaction(
+    signedTx: VersionedTransaction,
+  ): Promise<string> {
+    const provider = this.program.provider as AnchorProvider;
+    const signature = await provider.connection.sendTransaction(signedTx, {
+      skipPreflight: false,
+      preflightCommitment: 'confirmed',
+    });
+    await provider.connection.confirmTransaction(signature, 'confirmed');
+    return signature;
   }
 
   /* Address Lookup Table */
@@ -566,12 +841,21 @@ export class FutarchyClient {
     instructions: TransactionInstruction[],
     altAddress: PublicKey,
   ): Promise<VersionedTransaction> {
+    const provider = this.program.provider as AnchorProvider;
     const alt = await this.fetchALT(altAddress);
-    const blockhash = await this.program.provider.connection.getLatestBlockhash();
+    const { blockhash } = await provider.connection.getLatestBlockhash();
+    return this.buildVersionedTxWithALT(payer, instructions, alt, blockhash);
+  }
 
+  buildVersionedTxWithALT(
+    payer: PublicKey,
+    instructions: TransactionInstruction[],
+    alt: AddressLookupTableAccount,
+    blockhash: string,
+  ): VersionedTransaction {
     const message = new TransactionMessage({
       payerKey: payer,
-      recentBlockhash: blockhash.blockhash,
+      recentBlockhash: blockhash,
       instructions,
     }).compileToV0Message([alt]);
 
@@ -729,57 +1013,4 @@ export class FutarchyClient {
 
     return { builder, daoPda, moderatorPda };
   }
-
-  /* High-Level Proposal Creator */
-
-  async createProposal(
-    creator: PublicKey,
-    moderatorPda: PublicKey,
-    proposalParams: ProposalParams,
-    baseAmount: BN | number,
-    quoteAmount: BN | number,
-    numOptions: number = 2,
-    metadata?: string,
-    options?: TxOptions
-  ) {
-    if (numOptions < 2) {
-      throw new Error("Minimum 2 options required");
-    }
-
-    // 1. Create ALT (sends txs internally)
-    const { altAddress } = await this.createProposalALT(creator, moderatorPda, numOptions);
-
-    // 2. Build initializeProposal
-    const initResult = await this.initializeProposal(creator, moderatorPda, proposalParams, metadata, options);
-
-    // 3. Build addOption for each additional option (beyond initial 2)
-    const addOptionBuilders: Awaited<ReturnType<typeof this.addOption>>["builder"][] = [];
-    const additionalPools: PublicKey[] = [];
-    const additionalCondBaseMints: PublicKey[] = [];
-    const additionalCondQuoteMints: PublicKey[] = [];
-
-    for (let i = 2; i < numOptions; i++) {
-      const addResult = await this.addOption(creator, initResult.proposalPda, options);
-      addOptionBuilders.push(addResult.builder);
-      additionalPools.push(addResult.pool);
-      additionalCondBaseMints.push(addResult.condBaseMint);
-      additionalCondQuoteMints.push(addResult.condQuoteMint);
-    }
-
-    // 4. Build launchProposal
-    const launchResult = await this.launchProposal(creator, initResult.proposalPda, baseAmount, quoteAmount, options);
-
-    return {
-      altAddress,
-      proposalPda: initResult.proposalPda,
-      proposalId: initResult.proposalId,
-      vaultPda: initResult.vaultPda,
-      pools: [...initResult.pools, ...additionalPools],
-      condBaseMints: [...initResult.condBaseMints, ...additionalCondBaseMints],
-      condQuoteMints: [...initResult.condQuoteMints, ...additionalCondQuoteMints],
-      initializeBuilder: initResult.builder,
-      addOptionBuilders,
-      launchBuilder: launchResult.builder,
-    };
-  }
 }

package/src/utils.ts

@@ -8,6 +8,12 @@
 export interface TxOptions {
   includeCuBudget?: boolean;  // Include compute budget instruction (default: true)
   computeUnits?: number;      // Override default compute units
+  /**
+   * Pre-create conditional token ATAs before launch to avoid exceeding
+   * Solana's 64 instruction trace limit. Default: true for 3+ options.
+   * Set to false if you've already created ATAs or want to manage them manually.
+   */
+  ensureATAs?: boolean;
 }
 
 /*