Test complete_launch

Author: metaproph3t

programs/launchpad/src/instructions/complete_launch.rs

@@ -9,14 +9,12 @@ pub struct CompleteLaunch<'info> {
     #[account(
         mut,
         constraint = launch.state == LaunchState::Live @ LaunchpadError::InvalidLaunchState,
-        has_one = treasury_usdc_account
+        has_one = treasury_usdc_account,
+        has_one = usdc_vault
     )]
     pub launch: Account<'info, Launch>,
 
-    #[account(
-        mut,
-        constraint = usdc_vault.key() == launch.usdc_vault
-    )]
+    #[account(mut)]
     pub usdc_vault: Account<'info, TokenAccount>,
 
     #[account(mut)]

sdk/src/v0.4/LaunchpadClient.ts

@@ -137,4 +137,23 @@ export class LaunchpadClient {
       funderTokenAccount,
     });
   }
+
+  completeLaunchIx(
+    launch: PublicKey,
+    usdcMint: PublicKey,
+    daoTreasury: PublicKey
+  ) {
+    const usdcVault = getAssociatedTokenAddressSync(usdcMint, launch, true);
+    const treasuryUsdcAccount = getAssociatedTokenAddressSync(
+      usdcMint,
+      daoTreasury,
+      true
+    );
+
+    return this.launchpad.methods.completeLaunch().accounts({
+      launch,
+      usdcVault,
+      treasuryUsdcAccount,
+    });
+  }
 }

tests/launchpad/main.test.ts

@@ -1,8 +1,9 @@
 import initializeLaunch from "./unit/initializeLaunch.test.js";
 import fund from "./unit/fund.test.js";
-
+import completeLaunch from "./unit/completeLaunch.test.js";
 // TODO add a many-outcome integration test
 export default function suite() {
   describe("#initialize_launch", initializeLaunch);
   describe("#fund", fund);
+  describe("#complete_launch", completeLaunch);
 }

tests/launchpad/unit/completeLaunch.test.ts

@@ -0,0 +1,124 @@
+import { PublicKey } from "@solana/web3.js";
+import { assert } from "chai";
+import {
+  AutocratClient,
+  getLaunchAddr,
+  LaunchpadClient,
+} from "@metadaoproject/futarchy/v0.4";
+import { createMint } from "spl-token-bankrun";
+import { BN } from "bn.js";
+import { createSetAuthorityInstruction, AuthorityType, getAssociatedTokenAddressSync } from "@solana/spl-token";
+
+export default function suite() {
+  let autocratClient: AutocratClient;
+  let launchpadClient: LaunchpadClient;
+  let dao: PublicKey;
+  let daoTreasury: PublicKey;
+  let META: PublicKey;
+  let USDC: PublicKey;
+  let launch: PublicKey;
+  let usdcVault: PublicKey;
+  let treasuryUsdcAccount: PublicKey;
+
+  const minRaise = new BN(1000_000000); // 1000 USDC
+
+  before(async function () {
+    autocratClient = this.autocratClient;
+    launchpadClient = this.launchpadClient;
+  });
+
+  beforeEach(async function () {
+    // Create test tokens
+    META = await createMint(this.banksClient, this.payer, this.payer.publicKey, null, 6);
+    USDC = await createMint(this.banksClient, this.payer, this.payer.publicKey, null, 6);
+
+    // Initialize DAO
+    dao = await autocratClient.initializeDao(META, 400, 5, 5000, USDC);
+    [daoTreasury] = PublicKey.findProgramAddressSync(
+      [dao.toBuffer()],
+      autocratClient.autocrat.programId
+    );
+
+    // Get accounts
+    [launch] = getLaunchAddr(launchpadClient.getProgramId(), dao);
+    usdcVault = getAssociatedTokenAddressSync(USDC, launch, true);
+    treasuryUsdcAccount = getAssociatedTokenAddressSync(USDC, daoTreasury, true);
+
+    // Initialize launch
+    await launchpadClient.initializeLaunchIx(
+      dao,
+      minRaise,
+      new BN(5000_000000),
+      USDC,
+      META
+    ).preInstructions([
+      createSetAuthorityInstruction(
+        META,
+        this.payer.publicKey,
+        AuthorityType.MintTokens,
+        launch
+      )
+    ]).rpc();
+  });
+
+  it("completes launch successfully when minimum raise is met", async function () {
+    // Fund the launch with exactly minimum raise
+    const userUsdcAccount = await this.createTokenAccount(USDC, this.payer.publicKey);
+    const userTokenAccount = await this.createTokenAccount(META, this.payer.publicKey);
+    // await this.mintTo(USDC, userUsdcAccount, this.payer, minRaise.toNumber());
+    await this.mintTo(USDC, this.payer.publicKey, this.payer, minRaise.toNumber());
+
+    await launchpadClient.fundIx(
+      launch,
+      minRaise,
+      USDC,
+      META
+    ).rpc();
+
+    // Complete the launch
+    await launchpadClient.completeLaunchIx(launch, USDC, daoTreasury).rpc();
+
+    const launchAccount = await launchpadClient.fetchLaunch(launch);
+    const treasuryBalance = await this.getTokenBalance(USDC, daoTreasury);
+
+    assert.exists(launchAccount.state.complete);
+    assert.equal(treasuryBalance.toString(), minRaise.toString());
+  });
+
+  it("moves to refunding state when minimum raise is not met", async function () {
+    // Fund the launch with less than minimum raise
+    const userUsdcAccount = await this.createTokenAccount(USDC, this.payer.publicKey);
+    const userTokenAccount = await this.createTokenAccount(META, this.payer.publicKey);
+    const partialAmount = minRaise.divn(2);
+    await this.mintTo(USDC, this.payer.publicKey, this.payer, partialAmount.toNumber());
+
+    await launchpadClient.fundIx(
+      launch,
+      partialAmount,
+      USDC,
+      META
+    ).rpc();
+
+    // Complete the launch
+    await launchpadClient.completeLaunchIx(launch, USDC, daoTreasury).rpc();
+
+    const launchAccount = await launchpadClient.fetchLaunch(launch);
+    const treasuryBalance = await this.getTokenBalance(USDC, daoTreasury);
+
+    assert.exists(launchAccount.state.refunding);
+    assert.equal(treasuryBalance.toString(), "0");
+  });
+
+  it("fails when launch is not in live state", async function () {
+    // Complete launch first time
+    await launchpadClient.completeLaunchIx(launch, USDC, daoTreasury).rpc();
+
+    // Try to complete again
+    try {
+      await launchpadClient.completeLaunchIx(launch, USDC, daoTreasury).rpc();
+      assert.fail("Should have thrown error");
+    } catch (e) {
+      assert.include(e.message, "InvalidLaunchState");
+    }
+  });
+}