@zcomb/programs-sdk 1.6.0 → 1.8.0

package/src/svault/instructions.ts

@@ -1,258 +0,0 @@
-/*
- * Low-level instruction builders for the SVault program.
- * These are thin wrappers around the program methods - use SVaultClient for higher-level operations.
- */
-
-import { Program, BN } from "@coral-xyz/anchor";
-import { PublicKey } from "@solana/web3.js";
-import { getAssociatedTokenAddressSync, TOKEN_PROGRAM_ID } from "@solana/spl-token";
-import { Svault } from "./types";
-import {
-  deriveStakingConfigPDA,
-  deriveUserStakePDA,
-  deriveStakeVaultPDA,
-  deriveRewardVaultPDA,
-  deriveDelegatePDA,
-} from "./utils";
-
-/* Fee Authority (same as AMM program) */
-export const FEE_AUTHORITY = new PublicKey("FEEnkcCNE2623LYCPtLf63LFzXpCFigBLTu4qZovRGZC");
-
-export function initializeStakingVault(
-  program: Program<Svault>,
-  admin: PublicKey,
-  tokenMint: PublicKey,
-  unstakingPeriod: BN | number,
-  volumeWindow: BN | number,
-  nonce: number
-) {
-  const unstakingPeriodBN = typeof unstakingPeriod === "number" ? new BN(unstakingPeriod) : unstakingPeriod;
-  const volumeWindowBN = typeof volumeWindow === "number" ? new BN(volumeWindow) : volumeWindow;
-
-  const [configPda] = deriveStakingConfigPDA(tokenMint, nonce, program.programId);
-  const [stakeVault] = deriveStakeVaultPDA(configPda, program.programId);
-  const [rewardVault] = deriveRewardVaultPDA(configPda, program.programId);
-
-  return program.methods
-    .initializeStakingVault(unstakingPeriodBN, volumeWindowBN, nonce)
-    .accountsPartial({
-      admin,
-      tokenMint,
-      config: configPda,
-      stakeVault,
-      rewardVault,
-      tokenProgram: TOKEN_PROGRAM_ID,
-    });
-}
-
-export function stake(
-  program: Program<Svault>,
-  user: PublicKey,
-  tokenMint: PublicKey,
-  nonce: number,
-  amount: BN | number
-) {
-  const amountBN = typeof amount === "number" ? new BN(amount) : amount;
-
-  const [configPda] = deriveStakingConfigPDA(tokenMint, nonce, program.programId);
-  const [userStakePda] = deriveUserStakePDA(configPda, user, program.programId);
-  const [stakeVault] = deriveStakeVaultPDA(configPda, program.programId);
-  const userTokenAccount = getAssociatedTokenAddressSync(tokenMint, user);
-
-  return program.methods.stake(amountBN).accountsPartial({
-    user,
-    tokenMint,
-    config: configPda,
-    userStake: userStakePda,
-    stakeVault,
-    userTokenAccount,
-    tokenProgram: TOKEN_PROGRAM_ID,
-  });
-}
-
-export function initiateUnstake(
-  program: Program<Svault>,
-  user: PublicKey,
-  tokenMint: PublicKey,
-  nonce: number,
-  amount: BN | number
-) {
-  const amountBN = typeof amount === "number" ? new BN(amount) : amount;
-
-  const [configPda] = deriveStakingConfigPDA(tokenMint, nonce, program.programId);
-  const [userStakePda] = deriveUserStakePDA(configPda, user, program.programId);
-
-  return program.methods.initiateUnstake(amountBN).accountsPartial({
-    user,
-    tokenMint,
-    config: configPda,
-    userStake: userStakePda,
-  });
-}
-
-export function withdraw(
-  program: Program<Svault>,
-  user: PublicKey,
-  tokenMint: PublicKey,
-  nonce: number
-) {
-  const [configPda] = deriveStakingConfigPDA(tokenMint, nonce, program.programId);
-  const [userStakePda] = deriveUserStakePDA(configPda, user, program.programId);
-  const [stakeVault] = deriveStakeVaultPDA(configPda, program.programId);
-  const userTokenAccount = getAssociatedTokenAddressSync(tokenMint, user);
-
-  return program.methods.withdraw().accountsPartial({
-    user,
-    tokenMint,
-    config: configPda,
-    userStake: userStakePda,
-    stakeVault,
-    userTokenAccount,
-    tokenProgram: TOKEN_PROGRAM_ID,
-  });
-}
-
-export function postRewards(
-  program: Program<Svault>,
-  admin: PublicKey,
-  tokenMint: PublicKey,
-  nonce: number,
-  merkleRoot: number[],
-  totalAmount: BN | number
-) {
-  const merkleRootArray = merkleRoot as number[];
-  const totalAmountBN = typeof totalAmount === "number" ? new BN(totalAmount) : totalAmount;
-
-  const [configPda] = deriveStakingConfigPDA(tokenMint, nonce, program.programId);
-  const [rewardVault] = deriveRewardVaultPDA(configPda, program.programId);
-  const adminTokenAccount = getAssociatedTokenAddressSync(tokenMint, admin);
-
-  return program.methods
-    .postRewards(merkleRootArray, totalAmountBN)
-    .accountsPartial({
-      admin,
-      tokenMint,
-      config: configPda,
-      rewardVault,
-      adminTokenAccount,
-      tokenProgram: TOKEN_PROGRAM_ID,
-    });
-}
-
-export function claimRewards(
-  program: Program<Svault>,
-  user: PublicKey,
-  tokenMint: PublicKey,
-  nonce: number,
-  cumulativeAmount: BN | number,
-  proof: number[][]
-) {
-  const cumulativeAmountBN = typeof cumulativeAmount === "number" ? new BN(cumulativeAmount) : cumulativeAmount;
-
-  const [configPda] = deriveStakingConfigPDA(tokenMint, nonce, program.programId);
-  const [userStakePda] = deriveUserStakePDA(configPda, user, program.programId);
-  const [rewardVault] = deriveRewardVaultPDA(configPda, program.programId);
-  const userTokenAccount = getAssociatedTokenAddressSync(tokenMint, user);
-
-  return program.methods
-    .claimRewards(cumulativeAmountBN, proof)
-    .accountsPartial({
-      user,
-      tokenMint,
-      config: configPda,
-      userStake: userStakePda,
-      rewardVault,
-      userTokenAccount,
-      tokenProgram: TOKEN_PROGRAM_ID,
-    });
-}
-
-export function setConfig(
-  program: Program<Svault>,
-  admin: PublicKey,
-  tokenMint: PublicKey,
-  nonce: number,
-  unstakingPeriod: BN | number | null,
-  volumeWindow: BN | number | null
-) {
-  const unstakingPeriodArg = unstakingPeriod === null
-    ? null
-    : typeof unstakingPeriod === "number"
-      ? new BN(unstakingPeriod)
-      : unstakingPeriod;
-
-  const volumeWindowArg = volumeWindow === null
-    ? null
-    : typeof volumeWindow === "number"
-      ? new BN(volumeWindow)
-      : volumeWindow;
-
-  const [configPda] = deriveStakingConfigPDA(tokenMint, nonce, program.programId);
-
-  return program.methods
-    .setConfig(unstakingPeriodArg, volumeWindowArg)
-    .accountsPartial({
-      admin,
-      config: configPda,
-    });
-}
-
-export function slash(
-  program: Program<Svault>,
-  admin: PublicKey,
-  tokenMint: PublicKey,
-  nonce: number,
-  userStakePda: PublicKey,
-  basisPoints: number
-) {
-  const [configPda] = deriveStakingConfigPDA(tokenMint, nonce, program.programId);
-  const [stakeVault] = deriveStakeVaultPDA(configPda, program.programId);
-  const feeVault = getAssociatedTokenAddressSync(tokenMint, FEE_AUTHORITY);
-
-  return program.methods.slash(basisPoints).accountsPartial({
-    admin,
-    tokenMint,
-    config: configPda,
-    userStake: userStakePda,
-    stakeVault,
-    feeVault,
-    tokenProgram: TOKEN_PROGRAM_ID,
-  });
-}
-
-export function addDelegate(
-  program: Program<Svault>,
-  staker: PublicKey,
-  delegateWallet: PublicKey,
-  tokenMint: PublicKey,
-  nonce: number
-) {
-  const [configPda] = deriveStakingConfigPDA(tokenMint, nonce, program.programId);
-  const [userStakePda] = deriveUserStakePDA(configPda, staker, program.programId);
-  const [delegatePda] = deriveDelegatePDA(configPda, delegateWallet, program.programId);
-
-  return program.methods.addDelegate().accountsPartial({
-    staker,
-    delegateWallet,
-    config: configPda,
-    userStake: userStakePda,
-    delegate: delegatePda,
-  });
-}
-
-export function removeDelegate(
-  program: Program<Svault>,
-  staker: PublicKey,
-  delegateWallet: PublicKey,
-  tokenMint: PublicKey,
-  nonce: number
-) {
-  const [configPda] = deriveStakingConfigPDA(tokenMint, nonce, program.programId);
-  const [delegatePda] = deriveDelegatePDA(configPda, delegateWallet, program.programId);
-
-  return program.methods.removeDelegate().accountsPartial({
-    staker,
-    config: configPda,
-    delegate: delegatePda,
-  });
-}

package/src/svault/types.ts

@@ -1,45 +0,0 @@
-/*
- * Type definitions for the SVault program.
- * Exports IDL-derived types and SDK-friendly enums.
- */
-
-import { IdlAccounts, IdlEvents } from "@coral-xyz/anchor";
-import { TxOptions } from "../utils";
-
-export { Svault } from "../generated/types";
-import type { Svault } from "../generated/types";
-
-/* IDL-derived Account Types */
-
-export type StakingConfigAccount = IdlAccounts<Svault>["stakingConfig"];
-export type UserStakeAccount = IdlAccounts<Svault>["userStake"];
-export type DelegateAccount = IdlAccounts<Svault>["delegate"];
-
-/* IDL-derived Event Types */
-
-export type StakingVaultInitializedEvent = IdlEvents<Svault>["stakingVaultInitialized"];
-export type StakedEvent = IdlEvents<Svault>["staked"];
-export type UnstakeInitiatedEvent = IdlEvents<Svault>["unstakeInitiated"];
-export type WithdrawnEvent = IdlEvents<Svault>["withdrawn"];
-export type RewardsPostedEvent = IdlEvents<Svault>["rewardsPosted"];
-export type RewardsClaimedEvent = IdlEvents<Svault>["rewardsClaimed"];
-export type SlashedEvent = IdlEvents<Svault>["slashed"];
-export type DelegateAddedEvent = IdlEvents<Svault>["delegateAdded"];
-export type DelegateRemovedEvent = IdlEvents<Svault>["delegateRemoved"];
-
-/* Event Union Type */
-
-export type SVaultEvent =
-  | { name: "StakingVaultInitialized"; data: StakingVaultInitializedEvent }
-  | { name: "Staked"; data: StakedEvent }
-  | { name: "UnstakeInitiated"; data: UnstakeInitiatedEvent }
-  | { name: "Withdrawn"; data: WithdrawnEvent }
-  | { name: "RewardsPosted"; data: RewardsPostedEvent }
-  | { name: "RewardsClaimed"; data: RewardsClaimedEvent }
-  | { name: "Slashed"; data: SlashedEvent }
-  | { name: "DelegateAdded"; data: DelegateAddedEvent }
-  | { name: "DelegateRemoved"; data: DelegateRemovedEvent };
-
-/* Client Options */
-
-export interface SVaultTxOptions extends TxOptions {}

package/src/svault/utils.ts

@@ -1,145 +0,0 @@
-/*
- * Utility functions for the SVault program.
- * PDA derivation, state parsing, and account fetching.
- */
-
-import { Program } from "@coral-xyz/anchor";
-import { PublicKey } from "@solana/web3.js";
-import {
-  STAKING_CONFIG_SEED,
-  USER_STAKE_SEED,
-  STAKE_VAULT_SEED,
-  REWARD_VAULT_SEED,
-  PROGRAM_ID,
-  SECONDS_PER_DAY,
-} from "./constants";
-import { Svault, StakingConfigAccount, UserStakeAccount, DelegateAccount } from "./types";
-
-/* PDA Derivation */
-
-export function deriveStakingConfigPDA(
-  tokenMint: PublicKey,
-  nonce: number,
-  programId: PublicKey = PROGRAM_ID
-): [PublicKey, number] {
-  const nonceBuffer = Buffer.alloc(2);
-  nonceBuffer.writeUInt16LE(nonce);
-  return PublicKey.findProgramAddressSync(
-    [STAKING_CONFIG_SEED, tokenMint.toBuffer(), nonceBuffer],
-    programId
-  );
-}
-
-export function deriveUserStakePDA(
-  stakingConfig: PublicKey,
-  user: PublicKey,
-  programId: PublicKey = PROGRAM_ID
-): [PublicKey, number] {
-  return PublicKey.findProgramAddressSync(
-    [USER_STAKE_SEED, stakingConfig.toBuffer(), user.toBuffer()],
-    programId
-  );
-}
-
-export function deriveDelegatePDA(
-  stakingConfig: PublicKey,
-  delegate: PublicKey,
-  programId: PublicKey = PROGRAM_ID
-): [PublicKey, number] {
-  // Uses USER_STAKE_SEED to prevent delegate from also being a staker
-  return PublicKey.findProgramAddressSync(
-    [USER_STAKE_SEED, stakingConfig.toBuffer(), delegate.toBuffer()],
-    programId
-  );
-}
-
-export function deriveStakeVaultPDA(
-  stakingConfig: PublicKey,
-  programId: PublicKey = PROGRAM_ID
-): [PublicKey, number] {
-  return PublicKey.findProgramAddressSync(
-    [STAKE_VAULT_SEED, stakingConfig.toBuffer()],
-    programId
-  );
-}
-
-export function deriveRewardVaultPDA(
-  stakingConfig: PublicKey,
-  programId: PublicKey = PROGRAM_ID
-): [PublicKey, number] {
-  return PublicKey.findProgramAddressSync(
-    [REWARD_VAULT_SEED, stakingConfig.toBuffer()],
-    programId
-  );
-}
-
-/* Fetchers */
-
-export async function fetchStakingConfigAccount(
-  program: Program<Svault>,
-  pda: PublicKey
-): Promise<StakingConfigAccount> {
-  return program.account.stakingConfig.fetch(pda);
-}
-
-export async function fetchUserStakeAccount(
-  program: Program<Svault>,
-  pda: PublicKey
-): Promise<UserStakeAccount> {
-  return program.account.userStake.fetch(pda);
-}
-
-export async function fetchDelegateAccount(
-  program: Program<Svault>,
-  pda: PublicKey
-): Promise<DelegateAccount> {
-  return program.account.delegate.fetch(pda);
-}
-
-/* Helpers */
-
-/**
- * Compute when withdrawal will be available based on unstake initiation time.
- * @param unstakeInitiatedAt Unix timestamp when unstake was initiated (seconds)
- * @param unstakingPeriodDays Number of days in unstaking period
- * @returns Date when withdrawal becomes available
- */
-export function computeWithdrawAvailableAt(
-  unstakeInitiatedAt: number,
-  unstakingPeriodDays: number
-): Date {
-  const availableAtSeconds = unstakeInitiatedAt + unstakingPeriodDays * SECONDS_PER_DAY;
-  return new Date(availableAtSeconds * 1000);
-}
-
-/**
- * Check if withdrawal is currently available.
- * @param unstakeInitiatedAt Unix timestamp when unstake was initiated (seconds)
- * @param unstakingPeriodDays Number of days in unstaking period
- * @returns true if unstaking period has elapsed
- */
-export function isWithdrawAvailable(
-  unstakeInitiatedAt: number,
-  unstakingPeriodDays: number
-): boolean {
-  if (unstakeInitiatedAt === 0) return false;
-  const now = Math.floor(Date.now() / 1000);
-  const availableAt = unstakeInitiatedAt + unstakingPeriodDays * SECONDS_PER_DAY;
-  return now >= availableAt;
-}
-
-/**
- * Compute the time remaining until withdrawal is available.
- * @param unstakeInitiatedAt Unix timestamp when unstake was initiated (seconds)
- * @param unstakingPeriodDays Number of days in unstaking period
- * @returns Seconds remaining, or 0 if already available
- */
-export function getTimeUntilWithdraw(
-  unstakeInitiatedAt: number,
-  unstakingPeriodDays: number
-): number {
-  if (unstakeInitiatedAt === 0) return 0;
-  const now = Math.floor(Date.now() / 1000);
-  const availableAt = unstakeInitiatedAt + unstakingPeriodDays * SECONDS_PER_DAY;
-  return Math.max(0, availableAt - now);
-}

package/src/utils.ts

@@ -1,41 +0,0 @@
-/*
- * Shared utilities for parsing IDL values and common types.
- * Used across program SDKs.
- */
-
-/* Transaction Options */
-
-export interface TxOptions {
-  includeCuBudget?: boolean;  // Include compute budget instruction (default: true)
-  computeUnits?: number;      // Override default compute units
-  /**
-   * Pre-create conditional token ATAs before launch to avoid exceeding
-   * Solana's 64 instruction trace limit. Default: true for 3+ options.
-   * Set to false if you've already created ATAs or want to manage them manually.
-   */
-  ensureATAs?: boolean;
-}
-
-/*
- * Parse IDL bytes value string to Buffer.
- * e.g., "[99, 109, 105, 110, 116]" → Buffer.from([99, 109, 105, 110, 116])
- */
-export function parseIdlBytes(value: string): Buffer {
-  const bytes = JSON.parse(value) as number[];
-  return Buffer.from(bytes);
-}
-
-/*
- * Get a constant from an IDL by name.
- * Throws if the constant is not found (helps catch mismatches after IDL sync).
- */
-export function getIdlConstant(
-  idl: { constants: Array<{ name: string; value: string }> },
-  name: string
-) {
-  const constant = idl.constants.find((c) => c.name === name);
-  if (!constant) {
-    throw new Error(`IDL missing constant: ${name}`);
-  }
-  return constant.value;
-}