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

package/dist/index.cjs

@@ -0,0 +1,2067 @@
+'use strict';
+
+var midnightJsTypes = require('@midnight-ntwrk/midnight-js-types');
+var axios = require('axios');
+var promises = require('node:fs/promises');
+var path = require('path');
+var path$1 = require('node:path');
+var pino = require('pino');
+var pinoPretty = require('pino-pretty');
+var testcontainers = require('testcontainers');
+var ledgerV7 = require('@midnight-ntwrk/ledger-v7');
+var midnightJsNetworkId = require('@midnight-ntwrk/midnight-js-network-id');
+var midnightJsHttpClientProofProvider = require('@midnight-ntwrk/midnight-js-http-client-proof-provider');
+var midnightJsIndexerPublicDataProvider = require('@midnight-ntwrk/midnight-js-indexer-public-data-provider');
+var midnightJsLevelPrivateStateProvider = require('@midnight-ntwrk/midnight-js-level-private-state-provider');
+var midnightJsNodeZkConfigProvider = require('@midnight-ntwrk/midnight-js-node-zk-config-provider');
+var walletSdkUnshieldedWallet = require('@midnight-ntwrk/wallet-sdk-unshielded-wallet');
+var walletSdkDustWallet = require('@midnight-ntwrk/wallet-sdk-dust-wallet');
+var walletSdkFacade = require('@midnight-ntwrk/wallet-sdk-facade');
+var walletSdkShielded = require('@midnight-ntwrk/wallet-sdk-shielded');
+var walletSdkHd = require('@midnight-ntwrk/wallet-sdk-hd');
+var node_zlib = require('node:zlib');
+var fs = require('fs');
+var midnightJsUtils = require('@midnight-ntwrk/midnight-js-utils');
+var Rx = require('rxjs');
+var fs$1 = require('node:fs');
+var walletSdkAbstractions = require('@midnight-ntwrk/wallet-sdk-abstractions');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path$1);
+var Rx__namespace = /*#__PURE__*/_interopNamespaceDefault(Rx);
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const stateValueEqual = (a, b) => {
+    return a.toString(false) === b.toString(false);
+};
+const txsEqual = (a, b) => {
+    return a.toString(false) === b.toString(false);
+};
+const expectFoundAndDeployedTxPublicDataEqual = (deployTxData, foundDeployTxData) => {
+    expect(stateValueEqual(deployTxData.public.initialContractState.data.state, foundDeployTxData.public.initialContractState.data.state)).toBeTruthy();
+    expect(deployTxData.public.contractAddress).toEqual(foundDeployTxData.public.contractAddress);
+    expect(deployTxData.public.blockHash).toEqual(foundDeployTxData.public.blockHash);
+    expect(deployTxData.public.blockHeight).toEqual(foundDeployTxData.public.blockHeight);
+    expect(deployTxData.public.txHash).toEqual(foundDeployTxData.public.txHash);
+    expect(deployTxData.public.identifiers).toEqual(foundDeployTxData.public.identifiers);
+    expect(deployTxData.public.status).toEqual(foundDeployTxData.public.status);
+    expect(txsEqual(deployTxData.public.tx, foundDeployTxData.public.tx)).toBeTruthy();
+};
+const expectFoundAndDeployedTxPrivateDataEqual = (deployTxData, foundDeployTxData) => {
+    // For our purposes, we always find with the same private state that the contract is deployed with
+    // so this comparison is justified.
+    expect(deployTxData.private.initialPrivateState).toEqual(foundDeployTxData.private.initialPrivateState);
+};
+const expectFoundAndDeployedTxDataEqual = (deployTxData, foundDeployTxData) => {
+    expectFoundAndDeployedTxPublicDataEqual(deployTxData, foundDeployTxData);
+    expectFoundAndDeployedTxPrivateDataEqual(deployTxData, foundDeployTxData);
+};
+const expectFoundAndDeployedStatesEqual = async (providers, deployTxData, foundDeployTxData, privateStateId, initialPrivateState) => {
+    const deployedLedgerState = await providers.publicDataProvider.queryContractState(deployTxData.public.contractAddress);
+    expect(deployedLedgerState).toBeDefined();
+    expect(stateValueEqual(deployedLedgerState.data.state, foundDeployTxData.public.initialContractState.data.state)).toBeTruthy();
+    if (privateStateId) {
+        const privateState = await providers.privateStateProvider.get(privateStateId);
+        expect(privateState).toEqual(foundDeployTxData.private.initialPrivateState);
+        if (initialPrivateState !== undefined) {
+            expect(privateState).toEqual(initialPrivateState);
+        }
+    }
+};
+const expectSuccessfulTxData = (finalizedTxData) => {
+    expect(finalizedTxData.status).toEqual(midnightJsTypes.SucceedEntirely);
+    expect(finalizedTxData.tx).toBeTruthy();
+    expect(finalizedTxData.txId).toBeTruthy();
+    expect(finalizedTxData.txHash).toBeTruthy();
+    expect(finalizedTxData.blockHeight).toBeTruthy();
+    expect(finalizedTxData.blockHash).toBeTruthy();
+};
+const expectSuccessfulDeployTx = async (providers, deployTxData, deployTxOptions) => {
+    expectSuccessfulTxData(deployTxData.public);
+    expect(deployTxData.public.contractAddress).toBeTruthy();
+    const deployedLedgerState = await providers.publicDataProvider.queryContractState(deployTxData.public.contractAddress);
+    expect(stateValueEqual(deployTxData.public.initialContractState.data.state, deployedLedgerState.data.state));
+    expect(deployTxData.public.initialContractState).toBeTruthy();
+    // Checks that the signing key and private state passed in the deploy configuration
+    // were stored correctly.
+    if (deployTxOptions) {
+        if (deployTxOptions.signingKey) {
+            expect(deployTxData.private.signingKey).toEqual(deployTxOptions.signingKey);
+            const storedSigningKey = await providers.privateStateProvider.getSigningKey(deployTxData.public.contractAddress);
+            expect(storedSigningKey).toBeDefined();
+            expect(storedSigningKey).toEqual(deployTxOptions.signingKey);
+        }
+        // We only test contracts that pass 'initialPrivateState' through the contract constructor unchanged
+        // so this equality comparison is justified.
+        if ('privateStateId' in deployTxOptions && 'initialPrivateState' in deployTxOptions) {
+            expect(deployTxData.private.initialPrivateState).toEqual(deployTxOptions.initialPrivateState);
+            const storedPrivateState = await providers.privateStateProvider.get(deployTxOptions.privateStateId);
+            expect(storedPrivateState).toBeDefined();
+            expect(storedPrivateState).toEqual(deployTxOptions.initialPrivateState);
+        }
+    }
+};
+const expectSuccessfulCallTx = async (providers, callTxData, callTxOptions, nextPrivateState) => {
+    expectSuccessfulTxData(callTxData.public);
+    expect(callTxData.public.nextContractState).toBeTruthy();
+    expect(callTxData.private.nextZswapLocalState);
+    if (callTxOptions) {
+        if ('privateStateId' in callTxOptions) {
+            const storedPrivateState = await providers.privateStateProvider.get(callTxOptions.privateStateId);
+            expect(storedPrivateState).toBeDefined();
+            expect(storedPrivateState).toEqual(callTxData.private.nextPrivateState);
+            if (nextPrivateState) {
+                expect(nextPrivateState).toEqual(callTxData.private.nextPrivateState);
+            }
+        }
+    }
+};
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const currentWorkingDir = path.resolve(`${process.cwd()}`);
+const defaultContainersConfiguration = {
+    proofServer: {
+        path: currentWorkingDir,
+        fileName: 'proof-server.yml',
+        container: {
+            name: 'proof-server',
+            port: 6300,
+            waitStrategy: testcontainers.Wait.forListeningPorts().withStartupTimeout(3 * 60_000)
+        }
+    },
+    standalone: {
+        path: currentWorkingDir,
+        fileName: 'compose.yml',
+        container: {
+            proofServer: {
+                name: 'proof-server',
+                port: 6300,
+                waitStrategy: testcontainers.Wait.forListeningPorts().withStartupTimeout(3 * 60_000)
+            },
+            node: {
+                name: 'node',
+                port: 9944,
+                waitStrategy: testcontainers.Wait.forListeningPorts()
+            },
+            indexer: {
+                name: 'indexer',
+                port: 8088,
+                waitStrategy: testcontainers.Wait.forListeningPorts()
+            }
+        }
+    },
+    log: {
+        fileName: `tests_${new Date().toISOString().replace(/:/g, '_')}.log`,
+        path: path.resolve(currentWorkingDir, 'logs', 'tests'),
+        level: 'info'
+    }
+};
+const latestContainersConfiguration = {
+    ...defaultContainersConfiguration,
+    standalone: {
+        ...defaultContainersConfiguration.standalone,
+        fileName: 'compose-latest.yml'
+    },
+    proofServer: {
+        ...defaultContainersConfiguration.proofServer,
+        fileName: 'proof-server-latest.yml'
+    }
+};
+let containersConfiguration = defaultContainersConfiguration;
+const getContainersConfiguration = () => {
+    return containersConfiguration;
+};
+const setContainersConfiguration = (containersConfig) => {
+    containersConfiguration = containersConfig;
+};
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const { level } = getContainersConfiguration().log;
+function createLogger(fileName, dir = getContainersConfiguration().log.path) {
+    let logPath = path__namespace.resolve(fileName);
+    if (!fileName.includes('/')) {
+        logPath = path__namespace.resolve(dir, fileName);
+    }
+    const prettyStream = pinoPretty({
+        colorize: true,
+        sync: true
+    });
+    const prettyFileStream = pinoPretty({
+        mkdir: true,
+        colorize: false,
+        sync: true,
+        append: true,
+        destination: logPath
+    });
+    return pino({
+        level,
+        depthLimit: 20
+    }, pino.multistream([
+        { stream: prettyStream, level },
+        { stream: prettyFileStream, level }
+    ]));
+}
+function createDefaultTestLogger() {
+    return createLogger(getContainersConfiguration().log.fileName, getContainersConfiguration().log.path);
+}
+const logger = createDefaultTestLogger();
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const MINUTE = 60_000;
+/**
+ * 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);
+ */
+const delay = (ms) => {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+};
+/**
+ * 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
+ */
+const deleteDirectory = async (dirPath) => {
+    try {
+        const resolvedPath = path.resolve(dirPath);
+        await promises.rm(resolvedPath, { recursive: true, force: true });
+        logger.info(`Directory ${resolvedPath} deleted successfully.`);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            logger.error(`Error deleting directory: ${error.message}`);
+        }
+        else {
+            logger.error('Unknown error occurred');
+        }
+    }
+};
+const extractHostnameAndPort = (url) => {
+    const { hostname, port } = new URL(url);
+    if (port !== '') {
+        return `${hostname}:${port}`;
+    }
+    return hostname;
+};
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Client for interacting with the Midnight faucet service.
+ * Provides functionality to request test tokens for wallet addresses.
+ */
+class FaucetClient {
+    faucetUrl;
+    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, logger) {
+        this.faucetUrl = faucetUrl;
+        this.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
+     */
+    async health() {
+        const url = `https://${extractHostnameAndPort(this.faucetUrl)}/api/health`;
+        return axios
+            .get(url, { timeout: 1000 })
+            .then((r) => {
+            this.logger.info(`Connected to faucet ${url}: ${JSON.stringify(r.data)}`);
+            return r;
+        })
+            .catch((error) => {
+            this.logger.warn(`Failed to connect to faucet service at '${url}'`, error);
+        });
+    }
+    /**
+     * 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
+     */
+    async requestTokens(walletAddress) {
+        this.logger.info(`Requesting tokens from '${this.faucetUrl}' for address: '${walletAddress}'`);
+        try {
+            const response = await axios.post(this.faucetUrl, {
+                address: walletAddress,
+                captchaToken: 'XXXX.DUMMY.TOKEN.XXXX'
+            }, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-turnstile-token': process.env.TURNSTILE_HEADER ?? ''
+                }
+            });
+            this.logger.info(`Faucet response: ${response.statusText}`);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.logger.error(`Error requesting tokens: ${error.message}`);
+            }
+            else {
+                this.logger.error(`Error requesting tokens`);
+            }
+        }
+    }
+}
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class IndexerClient {
+    indexerUrl;
+    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, logger) {
+        this.indexerUrl = indexerUrl;
+        this.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.
+     */
+    async health() {
+        const url = `https://${extractHostnameAndPort(this.indexerUrl)}/ready`;
+        return axios
+            .get(url, { timeout: 1000 })
+            .then((r) => {
+            this.logger.info(`Connected to indexer ${url}: ${JSON.stringify(r.data)}`);
+            return r;
+        })
+            .catch((error) => {
+            this.logger.warn(`Failed to connect to indexer at '${url}'`, error);
+        });
+    }
+}
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Client for interacting with a Midnight node's JSON-RPC API
+ */
+class NodeClient {
+    nodeURL;
+    logger;
+    /**
+     * Creates a new NodeClient instance
+     * @param {string} nodeURL - URL of the Midnight node
+     * @param {Logger} logger - Logger instance for recording operations
+     */
+    constructor(nodeURL, logger) {
+        this.nodeURL = nodeURL;
+        this.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.
+     */
+    async health() {
+        const url = `https://${extractHostnameAndPort(this.nodeURL)}/health`;
+        return axios
+            .get(url, { timeout: 1000 })
+            .then((r) => {
+            this.logger.info(`Connected to node ${url}: ${JSON.stringify(r.data)}`);
+            return r;
+        })
+            .catch((error) => {
+            this.logger.warn(`Failed to connect to node at '${url}'`, error);
+        });
+    }
+    /**
+     * Validates response format and throws if unexpected
+     * @param {AxiosResponse} response - Response from node API
+     * @throws {Error} If response format is unexpected
+     * @private
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static throwOnUnexpected(response) {
+        if (typeof response.data !== 'object' || !response.data.result || typeof response.data.result !== 'string') {
+            throw new Error(`Unexpected response format: ${JSON.stringify(response.data)}`);
+        }
+    }
+    /**
+     * 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
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async jsonRPC(method, params) {
+        const response = await axios.post(this.nodeURL, {
+            id: 1,
+            jsonrpc: '2.0',
+            method,
+            params
+        }, {
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+        this.logger.info(`Node response: ${response.statusText}`);
+        NodeClient.throwOnUnexpected(response);
+        return response.data.result;
+    }
+    /**
+     * Fetches the state of a contract
+     * @param {ContractAddress} contractAddress - Address of the contract
+     * @returns {Promise<ContractState | null>} Contract state or null if not found
+     */
+    async contractState(contractAddress) {
+        this.logger.info(`Fetching contract state for address '${contractAddress}'`);
+        const result = await this.jsonRPC('midnight_contractState', [
+            `${midnightJsNetworkId.getNetworkId()}${contractAddress}`
+        ]);
+        return result === '' ? null : ledgerV7.ContractState.deserialize(Buffer.from(result, 'hex'));
+    }
+    /**
+     * Fetches the ledger state at a given block
+     * @param {BlockHash} blockHash - Hash of the block
+     * @returns {Promise<LedgerState>} Ledger state
+     */
+    async ledgerState(blockHash) {
+        const blob = await this.ledgerStateBlob(blockHash);
+        return ledgerV7.LedgerState.deserialize(blob);
+    }
+    /**
+     * 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
+     */
+    async ledgerStateBlob(blockHash) {
+        this.logger.info(`Fetching ledger state at block hash '${blockHash}'`);
+        const result = await this.jsonRPC('midnight_getLedgerState', []);
+        if (result === '') {
+            throw new Error(`No ledger state found at block hash '${blockHash}'`);
+        }
+        return Buffer.from(result.slice(4), 'hex');
+    }
+    /**
+     * 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
+     */
+    async ledgerVersion(blockHash) {
+        this.logger.info(`Fetching ledger version at block hash '${blockHash}'`);
+        const result = await this.jsonRPC('midnight_ledgerVersion', []);
+        if (result === '') {
+            throw new Error(`No ledger version found at block hash '${blockHash}'`);
+        }
+        return result;
+    }
+}
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class ProofServerClient {
+    proofServer;
+    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, logger) {
+        this.proofServer = proofServer;
+        this.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.
+     */
+    async health() {
+        const url = `http://${extractHostnameAndPort(this.proofServer)}/health`;
+        return axios
+            .get(url, { timeout: 1000 })
+            .then((r) => {
+            this.logger.info(`Connected to proof server ${url}: ${JSON.stringify(r.data)}`);
+            return r;
+        })
+            .catch((error) => {
+            this.logger.warn(`Failed to connect to proof server at '${url}'`, error);
+        });
+    }
+    /**
+     * Proves a transaction by sending a POST request to the proof server.
+     * @param data serialized transaction data
+     * @param config Axios request configuration
+     */
+    async proveTx(data, config = {
+        timeout: 3 * 60_000
+    }) {
+        const url = `http://${extractHostnameAndPort(this.proofServer)}/prove-tx`;
+        return axios
+            .post(url, data, config)
+            .then((r) => {
+            this.logger.info(`Received data from proof server ${url}`);
+            return r;
+        })
+            .catch((error) => {
+            this.logger.error(`Error in proof server at '${url}' ${error.toString()}`);
+        });
+    }
+}
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * 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.
+ */
+const inMemoryPrivateStateProvider = () => {
+    const record = new Map();
+    const signingKeys = {};
+    return {
+        /**
+         * Sets the private state for a given key.
+         * @param {PSI} key - The key for the private state.
+         * @param {PS} state - The private state to set.
+         * @returns {Promise<void>} A promise that resolves when the state is set.
+         */
+        set(key, state) {
+            record.set(key, state);
+            return Promise.resolve();
+        },
+        /**
+         * Gets the private state for a given key.
+         * @param {PSI} key - The key for the private state.
+         * @returns {Promise<PS | null>} A promise that resolves to the private state or null if not found.
+         */
+        get(key) {
+            const value = record.get(key) ?? null;
+            return Promise.resolve(value);
+        },
+        /**
+         * Removes the private state for a given key.
+         * @param {PSI} key - The key for the private state.
+         * @returns {Promise<void>} A promise that resolves when the state is removed.
+         */
+        remove(key) {
+            record.delete(key);
+            return Promise.resolve();
+        },
+        /**
+         * Clears all private states.
+         * @returns {Promise<void>} A promise that resolves when all states are cleared.
+         */
+        clear() {
+            record.clear();
+            return Promise.resolve();
+        },
+        /**
+         * Sets the signing key for a given contract address.
+         * @param {ContractAddress} contractAddress - The contract address.
+         * @param {SigningKey} signingKey - The signing key to set.
+         * @returns {Promise<void>} A promise that resolves when the signing key is set.
+         */
+        setSigningKey(contractAddress, signingKey) {
+            signingKeys[contractAddress] = signingKey;
+            return Promise.resolve();
+        },
+        /**
+         * Gets the signing key for a given contract address.
+         * @param {ContractAddress} contractAddress - The contract address.
+         * @returns {Promise<SigningKey | null>} A promise that resolves to the signing key or null if not found.
+         */
+        getSigningKey(contractAddress) {
+            const value = signingKeys[contractAddress] ?? null;
+            return Promise.resolve(value);
+        },
+        /**
+         * Removes the signing key for a given contract address.
+         * @param {ContractAddress} contractAddress - The contract address.
+         * @returns {Promise<void>} A promise that resolves when the signing key is removed.
+         */
+        removeSigningKey(contractAddress) {
+            delete signingKeys[contractAddress];
+            return Promise.resolve();
+        },
+        /**
+         * Clears all signing keys.
+         * @returns {Promise<void>} A promise that resolves when all signing keys are cleared.
+         */
+        clearSigningKeys() {
+            Object.keys(signingKeys).forEach((contractAddress) => {
+                delete signingKeys[contractAddress];
+            });
+            return Promise.resolve();
+        }
+    };
+};
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * 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
+ */
+const initializeMidnightProviders = (midnightWalletProvider, environmentConfiguration, contractConfiguration) => {
+    const zkConfigProvider = new midnightJsNodeZkConfigProvider.NodeZkConfigProvider(contractConfiguration.zkConfigPath);
+    return {
+        privateStateProvider: midnightJsLevelPrivateStateProvider.levelPrivateStateProvider({
+            privateStateStoreName: contractConfiguration.privateStateStoreName,
+            signingKeyStoreName: `${contractConfiguration.privateStateStoreName}-signing-keys`,
+            privateStoragePasswordProvider: () => { return 'key-just-for-testing-here!'; }
+        }),
+        publicDataProvider: midnightJsIndexerPublicDataProvider.indexerPublicDataProvider(environmentConfiguration.indexer, environmentConfiguration.indexerWS),
+        zkConfigProvider,
+        proofProvider: midnightJsHttpClientProofProvider.httpClientProofProvider(environmentConfiguration.proofServer, zkConfigProvider),
+        walletProvider: midnightWalletProvider,
+        midnightProvider: midnightWalletProvider
+    };
+};
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * A proof server container that is started and stopped dynamically by the test
+ * suite on random port.
+ */
+class DynamicProofServerContainer {
+    /** The Docker Compose environment running the container */
+    dockerEnv;
+    /** Unique identifier for the container instance */
+    uid;
+    /** Configuration for the proof server container */
+    config;
+    /**
+     * Creates a new DynamicProofServerContainer instance.
+     * @param {StartedDockerComposeEnvironment} dockerEnv - The started Docker Compose environment
+     * @param {string} uid - Unique identifier for the container
+     * @private
+     */
+    constructor(dockerEnv, uid) {
+        this.dockerEnv = dockerEnv;
+        this.uid = uid;
+        this.config = getContainersConfiguration().proofServer;
+    }
+    /**
+     * 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 async start(logger, maybeUID, maybeNetworkId) {
+        const config = getContainersConfiguration().proofServer;
+        const uid = maybeUID ?? Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString();
+        const networkId = maybeNetworkId;
+        logger.info(`Starting proof server: path='${config.path}', file=${config.fileName}, networkId=${networkId}, uid=${uid}`);
+        const dockerEnv = await new testcontainers.DockerComposeEnvironment(config.path, config.fileName)
+            .withWaitStrategy(`${config.container.name}_${uid}`, config.container.waitStrategy)
+            .withEnvironment({
+            TESTCONTAINERS_UID: uid,
+            NETWORK_ID: networkId ?? 'undeployed'
+        })
+            .up();
+        return new DynamicProofServerContainer(dockerEnv, uid);
+    }
+    /**
+     * Stops the proof server container.
+     * @returns {Promise<void>} A promise that resolves when the container is stopped
+     */
+    async stop() {
+        await this.dockerEnv.stop();
+    }
+    /**
+     * Gets the mapped port number for the container.
+     * @returns {number} The mapped port number
+     */
+    getMappedPort() {
+        return this.dockerEnv
+            .getContainer(`${this.config.container.name}_${this.uid}`)
+            .getMappedPort(this.config.container.port);
+    }
+    /**
+     * Gets the URL where the proof server can be accessed.
+     * @returns {string} The URL of the proof server
+     */
+    getUrl() {
+        return `http://localhost:${this.getMappedPort()}`;
+    }
+}
+/**
+ * A proof server that is currently running on a specific port.
+ * Used for connecting to an existing proof server instance.
+ */
+class StaticProofServerContainer {
+    /** The port number where the proof server is running */
+    port;
+    /**
+     * Creates a new StaticProofServerContainer instance.
+     * @param {number} port - The port number where the proof server is running (default: 6300)
+     */
+    constructor(port = 6300) {
+        this.port = port;
+    }
+    /**
+     * Gets the URL where the proof server can be accessed.
+     * @returns {string} The URL of the proof server
+     */
+    getUrl() {
+        return `http://localhost:${this.port}`;
+    }
+    /**
+     * No-op stop method since this represents an external proof server.
+     * @returns {Promise<void>} A resolved promise
+     */
+    stop() {
+        return Promise.resolve(undefined);
+    }
+}
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const getEnvVarEnvironment = () => {
+    if (process.env.MN_TEST_ENVIRONMENT === undefined || process.env.MN_TEST_ENVIRONMENT === 'undefined') {
+        return 'undeployed';
+    }
+    return process.env.MN_TEST_ENVIRONMENT;
+};
+const getEnvVarWalletSeeds = () => {
+    const envSeeds = process.env.MN_TEST_WALLET_SEED || process.env.TEST_WALLET_SEED;
+    return envSeeds ? envSeeds.split(',') : undefined;
+};
+const MN_TEST_INDEXER = process.env.MN_TEST_INDEXER;
+const MN_TEST_INDEXER_WS = process.env.MN_TEST_INDEXER_WS;
+const MN_TEST_NODE = process.env.MN_TEST_NODE;
+const MN_TEST_NODE_WS = process.env.MN_TEST_NODE_WS;
+const MN_TEST_FAUCET = process.env.MN_TEST_FAUCET;
+const MN_TEST_NETWORK_ID = process.env.MN_TEST_NETWORK_ID;
+const MN_TEST_WALLET_NETWORK_ID = process.env.MN_TEST_WALLET_NETWORK_ID;
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * An error representing a required, but missing, environment variable.
+ */
+class MissingEnvironmentVariable extends Error {
+    environmentVariable;
+    /**
+     * @param environmentVariable The name of the missing environment variable.
+     */
+    constructor(environmentVariable) {
+        super(`Environment variable '${environmentVariable}' is required`);
+        this.environmentVariable = environmentVariable;
+    }
+}
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+BigInt.prototype.toJSON = function () {
+    return Number(this);
+};
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function mapEnvironmentToConfiguration(env) {
+    return {
+        indexerClientConnection: {
+            indexerHttpUrl: env.indexer,
+            indexerWsUrl: env.indexerWS,
+        },
+        provingServerUrl: new URL(env.proofServer),
+        relayURL: new URL(env.nodeWS),
+        networkId: env.walletNetworkId,
+    };
+}
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const DEFAULT_DUST_OPTIONS = {
+    ledgerParams: ledgerV7.LedgerParameters.initialParameters(),
+    additionalFeeOverhead: 500000000000000000000n,
+    feeBlocksMargin: 5
+};
+class WalletFactory {
+    static createShieldedWallet(config, seed) {
+        const Shielded = walletSdkShielded.ShieldedWallet(config);
+        return Shielded.startWithShieldedSeed(seed);
+    }
+    static createUnshieldedWallet(config, unshieldedKeystore) {
+        return walletSdkUnshieldedWallet.UnshieldedWallet({
+            ...config,
+            txHistoryStorage: new walletSdkUnshieldedWallet.InMemoryTransactionHistoryStorage(),
+        }).startWithPublicKey(walletSdkUnshieldedWallet.PublicKey.fromKeyStore(unshieldedKeystore));
+    }
+    static createDustWallet(config, seed, dustOptions = DEFAULT_DUST_OPTIONS) {
+        const dustConfig = {
+            ...config,
+            costParameters: {
+                ledgerParams: dustOptions.ledgerParams,
+                additionalFeeOverhead: dustOptions.additionalFeeOverhead,
+                feeBlocksMargin: dustOptions.feeBlocksMargin,
+            },
+        };
+        logger.info(`Creating dust wallet with params: ${JSON.stringify(dustConfig)}`);
+        const Dust = walletSdkDustWallet.DustWallet(dustConfig);
+        const dustParameters = ledgerV7.LedgerParameters.initialParameters().dust;
+        return Dust.startWithSeed(seed, dustParameters);
+    }
+    static createWalletFacade(shieldedWallet, unshieldedWallet, dustWallet) {
+        return new walletSdkFacade.WalletFacade(shieldedWallet, unshieldedWallet, dustWallet);
+    }
+    static async startWalletFacade(wallet, shieldedSeed, dustSeed) {
+        logger.info('Starting wallet facade...');
+        await wallet.start(ledgerV7.ZswapSecretKeys.fromSeed(shieldedSeed), ledgerV7.DustSecretKey.fromSeed(dustSeed));
+        return wallet;
+    }
+    static async restoreShieldedWallet(config, serializedState) {
+        return walletSdkShielded.ShieldedWallet(config).restore(serializedState);
+    }
+}
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const deriveKeyForRole = (seed, role, account = 0, keyIndex = 0) => {
+    if (!seed || seed.length === 0) {
+        throw new Error('Seed cannot be empty');
+    }
+    const seedBuffer = Buffer.from(seed, 'hex');
+    const hdWalletResult = walletSdkHd.HDWallet.fromSeed(seedBuffer);
+    if (hdWalletResult.type !== 'seedOk') {
+        throw new Error('Invalid seed: failed to create HD wallet');
+    }
+    const derivationResult = hdWalletResult.hdWallet
+        .selectAccount(account)
+        .selectRole(role)
+        .deriveKeyAt(keyIndex);
+    if (derivationResult.type === 'keyOutOfBounds') {
+        throw new Error(`Key derivation out of bounds for role ${role} at index ${keyIndex}`);
+    }
+    return derivationResult.key;
+};
+const getShieldedSeed = (seed) => {
+    return deriveKeyForRole(seed, walletSdkHd.Roles.Zswap);
+};
+const getUnshieldedSeed = (seed) => {
+    return deriveKeyForRole(seed, walletSdkHd.Roles.NightExternal);
+};
+const getDustSeed = (seed) => {
+    return deriveKeyForRole(seed, walletSdkHd.Roles.Dust);
+};
+class WalletSeeds {
+    masterSeed;
+    shielded;
+    unshielded;
+    dust;
+    constructor(masterSeed, shielded, unshielded, dust) {
+        this.masterSeed = masterSeed;
+        this.shielded = shielded;
+        this.unshielded = unshielded;
+        this.dust = dust;
+    }
+    static fromMasterSeed(seed) {
+        if (!seed || seed.length === 0) {
+            throw new Error('Master seed cannot be empty');
+        }
+        return new WalletSeeds(seed, getShieldedSeed(seed), getUnshieldedSeed(seed), getDustSeed(seed));
+    }
+    static generateRandom() {
+        const randomSeed = Buffer.from(walletSdkHd.generateRandomSeed()).toString('hex');
+        return WalletSeeds.fromMasterSeed(randomSeed);
+    }
+}
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class FluentWalletBuilder {
+    config;
+    networkId;
+    seeds;
+    dustOptions;
+    constructor(config, networkId, seeds, dustOptions = DEFAULT_DUST_OPTIONS) {
+        this.config = config;
+        this.networkId = networkId;
+        this.seeds = seeds;
+        this.dustOptions = dustOptions;
+    }
+    static forEnvironment(envConfig) {
+        if (!envConfig) {
+            throw new Error('Environment configuration is required');
+        }
+        logger.info(`Initializing wallet builder for ${envConfig.walletNetworkId}`);
+        const config = mapEnvironmentToConfiguration(envConfig);
+        return new FluentWalletBuilder(config, envConfig.walletNetworkId);
+    }
+    withSeed(seed) {
+        if (!seed || seed.length === 0) {
+            throw new Error('Seed cannot be empty');
+        }
+        this.seeds = WalletSeeds.fromMasterSeed(seed);
+        return this;
+    }
+    withRandomSeed() {
+        this.seeds = WalletSeeds.generateRandom();
+        logger.info(`Generated random wallet seed: ${this.seeds.masterSeed}`);
+        return this;
+    }
+    withDustOptions(options) {
+        if (!options) {
+            throw new Error('Dust options cannot be null or undefined');
+        }
+        this.dustOptions = options;
+        return this;
+    }
+    async build() {
+        if (!this.seeds) {
+            logger.info('No seed provided, generating random seed');
+            this.seeds = WalletSeeds.generateRandom();
+            logger.info(`Generated random wallet seed: ${this.seeds.masterSeed}`);
+        }
+        logger.info(`Building wallet with configuration: ${JSON.stringify(this.config)}`);
+        const unshieldedKeystore = walletSdkUnshieldedWallet.createKeystore(this.seeds.unshielded, this.networkId);
+        const shieldedWallet = WalletFactory.createShieldedWallet(this.config, this.seeds.shielded);
+        const unshieldedWallet = WalletFactory.createUnshieldedWallet(this.config, unshieldedKeystore);
+        const dustWallet = WalletFactory.createDustWallet(this.config, this.seeds.dust, this.dustOptions);
+        const walletFacade = WalletFactory.createWalletFacade(shieldedWallet, unshieldedWallet, dustWallet);
+        return WalletFactory.startWalletFacade(walletFacade, this.seeds.shielded, this.seeds.dust);
+    }
+    async buildWithoutStarting() {
+        if (!this.seeds) {
+            logger.info('No seed provided, generating random seed');
+            this.seeds = WalletSeeds.generateRandom();
+            logger.info(`Generated random wallet seed: ${this.seeds.masterSeed}`);
+        }
+        logger.info(`Building wallet without starting with configuration: ${JSON.stringify(this.config)}`);
+        const unshieldedKeystore = walletSdkUnshieldedWallet.createKeystore(this.seeds.unshielded, this.networkId);
+        const shieldedWallet = WalletFactory.createShieldedWallet(this.config, this.seeds.shielded);
+        const unshieldedWallet = WalletFactory.createUnshieldedWallet(this.config, unshieldedKeystore);
+        const dustWallet = WalletFactory.createDustWallet(this.config, this.seeds.dust, this.dustOptions);
+        const walletFacade = WalletFactory.createWalletFacade(shieldedWallet, unshieldedWallet, dustWallet);
+        return {
+            wallet: walletFacade,
+            seeds: this.seeds,
+            keystore: unshieldedKeystore
+        };
+    }
+}
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * A class for compressing and decompressing files using gzip.
+ */
+class GzipFile {
+    /** The path to the input file */
+    inputFile;
+    /** The path to the output file */
+    outputFile;
+    /**
+     * 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, outputFile) {
+        this.inputFile = inputFile;
+        this.outputFile = outputFile;
+    }
+    /**
+     * 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 = () => {
+        const gzip = node_zlib.createGzip();
+        const source = fs.createReadStream(this.inputFile);
+        const destination = fs.createWriteStream(this.outputFile);
+        return new Promise((resolve, reject) => {
+            source
+                .pipe(gzip)
+                .pipe(destination)
+                .on('finish', () => {
+                resolve();
+            })
+                .on('error', (err) => {
+                reject(err);
+            });
+        });
+    };
+    /**
+     * 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 = () => {
+        const gunzip = node_zlib.createGunzip();
+        const source = fs.createReadStream(this.inputFile);
+        return new Promise((resolve, reject) => {
+            let data = '';
+            source
+                .pipe(gunzip)
+                .on('data', (chunk) => {
+                data += chunk.toString();
+            })
+                .on('end', () => {
+                resolve(data);
+            })
+                .on('error', (err) => {
+                reject(err);
+            });
+        });
+    };
+}
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const getInitialState = async (wallet) => {
+    if (wallet instanceof walletSdkShielded.ShieldedWallet) {
+        return Rx__namespace.firstValueFrom(wallet.state);
+    }
+    else {
+        return Rx__namespace.firstValueFrom(wallet.state);
+    }
+};
+const getInitialShieldedState = async (wallet) => {
+    logger.info('Getting initial state of wallet...');
+    return Rx__namespace.firstValueFrom(wallet.state);
+};
+const getInitialUnshieldedState = async (wallet) => {
+    logger.info('Getting initial state of wallet...');
+    return Rx__namespace.firstValueFrom(wallet.state);
+};
+const syncWallet = (wallet, throttleTime = 2_000, timeout = 90_000) => {
+    logger.info('Syncing wallet...');
+    return Rx__namespace.firstValueFrom(wallet.state().pipe(Rx__namespace.tap((state) => {
+        logger.info(`Wallet synced state emission: { shielded=${state.shielded.state.progress.isStrictlyComplete()}, unshielded=${state.unshielded.progress.isStrictlyComplete()}, dust=${state.dust.state.progress.isStrictlyComplete()} }`);
+    }), Rx__namespace.throttleTime(throttleTime), Rx__namespace.tap((state) => {
+        const isSynced = state.shielded.state.progress.isStrictlyComplete() &&
+            state.dust.state.progress.isStrictlyComplete() &&
+            state.unshielded.progress?.isStrictlyComplete() === true;
+        logger.info(`Wallet synced state emission (synced=${isSynced}): { shielded=${state.shielded.state.progress.isStrictlyComplete()}, unshielded=${state.unshielded.progress.isStrictlyComplete()}, dust=${state.dust.state.progress.isStrictlyComplete()} }`);
+    }), Rx__namespace.filter((state) => state.shielded.state.progress.isStrictlyComplete() &&
+        state.dust.state.progress.isStrictlyComplete() &&
+        state.unshielded.progress.isStrictlyComplete() === true), Rx__namespace.tap(() => logger.info('Sync complete')), Rx__namespace.tap((state) => {
+        const shieldedBalances = state.shielded.balances || {};
+        const unshieldedBalances = state.unshielded.balances || {};
+        const dustBalances = state.dust.walletBalance(new Date(Date.now())) || {};
+        logger.info(`Wallet balances after sync - Shielded: ${JSON.stringify(shieldedBalances)}, Unshielded: ${JSON.stringify(unshieldedBalances)}, Dust: ${JSON.stringify(dustBalances)}`);
+    }), Rx__namespace.timeout({
+        each: timeout,
+        with: () => Rx__namespace.throwError(() => new Error(`Wallet sync timeout after ${timeout}ms`))
+    })));
+};
+const waitForFunds = async (wallet, env, tokenType = ledgerV7.shieldedToken(), fundFromFaucet = false) => {
+    const initialState = await getInitialShieldedState(wallet.shielded);
+    logger.info(`Your wallet address is: ${initialState.address.coinPublicKeyString()}, waiting for funds...`);
+    if (fundFromFaucet && env.faucet) {
+        logger.info('Requesting tokens from faucet...');
+        await new FaucetClient(env.faucet, logger).requestTokens(initialState.address.coinPublicKeyString());
+    }
+    const initialBalance = initialState.balances[tokenType.tag];
+    if (initialBalance === undefined || initialBalance === 0n) {
+        logger.info(`Your wallet balance is: 0`);
+        logger.info(`Waiting to receive tokens...`);
+        return syncWallet(wallet);
+    }
+    return initialBalance;
+};
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Provider class that implements wallet functionality for the Midnight network.
+ * Handles transaction balancing, submission, and wallet state management.
+ */
+class MidnightWalletProvider {
+    logger;
+    env;
+    wallet;
+    unshieldedKeystore;
+    zswapSecretKeys;
+    dustSecretKey;
+    constructor(logger, environmentConfiguration, wallet, zswapSecretKeys, dustSecretKey, unshieldedKeystore) {
+        this.logger = logger;
+        this.env = environmentConfiguration;
+        this.wallet = wallet;
+        this.zswapSecretKeys = zswapSecretKeys;
+        this.dustSecretKey = dustSecretKey;
+        this.unshieldedKeystore = unshieldedKeystore;
+    }
+    getCoinPublicKey() {
+        return this.zswapSecretKeys.coinPublicKey;
+    }
+    getEncryptionPublicKey() {
+        return this.zswapSecretKeys.encryptionPublicKey;
+    }
+    async balanceTx(tx, _newCoins, ttl = midnightJsUtils.ttlOneHour()) {
+        const bound = tx.bind();
+        const finalizedTransactionRecipe = await this.wallet.balanceFinalizedTransaction(this.zswapSecretKeys, this.dustSecretKey, bound, ttl);
+        finalizedTransactionRecipe.balancingTransaction = await this.wallet.signTransaction(finalizedTransactionRecipe.balancingTransaction, (payload) => this.unshieldedKeystore.signData(payload));
+        return this.wallet.finalizeRecipe(finalizedTransactionRecipe);
+    }
+    submitTx(tx) {
+        return this.wallet.submitTransaction(tx);
+    }
+    async start(waitForFundsInWallet = true, tokenType = ledgerV7.shieldedToken()) {
+        this.logger.info('Starting wallet...');
+        await this.wallet.start(this.zswapSecretKeys, this.dustSecretKey);
+        if (waitForFundsInWallet) {
+            const balance = await waitForFunds(this.wallet, this.env, tokenType, true);
+            this.logger.info(`Your wallet balance is: ${JSON.stringify(balance)}`);
+        }
+    }
+    async stop() {
+        return this.wallet.stop();
+    }
+    static async build(logger, env, seed) {
+        const builder = FluentWalletBuilder.forEnvironment(env);
+        const { wallet, seeds, keystore } = seed
+            ? await builder.withSeed(seed).buildWithoutStarting()
+            : await builder.withRandomSeed().buildWithoutStarting();
+        const initialState = await getInitialShieldedState(wallet.shielded);
+        logger.info(`Your wallet seed is: ${seeds.masterSeed} and your address is: ${initialState.address.coinPublicKeyString()}`);
+        return new MidnightWalletProvider(logger, env, wallet, ledgerV7.ZswapSecretKeys.fromSeed(seeds.shielded), ledgerV7.DustSecretKey.fromSeed(seeds.dust), keystore);
+    }
+    static async withWallet(logger, env, wallet, zswapSecretKeys, dustSecretKey, unshieldedKeystore) {
+        return new MidnightWalletProvider(logger, env, wallet, zswapSecretKeys, dustSecretKey, unshieldedKeystore);
+    }
+}
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/** Default directory path for storing wallet state files */
+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
+ */
+const getWalletStateFilename = (seed) => {
+    if (seed === undefined) {
+        return `wallet.${getEnvVarEnvironment()}.state.gz`;
+    }
+    return `wallet.${getEnvVarEnvironment()}.${seed}.state.gz`;
+};
+/**
+ * Provider class for saving and loading wallet state to/from compressed files
+ */
+class WalletSaveStateProvider {
+    /** Logger instance for recording operations */
+    logger;
+    /** Absolute path to the directory containing wallet state files */
+    directoryPath;
+    /** Full path including filename for the wallet state file */
+    filePath;
+    /**
+     * 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, seed, directoryPath = DEFAULT_WALLET_STATE_DIRECTORY, filename = getWalletStateFilename(seed)) {
+        this.logger = logger;
+        if (!directoryPath.startsWith('/')) {
+            this.directoryPath = `${process.cwd()}/${directoryPath}`;
+        }
+        else {
+            this.directoryPath = directoryPath;
+        }
+        this.filePath = `${this.directoryPath}/${filename}`;
+    }
+    /**
+     * 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
+     */
+    async save(wallet) {
+        this.logger.info(`Saving state in ${this.filePath}`);
+        try {
+            fs$1.mkdirSync(this.directoryPath, { recursive: true });
+            const serializedState = await wallet.serializeState();
+            try {
+                const tempFile = `${this.filePath.replaceAll('.gz', '')}`;
+                fs$1.writeFileSync(tempFile, serializedState);
+                this.logger.info(`File '${tempFile}' written successfully.`);
+                await new GzipFile(tempFile, `${this.filePath.replaceAll('.gz', '')}.gz`).compress();
+                fs$1.rmSync(tempFile);
+                this.logger.info(`File '${this.filePath}' written successfully.`);
+            }
+            catch (err) {
+                this.logger.error(`Error writing file '${this.filePath}': ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        catch (e) {
+            this.logger.warn(e instanceof Error ? e.message : String(e));
+        }
+    }
+    /**
+     * 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
+     */
+    async load() {
+        this.logger.info(`Loading state from ${this.filePath}`);
+        try {
+            return await new GzipFile(this.filePath, `${this.filePath.replaceAll('.gz', '')}.gz`).decompress();
+        }
+        catch (error) {
+            this.logger.error(error instanceof Error ? error.message : String(error));
+            throw error;
+        }
+    }
+}
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Abstract base class for test environments.
+ * Provides common functionality for managing test wallets and environments.
+ */
+class TestEnvironment {
+    /** Logger instance for recording operations */
+    logger;
+    /** Unique identifier for this test environment instance */
+    uid;
+    envConfiguration;
+    /**
+     * Creates a new TestEnvironment instance.
+     * @param {Logger} logger - Logger instance for recording operations
+     */
+    constructor(logger) {
+        this.logger = logger;
+        this.uid = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString();
+    }
+    /**
+     * 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 = async () => {
+        const [walletProvider] = await this.startMidnightWalletProviders();
+        if (!walletProvider) {
+            throw Error('Undefined walletProvider found, but expected to have one');
+        }
+        return walletProvider;
+    };
+}
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Base class for remote test environments that connect to external network services.
+ * Provides functionality for managing walletProviders and a proof server container.
+ */
+class RemoteTestEnvironment extends TestEnvironment {
+    proofServerContainer;
+    environmentConfiguration;
+    walletProviders = undefined;
+    /**
+     * Creates and starts the specified number of wallet providers.
+     * @returns {Promise<MidnightWalletProvider[]>} Array of started wallet providers
+     */
+    startMidnightWalletProviders = async (amount = 1, seeds = getEnvVarWalletSeeds()) => {
+        if (amount > 1 && seeds && seeds.length !== amount) {
+            throw new Error(`Number of seeds provided (${seeds.length}) does not match the amount of wallets requested (${amount})`);
+        }
+        this.logger.info(`Getting ${amount} wallets...`);
+        const buildWallet = (seed) => MidnightWalletProvider.build(this.logger, this.environmentConfiguration, seed);
+        const seeds2 = seeds || Array(amount).fill(undefined);
+        this.walletProviders = await Promise.all(seeds2.map(buildWallet));
+        await Promise.all(this.walletProviders.map((wallet) => wallet.start()));
+        return this.walletProviders;
+    };
+    /**
+     * Shuts down the test environment by closing all walletProviders and stopping the proof server.
+     */
+    shutdown = async (saveWalletState) => {
+        this.logger.info(`Shutting down test environment...`);
+        if (this.walletProviders) {
+            if (saveWalletState) {
+                await Promise.all(this.walletProviders.map((midnightWallet) => new WalletSaveStateProvider(logger, midnightWallet.zswapSecretKeys.coinPublicKey).save(midnightWallet.wallet.shielded)));
+            }
+            await Promise.all(this.walletProviders.map((wallet) => wallet.stop()));
+        }
+        if (this.proofServerContainer) {
+            await this.proofServerContainer.stop();
+        }
+    };
+    /**
+     * 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 = async () => {
+        this.logger.info('Performing env health check');
+        await new NodeClient(this.environmentConfiguration.node, this.logger).health();
+        await new IndexerClient(this.environmentConfiguration.indexer, this.logger).health();
+        await new ProofServerClient(this.environmentConfiguration.proofServer, this.logger).health();
+        if (this.environmentConfiguration.faucet) {
+            await new FaucetClient(this.environmentConfiguration.faucet, this.logger).health();
+        }
+    };
+    /**
+     * 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 = async (maybeProofServerContainer) => {
+        this.logger.info(`Starting test environment... `);
+        this.proofServerContainer =
+            maybeProofServerContainer ?? (await DynamicProofServerContainer.start(this.logger, this.uid));
+        this.environmentConfiguration = this.getEnvironmentConfiguration();
+        this.logger.info(`Test environment configuration: ${JSON.stringify(this.environmentConfiguration)}`);
+        await this.healthCheck();
+        return this.environmentConfiguration;
+    };
+}
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * List of required environment variables that must be set for this test environment
+ */
+const MN_REQUIRED_ENVIRONMENT_VARIABLES = ['MN_TEST_INDEXER', 'MN_TEST_INDEXER_WS', 'MN_TEST_NODE', 'MN_TEST_NODE_WS', 'MN_TEST_NETWORK_ID'];
+/**
+ * Test environment that configures services using environment variables.
+ * Allows specifying custom endpoints through environment variables.
+ */
+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() {
+        // Throw is any of the required MN_* environment variables are missing.
+        MN_REQUIRED_ENVIRONMENT_VARIABLES.forEach((envVar) => {
+            if (!process.env[envVar]) {
+                throw new MissingEnvironmentVariable(envVar);
+            }
+        });
+        return {
+            walletNetworkId: MN_TEST_WALLET_NETWORK_ID,
+            networkId: MN_TEST_NETWORK_ID,
+            indexer: MN_TEST_INDEXER,
+            indexerWS: MN_TEST_INDEXER_WS,
+            node: MN_TEST_NODE,
+            nodeWS: MN_TEST_NODE_WS,
+            faucet: MN_TEST_FAUCET,
+            proofServer: this.proofServerContainer?.getUrl()
+        };
+    }
+}
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Configuration class for local test environment implementing EnvironmentConfiguration
+ */
+class LocalTestConfiguration {
+    walletNetworkId;
+    networkId;
+    indexer;
+    indexerWS;
+    node;
+    nodeWS;
+    proofServer;
+    faucet;
+    /**
+     * Creates a new LocalTestConfiguration instance
+     * @param {ComponentPortsConfiguration} ports - Object containing port numbers for each component
+     */
+    constructor({ indexer, node, proofServer }) {
+        this.walletNetworkId = walletSdkAbstractions.NetworkId.NetworkId.Undeployed;
+        this.networkId = 'undeployed';
+        this.indexer = `http://127.0.0.1:${indexer}/api/v3/graphql`;
+        this.indexerWS = `ws://127.0.0.1:${indexer}/api/v3/graphql/ws`;
+        this.node = `http://127.0.0.1:${node}`;
+        this.nodeWS = `ws://127.0.0.1:${node}`;
+        this.proofServer = `http://127.0.0.1:${proofServer}`;
+        this.faucet = undefined;
+    }
+}
+/**
+ * Test environment for local development using Docker containers
+ * Manages containers for node, indexer and proof server components
+ */
+class LocalTestEnvironment extends TestEnvironment {
+    static MAX_NUMBER_OF_WALLETS = 4;
+    genesisMintWalletSeed = [
+        '0000000000000000000000000000000000000000000000000000000000000002',
+        '0000000000000000000000000000000000000000000000000000000000000001',
+        '0000000000000000000000000000000000000000000000000000000000000003',
+        '0000000000000000000000000000000000000000000000000000000000000004'
+    ];
+    config;
+    environmentConfiguration;
+    dockerEnv;
+    walletProviders;
+    /**
+     * Creates a new LocalTestEnvironment instance
+     * @param {Logger} logger - Logger instance for recording operations
+     */
+    constructor(logger) {
+        super(logger);
+        this.config = getContainersConfiguration().standalone;
+    }
+    /**
+     * 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() {
+        return {
+            walletNetworkId: this.environmentConfiguration?.walletNetworkId,
+            networkId: this.environmentConfiguration?.networkId,
+            indexer: this.environmentConfiguration?.indexer,
+            indexerWS: this.environmentConfiguration?.indexerWS,
+            node: this.environmentConfiguration?.node,
+            nodeWS: this.environmentConfiguration?.nodeWS,
+            faucet: this.environmentConfiguration?.faucet,
+            proofServer: this.environmentConfiguration?.proofServer
+        };
+    }
+    /**
+     * Gets the mapped ports for all containers in the environment
+     * @returns {ComponentPortsConfiguration} Object containing mapped port numbers
+     * @private
+     */
+    getMappedPorts = () => ({
+        indexer: this.dockerEnv
+            .getContainer(`${this.config.container.indexer.name}_${this.uid}`)
+            .getMappedPort(this.config.container.indexer.port),
+        node: this.dockerEnv
+            .getContainer(`${this.config.container.node.name}_${this.uid}`)
+            .getMappedPort(this.config.container.node.port),
+        proofServer: this.dockerEnv
+            .getContainer(`${this.config.container.proofServer.name}_${this.uid}`)
+            .getMappedPort(this.config.container.proofServer.port)
+    });
+    /**
+     * 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 = async (dockerEnv, ports) => {
+        this.logger.info(`Starting test environment...`);
+        this.dockerEnv = dockerEnv;
+        this.environmentConfiguration = new LocalTestConfiguration(ports);
+        this.logger.info(`Test environment configuration: ${JSON.stringify(this.environmentConfiguration)}`);
+        return this.environmentConfiguration;
+    };
+    /**
+     * 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 = async (maybeProofServerContainer) => {
+        this.logger.info(`Starting test environment... path=${this.config.path}, file=${this.config.fileName}, uid=${this.uid}`);
+        if (maybeProofServerContainer) {
+            throw new Error('Invalid usage, trying to inject proof server container instance when starting new test environment with another proof server...');
+        }
+        this.dockerEnv = await new testcontainers.DockerComposeEnvironment(this.config.path, this.config.fileName)
+            .withWaitStrategy(`${this.config.container.proofServer.name}_${this.uid}`, this.config.container.proofServer.waitStrategy)
+            .withWaitStrategy(`${this.config.container.node.name}_${this.uid}`, this.config.container.node.waitStrategy)
+            .withWaitStrategy(`${this.config.container.indexer.name}_${this.uid}`, this.config.container.indexer.waitStrategy)
+            .withEnvironment({
+            TESTCONTAINERS_UID: this.uid,
+            NETWORK_ID: midnightJsNetworkId.getNetworkId()
+        })
+            .up();
+        this.environmentConfiguration = new LocalTestConfiguration(this.getMappedPorts());
+        this.logger.info(`Test environment configuration: ${JSON.stringify(this.environmentConfiguration)}`);
+        return this.environmentConfiguration;
+    };
+    /**
+     * Shuts down the test environment, closing walletProviders and stopping containers
+     * @returns {Promise<void>}
+     */
+    shutdown = async (saveWalletState) => {
+        this.logger.info(`Shutting down test environment...`);
+        if (this.walletProviders) {
+            if (saveWalletState) {
+                this.logger.warn('Skipping wallet save state as it is obsolete in this context...');
+            }
+            await Promise.all(this.walletProviders.map((wallet) => wallet.stop()));
+        }
+        if (this.dockerEnv) {
+            await this.dockerEnv.down({ timeout: 10000, removeVolumes: true });
+        }
+    };
+    /**
+     * 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 = async (amount = 1, seeds = getEnvVarWalletSeeds()) => {
+        this.logger.info(`Getting ${amount} wallets...`);
+        if (seeds) {
+            this.logger.warn('Provided seeds will be ignored, using genesis mint wallet seeds');
+        }
+        if (amount > LocalTestEnvironment.MAX_NUMBER_OF_WALLETS) {
+            throw new Error(`Maximum supported number of wallets for this environment reached: ${LocalTestEnvironment.MAX_NUMBER_OF_WALLETS}`);
+        }
+        this.walletProviders = await Promise.all(Array.from({ length: amount }).map((_elem, index) => MidnightWalletProvider.build(this.logger, this.environmentConfiguration, this.genesisMintWalletSeed[index])));
+        await Promise.all(this.walletProviders.map((wallet) => wallet.start()));
+        return this.walletProviders;
+    };
+}
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Test environment configuration for the Midnight QA network.
+ * Provides URLs and endpoints for QA network services.
+ */
+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() {
+        return {
+            walletNetworkId: walletSdkAbstractions.NetworkId.NetworkId.DevNet,
+            networkId: 'devnet',
+            indexer: 'https://indexer.qanet.dev.midnight.network/api/v3/graphql',
+            indexerWS: 'wss://indexer.qanet.dev.midnight.network/api/v3/graphql/ws',
+            node: 'https://rpc.qanet.dev.midnight.network',
+            nodeWS: 'wss://rpc.qanet.dev.midnight.network',
+            faucet: 'https://faucet.qanet.dev.midnight.network/api/request-tokens',
+            proofServer: this.proofServerContainer?.getUrl()
+        };
+    }
+}
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Test environment configuration for the Midnight testnet network.
+ * Provides URLs and endpoints for testnet services.
+ */
+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() {
+        return {
+            walletNetworkId: walletSdkAbstractions.NetworkId.NetworkId.TestNet,
+            networkId: 'testnet-02',
+            indexer: 'https://indexer.testnet-02.midnight.network/api/v3/graphql',
+            indexerWS: 'wss://indexer.testnet-02.midnight.network/api/v3/graphql/ws',
+            node: 'https://rpc.testnet-02.midnight.network',
+            nodeWS: 'wss://rpc.testnet-02.midnight.network',
+            faucet: 'https://faucet.testnet-02.midnight.network/api/request-tokens',
+            proofServer: this.proofServerContainer?.getUrl()
+        };
+    }
+}
+
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) 2025 Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * 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.
+ */
+const getTestEnvironment = (logger) => {
+    const testEnv = getEnvVarEnvironment().toLowerCase();
+    let env;
+    switch (testEnv) {
+        case 'testnet':
+        case 'testnet-02':
+            env = new Testnet2TestEnvironment(logger);
+            midnightJsNetworkId.setNetworkId('test');
+            break;
+        case 'qanet':
+            env = new QanetTestEnvironment(logger);
+            midnightJsNetworkId.setNetworkId('dev');
+            break;
+        case 'env-var-remote':
+            env = new EnvVarRemoteTestEnvironment(logger);
+            midnightJsNetworkId.setNetworkId(env.getEnvironmentConfiguration().networkId);
+            break;
+        default:
+            env = new LocalTestEnvironment(logger);
+            midnightJsNetworkId.setNetworkId('undeployed');
+    }
+    return env;
+};
+
+exports.DEFAULT_DUST_OPTIONS = DEFAULT_DUST_OPTIONS;
+exports.DEFAULT_WALLET_STATE_DIRECTORY = DEFAULT_WALLET_STATE_DIRECTORY;
+exports.DynamicProofServerContainer = DynamicProofServerContainer;
+exports.EnvVarRemoteTestEnvironment = EnvVarRemoteTestEnvironment;
+exports.FaucetClient = FaucetClient;
+exports.FluentWalletBuilder = FluentWalletBuilder;
+exports.GzipFile = GzipFile;
+exports.IndexerClient = IndexerClient;
+exports.LocalTestConfiguration = LocalTestConfiguration;
+exports.LocalTestEnvironment = LocalTestEnvironment;
+exports.MINUTE = MINUTE;
+exports.MidnightWalletProvider = MidnightWalletProvider;
+exports.NodeClient = NodeClient;
+exports.ProofServerClient = ProofServerClient;
+exports.QanetTestEnvironment = QanetTestEnvironment;
+exports.RemoteTestEnvironment = RemoteTestEnvironment;
+exports.StaticProofServerContainer = StaticProofServerContainer;
+exports.TestEnvironment = TestEnvironment;
+exports.Testnet2TestEnvironment = Testnet2TestEnvironment;
+exports.WalletFactory = WalletFactory;
+exports.WalletSaveStateProvider = WalletSaveStateProvider;
+exports.WalletSeeds = WalletSeeds;
+exports.createDefaultTestLogger = createDefaultTestLogger;
+exports.createLogger = createLogger;
+exports.defaultContainersConfiguration = defaultContainersConfiguration;
+exports.delay = delay;
+exports.deleteDirectory = deleteDirectory;
+exports.expectFoundAndDeployedStatesEqual = expectFoundAndDeployedStatesEqual;
+exports.expectFoundAndDeployedTxDataEqual = expectFoundAndDeployedTxDataEqual;
+exports.expectFoundAndDeployedTxPrivateDataEqual = expectFoundAndDeployedTxPrivateDataEqual;
+exports.expectFoundAndDeployedTxPublicDataEqual = expectFoundAndDeployedTxPublicDataEqual;
+exports.expectSuccessfulCallTx = expectSuccessfulCallTx;
+exports.expectSuccessfulDeployTx = expectSuccessfulDeployTx;
+exports.expectSuccessfulTxData = expectSuccessfulTxData;
+exports.extractHostnameAndPort = extractHostnameAndPort;
+exports.getContainersConfiguration = getContainersConfiguration;
+exports.getDustSeed = getDustSeed;
+exports.getInitialShieldedState = getInitialShieldedState;
+exports.getInitialState = getInitialState;
+exports.getInitialUnshieldedState = getInitialUnshieldedState;
+exports.getShieldedSeed = getShieldedSeed;
+exports.getTestEnvironment = getTestEnvironment;
+exports.getUnshieldedSeed = getUnshieldedSeed;
+exports.getWalletStateFilename = getWalletStateFilename;
+exports.inMemoryPrivateStateProvider = inMemoryPrivateStateProvider;
+exports.initializeMidnightProviders = initializeMidnightProviders;
+exports.latestContainersConfiguration = latestContainersConfiguration;
+exports.logger = logger;
+exports.setContainersConfiguration = setContainersConfiguration;
+exports.stateValueEqual = stateValueEqual;
+exports.syncWallet = syncWallet;
+exports.txsEqual = txsEqual;
+exports.waitForFunds = waitForFunds;
+//# sourceMappingURL=index.cjs.map