Add a script for merging conditional tokens (#233)

Anchor.toml

@@ -27,6 +27,7 @@ send-tokens = "yarn run ts-node scripts/sendTokens.ts"
 crank = "yarn run ts-node scripts/crankTwap.ts"
 attach-metadata = "yarn run ts-node scripts/attachMetadata.ts"
 reclaim-tokens = "yarn run ts-node scripts/reclaimTokens.ts"
+merge-tokens = "yarn run ts-node scripts/mergeTokens.ts"
 test = "yarn run ts-mocha -p ./tsconfig.json -t 1000000 tests/*.ts"
 
 [test]

scripts/mergeTokens.ts

@@ -0,0 +1,70 @@
+import * as anchor from "@coral-xyz/anchor";
+import { MEMO_PROGRAM_ID } from "@solana/spl-memo";
+import * as token from "@solana/spl-token";
+import { ComputeBudgetProgram, LAMPORTS_PER_SOL } from "@solana/web3.js";
+import {
+  AmmClient,
+  AutocratClient,
+  ConditionalVaultClient,
+} from "@metadaoproject/futarchy";
+import { InstructionUtils } from "@metadaoproject/futarchy";
+
+const { PublicKey, Keypair, SystemProgram } = anchor.web3;
+const { BN, Program } = anchor;
+
+const provider = anchor.AnchorProvider.env();
+anchor.setProvider(provider);
+
+let autocratClient: AutocratClient = AutocratClient.createClient({
+  provider: anchor.AnchorProvider.env(),
+});
+
+let ammClient: AmmClient = AmmClient.createClient({
+  provider: anchor.AnchorProvider.env(),
+});
+
+let vaultClient: ConditionalVaultClient = ConditionalVaultClient.createClient({
+  provider: anchor.AnchorProvider.env(),
+});
+
+const payer = provider.wallet["payer"];
+
+const PROPOSAL = new PublicKey("MW1dKeDYgewceWuaSmDytdpwNzZDwABf1FuwJix923C");
+
+async function main() {
+  const DAO = new PublicKey("ofvb3CPvEyRfD5az8PAqW6ATpPqVBeiB5zBnpPR5cgm");
+
+  const storedDao = await autocratClient.getDao(DAO);
+  console.log(storedDao);
+
+  const {
+    passAmm,
+    failAmm,
+    baseVault,
+    quoteVault,
+    passBaseMint,
+    passQuoteMint,
+    failBaseMint,
+    failQuoteMint,
+    passLp,
+    failLp,
+  } = autocratClient.getProposalPdas(
+    PROPOSAL,
+    storedDao.tokenMint,
+    storedDao.usdcMint,
+    DAO
+  );
+
+  const basePassBalance = (await token.getOrCreateAssociatedTokenAccount(provider.connection, payer, passBaseMint, payer.publicKey)).amount;
+  const quotePassBalance = (await token.getOrCreateAssociatedTokenAccount(provider.connection, payer, passQuoteMint, payer.publicKey)).amount;
+
+  await vaultClient.mergeConditionalTokensIx(baseVault, storedDao.tokenMint, new BN(basePassBalance.toString()))
+    .preInstructions([
+        ComputeBudgetProgram.setComputeUnitLimit({ units: 150_000 }),
+        ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 100 }),
+        await vaultClient.mergeConditionalTokensIx(quoteVault, storedDao.usdcMint, new BN(quotePassBalance.toString())).instruction(),
+    ])
+    .rpc();
+}
+
+main();

sdk/src/ConditionalVaultClient.ts

@@ -289,6 +289,48 @@ export class ConditionalVaultClient {
       });
   }
 
+  mergeConditionalTokensIx(
+    vault: PublicKey,
+    underlyingTokenMint: PublicKey,
+    amount: BN
+  ) {
+    const [conditionalOnFinalizeTokenMint] = getVaultFinalizeMintAddr(
+      this.vaultProgram.programId,
+      vault
+    );
+    const [conditionalOnRevertTokenMint] = getVaultRevertMintAddr(
+      this.vaultProgram.programId,
+      vault
+    );
+
+    return this.vaultProgram.methods
+      .mergeConditionalTokensForUnderlyingTokens(amount)
+      .accounts({
+        authority: this.provider.publicKey,
+        vault,
+        vaultUnderlyingTokenAccount: getAssociatedTokenAddressSync(
+          underlyingTokenMint,
+          vault,
+          true
+        ),
+        userUnderlyingTokenAccount: getAssociatedTokenAddressSync(
+          underlyingTokenMint,
+          this.provider.publicKey,
+          true
+        ),
+        conditionalOnFinalizeTokenMint,
+        userConditionalOnFinalizeTokenAccount: getAssociatedTokenAddressSync(
+          conditionalOnFinalizeTokenMint,
+          this.provider.publicKey
+        ),
+        conditionalOnRevertTokenMint,
+        userConditionalOnRevertTokenAccount: getAssociatedTokenAddressSync(
+          conditionalOnRevertTokenMint,
+          this.provider.publicKey
+        ),
+      });
+  }
+
   async initializeVault(
     settlementAuthority: PublicKey,
     underlyingTokenMint: PublicKey