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

package/src/proposal/factory.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { DeltaStatus } from '@openzeppelin/guardian-client';
-import { ProposalFactory } from './factory.js';
-
-describe('ProposalFactory.toStatus', () => {
-  const factory = new ProposalFactory({
-    accountId: '0x' + 'a'.repeat(30),
-    signerCommitments: [],
-    resolveRequiredSignatures: () => 2,
-  });
-  // TS `private` is compile-time only; the mapping is worth pinning
-  // without dragging a full tx summary through `fromDelta`.
-  const toStatus = (status: DeltaStatus) =>
-    (factory as unknown as { toStatus: (s: DeltaStatus, t: string, sigs: unknown[]) => string })
-      .toStatus(status, 'p2id', []);
-
-  it('maps every terminal delta status to finalized (issue #345)', () => {
-    // A retained delta left the active candidate path: no longer
-    // signable, so finalized here — whether it landed is resolved by
-    // background reconciliation via the delta status, not the proposal
-    // list.
-    expect(toStatus({ status: 'canonical', timestamp: 't' })).toBe('finalized');
-    // Cast until the published guardian-client types include `retained`.
-    expect(
-      toStatus({
-        status: 'retained',
-        timestamp: 't',
-        reason: 'retry_exhausted',
-      } as unknown as DeltaStatus),
-    ).toBe('finalized');
-    expect(toStatus({ status: 'discarded', timestamp: 't' })).toBe('finalized');
-  });
-
-  it('maps active statuses to pending/ready', () => {
-    expect(toStatus({ status: 'candidate', timestamp: 't' })).toBe('ready');
-    expect(
-      toStatus({ status: 'pending', timestamp: 't', proposerId: 'p', cosignerSigs: [] }),
-    ).toBe('pending');
-  });
-});

package/src/proposal/metadata.test.ts

@@ -1,235 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { ProposalMetadata as GuardianProposalMetadata } from '@openzeppelin/guardian-client';
-import { ProposalMetadataCodec } from './metadata.js';
-import type {
-  ConsumeNotesProposalMetadata,
-  CustomProposalMetadata,
-  P2IdProposalMetadata,
-} from '../types/proposal.js';
-
-describe('ProposalMetadataCodec consume_notes v2 round-trip (issue #229)', () => {
-  it('toGuardian threads metadataVersion and notes to the wire', () => {
-    const md: ConsumeNotesProposalMetadata = {
-      proposalType: 'consume_notes',
-      description: 'consume one note',
-      noteIds: ['0xabc'],
-      metadataVersion: 2,
-      notes: ['YmFzZTY0Tm90ZQ=='],
-    };
-    const wire = ProposalMetadataCodec.toGuardian(md);
-    expect(wire.noteIds).toEqual(['0xabc']);
-    expect(wire.consumeNotesMetadataVersion).toBe(2);
-    expect(wire.consumeNotesNotes).toEqual(['YmFzZTY0Tm90ZQ==']);
-  });
-
-  it('fromGuardian reconstructs the v2 fields', () => {
-    const wire: GuardianProposalMetadata = {
-      proposalType: 'consume_notes',
-      noteIds: ['0xabc'],
-      consumeNotesMetadataVersion: 2,
-      consumeNotesNotes: ['YmFzZTY0Tm90ZQ=='],
-    };
-    const md = ProposalMetadataCodec.fromGuardian(wire) as ConsumeNotesProposalMetadata;
-    expect(md.proposalType).toBe('consume_notes');
-    expect(md.metadataVersion).toBe(2);
-    expect(md.notes).toEqual(['YmFzZTY0Tm90ZQ==']);
-  });
-
-  it('round-trips a v1 (legacy) proposal without spurious v2 fields', () => {
-    const md: ConsumeNotesProposalMetadata = {
-      proposalType: 'consume_notes',
-      description: 'legacy',
-      noteIds: ['0xabc'],
-    };
-    const wire = ProposalMetadataCodec.toGuardian(md);
-    expect(wire.consumeNotesMetadataVersion).toBeUndefined();
-    expect(wire.consumeNotesNotes).toBeUndefined();
-    const back = ProposalMetadataCodec.fromGuardian(wire) as ConsumeNotesProposalMetadata;
-    expect(back.metadataVersion).toBeUndefined();
-    expect(back.notes).toBeUndefined();
-  });
-});
-
-describe('ProposalMetadataCodec custom proposal types (issue #266)', () => {
-  it('fromGuardian collapses an unmodeled type to the custom bucket, keeping the raw label', () => {
-    const wire: GuardianProposalMetadata = {
-      proposalType: 'b2agg',
-      description: 'agglayer bridge note',
-    };
-    const md = ProposalMetadataCodec.fromGuardian(wire) as CustomProposalMetadata;
-    expect(md.proposalType).toBe('custom');
-    expect(md.rawProposalType).toBe('b2agg');
-  });
-
-  it('toGuardian round-trips the raw label, not the custom bucket', () => {
-    const md: CustomProposalMetadata = {
-      proposalType: 'custom',
-      description: 'agglayer bridge note',
-      rawProposalType: 'b2agg',
-    };
-    const wire = ProposalMetadataCodec.toGuardian(md);
-    expect(wire.proposalType).toBe('b2agg');
-
-    const back = ProposalMetadataCodec.fromGuardian(wire) as CustomProposalMetadata;
-    expect(back.proposalType).toBe('custom');
-    expect(back.rawProposalType).toBe('b2agg');
-  });
-
-  it('validate accepts a custom proposal', () => {
-    const md: CustomProposalMetadata = {
-      proposalType: 'custom',
-      description: 'opaque',
-      rawProposalType: 'b2agg',
-    };
-    expect(ProposalMetadataCodec.validate(md)).toBe(md);
-  });
-
-  it('round-trips update_procedure_threshold through the codec', () => {
-    const wire: GuardianProposalMetadata = {
-      proposalType: 'update_procedure_threshold',
-      targetProcedure: 'send_asset',
-      targetThreshold: 2,
-    };
-    const md = ProposalMetadataCodec.fromGuardian(wire);
-    expect(md.proposalType).toBe('update_procedure_threshold');
-    const back = ProposalMetadataCodec.toGuardian(md);
-    expect(back.proposalType).toBe('update_procedure_threshold');
-    expect(back.targetProcedure).toBe('send_asset');
-    expect(back.targetThreshold).toBe(2);
-  });
-});
-
-describe('ProposalMetadataCodec p2id noteType (issue #322)', () => {
-  const baseWire: GuardianProposalMetadata = {
-    proposalType: 'p2id',
-    recipientId: '0xrecipient',
-    faucetId: '0xfaucet',
-    amount: '1000',
-  };
-
-  it('round-trips a private noteType through the codec', () => {
-    const md = ProposalMetadataCodec.fromGuardian({
-      ...baseWire,
-      noteType: 'private',
-    }) as P2IdProposalMetadata;
-    expect(md.noteType).toBe('private');
-
-    const wire = ProposalMetadataCodec.toGuardian(md);
-    expect(wire.noteType).toBe('private');
-  });
-
-  it('leaves noteType absent for legacy proposals (=> public)', () => {
-    const md = ProposalMetadataCodec.fromGuardian(baseWire) as P2IdProposalMetadata;
-    expect(md.noteType).toBeUndefined();
-    expect(ProposalMetadataCodec.toGuardian(md).noteType).toBeUndefined();
-  });
-
-  it('canonicalizes an explicit public noteType to absent on encode', () => {
-    const md = {
-      proposalType: 'p2id',
-      description: '',
-      recipientId: '0xrecipient',
-      faucetId: '0xfaucet',
-      amount: '1000',
-      noteType: 'public',
-    } as P2IdProposalMetadata;
-
-    // toGuardian omits the field so a public note keeps the pre-#322 wire
-    // shape and matches the Rust encoder, even if handed an explicit 'public'.
-    expect(ProposalMetadataCodec.toGuardian(md).noteType).toBeUndefined();
-  });
-
-  it('fromGuardian rejects an unsupported noteType', () => {
-    expect(() =>
-      ProposalMetadataCodec.fromGuardian({ ...baseWire, noteType: 'encrypted' }),
-    ).toThrow(/unsupported noteType/);
-  });
-
-  it('validate rejects an unsupported noteType', () => {
-    const md = {
-      proposalType: 'p2id',
-      description: '',
-      recipientId: '0xrecipient',
-      faucetId: '0xfaucet',
-      amount: '1000',
-      noteType: 'encrypted',
-    } as unknown as P2IdProposalMetadata;
-    expect(() => ProposalMetadataCodec.validate(md)).toThrow(/unsupported noteType/);
-  });
-});
-
-describe('ProposalMetadataCodec p2id P2IDE heights (issue #366)', () => {
-  const baseWire: GuardianProposalMetadata = {
-    proposalType: 'p2id',
-    recipientId: '0xrecipient',
-    faucetId: '0xfaucet',
-    amount: '1000',
-  };
-
-  it('round-trips reclaim and timelock heights through the codec', () => {
-    const md = ProposalMetadataCodec.fromGuardian({
-      ...baseWire,
-      reclaimHeight: 12345,
-      timelockHeight: 700,
-    }) as P2IdProposalMetadata;
-    expect(md.reclaimHeight).toBe(12345);
-    expect(md.timelockHeight).toBe(700);
-
-    const wire = ProposalMetadataCodec.toGuardian(md);
-    expect(wire.reclaimHeight).toBe(12345);
-    expect(wire.timelockHeight).toBe(700);
-  });
-
-  it('leaves heights absent for plain P2ID proposals (pre-#366 wire shape)', () => {
-    const md = ProposalMetadataCodec.fromGuardian(baseWire) as P2IdProposalMetadata;
-    expect(md.reclaimHeight).toBeUndefined();
-    expect(md.timelockHeight).toBeUndefined();
-
-    const wire = ProposalMetadataCodec.toGuardian(md);
-    expect(wire.reclaimHeight).toBeUndefined();
-    expect(wire.timelockHeight).toBeUndefined();
-  });
-
-  it('fromGuardian rejects a zero height (encodes "no constraint" on-chain)', () => {
-    expect(() =>
-      ProposalMetadataCodec.fromGuardian({ ...baseWire, reclaimHeight: 0 }),
-    ).toThrow(/unsupported reclaimHeight/);
-  });
-
-  it('fromGuardian rejects a non-integer or out-of-range height', () => {
-    expect(() =>
-      ProposalMetadataCodec.fromGuardian({ ...baseWire, timelockHeight: 1.5 }),
-    ).toThrow(/unsupported timelockHeight/);
-    expect(() =>
-      ProposalMetadataCodec.fromGuardian({ ...baseWire, reclaimHeight: 0x1_0000_0000 }),
-    ).toThrow(/unsupported reclaimHeight/);
-  });
-
-  it('validate rejects an invalid height', () => {
-    const md = {
-      proposalType: 'p2id',
-      description: '',
-      recipientId: '0xrecipient',
-      faucetId: '0xfaucet',
-      amount: '1000',
-      reclaimHeight: -1,
-    } as unknown as P2IdProposalMetadata;
-    expect(() => ProposalMetadataCodec.validate(md)).toThrow(/unsupported reclaimHeight/);
-  });
-
-  it('toGuardian rejects an invalid height instead of emitting it on the wire', () => {
-    const base = {
-      proposalType: 'p2id',
-      description: '',
-      recipientId: '0xrecipient',
-      faucetId: '0xfaucet',
-      amount: '1000',
-    };
-    expect(() =>
-      ProposalMetadataCodec.toGuardian({ ...base, reclaimHeight: 0 } as P2IdProposalMetadata),
-    ).toThrow(/unsupported reclaimHeight/);
-    expect(() =>
-      ProposalMetadataCodec.toGuardian({ ...base, timelockHeight: 1.5 } as P2IdProposalMetadata),
-    ).toThrow(/unsupported timelockHeight/);
-  });
-});

package/src/prover/config.test.ts

@@ -1,90 +0,0 @@
-import { readFileSync } from 'node:fs';
-import type { TransactionProver } from '@miden-sdk/miden-sdk';
-import { describe, expect, it } from 'vitest';
-import { resolveProverConfig } from './config.js';
-
-interface Fixtures {
-  attemptBudgets: Array<{ input: number | null; normalized: number }>;
-  endpoints: Array<{
-    input: string;
-    valid: boolean;
-    canonical?: string;
-  }>;
-}
-
-function fixtures(): Fixtures {
-  return JSON.parse(
-    readFileSync(
-      new URL(
-        '../../../../fixtures/miden-multisig-client/prover-policy-fixtures.json',
-        import.meta.url,
-      ),
-      'utf8',
-    ),
-  ) as Fixtures;
-}
-
-describe('resolveProverConfig', () => {
-  it('matches shared URL vectors', () => {
-    for (const fixture of fixtures().endpoints) {
-      const resolve = () => resolveProverConfig({ url: fixture.input }, null);
-      if (fixture.valid) {
-        expect(resolve().url, fixture.input).toBe(fixture.canonical);
-      } else {
-        expect(resolve, fixture.input).toThrow();
-      }
-    }
-  });
-
-  it('matches shared attempt-budget vectors for remote proving', () => {
-    for (const fixture of fixtures().attemptBudgets) {
-      const retry = fixture.input === null ? undefined : { maxAttempts: fixture.input };
-      const resolved = resolveProverConfig(
-        { url: 'https://prover.example', retry },
-        null,
-      );
-      expect(resolved.maxAttempts).toBe(fixture.normalized);
-    }
-  });
-
-  it.each([-1, 1.5, Number.NaN, Number.POSITIVE_INFINITY, 4_294_967_296])(
-    'rejects invalid maxAttempts value %s',
-    (maxAttempts) => {
-      expect(() =>
-        resolveProverConfig(
-          { url: 'https://prover.example', retry: { maxAttempts } },
-          null,
-        ),
-      ).toThrow('prover.retry.maxAttempts');
-    },
-  );
-
-  it('keeps an endpoint-less injected prover at one attempt without serializing it', () => {
-    const serialize = () => {
-      throw new Error('callback provers cannot be serialized');
-    };
-    const callback = {
-      endpoint: () => undefined,
-      serialize,
-    } as unknown as TransactionProver;
-
-    expect(resolveProverConfig({ retry: { maxAttempts: 5 } }, callback)).toMatchObject({
-      kind: 'injected',
-      maxAttempts: 1,
-    });
-  });
-
-  it('lets a custom remote URL override an injected local prover', () => {
-    const local = {
-      serialize: () => 'local',
-      endpoint: () => undefined,
-    } as unknown as TransactionProver;
-    expect(
-      resolveProverConfig({ url: 'https://prover.example' }, local),
-    ).toMatchObject({
-      kind: 'remote',
-      url: 'https://prover.example/',
-      maxAttempts: 2,
-    });
-  });
-});

package/src/prover/errors.test.ts

@@ -1,61 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { describe, expect, it } from 'vitest';
-import { isTransientProverError } 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/prover-policy-fixtures.json',
-        import.meta.url,
-      ),
-      'utf8',
-    ),
-  ) as Fixtures;
-}
-
-describe('isTransientProverError', () => {
-  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(isTransientProverError(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(isTransientProverError(error)).toBe(false);
-  });
-
-  it('recognizes numeric gRPC status codes', () => {
-    expect(isTransientProverError({ code: 14, message: 'unavailable' })).toBe(true);
-    expect(isTransientProverError({ code: 3, message: 'timeout text' })).toBe(false);
-  });
-
-  it('reads grpc code wording out of plain message text', () => {
-    expect(isTransientProverError(new Error('grpc code: NotFound'))).toBe(false);
-    expect(
-      isTransientProverError(new Error('grpc code: Internal; nested timeout')),
-    ).toBe(false);
-    expect(isTransientProverError(new Error('grpc code: Unavailable'))).toBe(true);
-  });
-});

package/src/prover/retry.test.ts

@@ -1,38 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { describe, expect, it } from 'vitest';
-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/prover-policy-fixtures.json',
-        import.meta.url,
-      ),
-      'utf8',
-    ),
-  ) as Fixtures;
-}
-
-describe('retryDelay', () => {
-  it('matches every shared delay vector', () => {
-    for (const fixture of fixtures().delays) {
-      expect(retryDelay(fixture.retryIndex, fixture.unitRandom)).toBe(fixture.delayMs);
-    }
-  });
-
-  it('remains capped after numeric overflow', () => {
-    expect(retryDelay(Number.MAX_SAFE_INTEGER, 0.5)).toBe(8_000);
-  });
-
-  it.each([Number.NaN, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY])(
-    'uses neutral jitter for non-finite randomness',
-    (unitRandom) => {
-      expect(retryDelay(0, unitRandom)).toBe(500);
-    },
-  );
-});

package/src/prover/workflow.test.ts

@@ -1,145 +0,0 @@
-import type {
-  AccountId,
-  ChainAnchor,
-  MidenClient,
-  TransactionProver,
-  TransactionRequest,
-} from '@miden-sdk/miden-sdk';
-import { describe, expect, it, vi } from 'vitest';
-import type { ResolvedProverConfig } from './config.js';
-import type { RetryRuntime } from '../retry/runtime.js';
-import { ProverWorkflow } from './workflow.js';
-
-function asType<T>(value: unknown): T {
-  return value as T;
-}
-
-const anchor = asType<ChainAnchor>({ marker: 'anchor' });
-
-describe('ProverWorkflow', () => {
-  it('executes once, retries proof with fresh provers, submits once, and applies once', async () => {
-    const transient = Object.assign(new Error('temporarily unavailable'), {
-      code: 'Unavailable',
-    });
-    const apply = vi.fn().mockResolvedValue({});
-    const submit = vi.fn().mockResolvedValue({ apply });
-    const prove = vi.fn().mockRejectedValueOnce(transient).mockResolvedValueOnce({ submit });
-    const execution = { marker: 'unchanged', prove };
-    const executeRequest = vi.fn().mockResolvedValue(execution);
-    const client = {
-      transactions: { executeRequest },
-    };
-    const provers: TransactionProver[] = [];
-    const config: ResolvedProverConfig = {
-      kind: 'remote',
-      url: 'https://prover.example/',
-      maxAttempts: 2,
-      createProver: () => {
-        const prover = asType<TransactionProver>({});
-        provers.push(prover);
-        return prover;
-      },
-    };
-    const runtime: RetryRuntime = {
-      sleep: vi.fn().mockResolvedValue(undefined),
-      unitRandom: () => 0.5,
-    };
-    const workflow = new ProverWorkflow(
-      asType<MidenClient>(client),
-      config,
-      runtime,
-    );
-
-    await workflow.submitAt(
-      asType<AccountId>({}),
-      asType<TransactionRequest>({}),
-      anchor,
-    );
-
-    expect(executeRequest).toHaveBeenCalledTimes(1);
-    expect(executeRequest.mock.calls[0][2]).toEqual({ anchor });
-    expect(prove).toHaveBeenCalledTimes(2);
-    expect(provers).toHaveLength(2);
-    expect(provers[0]).not.toBe(provers[1]);
-    expect(submit).toHaveBeenCalledTimes(1);
-    expect(apply).toHaveBeenCalledTimes(1);
-    expect(runtime.sleep).toHaveBeenCalledTimes(1);
-  });
-
-  it('returns the final original error without sleeping after exhaustion', async () => {
-    const first = Object.assign(new Error('unavailable'), { code: 'Unavailable' });
-    const final = Object.assign(new Error('deadline exceeded'), {
-      code: 'DeadlineExceeded',
-    });
-    const prove = vi.fn().mockRejectedValueOnce(first).mockRejectedValueOnce(final);
-    const client = { transactions: { executeRequest: vi.fn().mockResolvedValue({ prove }) } };
-    const runtime: RetryRuntime = {
-      sleep: vi.fn().mockResolvedValue(undefined),
-      unitRandom: () => 0.5,
-    };
-    const workflow = new ProverWorkflow(
-      asType<MidenClient>(client),
-      {
-        kind: 'remote',
-        maxAttempts: 2,
-        createProver: () => asType<TransactionProver>({}),
-      },
-      runtime,
-    );
-
-    await expect(
-      workflow.submitAt(asType<AccountId>({}), asType<TransactionRequest>({}), anchor),
-    ).rejects.toBe(final);
-    expect(prove).toHaveBeenCalledTimes(2);
-    expect(runtime.sleep).toHaveBeenCalledTimes(1);
-  });
-
-  it('never re-submits when submission fails with transient-looking wording', async () => {
-    const rateLimited = Object.assign(new Error('Too Many Requests!'), {
-      code: 'ResourceExhausted',
-    });
-    const submit = vi.fn().mockRejectedValue(rateLimited);
-    const prove = vi.fn().mockResolvedValue({ submit });
-    const client = {
-      transactions: { executeRequest: vi.fn().mockResolvedValue({ prove }) },
-    };
-    const runtime: RetryRuntime = {
-      sleep: vi.fn().mockResolvedValue(undefined),
-      unitRandom: () => 0.5,
-    };
-    const workflow = new ProverWorkflow(
-      asType<MidenClient>(client),
-      {
-        kind: 'remote',
-        maxAttempts: 5,
-        createProver: () => asType<TransactionProver>({}),
-      },
-      runtime,
-    );
-
-    await expect(
-      workflow.submitAt(asType<AccountId>({}), asType<TransactionRequest>({}), anchor),
-    ).rejects.toBe(rateLimited);
-    expect(prove).toHaveBeenCalledTimes(1);
-    expect(submit).toHaveBeenCalledTimes(1);
-    expect(runtime.sleep).not.toHaveBeenCalled();
-  });
-
-  it('uses the injected prover directly when no cloneable remote override exists', async () => {
-    const apply = vi.fn().mockResolvedValue({});
-    const submit = vi.fn().mockResolvedValue({ apply });
-    const prove = vi.fn().mockResolvedValue({ submit });
-    const client = {
-      transactions: { executeRequest: vi.fn().mockResolvedValue({ prove }) },
-    };
-    const workflow = new ProverWorkflow(asType<MidenClient>(client), {
-      kind: 'injected',
-      maxAttempts: 1,
-      createProver: () => undefined,
-    });
-
-    await workflow.submitAt(asType<AccountId>({}), asType<TransactionRequest>({}), anchor);
-
-    expect(prove).toHaveBeenCalledWith();
-  });
-});