@zemyth/raise-sdk 0.1.1 → 0.1.3

package/dist/index.d.ts

@@ -1,15 +1,15 @@
+import { MilestoneWithKey, InvestmentWithKey, VoteWithKey, AllocationProposalWithKey, TierConfig, FundingRoundWithKey } from './types/index.js';
+export { AdminConfigAccount, ClaimRoundInstantTokensArgs, ClaimRoundVestedTokensArgs, CreateMilestoneArgs, DepositTokensArgs, FundingRoundAccount, FundingRoundOpenedEvent, FundingRoundState, FutureRoundVaultAccount, FutureRoundVaultWithKey, InitializeProjectArgs, InvestArgs, InvestInRoundArgs, InvestmentAccount, InvestmentMadeEvent, MilestoneAccount, MilestoneState, MilestoneVoteCastEvent, MilestoneVoteFinalizedEvent, OpenFundingRoundArgs, PivotProposalAccount, PivotState, ProjectAccount, ProjectCreatedEvent, ProjectState, ProposePivotArgs, RoundEarlyTokensClaimedEvent, RoundInstantTokensClaimedEvent, RoundInvestmentMadeEvent, RoundMilestoneConfig, RoundMilestoneFinalizedEvent, RoundMilestoneVoteEvent, RoundVestedTokensClaimedEvent, SetTgeDateArgs, TgeEscrowAccount, Tier, VoteAccount, VoteChoice, VoteOnMilestoneArgs, VoteOnRoundMilestoneArgs } from './types/index.js';
 import { Program, AnchorProvider, BN } from '@coral-xyz/anchor';
 export { BN } from '@coral-xyz/anchor';
 import * as _solana_web3_js from '@solana/web3.js';
 import { Connection, PublicKey, Keypair, TransactionSignature } from '@solana/web3.js';
 export { Connection, Keypair, PublicKey } from '@solana/web3.js';
 import { TokenomicsInput } from './instructions/index.js';
-export { MAX_DEADLINE_DURATION_SECONDS, MIN_DEADLINE_DURATION_SECONDS_DEV, MIN_DEADLINE_DURATION_SECONDS_PROD, acceptAdmin, approvePivot, approveProject, calculateDeadline, cancelInvestment, checkAbandonment, claimExitWindowRefund, claimInvestorTokens, claimMilestoneFunds, claimMissedUnlock, claimRefund, claimTokens, claimVestedTokens, completeDistribution, createMilestone, depositTokens, distributeTokens, extendMilestoneDeadline, finalizePivot, finalizeVoting, forceCompleteDistribution, initializeAdmin, initializeFounderVesting, initializeProject, invest, minDeadline, proposePivot, releaseHoldback, reportScam, resubmitMilestone, setMilestoneDeadline, setTgeDate, submitForApproval, submitMilestone, symbolToBytes, transferAdmin, validateDeadline, voteOnMilestone, withdrawFromPivot } from './instructions/index.js';
-import { MilestoneWithKey, InvestmentWithKey, VoteWithKey, TierConfig } from './types/index.js';
-export { AdminConfigAccount, CreateMilestoneArgs, DepositTokensArgs, InitializeProjectArgs, InvestArgs, InvestmentAccount, InvestmentMadeEvent, MilestoneAccount, MilestoneState, MilestoneVoteCastEvent, MilestoneVoteFinalizedEvent, PivotProposalAccount, PivotState, ProjectAccount, ProjectCreatedEvent, ProjectState, ProposePivotArgs, SetTgeDateArgs, TgeEscrowAccount, Tier, VoteAccount, VoteChoice, VoteOnMilestoneArgs } from './types/index.js';
-export { GOVERNANCE, InvestmentTier, NFT, SEEDS, TIER_CONSTRAINTS, TIER_MINIMUMS, TIER_TOKEN_MULTIPLIERS, TIER_VOTE_MULTIPLIERS, TIMING, USDC, VALIDATION, findTierIndex, getTierFromAmount, getTokenMultiplier, getVoteMultiplier } from './constants/index.js';
-export { getAdminConfigPDA, getEscrowPDA, getFounderVaultPDA, getFounderVestingPDA, getInvestmentPDA, getInvestorVaultPDA, getLpTokenVaultPDA, getLpUsdcVaultPDA, getMilestonePDA, getNftMintPDA, getPivotProposalPDA, getProgramAuthorityPDA, getProjectPDA, getProjectPDAs, getScamReportPDA, getTgeEscrowPDA, getTokenMintPDA, getTokenVaultPDA, getTokenomicsPDA, getTreasuryVaultPDA, getVaultAuthorityPDA, getVotePDA } from './pdas/index.js';
-export { accountExists, fetchAdminConfig, fetchAllInvestments, fetchAllMilestones, fetchAllVotes, fetchInvestment, fetchMilestone, fetchPivotProposal, fetchProject, fetchProjectByPda, fetchTgeEscrow, fetchVote } from './accounts/index.js';
+export { MAX_DEADLINE_DURATION_SECONDS, MIN_DEADLINE_DURATION_SECONDS_DEV, MIN_DEADLINE_DURATION_SECONDS_PROD, acceptAdmin, approvePivot, approveProject, calculateDeadline, cancelInvestment, cancelRoundInvestment, checkAbandonment, claimExitWindowRefund, claimInvestorTokens, claimMilestoneFunds, claimMissedUnlock, claimRefund, claimRoundEarlyTokens, claimRoundInstantTokens, claimRoundMilestoneFunds, claimRoundVestedTokens, claimTokens, claimVestedTokens, completeDistribution, createMilestone, depositTokens, distributeTokens, extendMilestoneDeadline, finalizePivot, finalizeRoundVoting, finalizeVoting, forceCompleteDistribution, initializeAdmin, initializeFounderVesting, initializeProject, invest, investInRound, minDeadline, openFundingRound, proposePivot, releaseHoldback, reportScam, resubmitMilestone, setMilestoneDeadline, setTgeDate, submitForApproval, submitMilestone, submitRoundMilestone, symbolToBytes, transferAdmin, validateDeadline, voteOnMilestone, voteOnRoundMilestone, withdrawFromPivot } from './instructions/index.js';
+export { GOVERNANCE, InvestmentTier, NFT, SEEDS, TIER_CONSTRAINTS, TIER_MINIMUMS, TIER_TOKEN_MULTIPLIERS, TIER_VOTE_MULTIPLIERS, TIMING, TOKENOMICS, USDC, VALIDATION, findTierIndex, getTierFromAmount, getTokenMultiplier, getVoteMultiplier } from './constants/index.js';
+export { getAdminConfigPDA, getEscrowPDA, getFounderVaultPDA, getFounderVestingPDA, getFundingRoundPDA, getFutureRoundTokenVaultPDA, getFutureRoundVaultPDA, getInvestmentPDA, getInvestorVaultPDA, getLpTokenVaultPDA, getLpUsdcVaultPDA, getMilestonePDA, getNftMintPDA, getPivotProposalPDA, getProgramAuthorityPDA, getProjectPDA, getProjectPDAs, getRoundEscrowPDA, getRoundInvestmentPDA, getRoundInvestorMilestoneVestingPDA, getRoundMilestonePDA, getRoundNftMintPDA, getScamReportPDA, getTgeEscrowPDA, getTokenMintPDA, getTokenVaultPDA, getTokenomicsPDA, getTreasuryVaultPDA, getVaultAuthorityPDA, getVotePDA } from './pdas/index.js';
+export { EARLY_TOKEN_COOLING_PERIOD_SECONDS, EARLY_TOKEN_COOLING_PERIOD_SECONDS_DEV, EARLY_TOKEN_RELEASE_BPS, accountExists, calculateEarlyTokenAmount, calculateRemainingAllocation, canClaimEarlyTokens, canClaimFounderEarlyTokens, canClaimFounderMilestoneTokens, canClaimRoundEarlyTokens, fetchAdminConfig, fetchAllFundingRounds, fetchAllInvestments, fetchAllMilestones, fetchAllVotes, fetchFundingRound, fetchFutureRoundVault, fetchInvestment, fetchMilestone, fetchPivotProposal, fetchProject, fetchProjectByPda, fetchRoundInvestment, fetchRoundInvestorMilestoneVesting, fetchRoundMilestone, fetchTgeEscrow, fetchVote, requiresBurnForRefund } from './accounts/index.js';
 export { ERROR_CODES, ERROR_MESSAGES, RaiseError, getErrorMessage, isRaiseError, parseError } from './errors/index.js';
 
 /**
@@ -97,6 +97,12 @@ declare class RaiseClient {
     getTgeEscrowPDA(projectPda: PublicKey): PublicKey;
     getTgeEscrowVaultPDA(projectPda: PublicKey): PublicKey;
     getAdminConfigPDA(): PublicKey;
+    getAllocationProposalPDA(projectPda: PublicKey, proposalIndex: number): PublicKey;
+    getAllocationVotePDA(proposalPda: PublicKey, nftMint: PublicKey): PublicKey;
+    getSubAllocationVestingPDA(projectPda: PublicKey, subAllocationId: number): PublicKey;
+    getTokenomicsPDA(projectPda: PublicKey): PublicKey;
+    getInvestorMilestoneVestingPDA(projectPda: PublicKey, milestoneIndex: number, investmentPda: PublicKey): PublicKey;
+    getFounderMilestoneVestingPDA(projectPda: PublicKey, milestoneIndex: number): PublicKey;
     fetchProject(projectId: BN): Promise<any>;
     fetchMilestone(projectId: BN, milestoneIndex: number): Promise<any>;
     fetchAllMilestones(projectId: BN): Promise<MilestoneWithKey[]>;
@@ -107,6 +113,14 @@ declare class RaiseClient {
     fetchPivotProposal(projectId: BN): Promise<any>;
     fetchTgeEscrow(projectId: BN): Promise<any>;
     fetchAdminConfig(): Promise<any>;
+    fetchTokenVault(projectId: BN): Promise<any>;
+    fetchTokenomics(projectId: BN): Promise<any>;
+    fetchAllocationProposal(projectId: BN, proposalIndex: number): Promise<any>;
+    fetchAllAllocationProposals(projectId: BN): Promise<AllocationProposalWithKey[]>;
+    fetchAllocationVote(projectId: BN, proposalIndex: number, nftMint: PublicKey): Promise<any>;
+    fetchSubAllocationVesting(projectId: BN, subAllocationId: number): Promise<any>;
+    fetchInvestorMilestoneVesting(projectId: BN, milestoneIndex: number, nftMint: PublicKey): Promise<any>;
+    fetchFounderMilestoneVesting(projectId: BN, milestoneIndex: number): Promise<any>;
     initializeAdmin(admin: PublicKey): Promise<string>;
     transferAdmin(newAdmin: PublicKey, adminKeypair: Keypair): Promise<string>;
     acceptAdmin(): Promise<string>;
@@ -119,6 +133,8 @@ declare class RaiseClient {
         tokenomics: TokenomicsInput;
         /** Milestone 1 deadline - Unix timestamp (required) */
         milestone1Deadline: BN;
+        /** Milestone Price Increases: Price multipliers in BPS (optional, defaults to all 10000) */
+        priceMultipliers?: number[];
     }): Promise<string>;
     submitForApproval(projectId: BN): Promise<string>;
     approveProject(args: {
@@ -130,6 +146,9 @@ declare class RaiseClient {
         milestoneIndex: number;
         percentage: number;
         description: string;
+        vestingDurationMonths?: number | null;
+        cliffMonths?: number | null;
+        instantReleaseBps?: number | null;
     }): Promise<string>;
     submitMilestone(projectId: BN, milestoneIndex: number): Promise<string>;
     voteOnMilestone(args: {
@@ -338,6 +357,113 @@ declare class RaiseClient {
         milestoneIndex: number;
         claimerTokenAccount: PublicKey;
     }): Promise<string>;
+    /**
+     * 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
+     */
+    claimEarlyTokens(args: {
+        projectId: BN;
+        nftMint: PublicKey;
+        investorTokenAccount: PublicKey;
+    }): Promise<string>;
+    /**
+     * 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
+     */
+    claimFounderEarlyTokens(args: {
+        projectId: BN;
+        founderTokenAccount: PublicKey;
+    }): Promise<string>;
+    /**
+     * 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
+     */
+    claimFounderMilestoneTokens(args: {
+        projectId: BN;
+        milestoneIndex: number;
+        founderTokenAccount: PublicKey;
+    }): Promise<string>;
+    /**
+     * Claim instant tokens for a passed milestone (investor)
+     *
+     * 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
+     */
+    claimMilestoneInstantTokens(args: {
+        projectId: BN;
+        milestoneIndex: number;
+        nftMint: PublicKey;
+        investorTokenAccount: PublicKey;
+    }): Promise<string>;
+    /**
+     * Claim vested tokens for a milestone after cliff period (investor)
+     *
+     * 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
+     */
+    claimMilestoneVestedTokens(args: {
+        projectId: BN;
+        milestoneIndex: number;
+        nftMint: PublicKey;
+        investorTokenAccount: PublicKey;
+    }): Promise<string>;
+    /**
+     * Claim instant tokens for a passed milestone (founder)
+     *
+     * 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
+     */
+    claimFounderMsInstantTokens(args: {
+        projectId: BN;
+        milestoneIndex: number;
+        founderTokenAccount: PublicKey;
+    }): Promise<string>;
+    /**
+     * Claim vested tokens for a milestone after cliff period (founder)
+     *
+     * 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
+     */
+    claimFounderMsVestedTokens(args: {
+        projectId: BN;
+        milestoneIndex: number;
+        founderTokenAccount: PublicKey;
+    }): Promise<string>;
     checkAbandonment(projectId: BN, milestoneIndex?: number): Promise<string>;
     claimRefund(args: {
         projectId: BN;
@@ -347,6 +473,439 @@ declare class RaiseClient {
         escrowTokenAccount: PublicKey;
         milestoneCount?: number;
     }): Promise<string>;
+    /**
+     * 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.
+     */
+    initializeSubAllocationVesting(args: {
+        projectId: BN;
+        subAllocationId: number;
+    }): Promise<string>;
+    /**
+     * Claim vested tokens from a sub-allocation
+     *
+     * Only the designated recipient wallet can claim tokens.
+     * Project must be Completed and MAE must be completed.
+     */
+    claimSubAllocationTokens(args: {
+        projectId: BN;
+        subAllocationId: number;
+        recipientTokenAccount: PublicKey;
+    }): Promise<string>;
+    /**
+     * 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.
+     */
+    addSubAllocation(args: {
+        projectId: BN;
+        name: string;
+        bps: number;
+        recipient: PublicKey;
+        vestingMonths: number;
+        cliffMonths: number;
+    }): Promise<string>;
+    /**
+     * 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.
+     */
+    proposeAllocationChange(args: {
+        projectId: BN;
+        name: string;
+        bps: number;
+        recipient: PublicKey;
+        vestingMonths: number;
+        cliffMonths: number;
+    }): Promise<string>;
+    /**
+     * Vote on an allocation change proposal
+     *
+     * Investors can vote for/against using their Investment NFT.
+     * Must meet 7-day hold period for voting eligibility.
+     */
+    voteAllocationChange(args: {
+        projectId: BN;
+        proposalIndex: number;
+        nftMint: PublicKey;
+        voteFor: boolean;
+    }): Promise<string>;
+    /**
+     * Execute an approved allocation change proposal
+     *
+     * Permissionless - anyone can call after voting ends.
+     * Proposal must have passed (>51% approval).
+     */
+    executeAllocationChange(args: {
+        projectId: BN;
+        proposalIndex: number;
+    }): Promise<string>;
+    /**
+     * 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.
+     */
+    getRemainingFounderPool(projectId: BN): Promise<number>;
+    /**
+     * Get all active (non-executed, non-expired) allocation proposals
+     */
+    getActiveProposals(projectId: BN): Promise<AllocationProposalWithKey[]>;
+    /**
+     * Get vesting status for a sub-allocation
+     *
+     * Returns claimable amount, total vested, and remaining locked tokens.
+     */
+    getSubAllocationVestingStatus(projectId: BN, subAllocationId: number): Promise<{
+        totalAmount: any;
+        vestedAmount: any;
+        claimedAmount: any;
+        claimableAmount: number;
+        lockedAmount: number;
+        vestingProgress: number;
+        cliffPassed: boolean;
+    } | null>;
+    /** Base price multiplier constant (10000 BPS = 1.0x) */
+    static readonly PRICE_MULTIPLIER_BASE = 10000;
+    /**
+     * 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
+     */
+    getCurrentMultiplier(projectId: BN): Promise<number>;
+    /**
+     * Check if a project uses dynamic price multiplier mode
+     */
+    isDynamicMultiplierMode(projectId: BN): Promise<boolean>;
+    /**
+     * Calculate effective tier prices with current multiplier
+     *
+     * Returns array of tiers with their effective prices after applying
+     * the current milestone multiplier.
+     */
+    getEffectiveTierPrices(projectId: BN): Promise<Array<{
+        tierIndex: number;
+        baseAmount: BN;
+        effectiveAmount: BN;
+        multiplierBps: number;
+    }>>;
+    /**
+     * 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.
+     */
+    getPriceSchedule(projectId: BN): Promise<Array<{
+        afterMilestone: number;
+        multiplierBps: number;
+        multiplierPercent: number;
+    }> | null>;
+    /**
+     * 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: number, daysToDeadline: number): number;
+    /** Time factor lookup for dynamic multiplier preview (approximates 1/ln(d/7 + e) × 1000) */
+    private timeFactorLookup;
+    /** Constants for progressive pricing */
+    static readonly TIME_ALLOCATION_PERCENT = 50;
+    static readonly MILESTONE_ALLOCATION_PERCENT = 50;
+    /** DEV MODE: Time acceleration multiplier (10 real seconds = 1 simulated day) */
+    static readonly 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: {
+        milestonePeriodStartedAt: BN;
+    }): boolean;
+    /**
+     * 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: {
+        milestonePeriodStartedAt: BN;
+        expectedMilestoneDeadlineTs: BN;
+    }, currentTime: number): number;
+    /**
+     * 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: {
+        milestonePeriodStartedAt: BN;
+        expectedMilestoneDeadlineTs: BN;
+        milestoneBaseMultiplierBps: number;
+        timeAllocationBps: number;
+        currentPriceMultiplierBps: number;
+        priceMultipliers: number[];
+    }, currentTime: number): number;
+    /**
+     * 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: {
+        milestonePeriodStartedAt: BN;
+        expectedMilestoneDeadlineTs: BN;
+        milestoneBaseMultiplierBps: number;
+        timeAllocationBps: number;
+        milestoneAllocationBps: number;
+    }, claimTime: number): {
+        timeProgress: number;
+        consumedTimeBps: number;
+        unusedTimeBps: number;
+        milestoneSpikeBps: number;
+        effectiveMultiplierBps: number;
+        newBaseBps: number;
+    };
+    /**
+     * 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: {
+        tiers: Array<{
+            amount: BN;
+        }>;
+        tierCount: number;
+        milestonePeriodStartedAt: BN;
+        expectedMilestoneDeadlineTs: BN;
+        milestoneBaseMultiplierBps: number;
+        timeAllocationBps: number;
+        currentPriceMultiplierBps: number;
+        priceMultipliers: number[];
+    }, currentTime: number): Array<{
+        tierIndex: number;
+        baseAmount: BN;
+        effectiveAmount: BN;
+        multiplierBps: number;
+        timeProgressPercent: number;
+    }>;
+    getFundingRoundPDA(projectPda: PublicKey, roundNumber: number): PublicKey;
+    getRoundEscrowPDA(projectPda: PublicKey, roundNumber: number): PublicKey;
+    getRoundMilestonePDA(projectPda: PublicKey, roundNumber: number, milestoneIndex: number): PublicKey;
+    getRoundInvestmentPDA(projectPda: PublicKey, roundNumber: number, nftMint: PublicKey): PublicKey;
+    getRoundInvestorMilestoneVestingPDA(projectPda: PublicKey, roundNumber: number, milestoneIndex: number, investmentPda: PublicKey): PublicKey;
+    getFutureRoundVaultPDA(projectPda: PublicKey): PublicKey;
+    getFutureRoundTokenVaultPDA(projectPda: PublicKey): PublicKey;
+    fetchFundingRound(projectId: BN, roundNumber: number): Promise<any>;
+    fetchAllFundingRounds(projectId: BN): Promise<FundingRoundWithKey[]>;
+    fetchRoundMilestone(projectId: BN, roundNumber: number, milestoneIndex: number): Promise<any>;
+    fetchRoundInvestment(projectId: BN, roundNumber: number, nftMint: PublicKey): Promise<any>;
+    fetchFutureRoundVault(projectId: BN): Promise<any>;
+    /**
+     * 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
+     */
+    openFundingRound(args: {
+        projectId: BN;
+        roundAllocationBps: number;
+        fundingGoal: BN;
+        tiers: Array<{
+            amount: BN;
+            maxLots: number;
+            tokenRatio: BN;
+        }>;
+        milestones: Array<{
+            percentage: number;
+            description: string;
+            vestingDurationMonths?: number | null;
+            cliffMonths?: number | null;
+            instantReleaseBps?: number | null;
+        }>;
+        usdcMint: PublicKey;
+        previousFundingRoundPda?: PublicKey | null;
+    }): Promise<string>;
+    /**
+     * 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.
+     */
+    investInRound(args: {
+        projectId: BN;
+        roundNumber: number;
+        amount: BN;
+        investorTokenAccount: PublicKey;
+        investmentCount: number;
+    }): Promise<string>;
+    /**
+     * Cancel round investment within 24-hour cooling-off period
+     *
+     * Multi-Round Fundraising: Returns USDC from round escrow,
+     * closes investment account.
+     */
+    cancelRoundInvestment(args: {
+        projectId: BN;
+        roundNumber: number;
+        nftMint: PublicKey;
+        investorNftAccount: PublicKey;
+        investorUsdcAccount: PublicKey;
+    }): Promise<string>;
+    /**
+     * Submit round milestone for investor review
+     *
+     * Multi-Round Fundraising: Transitions milestone to UnderReview,
+     * sets voting deadline.
+     */
+    submitRoundMilestone(args: {
+        projectId: BN;
+        roundNumber: number;
+        milestoneIndex: number;
+    }): Promise<string>;
+    /**
+     * Vote on a round milestone (unified voting - ANY investor can vote)
+     *
+     * Multi-Round Fundraising: R1, R2, R3... investors can all vote
+     * on any round's milestones. Investment can be from any round.
+     */
+    voteOnRoundMilestone(args: {
+        projectId: BN;
+        roundNumber: number;
+        milestoneIndex: number;
+        nftMint: PublicKey | string;
+        choice: {
+            good: object;
+        } | {
+            bad: object;
+        };
+        investmentRoundNumber: number;
+    }): Promise<string>;
+    /**
+     * Finalize voting on a round milestone
+     *
+     * Multi-Round Fundraising: Processes vote results, transitions
+     * milestone to Passed or Failed state.
+     */
+    finalizeRoundVoting(args: {
+        projectId: BN;
+        roundNumber: number;
+        milestoneIndex: number;
+    }): Promise<string>;
+    /**
+     * Claim milestone funds from a round (founder)
+     *
+     * 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
+     */
+    claimRoundMilestoneFunds(args: {
+        projectId: BN;
+        roundNumber: number;
+        milestoneIndex: number;
+        founderUsdcAccount: PublicKey;
+        nextMilestoneDeadline: BN;
+    }): Promise<string>;
+    /**
+     * Claim instant tokens for a round milestone (investor)
+     *
+     * Multi-Round Fundraising: R2+ investors claim instant portion
+     * when milestone passes. Tokens come from FutureRoundVault.
+     */
+    claimRoundInstantTokens(args: {
+        projectId: BN;
+        roundNumber: number;
+        milestoneIndex: number;
+        nftMint: PublicKey;
+        investorTokenAccount: PublicKey;
+    }): Promise<string>;
+    /**
+     * Claim vested tokens for a round milestone (investor)
+     *
+     * Multi-Round Fundraising: R2+ investors claim vested portion
+     * after cliff period. Tokens come from FutureRoundVault.
+     */
+    claimRoundVestedTokens(args: {
+        projectId: BN;
+        roundNumber: number;
+        milestoneIndex: number;
+        nftMint: PublicKey;
+        investorTokenAccount: PublicKey;
+    }): Promise<string>;
+    /**
+     * Claim early tokens for a round investment (5% after 24h)
+     *
+     * Multi-Round Fundraising: R2+ investors claim 5% of token allocation
+     * 24 hours after investing. Tokens come from FutureRoundVault.
+     */
+    claimRoundEarlyTokens(args: {
+        projectId: BN;
+        roundNumber: number;
+        nftMint: PublicKey;
+        investorTokenAccount: PublicKey;
+    }): Promise<string>;
+    /**
+     * Check if the next funding round can be opened
+     *
+     * Returns eligibility status with reason and next round number.
+     */
+    canOpenNextRound(projectId: BN): Promise<{
+        canOpen: boolean;
+        reason?: string;
+        nextRoundNumber?: number;
+    }>;
+    /**
+     * Get remaining future round allocation in BPS
+     */
+    getRemainingFutureRoundAllocation(tokenomics: {
+        futureRoundAllocationBps: number;
+        usedFutureRoundBps?: number;
+    }): number;
+    /**
+     * Check if a specific round is fully funded
+     */
+    isRoundFullyFunded(projectId: BN, roundNumber: number): Promise<boolean>;
+    /**
+     * Get round details with computed state
+     *
+     * Returns funding round data with additional computed fields.
+     */
+    getRoundDetails(projectId: BN, roundNumber: number): Promise<any>;
 }
 
 /**
@@ -677,4 +1236,4 @@ declare function isValidPublicKey(pubkey: string | PublicKey): boolean;
  */
 declare function shortenPublicKey(pubkey: PublicKey | string, chars?: number): string;
 
-export { EVENT_NAMES, type InvestmentMadeEvent as InvestmentMadeEventType, InvestmentWithKey, type MilestoneReworkedEvent as MilestoneReworkedEventType, type MilestoneVoteFinalizedEvent as MilestoneVoteFinalizedEventType, MilestoneWithKey, type ProjectCreatedEvent as ProjectCreatedEventType, RaiseClient, type RaiseEvent, TierConfig, TokenomicsInput, VoteWithKey, type Wallet, bigIntToBN, bnToBigInt, bnToNumber, bpsToPercent, confirmTransaction, filterEventsByName, findEvent, formatDuration, getCurrentTimestamp, getTransactionWithRetry, hasTimestampPassed, isValidPublicKey, percentToBps, percentageOf, shortenPublicKey, timeRemaining, timestampToDate, validateMetadataUri, validateMilestonePercentages };
+export { EVENT_NAMES, FundingRoundWithKey, type InvestmentMadeEvent as InvestmentMadeEventType, InvestmentWithKey, type MilestoneReworkedEvent as MilestoneReworkedEventType, type MilestoneVoteFinalizedEvent as MilestoneVoteFinalizedEventType, MilestoneWithKey, type ProjectCreatedEvent as ProjectCreatedEventType, RaiseClient, type RaiseEvent, TierConfig, TokenomicsInput, VoteWithKey, type Wallet, bigIntToBN, bnToBigInt, bnToNumber, bpsToPercent, confirmTransaction, filterEventsByName, findEvent, formatDuration, getCurrentTimestamp, getTransactionWithRetry, hasTimestampPassed, isValidPublicKey, percentToBps, percentageOf, shortenPublicKey, timeRemaining, timestampToDate, validateMetadataUri, validateMilestonePercentages };