@zemyth/raise-sdk 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,680 @@
+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.cjs';
+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.cjs';
+import { MilestoneWithKey, InvestmentWithKey, VoteWithKey, TierConfig } from './types/index.cjs';
+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.cjs';
+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.cjs';
+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.cjs';
+export { accountExists, fetchAdminConfig, fetchAllInvestments, fetchAllMilestones, fetchAllVotes, fetchInvestment, fetchMilestone, fetchPivotProposal, fetchProject, fetchProjectByPda, fetchTgeEscrow, fetchVote } from './accounts/index.cjs';
+export { ERROR_CODES, ERROR_MESSAGES, RaiseError, getErrorMessage, isRaiseError, parseError } from './errors/index.cjs';
+
+/**
+ * Wallet interface required by the client
+ */
+interface Wallet {
+    publicKey: PublicKey;
+    signTransaction: <T>(tx: T) => Promise<T>;
+    signAllTransactions: <T>(txs: T[]) => Promise<T[]>;
+}
+/**
+ * Main client for interacting with the Raise program
+ *
+ * @example
+ * ```typescript
+ * import { RaiseClient } from '@raise/sdk';
+ *
+ * const client = RaiseClient.load(connection, wallet);
+ *
+ * // Create a project
+ * const tx = await client.initializeProject({
+ *   projectId: new BN(1),
+ *   fundingGoal: new BN(100000000000), // 100,000 USDC
+ *   metadataUri: 'https://example.com/project.json',
+ * });
+ *
+ * // Fetch project data
+ * const project = await client.fetchProject(new BN(1));
+ * ```
+ */
+declare class RaiseClient {
+    readonly program: Program<any>;
+    readonly provider: AnchorProvider;
+    /**
+     * Create a new RaiseClient
+     *
+     * @param program - Anchor program instance
+     * @param provider - Anchor provider
+     */
+    constructor(program: Program<any>, provider: AnchorProvider);
+    /**
+     * 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: Connection, _wallet: Wallet, _programId?: PublicKey): RaiseClient;
+    /**
+     * 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);
+     * ```
+     */
+    static fromProgram(program: Program<any>): RaiseClient;
+    /**
+     * Get the program ID
+     */
+    get programId(): PublicKey;
+    /**
+     * Get the connected wallet public key
+     */
+    get walletPublicKey(): PublicKey;
+    getProjectPDA(projectId: BN): PublicKey;
+    getEscrowPDA(projectId: BN): PublicKey;
+    getMilestonePDA(projectPda: PublicKey, milestoneIndex: number): PublicKey;
+    getInvestmentPDA(projectPda: PublicKey, nftMint: PublicKey): PublicKey;
+    getVotePDA(milestonePda: PublicKey, voterKey: PublicKey, votingRound: number): PublicKey;
+    getPivotProposalPDA(projectPda: PublicKey, pivotCount: number): PublicKey;
+    getTgeEscrowPDA(projectPda: PublicKey): PublicKey;
+    getTgeEscrowVaultPDA(projectPda: PublicKey): PublicKey;
+    getAdminConfigPDA(): PublicKey;
+    fetchProject(projectId: BN): Promise<any>;
+    fetchMilestone(projectId: BN, milestoneIndex: number): Promise<any>;
+    fetchAllMilestones(projectId: BN): Promise<MilestoneWithKey[]>;
+    fetchInvestment(projectId: BN, nftMint: PublicKey): Promise<any>;
+    fetchAllInvestments(projectId: BN): Promise<InvestmentWithKey[]>;
+    fetchVote(projectId: BN, milestoneIndex: number, voterKey: PublicKey, votingRound: number): Promise<any>;
+    fetchAllVotes(projectId: BN, milestoneIndex: number): Promise<VoteWithKey[]>;
+    fetchPivotProposal(projectId: BN): Promise<any>;
+    fetchTgeEscrow(projectId: BN): Promise<any>;
+    fetchAdminConfig(): Promise<any>;
+    initializeAdmin(admin: PublicKey): Promise<string>;
+    transferAdmin(newAdmin: PublicKey, adminKeypair: Keypair): Promise<string>;
+    acceptAdmin(): Promise<string>;
+    initializeProject(args: {
+        projectId: BN;
+        fundingGoal: BN;
+        metadataUri: string;
+        tiers: TierConfig[];
+        /** ZTM v2.0: Tokenomics configuration */
+        tokenomics: TokenomicsInput;
+        /** Milestone 1 deadline - Unix timestamp (required) */
+        milestone1Deadline: BN;
+    }): Promise<string>;
+    submitForApproval(projectId: BN): Promise<string>;
+    approveProject(args: {
+        projectId: BN;
+        usdcMint: PublicKey;
+    }, adminKeypair: Keypair): Promise<string>;
+    createMilestone(args: {
+        projectId: BN;
+        milestoneIndex: number;
+        percentage: number;
+        description: string;
+    }): Promise<string>;
+    submitMilestone(projectId: BN, milestoneIndex: number): Promise<string>;
+    voteOnMilestone(args: {
+        projectId: BN;
+        milestoneIndex: number;
+        nftMint: PublicKey | string;
+        choice: {
+            good: object;
+        } | {
+            bad: object;
+        };
+    }): Promise<string>;
+    finalizeVoting(projectId: BN, milestoneIndex: number): Promise<string>;
+    /**
+     * 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)
+     */
+    claimMilestoneFunds(args: {
+        projectId: BN;
+        milestoneIndex: number;
+        founderUsdcAccount: PublicKey;
+        escrowTokenAccount: PublicKey;
+        /** Deadline for next milestone - required for non-final milestones, use BN(0) for final */
+        nextMilestoneDeadline: BN;
+        /** Next milestone PDA - optional, auto-derived if not provided */
+        nextMilestonePda?: PublicKey;
+    }): Promise<string>;
+    /**
+     * 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.
+     */
+    resubmitMilestone(args: {
+        projectId: BN;
+        milestoneIndex: number;
+    }): Promise<string>;
+    /**
+     * 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.
+     */
+    setMilestoneDeadline(args: {
+        projectId: BN;
+        milestoneIndex: number;
+        /** Unix timestamp for the deadline */
+        deadline: BN;
+    }): Promise<string>;
+    /**
+     * 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.
+     */
+    extendMilestoneDeadline(args: {
+        projectId: BN;
+        milestoneIndex: number;
+        /** New deadline timestamp (must be > current deadline) */
+        newDeadline: BN;
+    }): Promise<string>;
+    invest(args: {
+        projectId: BN;
+        amount: BN;
+        investorTokenAccount: PublicKey;
+        escrowTokenAccount: PublicKey;
+        investmentCount: number;
+    }): Promise<string>;
+    cancelInvestment(args: {
+        projectId: BN;
+        nftMint: PublicKey;
+        investorNftAccount: PublicKey;
+        investorUsdcAccount: PublicKey;
+        escrowTokenAccount: PublicKey;
+    }): Promise<string>;
+    proposePivot(args: {
+        projectId: BN;
+        newMetadataUri: string;
+        newMilestones: Array<{
+            percentage: number;
+            description: string;
+        }>;
+    }): Promise<string>;
+    approvePivot(projectId: BN, adminKeypair: Keypair): Promise<string>;
+    withdrawFromPivot(args: {
+        projectId: BN;
+        pivotCount: number;
+        nftMint: PublicKey;
+        investorTokenAccount: PublicKey;
+        escrowTokenAccount: PublicKey;
+        milestoneAccounts: PublicKey[];
+    }): Promise<string>;
+    finalizePivot(args: {
+        projectId: BN;
+        pivotCount: number;
+        milestoneAccounts: PublicKey[];
+    }): Promise<string>;
+    setTgeDate(args: {
+        projectId: BN;
+        tgeDate: BN;
+        tokenMint: PublicKey;
+    }): Promise<string>;
+    depositTokens(args: {
+        projectId: BN;
+        amount: BN;
+        tokenMint: PublicKey;
+        founderTokenAccount: PublicKey;
+    }): Promise<string>;
+    claimTokens(args: {
+        projectId: BN;
+        nftMint: PublicKey;
+        investorNftAccount: PublicKey;
+        investorTokenAccount: PublicKey;
+        projectTokenVault: PublicKey;
+    }): Promise<string>;
+    reportScam(args: {
+        projectId: BN;
+        nftMint: PublicKey;
+    }): Promise<string>;
+    releaseHoldback(args: {
+        projectId: BN;
+        founderTokenAccount: PublicKey;
+    }): Promise<string>;
+    /**
+     * 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.
+     */
+    claimInvestorTokens(args: {
+        projectId: BN;
+        milestoneIndex: number;
+        nftMint: PublicKey;
+        investorTokenAccount: PublicKey;
+    }): Promise<string>;
+    /**
+     * 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)
+     */
+    distributeTokens(args: {
+        projectId: BN;
+        milestoneIndex: number;
+        investments: Array<{
+            investmentPda: PublicKey;
+            investorTokenAccount: PublicKey;
+        }>;
+    }): Promise<string>;
+    /**
+     * 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.
+     */
+    completeDistribution(args: {
+        projectId: BN;
+        milestoneIndex: number;
+    }): Promise<string>;
+    /**
+     * 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.
+     */
+    initializeFounderVesting(args: {
+        projectId: BN;
+    }): Promise<string>;
+    /**
+     * 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.
+     */
+    claimVestedTokens(args: {
+        projectId: BN;
+        founderTokenAccount: PublicKey;
+    }): Promise<string>;
+    /**
+     * 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.
+     */
+    forceCompleteDistribution(args: {
+        projectId: BN;
+    }, adminKeypair: Keypair): Promise<string>;
+    /**
+     * 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.
+     */
+    claimMissedUnlock(args: {
+        projectId: BN;
+        nftMint: PublicKey;
+        milestoneIndex: number;
+        claimerTokenAccount: PublicKey;
+    }): Promise<string>;
+    checkAbandonment(projectId: BN, milestoneIndex?: number): Promise<string>;
+    claimRefund(args: {
+        projectId: BN;
+        nftMint: PublicKey;
+        investorNftAccount: PublicKey;
+        investorUsdcAccount: PublicKey;
+        escrowTokenAccount: PublicKey;
+        milestoneCount?: number;
+    }): Promise<string>;
+}
+
+/**
+ * Raise Event Parsing
+ *
+ * Helpers for parsing program events from transaction logs.
+ */
+
+interface ProjectCreatedEvent {
+    name: 'ProjectCreated';
+    data: {
+        projectId: BN;
+        founder: PublicKey;
+        fundingGoal: BN;
+        metadataUri: string;
+    };
+}
+interface ProjectApprovedEvent {
+    name: 'ProjectApproved';
+    data: {
+        projectId: BN;
+    };
+}
+interface ProjectFundedEvent {
+    name: 'ProjectFunded';
+    data: {
+        projectId: BN;
+        amountRaised: BN;
+    };
+}
+interface InvestmentMadeEvent {
+    name: 'InvestmentMade';
+    data: {
+        projectId: BN;
+        investor: PublicKey;
+        amount: BN;
+        nftMint: PublicKey;
+        tier: number;
+        voteWeight: BN;
+    };
+}
+interface InvestmentCancelledEvent {
+    name: 'InvestmentCancelled';
+    data: {
+        projectId: BN;
+        investor: PublicKey;
+        amount: BN;
+        nftMint: PublicKey;
+    };
+}
+interface MilestoneCreatedEvent {
+    name: 'MilestoneCreated';
+    data: {
+        projectId: BN;
+        milestoneIndex: number;
+        percentage: number;
+        description: string;
+    };
+}
+interface MilestoneSubmittedEvent {
+    name: 'MilestoneSubmitted';
+    data: {
+        projectId: BN;
+        milestoneIndex: number;
+        votingEndsAt: BN;
+    };
+}
+interface VoteCastEvent {
+    name: 'VoteCast';
+    data: {
+        projectId: BN;
+        milestoneIndex: number;
+        voter: PublicKey;
+        choice: {
+            good: object;
+        } | {
+            bad: object;
+        };
+        weight: BN;
+    };
+}
+interface MilestoneVoteFinalizedEvent {
+    name: 'MilestoneVoteFinalized';
+    data: {
+        projectId: BN;
+        milestoneIndex: number;
+        passed: boolean;
+        yesVotes: BN;
+        noVotes: BN;
+    };
+}
+interface FundsUnlockedEvent {
+    name: 'FundsUnlocked';
+    data: {
+        projectId: BN;
+        milestoneIndex: number;
+        amount: BN;
+    };
+}
+interface TgeDateSetEvent {
+    name: 'TgeDateSet';
+    data: {
+        projectId: BN;
+        tgeDate: BN;
+        tokenMint: PublicKey;
+    };
+}
+interface TokensDepositedEvent {
+    name: 'TokensDeposited';
+    data: {
+        projectId: BN;
+        amount: BN;
+    };
+}
+interface TokensClaimedEvent {
+    name: 'TokensClaimed';
+    data: {
+        projectId: BN;
+        investor: PublicKey;
+        amount: BN;
+    };
+}
+interface RefundClaimedEvent {
+    name: 'RefundClaimed';
+    data: {
+        projectId: BN;
+        investor: PublicKey;
+        amount: BN;
+    };
+}
+interface PivotProposedEvent {
+    name: 'PivotProposed';
+    data: {
+        projectId: BN;
+        newMetadataUri: string;
+    };
+}
+interface PivotApprovedEvent {
+    name: 'PivotApproved';
+    data: {
+        projectId: BN;
+        withdrawalWindowEndsAt: BN;
+    };
+}
+interface PivotFinalizedEvent {
+    name: 'PivotFinalized';
+    data: {
+        projectId: BN;
+        withdrawnAmount: BN;
+        withdrawnCount: number;
+    };
+}
+interface MilestoneReworkedEvent {
+    name: 'MilestoneReworked';
+    data: {
+        projectId: BN;
+        milestoneIndex: number;
+        milestoneKey: PublicKey;
+        consecutiveFailures: number;
+        reworkedAt: BN;
+    };
+}
+type RaiseEvent = ProjectCreatedEvent | ProjectApprovedEvent | ProjectFundedEvent | InvestmentMadeEvent | InvestmentCancelledEvent | MilestoneCreatedEvent | MilestoneSubmittedEvent | VoteCastEvent | MilestoneVoteFinalizedEvent | FundsUnlockedEvent | TgeDateSetEvent | TokensDepositedEvent | TokensClaimedEvent | RefundClaimedEvent | PivotProposedEvent | PivotApprovedEvent | PivotFinalizedEvent | MilestoneReworkedEvent;
+/**
+ * Event name constants
+ */
+declare const EVENT_NAMES: {
+    readonly ProjectCreated: "ProjectCreated";
+    readonly ProjectApproved: "ProjectApproved";
+    readonly ProjectFunded: "ProjectFunded";
+    readonly InvestmentMade: "InvestmentMade";
+    readonly InvestmentCancelled: "InvestmentCancelled";
+    readonly MilestoneCreated: "MilestoneCreated";
+    readonly MilestoneSubmitted: "MilestoneSubmitted";
+    readonly VoteCast: "VoteCast";
+    readonly MilestoneVoteFinalized: "MilestoneVoteFinalized";
+    readonly FundsUnlocked: "FundsUnlocked";
+    readonly TgeDateSet: "TgeDateSet";
+    readonly TokensDeposited: "TokensDeposited";
+    readonly TokensClaimed: "TokensClaimed";
+    readonly RefundClaimed: "RefundClaimed";
+    readonly PivotProposed: "PivotProposed";
+    readonly PivotApproved: "PivotApproved";
+    readonly PivotFinalized: "PivotFinalized";
+    readonly MilestoneReworked: "MilestoneReworked";
+};
+/**
+ * Filter events by name
+ *
+ * @param events - Array of events
+ * @param name - Event name to filter
+ * @returns Filtered events
+ */
+declare function filterEventsByName<T extends RaiseEvent>(events: RaiseEvent[], name: T['name']): T[];
+/**
+ * Get the first event of a specific type
+ *
+ * @param events - Array of events
+ * @param name - Event name to find
+ * @returns First matching event or undefined
+ */
+declare function findEvent<T extends RaiseEvent>(events: RaiseEvent[], name: T['name']): T | undefined;
+
+/**
+ * Wait for transaction confirmation
+ *
+ * @param connection - Solana connection
+ * @param signature - Transaction signature
+ * @param commitment - Confirmation commitment level
+ * @returns Confirmation result
+ */
+declare function confirmTransaction(connection: Connection, signature: TransactionSignature, commitment?: 'confirmed' | 'finalized'): Promise<_solana_web3_js.RpcResponseAndContext<_solana_web3_js.SignatureResult>>;
+/**
+ * Get transaction details with retry
+ *
+ * @param connection - Solana connection
+ * @param signature - Transaction signature
+ * @param maxRetries - Maximum number of retries
+ * @returns Transaction details
+ */
+declare function getTransactionWithRetry(connection: Connection, signature: TransactionSignature, maxRetries?: number): Promise<_solana_web3_js.VersionedTransactionResponse>;
+/**
+ * Convert BN to number safely
+ *
+ * @param bn - BN value
+ * @returns Number value
+ * @throws If value is too large for safe integer
+ */
+declare function bnToNumber(bn: BN): number;
+/**
+ * Convert BN to bigint
+ *
+ * @param bn - BN value
+ * @returns BigInt value
+ */
+declare function bnToBigInt(bn: BN): bigint;
+/**
+ * Convert bigint to BN
+ *
+ * @param value - BigInt value
+ * @returns BN value
+ */
+declare function bigIntToBN(value: bigint): BN;
+/**
+ * Get current Unix timestamp in seconds
+ *
+ * @returns Current timestamp
+ */
+declare function getCurrentTimestamp(): number;
+/**
+ * Convert Unix timestamp to Date
+ *
+ * @param timestamp - Unix timestamp in seconds
+ * @returns Date object
+ */
+declare function timestampToDate(timestamp: number | BN): Date;
+/**
+ * Check if a timestamp has passed
+ *
+ * @param timestamp - Unix timestamp in seconds
+ * @returns True if timestamp has passed
+ */
+declare function hasTimestampPassed(timestamp: number | BN): boolean;
+/**
+ * Calculate time remaining until timestamp
+ *
+ * @param timestamp - Unix timestamp in seconds
+ * @returns Seconds remaining (0 if passed)
+ */
+declare function timeRemaining(timestamp: number | BN): number;
+/**
+ * Format duration in human-readable format
+ *
+ * @param seconds - Duration in seconds
+ * @returns Formatted string (e.g., "2d 5h 30m")
+ */
+declare function formatDuration(seconds: number): string;
+/**
+ * Calculate percentage from basis points
+ *
+ * @param bps - Basis points (1% = 100 bps)
+ * @returns Percentage as decimal
+ */
+declare function bpsToPercent(bps: number): number;
+/**
+ * Calculate basis points from percentage
+ *
+ * @param percent - Percentage as decimal
+ * @returns Basis points
+ */
+declare function percentToBps(percent: number): number;
+/**
+ * Calculate percentage of amount
+ *
+ * @param amount - Total amount
+ * @param percentage - Percentage (0-100)
+ * @returns Calculated amount
+ */
+declare function percentageOf(amount: bigint, percentage: number): bigint;
+/**
+ * Validate milestone percentages sum to 100
+ *
+ * @param percentages - Array of percentage values
+ * @returns True if valid
+ */
+declare function validateMilestonePercentages(percentages: number[]): boolean;
+/**
+ * Validate metadata URI format
+ *
+ * @param uri - URI string
+ * @param maxLength - Maximum allowed length
+ * @returns True if valid
+ */
+declare function validateMetadataUri(uri: string, maxLength?: number): boolean;
+/**
+ * Check if a public key is valid
+ *
+ * @param pubkey - String or PublicKey
+ * @returns True if valid
+ */
+declare function isValidPublicKey(pubkey: string | PublicKey): boolean;
+/**
+ * Shorten a public key for display
+ *
+ * @param pubkey - Public key
+ * @param chars - Number of characters to show on each end
+ * @returns Shortened string (e.g., "ABC...XYZ")
+ */
+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 };