@openzeppelin/miden-multisig-client 0.15.2 → 0.16.1

package/src/raw-client.ts

@@ -5,8 +5,6 @@ import {
   WasmWebClient,
 } from '@miden-sdk/miden-sdk';
 
-export const DEFAULT_MIDEN_RPC_URL = 'https://rpc.devnet.miden.io';
-
 export type RawClientSource = MidenClient | WasmWebClient;
 export interface ScriptLibrarySource {
   namespace: string;
@@ -16,8 +14,19 @@ export interface ScriptLibrarySource {
 
 const rawClientCache = new WeakMap<MidenClient, Promise<WasmWebClient>>();
 
-export function resolveMidenRpcEndpoint(endpoint?: string): string {
-  return endpoint ?? DEFAULT_MIDEN_RPC_URL;
+export function requireConfigValue(field: string, value?: unknown): string {
+  if (typeof value !== 'string') {
+    throw new Error(`missing required configuration: ${field}`);
+  }
+  const normalizedValue = value.trim();
+  if (normalizedValue === '') {
+    throw new Error(`missing required configuration: ${field}`);
+  }
+  return normalizedValue;
+}
+
+export function requireMidenRpcEndpoint(endpoint?: string): string {
+  return requireConfigValue('midenRpcEndpoint', endpoint);
 }
 
 function isPublicMidenClient(client: RawClientSource): client is MidenClient {
@@ -37,8 +46,9 @@ export async function getRawMidenClient(
     return cached;
   }
 
+  const endpoint = requireMidenRpcEndpoint(rpcUrl);
   const rawClient = WasmWebClient.createClient(
-    resolveMidenRpcEndpoint(rpcUrl),
+    endpoint,
     undefined,
     undefined,
     await client.storeIdentifier(),

package/src/transaction/consumeNotes.ts

@@ -15,7 +15,7 @@ import { LegacyConsumeNotesNoteMissingError } from '../multisig/consumeNotesErro
 import { getRawMidenClient } from '../raw-client.js';
 import { normalizeHexWord } from '../utils/encoding.js';
 import { randomWord } from '../utils/random.js';
-import type { SignatureOptions } from './options.js';
+import type { MidenClientSignatureOptions, SignatureOptions } from './options.js';
 
 /**
  * Build a consume-notes request from loaded `Note` objects (no local-store
@@ -57,6 +57,16 @@ export function buildConsumeNotesTransactionRequestFromNotes(
  * Legacy/creation adapter: fetches notes from the local store and delegates
  * to the from-notes variant. v2 verification MUST NOT call this.
  */
+export function buildConsumeNotesTransactionRequest(
+  client: MidenClient,
+  noteIds: string[],
+  options: MidenClientSignatureOptions,
+): Promise<{ request: TransactionRequest; salt: Word }>;
+export function buildConsumeNotesTransactionRequest(
+  client: WasmWebClient,
+  noteIds: string[],
+  options?: SignatureOptions,
+): Promise<{ request: TransactionRequest; salt: Word }>;
 export async function buildConsumeNotesTransactionRequest(
   client: MidenClient | WasmWebClient,
   noteIds: string[],

package/src/transaction/options.ts

@@ -7,3 +7,7 @@ export interface SignatureOptions {
   signatureScheme?: SignatureScheme;
   midenRpcEndpoint?: string;
 }
+
+export interface MidenClientSignatureOptions extends SignatureOptions {
+  midenRpcEndpoint: string;
+}

package/src/transaction/p2id.test.ts

@@ -2,10 +2,13 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import type { Word } from '@miden-sdk/miden-sdk';
 
 const {
+  mockFromVaultKey,
+  mockFungibleAssetConstructor,
   mockHashElements,
   mockNormalizeHexWord,
   mockRandomWord,
   mockWordFromHex,
+  noteMetadataCalls,
   saltFelts,
 } = vi.hoisted(() => {
   const saltFelts = [
@@ -16,6 +19,13 @@ const {
   ];
 
   return {
+    mockFromVaultKey: vi.fn((vaultKey: unknown, amount: bigint) => ({
+      kind: 'asset-from-vault-key',
+      vaultKey,
+      amount,
+    })),
+    mockFungibleAssetConstructor: vi.fn(),
+    noteMetadataCalls: [] as unknown[][],
     mockHashElements: vi.fn().mockReturnValue({ toString: () => 'serial' }),
     mockNormalizeHexWord: vi.fn((hex: string) => hex),
     mockRandomWord: vi.fn().mockReturnValue({
@@ -66,10 +76,12 @@ vi.mock('@miden-sdk/miden-sdk', () => {
 
   class NoteMetadata {
     constructor(
-      _sender: unknown,
-      _noteType: unknown,
-      _noteTag: unknown,
-    ) {}
+      sender: unknown,
+      noteType: unknown,
+      noteTag: unknown,
+    ) {
+      noteMetadataCalls.push([sender, noteType, noteTag]);
+    }
   }
 
   class NoteRecipient {
@@ -89,7 +101,11 @@ vi.mock('@miden-sdk/miden-sdk', () => {
   }
 
   class FungibleAsset {
-    constructor(_faucet: unknown, _amount: bigint) {}
+    constructor(faucet: unknown, amount: bigint) {
+      mockFungibleAssetConstructor(faucet, amount);
+    }
+
+    static fromVaultKey = mockFromVaultKey;
   }
 
   class NoteArray {
@@ -120,6 +136,7 @@ vi.mock('@miden-sdk/miden-sdk', () => {
         hex,
         prefix: () => 1,
         suffix: () => 2,
+        toString: () => hex,
       })),
     },
     Felt,
@@ -140,7 +157,8 @@ vi.mock('@miden-sdk/miden-sdk', () => {
       withAccountTarget: vi.fn(() => ({ kind: 'tag' })),
     },
     NoteType: {
-      Public: 'public',
+      Private: 0,
+      Public: 1,
     },
     OutputNote: {
       full: vi.fn((note: unknown) => ({ note })),
@@ -163,14 +181,32 @@ vi.mock('../utils/random.js', () => ({
   randomWord: mockRandomWord,
 }));
 
-import { buildP2idTransactionRequest } from './p2id.js';
+import { buildP2idTransactionRequest, parseP2idNoteType, p2idNoteTypeToMetadata } from './p2id.js';
+import type { Account } from '@miden-sdk/miden-sdk';
+
+const FAUCET_ID = '0x7bfb0f38b0fafa103f86a805594171';
+
+const mockAccount = {
+  vault: () => ({
+    fungibleAssets: () => [
+      {
+        faucetId: () => ({ toString: () => FAUCET_ID }),
+        vaultKey: () => ({ kind: 'vault-key' }),
+      },
+    ],
+  }),
+} as unknown as Account;
+import { NoteType } from '@miden-sdk/miden-sdk';
 
 describe('buildP2idTransactionRequest', () => {
   beforeEach(() => {
+    mockFromVaultKey.mockClear();
+    mockFungibleAssetConstructor.mockClear();
     mockHashElements.mockClear();
     mockNormalizeHexWord.mockClear();
     mockRandomWord.mockClear();
     mockWordFromHex.mockClear();
+    noteMetadataCalls.length = 0;
   });
 
   it('derives serial number from salt felts plus four zero felts', () => {
@@ -179,8 +215,9 @@ describe('buildP2idTransactionRequest', () => {
     buildP2idTransactionRequest(
       '0x7bfb0f38b0fafa103f86a805594170',
       '0x8a65fc5a39e4cd106d648e3eb4ab5f',
-      '0x7bfb0f38b0fafa103f86a805594171',
+      FAUCET_ID,
       10n,
+      mockAccount,
       { salt },
     );
 
@@ -197,4 +234,57 @@ describe('buildP2idTransactionRequest', () => {
       expect((felt as { value: bigint }).value).toBe(0n);
     }
   });
+
+  it('creates a public note by default (issue #322)', () => {
+    buildP2idTransactionRequest(
+      '0x7bfb0f38b0fafa103f86a805594170',
+      '0x8a65fc5a39e4cd106d648e3eb4ab5f',
+      '0x7bfb0f38b0fafa103f86a805594171',
+      10n,
+      mockAccount,
+    );
+
+    expect(noteMetadataCalls).toHaveLength(1);
+    expect(noteMetadataCalls[0][1]).toBe(NoteType.Public);
+  });
+
+  it('threads the requested noteType into the note metadata (issue #322)', () => {
+    buildP2idTransactionRequest(
+      '0x7bfb0f38b0fafa103f86a805594170',
+      '0x8a65fc5a39e4cd106d648e3eb4ab5f',
+      '0x7bfb0f38b0fafa103f86a805594171',
+      10n,
+      mockAccount,
+      { noteType: NoteType.Private },
+    );
+
+    expect(noteMetadataCalls).toHaveLength(1);
+    expect(noteMetadataCalls[0][1]).toBe(NoteType.Private);
+  });
+});
+
+describe('parseP2idNoteType', () => {
+  it('maps absent to Public (pre-#322 proposals)', () => {
+    expect(parseP2idNoteType(undefined)).toBe(NoteType.Public);
+  });
+
+  it('maps wire values to note types', () => {
+    expect(parseP2idNoteType('public')).toBe(NoteType.Public);
+    expect(parseP2idNoteType('private')).toBe(NoteType.Private);
+  });
+
+  it('rejects unknown values instead of silently rebuilding a public note', () => {
+    expect(() => parseP2idNoteType('encrypted')).toThrow(/unsupported metadata.noteType/);
+  });
+});
+
+describe('p2idNoteTypeToMetadata', () => {
+  it('omits the default so public payloads keep the legacy wire shape', () => {
+    expect(p2idNoteTypeToMetadata(undefined)).toBeUndefined();
+    expect(p2idNoteTypeToMetadata(NoteType.Public)).toBeUndefined();
+  });
+
+  it('serializes private', () => {
+    expect(p2idNoteTypeToMetadata(NoteType.Private)).toBe('private');
+  });
 });

package/src/transaction/p2id.ts

@@ -1,4 +1,4 @@
-import type { TransactionRequest, Word } from '@miden-sdk/miden-sdk';
+import type { Account, TransactionRequest, Word } from '@miden-sdk/miden-sdk';
 import {
   AccountId,
   FeltArray,
@@ -19,6 +19,38 @@ import {
 import { randomWord } from '../utils/random.js';
 import { normalizeHexWord } from '../utils/encoding.js';
 import type { SignatureOptions } from './options.js';
+import type { P2idNoteVisibility } from '../types/proposal.js';
+
+export interface P2idTransactionOptions extends SignatureOptions {
+  /** Visibility of the created note. Defaults to `NoteType.Public`. */
+  noteType?: NoteType;
+}
+
+/**
+ * Parses the metadata wire value for a P2ID note visibility (issue #322).
+ * Absent => public, the only behavior before the field existed. An unknown
+ * value is rejected rather than silently rebuilt as a public note that could
+ * never match the signed tx_summary commitment.
+ */
+export function parseP2idNoteType(value: string | undefined): NoteType {
+  switch (value) {
+    case undefined:
+    case 'public':
+      return NoteType.Public;
+    case 'private':
+      return NoteType.Private;
+    default:
+      throw new Error(`unsupported metadata.noteType '${value}': expected 'public' or 'private'`);
+  }
+}
+
+/**
+ * Maps a note type to its metadata wire value, omitting the default so
+ * public-note payloads keep the pre-#322 wire shape.
+ */
+export function p2idNoteTypeToMetadata(noteType: NoteType | undefined): P2idNoteVisibility | undefined {
+  return noteType === NoteType.Private ? 'private' : undefined;
+}
 
 export function deriveP2idSerialNumber(salt: Word): Word {
   const zeroWord = WordType.fromHex(`0x${'00'.repeat(32)}`);
@@ -28,6 +60,32 @@ export function deriveP2idSerialNumber(salt: Word): Word {
   ]));
 }
 
+/**
+ * Builds the fungible asset to transfer, sourcing the callback flag from the held asset.
+ *
+ * In Miden 0.15 the callback flag is part of the vault key, so rebuilding the asset from
+ * `faucet`/`amount` with the default flag would not match the held asset and the transfer
+ * would abort. When the faucet is absent the default flag is used, surfacing the
+ * missing-asset error during execution.
+ */
+function resolveFungibleAssetFromVault(
+  account: Account,
+  faucet: AccountId,
+  amount: bigint,
+): FungibleAsset {
+  const faucetHex = faucet.toString();
+  const assetFromVault = account
+    .vault()
+    .fungibleAssets()
+    .find(asset => asset.faucetId().toString() === faucetHex);
+
+  if (!assetFromVault) {
+    return new FungibleAsset(faucet, amount);
+  }
+
+  return FungibleAsset.fromVaultKey(assetFromVault.vaultKey(), amount);
+}
+
 function buildP2idNote(
   sender: AccountId,
   recipient: AccountId,
@@ -56,27 +114,48 @@ function buildP2idNote(
   return new Note(noteAssets, noteMetadata, noteRecipient);
 }
 
-export function buildP2idTransactionRequest(
+/**
+ * Rebuilds the P2ID note a proposal creates, from its metadata fields. The
+ * note is deterministic in the salt, so the resulting ID matches the note the
+ * proposal produces on execution (issue #356). The asset is derived from the
+ * account's current vault state, so call this before the transfer executes.
+ */
+export function buildP2idNoteFromMetadata(
   senderId: string,
   recipientId: string,
   faucetId: string,
   amount: bigint,
-  options: SignatureOptions = {},
-): { request: TransactionRequest; salt: Word } {
+  account: Account,
+  noteType: NoteType,
+  saltHex: string,
+): Note {
   const sender = AccountId.fromHex(senderId);
   const recipient = AccountId.fromHex(recipientId);
   const faucet = AccountId.fromHex(faucetId);
 
-  const authSaltHex = options.salt ? options.salt.toHex() : randomWord().toHex();
-
-  const asset = new FungibleAsset(faucet, amount);
+  const asset = resolveFungibleAssetFromVault(account, faucet, amount);
   const noteAssets = new NoteAssets([asset]);
 
-  const note = buildP2idNote(
-    sender,
-    recipient,
-    noteAssets,
-    NoteType.Public,
+  return buildP2idNote(sender, recipient, noteAssets, noteType, saltHex);
+}
+
+export function buildP2idTransactionRequest(
+  senderId: string,
+  recipientId: string,
+  faucetId: string,
+  amount: bigint,
+  account: Account,
+  options: P2idTransactionOptions = {},
+): { request: TransactionRequest; salt: Word } {
+  const authSaltHex = options.salt ? options.salt.toHex() : randomWord().toHex();
+
+  const note = buildP2idNoteFromMetadata(
+    senderId,
+    recipientId,
+    faucetId,
+    amount,
+    account,
+    options.noteType ?? NoteType.Public,
     authSaltHex,
   );
 

package/src/transaction/summary.ts

@@ -7,6 +7,18 @@ import type {
 import { AccountId } from '@miden-sdk/miden-sdk';
 import { getRawMidenClient } from '../raw-client.js';
 
+export function executeForSummary(
+  client: MidenClient,
+  accountId: string,
+  txRequest: TransactionRequest,
+  midenRpcEndpoint: string,
+): Promise<TransactionSummary>;
+export function executeForSummary(
+  client: WasmWebClient,
+  accountId: string,
+  txRequest: TransactionRequest,
+  midenRpcEndpoint?: string,
+): Promise<TransactionSummary>;
 export async function executeForSummary(
   client: MidenClient | WasmWebClient,
   accountId: string,

package/src/transaction/updateGuardian.ts

@@ -13,7 +13,7 @@ import { GUARDIAN_ECDSA_MASM, GUARDIAN_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';
+import type { MidenClientSignatureOptions, SignatureOptions } from './options.js';
 import type { SignatureScheme } from '../types.js';
 
 async function buildUpdateGuardianScript(
@@ -42,6 +42,16 @@ end
   );
 }
 
+export function buildUpdateGuardianTransactionRequest(
+  client: MidenClient,
+  newGuardianPubkey: string,
+  options: MidenClientSignatureOptions,
+): Promise<{ request: TransactionRequest; salt: Word }>;
+export function buildUpdateGuardianTransactionRequest(
+  client: WasmWebClient,
+  newGuardianPubkey: string,
+  options?: SignatureOptions,
+): Promise<{ request: TransactionRequest; salt: Word }>;
 export async function buildUpdateGuardianTransactionRequest(
   client: MidenClient | WasmWebClient,
   newGuardianPubkey: string,

package/src/transaction/updateProcedureThreshold.ts

@@ -18,7 +18,7 @@ import { getProcedureRoot, type ProcedureName } from '../procedures.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';
+import type { MidenClientSignatureOptions, SignatureOptions } from './options.js';
 import type { SignatureScheme } from '../types.js';
 
 function buildProcedureThresholdFelts(procedure: ProcedureName, threshold: number): Felt[] {
@@ -76,6 +76,18 @@ end
   );
 }
 
+export function buildUpdateProcedureThresholdTransactionRequest(
+  client: MidenClient,
+  procedure: ProcedureName,
+  threshold: number,
+  options: MidenClientSignatureOptions,
+): Promise<{ request: TransactionRequest; salt: Word; configHash: Word }>;
+export function buildUpdateProcedureThresholdTransactionRequest(
+  client: WasmWebClient,
+  procedure: ProcedureName,
+  threshold: number,
+  options?: SignatureOptions,
+): Promise<{ request: TransactionRequest; salt: Word; configHash: Word }>;
 export async function buildUpdateProcedureThresholdTransactionRequest(
   client: MidenClient | WasmWebClient,
   procedure: ProcedureName,

package/src/transaction/updateSigners.ts

@@ -18,7 +18,7 @@ import {
 import { compileTxScript } from '../raw-client.js';
 import { normalizeHexWord } from '../utils/encoding.js';
 import { randomWord } from '../utils/random.js';
-import type { SignatureOptions } from './options.js';
+import type { MidenClientSignatureOptions, SignatureOptions } from './options.js';
 import type { SignatureScheme } from '../types.js';
 
 function buildMultisigConfigFelts(threshold: number, signerCommitments: string[]): Felt[] {
@@ -73,6 +73,18 @@ end
   );
 }
 
+export function buildUpdateSignersTransactionRequest(
+  client: MidenClient,
+  threshold: number,
+  signerCommitments: string[],
+  options: MidenClientSignatureOptions,
+): Promise<{ request: TransactionRequest; salt: Word; configHash: Word }>;
+export function buildUpdateSignersTransactionRequest(
+  client: WasmWebClient,
+  threshold: number,
+  signerCommitments: string[],
+  options?: SignatureOptions,
+): Promise<{ request: TransactionRequest; salt: Word; configHash: Word }>;
 export async function buildUpdateSignersTransactionRequest(
   client: MidenClient | WasmWebClient,
   threshold: number,

package/src/transaction.ts

@@ -3,7 +3,11 @@ export {
 } from './transaction/consumeNotes.js';
 export { executeForSummary } from './transaction/summary.js';
 export {
+  buildP2idNoteFromMetadata,
   buildP2idTransactionRequest,
+  parseP2idNoteType,
+  p2idNoteTypeToMetadata,
+  type P2idTransactionOptions,
 } from './transaction/p2id.js';
 export {
   buildUpdateGuardianTransactionRequest,

package/src/types/proposal.ts

@@ -82,11 +82,20 @@ export function isConsumeNotesV1(md: ConsumeNotesProposalMetadata): boolean {
   return md.metadataVersion === undefined || md.metadataVersion === 1;
 }
 
+/** Wire values for a P2ID note's visibility (issue #322). */
+export type P2idNoteVisibility = 'public' | 'private';
+
+export function isP2idNoteVisibility(value: string): value is P2idNoteVisibility {
+  return value === 'public' || value === 'private';
+}
+
 export interface P2IdProposalMetadata extends BaseProposalMetadata {
   proposalType: 'p2id';
   recipientId: string;
   faucetId: string;
   amount: string;
+  /** Visibility of the created note. Absent on the wire => 'public' (pre-#322 proposals). */
+  noteType?: P2idNoteVisibility;
 }
 
 export interface CustomProposalMetadata extends BaseProposalMetadata {