refactor SDK's *Ix functions to only return a single instruction

scripts/v0.6/finalizeLaunch.ts

@@ -26,7 +26,7 @@ export const launch = async () => {
   await launchpad.closeLaunchIx({ launch }).rpc();
 
   const tx = await launchpad
-    .completeLaunchIx({
+    .completeLaunchTxBuilder({
       launch,
       // quoteMint: DEVNET_USDC,
       baseMint: mintKp,

scripts/v0.6/finalizeProposal.ts

@@ -1,6 +1,6 @@
 import * as anchor from "@coral-xyz/anchor";
 import { FutarchyClient } from "@metadaoproject/programs/futarchy/v0.6";
-import { PublicKey, Transaction } from "@solana/web3.js";
+import { PublicKey } from "@solana/web3.js";
 import { BN } from "@coral-xyz/anchor";
 
 const provider = anchor.AnchorProvider.env();
@@ -32,17 +32,14 @@ const finalizeProposal = async () => {
     })
     .instruction();
 
-  // Create finalize instruction
-  const finalizeIx = await futarchyClient
-    .finalizeProposalIxV2({
+  const tx = await futarchyClient
+    .finalizeProposalTxBuilder({
       squadsProposal: proposal.squadsProposal,
       dao: proposal.dao,
       baseMint: dao.baseMint,
     })
-    .instruction();
-
-  // Build and send transaction
-  const tx = new Transaction().add(spotSwapIx, finalizeIx);
+    .preInstructions([spotSwapIx])
+    .transaction();
   tx.recentBlockhash = (
     await provider.connection.getLatestBlockhash()
   ).blockhash;

scripts/v0.7/completeLaunch.ts

@@ -26,7 +26,7 @@ export const completeLaunch = async () => {
   let launchAccount = await launchpad.fetchLaunch(LAUNCH_TO_COMPLETE);
 
   const tx = await launchpad
-    .completeLaunchIx({
+    .completeLaunchTxBuilder({
       launch: LAUNCH_TO_COMPLETE,
       baseMint: launchAccount.baseMint,
       launchAuthority: payer.publicKey,

sdk/src/futarchy/v0.6/FutarchyClient.ts

@@ -300,44 +300,39 @@ export class FutarchyClient {
 
     const squadsMultisig = multisig.getMultisigPda({ createKey: dao })[0];
 
-    return this.futarchy.methods
-      .launchProposal()
-      .accounts({
-        proposal,
-        dao,
-        baseVault,
-        quoteVault,
-        passBaseMint,
+    return this.futarchy.methods.launchProposal().accounts({
+      proposal,
+      dao,
+      baseVault,
+      quoteVault,
+      passBaseMint,
+      passQuoteMint,
+      failBaseMint,
+      failQuoteMint,
+      ammPassBaseVault: getAssociatedTokenAddressSync(passBaseMint, dao, true),
+      ammPassQuoteVault: getAssociatedTokenAddressSync(
         passQuoteMint,
-        failBaseMint,
+        dao,
+        true,
+      ),
+      ammFailBaseVault: getAssociatedTokenAddressSync(failBaseMint, dao, true),
+      ammFailQuoteVault: getAssociatedTokenAddressSync(
         failQuoteMint,
-        ammPassBaseVault: getAssociatedTokenAddressSync(
-          passBaseMint,
-          dao,
-          true,
-        ),
-        ammPassQuoteVault: getAssociatedTokenAddressSync(
-          passQuoteMint,
-          dao,
-          true,
-        ),
-        ammFailBaseVault: getAssociatedTokenAddressSync(
-          failBaseMint,
-          dao,
-          true,
-        ),
-        ammFailQuoteVault: getAssociatedTokenAddressSync(
-          failQuoteMint,
-          dao,
-          true,
-        ),
-        squadsMultisig,
-        squadsProposal,
-        payer: this.provider.publicKey,
-      })
-      .preInstructions([
-        ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 }),
-      ]);
+        dao,
+        true,
+      ),
+      squadsMultisig,
+      squadsProposal,
+      payer: this.provider.publicKey,
+    });
+  }
+
+  launchProposalTxBuilder(
+    args: Parameters<FutarchyClient["launchProposalIx"]>[0],
+  ) {
+    return this.launchProposalIx(args).preInstructions([
+      ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 }),
+    ]);
   }
 
   spotSwapIx({
@@ -747,7 +742,11 @@ export class FutarchyClient {
       storedProposal.dao,
       storedDao.baseMint,
       storedDao.quoteMint,
-    ).rpc();
+    )
+      .preInstructions([
+        ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 }),
+      ])
+      .rpc();
   }
 
   finalizeProposalIxV2({
@@ -772,6 +771,14 @@ export class FutarchyClient {
     );
   }
 
+  finalizeProposalTxBuilder(
+    args: Parameters<FutarchyClient["finalizeProposalIxV2"]>[0],
+  ) {
+    return this.finalizeProposalIxV2(args).preInstructions([
+      ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 }),
+    ]);
+  }
+
   /**
    * @deprecated use `finalizeProposalIxV2` instead
    */
@@ -797,59 +804,46 @@ export class FutarchyClient {
 
     const [vaultEventAuthority] = getEventAuthorityAddr(vaultProgramId);
 
-    return this.futarchy.methods
-      .finalizeProposal()
-      .accounts({
-        proposal,
-        dao,
-        squadsProposal,
-        squadsMultisig: multisigPda,
-        squadsMultisigProgram: SQUADS_PROGRAM_ID,
+    return this.futarchy.methods.finalizeProposal().accounts({
+      proposal,
+      dao,
+      squadsProposal,
+      squadsMultisig: multisigPda,
+      squadsMultisigProgram: SQUADS_PROGRAM_ID,
+      quoteVault,
+      question,
+      quoteVaultUnderlyingTokenAccount: getAssociatedTokenAddressSync(
+        usdc,
         quoteVault,
-        question,
-        quoteVaultUnderlyingTokenAccount: getAssociatedTokenAddressSync(
-          usdc,
-          quoteVault,
-          true,
-        ),
+        true,
+      ),
+      passQuoteMint,
+      failQuoteMint,
+      passBaseMint,
+      failBaseMint,
+      ammPassQuoteVault: getAssociatedTokenAddressSync(
         passQuoteMint,
+        dao,
+        true,
+      ),
+      ammFailQuoteVault: getAssociatedTokenAddressSync(
         failQuoteMint,
-        passBaseMint,
-        failBaseMint,
-        ammPassQuoteVault: getAssociatedTokenAddressSync(
-          passQuoteMint,
-          dao,
-          true,
-        ),
-        ammFailQuoteVault: getAssociatedTokenAddressSync(
-          failQuoteMint,
-          dao,
-          true,
-        ),
-        ammQuoteVault: getAssociatedTokenAddressSync(usdc, dao, true),
-        ammPassBaseVault: getAssociatedTokenAddressSync(
-          passBaseMint,
-          dao,
-          true,
-        ),
-        ammFailBaseVault: getAssociatedTokenAddressSync(
-          failBaseMint,
-          dao,
-          true,
-        ),
-        ammBaseVault: getAssociatedTokenAddressSync(daoToken, dao, true),
+        dao,
+        true,
+      ),
+      ammQuoteVault: getAssociatedTokenAddressSync(usdc, dao, true),
+      ammPassBaseVault: getAssociatedTokenAddressSync(passBaseMint, dao, true),
+      ammFailBaseVault: getAssociatedTokenAddressSync(failBaseMint, dao, true),
+      ammBaseVault: getAssociatedTokenAddressSync(daoToken, dao, true),
+      baseVault,
+      baseVaultUnderlyingTokenAccount: getAssociatedTokenAddressSync(
+        daoToken,
         baseVault,
-        baseVaultUnderlyingTokenAccount: getAssociatedTokenAddressSync(
-          daoToken,
-          baseVault,
-          true,
-        ),
-        vaultProgram: this.vaultClient.vaultProgram.programId,
-        vaultEventAuthority,
-      })
-      .preInstructions([
-        ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 }),
-      ]);
+        true,
+      ),
+      vaultProgram: this.vaultClient.vaultProgram.programId,
+      vaultEventAuthority,
+    });
   }
 
   updateDaoIx({ dao, params }: { dao: PublicKey; params: UpdateDaoParams }) {

sdk/src/launchpad/v0.6/LaunchpadClient.ts

@@ -463,11 +463,16 @@ export class LaunchpadClient {
           dammV2EventAuthority,
         },
         // poolCreatorAuthority,
-      })
-      .preInstructions([
-        ComputeBudgetProgram.setComputeUnitLimit({ units: 850_000 }),
-        ComputeBudgetProgram.requestHeapFrame({ bytes: 255 * 1024 }),
-      ]);
+      });
+  }
+
+  completeLaunchTxBuilder(
+    args: Parameters<LaunchpadClient["completeLaunchIx"]>[0],
+  ) {
+    return this.completeLaunchIx(args).preInstructions([
+      ComputeBudgetProgram.setComputeUnitLimit({ units: 850_000 }),
+      ComputeBudgetProgram.requestHeapFrame({ bytes: 255 * 1024 }),
+    ]);
   }
 
   refundIx({