testing: Solana test chain

import { fork, local, CookReverted } from "@eco-incorp/sauce/testing";

export declare class SolanaTestChain {
    readonly chain: CanonicalChain;
    readonly mode: "replay" | "record" | "live" | "local";
    private readonly bank;
    readonly engine: Address;
    readonly kitchen: Address;
    private readonly feeConfig;
    private readonly signers;
    private readonly accounts;
    private readonly funder;
    private readonly cookChain;
    private recordTo;
    private constructor();
    static start(chain: CanonicalChain, bank: Bank, options: {
        readonly zeroFee?: boolean;
        readonly recordTo?: {
            readonly path: string;
            readonly rpcUrl: string;
        };
    }): Promise<SolanaTestChain>;
    account(index?: number): SolanaTestAccount;
    private accountOf;
    executionFee(): Promise<bigint>;
    deployPot(account?: number | SolanaTestAccount): Promise<Address>;
    getAccount(key: Address): Promise<SolanaAccount | null>;
    setAccount(key: Address, account: SolanaAccount | null): Promise<void>;
    private tokenOf;
    balanceOf(holder: Address, token: string): Promise<bigint>;
    fund(holder: Address, amounts: Readonly<Record<string, string | bigint>>): Promise<void>;
    compile(program: ProgramInput): CompiledProgram;
    private tokenName;
    private changesOf;
    private mintOf;
    private result;
    private cook;
    run(program: ProgramInput, options?: SolanaCookOptions): Promise<SolanaCookResult>;
    simulate(program: ProgramInput, options?: SolanaCookOptions): Promise<SolanaCookResult>;
    snapshot(): Promise<void>;
    revert(): Promise<void>;
    increaseTime(seconds: number | bigint): Promise<void>;
    warp(slots: number | bigint): Promise<void>;
    now(): Promise<bigint>;
    slot(): Promise<bigint>;
    stop(): Promise<void>;
}

export interface SolanaAccount {
    readonly lamports: bigint;
    readonly owner: Address;
    readonly data: Uint8Array;
    readonly executable: boolean;
}

export interface SolanaChange {
    readonly holder: Address;
    readonly token: string;
    readonly mint?: Address;
    readonly amount: bigint;
}

export interface SolanaCookOptions {
    readonly from?: number | SolanaTestAccount;
    readonly args?: readonly EntryValue[];
    readonly accounts?: Readonly<Record<string, string>>;
}

export interface SolanaCookResult {
    readonly signature?: string;
    readonly computeUnits: bigint;
    readonly returnData: Hex;
    readonly returned: Value | undefined;
    readonly logs: readonly string[];
    readonly changes: readonly SolanaChange[];
    readonly staged: boolean;
    readonly lookupTable: boolean;
    delta(holder: Address, token: string): bigint;
}

export interface SolanaForkOptions {
    readonly state?: string;
    readonly rpcUrl?: string;
    readonly mode?: "auto" | ForkMode;
    readonly zeroFee?: boolean;
}

export interface SolanaTestAccount {
    readonly index: number;
    readonly address: Address;
    readonly secretKey: Uint8Array;
    readonly pot: Address;
}