@openzeppelin/miden-multisig-client 0.12.7 → 0.13.0

package/src/multisig/proposal/parser.ts

@@ -0,0 +1,191 @@
+import type {
+  DeltaObject,
+  DeltaStatus,
+  ProposalMetadata as PsmProposalMetadata,
+} from '@openzeppelin/psm-client';
+import type {
+  ProposalMetadata,
+  ProposalType,
+  TransactionProposal,
+  TransactionProposalSignature,
+  TransactionProposalStatus,
+} from '../../types.js';
+
+export function buildPsmMetadata(metadata: ProposalMetadata): PsmProposalMetadata {
+  const base: PsmProposalMetadata = {
+    proposalType: metadata.proposalType,
+    description: metadata.description,
+    salt: metadata.saltHex,
+  };
+
+  switch (metadata.proposalType) {
+    case 'consume_notes':
+      return {
+        ...base,
+        noteIds: metadata.noteIds,
+      };
+    case 'p2id':
+      return {
+        ...base,
+        recipientId: metadata.recipientId,
+        faucetId: metadata.faucetId,
+        amount: metadata.amount,
+      };
+    case 'switch_psm':
+      return {
+        ...base,
+        targetThreshold: metadata.targetThreshold,
+        signerCommitments: metadata.targetSignerCommitments,
+        newPsmPubkey: metadata.newPsmPubkey,
+        newPsmEndpoint: metadata.newPsmEndpoint,
+      };
+    case 'add_signer':
+    case 'remove_signer':
+    case 'change_threshold':
+      return {
+        ...base,
+        targetThreshold: metadata.targetThreshold,
+        signerCommitments: metadata.targetSignerCommitments,
+      };
+    case 'unknown':
+      return base;
+    default:
+      return base;
+  }
+}
+
+export function fromPsmMetadata(psm: PsmProposalMetadata): ProposalMetadata | undefined {
+  if (!psm.proposalType) return undefined;
+
+  const base = {
+    description: psm.description ?? '',
+    saltHex: psm.salt,
+  };
+
+  switch (psm.proposalType) {
+    case 'p2id':
+      return {
+        ...base,
+        proposalType: 'p2id',
+        recipientId: psm.recipientId ?? '',
+        faucetId: psm.faucetId ?? '',
+        amount: psm.amount ?? '0',
+      };
+    case 'consume_notes':
+      return {
+        ...base,
+        proposalType: 'consume_notes',
+        noteIds: psm.noteIds ?? [],
+      };
+    case 'switch_psm':
+      return {
+        ...base,
+        proposalType: 'switch_psm',
+        newPsmPubkey: psm.newPsmPubkey ?? '',
+        newPsmEndpoint: psm.newPsmEndpoint,
+        targetThreshold: psm.targetThreshold,
+        targetSignerCommitments: psm.signerCommitments,
+      };
+    case 'add_signer':
+    case 'remove_signer':
+    case 'change_threshold':
+      return {
+        ...base,
+        proposalType: psm.proposalType,
+        targetThreshold: psm.targetThreshold ?? 0,
+        targetSignerCommitments: psm.signerCommitments ?? [],
+      };
+    default:
+      return undefined;
+  }
+}
+
+export function deltaStatusToProposalStatus(
+  status: DeltaStatus,
+  signaturesRequired: number,
+): TransactionProposalStatus {
+  switch (status.status) {
+    case 'pending': {
+      const signaturesCollected = status.cosignerSigs.length;
+      if (signaturesCollected >= signaturesRequired) {
+        return { type: 'ready' };
+      }
+      return {
+        type: 'pending',
+        signaturesCollected,
+        signaturesRequired,
+        signers: status.cosignerSigs.map((s) => s.signerId),
+      };
+    }
+    case 'candidate':
+      return { type: 'ready' };
+    case 'canonical':
+    case 'discarded':
+      return { type: 'finalized' };
+  }
+}
+
+interface DeltaToProposalParams {
+  delta: DeltaObject;
+  proposalId: string;
+  metadata: ProposalMetadata;
+  signaturesRequired: number;
+  existingSignatures?: TransactionProposalSignature[];
+}
+
+export function deltaToProposal({
+  delta,
+  proposalId,
+  metadata,
+  signaturesRequired,
+  existingSignatures,
+}: DeltaToProposalParams): TransactionProposal {
+  const status = deltaStatusToProposalStatus(delta.status, signaturesRequired);
+
+  const signaturesFromStatus =
+    delta.status.status === 'pending'
+      ? delta.status.cosignerSigs.map((s) => ({
+          signerId: s.signerId,
+          signature: s.signature,
+          timestamp: s.timestamp,
+        }))
+      : [];
+
+  const signaturesMap = new Map<string, TransactionProposalSignature>();
+  for (const sig of existingSignatures ?? []) {
+    signaturesMap.set(sig.signerId, sig);
+  }
+  for (const sig of signaturesFromStatus) {
+    signaturesMap.set(sig.signerId, sig);
+  }
+  const signatures = Array.from(signaturesMap.values());
+
+  return {
+    id: proposalId,
+    commitment: proposalId,
+    accountId: delta.accountId,
+    nonce: delta.nonce,
+    status,
+    txSummary: delta.deltaPayload.txSummary.data,
+    signatures,
+    metadata,
+  };
+}
+
+export function resolveMetadata(
+  delta: DeltaObject,
+  existingMetadata?: ProposalMetadata,
+): ProposalMetadata | undefined {
+  if (existingMetadata) return existingMetadata;
+  if (!delta.deltaPayload.metadata) return undefined;
+  return fromPsmMetadata(delta.deltaPayload.metadata);
+}
+
+export function signatureRequirementForProposal(
+  metadata: ProposalMetadata,
+  defaultThreshold: number,
+  getEffectiveThreshold: (proposalType: ProposalType) => number,
+): number {
+  if (metadata.proposalType === 'unknown') return defaultThreshold;
+  return getEffectiveThreshold(metadata.proposalType);
+}

package/src/multisig/signing.ts

@@ -0,0 +1,24 @@
+import type { ProposalSignature, Signer } from '@openzeppelin/psm-client';
+import type { SignatureScheme } from '../types.js';
+
+export function toPsmSignature(
+  scheme: SignatureScheme,
+  signatureHex: string,
+  publicKey?: string,
+): ProposalSignature {
+  if (scheme === 'ecdsa') {
+    if (!publicKey) {
+      throw new Error('ECDSA signature requires publicKey');
+    }
+    return { scheme: 'ecdsa', signature: signatureHex, publicKey };
+  }
+  return { scheme: 'falcon', signature: signatureHex };
+}
+
+export async function buildPsmSignatureFromSigner(
+  signer: Signer,
+  commitment: string,
+): Promise<ProposalSignature> {
+  const signatureHex = await signer.signCommitment(commitment);
+  return toPsmSignature(signer.scheme, signatureHex, signer.publicKey);
+}

package/src/multisig.test.ts

@@ -3,7 +3,7 @@ import { Multisig } from './multisig.js';
 import { PsmHttpClient, type Signer } from '@openzeppelin/psm-client';
 
 // Mock the Miden SDK
-vi.mock('@demox-labs/miden-sdk', () => ({
+vi.mock('@miden-sdk/miden-sdk', () => ({
   AccountId: {
     fromHex: vi.fn((hex: string) => ({ toString: () => hex })),
   },
@@ -73,8 +73,12 @@ vi.mock('./utils/signature.js', () => ({
 vi.mock('./utils/encoding.js', async () => {
   const actual = await vi.importActual<typeof import('./utils/encoding.js')>('./utils/encoding.js');
   return {
-    ...actual,
+    ensureHexPrefix: actual.ensureHexPrefix,
     normalizeHexWord: vi.fn((hex: string) => '0x' + hex.replace(/^0x/i, '').padStart(64, '0')),
+    bytesToHex: actual.bytesToHex,
+    hexToBytes: actual.hexToBytes,
+    uint8ArrayToBase64: actual.uint8ArrayToBase64,
+    base64ToUint8Array: actual.base64ToUint8Array,
   };
 });
 
@@ -97,8 +101,8 @@ describe('Multisig', () => {
       scheme: 'falcon',
       commitment: '0x' + '1'.repeat(64),
       publicKey: '0x' + '2'.repeat(64),
-      signAccountIdWithTimestamp: vi.fn().mockReturnValue('0x' + 'a'.repeat(128)),
-      signCommitment: vi.fn().mockReturnValue('0x' + 'b'.repeat(128)),
+      signAccountIdWithTimestamp: vi.fn().mockResolvedValue('0x' + 'a'.repeat(128)),
+      signCommitment: vi.fn().mockResolvedValue('0x' + 'b'.repeat(128)),
     };
 
     psm.setSigner(mockSigner);