@zcomb/programs-sdk 1.7.0 → 1.8.0

package/src/vault/client.ts

@@ -1,333 +0,0 @@
-/*
- * High-level client for the Vault program.
- * Provides ergonomic methods for vault operations with automatic PDA derivation,
- * native SOL wrapping/unwrapping, and compute budget management.
- */
-
-import { Program, AnchorProvider, BN } from "@coral-xyz/anchor";
-import { PublicKey, ComputeBudgetProgram, SystemProgram } from "@solana/web3.js";
-import {
-  getAccount,
-  getAssociatedTokenAddressSync,
-  TokenAccountNotFoundError,
-  NATIVE_MINT,
-  createSyncNativeInstruction,
-  createCloseAccountInstruction,
-  createAssociatedTokenAccountIdempotentInstruction,
-} from "@solana/spl-token";
-import { PROGRAM_ID } from "./constants";
-import { Vault, VaultType, VaultAccount, VaultActionOptions } from "./types";
-import {
-  deriveVaultPDA,
-  deriveConditionalMint,
-  fetchVaultAccount,
-} from "./utils";
-import {
-  initialize,
-  addOption,
-  activate,
-  deposit,
-  withdraw,
-  finalize,
-  redeemWinnings,
-} from "./instructions";
-
-import { VaultIDL } from "../generated/idls";
-
-const DEFAULT_COMPUTE_UNITS = 450_000;
-
-export class VaultClient {
-  public program: Program<Vault>;
-  public programId: PublicKey;
-  public computeUnits: number;
-
-  constructor(
-    provider: AnchorProvider,
-    programId?: PublicKey,
-    computeUnits?: number
-  ) {
-    this.programId = programId ?? PROGRAM_ID;
-    this.computeUnits = computeUnits ?? DEFAULT_COMPUTE_UNITS;
-    this.program = new Program(VaultIDL as Vault, provider);
-  }
-
-  /* PDA Helpers */
-
-  deriveVaultPDA(
-    owner: PublicKey,
-    nonce: number
-  ): [PublicKey, number] {
-    return deriveVaultPDA(owner, nonce, this.programId);
-  }
-
-  deriveConditionalMint(
-    vaultPda: PublicKey,
-    vaultType: VaultType,
-    index: number
-  ): [PublicKey, number] {
-    return deriveConditionalMint(vaultPda, vaultType, index, this.programId);
-  }
-
-  /* State Fetching */
-
-  async fetchVault(vaultPda: PublicKey): Promise<VaultAccount> {
-    return fetchVaultAccount(this.program, vaultPda);
-  }
-
-  async fetchUserATAs(vaultPda: PublicKey, user: PublicKey, vaultType: VaultType) {
-    const vault = await this.fetchVault(vaultPda);
-    const mint = vaultType === VaultType.Base ? vault.baseMint.address : vault.quoteMint.address;
-    const condMints = (vaultType === VaultType.Base ? vault.condBaseMints : vault.condQuoteMints)
-      .slice(0, vault.numOptions);
-    return {
-      userAta: getAssociatedTokenAddressSync(mint, user),
-      userCondATAs: condMints.map((m) => getAssociatedTokenAddressSync(m, user)),
-    };
-  }
-
-  async fetchVaultATA(vaultPda: PublicKey, vaultType: VaultType) {
-    const vault = await this.fetchVault(vaultPda);
-    const mint = vaultType === VaultType.Base ? vault.baseMint.address : vault.quoteMint.address;
-    return getAssociatedTokenAddressSync(mint, vaultPda, true);
-  }
-
-  async fetchUserBalances(vaultPda: PublicKey, user: PublicKey, vaultType: VaultType) {
-    const { userAta, userCondATAs } = await this.fetchUserATAs(vaultPda, user, vaultType);
-    const connection = this.program.provider.connection;
-
-    const getBalanceSafe = async (ata: PublicKey) => {
-      try {
-        const acc = await getAccount(connection, ata);
-        return new BN(acc.amount.toString());
-      } catch (e) {
-        if (e instanceof TokenAccountNotFoundError) {
-          return new BN(0);
-        }
-        throw e;
-      }
-    };
-
-    const [userBalance, ...condBalances] = await Promise.all([
-      getBalanceSafe(userAta),
-      ...userCondATAs.map(getBalanceSafe),
-    ]);
-
-    return { userBalance, condBalances };
-  }
-
-  async fetchVaultBalance(vaultPda: PublicKey, vaultType: VaultType): Promise<BN> {
-    const vaultAta = await this.fetchVaultATA(vaultPda, vaultType);
-    try {
-      const acc = await getAccount(this.program.provider.connection, vaultAta);
-      return new BN(acc.amount.toString());
-    } catch (e) {
-      if (e instanceof TokenAccountNotFoundError) {
-        return new BN(0);
-      }
-      throw e;
-    }
-  }
-
-  /* Instruction Builders */
-
-  initialize(
-    payer: PublicKey,
-    baseMint: PublicKey,
-    quoteMint: PublicKey,
-    nonce: number,
-    owner?: PublicKey
-  ) {
-    const vaultOwner = owner ?? payer;
-    const [vaultPda] = this.deriveVaultPDA(vaultOwner, nonce);
-    const [condBaseMint0] = this.deriveConditionalMint(vaultPda, VaultType.Base, 0);
-    const [condBaseMint1] = this.deriveConditionalMint(vaultPda, VaultType.Base, 1);
-    const [condQuoteMint0] = this.deriveConditionalMint(vaultPda, VaultType.Quote, 0);
-    const [condQuoteMint1] = this.deriveConditionalMint(vaultPda, VaultType.Quote, 1);
-
-    const builder = initialize(
-      this.program,
-      payer,
-      vaultOwner,
-      vaultPda,
-      baseMint,
-      quoteMint,
-      condBaseMint0,
-      condBaseMint1,
-      condQuoteMint0,
-      condQuoteMint1,
-      nonce
-    );
-
-    return {
-      builder,
-      vaultPda,
-      condBaseMint0,
-      condBaseMint1,
-      condQuoteMint0,
-      condQuoteMint1,
-    };
-  }
-
-  async addOption(payer: PublicKey, owner: PublicKey, vaultPda: PublicKey) {
-    const vault = await this.fetchVault(vaultPda);
-    const [condBaseMint] = this.deriveConditionalMint(vaultPda, VaultType.Base, vault.numOptions);
-    const [condQuoteMint] = this.deriveConditionalMint(vaultPda, VaultType.Quote, vault.numOptions);
-
-    const builder = addOption(
-      this.program,
-      payer,
-      owner,
-      vaultPda,
-      condBaseMint,
-      condQuoteMint
-    );
-
-    return { builder, condBaseMint, condQuoteMint };
-  }
-
-  activate(payer: PublicKey, owner: PublicKey, vaultPda: PublicKey) {
-    return activate(this.program, payer, owner, vaultPda);
-  }
-
-  async deposit(
-    signer: PublicKey,
-    vaultPda: PublicKey,
-    vaultType: VaultType,
-    amount: BN | number,
-    options?: VaultActionOptions
-  ) {
-    const { autoWrapUnwrap = true, includeCuBudget = true, computeUnits } = options ?? {};
-
-    const vault = await this.fetchVault(vaultPda);
-    const mint = vaultType === VaultType.Base ? vault.baseMint.address : vault.quoteMint.address;
-    const condMints = (vaultType === VaultType.Base ? vault.condBaseMints : vault.condQuoteMints)
-      .slice(0, vault.numOptions);
-
-    const builder = deposit(
-      this.program,
-      signer,
-      vaultPda,
-      mint,
-      condMints,
-      vaultType,
-      amount
-    );
-
-    const preIxs: ReturnType<typeof ComputeBudgetProgram.setComputeUnitLimit>[] = [];
-
-    if (includeCuBudget) {
-      preIxs.push(
-        ComputeBudgetProgram.setComputeUnitLimit({
-          units: computeUnits ?? this.computeUnits,
-        })
-      );
-    }
-
-    if (autoWrapUnwrap && mint.equals(NATIVE_MINT)) {
-      const amountBN = typeof amount === "number" ? new BN(amount) : amount;
-      const wsolAta = getAssociatedTokenAddressSync(NATIVE_MINT, signer);
-      preIxs.push(
-        createAssociatedTokenAccountIdempotentInstruction(
-          signer,
-          wsolAta,
-          signer,
-          NATIVE_MINT
-        ),
-        SystemProgram.transfer({
-          fromPubkey: signer,
-          toPubkey: wsolAta,
-          lamports: BigInt(amountBN.toString()),
-        }),
-        createSyncNativeInstruction(wsolAta)
-      );
-    }
-
-    return preIxs.length > 0 ? builder.preInstructions(preIxs) : builder;
-  }
-
-  async withdraw(
-    signer: PublicKey,
-    vaultPda: PublicKey,
-    vaultType: VaultType,
-    amount: BN | number,
-    options?: VaultActionOptions
-  ) {
-    const { autoWrapUnwrap = true, includeCuBudget = true, computeUnits } = options ?? {};
-
-    const vault = await this.fetchVault(vaultPda);
-    const mint = vaultType === VaultType.Base ? vault.baseMint.address : vault.quoteMint.address;
-    const condMints = (vaultType === VaultType.Base ? vault.condBaseMints : vault.condQuoteMints)
-      .slice(0, vault.numOptions);
-
-    let builder = withdraw(
-      this.program,
-      signer,
-      vaultPda,
-      mint,
-      condMints,
-      vaultType,
-      amount
-    );
-
-    if (includeCuBudget) {
-      builder = builder.preInstructions([
-        ComputeBudgetProgram.setComputeUnitLimit({
-          units: computeUnits ?? this.computeUnits,
-        }),
-      ]);
-    }
-
-    if (autoWrapUnwrap && mint.equals(NATIVE_MINT)) {
-      const wsolAta = getAssociatedTokenAddressSync(NATIVE_MINT, signer);
-      builder = builder.postInstructions([
-        createCloseAccountInstruction(wsolAta, signer, signer),
-      ]);
-    }
-
-    return builder;
-  }
-
-  finalize(payer: PublicKey, owner: PublicKey, vaultPda: PublicKey, winningIdx: number) {
-    return finalize(this.program, payer, owner, vaultPda, winningIdx);
-  }
-
-  async redeemWinnings(
-    signer: PublicKey,
-    vaultPda: PublicKey,
-    vaultType: VaultType,
-    options?: VaultActionOptions
-  ) {
-    const { autoWrapUnwrap = true, includeCuBudget = true, computeUnits } = options ?? {};
-
-    const vault = await this.fetchVault(vaultPda);
-    const mint = vaultType === VaultType.Base ? vault.baseMint.address : vault.quoteMint.address;
-    const condMints = (vaultType === VaultType.Base ? vault.condBaseMints : vault.condQuoteMints)
-      .slice(0, vault.numOptions);
-
-    let builder = redeemWinnings(
-      this.program,
-      signer,
-      vaultPda,
-      mint,
-      condMints,
-      vaultType
-    );
-
-    if (includeCuBudget) {
-      builder = builder.preInstructions([
-        ComputeBudgetProgram.setComputeUnitLimit({
-          units: computeUnits ?? this.computeUnits,
-        }),
-      ]);
-    }
-
-    if (autoWrapUnwrap && mint.equals(NATIVE_MINT)) {
-      const wsolAta = getAssociatedTokenAddressSync(NATIVE_MINT, signer);
-      builder = builder.postInstructions([
-        createCloseAccountInstruction(wsolAta, signer, signer),
-      ]);
-    }
-
-    return builder;
-  }
-}

package/src/vault/constants.ts

@@ -1,23 +0,0 @@
-/*
- * Constants for the Vault program.
- * Parsed from the generated IDL to stay in sync with the Rust program.
- */
-
-import { PublicKey } from "@solana/web3.js";
-import { VaultIDL } from "../generated/idls";
-import { parseIdlBytes, getIdlConstant } from "../utils";
-
-/* Program ID */
-
-export const PROGRAM_ID = new PublicKey(VaultIDL.address);
-
-/* PDA Seeds */
-
-export const VAULT_SEED = parseIdlBytes(getIdlConstant(VaultIDL, "VAULT_SEED"));
-export const CONDITIONAL_MINT_SEED = parseIdlBytes(getIdlConstant(VaultIDL, "CONDITIONAL_MINT_SEED"));
-
-/* Numeric Constants */
-
-export const MAX_OPTIONS = Number(getIdlConstant(VaultIDL, "MAX_OPTIONS"));
-export const MIN_OPTIONS = Number(getIdlConstant(VaultIDL, "MIN_OPTIONS"));
-export const VAULT_VERSION = Number(getIdlConstant(VaultIDL, "VAULT_VERSION"));

package/src/vault/index.ts

@@ -1,5 +0,0 @@
-export * from "./constants";
-export * from "./types";
-export * from "./utils";
-export * from "./instructions";
-export * from "./client";

package/src/vault/instructions.ts

@@ -1,170 +0,0 @@
-/*
- * Low-level instruction builders for the Vault program.
- * These are thin wrappers around the program methods - use VaultClient for higher-level operations.
- */
-
-import { Program, BN } from "@coral-xyz/anchor";
-import { PublicKey } from "@solana/web3.js";
-import { getAssociatedTokenAddressSync } from "@solana/spl-token";
-import { Vault, VaultType } from "./types";
-
-export function initialize(
-  program: Program<Vault>,
-  payer: PublicKey,
-  owner: PublicKey,
-  vaultPda: PublicKey,
-  baseMint: PublicKey,
-  quoteMint: PublicKey,
-  condBaseMint0: PublicKey,
-  condBaseMint1: PublicKey,
-  condQuoteMint0: PublicKey,
-  condQuoteMint1: PublicKey,
-  nonce: number
-) {
-  return program.methods.initialize(nonce).accountsPartial({
-    payer,
-    owner,
-    vault: vaultPda,
-    baseMint,
-    quoteMint,
-    condBaseMint0,
-    condBaseMint1,
-    condQuoteMint0,
-    condQuoteMint1,
-  });
-}
-
-export function addOption(
-  program: Program<Vault>,
-  payer: PublicKey,
-  owner: PublicKey,
-  vaultPda: PublicKey,
-  condBaseMint: PublicKey,
-  condQuoteMint: PublicKey
-) {
-  return program.methods.addOption().accountsPartial({
-    payer,
-    owner,
-    vault: vaultPda,
-    condBaseMint,
-    condQuoteMint,
-  });
-}
-
-export function activate(
-  program: Program<Vault>,
-  payer: PublicKey,
-  owner: PublicKey,
-  vaultPda: PublicKey
-) {
-  return program.methods.activate().accountsPartial({
-    payer,
-    owner,
-    vault: vaultPda,
-  });
-}
-
-export function deposit(
-  program: Program<Vault>,
-  signer: PublicKey,
-  vaultPda: PublicKey,
-  mint: PublicKey,
-  condMints: PublicKey[],
-  vaultType: VaultType,
-  amount: BN | number
-) {
-  const amountBN = typeof amount === "number" ? new BN(amount) : amount;
-  const vaultTypeArg = vaultType === VaultType.Base ? { base: {} } : { quote: {} };
-
-  return program.methods
-    .deposit(vaultTypeArg, amountBN)
-    .accountsPartial({
-      signer,
-      vault: vaultPda,
-      mint,
-    })
-    .remainingAccounts(
-      condMints.flatMap((condMint) => [
-        { pubkey: condMint, isSigner: false, isWritable: true },
-        {
-          pubkey: getAssociatedTokenAddressSync(condMint, signer),
-          isSigner: false,
-          isWritable: true,
-        },
-      ])
-    );
-}
-
-export function withdraw(
-  program: Program<Vault>,
-  signer: PublicKey,
-  vaultPda: PublicKey,
-  mint: PublicKey,
-  condMints: PublicKey[],
-  vaultType: VaultType,
-  amount: BN | number
-) {
-  const amountBN = typeof amount === "number" ? new BN(amount) : amount;
-  const vaultTypeArg = vaultType === VaultType.Base ? { base: {} } : { quote: {} };
-
-  return program.methods
-    .withdraw(vaultTypeArg, amountBN)
-    .accountsPartial({
-      signer,
-      vault: vaultPda,
-      mint,
-    })
-    .remainingAccounts(
-      condMints.flatMap((condMint) => [
-        { pubkey: condMint, isSigner: false, isWritable: true },
-        {
-          pubkey: getAssociatedTokenAddressSync(condMint, signer),
-          isSigner: false,
-          isWritable: true,
-        },
-      ])
-    );
-}
-
-export function finalize(
-  program: Program<Vault>,
-  payer: PublicKey,
-  owner: PublicKey,
-  vaultPda: PublicKey,
-  winningIdx: number
-) {
-  return program.methods.finalize(winningIdx).accountsPartial({
-    payer,
-    owner,
-    vault: vaultPda,
-  });
-}
-
-export function redeemWinnings(
-  program: Program<Vault>,
-  signer: PublicKey,
-  vaultPda: PublicKey,
-  mint: PublicKey,
-  condMints: PublicKey[],
-  vaultType: VaultType
-) {
-  const vaultTypeArg = vaultType === VaultType.Base ? { base: {} } : { quote: {} };
-
-  return program.methods
-    .redeemWinnings(vaultTypeArg)
-    .accountsPartial({
-      signer,
-      vault: vaultPda,
-      mint,
-    })
-    .remainingAccounts(
-      condMints.flatMap((condMint) => [
-        { pubkey: condMint, isSigner: false, isWritable: true },
-        {
-          pubkey: getAssociatedTokenAddressSync(condMint, signer),
-          isSigner: false,
-          isWritable: true,
-        },
-      ])
-    );
-}

package/src/vault/types.ts

@@ -1,54 +0,0 @@
-/*
- * Type definitions for the Vault program.
- * Exports IDL-derived types and SDK-friendly enums.
- */
-
-import { IdlAccounts, IdlEvents, IdlTypes } from "@coral-xyz/anchor";
-import { TxOptions } from "../utils";
-
-export { Vault } from "../generated/types";
-import type { Vault } from "../generated/types";
-
-/* IDL-derived Types */
-
-export type VaultAccount = IdlAccounts<Vault>["vaultAccount"];
-export type VaultStateRaw = IdlTypes<Vault>["vaultState"];
-export type VaultTypeRaw = IdlTypes<Vault>["vaultType"];
-
-export type VaultInitializedEvent = IdlEvents<Vault>["vaultInitialized"];
-export type VaultActivatedEvent = IdlEvents<Vault>["vaultActivated"];
-export type VaultDepositEvent = IdlEvents<Vault>["vaultDeposit"];
-export type VaultWithdrawalEvent = IdlEvents<Vault>["vaultWithdrawal"];
-export type VaultFinalizedEvent = IdlEvents<Vault>["vaultFinalized"];
-export type OptionAddedEvent = IdlEvents<Vault>["optionAdded"];
-export type WinningsRedeemedEvent = IdlEvents<Vault>["winningsRedeemed"];
-
-/* SDK Enums */
-
-export enum VaultType {
-  Base = 0,
-  Quote = 1,
-}
-
-export enum VaultState {
-  Setup = "setup",
-  Active = "active",
-  Finalized = "finalized",
-}
-
-/* Event Union Type */
-
-export type VaultEvent =
-  | { name: "VaultInitialized"; data: VaultInitializedEvent }
-  | { name: "VaultActivated"; data: VaultActivatedEvent }
-  | { name: "VaultDeposit"; data: VaultDepositEvent }
-  | { name: "VaultWithdrawal"; data: VaultWithdrawalEvent }
-  | { name: "VaultFinalized"; data: VaultFinalizedEvent }
-  | { name: "OptionAdded"; data: OptionAddedEvent }
-  | { name: "WinningsRedeemed"; data: WinningsRedeemedEvent };
-
-/* Client Options */
-
-export interface VaultActionOptions extends TxOptions {
-  autoWrapUnwrap?: boolean;  // Auto wrap/unwrap native SOL (default: true)
-}

package/src/vault/utils.ts

@@ -1,70 +0,0 @@
-/*
- * Utility functions for the Vault program.
- * PDA derivation, state parsing, and account fetching.
- */
-
-import { Program } from "@coral-xyz/anchor";
-import { PublicKey } from "@solana/web3.js";
-import { VAULT_SEED, CONDITIONAL_MINT_SEED, PROGRAM_ID } from "./constants";
-import { Vault, VaultType, VaultState, VaultAccount } from "./types";
-
-/* PDA Derivation */
-
-export function deriveVaultPDA(
-  owner: PublicKey,
-  nonce: number,
-  programId: PublicKey = PROGRAM_ID
-): [PublicKey, number] {
-  const nonceBuffer = Buffer.alloc(2);
-  nonceBuffer.writeUInt16LE(nonce);
-  return PublicKey.findProgramAddressSync(
-    [
-      VAULT_SEED,
-      owner.toBuffer(),
-      nonceBuffer,
-    ],
-    programId
-  );
-}
-
-export function deriveConditionalMint(
-  vaultPda: PublicKey,
-  vaultType: VaultType,
-  index: number,
-  programId: PublicKey = PROGRAM_ID
-): [PublicKey, number] {
-  return PublicKey.findProgramAddressSync(
-    [
-      CONDITIONAL_MINT_SEED,
-      vaultPda.toBuffer(),
-      Buffer.from([vaultType]),
-      Buffer.from([index]),
-    ],
-    programId
-  );
-}
-
-/* Parsers */
-
-export function parseVaultState(state: any): { state: VaultState; winningIdx: number | null } {
-  if ("setup" in state) {
-    return { state: VaultState.Setup, winningIdx: null };
-  }
-  if ("active" in state) {
-    return { state: VaultState.Active, winningIdx: null };
-  }
-  if ("finalized" in state) {
-    const winningIdx = state.finalized[0] ?? state.finalized;
-    return { state: VaultState.Finalized, winningIdx };
-  }
-  throw new Error("Unknown vault state");
-}
-
-/* Fetch */
-
-export async function fetchVaultAccount(
-  program: Program<Vault>,
-  vaultPda: PublicKey
-): Promise<VaultAccount> {
-  return program.account.vaultAccount.fetch(vaultPda);
-}