fix: added question resolution validation to three instructions

programs/conditional_vault/src/instructions/initialize_conditional_vault.rs

@@ -34,6 +34,11 @@ pub struct InitializeConditionalVault<'info> {
 
 impl<'info, 'c: 'info> InitializeConditionalVault<'info> {
     pub fn handle(ctx: Context<'_, '_, 'c, 'info, Self>) -> Result<()> {
+        require!(
+            !ctx.accounts.question.is_resolved(),
+            VaultError::QuestionAlreadyResolved
+        );
+
         let vault = &mut ctx.accounts.vault;
 
         let decimals = ctx.accounts.underlying_token_mint.decimals;

tests/conditionalVault/unit/initializeConditionalVault.test.ts

@@ -9,6 +9,7 @@ import { assert } from "chai";
 import { createMint, getMint } from "spl-token-bankrun";
 import * as anchor from "@coral-xyz/anchor";
 import * as token from "@solana/spl-token";
+import { expectError } from "../../utils.js";
 
 export default function suite() {
   let vaultClient: ConditionalVaultClient;
@@ -33,19 +34,15 @@ export default function suite() {
 
   testCases.forEach(({ name, idArray, outcomes }) => {
     describe(name, function () {
-      let question: PublicKey;
-      let oracle: Keypair = Keypair.generate();
-
-      beforeEach(async function () {
+      it("initializes vaults correctly", async function () {
+        let oracle = Keypair.generate();
         let questionId = sha256(new Uint8Array(idArray));
-        question = await vaultClient.initializeQuestion(
+        let question = await vaultClient.initializeQuestion(
           questionId,
           oracle.publicKey,
           outcomes
         );
-      });
 
-      it("initializes vaults correctly", async function () {
         await vaultClient
           .initializeVaultIx(question, underlyingTokenMint, outcomes)
           .rpc();
@@ -89,6 +86,38 @@ export default function suite() {
           assert.isNull(storedMint.freezeAuthority);
         }
       });
+
+      it("doesn't allow initializing vault for resolved question", async function () {
+        let oracle = Keypair.generate();
+        let questionId = sha256(new Uint8Array(idArray));
+        let question = await vaultClient.initializeQuestion(
+          questionId,
+          oracle.publicKey,
+          outcomes
+        );
+
+        await vaultClient
+          .resolveQuestionIx(question, oracle, Array(outcomes).fill(1))
+          .signers([oracle])
+          .rpc();
+
+        const resolvedQuestion = await vaultClient.fetchQuestion(question);
+        assert.notEqual(
+          resolvedQuestion.payoutDenominator.toString(), 
+          "0", 
+          "Question should be resolved"
+        );
+
+        const callbacks = expectError(
+          "QuestionAlreadyResolved",
+          "Vault initialized despite question being resolved"
+        );
+
+        await vaultClient
+          .initializeVaultIx(question, underlyingTokenMint, outcomes)
+          .rpc()
+          .then(callbacks[0], callbacks[1]);
+      });
     });
   });
-}
+}