duelfi_bets_anchor/tests/bets-comprehensive.ts

import * as anchor from "@coral-xyz/anchor";
import { Program } from "@coral-xyz/anchor";
import { Bets } from "../target/types/bets";
import { PublicKey, Keypair, LAMPORTS_PER_SOL, SystemProgram } from "@solana/web3.js";
import { expect } from "chai";
import { BN } from "bn.js";

describe("bets", () => {
  // Configure the client to use the local cluster
  const provider = anchor.AnchorProvider.env();
  anchor.setProvider(provider);

  const program = anchor.workspace.Bets as Program<Bets>;
  const payer = Keypair.generate();
  const joiner = Keypair.generate();
  let betsListPda: PublicKey;
  let betVaultPda: PublicKey;
  const gameId = "GAME123";
  const userId = "USER123";
  const joinerId = "JOINER123";
  const wager = new BN(1 * LAMPORTS_PER_SOL);
  const nonce = new BN(1);
  const FEE_COLLECTOR = new PublicKey("cocD4r4yNpHxPq7CzUebxEMyLki3X4d2Y3HcTX5ptUc");

  before(async () => {
    // Airdrop SOL to payer and joiner for testing
    const signature1 = await provider.connection.requestAirdrop(
      payer.publicKey,
      2 * LAMPORTS_PER_SOL
    );
    await provider.connection.confirmTransaction(signature1);

    const signature2 = await provider.connection.requestAirdrop(
      joiner.publicKey,
      2 * LAMPORTS_PER_SOL
    );
    await provider.connection.confirmTransaction(signature2);

    // Find PDA for bets list
    [betsListPda] = PublicKey.findProgramAddressSync(
      [Buffer.from("bets_list")],
      program.programId
    );

    // Find PDA for bet vault
    [betVaultPda] = PublicKey.findProgramAddressSync(
      [
        Buffer.from("bet_vault"),
        payer.publicKey.toBuffer(),
        Buffer.from(gameId),
        nonce.toArrayLike(Buffer, "le", 8)
      ],
      program.programId
    );
  });

  it("Can initialize bets list", async () => {
    try {
      await program.methods
        .initialize()
        .accounts({
          payer: provider.wallet.publicKey
        })
        .rpc();
    } catch (error) {
      // Ignore the error if account already exists
      if (!error.toString().includes("already in use")) {
        throw error;
      }
    }

    // Verify the bets list exists
    const betsListAccount = await program.account.betsList.fetch(betsListPda);
    expect(betsListAccount.bets).to.be.an('array');
  });

  it("Can create a new bet", async () => {
    await program.methods
      .createBet(wager, userId, gameId, nonce)
      .accounts({
        betsList: betsListPda,
        payer: payer.publicKey
      })
      .signers([payer])
      .rpc();

    // Verify the bet was created correctly
    const betVaultAccount = await program.account.betVault.fetch(betVaultPda);
    expect(betVaultAccount.gameId).to.equal(gameId);
    expect(betVaultAccount.owner.toString()).to.equal(payer.publicKey.toString());
    expect(betVaultAccount.wager.toString()).to.equal(wager.toString());
  });

  it("Can join a bet", async () => {
    await program.methods
      .joinBet(joinerId, gameId)
      .accounts({
        betVault: betVaultPda,
        payer: joiner.publicKey
      })
      .signers([joiner])
      .rpc();

    // Verify the joiner was added to the bet
    const betVaultAccount = await program.account.betVault.fetch(betVaultPda);
    expect(betVaultAccount.joiner.toString()).to.equal(joiner.publicKey.toString());
  });

  it("Can close a bet", async () => {
    await program.methods
      .closeBet(payer.publicKey)
      .accounts({
        betsList: betsListPda,
        betVault: betVaultPda,
        winner: payer.publicKey,
        feeWallet: FEE_COLLECTOR,
        payer: payer.publicKey
      })
      .signers([payer])
      .rpc();

    // Verify the bet was closed by checking if it still exists
    try {
      await program.account.betVault.fetch(betVaultPda);
      expect.fail("Bet should have been closed");
    } catch (error) {
      expect(error).to.be.an('Error');
    }
  });

//   it("Can refund a bet", async () => {
//     // First create a new bet for testing refund
//     const newNonce = new BN(2);
//     const [newBetVaultPda] = PublicKey.findProgramAddressSync(
//       [
//         Buffer.from("bet_vault"),
//         payer.publicKey.toBuffer(),
//         Buffer.from(gameId),
//         newNonce.toArrayLike(Buffer, "le", 8)
//       ],
//       program.programId
//     );

//     await program.methods
//       .createBet(wager, userId, gameId, newNonce)
//       .accounts({
//         payer: payer.publicKey,
//         betsList: betsListPda
//       })
//       .signers([payer])
//       .rpc();

//     // Now refund the bet
//     const tx = await program.methods
//       .refundBet(payer.publicKey)
//       .accounts({
//         betVault: newBetVaultPda,
//         betsList: betsListPda,
//         payer: payer.publicKey
//       })
//       .signers([payer])
//       .rpc();

//     // Verify the bet was refunded by checking if it still exists
//     try {
//       await program.account.betVault.fetch(newBetVaultPda);
//       expect.fail("Bet should have been refunded and closed");
//     } catch (error) {
//       expect(error).to.be.an('Error');
//     }
//   });
});