@obelyzk/sdk 0.5.0

package/dist/tee-BslKx4iU.d.ts

@@ -0,0 +1,4749 @@
+/**
+ * BitSage SDK Types
+ */
+/** Job identifier */
+type JobId = string;
+/** Worker identifier */
+type WorkerId = string;
+/** Job types supported by BitSage network */
+type JobType = {
+    type: 'ai_inference';
+    model_type: string;
+    batch_size: number;
+} | {
+    type: 'zk_proof';
+    circuit_type: string;
+    proof_system: string;
+} | {
+    type: 'computer_vision';
+    model_name: string;
+    input_format: string;
+} | {
+    type: 'data_pipeline';
+    pipeline_type: string;
+    tee_required: boolean;
+} | {
+    type: 'render_3d';
+    resolution: string;
+    frames: number;
+} | {
+    type: 'video_processing';
+    codec: string;
+    operation: string;
+} | {
+    type: 'custom';
+    name: string;
+    parallelizable: boolean;
+};
+/** Job status */
+type JobStatus = 'pending' | 'assigned' | 'running' | 'completed' | 'failed' | 'cancelled' | 'timeout';
+/** GPU tier classification */
+type GpuTier$1 = 'consumer' | 'workstation' | 'data_center' | 'enterprise' | 'frontier';
+/** Worker status */
+type WorkerStatus$1 = 'available' | 'busy' | 'offline' | 'suspended';
+/** Proof verification status */
+type ProofVerificationStatus = 'pending' | 'verified' | 'failed';
+/** Worker capabilities */
+interface WorkerCapabilities$1 {
+    gpu_model: string;
+    gpu_memory_gb: number;
+    cpu_cores: number;
+    ram_gb: number;
+    has_tee: boolean;
+    tee_type?: string;
+    supported_job_types: string[];
+}
+/** Worker information */
+interface WorkerInfo$1 {
+    id: WorkerId;
+    address: string;
+    capabilities: WorkerCapabilities$1;
+    status: WorkerStatus$1;
+    reputation: number;
+    stake_amount: bigint;
+    gpu_tier: GpuTier$1;
+    registered_at: Date;
+}
+/** Proof details */
+interface ProofDetails {
+    proof_hash: string;
+    job_id: JobId;
+    proof_type: string;
+    verification_status: ProofVerificationStatus;
+    created_at: Date;
+    verified_at?: Date;
+    gas_cost?: bigint;
+}
+/** Network statistics */
+interface NetworkStats$1 {
+    total_workers: number;
+    active_workers: number;
+    total_jobs_completed: bigint;
+    jobs_in_progress: number;
+    total_compute_hours: number;
+    average_job_duration_secs: number;
+    network_utilization: number;
+}
+/** Staking information */
+interface StakeInfo$1 {
+    staked_amount: bigint;
+    locked_until?: Date;
+    pending_rewards: bigint;
+    total_rewards_claimed: bigint;
+    gpu_tier: GpuTier$1;
+    is_slashable: boolean;
+}
+/** Faucet status */
+interface FaucetStatus {
+    can_claim: boolean;
+    time_until_next_claim_secs: number;
+    last_claim_at?: Date;
+    total_claimed: bigint;
+    claim_amount: bigint;
+}
+/** Submit job request */
+interface SubmitJobRequest {
+    job_type: JobType;
+    input_data: string;
+    max_cost_sage: bigint;
+    max_duration_secs: number;
+    priority: number;
+    require_tee: boolean;
+    deadline?: Date;
+    callback_url?: string;
+}
+/** Submit job response */
+interface SubmitJobResponse {
+    job_id: JobId;
+    status: JobStatus;
+    estimated_cost_sage: bigint;
+    estimated_completion_secs?: number;
+    queue_position?: number;
+}
+/** Job status response */
+interface JobStatusResponse {
+    job_id: JobId;
+    status: JobStatus;
+    worker_id?: WorkerId;
+    created_at: Date;
+    started_at?: Date;
+    completed_at?: Date;
+    error_message?: string;
+    result_hash?: string;
+}
+/** Job result */
+interface JobResult {
+    job_id: JobId;
+    output_data?: string;
+    output_files: string[];
+    execution_time_secs: number;
+    actual_cost_sage: bigint;
+    proof_hash?: string;
+    worker_id: WorkerId;
+    error?: string;
+}
+/** List jobs parameters */
+interface ListJobsParams {
+    limit?: number;
+    offset?: number;
+    status?: JobStatus;
+}
+/** List jobs response */
+interface ListJobsResponse {
+    jobs: JobStatusResponse[];
+    total: bigint;
+    has_more: boolean;
+}
+/** Faucet claim response */
+interface FaucetClaimResponse {
+    success: boolean;
+    amount: bigint;
+    transaction_hash: string;
+}
+/** Get minimum stake for GPU tier */
+declare function getMinStake(tier: GpuTier$1): bigint;
+/** Get GPU tier from model name */
+declare function getGpuTier(model: string): GpuTier$1;
+
+/**
+ * BitSage SDK Client
+ */
+
+/** Network selection */
+type Network$1 = 'mainnet' | 'sepolia' | 'local';
+/** Client configuration */
+interface ClientConfig {
+    /** Base URL for BitSage API */
+    apiUrl: string;
+    /** Starknet RPC URL */
+    starknetRpcUrl: string;
+    /** Request timeout in ms */
+    timeout: number;
+    /** Network */
+    network: Network$1;
+}
+/** Wallet configuration */
+interface WalletConfig {
+    privateKey: string;
+    accountAddress: string;
+}
+/** Default configuration for Sepolia testnet */
+declare const DEFAULT_CONFIG: ClientConfig;
+/** SDK Error */
+declare class SdkError extends Error {
+    code: string;
+    statusCode?: number | undefined;
+    constructor(message: string, code: string, statusCode?: number | undefined);
+}
+/**
+ * BitSage SDK Client
+ *
+ * @example
+ * ```typescript
+ * const client = new BitSageClient();
+ *
+ * // Submit a job
+ * const response = await client.submitJob({
+ *   job_type: { type: 'ai_inference', model_type: 'llama-7b', batch_size: 1 },
+ *   input_data: 'base64_data',
+ *   max_cost_sage: 100n,
+ *   max_duration_secs: 3600,
+ *   priority: 5,
+ *   require_tee: false,
+ * });
+ *
+ * // Wait for completion
+ * const result = await client.waitForCompletion(response.job_id);
+ * ```
+ */
+declare class BitSageClient {
+    private config;
+    private wallet?;
+    constructor(config?: Partial<ClientConfig>);
+    /** Set wallet for signing transactions */
+    withWallet(wallet: WalletConfig): this;
+    /** Submit a new job */
+    submitJob(request: SubmitJobRequest): Promise<SubmitJobResponse>;
+    /** Get job status */
+    getJobStatus(jobId: JobId): Promise<JobStatusResponse>;
+    /** Get job result */
+    getJobResult(jobId: JobId): Promise<JobResult>;
+    /** Cancel a job */
+    cancelJob(jobId: JobId): Promise<void>;
+    /** List jobs */
+    listJobs(params?: ListJobsParams): Promise<ListJobsResponse>;
+    /** Wait for job completion with polling */
+    waitForCompletion(jobId: JobId, pollIntervalMs?: number, timeoutSecs?: number): Promise<JobResult>;
+    /** Stream job status updates (async iterator) */
+    streamJobStatus(jobId: JobId, pollIntervalMs?: number): AsyncIterable<JobStatusResponse>;
+    /** List available workers */
+    listWorkers(): Promise<WorkerInfo$1[]>;
+    /** Get worker details */
+    getWorker(workerId: WorkerId): Promise<WorkerInfo$1>;
+    /** Get proof details */
+    getProof(proofHash: string): Promise<ProofDetails>;
+    /** Verify a proof */
+    verifyProof(proofHash: string): Promise<boolean>;
+    /** Stake SAGE tokens */
+    stake(amount: bigint, gpuTier: GpuTier$1): Promise<string>;
+    /** Unstake SAGE tokens */
+    unstake(amount: bigint): Promise<string>;
+    /** Claim staking rewards */
+    claimRewards(): Promise<bigint>;
+    /** Get stake information */
+    getStakeInfo(): Promise<StakeInfo$1>;
+    /** Get network statistics */
+    getNetworkStats(): Promise<NetworkStats$1>;
+    /** Claim tokens from faucet */
+    faucetClaim(address: string): Promise<FaucetClaimResponse>;
+    /** Get faucet status */
+    faucetStatus(address: string): Promise<FaucetStatus>;
+    private requireWallet;
+    private fetch;
+    private sleep;
+}
+
+/**
+ * Mining Rewards Types
+ * Generated from BitSage-Cairo-Smart-Contracts/src/economics/mining_rewards.cairo
+ */
+/** Staking tier determines daily mining caps */
+type StakeTier = 'None' | 'Bronze' | 'Silver' | 'Gold' | 'Platinum';
+/** Daily mining statistics */
+interface DailyStats {
+    /** Day number (unix timestamp / 86400) */
+    day: number;
+    /** Number of jobs completed this day */
+    jobs_completed: number;
+    /** SAGE earned today (wei) */
+    earned_today: bigint;
+}
+/** Worker's lifetime mining statistics */
+interface WorkerMiningStats {
+    /** Total jobs completed since registration */
+    total_jobs: bigint;
+    /** Total SAGE earned (wei) */
+    total_earned: bigint;
+    /** Daily statistics array */
+    daily_stats: DailyStats[];
+    /** Timestamp of first job */
+    first_job_at: number;
+    /** Timestamp of most recent job */
+    last_job_at: number;
+}
+/** Mining pool status */
+interface MiningPoolStatus {
+    /** Total SAGE distributed from pool (wei) */
+    total_distributed: bigint;
+    /** Remaining SAGE in mining pool (wei) */
+    remaining_pool: bigint;
+    /** Current base reward per job with halvening applied (wei) */
+    current_base_reward: bigint;
+    /** Current halvening multiplier (basis points, 10000 = 1.0x) */
+    halvening_multiplier: number;
+    /** Year number since mining started */
+    current_year: number;
+}
+/** Mining configuration */
+interface MiningConfig {
+    /** Base reward per job (wei) - 2 SAGE in Year 1 */
+    base_reward_wei: bigint;
+    /** Timestamp when mining started */
+    start_timestamp: number;
+    /** Halvening period in seconds (1 year) */
+    halvening_period_secs: number;
+    /** Daily caps by stake tier (wei) */
+    caps_by_tier: {
+        None: bigint;
+        Bronze: bigint;
+        Silver: bigint;
+        Gold: bigint;
+        Platinum: bigint;
+    };
+    /** GPU multipliers by tier (basis points, 10000 = 1.0x) */
+    gpu_multipliers: {
+        Consumer: number;
+        Workstation: number;
+        DataCenter: number;
+        Enterprise: number;
+        Frontier: number;
+    };
+}
+/** Result of mining reward calculation */
+interface RewardResult {
+    /** Calculated reward amount (wei) */
+    amount: bigint;
+    /** Whether the reward was capped by daily limit */
+    capped: boolean;
+    /** Remaining daily cap after this reward (wei) */
+    remaining_cap: bigint;
+    /** Worker's current stake tier */
+    stake_tier: StakeTier;
+}
+/** GPU tier for mining multipliers */
+type MiningGpuTier = 'Consumer' | 'Workstation' | 'DataCenter' | 'Enterprise' | 'Frontier';
+/** Stake tier thresholds (in SAGE wei) */
+declare const STAKE_TIER_THRESHOLDS: {
+    readonly None: 0n;
+    readonly Bronze: bigint;
+    readonly Silver: bigint;
+    readonly Gold: bigint;
+    readonly Platinum: bigint;
+};
+/** Daily caps by stake tier (in SAGE wei) */
+declare const DAILY_CAPS: {
+    readonly None: bigint;
+    readonly Bronze: bigint;
+    readonly Silver: bigint;
+    readonly Gold: bigint;
+    readonly Platinum: bigint;
+};
+/** GPU multipliers (basis points, 10000 = 1.0x) */
+declare const GPU_MULTIPLIERS: {
+    readonly Consumer: 10000;
+    readonly Workstation: 12500;
+    readonly DataCenter: 15000;
+    readonly Enterprise: 20000;
+    readonly Frontier: 25000;
+};
+/** Halvening schedule (year -> multiplier in basis points) */
+declare const HALVENING_SCHEDULE: {
+    readonly 1: 10000;
+    readonly 2: 7500;
+    readonly 3: 5000;
+    readonly 4: 3750;
+    readonly 5: 2500;
+};
+/** Helper to get stake tier from staked amount */
+declare function getStakeTierFromAmount(stakedAmount: bigint): StakeTier;
+/** Helper to get daily cap for stake tier */
+declare function getDailyCapForTier(tier: StakeTier): bigint;
+/** Helper to get GPU multiplier */
+declare function getGpuMultiplier(tier: MiningGpuTier): number;
+
+/**
+ * Obelysk Privacy Types
+ * Generated from BitSage-Cairo-Smart-Contracts/src/obelysk/
+ */
+/** Elliptic curve point (STARK curve) */
+interface ECPoint {
+    /** X coordinate (felt252) */
+    x: bigint;
+    /** Y coordinate (felt252) */
+    y: bigint;
+}
+/** ElGamal ciphertext (encrypted value) */
+interface ElGamalCiphertext {
+    /** First component C1 = r*G */
+    c1: ECPoint;
+    /** Second component C2 = M + r*PK */
+    c2: ECPoint;
+}
+/** Encrypted balance with pending operations */
+interface EncryptedBalance {
+    /** Main encrypted balance */
+    ciphertext: ElGamalCiphertext;
+    /** Pending incoming amount (encrypted) */
+    pending_in: ElGamalCiphertext;
+    /** Pending outgoing amount (encrypted) */
+    pending_out: ElGamalCiphertext;
+    /** Current epoch for balance updates */
+    epoch: number;
+}
+/** Schnorr proof for knowledge of discrete log */
+interface SchnorrProof {
+    /** Commitment point R = k*G */
+    commitment: ECPoint;
+    /** Challenge c = H(R || P || context) */
+    challenge: bigint;
+    /** Response s = k + c*x */
+    response: bigint;
+}
+/** Range proof for value bounds (0 <= v < 2^64) */
+interface RangeProof {
+    /** Commitment to value V = v*G + r*H */
+    commitment: ECPoint;
+    /** Proof hash (compressed representation) */
+    proof_hash: bigint;
+    /** Bit commitments for range decomposition */
+    bit_commitments: ECPoint[];
+}
+/** Complete transfer proof */
+interface TransferProof {
+    /** Proof sender has sufficient balance */
+    sender_proof: SchnorrProof;
+    /** Proof receiver received correct amount */
+    receiver_proof: SchnorrProof;
+    /** Range proof that amount is valid */
+    balance_proof: RangeProof;
+    /** Nullifier to prevent double-spending */
+    nullifier: bigint;
+}
+/** Same encryption proof (auditable transfers) */
+interface SameEncryption3Proof {
+    /** Proof that all ciphertexts encrypt same value */
+    commitment: ECPoint;
+    /** Challenge */
+    challenge: bigint;
+    /** Response */
+    response: bigint;
+    /** Second commitment for 3-party proof */
+    commitment2: ECPoint;
+    /** Second response */
+    response2: bigint;
+}
+/** AE (Additively Encrypted) hint for fast decryption */
+interface AEHint {
+    /** Hint component 0 */
+    c0: bigint;
+    /** Hint component 1 */
+    c1: bigint;
+    /** Hint component 2 */
+    c2: bigint;
+}
+/** Private account state */
+interface PrivateAccount {
+    /** Account owner address */
+    owner: string;
+    /** ElGamal public key for receiving */
+    public_key: ECPoint;
+    /** Current encrypted balance */
+    balance: EncryptedBalance;
+    /** AE hints for fast balance lookup */
+    hints: AEHint;
+    /** Account creation timestamp */
+    created_at: number;
+    /** Last activity timestamp */
+    last_activity: number;
+}
+/** Account hints for fast decryption */
+interface AccountHints {
+    /** AE hint data */
+    hint: AEHint;
+    /** Last update epoch */
+    epoch: number;
+    /** Hint verification hash */
+    verification_hash: bigint;
+}
+/** Privacy key pair */
+interface PrivacyKeyPair {
+    /** Public key for receiving encrypted funds */
+    publicKey: ECPoint;
+    /** Private key (never expose, use via WASM only) */
+    privateKey: Uint8Array;
+}
+/** Stealth address for one-time payments */
+interface StealthAddress {
+    /** Ephemeral public key (for ECDH) */
+    ephemeral_pubkey: ECPoint;
+    /** Stealth public key derived via ECDH */
+    stealth_pubkey: ECPoint;
+    /** View tag for scanning optimization */
+    view_tag: number;
+}
+/** Steganographic transaction (uniform format) */
+interface SteganographicTransaction {
+    /** Transaction type hidden in uniform format */
+    type_commitment: bigint;
+    /** Encrypted amount */
+    encrypted_amount: ElGamalCiphertext;
+    /** Sender's new balance (encrypted) */
+    sender_new_balance: ElGamalCiphertext;
+    /** Receiver's new balance (encrypted) */
+    receiver_new_balance: ElGamalCiphertext;
+    /** Proof of correctness */
+    proof: TransferProof;
+    /** Random padding for uniformity */
+    padding: bigint[];
+}
+/** Ring signature member */
+interface RingMember {
+    /** Member's public key */
+    public_key: ECPoint;
+    /** Member's commitment */
+    commitment: ECPoint;
+}
+/** Ring signature for anonymity */
+interface RingSignature {
+    /** Key image (prevents double-spending) */
+    key_image: ECPoint;
+    /** Ring members (including real signer) */
+    ring: RingMember[];
+    /** Signature components c values */
+    c_values: bigint[];
+    /** Signature components r values */
+    r_values: bigint[];
+}
+/** Mixing transaction for anonymity set */
+interface MixingTransaction {
+    /** Ring signature */
+    signature: RingSignature;
+    /** Encrypted output amount */
+    output: ElGamalCiphertext;
+    /** Recipient's stealth address */
+    recipient: StealthAddress;
+    /** Fee commitment */
+    fee_commitment: ECPoint;
+}
+/** Mixing output for anonymity pool */
+interface MixingOutput {
+    /** Output commitment */
+    commitment: ECPoint;
+    /** Encrypted amount */
+    encrypted_amount: ElGamalCiphertext;
+    /** Public key for claiming */
+    claim_key: ECPoint;
+    /** Timestamp */
+    created_at: number;
+    /** Whether used as decoy */
+    is_decoy_eligible: boolean;
+}
+/** Ragequit proof for emergency withdrawal */
+interface RagequitProof {
+    /** Proof of account ownership */
+    ownership_proof: SchnorrProof;
+    /** Revealed balance amount */
+    revealed_amount: bigint;
+    /** Balance proof */
+    balance_proof: RangeProof;
+    /** Current timestamp */
+    timestamp: number;
+}
+/** DKG (Distributed Key Generation) share */
+interface DKGShare {
+    /** Participant index */
+    index: number;
+    /** Share value */
+    share: bigint;
+    /** Commitment to share */
+    commitment: ECPoint;
+    /** Verification shares for VSS */
+    verification_shares: ECPoint[];
+}
+/** Threshold decryption request */
+interface ThresholdDecryptionRequest {
+    /** Request ID */
+    id: bigint;
+    /** Ciphertext to decrypt */
+    ciphertext: ElGamalCiphertext;
+    /** Requester address */
+    requester: string;
+    /** Shares received so far */
+    shares_received: number;
+    /** Required threshold */
+    threshold: number;
+    /** Status */
+    status: 'pending' | 'in_progress' | 'completed' | 'failed';
+}
+/** Multi-asset encrypted balance */
+interface MultiAssetBalance {
+    /** Asset token address */
+    asset: string;
+    /** Encrypted balance for this asset */
+    balance: EncryptedBalance;
+}
+/** Multi-asset balances container */
+interface MultiAssetBalances {
+    /** SAGE token balance */
+    SAGE: EncryptedBalance;
+    /** USDC balance */
+    USDC: EncryptedBalance;
+    /** STRK balance */
+    STRK: EncryptedBalance;
+    /** WBTC balance */
+    WBTC: EncryptedBalance;
+    /** ETH balance */
+    ETH: EncryptedBalance;
+}
+/** Private swap parameters */
+interface PrivateSwapParams {
+    /** Source asset */
+    from_asset: 'SAGE' | 'USDC' | 'STRK' | 'WBTC' | 'ETH';
+    /** Destination asset */
+    to_asset: 'SAGE' | 'USDC' | 'STRK' | 'WBTC' | 'ETH';
+    /** Encrypted amount to swap */
+    encrypted_amount: ElGamalCiphertext;
+    /** Minimum output proof */
+    min_output_proof: RangeProof;
+    /** Swap proof */
+    swap_proof: TransferProof;
+}
+/** Audit report for compliance */
+interface AuditReport {
+    /** Auditor address */
+    auditor: string;
+    /** Transaction hash audited */
+    tx_hash: bigint;
+    /** Decrypted amount (only auditor sees) */
+    decrypted_amount: bigint;
+    /** Audit timestamp */
+    timestamp: number;
+    /** Signature of audit */
+    signature: bigint;
+}
+/** Private transfer parameters */
+interface PrivateTransferParams {
+    /** Recipient address */
+    to: string;
+    /** Encrypted amount to transfer */
+    encrypted_amount: ElGamalCiphertext;
+    /** Sender's new balance (encrypted) */
+    sender_new_balance: ElGamalCiphertext;
+    /** Receiver's new balance (encrypted) */
+    receiver_new_balance: ElGamalCiphertext;
+    /** Transfer proof */
+    proof: TransferProof;
+}
+/** Private transfer with audit parameters */
+interface PrivateTransferWithAuditParams extends PrivateTransferParams {
+    /** Encrypted amount for auditor */
+    auditor_encrypted: ElGamalCiphertext;
+    /** Proof all three encrypt same value */
+    same_encryption_proof: SameEncryption3Proof;
+}
+/** Worker payment envelope */
+interface PrivateWorkerPayment {
+    /** Job ID */
+    job_id: bigint;
+    /** Worker address */
+    worker: string;
+    /** Encrypted payment amount */
+    encrypted_amount: ElGamalCiphertext;
+    /** Payment assets (multi-asset) */
+    assets: {
+        asset: string;
+        amount: ElGamalCiphertext;
+    }[];
+    /** Payment proof */
+    proof: TransferProof;
+}
+
+/**
+ * Payment Router Types
+ * Generated from BitSage-Cairo-Smart-Contracts/src/payments/
+ */
+/** Supported payment tokens */
+type PaymentToken = 'USDC' | 'STRK' | 'WBTC' | 'SAGE' | 'STAKED_SAGE' | 'PRIVACY_CREDIT';
+/** Payment quote from router */
+interface PaymentQuote {
+    /** Unique quote ID */
+    quote_id: bigint;
+    /** Token to pay with */
+    payment_token: PaymentToken;
+    /** Amount in payment token (wei) */
+    payment_amount: bigint;
+    /** SAGE equivalent amount (wei) */
+    sage_equivalent: bigint;
+    /** Discount applied (basis points) */
+    discount_bps: number;
+    /** USD value (6 decimals) */
+    usd_value: bigint;
+    /** Quote expiration timestamp */
+    expires_at: number;
+}
+/** Discount tiers by payment method */
+interface DiscountTiers {
+    /** Stablecoin discount (0%) */
+    stablecoin_discount_bps: number;
+    /** STRK discount (0%) */
+    strk_discount_bps: number;
+    /** WBTC discount (0%) */
+    wbtc_discount_bps: number;
+    /** SAGE direct payment discount (5%) */
+    sage_discount_bps: number;
+    /** Staked SAGE discount (10%) */
+    staked_sage_discount_bps: number;
+    /** Privacy credit discount (2%) */
+    privacy_credit_discount_bps: number;
+}
+/** Fee distribution configuration */
+interface FeeDistribution {
+    /** Worker share (80%) */
+    worker_bps: number;
+    /** Protocol fee (20%) */
+    protocol_fee_bps: number;
+    /** Burn share of protocol fee (70%) */
+    burn_share_bps: number;
+    /** Treasury share of protocol fee (20%) */
+    treasury_share_bps: number;
+    /** Staker rewards share of protocol fee (10%) */
+    staker_share_bps: number;
+}
+/** OTC desk configuration */
+interface OTCConfig {
+    /** USDC token address */
+    usdc_address: string;
+    /** STRK token address */
+    strk_address: string;
+    /** WBTC token address */
+    wbtc_address: string;
+    /** SAGE token address */
+    sage_address: string;
+    /** Pragma oracle address */
+    oracle_address: string;
+    /** Maximum slippage (basis points) */
+    max_slippage_bps: number;
+    /** Quote validity duration (seconds) */
+    quote_validity_secs: number;
+}
+/** Payment statistics */
+interface PaymentStats {
+    /** Total payments in USD (6 decimals) */
+    total_payments_usd: bigint;
+    /** Total SAGE burned (wei) */
+    total_sage_burned: bigint;
+    /** Total paid to workers (wei) */
+    total_worker_payments: bigint;
+    /** Total staker rewards (wei) */
+    total_staker_rewards: bigint;
+    /** Total treasury collected (wei) */
+    total_treasury_collected: bigint;
+    /** Number of payments processed */
+    payment_count: bigint;
+}
+/** Job payment record */
+interface JobPaymentRecord {
+    /** Job ID */
+    job_id: bigint;
+    /** Worker address */
+    worker: string;
+    /** Client address */
+    client: string;
+    /** Payment amount in SAGE (wei) */
+    sage_amount: bigint;
+    /** USD value (6 decimals) */
+    usd_value: bigint;
+    /** Whether privacy is enabled */
+    privacy_enabled: boolean;
+    /** Payment status */
+    status: PaymentStatus;
+    /** Proof hash (if verified) */
+    proof_hash?: bigint;
+    /** Registration timestamp */
+    registered_at: number;
+    /** Completion timestamp */
+    completed_at?: number;
+}
+/** Payment status */
+type PaymentStatus = 'Pending' | 'ProofVerified' | 'PaymentReleased' | 'Disputed' | 'Cancelled';
+/** Verification source for payment release */
+type VerificationSource = 'STWOProof' | 'TEEOptimistic' | 'TEEChallenged';
+/** Metered billing checkpoint */
+interface ComputeCheckpoint {
+    /** Checkpoint ID */
+    checkpoint_id: bigint;
+    /** Job ID */
+    job_id: bigint;
+    /** Hour number (1-indexed) */
+    hour_number: number;
+    /** Proof data hash */
+    proof_hash: bigint;
+    /** Checkpoint status */
+    status: CheckpointStatus;
+    /** Submitted at timestamp */
+    submitted_at: number;
+    /** Verified at timestamp */
+    verified_at?: number;
+    /** Payment released at */
+    paid_at?: number;
+}
+/** Checkpoint status */
+type CheckpointStatus = 'Submitted' | 'Verified' | 'Paid' | 'Failed';
+/** Privacy credit deposit */
+interface PrivacyCreditDeposit {
+    /** Depositor address */
+    depositor: string;
+    /** Amount deposited (wei) */
+    amount: bigint;
+    /** Commitment for privacy */
+    commitment: bigint;
+    /** Timestamp */
+    deposited_at: number;
+}
+/** Privacy credit usage */
+interface PrivacyCreditUsage {
+    /** Job ID paid for */
+    job_id: bigint;
+    /** USD amount used (6 decimals) */
+    usd_amount: bigint;
+    /** Nullifier to prevent double-spend */
+    nullifier: bigint;
+    /** Timestamp */
+    used_at: number;
+}
+/** Transaction result */
+interface TransactionResult$6 {
+    /** Transaction hash */
+    transaction_hash: string;
+    /** Status */
+    status: 'pending' | 'accepted' | 'rejected';
+    /** Block number (if accepted) */
+    block_number?: number;
+    /** Gas used */
+    gas_used?: bigint;
+}
+/** Default discount tiers */
+declare const DEFAULT_DISCOUNT_TIERS: DiscountTiers;
+/** Default fee distribution */
+declare const DEFAULT_FEE_DISTRIBUTION: FeeDistribution;
+
+/**
+ * Staking Types
+ * Generated from BitSage-Cairo-Smart-Contracts/src/staking/prover_staking.cairo
+ */
+/** GPU tier classification for staking */
+type GpuTier = 'Consumer' | 'Workstation' | 'DataCenter' | 'Enterprise' | 'Frontier';
+/** Worker tier (8 levels for tokenomics v3.0) */
+type WorkerTier = 'Basic' | 'Premium' | 'Enterprise' | 'Infrastructure' | 'Fleet' | 'Datacenter' | 'Hyperscale' | 'Institutional';
+/** Holder tier based on stake amount */
+type HolderTier = 'Regular' | 'Whale' | 'Institution' | 'HyperWhale';
+/** Slash reason codes */
+type SlashReason = 'InvalidProof' | 'Timeout' | 'RepeatedFailures' | 'Malicious' | 'BenchmarkFraud' | 'ProtocolViolation' | 'Unavailable' | 'PoorPerformance' | 'Fraud';
+/** Worker stake information */
+interface WorkerStake {
+    /** Total staked amount (wei) */
+    amount: bigint;
+    /** Amount locked (cannot unstake) */
+    locked_amount: bigint;
+    /** Timestamp when staked */
+    staked_at: number;
+    /** Last rewards claim timestamp */
+    last_claim_at: number;
+    /** GPU tier */
+    gpu_tier: GpuTier;
+    /** Whether worker is active */
+    is_active: boolean;
+    /** Consecutive job failures */
+    consecutive_failures: number;
+    /** Total successful jobs */
+    total_successes: bigint;
+    /** Total slashed amount */
+    total_slashed: bigint;
+    /** Whether has TEE support */
+    has_tee: boolean;
+    /** TEE type if applicable */
+    tee_type?: 'IntelTDX' | 'AMDSEVSNP' | 'NvidiaCC';
+}
+/** Extended stake info with rewards */
+interface StakeInfo {
+    /** Core stake data */
+    stake: WorkerStake;
+    /** Pending rewards (wei) */
+    pending_rewards: bigint;
+    /** Total rewards claimed (wei) */
+    total_rewards_claimed: bigint;
+    /** Current APY estimate (basis points) */
+    estimated_apy_bps: number;
+    /** Worker tier */
+    worker_tier: WorkerTier;
+    /** Holder tier */
+    holder_tier: HolderTier;
+    /** Locked until timestamp (for unstaking) */
+    locked_until?: number;
+    /** Is eligible for jobs */
+    is_eligible: boolean;
+}
+/** Staking configuration */
+interface StakingConfig {
+    /** Minimum stake per GPU tier (wei) */
+    min_stake_per_tier: {
+        Consumer: bigint;
+        Workstation: bigint;
+        DataCenter: bigint;
+        Enterprise: bigint;
+        Frontier: bigint;
+    };
+    /** Slash percentages per reason (basis points) */
+    slash_percentages: {
+        InvalidProof: number;
+        Timeout: number;
+        RepeatedFailures: number;
+        Malicious: number;
+        BenchmarkFraud: number;
+        ProtocolViolation: number;
+        Unavailable: number;
+        PoorPerformance: number;
+        Fraud: number;
+    };
+    /** Unstake lockup period (seconds) */
+    unstake_lockup_secs: number;
+    /** Base reward APY (basis points) */
+    reward_apy_bps: number;
+    /** TEE bonus APY (basis points) */
+    tee_bonus_apy_bps: number;
+}
+/** Slash record */
+interface SlashRecord {
+    /** Slash ID */
+    slash_id: bigint;
+    /** Worker address */
+    worker: string;
+    /** Slash reason */
+    reason: SlashReason;
+    /** Amount slashed (wei) */
+    amount: bigint;
+    /** Percentage slashed (basis points) */
+    percentage_bps: number;
+    /** Related job ID if applicable */
+    job_id?: bigint;
+    /** Challenger address if any */
+    challenger?: string;
+    /** Timestamp */
+    slashed_at: number;
+    /** Evidence hash */
+    evidence_hash?: bigint;
+    /** Is disputed */
+    is_disputed: boolean;
+    /** Dispute ID if disputed */
+    dispute_id?: bigint;
+}
+/** Dispute record for slash challenges */
+interface DisputeRecord {
+    /** Dispute ID */
+    dispute_id: bigint;
+    /** Related slash ID */
+    slash_id: bigint;
+    /** Challenger address */
+    challenger: string;
+    /** Dispute bond amount (wei) */
+    bond_amount: bigint;
+    /** Evidence hash provided */
+    evidence_hash: bigint;
+    /** Dispute status */
+    status: DisputeStatus;
+    /** Submitted at timestamp */
+    submitted_at: number;
+    /** Resolution timestamp */
+    resolved_at?: number;
+    /** Resolution reason */
+    resolution_reason?: string;
+    /** Whether slash was upheld */
+    slash_upheld?: boolean;
+}
+/** Dispute status */
+type DisputeStatus = 'Pending' | 'UnderReview' | 'Resolved' | 'Rejected' | 'Expired';
+/** Worker tier benefits */
+interface WorkerTierBenefits {
+    /** Tier name */
+    tier: WorkerTier;
+    /** Required stake USD value */
+    required_stake_usd: bigint;
+    /** Priority queue access */
+    priority_queue: boolean;
+    /** Job multiplier (basis points) */
+    job_multiplier_bps: number;
+    /** Reduced slashing (basis points reduction) */
+    slash_reduction_bps: number;
+    /** Governance voting weight multiplier */
+    voting_weight_multiplier: number;
+}
+/** Unstake request */
+interface UnstakeRequest {
+    /** Request ID */
+    request_id: bigint;
+    /** Worker address */
+    worker: string;
+    /** Amount to unstake (wei) */
+    amount: bigint;
+    /** Request timestamp */
+    requested_at: number;
+    /** Available after timestamp */
+    available_at: number;
+    /** Status */
+    status: 'Pending' | 'Available' | 'Completed' | 'Cancelled';
+}
+/** Minimum stake requirements */
+declare const MIN_STAKE: {
+    readonly Consumer: bigint;
+    readonly Workstation: bigint;
+    readonly DataCenter: bigint;
+    readonly Enterprise: bigint;
+    readonly Frontier: bigint;
+};
+/** Slash percentages (basis points) */
+declare const SLASH_PERCENTAGES: {
+    readonly InvalidProof: 1000;
+    readonly Timeout: 500;
+    readonly RepeatedFailures: 1500;
+    readonly Malicious: 5000;
+    readonly BenchmarkFraud: 3000;
+    readonly ProtocolViolation: 2000;
+    readonly Unavailable: 200;
+    readonly PoorPerformance: 500;
+    readonly Fraud: 10000;
+};
+/** Unstake lockup period (7 days) */
+declare const UNSTAKE_LOCKUP_SECS: number;
+/** Helper to check if worker is eligible */
+declare function isWorkerEligible(stake: WorkerStake): boolean;
+/** Helper to get min stake for tier */
+declare function getMinStakeForTier(tier: GpuTier): bigint;
+
+/**
+ * SAGE Token Governance Types
+ * Generated from BitSage-Cairo-Smart-Contracts/src/sage_token.cairo
+ */
+/** Proposal status */
+type ProposalStatus = 'Draft' | 'Active' | 'Succeeded' | 'Executed' | 'Defeated' | 'Cancelled' | 'Expired';
+/** Proposal type for enhanced governance */
+type ProposalType = 'Standard' | 'InflationAdjustment' | 'BurnRateChange' | 'TreasurySpend' | 'ProtocolUpgrade' | 'Emergency';
+/** Governance proposal */
+interface GovernanceProposal {
+    /** Proposal ID */
+    proposal_id: bigint;
+    /** Proposer address */
+    proposer: string;
+    /** Description of proposal */
+    description: string;
+    /** Proposal type */
+    proposal_type: ProposalType;
+    /** Inflation change (basis points, signed) */
+    inflation_change_bps: number;
+    /** Burn rate change (basis points, signed) */
+    burn_rate_change_bps: number;
+    /** Treasury spend amount (if applicable) */
+    treasury_spend_amount?: bigint;
+    /** Treasury spend recipient */
+    treasury_spend_recipient?: string;
+    /** Votes in favor */
+    votes_for: bigint;
+    /** Votes against */
+    votes_against: bigint;
+    /** Current status */
+    status: ProposalStatus;
+    /** Creation timestamp */
+    created_at: number;
+    /** Voting start timestamp */
+    voting_starts_at: number;
+    /** Voting end timestamp */
+    voting_ends_at: number;
+    /** Execution timestamp (if executed) */
+    executed_at?: number;
+    /** Quorum required (basis points) */
+    quorum_bps: number;
+    /** Snapshot block number */
+    snapshot_block: number;
+}
+/** Governance rights for an address */
+interface GovernanceRights {
+    /** Address */
+    address: string;
+    /** Current voting power */
+    voting_power: bigint;
+    /** Can create standard proposals */
+    can_create_standard: boolean;
+    /** Can create inflation proposals */
+    can_create_inflation: boolean;
+    /** Can create emergency proposals */
+    can_create_emergency: boolean;
+    /** Number of active proposals */
+    active_proposals: number;
+    /** Last proposal timestamp */
+    last_proposal_at?: number;
+    /** Delegated voting power */
+    delegated_power: bigint;
+    /** Address delegated to */
+    delegated_to?: string;
+}
+/** Governance statistics */
+interface GovernanceStats {
+    /** Total proposals created */
+    total_proposals: bigint;
+    /** Total executed proposals */
+    executed_proposals: bigint;
+    /** Total defeated proposals */
+    defeated_proposals: bigint;
+    /** Current total voting power */
+    total_voting_power: bigint;
+    /** Average participation rate (basis points) */
+    avg_participation_bps: number;
+    /** Current quorum threshold (basis points) */
+    quorum_threshold_bps: number;
+    /** Minimum proposal threshold (SAGE) */
+    proposal_threshold: bigint;
+}
+/** Token pool balances */
+interface PoolBalances {
+    /** Ecosystem pool (40%) */
+    ecosystem: bigint;
+    /** Treasury pool (15%) */
+    treasury: bigint;
+    /** Team pool (15%) */
+    team: bigint;
+    /** Public sale pool (10%) */
+    public_sale: bigint;
+    /** Pre-seed pool (2%) */
+    pre_seed: bigint;
+    /** Seed pool (5%) */
+    seed: bigint;
+    /** Strategic pool (8%) */
+    strategic: bigint;
+    /** Advisors pool (3%) */
+    advisors: bigint;
+    /** Code dev pool (2%) */
+    code_dev: bigint;
+}
+/** Vesting status */
+interface VestingStatus {
+    /** Treasury vesting progress (basis points) */
+    treasury_vested_bps: number;
+    /** Team vesting progress (basis points) */
+    team_vested_bps: number;
+    /** Whether team cliff has passed */
+    team_cliff_passed: boolean;
+    /** Public sale vesting progress (basis points) */
+    public_sale_vested_bps: number;
+    /** Months since TGE */
+    months_since_tge: number;
+    /** Next vesting release timestamp */
+    next_release_at: number;
+}
+/** Security budget information */
+interface SecurityBudget {
+    /** Annual security budget (wei) */
+    annual_budget: bigint;
+    /** Remaining budget this year (wei) */
+    remaining_budget: bigint;
+    /** Reserve fund (wei) */
+    reserve_fund: bigint;
+    /** Last audit timestamp */
+    last_audit_at: number;
+    /** Current security score (0-100) */
+    security_score: number;
+}
+/** Burn event record */
+interface BurnEvent {
+    /** Event ID */
+    event_id: bigint;
+    /** Amount burned (wei) */
+    amount: bigint;
+    /** Revenue source */
+    revenue_source: string;
+    /** Execution price (6 decimals) */
+    execution_price: bigint;
+    /** Timestamp */
+    burned_at: number;
+    /** Transaction hash */
+    tx_hash: string;
+}
+/** Ecosystem emission status */
+interface EcosystemEmissionStatus {
+    /** Remaining to emit (wei) */
+    remaining: bigint;
+    /** Total emitted (wei) */
+    total_emitted: bigint;
+    /** Current month number */
+    current_month: number;
+    /** Last emission timestamp */
+    last_emission_at: number;
+    /** Current emission rate (wei/month) */
+    emission_rate: bigint;
+}
+/** Token flow summary */
+interface TokenFlowSummary {
+    /** Total minted (wei) */
+    total_minted: bigint;
+    /** Total burned (wei) */
+    total_burned: bigint;
+    /** Net change (wei, absolute value) */
+    net_change_abs: bigint;
+    /** Whether net deflationary */
+    is_deflationary: boolean;
+    /** Period start timestamp */
+    period_start: number;
+    /** Period end timestamp */
+    period_end: number;
+}
+/** Milestone status flags */
+interface MilestoneStatus {
+    /** Burned 10% of supply */
+    burn_10_percent: boolean;
+    /** Burned 25% of supply */
+    burn_25_percent: boolean;
+    /** Burned 50% of supply */
+    burn_50_percent: boolean;
+    /** Reached 1M USD monthly revenue */
+    revenue_1m_usd: boolean;
+    /** Reached 10M USD monthly revenue */
+    revenue_10m_usd: boolean;
+}
+/** Rate limit info for large transfers */
+interface RateLimitInfo {
+    /** Amount already transferred this period */
+    amount_transferred: bigint;
+    /** Period start timestamp */
+    period_start: number;
+    /** Maximum allowed per period */
+    max_per_period: bigint;
+    /** Cooldown remaining (seconds) */
+    cooldown_remaining: number;
+}
+/** Pending large transfer */
+interface PendingTransfer {
+    /** Transfer ID */
+    transfer_id: bigint;
+    /** Sender address */
+    from: string;
+    /** Recipient address */
+    to: string;
+    /** Amount (wei) */
+    amount: bigint;
+    /** Initiated timestamp */
+    initiated_at: number;
+    /** Executable after timestamp */
+    executable_after: number;
+    /** Status */
+    status: 'Pending' | 'Executed' | 'Cancelled';
+}
+/** Create proposal parameters */
+interface CreateProposalParams {
+    /** Proposal description */
+    description: string;
+    /** Proposal type */
+    proposal_type: ProposalType;
+    /** Inflation change (optional, basis points) */
+    inflation_change_bps?: number;
+    /** Burn rate change (optional, basis points) */
+    burn_rate_change_bps?: number;
+    /** Treasury spend amount (optional, wei) */
+    treasury_spend_amount?: bigint;
+    /** Treasury spend recipient (optional) */
+    treasury_spend_recipient?: string;
+}
+/** Governance configuration constants */
+declare const GOVERNANCE_CONFIG: {
+    /** Voting period (3 days) */
+    readonly VOTING_PERIOD_SECS: number;
+    /** Execution delay (1 day) */
+    readonly EXECUTION_DELAY_SECS: number;
+    /** Quorum threshold (4%) */
+    readonly QUORUM_BPS: 400;
+    /** Proposal threshold (100,000 SAGE) */
+    readonly PROPOSAL_THRESHOLD: bigint;
+    /** Emergency proposal threshold (1,000,000 SAGE) */
+    readonly EMERGENCY_THRESHOLD: bigint;
+    /** Maximum inflation change per proposal (1%) */
+    readonly MAX_INFLATION_CHANGE_BPS: 100;
+    /** Maximum burn rate change per proposal (5%) */
+    readonly MAX_BURN_RATE_CHANGE_BPS: 500;
+    /** Rate limit window (24 hours) */
+    readonly RATE_LIMIT_WINDOW_SECS: number;
+    /** Large transfer threshold */
+    readonly LARGE_TRANSFER_THRESHOLD: bigint;
+    /** Large transfer timelock (24 hours) */
+    readonly LARGE_TRANSFER_TIMELOCK_SECS: number;
+};
+
+/**
+ * STWO Verifier and Proof Types
+ * Generated from BitSage-Cairo-Smart-Contracts/src/obelysk/stwo_verifier.cairo
+ */
+/** Proof verification status */
+type VerificationStatus = 'NotSubmitted' | 'Pending' | 'Verified' | 'Failed' | 'Rejected' | 'OptimisticPending' | 'Challenged';
+/** Proof source type */
+type ProofSource = 'StandardSTWO' | 'GpuTeeSTWO' | 'Unknown';
+/** TEE type for GPU attestation */
+type TeeType$1 = 'IntelTDX' | 'AMDSEVSNP' | 'NvidiaCC';
+/** TEE attestation data */
+interface TeeAttestation {
+    /** TEE type */
+    tee_type: TeeType$1;
+    /** Enclave measurement hash */
+    enclave_measurement: bigint;
+    /** Quote hash */
+    quote_hash: bigint;
+    /** Attestation timestamp */
+    attestation_timestamp: number;
+    /** Whether enclave is whitelisted */
+    is_whitelisted: boolean;
+}
+/** Proof metadata */
+interface ProofMetadata {
+    /** Proof hash */
+    proof_hash: bigint;
+    /** Public input hash */
+    public_input_hash: bigint;
+    /** Security bits */
+    security_bits: number;
+    /** Submission timestamp */
+    submitted_at: number;
+    /** Submitter address */
+    submitter: string;
+    /** Verification status */
+    status: VerificationStatus;
+    /** Proof source */
+    source: ProofSource;
+    /** TEE attestation (if GPU-TEE proof) */
+    tee_attestation?: TeeAttestation;
+    /** Verification timestamp */
+    verified_at?: number;
+    /** Gas used for verification */
+    gas_used?: bigint;
+    /** Challenge window end (for optimistic proofs) */
+    challenge_window_end?: number;
+}
+/** GPU-TEE proof submission parameters */
+interface GpuTeeProofParams {
+    /** Proof data (serialized) */
+    proof_data: string[];
+    /** Public input hash */
+    public_input_hash: bigint;
+    /** TEE type (1=Intel TDX, 2=AMD SEV-SNP, 3=NVIDIA CC) */
+    tee_type: number;
+    /** Enclave measurement */
+    enclave_measurement: bigint;
+    /** Quote hash */
+    quote_hash: bigint;
+    /** Attestation timestamp */
+    attestation_timestamp: number;
+}
+/** Batch verification status */
+interface BatchStatus {
+    /** Batch ID */
+    batch_id: string;
+    /** Batch hash */
+    batch_hash: bigint;
+    /** Number of proofs in batch */
+    proof_count: number;
+    /** Number verified */
+    verified_count: number;
+    /** Number failed */
+    failed_count: number;
+    /** Overall status */
+    status: 'Pending' | 'InProgress' | 'Completed' | 'PartialFailure' | 'Failed';
+    /** Submitted at */
+    submitted_at: number;
+    /** Completed at */
+    completed_at?: number;
+    /** Total gas used */
+    total_gas_used?: bigint;
+}
+/** Proof job specification */
+interface ProofJobSpec {
+    /** Proof type */
+    proof_type: ProofType;
+    /** Batch hash (what we're proving) */
+    batch_hash: bigint;
+    /** Public input hash */
+    public_input_hash: bigint;
+    /** Priority level */
+    priority: ProofPriority;
+    /** Base reward in USDC (6 decimals) */
+    reward_usdc: bigint;
+    /** Bonus in SAGE (wei) */
+    bonus_sage: bigint;
+    /** Deadline timestamp */
+    deadline_timestamp: number;
+    /** Required TEE attestations */
+    required_attestations: number;
+    /** Minimum stake requirement */
+    min_stake_requirement: bigint;
+}
+/** Proof type */
+type ProofType = 'StarknetBatch' | 'RecursiveProof' | 'ZKMLInference' | 'CrossChainBridge' | 'ApplicationSpecific';
+/** Proof priority level */
+type ProofPriority = 'Standard' | 'High' | 'Critical' | 'Emergency';
+/** Proof submission for verification */
+interface ProofSubmission {
+    /** Job ID being proven */
+    job_id: bigint;
+    /** Proof data (serialized) */
+    proof_data: string[];
+    /** Public inputs */
+    public_inputs: bigint[];
+    /** Worker address */
+    worker: string;
+    /** TEE attestation (if using GPU-TEE) */
+    tee_attestation?: TeeAttestation;
+    /** Computation proof hash */
+    computation_proof_hash: bigint;
+}
+/** Prover metrics */
+interface ProverMetrics {
+    /** Worker ID */
+    worker_id: string;
+    /** Total proofs submitted */
+    total_proofs: bigint;
+    /** Total verified */
+    verified_proofs: bigint;
+    /** Total failed */
+    failed_proofs: bigint;
+    /** Average verification time (ms) */
+    avg_verification_time_ms: number;
+    /** Current reputation score */
+    reputation_score: number;
+    /** Total rewards earned (wei) */
+    total_rewards: bigint;
+}
+/** Compression statistics */
+interface CompressionStats {
+    /** Original proof size (bytes) */
+    original_size: number;
+    /** Compressed size (bytes) */
+    compressed_size: number;
+    /** Compression ratio (0.0-1.0) */
+    compression_ratio: number;
+    /** Algorithm used */
+    algorithm: 'zstd' | 'lz4' | 'snappy';
+    /** Compression time (ms) */
+    compression_time_ms: number;
+}
+/** Compressed proof envelope */
+interface CompressedProof {
+    /** Algorithm used */
+    algorithm: 'zstd' | 'lz4' | 'snappy';
+    /** Compressed data */
+    data: Uint8Array;
+    /** Original size for validation */
+    original_size: number;
+    /** Integrity hash */
+    integrity_hash: bigint;
+}
+/** TEE quote for attestation */
+interface TeeQuote {
+    /** Quote data (raw) */
+    quote_data: Uint8Array;
+    /** Enclave measurement */
+    enclave_measurement: bigint;
+    /** Timestamp */
+    timestamp: number;
+    /** Additional claims */
+    claims: Record<string, bigint>;
+}
+/** Execution metrics from TEE */
+interface ExecutionMetrics {
+    /** CPU cycles */
+    cpu_cycles: bigint;
+    /** Memory peak (bytes) */
+    memory_peak: bigint;
+    /** Execution time (ms) */
+    execution_time_ms: number;
+    /** GPU utilization (if applicable) */
+    gpu_utilization?: number;
+}
+/** Enclave information */
+interface EnclaveInfo {
+    /** Enclave measurement */
+    measurement: bigint;
+    /** TEE type */
+    tee_type: TeeType$1;
+    /** Whitelisted at */
+    whitelisted_at: number;
+    /** Whitelisted by */
+    whitelisted_by: string;
+    /** Is currently valid */
+    is_valid: boolean;
+    /** Revoked at (if revoked) */
+    revoked_at?: number;
+}
+/** Verification constants */
+declare const VERIFICATION_CONFIG: {
+    /** Standard verification gas estimate */
+    readonly STANDARD_GAS: 500000n;
+    /** GPU-TEE verification gas estimate */
+    readonly GPU_TEE_GAS: 100000n;
+    /** Challenge period (24 hours) */
+    readonly CHALLENGE_PERIOD_SECS: number;
+    /** Minimum challenge stake */
+    readonly MIN_CHALLENGE_STAKE: bigint;
+    /** Maximum proof size (256KB) */
+    readonly MAX_PROOF_SIZE: number;
+    /** Security bits required */
+    readonly REQUIRED_SECURITY_BITS: 128;
+};
+
+/**
+ * HTTP Client with retry logic and error handling
+ */
+interface HttpConfig {
+    /** Base URL for API */
+    baseUrl: string;
+    /** Request timeout in ms */
+    timeout: number;
+    /** Maximum retry attempts */
+    maxRetries: number;
+    /** Retry delay base (ms) - uses exponential backoff */
+    retryDelayMs: number;
+    /** Custom headers */
+    headers?: Record<string, string>;
+}
+declare const DEFAULT_HTTP_CONFIG: HttpConfig;
+/**
+ * HTTP Client with automatic retry and error handling
+ */
+declare class HttpClient {
+    private config;
+    constructor(config?: Partial<HttpConfig>);
+    /**
+     * GET request
+     */
+    get<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    /**
+     * POST request
+     */
+    post<T>(path: string, body?: unknown): Promise<T>;
+    /**
+     * PUT request
+     */
+    put<T>(path: string, body?: unknown): Promise<T>;
+    /**
+     * DELETE request
+     */
+    delete<T>(path: string): Promise<T>;
+    /**
+     * Build URL with query parameters
+     */
+    private buildUrl;
+    /**
+     * Execute request with retry logic
+     */
+    private request;
+    /**
+     * Execute single request
+     */
+    private executeRequest;
+    /**
+     * Check if error is retryable
+     */
+    private isRetryable;
+    /**
+     * Sleep helper
+     */
+    private sleep;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<HttpConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): HttpConfig;
+}
+
+/**
+ * WebSocket Client with auto-reconnect and subscription management
+ */
+interface WsConfig {
+    /** WebSocket URL */
+    url: string;
+    /** Auto-reconnect on disconnect */
+    reconnect: boolean;
+    /** Initial reconnect delay (ms) */
+    reconnectIntervalMs: number;
+    /** Maximum reconnect attempts */
+    maxReconnectAttempts: number;
+    /** Heartbeat interval (ms) */
+    heartbeatIntervalMs: number;
+    /** Connection timeout (ms) */
+    connectTimeoutMs: number;
+}
+declare const DEFAULT_WS_CONFIG: WsConfig;
+/** WebSocket event types */
+type WsEventType = 'job_update' | 'worker_update' | 'network_stats' | 'proof_verified' | 'heartbeat' | 'error';
+/** Base WebSocket event */
+interface WsEvent {
+    type: WsEventType;
+    timestamp: number;
+    data: unknown;
+}
+/** Job update event */
+interface JobUpdateEvent extends WsEvent {
+    type: 'job_update';
+    data: {
+        job_id: string;
+        status: string;
+        progress?: number;
+        error?: string;
+        worker_id?: string;
+    };
+}
+/** Worker update event */
+interface WorkerUpdateEvent extends WsEvent {
+    type: 'worker_update';
+    data: {
+        worker_id: string;
+        status: string;
+        gpu_utilization?: number;
+        memory_usage?: number;
+        active_jobs?: number;
+        temperature?: number;
+    };
+}
+/** Network stats event */
+interface NetworkStatsEvent extends WsEvent {
+    type: 'network_stats';
+    data: {
+        active_workers: number;
+        jobs_in_progress: number;
+        tps: number;
+        jobs_completed_last_hour: number;
+    };
+}
+/** Proof verified event */
+interface ProofVerifiedEvent extends WsEvent {
+    type: 'proof_verified';
+    data: {
+        proof_hash: string;
+        job_id: string;
+        verified: boolean;
+        gas_used?: bigint;
+        tx_hash?: string;
+    };
+}
+type EventCallback<T extends WsEvent = WsEvent> = (event: T) => void;
+type Unsubscribe = () => void;
+/**
+ * WebSocket Client with auto-reconnect and subscriptions
+ */
+declare class WebSocketClient {
+    private config;
+    private ws;
+    private subscriptions;
+    private reconnectAttempts;
+    private heartbeatTimer;
+    private reconnectTimer;
+    private isIntentionallyClosed;
+    private onReconnectCallback?;
+    private onErrorCallback?;
+    private onDisconnectCallback?;
+    constructor(config?: Partial<WsConfig>);
+    /**
+     * Connect to WebSocket server
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from WebSocket server
+     */
+    disconnect(): void;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Subscribe to job updates
+     */
+    subscribeToJobUpdates(jobId: string, callback: EventCallback<JobUpdateEvent>): Unsubscribe;
+    /**
+     * Subscribe to worker updates
+     */
+    subscribeToWorkerUpdates(workerId: string, callback: EventCallback<WorkerUpdateEvent>): Unsubscribe;
+    /**
+     * Subscribe to network stats
+     */
+    subscribeToNetworkStats(callback: EventCallback<NetworkStatsEvent>): Unsubscribe;
+    /**
+     * Subscribe to proof verified events
+     */
+    subscribeToProofVerified(proofHash: string, callback: EventCallback<ProofVerifiedEvent>): Unsubscribe;
+    /**
+     * Generic subscribe method
+     */
+    subscribe(channel: string, callback: EventCallback): Unsubscribe;
+    /**
+     * Set reconnect callback
+     */
+    onReconnect(callback: () => void): Unsubscribe;
+    /**
+     * Set error callback
+     */
+    onError(callback: (error: Error) => void): Unsubscribe;
+    /**
+     * Set disconnect callback
+     */
+    onDisconnect(callback: () => void): Unsubscribe;
+    /**
+     * Handle incoming message
+     */
+    private handleMessage;
+    /**
+     * Get channel from event
+     */
+    private getChannelFromEvent;
+    /**
+     * Send subscribe message
+     */
+    private sendSubscribe;
+    /**
+     * Send unsubscribe message
+     */
+    private sendUnsubscribe;
+    /**
+     * Send message
+     */
+    private send;
+    /**
+     * Start heartbeat
+     */
+    private startHeartbeat;
+    /**
+     * Stop heartbeat
+     */
+    private stopHeartbeat;
+    /**
+     * Schedule reconnection
+     */
+    private scheduleReconnect;
+    /**
+     * Clear reconnect timer
+     */
+    private clearReconnectTimer;
+    /**
+     * Resubscribe to all channels after reconnect
+     */
+    private resubscribeAll;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<WsConfig>): void;
+}
+
+/**
+ * Starknet Contract Client
+ * Handles direct contract interactions for on-chain operations
+ */
+
+interface ContractConfig {
+    /** Starknet RPC URL */
+    rpcUrl: string;
+    /** Network (mainnet, sepolia, local) */
+    network: 'mainnet' | 'sepolia' | 'local';
+    /** Account address for signing */
+    accountAddress?: string;
+    /** Private key for signing */
+    privateKey?: string;
+    /** Maximum gas price (wei) */
+    maxGasPrice?: bigint;
+    /** Transaction confirmation timeout (ms) */
+    confirmationTimeoutMs: number;
+    /** Polling interval for transaction status (ms) */
+    pollingIntervalMs: number;
+}
+declare const DEFAULT_CONTRACT_CONFIG: ContractConfig;
+/** Transaction status */
+type TxStatus = 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+/** Transaction receipt */
+interface TransactionReceipt {
+    transaction_hash: string;
+    status: TxStatus;
+    block_hash?: string;
+    block_number?: number;
+    actual_fee?: {
+        amount: string;
+        unit: string;
+    };
+    execution_status?: 'SUCCEEDED' | 'REVERTED';
+    revert_reason?: string;
+}
+/**
+ * Starknet Contract Client
+ *
+ * Provides direct contract interaction capabilities for:
+ * - Reading contract state (call)
+ * - Writing to contracts (invoke)
+ * - Waiting for transaction confirmation
+ */
+declare class ContractClient {
+    private config;
+    constructor(config?: Partial<ContractConfig>);
+    /**
+     * Configure wallet for signing transactions
+     */
+    withWallet(accountAddress: string, privateKey: string): this;
+    /**
+     * Call a contract method (read-only, no gas)
+     */
+    call(contractAddress: string, entrypoint: string, calldata?: string[]): Promise<string[]>;
+    /**
+     * Invoke a contract method (write, requires gas)
+     */
+    invoke(contractAddress: string, entrypoint: string, calldata?: string[]): Promise<TransactionResult$6>;
+    /**
+     * Invoke and wait for confirmation
+     */
+    invokeAndWait(contractAddress: string, entrypoint: string, calldata?: string[]): Promise<TransactionResult$6>;
+    /**
+     * Wait for transaction to be accepted
+     */
+    waitForTransaction(txHash: string): Promise<TransactionResult$6>;
+    /**
+     * Get transaction receipt
+     */
+    getTransactionReceipt(txHash: string): Promise<TransactionReceipt>;
+    /**
+     * Get transaction status
+     */
+    getTransactionStatus(txHash: string): Promise<TxStatus>;
+    /**
+     * Get current block number
+     */
+    getBlockNumber(): Promise<number>;
+    /**
+     * Get chain ID
+     */
+    getChainId(): Promise<string>;
+    /**
+     * Send transaction (internal)
+     */
+    private sendTransaction;
+    /**
+     * Make RPC call
+     */
+    private rpcCall;
+    /**
+     * Get selector from function name
+     */
+    private getSelectorFromName;
+    /**
+     * Simplified Starknet Keccak (for selector calculation)
+     */
+    private starknetKeccak;
+    /**
+     * Require wallet to be configured
+     */
+    private requireWallet;
+    /**
+     * Sleep helper
+     */
+    private sleep;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<ContractConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): ContractConfig;
+}
+/**
+ * Helper to encode felt252 values
+ */
+declare function toFelt(value: string | number | bigint): string;
+/**
+ * Helper to decode felt252 values
+ */
+declare function fromFelt(felt: string): bigint;
+/**
+ * Split u256 into two felt252 (low, high)
+ */
+declare function splitU256(value: bigint): [string, string];
+/**
+ * Join two felt252 into u256
+ */
+declare function joinU256(low: string, high: string): bigint;
+
+/**
+ * Contract Address Registry
+ * Maintains deployed contract addresses for all networks
+ */
+/** Contract registry interface */
+interface ContractRegistry {
+    /** SAGE ERC20 token */
+    sageToken: string;
+    /** Prover staking contract */
+    proverStaking: string;
+    /** Mining rewards contract */
+    miningRewards: string;
+    /** Job manager contract */
+    jobManager: string;
+    /** CDC Pool (worker registry) */
+    cdcPool: string;
+    /** Reputation manager */
+    reputationManager: string;
+    /** Payment router */
+    paymentRouter: string;
+    /** Proof-gated payment */
+    proofGatedPayment: string;
+    /** STWO verifier */
+    stwoVerifier: string;
+    /** Privacy router (Obelysk) */
+    privacyRouter: string;
+    /** Optimistic TEE verifier */
+    optimisticTee: string;
+    /** Faucet (testnet only) */
+    faucet?: string;
+}
+/** Sepolia testnet contract addresses */
+declare const SEPOLIA_CONTRACTS: ContractRegistry;
+/** Mainnet contract addresses (to be updated at launch) */
+declare const MAINNET_CONTRACTS: ContractRegistry;
+/** Local development contract addresses */
+declare const LOCAL_CONTRACTS: ContractRegistry;
+/** Network type */
+type Network = 'mainnet' | 'sepolia' | 'local';
+/**
+ * Get contract addresses for a network
+ */
+declare function getContractsForNetwork(network: Network): ContractRegistry;
+/**
+ * Check if a contract address is configured (not zero)
+ */
+declare function isContractConfigured(address: string): boolean;
+/**
+ * External token addresses (not BitSage contracts)
+ */
+interface ExternalTokens {
+    /** USDC stablecoin */
+    usdc: string;
+    /** Starknet token (STRK) */
+    strk: string;
+    /** Wrapped Bitcoin */
+    wbtc: string;
+    /** Wrapped Ethereum */
+    weth: string;
+}
+/** Sepolia external tokens */
+declare const SEPOLIA_TOKENS: ExternalTokens;
+/** Mainnet external tokens */
+declare const MAINNET_TOKENS: ExternalTokens;
+/**
+ * Get external tokens for a network
+ */
+declare function getTokensForNetwork(network: Network): ExternalTokens;
+/**
+ * Pragma Oracle addresses
+ */
+declare const PRAGMA_ORACLE: {
+    readonly sepolia: "0x036031daa264c24520b11d93af622c848b2499b66b41d611bac95e13cfca131a";
+    readonly mainnet: "0x2a85bd616f912537c50a49a4076db02c00b29b2cdc8a197ce92ed1837fa875b";
+};
+
+/**
+ * Mining Rewards Module
+ * Interacts with the MiningRewards contract for per-job rewards
+ */
+
+interface MiningClientConfig {
+    /** Mining rewards contract address */
+    contractAddress: string;
+}
+/**
+ * Mining Rewards Client
+ *
+ * Provides access to the mining rewards system including:
+ * - Per-job reward estimation
+ * - Worker mining statistics
+ * - Mining pool status and halvening
+ * - Daily caps by stake tier
+ *
+ * @example
+ * ```typescript
+ * const mining = new MiningClient(httpClient, contractClient, { contractAddress: '0x...' });
+ *
+ * // Estimate reward for a job
+ * const estimate = await mining.getMiningRewardEstimate('Frontier');
+ * console.log(`Expected reward: ${estimate.amount / 10n**18n} SAGE`);
+ *
+ * // Check worker stats
+ * const stats = await mining.getWorkerMiningStats('worker-123');
+ * console.log(`Total earned: ${stats.total_earned} SAGE`);
+ * ```
+ */
+declare class MiningClient {
+    private http;
+    private contract;
+    private config;
+    constructor(http: HttpClient, contract: ContractClient, config: MiningClientConfig);
+    /**
+     * Estimate mining reward for a job completion
+     *
+     * @param gpuTier - GPU tier of the worker
+     * @param workerAddress - Optional worker address for accurate daily cap
+     * @returns Estimated reward with cap status
+     */
+    getMiningRewardEstimate(gpuTier: MiningGpuTier, workerAddress?: string): Promise<RewardResult>;
+    /**
+     * Get worker's mining statistics
+     *
+     * @param workerId - Worker identifier
+     * @returns Lifetime mining statistics
+     */
+    getWorkerMiningStats(workerId: string): Promise<WorkerMiningStats>;
+    /**
+     * Get mining pool status
+     *
+     * @returns Current pool status including distributed amount and halvening
+     */
+    getMiningPoolStatus(): Promise<MiningPoolStatus>;
+    /**
+     * Get daily cap for a stake tier
+     *
+     * @param stakeTier - Stake tier
+     * @returns Daily cap in wei
+     */
+    getDailyCap(stakeTier: StakeTier): Promise<bigint>;
+    /**
+     * Get current base reward (with halvening applied)
+     *
+     * @returns Base reward per job in wei
+     */
+    getCurrentBaseReward(): Promise<bigint>;
+    /**
+     * Get GPU multiplier for a tier
+     *
+     * @param gpuTier - GPU tier
+     * @returns Multiplier in basis points (10000 = 1.0x)
+     */
+    getGPUMultiplier(gpuTier: MiningGpuTier): number;
+    /**
+     * Get remaining daily cap for a worker
+     *
+     * @param workerAddress - Worker address
+     * @returns Remaining cap in wei
+     */
+    getRemainingDailyCap(workerAddress: string): Promise<bigint>;
+    /**
+     * Get mining configuration
+     *
+     * @returns Full mining configuration
+     */
+    getMiningConfig(): Promise<MiningConfig>;
+    /**
+     * Get worker's daily statistics for a specific day
+     *
+     * @param workerId - Worker identifier
+     * @param day - Day number (optional, defaults to today)
+     * @returns Daily statistics
+     */
+    getWorkerDailyStats(workerId: string, day?: number): Promise<DailyStats>;
+    /**
+     * Get total distributed from mining pool
+     *
+     * @returns Total distributed in wei
+     */
+    getTotalDistributed(): Promise<bigint>;
+    /**
+     * Get remaining in mining pool
+     *
+     * @returns Remaining pool in wei
+     */
+    getRemainingPool(): Promise<bigint>;
+    /**
+     * Get current halvening year and multiplier
+     *
+     * @returns Halvening info
+     */
+    getHalveningInfo(): Promise<{
+        year: number;
+        multiplier: number;
+    }>;
+    /**
+     * Calculate expected reward locally (without API call)
+     *
+     * @param gpuTier - GPU tier
+     * @param stakeTier - Stake tier
+     * @param baseReward - Base reward (optional, uses Year 1 default)
+     * @param halveningYear - Halvening year (optional, defaults to 1)
+     * @returns Calculated reward
+     */
+    calculateRewardLocally(gpuTier: MiningGpuTier, stakeTier: StakeTier, baseReward?: bigint, // 2 SAGE default
+    halveningYear?: number): bigint;
+    /**
+     * Record job completion and distribute mining reward
+     * Note: This is typically called by the coordinator, not directly by workers
+     *
+     * @param jobId - Completed job ID
+     * @param gpuTier - Worker's GPU tier
+     * @returns Transaction result
+     */
+    recordJobCompletion(jobId: string, gpuTier: MiningGpuTier): Promise<TransactionResult$6>;
+    /**
+     * Get worker stats directly from contract
+     *
+     * @param workerAddress - Worker address
+     * @returns Worker mining stats
+     */
+    getWorkerMiningStatsFromContract(workerAddress: string): Promise<WorkerMiningStats>;
+    /**
+     * Get remaining cap from contract
+     *
+     * @param workerAddress - Worker address
+     * @returns Remaining cap in wei
+     */
+    getRemainingCapFromContract(workerAddress: string): Promise<bigint>;
+    /**
+     * Get stake tier from contract
+     *
+     * @param workerAddress - Worker address
+     * @returns Stake tier
+     */
+    getStakeTierFromContract(workerAddress: string): Promise<StakeTier>;
+    /**
+     * Convert GPU tier to contract enum value
+     */
+    private gpuTierToContractValue;
+    /**
+     * Convert contract value to stake tier
+     */
+    private contractValueToStakeTier;
+    /**
+     * Parse worker stats response from contract
+     */
+    private parseWorkerStatsResponse;
+}
+/**
+ * Create a MiningClient instance
+ */
+declare function createMiningClient(http: HttpClient, contract: ContractClient, contractAddress: string): MiningClient;
+
+/**
+ * Dashboard API Module
+ * Provides validator metrics, GPU stats, and network information
+ */
+
+/** Validator registration status */
+type ValidatorStatus = 'unregistered' | 'pending' | 'active' | 'suspended' | 'exiting';
+/** Validator status response */
+interface ValidatorStatusResponse {
+    /** Wallet address */
+    address: string;
+    /** Worker ID (if registered) */
+    worker_id?: string;
+    /** Registration status */
+    status: ValidatorStatus;
+    /** GPU tier */
+    gpu_tier?: GpuTier;
+    /** Stake tier */
+    stake_tier?: StakeTier;
+    /** Reputation score (0-1000) */
+    reputation_score: number;
+    /** Uptime percentage (basis points) */
+    uptime_bps: number;
+    /** Total jobs completed */
+    jobs_completed: number;
+    /** Jobs in progress */
+    jobs_in_progress: number;
+    /** Registration timestamp */
+    registered_at?: number;
+    /** Last activity timestamp */
+    last_activity_at?: number;
+}
+/** Individual GPU metrics */
+interface GpuMetrics {
+    /** GPU index */
+    index: number;
+    /** GPU model name */
+    model: string;
+    /** GPU tier classification */
+    tier: GpuTier;
+    /** Total VRAM in GB */
+    vram_total_gb: number;
+    /** Used VRAM in GB */
+    vram_used_gb: number;
+    /** VRAM utilization percentage */
+    vram_utilization: number;
+    /** GPU compute utilization percentage */
+    compute_utilization: number;
+    /** Temperature in Celsius */
+    temperature_celsius: number;
+    /** Power usage in watts */
+    power_watts: number;
+    /** Current job ID (if busy) */
+    current_job_id?: string;
+    /** Driver version */
+    driver_version: string;
+    /** CUDA version */
+    cuda_version?: string;
+    /** Whether has TEE support */
+    has_tee: boolean;
+    /** TEE type if available */
+    tee_type?: 'IntelTDX' | 'AMDSEVSNP' | 'NvidiaCC';
+}
+/** GPU metrics response */
+interface GpuMetricsResponse {
+    /** Array of GPU metrics */
+    gpus: GpuMetrics[];
+    /** Total GPUs */
+    total_gpus: number;
+    /** Active GPUs (currently processing) */
+    active_gpus: number;
+    /** Average utilization */
+    avg_utilization: number;
+    /** Total compute power (TFLOPs) */
+    total_tflops: number;
+}
+/** Rewards information */
+interface RewardsInfo {
+    /** Claimable rewards (wei) */
+    claimable_rewards: bigint;
+    /** Pending rewards (not yet claimable) */
+    pending_rewards: bigint;
+    /** Total rewards earned (lifetime) */
+    total_earned: bigint;
+    /** Total rewards claimed (lifetime) */
+    total_claimed: bigint;
+    /** Estimated APY (basis points) */
+    estimated_apy_bps: number;
+    /** Last claim timestamp */
+    last_claim_at?: number;
+    /** Mining rewards (from jobs) */
+    mining_rewards: bigint;
+    /** Staking rewards */
+    staking_rewards: bigint;
+}
+/** Period filter for history */
+type HistoryPeriod = 'day' | 'week' | 'month' | 'year' | 'all';
+/** Reward history entry */
+interface RewardHistoryEntry {
+    /** Timestamp */
+    timestamp: number;
+    /** Amount earned (wei) */
+    amount: bigint;
+    /** Reward type */
+    type: 'mining' | 'staking' | 'bonus';
+    /** Related job ID (for mining rewards) */
+    job_id?: string;
+    /** Transaction hash (for claimed rewards) */
+    tx_hash?: string;
+}
+/** Reward history response */
+interface RewardHistoryResponse {
+    /** History entries */
+    entries: RewardHistoryEntry[];
+    /** Total for period (wei) */
+    total: bigint;
+    /** Period */
+    period: HistoryPeriod;
+    /** Period start */
+    period_start: number;
+    /** Period end */
+    period_end: number;
+}
+/** Job analytics */
+interface JobAnalytics {
+    /** Total jobs received */
+    total_jobs: number;
+    /** Completed jobs */
+    completed_jobs: number;
+    /** Failed jobs */
+    failed_jobs: number;
+    /** Success rate (basis points) */
+    success_rate_bps: number;
+    /** Average completion time (ms) */
+    avg_completion_time_ms: number;
+    /** Jobs by type */
+    jobs_by_type: Record<string, number>;
+    /** Average reward per job (wei) */
+    avg_reward_per_job: bigint;
+    /** Total compute hours */
+    total_compute_hours: number;
+}
+/** Recent job */
+interface RecentJob {
+    /** Job ID */
+    job_id: string;
+    /** Job type */
+    job_type: string;
+    /** Status */
+    status: string;
+    /** Reward earned (wei) */
+    reward: bigint;
+    /** Duration (ms) */
+    duration_ms: number;
+    /** Completed at */
+    completed_at: number;
+    /** Proof hash */
+    proof_hash?: string;
+}
+/** Network statistics */
+interface NetworkStats {
+    /** Total registered workers */
+    total_workers: number;
+    /** Currently active workers */
+    active_workers: number;
+    /** Workers by GPU tier */
+    workers_by_tier: Record<GpuTier, number>;
+    /** Total jobs completed (all time) */
+    total_jobs_completed: bigint;
+    /** Jobs in progress */
+    jobs_in_progress: number;
+    /** Network TPS (jobs per second) */
+    current_tps: number;
+    /** Total compute hours (all time) */
+    total_compute_hours: number;
+    /** Network utilization (basis points) */
+    utilization_bps: number;
+    /** Total SAGE staked (wei) */
+    total_staked: bigint;
+    /** Average APY (basis points) */
+    avg_apy_bps: number;
+}
+/** Worker summary for network view */
+interface WorkerSummary {
+    /** Worker ID */
+    worker_id: string;
+    /** GPU tier */
+    gpu_tier: GpuTier;
+    /** Reputation score */
+    reputation: number;
+    /** Jobs completed (last 24h) */
+    jobs_24h: number;
+    /** Is currently active */
+    is_active: boolean;
+    /** Location hash (privacy-preserving) */
+    location_hash?: string;
+}
+/** Network workers response */
+interface NetworkWorkersResponse {
+    /** Worker summaries */
+    workers: WorkerSummary[];
+    /** Total count */
+    total: number;
+    /** Page */
+    page: number;
+    /** Page size */
+    page_size: number;
+    /** Has more pages */
+    has_more: boolean;
+}
+/**
+ * Dashboard API Client
+ *
+ * Provides comprehensive dashboard data for validators including:
+ * - Validator status and registration
+ * - GPU metrics and utilization
+ * - Rewards tracking and history
+ * - Job analytics
+ * - Network statistics
+ *
+ * @example
+ * ```typescript
+ * const dashboard = new DashboardClient(httpClient);
+ *
+ * // Get validator status
+ * const status = await dashboard.getValidatorStatus();
+ * console.log(`Status: ${status.status}, Reputation: ${status.reputation_score}`);
+ *
+ * // Get GPU metrics
+ * const gpus = await dashboard.getGPUMetrics();
+ * gpus.gpus.forEach(gpu => {
+ *   console.log(`${gpu.model}: ${gpu.compute_utilization}% utilization`);
+ * });
+ * ```
+ */
+declare class DashboardClient {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Get current validator status
+     *
+     * @returns Validator status and metrics
+     */
+    getValidatorStatus(): Promise<ValidatorStatusResponse>;
+    /**
+     * Get GPU metrics for all GPUs
+     *
+     * @returns GPU metrics array
+     */
+    getGPUMetrics(): Promise<GpuMetricsResponse>;
+    /**
+     * Get rewards information
+     *
+     * @returns Claimable and pending rewards
+     */
+    getRewardsInfo(): Promise<RewardsInfo>;
+    /**
+     * Get rewards history
+     *
+     * @param period - Time period filter
+     * @returns Reward history entries
+     */
+    getRewardsHistory(period?: HistoryPeriod): Promise<RewardHistoryResponse>;
+    /**
+     * Get job analytics
+     *
+     * @returns Job completion statistics
+     */
+    getJobAnalytics(): Promise<JobAnalytics>;
+    /**
+     * Get recent completed jobs
+     *
+     * @param limit - Maximum number of jobs to return
+     * @returns Recent job list
+     */
+    getRecentJobs(limit?: number): Promise<RecentJob[]>;
+    /**
+     * Get network-wide statistics
+     *
+     * @returns Network statistics
+     */
+    getNetworkStats(): Promise<NetworkStats>;
+    /**
+     * Get list of network workers
+     *
+     * @param page - Page number (1-indexed)
+     * @param pageSize - Items per page
+     * @returns Paginated worker list
+     */
+    getNetworkWorkers(page?: number, pageSize?: number): Promise<NetworkWorkersResponse>;
+    /**
+     * Get deployed contract addresses
+     *
+     * @returns Contract registry
+     */
+    getContractAddresses(): Promise<ContractRegistry>;
+    /**
+     * Check API health
+     *
+     * @returns Health status
+     */
+    healthCheck(): Promise<{
+        status: 'healthy' | 'degraded' | 'unhealthy';
+        latency_ms: number;
+    }>;
+}
+/**
+ * Create a DashboardClient instance
+ */
+declare function createDashboardClient(http: HttpClient): DashboardClient;
+
+/**
+ * Batch Operations Module
+ * Provides gas-optimized batch operations for jobs and proofs
+ */
+
+/** Maximum jobs per batch */
+declare const MAX_BATCH_SIZE = 100;
+/** Batch job submission response */
+interface BatchJobResponse {
+    /** Successfully submitted jobs */
+    submitted: SubmitJobResponse[];
+    /** Failed submissions with errors */
+    failed: Array<{
+        index: number;
+        request: SubmitJobRequest;
+        error: string;
+    }>;
+    /** Total submitted count */
+    submitted_count: number;
+    /** Total failed count */
+    failed_count: number;
+    /** Estimated total gas saved (vs individual) */
+    gas_saved_estimate: bigint;
+}
+/** Batch status response */
+interface BatchStatusResponse {
+    /** Job statuses by ID */
+    statuses: Map<string, JobStatusResponse>;
+    /** Jobs not found */
+    not_found: string[];
+}
+/** Batch operation type for gas estimation */
+type BatchOperationType = 'submit_job' | 'cancel_job' | 'verify_proof' | 'claim_rewards';
+/** Batch operation for gas estimation */
+interface BatchOperation {
+    type: BatchOperationType;
+    /** Number of operations */
+    count: number;
+    /** Estimated calldata size per operation */
+    calldata_size?: number;
+}
+/** Gas estimate result */
+interface GasEstimate {
+    /** Total estimated gas */
+    total_gas: bigint;
+    /** Gas per operation */
+    gas_per_operation: bigint;
+    /** Estimated gas savings vs individual calls */
+    savings_bps: number;
+    /** Estimated cost in SAGE (wei) */
+    estimated_cost_sage: bigint;
+}
+/** Batch proof verification request */
+interface BatchVerifyRequest {
+    /** Proof hashes to verify */
+    proof_hashes: string[];
+}
+/** Batch proof verification response */
+interface BatchVerifyResponse {
+    /** Verification results by proof hash */
+    results: Map<string, boolean>;
+    /** Total verified */
+    verified_count: number;
+    /** Total failed */
+    failed_count: number;
+    /** Gas used */
+    gas_used: bigint;
+}
+/**
+ * Batch Operations Client
+ *
+ * Provides gas-optimized batch operations for:
+ * - Submitting multiple jobs at once
+ * - Checking status of multiple jobs
+ * - Verifying multiple proofs
+ *
+ * Batch operations can save up to 60% on gas costs compared to
+ * individual transactions.
+ *
+ * @example
+ * ```typescript
+ * const batch = new BatchClient(httpClient);
+ *
+ * // Submit multiple jobs
+ * const jobs: SubmitJobRequest[] = [...];
+ * const result = await batch.submitJobBatch(jobs);
+ * console.log(`Submitted ${result.submitted_count} jobs, saved ~${result.gas_saved_estimate} gas`);
+ *
+ * // Check multiple job statuses
+ * const jobIds = result.submitted.map(j => j.job_id);
+ * const statuses = await batch.getJobStatusBatch(jobIds);
+ * ```
+ */
+declare class BatchClient {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Submit multiple jobs in a single batch
+     *
+     * @param jobs - Array of job requests (max 100)
+     * @returns Batch submission result
+     * @throws Error if batch size exceeds maximum
+     */
+    submitJobBatch(jobs: SubmitJobRequest[]): Promise<BatchJobResponse>;
+    /**
+     * Get status of multiple jobs
+     *
+     * @param jobIds - Array of job IDs
+     * @returns Map of job ID to status
+     */
+    getJobStatusBatch(jobIds: string[]): Promise<BatchStatusResponse>;
+    /**
+     * Verify multiple proofs in batch
+     *
+     * @param proofHashes - Array of proof hashes
+     * @returns Verification results
+     */
+    verifyProofBatch(proofHashes: string[]): Promise<BatchVerifyResponse>;
+    /**
+     * Estimate gas for batch operations
+     *
+     * @param operations - Operations to estimate
+     * @returns Gas estimate
+     */
+    estimateBatchGas(operations: BatchOperation[]): Promise<GasEstimate>;
+    /**
+     * Cancel multiple jobs in batch
+     *
+     * @param jobIds - Array of job IDs to cancel
+     * @returns Cancellation results
+     */
+    cancelJobBatch(jobIds: string[]): Promise<{
+        cancelled: string[];
+        failed: Array<{
+            job_id: string;
+            error: string;
+        }>;
+    }>;
+    /**
+     * Split large array into batches
+     *
+     * @param items - Items to split
+     * @param batchSize - Size of each batch (default: MAX_BATCH_SIZE)
+     * @returns Array of batches
+     */
+    static splitIntoBatches<T>(items: T[], batchSize?: number): T[][];
+    /**
+     * Process items in batches with parallel execution
+     *
+     * @param items - Items to process
+     * @param processor - Batch processor function
+     * @param options - Processing options
+     * @returns Combined results
+     */
+    static processBatches<T, R>(items: T[], processor: (batch: T[]) => Promise<R[]>, options?: {
+        batchSize?: number;
+        concurrency?: number;
+    }): Promise<R[]>;
+}
+/**
+ * Create a BatchClient instance
+ */
+declare function createBatchClient(http: HttpClient): BatchClient;
+
+/**
+ * Payments Module
+ * Multi-token payment system with OTC desk and privacy credits
+ */
+
+interface PaymentsClientConfig {
+    /** Payment router contract address */
+    paymentRouterAddress: string;
+    /** Proof-gated payment contract address */
+    proofGatedPaymentAddress: string;
+}
+/**
+ * Payments Client
+ *
+ * Handles all payment operations including:
+ * - Multi-token payment quotes (USDC, STRK, WBTC, SAGE)
+ * - Direct SAGE payments with discounts
+ * - Staked SAGE payments (10% discount)
+ * - Privacy credits for anonymous payments
+ * - Metered billing with hourly checkpoints
+ *
+ * @example
+ * ```typescript
+ * const payments = new PaymentsClient(httpClient, contractClient, config);
+ *
+ * // Get a payment quote
+ * const quote = await payments.getPaymentQuote('SAGE', 100n * 10n**6n); // $100 worth
+ * console.log(`Pay ${quote.payment_amount} SAGE (${quote.discount_bps/100}% discount)`);
+ *
+ * // Execute the payment
+ * const result = await payments.executePayment(quote.quote_id, jobId);
+ * ```
+ */
+declare class PaymentsClient {
+    private http;
+    private contract;
+    private config;
+    constructor(http: HttpClient, contract: ContractClient, config: PaymentsClientConfig);
+    /**
+     * Get a payment quote for a USD amount
+     *
+     * @param token - Payment token to use
+     * @param usdAmount - Amount in USD (6 decimals, e.g., 100_000_000 = $100)
+     * @returns Payment quote with conversion rate and discount
+     */
+    getPaymentQuote(token: PaymentToken, usdAmount: bigint): Promise<PaymentQuote>;
+    /**
+     * Execute a quoted payment
+     *
+     * @param quoteId - Quote ID from getPaymentQuote
+     * @param jobId - Job being paid for
+     * @returns Transaction result
+     */
+    executePayment(quoteId: bigint, jobId: bigint): Promise<TransactionResult$6>;
+    /**
+     * Pay directly with SAGE tokens (5% discount)
+     *
+     * @param amount - SAGE amount (wei)
+     * @param jobId - Job being paid for
+     * @returns Transaction result
+     */
+    payWithSAGE(amount: bigint, jobId: bigint): Promise<TransactionResult$6>;
+    /**
+     * Pay with staked SAGE (10% discount)
+     *
+     * @param usdAmount - USD amount (6 decimals)
+     * @param jobId - Job being paid for
+     * @returns Transaction result
+     */
+    payWithStakedSAGE(usdAmount: bigint, jobId: bigint): Promise<TransactionResult$6>;
+    /**
+     * Deposit tokens as privacy credits
+     *
+     * @param amount - Amount to deposit (wei)
+     * @param commitment - Privacy commitment hash
+     * @returns Transaction result
+     */
+    depositPrivacyCredits(amount: bigint, commitment: string): Promise<TransactionResult$6>;
+    /**
+     * Pay anonymously using privacy credits (2% discount)
+     *
+     * @param usdAmount - USD amount (6 decimals)
+     * @param nullifier - Nullifier to prevent double-spending
+     * @param proof - ZK proof of valid credit
+     * @returns Transaction result
+     */
+    payWithPrivacyCredits(usdAmount: bigint, nullifier: string, proof: string[]): Promise<TransactionResult$6>;
+    /**
+     * Get current discount tiers
+     *
+     * @returns Discount configuration
+     */
+    getDiscountTiers(): Promise<DiscountTiers>;
+    /**
+     * Get fee distribution configuration
+     *
+     * @returns Fee distribution (worker/burn/treasury/stakers split)
+     */
+    getFeeDistribution(): Promise<FeeDistribution>;
+    /**
+     * Get payment statistics
+     *
+     * @returns Payment volume statistics
+     */
+    getStats(): Promise<PaymentStats>;
+    /**
+     * Check if payment is ready for release
+     *
+     * @param jobId - Job ID
+     * @returns Whether proof has been verified and payment can be released
+     */
+    isPaymentReady(jobId: bigint): Promise<boolean>;
+    /**
+     * Get job payment record
+     *
+     * @param jobId - Job ID
+     * @returns Payment record details
+     */
+    getJobPayment(jobId: bigint): Promise<JobPaymentRecord>;
+    /**
+     * Manually release payment (if proof verified)
+     *
+     * @param jobId - Job ID
+     * @returns Transaction result
+     */
+    releasePayment(jobId: bigint): Promise<TransactionResult$6>;
+    /**
+     * Submit hourly compute checkpoint
+     *
+     * @param jobId - Job ID
+     * @param hour - Hour number (1-indexed)
+     * @param proofData - Proof of computation
+     * @param proofHash - Hash of the proof
+     * @returns Transaction result
+     */
+    submitCheckpoint(jobId: bigint, hour: number, proofData: string[], proofHash: string): Promise<TransactionResult$6>;
+    /**
+     * Verify and pay for a checkpoint
+     *
+     * @param checkpointId - Checkpoint ID
+     * @returns Transaction result
+     */
+    verifyAndPayCheckpoint(checkpointId: bigint): Promise<TransactionResult$6>;
+    /**
+     * Get checkpoints for a job
+     *
+     * @param jobId - Job ID
+     * @returns Array of checkpoint records
+     */
+    getJobCheckpoints(jobId: bigint): Promise<ComputeCheckpoint[]>;
+    /**
+     * Calculate discount amount
+     *
+     * @param baseAmount - Base amount (wei)
+     * @param discountBps - Discount in basis points
+     * @returns Discounted amount
+     */
+    static calculateDiscount(baseAmount: bigint, discountBps: number): bigint;
+    /**
+     * Get discount for payment token
+     *
+     * @param token - Payment token
+     * @param tiers - Discount tiers (or uses defaults)
+     * @returns Discount in basis points
+     */
+    static getDiscountForToken(token: PaymentToken, tiers?: DiscountTiers): number;
+}
+/**
+ * Create a PaymentsClient instance
+ */
+declare function createPaymentsClient(http: HttpClient, contract: ContractClient, paymentRouterAddress: string, proofGatedPaymentAddress: string): PaymentsClient;
+
+/**
+ * Enhanced Staking Module
+ * Full staking system with TEE support, slashing, and worker tiers
+ */
+
+interface StakingClientConfig {
+    /** Prover staking contract address */
+    proverStakingAddress: string;
+    /** CDC Pool contract address */
+    cdcPoolAddress: string;
+}
+/** Transaction result */
+interface TransactionResult$5 {
+    transaction_hash: string;
+    status: 'pending' | 'accepted' | 'rejected';
+    receipt?: TransactionReceipt;
+}
+/** TEE type for enhanced staking */
+type TeeType = 'IntelTDX' | 'AMDSEVSNP' | 'NvidiaCC';
+/**
+ * Enhanced Staking Client
+ *
+ * Full staking system including:
+ * - Basic staking operations (stake, unstake, claim)
+ * - TEE-enhanced staking with bonus rewards
+ * - 8-level worker tier system
+ * - Slashing and dispute mechanisms
+ * - Delegation support
+ *
+ * @example
+ * ```typescript
+ * const staking = new StakingClient(httpClient, contractClient, config);
+ *
+ * // Stake with TEE support
+ * await staking.stakeWithTEE(5000n * 10n**18n, 'DataCenter', true, 'NvidiaCC');
+ *
+ * // Check worker tier and benefits
+ * const tier = await staking.getWorkerTier(workerAddress);
+ * const benefits = await staking.getWorkerTierBenefits(tier);
+ * console.log(`Tier: ${tier}, Job multiplier: ${benefits.job_multiplier_bps/100}%`);
+ *
+ * // Claim rewards
+ * await staking.claimRewards();
+ * ```
+ */
+declare class StakingClient {
+    private http;
+    private contract;
+    private config;
+    constructor(http: HttpClient, contract: ContractClient, config: StakingClientConfig);
+    /**
+     * Stake SAGE tokens
+     *
+     * @param amount - Amount to stake (wei)
+     * @param gpuTier - GPU tier classification
+     * @returns Transaction result
+     */
+    stake(amount: bigint, gpuTier: GpuTier): Promise<TransactionResult$5>;
+    /**
+     * Stake with TEE support for bonus rewards
+     *
+     * @param amount - Amount to stake (wei)
+     * @param gpuTier - GPU tier classification
+     * @param hasTEE - Whether worker has TEE support
+     * @param teeType - Type of TEE if hasTEE is true
+     * @returns Transaction result
+     */
+    stakeWithTEE(amount: bigint, gpuTier: GpuTier, hasTEE: boolean, teeType?: TeeType): Promise<TransactionResult$5>;
+    /**
+     * Request to unstake tokens (enters lockup period)
+     *
+     * @param amount - Amount to unstake (wei)
+     * @returns Transaction result with unstake request ID
+     */
+    requestUnstake(amount: bigint): Promise<TransactionResult$5>;
+    /**
+     * Complete unstake after lockup period
+     *
+     * @param requestId - Unstake request ID
+     * @returns Transaction result
+     */
+    completeUnstake(requestId: bigint): Promise<TransactionResult$5>;
+    /**
+     * Cancel pending unstake request
+     *
+     * @param requestId - Unstake request ID
+     * @returns Transaction result
+     */
+    cancelUnstake(requestId: bigint): Promise<TransactionResult$5>;
+    /**
+     * Claim pending staking rewards
+     *
+     * @returns Transaction result
+     */
+    claimRewards(): Promise<TransactionResult$5>;
+    /**
+     * Get stake info for an address
+     *
+     * @param address - Worker address
+     * @returns Complete stake information
+     */
+    getStakeInfo(address: string): Promise<StakeInfo>;
+    /**
+     * Get minimum stake for GPU tier with optional TEE
+     *
+     * @param gpuTier - GPU tier
+     * @param hasTEE - Whether has TEE support
+     * @param reputationScore - Optional reputation score (0-100)
+     * @returns Minimum stake amount (wei)
+     */
+    getMinStake(gpuTier: GpuTier, hasTEE?: boolean, reputationScore?: number): bigint;
+    /**
+     * Get minimum stake for tier with TEE (private helper)
+     */
+    private getMinStakeForTierWithTEE;
+    /**
+     * Get worker's current tier
+     *
+     * @param workerAddress - Worker address
+     * @returns Worker tier
+     */
+    getWorkerTier(workerAddress: string): Promise<WorkerTier>;
+    /**
+     * Get benefits for a worker tier
+     *
+     * @param tier - Worker tier
+     * @returns Tier benefits
+     */
+    getWorkerTierBenefits(tier: WorkerTier): Promise<WorkerTierBenefits>;
+    /**
+     * Get pending unstake requests for an address
+     *
+     * @param address - Worker address
+     * @returns Array of unstake requests
+     */
+    getUnstakeRequests(address: string): Promise<UnstakeRequest[]>;
+    /**
+     * Slash a worker (governance/protocol only)
+     *
+     * @param worker - Worker address to slash
+     * @param percentage - Slash percentage (basis points)
+     * @param reason - Slash reason
+     * @param jobId - Related job ID if applicable
+     * @param evidenceHash - Hash of evidence
+     * @returns Transaction result
+     */
+    slash(worker: string, percentage: number, reason: SlashReason, jobId?: bigint, evidenceHash?: bigint): Promise<TransactionResult$5>;
+    /**
+     * Challenge a slash (stake bond to dispute)
+     *
+     * @param slashId - Slash ID to challenge
+     * @param evidence - Evidence supporting the challenge
+     * @returns Transaction result with dispute ID
+     */
+    challengeSlash(slashId: bigint, evidence: string[]): Promise<TransactionResult$5>;
+    /**
+     * Resolve a slash challenge (governance only)
+     *
+     * @param disputeId - Dispute ID
+     * @param upheld - Whether the original slash is upheld
+     * @param reason - Resolution reason
+     * @returns Transaction result
+     */
+    resolveSlashChallenge(disputeId: bigint, upheld: boolean, reason: string): Promise<TransactionResult$5>;
+    /**
+     * Get slash record
+     *
+     * @param slashId - Slash ID
+     * @returns Slash record details
+     */
+    getSlashRecord(slashId: bigint): Promise<SlashRecord>;
+    /**
+     * Get dispute record
+     *
+     * @param disputeId - Dispute ID
+     * @returns Dispute record details
+     */
+    getDisputeRecord(disputeId: bigint): Promise<DisputeRecord>;
+    /**
+     * Get staking configuration
+     *
+     * @returns Staking config
+     */
+    getStakingConfig(): Promise<StakingConfig>;
+    /**
+     * Get total staked amount
+     *
+     * @returns Total staked (wei)
+     */
+    getTotalStaked(): Promise<bigint>;
+    /**
+     * Get total slashed amount
+     *
+     * @returns Total slashed (wei)
+     */
+    getTotalSlashed(): Promise<bigint>;
+    /**
+     * Get staking leaderboard
+     *
+     * @param limit - Number of entries
+     * @returns Leaderboard entries
+     */
+    getStakingLeaderboard(limit?: number): Promise<Array<{
+        rank: number;
+        worker: string;
+        staked: bigint;
+        tier: WorkerTier;
+        apy_bps: number;
+    }>>;
+    /**
+     * Delegate stake to a worker
+     *
+     * @param worker - Worker to delegate to
+     * @param amount - Amount to delegate (wei)
+     * @returns Transaction result
+     */
+    delegateStake(worker: string, amount: bigint): Promise<TransactionResult$5>;
+    /**
+     * Undelegate stake from a worker
+     *
+     * @param worker - Worker to undelegate from
+     * @param amount - Amount to undelegate (wei)
+     * @returns Transaction result
+     */
+    undelegateStake(worker: string, amount: bigint): Promise<TransactionResult$5>;
+    /**
+     * Get delegation info
+     *
+     * @param delegator - Delegator address
+     * @returns Delegation info
+     */
+    getDelegationInfo(delegator: string): Promise<Array<{
+        worker: string;
+        amount: bigint;
+        rewards_share_bps: number;
+        delegated_at: number;
+    }>>;
+    /**
+     * Check if worker is eligible for jobs
+     *
+     * @param stake - Worker stake info
+     * @returns Whether worker is eligible
+     */
+    static isEligible(stake: WorkerStake): boolean;
+    /**
+     * Get lockup end timestamp
+     *
+     * @param requestedAt - When unstake was requested
+     * @returns Timestamp when unstake becomes available
+     */
+    static getLockupEndTimestamp(requestedAt: number): number;
+    /**
+     * Calculate expected slash amount
+     *
+     * @param stakeAmount - Current stake (wei)
+     * @param reason - Slash reason
+     * @returns Expected slash amount (wei)
+     */
+    static calculateSlashAmount(stakeAmount: bigint, reason: SlashReason): bigint;
+    private gpuTierToFelt;
+    private teeTypeToFelt;
+    private slashReasonToFelt;
+}
+/**
+ * Create a StakingClient instance
+ */
+declare function createStakingClient(http: HttpClient, contract: ContractClient, proverStakingAddress: string, cdcPoolAddress: string): StakingClient;
+
+/**
+ * Enhanced Workers Module
+ * Full worker management with registration, heartbeat, and leaderboard
+ */
+
+interface WorkersClientConfig {
+    /** CDC Pool contract address */
+    cdcPoolAddress: string;
+    /** Reputation Manager contract address */
+    reputationManagerAddress: string;
+}
+/** Transaction result */
+interface TransactionResult$4 {
+    transaction_hash: string;
+    status: 'pending' | 'accepted' | 'rejected';
+    receipt?: TransactionReceipt;
+}
+/** Worker status */
+type WorkerStatus = 'Active' | 'Inactive' | 'Suspended' | 'Banned' | 'PendingRegistration';
+/** Worker capabilities flags */
+interface WorkerCapabilities {
+    /** Has GPU */
+    has_gpu: boolean;
+    /** GPU tier if has_gpu */
+    gpu_tier?: GpuTier;
+    /** VRAM in GB */
+    vram_gb?: number;
+    /** Has TEE support */
+    has_tee: boolean;
+    /** TEE type */
+    tee_type?: 'IntelTDX' | 'AMDSEVSNP' | 'NvidiaCC';
+    /** Supported job types (bitfield) */
+    supported_job_types: number;
+    /** Maximum concurrent jobs */
+    max_concurrent_jobs: number;
+    /** Network bandwidth (Mbps) */
+    bandwidth_mbps: number;
+    /** Available storage (GB) */
+    storage_gb: number;
+    /** CPU cores */
+    cpu_cores: number;
+    /** RAM (GB) */
+    ram_gb: number;
+}
+/** Worker capability flags */
+declare const CAPABILITY_FLAGS: {
+    readonly AI_INFERENCE: number;
+    readonly ZK_PROVING: number;
+    readonly IMAGE_GENERATION: number;
+    readonly VIDEO_GENERATION: number;
+    readonly TRAINING: number;
+    readonly FINE_TUNING: number;
+    readonly EMBEDDINGS: number;
+    readonly CUSTOM_COMPUTE: number;
+};
+/** Worker basic info */
+interface WorkerInfo {
+    /** Worker address */
+    address: string;
+    /** Worker ID (may differ from address) */
+    worker_id: string;
+    /** Current status */
+    status: WorkerStatus;
+    /** Registration timestamp */
+    registered_at: number;
+    /** Capabilities */
+    capabilities: WorkerCapabilities;
+    /** Reputation score (0-100) */
+    reputation: number;
+    /** Total jobs completed */
+    total_jobs: bigint;
+    /** Success rate (basis points) */
+    success_rate_bps: number;
+    /** Current stake */
+    stake: bigint;
+    /** Worker tier */
+    tier: WorkerTier;
+    /** Geographic region */
+    region?: string;
+    /** Last heartbeat timestamp */
+    last_heartbeat: number;
+}
+/** Worker detailed profile */
+interface WorkerProfile {
+    /** Basic info */
+    info: WorkerInfo;
+    /** Total earnings (wei) */
+    total_earnings: bigint;
+    /** Average job completion time (seconds) */
+    avg_completion_time_secs: number;
+    /** Jobs in last 24h */
+    jobs_24h: number;
+    /** Earnings in last 24h (wei) */
+    earnings_24h: bigint;
+    /** Proof success rate (basis points) */
+    proof_success_rate_bps: number;
+    /** Consecutive successful jobs */
+    consecutive_successes: number;
+    /** Slash history count */
+    slash_count: number;
+    /** Total slashed amount (wei) */
+    total_slashed: bigint;
+    /** Delegated stake amount (wei) */
+    delegated_stake: bigint;
+    /** Number of delegators */
+    delegator_count: number;
+    /** TEE attestation status */
+    tee_attestation_valid: boolean;
+    /** TEE attestation expiry */
+    tee_attestation_expiry?: number;
+}
+/** Worker performance data for heartbeat */
+interface PerformanceData {
+    /** Current CPU usage (0-100) */
+    cpu_usage: number;
+    /** Current memory usage (0-100) */
+    memory_usage: number;
+    /** Current GPU usage (0-100) */
+    gpu_usage?: number;
+    /** Current GPU temperature (Celsius) */
+    gpu_temp?: number;
+    /** Current GPU memory usage (0-100) */
+    gpu_memory_usage?: number;
+    /** Active jobs count */
+    active_jobs: number;
+    /** Queue depth */
+    queue_depth: number;
+    /** Network latency (ms) */
+    network_latency_ms: number;
+    /** Is available for new jobs */
+    is_available: boolean;
+    /** Custom metrics */
+    custom_metrics?: Record<string, number>;
+}
+/** Leaderboard metric type */
+type LeaderboardMetric = 'reputation' | 'earnings' | 'jobs' | 'stake' | 'success_rate';
+/** Leaderboard entry */
+interface LeaderboardEntry {
+    /** Rank */
+    rank: number;
+    /** Worker address */
+    worker: string;
+    /** Metric value */
+    value: bigint | number;
+    /** Worker tier */
+    tier: WorkerTier;
+    /** Change from previous period */
+    change: number;
+}
+/** Worker registration params */
+interface RegisterWorkerParams {
+    /** Worker capabilities */
+    capabilities: WorkerCapabilities;
+    /** TEE attestation proof (if has TEE) */
+    tee_attestation?: string;
+    /** Geographic region code */
+    region?: string;
+    /** Initial stake amount (wei) */
+    initial_stake: bigint;
+    /** Benchmark proof */
+    benchmark_proof: string;
+    /** Benchmark result hash */
+    benchmark_hash: string;
+}
+/**
+ * Enhanced Workers Client
+ *
+ * Full worker management including:
+ * - Worker registration and onboarding
+ * - Heartbeat and health monitoring
+ * - Profile and capability queries
+ * - Leaderboard and rankings
+ * - Delegation support
+ * - Dispute handling
+ *
+ * @example
+ * ```typescript
+ * const workers = new WorkersClient(httpClient, contractClient, config);
+ *
+ * // Register a new worker
+ * await workers.registerWorker({
+ *   capabilities: {
+ *     has_gpu: true,
+ *     gpu_tier: 'DataCenter',
+ *     vram_gb: 80,
+ *     has_tee: true,
+ *     tee_type: 'NvidiaCC',
+ *     supported_job_types: CAPABILITY_FLAGS.AI_INFERENCE | CAPABILITY_FLAGS.ZK_PROVING,
+ *     max_concurrent_jobs: 4,
+ *     bandwidth_mbps: 1000,
+ *     storage_gb: 500,
+ *     cpu_cores: 32,
+ *     ram_gb: 256,
+ *   },
+ *   initial_stake: 5000n * 10n**18n,
+ *   benchmark_proof: '0x...',
+ *   benchmark_hash: '0x...',
+ * });
+ *
+ * // Submit periodic heartbeat
+ * await workers.submitHeartbeat({
+ *   cpu_usage: 45,
+ *   memory_usage: 60,
+ *   gpu_usage: 80,
+ *   gpu_temp: 72,
+ *   active_jobs: 2,
+ *   queue_depth: 5,
+ *   network_latency_ms: 15,
+ *   is_available: true,
+ * });
+ * ```
+ */
+declare class WorkersClient {
+    private http;
+    private contract;
+    private config;
+    constructor(http: HttpClient, contract: ContractClient, config: WorkersClientConfig);
+    /**
+     * Register a new worker
+     *
+     * @param params - Registration parameters
+     * @returns Transaction result
+     */
+    registerWorker(params: RegisterWorkerParams): Promise<TransactionResult$4>;
+    /**
+     * Update worker capabilities
+     *
+     * @param capabilities - New capabilities
+     * @returns Transaction result
+     */
+    updateCapabilities(capabilities: WorkerCapabilities): Promise<TransactionResult$4>;
+    /**
+     * Deregister worker
+     *
+     * @returns Transaction result
+     */
+    deregisterWorker(): Promise<TransactionResult$4>;
+    /**
+     * Submit worker heartbeat with performance data
+     *
+     * @param performanceData - Current performance metrics
+     * @returns Transaction result
+     */
+    submitHeartbeat(performanceData: PerformanceData): Promise<TransactionResult$4>;
+    /**
+     * Mark worker as unavailable
+     *
+     * @param reason - Reason for unavailability
+     * @param estimatedReturnTime - Unix timestamp for estimated return
+     * @returns Transaction result
+     */
+    setUnavailable(reason: string, estimatedReturnTime?: number): Promise<TransactionResult$4>;
+    /**
+     * Mark worker as available
+     *
+     * @returns Transaction result
+     */
+    setAvailable(): Promise<TransactionResult$4>;
+    /**
+     * List all workers
+     *
+     * @param params - Filter parameters
+     * @returns Array of worker info
+     */
+    listWorkers(params?: {
+        status?: WorkerStatus;
+        min_reputation?: number;
+        gpu_tier?: GpuTier;
+        has_tee?: boolean;
+        capability_flags?: number;
+        limit?: number;
+        offset?: number;
+    }): Promise<WorkerInfo[]>;
+    /**
+     * Get worker info by ID
+     *
+     * @param workerId - Worker ID or address
+     * @returns Worker info
+     */
+    getWorker(workerId: string): Promise<WorkerInfo>;
+    /**
+     * Get detailed worker profile
+     *
+     * @param workerId - Worker ID or address
+     * @returns Detailed worker profile
+     */
+    getWorkerProfile(workerId: string): Promise<WorkerProfile>;
+    /**
+     * Get workers by capability flags
+     *
+     * @param flags - Capability flags (bitfield)
+     * @param minReputation - Minimum reputation score
+     * @returns Array of worker addresses
+     */
+    getWorkersByCapability(flags: number, minReputation?: number): Promise<string[]>;
+    /**
+     * Get available workers for a job type
+     *
+     * @param jobType - Job type capability flag
+     * @param gpuTierRequired - Minimum GPU tier required
+     * @returns Array of available worker addresses
+     */
+    getAvailableWorkers(jobType: number, gpuTierRequired?: GpuTier): Promise<string[]>;
+    /**
+     * Get worker leaderboard
+     *
+     * @param metric - Ranking metric
+     * @param limit - Number of entries
+     * @param period - Time period ('day' | 'week' | 'month' | 'all')
+     * @returns Leaderboard entries
+     */
+    getLeaderboard(metric: LeaderboardMetric, limit?: number, period?: 'day' | 'week' | 'month' | 'all'): Promise<LeaderboardEntry[]>;
+    /**
+     * Get worker rank for a metric
+     *
+     * @param workerId - Worker ID
+     * @param metric - Ranking metric
+     * @returns Worker's rank
+     */
+    getWorkerRank(workerId: string, metric: LeaderboardMetric): Promise<number>;
+    /**
+     * Get worker reputation details
+     *
+     * @param workerId - Worker ID
+     * @returns Reputation breakdown
+     */
+    getReputationDetails(workerId: string): Promise<{
+        overall: number;
+        job_completion: number;
+        proof_accuracy: number;
+        uptime: number;
+        response_time: number;
+        peer_reviews: number;
+        stake_factor: number;
+        history: Array<{
+            timestamp: number;
+            change: number;
+            reason: string;
+        }>;
+    }>;
+    /**
+     * Submit peer review (for other workers)
+     *
+     * @param workerId - Worker being reviewed
+     * @param jobId - Job the review is for
+     * @param rating - Rating (1-5)
+     * @param comment - Optional comment
+     * @returns Transaction result
+     */
+    submitPeerReview(workerId: string, jobId: bigint, rating: number, comment?: string): Promise<TransactionResult$4>;
+    /**
+     * Challenge a slash against this worker
+     *
+     * @param slashId - Slash ID to challenge
+     * @param evidence - Evidence supporting the challenge
+     * @param bond - Bond amount (wei)
+     * @returns Transaction result with dispute ID
+     */
+    challengeSlash(slashId: bigint, evidence: string[], bond: bigint): Promise<TransactionResult$4>;
+    /**
+     * Get dispute status
+     *
+     * @param disputeId - Dispute ID
+     * @returns Dispute record
+     */
+    getDisputeStatus(disputeId: bigint): Promise<DisputeRecord>;
+    /**
+     * Get slash records for a worker
+     *
+     * @param workerId - Worker ID
+     * @returns Array of slash records
+     */
+    getSlashHistory(workerId: string): Promise<SlashRecord[]>;
+    /**
+     * Submit TEE attestation
+     *
+     * @param attestation - TEE attestation data
+     * @returns Transaction result
+     */
+    submitTeeAttestation(attestation: string): Promise<TransactionResult$4>;
+    /**
+     * Verify worker's TEE attestation
+     *
+     * @param workerId - Worker ID
+     * @returns Whether attestation is valid
+     */
+    verifyTeeAttestation(workerId: string): Promise<{
+        valid: boolean;
+        tee_type?: string;
+        expires_at?: number;
+        measurement?: string;
+    }>;
+    /**
+     * Get network-wide worker statistics
+     *
+     * @returns Worker statistics
+     */
+    getNetworkStats(): Promise<{
+        total_workers: number;
+        active_workers: number;
+        total_stake: bigint;
+        avg_reputation: number;
+        workers_by_tier: Record<WorkerTier, number>;
+        workers_by_gpu_tier: Record<GpuTier, number>;
+        tee_enabled_workers: number;
+    }>;
+    private encodeCapabilities;
+    private gpuTierToFelt;
+    private teeTypeToFelt;
+}
+/**
+ * Create a WorkersClient instance
+ */
+declare function createWorkersClient(http: HttpClient, contract: ContractClient, cdcPoolAddress: string, reputationManagerAddress: string): WorkersClient;
+
+/**
+ * Obelysk Privacy Module
+ * Full privacy system with ElGamal encryption, threshold decryption, and ring signatures
+ */
+
+interface PrivacyClientConfig {
+    /** Privacy router contract address */
+    privacyRouterAddress: string;
+    /** DKG coordinator contract address */
+    dkgCoordinatorAddress?: string;
+    /** Mixing pool contract address */
+    mixingPoolAddress?: string;
+}
+/** Transaction result */
+interface TransactionResult$3 {
+    transaction_hash: string;
+    status: 'pending' | 'accepted' | 'rejected';
+    receipt?: TransactionReceipt;
+}
+/** Supported privacy assets */
+type PrivacyAsset = 'SAGE' | 'USDC' | 'STRK' | 'WBTC' | 'ETH';
+/**
+ * Obelysk Privacy Client
+ *
+ * Full privacy functionality including:
+ * - Account registration and management
+ * - Private transfers with zero-knowledge proofs
+ * - Auditable transfers (with designated auditor)
+ * - Steganographic operations (hidden transaction types)
+ * - Ring signatures for transaction mixing
+ * - Threshold decryption via DKG
+ * - Multi-asset privacy support
+ * - Emergency ragequit (privacy exit)
+ *
+ * @example
+ * ```typescript
+ * const privacy = new PrivacyClient(httpClient, contractClient, config);
+ *
+ * // Generate privacy keys
+ * const keys = await privacy.generateKeys();
+ * // Or derive from wallet
+ * const sig = await wallet.signMessage(getPrivacyDerivationMessage(address));
+ * const keys = await privacy.deriveKeysFromWallet(sig);
+ *
+ * // Register private account
+ * await privacy.registerAccount(keys.publicKey);
+ *
+ * // Get encrypted balance
+ * const balance = await privacy.getEncryptedBalance(address);
+ *
+ * // Reveal balance (client-side decryption)
+ * const revealed = await privacy.revealBalance(balance, keys.privateKey);
+ *
+ * // Private transfer
+ * await privacy.privateTransfer({
+ *   to: recipientAddress,
+ *   amount: 100n * 10n**18n,
+ *   keys,
+ * });
+ * ```
+ */
+declare class PrivacyClient {
+    private http;
+    private contract;
+    private config;
+    private keyManager;
+    constructor(http: HttpClient, contract: ContractClient, config: PrivacyClientConfig);
+    /**
+     * Generate fresh privacy keys
+     *
+     * @returns New privacy keypair
+     */
+    generateKeys(): Promise<PrivacyKeyPair>;
+    /**
+     * Derive privacy keys from wallet signature
+     *
+     * @param signature - Wallet signature of derivation message
+     * @returns Derived privacy keypair
+     */
+    deriveKeysFromWallet(signature: string): Promise<PrivacyKeyPair>;
+    /**
+     * Store keys encrypted in local storage
+     *
+     * @param keys - Keypair to store
+     * @param password - Encryption password
+     */
+    storeKeys(keys: PrivacyKeyPair, password: string): Promise<void>;
+    /**
+     * Retrieve keys from local storage
+     *
+     * @param password - Decryption password
+     * @returns Keypair or null if not found/wrong password
+     */
+    retrieveKeys(password: string): Promise<PrivacyKeyPair | null>;
+    /**
+     * Check if keys are stored
+     */
+    hasStoredKeys(): boolean;
+    /**
+     * Clear stored keys
+     */
+    clearKeys(): void;
+    /**
+     * Register a private account
+     *
+     * @param publicKey - ElGamal public key
+     * @returns Transaction result
+     */
+    registerAccount(publicKey: ECPoint): Promise<TransactionResult$3>;
+    /**
+     * Get private account info
+     *
+     * @param address - Account address
+     * @returns Private account or null
+     */
+    getAccount(address: string): Promise<PrivateAccount | null>;
+    /**
+     * Get encrypted balance for an address
+     *
+     * @param address - Account address
+     * @returns Encrypted balance
+     */
+    getEncryptedBalance(address: string): Promise<EncryptedBalance>;
+    /**
+     * Reveal balance (client-side decryption)
+     *
+     * @param balance - Encrypted balance
+     * @param privateKey - Private key for decryption
+     * @param hint - Optional AE hint for fast decryption
+     * @returns Decrypted balance amount
+     */
+    revealBalance(balance: EncryptedBalance, privateKey: Uint8Array, hint?: AEHint): Promise<bigint>;
+    /**
+     * Execute a private transfer
+     *
+     * @param params - Transfer parameters
+     * @returns Transaction result
+     */
+    privateTransfer(params: {
+        to: string;
+        amount: bigint;
+        keys: PrivacyKeyPair;
+    }): Promise<TransactionResult$3>;
+    /**
+     * Execute raw private transfer with pre-computed proof
+     *
+     * @param params - Pre-computed transfer parameters
+     * @returns Transaction result
+     */
+    executePrivateTransfer(params: PrivateTransferParams): Promise<TransactionResult$3>;
+    /**
+     * Execute private transfer with audit trail
+     *
+     * @param params - Transfer parameters with audit info
+     * @returns Transaction result
+     */
+    privateTransferWithAudit(params: PrivateTransferWithAuditParams): Promise<TransactionResult$3>;
+    /**
+     * Generate a stealth address for one-time payments
+     *
+     * @param recipientPublicKey - Recipient's public key
+     * @returns Stealth address
+     */
+    generateStealthAddress(recipientPublicKey: ECPoint): StealthAddress;
+    /**
+     * Scan for stealth payments
+     *
+     * @param privateKey - Recipient's private key
+     * @param startBlock - Block to start scanning from
+     * @returns Array of received stealth payments
+     */
+    scanStealthPayments(privateKey: Uint8Array, startBlock?: number): Promise<Array<{
+        stealthAddress: StealthAddress;
+        amount: bigint;
+        blockNumber: number;
+    }>>;
+    /**
+     * Execute stealth (steganographic) transfer
+     *
+     * @param stegTx - Steganographic transaction
+     * @returns Transaction result
+     */
+    stealthTransfer(stegTx: SteganographicTransaction): Promise<TransactionResult$3>;
+    /**
+     * Execute stealth deposit (hide deposit as transfer)
+     *
+     * @param stegTx - Steganographic transaction
+     * @returns Transaction result
+     */
+    stealthDeposit(stegTx: SteganographicTransaction): Promise<TransactionResult$3>;
+    /**
+     * Execute stealth withdrawal (hide withdrawal as transfer)
+     *
+     * @param stegTx - Steganographic transaction
+     * @returns Transaction result
+     */
+    stealthWithdraw(stegTx: SteganographicTransaction): Promise<TransactionResult$3>;
+    /**
+     * Execute mixed transaction using ring signature
+     *
+     * @param mixingTx - Mixing transaction with ring signature
+     * @returns Transaction result
+     */
+    mixTransaction(mixingTx: MixingTransaction): Promise<TransactionResult$3>;
+    /**
+     * Register a mixing output (add to anonymity set)
+     *
+     * @param output - Mixing output to register
+     * @returns Transaction result
+     */
+    registerMixingOutput(output: MixingOutput): Promise<TransactionResult$3>;
+    /**
+     * Get available mixing outputs for ring construction
+     *
+     * @param count - Number of outputs to fetch
+     * @returns Array of mixing outputs
+     */
+    getMixingOutputs(count: number): Promise<MixingOutput[]>;
+    /**
+     * Initiate DKG ceremony
+     *
+     * @param participants - Participant addresses
+     * @param threshold - Required threshold (t of n)
+     * @returns Transaction result with DKG session ID
+     */
+    initiateDKG(participants: string[], threshold: number): Promise<TransactionResult$3>;
+    /**
+     * Submit DKG share
+     *
+     * @param share - DKG share with commitments
+     * @returns Transaction result
+     */
+    submitDKGShare(share: DKGShare): Promise<TransactionResult$3>;
+    /**
+     * Request threshold decryption
+     *
+     * @param ciphertext - Ciphertext to decrypt
+     * @returns Transaction result with request ID
+     */
+    requestThresholdDecryption(ciphertext: ElGamalCiphertext): Promise<TransactionResult$3>;
+    /**
+     * Get threshold decryption request status
+     *
+     * @param requestId - Request ID
+     * @returns Request status
+     */
+    getThresholdDecryptionStatus(requestId: bigint): Promise<ThresholdDecryptionRequest>;
+    /**
+     * Get private balances for all supported assets
+     *
+     * @param address - Account address
+     * @returns Multi-asset encrypted balances
+     */
+    getPrivateBalances(address: string): Promise<MultiAssetBalances>;
+    /**
+     * Execute private swap between assets
+     *
+     * @param params - Swap parameters
+     * @returns Transaction result
+     */
+    privateSwap(params: PrivateSwapParams): Promise<TransactionResult$3>;
+    /**
+     * Execute ragequit (emergency withdrawal)
+     *
+     * Reveals balance and withdraws to public address.
+     * Use only in emergencies as it breaks privacy.
+     *
+     * @param proof - Ragequit proof with ownership and balance
+     * @returns Transaction result
+     */
+    ragequit(proof: RagequitProof): Promise<TransactionResult$3>;
+    /**
+     * Create ragequit proof
+     *
+     * @param privateKey - Private key
+     * @param publicKey - Public key
+     * @param balance - Current encrypted balance
+     * @returns Ragequit proof
+     */
+    createRagequitProof(privateKey: Uint8Array, publicKey: ECPoint, balance: EncryptedBalance, hint?: AEHint): Promise<RagequitProof>;
+    /**
+     * Encrypt an amount for a recipient
+     *
+     * @param amount - Amount to encrypt
+     * @param recipientPublicKey - Recipient's public key
+     * @returns ElGamal ciphertext
+     */
+    encrypt(amount: bigint, recipientPublicKey: ECPoint): ElGamalCiphertext;
+    /**
+     * Add two encrypted values
+     *
+     * @param a - First ciphertext
+     * @param b - Second ciphertext
+     * @returns Sum ciphertext
+     */
+    homomorphicAdd(a: ElGamalCiphertext, b: ElGamalCiphertext): ElGamalCiphertext;
+    /**
+     * Subtract encrypted values
+     *
+     * @param a - First ciphertext
+     * @param b - Second ciphertext
+     * @returns Difference ciphertext
+     */
+    homomorphicSub(a: ElGamalCiphertext, b: ElGamalCiphertext): ElGamalCiphertext;
+    private parseEncryptedBalance;
+    private parseCiphertext;
+    private encodeCiphertext;
+    private encodeTransferProof;
+    private encodeSchnorrProof;
+    private encodeRangeProof;
+    private encodeSameEncryptionProof;
+    private encodeMixingTransaction;
+}
+/**
+ * Create a PrivacyClient instance
+ */
+declare function createPrivacyClient(http: HttpClient, contract: ContractClient, privacyRouterAddress: string, dkgCoordinatorAddress?: string, mixingPoolAddress?: string): PrivacyClient;
+
+/**
+ * SAGE Token Governance Module
+ * Full governance system with proposals, voting, and tokenomics
+ */
+
+interface GovernanceClientConfig {
+    /** SAGE token contract address */
+    sageTokenAddress: string;
+    /** Governance contract address (if separate) */
+    governanceAddress?: string;
+    /** Burn manager contract address */
+    burnManagerAddress?: string;
+}
+/** Transaction result */
+interface TransactionResult$2 {
+    transaction_hash: string;
+    status: 'pending' | 'accepted' | 'rejected';
+    receipt?: TransactionReceipt;
+}
+/** Vote direction */
+type VoteDirection = 'for' | 'against' | 'abstain';
+/** Delegation info */
+interface DelegationInfo {
+    /** Address delegated to */
+    delegatee: string;
+    /** Amount of voting power delegated */
+    voting_power: bigint;
+    /** When delegation started */
+    delegated_at: number;
+}
+/** Voter info for a specific proposal */
+interface VoterInfo {
+    /** Has voted */
+    has_voted: boolean;
+    /** Vote direction (if voted) */
+    vote_direction?: VoteDirection;
+    /** Voting power used */
+    voting_power_used: bigint;
+    /** Timestamp of vote */
+    voted_at?: number;
+}
+/**
+ * SAGE Token Governance Client
+ *
+ * Full governance functionality including:
+ * - Proposal creation and management
+ * - Voting with delegation support
+ * - Tokenomics (burn rate, inflation, pools)
+ * - Treasury management
+ * - Large transfer rate limiting
+ * - Vesting schedules
+ *
+ * @example
+ * ```typescript
+ * const governance = new GovernanceClient(httpClient, contractClient, config);
+ *
+ * // Check voting power
+ * const power = await governance.getVotingPower(myAddress);
+ * console.log(`Voting power: ${power / 10n**18n} SAGE`);
+ *
+ * // Create a proposal
+ * const result = await governance.createProposal({
+ *   description: 'Increase burn rate by 1%',
+ *   proposal_type: 'BurnRateChange',
+ *   burn_rate_change_bps: 100,
+ * });
+ *
+ * // Vote on a proposal
+ * await governance.vote(proposalId, 'for');
+ *
+ * // Check tokenomics
+ * const burned = await governance.getTotalBurned();
+ * const rate = await governance.getBurnRate();
+ * ```
+ */
+declare class GovernanceClient {
+    private http;
+    private contract;
+    private config;
+    constructor(http: HttpClient, contract: ContractClient, config: GovernanceClientConfig);
+    /**
+     * Create a new governance proposal
+     *
+     * @param params - Proposal parameters
+     * @returns Transaction result with proposal ID
+     */
+    createProposal(params: CreateProposalParams): Promise<TransactionResult$2>;
+    /**
+     * Get proposal details
+     *
+     * @param proposalId - Proposal ID
+     * @returns Proposal details
+     */
+    getProposal(proposalId: bigint): Promise<GovernanceProposal>;
+    /**
+     * List proposals with filtering
+     *
+     * @param params - Filter parameters
+     * @returns Array of proposals
+     */
+    listProposals(params?: {
+        status?: ProposalStatus;
+        proposal_type?: ProposalType;
+        proposer?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<GovernanceProposal[]>;
+    /**
+     * Cancel a proposal (proposer only)
+     *
+     * @param proposalId - Proposal ID
+     * @returns Transaction result
+     */
+    cancelProposal(proposalId: bigint): Promise<TransactionResult$2>;
+    /**
+     * Execute a succeeded proposal
+     *
+     * @param proposalId - Proposal ID
+     * @returns Transaction result
+     */
+    executeProposal(proposalId: bigint): Promise<TransactionResult$2>;
+    /**
+     * Vote on a proposal
+     *
+     * @param proposalId - Proposal ID
+     * @param direction - Vote direction
+     * @returns Transaction result
+     */
+    vote(proposalId: bigint, direction: VoteDirection): Promise<TransactionResult$2>;
+    /**
+     * Vote with specific voting power
+     *
+     * @param proposalId - Proposal ID
+     * @param direction - Vote direction
+     * @param votingPower - Amount of voting power to use
+     * @returns Transaction result
+     */
+    voteWithPower(proposalId: bigint, direction: VoteDirection, votingPower: bigint): Promise<TransactionResult$2>;
+    /**
+     * Get voter info for a proposal
+     *
+     * @param proposalId - Proposal ID
+     * @param voter - Voter address
+     * @returns Voter info
+     */
+    getVoterInfo(proposalId: bigint, voter: string): Promise<VoterInfo>;
+    /**
+     * Get voting power for an address
+     *
+     * @param address - Address to check
+     * @returns Voting power (wei)
+     */
+    getVotingPower(address: string): Promise<bigint>;
+    /**
+     * Get governance rights for an address
+     *
+     * @param address - Address to check
+     * @returns Governance rights
+     */
+    getGovernanceRights(address: string): Promise<GovernanceRights>;
+    /**
+     * Delegate voting power to another address
+     *
+     * @param delegatee - Address to delegate to
+     * @returns Transaction result
+     */
+    delegate(delegatee: string): Promise<TransactionResult$2>;
+    /**
+     * Undelegate voting power
+     *
+     * @returns Transaction result
+     */
+    undelegate(): Promise<TransactionResult$2>;
+    /**
+     * Get delegation info for an address
+     *
+     * @param address - Address to check
+     * @returns Delegation info or null if not delegating
+     */
+    getDelegationInfo(address: string): Promise<DelegationInfo | null>;
+    /**
+     * Get total SAGE burned
+     *
+     * @returns Total burned (wei)
+     */
+    getTotalBurned(): Promise<bigint>;
+    /**
+     * Get current burn rate
+     *
+     * @returns Burn rate in basis points
+     */
+    getBurnRate(): Promise<number>;
+    /**
+     * Get current inflation rate
+     *
+     * @returns Inflation rate in basis points
+     */
+    getInflationRate(): Promise<number>;
+    /**
+     * Get pool balances
+     *
+     * @returns All pool balances
+     */
+    getPoolBalances(): Promise<PoolBalances>;
+    /**
+     * Get vesting status
+     *
+     * @returns Current vesting status
+     */
+    getVestingStatus(): Promise<VestingStatus>;
+    /**
+     * Get security budget
+     *
+     * @returns Security budget info
+     */
+    getSecurityBudget(): Promise<SecurityBudget>;
+    /**
+     * Get ecosystem emission status
+     *
+     * @returns Emission status
+     */
+    getEcosystemEmissionStatus(): Promise<EcosystemEmissionStatus>;
+    /**
+     * Get burn event history
+     *
+     * @param limit - Number of events
+     * @returns Array of burn events
+     */
+    getBurnHistory(limit?: number): Promise<BurnEvent[]>;
+    /**
+     * Get token flow summary
+     *
+     * @param periodDays - Number of days for period
+     * @returns Token flow summary
+     */
+    getTokenFlowSummary(periodDays?: number): Promise<TokenFlowSummary>;
+    /**
+     * Get milestone status
+     *
+     * @returns Milestone flags
+     */
+    getMilestoneStatus(): Promise<MilestoneStatus>;
+    /**
+     * Get rate limit info for an address
+     *
+     * @param address - Address to check
+     * @returns Rate limit info
+     */
+    getRateLimitInfo(address: string): Promise<RateLimitInfo>;
+    /**
+     * Initiate a large transfer (requires timelock)
+     *
+     * @param to - Recipient address
+     * @param amount - Amount (wei)
+     * @returns Transaction result with transfer ID
+     */
+    initiateLargeTransfer(to: string, amount: bigint): Promise<TransactionResult$2>;
+    /**
+     * Execute a pending large transfer
+     *
+     * @param transferId - Transfer ID
+     * @returns Transaction result
+     */
+    executeLargeTransfer(transferId: bigint): Promise<TransactionResult$2>;
+    /**
+     * Cancel a pending large transfer
+     *
+     * @param transferId - Transfer ID
+     * @returns Transaction result
+     */
+    cancelLargeTransfer(transferId: bigint): Promise<TransactionResult$2>;
+    /**
+     * Get pending large transfers for an address
+     *
+     * @param address - Address to check
+     * @returns Array of pending transfers
+     */
+    getPendingTransfers(address: string): Promise<PendingTransfer[]>;
+    /**
+     * Get governance statistics
+     *
+     * @returns Governance stats
+     */
+    getGovernanceStats(): Promise<GovernanceStats>;
+    /**
+     * Get top voters by participation
+     *
+     * @param limit - Number of voters
+     * @returns Array of top voters
+     */
+    getTopVoters(limit?: number): Promise<Array<{
+        address: string;
+        voting_power: bigint;
+        proposals_voted: number;
+        participation_rate_bps: number;
+    }>>;
+    /**
+     * Check if address can create a proposal
+     *
+     * @param address - Address to check
+     * @param proposalType - Type of proposal
+     * @returns Whether address can create this proposal type
+     */
+    canCreateProposal(address: string, proposalType: ProposalType): Promise<boolean>;
+    /**
+     * Get proposal quorum progress
+     *
+     * @param proposalId - Proposal ID
+     * @returns Quorum progress (basis points of quorum achieved)
+     */
+    getQuorumProgress(proposalId: bigint): Promise<{
+        current_participation_bps: number;
+        quorum_required_bps: number;
+        quorum_reached: boolean;
+    }>;
+    /**
+     * Check if proposal can be executed
+     *
+     * @param proposalId - Proposal ID
+     * @returns Whether proposal can be executed
+     */
+    canExecuteProposal(proposalId: bigint): Promise<{
+        can_execute: boolean;
+        reason?: string;
+    }>;
+    private validateProposalParams;
+    private proposalTypeToFelt;
+    private voteDirectionToFelt;
+}
+/**
+ * Create a GovernanceClient instance
+ */
+declare function createGovernanceClient(http: HttpClient, contract: ContractClient, sageTokenAddress: string, governanceAddress?: string, burnManagerAddress?: string): GovernanceClient;
+
+/**
+ * STWO Verifier Module
+ * STWO proof verification, GPU-TEE proofs, and batch verification
+ */
+
+interface StwoClientConfig {
+    /** STWO verifier contract address */
+    stwoVerifierAddress: string;
+    /** Optimistic TEE contract address */
+    optimisticTeeAddress?: string;
+    /** Batch verifier contract address */
+    batchVerifierAddress?: string;
+}
+/** Transaction result */
+interface TransactionResult$1 {
+    transaction_hash: string;
+    status: 'pending' | 'accepted' | 'rejected';
+    receipt?: TransactionReceipt;
+}
+/** Challenge submission parameters */
+interface ChallengeParams {
+    /** Proof hash to challenge */
+    proof_hash: bigint;
+    /** Challenge stake (wei) */
+    stake: bigint;
+    /** Fraud proof data */
+    fraud_proof: string[];
+    /** Challenge reason */
+    reason: string;
+}
+/** Challenge status */
+interface ChallengeStatus {
+    /** Challenge ID */
+    challenge_id: bigint;
+    /** Challenged proof hash */
+    proof_hash: bigint;
+    /** Challenger address */
+    challenger: string;
+    /** Challenge stake */
+    stake: bigint;
+    /** Status */
+    status: 'Pending' | 'Resolved' | 'Rejected' | 'Slashed';
+    /** Submitted at */
+    submitted_at: number;
+    /** Resolution timestamp */
+    resolved_at?: number;
+    /** Challenge upheld */
+    upheld?: boolean;
+}
+/**
+ * STWO Verifier Client
+ *
+ * Full STWO proof verification including:
+ * - Standard proof submission and verification
+ * - GPU-TEE optimistic proofs with challenge window
+ * - Batch verification for multiple proofs
+ * - Proof compression (zstd, lz4, snappy)
+ * - Enclave whitelist management
+ * - Prover metrics and statistics
+ *
+ * @example
+ * ```typescript
+ * const stwo = new StwoClient(httpClient, contractClient, config);
+ *
+ * // Submit a standard proof
+ * const proofHash = await stwo.submitProof(proofData, publicInputHash);
+ *
+ * // Verify the proof
+ * const isValid = await stwo.verifyProof(proofHash);
+ *
+ * // Submit GPU-TEE proof (optimistic)
+ * await stwo.submitGpuTeeProof({
+ *   proof_data: proofData,
+ *   public_input_hash: publicInputHash,
+ *   tee_type: 3, // NvidiaCC
+ *   enclave_measurement: measurement,
+ *   quote_hash: quoteHash,
+ *   attestation_timestamp: Date.now(),
+ * });
+ *
+ * // Check if proof is finalized
+ * const metadata = await stwo.getProofMetadata(proofHash);
+ * if (metadata.status === 'Verified') {
+ *   console.log('Proof verified!');
+ * }
+ * ```
+ */
+declare class StwoClient {
+    private http;
+    private contract;
+    private config;
+    constructor(http: HttpClient, contract: ContractClient, config: StwoClientConfig);
+    /**
+     * Submit a proof for verification
+     *
+     * @param proofData - Serialized proof data
+     * @param publicInputHash - Hash of public inputs
+     * @returns Proof hash
+     */
+    submitProof(proofData: string[], publicInputHash: bigint): Promise<string>;
+    /**
+     * Verify a submitted proof
+     *
+     * @param proofHash - Hash of the proof
+     * @returns Whether proof is valid
+     */
+    verifyProof(proofHash: string): Promise<boolean>;
+    /**
+     * Submit and verify proof in one operation
+     *
+     * @param proofData - Serialized proof data
+     * @param publicInputHash - Hash of public inputs
+     * @param jobId - Associated job ID
+     * @returns Whether proof was verified
+     */
+    submitAndVerifyProof(proofData: string[], publicInputHash: bigint, jobId: bigint): Promise<boolean>;
+    /**
+     * Get proof metadata
+     *
+     * @param proofHash - Hash of the proof
+     * @returns Proof metadata
+     */
+    getProofMetadata(proofHash: string): Promise<ProofMetadata>;
+    /**
+     * Check if proof is verified
+     *
+     * @param proofHash - Hash of the proof
+     * @returns Whether proof is verified
+     */
+    isProofVerified(proofHash: string): Promise<boolean>;
+    /**
+     * Submit a GPU-TEE proof (optimistic verification)
+     *
+     * @param params - GPU-TEE proof parameters
+     * @returns Proof hash
+     */
+    submitGpuTeeProof(params: GpuTeeProofParams): Promise<string>;
+    /**
+     * Finalize a GPU-TEE proof after challenge window
+     *
+     * @param proofHash - Hash of the proof
+     * @returns Whether finalization succeeded
+     */
+    finalizeGpuTeeProof(proofHash: string): Promise<boolean>;
+    /**
+     * Challenge a GPU-TEE proof with fraud proof
+     *
+     * @param params - Challenge parameters
+     * @returns Transaction result with challenge ID
+     */
+    challengeGpuTeeProof(params: ChallengeParams): Promise<TransactionResult$1>;
+    /**
+     * Get challenge status
+     *
+     * @param challengeId - Challenge ID
+     * @returns Challenge status
+     */
+    getChallengeStatus(challengeId: bigint): Promise<ChallengeStatus>;
+    /**
+     * Check if proof can be finalized
+     *
+     * @param proofHash - Hash of the proof
+     * @returns Finalization status
+     */
+    canFinalizeProof(proofHash: string): Promise<{
+        can_finalize: boolean;
+        reason?: string;
+        time_remaining_secs?: number;
+    }>;
+    /**
+     * Verify multiple proofs in batch
+     *
+     * @param batchHash - Hash identifying the batch
+     * @param proofs - Array of proof data arrays
+     * @returns Whether batch verification succeeded
+     */
+    verifyBatch(batchHash: string, proofs: string[][]): Promise<boolean>;
+    /**
+     * Get batch status
+     *
+     * @param batchId - Batch ID
+     * @returns Batch status
+     */
+    getBatchStatus(batchId: string): Promise<BatchStatus>;
+    /**
+     * Submit proofs for batch verification
+     *
+     * @param proofs - Array of proof submissions
+     * @returns Batch ID
+     */
+    submitBatch(proofs: ProofSubmission[]): Promise<string>;
+    /**
+     * Check if enclave is whitelisted
+     *
+     * @param measurement - Enclave measurement hash
+     * @returns Whether enclave is whitelisted
+     */
+    isEnclaveWhitelisted(measurement: string): Promise<boolean>;
+    /**
+     * Get whitelisted enclaves
+     *
+     * @returns Array of enclave info
+     */
+    getWhitelistedEnclaves(): Promise<EnclaveInfo[]>;
+    /**
+     * Get TEE attestation for a proof
+     *
+     * @param proofHash - Hash of the proof
+     * @returns TEE attestation if available
+     */
+    getTeeAttestation(proofHash: string): Promise<TeeAttestation | null>;
+    /**
+     * Compress proof data
+     *
+     * @param proof - Raw proof data
+     * @param algorithm - Compression algorithm
+     * @returns Compressed proof
+     */
+    compressProof(proof: Uint8Array, algorithm?: 'zstd' | 'lz4' | 'snappy'): Promise<CompressedProof>;
+    /**
+     * Decompress proof data
+     *
+     * @param compressed - Compressed proof
+     * @returns Decompressed proof data
+     */
+    decompressProof(compressed: CompressedProof): Promise<Uint8Array>;
+    /**
+     * Get compression stats for a proof
+     *
+     * @param proofHash - Hash of the proof
+     * @returns Compression statistics
+     */
+    getCompressionStats(proofHash: string): Promise<CompressionStats | null>;
+    /**
+     * Get prover metrics for a worker
+     *
+     * @param workerId - Worker ID
+     * @returns Prover metrics
+     */
+    getProverMetrics(workerId: string): Promise<ProverMetrics>;
+    /**
+     * Get proof leaderboard
+     *
+     * @param limit - Number of entries
+     * @returns Leaderboard entries
+     */
+    getProofLeaderboard(limit?: number): Promise<Array<{
+        rank: number;
+        worker_id: string;
+        verified_proofs: bigint;
+        success_rate_bps: number;
+        total_rewards: bigint;
+    }>>;
+    /**
+     * Get global proof verification statistics
+     *
+     * @returns Verification statistics
+     */
+    getVerificationStats(): Promise<{
+        total_proofs: bigint;
+        verified_proofs: bigint;
+        failed_proofs: bigint;
+        pending_proofs: bigint;
+        total_gas_used: bigint;
+        avg_verification_time_ms: number;
+        standard_proofs: bigint;
+        gpu_tee_proofs: bigint;
+        challenges_submitted: bigint;
+        challenges_upheld: bigint;
+    }>;
+    /**
+     * Get proof history for a job
+     *
+     * @param jobId - Job ID
+     * @returns Array of proof metadata
+     */
+    getJobProofHistory(jobId: bigint): Promise<ProofMetadata[]>;
+    /**
+     * Estimate gas for proof verification
+     *
+     * @param proofSize - Size of proof in bytes
+     * @param isGpuTee - Whether it's a GPU-TEE proof
+     * @returns Estimated gas
+     */
+    estimateVerificationGas(proofSize: number, isGpuTee?: boolean): bigint;
+    /**
+     * Validate proof data before submission
+     *
+     * @param proofData - Proof data to validate
+     * @returns Validation result
+     */
+    validateProofData(proofData: string[]): {
+        valid: boolean;
+        error?: string;
+    };
+}
+/**
+ * Create a StwoClient instance
+ */
+declare function createStwoClient(http: HttpClient, contract: ContractClient, stwoVerifierAddress: string, optimisticTeeAddress?: string, batchVerifierAddress?: string): StwoClient;
+
+/**
+ * TEE Integration Module
+ * Trusted Execution Environment attestation and verification
+ */
+
+interface TeeClientConfig {
+    /** Optimistic TEE contract address */
+    optimisticTeeAddress: string;
+    /** TEE Registry contract address */
+    teeRegistryAddress?: string;
+}
+/** Transaction result */
+interface TransactionResult {
+    transaction_hash: string;
+    status: 'pending' | 'accepted' | 'rejected';
+    receipt?: TransactionReceipt;
+}
+/** TEE result submission parameters */
+interface TeeResultParams {
+    /** Job ID */
+    job_id: bigint;
+    /** Output data hash */
+    output_hash: bigint;
+    /** TEE quote */
+    quote: TeeQuote;
+    /** Execution metrics */
+    execution_metrics: ExecutionMetrics;
+}
+/** TEE job result */
+interface TeeJobResult {
+    /** Job ID */
+    job_id: bigint;
+    /** Worker address */
+    worker: string;
+    /** Output hash */
+    output_hash: bigint;
+    /** TEE type used */
+    tee_type: TeeType$1;
+    /** Enclave measurement */
+    enclave_measurement: bigint;
+    /** Status */
+    status: 'Pending' | 'Accepted' | 'Challenged' | 'Finalized' | 'Rejected';
+    /** Submission timestamp */
+    submitted_at: number;
+    /** Finalization timestamp */
+    finalized_at?: number;
+    /** Challenge window end */
+    challenge_window_end: number;
+    /** Challenge ID if challenged */
+    challenge_id?: bigint;
+}
+/** TEE challenge parameters */
+interface TeeChallengeParams {
+    /** Job ID to challenge */
+    job_id: bigint;
+    /** Challenge stake (wei) */
+    stake: bigint;
+    /** Challenge reason */
+    reason: string;
+    /** Evidence data */
+    evidence?: string[];
+}
+/** TEE challenge status */
+interface TeeChallengeStatus {
+    /** Challenge ID */
+    challenge_id: bigint;
+    /** Job ID challenged */
+    job_id: bigint;
+    /** Challenger address */
+    challenger: string;
+    /** Stake amount */
+    stake: bigint;
+    /** Reason */
+    reason: string;
+    /** Status */
+    status: 'Pending' | 'Investigating' | 'Resolved' | 'Rejected';
+    /** Submitted at */
+    submitted_at: number;
+    /** Resolution timestamp */
+    resolved_at?: number;
+    /** Whether challenge was upheld */
+    upheld?: boolean;
+    /** Reward/penalty amount */
+    result_amount?: bigint;
+}
+/** GPU attestation details */
+interface GpuAttestation {
+    /** GPU model */
+    gpu_model: string;
+    /** GPU serial (hashed) */
+    gpu_serial_hash: bigint;
+    /** TEE type */
+    tee_type: TeeType$1;
+    /** Driver version */
+    driver_version: string;
+    /** Firmware hash */
+    firmware_hash: bigint;
+    /** Attestation timestamp */
+    attestation_timestamp: number;
+    /** Expiry timestamp */
+    expiry_timestamp: number;
+    /** Is valid */
+    is_valid: boolean;
+}
+/** Worker TEE status */
+interface WorkerTeeStatus {
+    /** Worker address */
+    worker: string;
+    /** Has valid TEE attestation */
+    has_valid_attestation: boolean;
+    /** TEE types supported */
+    tee_types: TeeType$1[];
+    /** GPU attestations */
+    gpu_attestations: GpuAttestation[];
+    /** Last attestation refresh */
+    last_refresh: number;
+    /** Attestation expiry */
+    attestation_expiry: number;
+    /** Jobs processed with TEE */
+    tee_jobs_count: bigint;
+    /** TEE failure rate (basis points) */
+    failure_rate_bps: number;
+}
+/**
+ * TEE Integration Client
+ *
+ * Manages Trusted Execution Environment operations including:
+ * - TEE result submission and verification
+ * - Challenge and dispute mechanisms
+ * - Enclave attestation management
+ * - GPU TEE (H100/H200/B200) support
+ * - Worker TEE status tracking
+ *
+ * @example
+ * ```typescript
+ * const tee = new TeeClient(httpClient, contractClient, config);
+ *
+ * // Submit TEE result for a job
+ * await tee.submitTeeResult({
+ *   job_id: jobId,
+ *   output_hash: outputHash,
+ *   quote: {
+ *     quote_data: quoteBytes,
+ *     enclave_measurement: measurement,
+ *     timestamp: Date.now(),
+ *     claims: {},
+ *   },
+ *   execution_metrics: {
+ *     cpu_cycles: 1000000n,
+ *     memory_peak: 1024n * 1024n * 1024n,
+ *     execution_time_ms: 5000,
+ *   },
+ * });
+ *
+ * // Verify enclave attestation
+ * const isValid = await tee.verifyEnclaveAttestation(measurement);
+ *
+ * // Check worker TEE status
+ * const status = await tee.getWorkerTeeStatus(workerAddress);
+ * ```
+ */
+declare class TeeClient {
+    private http;
+    private contract;
+    private config;
+    constructor(http: HttpClient, contract: ContractClient, config: TeeClientConfig);
+    /**
+     * Submit TEE execution result
+     *
+     * @param params - TEE result parameters
+     * @returns Transaction result
+     */
+    submitTeeResult(params: TeeResultParams): Promise<TransactionResult>;
+    /**
+     * Get TEE result for a job
+     *
+     * @param jobId - Job ID
+     * @returns TEE job result
+     */
+    getTeeResult(jobId: bigint): Promise<TeeJobResult | null>;
+    /**
+     * Finalize TEE result after challenge window
+     *
+     * @param jobId - Job ID
+     * @returns Transaction result
+     */
+    finalizeTeeResult(jobId: bigint): Promise<TransactionResult>;
+    /**
+     * Check if TEE result can be finalized
+     *
+     * @param jobId - Job ID
+     * @returns Finalization status
+     */
+    canFinalizeTeeResult(jobId: bigint): Promise<{
+        can_finalize: boolean;
+        reason?: string;
+        time_remaining_secs?: number;
+    }>;
+    /**
+     * Challenge a TEE result
+     *
+     * @param params - Challenge parameters
+     * @returns Transaction result with challenge ID
+     */
+    challengeTeeResult(params: TeeChallengeParams): Promise<TransactionResult>;
+    /**
+     * Get challenge status
+     *
+     * @param challengeId - Challenge ID
+     * @returns Challenge status
+     */
+    getChallengeStatus(challengeId: bigint): Promise<TeeChallengeStatus>;
+    /**
+     * Get challenges for a job
+     *
+     * @param jobId - Job ID
+     * @returns Array of challenges
+     */
+    getJobChallenges(jobId: bigint): Promise<TeeChallengeStatus[]>;
+    /**
+     * Verify enclave attestation
+     *
+     * @param measurement - Enclave measurement hash
+     * @returns Whether attestation is valid
+     */
+    verifyEnclaveAttestation(measurement: string): Promise<boolean>;
+    /**
+     * Get enclave info
+     *
+     * @param measurement - Enclave measurement
+     * @returns Enclave info or null
+     */
+    getEnclaveInfo(measurement: string): Promise<EnclaveInfo | null>;
+    /**
+     * Get all whitelisted enclaves
+     *
+     * @returns Array of enclave info
+     */
+    getWhitelistedEnclaves(): Promise<EnclaveInfo[]>;
+    /**
+     * Submit GPU attestation for worker
+     *
+     * @param attestation - GPU attestation data
+     * @returns Transaction result
+     */
+    submitGpuAttestation(attestation: GpuAttestation): Promise<TransactionResult>;
+    /**
+     * Refresh worker TEE attestation
+     *
+     * @returns Transaction result
+     */
+    refreshAttestation(): Promise<TransactionResult>;
+    /**
+     * Get worker TEE status
+     *
+     * @param workerAddress - Worker address
+     * @returns Worker TEE status
+     */
+    getWorkerTeeStatus(workerAddress: string): Promise<WorkerTeeStatus>;
+    /**
+     * Get workers with valid TEE attestation
+     *
+     * @param teeType - Optional TEE type filter
+     * @returns Array of worker addresses
+     */
+    getTeeEnabledWorkers(teeType?: TeeType$1): Promise<string[]>;
+    /**
+     * Get TEE statistics
+     *
+     * @returns TEE statistics
+     */
+    getTeeStats(): Promise<{
+        total_tee_jobs: bigint;
+        finalized_jobs: bigint;
+        challenged_jobs: bigint;
+        challenge_success_rate_bps: number;
+        avg_finalization_time_secs: number;
+        workers_with_tee: number;
+        tee_type_breakdown: Record<TeeType$1, number>;
+    }>;
+    /**
+     * Get TEE job history for worker
+     *
+     * @param workerAddress - Worker address
+     * @param limit - Number of jobs
+     * @returns Array of TEE job results
+     */
+    getWorkerTeeHistory(workerAddress: string, limit?: number): Promise<TeeJobResult[]>;
+    /**
+     * Check if TEE type is supported
+     *
+     * @param teeType - TEE type to check
+     * @returns Whether TEE type is supported
+     */
+    isTeeTypeSupported(teeType: TeeType$1): boolean;
+    /**
+     * Get TEE type display name
+     *
+     * @param teeType - TEE type
+     * @returns Display name
+     */
+    getTeeTypeDisplayName(teeType: TeeType$1): string;
+    /**
+     * Calculate challenge window end
+     *
+     * @param submittedAt - Submission timestamp
+     * @param windowSecs - Challenge window duration (default 24h)
+     * @returns Challenge window end timestamp
+     */
+    calculateChallengeWindowEnd(submittedAt: number, windowSecs?: number): number;
+    private teeTypeToFelt;
+    private getTeeTypeFromQuote;
+}
+/**
+ * Create a TeeClient instance
+ */
+declare function createTeeClient(http: HttpClient, contract: ContractClient, optimisticTeeAddress: string, teeRegistryAddress?: string): TeeClient;
+
+export { type TransactionReceipt as $, type AEHint as A, BitSageClient as B, type ClientConfig as C, DEFAULT_CONFIG as D, type ECPoint as E, type FaucetStatus as F, type GpuTier$1 as G, HttpClient as H, ContractClient as I, type JobId as J, DEFAULT_CONTRACT_CONFIG as K, type ListJobsParams as L, toFelt as M, type Network$1 as N, fromFelt as O, type PrivacyKeyPair as P, splitU256 as Q, joinU256 as R, type SchnorrProof as S, type TransferProof as T, type HttpConfig as U, type JobUpdateEvent as V, type WsConfig as W, type WorkerUpdateEvent as X, type NetworkStatsEvent as Y, type ProofVerifiedEvent as Z, type ContractConfig as _, WebSocketClient as a, type TransactionResult$5 as a$, type TxStatus as a0, SEPOLIA_CONTRACTS as a1, MAINNET_CONTRACTS as a2, LOCAL_CONTRACTS as a3, getContractsForNetwork as a4, isContractConfigured as a5, SEPOLIA_TOKENS as a6, MAINNET_TOKENS as a7, getTokensForNetwork as a8, PRAGMA_ORACLE as a9, StwoClient as aA, createStwoClient as aB, VERIFICATION_CONFIG as aC, TeeClient as aD, createTeeClient as aE, type MiningClientConfig as aF, type ValidatorStatus as aG, type ValidatorStatusResponse as aH, type GpuMetrics as aI, type GpuMetricsResponse as aJ, type RewardsInfo as aK, type HistoryPeriod as aL, type RewardHistoryEntry as aM, type RewardHistoryResponse as aN, type JobAnalytics as aO, type RecentJob as aP, type WorkerSummary as aQ, type NetworkWorkersResponse as aR, type BatchJobResponse as aS, type BatchStatusResponse as aT, type BatchOperationType as aU, type BatchOperation as aV, type GasEstimate as aW, type BatchVerifyRequest as aX, type BatchVerifyResponse as aY, type PaymentsClientConfig as aZ, type StakingClientConfig as a_, type ContractRegistry as aa, type ExternalTokens as ab, MiningClient as ac, createMiningClient as ad, DashboardClient as ae, createDashboardClient as af, BatchClient as ag, createBatchClient as ah, MAX_BATCH_SIZE as ai, PaymentsClient as aj, createPaymentsClient as ak, StakingClient as al, createStakingClient as am, MIN_STAKE as an, SLASH_PERCENTAGES as ao, UNSTAKE_LOCKUP_SECS as ap, isWorkerEligible as aq, getMinStakeForTier as ar, WorkersClient as as, createWorkersClient as at, CAPABILITY_FLAGS as au, PrivacyClient as av, createPrivacyClient as aw, GovernanceClient as ax, createGovernanceClient as ay, GOVERNANCE_CONFIG as az, type WsEvent as b, type ProofType as b$, type TeeType as b0, type WorkerTier as b1, type HolderTier as b2, type SlashReason as b3, type WorkerStake as b4, type StakingConfig as b5, type SlashRecord as b6, type DisputeRecord as b7, type WorkerTierBenefits as b8, type UnstakeRequest as b9, type ProposalType as bA, type GovernanceProposal as bB, type GovernanceRights as bC, type GovernanceStats as bD, type PoolBalances as bE, type VestingStatus as bF, type SecurityBudget as bG, type BurnEvent as bH, type EcosystemEmissionStatus as bI, type TokenFlowSummary as bJ, type MilestoneStatus as bK, type RateLimitInfo as bL, type PendingTransfer as bM, type CreateProposalParams as bN, type VoteDirection as bO, type DelegationInfo as bP, type VoterInfo as bQ, type StwoClientConfig as bR, type TransactionResult$1 as bS, type VerificationStatus as bT, type ProofSource as bU, type TeeType$1 as bV, type TeeAttestation as bW, type ProofMetadata as bX, type GpuTeeProofParams as bY, type BatchStatus as bZ, type ProofJobSpec as b_, type WorkersClientConfig as ba, type TransactionResult$4 as bb, type WorkerCapabilities as bc, type WorkerProfile as bd, type PerformanceData as be, type LeaderboardMetric as bf, type LeaderboardEntry as bg, type RegisterWorkerParams as bh, type PrivacyClientConfig as bi, type TransactionResult$3 as bj, type PrivacyAsset as bk, type PrivateAccount as bl, type PrivateTransferParams as bm, type PrivateTransferWithAuditParams as bn, type SteganographicTransaction as bo, type MixingTransaction as bp, type MixingOutput as bq, type RagequitProof as br, type DKGShare as bs, type ThresholdDecryptionRequest as bt, type MultiAssetBalances as bu, type PrivateSwapParams as bv, type StealthAddress as bw, type GovernanceClientConfig as bx, type TransactionResult$2 as by, type ProposalStatus as bz, type ElGamalCiphertext as c, type ProofPriority as c0, type ProofSubmission as c1, type ProverMetrics as c2, type CompressionStats as c3, type CompressedProof as c4, type EnclaveInfo as c5, type ChallengeParams as c6, type ChallengeStatus as c7, type TeeClientConfig as c8, type TransactionResult as c9, type PrivateWorkerPayment as cA, type PaymentToken as cB, type PaymentQuote as cC, type DiscountTiers as cD, type FeeDistribution as cE, type OTCConfig as cF, type PaymentStats as cG, type JobPaymentRecord as cH, type PaymentStatus as cI, type VerificationSource as cJ, type ComputeCheckpoint as cK, type CheckpointStatus as cL, type PrivacyCreditDeposit as cM, type PrivacyCreditUsage as cN, type TransactionResult$6 as cO, DEFAULT_DISCOUNT_TIERS as cP, DEFAULT_FEE_DISTRIBUTION as cQ, type DisputeStatus as cR, type TeeQuote as cS, type ExecutionMetrics as cT, type GpuTier as cU, type StakeInfo as cV, type WorkerInfo as cW, type NetworkStats as cX, type TeeResultParams as ca, type TeeJobResult as cb, type TeeChallengeParams as cc, type TeeChallengeStatus as cd, type GpuAttestation as ce, type WorkerTeeStatus as cf, type StakeTier as cg, type DailyStats as ch, type WorkerMiningStats as ci, type MiningPoolStatus as cj, type MiningConfig as ck, type RewardResult as cl, type MiningGpuTier as cm, STAKE_TIER_THRESHOLDS as cn, DAILY_CAPS as co, GPU_MULTIPLIERS as cp, HALVENING_SCHEDULE as cq, getStakeTierFromAmount as cr, getDailyCapForTier as cs, getGpuMultiplier as ct, type SameEncryption3Proof as cu, type AccountHints as cv, type RingMember as cw, type RingSignature as cx, type MultiAssetBalance as cy, type AuditReport as cz, type EncryptedBalance as d, SdkError as e, type WalletConfig as f, type WorkerId as g, type JobType as h, type JobStatus as i, type WorkerStatus$1 as j, type ProofVerificationStatus as k, type WorkerCapabilities$1 as l, type WorkerInfo$1 as m, type ProofDetails as n, type NetworkStats$1 as o, type StakeInfo$1 as p, type SubmitJobRequest as q, type SubmitJobResponse as r, type JobStatusResponse as s, type JobResult as t, type ListJobsResponse as u, type FaucetClaimResponse as v, getMinStake as w, getGpuTier as x, DEFAULT_HTTP_CONFIG as y, DEFAULT_WS_CONFIG as z };