@midnight-ntwrk/testkit-js 3.0.0-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,789 @@
+import { Contract } from '@midnight-ntwrk/compact-js';
+import { StateValue, ContractAddress } from '@midnight-ntwrk/compact-runtime';
+import { Signaturish, Proofish, Bindingish, Transaction, ContractState, LedgerState, ZswapSecretKeys, DustSecretKey, CoinPublicKey, EncPublicKey, ShieldedCoinInfo, FinalizedTransaction, TokenType, LedgerParameters } from '@midnight-ntwrk/ledger-v7';
+import { FinalizedDeployTxData, FinalizedDeployTxDataBase, DeployContractOptions, DeployTxOptions, FinalizedCallTxData, CallTxOptions } from '@midnight-ntwrk/midnight-js-contracts';
+import { MidnightProviders, PrivateStateId, FinalizedTxData, BlockHash, PrivateStateProvider, MidnightProvider, WalletProvider, UnboundTransaction } from '@midnight-ntwrk/midnight-js-types';
+import * as axios from 'axios';
+import { AxiosResponse, AxiosRequestConfig } from 'axios';
+import pino, { Logger } from 'pino';
+import { WaitStrategy, StartedDockerComposeEnvironment } from 'testcontainers';
+import { EnvironmentConfiguration as EnvironmentConfiguration$1 } from '@/test-environment';
+import { MidnightWalletProvider as MidnightWalletProvider$1 } from '@/wallet';
+import { NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { TestEnvironment as TestEnvironment$1 } from '@/test-environment/test-environments/test-environment';
+import { ProofServerContainer as ProofServerContainer$1 } from '@/proof-server-container';
+import * as _midnight_ntwrk_wallet_sdk_facade from '@midnight-ntwrk/wallet-sdk-facade';
+import { WalletFacade } from '@midnight-ntwrk/wallet-sdk-facade';
+import { UnshieldedKeystore, UnshieldedWallet, UnshieldedWalletState } from '@midnight-ntwrk/wallet-sdk-unshielded-wallet';
+import { EnvironmentConfiguration as EnvironmentConfiguration$2 } from '@/test-environment/environment-configuration';
+import { DustWalletOptions as DustWalletOptions$1 } from '@/wallet/wallet-factory';
+import { WalletSeeds as WalletSeeds$1 } from '@/wallet/wallet-seed';
+import { EnvironmentConfiguration as EnvironmentConfiguration$3 } from '@/index';
+import { DustWallet } from '@midnight-ntwrk/wallet-sdk-dust-wallet';
+import { ShieldedWallet, ShieldedWalletState } from '@midnight-ntwrk/wallet-sdk-shielded';
+import { DefaultV1Configuration } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
+
+declare const stateValueEqual: (a: StateValue, b: StateValue) => boolean;
+declare const txsEqual: <S extends Signaturish, P extends Proofish, B extends Bindingish>(a: Transaction<S, P, B>, b: Transaction<S, P, B>) => boolean;
+declare const expectFoundAndDeployedTxPublicDataEqual: <C extends Contract.Any>(deployTxData: FinalizedDeployTxData<C>, foundDeployTxData: FinalizedDeployTxDataBase<C>) => void;
+declare const expectFoundAndDeployedTxPrivateDataEqual: <C extends Contract.Any>(deployTxData: FinalizedDeployTxData<C>, foundDeployTxData: FinalizedDeployTxDataBase<C>) => void;
+declare const expectFoundAndDeployedTxDataEqual: <C extends Contract.Any>(deployTxData: FinalizedDeployTxData<C>, foundDeployTxData: FinalizedDeployTxDataBase<C>) => void;
+declare const expectFoundAndDeployedStatesEqual: <C extends Contract.Any>(providers: MidnightProviders<Contract.ImpureCircuitId<C>, PrivateStateId, Contract.PrivateState<C> | unknown>, deployTxData: FinalizedDeployTxData<C>, foundDeployTxData: FinalizedDeployTxDataBase<C>, privateStateId?: PrivateStateId, initialPrivateState?: Contract.PrivateState<C>) => Promise<void>;
+declare const expectSuccessfulTxData: (finalizedTxData: FinalizedTxData) => void;
+declare const expectSuccessfulDeployTx: <C extends Contract.Any>(providers: MidnightProviders<Contract.ImpureCircuitId<C>, PrivateStateId, Contract.PrivateState<C> | unknown>, deployTxData: FinalizedDeployTxData<C>, deployTxOptions?: DeployContractOptions<C> | DeployTxOptions<C>) => Promise<void>;
+declare const expectSuccessfulCallTx: <C extends Contract.Any, ICK extends Contract.ImpureCircuitId<C>>(providers: MidnightProviders<Contract.ImpureCircuitId<C>, PrivateStateId, Contract.PrivateState<C> | unknown>, callTxData: FinalizedCallTxData<C, ICK>, callTxOptions?: CallTxOptions<C, ICK>, nextPrivateState?: Contract.PrivateState<C>) => Promise<void>;
+
+/**
+ * Client for interacting with the Midnight faucet service.
+ * Provides functionality to request test tokens for wallet addresses.
+ */
+declare class FaucetClient {
+    readonly faucetUrl: string;
+    private logger;
+    /**
+     * Creates a new FaucetClient instance.
+     * @param {string} faucetUrl - The URL of the faucet service endpoint
+     * @param {Logger} logger - Logger instance for recording operations
+     */
+    constructor(faucetUrl: string, logger: Logger);
+    /**
+     * Checks the health status of the faucet service.
+     * Makes a GET request to the health endpoint of the faucet service.
+     * @returns {Promise<AxiosResponse | void>} A promise that resolves to the response of the health check or logs an error if the request fails
+     */
+    health(): Promise<void | axios.AxiosResponse<any, any, {}>>;
+    /**
+     * Requests test tokens from the faucet for a specified wallet address.
+     * Makes a POST request to the faucet service with the wallet address.
+     * @param {string} walletAddress - The address to receive the test tokens
+     * @returns {Promise<void>} A promise that resolves when the request is complete
+     * @throws Will log but not throw if the request fails
+     */
+    requestTokens(walletAddress: string): Promise<void>;
+}
+
+declare class IndexerClient {
+    readonly indexerUrl: string;
+    private logger;
+    /**
+     * Creates an instance of IndexerClient.
+     * @param {string} indexerUrl - The URL of the indexer service.
+     * @param {Logger} logger - The logger instance for logging information.
+     */
+    constructor(indexerUrl: string, logger: Logger);
+    /**
+     * Checks the health status of the indexer service.
+     * Makes a GET request to the status endpoint of the indexer service.
+     * @returns {Promise<AxiosResponse | void>} A promise that resolves to the response of the health check or logs an error if the request fails.
+     */
+    health(): Promise<void | axios.AxiosResponse<any, any, {}>>;
+}
+
+/**
+ * Client for interacting with a Midnight node's JSON-RPC API
+ */
+declare class NodeClient {
+    readonly nodeURL: string;
+    private logger;
+    /**
+     * Creates a new NodeClient instance
+     * @param {string} nodeURL - URL of the Midnight node
+     * @param {Logger} logger - Logger instance for recording operations
+     */
+    constructor(nodeURL: string, logger: Logger);
+    /**
+     * Checks the health status of the node.
+     * Makes a GET request to the health endpoint of the node.
+     * @returns {Promise<AxiosResponse | void>} A promise that resolves to the response of the health check or logs an error if the request fails.
+     */
+    health(): Promise<void | AxiosResponse<any, any, {}>>;
+    /**
+     * Validates response format and throws if unexpected
+     * @param {AxiosResponse} response - Response from node API
+     * @throws {Error} If response format is unexpected
+     * @private
+     */
+    private static throwOnUnexpected;
+    /**
+     * Makes a JSON-RPC request to the node
+     * @param {string} method - RPC method name
+     * @param {any[]} params - RPC method parameters
+     * @returns {Promise<string>} Response result as string
+     * @private
+     */
+    private jsonRPC;
+    /**
+     * Fetches the state of a contract
+     * @param {ContractAddress} contractAddress - Address of the contract
+     * @returns {Promise<ContractState | null>} Contract state or null if not found
+     */
+    contractState(contractAddress: ContractAddress): Promise<ContractState | null>;
+    /**
+     * Fetches the ledger state at a given block
+     * @param {BlockHash} blockHash - Hash of the block
+     * @returns {Promise<LedgerState>} Ledger state
+     */
+    ledgerState(blockHash: BlockHash): Promise<LedgerState>;
+    /**
+     * Fetches the raw ledger state blob at a given block
+     * @param {BlockHash} blockHash - Hash of the block
+     * @returns {Promise<Uint8Array>} Raw ledger state data
+     * @throws {Error} If no ledger state is found
+     */
+    ledgerStateBlob(blockHash: BlockHash): Promise<Uint8Array>;
+    /**
+     * Fetches the ledger version at a given block
+     * @param {BlockHash} blockHash - Hash of the block
+     * @returns {Promise<string>} Ledger version
+     * @throws {Error} If no ledger version is found
+     */
+    ledgerVersion(blockHash: BlockHash): Promise<string>;
+}
+
+declare class ProofServerClient {
+    readonly proofServer: string;
+    private logger;
+    /**
+     * Creates an instance of ProofServerClient.
+     * @param {string} proofServer - The URL of the proof server service.
+     * @param {Logger} logger - The logger instance for logging information.
+     */
+    constructor(proofServer: string, logger: Logger);
+    /**
+     * Checks the health status of the indexer service.
+     * Makes a GET request to the status endpoint of the indexer service.
+     * @returns {Promise<AxiosResponse | void>} A promise that resolves to the response of the health check or logs an error if the request fails.
+     */
+    health(): Promise<void | axios.AxiosResponse<any, any, {}>>;
+    /**
+     * Proves a transaction by sending a POST request to the proof server.
+     * @param data serialized transaction data
+     * @param config Axios request configuration
+     */
+    proveTx(data?: ArrayBuffer, config?: AxiosRequestConfig): Promise<void | axios.AxiosResponse<any, any, {}>>;
+}
+
+/**
+ * Configuration for a proof server container instance
+ */
+interface ProofServerContainerConfiguration {
+    /** Directory path where container configuration is located */
+    path: string;
+    /** Name of the container configuration file */
+    fileName: string;
+    /** Network endpoint configuration for the container */
+    container: ContainerEndpoints;
+}
+/**
+ * Network endpoint configuration for a container
+ */
+interface ContainerEndpoints {
+    /** Name of the container */
+    name: string;
+    /** Port number the container listens on */
+    port: number;
+    /** TestContainers WaitStrategy to use for container start */
+    waitStrategy: WaitStrategy;
+}
+/**
+ * Container endpoint configurations for standalone mode services
+ */
+interface StandaloneContainerNames {
+    /** Proof server container configuration */
+    proofServer: ContainerEndpoints;
+    /** Blockchain node container configuration */
+    node: ContainerEndpoints;
+    /** Indexer service container configuration */
+    indexer: ContainerEndpoints;
+}
+/**
+ * Configuration for standalone mode containers
+ */
+interface StandaloneContainersConfiguration {
+    /** Directory path where container configuration is located */
+    path: string;
+    /** Name of the container configuration file */
+    fileName: string;
+    /** Container endpoint configurations */
+    container: StandaloneContainerNames;
+}
+/**
+ * Configuration for test logging
+ */
+interface LogConfiguration {
+    /** Directory path where log files will be written */
+    path: string;
+    /** Name of the log file */
+    fileName: string;
+    /** Log level (e.g. 'info', 'debug', etc) */
+    level: string;
+}
+/**
+ * Top-level configuration for all test containers
+ */
+interface ContainersConfiguration {
+    /** Proof server container configuration */
+    proofServer: ProofServerContainerConfiguration;
+    /** Standalone mode containers configuration */
+    standalone: StandaloneContainersConfiguration;
+    /** Logging configuration */
+    log: LogConfiguration;
+}
+
+declare const defaultContainersConfiguration: ContainersConfiguration;
+declare const latestContainersConfiguration: ContainersConfiguration;
+declare const getContainersConfiguration: () => ContainersConfiguration;
+declare const setContainersConfiguration: (containersConfig: ContainersConfiguration) => void;
+
+/**
+ * Configuration interface for Midnight contracts.
+ */
+interface ContractConfiguration {
+    /**
+     * Name of the store used for persisting private state data.
+     * This is used as a base name - a signing key store will also be created with "-signing-keys" appended.
+     */
+    readonly privateStateStoreName: string;
+    /**
+     * File system path to the zero-knowledge proof configuration files.
+     * This should point to the directory containing the circuit verification keys and other ZK artifacts.
+     */
+    readonly zkConfigPath: string;
+}
+
+/**
+ * A simple in-memory implementation of private state provider. Makes it easy to capture and rewrite private state from deploy.
+ * @template PSI - Type of the private state identifier.
+ * @template PS - Type of the private state.
+ * @returns {PrivateStateProvider<PSI, PS>} An in-memory private state provider.
+ */
+declare const inMemoryPrivateStateProvider: <PSI extends PrivateStateId, PS extends Contract.PrivateState<Contract.Any>>() => PrivateStateProvider<PSI, PS>;
+
+/**
+ * Configures and returns the required providers for a Midnight contract.
+ *
+ * @template ICK - Type parameter for the input circuit key string
+ * @template PS - Type parameter for the private state
+ *
+ * @param {MidnightWalletProvider} midnightWalletProvider - The midnightWalletProvider provider instance to use for transactions
+ * @param {EnvironmentConfiguration} environmentConfiguration - Configuration for the environment including indexer and proof server details
+ * @param {ContractConfiguration} contractConfiguration - Configuration specific to the contract including storage names and ZK config path
+ *
+ * @returns {MidnightProviders} An object containing all configured providers:
+ *   - privateStateProvider: For managing private contract state
+ *   - publicDataProvider: For accessing public blockchain data
+ *   - zkConfigProvider: For zero-knowledge proof configurations
+ *   - proofProvider: For generating and verifying proofs
+ *   - walletProvider: For midnightWalletProvider operations
+ *   - midnightProvider: For Midnight-specific operations
+ */
+declare const initializeMidnightProviders: <ICK extends string, PS>(midnightWalletProvider: MidnightWalletProvider$1, environmentConfiguration: EnvironmentConfiguration$1, contractConfiguration: ContractConfiguration) => MidnightProviders<ICK, PrivateStateId, PS>;
+
+declare function createLogger(fileName: string, dir?: string): pino.Logger<never, boolean>;
+declare function createDefaultTestLogger(): pino.Logger<never, boolean>;
+declare const logger: pino.Logger<never, boolean>;
+
+/**
+ * Interface representing a proof server container that can be started and stopped.
+ */
+interface ProofServerContainer {
+    /**
+     * Stops the proof server container.
+     * @returns {Promise<void>} A promise that resolves when the container is stopped
+     */
+    stop(): Promise<void>;
+    /**
+     * Gets the URL where the proof server can be accessed.
+     * @returns {string} The URL of the proof server
+     */
+    getUrl(): string;
+}
+/**
+ * A proof server container that is started and stopped dynamically by the test
+ * suite on random port.
+ */
+declare class DynamicProofServerContainer implements ProofServerContainer {
+    /** The Docker Compose environment running the container */
+    dockerEnv: StartedDockerComposeEnvironment;
+    /** Unique identifier for the container instance */
+    private uid;
+    /** Configuration for the proof server container */
+    private config;
+    /**
+     * Creates a new DynamicProofServerContainer instance.
+     * @param {StartedDockerComposeEnvironment} dockerEnv - The started Docker Compose environment
+     * @param {string} uid - Unique identifier for the container
+     * @private
+     */
+    private constructor();
+    /**
+     * Starts a new proof server container.
+     * @param {Logger} logger - Logger instance for recording operations
+     * @param {string} [maybeUID] - Optional unique identifier for the container
+     * @param {string} [maybeNetworkId] - Optional network ID for the container
+     * @returns {Promise<DynamicProofServerContainer>} A promise that resolves to the new container instance
+     */
+    static start(logger: Logger, maybeUID?: string, maybeNetworkId?: string): Promise<DynamicProofServerContainer>;
+    /**
+     * Stops the proof server container.
+     * @returns {Promise<void>} A promise that resolves when the container is stopped
+     */
+    stop(): Promise<void>;
+    /**
+     * Gets the mapped port number for the container.
+     * @returns {number} The mapped port number
+     */
+    getMappedPort(): number;
+    /**
+     * Gets the URL where the proof server can be accessed.
+     * @returns {string} The URL of the proof server
+     */
+    getUrl(): string;
+}
+/**
+ * A proof server that is currently running on a specific port.
+ * Used for connecting to an existing proof server instance.
+ */
+declare class StaticProofServerContainer implements ProofServerContainer {
+    /** The port number where the proof server is running */
+    port: number;
+    /**
+     * Creates a new StaticProofServerContainer instance.
+     * @param {number} port - The port number where the proof server is running (default: 6300)
+     */
+    constructor(port?: number);
+    /**
+     * Gets the URL where the proof server can be accessed.
+     * @returns {string} The URL of the proof server
+     */
+    getUrl(): string;
+    /**
+     * No-op stop method since this represents an external proof server.
+     * @returns {Promise<void>} A resolved promise
+     */
+    stop(): Promise<void>;
+}
+
+/**
+ * Configuration interface for the test environment services
+ */
+interface EnvironmentConfiguration {
+    /** Wallet Network identifier */
+    readonly walletNetworkId: NetworkId.NetworkId;
+    /** Network identifier */
+    readonly networkId: string;
+    /** URL of the indexer HTTP endpoint */
+    readonly indexer: string;
+    /** WebSocket URL for the indexer service */
+    readonly indexerWS: string;
+    /** URL of the blockchain node */
+    readonly node: string;
+    /** WebSocket URL for the blockchain node */
+    readonly nodeWS: string;
+    /** URL of the proof generation server */
+    readonly proofServer: string;
+    /** Optional URL for the faucet service to obtain test tokens */
+    readonly faucet: string | undefined;
+}
+
+/**
+ * Returns the appropriate test environment based on the MN_TEST_ENVIRONMENT variable.
+ * @param {Logger} logger - The logger instance to be used by the test environment.
+ * @returns { TestEnvironment} The selected test environment instance.
+ */
+declare const getTestEnvironment: (logger: Logger) => TestEnvironment$1;
+
+/**
+ * Abstract base class for test environments.
+ * Provides common functionality for managing test wallets and environments.
+ */
+declare abstract class TestEnvironment {
+    /** Logger instance for recording operations */
+    protected readonly logger: Logger;
+    /** Unique identifier for this test environment instance */
+    protected readonly uid: string;
+    protected readonly envConfiguration: EnvironmentConfiguration;
+    /**
+     * Creates a new TestEnvironment instance.
+     * @param {Logger} logger - Logger instance for recording operations
+     */
+    constructor(logger: Logger);
+    /**
+     * Starts a single wallet instance.
+     * @returns {Promise<MidnightWalletProvider>} A promise that resolves to the started wallet
+     * @throws {Error} If no wallet could be started
+     */
+    getMidnightWalletProvider: () => Promise<MidnightWalletProvider$1>;
+    /**
+     * Shuts down the test environment and cleans up resources.
+     * @param {boolean} [saveWalletState] - Optional flag to save the wallet state before shutdown
+     * @returns {Promise<void>} A promise that resolves when shutdown is complete
+     */
+    abstract shutdown(saveWalletState?: boolean): Promise<void>;
+    /**
+     * Start the test environment.
+     *
+     * @param maybeProofServerContainer If defined, a container representing an already
+     *                                  running proof server. If undefined, a proof server
+     *                                  will be started automatically.
+     * @returns {Promise<EnvironmentConfiguration>} A promise that resolves to the environment configuration
+     */
+    abstract start(maybeProofServerContainer?: ProofServerContainer$1): Promise<EnvironmentConfiguration>;
+    /**
+     * Starts multiple wallet instances.
+     * @param {number} [amount] - Optional number of wallet instances to start
+     * @param {string[]} [seeds] - Optional array of seeds for the wallets
+     * @returns {Promise<MidnightWalletProvider[]>} A promise that resolves to an array of started wallets
+     */
+    abstract startMidnightWalletProviders(amount?: number, seeds?: string[]): Promise<MidnightWalletProvider$1[]>;
+    abstract getEnvironmentConfiguration(): EnvironmentConfiguration;
+}
+
+/**
+ * Base class for remote test environments that connect to external network services.
+ * Provides functionality for managing walletProviders and a proof server container.
+ */
+declare abstract class RemoteTestEnvironment extends TestEnvironment {
+    protected proofServerContainer: ProofServerContainer$1;
+    private environmentConfiguration;
+    private walletProviders;
+    /**
+     * Abstract method that must be implemented by subclasses to provide environment configuration.
+     * @returns {EnvironmentConfiguration} Configuration object containing service URLs and endpoints
+     */
+    abstract getEnvironmentConfiguration(): EnvironmentConfiguration$1;
+    /**
+     * Creates and starts the specified number of wallet providers.
+     * @returns {Promise<MidnightWalletProvider[]>} Array of started wallet providers
+     */
+    startMidnightWalletProviders: (amount?: number, seeds?: string[] | undefined) => Promise<MidnightWalletProvider$1[]>;
+    /**
+     * Shuts down the test environment by closing all walletProviders and stopping the proof server.
+     */
+    shutdown: (saveWalletState?: boolean) => Promise<void>;
+    /**
+     * Performs a health check for the environment.
+     * Checks the health of the node, indexer, and optionally the faucet services.
+     * @returns {Promise<void>} A promise that resolves when the health check is complete.
+     */
+    healthCheck: () => Promise<void>;
+    /**
+     * Starts the test environment by initializing the proof server and environment configuration.
+     * @param {ProofServerContainer} maybeProofServerContainer Optional proof server container to use instead of creating a new one
+     * @returns {Promise<EnvironmentConfiguration>} The environment configuration
+     */
+    start: (maybeProofServerContainer?: ProofServerContainer$1) => Promise<EnvironmentConfiguration$1>;
+}
+
+/**
+ * Test environment that configures services using environment variables.
+ * Allows specifying custom endpoints through environment variables.
+ */
+declare class EnvVarRemoteTestEnvironment extends RemoteTestEnvironment {
+    /**
+     * Returns the configuration for environment services based on environment variables.
+     * Required environment variables:
+     * - MN_TEST_NETWORK_ID: Network identifier (e.g., 'testnet', 'devnet')
+     * - MN_TEST_INDEXER: GraphQL API endpoint for the indexer
+     * - MN_TEST_INDEXER_WS: WebSocket endpoint for the indexer
+     * - MN_TEST_NODE: RPC endpoint for the blockchain node
+     * Optional environment variables:
+     * - MN_TEST_FAUCET: API endpoint for requesting test tokens
+     * @returns {EnvironmentConfiguration} Object containing service URLs from environment variables
+     * @throws {MissingEnvironmentVariable} If any required environment variable is not set
+     */
+    getEnvironmentConfiguration(): EnvironmentConfiguration$1;
+}
+
+/**
+ * Configuration for component ports in the local test environment
+ */
+type ComponentPortsConfiguration = {
+    indexer: number;
+    node: number;
+    proofServer: number;
+};
+/**
+ * Configuration class for local test environment implementing EnvironmentConfiguration
+ */
+declare class LocalTestConfiguration implements EnvironmentConfiguration$1 {
+    readonly walletNetworkId: NetworkId.NetworkId;
+    readonly networkId: string;
+    readonly indexer: string;
+    readonly indexerWS: string;
+    readonly node: string;
+    readonly nodeWS: string;
+    readonly proofServer: string;
+    readonly faucet: string | undefined;
+    /**
+     * Creates a new LocalTestConfiguration instance
+     * @param {ComponentPortsConfiguration} ports - Object containing port numbers for each component
+     */
+    constructor({ indexer, node, proofServer }: ComponentPortsConfiguration);
+}
+/**
+ * Test environment for local development using Docker containers
+ * Manages containers for node, indexer and proof server components
+ */
+declare class LocalTestEnvironment extends TestEnvironment {
+    static readonly MAX_NUMBER_OF_WALLETS = 4;
+    readonly genesisMintWalletSeed: string[];
+    private config;
+    private environmentConfiguration;
+    dockerEnv: StartedDockerComposeEnvironment;
+    private walletProviders;
+    /**
+     * Creates a new LocalTestEnvironment instance
+     * @param {Logger} logger - Logger instance for recording operations
+     */
+    constructor(logger: Logger);
+    /**
+     * Returns the configuration for the testnet environment services.
+     * @returns {EnvironmentConfiguration} Object containing URLs for testnet services:
+     * - indexer: GraphQL API endpoint for the indexer
+     * - indexerWS: WebSocket endpoint for the indexer
+     * - node: RPC endpoint for the blockchain node
+     * - faucet: API endpoint for requesting test tokens
+     * - proofServer: URL for the proof generation server
+     */
+    getEnvironmentConfiguration(): EnvironmentConfiguration$1;
+    /**
+     * Gets the mapped ports for all containers in the environment
+     * @returns {ComponentPortsConfiguration} Object containing mapped port numbers
+     * @private
+     */
+    private getMappedPorts;
+    /**
+     * Instead of starting the test environment by building the docker containers
+     * from the default configuration files in this package, start the test environment
+     * by passing an existing {@link StartedDockerComposeEnvironment} along with the
+     * ports for the containers in the environment.
+     *
+     * @param {StartedDockerComposeEnvironment} dockerEnv - A started docker compose environment
+     * @param {ComponentPortsConfiguration} ports - The ports of the containers in the given environment
+     * @returns {Promise<EnvironmentConfiguration>} The environment configuration
+     */
+    startWithInjectedEnvironment: (dockerEnv: StartedDockerComposeEnvironment, ports: ComponentPortsConfiguration) => Promise<EnvironmentConfiguration$1>;
+    /**
+     * Starts the test environment by creating and configuring Docker containers
+     * @param {ProofServerContainer} maybeProofServerContainer - Optional proof server container
+     * @returns {Promise<EnvironmentConfiguration>} The environment configuration
+     * @throws {Error} If trying to inject proof server container when starting new environment
+     */
+    start: (maybeProofServerContainer?: ProofServerContainer$1) => Promise<EnvironmentConfiguration$1>;
+    /**
+     * Shuts down the test environment, closing walletProviders and stopping containers
+     * @returns {Promise<void>}
+     */
+    shutdown: (saveWalletState?: boolean) => Promise<void>;
+    /**
+     * Creates and starts the specified number of wallet providers
+     * @throws {Error} If requested amount exceeds maximum supported walletProviders
+     * @returns {Promise<MidnightWalletProvider[]>} A promise that resolves to an array of started wallets
+     */
+    startMidnightWalletProviders: (amount?: number, seeds?: string[] | undefined) => Promise<MidnightWalletProvider$1[]>;
+}
+
+/**
+ * Test environment configuration for the Midnight QA network.
+ * Provides URLs and endpoints for QA network services.
+ */
+declare class QanetTestEnvironment extends RemoteTestEnvironment {
+    /**
+     * Returns the configuration for the QA network environment services.
+     * @returns {EnvironmentConfiguration} Object containing URLs for QA network services:
+     * - indexer: GraphQL API endpoint for the indexer
+     * - indexerWS: WebSocket endpoint for the indexer
+     * - node: RPC endpoint for the blockchain node
+     * - faucet: API endpoint for requesting test tokens
+     * - proofServer: URL for the proof generation server
+     */
+    getEnvironmentConfiguration(): EnvironmentConfiguration$1;
+}
+
+/**
+ * Test environment configuration for the Midnight testnet network.
+ * Provides URLs and endpoints for testnet services.
+ */
+declare class Testnet2TestEnvironment extends RemoteTestEnvironment {
+    /**
+     * Returns the configuration for the testnet environment services.
+     * @returns {EnvironmentConfiguration} Object containing URLs for testnet services:
+     * - indexer: GraphQL API endpoint for the indexer
+     * - indexerWS: WebSocket endpoint for the indexer
+     * - node: RPC endpoint for the blockchain node
+     * - faucet: API endpoint for requesting test tokens
+     * - proofServer: URL for the proof generation server
+     */
+    getEnvironmentConfiguration(): EnvironmentConfiguration$1;
+}
+
+declare const MINUTE = 60000;
+/**
+ * Creates a Promise that resolves after a specified delay.
+ * @param ms The delay duration in milliseconds.
+ * @returns A Promise that resolves after the specified delay.
+ * @example
+ * // Wait for 1 second
+ * await delay(1000);
+ */
+declare const delay: (ms: number) => Promise<unknown>;
+/**
+ * Deletes a directory and its contents recursively.
+ * @param {string} dirPath - The path to the directory to delete
+ * @returns {Promise<void>} A promise that resolves when the directory is deleted
+ * @private
+ */
+declare const deleteDirectory: (dirPath: string) => Promise<void>;
+declare const extractHostnameAndPort: (url: string) => string;
+
+declare global {
+    interface BigInt {
+        toJSON(): number;
+    }
+}
+
+declare class FluentWalletBuilder {
+    private readonly config;
+    private readonly networkId;
+    private seeds?;
+    private dustOptions;
+    private constructor();
+    static forEnvironment(envConfig: EnvironmentConfiguration$2): FluentWalletBuilder;
+    withSeed(seed: string): FluentWalletBuilder;
+    withRandomSeed(): FluentWalletBuilder;
+    withDustOptions(options: DustWalletOptions$1): FluentWalletBuilder;
+    build(): Promise<WalletFacade>;
+    buildWithoutStarting(): Promise<{
+        wallet: WalletFacade;
+        seeds: WalletSeeds$1;
+        keystore: UnshieldedKeystore;
+    }>;
+}
+
+/**
+ * A class for compressing and decompressing files using gzip.
+ */
+declare class GzipFile {
+    /** The path to the input file */
+    inputFile: string;
+    /** The path to the output file */
+    outputFile: string;
+    /**
+     * Creates a new GzipFile instance.
+     * @param inputFile - The path to the input file to compress/decompress
+     * @param outputFile - The path where the compressed file will be saved
+     */
+    constructor(inputFile: string, outputFile: string);
+    /**
+     * Compresses the input file using gzip compression.
+     * @returns A promise that resolves when compression is complete
+     * @throws If there is an error during compression
+     */
+    compress: () => Promise<void>;
+    /**
+     * Decompresses the input gzip file and returns its contents as a string.
+     * @returns A promise that resolves with the decompressed file contents as a string
+     * @throws If there is an error during decompression
+     */
+    decompress: () => Promise<string>;
+}
+
+/**
+ * Provider class that implements wallet functionality for the Midnight network.
+ * Handles transaction balancing, submission, and wallet state management.
+ */
+declare class MidnightWalletProvider implements MidnightProvider, WalletProvider {
+    logger: Logger;
+    readonly env: EnvironmentConfiguration$3;
+    readonly wallet: WalletFacade;
+    readonly unshieldedKeystore: UnshieldedKeystore;
+    readonly zswapSecretKeys: ZswapSecretKeys;
+    readonly dustSecretKey: DustSecretKey;
+    private constructor();
+    getCoinPublicKey(): CoinPublicKey;
+    getEncryptionPublicKey(): EncPublicKey;
+    balanceTx(tx: UnboundTransaction, _newCoins: ShieldedCoinInfo[], ttl?: Date): Promise<FinalizedTransaction>;
+    submitTx(tx: FinalizedTransaction): Promise<string>;
+    start(waitForFundsInWallet?: boolean, tokenType?: TokenType): Promise<void>;
+    stop(): Promise<void>;
+    static build(logger: Logger, env: EnvironmentConfiguration$3, seed?: string | undefined): Promise<MidnightWalletProvider>;
+    static withWallet(logger: Logger, env: EnvironmentConfiguration$3, wallet: WalletFacade, zswapSecretKeys: ZswapSecretKeys, dustSecretKey: DustSecretKey, unshieldedKeystore: UnshieldedKeystore): Promise<MidnightWalletProvider>;
+}
+
+interface DustWalletOptions {
+    ledgerParams: LedgerParameters;
+    additionalFeeOverhead: bigint;
+    feeBlocksMargin: number;
+}
+declare const DEFAULT_DUST_OPTIONS: DustWalletOptions;
+declare class WalletFactory {
+    static createShieldedWallet(config: DefaultV1Configuration, seed: Uint8Array): ShieldedWallet;
+    static createUnshieldedWallet(config: DefaultV1Configuration, unshieldedKeystore: UnshieldedKeystore): UnshieldedWallet;
+    static createDustWallet(config: DefaultV1Configuration, seed: Uint8Array, dustOptions?: DustWalletOptions): DustWallet;
+    static createWalletFacade(shieldedWallet: ShieldedWallet, unshieldedWallet: UnshieldedWallet, dustWallet: DustWallet): WalletFacade;
+    static startWalletFacade(wallet: WalletFacade, shieldedSeed: Uint8Array, dustSeed: Uint8Array): Promise<WalletFacade>;
+    static restoreShieldedWallet(config: DefaultV1Configuration, serializedState: string): Promise<ShieldedWallet>;
+}
+
+declare const getShieldedSeed: (seed: string) => Uint8Array;
+declare const getUnshieldedSeed: (seed: string) => Uint8Array;
+declare const getDustSeed: (seed: string) => Uint8Array;
+declare class WalletSeeds {
+    readonly masterSeed: string;
+    readonly shielded: Uint8Array;
+    readonly unshielded: Uint8Array;
+    readonly dust: Uint8Array;
+    private constructor();
+    static fromMasterSeed(seed: string): WalletSeeds;
+    static generateRandom(): WalletSeeds;
+}
+
+/** Default directory path for storing wallet state files */
+declare const DEFAULT_WALLET_STATE_DIRECTORY = "./.states";
+/**
+ * Generates a filename for the wallet state file based on environment and optional seed
+ * @returns {string} Generated filename for the wallet state
+ * @param seed
+ */
+declare const getWalletStateFilename: (seed: string | undefined) => string;
+/**
+ * Provider class for saving and loading wallet state to/from compressed files
+ */
+declare class WalletSaveStateProvider {
+    /** Logger instance for recording operations */
+    logger: Logger;
+    /** Absolute path to the directory containing wallet state files */
+    directoryPath: string;
+    /** Full path including filename for the wallet state file */
+    filePath: string;
+    /**
+     * Creates a new WalletSaveStateProvider instance
+     * @param {Logger} logger - Logger instance for recording operations
+     * @param seed
+     * @param {string} [directoryPath=DEFAULT_WALLET_STATE_DIRECTORY] - Directory path for wallet state files
+     * @param {string} [filename] - Filename for the wallet state file
+     */
+    constructor(logger: Logger, seed: string, directoryPath?: string, filename?: string);
+    /**
+     * Saves the wallet state to a compressed file
+     * @param {ShieldedWallet | UnshieldedWallet} wallet - The wallet instance to save state from
+     * @returns {Promise<void>} A promise that resolves when the save is complete
+     */
+    save(wallet: ShieldedWallet | UnshieldedWallet): Promise<void>;
+    /**
+     * Loads and decompresses the wallet state from a file
+     * @returns {Promise<string>} A promise that resolves with the decompressed wallet state as a string
+     * @throws {Error} If there is an error reading or decompressing the file
+     */
+    load(): Promise<string>;
+}
+
+declare const getInitialState: (wallet: ShieldedWallet | UnshieldedWallet) => Promise<ShieldedWalletState | UnshieldedWalletState>;
+declare const getInitialShieldedState: (wallet: ShieldedWallet) => Promise<ShieldedWalletState>;
+declare const getInitialUnshieldedState: (wallet: UnshieldedWallet) => Promise<UnshieldedWalletState>;
+declare const syncWallet: (wallet: WalletFacade, throttleTime?: number, timeout?: number) => Promise<_midnight_ntwrk_wallet_sdk_facade.FacadeState>;
+declare const waitForFunds: (wallet: WalletFacade, env: EnvironmentConfiguration$3, tokenType?: TokenType, fundFromFaucet?: boolean) => Promise<bigint | _midnight_ntwrk_wallet_sdk_facade.FacadeState>;
+
+export { DEFAULT_DUST_OPTIONS, DEFAULT_WALLET_STATE_DIRECTORY, DynamicProofServerContainer, EnvVarRemoteTestEnvironment, FaucetClient, FluentWalletBuilder, GzipFile, IndexerClient, LocalTestConfiguration, LocalTestEnvironment, MINUTE, MidnightWalletProvider, NodeClient, ProofServerClient, QanetTestEnvironment, RemoteTestEnvironment, StaticProofServerContainer, TestEnvironment, Testnet2TestEnvironment, WalletFactory, WalletSaveStateProvider, WalletSeeds, createDefaultTestLogger, createLogger, defaultContainersConfiguration, delay, deleteDirectory, expectFoundAndDeployedStatesEqual, expectFoundAndDeployedTxDataEqual, expectFoundAndDeployedTxPrivateDataEqual, expectFoundAndDeployedTxPublicDataEqual, expectSuccessfulCallTx, expectSuccessfulDeployTx, expectSuccessfulTxData, extractHostnameAndPort, getContainersConfiguration, getDustSeed, getInitialShieldedState, getInitialState, getInitialUnshieldedState, getShieldedSeed, getTestEnvironment, getUnshieldedSeed, getWalletStateFilename, inMemoryPrivateStateProvider, initializeMidnightProviders, latestContainersConfiguration, logger, setContainersConfiguration, stateValueEqual, syncWallet, txsEqual, waitForFunds };
+export type { ComponentPortsConfiguration, ContainerEndpoints, ContainersConfiguration, ContractConfiguration, DustWalletOptions, EnvironmentConfiguration, LogConfiguration, ProofServerContainer, ProofServerContainerConfiguration, StandaloneContainerNames, StandaloneContainersConfiguration };