@0xbow/privacy-pools-core-sdk 0.0.0-b21c14ba

package/dist/types/core/bruteForce.service.d.ts

@@ -0,0 +1,61 @@
+import { Commitment, Hash, Precommitment } from "../types/commitment.js";
+/**
+ * Parameters required for brute-force commitment recovery.
+ */
+interface BruteForceRecoveryParams {
+    /** The target commitment hash to match against */
+    commitmentHash: Hash;
+    /** Defines the range of values to search within */
+    valueRange: {
+        min: number;
+        max: number;
+        step: number;
+    };
+    /** The precommitment object containing the hash, nullifier, and secret */
+    basePrecommitment: Precommitment;
+    /** The label used during commitment computation */
+    label: bigint;
+    /** Optional settings: timeout in milliseconds */
+    options?: {
+        timeout?: number;
+    };
+}
+/**
+ * The result of the brute-force commitment recovery process.
+ */
+interface RecoveryResult {
+    /** Indicates whether the recovery was successful */
+    success: boolean;
+    /** Contains the found commitment and its value if successful */
+    data?: Array<{
+        commitment: Commitment;
+        value: number;
+    }>;
+    /** Contains an error code and message if the recovery fails */
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Service for brute-force recovering commitments by iterating over possible values.
+ * This method is useful when the original commitment value is lost, but the precommitment and hash are known.
+ */
+export declare class BruteForceRecoveryService {
+    /**
+     * Attempts to recover a commitment by brute-forcing through the given value range.
+     *
+     * @param params - The parameters required for the brute-force search.
+     * @returns A `Promise` resolving to a `RecoveryResult` containing either the found commitment or an error.
+     */
+    bruteForceRecoverCommitment(params: BruteForceRecoveryParams): Promise<RecoveryResult>;
+    /**
+     * Computes the Poseidon hash of a commitment.
+     */
+    private computeCommitmentHash;
+    /**
+     * Determines the number of decimal places in a given number.
+     */
+    private getDecimalPlaces;
+}
+export {};

package/dist/types/core/commitment.service.d.ts

@@ -0,0 +1,30 @@
+import { CircuitsInterface } from "../interfaces/circuits.interface.js";
+import { CommitmentProof } from "../types/commitment.js";
+/**
+ * Service responsible for handling commitment-related operations.
+ * All hash operations use Poseidon for ZK-friendly hashing.
+ */
+export declare class CommitmentService {
+    private readonly circuits;
+    constructor(circuits: CircuitsInterface);
+    /**
+     * Generates a zero-knowledge proof for a commitment using Poseidon hash.
+     *
+     * @param value - The value being committed to
+     * @param label - Label associated with the commitment
+     * @param nullifier - Unique nullifier for the commitment
+     * @param secret - Secret key for the commitment
+     * @returns Promise resolving to proof and public signals
+     * @throws {ProofError} If proof generation fails
+     */
+    proveCommitment(value: bigint, label: bigint, nullifier: bigint, secret: bigint): Promise<CommitmentProof>;
+    /**
+     * Verifies a commitment proof.
+     *
+     * @param proof - The commitment proof to verify
+     * @param publicSignals - Public signals associated with the proof
+     * @returns Promise resolving to boolean indicating proof validity
+     * @throws {ProofError} If verification fails
+     */
+    verifyCommitment({ proof, publicSignals, }: CommitmentProof): Promise<boolean>;
+}

package/dist/types/core/contracts.service.d.ts

@@ -0,0 +1,114 @@
+import { Address, Chain, Hex } from "viem";
+import { Withdrawal, WithdrawalProof } from "../types/withdrawal.js";
+import { AssetConfig, ContractInteractions, TransactionResponse } from "../interfaces/contracts.interface.js";
+import { CommitmentProof, Hash } from "../types/commitment.js";
+export declare class ContractInteractionsService implements ContractInteractions {
+    private publicClient;
+    private walletClient;
+    private entrypointAddress;
+    private account;
+    /**
+     * Initializes the contract interactions service.
+     *
+     * @param rpcUrl - The RPC endpoint URL for the blockchain network.
+     * @param chain - The blockchain network configuration.
+     * @param entrypointAddress - The address of the entrypoint contract.
+     * @param accountPrivateKey - The private key used for signing transactions.
+     */
+    constructor(rpcUrl: string, chain: Chain, entrypointAddress: Address, accountPrivateKey: Hex);
+    /**
+     * Deposits ERC20 tokens into the privacy pool.
+     *
+     * @param asset - The address of the ERC20 token.
+     * @param amount - The amount of tokens to deposit.
+     * @param precommitment - The precommitment value.
+     * @returns Transaction response containing the transaction hash.
+     */
+    depositERC20(asset: Address, amount: bigint, precommitment: bigint): Promise<TransactionResponse>;
+    /**
+     * Deposits ETH into the privacy pool.
+     *
+     * @param amount - The amount of ETH to deposit.
+     * @param precommitment - The precommitment value.
+     * @returns Transaction response containing the transaction hash.
+     */
+    depositETH(amount: bigint, precommitment: bigint): Promise<TransactionResponse>;
+    /**
+     * Withdraws funds from the privacy pool.
+     *
+     * @param withdrawal - The withdrawal object containing recipient details and amount.
+     * @param withdrawalProof - The cryptographic proof verifying the withdrawal.
+     * @returns Transaction response containing the transaction hash.
+     */
+    withdraw(withdrawal: Withdrawal, withdrawalProof: WithdrawalProof, scope: Hash): Promise<TransactionResponse>;
+    /**
+     * Relays a withdrawal transaction to the entrypoint contract.
+     * This function is used to facilitate relayer transactions.
+     *
+     * @param withdrawal - The withdrawal data structure.
+     * @param withdrawalProof - The cryptographic proof required for withdrawal.
+     * @returns Transaction response containing hash and wait function.
+     */
+    relay(withdrawal: Withdrawal, withdrawalProof: WithdrawalProof, scope: Hash): Promise<TransactionResponse>;
+    /**
+     * Executes a ragequit operation, allowing a user to exit the pool
+     * by nullifying their commitment and proving their withdrawal.
+     *
+     * @param commitmentProof - The cryptographic proof of the commitment.
+     * @param privacyPoolAddress - The address of the privacy pool contract.
+     * @returns Transaction response containing hash and wait function.
+     */
+    ragequit(commitmentProof: CommitmentProof, privacyPoolAddress: Address): Promise<TransactionResponse>;
+    /**
+     * Retrieves the scope identifier of a given privacy pool.
+     *
+     * @param privacyPoolAddress - The address of the privacy pool contract.
+     * @returns The scope identifier as a bigint.
+     */
+    getScope(privacyPoolAddress: Address): Promise<bigint>;
+    /**
+     * Retrieves the latest state root of the privacy pool from the entrypoint contract.
+     *
+     * @param privacyPoolAddress - The address of the privacy pool contract.
+     * @returns The latest state root as a bigint.
+     */
+    getStateRoot(privacyPoolAddress: Address): Promise<bigint>;
+    /**
+     * Retrieves the current state size of the privacy pool.
+     *
+     * @param privacyPoolAddress - The address of the privacy pool contract.
+     * @returns The size of the state tree as a bigint.
+     */
+    getStateSize(privacyPoolAddress: Address): Promise<bigint>;
+    /**
+     * Retrieves data from the corresponding asset
+     *
+     * @param assetAddress - The asset contract address.
+     * @returns AssetConfig - An object containing the privacy pool address, minimum deposit amount, vetting fee and maximum relaying fee.
+     * @throws ContractError if the asset does not exist in the pool.
+     */
+    getAssetConfig(assetAddress: Address): Promise<AssetConfig>;
+    /**
+     * Retrieves data about a specific scope, including the associated privacy pool
+     * and the asset used in that pool.
+     *
+     * @param scope - The scope identifier to look up.
+     * @returns An object containing the privacy pool address and asset address.
+     * @throws ContractError if the scope does not exist.
+     */
+    getScopeData(scope: bigint): Promise<{
+        poolAddress: Address;
+        assetAddress: Address;
+    }>;
+    /**
+     * Approves the entrypoint contract to spend a specified amount of ERC20 tokens.
+     *
+     * @param spenderAddress - The address of the entity that will be approved to spend tokens.
+     * @param tokenAddress - The address of the ERC20 token contract.
+     * @param amount - The amount of tokens to approve.
+     * @returns Transaction response containing hash and wait function.
+     */
+    approveERC20(spenderAddress: Address, tokenAddress: Address, amount: bigint): Promise<TransactionResponse>;
+    private formatProof;
+    private executeTransaction;
+}

package/dist/types/core/data.service.d.ts

@@ -0,0 +1,52 @@
+import { ChainConfig, DepositEvent, WithdrawalEvent, RagequitEvent } from "../types/events.js";
+import { PoolInfo } from "../types/account.js";
+/**
+ * Service responsible for fetching and managing privacy pool events across multiple chains.
+ * Handles event retrieval, parsing, and validation for deposits, withdrawals, and ragequits.
+ *
+ * @remarks
+ * This service uses viem's PublicClient to efficiently fetch and process blockchain events.
+ * It supports multiple chains and provides robust error handling and validation.
+ * All uint256 values from events are handled as bigints, with Hash type assertions for commitment-related fields.
+ */
+export declare class DataService {
+    private readonly chainConfigs;
+    private readonly clients;
+    private readonly logger;
+    /**
+     * Initialize the data service with chain configurations
+     *
+     * @param chainConfigs - Array of chain configurations containing chainId, RPC URL, and API key
+     * @throws {DataError} If client initialization fails for any chain
+     */
+    constructor(chainConfigs: ChainConfig[]);
+    /**
+     * Get deposit events for a specific chain
+     *
+     * @param chainId - Chain ID to fetch events from
+     * @param options - Event filter options including fromBlock, toBlock, and other filters
+     * @returns Array of deposit events with properly typed fields (bigint for numbers, Hash for commitments)
+     * @throws {DataError} If client is not configured, network error occurs, or event data is invalid
+     */
+    getDeposits(pool: PoolInfo): Promise<DepositEvent[]>;
+    /**
+     * Get withdrawal events for a specific chain
+     *
+     * @param chainId - Chain ID to fetch events from
+     * @param options - Event filter options including fromBlock, toBlock, and other filters
+     * @returns Array of withdrawal events with properly typed fields (bigint for numbers, Hash for commitments)
+     * @throws {DataError} If client is not configured, network error occurs, or event data is invalid
+     */
+    getWithdrawals(pool: PoolInfo, fromBlock?: bigint): Promise<WithdrawalEvent[]>;
+    /**
+     * Get ragequit events for a specific chain
+     *
+     * @param chainId - Chain ID to fetch events from
+     * @param options - Event filter options including fromBlock, toBlock, and other filters
+     * @returns Array of ragequit events with properly typed fields (bigint for numbers, Hash for commitments)
+     * @throws {DataError} If client is not configured, network error occurs, or event data is invalid
+     */
+    getRagequits(pool: PoolInfo, fromBlock?: bigint): Promise<RagequitEvent[]>;
+    private getClientForChain;
+    private getConfigForChain;
+}

package/dist/types/core/sdk.d.ts

@@ -0,0 +1,45 @@
+import { CircuitsInterface } from "../interfaces/circuits.interface.js";
+import { Commitment, CommitmentProof } from "../types/commitment.js";
+import { WithdrawalProof, WithdrawalProofInput } from "../types/withdrawal.js";
+import { ContractInteractionsService } from "./contracts.service.js";
+import { Hex, Address, Chain } from "viem";
+import { AccountCommitment } from "../types/account.js";
+/**
+ * Main SDK class providing access to all privacy pool functionality.
+ * Uses Poseidon hash for all commitment operations.
+ */
+export declare class PrivacyPoolSDK {
+    private readonly commitmentService;
+    private readonly withdrawalService;
+    constructor(circuits: CircuitsInterface);
+    createContractInstance(rpcUrl: string, chain: Chain, entrypointAddress: Address, privateKey: Hex): ContractInteractionsService;
+    /**
+     * Generates a commitment proof.
+     *
+     * @param value - Value to commit
+     * @param label - Label for the commitment
+     * @param nullifier - Nullifier for the commitment
+     * @param secret - Secret for the commitment
+     */
+    proveCommitment(value: bigint, label: bigint, nullifier: bigint, secret: bigint): Promise<CommitmentProof>;
+    /**
+     * Verifies a commitment proof.
+     *
+     * @param proof - The proof to verify
+     */
+    verifyCommitment(proof: CommitmentProof): Promise<boolean>;
+    /**
+     * Generates a withdrawal proof.
+     *
+     * @param commitment - Commitment to withdraw
+     * @param input - Input parameters for the withdrawal
+     * @param withdrawal - Withdrawal details
+     */
+    proveWithdrawal(commitment: Commitment | AccountCommitment, input: WithdrawalProofInput): Promise<WithdrawalProof>;
+    /**
+     * Verifies a withdrawal proof.
+     *
+     * @param withdrawalProof - The withdrawal payload to verify
+     */
+    verifyWithdrawal(withdrawalProof: WithdrawalProof): Promise<boolean>;
+}

package/dist/types/core/withdrawal.service.d.ts

@@ -0,0 +1,32 @@
+import { CircuitsInterface } from "../interfaces/circuits.interface.js";
+import { WithdrawalProof, WithdrawalProofInput } from "../types/withdrawal.js";
+import { AccountCommitment, Commitment } from "../index.js";
+/**
+ * Service responsible for handling withdrawal-related operations.
+ */
+export declare class WithdrawalService {
+    private readonly circuits;
+    constructor(circuits: CircuitsInterface);
+    /**
+     * Generates a withdrawal proof.
+     *
+     * @param commitment - Commitment to withdraw
+     * @param input - Input parameters for the withdrawal
+     * @param withdrawal - Withdrawal details
+     * @returns Promise resolving to withdrawal payload
+     * @throws {ProofError} If proof generation fails
+     */
+    proveWithdrawal(commitment: Commitment | AccountCommitment, input: WithdrawalProofInput): Promise<WithdrawalProof>;
+    /**
+     * Verifies a withdrawal proof.
+     *
+     * @param withdrawalPayload - The withdrawal payload to verify
+     * @returns Promise resolving to boolean indicating proof validity
+     * @throws {ProofError} If verification fails
+     */
+    verifyWithdrawal(withdrawalPayload: WithdrawalProof): Promise<boolean>;
+    /**
+     * Prepares input signals for the withdrawal circuit.
+     */
+    private prepareInputSignals;
+}

package/dist/types/crypto.d.ts

@@ -0,0 +1,67 @@
+import { LeanIMTMerkleProof } from "@zk-kit/lean-imt";
+import { Commitment, Hash, Secret, Withdrawal, MasterKeys } from "./types/index.js";
+import { Hex } from "viem";
+/**
+ * Generates two master keys based on some provided seed or a random value.
+ *
+ * @param {Hex} seed - The optional seed.
+ * @returns {MasterKeys} The master key pair.
+ */
+export declare function generateMasterKeys(mnemonic: string): MasterKeys;
+/**
+ * Generates a nullifier and secret pair for a deposit commitment.
+ *
+ * @param {MasterKeys} keys - The master keys pair.
+ * @param {Hash} scope - The pool scope.
+ * @param {bigint} index - The pool account index for the scope.
+ * @returns {Secret, Secret} The commitment nullifier and secret pair.
+ */
+export declare function generateDepositSecrets(keys: MasterKeys, scope: Hash, index: bigint): {
+    nullifier: Secret;
+    secret: Secret;
+};
+/**
+ * Generates a nullifier and secret pair for a withdrawal commitment.
+ *
+ * @param {MasterKeys} keys - The master keys pair.
+ * @param {Hash} label - The deposit commitment label.
+ * @param {bigint} index - The withdrawal index for the pool account.
+ * @returns {Secret, Secret} The commitment nullifier and secret pair.
+ */
+export declare function generateWithdrawalSecrets(keys: MasterKeys, label: Hash, index: bigint): {
+    nullifier: Secret;
+    secret: Secret;
+};
+/**
+ * Computes a Poseidon hash for the given nullifier and secret.
+ *
+ * @param {Secret} nullifier - The nullifier to hash.
+ * @param {Secret} secret - The secret to hash.
+ * @returns {Hash} The Poseidon hash.
+ */
+export declare function hashPrecommitment(nullifier: Secret, secret: Secret): Hash;
+/**
+ * Generates a commitment using the given parameters.
+ *
+ * @param {bigint} value - The value associated with the commitment.
+ * @param {bigint} label - The label used for the commitment.
+ * @param {Secret} nullifier - The nullifier used in the precommitment.
+ * @param {Secret} secret - The secret used in the precommitment.
+ * @returns {Commitment} The generated commitment object.
+ */
+export declare function getCommitment(value: bigint, label: bigint, nullifier: Secret, secret: Secret): Commitment;
+/**
+ * Generates a Merkle inclusion proof for a given leaf in a set of leaves.
+ *
+ * @param {bigint[]} leaves - Array of leaves for the Lean Incremental Merkle tree.
+ * @param {bigint} leaf - The specific leaf to generate the inclusion proof for.
+ * @returns {LeanIMTMerkleProof<bigint>} A lean incremental Merkle tree inclusion proof.
+ * @throws {Error} If the leaf is not found in the leaves array.
+ */
+export declare function generateMerkleProof(leaves: bigint[], leaf: bigint): LeanIMTMerkleProof<bigint>;
+export declare function bigintToHash(value: bigint): Hash;
+export declare function bigintToHex(num: bigint | string | undefined): Hex;
+/**
+ * Calculates the context hash for a withdrawal.
+ */
+export declare function calculateContext(withdrawal: Withdrawal, scope: Hash): string;

package/dist/types/dirname.helper.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

package/dist/types/errors/account.error.d.ts

@@ -0,0 +1,10 @@
+import { ErrorCode, SDKError } from "./base.error.js";
+import { Hash } from "../types/commitment.js";
+export declare class AccountError extends SDKError {
+    constructor(message: string, code?: ErrorCode, details?: Record<string, unknown>);
+    static commitmentNotFound(hash: Hash | string): AccountError;
+    static invalidPoolAccount(): AccountError;
+    static accountInitializationFailed(reason: string): AccountError;
+    static duplicatePools(scope: bigint): AccountError;
+    static invalidIndex(index: bigint): AccountError;
+}

package/dist/types/errors/base.error.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Unified error codes for the SDK.
+ */
+export declare enum ErrorCode {
+    UNKNOWN = "UNKNOWN",
+    INVALID_INPUT = "INVALID_INPUT",
+    OPERATION_FAILED = "OPERATION_FAILED",
+    NETWORK_ERROR = "NETWORK_ERROR",
+    PROOF_GENERATION_FAILED = "PROOF_GENERATION_FAILED",
+    PROOF_VERIFICATION_FAILED = "PROOF_VERIFICATION_FAILED",
+    INVALID_PROOF = "INVALID_PROOF",
+    INVALID_PUBLIC_SIGNALS = "INVALID_PUBLIC_SIGNALS",
+    CIRCUIT_ERROR = "CIRCUIT_ERROR",
+    CONTRACT_ERROR = "CONTRACT_ERROR",
+    CRYPTO_ERROR = "CRYPTO_ERROR",
+    MERKLE_ERROR = "MERKLE_ERROR"
+}
+/**
+ * Base error class for the SDK.
+ * All other error classes should extend this.
+ */
+export declare class SDKError extends Error {
+    readonly code: ErrorCode;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(message: string, code?: ErrorCode, details?: Record<string, unknown> | undefined);
+    /**
+     * Creates a JSON representation of the error.
+     */
+    toJSON(): Record<string, unknown>;
+}
+/**
+ * Specialized error class for proof-related operations.
+ */
+export declare class ProofError extends SDKError {
+    constructor(message: string, code?: ErrorCode, details?: Record<string, unknown>);
+    /**
+     * Creates an error for proof generation failures.
+     */
+    static generationFailed(details?: Record<string, unknown>): ProofError;
+    /**
+     * Creates an error for proof verification failures.
+     */
+    static verificationFailed(details?: Record<string, unknown>): ProofError;
+    /**
+     * Creates an error for invalid proof format.
+     */
+    static invalidProof(details?: Record<string, unknown>): ProofError;
+}
+export declare class ContractError extends SDKError {
+    constructor(message: string, code?: ErrorCode, details?: Record<string, unknown>);
+    static scopeNotFound(scope: bigint): ContractError;
+    static assetNotFound(address: string): ContractError;
+}

package/dist/types/errors/data.error.d.ts

@@ -0,0 +1,7 @@
+import { ErrorCode, SDKError } from "./base.error.js";
+export declare class DataError extends SDKError {
+    constructor(message: string, code?: ErrorCode, details?: Record<string, unknown>);
+    static invalidLog(type: string, reason: string): DataError;
+    static chainNotConfigured(chainId: number): DataError;
+    static networkError(chainId: number, error: Error): DataError;
+}

package/dist/types/errors/events.error.d.ts

@@ -0,0 +1,9 @@
+import { ErrorCode } from "./base.error.js";
+import { DataError } from "./data.error.js";
+import { Hash } from "../types/commitment.js";
+export declare class EventError extends DataError {
+    constructor(message: string, code?: ErrorCode, details?: Record<string, unknown>);
+    static depositEventError(chainId: number, scope: Hash, error: Error): EventError;
+    static withdrawalEventError(chainId: number, scope: Hash, error: Error): EventError;
+    static ragequitEventError(chainId: number, scope: Hash, error: Error): EventError;
+}

package/dist/types/exceptions/circuitInitialization.exception.d.ts

@@ -0,0 +1,3 @@
+export declare class CircuitInitialization extends Error {
+    constructor(message: string);
+}

package/dist/types/exceptions/fetchArtifacts.exception.d.ts

@@ -0,0 +1,3 @@
+export declare class FetchArtifact extends Error {
+    constructor(artifact: URL);
+}

package/dist/types/exceptions/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./invalidRpcUrl.exception.js";
+export * from "./fetchArtifacts.exception.js";
+export * from "./circuitInitialization.exception.js";
+export * from "./privacyPool.exception.js";

package/dist/types/exceptions/invalidRpcUrl.exception.d.ts

@@ -0,0 +1,3 @@
+export declare class InvalidRpcUrl extends Error {
+    constructor(url: string);
+}

package/dist/types/exceptions/privacyPool.exception.d.ts

@@ -0,0 +1,13 @@
+export declare enum ErrorCode {
+    INVALID_COMMITMENT = "INVALID_COMMITMENT",
+    INVALID_MERKLE_PROOF = "INVALID_MERKLE_PROOF",
+    INVALID_NULLIFIER = "INVALID_NULLIFIER",
+    INVALID_SECRET = "INVALID_SECRET",
+    INVALID_VALUE = "INVALID_VALUE",
+    INVALID_LABEL = "INVALID_LABEL",
+    MERKLE_ERROR = "MERKLE_ERROR"
+}
+export declare class PrivacyPoolError extends Error {
+    code: ErrorCode;
+    constructor(code: ErrorCode, message: string);
+}

package/dist/types/external.d.ts

@@ -0,0 +1,7 @@
+export type { IBlockchainProvider } from "./internal.js";
+export { InvalidRpcUrl } from "./internal.js";
+export { BlockchainProvider } from "./internal.js";
+export { Circuits } from "./circuits/index.js";
+export { ContractInteractionsService } from "./core/contracts.service.js";
+export type { LeanIMTMerkleProof } from "@zk-kit/lean-imt";
+export type { Address } from "viem";

package/dist/types/fetchArtifacts.esm-CwvN5XjW.js

@@ -0,0 +1,34 @@
+import { F as FetchArtifact } from './index-CPuQ9H-0.js';
+import 'viem/accounts';
+import 'buffer';
+import 'http';
+import 'https';
+import 'zlib';
+import 'crypto';
+import 'node:crypto';
+import 'events';
+import 'net';
+import 'tls';
+import 'stream';
+import 'url';
+import 'assert';
+import 'viem';
+import 'viem/chains';
+import 'os';
+import 'vm';
+import 'worker_threads';
+import 'fs';
+import 'constants';
+import 'readline';
+import 'path';
+
+async function fetchVersionedArtifact(artifactUrl) {
+    const res = await fetch(artifactUrl);
+    if (res.status !== 200) {
+        throw new FetchArtifact(artifactUrl);
+    }
+    const aBuf = await res.arrayBuffer();
+    return new Uint8Array(aBuf);
+}
+
+export { fetchVersionedArtifact };

package/dist/types/fetchArtifacts.node-VEzDC3k8.js

@@ -0,0 +1,47 @@
+import { F as FetchArtifact } from './index-CPuQ9H-0.js';
+import 'viem/accounts';
+import 'buffer';
+import 'http';
+import 'https';
+import 'zlib';
+import 'crypto';
+import 'node:crypto';
+import 'events';
+import 'net';
+import 'tls';
+import 'stream';
+import 'url';
+import 'assert';
+import 'viem';
+import 'viem/chains';
+import 'os';
+import 'vm';
+import 'worker_threads';
+import 'fs';
+import 'constants';
+import 'readline';
+import 'path';
+
+async function fetchVersionedArtifact(artifactUrl) {
+    try {
+        const fs = (await import('fs')).default;
+        const readPromise = new Promise((resolve, reject) => {
+            fs.readFile(artifactUrl.pathname, (err, data) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(data);
+                }
+            });
+        });
+        const buf = await readPromise;
+        return new Uint8Array(buf);
+    }
+    catch (error) {
+        console.error(error);
+        throw new FetchArtifact(artifactUrl);
+    }
+}
+
+export { fetchVersionedArtifact };

package/dist/types/filename.helper.d.ts

@@ -0,0 +1,2 @@
+declare const __filename: string;
+export default __filename;