testing: EVM test chain

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

export declare class TestChain {
    readonly chain: CanonicalChain;
    readonly rpcUrl: string;
    readonly mode: "replay" | "record" | "live" | "local";
    readonly stack: Stack;
    private readonly stopNode;
    readonly client: PublicClient;
    readonly test: TestClient;
    private readonly viemChain;
    private readonly snapshots;
    private readonly accounts;
    constructor(chain: CanonicalChain, rpcUrl: string, mode: "replay" | "record" | "live" | "local", stack: Stack, stopNode: () => Promise<void>);
    get engine(): Address;
    get kitchen(): Address;
    get router(): Address;
    get nativeSymbol(): string;
    account(index?: number): TestAccount;
    private accountOf;
    executionFee(): Promise<bigint>;
    deployPot(account?: number | TestAccount): Promise<Address>;
    private wallet;
    private token;
    private decimals;
    balanceOf(holder: Address, token: string): Promise<bigint>;
    fund(holder: Address, amounts: Readonly<Record<string, string | bigint>>): Promise<void>;
    impersonate<T>(address: Address, body: (send: (tx: {
        to: Address;
        data?: Hex;
        value?: bigint;
    }) => Promise<Hex>) => Promise<T>): Promise<T>;
    compile(program: ProgramInput): CompiledProgram;
    private cookCall;
    private result;
    simulate(program: ProgramInput, options?: CookOptions): Promise<CookResult>;
    run(program: ProgramInput, options?: CookOptions): Promise<CookResult>;
    snapshot(): Promise<void>;
    revert(): Promise<void>;
    increaseTime(seconds: number | bigint): Promise<void>;
    mine(blocks?: number): Promise<void>;
    now(): Promise<bigint>;
    stop(): Promise<void>;
}

DEFAULT_POT_SALT: Hex

export interface CookOptions {
    readonly from?: number | TestAccount;
    readonly args?: readonly EntryValue[];
    readonly value?: bigint;
}

export interface CookResult {
    readonly hash?: Hex;
    readonly gasUsed: bigint;
    readonly returnData: Hex;
    readonly returned: Value | undefined;
    readonly transfers: readonly Movement[];
    readonly effects: Effects;
    delta(holder: Address, token: string): bigint;
}

export interface TestAccount {
    readonly index: number;
    readonly address: Address;
    readonly privateKey: Hex;
    readonly pot: Address;
}

export interface Effects {
    readonly moves: readonly Movement[];
    readonly transfers: readonly Movement[];
    readonly approvals: readonly ApprovalEvent[];
    readonly native?: readonly Movement[];
    readonly changes: readonly BalanceChange[];
    readonly other: readonly RawLog[];
    readonly tokens: ReadonlyMap<string, TokenInfo>;
    readonly labels: ReadonlyMap<string, string>;
}

export interface Movement {
    readonly token: Address | "native";
    readonly from: Address;
    readonly to: Address;
    readonly amount: bigint;
    readonly kind: "transfer" | "wrap" | "unwrap";
}