@zemyth/raise-sdk 0.1.1 → 0.1.3

package/dist/index.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
-var web3_js = require('@solana/web3.js');
 var anchor = require('@coral-xyz/anchor');
+var web3_js = require('@solana/web3.js');
 var splToken = require('@solana/spl-token');
 
-// src/pdas/index.ts
+// src/client.ts
 
 // src/constants/index.ts
 var SEEDS = {
@@ -20,7 +20,13 @@ var SEEDS = {
   SCAM_REPORT: "scam_report",
   ADMIN_CONFIG: "admin-config",
   NFT_MINT: "nft_mint",
-  AUTHORITY: "authority"
+  AUTHORITY: "authority",
+  FUTURE_ROUND_VAULT: "future_round_vault",
+  FUTURE_ROUND_STATE: "future_round_state",
+  // Multi-Round Fundraising seeds
+  FUNDING_ROUND: "funding_round",
+  ROUND_ESCROW: "round_escrow",
+  INVESTOR_MS_VESTING: "investor_ms_vesting"
 };
 var VALIDATION = {
   /** Minimum number of milestones per project */
@@ -146,9 +152,9 @@ var GOVERNANCE = {
 };
 var NFT = {
   /** NFT symbol */
-  SYMBOL: "SNI",
+  SYMBOL: "ZRI",
   /** NFT name prefix */
-  NAME_PREFIX: "Raise Investment #",
+  NAME_PREFIX: "Zemyth Raise Investment #",
   /** Royalty basis points (2%) */
   ROYALTY_BASIS_POINTS: 200
 };
@@ -160,6 +166,26 @@ var USDC = {
   /** Convert lamports to USDC */
   fromAmount: (lamports) => Number(lamports) / 10 ** 6
 };
+var TOKENOMICS = {
+  /** Minimum investor allocation (20%) */
+  MIN_INVESTOR_ALLOCATION_BPS: 2e3,
+  /** Minimum founder allocation (5%) if > 0 */
+  MIN_FOUNDER_ALLOCATION_BPS: 500,
+  /** Minimum LP token allocation (5%) */
+  MIN_LP_TOKEN_ALLOCATION_BPS: 500,
+  /** Minimum LP USDC allocation (5%) */
+  MIN_LP_USDC_BPS: 500,
+  /** Minimum Zemyth allocation (1%) */
+  MIN_ZEMYTH_ALLOCATION_BPS: 100,
+  /** Default Zemyth allocation (1%) */
+  DEFAULT_ZEMYTH_ALLOCATION_BPS: 100,
+  /** Minimum future round allocation (10%) if > 0 */
+  MIN_FUTURE_ROUND_ALLOCATION_BPS: 1e3,
+  /** Maximum token symbol length */
+  MAX_TOKEN_SYMBOL_LEN: 8,
+  /** Total allocation must sum to this (100% = 10000 bps) */
+  TOTAL_ALLOCATION_BPS: 1e4
+};
 
 // src/pdas/index.ts
 function ensureBN(value) {
@@ -353,8 +379,149 @@ function getFounderVestingPDA(projectPda, programId) {
   );
   return pda;
 }
-
-// src/accounts/index.ts
+function getAllocationProposalPDA(projectPda, proposalIndex, programId) {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("allocation_proposal"),
+      projectPda.toBuffer(),
+      Buffer.from([proposalIndex])
+    ],
+    programId
+  );
+  return pda;
+}
+function getAllocationVotePDA(proposalPda, nftMint, programId) {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("allocation_vote"),
+      proposalPda.toBuffer(),
+      nftMint.toBuffer()
+    ],
+    programId
+  );
+  return pda;
+}
+function getSubAllocationVestingPDA(projectPda, subAllocationId, programId) {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("sub_allocation_vesting"),
+      projectPda.toBuffer(),
+      Buffer.from([subAllocationId])
+    ],
+    programId
+  );
+  return pda;
+}
+function getInvestorMilestoneVestingPDA(projectPda, milestoneIndex, investmentPda, programId) {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("investor_ms_vesting"),
+      projectPda.toBuffer(),
+      Buffer.from([milestoneIndex]),
+      investmentPda.toBuffer()
+    ],
+    programId
+  );
+  return pda;
+}
+function getFounderMilestoneVestingPDA(projectPda, milestoneIndex, programId) {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("founder_ms_vesting"),
+      projectPda.toBuffer(),
+      Buffer.from([milestoneIndex])
+    ],
+    programId
+  );
+  return pda;
+}
+function getFutureRoundTokenVaultPDA(projectPda, programId) {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from(SEEDS.FUTURE_ROUND_VAULT), projectPda.toBuffer()],
+    programId
+  );
+  return pda;
+}
+function getFutureRoundVaultPDA(projectPda, programId) {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from(SEEDS.FUTURE_ROUND_STATE), projectPda.toBuffer()],
+    programId
+  );
+  return pda;
+}
+function getFundingRoundPDA(projectPda, roundNumber, programId) {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [
+      Buffer.from(SEEDS.FUNDING_ROUND),
+      projectPda.toBuffer(),
+      Buffer.from([roundNumber])
+    ],
+    programId
+  );
+  return pda;
+}
+function getRoundEscrowPDA(projectPda, roundNumber, programId) {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [
+      Buffer.from(SEEDS.ROUND_ESCROW),
+      projectPda.toBuffer(),
+      Buffer.from([roundNumber])
+    ],
+    programId
+  );
+  return pda;
+}
+function getRoundMilestonePDA(projectPda, roundNumber, milestoneIndex, programId) {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [
+      Buffer.from(SEEDS.MILESTONE),
+      projectPda.toBuffer(),
+      Buffer.from([roundNumber]),
+      Buffer.from([milestoneIndex])
+    ],
+    programId
+  );
+  return pda;
+}
+function getRoundNftMintPDA(projectId, roundNumber, investor, investmentCount, programId) {
+  const projectIdBN = ensureBN(projectId);
+  const countBN = ensureBN(investmentCount);
+  return web3_js.PublicKey.findProgramAddressSync(
+    [
+      Buffer.from(SEEDS.NFT_MINT),
+      projectIdBN.toArrayLike(Buffer, "le", 8),
+      Buffer.from([roundNumber]),
+      investor.toBuffer(),
+      countBN.toArrayLike(Buffer, "le", 8)
+    ],
+    programId
+  );
+}
+function getRoundInvestmentPDA(projectPda, roundNumber, nftMint, programId) {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [
+      Buffer.from(SEEDS.INVESTMENT),
+      projectPda.toBuffer(),
+      Buffer.from([roundNumber]),
+      nftMint.toBuffer()
+    ],
+    programId
+  );
+  return pda;
+}
+function getRoundInvestorMilestoneVestingPDA(projectPda, roundNumber, milestoneIndex, investmentPda, programId) {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [
+      Buffer.from(SEEDS.INVESTOR_MS_VESTING),
+      projectPda.toBuffer(),
+      Buffer.from([roundNumber]),
+      Buffer.from([milestoneIndex]),
+      investmentPda.toBuffer()
+    ],
+    programId
+  );
+  return pda;
+}
 function getAccountNamespace(program) {
   return program.account;
 }
@@ -500,6 +667,18 @@ async function fetchAdminConfig(program) {
   const adminConfigPda = getAdminConfigPDA(program.programId);
   return await getAccountNamespace(program).adminConfig.fetch(adminConfigPda);
 }
+async function fetchTokenVault(program, projectId) {
+  try {
+    const projectPda = getProjectPDA(projectId, program.programId);
+    const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+    return await getAccountNamespace(program).tokenVault.fetch(tokenVaultPda);
+  } catch (error) {
+    if (error instanceof Error && error.message?.includes("Account does not exist")) {
+      return null;
+    }
+    throw error;
+  }
+}
 async function accountExists(program, accountType, pda) {
   try {
     await program.account[accountType].fetch(pda);
@@ -508,107 +687,468 @@ async function accountExists(program, accountType, pda) {
     return false;
   }
 }
-var TOKEN_METADATA_PROGRAM_ID = new web3_js.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
-function ensurePublicKey(value) {
-  if (value instanceof web3_js.PublicKey) {
-    return value;
+async function fetchTokenomics(program, projectId) {
+  try {
+    const projectPda = getProjectPDA(projectId, program.programId);
+    const tokenomicsPda = getTokenomicsPDA(projectPda, program.programId);
+    return await getAccountNamespace(program).tokenomics.fetch(tokenomicsPda);
+  } catch (error) {
+    if (error instanceof Error && error.message?.includes("Account does not exist")) {
+      return null;
+    }
+    throw error;
   }
-  return new web3_js.PublicKey(String(value));
-}
-function getMethods(program) {
-  return program.methods;
 }
-function getAccountNamespace2(program) {
-  return program.account;
+async function fetchAllocationProposal(program, projectId, proposalIndex) {
+  try {
+    const projectPda = getProjectPDA(projectId, program.programId);
+    const proposalPda = getAllocationProposalPDA(projectPda, proposalIndex, program.programId);
+    return await getAccountNamespace(program).allocationProposal.fetch(proposalPda);
+  } catch (error) {
+    if (error instanceof Error && error.message?.includes("Account does not exist")) {
+      return null;
+    }
+    throw error;
+  }
 }
-async function initializeAdmin(program, admin, payer) {
-  return getMethods(program).initializeAdmin().accounts({
-    admin,
-    payer
-  }).rpc();
+async function fetchAllAllocationProposals(program, projectId) {
+  const projectPda = getProjectPDA(projectId, program.programId);
+  const proposals = await getAccountNamespace(program).allocationProposal.all([
+    {
+      memcmp: {
+        offset: 8,
+        // Skip discriminator
+        bytes: projectPda.toBase58()
+      }
+    }
+  ]);
+  return proposals.map((p) => ({
+    publicKey: p.publicKey,
+    account: p.account
+  }));
 }
-async function transferAdmin(program, adminKeypair, newAdmin) {
-  return getMethods(program).transferAdmin().accounts({
-    authority: adminKeypair.publicKey,
-    newAdmin
-  }).signers([adminKeypair]).rpc();
+async function fetchAllocationVote(program, projectId, proposalIndex, nftMint) {
+  try {
+    const projectPda = getProjectPDA(projectId, program.programId);
+    const proposalPda = getAllocationProposalPDA(projectPda, proposalIndex, program.programId);
+    const votePda = getAllocationVotePDA(proposalPda, nftMint, program.programId);
+    return await getAccountNamespace(program).allocationVote.fetch(votePda);
+  } catch (error) {
+    if (error instanceof Error && error.message?.includes("Account does not exist")) {
+      return null;
+    }
+    throw error;
+  }
 }
-async function acceptAdmin(program, newAuthority) {
-  return getMethods(program).acceptAdmin().accounts({
-    newAuthority
-  }).rpc();
+async function fetchSubAllocationVesting(program, projectId, subAllocationId) {
+  try {
+    const projectPda = getProjectPDA(projectId, program.programId);
+    const vestingPda = getSubAllocationVestingPDA(projectPda, subAllocationId, program.programId);
+    return await getAccountNamespace(program).subAllocationVesting.fetch(vestingPda);
+  } catch (error) {
+    if (error instanceof Error && error.message?.includes("Account does not exist")) {
+      return null;
+    }
+    throw error;
+  }
 }
-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);
+async function fetchInvestorMilestoneVesting(program, projectId, milestoneIndex, nftMint) {
+  try {
+    const projectPda = getProjectPDA(projectId, program.programId);
+    const investmentPda = getInvestmentPDA(projectPda, nftMint, program.programId);
+    const vestingPda = getInvestorMilestoneVestingPDA(projectPda, milestoneIndex, investmentPda, program.programId);
+    return await getAccountNamespace(program).investorMilestoneVesting.fetch(vestingPda);
+  } catch (error) {
+    if (error instanceof Error && error.message?.includes("Account does not exist")) {
+      return null;
+    }
+    throw error;
   }
-  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 anchor.BN(Math.min(deadlineSeconds, maxDeadline));
+async function fetchFounderMilestoneVesting(program, projectId, milestoneIndex) {
+  try {
+    const projectPda = getProjectPDA(projectId, program.programId);
+    const vestingPda = getFounderMilestoneVestingPDA(projectPda, milestoneIndex, program.programId);
+    return await getAccountNamespace(program).founderMilestoneVesting.fetch(vestingPda);
+  } catch (error) {
+    if (error instanceof Error && error.message?.includes("Account does not exist")) {
+      return null;
+    }
+    throw error;
+  }
 }
-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 anchor.BN(nowSeconds + minDuration + 1);
+var EARLY_TOKEN_COOLING_PERIOD_SECONDS = 86400;
+var EARLY_TOKEN_COOLING_PERIOD_SECONDS_DEV = 10;
+var EARLY_TOKEN_RELEASE_BPS = 500;
+function canClaimEarlyTokens(investment, currentTimestamp, isDev = false) {
+  const now = currentTimestamp ?? Math.floor(Date.now() / 1e3);
+  const coolingPeriod = isDev ? EARLY_TOKEN_COOLING_PERIOD_SECONDS_DEV : EARLY_TOKEN_COOLING_PERIOD_SECONDS;
+  if (investment.earlyTokensClaimed) {
+    return { canClaim: false, reason: "Early tokens already claimed" };
+  }
+  if (investment.votingRightsActive === false) {
+    return { canClaim: false, reason: "Voting rights have been revoked" };
+  }
+  if (investment.withdrawnFromPivot === true) {
+    return { canClaim: false, reason: "Investment has been withdrawn from pivot" };
+  }
+  const investedAt = typeof investment.investedAt === "number" ? investment.investedAt : investment.investedAt.toNumber();
+  const coolingEndTime = investedAt + coolingPeriod;
+  if (now < coolingEndTime) {
+    const timeRemaining2 = coolingEndTime - now;
+    return {
+      canClaim: false,
+      reason: `Cooling period not expired. ${formatTimeRemaining(timeRemaining2)} remaining.`,
+      timeRemainingSeconds: timeRemaining2
+    };
+  }
+  return { canClaim: true };
 }
-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";
+function canClaimFounderEarlyTokens(project) {
+  if (project.founderEarlyTokensClaimed) {
+    return { canClaim: false, reason: "Founder early tokens already claimed" };
+  }
+  const stateStr = getProjectStateString(project.state);
+  const validStates = ["funded", "inProgress", "completed"];
+  if (!validStates.includes(stateStr)) {
     return {
-      valid: false,
-      error: `Deadline must be at least ${minDays} from now`
+      canClaim: false,
+      reason: `Project must be in Funded, InProgress, or Completed state. Current state: ${stateStr}`
     };
   }
-  if (deadlineSeconds > maxDeadline) {
+  return { canClaim: true };
+}
+function canClaimFounderMilestoneTokens(milestone) {
+  const stateStr = getMilestoneStateString(milestone.state);
+  if (stateStr !== "unlocked") {
     return {
-      valid: false,
-      error: "Deadline must be within 1 year from now"
+      canClaim: false,
+      reason: `Milestone must be in Unlocked state. Current state: ${stateStr}`
     };
   }
-  return { valid: true };
+  return { canClaim: 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,
+function requiresBurnForRefund(project, investment) {
+  const isFullRefund = project.cumulativePercentage === 0;
+  const requiresBurn = isFullRefund && investment.earlyTokensClaimed;
+  if (!requiresBurn) {
+    return { requiresBurn: false, burnAmount: 0 };
+  }
+  const burnAmount = typeof investment.earlyTokensAmount === "number" ? investment.earlyTokensAmount : investment.earlyTokensAmount.toNumber();
+  return { requiresBurn: true, burnAmount };
+}
+function calculateEarlyTokenAmount(tokensAllocated) {
+  const allocated = typeof tokensAllocated === "number" ? new anchor.BN(tokensAllocated) : tokensAllocated;
+  return allocated.muln(EARLY_TOKEN_RELEASE_BPS).divn(1e4);
+}
+function calculateRemainingAllocation(tokensAllocated) {
+  const allocated = typeof tokensAllocated === "number" ? new anchor.BN(tokensAllocated) : tokensAllocated;
+  const remainingBps = 1e4 - EARLY_TOKEN_RELEASE_BPS;
+  return allocated.muln(remainingBps).divn(1e4);
+}
+function formatTimeRemaining(seconds) {
+  if (seconds <= 0) return "0 seconds";
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor(seconds % 3600 / 60);
+  const secs = seconds % 60;
+  const parts = [];
+  if (hours > 0) parts.push(`${hours}h`);
+  if (minutes > 0) parts.push(`${minutes}m`);
+  if (secs > 0 && hours === 0) parts.push(`${secs}s`);
+  return parts.join(" ") || "0 seconds";
+}
+function getProjectStateString(state) {
+  if (typeof state === "object" && state !== null) {
+    const keys = Object.keys(state);
+    return keys[0]?.toLowerCase() ?? "unknown";
+  }
+  return "unknown";
+}
+function getMilestoneStateString(state) {
+  if (typeof state === "object" && state !== null) {
+    const keys = Object.keys(state);
+    return keys[0]?.toLowerCase() ?? "unknown";
+  }
+  return "unknown";
+}
+async function fetchFundingRound(program, projectId, roundNumber) {
+  try {
+    const projectPda = getProjectPDA(projectId, program.programId);
+    const fundingRoundPda = getFundingRoundPDA(projectPda, roundNumber, program.programId);
+    return await getAccountNamespace(program).fundingRound.fetch(fundingRoundPda);
+  } catch (error) {
+    if (error instanceof Error && error.message?.includes("Account does not exist")) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function fetchAllFundingRounds(program, projectId) {
+  const projectPda = getProjectPDA(projectId, program.programId);
+  const rounds = await getAccountNamespace(program).fundingRound.all([
+    {
+      memcmp: {
+        offset: 8,
+        // Skip discriminator
+        bytes: projectPda.toBase58()
+      }
+    }
+  ]);
+  return rounds.map((r) => ({
+    publicKey: r.publicKey,
+    account: r.account
+  }));
+}
+async function fetchRoundMilestone(program, projectId, roundNumber, milestoneIndex) {
+  try {
+    const projectPda = getProjectPDA(projectId, program.programId);
+    const milestonePda = getRoundMilestonePDA(projectPda, roundNumber, 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 fetchRoundInvestment(program, projectId, roundNumber, nftMint) {
+  try {
+    const projectPda = getProjectPDA(projectId, program.programId);
+    const investmentPda = getRoundInvestmentPDA(projectPda, roundNumber, 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 fetchRoundInvestorMilestoneVesting(program, projectId, roundNumber, milestoneIndex, nftMint) {
+  try {
+    const projectPda = getProjectPDA(projectId, program.programId);
+    const investmentPda = getRoundInvestmentPDA(projectPda, roundNumber, nftMint, program.programId);
+    const vestingPda = getRoundInvestorMilestoneVestingPDA(
+      projectPda,
+      roundNumber,
+      milestoneIndex,
+      investmentPda,
+      program.programId
+    );
+    return await getAccountNamespace(program).investorMilestoneVesting.fetch(vestingPda);
+  } catch (error) {
+    if (error instanceof Error && error.message?.includes("Account does not exist")) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function fetchFutureRoundVault(program, projectId) {
+  try {
+    const projectPda = getProjectPDA(projectId, program.programId);
+    const vaultPda = getFutureRoundVaultPDA(projectPda, program.programId);
+    return await getAccountNamespace(program).futureRoundVault.fetch(vaultPda);
+  } catch (error) {
+    if (error instanceof Error && error.message?.includes("Account does not exist")) {
+      return null;
+    }
+    throw error;
+  }
+}
+function canClaimRoundEarlyTokens(investment, currentTimestamp, isDev = false) {
+  if (investment.roundNumber < 2) {
+    return { canClaim: false, reason: "R1 investments use claim_investor_early_tokens instruction" };
+  }
+  return canClaimEarlyTokens(investment, currentTimestamp, isDev);
+}
+function isR1FullyFunded(project) {
+  const raised = typeof project.totalRaised === "number" ? new anchor.BN(project.totalRaised) : project.totalRaised;
+  const goal = typeof project.fundingGoal === "number" ? new anchor.BN(project.fundingGoal) : project.fundingGoal;
+  return raised.gte(goal);
+}
+function isFundingRoundFullyFunded(fundingRound) {
+  const stateStr = getRoundStateString(fundingRound.state);
+  return ["funded", "inProgress", "inprogress", "completed"].includes(stateStr);
+}
+async function isRoundFullyFunded(program, projectId, roundNumber) {
+  if (roundNumber === 1) {
+    const project = await fetchProject(program, projectId);
+    if (!project) return false;
+    return isR1FullyFunded(project);
+  } else {
+    const fundingRound = await fetchFundingRound(program, projectId, roundNumber);
+    if (!fundingRound) return false;
+    return isFundingRoundFullyFunded(fundingRound);
+  }
+}
+async function canOpenNextRound(program, projectId) {
+  const project = await fetchProject(program, projectId);
+  if (!project) {
+    return { canOpen: false, reason: "Project not found" };
+  }
+  const projectState = getProjectStateString(project.state);
+  if (!["inProgress", "inprogress", "completed"].includes(projectState)) {
+    return {
+      canOpen: false,
+      reason: `Project must be in InProgress or Completed state. Current: ${projectState}`
+    };
+  }
+  if (projectState !== "completed" && project.milestonesPassed === 0) {
+    return {
+      canOpen: false,
+      reason: "At least one milestone must pass before opening next round"
+    };
+  }
+  if (project.activeRound !== 0) {
+    return {
+      canOpen: false,
+      reason: `Round ${project.activeRound} is already active`
+    };
+  }
+  const currentRound = project.roundCount;
+  const isCurrentFunded = await isRoundFullyFunded(program, projectId, currentRound);
+  if (!isCurrentFunded) {
+    return {
+      canOpen: false,
+      reason: `Current round ${currentRound} must be fully funded before opening next round`
+    };
+  }
+  const tokenomics = await fetchTokenomics(program, projectId);
+  if (!tokenomics) {
+    return { canOpen: false, reason: "Tokenomics not found" };
+  }
+  if (tokenomics.futureRoundAllocationBps === 0) {
+    return {
+      canOpen: false,
+      reason: "No future round allocation configured"
+    };
+  }
+  const remainingAllocation = tokenomics.futureRoundAllocationBps - (tokenomics.usedFutureRoundBps || 0);
+  if (remainingAllocation <= 0) {
+    return {
+      canOpen: false,
+      reason: "Future round allocation pool exhausted"
+    };
+  }
+  return {
+    canOpen: true,
+    nextRoundNumber: currentRound + 1
+  };
+}
+function getRemainingFutureRoundAllocation(tokenomics) {
+  return tokenomics.futureRoundAllocationBps - (tokenomics.usedFutureRoundBps || 0);
+}
+function getRoundStateString(state) {
+  if (typeof state === "object" && state !== null) {
+    const keys = Object.keys(state);
+    return keys[0]?.toLowerCase() ?? "unknown";
+  }
+  return "unknown";
+}
+var TOKEN_METADATA_PROGRAM_ID = new web3_js.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
+function ensurePublicKey(value) {
+  if (value instanceof web3_js.PublicKey) {
+    return value;
+  }
+  return new web3_js.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().accountsPartial({
+    admin,
+    payer
+  }).rpc();
+}
+async function transferAdmin(program, adminKeypair, newAdmin) {
+  return getMethods(program).transferAdmin().accountsPartial({
+    authority: adminKeypair.publicKey,
+    newAdmin
+  }).signers([adminKeypair]).rpc();
+}
+async function acceptAdmin(program, newAuthority) {
+  return getMethods(program).acceptAdmin().accountsPartial({
+    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 anchor.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 anchor.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,
+      zemythAllocationBps: args.tokenomics.zemythAllocationBps ?? null,
+      founderWallet: args.tokenomics.founderWallet ?? null,
       vestingDurationMonths: args.tokenomics.vestingDurationMonths ?? null,
-      cliffMonths: args.tokenomics.cliffMonths ?? null
+      cliffMonths: args.tokenomics.cliffMonths ?? null,
+      founderMilestoneVestingBps: args.tokenomics.founderMilestoneVestingBps ?? null,
+      founderTimeVestingBps: args.tokenomics.founderTimeVestingBps ?? null,
+      futureRoundAllocationBps: args.tokenomics.futureRoundAllocationBps ?? null
     },
-    milestone1Deadline: args.milestone1Deadline
-  }).accounts({
+    milestone1Deadline: args.milestone1Deadline,
+    priceMultipliers: args.priceMultipliers ?? null
+  }).accountsPartial({
     founder
   }).rpc();
 }
 async function submitForApproval(program, projectId, founder) {
   const projectPda = getProjectPDA(projectId, program.programId);
-  return getMethods(program).submitForApproval().accounts({
+  return getMethods(program).submitForApproval().accountsPartial({
     project: projectPda,
     founder
   }).rpc();
@@ -624,7 +1164,12 @@ async function approveProject(program, args, adminKeypair) {
   const lpTokenVaultPda = getLpTokenVaultPDA(projectPda, program.programId);
   const treasuryVaultPda = getTreasuryVaultPDA(projectPda, program.programId);
   const lpUsdcVaultPda = getLpUsdcVaultPDA(projectPda, program.programId);
-  return getMethods(program).approveProject().accounts({
+  const futureRoundTokenVaultPda = getFutureRoundTokenVaultPDA(projectPda, program.programId);
+  const futureRoundVaultPda = getFutureRoundVaultPDA(projectPda, program.programId);
+  const computeBudgetIx = web3_js.ComputeBudgetProgram.setComputeUnitLimit({
+    units: 4e5
+  });
+  return getMethods(program).approveProject().accountsPartial({
     project: projectPda,
     tokenomics: tokenomicsPda,
     tokenVault: tokenVaultPda,
@@ -635,10 +1180,12 @@ async function approveProject(program, args, adminKeypair) {
     lpTokenVault: lpTokenVaultPda,
     treasuryVault: treasuryVaultPda,
     lpUsdcVault: lpUsdcVaultPda,
+    futureRoundTokenVault: futureRoundTokenVaultPda,
+    futureRoundVault: futureRoundVaultPda,
     usdcMint: args.usdcMint,
     authority: adminKeypair.publicKey,
     payer: adminKeypair.publicKey
-  }).signers([adminKeypair]).rpc();
+  }).preInstructions([computeBudgetIx]).signers([adminKeypair]).rpc();
 }
 async function createMilestone(program, args, founder) {
   const projectPda = getProjectPDA(args.projectId, program.programId);
@@ -646,8 +1193,11 @@ async function createMilestone(program, args, founder) {
   return getMethods(program).createMilestone({
     milestoneIndex: args.milestoneIndex,
     percentage: args.percentage,
-    description: args.description
-  }).accounts({
+    description: args.description,
+    vestingDurationMonths: args.vestingDurationMonths ?? null,
+    cliffMonths: args.cliffMonths ?? null,
+    instantReleaseBps: args.instantReleaseBps ?? null
+  }).accountsPartial({
     project: projectPda,
     milestone: milestonePda,
     founder
@@ -656,7 +1206,7 @@ async function createMilestone(program, args, founder) {
 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({
+  return getMethods(program).submitMilestone().accountsPartial({
     project: projectPda,
     milestone: milestonePda,
     founder
@@ -677,7 +1227,7 @@ async function voteOnMilestone(program, args, voter) {
     // allowOwnerOffCurve
     splToken.TOKEN_PROGRAM_ID
   );
-  return getMethods(program).voteOnMilestone({ choice: args.choice }).accounts({
+  return getMethods(program).voteOnMilestone({ choice: args.choice }).accountsPartial({
     milestone: milestonePda,
     project: projectPda,
     investment: investmentPda,
@@ -690,7 +1240,7 @@ async function voteOnMilestone(program, args, voter) {
 async function finalizeVoting(program, projectId, milestoneIndex) {
   const projectPda = getProjectPDA(projectId, program.programId);
   const milestonePda = getMilestonePDA(projectPda, milestoneIndex, program.programId);
-  return getMethods(program).finalizeVoting().accounts({
+  return getMethods(program).finalizeVoting().accountsPartial({
     project: projectPda,
     milestone: milestonePda
   }).rpc();
@@ -703,7 +1253,7 @@ async function claimMilestoneFunds(program, args, founder) {
   const tokenomicsPda = getTokenomicsPDA(projectPda, program.programId);
   const lpUsdcVaultPda = getLpUsdcVaultPDA(projectPda, program.programId);
   const nextMilestonePda = args.nextMilestonePda ?? (args.nextMilestoneDeadline.gt(new anchor.BN(0)) ? getMilestonePDA(projectPda, args.milestoneIndex + 1, program.programId) : null);
-  return getMethods(program).claimMilestoneFunds({ nextMilestoneDeadline: args.nextMilestoneDeadline }).accounts({
+  return getMethods(program).claimMilestoneFunds({ nextMilestoneDeadline: args.nextMilestoneDeadline }).accountsPartial({
     milestone: milestonePda,
     project: projectPda,
     founder,
@@ -721,7 +1271,7 @@ async function claimMilestoneFunds(program, args, founder) {
 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({
+  return getMethods(program).resubmitMilestone().accountsPartial({
     project: projectPda,
     milestone: milestonePda,
     founder
@@ -733,7 +1283,7 @@ async function setMilestoneDeadline(program, args, founder) {
   return getMethods(program).setMilestoneDeadline({
     milestoneIndex: args.milestoneIndex,
     deadline: args.deadline
-  }).accounts({
+  }).accountsPartial({
     project: projectPda,
     milestone: milestonePda,
     founder
@@ -745,7 +1295,7 @@ async function extendMilestoneDeadline(program, args, founder) {
   return getMethods(program).extendMilestoneDeadline({
     milestoneIndex: args.milestoneIndex,
     newDeadline: args.newDeadline
-  }).accounts({
+  }).accountsPartial({
     project: projectPda,
     milestone: milestonePda,
     founder
@@ -783,7 +1333,7 @@ async function invest(program, args, investor) {
   const masterEdition = getMasterEditionPDA(nftMint);
   const [programAuthority] = getProgramAuthorityPDA(program.programId);
   const firstMilestonePda = getMilestonePDA(projectPda, 0, program.programId);
-  return getMethods(program).invest({ amount: args.amount }).accounts({
+  return getMethods(program).invest({ amount: args.amount }).accountsPartial({
     project: projectPda,
     firstMilestone: firstMilestonePda,
     nftMint,
@@ -810,7 +1360,7 @@ async function cancelInvestment(program, args, investor) {
   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({
+  return getMethods(program).cancelInvestment().accountsPartial({
     investor,
     project: projectPda,
     investment: investmentPda,
@@ -829,7 +1379,7 @@ async function proposePivot(program, args, founder) {
   return getMethods(program).proposePivot({
     newMetadataUri: args.newMetadataUri,
     newMilestones: args.newMilestones
-  }).accounts({
+  }).accountsPartial({
     project: projectPda,
     founder,
     pivotProposal: pivotProposalPda,
@@ -847,7 +1397,7 @@ async function approvePivot(program, projectId, adminKeypair) {
     const pivotCount = projectAccount.pivotCount || 0;
     pivotProposalPda = getPivotProposalPDA(projectPda, pivotCount, program.programId);
   }
-  return getMethods(program).approvePivot().accounts({
+  return getMethods(program).approvePivot().accountsPartial({
     moderator: adminKeypair.publicKey,
     project: projectPda,
     pivotProposal: pivotProposalPda
@@ -870,7 +1420,7 @@ async function withdrawFromPivot(program, args, investor) {
     isSigner: false,
     isWritable: false
   }));
-  return getMethods(program).withdrawFromPivot().accounts({
+  return getMethods(program).withdrawFromPivot().accountsPartial({
     investor,
     project: projectPda,
     pivotProposal: pivotProposalPda,
@@ -890,7 +1440,7 @@ async function finalizePivot(program, args, authority) {
     isSigner: false,
     isWritable: true
   }));
-  return getMethods(program).finalizePivot().accounts({
+  return getMethods(program).finalizePivot().accountsPartial({
     authority,
     project: projectPda,
     pivotProposal: pivotProposalPda
@@ -901,14 +1451,14 @@ async function setTgeDate(program, args, founder) {
   return getMethods(program).setTgeDate({
     tgeDate: args.tgeDate,
     tokenMint: args.tokenMint
-  }).accounts({
+  }).accountsPartial({
     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({
+  return getMethods(program).depositTokens({ amount: args.amount }).accountsPartial({
     project: projectPda,
     tokenMint: args.tokenMint,
     founderTokenAccount: args.founderTokenAccount,
@@ -919,7 +1469,7 @@ 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({
+  return getMethods(program).claimTokens().accountsPartial({
     investor,
     project: projectPda,
     investment: investmentPda,
@@ -934,7 +1484,7 @@ 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({
+  return getMethods(program).reportScam().accountsPartial({
     tgeEscrow: tgeEscrowPda,
     project: projectPda,
     investment: investmentPda,
@@ -945,7 +1495,7 @@ async function reportScam(program, args, reporter) {
 async function releaseHoldback(program, args) {
   const projectPda = getProjectPDA(args.projectId, program.programId);
   const tgeEscrowPda = getTgeEscrowPDA(projectPda, program.programId);
-  return getMethods(program).releaseHoldback().accounts({
+  return getMethods(program).releaseHoldback().accountsPartial({
     tgeEscrow: tgeEscrowPda,
     project: projectPda,
     founderTokenAccount: args.founderTokenAccount
@@ -954,7 +1504,7 @@ async function releaseHoldback(program, args) {
 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({
+  return getMethods(program).checkAbandonment().accountsPartial({
     project: projectPda,
     milestone: milestonePda
   }).rpc();
@@ -973,7 +1523,7 @@ async function claimRefund(program, args, investor) {
       isSigner: false
     });
   }
-  return getMethods(program).claimRefund().accounts({
+  return getMethods(program).claimRefund().accountsPartial({
     project: projectPda,
     investment: investmentPda,
     nftMint: nftMintPubkey,
@@ -996,7 +1546,7 @@ async function claimInvestorTokens(program, args, investor) {
     false,
     splToken.TOKEN_PROGRAM_ID
   );
-  return getMethods(program).claimInvestorTokens({ milestoneIndex: args.milestoneIndex }).accounts({
+  return getMethods(program).claimInvestorTokens({ milestoneIndex: args.milestoneIndex }).accountsPartial({
     investor,
     project: projectPda,
     tokenVault: tokenVaultPda,
@@ -1018,7 +1568,7 @@ async function distributeTokens(program, args, payer) {
     { pubkey: inv.investmentPda, isSigner: false, isWritable: true },
     { pubkey: inv.investorTokenAccount, isSigner: false, isWritable: true }
   ]);
-  return getMethods(program).distributeTokens({ milestoneIndex: args.milestoneIndex }).accounts({
+  return getMethods(program).distributeTokens({ milestoneIndex: args.milestoneIndex }).accountsPartial({
     project: projectPda,
     tokenVault: tokenVaultPda,
     investorVault: investorVaultPda,
@@ -1030,7 +1580,7 @@ async function distributeTokens(program, args, payer) {
 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({
+  return getMethods(program).completeDistribution({ milestoneIndex: args.milestoneIndex }).accountsPartial({
     project: projectPda,
     tokenVault: tokenVaultPda,
     payer
@@ -1061,7 +1611,7 @@ async function initializeFounderVesting(program, args, payer) {
   const tokenomicsPda = getTokenomicsPDA(projectPda, program.programId);
   const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
   const founderVestingPda = getFounderVestingPDA(projectPda, program.programId);
-  return getMethods(program).initializeFounderVesting().accounts({
+  return getMethods(program).initializeFounderVesting().accountsPartial({
     project: projectPda,
     tokenomics: tokenomicsPda,
     tokenVault: tokenVaultPda,
@@ -1076,7 +1626,7 @@ async function claimVestedTokens(program, args, founder) {
   const founderVestingPda = getFounderVestingPDA(projectPda, program.programId);
   const founderVaultPda = getFounderVaultPDA(projectPda, program.programId);
   const vaultAuthorityPda = getVaultAuthorityPDA(projectPda, program.programId);
-  return getMethods(program).claimVestedTokens().accounts({
+  return getMethods(program).claimVestedTokens().accountsPartial({
     project: projectPda,
     tokenVault: tokenVaultPda,
     founderVesting: founderVestingPda,
@@ -1091,7 +1641,7 @@ 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({
+  return getMethods(program).forceCompleteDistribution().accountsPartial({
     admin: adminKeypair.publicKey,
     adminConfig: adminConfigPda,
     project: projectPda,
@@ -1111,7 +1661,7 @@ async function claimMissedUnlock(program, args, claimer) {
     false,
     splToken.TOKEN_PROGRAM_ID
   );
-  return getMethods(program).claimMissedUnlock({ milestoneIndex: args.milestoneIndex }).accounts({
+  return getMethods(program).claimMissedUnlock({ milestoneIndex: args.milestoneIndex }).accountsPartial({
     claimer,
     project: projectPda,
     tokenVault: tokenVaultPda,
@@ -1124,70 +1674,627 @@ async function claimMissedUnlock(program, args, claimer) {
     tokenProgram: splToken.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;
-  }
-  // ===========================================================================
+async function addSubAllocation(program, args, founder) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const tokenomicsPda = getTokenomicsPDA(projectPda, program.programId);
+  return getMethods(program).addSubAllocation({
+    name: args.name,
+    bps: args.bps,
+    recipient: args.recipient,
+    vestingMonths: args.vestingMonths,
+    cliffMonths: args.cliffMonths
+  }).accountsPartial({
+    project: projectPda,
+    tokenomics: tokenomicsPda,
+    founder
+  }).rpc();
+}
+async function proposeAllocationChange(program, args, founder) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const tokenomicsPda = getTokenomicsPDA(projectPda, program.programId);
+  const tokenomics = await getAccountNamespace2(program).tokenomics.fetch(tokenomicsPda);
+  const proposalIndex = tokenomics.proposalCount || 0;
+  const proposalPda = getAllocationProposalPDA(projectPda, proposalIndex, program.programId);
+  return getMethods(program).proposeAllocationChange({
+    name: args.name,
+    bps: args.bps,
+    recipient: args.recipient,
+    vestingMonths: args.vestingMonths,
+    cliffMonths: args.cliffMonths
+  }).accountsPartial({
+    project: projectPda,
+    tokenomics: tokenomicsPda,
+    proposal: proposalPda,
+    founder,
+    systemProgram: web3_js.SystemProgram.programId
+  }).rpc();
+}
+async function voteAllocationChange(program, args, voter) {
+  const nftMintPubkey = ensurePublicKey(args.nftMint);
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const proposalPda = getAllocationProposalPDA(projectPda, args.proposalIndex, program.programId);
+  const investmentPda = getInvestmentPDA(projectPda, nftMintPubkey, program.programId);
+  const votePda = getAllocationVotePDA(proposalPda, nftMintPubkey, program.programId);
+  const investorNftAccount = splToken.getAssociatedTokenAddressSync(
+    nftMintPubkey,
+    voter,
+    false,
+    splToken.TOKEN_PROGRAM_ID
+  );
+  return getMethods(program).voteAllocationChange({ voteFor: args.voteFor }).accountsPartial({
+    project: projectPda,
+    proposal: proposalPda,
+    investment: investmentPda,
+    nftMint: nftMintPubkey,
+    investorNftAccount,
+    voteRecord: votePda,
+    voter,
+    systemProgram: web3_js.SystemProgram.programId
+  }).rpc();
+}
+async function executeAllocationChange(program, args, executor) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const tokenomicsPda = getTokenomicsPDA(projectPda, program.programId);
+  const proposalPda = getAllocationProposalPDA(projectPda, args.proposalIndex, program.programId);
+  return getMethods(program).executeAllocationChange().accountsPartial({
+    project: projectPda,
+    tokenomics: tokenomicsPda,
+    proposal: proposalPda,
+    executor
+  }).rpc();
+}
+async function claimEarlyTokens(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 = splToken.getAssociatedTokenAddressSync(
+    nftMintPubkey,
+    investor,
+    false,
+    splToken.TOKEN_PROGRAM_ID
+  );
+  return getMethods(program).claimEarlyTokens().accountsPartial({
+    investor,
+    project: projectPda,
+    tokenVault: tokenVaultPda,
+    investment: investmentPda,
+    nftMint: nftMintPubkey,
+    investorNftAccount,
+    investorVault: investorVaultPda,
+    investorTokenAccount: args.investorTokenAccount,
+    vaultAuthority: vaultAuthorityPda,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID
+  }).rpc();
+}
+async function claimFounderEarlyTokens(program, args, founder) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const tokenomicsPda = getTokenomicsPDA(projectPda, program.programId);
+  const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  const founderVaultPda = getFounderVaultPDA(projectPda, program.programId);
+  const vaultAuthorityPda = getVaultAuthorityPDA(projectPda, program.programId);
+  return getMethods(program).claimFounderEarlyTokens().accountsPartial({
+    founder,
+    project: projectPda,
+    tokenomics: tokenomicsPda,
+    tokenVault: tokenVaultPda,
+    founderVault: founderVaultPda,
+    founderTokenAccount: args.founderTokenAccount,
+    vaultAuthority: vaultAuthorityPda,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID
+  }).rpc();
+}
+async function claimFounderMilestoneTokens(program, args, founder) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const milestonePda = getMilestonePDA(projectPda, args.milestoneIndex, program.programId);
+  const tokenomicsPda = getTokenomicsPDA(projectPda, program.programId);
+  const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  const founderVaultPda = getFounderVaultPDA(projectPda, program.programId);
+  const vaultAuthorityPda = getVaultAuthorityPDA(projectPda, program.programId);
+  return getMethods(program).claimFounderMilestoneTokens({ milestoneIndex: args.milestoneIndex }).accountsPartial({
+    founder,
+    project: projectPda,
+    milestone: milestonePda,
+    tokenomics: tokenomicsPda,
+    tokenVault: tokenVaultPda,
+    founderVault: founderVaultPda,
+    founderTokenAccount: args.founderTokenAccount,
+    vaultAuthority: vaultAuthorityPda,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID
+  }).rpc();
+}
+async function initializeSubAllocationVesting(program, args, payer) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const tokenomicsPda = getTokenomicsPDA(projectPda, program.programId);
+  const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  const subAllocationVestingPda = getSubAllocationVestingPDA(projectPda, args.subAllocationId, program.programId);
+  return getMethods(program).initializeSubAllocationVesting({ subAllocationId: args.subAllocationId }).accountsPartial({
+    project: projectPda,
+    tokenomics: tokenomicsPda,
+    tokenVault: tokenVaultPda,
+    subAllocationVesting: subAllocationVestingPda,
+    payer,
+    systemProgram: web3_js.SystemProgram.programId
+  }).rpc();
+}
+async function claimSubAllocationTokens(program, args, recipient) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const tokenomicsPda = getTokenomicsPDA(projectPda, program.programId);
+  const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  const subAllocationVestingPda = getSubAllocationVestingPDA(projectPda, args.subAllocationId, program.programId);
+  const treasuryVaultPda = getTreasuryVaultPDA(projectPda, program.programId);
+  const vaultAuthorityPda = getVaultAuthorityPDA(projectPda, program.programId);
+  return getMethods(program).claimSubAllocationTokens({ subAllocationId: args.subAllocationId }).accountsPartial({
+    project: projectPda,
+    tokenomics: tokenomicsPda,
+    tokenVault: tokenVaultPda,
+    subAllocationVesting: subAllocationVestingPda,
+    reserveVault: treasuryVaultPda,
+    vaultAuthority: vaultAuthorityPda,
+    recipientTokenAccount: args.recipientTokenAccount,
+    recipient,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID
+  }).rpc();
+}
+async function claimMilestoneInstantTokens(program, args, investor) {
+  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 tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  const vestingPda = getInvestorMilestoneVestingPDA(projectPda, args.milestoneIndex, investmentPda, program.programId);
+  const investorVaultPda = getInvestorVaultPDA(projectPda, program.programId);
+  const vaultAuthorityPda = getVaultAuthorityPDA(projectPda, program.programId);
+  const investorNftAccount = splToken.getAssociatedTokenAddressSync(
+    nftMintPubkey,
+    investor,
+    false,
+    splToken.TOKEN_PROGRAM_ID
+  );
+  return getMethods(program).claimMilestoneInstantTokens({ milestoneIndex: args.milestoneIndex }).accountsPartial({
+    investor,
+    project: projectPda,
+    milestone: milestonePda,
+    investment: investmentPda,
+    tokenVault: tokenVaultPda,
+    vesting: vestingPda,
+    nftMint: nftMintPubkey,
+    investorNftAccount,
+    investorVault: investorVaultPda,
+    investorTokenAccount: args.investorTokenAccount,
+    vaultAuthority: vaultAuthorityPda,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID,
+    systemProgram: web3_js.SystemProgram.programId
+  }).rpc();
+}
+async function claimMilestoneVestedTokens(program, args, investor) {
+  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 tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  const vestingPda = getInvestorMilestoneVestingPDA(projectPda, args.milestoneIndex, investmentPda, program.programId);
+  const investorVaultPda = getInvestorVaultPDA(projectPda, program.programId);
+  const vaultAuthorityPda = getVaultAuthorityPDA(projectPda, program.programId);
+  const investorNftAccount = splToken.getAssociatedTokenAddressSync(
+    nftMintPubkey,
+    investor,
+    false,
+    splToken.TOKEN_PROGRAM_ID
+  );
+  return getMethods(program).claimMilestoneVestedTokens({ milestoneIndex: args.milestoneIndex }).accountsPartial({
+    investor,
+    project: projectPda,
+    milestone: milestonePda,
+    investment: investmentPda,
+    tokenVault: tokenVaultPda,
+    vesting: vestingPda,
+    nftMint: nftMintPubkey,
+    investorNftAccount,
+    investorVault: investorVaultPda,
+    investorTokenAccount: args.investorTokenAccount,
+    vaultAuthority: vaultAuthorityPda,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID
+  }).rpc();
+}
+async function claimFounderMsInstantTokens(program, args, founder) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const milestonePda = getMilestonePDA(projectPda, args.milestoneIndex, program.programId);
+  const tokenomicsPda = getTokenomicsPDA(projectPda, program.programId);
+  const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  const vestingPda = getFounderMilestoneVestingPDA(projectPda, args.milestoneIndex, program.programId);
+  const founderVaultPda = getFounderVaultPDA(projectPda, program.programId);
+  const vaultAuthorityPda = getVaultAuthorityPDA(projectPda, program.programId);
+  return getMethods(program).claimFounderMsInstantTokens({ milestoneIndex: args.milestoneIndex }).accountsPartial({
+    founder,
+    project: projectPda,
+    tokenomics: tokenomicsPda,
+    milestone: milestonePda,
+    tokenVault: tokenVaultPda,
+    vesting: vestingPda,
+    founderVault: founderVaultPda,
+    founderTokenAccount: args.founderTokenAccount,
+    vaultAuthority: vaultAuthorityPda,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID,
+    systemProgram: web3_js.SystemProgram.programId
+  }).rpc();
+}
+async function claimFounderMsVestedTokens(program, args, founder) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  const vestingPda = getFounderMilestoneVestingPDA(projectPda, args.milestoneIndex, program.programId);
+  const founderVaultPda = getFounderVaultPDA(projectPda, program.programId);
+  const vaultAuthorityPda = getVaultAuthorityPDA(projectPda, program.programId);
+  return getMethods(program).claimFounderMsVestedTokens({ milestoneIndex: args.milestoneIndex }).accountsPartial({
+    founder,
+    project: projectPda,
+    tokenVault: tokenVaultPda,
+    vesting: vestingPda,
+    founderVault: founderVaultPda,
+    founderTokenAccount: args.founderTokenAccount,
+    vaultAuthority: vaultAuthorityPda,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID
+  }).rpc();
+}
+function getRoundEscrowAuthorityPDA(projectPda, roundNumber, programId) {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("round_escrow"),
+      projectPda.toBuffer(),
+      Buffer.from([roundNumber]),
+      Buffer.from("authority")
+    ],
+    programId
+  );
+}
+async function openFundingRound(program, args, founder) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const tokenomicsPda = getTokenomicsPDA(projectPda, program.programId);
+  const project = await getAccountNamespace2(program).project.fetch(projectPda);
+  const newRoundNumber = (project.roundCount || 1) + 1;
+  const fundingRoundPda = getFundingRoundPDA(projectPda, newRoundNumber, program.programId);
+  const roundEscrowPda = getRoundEscrowPDA(projectPda, newRoundNumber, program.programId);
+  const [roundEscrowAuthorityPda] = getRoundEscrowAuthorityPDA(projectPda, newRoundNumber, program.programId);
+  const remainingAccounts = args.milestones.map((_, i) => {
+    const milestonePda = getRoundMilestonePDA(projectPda, newRoundNumber, i, program.programId);
+    return {
+      pubkey: milestonePda,
+      isSigner: false,
+      isWritable: true
+    };
+  });
+  const milestonesParam = args.milestones.map((m) => ({
+    percentage: m.percentage,
+    description: m.description,
+    vestingDurationMonths: m.vestingDurationMonths ?? null,
+    cliffMonths: m.cliffMonths ?? null,
+    instantReleaseBps: m.instantReleaseBps ?? null
+  }));
+  return getMethods(program).openFundingRound({
+    roundAllocationBps: args.roundAllocationBps,
+    fundingGoal: args.fundingGoal,
+    tiers: args.tiers,
+    milestones: milestonesParam
+  }).accountsPartial({
+    project: projectPda,
+    tokenomics: tokenomicsPda,
+    fundingRound: fundingRoundPda,
+    roundEscrow: roundEscrowPda,
+    roundEscrowAuthority: roundEscrowAuthorityPda,
+    usdcMint: args.usdcMint,
+    previousFundingRound: args.previousFundingRoundPda ?? null,
+    founder,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID,
+    systemProgram: web3_js.SystemProgram.programId,
+    rent: web3_js.SYSVAR_RENT_PUBKEY
+  }).remainingAccounts(remainingAccounts).rpc();
+}
+async function investInRound(program, args, investor) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const fundingRoundPda = getFundingRoundPDA(projectPda, args.roundNumber, program.programId);
+  const roundEscrowPda = getRoundEscrowPDA(projectPda, args.roundNumber, program.programId);
+  const firstRoundMilestonePda = getRoundMilestonePDA(projectPda, args.roundNumber, 0, program.programId);
+  const [nftMint] = getRoundNftMintPDA(args.projectId, args.roundNumber, investor, args.investmentCount, program.programId);
+  const investmentPda = getRoundInvestmentPDA(projectPda, args.roundNumber, nftMint, program.programId);
+  const investorNftAccount = splToken.getAssociatedTokenAddressSync(nftMint, investor);
+  const metadataAccount = getMetadataPDA(nftMint);
+  const masterEdition = getMasterEditionPDA(nftMint);
+  const [programAuthority] = getProgramAuthorityPDA(program.programId);
+  return getMethods(program).investInRound({ amount: args.amount }).accountsPartial({
+    project: projectPda,
+    fundingRound: fundingRoundPda,
+    firstRoundMilestone: firstRoundMilestonePda,
+    nftMint,
+    investment: investmentPda,
+    investorNftAccount,
+    metadataAccount,
+    masterEdition,
+    roundEscrow: roundEscrowPda,
+    investorTokenAccount: args.investorTokenAccount,
+    programAuthority,
+    investor,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID,
+    associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+    systemProgram: web3_js.SystemProgram.programId,
+    rent: web3_js.SYSVAR_RENT_PUBKEY,
+    tokenMetadataProgram: TOKEN_METADATA_PROGRAM_ID,
+    sysvarInstructions: web3_js.SYSVAR_INSTRUCTIONS_PUBKEY
+  }).preInstructions([
+    web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 4e5 })
+  ]).rpc();
+}
+async function cancelRoundInvestment(program, args, investor) {
+  const nftMintPubkey = ensurePublicKey(args.nftMint);
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const fundingRoundPda = getFundingRoundPDA(projectPda, args.roundNumber, program.programId);
+  const investmentPda = getRoundInvestmentPDA(projectPda, args.roundNumber, nftMintPubkey, program.programId);
+  const roundEscrowPda = getRoundEscrowPDA(projectPda, args.roundNumber, program.programId);
+  const [roundEscrowAuthorityPda] = getRoundEscrowAuthorityPDA(projectPda, args.roundNumber, program.programId);
+  return getMethods(program).cancelRoundInvestment().accountsPartial({
+    investor,
+    project: projectPda,
+    fundingRound: fundingRoundPda,
+    investment: investmentPda,
+    nftMint: nftMintPubkey,
+    investorNftAccount: args.investorNftAccount,
+    roundEscrow: roundEscrowPda,
+    roundEscrowAuthority: roundEscrowAuthorityPda,
+    investorUsdcAccount: args.investorUsdcAccount,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID
+  }).rpc();
+}
+async function submitRoundMilestone(program, args, founder) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const fundingRoundPda = getFundingRoundPDA(projectPda, args.roundNumber, program.programId);
+  const milestonePda = getRoundMilestonePDA(projectPda, args.roundNumber, args.milestoneIndex, program.programId);
+  return getMethods(program).submitRoundMilestone().accountsPartial({
+    founder,
+    project: projectPda,
+    fundingRound: fundingRoundPda,
+    milestone: milestonePda,
+    clock: web3_js.SYSVAR_CLOCK_PUBKEY
+  }).rpc();
+}
+async function voteOnRoundMilestone(program, args, voter) {
+  const nftMintPubkey = ensurePublicKey(args.nftMint);
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const fundingRoundPda = getFundingRoundPDA(projectPda, args.roundNumber, program.programId);
+  const milestonePda = getRoundMilestonePDA(projectPda, args.roundNumber, args.milestoneIndex, program.programId);
+  let investmentPda;
+  if (args.investmentRoundNumber === 1) {
+    investmentPda = getInvestmentPDA(projectPda, nftMintPubkey, program.programId);
+  } else {
+    investmentPda = getRoundInvestmentPDA(projectPda, args.investmentRoundNumber, 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 = splToken.getAssociatedTokenAddressSync(
+    nftMintPubkey,
+    voter,
+    false,
+    splToken.TOKEN_PROGRAM_ID
+  );
+  return getMethods(program).voteOnRoundMilestone({ choice: args.choice }).accountsPartial({
+    vote: votePda,
+    project: projectPda,
+    fundingRound: fundingRoundPda,
+    milestone: milestonePda,
+    investment: investmentPda,
+    nftMint: nftMintPubkey,
+    voterNftAccount,
+    voter,
+    systemProgram: web3_js.SystemProgram.programId
+  }).rpc();
+}
+async function finalizeRoundVoting(program, args) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const fundingRoundPda = getFundingRoundPDA(projectPda, args.roundNumber, program.programId);
+  const milestonePda = getRoundMilestonePDA(projectPda, args.roundNumber, args.milestoneIndex, program.programId);
+  return getMethods(program).finalizeRoundVoting().accountsPartial({
+    project: projectPda,
+    fundingRound: fundingRoundPda,
+    milestone: milestonePda,
+    clock: web3_js.SYSVAR_CLOCK_PUBKEY
+  }).rpc();
+}
+async function claimRoundMilestoneFunds(program, args, founder) {
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const fundingRoundPda = getFundingRoundPDA(projectPda, args.roundNumber, program.programId);
+  const milestonePda = getRoundMilestonePDA(projectPda, args.roundNumber, args.milestoneIndex, program.programId);
+  const roundEscrowPda = getRoundEscrowPDA(projectPda, args.roundNumber, program.programId);
+  const [roundEscrowAuthorityPda] = getRoundEscrowAuthorityPDA(projectPda, args.roundNumber, program.programId);
+  const nextMilestonePda = args.nextMilestoneDeadline.gt(new anchor.BN(0)) ? getRoundMilestonePDA(projectPda, args.roundNumber, args.milestoneIndex + 1, program.programId) : null;
+  return getMethods(program).claimRoundMilestoneFunds({ nextMilestoneDeadline: args.nextMilestoneDeadline }).accountsPartial({
+    project: projectPda,
+    fundingRound: fundingRoundPda,
+    milestone: milestonePda,
+    founder,
+    roundEscrow: roundEscrowPda,
+    roundEscrowAuthority: roundEscrowAuthorityPda,
+    founderUsdcAccount: args.founderUsdcAccount,
+    nextMilestone: nextMilestonePda,
+    systemProgram: web3_js.SystemProgram.programId,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID
+  }).rpc();
+}
+async function claimRoundInstantTokens(program, args, investor) {
+  const nftMintPubkey = ensurePublicKey(args.nftMint);
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const fundingRoundPda = getFundingRoundPDA(projectPda, args.roundNumber, program.programId);
+  const milestonePda = getRoundMilestonePDA(projectPda, args.roundNumber, args.milestoneIndex, program.programId);
+  const investmentPda = getRoundInvestmentPDA(projectPda, args.roundNumber, nftMintPubkey, program.programId);
+  const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  const futureRoundVaultPda = getFutureRoundVaultPDA(projectPda, program.programId);
+  const futureRoundTokenVaultPda = getFutureRoundTokenVaultPDA(projectPda, program.programId);
+  const vaultAuthorityPda = getVaultAuthorityPDA(projectPda, program.programId);
+  const vestingPda = getRoundInvestorMilestoneVestingPDA(
+    projectPda,
+    args.roundNumber,
+    args.milestoneIndex,
+    investmentPda,
+    program.programId
+  );
+  const investorNftAccount = splToken.getAssociatedTokenAddressSync(
+    nftMintPubkey,
+    investor,
+    false,
+    splToken.TOKEN_PROGRAM_ID
+  );
+  return getMethods(program).claimRoundInstantTokens({ milestoneIndex: args.milestoneIndex }).accountsPartial({
+    investor,
+    project: projectPda,
+    fundingRound: fundingRoundPda,
+    milestone: milestonePda,
+    investment: investmentPda,
+    tokenVault: tokenVaultPda,
+    futureRoundVault: futureRoundVaultPda,
+    vesting: vestingPda,
+    nftMint: nftMintPubkey,
+    investorNftAccount,
+    futureRoundTokenVault: futureRoundTokenVaultPda,
+    investorTokenAccount: args.investorTokenAccount,
+    vaultAuthority: vaultAuthorityPda,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID,
+    systemProgram: web3_js.SystemProgram.programId
+  }).rpc();
+}
+async function claimRoundVestedTokens(program, args, investor) {
+  const nftMintPubkey = ensurePublicKey(args.nftMint);
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const fundingRoundPda = getFundingRoundPDA(projectPda, args.roundNumber, program.programId);
+  const milestonePda = getRoundMilestonePDA(projectPda, args.roundNumber, args.milestoneIndex, program.programId);
+  const investmentPda = getRoundInvestmentPDA(projectPda, args.roundNumber, nftMintPubkey, program.programId);
+  const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  const futureRoundVaultPda = getFutureRoundVaultPDA(projectPda, program.programId);
+  const futureRoundTokenVaultPda = getFutureRoundTokenVaultPDA(projectPda, program.programId);
+  const vaultAuthorityPda = getVaultAuthorityPDA(projectPda, program.programId);
+  const vestingPda = getRoundInvestorMilestoneVestingPDA(
+    projectPda,
+    args.roundNumber,
+    args.milestoneIndex,
+    investmentPda,
+    program.programId
+  );
+  const investorNftAccount = splToken.getAssociatedTokenAddressSync(
+    nftMintPubkey,
+    investor,
+    false,
+    splToken.TOKEN_PROGRAM_ID
+  );
+  return getMethods(program).claimRoundVestedTokens({ milestoneIndex: args.milestoneIndex }).accountsPartial({
+    investor,
+    project: projectPda,
+    fundingRound: fundingRoundPda,
+    milestone: milestonePda,
+    investment: investmentPda,
+    tokenVault: tokenVaultPda,
+    futureRoundVault: futureRoundVaultPda,
+    vesting: vestingPda,
+    nftMint: nftMintPubkey,
+    investorNftAccount,
+    futureRoundTokenVault: futureRoundTokenVaultPda,
+    investorTokenAccount: args.investorTokenAccount,
+    vaultAuthority: vaultAuthorityPda,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID
+  }).rpc();
+}
+async function claimRoundEarlyTokens(program, args, investor) {
+  const nftMintPubkey = ensurePublicKey(args.nftMint);
+  const projectPda = getProjectPDA(args.projectId, program.programId);
+  const fundingRoundPda = getFundingRoundPDA(projectPda, args.roundNumber, program.programId);
+  const investmentPda = getRoundInvestmentPDA(projectPda, args.roundNumber, nftMintPubkey, program.programId);
+  const tokenVaultPda = getTokenVaultPDA(projectPda, program.programId);
+  const futureRoundVaultPda = getFutureRoundVaultPDA(projectPda, program.programId);
+  const futureRoundTokenVaultPda = getFutureRoundTokenVaultPDA(projectPda, program.programId);
+  const vaultAuthorityPda = getVaultAuthorityPDA(projectPda, program.programId);
+  const investorNftAccount = splToken.getAssociatedTokenAddressSync(
+    nftMintPubkey,
+    investor,
+    false,
+    splToken.TOKEN_PROGRAM_ID
+  );
+  return getMethods(program).claimRoundEarlyTokens().accountsPartial({
+    investor,
+    project: projectPda,
+    fundingRound: fundingRoundPda,
+    investment: investmentPda,
+    tokenVault: tokenVaultPda,
+    futureRoundVault: futureRoundVaultPda,
+    nftMint: nftMintPubkey,
+    investorNftAccount,
+    futureRoundTokenVault: futureRoundTokenVaultPda,
+    investorTokenAccount: args.investorTokenAccount,
+    vaultAuthority: vaultAuthorityPda,
+    tokenProgram: splToken.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) {
@@ -1214,381 +2321,1166 @@ var RaiseClient = class _RaiseClient {
   getTgeEscrowVaultPDA(projectPda) {
     return getTgeEscrowVaultPDA(projectPda, this.programId);
   }
-  getAdminConfigPDA() {
-    return getAdminConfigPDA(this.programId);
+  getAdminConfigPDA() {
+    return getAdminConfigPDA(this.programId);
+  }
+  getAllocationProposalPDA(projectPda, proposalIndex) {
+    return getAllocationProposalPDA(projectPda, proposalIndex, this.programId);
+  }
+  getAllocationVotePDA(proposalPda, nftMint) {
+    return getAllocationVotePDA(proposalPda, nftMint, this.programId);
+  }
+  getSubAllocationVestingPDA(projectPda, subAllocationId) {
+    return getSubAllocationVestingPDA(projectPda, subAllocationId, this.programId);
+  }
+  getTokenomicsPDA(projectPda) {
+    return getTokenomicsPDA(projectPda, this.programId);
+  }
+  // Per-Milestone Vesting PDAs
+  getInvestorMilestoneVestingPDA(projectPda, milestoneIndex, investmentPda) {
+    return getInvestorMilestoneVestingPDA(projectPda, milestoneIndex, investmentPda, this.programId);
+  }
+  getFounderMilestoneVestingPDA(projectPda, milestoneIndex) {
+    return getFounderMilestoneVestingPDA(projectPda, milestoneIndex, 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);
+  }
+  async fetchTokenVault(projectId) {
+    return fetchTokenVault(this.program, projectId);
+  }
+  async fetchTokenomics(projectId) {
+    return fetchTokenomics(this.program, projectId);
+  }
+  async fetchAllocationProposal(projectId, proposalIndex) {
+    return fetchAllocationProposal(this.program, projectId, proposalIndex);
+  }
+  async fetchAllAllocationProposals(projectId) {
+    return fetchAllAllocationProposals(this.program, projectId);
+  }
+  async fetchAllocationVote(projectId, proposalIndex, nftMint) {
+    return fetchAllocationVote(this.program, projectId, proposalIndex, nftMint);
+  }
+  async fetchSubAllocationVesting(projectId, subAllocationId) {
+    return fetchSubAllocationVesting(this.program, projectId, subAllocationId);
+  }
+  async fetchInvestorMilestoneVesting(projectId, milestoneIndex, nftMint) {
+    return fetchInvestorMilestoneVesting(this.program, projectId, milestoneIndex, nftMint);
+  }
+  async fetchFounderMilestoneVesting(projectId, milestoneIndex) {
+    return fetchFounderMilestoneVesting(this.program, projectId, milestoneIndex);
+  }
+  // ===========================================================================
+  // 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
+    );
   }
   // ===========================================================================
-  // Account Fetchers
+  // Pivot Instructions
   // ===========================================================================
-  async fetchProject(projectId) {
-    return fetchProject(this.program, projectId);
-  }
-  async fetchMilestone(projectId, milestoneIndex) {
-    return fetchMilestone(this.program, projectId, milestoneIndex);
+  async proposePivot(args) {
+    return proposePivot(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
   }
-  async fetchAllMilestones(projectId) {
-    return fetchAllMilestones(this.program, projectId);
+  async approvePivot(projectId, adminKeypair) {
+    return approvePivot(
+      this.program,
+      projectId,
+      adminKeypair
+    );
   }
-  async fetchInvestment(projectId, nftMint) {
-    return fetchInvestment(this.program, projectId, nftMint);
+  async withdrawFromPivot(args) {
+    return withdrawFromPivot(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
   }
-  async fetchAllInvestments(projectId) {
-    return fetchAllInvestments(this.program, projectId);
+  async finalizePivot(args) {
+    return finalizePivot(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
   }
-  async fetchVote(projectId, milestoneIndex, voterKey, votingRound) {
-    return fetchVote(this.program, projectId, milestoneIndex, voterKey, votingRound);
+  // ===========================================================================
+  // TGE Instructions
+  // ===========================================================================
+  async setTgeDate(args) {
+    return setTgeDate(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
   }
-  async fetchAllVotes(projectId, milestoneIndex) {
-    return fetchAllVotes(this.program, projectId, milestoneIndex);
+  async depositTokens(args) {
+    return depositTokens(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
   }
-  async fetchPivotProposal(projectId) {
-    return fetchPivotProposal(this.program, projectId);
+  async claimTokens(args) {
+    return claimTokens(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
   }
-  async fetchTgeEscrow(projectId) {
-    return fetchTgeEscrow(this.program, projectId);
+  async reportScam(args) {
+    return reportScam(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
   }
-  async fetchAdminConfig() {
-    return fetchAdminConfig(this.program);
+  async releaseHoldback(args) {
+    return releaseHoldback(
+      this.program,
+      args
+    );
   }
   // ===========================================================================
-  // Admin Instructions
+  // ZTM v2.0 Token Distribution Instructions
   // ===========================================================================
-  async initializeAdmin(admin) {
-    return initializeAdmin(
+  /**
+   * 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,
-      admin,
+      args,
       this.walletPublicKey
     );
   }
-  async transferAdmin(newAdmin, adminKeypair) {
-    return transferAdmin(
+  /**
+   * 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,
-      adminKeypair,
-      newAdmin
+      args,
+      this.walletPublicKey
     );
   }
-  async acceptAdmin() {
-    return acceptAdmin(
+  /**
+   * 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
     );
   }
   // ===========================================================================
-  // Project Instructions
+  // ZTM v2.0: Founder Vesting Instructions
   // ===========================================================================
-  async initializeProject(args) {
-    return initializeProject(
+  /**
+   * 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
     );
   }
-  async submitForApproval(projectId) {
-    return submitForApproval(
+  /**
+   * 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,
-      projectId,
+      args,
       this.walletPublicKey
     );
   }
-  async approveProject(args, adminKeypair) {
-    return approveProject(
+  // ===========================================================================
+  // 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
     );
   }
-  // ===========================================================================
-  // Milestone Instructions
-  // ===========================================================================
-  async createMilestone(args) {
-    return createMilestone(
+  /**
+   * 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
     );
   }
-  async submitMilestone(projectId, milestoneIndex) {
-    return submitMilestone(
+  // ===========================================================================
+  // Early Token Release Instructions
+  // ===========================================================================
+  /**
+   * Claim early tokens as an investor (5% of token allocation)
+   *
+   * Early Token Release: Investors can claim 5% of their token allocation
+   * 24 hours after investing. These tokens are fully liquid immediately.
+   *
+   * Prerequisites:
+   * - 24h cooling period must have passed since investment
+   * - Investment must not have already claimed early tokens
+   * - Investment must have active voting rights
+   */
+  async claimEarlyTokens(args) {
+    return claimEarlyTokens(
       this.program,
-      projectId,
-      milestoneIndex,
+      args,
       this.walletPublicKey
     );
   }
-  async voteOnMilestone(args) {
-    return voteOnMilestone(
+  /**
+   * Claim early tokens as a founder (5% of founder allocation)
+   *
+   * Early Token Release: Founders can claim 5% of their token allocation
+   * when the project becomes Funded. These tokens are fully liquid immediately.
+   *
+   * Prerequisites:
+   * - Project must be in Funded, InProgress, or Completed state
+   * - Founder must not have already claimed early tokens
+   */
+  async claimFounderEarlyTokens(args) {
+    return claimFounderEarlyTokens(
       this.program,
       args,
       this.walletPublicKey
     );
   }
-  async finalizeVoting(projectId, milestoneIndex) {
-    return finalizeVoting(
+  /**
+   * Claim founder milestone-based tokens for a specific milestone
+   *
+   * Early Token Release: Founders can claim their milestone-based portion
+   * (default 47.5% of founder allocation) when milestones are unlocked.
+   *
+   * Prerequisites:
+   * - Milestone must be in Unlocked state
+   * - Founder must not have already claimed tokens for this milestone
+   */
+  async claimFounderMilestoneTokens(args) {
+    return claimFounderMilestoneTokens(
       this.program,
-      projectId,
-      milestoneIndex
+      args,
+      this.walletPublicKey
     );
   }
+  // ===========================================================================
+  // Per-Milestone Vesting Instructions (add-per-milestone-vesting)
+  // ===========================================================================
   /**
-   * Claim milestone funds (ZTM v2.0)
-   * - Regular milestones: Full payout to founder
-   * - Final milestone: LP USDC reserved for PCL, triggers MAE
+   * Claim instant tokens for a passed milestone (investor)
    *
-   * @param nextMilestoneDeadline - Deadline for next milestone (required for non-final milestones)
-   *   Set to BN(0) for final milestone claims (no next milestone exists)
+   * Per-milestone vesting: Investors claim the instant portion (e.g., 5-50%)
+   * immediately when a milestone passes. Creates vesting PDA on first claim.
+   *
+   * @param milestoneIndex - The milestone index to claim tokens from
+   * @param nftMint - The NFT mint proving investment ownership
+   * @param investorTokenAccount - Investor's token account to receive claimed tokens
    */
-  async claimMilestoneFunds(args) {
-    return claimMilestoneFunds(
+  async claimMilestoneInstantTokens(args) {
+    return claimMilestoneInstantTokens(
       this.program,
       args,
       this.walletPublicKey
     );
   }
   /**
-   * Resubmit a failed milestone for rework (Failed → InProgress)
+   * Claim vested tokens for a milestone after cliff period (investor)
    *
-   * Allows founders to iterate on failed milestones. Clears voting state
-   * for a fresh voting cycle. consecutive_failures is NOT reset.
+   * Per-milestone vesting: Investors claim vested tokens linearly after
+   * the cliff period passes. Must have already claimed instant tokens
+   * to initialize the vesting PDA.
+   *
+   * @param milestoneIndex - The milestone index to claim vested tokens from
+   * @param nftMint - The NFT mint proving investment ownership
+   * @param investorTokenAccount - Investor's token account to receive claimed tokens
    */
-  async resubmitMilestone(args) {
-    return resubmitMilestone(
+  async claimMilestoneVestedTokens(args) {
+    return claimMilestoneVestedTokens(
       this.program,
       args,
       this.walletPublicKey
     );
   }
   /**
-   * Set milestone deadline for founder to commit submission date
+   * Claim instant tokens for a passed milestone (founder)
    *
-   * 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.
+   * Per-milestone vesting: Founders claim the instant portion (e.g., 5-50%)
+   * of their milestone-based allocation when a milestone passes.
+   *
+   * @param milestoneIndex - The milestone index to claim tokens from
+   * @param founderTokenAccount - Founder's token account to receive claimed tokens
    */
-  async setMilestoneDeadline(args) {
-    return setMilestoneDeadline(
+  async claimFounderMsInstantTokens(args) {
+    return claimFounderMsInstantTokens(
       this.program,
       args,
       this.walletPublicKey
     );
   }
   /**
-   * Extend milestone deadline (max 3 extensions per milestone)
+   * Claim vested tokens for a milestone after cliff period (founder)
    *
-   * Founders can extend a deadline up to 3 times before it passes.
-   * Must be called BEFORE the current deadline passes.
+   * Per-milestone vesting: Founders claim vested tokens linearly after
+   * the cliff period passes. Must have already claimed instant tokens
+   * to initialize the vesting PDA.
+   *
+   * @param milestoneIndex - The milestone index to claim vested tokens from
+   * @param founderTokenAccount - Founder's token account to receive claimed tokens
    */
-  async extendMilestoneDeadline(args) {
-    return extendMilestoneDeadline(
+  async claimFounderMsVestedTokens(args) {
+    return claimFounderMsVestedTokens(
       this.program,
       args,
       this.walletPublicKey
     );
   }
   // ===========================================================================
-  // Investment Instructions
+  // Abandonment Instructions
+  // ===========================================================================
+  async checkAbandonment(projectId, milestoneIndex = 0) {
+    return checkAbandonment(
+      this.program,
+      projectId,
+      milestoneIndex
+    );
+  }
+  async claimRefund(args) {
+    return claimRefund(
+      this.program,
+      args,
+      this.walletPublicKey
+    );
+  }
+  // ===========================================================================
+  // Sub-Allocation Vesting Instructions
   // ===========================================================================
-  async invest(args) {
-    return invest(
+  /**
+   * Initialize sub-allocation vesting after MAE (Market Access Event)
+   *
+   * Creates SubAllocationVesting PDA for a specific sub-allocation ID.
+   * Project must be in Completed state with MAE completed.
+   * Permissionless - anyone can pay to initialize.
+   */
+  async initializeSubAllocationVesting(args) {
+    return initializeSubAllocationVesting(
       this.program,
       args,
       this.walletPublicKey
     );
   }
-  async cancelInvestment(args) {
-    return cancelInvestment(
+  /**
+   * Claim vested tokens from a sub-allocation
+   *
+   * Only the designated recipient wallet can claim tokens.
+   * Project must be Completed and MAE must be completed.
+   */
+  async claimSubAllocationTokens(args) {
+    return claimSubAllocationTokens(
       this.program,
       args,
       this.walletPublicKey
     );
   }
   // ===========================================================================
-  // Pivot Instructions
+  // Dynamic Tokenomics Instructions
   // ===========================================================================
-  async proposePivot(args) {
-    return proposePivot(
+  /**
+   * Add a sub-allocation from the reserve pool (Draft state only)
+   *
+   * Allows founders to add named allocations (advisors, marketing, etc.)
+   * from their reserve pool before submitting for approval.
+   */
+  async addSubAllocation(args) {
+    return addSubAllocation(
       this.program,
       args,
       this.walletPublicKey
     );
   }
-  async approvePivot(projectId, adminKeypair) {
-    return approvePivot(
+  /**
+   * Propose an allocation change via governance (post-Draft states)
+   *
+   * Creates a 7-day voting period for investors to approve/reject
+   * a new sub-allocation from the reserve pool.
+   */
+  async proposeAllocationChange(args) {
+    return proposeAllocationChange(
       this.program,
-      projectId,
-      adminKeypair
+      args,
+      this.walletPublicKey
     );
   }
-  async withdrawFromPivot(args) {
-    return withdrawFromPivot(
+  /**
+   * Vote on an allocation change proposal
+   *
+   * Investors can vote for/against using their Investment NFT.
+   * Must meet 7-day hold period for voting eligibility.
+   */
+  async voteAllocationChange(args) {
+    return voteAllocationChange(
       this.program,
       args,
       this.walletPublicKey
     );
   }
-  async finalizePivot(args) {
-    return finalizePivot(
+  /**
+   * Execute an approved allocation change proposal
+   *
+   * Permissionless - anyone can call after voting ends.
+   * Proposal must have passed (>51% approval).
+   */
+  async executeAllocationChange(args) {
+    return executeAllocationChange(
       this.program,
       args,
       this.walletPublicKey
     );
   }
   // ===========================================================================
-  // TGE Instructions
+  // Dynamic Tokenomics Helpers
   // ===========================================================================
-  async setTgeDate(args) {
-    return setTgeDate(
-      this.program,
-      args,
-      this.walletPublicKey
+  /**
+   * Get remaining founder pool capacity for sub-allocations in basis points
+   *
+   * Calculates: founder_allocation_bps - sum(sub_allocations.bps)
+   * Sub-allocations (treasury, advisors, marketing) draw from founder's allocation pool.
+   */
+  async getRemainingFounderPool(projectId) {
+    const tokenomics = await this.fetchTokenomics(projectId);
+    if (!tokenomics) {
+      throw new Error("Tokenomics account not found");
+    }
+    const founderBps = tokenomics.founderAllocationBps || 0;
+    const usedBps = (tokenomics.subAllocations || []).filter((sa) => sa.bps > 0).reduce((sum, sa) => sum + sa.bps, 0);
+    return founderBps - usedBps;
+  }
+  /**
+   * Get all active (non-executed, non-expired) allocation proposals
+   */
+  async getActiveProposals(projectId) {
+    const proposals = await this.fetchAllAllocationProposals(projectId);
+    const now = Math.floor(Date.now() / 1e3);
+    return proposals.filter((p) => {
+      const account = p.account;
+      return !account.executed && account.votingEndsAt.toNumber() > now;
+    });
+  }
+  /**
+   * Get vesting status for a sub-allocation
+   *
+   * Returns claimable amount, total vested, and remaining locked tokens.
+   */
+  async getSubAllocationVestingStatus(projectId, subAllocationId) {
+    const vesting = await this.fetchSubAllocationVesting(projectId, subAllocationId);
+    if (!vesting) {
+      return null;
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    const cliffEnd = vesting.cliffEnd.toNumber();
+    const vestingEnd = vesting.vestingEnd.toNumber();
+    const totalAmount = vesting.totalAmount.toNumber();
+    const claimedAmount = vesting.claimedAmount.toNumber();
+    if (now < cliffEnd) {
+      return {
+        totalAmount,
+        vestedAmount: 0,
+        claimedAmount,
+        claimableAmount: 0,
+        lockedAmount: totalAmount - claimedAmount,
+        vestingProgress: 0,
+        cliffPassed: false
+      };
+    }
+    if (now >= vestingEnd) {
+      return {
+        totalAmount,
+        vestedAmount: totalAmount,
+        claimedAmount,
+        claimableAmount: totalAmount - claimedAmount,
+        lockedAmount: 0,
+        vestingProgress: 100,
+        cliffPassed: true
+      };
+    }
+    const vestingDuration = vestingEnd - cliffEnd;
+    const elapsed = now - cliffEnd;
+    const vestedAmount = Math.floor(totalAmount * elapsed / vestingDuration);
+    return {
+      totalAmount,
+      vestedAmount,
+      claimedAmount,
+      claimableAmount: vestedAmount - claimedAmount,
+      lockedAmount: totalAmount - vestedAmount,
+      vestingProgress: Math.floor(elapsed / vestingDuration * 100),
+      cliffPassed: true
+    };
+  }
+  // ===========================================================================
+  // Milestone Price Increase Helpers
+  // ===========================================================================
+  /** Base price multiplier constant (10000 BPS = 1.0x) */
+  static PRICE_MULTIPLIER_BASE = 1e4;
+  /**
+   * Get the current price multiplier for a project
+   *
+   * Returns the multiplier in BPS (10000 = 1.0x, 15000 = 1.5x)
+   *
+   * Supports two modes:
+   * - Dynamic mode (priceMultipliers[0] === 0): Uses currentPriceMultiplierBps
+   *   calculated dynamically via ZEMYTH formula at each milestone claim
+   * - Static mode (legacy): Uses pre-configured priceMultipliers array lookup
+   */
+  async getCurrentMultiplier(projectId) {
+    const project = await this.fetchProject(projectId);
+    if (!project) {
+      throw new Error("Project account not found");
+    }
+    const { priceMultipliers, milestonesPassed, milestoneCount, currentPriceMultiplierBps } = project;
+    if (priceMultipliers[0] === 0) {
+      return currentPriceMultiplierBps || _RaiseClient.PRICE_MULTIPLIER_BASE;
+    }
+    const index = milestoneCount === 0 ? 0 : Math.min(milestonesPassed, milestoneCount - 1);
+    return priceMultipliers[index] || _RaiseClient.PRICE_MULTIPLIER_BASE;
+  }
+  /**
+   * Check if a project uses dynamic price multiplier mode
+   */
+  async isDynamicMultiplierMode(projectId) {
+    const project = await this.fetchProject(projectId);
+    if (!project) {
+      throw new Error("Project account not found");
+    }
+    return project.priceMultipliers[0] === 0;
+  }
+  /**
+   * Calculate effective tier prices with current multiplier
+   *
+   * Returns array of tiers with their effective prices after applying
+   * the current milestone multiplier.
+   */
+  async getEffectiveTierPrices(projectId) {
+    const project = await this.fetchProject(projectId);
+    if (!project) {
+      throw new Error("Project account not found");
+    }
+    const multiplier = await this.getCurrentMultiplier(projectId);
+    const tiers = project.tiers.slice(0, project.tierCount);
+    return tiers.map((tier, index) => ({
+      tierIndex: index,
+      baseAmount: tier.amount,
+      effectiveAmount: tier.amount.mul(new anchor.BN(multiplier)).div(new anchor.BN(_RaiseClient.PRICE_MULTIPLIER_BASE)),
+      multiplierBps: multiplier
+    }));
+  }
+  /**
+   * Get price schedule showing multipliers after each milestone
+   *
+   * Returns array showing what the price multiplier will be
+   * after each milestone passes.
+   *
+   * For dynamic mode projects (priceMultipliers[0] === 0), returns null
+   * as multipliers are calculated dynamically based on deadline timing.
+   */
+  async getPriceSchedule(projectId) {
+    const project = await this.fetchProject(projectId);
+    if (!project) {
+      throw new Error("Project account not found");
+    }
+    const { priceMultipliers, milestoneCount } = project;
+    if (priceMultipliers[0] === 0) {
+      return null;
+    }
+    return priceMultipliers.slice(0, milestoneCount).map((multiplier, index) => ({
+      afterMilestone: index,
+      multiplierBps: multiplier,
+      multiplierPercent: multiplier / 100
+      // 10000 -> 100%
+    }));
+  }
+  /**
+   * Preview multiplier calculation for dynamic mode projects
+   *
+   * Uses the ZEMYTH formula to calculate what the multiplier would be
+   * given a specific number of remaining milestones and days to deadline.
+   *
+   * Formula: totalMultiplier = 1 + (sqrt(n) / sqrt(15)) × (1 / ln(d/7 + e))
+   *
+   * @param remainingMilestones Number of milestones left (1-10)
+   * @param daysToDeadline Days until next milestone deadline (1-365)
+   * @returns Preview of the multiplier in BPS (10000 = 1.0x, max 20000 = 2.0x)
+   */
+  previewDynamicMultiplier(remainingMilestones, daysToDeadline) {
+    if (remainingMilestones === 0) {
+      return _RaiseClient.PRICE_MULTIPLIER_BASE;
+    }
+    const days = Math.max(1, Math.min(365, daysToDeadline));
+    const sqrtN = Math.sqrt(remainingMilestones) * 1e3;
+    const milestoneFactor = sqrtN / 3.873;
+    const timeFactor = this.timeFactorLookup(days);
+    const combined = milestoneFactor * timeFactor / 1e3;
+    const bonusBps = Math.min(combined, 1e4);
+    return Math.min(2e4, Math.max(1e4, Math.round(1e4 + bonusBps)));
+  }
+  /** Time factor lookup for dynamic multiplier preview (approximates 1/ln(d/7 + e) × 1000) */
+  timeFactorLookup(days) {
+    if (days <= 7) return 950 - days * 25;
+    if (days <= 14) return 775 - (days - 7) * 20;
+    if (days <= 30) return 635 - (days - 14) * 8;
+    if (days <= 60) return 507 - (days - 30) * 4;
+    if (days <= 90) return 387 - (days - 60) * 3;
+    if (days <= 180) return 297 - (days - 90) * 1;
+    return 250;
+  }
+  // ===========================================================================
+  // Linear Progressive Pricing Helpers (add-linear-progressive-pricing)
+  // ===========================================================================
+  /** Constants for progressive pricing */
+  static TIME_ALLOCATION_PERCENT = 50;
+  static MILESTONE_ALLOCATION_PERCENT = 50;
+  /** DEV MODE: Time acceleration multiplier (10 real seconds = 1 simulated day) */
+  static PROGRESSIVE_TIME_MULTIPLIER = 8640;
+  /**
+   * Check if progressive pricing is active for a project
+   *
+   * Progressive pricing is active when milestonePeriodStartedAt > 0,
+   * meaning the first milestone period has been initialized.
+   */
+  isProgressivePricingActive(project) {
+    return project.milestonePeriodStartedAt.gt(new anchor.BN(0));
+  }
+  /**
+   * Calculate time progress for a milestone period
+   *
+   * @param project Project account with progressive pricing fields
+   * @param currentTime Current unix timestamp (seconds)
+   * @returns Progress as ratio 0-1 (capped at 1.0)
+   */
+  getTimeProgress(project, currentTime) {
+    const startedAt = project.milestonePeriodStartedAt.toNumber();
+    const deadline = project.expectedMilestoneDeadlineTs.toNumber();
+    if (startedAt === 0 || deadline <= startedAt) {
+      return 0;
+    }
+    const rawElapsed = Math.max(0, currentTime - startedAt);
+    const elapsed = rawElapsed * _RaiseClient.PROGRESSIVE_TIME_MULTIPLIER;
+    const expectedDuration = Math.max(1, deadline - startedAt);
+    return Math.min(1, elapsed / expectedDuration);
+  }
+  /**
+   * Calculate the effective multiplier including time-based component
+   *
+   * @param project Project account with progressive pricing fields
+   * @param currentTime Current unix timestamp (seconds)
+   * @returns Effective multiplier in BPS (10000 = 1.0x)
+   */
+  calculateEffectiveMultiplier(project, currentTime) {
+    if (!this.isProgressivePricingActive(project)) {
+      if (project.priceMultipliers[0] === 0) {
+        return project.currentPriceMultiplierBps || _RaiseClient.PRICE_MULTIPLIER_BASE;
+      }
+      return project.currentPriceMultiplierBps || _RaiseClient.PRICE_MULTIPLIER_BASE;
+    }
+    const timeProgress = this.getTimeProgress(project, currentTime);
+    const timeIncrement = Math.floor(project.timeAllocationBps * timeProgress);
+    return project.milestoneBaseMultiplierBps + timeIncrement;
+  }
+  /**
+   * Preview what the milestone spike will be at a given claim time
+   *
+   * If founder claims early, unused time allocation accumulates to spike.
+   *
+   * @param project Project account with progressive pricing fields
+   * @param claimTime Unix timestamp when claim will happen
+   * @returns Object with spike details
+   */
+  previewMilestoneSpike(project, claimTime) {
+    const timeProgress = this.getTimeProgress(project, claimTime);
+    const consumedTimeBps = Math.floor(project.timeAllocationBps * timeProgress);
+    const unusedTimeBps = project.timeAllocationBps - consumedTimeBps;
+    const milestoneSpikeBps = project.milestoneAllocationBps + unusedTimeBps;
+    const effectiveMultiplierBps = project.milestoneBaseMultiplierBps + consumedTimeBps;
+    const newBaseBps = effectiveMultiplierBps + milestoneSpikeBps;
+    return {
+      timeProgress,
+      consumedTimeBps,
+      unusedTimeBps,
+      milestoneSpikeBps,
+      effectiveMultiplierBps,
+      newBaseBps
+    };
+  }
+  /**
+   * Get effective tier prices with time-based progressive pricing
+   *
+   * Unlike getEffectiveTierPrices which fetches the project, this takes
+   * the project and current time to calculate prices including time component.
+   */
+  getProgressiveTierPrices(project, currentTime) {
+    const multiplier = this.calculateEffectiveMultiplier(project, currentTime);
+    const timeProgress = this.getTimeProgress(project, currentTime);
+    const tiers = project.tiers.slice(0, project.tierCount);
+    return tiers.map((tier, index) => ({
+      tierIndex: index,
+      baseAmount: tier.amount,
+      effectiveAmount: tier.amount.mul(new anchor.BN(multiplier)).div(new anchor.BN(_RaiseClient.PRICE_MULTIPLIER_BASE)),
+      multiplierBps: multiplier,
+      timeProgressPercent: Math.round(timeProgress * 100)
+    }));
+  }
+  // ===========================================================================
+  // Multi-Round Fundraising PDAs
+  // ===========================================================================
+  getFundingRoundPDA(projectPda, roundNumber) {
+    return getFundingRoundPDA(projectPda, roundNumber, this.programId);
+  }
+  getRoundEscrowPDA(projectPda, roundNumber) {
+    return getRoundEscrowPDA(projectPda, roundNumber, this.programId);
+  }
+  getRoundMilestonePDA(projectPda, roundNumber, milestoneIndex) {
+    return getRoundMilestonePDA(projectPda, roundNumber, milestoneIndex, this.programId);
+  }
+  getRoundInvestmentPDA(projectPda, roundNumber, nftMint) {
+    return getRoundInvestmentPDA(projectPda, roundNumber, nftMint, this.programId);
+  }
+  getRoundInvestorMilestoneVestingPDA(projectPda, roundNumber, milestoneIndex, investmentPda) {
+    return getRoundInvestorMilestoneVestingPDA(
+      projectPda,
+      roundNumber,
+      milestoneIndex,
+      investmentPda,
+      this.programId
     );
   }
-  async depositTokens(args) {
-    return depositTokens(
+  getFutureRoundVaultPDA(projectPda) {
+    return getFutureRoundVaultPDA(projectPda, this.programId);
+  }
+  getFutureRoundTokenVaultPDA(projectPda) {
+    return getFutureRoundTokenVaultPDA(projectPda, this.programId);
+  }
+  // ===========================================================================
+  // Multi-Round Fundraising Account Fetchers
+  // ===========================================================================
+  async fetchFundingRound(projectId, roundNumber) {
+    return fetchFundingRound(this.program, projectId, roundNumber);
+  }
+  async fetchAllFundingRounds(projectId) {
+    return fetchAllFundingRounds(this.program, projectId);
+  }
+  async fetchRoundMilestone(projectId, roundNumber, milestoneIndex) {
+    return fetchRoundMilestone(this.program, projectId, roundNumber, milestoneIndex);
+  }
+  async fetchRoundInvestment(projectId, roundNumber, nftMint) {
+    return fetchRoundInvestment(this.program, projectId, roundNumber, nftMint);
+  }
+  async fetchFutureRoundVault(projectId) {
+    return fetchFutureRoundVault(this.program, projectId);
+  }
+  // ===========================================================================
+  // Multi-Round Fundraising Instructions
+  // ===========================================================================
+  /**
+   * Open a new funding round (R2, R3, R4...)
+   *
+   * Multi-Round Fundraising: Creates FundingRound PDA, round escrow,
+   * and milestone PDAs for the new round. Tokens come from FutureRoundVault.
+   *
+   * Prerequisites:
+   * - Project must be InProgress or Completed state
+   * - At least 1 milestone must have passed (for InProgress projects)
+   * - No other round currently Open
+   * - Current round must be fully funded before opening next
+   * - Must have future_round_allocation configured in tokenomics
+   */
+  async openFundingRound(args) {
+    return openFundingRound(
       this.program,
       args,
       this.walletPublicKey
     );
   }
-  async claimTokens(args) {
-    return claimTokens(
+  /**
+   * Invest in a funding round (R2, R3, R4...)
+   *
+   * Multi-Round Fundraising: Creates investment NFT and deposits USDC
+   * to the round-specific escrow. Tokens come from FutureRoundVault.
+   */
+  async investInRound(args) {
+    return investInRound(
       this.program,
       args,
       this.walletPublicKey
     );
   }
-  async reportScam(args) {
-    return reportScam(
+  /**
+   * Cancel round investment within 24-hour cooling-off period
+   *
+   * Multi-Round Fundraising: Returns USDC from round escrow,
+   * closes investment account.
+   */
+  async cancelRoundInvestment(args) {
+    return cancelRoundInvestment(
       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)
+   * Submit round milestone for investor review
    *
-   * 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.
+   * Multi-Round Fundraising: Transitions milestone to UnderReview,
+   * sets voting deadline.
    */
-  async claimInvestorTokens(args) {
-    return claimInvestorTokens(
+  async submitRoundMilestone(args) {
+    return submitRoundMilestone(
       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.
+   * Vote on a round milestone (unified voting - ANY investor can vote)
    *
-   * @deprecated Use claimInvestorTokens instead (whitepaper manual claim model)
+   * Multi-Round Fundraising: R1, R2, R3... investors can all vote
+   * on any round's milestones. Investment can be from any round.
    */
-  async distributeTokens(args) {
-    return distributeTokens(
+  async voteOnRoundMilestone(args) {
+    return voteOnRoundMilestone(
       this.program,
       args,
       this.walletPublicKey
     );
   }
   /**
-   * Complete token distribution for a milestone
+   * Finalize voting on a round milestone
    *
-   * ZTM v2.0: Marks distribution as complete after all batches have been processed.
-   * Permissionless - anyone can call this to finalize a distribution.
+   * Multi-Round Fundraising: Processes vote results, transitions
+   * milestone to Passed or Failed state.
    */
-  async completeDistribution(args) {
-    return completeDistribution(
+  async finalizeRoundVoting(args) {
+    return finalizeRoundVoting(
       this.program,
-      args,
-      this.walletPublicKey
+      args
     );
   }
-  // ===========================================================================
-  // ZTM v2.0: Founder Vesting Instructions
-  // ===========================================================================
   /**
-   * Initialize founder vesting after MAE (Market Access Event)
+   * Claim milestone funds from a round (founder)
    *
-   * 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.
+   * Multi-Round Fundraising: Transfers USDC from round escrow
+   * to founder's account.
+   *
+   * @param nextMilestoneDeadline - Deadline for next milestone (required for non-final)
+   *   Set to BN(0) for final milestone claims
    */
-  async initializeFounderVesting(args) {
-    return initializeFounderVesting(
+  async claimRoundMilestoneFunds(args) {
+    return claimRoundMilestoneFunds(
       this.program,
       args,
       this.walletPublicKey
     );
   }
   /**
-   * Claim vested tokens from founder vault
+   * Claim instant tokens for a round milestone (investor)
    *
-   * ZTM v2.0: Founder claims tokens based on linear vesting schedule.
-   * Requires cliff period to pass before any tokens can be claimed.
+   * Multi-Round Fundraising: R2+ investors claim instant portion
+   * when milestone passes. Tokens come from FutureRoundVault.
    */
-  async claimVestedTokens(args) {
-    return claimVestedTokens(
+  async claimRoundInstantTokens(args) {
+    return claimRoundInstantTokens(
       this.program,
       args,
       this.walletPublicKey
     );
   }
-  // ===========================================================================
-  // ZTM v2.0: Circuit Breaker Instructions
-  // ===========================================================================
   /**
-   * Force complete a stuck distribution (admin only)
+   * Claim vested tokens for a round milestone (investor)
    *
-   * 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.
+   * Multi-Round Fundraising: R2+ investors claim vested portion
+   * after cliff period. Tokens come from FutureRoundVault.
    */
-  async forceCompleteDistribution(args, adminKeypair) {
-    return forceCompleteDistribution(
+  async claimRoundVestedTokens(args) {
+    return claimRoundVestedTokens(
       this.program,
       args,
-      adminKeypair
+      this.walletPublicKey
     );
   }
   /**
-   * Claim missed token unlock after force-complete distribution
+   * Claim early tokens for a round investment (5% after 24h)
    *
-   * ZTM v2.0: Allows investors to claim tokens they missed during a stuck
-   * distribution that was force-completed by admin.
+   * Multi-Round Fundraising: R2+ investors claim 5% of token allocation
+   * 24 hours after investing. Tokens come from FutureRoundVault.
    */
-  async claimMissedUnlock(args) {
-    return claimMissedUnlock(
+  async claimRoundEarlyTokens(args) {
+    return claimRoundEarlyTokens(
       this.program,
       args,
       this.walletPublicKey
     );
   }
   // ===========================================================================
-  // Abandonment Instructions
+  // Multi-Round Fundraising Helpers
   // ===========================================================================
-  async checkAbandonment(projectId, milestoneIndex = 0) {
-    return checkAbandonment(
-      this.program,
-      projectId,
-      milestoneIndex
-    );
+  /**
+   * Check if the next funding round can be opened
+   *
+   * Returns eligibility status with reason and next round number.
+   */
+  async canOpenNextRound(projectId) {
+    return canOpenNextRound(this.program, projectId);
   }
-  async claimRefund(args) {
-    return claimRefund(
-      this.program,
-      args,
-      this.walletPublicKey
-    );
+  /**
+   * Get remaining future round allocation in BPS
+   */
+  getRemainingFutureRoundAllocation(tokenomics) {
+    return getRemainingFutureRoundAllocation(tokenomics);
+  }
+  /**
+   * Check if a specific round is fully funded
+   */
+  async isRoundFullyFunded(projectId, roundNumber) {
+    return isRoundFullyFunded(this.program, projectId, roundNumber);
+  }
+  /**
+   * Get round details with computed state
+   *
+   * Returns funding round data with additional computed fields.
+   */
+  async getRoundDetails(projectId, roundNumber) {
+    const fundingRound = await this.fetchFundingRound(projectId, roundNumber);
+    if (!fundingRound) {
+      return null;
+    }
+    const milestones = [];
+    for (let i = 0; i < fundingRound.milestoneCount; i++) {
+      const milestone = await this.fetchRoundMilestone(projectId, roundNumber, i);
+      if (milestone) {
+        milestones.push(milestone);
+      }
+    }
+    const totalRaised = fundingRound.totalRaised.toNumber();
+    const fundingGoal = fundingRound.fundingGoal.toNumber();
+    const fundingProgress = fundingGoal > 0 ? totalRaised / fundingGoal * 100 : 0;
+    return {
+      ...fundingRound,
+      milestones,
+      fundingProgress,
+      isFullyFunded: totalRaised >= fundingGoal
+    };
   }
 };
 
@@ -1627,6 +3519,14 @@ var PivotState = /* @__PURE__ */ ((PivotState2) => {
   PivotState2["Finalized"] = "finalized";
   return PivotState2;
 })(PivotState || {});
+var FundingRoundState = /* @__PURE__ */ ((FundingRoundState2) => {
+  FundingRoundState2["Open"] = "open";
+  FundingRoundState2["Funded"] = "funded";
+  FundingRoundState2["InProgress"] = "inProgress";
+  FundingRoundState2["Completed"] = "completed";
+  FundingRoundState2["Failed"] = "failed";
+  return FundingRoundState2;
+})(FundingRoundState || {});
 var ERROR_CODES = {
   // State Transition Errors (6000-6099)
   InvalidStateTransition: 6e3,
@@ -1921,6 +3821,10 @@ function shortenPublicKey(pubkey, chars = 4) {
   return `${str.slice(0, chars)}...${str.slice(-chars)}`;
 }
 
+Object.defineProperty(exports, "BN", {
+  enumerable: true,
+  get: function () { return anchor.BN; }
+});
 Object.defineProperty(exports, "Connection", {
   enumerable: true,
   get: function () { return web3_js.Connection; }
@@ -1933,13 +3837,13 @@ Object.defineProperty(exports, "PublicKey", {
   enumerable: true,
   get: function () { return web3_js.PublicKey; }
 });
-Object.defineProperty(exports, "BN", {
-  enumerable: true,
-  get: function () { return anchor.BN; }
-});
+exports.EARLY_TOKEN_COOLING_PERIOD_SECONDS = EARLY_TOKEN_COOLING_PERIOD_SECONDS;
+exports.EARLY_TOKEN_COOLING_PERIOD_SECONDS_DEV = EARLY_TOKEN_COOLING_PERIOD_SECONDS_DEV;
+exports.EARLY_TOKEN_RELEASE_BPS = EARLY_TOKEN_RELEASE_BPS;
 exports.ERROR_CODES = ERROR_CODES;
 exports.ERROR_MESSAGES = ERROR_MESSAGES;
 exports.EVENT_NAMES = EVENT_NAMES;
+exports.FundingRoundState = FundingRoundState;
 exports.GOVERNANCE = GOVERNANCE;
 exports.InvestmentTier = InvestmentTier;
 exports.MAX_DEADLINE_DURATION_SECONDS = MAX_DEADLINE_DURATION_SECONDS;
@@ -1957,6 +3861,7 @@ exports.TIER_MINIMUMS = TIER_MINIMUMS;
 exports.TIER_TOKEN_MULTIPLIERS = TIER_TOKEN_MULTIPLIERS;
 exports.TIER_VOTE_MULTIPLIERS = TIER_VOTE_MULTIPLIERS;
 exports.TIMING = TIMING;
+exports.TOKENOMICS = TOKENOMICS;
 exports.USDC = USDC;
 exports.VALIDATION = VALIDATION;
 exports.VoteChoice = VoteChoice;
@@ -1969,13 +3874,24 @@ exports.bnToBigInt = bnToBigInt;
 exports.bnToNumber = bnToNumber;
 exports.bpsToPercent = bpsToPercent;
 exports.calculateDeadline = calculateDeadline;
+exports.calculateEarlyTokenAmount = calculateEarlyTokenAmount;
+exports.calculateRemainingAllocation = calculateRemainingAllocation;
+exports.canClaimEarlyTokens = canClaimEarlyTokens;
+exports.canClaimFounderEarlyTokens = canClaimFounderEarlyTokens;
+exports.canClaimFounderMilestoneTokens = canClaimFounderMilestoneTokens;
+exports.canClaimRoundEarlyTokens = canClaimRoundEarlyTokens;
 exports.cancelInvestment = cancelInvestment;
+exports.cancelRoundInvestment = cancelRoundInvestment;
 exports.checkAbandonment = checkAbandonment;
 exports.claimExitWindowRefund = claimExitWindowRefund;
 exports.claimInvestorTokens = claimInvestorTokens;
 exports.claimMilestoneFunds = claimMilestoneFunds;
 exports.claimMissedUnlock = claimMissedUnlock;
 exports.claimRefund = claimRefund;
+exports.claimRoundEarlyTokens = claimRoundEarlyTokens;
+exports.claimRoundInstantTokens = claimRoundInstantTokens;
+exports.claimRoundMilestoneFunds = claimRoundMilestoneFunds;
+exports.claimRoundVestedTokens = claimRoundVestedTokens;
 exports.claimTokens = claimTokens;
 exports.claimVestedTokens = claimVestedTokens;
 exports.completeDistribution = completeDistribution;
@@ -1985,18 +3901,25 @@ exports.depositTokens = depositTokens;
 exports.distributeTokens = distributeTokens;
 exports.extendMilestoneDeadline = extendMilestoneDeadline;
 exports.fetchAdminConfig = fetchAdminConfig;
+exports.fetchAllFundingRounds = fetchAllFundingRounds;
 exports.fetchAllInvestments = fetchAllInvestments;
 exports.fetchAllMilestones = fetchAllMilestones;
 exports.fetchAllVotes = fetchAllVotes;
+exports.fetchFundingRound = fetchFundingRound;
+exports.fetchFutureRoundVault = fetchFutureRoundVault;
 exports.fetchInvestment = fetchInvestment;
 exports.fetchMilestone = fetchMilestone;
 exports.fetchPivotProposal = fetchPivotProposal;
 exports.fetchProject = fetchProject;
 exports.fetchProjectByPda = fetchProjectByPda;
+exports.fetchRoundInvestment = fetchRoundInvestment;
+exports.fetchRoundInvestorMilestoneVesting = fetchRoundInvestorMilestoneVesting;
+exports.fetchRoundMilestone = fetchRoundMilestone;
 exports.fetchTgeEscrow = fetchTgeEscrow;
 exports.fetchVote = fetchVote;
 exports.filterEventsByName = filterEventsByName;
 exports.finalizePivot = finalizePivot;
+exports.finalizeRoundVoting = finalizeRoundVoting;
 exports.finalizeVoting = finalizeVoting;
 exports.findEvent = findEvent;
 exports.findTierIndex = findTierIndex;
@@ -2008,6 +3931,9 @@ exports.getErrorMessage = getErrorMessage;
 exports.getEscrowPDA = getEscrowPDA;
 exports.getFounderVaultPDA = getFounderVaultPDA;
 exports.getFounderVestingPDA = getFounderVestingPDA;
+exports.getFundingRoundPDA = getFundingRoundPDA;
+exports.getFutureRoundTokenVaultPDA = getFutureRoundTokenVaultPDA;
+exports.getFutureRoundVaultPDA = getFutureRoundVaultPDA;
 exports.getInvestmentPDA = getInvestmentPDA;
 exports.getInvestorVaultPDA = getInvestorVaultPDA;
 exports.getLpTokenVaultPDA = getLpTokenVaultPDA;
@@ -2018,6 +3944,11 @@ exports.getPivotProposalPDA = getPivotProposalPDA;
 exports.getProgramAuthorityPDA = getProgramAuthorityPDA;
 exports.getProjectPDA = getProjectPDA;
 exports.getProjectPDAs = getProjectPDAs;
+exports.getRoundEscrowPDA = getRoundEscrowPDA;
+exports.getRoundInvestmentPDA = getRoundInvestmentPDA;
+exports.getRoundInvestorMilestoneVestingPDA = getRoundInvestorMilestoneVestingPDA;
+exports.getRoundMilestonePDA = getRoundMilestonePDA;
+exports.getRoundNftMintPDA = getRoundNftMintPDA;
 exports.getScamReportPDA = getScamReportPDA;
 exports.getTgeEscrowPDA = getTgeEscrowPDA;
 exports.getTierFromAmount = getTierFromAmount;
@@ -2035,21 +3966,25 @@ exports.initializeAdmin = initializeAdmin;
 exports.initializeFounderVesting = initializeFounderVesting;
 exports.initializeProject = initializeProject;
 exports.invest = invest;
+exports.investInRound = investInRound;
 exports.isRaiseError = isRaiseError;
 exports.isValidPublicKey = isValidPublicKey;
 exports.minDeadline = minDeadline;
+exports.openFundingRound = openFundingRound;
 exports.parseError = parseError;
 exports.percentToBps = percentToBps;
 exports.percentageOf = percentageOf;
 exports.proposePivot = proposePivot;
 exports.releaseHoldback = releaseHoldback;
 exports.reportScam = reportScam;
+exports.requiresBurnForRefund = requiresBurnForRefund;
 exports.resubmitMilestone = resubmitMilestone;
 exports.setMilestoneDeadline = setMilestoneDeadline;
 exports.setTgeDate = setTgeDate;
 exports.shortenPublicKey = shortenPublicKey;
 exports.submitForApproval = submitForApproval;
 exports.submitMilestone = submitMilestone;
+exports.submitRoundMilestone = submitRoundMilestone;
 exports.symbolToBytes = symbolToBytes;
 exports.timeRemaining = timeRemaining;
 exports.timestampToDate = timestampToDate;
@@ -2058,6 +3993,7 @@ exports.validateDeadline = validateDeadline;
 exports.validateMetadataUri = validateMetadataUri;
 exports.validateMilestonePercentages = validateMilestonePercentages;
 exports.voteOnMilestone = voteOnMilestone;
+exports.voteOnRoundMilestone = voteOnRoundMilestone;
 exports.withdrawFromPivot = withdrawFromPivot;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map