@zcomb/programs-sdk 1.7.0 → 1.8.1

package/src/index.ts

@@ -1,163 +0,0 @@
-/* Shared Types */
-
-export { TxOptions } from "./utils";
-
-/* Vault Sub-SDK */
-
-export {
-  // Client
-  VaultClient,
-  // Types
-  VaultType,
-  VaultState,
-  VaultAccount,
-  VaultInitializedEvent,
-  VaultActivatedEvent,
-  VaultDepositEvent,
-  VaultWithdrawalEvent,
-  VaultFinalizedEvent,
-  OptionAddedEvent as VaultOptionAddedEvent,
-  WinningsRedeemedEvent,
-  VaultEvent,
-  VaultActionOptions,
-  // Utils
-  deriveVaultPDA,
-  deriveConditionalMint,
-  parseVaultState,
-  fetchVaultAccount,
-  // Constants
-  PROGRAM_ID as VAULT_PROGRAM_ID,
-  VAULT_SEED,
-  CONDITIONAL_MINT_SEED,
-  MAX_OPTIONS as VAULT_MAX_OPTIONS,
-  MIN_OPTIONS as VAULT_MIN_OPTIONS,
-} from "./vault";
-
-/* AMM Sub-SDK */
-
-export {
-  // Client
-  AMMClient,
-  // Types
-  PoolState,
-  TwapOracle,
-  PoolBumps,
-  PoolAccount,
-  SwapQuote,
-  PoolCreatedEvent,
-  LiquidityAddedEvent,
-  LiquidityRemovedEvent,
-  CondSwapEvent,
-  TWAPUpdateEvent,
-  AMMEvent,
-  // Utils
-  derivePoolPDA,
-  deriveReservePDA,
-  deriveFeeVaultPDA,
-  parsePoolState,
-  fetchPoolAccount,
-  calculateSpotPrice,
-  computeSwapOutput,
-  computeSwapInput,
-  calculatePriceImpact,
-  createSwapQuote,
-  // Constants
-  PROGRAM_ID as AMM_PROGRAM_ID,
-  FEE_AUTHORITY,
-  POOL_SEED,
-  RESERVE_SEED,
-  FEE_VAULT_SEED,
-  MAX_FEE,
-  PRICE_SCALE,
-} from "./amm";
-
-/* Futarchy Sub-SDK */
-
-export {
-  // Client
-  FutarchyClient,
-  // Types
-  ProposalState,
-  DAOAccount,
-  ModeratorAccount,
-  ProposalAccount,
-  ProposalParams,
-  DAOType,
-  PoolType,
-  DAOInitializedEvent,
-  DAOUpgradedEvent,
-  ModeratorInitializedEvent,
-  ProposalInitializedEvent,
-  ProposalLaunchedEvent,
-  OptionAddedEvent as FutarchyOptionAddedEvent,
-  ProposalFinalizedEvent,
-  LiquidityRedeemedEvent,
-  FutarchyEvent,
-  // Utils
-  deriveDAOPDA,
-  deriveModeratorPDA,
-  deriveProposalPDA,
-  parseProposalState,
-  fetchDAOAccount,
-  fetchModeratorAccount,
-  fetchProposalAccount,
-  isProposalExpired,
-  getTimeRemaining,
-  // Constants
-  PROGRAM_ID as FUTARCHY_PROGRAM_ID,
-  DAO_SEED,
-  MODERATOR_SEED,
-  PROPOSAL_SEED,
-  MAX_OPTIONS as FUTARCHY_MAX_OPTIONS,
-  MIN_OPTIONS as FUTARCHY_MIN_OPTIONS,
-} from "./futarchy";
-
-/* SVault Sub-SDK */
-
-export {
-  // Client
-  SVaultClient,
-  // Types
-  StakingConfigAccount,
-  UserStakeAccount,
-  DelegateAccount,
-  StakingVaultInitializedEvent,
-  StakedEvent,
-  UnstakeInitiatedEvent,
-  WithdrawnEvent,
-  RewardsPostedEvent,
-  RewardsClaimedEvent,
-  SlashedEvent,
-  DelegateAddedEvent,
-  DelegateRemovedEvent,
-  SVaultEvent,
-  SVaultTxOptions,
-  // Utils
-  deriveStakingConfigPDA,
-  deriveUserStakePDA,
-  deriveDelegatePDA,
-  deriveStakeVaultPDA,
-  deriveRewardVaultPDA,
-  fetchStakingConfigAccount,
-  fetchUserStakeAccount,
-  fetchDelegateAccount,
-  computeWithdrawAvailableAt,
-  isWithdrawAvailable,
-  getTimeUntilWithdraw,
-  // Constants
-  PROGRAM_ID as SVAULT_PROGRAM_ID,
-  STAKING_CONFIG_SEED,
-  USER_STAKE_SEED,
-  STAKE_VAULT_SEED,
-  REWARD_VAULT_SEED,
-  SECONDS_PER_DAY,
-} from "./svault";
-
-/* Sub-SDK Namespaces */
-
-import * as vault from "./vault";
-import * as amm from "./amm";
-import * as futarchy from "./futarchy";
-import * as svault from "./svault";
-
-export { vault, amm, futarchy, svault };

package/src/svault/client.ts

@@ -1,401 +0,0 @@
-/*
- * High-level client for the SVault program.
- * Provides ergonomic methods for staking operations with automatic PDA derivation
- * and compute budget management.
- */
-
-import { Program, AnchorProvider, BN } from "@coral-xyz/anchor";
-import { PublicKey, ComputeBudgetProgram } from "@solana/web3.js";
-import { PROGRAM_ID } from "./constants";
-import {
-  Svault,
-  SVaultTxOptions,
-  StakingConfigAccount,
-  UserStakeAccount,
-  DelegateAccount,
-} from "./types";
-import {
-  deriveStakingConfigPDA,
-  deriveUserStakePDA,
-  deriveDelegatePDA,
-  deriveStakeVaultPDA,
-  deriveRewardVaultPDA,
-  fetchStakingConfigAccount,
-  fetchUserStakeAccount,
-  fetchDelegateAccount,
-} from "./utils";
-import {
-  initializeStakingVault,
-  stake,
-  initiateUnstake,
-  withdraw,
-  postRewards,
-  claimRewards,
-  setConfig,
-  slash,
-  addDelegate,
-  removeDelegate,
-} from "./instructions";
-
-import { SvaultIDL } from "../generated/idls";
-
-const DEFAULT_COMPUTE_UNITS = 200_000;
-
-export class SVaultClient {
-  public program: Program<Svault>;
-  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(SvaultIDL as Svault, provider);
-  }
-
-  /* PDA Helpers */
-
-  deriveStakingConfigPDA(tokenMint: PublicKey, nonce: number): [PublicKey, number] {
-    return deriveStakingConfigPDA(tokenMint, nonce, this.programId);
-  }
-
-  deriveUserStakePDA(
-    stakingConfig: PublicKey,
-    user: PublicKey
-  ): [PublicKey, number] {
-    return deriveUserStakePDA(stakingConfig, user, this.programId);
-  }
-
-  deriveDelegatePDA(
-    stakingConfig: PublicKey,
-    delegate: PublicKey
-  ): [PublicKey, number] {
-    return deriveDelegatePDA(stakingConfig, delegate, this.programId);
-  }
-
-  deriveStakeVaultPDA(stakingConfig: PublicKey): [PublicKey, number] {
-    return deriveStakeVaultPDA(stakingConfig, this.programId);
-  }
-
-  deriveRewardVaultPDA(stakingConfig: PublicKey): [PublicKey, number] {
-    return deriveRewardVaultPDA(stakingConfig, this.programId);
-  }
-
-  /* State Fetching */
-
-  async fetchStakingConfig(pda: PublicKey): Promise<StakingConfigAccount> {
-    return fetchStakingConfigAccount(this.program, pda);
-  }
-
-  async fetchUserStake(pda: PublicKey): Promise<UserStakeAccount> {
-    return fetchUserStakeAccount(this.program, pda);
-  }
-
-  async fetchDelegate(pda: PublicKey): Promise<DelegateAccount> {
-    return fetchDelegateAccount(this.program, pda);
-  }
-
-  /**
-   * Convenience method: Derive staking config PDA from mint + nonce, then fetch user stake.
-   */
-  async fetchUserStakeByMint(
-    tokenMint: PublicKey,
-    nonce: number,
-    user: PublicKey
-  ): Promise<UserStakeAccount> {
-    const [configPda] = this.deriveStakingConfigPDA(tokenMint, nonce);
-    const [userStakePda] = this.deriveUserStakePDA(configPda, user);
-    return this.fetchUserStake(userStakePda);
-  }
-
-  /**
-   * Convenience method: Derive staking config PDA from mint + nonce, then fetch config.
-   */
-  async fetchStakingConfigByMint(
-    tokenMint: PublicKey,
-    nonce: number
-  ): Promise<StakingConfigAccount> {
-    const [configPda] = this.deriveStakingConfigPDA(tokenMint, nonce);
-    return this.fetchStakingConfig(configPda);
-  }
-
-  /* Instruction Builders */
-
-  initializeStakingVault(
-    admin: PublicKey,
-    tokenMint: PublicKey,
-    unstakingPeriod: BN | number,
-    volumeWindow: BN | number,
-    nonce: number,
-    options?: SVaultTxOptions
-  ) {
-    const { includeCuBudget = true, computeUnits } = options ?? {};
-
-    let builder = initializeStakingVault(
-      this.program,
-      admin,
-      tokenMint,
-      unstakingPeriod,
-      volumeWindow,
-      nonce
-    );
-
-    if (includeCuBudget) {
-      builder = builder.preInstructions([
-        ComputeBudgetProgram.setComputeUnitLimit({
-          units: computeUnits ?? this.computeUnits,
-        }),
-      ]);
-    }
-
-    const [configPda] = this.deriveStakingConfigPDA(tokenMint, nonce);
-    return { builder, configPda };
-  }
-
-  stake(
-    user: PublicKey,
-    tokenMint: PublicKey,
-    nonce: number,
-    amount: BN | number,
-    options?: SVaultTxOptions
-  ) {
-    const { includeCuBudget = true, computeUnits } = options ?? {};
-
-    let builder = stake(this.program, user, tokenMint, nonce, amount);
-
-    if (includeCuBudget) {
-      builder = builder.preInstructions([
-        ComputeBudgetProgram.setComputeUnitLimit({
-          units: computeUnits ?? this.computeUnits,
-        }),
-      ]);
-    }
-
-    return builder;
-  }
-
-  initiateUnstake(
-    user: PublicKey,
-    tokenMint: PublicKey,
-    nonce: number,
-    amount: BN | number,
-    options?: SVaultTxOptions
-  ) {
-    const { includeCuBudget = true, computeUnits } = options ?? {};
-
-    let builder = initiateUnstake(this.program, user, tokenMint, nonce, amount);
-
-    if (includeCuBudget) {
-      builder = builder.preInstructions([
-        ComputeBudgetProgram.setComputeUnitLimit({
-          units: computeUnits ?? this.computeUnits,
-        }),
-      ]);
-    }
-
-    return builder;
-  }
-
-  withdraw(
-    user: PublicKey,
-    tokenMint: PublicKey,
-    nonce: number,
-    options?: SVaultTxOptions
-  ) {
-    const { includeCuBudget = true, computeUnits } = options ?? {};
-
-    let builder = withdraw(this.program, user, tokenMint, nonce);
-
-    if (includeCuBudget) {
-      builder = builder.preInstructions([
-        ComputeBudgetProgram.setComputeUnitLimit({
-          units: computeUnits ?? this.computeUnits,
-        }),
-      ]);
-    }
-
-    return builder;
-  }
-
-  postRewards(
-    admin: PublicKey,
-    tokenMint: PublicKey,
-    nonce: number,
-    merkleRoot: number[],
-    totalAmount: BN | number,
-    options?: SVaultTxOptions
-  ) {
-    const { includeCuBudget = true, computeUnits } = options ?? {};
-
-    let builder = postRewards(
-      this.program,
-      admin,
-      tokenMint,
-      nonce,
-      merkleRoot,
-      totalAmount
-    );
-
-    if (includeCuBudget) {
-      builder = builder.preInstructions([
-        ComputeBudgetProgram.setComputeUnitLimit({
-          units: computeUnits ?? this.computeUnits,
-        }),
-      ]);
-    }
-
-    return builder;
-  }
-
-  claimRewards(
-    user: PublicKey,
-    tokenMint: PublicKey,
-    nonce: number,
-    cumulativeAmount: BN | number,
-    proof: number[][],
-    options?: SVaultTxOptions
-  ) {
-    const { includeCuBudget = true, computeUnits } = options ?? {};
-
-    let builder = claimRewards(
-      this.program,
-      user,
-      tokenMint,
-      nonce,
-      cumulativeAmount,
-      proof
-    );
-
-    if (includeCuBudget) {
-      builder = builder.preInstructions([
-        ComputeBudgetProgram.setComputeUnitLimit({
-          units: computeUnits ?? this.computeUnits,
-        }),
-      ]);
-    }
-
-    return builder;
-  }
-
-  setConfig(
-    admin: PublicKey,
-    tokenMint: PublicKey,
-    nonce: number,
-    params: { unstakingPeriod?: BN | number; volumeWindow?: BN | number },
-    options?: SVaultTxOptions
-  ) {
-    const { includeCuBudget = true, computeUnits } = options ?? {};
-
-    let builder = setConfig(
-      this.program,
-      admin,
-      tokenMint,
-      nonce,
-      params.unstakingPeriod ?? null,
-      params.volumeWindow ?? null
-    );
-
-    if (includeCuBudget) {
-      builder = builder.preInstructions([
-        ComputeBudgetProgram.setComputeUnitLimit({
-          units: computeUnits ?? this.computeUnits,
-        }),
-      ]);
-    }
-
-    return builder;
-  }
-
-  slash(
-    admin: PublicKey,
-    tokenMint: PublicKey,
-    nonce: number,
-    userToSlash: PublicKey,
-    basisPoints: number,
-    options?: SVaultTxOptions
-  ) {
-    const { includeCuBudget = true, computeUnits } = options ?? {};
-
-    // Derive user stake PDA from user pubkey
-    const [configPda] = this.deriveStakingConfigPDA(tokenMint, nonce);
-    const [userStakePda] = this.deriveUserStakePDA(configPda, userToSlash);
-
-    let builder = slash(
-      this.program,
-      admin,
-      tokenMint,
-      nonce,
-      userStakePda,
-      basisPoints
-    );
-
-    if (includeCuBudget) {
-      builder = builder.preInstructions([
-        ComputeBudgetProgram.setComputeUnitLimit({
-          units: computeUnits ?? this.computeUnits,
-        }),
-      ]);
-    }
-
-    return builder;
-  }
-
-  addDelegate(
-    staker: PublicKey,
-    delegateWallet: PublicKey,
-    tokenMint: PublicKey,
-    nonce: number,
-    options?: SVaultTxOptions
-  ) {
-    const { includeCuBudget = true, computeUnits } = options ?? {};
-
-    let builder = addDelegate(
-      this.program,
-      staker,
-      delegateWallet,
-      tokenMint,
-      nonce
-    );
-
-    if (includeCuBudget) {
-      builder = builder.preInstructions([
-        ComputeBudgetProgram.setComputeUnitLimit({
-          units: computeUnits ?? this.computeUnits,
-        }),
-      ]);
-    }
-
-    return builder;
-  }
-
-  removeDelegate(
-    staker: PublicKey,
-    delegateWallet: PublicKey,
-    tokenMint: PublicKey,
-    nonce: number,
-    options?: SVaultTxOptions
-  ) {
-    const { includeCuBudget = true, computeUnits } = options ?? {};
-
-    let builder = removeDelegate(
-      this.program,
-      staker,
-      delegateWallet,
-      tokenMint,
-      nonce
-    );
-
-    if (includeCuBudget) {
-      builder = builder.preInstructions([
-        ComputeBudgetProgram.setComputeUnitLimit({
-          units: computeUnits ?? this.computeUnits,
-        }),
-      ]);
-    }
-
-    return builder;
-  }
-}

package/src/svault/constants.ts

@@ -1,23 +0,0 @@
-/*
- * Constants for the SVault program.
- * Parsed from the generated IDL to stay in sync with the Rust program.
- */
-
-import { PublicKey } from "@solana/web3.js";
-import { SvaultIDL } from "../generated/idls";
-import { parseIdlBytes, getIdlConstant } from "../utils";
-
-/* Program ID */
-
-export const PROGRAM_ID = new PublicKey(SvaultIDL.address);
-
-/* PDA Seeds */
-
-export const STAKING_CONFIG_SEED = parseIdlBytes(getIdlConstant(SvaultIDL, "STAKING_CONFIG_SEED"));
-export const USER_STAKE_SEED = parseIdlBytes(getIdlConstant(SvaultIDL, "USER_STAKE_SEED"));
-export const STAKE_VAULT_SEED = parseIdlBytes(getIdlConstant(SvaultIDL, "STAKE_VAULT_SEED"));
-export const REWARD_VAULT_SEED = parseIdlBytes(getIdlConstant(SvaultIDL, "REWARD_VAULT_SEED"));
-
-/* Time Constants */
-
-export const SECONDS_PER_DAY = 86400;

package/src/svault/index.ts

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