@ghostspeak/sdk 2.0.5 → 2.0.7

package/dist/feature-flags-B1g0DCPe.d.ts

@@ -0,0 +1,1181 @@
+import { T as TagDecayConfig, b as ReputationMetrics, c as TagScore, d as TagFilters, e as TagQueryResult, G as GovernanceProposal, f as VotingResults, Q as QuorumRequirements, V as VoteChoice, I as IPFSConfig, g as IPFSUploadOptions, h as IPFSOperationResult, i as IPFSUploadResult, j as IPFSRetrievalOptions, k as IPFSRetrievalResult, l as IPFSPinResult, m as IPFSContentMetadata, C as ContentStorageResult } from './reputation-types-Yebf0Rm_.js';
+import { EncodedAccount, MaybeEncodedAccount, fetchEncodedAccount, Address as Address$1 } from '@solana/kit';
+import { Address } from '@solana/addresses';
+
+/**
+ * Reputation Tag Engine
+ *
+ * Automatically assigns and manages reputation tags based on agent metrics.
+ * Implements confidence scoring, evidence tracking, and tag decay mechanisms.
+ *
+ * Features:
+ * - Auto-tagging based on performance metrics
+ * - Confidence calculation with evidence counting
+ * - Time-based tag decay (stale tags after 90 days)
+ * - Tag validation and limits enforcement
+ */
+
+/**
+ * Reputation Tag Engine
+ *
+ * Core engine for automatic tag assignment and management
+ */
+declare class ReputationTagEngine {
+    private tagCriteria;
+    private decayConfig;
+    constructor(decayConfig?: TagDecayConfig);
+    /**
+     * Initialize all tag assignment criteria
+     */
+    private initializeTagCriteria;
+    /**
+     * Calculate tags for an agent based on their metrics
+     */
+    calculateTags(metrics: ReputationMetrics): Promise<TagScore[]>;
+    /**
+     * Apply decay to existing tags based on age
+     */
+    applyTagDecay(tagScores: TagScore[], currentTimestamp?: number): TagScore[];
+    /**
+     * Merge new tags with existing tags, updating confidence scores
+     */
+    mergeTags(existingTags: TagScore[], newTags: TagScore[]): TagScore[];
+    /**
+     * Filter tags based on criteria
+     */
+    filterTags(tags: TagScore[], filters: TagFilters): TagScore[];
+    /**
+     * Get category for a tag
+     */
+    private getTagCategory;
+    /**
+     * Validate tag name length
+     */
+    validateTagName(tagName: string): boolean;
+    /**
+     * Validate confidence score
+     */
+    validateConfidence(confidence: number): boolean;
+    /**
+     * Get confidence level description
+     */
+    getConfidenceLevel(confidence: number): string;
+    /**
+     * Sort tags by confidence (descending)
+     */
+    sortByConfidence(tags: TagScore[]): TagScore[];
+    /**
+     * Sort tags by evidence count (descending)
+     */
+    sortByEvidence(tags: TagScore[]): TagScore[];
+    /**
+     * Sort tags by last updated (most recent first)
+     */
+    sortByRecent(tags: TagScore[]): TagScore[];
+    /**
+     * Get top N tags by confidence
+     */
+    getTopTags(tags: TagScore[], count: number): TagScore[];
+    /**
+     * Categorize tags by type
+     */
+    categorizeTags(tags: TagScore[]): TagQueryResult;
+}
+
+/**
+ * Discriminator Validation Utilities
+ *
+ * Handles discriminator validation and provides fallback mechanisms
+ * for accounts with mismatched discriminators
+ */
+
+interface DiscriminatorValidationResult {
+    isValid: boolean;
+    expectedLength: number;
+    actualLength: number;
+    canDecode: boolean;
+    needsMigration: boolean;
+    errorMessage?: string;
+}
+interface AccountInspectionResult {
+    address: string;
+    dataLength: number;
+    discriminator: Uint8Array | null;
+    discriminatorLength: number;
+    isAgentAccount: boolean;
+    needsMigration: boolean;
+    rawData: Uint8Array;
+}
+/**
+ * Validates account discriminator before attempting to decode
+ */
+declare function validateAccountDiscriminator(accountData: Uint8Array, expectedDiscriminator: Uint8Array): DiscriminatorValidationResult;
+/**
+ * Create user-friendly error message for discriminator issues
+ */
+declare function createDiscriminatorErrorMessage(validation: DiscriminatorValidationResult, accountType: string, address: string): string;
+/**
+ * Safe Agent account decoding with discriminator validation
+ * Returns a compatibility result with exists property
+ */
+declare function safeDecodeAgent(encodedAccount: {
+    address: Address;
+    data: Uint8Array;
+}): Promise<{
+    exists: boolean;
+    data?: unknown;
+} | null>;
+/**
+ * Inspects account data and extracts useful information about discriminator
+ */
+declare function inspectAccountData(encodedAccount: EncodedAccount | MaybeEncodedAccount, address: string): AccountInspectionResult;
+
+/**
+ * Account Migration Utility
+ *
+ * Handles migration of old Agent accounts that were created with
+ * different discriminator formats to the current format.
+ */
+
+interface MigrationPlan {
+    address: string;
+    currentState: 'valid' | 'needs_migration' | 'invalid' | 'not_exists';
+    migrationType: 'none' | 'recreate' | 'data_conversion' | 'unsupported';
+    issues: string[];
+    recommendations: string[];
+    canAutoMigrate: boolean;
+}
+interface MigrationResult {
+    success: boolean;
+    address: string;
+    action: 'skipped' | 'migrated' | 'failed';
+    error?: string;
+    newAccountData?: Uint8Array;
+}
+interface LegacyAgentData {
+    discriminator: Uint8Array;
+    owner?: string;
+    name?: string;
+}
+/**
+ * Analyzes an account and creates a migration plan
+ */
+declare function createMigrationPlan(encodedAccount: EncodedAccount | MaybeEncodedAccount, address: string): Promise<MigrationPlan>;
+/**
+ * Attempts to extract meaningful data from a legacy account
+ */
+declare function extractLegacyData(encodedAccount: EncodedAccount | MaybeEncodedAccount): LegacyAgentData | null;
+/**
+ * Creates a detailed migration report for multiple accounts
+ */
+declare function createMigrationReport(accounts: {
+    address: string;
+    encodedAccount: EncodedAccount | MaybeEncodedAccount;
+}[]): Promise<{
+    summary: {
+        total: number;
+        valid: number;
+        needsMigration: number;
+        invalid: number;
+        canAutoMigrate: number;
+    };
+    plans: MigrationPlan[];
+    recommendations: string[];
+}>;
+/**
+ * Simulates migration without actually performing it
+ */
+declare function simulateMigration(encodedAccount: EncodedAccount | MaybeEncodedAccount, address: string): Promise<{
+    plan: MigrationPlan;
+    simulation: {
+        wouldSucceed: boolean;
+        estimatedSteps: string[];
+        warnings: string[];
+        requiredActions: string[];
+    };
+}>;
+/**
+ * Provides user-friendly migration instructions
+ */
+declare function getMigrationInstructions(plan: MigrationPlan): string[];
+
+/**
+ * Account Diagnostics Utility
+ *
+ * Comprehensive diagnostic tools for inspecting and debugging
+ * account discriminator issues and data format problems.
+ */
+
+interface DiagnosticReport {
+    address: string;
+    timestamp: string;
+    accountExists: boolean;
+    discriminatorValidation: ReturnType<typeof validateAccountDiscriminator>;
+    inspection: AccountInspectionResult;
+    migrationPlan: Awaited<ReturnType<typeof createMigrationPlan>>;
+    migrationSimulation: Awaited<ReturnType<typeof simulateMigration>>;
+    recommendations: string[];
+    debugInfo: {
+        expectedDiscriminator: number[];
+        actualDiscriminator: number[] | null;
+        dataPreview: number[];
+        programId?: string;
+    };
+}
+interface BatchDiagnosticReport {
+    summary: {
+        total: number;
+        valid: number;
+        invalid: number;
+        needsMigration: number;
+        notExists: number;
+    };
+    reports: DiagnosticReport[];
+    globalRecommendations: string[];
+    timestamp: string;
+}
+/**
+ * Runs comprehensive diagnostics on a single account
+ */
+declare function runAccountDiagnostics(encodedAccount: EncodedAccount | MaybeEncodedAccount, address: string): Promise<DiagnosticReport>;
+/**
+ * Runs diagnostics on multiple accounts
+ */
+declare function runBatchDiagnostics(accounts: {
+    address: string;
+    encodedAccount: EncodedAccount | MaybeEncodedAccount;
+}[]): Promise<BatchDiagnosticReport>;
+/**
+ * Fetches and diagnoses an account directly from the blockchain
+ */
+declare function diagnoseAccountFromChain(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address$1, options?: {
+    logToConsole?: boolean;
+}): Promise<DiagnosticReport>;
+/**
+ * Fetches and diagnoses multiple accounts from the blockchain
+ */
+declare function diagnoseBatchFromChain(rpc: Parameters<typeof fetchEncodedAccount>[0], addresses: Address$1[], options?: {
+    logToConsole?: boolean;
+    maxConcurrent?: number;
+}): Promise<BatchDiagnosticReport>;
+/**
+ * Exports a diagnostic report as JSON
+ */
+declare function exportDiagnosticReport(report: DiagnosticReport | BatchDiagnosticReport, filename?: string): string;
+
+type accountDiagnostics_BatchDiagnosticReport = BatchDiagnosticReport;
+type accountDiagnostics_DiagnosticReport = DiagnosticReport;
+declare const accountDiagnostics_diagnoseAccountFromChain: typeof diagnoseAccountFromChain;
+declare const accountDiagnostics_diagnoseBatchFromChain: typeof diagnoseBatchFromChain;
+declare const accountDiagnostics_exportDiagnosticReport: typeof exportDiagnosticReport;
+declare const accountDiagnostics_runAccountDiagnostics: typeof runAccountDiagnostics;
+declare const accountDiagnostics_runBatchDiagnostics: typeof runBatchDiagnostics;
+declare namespace accountDiagnostics {
+  export { type accountDiagnostics_BatchDiagnosticReport as BatchDiagnosticReport, type accountDiagnostics_DiagnosticReport as DiagnosticReport, accountDiagnostics_diagnoseAccountFromChain as diagnoseAccountFromChain, accountDiagnostics_diagnoseBatchFromChain as diagnoseBatchFromChain, accountDiagnostics_exportDiagnosticReport as exportDiagnosticReport, accountDiagnostics_runAccountDiagnostics as runAccountDiagnostics, accountDiagnostics_runBatchDiagnostics as runBatchDiagnostics };
+}
+
+/**
+ * Enhanced Client Error Utilities
+ *
+ * Provides wrapper functions for SDK operations that automatically enhance
+ * error messages with detailed instruction account information.
+ */
+
+/**
+ * Enhanced error class for SDK operations
+ */
+declare class GhostSpeakSDKError extends Error {
+    readonly originalError: Error;
+    readonly operation: string;
+    readonly instructionName?: string;
+    constructor(operation: string, originalError: Error, instructionName?: string);
+}
+/**
+ * Type for account context
+ */
+type AccountContext = Address | {
+    address: Address;
+    name?: string;
+};
+/**
+ * Wrapper for async operations that enhances errors with instruction context
+ */
+declare function withEnhancedErrors<T>(operation: string, instructionName: string | undefined, fn: () => Promise<T>, debugAccounts?: AccountContext[]): Promise<T>;
+/**
+ * Wrapper for synchronous operations that enhances errors with instruction context
+ */
+declare function withEnhancedErrorsSync<T>(operation: string, instructionName: string | undefined, fn: () => T, debugAccounts?: AccountContext[]): T;
+/**
+ * Parse and enhance transaction errors with instruction context
+ */
+declare function enhanceTransactionError(error: Error, instructionName?: string, accounts?: AccountContext[]): Error;
+/**
+ * Helper to log detailed error information for debugging
+ */
+declare function logEnhancedError(error: Error, context?: {
+    operation?: string;
+    instructionName?: string;
+    accounts?: AccountContext[];
+    params?: Record<string, unknown>;
+}): void;
+/**
+ * Error context for operations
+ */
+interface ErrorContext {
+    operation: string;
+    instructionName?: string;
+    accounts?: AccountContext[];
+    params?: Record<string, unknown>;
+}
+/**
+ * Create a detailed error context for operations
+ */
+declare function createErrorContext(operation: string, instructionName?: string, accounts?: AccountContext[], params?: Record<string, unknown>): ErrorContext;
+/**
+ * Validate common preconditions and throw enhanced errors
+ */
+declare function validatePreconditions(checks: {
+    condition: boolean;
+    message: string;
+    instructionName?: string;
+}[]): void;
+/**
+ * Helper to extract instruction name from operation context
+ */
+declare function extractInstructionName(operation: string): string | undefined;
+
+/**
+ * Token Utilities for SPL Token and Token 2022 (Token Extensions)
+ *
+ * Provides comprehensive token handling utilities including:
+ * - Associated Token Account (ATA) derivation for both SPL Token and Token 2022
+ * - Token 2022 specific features (transfer fees, confidential transfers, etc.)
+ * - Token program detection and validation
+ * - Account creation and management utilities
+ *
+ * Based on the latest SPL Token 2022 specification and @solana/kit v2.3.0
+ */
+
+/**
+ * Token program variants supported by GhostSpeak
+ */
+declare enum TokenProgram {
+    /** Original SPL Token Program */
+    SPL_TOKEN = "spl-token",
+    /** SPL Token 2022 (Token Extensions) Program */
+    TOKEN_2022 = "token-2022"
+}
+/**
+ * Associated Token Account information
+ */
+interface AssociatedTokenAccount {
+    /** The derived ATA address */
+    address: Address;
+    /** The wallet/owner address */
+    owner: Address;
+    /** The token mint address */
+    mint: Address;
+    /** The token program used (SPL Token or Token 2022) */
+    tokenProgram: Address;
+    /** Whether this is a Token 2022 ATA */
+    isToken2022: boolean;
+}
+/**
+ * Token 2022 Extension Types
+ * Based on the latest Token Extensions specification
+ */
+declare enum TokenExtension {
+    /** Uninitialized account */
+    UNINITIALIZED = 0,
+    /** Transfer fee extension */
+    TRANSFER_FEE_CONFIG = 1,
+    /** Transfer fee amount */
+    TRANSFER_FEE_AMOUNT = 2,
+    /** Mint close authority */
+    MINT_CLOSE_AUTHORITY = 3,
+    /** Confidential transfer mint */
+    CONFIDENTIAL_TRANSFER_MINT = 4,
+    /** Confidential transfer account */
+    CONFIDENTIAL_TRANSFER_ACCOUNT = 5,
+    /** Default account state */
+    DEFAULT_ACCOUNT_STATE = 6,
+    /** Immutable owner */
+    IMMUTABLE_OWNER = 7,
+    /** Memo transfer */
+    MEMO_TRANSFER = 8,
+    /** Non-transferable */
+    NON_TRANSFERABLE = 9,
+    /** Interest bearing mint */
+    INTEREST_BEARING_MINT = 10,
+    /** CPI guard */
+    CPI_GUARD = 11,
+    /** Permanent delegate */
+    PERMANENT_DELEGATE = 12,
+    /** Non-transferable account */
+    NON_TRANSFERABLE_ACCOUNT = 13,
+    /** Transfer hook */
+    TRANSFER_HOOK = 14,
+    /** Transfer hook account */
+    TRANSFER_HOOK_ACCOUNT = 15,
+    /** Metadata pointer */
+    METADATA_POINTER = 16,
+    /** Token metadata */
+    TOKEN_METADATA = 17,
+    /** Group pointer */
+    GROUP_POINTER = 18,
+    /** Token group */
+    TOKEN_GROUP = 19,
+    /** Group member pointer */
+    GROUP_MEMBER_POINTER = 20,
+    /** Token group member */
+    TOKEN_GROUP_MEMBER = 21
+}
+/**
+ * Transfer fee configuration for Token 2022
+ */
+interface TransferFeeConfig {
+    /** Transfer fee basis points (0-10000, where 10000 = 100%) */
+    transferFeeBasisPoints: number;
+    /** Maximum transfer fee in token base units */
+    maximumFee: bigint;
+    /** Authority that can modify transfer fee config */
+    transferFeeConfigAuthority: Address | null;
+    /** Authority that can withdraw collected fees */
+    withdrawWithheldAuthority: Address | null;
+    /** Amount of fees currently withheld */
+    withheldAmount: bigint;
+    /** Older transfer fee configuration */
+    olderTransferFee: {
+        epoch: bigint;
+        transferFeeBasisPoints: number;
+        maximumFee: bigint;
+    };
+    /** Newer transfer fee configuration */
+    newerTransferFee: {
+        epoch: bigint;
+        transferFeeBasisPoints: number;
+        maximumFee: bigint;
+    };
+}
+/**
+ * Confidential transfer configuration for Token 2022
+ */
+interface ConfidentialTransferConfig {
+    /** Authority that can configure confidential transfers */
+    authority: Address | null;
+    /** Automatically approve new accounts for confidential transfers */
+    autoApproveNewAccounts: boolean;
+    /** Public key for auditing confidential transfers */
+    auditorElgamalPubkey: Uint8Array | null;
+}
+/**
+ * Interest-bearing token configuration for Token 2022
+ */
+interface InterestBearingConfig {
+    /** Authority that can update the interest rate */
+    rateAuthority: Address | null;
+    /** Current interest rate (basis points per year) */
+    currentRate: number;
+    /** Timestamp when interest bearing was initialized */
+    initializationTimestamp: bigint;
+    /** Timestamp of last rate update */
+    lastUpdateTimestamp: bigint;
+    /** Pre-computed interest rate */
+    preUpdateAverageRate: number;
+}
+/**
+ * Derive Associated Token Account address for any token program
+ *
+ * This is the core ATA derivation function that works with both
+ * SPL Token and Token 2022 programs. The derivation follows the
+ * standard pattern: ['owner', 'token_program', 'mint']
+ *
+ * @param owner - The wallet/owner address
+ * @param mint - The token mint address
+ * @param tokenProgram - The token program address (SPL Token or Token 2022)
+ * @returns Promise<Address> - The derived ATA address
+ */
+declare function deriveAssociatedTokenAddress(owner: Address, mint: Address, tokenProgram?: Address): Promise<Address>;
+/**
+ * Derive Associated Token Account for SPL Token (legacy)
+ *
+ * @param owner - The wallet/owner address
+ * @param mint - The token mint address
+ * @returns Promise<Address> - The derived ATA address
+ */
+declare function deriveSplTokenAssociatedTokenAddress(owner: Address, mint: Address): Promise<Address>;
+/**
+ * Derive Associated Token Account for Token 2022
+ *
+ * @param owner - The wallet/owner address
+ * @param mint - The token mint address
+ * @returns Promise<Address> - The derived ATA address
+ */
+declare function deriveToken2022AssociatedTokenAddress(owner: Address, mint: Address): Promise<Address>;
+/**
+ * Get complete ATA information including program detection
+ *
+ * @param owner - The wallet/owner address
+ * @param mint - The token mint address
+ * @param tokenProgram - Optional: specify token program, auto-detect if not provided
+ * @returns Promise<AssociatedTokenAccount> - Complete ATA information
+ */
+declare function getAssociatedTokenAccount(owner: Address, mint: Address, tokenProgram?: Address): Promise<AssociatedTokenAccount>;
+/**
+ * Detect which token program owns a given mint
+ * Note: This requires RPC calls to fetch mint account data
+ *
+ * @param mint - The token mint address
+ * @returns Promise<Address> - The token program address
+ */
+declare function detectTokenProgram(mint: Address, rpcEndpoint?: string): Promise<Address>;
+/**
+ * Check if a mint is a Token 2022 mint
+ *
+ * @param mint - The token mint address
+ * @returns Promise<boolean> - True if Token 2022, false if SPL Token
+ */
+declare function isToken2022Mint(mint: Address): Promise<boolean>;
+/**
+ * Get the appropriate token program for a given mint
+ *
+ * @param mint - The token mint address
+ * @returns Promise<TokenProgram> - The token program enum
+ */
+declare function getTokenProgramType(mint: Address): Promise<TokenProgram>;
+/**
+ * Check if a mint has the transfer fee extension
+ *
+ * @param mint - The token mint address
+ * @param rpcEndpoint - Optional RPC endpoint
+ * @returns Promise<boolean> - True if mint has transfer fee extension
+ */
+declare function hasTransferFeeExtension(mint: Address, rpcEndpoint?: string): Promise<boolean>;
+/**
+ * Check if a mint has the confidential transfer extension
+ *
+ * @param mint - The token mint address
+ * @param rpcEndpoint - Optional RPC endpoint
+ * @returns Promise<boolean> - True if mint has confidential transfer extension
+ */
+declare function hasConfidentialTransferExtension(mint: Address, rpcEndpoint?: string): Promise<boolean>;
+/**
+ * Check if a mint has the interest-bearing extension
+ *
+ * @param mint - The token mint address
+ * @param rpcEndpoint - Optional RPC endpoint
+ * @returns Promise<boolean> - True if mint has interest-bearing extension
+ */
+declare function hasInterestBearingExtension(mint: Address, rpcEndpoint?: string): Promise<boolean>;
+/**
+ * Get transfer fee configuration for a Token 2022 mint
+ *
+ * @param mint - The Token 2022 mint address
+ * @returns Promise<TransferFeeConfig | null> - Transfer fee config or null if not configured
+ */
+declare function getTransferFeeConfig(mint: Address, _rpcEndpoint?: string): Promise<TransferFeeConfig | null>;
+/**
+ * Get confidential transfer configuration for a Token 2022 mint
+ *
+ * @param mint - The Token 2022 mint address
+ * @returns Promise<ConfidentialTransferConfig | null> - Confidential transfer config or null
+ */
+declare function getConfidentialTransferConfig(mint: Address, _rpcEndpoint?: string): Promise<ConfidentialTransferConfig | null>;
+/**
+ * Get interest-bearing configuration for a Token 2022 mint
+ *
+ * @param mint - The Token 2022 mint address
+ * @returns Promise<InterestBearingConfig | null> - Interest-bearing config or null
+ */
+declare function getInterestBearingConfig(mint: Address, _rpcEndpoint?: string): Promise<InterestBearingConfig | null>;
+/**
+ * Get all possible ATA addresses for a wallet/mint pair
+ * Returns both SPL Token and Token 2022 ATAs
+ *
+ * @param owner - The wallet/owner address
+ * @param mint - The token mint address
+ * @returns Promise<{ splToken: Address, token2022: Address }> - Both ATA addresses
+ */
+declare function getAllAssociatedTokenAddresses(owner: Address, mint: Address): Promise<{
+    splToken: Address;
+    token2022: Address;
+}>;
+/**
+ * Validate if an address could be a valid ATA
+ *
+ * @param address - The address to validate
+ * @param owner - The expected owner
+ * @param mint - The expected mint
+ * @returns Promise<{ isValid: boolean, program?: Address }> - Validation result
+ */
+declare function validateAssociatedTokenAddress(address: Address, owner: Address, mint: Address): Promise<{
+    isValid: boolean;
+    program?: Address;
+}>;
+/**
+ * Convert TokenProgram enum to program address
+ *
+ * @param program - The token program enum
+ * @returns Address - The program address
+ */
+declare function getTokenProgramAddress(program: TokenProgram): Address;
+/**
+ * Convert program address to TokenProgram enum
+ *
+ * @param address - The program address
+ * @returns TokenProgram - The token program enum
+ */
+declare function getTokenProgramFromAddress(address: Address): TokenProgram;
+/**
+ * Format token amount with proper decimals
+ *
+ * @param amount - Raw token amount (in base units)
+ * @param decimals - Number of decimal places for the token
+ * @returns string - Formatted amount
+ */
+declare function formatTokenAmount(amount: bigint, decimals: number): string;
+/**
+ * Parse formatted token amount to raw base units
+ *
+ * @param formatted - Formatted token amount string
+ * @param decimals - Number of decimal places for the token
+ * @returns bigint - Raw token amount
+ */
+declare function parseTokenAmount(formatted: string, decimals: number): bigint;
+
+/**
+ * Governance Helper Utilities
+ *
+ * Comprehensive utilities for RBAC management, multi-signature wallets,
+ * proposal lifecycle, and voting mechanisms.
+ */
+
+/**
+ * Derive multisig account PDA
+ */
+declare function deriveMultisigPda(programId: Address$1, authority: Address$1, multisigId: bigint): Promise<Address$1>;
+/**
+ * Derive proposal account PDA
+ */
+declare function deriveProposalPda(programId: Address$1, multisig: Address$1, proposalId: bigint): Promise<Address$1>;
+/**
+ * Derive RBAC account PDA
+ */
+declare function deriveRbacPda(programId: Address$1, admin: Address$1): Promise<Address$1>;
+declare class ProposalUtils {
+    /**
+     * Check if proposal is in voting period
+     */
+    static isVotingOpen(proposal: GovernanceProposal): boolean;
+    /**
+     * Check if proposal has expired
+     */
+    static hasExpired(proposal: GovernanceProposal): boolean;
+    /**
+     * Calculate time remaining for voting
+     */
+    static timeRemaining(proposal: GovernanceProposal): bigint;
+    /**
+     * Format time remaining as human-readable string
+     */
+    static formatTimeRemaining(proposal: GovernanceProposal): string;
+    /**
+     * Calculate if proposal has reached quorum
+     */
+    static hasReachedQuorum(votingResults: VotingResults, quorumRequirements: QuorumRequirements, totalEligibleVoters: number): boolean;
+    /**
+     * Calculate voting results summary
+     */
+    static calculateResults(votingResults: VotingResults): {
+        total: number;
+        forPercentage: number;
+        againstPercentage: number;
+        abstainPercentage: number;
+        passed: boolean;
+    };
+    /**
+     * Validate proposal
+     */
+    static validateProposal(proposal: GovernanceProposal): {
+        valid: boolean;
+        error?: string;
+    };
+}
+declare class VotingUtils {
+    /**
+     * Calculate vote weight based on token holdings or other factors
+     */
+    static calculateVoteWeight(baseWeight: number, tokenBalance?: bigint, stakeDuration?: bigint): number;
+    /**
+     * Format vote choice as string
+     */
+    static formatVoteChoice(voteChoice: VoteChoice): string;
+    /**
+     * Calculate if simple majority is reached
+     */
+    static hasSimpleMajority(votingResults: VotingResults): boolean;
+    /**
+     * Calculate if supermajority is reached (2/3)
+     */
+    static hasSupermajority(votingResults: VotingResults): boolean;
+}
+declare const PERMISSION_TEMPLATES: {
+    ADMIN: {
+        CREATE_PROPOSAL: {
+            action: string;
+            resource: string;
+        };
+        EXECUTE_PROPOSAL: {
+            action: string;
+            resource: string;
+        };
+        MANAGE_ROLES: {
+            action: string;
+            resource: string;
+        };
+        MANAGE_TREASURY: {
+            action: string;
+            resource: string;
+        };
+    };
+    MEMBER: {
+        VOTE: {
+            action: string;
+            resource: string;
+        };
+        VIEW: {
+            action: string;
+            resource: string;
+        };
+        COMMENT: {
+            action: string;
+            resource: string;
+        };
+    };
+    MODERATOR: {
+        CANCEL_PROPOSAL: {
+            action: string;
+            resource: string;
+        };
+        MODERATE_COMMENTS: {
+            action: string;
+            resource: string;
+        };
+        VIEW_REPORTS: {
+            action: string;
+            resource: string;
+        };
+    };
+};
+declare const ROLE_TEMPLATES: {
+    ADMIN: {
+        name: string;
+        description: string;
+        permissions: ({
+            action: string;
+            resource: string;
+        } | {
+            action: string;
+            resource: string;
+        } | {
+            action: string;
+            resource: string;
+        } | {
+            action: string;
+            resource: string;
+        })[];
+    };
+    MEMBER: {
+        name: string;
+        description: string;
+        permissions: ({
+            action: string;
+            resource: string;
+        } | {
+            action: string;
+            resource: string;
+        } | {
+            action: string;
+            resource: string;
+        })[];
+    };
+    MODERATOR: {
+        name: string;
+        description: string;
+        permissions: {
+            action: string;
+            resource: string;
+        }[];
+    };
+};
+interface GovernanceAnalytics {
+    totalProposals: number;
+    activeProposals: number;
+    passedProposals: number;
+    failedProposals: number;
+    averageVoterTurnout: number;
+    topVoters: {
+        address: Address$1;
+        voteCount: number;
+    }[];
+    proposalCategories: {
+        category: string;
+        count: number;
+    }[];
+}
+declare class GovernanceAnalyticsUtils {
+    /**
+     * Calculate governance health score (0-100)
+     */
+    static calculateHealthScore(analytics: GovernanceAnalytics): number;
+    /**
+     * Generate governance summary report
+     */
+    static generateSummaryReport(analytics: GovernanceAnalytics): string;
+}
+
+type governanceHelpers_GovernanceAnalytics = GovernanceAnalytics;
+type governanceHelpers_GovernanceAnalyticsUtils = GovernanceAnalyticsUtils;
+declare const governanceHelpers_GovernanceAnalyticsUtils: typeof GovernanceAnalyticsUtils;
+declare const governanceHelpers_PERMISSION_TEMPLATES: typeof PERMISSION_TEMPLATES;
+type governanceHelpers_ProposalUtils = ProposalUtils;
+declare const governanceHelpers_ProposalUtils: typeof ProposalUtils;
+declare const governanceHelpers_ROLE_TEMPLATES: typeof ROLE_TEMPLATES;
+type governanceHelpers_VotingUtils = VotingUtils;
+declare const governanceHelpers_VotingUtils: typeof VotingUtils;
+declare const governanceHelpers_deriveMultisigPda: typeof deriveMultisigPda;
+declare const governanceHelpers_deriveProposalPda: typeof deriveProposalPda;
+declare const governanceHelpers_deriveRbacPda: typeof deriveRbacPda;
+declare namespace governanceHelpers {
+  export { type governanceHelpers_GovernanceAnalytics as GovernanceAnalytics, governanceHelpers_GovernanceAnalyticsUtils as GovernanceAnalyticsUtils, governanceHelpers_PERMISSION_TEMPLATES as PERMISSION_TEMPLATES, governanceHelpers_ProposalUtils as ProposalUtils, governanceHelpers_ROLE_TEMPLATES as ROLE_TEMPLATES, governanceHelpers_VotingUtils as VotingUtils, governanceHelpers_deriveMultisigPda as deriveMultisigPda, governanceHelpers_deriveProposalPda as deriveProposalPda, governanceHelpers_deriveRbacPda as deriveRbacPda };
+}
+
+/**
+ * IPFS client implementation with multiple provider support
+ */
+
+/**
+ * Main IPFS client with multiple provider support and fallback
+ */
+declare class IPFSClient {
+    private config;
+    private providers;
+    private cache;
+    constructor(config: IPFSConfig);
+    private initializeProviders;
+    private createProvider;
+    /**
+     * Upload content to IPFS with automatic fallback
+     */
+    upload(content: string | Uint8Array, options?: IPFSUploadOptions): Promise<IPFSOperationResult<IPFSUploadResult>>;
+    /**
+     * Retrieve content from IPFS with caching and fallback
+     */
+    retrieve(hash: string, options?: IPFSRetrievalOptions): Promise<IPFSOperationResult<IPFSRetrievalResult>>;
+    /**
+     * Pin content on IPFS
+     */
+    pin(hash: string): Promise<IPFSOperationResult<IPFSPinResult>>;
+    /**
+     * Store content with automatic IPFS decision based on size
+     */
+    storeContent(content: string, type: IPFSContentMetadata['type'], options?: IPFSUploadOptions & {
+        forceIpfs?: boolean;
+    }): Promise<ContentStorageResult>;
+    /**
+     * Retrieve content that may be stored inline or on IPFS
+     */
+    retrieveContent(uri: string): Promise<string>;
+    /**
+     * Retry wrapper for operations
+     */
+    private withRetry;
+    /**
+     * Calculate checksum for content integrity
+     */
+    private calculateChecksum;
+    /**
+     * Clear cache
+     */
+    clearCache(): void;
+    /**
+     * Get cache stats
+     */
+    getCacheStats(): {
+        size: number;
+        keys: string[];
+    };
+}
+
+type ipfsClient_IPFSClient = IPFSClient;
+declare const ipfsClient_IPFSClient: typeof IPFSClient;
+declare namespace ipfsClient {
+  export { ipfsClient_IPFSClient as IPFSClient };
+}
+
+/**
+ * ElGamal Encryption Implementation
+ *
+ * Implements twisted ElGamal encryption over curve25519 for
+ * client-side privacy features.
+ *
+ * Key features:
+ * - Twisted ElGamal with Pedersen commitments
+ * - Homomorphic addition/subtraction of ciphertexts
+ * - Efficient decryption for small values (up to 32 bits)
+ */
+
+/**
+ * ElGamal public key (32 bytes)
+ */
+type ElGamalPubkey = Uint8Array;
+/**
+ * ElGamal secret key (32 bytes)
+ */
+type ElGamalSecretKey = Uint8Array;
+/**
+ * ElGamal keypair
+ */
+interface ElGamalKeypair {
+    publicKey: ElGamalPubkey;
+    secretKey: ElGamalSecretKey;
+}
+/**
+ * Pedersen commitment (curve point)
+ */
+interface PedersenCommitment {
+    /** Commitment to the value */
+    commitment: Uint8Array;
+}
+/**
+ * Decrypt handle for ElGamal ciphertext
+ */
+interface DecryptHandle {
+    /** Encrypted randomness */
+    handle: Uint8Array;
+}
+/**
+ * Twisted ElGamal ciphertext
+ * Split into Pedersen commitment and decrypt handle
+ */
+interface ElGamalCiphertext {
+    /** Pedersen commitment (independent of pubkey) */
+    commitment: PedersenCommitment;
+    /** Decrypt handle (encodes randomness) */
+    handle: DecryptHandle;
+}
+/**
+ * Generate a new ElGamal keypair
+ *
+ * @param seed - Optional seed for deterministic generation
+ * @returns ElGamalKeypair
+ */
+declare function generateElGamalKeypair(seed?: Uint8Array): ElGamalKeypair;
+
+/**
+ * Client-Side Encryption Service
+ *
+ * Provides production-ready client-side encryption for privacy features
+ * using ElGamal encryption and x402 verification.
+ */
+
+interface EncryptedData {
+    /** Encrypted payload */
+    ciphertext: ElGamalCiphertext;
+    /** Public key used for encryption */
+    publicKey: ElGamalPubkey;
+    /** Commitment to the plaintext (for verification) */
+    commitment: Uint8Array;
+    /** Timestamp of encryption */
+    timestamp: number;
+    /** Version for future compatibility */
+    version: number;
+}
+interface PrivateMetadata {
+    /** Encrypted data */
+    encrypted: EncryptedData;
+    /** Public metadata (not encrypted) */
+    public: Record<string, unknown>;
+    /** IPFS hash if stored off-chain */
+    ipfsHash?: string;
+    /** On-chain storage hash */
+    storageHash: Uint8Array;
+}
+interface ClientEncryptionOptions {
+    /** Whether to generate range proofs locally */
+    generateLocalProofs?: boolean;
+    /** Whether to store on IPFS */
+    useIpfsStorage?: boolean;
+    /** Custom encryption keypair (uses ephemeral if not provided) */
+    encryptionKeypair?: ElGamalKeypair;
+}
+declare class ClientEncryptionService {
+    private keypair;
+    private featureFlags;
+    constructor(options?: ClientEncryptionOptions);
+    /**
+     * Encrypt an amount for a recipient
+     */
+    encryptAmountForRecipient(amount: bigint, recipientPubkey: ElGamalPubkey): Promise<EncryptedData>;
+    /**
+     * Decrypt an amount (requires private key)
+     */
+    decryptAmount(encrypted: EncryptedData, secretKey: Uint8Array): Promise<bigint>;
+    /**
+     * Encrypt arbitrary data
+     */
+    encryptData(data: Uint8Array, recipientPubkey: ElGamalPubkey): Promise<EncryptedData>;
+    /**
+     * Create private metadata with mixed public/private data
+     */
+    createPrivateMetadata(privateData: Record<string, unknown>, publicData: Record<string, unknown>, recipientPubkey: ElGamalPubkey): Promise<PrivateMetadata>;
+    /**
+     * Verify encrypted data integrity
+     */
+    verifyCommitment(encrypted: EncryptedData): Promise<boolean>;
+    /**
+     * Create a commitment to an amount
+     */
+    private createCommitment;
+    /**
+     * Create a commitment to arbitrary data
+     */
+    private createDataCommitment;
+    /**
+     * Create storage hash for on-chain reference
+     */
+    private createStorageHash;
+    /**
+     * Combine multiple ciphertext chunks
+     */
+    private combineChunks;
+}
+/**
+ * Generate a local privacy proof (verified via x402 consensus)
+ * This provides cryptographic commitment without on-chain proofs
+ */
+declare function generateLocalPrivacyProof(encrypted: EncryptedData, statement: string): Promise<{
+    proof: Uint8Array;
+    publicInputs: Uint8Array;
+    timestamp: number;
+}>;
+/**
+ * Verify a local privacy proof
+ */
+declare function verifyLocalPrivacyProof(proof: Uint8Array, publicInputs: Uint8Array, encrypted: EncryptedData): Promise<boolean>;
+
+type clientEncryption_ClientEncryptionOptions = ClientEncryptionOptions;
+type clientEncryption_ClientEncryptionService = ClientEncryptionService;
+declare const clientEncryption_ClientEncryptionService: typeof ClientEncryptionService;
+type clientEncryption_ElGamalCiphertext = ElGamalCiphertext;
+type clientEncryption_ElGamalKeypair = ElGamalKeypair;
+type clientEncryption_ElGamalPubkey = ElGamalPubkey;
+type clientEncryption_EncryptedData = EncryptedData;
+type clientEncryption_PrivateMetadata = PrivateMetadata;
+declare const clientEncryption_generateElGamalKeypair: typeof generateElGamalKeypair;
+declare const clientEncryption_generateLocalPrivacyProof: typeof generateLocalPrivacyProof;
+declare const clientEncryption_verifyLocalPrivacyProof: typeof verifyLocalPrivacyProof;
+declare namespace clientEncryption {
+  export { type clientEncryption_ClientEncryptionOptions as ClientEncryptionOptions, clientEncryption_ClientEncryptionService as ClientEncryptionService, type clientEncryption_ElGamalCiphertext as ElGamalCiphertext, type clientEncryption_ElGamalKeypair as ElGamalKeypair, type clientEncryption_ElGamalPubkey as ElGamalPubkey, type clientEncryption_EncryptedData as EncryptedData, type clientEncryption_PrivateMetadata as PrivateMetadata, clientEncryption_generateElGamalKeypair as generateElGamalKeypair, clientEncryption_generateLocalPrivacyProof as generateLocalPrivacyProof, clientEncryption_verifyLocalPrivacyProof as verifyLocalPrivacyProof };
+}
+
+/**
+ * Feature Flags for GhostSpeak Protocol
+ *
+ * Centralized feature flag management for enabling/disabling features
+ * based on network conditions and protocol status.
+ */
+interface FeatureFlags {
+    /** Enable confidential transfers (currently in beta) */
+    CONFIDENTIAL_TRANSFERS_ENABLED: boolean;
+    /** Use client-side encryption as fallback */
+    USE_CLIENT_ENCRYPTION: boolean;
+    /** Enable IPFS integration for private metadata */
+    ENABLE_IPFS_STORAGE: boolean;
+    /** Enable compressed NFTs for agents */
+    ENABLE_COMPRESSED_AGENTS: boolean;
+    /** Enable governance features */
+    ENABLE_GOVERNANCE: boolean;
+    /** Enable analytics collection */
+    ENABLE_ANALYTICS: boolean;
+    /** Show beta/experimental features in UI */
+    SHOW_EXPERIMENTAL_FEATURES: boolean;
+}
+/**
+ * Default feature flags for production
+ */
+declare const DEFAULT_FLAGS: FeatureFlags;
+/**
+ * Development feature flags (all features enabled)
+ */
+declare const DEV_FLAGS: FeatureFlags;
+/**
+ * Feature flag manager
+ */
+declare class FeatureFlagManager {
+    private flags;
+    private overrides;
+    constructor(environment?: 'production' | 'development');
+    /**
+     * Load flag overrides from environment variables
+     */
+    private loadOverridesFromEnv;
+    /**
+     * Get current feature flags
+     */
+    getFlags(): FeatureFlags;
+    /**
+     * Check if a specific feature is enabled
+     */
+    isEnabled(feature: keyof FeatureFlags): boolean;
+    /**
+     * Set a feature flag (runtime override)
+     */
+    setFlag(feature: keyof FeatureFlags, enabled: boolean): void;
+    /**
+     * Reset all overrides
+     */
+    resetOverrides(): void;
+    /**
+     * Get privacy feature status
+     */
+    getPrivacyStatus(): {
+        mode: 'client-encryption' | 'disabled';
+        beta: boolean;
+        message: string;
+    };
+    /**
+     * Check if we should use client encryption
+     */
+    shouldUseClientEncryption(): boolean;
+}
+/**
+ * Get or create the global feature flag manager
+ */
+declare function getFeatureFlags(environment?: 'production' | 'development'): FeatureFlagManager;
+/**
+ * Quick helper to check if a feature is enabled
+ */
+declare function isFeatureEnabled(feature: keyof FeatureFlags): boolean;
+/**
+ * Quick helper to get privacy status
+ */
+declare function getPrivacyStatus(): {
+    mode: "client-encryption" | "disabled";
+    beta: boolean;
+    message: string;
+};
+
+declare const featureFlags_DEFAULT_FLAGS: typeof DEFAULT_FLAGS;
+declare const featureFlags_DEV_FLAGS: typeof DEV_FLAGS;
+type featureFlags_FeatureFlagManager = FeatureFlagManager;
+declare const featureFlags_FeatureFlagManager: typeof FeatureFlagManager;
+type featureFlags_FeatureFlags = FeatureFlags;
+declare const featureFlags_getFeatureFlags: typeof getFeatureFlags;
+declare const featureFlags_getPrivacyStatus: typeof getPrivacyStatus;
+declare const featureFlags_isFeatureEnabled: typeof isFeatureEnabled;
+declare namespace featureFlags {
+  export { featureFlags_DEFAULT_FLAGS as DEFAULT_FLAGS, featureFlags_DEV_FLAGS as DEV_FLAGS, featureFlags_FeatureFlagManager as FeatureFlagManager, type featureFlags_FeatureFlags as FeatureFlags, featureFlags_getFeatureFlags as getFeatureFlags, featureFlags_getPrivacyStatus as getPrivacyStatus, featureFlags_isFeatureEnabled as isFeatureEnabled };
+}
+
+export { hasTransferFeeExtension as $, type AccountInspectionResult as A, diagnoseAccountFromChain as B, ClientEncryptionService as C, type DiscriminatorValidationResult as D, type ErrorContext as E, diagnoseBatchFromChain as F, GhostSpeakSDKError as G, exportDiagnosticReport as H, IPFSClient as I, type DiagnosticReport as J, type BatchDiagnosticReport as K, type LegacyAgentData as L, type MigrationPlan as M, withEnhancedErrorsSync as N, logEnhancedError as O, validatePreconditions as P, extractInstructionName as Q, ReputationTagEngine as R, deriveSplTokenAssociatedTokenAddress as S, TokenProgram as T, deriveToken2022AssociatedTokenAddress as U, getAssociatedTokenAccount as V, getAllAssociatedTokenAddresses as W, validateAssociatedTokenAddress as X, getTokenProgramAddress as Y, getTokenProgramFromAddress as Z, TokenExtension as _, detectTokenProgram as a, hasConfidentialTransferExtension as a0, hasInterestBearingExtension as a1, getTransferFeeConfig as a2, getConfidentialTransferConfig as a3, getInterestBearingConfig as a4, type AssociatedTokenAccount as a5, type TransferFeeConfig as a6, type ConfidentialTransferConfig as a7, type InterestBearingConfig as a8, deriveMultisigPda as a9, deriveProposalPda as aa, generateLocalPrivacyProof as ab, verifyLocalPrivacyProof as ac, type EncryptedData as ad, type PrivateMetadata as ae, type ClientEncryptionOptions as af, getFeatureFlags as ag, isFeatureEnabled as ah, FeatureFlagManager as ai, type FeatureFlags as aj, ipfsClient as b, createErrorContext as c, deriveAssociatedTokenAddress as d, enhanceTransactionError as e, formatTokenAmount as f, getTokenProgramType as g, clientEncryption as h, isToken2022Mint as i, accountDiagnostics as j, governanceHelpers as k, featureFlags as l, createDiscriminatorErrorMessage as m, inspectAccountData as n, createMigrationPlan as o, parseTokenAmount as p, createMigrationReport as q, simulateMigration as r, safeDecodeAgent as s, getMigrationInstructions as t, extractLegacyData as u, validateAccountDiscriminator as v, withEnhancedErrors as w, type MigrationResult as x, runAccountDiagnostics as y, runBatchDiagnostics as z };