@zemyth/raise-sdk 0.1.1 → 0.1.3

package/README.md

@@ -79,13 +79,15 @@ const tx = await client.initializeProject({
   ],
   tokenomics: {
     totalSupply: new BN('1000000000000000'), // 1B tokens (with decimals)
-    symbol: 'PROJ',
-    investorAllocationBps: 2000, // 20%
-    founderAllocationBps: 2000, // 20%
-    lpAllocationBps: 3000, // 30%
-    treasuryAllocationBps: 3000, // 30%
-    cliffSeconds: new BN(15552000), // 6 months
-    vestingSeconds: new BN(63072000), // 2 years
+    tokenSymbol: [80, 82, 79, 74, 0, 0, 0, 0], // 'PROJ' as byte array
+    investorAllocationBps: 4000, // 40%
+    founderAllocationBps: 4900, // 49% - sub-allocations (treasury, advisors, marketing) draw from this pool
+    lpTokenAllocationBps: 1000, // 10%
+    lpUsdcAllocationBps: 500, // 5% of raised USDC
+    zemythAllocationBps: 100, // 1% platform fee (minimum), vests per milestone
+    founderWallet: founderWallet.publicKey,
+    vestingDurationMonths: 24, // 2 years
+    cliffMonths: 6, // 6 month cliff
   },
   milestone1Deadline: new BN(Math.floor(Date.now() / 1000) + 90 * 24 * 60 * 60), // 90 days
 });
@@ -747,8 +749,8 @@ npm run clean
 
 ## Links
 
-- [GitHub Repository](https://github.com/zemyth/raise)
-- [Issue Tracker](https://github.com/zemyth/raise/issues)
+- [GitHub Repository](https://github.com/zemyth-app/raise)
+- [Issue Tracker](https://github.com/zemyth-app/raise/issues)
 - [npm Package](https://www.npmjs.com/package/@zemyth/raise-sdk)
 
 ## License

package/dist/accounts/index.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
-var web3_js = require('@solana/web3.js');
 var anchor = require('@coral-xyz/anchor');
+var web3_js = require('@solana/web3.js');
 
-// src/pdas/index.ts
+// src/accounts/index.ts
 
 // src/constants/index.ts
 var SEEDS = {
@@ -13,7 +13,12 @@ var SEEDS = {
   VOTE: "vote",
   PIVOT: "pivot",
   TGE_ESCROW: "tge_escrow",
-  ADMIN_CONFIG: "admin-config"};
+  ADMIN_CONFIG: "admin-config",
+  FUTURE_ROUND_STATE: "future_round_state",
+  // Multi-Round Fundraising seeds
+  FUNDING_ROUND: "funding_round",
+  INVESTOR_MS_VESTING: "investor_ms_vesting"
+};
 
 // src/pdas/index.ts
 function ensureBN(value) {
@@ -79,6 +84,13 @@ function getTgeEscrowPDA(projectPda, programId) {
   );
   return pda;
 }
+function getTokenVaultPDA(projectPda, programId) {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from("token_vault"), projectPda.toBuffer()],
+    programId
+  );
+  return pda;
+}
 function getAdminConfigPDA(programId) {
   const [pda] = web3_js.PublicKey.findProgramAddressSync(
     [Buffer.from(SEEDS.ADMIN_CONFIG)],
@@ -86,6 +98,124 @@ function getAdminConfigPDA(programId) {
   );
   return pda;
 }
+function getTokenomicsPDA(projectPda, programId) {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from("tokenomics"), projectPda.toBuffer()],
+    programId
+  );
+  return pda;
+}
+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 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 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 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;
+}
 
 // src/accounts/index.ts
 function getAccountNamespace(program) {
@@ -233,6 +363,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);
@@ -241,18 +383,404 @@ async function accountExists(program, accountType, pda) {
     return false;
   }
 }
+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;
+  }
+}
+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 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 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 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;
+  }
+}
+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;
+  }
+}
+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;
+  }
+}
+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 timeRemaining = coolingEndTime - now;
+    return {
+      canClaim: false,
+      reason: `Cooling period not expired. ${formatTimeRemaining(timeRemaining)} remaining.`,
+      timeRemainingSeconds: timeRemaining
+    };
+  }
+  return { canClaim: true };
+}
+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 {
+      canClaim: false,
+      reason: `Project must be in Funded, InProgress, or Completed state. Current state: ${stateStr}`
+    };
+  }
+  return { canClaim: true };
+}
+function canClaimFounderMilestoneTokens(milestone) {
+  const stateStr = getMilestoneStateString(milestone.state);
+  if (stateStr !== "unlocked") {
+    return {
+      canClaim: false,
+      reason: `Milestone must be in Unlocked state. Current state: ${stateStr}`
+    };
+  }
+  return { canClaim: true };
+}
+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";
+}
 
+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.accountExists = accountExists;
+exports.calculateEarlyTokenAmount = calculateEarlyTokenAmount;
+exports.calculateRemainingAllocation = calculateRemainingAllocation;
+exports.canClaimEarlyTokens = canClaimEarlyTokens;
+exports.canClaimFounderEarlyTokens = canClaimFounderEarlyTokens;
+exports.canClaimFounderMilestoneTokens = canClaimFounderMilestoneTokens;
+exports.canClaimRoundEarlyTokens = canClaimRoundEarlyTokens;
+exports.canOpenNextRound = canOpenNextRound;
 exports.fetchAdminConfig = fetchAdminConfig;
+exports.fetchAllAllocationProposals = fetchAllAllocationProposals;
+exports.fetchAllFundingRounds = fetchAllFundingRounds;
 exports.fetchAllInvestments = fetchAllInvestments;
 exports.fetchAllMilestones = fetchAllMilestones;
 exports.fetchAllVotes = fetchAllVotes;
+exports.fetchAllocationProposal = fetchAllocationProposal;
+exports.fetchAllocationVote = fetchAllocationVote;
+exports.fetchFounderMilestoneVesting = fetchFounderMilestoneVesting;
+exports.fetchFundingRound = fetchFundingRound;
+exports.fetchFutureRoundVault = fetchFutureRoundVault;
 exports.fetchInvestment = fetchInvestment;
+exports.fetchInvestorMilestoneVesting = fetchInvestorMilestoneVesting;
 exports.fetchMilestone = fetchMilestone;
 exports.fetchPivotProposal = fetchPivotProposal;
 exports.fetchProject = fetchProject;
 exports.fetchProjectByPda = fetchProjectByPda;
+exports.fetchRoundInvestment = fetchRoundInvestment;
+exports.fetchRoundInvestorMilestoneVesting = fetchRoundInvestorMilestoneVesting;
+exports.fetchRoundMilestone = fetchRoundMilestone;
+exports.fetchSubAllocationVesting = fetchSubAllocationVesting;
 exports.fetchTgeEscrow = fetchTgeEscrow;
+exports.fetchTokenVault = fetchTokenVault;
+exports.fetchTokenomics = fetchTokenomics;
 exports.fetchVote = fetchVote;
+exports.getRemainingFutureRoundAllocation = getRemainingFutureRoundAllocation;
+exports.isFundingRoundFullyFunded = isFundingRoundFullyFunded;
+exports.isR1FullyFunded = isR1FullyFunded;
+exports.isRoundFullyFunded = isRoundFullyFunded;
+exports.requiresBurnForRefund = requiresBurnForRefund;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map