@zcomb/programs-sdk 1.6.0 → 1.8.0

package/src/futarchy/constants.ts

@@ -1,28 +0,0 @@
-/*
- * Constants for the Futarchy program.
- * Parsed from the generated IDL to stay in sync with the Rust program.
- */
-
-import { PublicKey } from "@solana/web3.js";
-import { FutarchyIDL } from "../generated/idls";
-import { parseIdlBytes, getIdlConstant } from "../utils";
-
-/* Program ID */
-
-export const PROGRAM_ID = new PublicKey(FutarchyIDL.address);
-
-/* PDA Seeds */
-
-export const DAO_SEED = parseIdlBytes(getIdlConstant(FutarchyIDL, "DAO_SEED"));
-export const MODERATOR_SEED = parseIdlBytes(getIdlConstant(FutarchyIDL, "MODERATOR_SEED"));
-export const PROPOSAL_SEED = parseIdlBytes(getIdlConstant(FutarchyIDL, "PROPOSAL_SEED"));
-
-/* Numeric Constants */
-
-export const MAX_OPTIONS = Number(getIdlConstant(FutarchyIDL, "MAX_OPTIONS"));
-export const MIN_OPTIONS = Number(getIdlConstant(FutarchyIDL, "MIN_OPTIONS"));
-
-/* Squads Integration */
-
-export const SQUADS_PROGRAM_ID = new PublicKey("SQDS4ep65T869zMMBKyuUq6aD6EgTu8psMjkvj52pCf");
-export const MINT_CREATE_KEY_SEED = parseIdlBytes(getIdlConstant(FutarchyIDL, "MINT_CREATE_KEY_SEED"));

package/src/futarchy/index.ts

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

package/src/futarchy/instructions.ts

@@ -1,235 +0,0 @@
-/*
- * Low-level instruction builders for the Futarchy program.
- * These are thin wrappers around the program methods - use FutarchyClient for higher-level operations.
- */
-
-import { Program, BN } from "@coral-xyz/anchor";
-import { PublicKey } from "@solana/web3.js";
-import { Futarchy, ProposalParams, PoolType } from "./types";
-
-/* Instruction Builders */
-
-export function initializeModerator(
-  program: Program<Futarchy>,
-  admin: PublicKey,
-  baseMint: PublicKey,
-  quoteMint: PublicKey,
-  moderator: PublicKey,
-  name: string
-) {
-  return program.methods.initializeModerator(name).accountsPartial({
-    admin,
-    baseMint,
-    quoteMint,
-    moderator,
-  });
-}
-
-export function initializeProposal(
-  program: Program<Futarchy>,
-  creator: PublicKey,
-  moderator: PublicKey,
-  proposal: PublicKey,
-  proposalParams: ProposalParams,
-  metadata: string | null,
-  remainingAccounts: { pubkey: PublicKey; isSigner: boolean; isWritable: boolean }[]
-) {
-  return program.methods
-    .initializeProposal(proposalParams, metadata)
-    .accountsPartial({
-      creator,
-      moderator,
-      proposal,
-    })
-    .remainingAccounts(remainingAccounts);
-}
-
-export function addOption(
-  program: Program<Futarchy>,
-  creator: PublicKey,
-  proposal: PublicKey,
-  remainingAccounts: { pubkey: PublicKey; isSigner: boolean; isWritable: boolean }[]
-) {
-  return program.methods
-    .addOption()
-    .accountsPartial({
-      creator,
-      proposal,
-    })
-    .remainingAccounts(remainingAccounts);
-}
-
-export function launchProposal(
-  program: Program<Futarchy>,
-  creator: PublicKey,
-  proposal: PublicKey,
-  vault: PublicKey,
-  baseAmount: BN | number,
-  quoteAmount: BN | number,
-  remainingAccounts: { pubkey: PublicKey; isSigner: boolean; isWritable: boolean }[]
-) {
-  const baseAmountBN = typeof baseAmount === "number" ? new BN(baseAmount) : baseAmount;
-  const quoteAmountBN = typeof quoteAmount === "number" ? new BN(quoteAmount) : quoteAmount;
-
-  return program.methods
-    .launchProposal(baseAmountBN, quoteAmountBN)
-    .accountsPartial({
-      creator,
-      proposal,
-      vault,
-    })
-    .remainingAccounts(remainingAccounts);
-}
-
-export function finalizeProposal(
-  program: Program<Futarchy>,
-  signer: PublicKey,
-  proposal: PublicKey,
-  vault: PublicKey,
-  remainingAccounts: { pubkey: PublicKey; isSigner: boolean; isWritable: boolean }[]
-) {
-  return program.methods
-    .finalizeProposal()
-    .accountsPartial({
-      signer,
-      proposal,
-      vault,
-    })
-    .remainingAccounts(remainingAccounts);
-}
-
-export function redeemLiquidity(
-  program: Program<Futarchy>,
-  creator: PublicKey,
-  proposal: PublicKey,
-  vault: PublicKey,
-  pool: PublicKey,
-  remainingAccounts: { pubkey: PublicKey; isSigner: boolean; isWritable: boolean }[]
-) {
-  return program.methods
-    .redeemLiquidity()
-    .accountsPartial({
-      creator,
-      proposal,
-      vault,
-      pool,
-    })
-    .remainingAccounts(remainingAccounts);
-}
-
-export function addHistoricalProposal(
-  program: Program<Futarchy>,
-  admin: PublicKey,
-  moderator: PublicKey,
-  proposal: PublicKey,
-  numOptions: number,
-  winningIdx: number,
-  length: number,
-  createdAt: BN | number
-) {
-  const createdAtBN = typeof createdAt === "number" ? new BN(createdAt) : createdAt;
-  return program.methods
-    .addHistoricalProposal(numOptions, winningIdx, length, createdAtBN)
-    .accountsPartial({
-      admin,
-      moderator,
-      proposal,
-    });
-}
-
-/* DAO Instruction Builders */
-
-export function initializeParentDAO(
-  program: Program<Futarchy>,
-  admin: PublicKey,
-  parentAdmin: PublicKey,
-  dao: PublicKey,
-  moderator: PublicKey,
-  baseMint: PublicKey,
-  quoteMint: PublicKey,
-  programConfig: PublicKey,
-  programConfigTreasury: PublicKey,
-  treasuryMultisig: PublicKey,
-  mintMultisig: PublicKey,
-  mintCreateKey: PublicKey,
-  squadsProgram: PublicKey,
-  name: string,
-  treasuryCosigner: PublicKey,
-  pool: PublicKey,
-  poolType: PoolType
-) {
-  return program.methods
-    .initializeParentDao(name, treasuryCosigner, pool, poolType)
-    .accountsPartial({
-      admin,
-      parentAdmin,
-      dao,
-      moderator,
-      baseMint,
-      quoteMint,
-      programConfig,
-      programConfigTreasury,
-      treasuryMultisig,
-      mintMultisig,
-      mintCreateKey,
-      squadsProgram,
-    });
-}
-
-export function initializeChildDAO(
-  program: Program<Futarchy>,
-  admin: PublicKey,
-  parentAdmin: PublicKey,
-  dao: PublicKey,
-  parentDao: PublicKey,
-  tokenMint: PublicKey,
-  programConfig: PublicKey,
-  programConfigTreasury: PublicKey,
-  treasuryMultisig: PublicKey,
-  mintMultisig: PublicKey,
-  mintCreateKey: PublicKey,
-  squadsProgram: PublicKey,
-  name: string,
-  treasuryCosigner: PublicKey
-) {
-  return program.methods
-    .initializeChildDao(name, treasuryCosigner)
-    .accountsPartial({
-      admin,
-      parentAdmin,
-      dao,
-      parentDao,
-      tokenMint,
-      programConfig,
-      programConfigTreasury,
-      treasuryMultisig,
-      mintMultisig,
-      mintCreateKey,
-      squadsProgram,
-    });
-}
-
-export function upgradeDAO(
-  program: Program<Futarchy>,
-  admin: PublicKey,
-  parentAdmin: PublicKey,
-  dao: PublicKey,
-  parentDao: PublicKey,
-  moderator: PublicKey,
-  baseMint: PublicKey,
-  quoteMint: PublicKey,
-  pool: PublicKey,
-  poolType: PoolType
-) {
-  return program.methods
-    .upgradeDao(pool, poolType)
-    .accountsPartial({
-      admin,
-      parentAdmin,
-      dao,
-      parentDao,
-      moderator,
-      baseMint,
-      quoteMint,
-    });
-}

package/src/futarchy/types.ts

@@ -1,54 +0,0 @@
-/*
- * Type definitions for the Futarchy program.
- * Derived from the generated IDL types.
- */
-
-import { IdlAccounts, IdlEvents, IdlTypes } from "@coral-xyz/anchor";
-
-// Re-export the generated IDL type
-export { Futarchy } from "../generated/types";
-import type { Futarchy } from "../generated/types";
-
-/* Account Types */
-
-export type DAOAccount = IdlAccounts<Futarchy>["daoAccount"];
-export type ModeratorAccount = IdlAccounts<Futarchy>["moderatorAccount"];
-export type ProposalAccount = IdlAccounts<Futarchy>["proposalAccount"];
-
-/* IDL Types */
-
-export type ProposalParams = IdlTypes<Futarchy>["proposalParams"];
-export type ProposalStateRaw = IdlTypes<Futarchy>["proposalState"];
-export type DAOType = IdlTypes<Futarchy>["daoType"];
-export type PoolType = IdlTypes<Futarchy>["poolType"];
-
-/* Event Types */
-
-export type DAOInitializedEvent = IdlEvents<Futarchy>["daoInitialized"];
-export type DAOUpgradedEvent = IdlEvents<Futarchy>["daoUpgraded"];
-export type ModeratorInitializedEvent = IdlEvents<Futarchy>["moderatorInitialized"];
-export type ProposalInitializedEvent = IdlEvents<Futarchy>["proposalInitialized"];
-export type ProposalLaunchedEvent = IdlEvents<Futarchy>["proposalLaunched"];
-export type OptionAddedEvent = IdlEvents<Futarchy>["optionAdded"];
-export type ProposalFinalizedEvent = IdlEvents<Futarchy>["proposalFinalized"];
-export type LiquidityRedeemedEvent = IdlEvents<Futarchy>["liquidityRedeemed"];
-
-/* Enums */
-
-export enum ProposalState {
-  Setup = "setup",
-  Pending = "pending",
-  Resolved = "resolved",
-}
-
-/* Event Union Type */
-
-export type FutarchyEvent =
-  | { name: "DAOInitialized"; data: DAOInitializedEvent }
-  | { name: "DAOUpgraded"; data: DAOUpgradedEvent }
-  | { name: "ModeratorInitialized"; data: ModeratorInitializedEvent }
-  | { name: "ProposalInitialized"; data: ProposalInitializedEvent }
-  | { name: "ProposalLaunched"; data: ProposalLaunchedEvent }
-  | { name: "OptionAdded"; data: OptionAddedEvent }
-  | { name: "ProposalFinalized"; data: ProposalFinalizedEvent }
-  | { name: "LiquidityRedeemed"; data: LiquidityRedeemedEvent };

package/src/futarchy/utils.ts

@@ -1,108 +0,0 @@
-/*
- * Utility functions for the Futarchy program.
- * Includes PDA derivation, parsers, and fetch helpers.
- */
-
-import { Program } from "@coral-xyz/anchor";
-import { PublicKey } from "@solana/web3.js";
-import { DAO_SEED, MODERATOR_SEED, PROPOSAL_SEED, MINT_CREATE_KEY_SEED, PROGRAM_ID } from "./constants";
-import { Futarchy, DAOAccount, ModeratorAccount, ProposalAccount, ProposalState } from "./types";
-
-/* PDA Derivation */
-
-export function deriveDAOPDA(
-  name: string,
-  programId: PublicKey = PROGRAM_ID
-): [PublicKey, number] {
-  return PublicKey.findProgramAddressSync(
-    [DAO_SEED, Buffer.from(name)],
-    programId
-  );
-}
-
-export function deriveModeratorPDA(
-  name: string,
-  programId: PublicKey = PROGRAM_ID
-): [PublicKey, number] {
-  return PublicKey.findProgramAddressSync(
-    [MODERATOR_SEED, Buffer.from(name)],
-    programId
-  );
-}
-
-export function deriveProposalPDA(
-  moderator: PublicKey,
-  proposalId: number,
-  programId: PublicKey = PROGRAM_ID
-): [PublicKey, number] {
-  const proposalIdBuffer = Buffer.alloc(2);
-  proposalIdBuffer.writeUInt16LE(proposalId);
-  return PublicKey.findProgramAddressSync(
-    [PROPOSAL_SEED, moderator.toBuffer(), proposalIdBuffer],
-    programId
-  );
-}
-
-export function deriveMintCreateKeyPDA(
-  daoPda: PublicKey,
-  name: string,
-  programId: PublicKey = PROGRAM_ID
-): [PublicKey, number] {
-  return PublicKey.findProgramAddressSync(
-    [daoPda.toBuffer(), MINT_CREATE_KEY_SEED, Buffer.from(name)],
-    programId
-  );
-}
-
-/* Parsers */
-
-export function parseProposalState(state: any): { state: ProposalState; winningIdx: number | null } {
-  if ("setup" in state) {
-    return { state: ProposalState.Setup, winningIdx: null };
-  }
-  if ("pending" in state) {
-    return { state: ProposalState.Pending, winningIdx: null };
-  }
-  if ("resolved" in state) {
-    const winningIdx = state.resolved[0] ?? state.resolved;
-    return { state: ProposalState.Resolved, winningIdx };
-  }
-  throw new Error("Unknown proposal state");
-}
-
-/* Fetchers */
-
-export async function fetchDAOAccount(
-  program: Program<Futarchy>,
-  daoPda: PublicKey
-): Promise<DAOAccount> {
-  return program.account.daoAccount.fetch(daoPda);
-}
-
-export async function fetchModeratorAccount(
-  program: Program<Futarchy>,
-  moderatorPda: PublicKey
-): Promise<ModeratorAccount> {
-  return program.account.moderatorAccount.fetch(moderatorPda);
-}
-
-export async function fetchProposalAccount(
-  program: Program<Futarchy>,
-  proposalPda: PublicKey
-): Promise<ProposalAccount> {
-  return program.account.proposalAccount.fetch(proposalPda);
-}
-
-/* Proposal Helpers */
-
-export function isProposalExpired(proposal: ProposalAccount, currentTime?: number): boolean {
-  const now = currentTime ?? Math.floor(Date.now() / 1000);
-  const endTime = proposal.createdAt.toNumber() + proposal.config.length;
-  return now >= endTime;
-}
-
-export function getTimeRemaining(proposal: ProposalAccount, currentTime?: number): number {
-  const now = currentTime ?? Math.floor(Date.now() / 1000);
-  const endTime = proposal.createdAt.toNumber() + proposal.config.length;
-  return Math.max(0, endTime - now);
-}