@openzeppelin/miden-multisig-client 0.17.0-rc.2 → 0.17.0

package/src/raw-client.test.ts

@@ -1,171 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-const { mockCreateClient } = vi.hoisted(() => ({
-  mockCreateClient: vi.fn(),
-}));
-
-vi.mock('@miden-sdk/miden-sdk', () => ({
-  WasmWebClient: {
-    createClient: mockCreateClient,
-  },
-}));
-
-import {
-  compileTxScript,
-  getRawMidenClient,
-  getTransactionProver,
-  requireConfigValue,
-} from './raw-client.js';
-
-describe('raw-client', () => {
-  beforeEach(() => {
-    mockCreateClient.mockReset();
-  });
-
-  it.each([undefined, null, 42, {}, []])(
-    'rejects non-string configuration value %j consistently',
-    (value) => {
-      expect(() => requireConfigValue('guardianEndpoint', value)).toThrow(
-        'missing required configuration: guardianEndpoint',
-      );
-    },
-  );
-
-  it('trims surrounding whitespace from configuration values', () => {
-    expect(requireConfigValue('guardianEndpoint', '  http://localhost:3000\n')).toBe(
-      'http://localhost:3000',
-    );
-  });
-
-  it('rejects shadow client creation without an RPC endpoint', async () => {
-    const client = {
-      accounts: {},
-      sync: vi.fn(),
-      defaultProver: null,
-      storeIdentifier: vi.fn(() => 'browser-db'),
-    };
-
-    await expect(getRawMidenClient(client as any)).rejects.toThrow(
-      'missing required configuration: midenRpcEndpoint',
-    );
-    await expect(getRawMidenClient(client as any, '   ')).rejects.toThrow(
-      'missing required configuration: midenRpcEndpoint',
-    );
-    expect(mockCreateClient).not.toHaveBeenCalled();
-  });
-
-  it('returns an injected raw web client without needing an endpoint', async () => {
-    const rawClient = {
-      executeTransaction: vi.fn(),
-      proveTransaction: vi.fn(),
-    };
-
-    await expect(getRawMidenClient(rawClient as any)).resolves.toBe(rawClient);
-    expect(mockCreateClient).not.toHaveBeenCalled();
-  });
-
-  it('returns the default prover from a public MidenClient', () => {
-    const prover = { kind: 'devnet-prover' };
-    const client = {
-      accounts: {},
-      sync: vi.fn(),
-      defaultProver: prover,
-      storeIdentifier: vi.fn(() => 'browser-db'),
-    };
-
-    expect(getTransactionProver(client as any)).toBe(prover);
-  });
-
-  it('returns null for raw web clients', () => {
-    const rawClient = {
-      executeTransaction: vi.fn(),
-      proveTransaction: vi.fn(),
-    };
-
-    expect(getTransactionProver(rawClient as any)).toBeNull();
-  });
-
-  it('creates and caches a raw client for a public MidenClient', async () => {
-    const rawClient = { kind: 'raw-client' };
-    const client = {
-      accounts: {},
-      sync: vi.fn(),
-      defaultProver: null,
-      storeIdentifier: vi.fn(() => 'browser-db'),
-    };
-
-    mockCreateClient.mockResolvedValue(rawClient);
-
-    await expect(
-      getRawMidenClient(client as any, 'https://rpc.devnet.miden.io'),
-    ).resolves.toBe(rawClient);
-    await expect(
-      getRawMidenClient(client as any, 'https://rpc.devnet.miden.io'),
-    ).resolves.toBe(rawClient);
-
-    expect(mockCreateClient).toHaveBeenCalledTimes(1);
-    expect(mockCreateClient).toHaveBeenCalledWith(
-      'https://rpc.devnet.miden.io',
-      undefined,
-      undefined,
-      'browser-db',
-    );
-  });
-
-  it('uses the public compile resource when available', async () => {
-    const script = { kind: 'compiled-script' };
-    const client = {
-      accounts: {},
-      sync: vi.fn(),
-      compile: {
-        txScript: vi.fn().mockResolvedValue(script),
-      },
-      storeIdentifier: vi.fn(() => 'browser-db'),
-    };
-
-    await expect(
-      compileTxScript(
-        client as any,
-        'begin end',
-        [{ namespace: 'auth::multisig', code: 'export.foo' }],
-      ),
-    ).resolves.toBe(script);
-
-    expect(client.compile.txScript).toHaveBeenCalledWith({
-      code: 'begin end',
-      libraries: [{ namespace: 'auth::multisig', code: 'export.foo' }],
-    });
-    expect(mockCreateClient).not.toHaveBeenCalled();
-  });
-
-  it('falls back to raw client compilation for low-level callers', async () => {
-    const compiledScript = { kind: 'compiled-script' };
-    const builtLibrary = { kind: 'built-library' };
-    const builder = {
-      buildLibrary: vi.fn().mockReturnValue(builtLibrary),
-      linkDynamicLibrary: vi.fn(),
-      linkStaticLibrary: vi.fn(),
-      compileTxScript: vi.fn().mockReturnValue(compiledScript),
-    };
-    const rawClient = {
-      createCodeBuilder: vi.fn().mockReturnValue(builder),
-    };
-
-    await expect(
-      compileTxScript(
-        rawClient as any,
-        'begin end',
-        [
-          { namespace: 'auth::multisig', code: 'export.foo' },
-          { namespace: 'auth::guardian', code: 'export.bar', linking: 'static' },
-        ],
-      ),
-    ).resolves.toBe(compiledScript);
-
-    expect(builder.buildLibrary).toHaveBeenNthCalledWith(1, 'auth::multisig', 'export.foo');
-    expect(builder.buildLibrary).toHaveBeenNthCalledWith(2, 'auth::guardian', 'export.bar');
-    expect(builder.linkDynamicLibrary).toHaveBeenCalledWith(builtLibrary);
-    expect(builder.linkStaticLibrary).toHaveBeenCalledWith(builtLibrary);
-    expect(builder.compileTxScript).toHaveBeenCalledWith('begin end');
-  });
-});

package/src/rpc/config.test.ts

@@ -1,45 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { describe, expect, it } from 'vitest';
-import { resolveRpcConfig } from './config.js';
-
-interface Fixtures {
-  attemptBudgets: Array<{ input: number | null; normalized: number }>;
-}
-
-function fixtures(): Fixtures {
-  return JSON.parse(
-    readFileSync(
-      new URL(
-        '../../../../fixtures/miden-multisig-client/rpc-policy-fixtures.json',
-        import.meta.url,
-      ),
-      'utf8',
-    ),
-  ) as Fixtures;
-}
-
-describe('resolveRpcConfig', () => {
-  it('matches shared attempt-budget vectors', () => {
-    for (const fixture of fixtures().attemptBudgets) {
-      const retry = fixture.input === null ? undefined : { maxAttempts: fixture.input };
-      expect(resolveRpcConfig({ retry }).maxAttempts).toBe(fixture.normalized);
-    }
-  });
-
-  it('defaults to one retry when no config is given', () => {
-    expect(resolveRpcConfig(undefined).maxAttempts).toBe(2);
-  });
-
-  it('treats an explicit single attempt as a full opt-out', () => {
-    expect(resolveRpcConfig({ retry: { maxAttempts: 1 } }).maxAttempts).toBe(1);
-  });
-
-  it.each([-1, 1.5, Number.NaN, Number.POSITIVE_INFINITY, 4_294_967_296])(
-    'rejects invalid maxAttempts value %s',
-    (maxAttempts) => {
-      expect(() => resolveRpcConfig({ retry: { maxAttempts } })).toThrow(
-        'rpc.retry.maxAttempts',
-      );
-    },
-  );
-});

package/src/rpc/errors.test.ts

@@ -1,69 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { describe, expect, it } from 'vitest';
-import { isTransientRpcError } from './errors.js';
-
-interface FixtureError {
-  code?: string;
-  status?: number;
-  message: string;
-  cause?: FixtureError;
-}
-
-interface Fixtures {
-  classifications: Array<{
-    name: string;
-    chain: FixtureError[];
-    transient: boolean;
-  }>;
-}
-
-function fixtures(): Fixtures {
-  return JSON.parse(
-    readFileSync(
-      new URL(
-        '../../../../fixtures/miden-multisig-client/rpc-policy-fixtures.json',
-        import.meta.url,
-      ),
-      'utf8',
-    ),
-  ) as Fixtures;
-}
-
-describe('isTransientRpcError', () => {
-  it('matches every shared classification vector', () => {
-    for (const fixture of fixtures().classifications) {
-      const error = fixture.chain.reduceRight<FixtureError | undefined>(
-        (cause, item) => ({ ...item, cause }),
-        undefined,
-      );
-      expect(isTransientRpcError(error), fixture.name).toBe(fixture.transient);
-    }
-  });
-
-  it('stops safely on cyclic cause graphs', () => {
-    const error: FixtureError = { code: 'Unknown', message: 'not retryable' };
-    error.cause = error;
-    expect(isTransientRpcError(error)).toBe(false);
-  });
-
-  it('recognizes numeric gRPC status codes', () => {
-    expect(isTransientRpcError({ code: 14, message: 'unavailable' })).toBe(true);
-    expect(isTransientRpcError({ code: 3, message: 'timeout text' })).toBe(false);
-  });
-
-  it('keeps permanent status evidence ahead of transport wording', () => {
-    expect(
-      isTransientRpcError({
-        code: 'FailedPrecondition',
-        message: 'transport error while checking preconditions',
-      }),
-    ).toBe(false);
-  });
-
-  it('reads grpc code wording out of plain message text', () => {
-    expect(isTransientRpcError(new Error('grpc code: InvalidArgument; request timeout'))).toBe(
-      false,
-    );
-    expect(isTransientRpcError(new Error('grpc code: Unavailable'))).toBe(true);
-  });
-});

package/src/rpc/retry.test.ts

@@ -1,144 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { describe, expect, it, vi } from 'vitest';
-import { resolveRpcConfig } from './config.js';
-import { retryRpcRead } from './retry.js';
-import type { RetryRuntime } from '../retry/runtime.js';
-import { retryDelay } from '../retry/runtime.js';
-
-interface Fixtures {
-  delays: Array<{ retryIndex: number; unitRandom: number; delayMs: number }>;
-}
-
-function fixtures(): Fixtures {
-  return JSON.parse(
-    readFileSync(
-      new URL(
-        '../../../../fixtures/miden-multisig-client/rpc-policy-fixtures.json',
-        import.meta.url,
-      ),
-      'utf8',
-    ),
-  ) as Fixtures;
-}
-
-function recordingRuntime(): RetryRuntime & { sleeps: number[] } {
-  const sleeps: number[] = [];
-  return {
-    sleeps,
-    sleep: (delayMs) => {
-      sleeps.push(delayMs);
-      return Promise.resolve();
-    },
-    unitRandom: () => 0.5,
-  };
-}
-
-function rateLimitError(): Error {
-  return Object.assign(new Error('Too Many Requests!'), {
-    code: 'ResourceExhausted',
-  });
-}
-
-describe('retryRpcRead', () => {
-  it('matches every shared delay vector', () => {
-    for (const fixture of fixtures().delays) {
-      expect(retryDelay(fixture.retryIndex, fixture.unitRandom)).toBe(fixture.delayMs);
-    }
-  });
-
-  it('waits out rate limiting and returns the eventual result', async () => {
-    const runtime = recordingRuntime();
-    const operation = vi
-      .fn()
-      .mockRejectedValueOnce(rateLimitError())
-      .mockRejectedValueOnce(rateLimitError())
-      .mockResolvedValueOnce('synced');
-
-    const result = await retryRpcRead(
-      operation,
-      resolveRpcConfig({ retry: { maxAttempts: 3 } }),
-      runtime,
-    );
-
-    expect(result).toBe('synced');
-    expect(operation).toHaveBeenCalledTimes(3);
-    expect(runtime.sleeps).toEqual([retryDelay(0, 0.5), retryDelay(1, 0.5)]);
-  });
-
-  it('throws a permanent error immediately without sleeping', async () => {
-    const runtime = recordingRuntime();
-    const permanent = Object.assign(new Error('malformed account id'), {
-      code: 'InvalidArgument',
-    });
-    const operation = vi.fn().mockRejectedValue(permanent);
-
-    await expect(
-      retryRpcRead(operation, resolveRpcConfig({ retry: { maxAttempts: 5 } }), runtime),
-    ).rejects.toBe(permanent);
-    expect(operation).toHaveBeenCalledTimes(1);
-    expect(runtime.sleeps).toEqual([]);
-  });
-
-  it('rethrows the final upstream error unchanged after budget exhaustion', async () => {
-    const runtime = recordingRuntime();
-    const final = Object.assign(new Error('still rate limited'), {
-      code: 'ResourceExhausted',
-    });
-    const operation = vi
-      .fn()
-      .mockRejectedValueOnce(rateLimitError())
-      .mockRejectedValueOnce(final);
-
-    await expect(
-      retryRpcRead(operation, resolveRpcConfig({ retry: { maxAttempts: 2 } }), runtime),
-    ).rejects.toBe(final);
-    expect(operation).toHaveBeenCalledTimes(2);
-    expect(runtime.sleeps).toHaveLength(1);
-  });
-
-  it('retries a transient read once under the default config', async () => {
-    const runtime = recordingRuntime();
-    const operation = vi
-      .fn()
-      .mockRejectedValueOnce(rateLimitError())
-      .mockResolvedValueOnce('synced');
-
-    await expect(retryRpcRead(operation, resolveRpcConfig(undefined), runtime)).resolves.toBe(
-      'synced',
-    );
-    expect(operation).toHaveBeenCalledTimes(2);
-    expect(runtime.sleeps).toHaveLength(1);
-  });
-
-  it('never retries under an explicit single-attempt config', async () => {
-    const runtime = recordingRuntime();
-    const operation = vi.fn().mockRejectedValue(rateLimitError());
-
-    await expect(
-      retryRpcRead(operation, resolveRpcConfig({ retry: { maxAttempts: 1 } }), runtime),
-    ).rejects.toThrow('Too Many Requests!');
-    expect(operation).toHaveBeenCalledTimes(1);
-    expect(runtime.sleeps).toEqual([]);
-  });
-
-  it('completes 64 concurrent reads against a rate-limited node', async () => {
-    const runtime = recordingRuntime();
-    let rejected = 0;
-    const operation = () => {
-      if (rejected < 40) {
-        rejected += 1;
-        return Promise.reject(rateLimitError());
-      }
-      return Promise.resolve('synced');
-    };
-
-    const results = await Promise.all(
-      Array.from({ length: 64 }, () =>
-        retryRpcRead(operation, resolveRpcConfig({ retry: { maxAttempts: 4 } }), runtime),
-      ),
-    );
-
-    expect(results).toEqual(Array.from({ length: 64 }, () => 'synced'));
-    expect(rejected).toBe(40);
-  });
-});

package/src/signers/ecdsa.test.ts

@@ -1,111 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from 'vitest';
-import { EcdsaSigner } from './ecdsa.js';
-
-vi.mock('@miden-sdk/miden-sdk', () => {
-  const mockSignature = {
-    serialize: () => new Uint8Array([0, 1, 2, 3, 4, 5]),
-  };
-
-  const mockCommitment = {
-    toHex: () => '0x' + 'a'.repeat(64),
-  };
-
-  const mockPublicKey = {
-    toCommitment: () => mockCommitment,
-    serialize: () => new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
-  };
-
-  const mockSecretKey = {
-    publicKey: vi.fn().mockReturnValue(mockPublicKey),
-    sign: vi.fn().mockReturnValue(mockSignature),
-  };
-
-  return {
-    AuthSecretKey: vi.fn(),
-    Word: {
-      fromHex: vi.fn((hex: string) => ({
-        toHex: () => hex,
-        toFelts: () => [1, 2, 3, 4],
-      })),
-    },
-    AccountId: {
-      fromHex: vi.fn((hex: string) => ({
-        toString: () => hex,
-        prefix: () => ({ asInt: () => BigInt(1) }),
-        suffix: () => ({ asInt: () => BigInt(2) }),
-      })),
-    },
-    Felt: vi.fn().mockImplementation((value: bigint) => ({ value })),
-    FeltArray: vi.fn().mockImplementation((elements: unknown[]) => elements),
-    Rpo256: {
-      hashElements: vi.fn().mockReturnValue({
-        toHex: () => '0x' + 'b'.repeat(64),
-        toFelts: () => [1, 2, 3, 4],
-      }),
-    },
-  };
-});
-
-describe('EcdsaSigner', () => {
-  let mockSecretKey: {
-    publicKey: ReturnType<typeof vi.fn>;
-    sign: ReturnType<typeof vi.fn>;
-  };
-  let signer: EcdsaSigner;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    mockSecretKey = {
-      publicKey: vi.fn().mockReturnValue({
-        toCommitment: () => ({ toHex: () => '0x' + 'a'.repeat(64) }),
-        serialize: () => new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
-      }),
-      sign: vi.fn().mockReturnValue({
-        serialize: () => new Uint8Array([0, 1, 2, 3, 4, 5]),
-      }),
-    };
-    signer = new EcdsaSigner(mockSecretKey as never);
-  });
-
-  it('signs request-bound auth messages for ECDSA', async () => {
-    const { Rpo256 } = await import('@miden-sdk/miden-sdk');
-
-    const signature = await signer.signRequest(
-      '0x' + 'a'.repeat(30),
-      1700000000,
-      { toBytes: () => new Uint8Array([1, 2, 3, 4]) } as never,
-    );
-
-    expect(signature).toBe('0x0102030405');
-    expect(mockSecretKey.sign).toHaveBeenCalled();
-    expect(Rpo256.hashElements).toHaveBeenCalledTimes(2);
-  });
-
-  it('skips rebinding when the signer key is already attached to the same account', async () => {
-    const accountId = '0x' + 'd'.repeat(30);
-    const midenClient = {
-      keystore: {
-        getAccountId: vi.fn().mockResolvedValue({ toString: () => accountId }),
-        insert: vi.fn().mockResolvedValue(undefined),
-      },
-    };
-
-    await signer.bindAccountKey(midenClient as never, accountId);
-
-    expect(midenClient.keystore.insert).not.toHaveBeenCalled();
-  });
-
-  it('throws when the signer key is already attached to a different account', async () => {
-    const midenClient = {
-      keystore: {
-        getAccountId: vi.fn().mockResolvedValue({ toString: () => '0x' + 'e'.repeat(30) }),
-        insert: vi.fn().mockResolvedValue(undefined),
-      },
-    };
-
-    await expect(
-      signer.bindAccountKey(midenClient as never, '0x' + 'd'.repeat(30)),
-    ).rejects.toThrow('already bound to account');
-    expect(midenClient.keystore.insert).not.toHaveBeenCalled();
-  });
-});