@zemyth/raise-sdk 0.1.1 → 0.1.3

package/dist/accounts/index.js

@@ -1,7 +1,7 @@
-import { PublicKey } from '@solana/web3.js';
 import { BN } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
 
-// src/pdas/index.ts
+// src/accounts/index.ts
 
 // src/constants/index.ts
 var SEEDS = {
@@ -11,7 +11,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) {
@@ -77,6 +82,13 @@ function getTgeEscrowPDA(projectPda, programId) {
   );
   return pda;
 }
+function getTokenVaultPDA(projectPda, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from("token_vault"), projectPda.toBuffer()],
+    programId
+  );
+  return pda;
+}
 function getAdminConfigPDA(programId) {
   const [pda] = PublicKey.findProgramAddressSync(
     [Buffer.from(SEEDS.ADMIN_CONFIG)],
@@ -84,6 +96,124 @@ function getAdminConfigPDA(programId) {
   );
   return pda;
 }
+function getTokenomicsPDA(projectPda, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from("tokenomics"), projectPda.toBuffer()],
+    programId
+  );
+  return pda;
+}
+function getAllocationProposalPDA(projectPda, proposalIndex, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("allocation_proposal"),
+      projectPda.toBuffer(),
+      Buffer.from([proposalIndex])
+    ],
+    programId
+  );
+  return pda;
+}
+function getAllocationVotePDA(proposalPda, nftMint, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("allocation_vote"),
+      proposalPda.toBuffer(),
+      nftMint.toBuffer()
+    ],
+    programId
+  );
+  return pda;
+}
+function getSubAllocationVestingPDA(projectPda, subAllocationId, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("sub_allocation_vesting"),
+      projectPda.toBuffer(),
+      Buffer.from([subAllocationId])
+    ],
+    programId
+  );
+  return pda;
+}
+function getInvestorMilestoneVestingPDA(projectPda, milestoneIndex, investmentPda, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("investor_ms_vesting"),
+      projectPda.toBuffer(),
+      Buffer.from([milestoneIndex]),
+      investmentPda.toBuffer()
+    ],
+    programId
+  );
+  return pda;
+}
+function getFounderMilestoneVestingPDA(projectPda, milestoneIndex, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("founder_ms_vesting"),
+      projectPda.toBuffer(),
+      Buffer.from([milestoneIndex])
+    ],
+    programId
+  );
+  return pda;
+}
+function getFutureRoundVaultPDA(projectPda, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from(SEEDS.FUTURE_ROUND_STATE), projectPda.toBuffer()],
+    programId
+  );
+  return pda;
+}
+function getFundingRoundPDA(projectPda, roundNumber, programId) {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [
+      Buffer.from(SEEDS.FUNDING_ROUND),
+      projectPda.toBuffer(),
+      Buffer.from([roundNumber])
+    ],
+    programId
+  );
+  return pda;
+}
+function getRoundMilestonePDA(projectPda, roundNumber, milestoneIndex, programId) {
+  const [pda] = 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] = 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] = 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) {
@@ -231,6 +361,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);
@@ -239,7 +381,364 @@ 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 BN(tokensAllocated) : tokensAllocated;
+  return allocated.muln(EARLY_TOKEN_RELEASE_BPS).divn(1e4);
+}
+function calculateRemainingAllocation(tokensAllocated) {
+  const allocated = typeof tokensAllocated === "number" ? new 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 BN(project.totalRaised) : project.totalRaised;
+  const goal = typeof project.fundingGoal === "number" ? new 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";
+}
 
-export { accountExists, fetchAdminConfig, fetchAllInvestments, fetchAllMilestones, fetchAllVotes, fetchInvestment, fetchMilestone, fetchPivotProposal, fetchProject, fetchProjectByPda, fetchTgeEscrow, fetchVote };
+export { EARLY_TOKEN_COOLING_PERIOD_SECONDS, EARLY_TOKEN_COOLING_PERIOD_SECONDS_DEV, EARLY_TOKEN_RELEASE_BPS, accountExists, calculateEarlyTokenAmount, calculateRemainingAllocation, canClaimEarlyTokens, canClaimFounderEarlyTokens, canClaimFounderMilestoneTokens, canClaimRoundEarlyTokens, canOpenNextRound, fetchAdminConfig, fetchAllAllocationProposals, fetchAllFundingRounds, fetchAllInvestments, fetchAllMilestones, fetchAllVotes, fetchAllocationProposal, fetchAllocationVote, fetchFounderMilestoneVesting, fetchFundingRound, fetchFutureRoundVault, fetchInvestment, fetchInvestorMilestoneVesting, fetchMilestone, fetchPivotProposal, fetchProject, fetchProjectByPda, fetchRoundInvestment, fetchRoundInvestorMilestoneVesting, fetchRoundMilestone, fetchSubAllocationVesting, fetchTgeEscrow, fetchTokenVault, fetchTokenomics, fetchVote, getRemainingFutureRoundAllocation, isFundingRoundFullyFunded, isR1FullyFunded, isRoundFullyFunded, requiresBurnForRefund };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map