@openzeppelin/miden-multisig-client 0.13.3 → 0.14.3

package/src/transaction/updateSigners.ts

@@ -2,11 +2,12 @@ import {
   AdviceMap,
   Felt,
   FeltArray,
-  Rpo256,
+  type MidenClient,
+  Poseidon2,
   TransactionRequest,
   TransactionRequestBuilder,
   TransactionScript,
-  WebClient,
+  type WasmWebClient,
   Word,
   Word as WordType,
 } from '@miden-sdk/miden-sdk';
@@ -14,6 +15,7 @@ import {
   MULTISIG_ECDSA_MASM,
   MULTISIG_MASM,
 } from '../account/masm/auth.js';
+import { compileTxScript } from '../raw-client.js';
 import { normalizeHexWord } from '../utils/encoding.js';
 import { randomWord } from '../utils/random.js';
 import type { SignatureOptions } from './options.js';
@@ -35,33 +37,35 @@ function buildMultisigConfigAdvice(
     felts.push(...word.toFelts());
   }
   const payload = new FeltArray(felts);
-  const configHash = Rpo256.hashElements(payload);
+  const configHash = Poseidon2.hashElements(payload);
   return { configHash, payload };
 }
 
-function buildUpdateSignersScript(
-  webClient: WebClient,
+async function buildUpdateSignersScript(
+  client: MidenClient | WasmWebClient,
   signatureScheme: SignatureScheme,
-): TransactionScript {
-  const libBuilder = webClient.createCodeBuilder();
+  midenRpcEndpoint?: string,
+): Promise<TransactionScript> {
   const multisigMasm = signatureScheme === 'ecdsa' ? MULTISIG_ECDSA_MASM : MULTISIG_MASM;
 
-  const multisigLib = libBuilder.buildLibrary('auth::multisig', multisigMasm);
-  libBuilder.linkDynamicLibrary(multisigLib);
-
   const scriptSource = `
-use auth::multisig
+use oz_multisig::multisig
 
 begin
     call.multisig::update_signers_and_threshold
 end
   `;
 
-  return libBuilder.compileTxScript(scriptSource);
+  return compileTxScript(
+    client,
+    scriptSource,
+    [{ namespace: 'oz_multisig::multisig', code: multisigMasm }],
+    midenRpcEndpoint,
+  );
 }
 
 export async function buildUpdateSignersTransactionRequest(
-  webClient: WebClient,
+  client: MidenClient | WasmWebClient,
   threshold: number,
   signerCommitments: string[],
   options: SignatureOptions = {},
@@ -76,7 +80,11 @@ export async function buildUpdateSignersTransactionRequest(
   const advice = new AdviceMap();
   advice.insert(configHashForAdvice, payload);
 
-  const script = buildUpdateSignersScript(webClient, signatureScheme);
+  const script = await buildUpdateSignersScript(
+    client,
+    signatureScheme,
+    options.midenRpcEndpoint,
+  );
 
   const authSaltHex = options.salt ? options.salt.toHex() : randomWord().toHex();
 

package/src/transaction.test.ts

@@ -6,7 +6,7 @@ vi.mock('@miden-sdk/miden-sdk', () => ({
   AdviceMap: vi.fn(),
   Felt: vi.fn().mockImplementation((v) => ({ value: v })),
   FeltArray: vi.fn().mockImplementation((arr) => arr),
-  Rpo256: { hashElements: vi.fn() },
+  Poseidon2: { hashElements: vi.fn() },
   Signature: { deserialize: vi.fn() },
   TransactionRequestBuilder: vi.fn().mockImplementation(() => ({
     withCustomScript: vi.fn().mockReturnThis(),
@@ -110,21 +110,21 @@ describe('transaction utilities', () => {
   });
 
   describe('signatureHexToBytes', () => {
-    it('should prepend auth scheme byte (0 = RpoFalcon512)', () => {
+    it('should prepend auth scheme byte (2 = Falcon Poseidon2)', () => {
       const result = signatureHexToBytes('deadbeef');
-      expect(result[0]).toBe(0); // RpoFalcon512 scheme byte
+      expect(result[0]).toBe(2);
       expect(result.slice(1)).toEqual(new Uint8Array([0xde, 0xad, 0xbe, 0xef]));
     });
 
     it('should prepend auth scheme byte (1 = ECDSA)', () => {
       const result = signatureHexToBytes('deadbeef', 'ecdsa');
-      expect(result[0]).toBe(1); // ECDSA scheme byte
+      expect(result[0]).toBe(1);
       expect(result.slice(1)).toEqual(new Uint8Array([0xde, 0xad, 0xbe, 0xef]));
     });
 
     it('should handle 0x prefix', () => {
       const result = signatureHexToBytes('0xaabbccdd');
-      expect(result[0]).toBe(0);
+      expect(result[0]).toBe(2);
       expect(result.slice(1)).toEqual(new Uint8Array([0xaa, 0xbb, 0xcc, 0xdd]));
     });
 
@@ -136,7 +136,7 @@ describe('transaction utilities', () => {
 
     it('should handle empty signature', () => {
       const result = signatureHexToBytes('');
-      expect(result).toEqual(new Uint8Array([0])); // Just the prefix
+      expect(result).toEqual(new Uint8Array([2]));
     });
   });
 });

package/src/utils/key.test.ts

@@ -18,6 +18,8 @@ vi.mock('@miden-sdk/miden-sdk', () => ({
 }));
 
 vi.mock('./signature.js', () => ({
+  ECDSA_AUTH_SCHEME_ID: 1,
+  FALCON_AUTH_SCHEME_ID: 2,
   tryComputeCommitmentHex: vi.fn((_hex: string, _scheme: string) => '0x' + 'cc'.repeat(32)),
 }));
 
@@ -32,9 +34,9 @@ describe('PublicKeyFormat', () => {
       expect(result.publicKeyHex).toMatch(/^0x[a-f0-9]{64}$/);
     });
 
-    it('should detect 0x00-prefixed key as falcon', () => {
+    it('should detect 0x02-prefixed key as falcon', () => {
       const bytes = new Uint8Array(200);
-      bytes[0] = 0x00;
+      bytes[0] = 0x02;
       bytes[1] = 0xab;
       const result = PublicKeyFormat.parse(bytes);
       expect(result.scheme).toBe('falcon');

package/src/utils/key.ts

@@ -1,7 +1,11 @@
 import { Word } from '@miden-sdk/miden-sdk';
 import type { SignatureScheme } from '../types.js';
 import { bytesToHex } from './encoding.js';
-import { tryComputeCommitmentHex } from './signature.js';
+import {
+  ECDSA_AUTH_SCHEME_ID,
+  FALCON_AUTH_SCHEME_ID,
+  tryComputeCommitmentHex,
+} from './signature.js';
 
 export class PublicKeyFormat {
   static parse(publicKey: Uint8Array): {
@@ -16,12 +20,12 @@ export class PublicKeyFormat {
 
     const firstByte = publicKey[0];
 
-    if (firstByte === 0x00 && publicKey.length > 100) {
+    if (firstByte === FALCON_AUTH_SCHEME_ID && publicKey.length > 100) {
       const hex = bytesToHex(publicKey.slice(1));
       return { scheme: 'falcon', publicKeyHex: hex, commitment: tryComputeCommitmentHex(hex, 'falcon') };
     }
 
-    if (firstByte === 0x01 && publicKey.length === 34) {
+    if (firstByte === ECDSA_AUTH_SCHEME_ID && publicKey.length === 34) {
       const hex = bytesToHex(publicKey.slice(1));
       return { scheme: 'ecdsa', publicKeyHex: hex, commitment: tryComputeCommitmentHex(hex, 'ecdsa') };
     }

package/src/utils/signature.test.ts

@@ -14,7 +14,7 @@ vi.mock('@miden-sdk/miden-sdk', () => ({
   })),
   Felt: vi.fn().mockImplementation((v: bigint) => ({ value: v })),
   FeltArray: vi.fn().mockImplementation((arr: any[]) => arr),
-  Rpo256: {
+  Poseidon2: {
     hashElements: vi.fn().mockReturnValue({
       toHex: () => '0x' + 'h'.repeat(64),
     }),
@@ -48,15 +48,15 @@ describe('signature utilities', () => {
   });
 
   describe('signatureHexToBytes', () => {
-    it('prepends auth scheme byte (0 = RpoFalcon512)', () => {
+    it('prepends auth scheme byte (2 = Falcon Poseidon2)', () => {
       const result = signatureHexToBytes('deadbeef');
-      expect(result[0]).toBe(0); // RpoFalcon512 scheme byte
+      expect(result[0]).toBe(2);
     });
 
     it('prepends auth scheme byte (1 = ECDSA)', () => {
       const result = signatureHexToBytes('deadbeef', 'ecdsa');
-      expect(result[0]).toBe(1); // ECDSA scheme byte
-    });
+      expect(result[0]).toBe(1);
+   });
 
     it('converts hex to bytes after prefix', () => {
       const result = signatureHexToBytes('deadbeef');
@@ -65,7 +65,7 @@ describe('signature utilities', () => {
 
     it('handles 0x prefix', () => {
       const result = signatureHexToBytes('0xaabbccdd');
-      expect(result[0]).toBe(0);
+      expect(result[0]).toBe(2);
       expect(result.slice(1)).toEqual(new Uint8Array([0xaa, 0xbb, 0xcc, 0xdd]));
     });
 
@@ -77,12 +77,12 @@ describe('signature utilities', () => {
 
     it('handles empty signature', () => {
       const result = signatureHexToBytes('');
-      expect(result).toEqual(new Uint8Array([0])); // Just the prefix
+      expect(result).toEqual(new Uint8Array([2]));
     });
 
     it('handles empty with 0x prefix', () => {
       const result = signatureHexToBytes('0x');
-      expect(result).toEqual(new Uint8Array([0]));
+      expect(result).toEqual(new Uint8Array([2]));
     });
   });
 
@@ -100,14 +100,14 @@ describe('signature utilities', () => {
     });
 
     it('hashes pubkey commitment and message to produce key', async () => {
-      const { Word, Signature, Rpo256 } = await import('@miden-sdk/miden-sdk');
+      const { Word, Signature, Poseidon2 } = await import('@miden-sdk/miden-sdk');
       const pubkeyCommitment = Word.fromHex('0x' + 'a'.repeat(64));
       const message = Word.fromHex('0x' + 'b'.repeat(64));
       const signature = Signature.deserialize(new Uint8Array([0, 1, 2, 3]));
 
       buildSignatureAdviceEntry(pubkeyCommitment, message, signature);
 
-      expect(Rpo256.hashElements).toHaveBeenCalled();
+      expect(Poseidon2.hashElements).toHaveBeenCalled();
     });
 
     it('uses toPreparedSignature to get values', async () => {

package/src/utils/signature.ts

@@ -1,15 +1,22 @@
-import { AdviceMap, Felt, FeltArray, Rpo256, Signature, Word } from '@miden-sdk/miden-sdk';
+import { AdviceMap, Felt, FeltArray, Poseidon2, Signature, Word } from '@miden-sdk/miden-sdk';
 import * as midenSdk from '@miden-sdk/miden-sdk';
 import { hexToBytes, normalizeHexWord } from './encoding.js';
 import type { ProposalSignatureEntry, SignatureScheme } from '../types.js';
 
+export const ECDSA_AUTH_SCHEME_ID = 1;
+export const FALCON_AUTH_SCHEME_ID = 2;
+
+function authSchemeId(scheme: SignatureScheme): number {
+  return scheme === 'ecdsa' ? ECDSA_AUTH_SCHEME_ID : FALCON_AUTH_SCHEME_ID;
+}
+
 export function signatureHexToBytes(
   hex: string,
   scheme: SignatureScheme = 'falcon',
 ): Uint8Array {
   const sigBytes = hexToBytes(hex);
   const withPrefix = new Uint8Array(sigBytes.length + 1);
-  withPrefix[0] = scheme === 'ecdsa' ? 1 : 0;
+  withPrefix[0] = authSchemeId(scheme);
   withPrefix.set(sigBytes, 1);
   return withPrefix;
 }
@@ -45,7 +52,7 @@ export function buildSignatureAdviceEntry(
     ...pubkeyCommitment.toFelts(),
     ...message.toFelts(),
   ]);
-  const key = Rpo256.hashElements(elements);
+  const key = Poseidon2.hashElements(elements);
 
   let values: Felt[];
   if (ecdsaPubkeyHex && ecdsaSigHex) {
@@ -69,7 +76,7 @@ export function tryComputeCommitmentHex(
 ): string | null {
   const bytes = hexToBytes(pubkeyHex);
   const withPrefix = new Uint8Array(bytes.length + 1);
-  withPrefix[0] = scheme === 'ecdsa' ? 1 : 0;
+  withPrefix[0] = authSchemeId(scheme);
   withPrefix.set(bytes, 1);
 
   try {
@@ -98,7 +105,7 @@ export function verifyEcdsaCommitment(
 
     const packedFelts = bytesToPackedU32Felts(bytes);
     const feltArray = new FeltArray(packedFelts);
-    const computed = Rpo256.hashElements(feltArray);
+    const computed = Poseidon2.hashElements(feltArray);
     const computedHex = normalizeHexWord(computed.toHex());
     const expectedNorm = normalizeHexWord(expectedCommitmentHex);
     return {