@zemyth/raise-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1926 @@
+import { PublicKey, SystemProgram, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_RENT_PUBKEY, ComputeBudgetProgram, SYSVAR_CLOCK_PUBKEY } from '@solana/web3.js';
+export { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import { BN, AnchorError } from '@coral-xyz/anchor';
+export { BN } from '@coral-xyz/anchor';
+import { getAssociatedTokenAddressSync, TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID } from '@solana/spl-token';
+
+// src/pdas/index.ts
+
+// src/constants/index.ts
+var SEEDS = {
+  PROJECT: "project",
+  MILESTONE: "milestone",
+  INVESTMENT: "investment",
+  VOTE: "vote",
+  ESCROW: "escrow",
+  PIVOT: "pivot",
+  PIVOT_PROPOSAL: "pivot_proposal",
+  TGE_ESCROW: "tge_escrow",
+  TGE_ESCROW_VAULT: "tge_escrow_vault",
+  SCAM_REPORT: "scam_report",
+  ADMIN_CONFIG: "admin-config",
+  NFT_MINT: "nft_mint",
+  AUTHORITY: "authority"
+};
+var VALIDATION = {
+  /** Minimum number of milestones per project */
+  MIN_MILESTONES: 2,
+  /** Maximum number of milestones per project */
+  MAX_MILESTONES: 10,
+  /** Milestone percentages must sum to this value */
+  MILESTONE_PERCENTAGE_SUM: 100,
+  /** Maximum funding buffer (110% of goal) */
+  MAX_FUNDING_BUFFER_PERCENT: 110,
+  /** Maximum metadata URI length */
+  MAX_METADATA_URI_LENGTH: 200,
+  /** Maximum pivot description length */
+  MAX_PIVOT_DESCRIPTION_LEN: 256,
+  /** Maximum pivot vision length */
+  MAX_PIVOT_VISION_LEN: 512,
+  /** Maximum pivot justification length */
+  MAX_PIVOT_JUSTIFICATION_LEN: 512
+};
+var TIMING = {
+  /** Production voting period (14 days) */
+  VOTING_PERIOD_SECONDS: 1209600,
+  /** Production hold period (7 days) */
+  HOLD_PERIOD_SECONDS: 604800,
+  /** Inactivity timeout (90 days) */
+  INACTIVITY_TIMEOUT_SECONDS: 7776e3,
+  /** Abandonment timeout (90 days) */
+  ABANDONMENT_TIMEOUT_SECONDS: 7776e3,
+  /** Refund window (14 days) */
+  REFUND_WINDOW_SECONDS: 1209600,
+  /** Pivot withdrawal window (7 days) */
+  PIVOT_WITHDRAWAL_WINDOW_SECONDS: 604800,
+  /** Minimum TGE date (15 days from now) */
+  TGE_MIN_DAYS: 1296e3,
+  /** Maximum TGE date (90 days from now) */
+  TGE_MAX_DAYS: 7776e3,
+  /** Post-TGE holdback period (30 days) */
+  POST_TGE_HOLDBACK_DAYS: 2592e3
+};
+var TIER_CONSTRAINTS = {
+  /** Minimum number of tiers */
+  MIN_TIERS: 1,
+  /** Maximum number of tiers */
+  MAX_TIERS: 10,
+  /** Minimum tier amount (10 USDC in lamports) */
+  MIN_TIER_AMOUNT: 10000000n,
+  /** Minimum max_lots per tier */
+  MIN_TIER_MAX_LOTS: 1,
+  /** Minimum token ratio */
+  MIN_TIER_TOKEN_RATIO: 1n,
+  /** Minimum vote multiplier (100 = 1.0x) */
+  MIN_TIER_VOTE_MULTIPLIER: 100
+};
+var InvestmentTier = /* @__PURE__ */ ((InvestmentTier2) => {
+  InvestmentTier2["Bronze"] = "Bronze";
+  InvestmentTier2["Silver"] = "Silver";
+  InvestmentTier2["Gold"] = "Gold";
+  InvestmentTier2["Platinum"] = "Platinum";
+  InvestmentTier2["Diamond"] = "Diamond";
+  return InvestmentTier2;
+})(InvestmentTier || {});
+var TIER_MINIMUMS = {
+  ["Bronze" /* Bronze */]: 100000000n,
+  // 100 USDC
+  ["Silver" /* Silver */]: 500000000n,
+  // 500 USDC
+  ["Gold" /* Gold */]: 1000000000n,
+  // 1,000 USDC
+  ["Platinum" /* Platinum */]: 5000000000n,
+  // 5,000 USDC
+  ["Diamond" /* Diamond */]: 10000000000n
+  // 10,000 USDC
+};
+var TIER_VOTE_MULTIPLIERS = {
+  ["Bronze" /* Bronze */]: 100,
+  // 1.0x
+  ["Silver" /* Silver */]: 120,
+  // 1.2x
+  ["Gold" /* Gold */]: 150,
+  // 1.5x
+  ["Platinum" /* Platinum */]: 200,
+  // 2.0x
+  ["Diamond" /* Diamond */]: 300
+  // 3.0x
+};
+var TIER_TOKEN_MULTIPLIERS = {
+  ["Bronze" /* Bronze */]: 100,
+  ["Silver" /* Silver */]: 120,
+  ["Gold" /* Gold */]: 150,
+  ["Platinum" /* Platinum */]: 200,
+  ["Diamond" /* Diamond */]: 300
+};
+function getTierFromAmount(amount) {
+  if (amount >= TIER_MINIMUMS["Diamond" /* Diamond */]) return "Diamond" /* Diamond */;
+  if (amount >= TIER_MINIMUMS["Platinum" /* Platinum */]) return "Platinum" /* Platinum */;
+  if (amount >= TIER_MINIMUMS["Gold" /* Gold */]) return "Gold" /* Gold */;
+  if (amount >= TIER_MINIMUMS["Silver" /* Silver */]) return "Silver" /* Silver */;
+  return "Bronze" /* Bronze */;
+}
+function getVoteMultiplier(amount) {
+  const tier = getTierFromAmount(amount);
+  return TIER_VOTE_MULTIPLIERS[tier] / 100;
+}
+function getTokenMultiplier(amount) {
+  const tier = getTierFromAmount(amount);
+  return TIER_TOKEN_MULTIPLIERS[tier] / 100;
+}
+function findTierIndex(tiers, amount) {
+  for (let i = tiers.length - 1; i >= 0; i--) {
+    if (amount >= tiers[i].amount) {
+      return i;
+    }
+  }
+  return null;
+}
+var GOVERNANCE = {
+  /** Scam report threshold (30%) */
+  SCAM_THRESHOLD_PERCENT: 30,
+  /** Consecutive milestone failures before exit window eligible */
+  CONSECUTIVE_FAILURES_THRESHOLD: 3,
+  /** Milestone approval threshold (>50% weighted approval per whitepaper voting.md:100-101) */
+  MILESTONE_APPROVAL_THRESHOLD_PERCENT: 50
+};
+var NFT = {
+  /** NFT symbol */
+  SYMBOL: "SNI",
+  /** NFT name prefix */
+  NAME_PREFIX: "Raise Investment #",
+  /** Royalty basis points (2%) */
+  ROYALTY_BASIS_POINTS: 200
+};
+var USDC = {
+  /** USDC decimals */
+  DECIMALS: 6,
+  /** Convert USDC to lamports */
+  toAmount: (usdc) => BigInt(Math.floor(usdc * 10 ** 6)),
+  /** Convert lamports to USDC */
+  fromAmount: (lamports) => Number(lamports) / 10 ** 6
+};
+
+// src/pdas/index.ts
+function ensureBN(value) {
+  if (value && typeof value.toArrayLike === "function") {
+    return value;
+  }
+  return new BN(String(value));
+}
+function getProjectPDA(projectId, programId) {
+  const projectIdBN = ensureBN(projectId);
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from(SEEDS.PROJECT), projectIdBN.toArrayLike(Buffer, "le", 8)],
+    programId
+  );
+  return pda;
+}
+function getEscrowPDA(projectId, programId) {
+  const projectIdBN = ensureBN(projectId);
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from(SEEDS.ESCROW), projectIdBN.toArrayLike(Buffer, "le", 8)],
+    programId
+  );
+  return pda;
+}
+function getMilestonePDA(projectPda, milestoneIndex, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [
+      Buffer.from(SEEDS.MILESTONE),
+      projectPda.toBuffer(),
+      Buffer.from([milestoneIndex])
+    ],
+    programId
+  );
+  return pda;
+}
+function getInvestmentPDA(projectPda, nftMint, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [
+      Buffer.from(SEEDS.INVESTMENT),
+      projectPda.toBuffer(),
+      nftMint.toBuffer()
+    ],
+    programId
+  );
+  return pda;
+}
+function getVotePDA(milestonePda, voterKey, votingRound, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from(SEEDS.VOTE), milestonePda.toBuffer(), voterKey.toBuffer(), Buffer.from([votingRound])],
+    programId
+  );
+  return pda;
+}
+function getPivotProposalPDA(projectPda, pivotCount, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [
+      Buffer.from(SEEDS.PIVOT),
+      // Use PIVOT seed, not PIVOT_PROPOSAL
+      projectPda.toBuffer(),
+      Buffer.from([pivotCount])
+      // pivot_count is u8 (1 byte) on-chain
+    ],
+    programId
+  );
+  return pda;
+}
+function getTgeEscrowPDA(projectPda, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from(SEEDS.TGE_ESCROW), projectPda.toBuffer()],
+    programId
+  );
+  return pda;
+}
+function getTgeEscrowVaultPDA(projectPda, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from(SEEDS.TGE_ESCROW_VAULT), projectPda.toBuffer()],
+    programId
+  );
+  return pda;
+}
+function getTokenVaultPDA(projectPda, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from("token_vault"), projectPda.toBuffer()],
+    programId
+  );
+  return pda;
+}
+function getScamReportPDA(projectPda, nftMint, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [
+      Buffer.from(SEEDS.SCAM_REPORT),
+      projectPda.toBuffer(),
+      nftMint.toBuffer()
+    ],
+    programId
+  );
+  return pda;
+}
+function getAdminConfigPDA(programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from(SEEDS.ADMIN_CONFIG)],
+    programId
+  );
+  return pda;
+}
+function getNftMintPDA(projectId, investor, investmentCount, programId) {
+  const projectIdBN = ensureBN(projectId);
+  const countBN = ensureBN(investmentCount);
+  return PublicKey.findProgramAddressSync(
+    [
+      Buffer.from(SEEDS.NFT_MINT),
+      projectIdBN.toArrayLike(Buffer, "le", 8),
+      investor.toBuffer(),
+      countBN.toArrayLike(Buffer, "le", 8)
+      // u64 is 8 bytes LE
+    ],
+    programId
+  );
+}
+function getProgramAuthorityPDA(programId) {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(SEEDS.AUTHORITY)],
+    programId
+  );
+}
+function getProjectPDAs(projectId, programId) {
+  const project = getProjectPDA(projectId, programId);
+  const escrow = getEscrowPDA(projectId, programId);
+  return { project, escrow };
+}
+function getTokenomicsPDA(projectPda, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from("tokenomics"), projectPda.toBuffer()],
+    programId
+  );
+  return pda;
+}
+function getTokenMintPDA(projectPda, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from("token_mint"), projectPda.toBuffer()],
+    programId
+  );
+  return pda;
+}
+function getVaultAuthorityPDA(projectPda, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from("vault_authority"), projectPda.toBuffer()],
+    programId
+  );
+  return pda;
+}
+function getInvestorVaultPDA(projectPda, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from("investor_vault"), projectPda.toBuffer()],
+    programId
+  );
+  return pda;
+}
+function getFounderVaultPDA(projectPda, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from("founder_vault"), projectPda.toBuffer()],
+    programId
+  );
+  return pda;
+}
+function getLpTokenVaultPDA(projectPda, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from("lp_token_vault"), projectPda.toBuffer()],
+    programId
+  );
+  return pda;
+}
+function getTreasuryVaultPDA(projectPda, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from("treasury_vault"), projectPda.toBuffer()],
+    programId
+  );
+  return pda;
+}
+function getLpUsdcVaultPDA(projectPda, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from("lp_usdc_vault"), projectPda.toBuffer()],
+    programId
+  );
+  return pda;
+}
+function getFounderVestingPDA(projectPda, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from("founder_vesting"), projectPda.toBuffer()],
+    programId
+  );
+  return pda;
+}
+
+// src/accounts/index.ts
+function getAccountNamespace(program) {
+  return program.account;
+}
+async function fetchProject(program, projectId) {
+  try {
+    const projectPda = getProjectPDA(projectId, program.programId);
+    return await getAccountNamespace(program).project.fetch(projectPda);
+  } catch (error) {
+    if (error instanceof Error && error.message?.includes("Account does not exist")) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function fetchProjectByPda(program, projectPda) {
+  try {
+    return await getAccountNamespace(program).project.fetch(projectPda);
+  } catch (error) {
+    if (error instanceof Error && error.message?.includes("Account does not exist")) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function fetchMilestone(program, projectId, milestoneIndex) {
+  try {
+    const projectPda = getProjectPDA(projectId, program.programId);
+    const milestonePda = getMilestonePDA(projectPda, milestoneIndex, program.programId);
+    return await getAccountNamespace(program).milestone.fetch(milestonePda);
+  } catch (error) {
+    if (error instanceof Error && error.message?.includes("Account does not exist")) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function fetchAllMilestones(program, projectId) {
+  const projectPda = getProjectPDA(projectId, program.programId);
+  const milestones = await getAccountNamespace(program).milestone.all([
+    {
+      memcmp: {
+        offset: 8,
+        // Skip discriminator
+        bytes: projectPda.toBase58()
+      }
+    }
+  ]);
+  return milestones.map((m) => ({
+    publicKey: m.publicKey,
+    account: m.account
+  }));
+}
+async function fetchInvestment(program, projectId, nftMint) {
+  try {
+    const projectPda = getProjectPDA(projectId, program.programId);
+    const investmentPda = getInvestmentPDA(projectPda, nftMint, program.programId);
+    return await getAccountNamespace(program).investment.fetch(investmentPda);
+  } catch (error) {
+    if (error instanceof Error && error.message?.includes("Account does not exist")) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function fetchAllInvestments(program, projectId) {
+  const projectPda = getProjectPDA(projectId, program.programId);
+  const investments = await getAccountNamespace(program).investment.all([
+    {
+      memcmp: {
+        offset: 8,
+        // Skip discriminator
+        bytes: projectPda.toBase58()
+      }
+    }
+  ]);
+  return investments.map((inv) => ({
+    publicKey: inv.publicKey,
+    account: inv.account
+  }));
+}
+async function fetchVote(program, projectId, milestoneIndex, voterKey, votingRound) {
+  try {
+    const projectPda = getProjectPDA(projectId, program.programId);
+    const milestonePda = getMilestonePDA(projectPda, milestoneIndex, program.programId);
+    const votePda = getVotePDA(milestonePda, voterKey, votingRound, program.programId);
+    return await getAccountNamespace(program).vote.fetch(votePda);
+  } catch (error) {
+    if (error instanceof Error && error.message?.includes("Account does not exist")) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function fetchAllVotes(program, projectId, milestoneIndex) {
+  const projectPda = getProjectPDA(projectId, program.programId);
+  const milestonePda = getMilestonePDA(projectPda, milestoneIndex, program.programId);
+  const votes = await getAccountNamespace(program).vote.all([
+    {
+      memcmp: {
+        offset: 8,
+        // Skip discriminator
+        bytes: milestonePda.toBase58()
+      }
+    }
+  ]);
+  return votes.map((v) => ({
+    publicKey: v.publicKey,
+    account: v.account
+  }));
+}
+async function fetchPivotProposal(program, projectId) {
+  try {
+    const projectPda = getProjectPDA(projectId, program.programId);
+    const projectAccount = await getAccountNamespace(program).project.fetch(projectPda);
+    let pivotPda;
+    if (projectAccount.activePivot) {
+      pivotPda = projectAccount.activePivot;
+    } else {
+      const pivotCount = projectAccount.pivotCount || 0;
+      pivotPda = getPivotProposalPDA(projectPda, pivotCount, program.programId);
+    }
+    return await getAccountNamespace(program).pivotProposal.fetch(pivotPda);
+  } catch (error) {
+    if (error instanceof Error && error.message?.includes("Account does not exist")) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function fetchTgeEscrow(program, projectId) {
+  try {
+    const projectPda = getProjectPDA(projectId, program.programId);
+    const tgeEscrowPda = getTgeEscrowPDA(projectPda, program.programId);
+    return await getAccountNamespace(program).tgeEscrow.fetch(tgeEscrowPda);
+  } catch (error) {
+    if (error instanceof Error && error.message?.includes("Account does not exist")) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function fetchAdminConfig(program) {
+  const adminConfigPda = getAdminConfigPDA(program.programId);
+  return await getAccountNamespace(program).adminConfig.fetch(adminConfigPda);
+}
+async function accountExists(program, accountType, pda) {
+  try {
+    await program.account[accountType].fetch(pda);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var TOKEN_METADATA_PROGRAM_ID = new PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
+function ensurePublicKey(value) {
+  if (value instanceof PublicKey) {
+    return value;
+  }
+  return new PublicKey(String(value));
+}
+function getMethods(program) {
+  return program.methods;
+}
+function getAccountNamespace2(program) {
+  return program.account;
+}
+async function initializeAdmin(program, admin, payer) {
+  return getMethods(program).initializeAdmin().accounts({
+    admin,
+    payer
+  }).rpc();
+}
+async function transferAdmin(program, adminKeypair, newAdmin) {
+  return getMethods(program).transferAdmin().accounts({
+    authority: adminKeypair.publicKey,
+    newAdmin
+  }).signers([adminKeypair]).rpc();
+}
+async function acceptAdmin(program, newAuthority) {
+  return getMethods(program).acceptAdmin().accounts({
+    newAuthority
+  }).rpc();
+}
+function symbolToBytes(symbol) {
+  const bytes = new Array(8).fill(0);
+  const chars = symbol.toUpperCase().slice(0, 8);
+  for (let i = 0; i < chars.length; i++) {
+    bytes[i] = chars.charCodeAt(i);
+  }
+  return bytes;
+}
+var MIN_DEADLINE_DURATION_SECONDS_PROD = 604800;
+var MIN_DEADLINE_DURATION_SECONDS_DEV = 60;
+var MAX_DEADLINE_DURATION_SECONDS = 31536e3;
+function calculateDeadline(daysFromNow, isDev = false) {
+  const nowSeconds = Math.floor(Date.now() / 1e3);
+  const minDuration = isDev ? MIN_DEADLINE_DURATION_SECONDS_DEV : MIN_DEADLINE_DURATION_SECONDS_PROD;
+  const daysInSeconds = daysFromNow * 24 * 60 * 60;
+  const deadlineSeconds = nowSeconds + Math.max(daysInSeconds, minDuration);
+  const maxDeadline = nowSeconds + MAX_DEADLINE_DURATION_SECONDS;
+  return new BN(Math.min(deadlineSeconds, maxDeadline));
+}
+function minDeadline(isDev = false) {
+  const nowSeconds = Math.floor(Date.now() / 1e3);
+  const minDuration = isDev ? MIN_DEADLINE_DURATION_SECONDS_DEV : MIN_DEADLINE_DURATION_SECONDS_PROD;
+  return new BN(nowSeconds + minDuration + 1);
+}
+function validateDeadline(deadline, isDev = false) {
+  const nowSeconds = Math.floor(Date.now() / 1e3);
+  const deadlineSeconds = deadline.toNumber();
+  const minDuration = isDev ? MIN_DEADLINE_DURATION_SECONDS_DEV : MIN_DEADLINE_DURATION_SECONDS_PROD;
+  const minDeadline2 = nowSeconds + minDuration;
+  const maxDeadline = nowSeconds + MAX_DEADLINE_DURATION_SECONDS;
+  if (deadlineSeconds < minDeadline2) {
+    const minDays = isDev ? "60 seconds" : "7 days";
+    return {
+      valid: false,
+      error: `Deadline must be at least ${minDays} from now`
+    };
+  }
+  if (deadlineSeconds > maxDeadline) {
+    return {
+      valid: false,
+      error: "Deadline must be within 1 year from now"
+    };
+  }
+  return { valid: true };
+}
+async function initializeProject(program, args, founder) {
+  return getMethods(program).initializeProject({
+    projectId: args.projectId,
+    fundingGoal: args.fundingGoal,
+    metadataUri: args.metadataUri,
+    tiers: args.tiers,
+    tokenomics: {
+      tokenSymbol: args.tokenomics.tokenSymbol,
+      totalSupply: args.tokenomics.totalSupply,
+      investorAllocationBps: args.tokenomics.investorAllocationBps,
+      lpTokenAllocationBps: args.tokenomics.lpTokenAllocationBps,
+      lpUsdcAllocationBps: args.tokenomics.lpUsdcAllocationBps,
+      founderAllocationBps: args.tokenomics.founderAllocationBps ?? null,
+      treasuryAllocationBps: args.tokenomics.treasuryAllocationBps ?? null,
+      founderWallet: args.tokenomics.founderWallet ?? null,
+      vestingDurationMonths: args.tokenomics.vestingDurationMonths ?? null,
+      cliffMonths: args.tokenomics.cliffMonths ?? null
+    },
+    milestone1Deadline: args.milestone1Deadline
+  }).accounts({
+    founder
+  }).rpc();
+}
+async function submitForApproval(program, projectId, founder) {
+  const projectPda = getProjectPDA(projectId, program.programId);
+  return getMethods(program).submitForApproval().accounts({
+    project: projectPda,
+    founder
+  }).rpc();
+}
+async function approveProject(program, args, adminKeypair) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const tokenomicsPda = getTokenomicsPDA(projectPda, program.programId);
+  const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  const tokenMintPda = getTokenMintPDA(projectPda, program.programId);
+  const vaultAuthorityPda = getVaultAuthorityPDA(projectPda, program.programId);
+  const investorVaultPda = getInvestorVaultPDA(projectPda, program.programId);
+  const founderVaultPda = getFounderVaultPDA(projectPda, program.programId);
+  const lpTokenVaultPda = getLpTokenVaultPDA(projectPda, program.programId);
+  const treasuryVaultPda = getTreasuryVaultPDA(projectPda, program.programId);
+  const lpUsdcVaultPda = getLpUsdcVaultPDA(projectPda, program.programId);
+  return getMethods(program).approveProject().accounts({
+    project: projectPda,
+    tokenomics: tokenomicsPda,
+    tokenVault: tokenVaultPda,
+    tokenMint: tokenMintPda,
+    vaultAuthority: vaultAuthorityPda,
+    investorVault: investorVaultPda,
+    founderVault: founderVaultPda,
+    lpTokenVault: lpTokenVaultPda,
+    treasuryVault: treasuryVaultPda,
+    lpUsdcVault: lpUsdcVaultPda,
+    usdcMint: args.usdcMint,
+    authority: adminKeypair.publicKey,
+    payer: adminKeypair.publicKey
+  }).signers([adminKeypair]).rpc();
+}
+async function createMilestone(program, args, founder) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const milestonePda = getMilestonePDA(projectPda, args.milestoneIndex, program.programId);
+  return getMethods(program).createMilestone({
+    milestoneIndex: args.milestoneIndex,
+    percentage: args.percentage,
+    description: args.description
+  }).accounts({
+    project: projectPda,
+    milestone: milestonePda,
+    founder
+  }).rpc();
+}
+async function submitMilestone(program, projectId, milestoneIndex, founder) {
+  const projectPda = getProjectPDA(projectId, program.programId);
+  const milestonePda = getMilestonePDA(projectPda, milestoneIndex, program.programId);
+  return getMethods(program).submitMilestone().accounts({
+    project: projectPda,
+    milestone: milestonePda,
+    founder
+  }).rpc();
+}
+async function voteOnMilestone(program, args, voter) {
+  const nftMintPubkey = ensurePublicKey(args.nftMint);
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const milestonePda = getMilestonePDA(projectPda, args.milestoneIndex, program.programId);
+  const investmentPda = getInvestmentPDA(projectPda, nftMintPubkey, program.programId);
+  const milestone = await getAccountNamespace2(program).milestone.fetch(milestonePda);
+  const votingRound = milestone.votingRound ?? 0;
+  const votePda = getVotePDA(milestonePda, voter, votingRound, program.programId);
+  const voterNftAccount = getAssociatedTokenAddressSync(
+    nftMintPubkey,
+    voter,
+    false,
+    // allowOwnerOffCurve
+    TOKEN_PROGRAM_ID
+  );
+  return getMethods(program).voteOnMilestone({ choice: args.choice }).accounts({
+    milestone: milestonePda,
+    project: projectPda,
+    investment: investmentPda,
+    vote: votePda,
+    nftMint: nftMintPubkey,
+    voterNftAccount,
+    voter
+  }).rpc();
+}
+async function finalizeVoting(program, projectId, milestoneIndex) {
+  const projectPda = getProjectPDA(projectId, program.programId);
+  const milestonePda = getMilestonePDA(projectPda, milestoneIndex, program.programId);
+  return getMethods(program).finalizeVoting().accounts({
+    project: projectPda,
+    milestone: milestonePda
+  }).rpc();
+}
+async function claimMilestoneFunds(program, args, founder) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const milestonePda = getMilestonePDA(projectPda, args.milestoneIndex, program.programId);
+  const escrowPda = getEscrowPDA(args.projectId, program.programId);
+  const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  const tokenomicsPda = getTokenomicsPDA(projectPda, program.programId);
+  const lpUsdcVaultPda = getLpUsdcVaultPDA(projectPda, program.programId);
+  const nextMilestonePda = args.nextMilestonePda ?? (args.nextMilestoneDeadline.gt(new BN(0)) ? getMilestonePDA(projectPda, args.milestoneIndex + 1, program.programId) : null);
+  return getMethods(program).claimMilestoneFunds({ nextMilestoneDeadline: args.nextMilestoneDeadline }).accounts({
+    milestone: milestonePda,
+    project: projectPda,
+    founder,
+    projectEscrow: args.escrowTokenAccount,
+    founderUsdcAccount: args.founderUsdcAccount,
+    escrowPda,
+    tokenVault: tokenVaultPda,
+    tokenomics: tokenomicsPda,
+    lpUsdcVault: lpUsdcVaultPda,
+    nextMilestone: nextMilestonePda,
+    systemProgram: SystemProgram.programId,
+    tokenProgram: TOKEN_PROGRAM_ID
+  }).rpc();
+}
+async function resubmitMilestone(program, args, founder) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const milestonePda = getMilestonePDA(projectPda, args.milestoneIndex, program.programId);
+  return getMethods(program).resubmitMilestone().accounts({
+    project: projectPda,
+    milestone: milestonePda,
+    founder
+  }).rpc();
+}
+async function setMilestoneDeadline(program, args, founder) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const milestonePda = getMilestonePDA(projectPda, args.milestoneIndex, program.programId);
+  return getMethods(program).setMilestoneDeadline({
+    milestoneIndex: args.milestoneIndex,
+    deadline: args.deadline
+  }).accounts({
+    project: projectPda,
+    milestone: milestonePda,
+    founder
+  }).rpc();
+}
+async function extendMilestoneDeadline(program, args, founder) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const milestonePda = getMilestonePDA(projectPda, args.milestoneIndex, program.programId);
+  return getMethods(program).extendMilestoneDeadline({
+    milestoneIndex: args.milestoneIndex,
+    newDeadline: args.newDeadline
+  }).accounts({
+    project: projectPda,
+    milestone: milestonePda,
+    founder
+  }).rpc();
+}
+function getMetadataPDA(mint) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("metadata"),
+      TOKEN_METADATA_PROGRAM_ID.toBuffer(),
+      mint.toBuffer()
+    ],
+    TOKEN_METADATA_PROGRAM_ID
+  );
+  return pda;
+}
+function getMasterEditionPDA(mint) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("metadata"),
+      TOKEN_METADATA_PROGRAM_ID.toBuffer(),
+      mint.toBuffer(),
+      Buffer.from("edition")
+    ],
+    TOKEN_METADATA_PROGRAM_ID
+  );
+  return pda;
+}
+async function invest(program, args, investor) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const [nftMint] = getNftMintPDA(args.projectId, investor, args.investmentCount, program.programId);
+  const investmentPda = getInvestmentPDA(projectPda, nftMint, program.programId);
+  const investorNftAccount = getAssociatedTokenAddressSync(nftMint, investor);
+  const metadataAccount = getMetadataPDA(nftMint);
+  const masterEdition = getMasterEditionPDA(nftMint);
+  const [programAuthority] = getProgramAuthorityPDA(program.programId);
+  const firstMilestonePda = getMilestonePDA(projectPda, 0, program.programId);
+  return getMethods(program).invest({ amount: args.amount }).accounts({
+    project: projectPda,
+    firstMilestone: firstMilestonePda,
+    nftMint,
+    investment: investmentPda,
+    investorNftAccount,
+    metadataAccount,
+    masterEdition,
+    escrowTokenAccount: args.escrowTokenAccount,
+    investorTokenAccount: args.investorTokenAccount,
+    programAuthority,
+    investor,
+    tokenProgram: TOKEN_PROGRAM_ID,
+    associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+    systemProgram: SystemProgram.programId,
+    rent: SYSVAR_RENT_PUBKEY,
+    tokenMetadataProgram: TOKEN_METADATA_PROGRAM_ID,
+    sysvarInstructions: SYSVAR_INSTRUCTIONS_PUBKEY
+  }).preInstructions([
+    ComputeBudgetProgram.setComputeUnitLimit({ units: 4e5 })
+  ]).rpc();
+}
+async function cancelInvestment(program, args, investor) {
+  const nftMintPubkey = ensurePublicKey(args.nftMint);
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const investmentPda = getInvestmentPDA(projectPda, nftMintPubkey, program.programId);
+  const escrowPda = getEscrowPDA(args.projectId, program.programId);
+  return getMethods(program).cancelInvestment().accounts({
+    investor,
+    project: projectPda,
+    investment: investmentPda,
+    nftMint: nftMintPubkey,
+    investorNftAccount: args.investorNftAccount,
+    projectEscrow: args.escrowTokenAccount,
+    investorUsdcAccount: args.investorUsdcAccount,
+    escrowPda
+  }).rpc();
+}
+async function proposePivot(program, args, founder) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const projectAccount = await getAccountNamespace2(program).project.fetch(projectPda);
+  const pivotCount = projectAccount.pivotCount || 0;
+  const pivotProposalPda = getPivotProposalPDA(projectPda, pivotCount, program.programId);
+  return getMethods(program).proposePivot({
+    newMetadataUri: args.newMetadataUri,
+    newMilestones: args.newMilestones
+  }).accounts({
+    project: projectPda,
+    founder,
+    pivotProposal: pivotProposalPda,
+    systemProgram: SystemProgram.programId,
+    clock: SYSVAR_CLOCK_PUBKEY
+  }).rpc();
+}
+async function approvePivot(program, projectId, adminKeypair) {
+  const projectPda = getProjectPDA(projectId, program.programId);
+  const projectAccount = await getAccountNamespace2(program).project.fetch(projectPda);
+  let pivotProposalPda;
+  if (projectAccount.activePivot) {
+    pivotProposalPda = projectAccount.activePivot;
+  } else {
+    const pivotCount = projectAccount.pivotCount || 0;
+    pivotProposalPda = getPivotProposalPDA(projectPda, pivotCount, program.programId);
+  }
+  return getMethods(program).approvePivot().accounts({
+    moderator: adminKeypair.publicKey,
+    project: projectPda,
+    pivotProposal: pivotProposalPda
+  }).signers([adminKeypair]).rpc();
+}
+async function withdrawFromPivot(program, args, investor) {
+  const nftMintPubkey = ensurePublicKey(args.nftMint);
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const investmentPda = getInvestmentPDA(projectPda, nftMintPubkey, program.programId);
+  const escrowPda = getEscrowPDA(args.projectId, program.programId);
+  const pivotProposalPda = getPivotProposalPDA(projectPda, args.pivotCount, program.programId);
+  const investorNftAccount = getAssociatedTokenAddressSync(
+    nftMintPubkey,
+    investor,
+    false,
+    TOKEN_PROGRAM_ID
+  );
+  const remainingAccounts = args.milestoneAccounts.map((pubkey) => ({
+    pubkey: ensurePublicKey(pubkey),
+    isSigner: false,
+    isWritable: false
+  }));
+  return getMethods(program).withdrawFromPivot().accounts({
+    investor,
+    project: projectPda,
+    pivotProposal: pivotProposalPda,
+    investment: investmentPda,
+    nftMint: nftMintPubkey,
+    investorNftAccount,
+    escrowTokenAccount: args.escrowTokenAccount,
+    investorTokenAccount: args.investorTokenAccount,
+    escrow: escrowPda
+  }).remainingAccounts(remainingAccounts).rpc();
+}
+async function finalizePivot(program, args, authority) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const pivotProposalPda = getPivotProposalPDA(projectPda, args.pivotCount, program.programId);
+  const remainingAccounts = args.milestoneAccounts.map((pubkey) => ({
+    pubkey,
+    isSigner: false,
+    isWritable: true
+  }));
+  return getMethods(program).finalizePivot().accounts({
+    authority,
+    project: projectPda,
+    pivotProposal: pivotProposalPda
+  }).remainingAccounts(remainingAccounts).rpc();
+}
+async function setTgeDate(program, args, founder) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  return getMethods(program).setTgeDate({
+    tgeDate: args.tgeDate,
+    tokenMint: args.tokenMint
+  }).accounts({
+    project: projectPda,
+    founder
+  }).rpc();
+}
+async function depositTokens(program, args, founder) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  return getMethods(program).depositTokens({ amount: args.amount }).accounts({
+    project: projectPda,
+    tokenMint: args.tokenMint,
+    founderTokenAccount: args.founderTokenAccount,
+    founder
+  }).rpc();
+}
+async function claimTokens(program, args, investor) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const investmentPda = getInvestmentPDA(projectPda, args.nftMint, program.programId);
+  const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  return getMethods(program).claimTokens().accounts({
+    investor,
+    project: projectPda,
+    investment: investmentPda,
+    investorNftAccount: args.investorNftAccount,
+    projectTokenVault: args.projectTokenVault,
+    investorTokenAccount: args.investorTokenAccount,
+    tokenVaultPda,
+    tokenProgram: TOKEN_PROGRAM_ID
+  }).rpc();
+}
+async function reportScam(program, args, reporter) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const tgeEscrowPda = getTgeEscrowPDA(projectPda, program.programId);
+  const investmentPda = getInvestmentPDA(projectPda, args.nftMint, program.programId);
+  return getMethods(program).reportScam().accounts({
+    tgeEscrow: tgeEscrowPda,
+    project: projectPda,
+    investment: investmentPda,
+    nftMint: args.nftMint,
+    reporter
+  }).rpc();
+}
+async function releaseHoldback(program, args) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const tgeEscrowPda = getTgeEscrowPDA(projectPda, program.programId);
+  return getMethods(program).releaseHoldback().accounts({
+    tgeEscrow: tgeEscrowPda,
+    project: projectPda,
+    founderTokenAccount: args.founderTokenAccount
+  }).rpc();
+}
+async function checkAbandonment(program, projectId, milestoneIndex = 0) {
+  const projectPda = getProjectPDA(projectId, program.programId);
+  const milestonePda = getMilestonePDA(projectPda, milestoneIndex, program.programId);
+  return getMethods(program).checkAbandonment().accounts({
+    project: projectPda,
+    milestone: milestonePda
+  }).rpc();
+}
+async function claimRefund(program, args, investor) {
+  const nftMintPubkey = ensurePublicKey(args.nftMint);
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const investmentPda = getInvestmentPDA(projectPda, nftMintPubkey, program.programId);
+  const milestoneCount = args.milestoneCount ?? 1;
+  const remainingAccounts = [];
+  for (let i = 0; i < milestoneCount; i++) {
+    const milestonePda = getMilestonePDA(projectPda, i, program.programId);
+    remainingAccounts.push({
+      pubkey: milestonePda,
+      isWritable: false,
+      isSigner: false
+    });
+  }
+  return getMethods(program).claimRefund().accounts({
+    project: projectPda,
+    investment: investmentPda,
+    nftMint: nftMintPubkey,
+    investorNftAccount: args.investorNftAccount,
+    investor,
+    investorTokenAccount: args.investorUsdcAccount,
+    escrowTokenAccount: args.escrowTokenAccount
+  }).remainingAccounts(remainingAccounts).rpc();
+}
+async function claimInvestorTokens(program, args, investor) {
+  const nftMintPubkey = ensurePublicKey(args.nftMint);
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  const investmentPda = getInvestmentPDA(projectPda, nftMintPubkey, program.programId);
+  const investorVaultPda = getInvestorVaultPDA(projectPda, program.programId);
+  const vaultAuthorityPda = getVaultAuthorityPDA(projectPda, program.programId);
+  const investorNftAccount = getAssociatedTokenAddressSync(
+    nftMintPubkey,
+    investor,
+    false,
+    TOKEN_PROGRAM_ID
+  );
+  return getMethods(program).claimInvestorTokens({ milestoneIndex: args.milestoneIndex }).accounts({
+    investor,
+    project: projectPda,
+    tokenVault: tokenVaultPda,
+    investment: investmentPda,
+    nftMint: nftMintPubkey,
+    investorNftAccount,
+    investorVault: investorVaultPda,
+    investorTokenAccount: args.investorTokenAccount,
+    vaultAuthority: vaultAuthorityPda,
+    tokenProgram: TOKEN_PROGRAM_ID
+  }).rpc();
+}
+async function distributeTokens(program, args, payer) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  const investorVaultPda = getInvestorVaultPDA(projectPda, program.programId);
+  const vaultAuthorityPda = getVaultAuthorityPDA(projectPda, program.programId);
+  const remainingAccounts = args.investments.flatMap((inv) => [
+    { pubkey: inv.investmentPda, isSigner: false, isWritable: true },
+    { pubkey: inv.investorTokenAccount, isSigner: false, isWritable: true }
+  ]);
+  return getMethods(program).distributeTokens({ milestoneIndex: args.milestoneIndex }).accounts({
+    project: projectPda,
+    tokenVault: tokenVaultPda,
+    investorVault: investorVaultPda,
+    vaultAuthority: vaultAuthorityPda,
+    payer,
+    tokenProgram: TOKEN_PROGRAM_ID
+  }).remainingAccounts(remainingAccounts).rpc();
+}
+async function completeDistribution(program, args, payer) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  return getMethods(program).completeDistribution({ milestoneIndex: args.milestoneIndex }).accounts({
+    project: projectPda,
+    tokenVault: tokenVaultPda,
+    payer
+  }).rpc();
+}
+async function claimExitWindowRefund(program, args, investor) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const investmentPda = getInvestmentPDA(projectPda, args.nftMint, program.programId);
+  const escrowPda = getEscrowPDA(args.projectId, program.programId);
+  const remainingAccounts = (args.milestoneAccounts || []).map((pubkey) => ({
+    pubkey,
+    isSigner: false,
+    isWritable: false
+  }));
+  return getMethods(program).claimExitWindowRefund().accountsPartial({
+    project: projectPda,
+    investment: investmentPda,
+    nftMint: args.nftMint,
+    investorNftAccount: args.investorNftAccount,
+    escrowTokenAccount: args.escrowTokenAccount,
+    investorTokenAccount: args.investorTokenAccount,
+    escrowPda,
+    investor
+  }).remainingAccounts(remainingAccounts).rpc();
+}
+async function initializeFounderVesting(program, args, payer) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const tokenomicsPda = getTokenomicsPDA(projectPda, program.programId);
+  const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  const founderVestingPda = getFounderVestingPDA(projectPda, program.programId);
+  return getMethods(program).initializeFounderVesting().accounts({
+    project: projectPda,
+    tokenomics: tokenomicsPda,
+    tokenVault: tokenVaultPda,
+    founderVesting: founderVestingPda,
+    payer,
+    systemProgram: SystemProgram.programId
+  }).rpc();
+}
+async function claimVestedTokens(program, args, founder) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  const founderVestingPda = getFounderVestingPDA(projectPda, program.programId);
+  const founderVaultPda = getFounderVaultPDA(projectPda, program.programId);
+  const vaultAuthorityPda = getVaultAuthorityPDA(projectPda, program.programId);
+  return getMethods(program).claimVestedTokens().accounts({
+    project: projectPda,
+    tokenVault: tokenVaultPda,
+    founderVesting: founderVestingPda,
+    founderVault: founderVaultPda,
+    vaultAuthority: vaultAuthorityPda,
+    founderTokenAccount: args.founderTokenAccount,
+    founder,
+    tokenProgram: TOKEN_PROGRAM_ID
+  }).rpc();
+}
+async function forceCompleteDistribution(program, args, adminKeypair) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  const adminConfigPda = getAdminConfigPDA(program.programId);
+  return getMethods(program).forceCompleteDistribution().accounts({
+    admin: adminKeypair.publicKey,
+    adminConfig: adminConfigPda,
+    project: projectPda,
+    tokenVault: tokenVaultPda
+  }).signers([adminKeypair]).rpc();
+}
+async function claimMissedUnlock(program, args, claimer) {
+  const nftMintPubkey = ensurePublicKey(args.nftMint);
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  const investmentPda = getInvestmentPDA(projectPda, nftMintPubkey, program.programId);
+  const investorVaultPda = getInvestorVaultPDA(projectPda, program.programId);
+  const vaultAuthorityPda = getVaultAuthorityPDA(projectPda, program.programId);
+  const claimerNftAccount = getAssociatedTokenAddressSync(
+    nftMintPubkey,
+    claimer,
+    false,
+    TOKEN_PROGRAM_ID
+  );
+  return getMethods(program).claimMissedUnlock({ milestoneIndex: args.milestoneIndex }).accounts({
+    claimer,
+    project: projectPda,
+    tokenVault: tokenVaultPda,
+    investment: investmentPda,
+    nftMint: nftMintPubkey,
+    claimerNftAccount,
+    investorVault: investorVaultPda,
+    claimerTokenAccount: args.claimerTokenAccount,
+    vaultAuthority: vaultAuthorityPda,
+    tokenProgram: TOKEN_PROGRAM_ID
+  }).rpc();
+}
+
+// src/client.ts
+var RaiseClient = class _RaiseClient {
+  /**
+   * Create a new RaiseClient
+   *
+   * @param program - Anchor program instance
+   * @param provider - Anchor provider
+   */
+  constructor(program, provider) {
+    this.program = program;
+    this.provider = provider;
+  }
+  /**
+   * Load a new RaiseClient instance
+   *
+   * @param connection - Solana connection
+   * @param wallet - Wallet instance
+   * @param programId - Optional program ID override
+   * @returns Initialized RaiseClient
+   *
+   * @example
+   * ```typescript
+   * const client = RaiseClient.load(connection, wallet);
+   * ```
+   */
+  static load(_connection, _wallet, _programId) {
+    throw new Error(
+      "RaiseClient.load requires IDL. Use RaiseClient.fromProgram instead, or ensure the IDL is bundled with your application."
+    );
+  }
+  /**
+   * Create client from an existing program instance
+   *
+   * @param program - Anchor program instance
+   * @returns Initialized RaiseClient
+   *
+   * @example
+   * ```typescript
+   * import idl from './idl/raise.json';
+   *
+   * const provider = new AnchorProvider(connection, wallet, {});
+   * const program = new Program(idl, provider);
+   * const client = RaiseClient.fromProgram(program);
+   * ```
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromProgram(program) {
+    const provider = program.provider;
+    return new _RaiseClient(program, provider);
+  }
+  /**
+   * Get the program ID
+   */
+  get programId() {
+    return this.program.programId;
+  }
+  /**
+   * Get the connected wallet public key
+   */
+  get walletPublicKey() {
+    return this.provider.wallet.publicKey;
+  }
+  // ===========================================================================
+  // PDA Helpers
+  // ===========================================================================
+  getProjectPDA(projectId) {
+    return getProjectPDA(projectId, this.programId);
+  }
+  getEscrowPDA(projectId) {
+    return getEscrowPDA(projectId, this.programId);
+  }
+  getMilestonePDA(projectPda, milestoneIndex) {
+    return getMilestonePDA(projectPda, milestoneIndex, this.programId);
+  }
+  getInvestmentPDA(projectPda, nftMint) {
+    return getInvestmentPDA(projectPda, nftMint, this.programId);
+  }
+  getVotePDA(milestonePda, voterKey, votingRound) {
+    return getVotePDA(milestonePda, voterKey, votingRound, this.programId);
+  }
+  getPivotProposalPDA(projectPda, pivotCount) {
+    return getPivotProposalPDA(projectPda, pivotCount, this.programId);
+  }
+  getTgeEscrowPDA(projectPda) {
+    return getTgeEscrowPDA(projectPda, this.programId);
+  }
+  getTgeEscrowVaultPDA(projectPda) {
+    return getTgeEscrowVaultPDA(projectPda, this.programId);
+  }
+  getAdminConfigPDA() {
+    return getAdminConfigPDA(this.programId);
+  }
+  // ===========================================================================
+  // Account Fetchers
+  // ===========================================================================
+  async fetchProject(projectId) {
+    return fetchProject(this.program, projectId);
+  }
+  async fetchMilestone(projectId, milestoneIndex) {
+    return fetchMilestone(this.program, projectId, milestoneIndex);
+  }
+  async fetchAllMilestones(projectId) {
+    return fetchAllMilestones(this.program, projectId);
+  }
+  async fetchInvestment(projectId, nftMint) {
+    return fetchInvestment(this.program, projectId, nftMint);
+  }
+  async fetchAllInvestments(projectId) {
+    return fetchAllInvestments(this.program, projectId);
+  }
+  async fetchVote(projectId, milestoneIndex, voterKey, votingRound) {
+    return fetchVote(this.program, projectId, milestoneIndex, voterKey, votingRound);
+  }
+  async fetchAllVotes(projectId, milestoneIndex) {
+    return fetchAllVotes(this.program, projectId, milestoneIndex);
+  }
+  async fetchPivotProposal(projectId) {
+    return fetchPivotProposal(this.program, projectId);
+  }
+  async fetchTgeEscrow(projectId) {
+    return fetchTgeEscrow(this.program, projectId);
+  }
+  async fetchAdminConfig() {
+    return fetchAdminConfig(this.program);
+  }
+  // ===========================================================================
+  // Admin Instructions
+  // ===========================================================================
+  async initializeAdmin(admin) {
+    return initializeAdmin(
+      this.program,
+      admin,
+      this.walletPublicKey
+    );
+  }
+  async transferAdmin(newAdmin, adminKeypair) {
+    return transferAdmin(
+      this.program,
+      adminKeypair,
+      newAdmin
+    );
+  }
+  async acceptAdmin() {
+    return acceptAdmin(
+      this.program,
+      this.walletPublicKey
+    );
+  }
+  // ===========================================================================
+  // Project Instructions
+  // ===========================================================================
+  async initializeProject(args) {
+    return initializeProject(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  async submitForApproval(projectId) {
+    return submitForApproval(
+      this.program,
+      projectId,
+      this.walletPublicKey
+    );
+  }
+  async approveProject(args, adminKeypair) {
+    return approveProject(
+      this.program,
+      args,
+      adminKeypair
+    );
+  }
+  // ===========================================================================
+  // Milestone Instructions
+  // ===========================================================================
+  async createMilestone(args) {
+    return createMilestone(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  async submitMilestone(projectId, milestoneIndex) {
+    return submitMilestone(
+      this.program,
+      projectId,
+      milestoneIndex,
+      this.walletPublicKey
+    );
+  }
+  async voteOnMilestone(args) {
+    return voteOnMilestone(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  async finalizeVoting(projectId, milestoneIndex) {
+    return finalizeVoting(
+      this.program,
+      projectId,
+      milestoneIndex
+    );
+  }
+  /**
+   * Claim milestone funds (ZTM v2.0)
+   * - Regular milestones: Full payout to founder
+   * - Final milestone: LP USDC reserved for PCL, triggers MAE
+   *
+   * @param nextMilestoneDeadline - Deadline for next milestone (required for non-final milestones)
+   *   Set to BN(0) for final milestone claims (no next milestone exists)
+   */
+  async claimMilestoneFunds(args) {
+    return claimMilestoneFunds(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  /**
+   * Resubmit a failed milestone for rework (Failed → InProgress)
+   *
+   * Allows founders to iterate on failed milestones. Clears voting state
+   * for a fresh voting cycle. consecutive_failures is NOT reset.
+   */
+  async resubmitMilestone(args) {
+    return resubmitMilestone(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  /**
+   * Set milestone deadline for founder to commit submission date
+   *
+   * Founders must set deadlines for milestones to provide visibility to investors.
+   * Deadline must be at least 7 days from now and at most 1 year from now.
+   */
+  async setMilestoneDeadline(args) {
+    return setMilestoneDeadline(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  /**
+   * Extend milestone deadline (max 3 extensions per milestone)
+   *
+   * Founders can extend a deadline up to 3 times before it passes.
+   * Must be called BEFORE the current deadline passes.
+   */
+  async extendMilestoneDeadline(args) {
+    return extendMilestoneDeadline(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  // ===========================================================================
+  // Investment Instructions
+  // ===========================================================================
+  async invest(args) {
+    return invest(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  async cancelInvestment(args) {
+    return cancelInvestment(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  // ===========================================================================
+  // Pivot Instructions
+  // ===========================================================================
+  async proposePivot(args) {
+    return proposePivot(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  async approvePivot(projectId, adminKeypair) {
+    return approvePivot(
+      this.program,
+      projectId,
+      adminKeypair
+    );
+  }
+  async withdrawFromPivot(args) {
+    return withdrawFromPivot(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  async finalizePivot(args) {
+    return finalizePivot(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  // ===========================================================================
+  // TGE Instructions
+  // ===========================================================================
+  async setTgeDate(args) {
+    return setTgeDate(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  async depositTokens(args) {
+    return depositTokens(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  async claimTokens(args) {
+    return claimTokens(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  async reportScam(args) {
+    return reportScam(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  async releaseHoldback(args) {
+    return releaseHoldback(
+      this.program,
+      args
+    );
+  }
+  // ===========================================================================
+  // ZTM v2.0 Token Distribution Instructions
+  // ===========================================================================
+  /**
+   * Claim investor tokens from a passed milestone (whitepaper: manual claim model)
+   *
+   * ZTM v2.0: Per whitepaper, investors manually claim their tokens after a milestone passes.
+   * This replaces the batch distribution model with investor-initiated per-NFT claims.
+   */
+  async claimInvestorTokens(args) {
+    return claimInvestorTokens(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  /**
+   * Distribute tokens to NFT holders for a milestone
+   *
+   * ZTM v2.0: Called by cranker after finalize_voting sets distribution_pending = true.
+   * Processes batch of investments, transferring unlocked tokens to NFT holders.
+   * Max batch size: 10 investments per call.
+   *
+   * @deprecated Use claimInvestorTokens instead (whitepaper manual claim model)
+   */
+  async distributeTokens(args) {
+    return distributeTokens(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  /**
+   * Complete token distribution for a milestone
+   *
+   * ZTM v2.0: Marks distribution as complete after all batches have been processed.
+   * Permissionless - anyone can call this to finalize a distribution.
+   */
+  async completeDistribution(args) {
+    return completeDistribution(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  // ===========================================================================
+  // ZTM v2.0: Founder Vesting Instructions
+  // ===========================================================================
+  /**
+   * Initialize founder vesting after MAE (Market Access Event)
+   *
+   * ZTM v2.0: Creates FounderVesting PDA with vesting schedule from Tokenomics.
+   * Must be called after project reaches Completed state (all milestones done).
+   * Permissionless - anyone can pay to initialize.
+   */
+  async initializeFounderVesting(args) {
+    return initializeFounderVesting(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  /**
+   * Claim vested tokens from founder vault
+   *
+   * ZTM v2.0: Founder claims tokens based on linear vesting schedule.
+   * Requires cliff period to pass before any tokens can be claimed.
+   */
+  async claimVestedTokens(args) {
+    return claimVestedTokens(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  // ===========================================================================
+  // ZTM v2.0: Circuit Breaker Instructions
+  // ===========================================================================
+  /**
+   * Force complete a stuck distribution (admin only)
+   *
+   * ZTM v2.0: Circuit breaker for when token distribution is stuck for >7 days.
+   * Marks distribution as complete so project can continue.
+   * Affected investors can use claimMissedUnlock to get their tokens.
+   */
+  async forceCompleteDistribution(args, adminKeypair) {
+    return forceCompleteDistribution(
+      this.program,
+      args,
+      adminKeypair
+    );
+  }
+  /**
+   * Claim missed token unlock after force-complete distribution
+   *
+   * ZTM v2.0: Allows investors to claim tokens they missed during a stuck
+   * distribution that was force-completed by admin.
+   */
+  async claimMissedUnlock(args) {
+    return claimMissedUnlock(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  // ===========================================================================
+  // Abandonment Instructions
+  // ===========================================================================
+  async checkAbandonment(projectId, milestoneIndex = 0) {
+    return checkAbandonment(
+      this.program,
+      projectId,
+      milestoneIndex
+    );
+  }
+  async claimRefund(args) {
+    return claimRefund(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+};
+
+// src/types/index.ts
+var ProjectState = /* @__PURE__ */ ((ProjectState2) => {
+  ProjectState2["Draft"] = "draft";
+  ProjectState2["PendingApproval"] = "pendingApproval";
+  ProjectState2["Open"] = "open";
+  ProjectState2["Funded"] = "funded";
+  ProjectState2["InProgress"] = "inProgress";
+  ProjectState2["Completed"] = "completed";
+  ProjectState2["Abandoned"] = "abandoned";
+  ProjectState2["Failed"] = "failed";
+  ProjectState2["TGEFailed"] = "tgeFailed";
+  ProjectState2["Cancelled"] = "cancelled";
+  return ProjectState2;
+})(ProjectState || {});
+var MilestoneState = /* @__PURE__ */ ((MilestoneState2) => {
+  MilestoneState2["Proposed"] = "proposed";
+  MilestoneState2["Approved"] = "approved";
+  MilestoneState2["InProgress"] = "inProgress";
+  MilestoneState2["UnderReview"] = "underReview";
+  MilestoneState2["Passed"] = "passed";
+  MilestoneState2["Failed"] = "failed";
+  MilestoneState2["Unlocked"] = "unlocked";
+  return MilestoneState2;
+})(MilestoneState || {});
+var VoteChoice = /* @__PURE__ */ ((VoteChoice2) => {
+  VoteChoice2["Good"] = "good";
+  VoteChoice2["Bad"] = "bad";
+  return VoteChoice2;
+})(VoteChoice || {});
+var PivotState = /* @__PURE__ */ ((PivotState2) => {
+  PivotState2["PendingModeratorApproval"] = "pendingModeratorApproval";
+  PivotState2["ApprovedAwaitingInvestorWindow"] = "approvedAwaitingInvestorWindow";
+  PivotState2["Finalized"] = "finalized";
+  return PivotState2;
+})(PivotState || {});
+var ERROR_CODES = {
+  // State Transition Errors (6000-6099)
+  InvalidStateTransition: 6e3,
+  ProjectNotInOpenState: 6001,
+  ProjectNotInProgress: 6002,
+  MilestoneNotUnderReview: 6003,
+  VotingPeriodEnded: 6004,
+  VotingPeriodNotEnded: 6005,
+  MilestoneNotPassed: 6006,
+  MilestoneAlreadyUnlocked: 6007,
+  ProjectAlreadyFunded: 6008,
+  ProjectNotFunded: 6009,
+  // Authorization Errors (6100-6199)
+  UnauthorizedFounder: 6100,
+  UnauthorizedAdmin: 6101,
+  NotInvestor: 6102,
+  AlreadyVoted: 6103,
+  // Investment Errors (6200-6299)
+  InvestmentBelowMinimum: 6200,
+  FundingGoalExceeded: 6201,
+  InvalidTier: 6202,
+  CoolingOffPeriodActive: 6203,
+  CoolingOffPeriodExpired: 6204,
+  // Milestone Errors (6300-6399)
+  InvalidMilestoneIndex: 6300,
+  MilestonePercentageInvalid: 6301,
+  TotalPercentageExceeded: 6302,
+  MilestoneNotInProgress: 6303,
+  MilestoneNotApproved: 6304,
+  // TGE Errors (6400-6499)
+  TgeDateNotSet: 6400,
+  TgeDateAlreadySet: 6401,
+  TgeDateTooSoon: 6402,
+  TgeDateTooLate: 6403,
+  TgeNotReached: 6404,
+  TokensAlreadyClaimed: 6405,
+  InsufficientTokensDeposited: 6406,
+  // Pivot Errors (6500-6599)
+  PivotAlreadyProposed: 6500,
+  NoPivotProposed: 6501,
+  PivotNotApproved: 6502,
+  PivotWindowNotEnded: 6503,
+  PivotWindowEnded: 6504,
+  AlreadyWithdrawnFromPivot: 6505,
+  // Refund Errors (6800-6899)
+  RefundAlreadyClaimed: 6800,
+  RefundNotAvailable: 6801,
+  ProjectNotAbandoned: 6802,
+  // Scam Errors (6900-6999)
+  ScamReportPeriodEnded: 6900,
+  ScamAlreadyReported: 6901,
+  ScamNotConfirmed: 6902,
+  HoldbackAlreadyReleased: 6903,
+  HoldbackPeriodNotEnded: 6904
+};
+var ERROR_MESSAGES = {
+  // State Transition Errors
+  [ERROR_CODES.InvalidStateTransition]: "Invalid project state transition",
+  [ERROR_CODES.ProjectNotInOpenState]: "Project must be in Open state to accept investments",
+  [ERROR_CODES.ProjectNotInProgress]: "Project must be InProgress to perform this action",
+  [ERROR_CODES.MilestoneNotUnderReview]: "Milestone must be under review to vote",
+  [ERROR_CODES.VotingPeriodEnded]: "Voting period has ended",
+  [ERROR_CODES.VotingPeriodNotEnded]: "Voting period has not ended yet",
+  [ERROR_CODES.MilestoneNotPassed]: "Milestone did not pass voting",
+  [ERROR_CODES.MilestoneAlreadyUnlocked]: "Milestone funds already unlocked",
+  [ERROR_CODES.ProjectAlreadyFunded]: "Project has already reached funding goal",
+  [ERROR_CODES.ProjectNotFunded]: "Project has not reached funding goal",
+  // Authorization Errors
+  [ERROR_CODES.UnauthorizedFounder]: "Only the project founder can perform this action",
+  [ERROR_CODES.UnauthorizedAdmin]: "Only the admin can perform this action",
+  [ERROR_CODES.NotInvestor]: "You must be an investor to perform this action",
+  [ERROR_CODES.AlreadyVoted]: "You have already voted on this",
+  // Investment Errors
+  [ERROR_CODES.InvestmentBelowMinimum]: "Investment amount below minimum tier requirement",
+  [ERROR_CODES.FundingGoalExceeded]: "Investment would exceed funding goal",
+  [ERROR_CODES.InvalidTier]: "Invalid investment tier",
+  [ERROR_CODES.CoolingOffPeriodActive]: "Investment is within 24-hour cooling-off period",
+  [ERROR_CODES.CoolingOffPeriodExpired]: "Cooling-off period has expired, cannot cancel",
+  // Milestone Errors
+  [ERROR_CODES.InvalidMilestoneIndex]: "Invalid milestone index",
+  [ERROR_CODES.MilestonePercentageInvalid]: "Milestone percentage must be between 1-100",
+  [ERROR_CODES.TotalPercentageExceeded]: "Total milestone percentages exceed 100%",
+  [ERROR_CODES.MilestoneNotInProgress]: "Milestone must be in progress",
+  [ERROR_CODES.MilestoneNotApproved]: "Milestone must be approved first",
+  // TGE Errors
+  [ERROR_CODES.TgeDateNotSet]: "TGE date has not been set",
+  [ERROR_CODES.TgeDateAlreadySet]: "TGE date has already been set",
+  [ERROR_CODES.TgeDateTooSoon]: "TGE date must be at least 15 days in the future",
+  [ERROR_CODES.TgeDateTooLate]: "TGE date must be within 90 days",
+  [ERROR_CODES.TgeNotReached]: "TGE date has not been reached",
+  [ERROR_CODES.TokensAlreadyClaimed]: "Tokens have already been claimed",
+  [ERROR_CODES.InsufficientTokensDeposited]: "Insufficient tokens deposited by founder",
+  // Pivot Errors
+  [ERROR_CODES.PivotAlreadyProposed]: "A pivot is already pending",
+  [ERROR_CODES.NoPivotProposed]: "No pivot has been proposed",
+  [ERROR_CODES.PivotNotApproved]: "Pivot has not been approved by admin",
+  [ERROR_CODES.PivotWindowNotEnded]: "7-day withdrawal window has not ended",
+  [ERROR_CODES.PivotWindowEnded]: "7-day withdrawal window has ended",
+  [ERROR_CODES.AlreadyWithdrawnFromPivot]: "Already withdrawn from this pivot",
+  // Refund Errors
+  [ERROR_CODES.RefundAlreadyClaimed]: "Refund has already been claimed",
+  [ERROR_CODES.RefundNotAvailable]: "Refund is not available",
+  [ERROR_CODES.ProjectNotAbandoned]: "Project has not been abandoned",
+  // Scam Errors
+  [ERROR_CODES.ScamReportPeriodEnded]: "30-day scam report period has ended",
+  [ERROR_CODES.ScamAlreadyReported]: "Already reported this project for scam",
+  [ERROR_CODES.ScamNotConfirmed]: "Scam has not been confirmed",
+  [ERROR_CODES.HoldbackAlreadyReleased]: "Holdback has already been released",
+  [ERROR_CODES.HoldbackPeriodNotEnded]: "30-day holdback period has not ended"
+};
+var RaiseError = class _RaiseError extends Error {
+  constructor(code, message, logs) {
+    super(message);
+    this.code = code;
+    this.logs = logs;
+    this.name = "RaiseError";
+  }
+  /**
+   * Create from an Anchor error
+   */
+  static fromAnchorError(error) {
+    const code = error.error.errorCode.number;
+    const message = ERROR_MESSAGES[code] || error.error.errorMessage;
+    return new _RaiseError(code, message, error.logs);
+  }
+  /**
+   * Check if this is a specific error type
+   */
+  is(errorCode) {
+    return this.code === errorCode;
+  }
+};
+function parseError(error) {
+  if (error instanceof AnchorError) {
+    return RaiseError.fromAnchorError(error);
+  }
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(String(error));
+}
+function isRaiseError(error, code) {
+  if (!(error instanceof RaiseError)) {
+    return false;
+  }
+  if (code !== void 0) {
+    return error.code === code;
+  }
+  return true;
+}
+function getErrorMessage(error) {
+  if (error instanceof RaiseError) {
+    return error.message;
+  }
+  if (error instanceof AnchorError) {
+    const code = error.error.errorCode.number;
+    return ERROR_MESSAGES[code] || error.error.errorMessage;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "An unknown error occurred";
+}
+
+// src/events/index.ts
+var EVENT_NAMES = {
+  ProjectCreated: "ProjectCreated",
+  ProjectApproved: "ProjectApproved",
+  ProjectFunded: "ProjectFunded",
+  InvestmentMade: "InvestmentMade",
+  InvestmentCancelled: "InvestmentCancelled",
+  MilestoneCreated: "MilestoneCreated",
+  MilestoneSubmitted: "MilestoneSubmitted",
+  VoteCast: "VoteCast",
+  MilestoneVoteFinalized: "MilestoneVoteFinalized",
+  FundsUnlocked: "FundsUnlocked",
+  TgeDateSet: "TgeDateSet",
+  TokensDeposited: "TokensDeposited",
+  TokensClaimed: "TokensClaimed",
+  RefundClaimed: "RefundClaimed",
+  PivotProposed: "PivotProposed",
+  PivotApproved: "PivotApproved",
+  PivotFinalized: "PivotFinalized",
+  MilestoneReworked: "MilestoneReworked"
+};
+function filterEventsByName(events, name) {
+  return events.filter((e) => e.name === name);
+}
+function findEvent(events, name) {
+  return events.find((e) => e.name === name);
+}
+async function confirmTransaction(connection, signature, commitment = "confirmed") {
+  const latestBlockhash = await connection.getLatestBlockhash();
+  return connection.confirmTransaction(
+    {
+      signature,
+      blockhash: latestBlockhash.blockhash,
+      lastValidBlockHeight: latestBlockhash.lastValidBlockHeight
+    },
+    commitment
+  );
+}
+async function getTransactionWithRetry(connection, signature, maxRetries = 3) {
+  for (let i = 0; i < maxRetries; i++) {
+    const tx = await connection.getTransaction(signature, {
+      maxSupportedTransactionVersion: 0
+    });
+    if (tx) {
+      return tx;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1e3 * (i + 1)));
+  }
+  throw new Error(`Transaction ${signature} not found after ${maxRetries} retries`);
+}
+function bnToNumber(bn) {
+  const num = bn.toNumber();
+  if (!Number.isSafeInteger(num)) {
+    throw new Error(`BN value ${bn.toString()} is too large to convert to number`);
+  }
+  return num;
+}
+function bnToBigInt(bn) {
+  return BigInt(bn.toString());
+}
+function bigIntToBN(value) {
+  return new BN(value.toString());
+}
+function getCurrentTimestamp() {
+  return Math.floor(Date.now() / 1e3);
+}
+function timestampToDate(timestamp) {
+  const ts = typeof timestamp === "number" ? timestamp : timestamp.toNumber();
+  return new Date(ts * 1e3);
+}
+function hasTimestampPassed(timestamp) {
+  const ts = typeof timestamp === "number" ? timestamp : timestamp.toNumber();
+  return getCurrentTimestamp() > ts;
+}
+function timeRemaining(timestamp) {
+  const ts = typeof timestamp === "number" ? timestamp : timestamp.toNumber();
+  const remaining = ts - getCurrentTimestamp();
+  return remaining > 0 ? remaining : 0;
+}
+function formatDuration(seconds) {
+  if (seconds <= 0) return "0s";
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor(seconds % 86400 / 3600);
+  const minutes = Math.floor(seconds % 3600 / 60);
+  const secs = seconds % 60;
+  const parts = [];
+  if (days > 0) parts.push(`${days}d`);
+  if (hours > 0) parts.push(`${hours}h`);
+  if (minutes > 0) parts.push(`${minutes}m`);
+  if (secs > 0 && days === 0) parts.push(`${secs}s`);
+  return parts.join(" ") || "0s";
+}
+function bpsToPercent(bps) {
+  return bps / 1e4;
+}
+function percentToBps(percent) {
+  return Math.floor(percent * 1e4);
+}
+function percentageOf(amount, percentage) {
+  return amount * BigInt(Math.floor(percentage * 100)) / 10000n;
+}
+function validateMilestonePercentages(percentages) {
+  const sum = percentages.reduce((acc, p) => acc + p, 0);
+  return sum === 100;
+}
+function validateMetadataUri(uri, maxLength = 200) {
+  if (uri.length > maxLength) return false;
+  try {
+    new URL(uri);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isValidPublicKey(pubkey) {
+  try {
+    if (typeof pubkey === "string") {
+      new PublicKey(pubkey);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function shortenPublicKey(pubkey, chars = 4) {
+  const str = pubkey.toString();
+  if (str.length <= chars * 2 + 3) return str;
+  return `${str.slice(0, chars)}...${str.slice(-chars)}`;
+}
+
+export { ERROR_CODES, ERROR_MESSAGES, EVENT_NAMES, GOVERNANCE, InvestmentTier, MAX_DEADLINE_DURATION_SECONDS, MIN_DEADLINE_DURATION_SECONDS_DEV, MIN_DEADLINE_DURATION_SECONDS_PROD, MilestoneState, NFT, PivotState, ProjectState, RaiseClient, RaiseError, SEEDS, TIER_CONSTRAINTS, TIER_MINIMUMS, TIER_TOKEN_MULTIPLIERS, TIER_VOTE_MULTIPLIERS, TIMING, USDC, VALIDATION, VoteChoice, acceptAdmin, accountExists, approvePivot, approveProject, bigIntToBN, bnToBigInt, bnToNumber, bpsToPercent, calculateDeadline, cancelInvestment, checkAbandonment, claimExitWindowRefund, claimInvestorTokens, claimMilestoneFunds, claimMissedUnlock, claimRefund, claimTokens, claimVestedTokens, completeDistribution, confirmTransaction, createMilestone, depositTokens, distributeTokens, extendMilestoneDeadline, fetchAdminConfig, fetchAllInvestments, fetchAllMilestones, fetchAllVotes, fetchInvestment, fetchMilestone, fetchPivotProposal, fetchProject, fetchProjectByPda, fetchTgeEscrow, fetchVote, filterEventsByName, finalizePivot, finalizeVoting, findEvent, findTierIndex, forceCompleteDistribution, formatDuration, getAdminConfigPDA, getCurrentTimestamp, getErrorMessage, getEscrowPDA, getFounderVaultPDA, getFounderVestingPDA, getInvestmentPDA, getInvestorVaultPDA, getLpTokenVaultPDA, getLpUsdcVaultPDA, getMilestonePDA, getNftMintPDA, getPivotProposalPDA, getProgramAuthorityPDA, getProjectPDA, getProjectPDAs, getScamReportPDA, getTgeEscrowPDA, getTierFromAmount, getTokenMintPDA, getTokenMultiplier, getTokenVaultPDA, getTokenomicsPDA, getTransactionWithRetry, getTreasuryVaultPDA, getVaultAuthorityPDA, getVoteMultiplier, getVotePDA, hasTimestampPassed, initializeAdmin, initializeFounderVesting, initializeProject, invest, isRaiseError, isValidPublicKey, minDeadline, parseError, percentToBps, percentageOf, proposePivot, releaseHoldback, reportScam, resubmitMilestone, setMilestoneDeadline, setTgeDate, shortenPublicKey, submitForApproval, submitMilestone, symbolToBytes, timeRemaining, timestampToDate, transferAdmin, validateDeadline, validateMetadataUri, validateMilestonePercentages, voteOnMilestone, withdrawFromPivot };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map