@metadaoproject/futarchy 0.3.0-alpha.15 → 0.3.0-alpha.17

package/dist/ConditionalVaultClient.d.ts

@@ -1,5 +1,5 @@
 import { AnchorProvider, Program } from "@coral-xyz/anchor";
-import { Keypair, PublicKey } from "@solana/web3.js";
+import { AddressLookupTableAccount, Keypair, PublicKey } from "@solana/web3.js";
 import { ConditionalVault } from "./types/conditional_vault";
 import BN from "bn.js";
 import { MethodsBuilder } from "@coral-xyz/anchor/dist/cjs/program/namespace/methods";
@@ -10,135 +10,151 @@ export type CreateVaultClientParams = {
 export declare class ConditionalVaultClient {
     readonly provider: AnchorProvider;
     readonly vaultProgram: Program<ConditionalVault>;
-    constructor(provider: AnchorProvider, conditionalVaultProgramId: PublicKey);
+    readonly luts: AddressLookupTableAccount[];
+    constructor(provider: AnchorProvider, conditionalVaultProgramId: PublicKey, luts: AddressLookupTableAccount[]);
     static createClient(createVaultClientParams: CreateVaultClientParams): ConditionalVaultClient;
-    fetchQuestion(question: PublicKey): Promise<{
-        questionId: number[];
-        oracle: PublicKey;
-        payoutNumerators: number[];
-        payoutDenominator: number;
-    }>;
-    fetchVault(vault: PublicKey): Promise<{
-        question: PublicKey;
-        underlyingTokenMint: PublicKey;
-        underlyingTokenAccount: PublicKey;
-        conditionalTokenMints: PublicKey[];
-        pdaBump: number;
-        decimals: number;
-    }>;
     getVault(vault: PublicKey): Promise<{
-        question: PublicKey;
+        status: ({
+            finalized?: undefined;
+            reverted?: undefined;
+        } & {
+            active: Record<string, never>;
+        }) | ({
+            active?: undefined;
+            reverted?: undefined;
+        } & {
+            finalized: Record<string, never>;
+        }) | ({
+            active?: undefined;
+            finalized?: undefined;
+        } & {
+            reverted: Record<string, never>;
+        });
+        settlementAuthority: PublicKey;
         underlyingTokenMint: PublicKey;
         underlyingTokenAccount: PublicKey;
-        conditionalTokenMints: PublicKey[];
+        conditionalOnFinalizeTokenMint: PublicKey;
+        conditionalOnRevertTokenMint: PublicKey;
         pdaBump: number;
         decimals: number;
     }>;
-    initializeQuestionIx(questionId: Uint8Array, oracle: PublicKey, numConditions: number): MethodsBuilder<ConditionalVault, {
-        name: "initializeQuestion";
+    mintConditionalTokens(vault: PublicKey, uiAmount: number, user?: PublicKey | Keypair): Promise<string>;
+    mintConditionalTokensIx(vault: PublicKey, underlyingTokenMint: PublicKey, amount: BN, user?: PublicKey | Keypair): MethodsBuilder<ConditionalVault, {
+        name: "mintConditionalTokens";
         accounts: [{
-            name: "question";
+            name: "vault";
+            isMut: false;
+            isSigner: false;
+        }, {
+            name: "conditionalOnFinalizeTokenMint";
             isMut: true;
             isSigner: false;
         }, {
-            name: "payer";
+            name: "conditionalOnRevertTokenMint";
             isMut: true;
-            isSigner: true;
+            isSigner: false;
         }, {
-            name: "systemProgram";
+            name: "vaultUnderlyingTokenAccount";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "authority";
             isMut: false;
+            isSigner: true;
+        }, {
+            name: "userConditionalOnFinalizeTokenAccount";
+            isMut: true;
             isSigner: false;
-        }];
-        args: [{
-            name: "args";
-            type: {
-                defined: "InitializeQuestionArgs";
-            };
-        }];
-    } & {
-        name: "initializeQuestion";
-    }>;
-    initializeQuestion(questionId: Uint8Array, oracle: PublicKey, numConditions: number): Promise<PublicKey>;
-    initializeVaultIx(question: PublicKey, underlyingTokenMint: PublicKey, numOutcomes: number): MethodsBuilder<ConditionalVault, any>;
-    initializeVault(question: PublicKey, underlyingTokenMint: PublicKey, numOutcomes: number): Promise<PublicKey>;
-    resolveQuestionIx(question: PublicKey, oracle: Keypair, payoutNumerators: number[]): MethodsBuilder<ConditionalVault, {
-        name: "resolveQuestion";
-        accounts: [{
-            name: "question";
+        }, {
+            name: "userConditionalOnRevertTokenAccount";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "userUnderlyingTokenAccount";
             isMut: true;
             isSigner: false;
         }, {
-            name: "oracle";
+            name: "tokenProgram";
             isMut: false;
-            isSigner: true;
+            isSigner: false;
         }];
         args: [{
-            name: "args";
-            type: {
-                defined: "ResolveQuestionArgs";
-            };
+            name: "amount";
+            type: "u64";
         }];
     } & {
-        name: "resolveQuestion";
+        name: "mintConditionalTokens";
     }>;
-    getConditionalTokenMints(vault: PublicKey, numOutcomes: number): PublicKey[];
-    getRemainingAccounts(conditionalTokenMints: PublicKey[], userConditionalAccounts: PublicKey[]): {
-        pubkey: PublicKey;
-        isWritable: boolean;
-        isSigner: boolean;
-    }[];
-    getConditionalTokenAccountsAndInstructions(vault: PublicKey, numOutcomes: number, user: PublicKey): {
-        userConditionalAccounts: PublicKey[];
-        preInstructions: import("@solana/web3.js").TransactionInstruction[];
-        remainingAccounts: {
-            pubkey: PublicKey;
-            isWritable: boolean;
-            isSigner: boolean;
-        }[];
-    };
-    splitTokensIx(question: PublicKey, vault: PublicKey, underlyingTokenMint: PublicKey, amount: BN, numOutcomes: number, user?: PublicKey): MethodsBuilder<ConditionalVault, {
-        name: "splitTokens";
+    initializeVaultIx(settlementAuthority: PublicKey, underlyingTokenMint: PublicKey): MethodsBuilder<ConditionalVault, any>;
+    addMetadataToConditionalTokensIx(vault: PublicKey, underlyingTokenMint: PublicKey, proposalNumber: number, onFinalizeUri: string, onRevertUri: string): MethodsBuilder<ConditionalVault, {
+        name: "addMetadataToConditionalTokens";
         accounts: [{
-            name: "question";
-            isMut: false;
-            isSigner: false;
+            name: "payer";
+            isMut: true;
+            isSigner: true;
         }, {
             name: "vault";
-            isMut: false;
+            isMut: true;
             isSigner: false;
         }, {
-            name: "vaultUnderlyingTokenAccount";
+            name: "underlyingTokenMint";
             isMut: true;
             isSigner: false;
         }, {
-            name: "authority";
+            name: "underlyingTokenMetadata";
             isMut: false;
-            isSigner: true;
+            isSigner: false;
         }, {
-            name: "userUnderlyingTokenAccount";
+            name: "conditionalOnFinalizeTokenMint";
             isMut: true;
             isSigner: false;
         }, {
-            name: "tokenProgram";
+            name: "conditionalOnRevertTokenMint";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "conditionalOnFinalizeTokenMetadata";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "conditionalOnRevertTokenMetadata";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "tokenMetadataProgram";
+            isMut: false;
+            isSigner: false;
+        }, {
+            name: "systemProgram";
+            isMut: false;
+            isSigner: false;
+        }, {
+            name: "rent";
             isMut: false;
             isSigner: false;
         }];
         args: [{
-            name: "amount";
-            type: "u64";
+            name: "args";
+            type: {
+                defined: "AddMetadataToConditionalTokensArgs";
+            };
         }];
     } & {
-        name: "splitTokens";
+        name: "addMetadataToConditionalTokens";
     }>;
-    mergeTokensIx(question: PublicKey, vault: PublicKey, underlyingTokenMint: PublicKey, amount: BN, numOutcomes: number, user?: PublicKey): MethodsBuilder<ConditionalVault, {
-        name: "mergeTokens";
+    redeemConditionalTokensIx(vault: PublicKey, underlyingTokenMint: PublicKey): MethodsBuilder<ConditionalVault, {
+        name: "redeemConditionalTokensForUnderlyingTokens";
         accounts: [{
-            name: "question";
+            name: "vault";
             isMut: false;
             isSigner: false;
         }, {
-            name: "vault";
-            isMut: false;
+            name: "conditionalOnFinalizeTokenMint";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "conditionalOnRevertTokenMint";
+            isMut: true;
             isSigner: false;
         }, {
             name: "vaultUnderlyingTokenAccount";
@@ -148,6 +164,14 @@ export declare class ConditionalVaultClient {
             name: "authority";
             isMut: false;
             isSigner: true;
+        }, {
+            name: "userConditionalOnFinalizeTokenAccount";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "userConditionalOnRevertTokenAccount";
+            isMut: true;
+            isSigner: false;
         }, {
             name: "userUnderlyingTokenAccount";
             isMut: true;
@@ -157,22 +181,23 @@ export declare class ConditionalVaultClient {
             isMut: false;
             isSigner: false;
         }];
-        args: [{
-            name: "amount";
-            type: "u64";
-        }];
+        args: [];
     } & {
-        name: "mergeTokens";
+        name: "redeemConditionalTokensForUnderlyingTokens";
     }>;
-    redeemTokensIx(question: PublicKey, vault: PublicKey, underlyingTokenMint: PublicKey, numOutcomes: number, user?: PublicKey): MethodsBuilder<ConditionalVault, {
-        name: "redeemTokens";
+    mergeConditionalTokensIx(vault: PublicKey, underlyingTokenMint: PublicKey, amount: BN): MethodsBuilder<ConditionalVault, {
+        name: "mergeConditionalTokensForUnderlyingTokens";
         accounts: [{
-            name: "question";
+            name: "vault";
             isMut: false;
             isSigner: false;
         }, {
-            name: "vault";
-            isMut: false;
+            name: "conditionalOnFinalizeTokenMint";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "conditionalOnRevertTokenMint";
+            isMut: true;
             isSigner: false;
         }, {
             name: "vaultUnderlyingTokenAccount";
@@ -182,6 +207,14 @@ export declare class ConditionalVaultClient {
             name: "authority";
             isMut: false;
             isSigner: true;
+        }, {
+            name: "userConditionalOnFinalizeTokenAccount";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "userConditionalOnRevertTokenAccount";
+            isMut: true;
+            isSigner: false;
         }, {
             name: "userUnderlyingTokenAccount";
             isMut: true;
@@ -191,8 +224,12 @@ export declare class ConditionalVaultClient {
             isMut: false;
             isSigner: false;
         }];
-        args: [];
+        args: [{
+            name: "amount";
+            type: "u64";
+        }];
     } & {
-        name: "redeemTokens";
+        name: "mergeConditionalTokensForUnderlyingTokens";
     }>;
+    initializeVault(settlementAuthority: PublicKey, underlyingTokenMint: PublicKey): Promise<PublicKey>;
 }

package/dist/ConditionalVaultClient.js

@@ -1,191 +1,158 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConditionalVaultClient = void 0;
 const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
 const conditional_vault_1 = require("./types/conditional_vault");
+const bn_js_1 = __importDefault(require("bn.js"));
 const constants_1 = require("./constants");
 const utils_1 = require("./utils");
 const spl_token_1 = require("@solana/spl-token");
 class ConditionalVaultClient {
     provider;
     vaultProgram;
-    constructor(provider, conditionalVaultProgramId) {
+    luts;
+    constructor(provider, conditionalVaultProgramId, luts) {
         this.provider = provider;
         this.vaultProgram = new anchor_1.Program(conditional_vault_1.IDL, conditionalVaultProgramId, provider);
+        this.luts = luts;
     }
     static createClient(createVaultClientParams) {
         let { provider, conditionalVaultProgramId } = createVaultClientParams;
-        return new ConditionalVaultClient(provider, conditionalVaultProgramId || constants_1.CONDITIONAL_VAULT_PROGRAM_ID);
-    }
-    async fetchQuestion(question) {
-        return this.vaultProgram.account.question.fetch(question);
-    }
-    async fetchVault(vault) {
-        return this.vaultProgram.account.conditionalVault.fetch(vault);
+        const luts = [];
+        return new ConditionalVaultClient(provider, conditionalVaultProgramId || constants_1.CONDITIONAL_VAULT_PROGRAM_ID, luts);
     }
     async getVault(vault) {
         return this.vaultProgram.account.conditionalVault.fetch(vault);
     }
-    initializeQuestionIx(questionId, oracle, numConditions) {
-        const [question] = (0, utils_1.getQuestionAddr)(this.vaultProgram.programId, questionId, oracle, numConditions);
-        return this.vaultProgram.methods
-            .initializeQuestion({
-            questionId: Array.from(questionId),
-            oracle,
-            numConditions,
-        })
-            .accounts({
-            question,
-        });
-    }
-    async initializeQuestion(questionId, oracle, numConditions) {
-        const [question] = (0, utils_1.getQuestionAddr)(this.vaultProgram.programId, questionId, oracle, numConditions);
-        await this.initializeQuestionIx(questionId, oracle, numConditions).rpc();
-        return question;
+    async mintConditionalTokens(vault, uiAmount, user) {
+        const storedVault = await this.getVault(vault);
+        try {
+            const scaledAmount = uiAmount * Math.pow(10, storedVault.decimals);
+            const bnAmount = new bn_js_1.default(scaledAmount.toFixed(0));
+            return this.mintConditionalTokensIx(vault, storedVault.underlyingTokenMint, bnAmount, user).rpc();
+        }
+        catch (e) {
+            throw new Error(`Error minting conditional tokens for ${storedVault.underlyingTokenMint} with error ${e}`);
+        }
     }
-    initializeVaultIx(question, underlyingTokenMint, numOutcomes) {
-        const [vault] = (0, utils_1.getVaultAddr)(this.vaultProgram.programId, question, underlyingTokenMint);
-        let conditionalTokenMintAddrs = [];
-        for (let i = 0; i < numOutcomes; i++) {
-            const [conditionalTokenMint] = (0, utils_1.getConditionalTokenMintAddr)(this.vaultProgram.programId, vault, i);
-            conditionalTokenMintAddrs.push(conditionalTokenMint);
+    mintConditionalTokensIx(vault, underlyingTokenMint, amount, user) {
+        let userPubkey;
+        if (!user) {
+            userPubkey = this.provider.publicKey;
         }
+        else if (user instanceof web3_js_1.Keypair) {
+            userPubkey = user.publicKey;
+        }
+        else {
+            userPubkey = user;
+        }
+        const [conditionalOnFinalizeTokenMint] = (0, utils_1.getVaultFinalizeMintAddr)(this.vaultProgram.programId, vault);
+        const [conditionalOnRevertTokenMint] = (0, utils_1.getVaultRevertMintAddr)(this.vaultProgram.programId, vault);
+        let userConditionalOnFinalizeTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(conditionalOnFinalizeTokenMint, userPubkey);
+        let userConditionalOnRevertTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(conditionalOnRevertTokenMint, userPubkey);
+        let ix = this.vaultProgram.methods
+            .mintConditionalTokens(amount)
+            .accounts({
+            authority: userPubkey,
+            vault,
+            vaultUnderlyingTokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(underlyingTokenMint, vault, true),
+            userUnderlyingTokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(underlyingTokenMint, userPubkey, true),
+            conditionalOnFinalizeTokenMint,
+            userConditionalOnFinalizeTokenAccount,
+            conditionalOnRevertTokenMint,
+            userConditionalOnRevertTokenAccount,
+        })
+            .preInstructions([
+            (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(userPubkey, userConditionalOnFinalizeTokenAccount, userPubkey, conditionalOnFinalizeTokenMint),
+            (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(userPubkey, userConditionalOnRevertTokenAccount, userPubkey, conditionalOnRevertTokenMint),
+        ]);
+        if (user instanceof web3_js_1.Keypair) {
+            ix = ix.signers([user]);
+        }
+        return ix;
+    }
+    initializeVaultIx(settlementAuthority, underlyingTokenMint) {
+        const [vault] = (0, utils_1.getVaultAddr)(this.vaultProgram.programId, settlementAuthority, underlyingTokenMint);
+        const [conditionalOnFinalizeTokenMint] = (0, utils_1.getVaultFinalizeMintAddr)(this.vaultProgram.programId, vault);
+        const [conditionalOnRevertTokenMint] = (0, utils_1.getVaultRevertMintAddr)(this.vaultProgram.programId, vault);
         const vaultUnderlyingTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(underlyingTokenMint, vault, true);
         return this.vaultProgram.methods
-            .initializeConditionalVault()
+            .initializeConditionalVault({ settlementAuthority })
             .accounts({
             vault,
-            question,
             underlyingTokenMint,
             vaultUnderlyingTokenAccount,
+            conditionalOnFinalizeTokenMint,
+            conditionalOnRevertTokenMint,
         })
             .preInstructions([
             (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(this.provider.publicKey, vaultUnderlyingTokenAccount, vault, underlyingTokenMint),
-        ])
-            .remainingAccounts(conditionalTokenMintAddrs.map((conditionalTokenMint) => {
-            return {
-                pubkey: conditionalTokenMint,
-                isWritable: true,
-                isSigner: false,
-            };
-        }));
-    }
-    async initializeVault(question, underlyingTokenMint, numOutcomes) {
-        const [vault] = (0, utils_1.getVaultAddr)(this.vaultProgram.programId, question, underlyingTokenMint);
-        await this.initializeVaultIx(question, underlyingTokenMint, numOutcomes).rpc();
-        return vault;
-    }
-    resolveQuestionIx(question, oracle, payoutNumerators) {
+        ]);
+    }
+    addMetadataToConditionalTokensIx(vault, underlyingTokenMint, proposalNumber, onFinalizeUri, onRevertUri) {
+        const [underlyingTokenMetadata] = (0, utils_1.getMetadataAddr)(underlyingTokenMint);
+        const [conditionalOnFinalizeTokenMint] = (0, utils_1.getVaultFinalizeMintAddr)(this.vaultProgram.programId, vault);
+        const [conditionalOnRevertTokenMint] = (0, utils_1.getVaultRevertMintAddr)(this.vaultProgram.programId, vault);
+        const [conditionalOnFinalizeTokenMetadata] = (0, utils_1.getMetadataAddr)(conditionalOnFinalizeTokenMint);
+        const [conditionalOnRevertTokenMetadata] = (0, utils_1.getMetadataAddr)(conditionalOnRevertTokenMint);
         return this.vaultProgram.methods
-            .resolveQuestion({
-            payoutNumerators,
+            .addMetadataToConditionalTokens({
+            proposalNumber: new bn_js_1.default(proposalNumber),
+            onFinalizeUri,
+            onRevertUri,
         })
             .accounts({
-            question,
-            oracle: oracle.publicKey,
-        })
-            .signers([oracle]);
-    }
-    getConditionalTokenMints(vault, numOutcomes) {
-        let conditionalTokenMintAddrs = [];
-        for (let i = 0; i < numOutcomes; i++) {
-            const [conditionalTokenMint] = (0, utils_1.getConditionalTokenMintAddr)(this.vaultProgram.programId, vault, i);
-            conditionalTokenMintAddrs.push(conditionalTokenMint);
-        }
-        return conditionalTokenMintAddrs;
-    }
-    getRemainingAccounts(conditionalTokenMints, userConditionalAccounts) {
-        return conditionalTokenMints
-            .concat(userConditionalAccounts)
-            .map((account) => ({
-            pubkey: account,
-            isWritable: true,
-            isSigner: false,
-        }));
-    }
-    // Helper method to get conditional token accounts and instructions
-    getConditionalTokenAccountsAndInstructions(vault, numOutcomes, user) {
-        const conditionalTokenMintAddrs = this.getConditionalTokenMints(vault, numOutcomes);
-        const userConditionalAccounts = conditionalTokenMintAddrs.map((mint) => (0, spl_token_1.getAssociatedTokenAddressSync)(mint, user, true));
-        const preInstructions = conditionalTokenMintAddrs.map((mint) => (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(this.provider.publicKey, (0, spl_token_1.getAssociatedTokenAddressSync)(mint, user), user, mint));
-        const remainingAccounts = this.getRemainingAccounts(conditionalTokenMintAddrs, userConditionalAccounts);
-        return { userConditionalAccounts, preInstructions, remainingAccounts };
+            payer: this.provider.publicKey,
+            vault,
+            underlyingTokenMint,
+            underlyingTokenMetadata,
+            conditionalOnFinalizeTokenMint,
+            conditionalOnRevertTokenMint,
+            conditionalOnFinalizeTokenMetadata,
+            conditionalOnRevertTokenMetadata,
+            tokenMetadataProgram: constants_1.MPL_TOKEN_METADATA_PROGRAM_ID,
+        });
     }
-    splitTokensIx(question, vault, underlyingTokenMint, amount, numOutcomes, user = this.provider.publicKey) {
-        const { preInstructions, remainingAccounts } = this.getConditionalTokenAccountsAndInstructions(vault, numOutcomes, user);
+    redeemConditionalTokensIx(vault, underlyingTokenMint) {
+        const [conditionalOnFinalizeTokenMint] = (0, utils_1.getVaultFinalizeMintAddr)(this.vaultProgram.programId, vault);
+        const [conditionalOnRevertTokenMint] = (0, utils_1.getVaultRevertMintAddr)(this.vaultProgram.programId, vault);
         return this.vaultProgram.methods
-            .splitTokens(amount)
+            .redeemConditionalTokensForUnderlyingTokens()
             .accounts({
-            question,
-            authority: user,
+            authority: this.provider.publicKey,
             vault,
             vaultUnderlyingTokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(underlyingTokenMint, vault, true),
-            userUnderlyingTokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(underlyingTokenMint, user, true),
-        })
-            .preInstructions(preInstructions)
-            .remainingAccounts(remainingAccounts);
+            userUnderlyingTokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(underlyingTokenMint, this.provider.publicKey, true),
+            conditionalOnFinalizeTokenMint,
+            userConditionalOnFinalizeTokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(conditionalOnFinalizeTokenMint, this.provider.publicKey),
+            conditionalOnRevertTokenMint,
+            userConditionalOnRevertTokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(conditionalOnRevertTokenMint, this.provider.publicKey),
+        });
     }
-    mergeTokensIx(question, vault, underlyingTokenMint, amount, numOutcomes, user = this.provider.publicKey) {
-        let conditionalTokenMintAddrs = this.getConditionalTokenMints(vault, numOutcomes);
-        let userConditionalAccounts = [];
-        for (let conditionalTokenMint of conditionalTokenMintAddrs) {
-            userConditionalAccounts.push((0, spl_token_1.getAssociatedTokenAddressSync)(conditionalTokenMint, user, true));
-        }
-        let ix = this.vaultProgram.methods
-            .mergeTokens(amount)
+    mergeConditionalTokensIx(vault, underlyingTokenMint, amount) {
+        const [conditionalOnFinalizeTokenMint] = (0, utils_1.getVaultFinalizeMintAddr)(this.vaultProgram.programId, vault);
+        const [conditionalOnRevertTokenMint] = (0, utils_1.getVaultRevertMintAddr)(this.vaultProgram.programId, vault);
+        return this.vaultProgram.methods
+            .mergeConditionalTokensForUnderlyingTokens(amount)
             .accounts({
-            question,
-            authority: user,
+            authority: this.provider.publicKey,
             vault,
             vaultUnderlyingTokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(underlyingTokenMint, vault, true),
-            userUnderlyingTokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(underlyingTokenMint, user, true),
-        })
-            .preInstructions(conditionalTokenMintAddrs.map((conditionalTokenMint) => {
-            return (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(this.provider.publicKey, (0, spl_token_1.getAssociatedTokenAddressSync)(conditionalTokenMint, user), user, conditionalTokenMint);
-        }))
-            .remainingAccounts(conditionalTokenMintAddrs
-            .concat(userConditionalAccounts)
-            .map((conditionalTokenMint) => {
-            return {
-                pubkey: conditionalTokenMint,
-                isWritable: true,
-                isSigner: false,
-            };
-        }));
-        return ix;
+            userUnderlyingTokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(underlyingTokenMint, this.provider.publicKey, true),
+            conditionalOnFinalizeTokenMint,
+            userConditionalOnFinalizeTokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(conditionalOnFinalizeTokenMint, this.provider.publicKey),
+            conditionalOnRevertTokenMint,
+            userConditionalOnRevertTokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(conditionalOnRevertTokenMint, this.provider.publicKey),
+        });
     }
-    redeemTokensIx(question, vault, underlyingTokenMint, numOutcomes, user = this.provider.publicKey) {
-        let conditionalTokenMintAddrs = [];
-        for (let i = 0; i < numOutcomes; i++) {
-            const [conditionalTokenMint] = (0, utils_1.getConditionalTokenMintAddr)(this.vaultProgram.programId, vault, i);
-            conditionalTokenMintAddrs.push(conditionalTokenMint);
-        }
-        let userConditionalAccounts = [];
-        for (let conditionalTokenMint of conditionalTokenMintAddrs) {
-            userConditionalAccounts.push((0, spl_token_1.getAssociatedTokenAddressSync)(conditionalTokenMint, user, true));
-        }
-        let ix = this.vaultProgram.methods
-            .redeemTokens()
-            .accounts({
-            question,
-            authority: user,
-            vault,
-            vaultUnderlyingTokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(underlyingTokenMint, vault, true),
-            userUnderlyingTokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(underlyingTokenMint, user, true),
-        })
-            .preInstructions(conditionalTokenMintAddrs.map((conditionalTokenMint) => {
-            return (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(this.provider.publicKey, (0, spl_token_1.getAssociatedTokenAddressSync)(conditionalTokenMint, user), user, conditionalTokenMint);
-        }))
-            .remainingAccounts(conditionalTokenMintAddrs
-            .concat(userConditionalAccounts)
-            .map((conditionalTokenMint) => {
-            return {
-                pubkey: conditionalTokenMint,
-                isWritable: true,
-                isSigner: false,
-            };
-        }));
-        return ix;
+    async initializeVault(settlementAuthority, underlyingTokenMint) {
+        const [vault] = (0, utils_1.getVaultAddr)(this.vaultProgram.programId, settlementAuthority, underlyingTokenMint);
+        await this.initializeVaultIx(settlementAuthority, underlyingTokenMint).rpc();
+        return vault;
     }
 }
 exports.ConditionalVaultClient = ConditionalVaultClient;