@inco/lightning-js 0.0.0-bootstrap.0

package/dist/esm/local/local-node.js

@@ -0,0 +1,76 @@
+import { Schema } from 'effect';
+import { Address, HexString } from '../binary.js';
+/**
+ * Schema for the environment variables required to connect to a local Inco node.
+ *
+ * Includes executor/sender addresses, keys, covalidator settings, and optional
+ * remote compute-server overrides. Typically populated from a `.env` file.
+ */
+export const LocalNodeEnv = Schema.Struct({
+    DEPLOYER_ADDRESS: Address,
+    STATE_DUMP: Schema.String,
+    EXECUTOR_ADDRESS: Address,
+    // Empty if compute-server is remote
+    NETWORK_PUBKEY: Schema.optional(HexString),
+    SENDER_ADDRESS: Address,
+    SENDER_PRIVATE_KEY: HexString,
+    // Empty if compute-server is remote
+    EIP712_SIGNER_ADDRESS: Schema.optional(HexString),
+    PEPPER: Schema.String,
+    // Empty if compute-server is remote
+    COVALIDATOR_NETWORK_PRIVATE_KEY: Schema.optional(HexString),
+    // Empty if compute-server is remote
+    COVALIDATOR_EIP712_PRIVATE_SIGNING_KEY: Schema.optional(HexString),
+    COVALIDATOR_INCO_EXECUTOR_ADDR: Address,
+    COVALIDATOR_HOST_CHAIN_ID: Schema.optional(Schema.String),
+    COVALIDATOR_URL: Schema.optional(Schema.String),
+    COVALIDATOR_HOST_CHAIN_RPC_URL: Schema.optional(Schema.String),
+    COVALIDATOR_COMPUTE_TYPE: Schema.optional(Schema.String),
+    COVALIDATOR_STORAGE_KEY: Schema.optional(HexString),
+});
+/**
+ * Parses a dotenv-formatted string or `Buffer` into a validated {@link LocalNodeEnv}.
+ *
+ * Falls back to `process.env` when no argument is provided.
+ *
+ * @param envFileOrObj - A dotenv-formatted string, `Buffer`, or `undefined` to use `process.env`.
+ * @returns A validated `LocalNodeEnv` object.
+ * @throws If required environment variables are missing or invalid.
+ */
+export function parseLocalEnv(envFileOrObj) {
+    const envObj = envFileOrObj ? readEnv(envFileOrObj) : process.env;
+    return Schema.decodeUnknownSync(LocalNodeEnv)(envObj);
+}
+function readEnv(envContent) {
+    return parseEnv(envContent.toString());
+}
+// Parse environment variables with support for variable substitutions and comments
+function parseEnv(envContent) {
+    let env = {};
+    const lines = envContent.split('\n');
+    // First pass: collect raw values
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (trimmedLine && !trimmedLine.startsWith('#')) {
+            const equalIndex = trimmedLine.indexOf('=');
+            if (equalIndex !== -1) {
+                const key = trimmedLine.substring(0, equalIndex).trim();
+                let value = trimmedLine.substring(equalIndex + 1).trim();
+                // Handle quoted values
+                if ((value.startsWith('"') && value.endsWith('"')) ||
+                    (value.startsWith("'") && value.endsWith("'"))) {
+                    value = value.substring(1, value.length - 1);
+                }
+                env[key] = value;
+            }
+        }
+    }
+    // Second pass: resolve substitutions like $VAR or ${VAR}
+    for (const [key, value] of Object.entries(env)) {
+        env[key] = value.replace(/\${?(\w+)}?/g, (_, varName) => {
+            return env[varName] ?? '';
+        });
+    }
+    return env;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/reencryption/eip712.d.ts

@@ -0,0 +1,56 @@
+import { Schema } from 'effect';
+import { Address } from 'viem';
+declare const baseEIP712: Schema.Struct<{
+    domain: Schema.Struct<{
+        chainId: typeof Schema.BigInt;
+        name: typeof Schema.String;
+        version: typeof Schema.String;
+        verifyingContract: Schema.optional<Schema.TemplateLiteral<`0x${string}`>>;
+    }>;
+    primaryType: typeof Schema.String;
+    types: Schema.Record$<typeof Schema.String, Schema.Array$<Schema.Struct<{
+        name: typeof Schema.String;
+        type: typeof Schema.String;
+    }>>>;
+}>;
+type BaseEIP712 = typeof baseEIP712.Type;
+/**
+ * An EIP-712 typed data payload with a generic `message` field.
+ *
+ * Extends the base EIP-712 structure (domain, primaryType, types) with
+ * a strongly-typed `message` object for signing.
+ *
+ * @typeParam Message - The shape of the application-specific message to sign.
+ */
+export interface EIP712<Message extends object> extends BaseEIP712 {
+    message: Message;
+}
+/**
+ * Creates an EIP-712 typed data payload for user signing.
+ *
+ * Used to verify the user controls the private key corresponding to the ephemeral
+ * public key embedded in the payload. The `message` keys must exactly match the
+ * `name` values in `primaryTypeFields`.
+ *
+ * @typeParam PrimaryType - The EIP-712 primary type name.
+ * @typeParam Message - The shape of the message to sign.
+ * @param params.chainId - The chain ID for the EIP-712 domain.
+ * @param params.primaryType - The primary type name (e.g. `"Reencrypt"`).
+ * @param params.primaryTypeFields - The field definitions for the primary type.
+ * @param params.message - The message object to sign (must match `primaryTypeFields`).
+ * @param params.verifyingContract - Optional verifying contract address for the domain.
+ * @param params.domainName - Human-readable name for the EIP-712 domain.
+ * @param params.domainVersion - Version string for the EIP-712 domain.
+ * @returns A complete {@link EIP712} payload ready for signing.
+ * @throws If message keys do not match `primaryTypeFields` names.
+ */
+export declare function createEIP712Payload<PrimaryType extends string, Message extends object>({ chainId, primaryType, primaryTypeFields, message, verifyingContract, domainName, domainVersion, }: {
+    chainId: bigint;
+    primaryType: PrimaryType;
+    primaryTypeFields: BaseEIP712['types'][PrimaryType];
+    message: Message;
+    verifyingContract?: Address;
+    domainName: string;
+    domainVersion: string;
+}): EIP712<Message>;
+export {};

package/dist/esm/reencryption/eip712.js

@@ -0,0 +1,87 @@
+import { Schema } from 'effect';
+import { HexString } from '../binary.js';
+// An effect Schema representing a base EIP712 typed message, without any
+// custom message types, as defined in EIP-712.
+const baseEIP712 = Schema.Struct({
+    domain: Schema.Struct({
+        chainId: Schema.BigInt,
+        name: Schema.String,
+        version: Schema.String,
+        verifyingContract: Schema.optional(HexString),
+        // If salt is needed, it can be added here. Currently, none of the Incolite
+        // features need this.
+    }),
+    primaryType: Schema.String,
+    types: Schema.Record({
+        key: Schema.String,
+        value: Schema.Array(Schema.Struct({
+            name: Schema.String,
+            type: Schema.String,
+        })),
+    }),
+});
+/**
+ * Creates an EIP-712 typed data payload for user signing.
+ *
+ * Used to verify the user controls the private key corresponding to the ephemeral
+ * public key embedded in the payload. The `message` keys must exactly match the
+ * `name` values in `primaryTypeFields`.
+ *
+ * @typeParam PrimaryType - The EIP-712 primary type name.
+ * @typeParam Message - The shape of the message to sign.
+ * @param params.chainId - The chain ID for the EIP-712 domain.
+ * @param params.primaryType - The primary type name (e.g. `"Reencrypt"`).
+ * @param params.primaryTypeFields - The field definitions for the primary type.
+ * @param params.message - The message object to sign (must match `primaryTypeFields`).
+ * @param params.verifyingContract - Optional verifying contract address for the domain.
+ * @param params.domainName - Human-readable name for the EIP-712 domain.
+ * @param params.domainVersion - Version string for the EIP-712 domain.
+ * @returns A complete {@link EIP712} payload ready for signing.
+ * @throws If message keys do not match `primaryTypeFields` names.
+ */
+export function createEIP712Payload({ chainId, primaryType, primaryTypeFields, message, verifyingContract, domainName, domainVersion, }) {
+    const types = {
+        // This refers to the domain the contract is hosted on.
+        EIP712Domain: [
+            { name: 'name', type: 'string' },
+            { name: 'version', type: 'string' },
+            { name: 'chainId', type: 'uint256' },
+        ],
+        // Refer to primaryType.
+        [primaryType]: primaryTypeFields,
+    };
+    if (verifyingContract) {
+        types.EIP712Domain.push({ name: 'verifyingContract', type: 'address' });
+    }
+    // Check that the message has the same keys as the primaryTypeFields.
+    const messageKeys = Object.keys(message);
+    const primaryTypeFieldsKeys = primaryTypeFields.map((field) => field.name);
+    if (messageKeys.length !== primaryTypeFieldsKeys.length) {
+        throw new Error('Message keys do not match primaryTypeFields keys');
+    }
+    for (const key of messageKeys) {
+        if (!primaryTypeFieldsKeys.includes(key)) {
+            throw new Error(`Message key ${key} does not match primaryTypeFields key`);
+        }
+    }
+    const msgParams = {
+        types,
+        // This defines the message you're proposing the user to sign, is dapp-specific, and contains
+        // anything you want. There are no required fields. Be as explicit as possible when building out
+        // the message schema.
+        // This refers to the keys of the following types object.
+        primaryType,
+        domain: {
+            // Give a user-friendly name to the specific contract you're signing for.
+            name: domainName,
+            // This identifies the latest version.
+            version: domainVersion,
+            // This defines the network, in this case, Mainnet.
+            chainId,
+            verifyingContract,
+        },
+        message,
+    };
+    return msgParams;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/reencryption/index.d.ts

@@ -0,0 +1,2 @@
+export * from './eip712.js';
+export * from './types.js';

package/dist/esm/reencryption/index.js

@@ -0,0 +1,3 @@
+export * from './eip712.js';
+export * from './types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcmVlbmNyeXB0aW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsWUFBWSxDQUFDIn0=

package/dist/esm/reencryption/types.d.ts

@@ -0,0 +1,48 @@
+import { Address } from 'viem';
+import { HexString } from '../binary.js';
+import { CiphertextOf, EncryptionScheme, PlaintextOf, SupportedTeeType } from '../encryption/encryption.js';
+import { Handle } from '../handle.js';
+import type { XwingKeypair } from '../lite/xwing.js';
+import type { BackoffConfig } from '../retry.js';
+/**
+ * The core reencryption function type. Takes a handle (and optional ciphertext) and returns
+ * the decrypted plaintext. Supports retry configuration for handles that are not yet available.
+ *
+ * @typeParam S - The encryption scheme (e.g. X-Wing).
+ */
+export type Reencryptor<S extends EncryptionScheme> = <T extends SupportedTeeType>(args: ReencryptFnArgs<S, T>, backoffConfig?: Partial<BackoffConfig>) => Promise<PlaintextOf<S, T>>;
+/** Arguments required to construct a {@link Reencryptor}. */
+export interface ReencryptorArgs {
+    chainId: bigint;
+}
+/**
+ * Arguments for a single reencryption call.
+ *
+ * @typeParam S - The encryption scheme.
+ * @typeParam T - The ENCRYPTION type of the ciphertext.
+ */
+export type ReencryptFnArgs<S extends EncryptionScheme, T extends SupportedTeeType> = {
+    handle: Handle;
+    /**
+     * Optional ciphertext hint. If provided, the reencrypt endpoint may use it directly
+     * instead of fetching from the covalidators.
+     */
+    ciphertext?: CiphertextOf<S, T>;
+};
+/** Union of supported ephemeral keypair types for reencryption (currently X-Wing only). */
+export type SupportedEphemeralKeypairs = XwingKeypair;
+/** An object whose public key can be serialized to a `Uint8Array`. */
+export interface PubKeyEncodable {
+    encodePublicKey(): Uint8Array;
+}
+/**
+ * A reencryption request to be sent to a reencrypt endpoint.
+ *
+ * @typeParam EKP - The type of ephemeral keypair used for the reencryption session.
+ */
+export interface ReencryptEndpointRequest<EKP extends SupportedEphemeralKeypairs> {
+    userAddress: Address;
+    handle: Handle;
+    eip712Signature: HexString;
+    ephemeralKeypair: EKP;
+}

package/dist/esm/reencryption/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcmVlbmNyeXB0aW9uL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist/esm/retry.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Configuration for exponential backoff retry logic.
+ */
+export type BackoffConfig = {
+    maxRetries: number;
+    baseDelayInMs: number;
+    backoffFactor: number;
+    errHandler?: (error: Error, attempt: number) => 'stop' | 'continue';
+};
+/**
+ * Checks if an error is safe to retry.
+ * Only transient errors matching the allowlist should return true.
+ * All other errors fail fast to avoid masking security-critical failures.
+ *
+ * @param error - The error to check
+ * @returns true if the error is transient and safe to retry, false otherwise
+ */
+export declare function isRetryableError(error: Error): boolean;
+/**
+ * Default error handler that only retries known transient errors.
+ * Security-critical errors will fail fast.
+ */
+export declare function defaultRetryErrorHandler(error: Error): 'stop' | 'continue';
+/**
+ * Helper function to implement exponential backoff retry logic.
+ * @param fn - The function to retry
+ * @param config - Optional backoff configuration
+ * @returns Promise that resolves with the result of the function
+ */
+export declare function retryWithBackoff<T>(fn: () => Promise<T>, { maxRetries, baseDelayInMs, backoffFactor, errHandler, }?: Partial<BackoffConfig>): Promise<T>;

package/dist/esm/retry.js

@@ -0,0 +1,82 @@
+/**
+ * Allowlist of transient error patterns that are safe to retry.
+ * Each pattern includes a substring to match (case-insensitive) and a description.
+ *
+ * SECURITY: Only add patterns here for genuinely transient errors.
+ * Do NOT add patterns that could mask security-critical errors like:
+ * - Authentication failures
+ * - Permission denied
+ * - Signature validation errors
+ * - Invalid input/format errors
+ */
+const RETRYABLE_ERROR_PATTERNS = [
+    // Explicit retry suggestions from the server
+    {
+        pattern: 'try again later',
+        description: 'Server explicitly suggests retry',
+    },
+    // Network/connectivity issues
+    { pattern: 'timeout', description: 'Request timeout' },
+    { pattern: 'etimedout', description: 'Connection timeout' },
+    { pattern: 'econnreset', description: 'Connection reset' },
+    { pattern: 'econnrefused', description: 'Connection refused' },
+    // Service availability
+    { pattern: '503', description: 'Service unavailable (503)' },
+    { pattern: 'service unavailable', description: 'Service unavailable' },
+    // Data propagation delays (eventual consistency)
+    {
+        pattern: 'ciphertext too short',
+        description: 'Ciphertext not yet propagated to covalidator',
+    },
+];
+/**
+ * Checks if an error is safe to retry.
+ * Only transient errors matching the allowlist should return true.
+ * All other errors fail fast to avoid masking security-critical failures.
+ *
+ * @param error - The error to check
+ * @returns true if the error is transient and safe to retry, false otherwise
+ */
+export function isRetryableError(error) {
+    const message = error.message?.toLowerCase() ?? '';
+    return RETRYABLE_ERROR_PATTERNS.some(({ pattern }) => message.includes(pattern));
+}
+/**
+ * Default error handler that only retries known transient errors.
+ * Security-critical errors will fail fast.
+ */
+export function defaultRetryErrorHandler(error) {
+    if (isRetryableError(error)) {
+        console.warn(`Retrying after transient error: ${error.message}`);
+        return 'continue';
+    }
+    return 'stop';
+}
+/**
+ * Helper function to implement exponential backoff retry logic.
+ * @param fn - The function to retry
+ * @param config - Optional backoff configuration
+ * @returns Promise that resolves with the result of the function
+ */
+export async function retryWithBackoff(fn, { 
+// These default values will make it return an error after ~10s if the fn response is fast.
+maxRetries = 5, baseDelayInMs = 1000, backoffFactor = 1.5, errHandler = defaultRetryErrorHandler, } = {}) {
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (errHandler(lastError, attempt) !== 'continue' ||
+                attempt === maxRetries - 1) {
+                break;
+            }
+            const delay = baseDelayInMs * Math.pow(backoffFactor, attempt);
+            const jitter = delay * (0.8 + Math.random() * 0.4); // random jitter, 80% to 120% of the delay
+            await new Promise((resolve) => setTimeout(resolve, jitter));
+        }
+    }
+    throw lastError;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/schema.d.ts

@@ -0,0 +1,4 @@
+import { Schema } from 'effect';
+import { ParseOptions } from 'effect/SchemaAST';
+export declare function parse<A, I>(schema: Schema.Schema<A, I>, obj: unknown, options?: ParseOptions): A;
+export declare function parseJson<A, I>(schema: Schema.Schema<A, I>, json: string | Uint8Array, options?: ParseOptions): A;

package/dist/esm/schema.js

@@ -0,0 +1,15 @@
+import { Schema } from 'effect';
+// parse takes an effect Schema object and parses an unknown value into that schema, if parsing fails an error is thrown
+// only fields specified in the schema will be present in the parsed object.
+export function parse(schema, obj, options) {
+    return Schema.decodeUnknownSync(schema)(obj, options);
+}
+// parseJson takes an effect Schema object and parses a JSON string into that schema, if parsing fails an error is thrown
+// only fields specified in the schema will be present in the parsed object.
+export function parseJson(schema, json, options) {
+    if (typeof json !== 'string') {
+        json = json.toString();
+    }
+    return Schema.decodeUnknownSync(Schema.parseJson(schema))(json, options);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NjaGVtYS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBR2hDLHdIQUF3SDtBQUN4SCw0RUFBNEU7QUFDNUUsTUFBTSxVQUFVLEtBQUssQ0FDbkIsTUFBMkIsRUFDM0IsR0FBWSxFQUNaLE9BQXNCO0lBRXRCLE9BQU8sTUFBTSxDQUFDLGlCQUFpQixDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsRUFBRSxPQUFPLENBQUMsQ0FBQztBQUN4RCxDQUFDO0FBRUQseUhBQXlIO0FBQ3pILDRFQUE0RTtBQUM1RSxNQUFNLFVBQVUsU0FBUyxDQUN2QixNQUEyQixFQUMzQixJQUF5QixFQUN6QixPQUFzQjtJQUV0QixJQUFJLE9BQU8sSUFBSSxLQUFLLFFBQVEsRUFBRSxDQUFDO1FBQzdCLElBQUksR0FBRyxJQUFJLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDekIsQ0FBQztJQUNELE9BQU8sTUFBTSxDQUFDLGlCQUFpQixDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsT0FBTyxDQUFDLENBQUM7QUFDM0UsQ0FBQyJ9

package/dist/esm/test/mocks.d.ts

@@ -0,0 +1,20 @@
+import { Account, Chain, PublicClient, Transport, WalletClient } from 'viem';
+import { vi } from 'vitest';
+import { KmsClient } from '../kms/client.js';
+import { KmsQuorumClient } from '../kms/quorumClient.js';
+interface MinimalKmsClient {
+    attestedCompute: ReturnType<typeof vi.fn>;
+    attestedDecrypt: ReturnType<typeof vi.fn>;
+    attestedReveal: ReturnType<typeof vi.fn>;
+    eListAttestedDecrypt: ReturnType<typeof vi.fn>;
+    eListAttestedReveal: ReturnType<typeof vi.fn>;
+    key: ReturnType<typeof vi.fn>;
+    reencrypt: ReturnType<typeof vi.fn>;
+}
+export declare function createMockKmsClient(): MinimalKmsClient & KmsClient;
+export declare function createMockQuorumClient(): KmsQuorumClient;
+export declare function setupMockInQuorumClient(quorumClient: KmsQuorumClient, mockKmsClient: MinimalKmsClient & KmsClient): void;
+export declare function createMockPublicClient(): PublicClient<Transport, Chain>;
+export declare function createTestWalletClient(): WalletClient<Transport, Chain, Account>;
+export declare function createFallbackWalletClient(): WalletClient<Transport, Chain, Account>;
+export {};

package/dist/esm/test/mocks.js

@@ -0,0 +1,64 @@
+import { createPublicClient, createWalletClient, fallback, http, } from 'viem';
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+import { sepolia } from 'viem/chains';
+import { vi } from 'vitest';
+import { TEST_DEFAULT_COVALIDATOR_SIGNER } from '../kms/client.js';
+import { KmsQuorumClient } from '../kms/quorumClient.js';
+// Create a mock that satisfies our minimal interface
+export function createMockKmsClient() {
+    return {
+        attestedCompute: vi.fn(),
+        attestedDecrypt: vi.fn(),
+        attestedReveal: vi.fn(),
+        eListAttestedDecrypt: vi.fn(),
+        eListAttestedReveal: vi.fn(),
+        key: vi.fn(),
+        reencrypt: vi.fn(),
+    };
+}
+// Create a mock KmsQuorumClient from a mock KmsClient for testing
+export function createMockQuorumClient() {
+    // Use the private constructor via type casting (similar to quorumClient.test.ts)
+    const AnyClass = KmsQuorumClient;
+    return new AnyClass([{ url: 'https://mock-kms', signer: TEST_DEFAULT_COVALIDATOR_SIGNER }], 1);
+}
+// Helper to set up the mock client inside the quorum client
+export function setupMockInQuorumClient(quorumClient, mockKmsClient) {
+    // Access private kmss array and replace the client
+    const anyQuorumClient = quorumClient;
+    if (anyQuorumClient.kmss && anyQuorumClient.kmss.length > 0) {
+        anyQuorumClient.kmss[0].client = mockKmsClient;
+    }
+}
+// Create a public client for testing (transport URL is never actually called;
+// publicClient is required by attestedDecrypt/attestedCompute but KMS is mocked in tests)
+export function createMockPublicClient() {
+    return createPublicClient({
+        chain: sepolia,
+        transport: http('http://localhost:8567'),
+    });
+}
+// Create a wallet client for testing (transport URL is never actually called;
+// signing with a local key account does not require an RPC connection)
+export function createTestWalletClient() {
+    const account = privateKeyToAccount(generatePrivateKey());
+    return createWalletClient({
+        chain: sepolia, // Arbitrary chain, not relevant to test
+        transport: http('http://localhost:8567'),
+        account,
+    });
+}
+// Create a wallet client with a fallback() transport for testing that code
+// handles non-http transports correctly (fallback has no .url property)
+export function createFallbackWalletClient() {
+    const account = privateKeyToAccount(generatePrivateKey());
+    return createWalletClient({
+        chain: sepolia,
+        transport: fallback([
+            http('http://localhost:8567'),
+            http('http://localhost:8568'),
+        ]),
+        account,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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