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

package/src/procedures.ts

@@ -11,13 +11,12 @@
  * human-readable encoding and should not be copied into this table.
  */
 export const PROCEDURE_ROOTS = {
-  update_signers: '0x34963b067dbba634e57b416bc2f2a9a8d4ac24147f40b2900148c9ba44774274',
-  update_procedure_threshold: '0xec74c4b96ce593c11017ae54dec9c0ae5e0d242e8b3074eb3908d961300aed67',
-  auth_tx: '0x0708020dce7b91b61116e3eb27e5d686e129a83df3c540e0a7693b4523814e72',
-  update_guardian: '0xeceb1f2c2d7d20312dbaf091e9a27a2b63f9fcba120948043069793a5715bc96',
-  verify_guardian: '0xe6a8a62d37117f55a79b5345aa3d263ab16e973d486bac9a1612663dfdecf82d',
-  send_asset: '0xfb1c73d10de1954e9e8948964e3e77cf4e33759d2e012cb00eb10c50f2974eb4',
-  receive_asset: '0x6170fd6d682d91777b551fd866258f43cc657f1291f8f071500f4e56e9c153da',
+  update_signers: '0xa261cfd3c8791ac5abe1e78e14eade2f20789d73ab1c23c430418de59bc3380e',
+  update_procedure_threshold: '0x97587c61d49313b1d5a3c8b7437e0080e67ed9bd9d3e7206bcae562f934ccd03',
+  auth_tx: '0xa6aa6f69d9358535272ba433cd48d20628a5c69598e00c6dd01a22e83a5f15df',
+  update_guardian: '0x0a614ff7c81a561cbd2a4c2d9482031a7a841ca5de33349daed23a9d871b3675',
+  send_asset: '0x595bc83258726a66bd904912cfd5186c07cbd902dfbc115b7d6bc8105efc57e3',
+  receive_asset: '0x34a56dd18f6fe5aab63198b9dcfc6467e793ebabb37d56b994b902504635da13',
 } as const;
 
 /**

package/src/proposal/metadata.test.ts

@@ -157,3 +157,79 @@ describe('ProposalMetadataCodec p2id noteType (issue #322)', () => {
     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/proposal/metadata.ts

@@ -1,7 +1,7 @@
 import type { ProposalMetadata as GuardianProposalMetadata } from '@openzeppelin/guardian-client';
 import type { ProposalMetadata } from '../types.js';
 import { isProcedureName } from '../procedures.js';
-import { isP2idNoteVisibility } from '../types/proposal.js';
+import { isP2idNoteVisibility, parseP2ideHeight } from '../types/proposal.js';
 
 export class ProposalMetadataCodec {
   static toGuardian(metadata: ProposalMetadata): GuardianProposalMetadata {
@@ -10,6 +10,7 @@ export class ProposalMetadataCodec {
       description: metadata.description,
       salt: metadata.saltHex,
       requiredSignatures: metadata.requiredSignatures,
+      chainAnchor: metadata.chainAnchor,
     };
 
     switch (metadata.proposalType) {
@@ -30,6 +31,11 @@ export class ProposalMetadataCodec {
           // keeps the pre-#322 wire shape and matches the Rust encoder (which
           // round-trips through the NoteType enum). Absent => public.
           noteType: metadata.noteType === 'private' ? 'private' : undefined,
+          // Validated on encode too: the create path already rejects bad
+          // heights when building the note, but metadata handed directly to
+          // the codec must not reach the wire with a value cosigners reject.
+          reclaimHeight: parseP2ideHeight('reclaimHeight', metadata.reclaimHeight),
+          timelockHeight: parseP2ideHeight('timelockHeight', metadata.timelockHeight),
         };
       case 'switch_guardian':
         return {
@@ -68,6 +74,7 @@ export class ProposalMetadataCodec {
       description: guardian.description ?? '',
       saltHex: guardian.salt,
       requiredSignatures: guardian.requiredSignatures,
+      chainAnchor: guardian.chainAnchor,
     };
 
     switch (guardian.proposalType) {
@@ -87,6 +94,8 @@ export class ProposalMetadataCodec {
           faucetId: guardian.faucetId,
           amount: guardian.amount,
           noteType: guardian.noteType,
+          reclaimHeight: parseP2ideHeight('reclaimHeight', guardian.reclaimHeight),
+          timelockHeight: parseP2ideHeight('timelockHeight', guardian.timelockHeight),
         };
       case 'consume_notes':
         if (!guardian.noteIds || guardian.noteIds.length === 0) {
@@ -138,7 +147,7 @@ export class ProposalMetadataCodec {
         };
       default:
         // Any proposal type the SDK does not model collapses to the 'custom'
-        // bucket while preserving the original label (issue #266).
+        // bucket while preserving the original label.
         return {
           ...base,
           proposalType: 'custom',
@@ -182,6 +191,8 @@ export class ProposalMetadataCodec {
         if (metadata.noteType !== undefined && !isP2idNoteVisibility(metadata.noteType)) {
           throw new Error(`p2id proposal has unsupported noteType '${metadata.noteType}'`);
         }
+        parseP2ideHeight('reclaimHeight', metadata.reclaimHeight);
+        parseP2ideHeight('timelockHeight', metadata.timelockHeight);
         return metadata;
       case 'custom':
         // Custom proposals are opaque to the SDK; nothing to validate beyond

package/src/prover/workflow.test.ts

@@ -1,5 +1,6 @@
 import type {
   AccountId,
+  ChainAnchor,
   MidenClient,
   TransactionProver,
   TransactionRequest,
@@ -13,6 +14,8 @@ 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'), {
@@ -47,12 +50,14 @@ describe('ProverWorkflow', () => {
       runtime,
     );
 
-    await workflow.submit(
+    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]);
@@ -83,7 +88,7 @@ describe('ProverWorkflow', () => {
     );
 
     await expect(
-      workflow.submit(asType<AccountId>({}), asType<TransactionRequest>({})),
+      workflow.submitAt(asType<AccountId>({}), asType<TransactionRequest>({}), anchor),
     ).rejects.toBe(final);
     expect(prove).toHaveBeenCalledTimes(2);
     expect(runtime.sleep).toHaveBeenCalledTimes(1);
@@ -113,7 +118,7 @@ describe('ProverWorkflow', () => {
     );
 
     await expect(
-      workflow.submit(asType<AccountId>({}), asType<TransactionRequest>({})),
+      workflow.submitAt(asType<AccountId>({}), asType<TransactionRequest>({}), anchor),
     ).rejects.toBe(rateLimited);
     expect(prove).toHaveBeenCalledTimes(1);
     expect(submit).toHaveBeenCalledTimes(1);
@@ -133,7 +138,7 @@ describe('ProverWorkflow', () => {
       createProver: () => undefined,
     });
 
-    await workflow.submit(asType<AccountId>({}), asType<TransactionRequest>({}));
+    await workflow.submitAt(asType<AccountId>({}), asType<TransactionRequest>({}), anchor);
 
     expect(prove).toHaveBeenCalledWith();
   });

package/src/prover/workflow.ts

@@ -1,4 +1,9 @@
-import type { AccountId, MidenClient, TransactionRequest } from '@miden-sdk/miden-sdk';
+import type {
+  AccountId,
+  ChainAnchor,
+  MidenClient,
+  TransactionRequest,
+} from '@miden-sdk/miden-sdk';
 import type { ResolvedProverConfig } from './config.js';
 import type { RetryRuntime } from '../retry/runtime.js';
 import { proveWithRetry } from './retry.js';
@@ -10,8 +15,15 @@ export class ProverWorkflow {
     private readonly runtime?: RetryRuntime,
   ) {}
 
-  async submit(accountId: AccountId, request: TransactionRequest): Promise<void> {
-    const execution = await this.client.transactions.executeRequest(accountId, request);
+  /** Proves, submits, and applies a request at its signed chain anchor. */
+  async submitAt(
+    accountId: AccountId,
+    request: TransactionRequest,
+    anchor: ChainAnchor,
+  ): Promise<void> {
+    const execution = await this.client.transactions.executeRequest(accountId, request, {
+      anchor,
+    });
     const proof = await proveWithRetry(execution, this.config, this.runtime);
     const submission = await proof.submit();
     await submission.apply();

package/src/transaction/index.ts

@@ -1,4 +1,10 @@
-export { executeForSummary } from './summary.js';
+export {
+  chainAnchorFromBase64,
+  chainAnchorToBase64,
+  executeForSummary,
+  executeForSummaryAt,
+  summarySalt,
+} from './summary.js';
 export { buildUpdateSignersTransactionRequest } from './updateSigners.js';
 export { buildUpdateProcedureThresholdTransactionRequest } from './updateProcedureThreshold.js';
 export { buildUpdateGuardianTransactionRequest } from './updateGuardian.js';

package/src/transaction/p2id.test.ts

@@ -2,13 +2,14 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import type { Word } from '@miden-sdk/miden-sdk';
 
 const {
-  mockFromVaultKey,
   mockFungibleAssetConstructor,
   mockHashElements,
   mockNormalizeHexWord,
   mockRandomWord,
   mockWordFromHex,
   noteMetadataCalls,
+  noteRecipientCalls,
+  noteStorageCalls,
   saltFelts,
 } = vi.hoisted(() => {
   const saltFelts = [
@@ -19,13 +20,10 @@ const {
   ];
 
   return {
-    mockFromVaultKey: vi.fn((vaultKey: unknown, amount: bigint) => ({
-      kind: 'asset-from-vault-key',
-      vaultKey,
-      amount,
-    })),
     mockFungibleAssetConstructor: vi.fn(),
     noteMetadataCalls: [] as unknown[][],
+    noteRecipientCalls: [] as unknown[][],
+    noteStorageCalls: [] as unknown[][],
     mockHashElements: vi.fn().mockReturnValue({ toString: () => 'serial' }),
     mockNormalizeHexWord: vi.fn((hex: string) => hex),
     mockRandomWord: vi.fn().mockReturnValue({
@@ -71,7 +69,9 @@ vi.mock('@miden-sdk/miden-sdk', () => {
   }
 
   class NoteStorage {
-    constructor(_inputs: FeltArray) {}
+    constructor(inputs: FeltArray) {
+      noteStorageCalls.push([inputs]);
+    }
   }
 
   class NoteMetadata {
@@ -86,10 +86,12 @@ vi.mock('@miden-sdk/miden-sdk', () => {
 
   class NoteRecipient {
     constructor(
-      _serialNum: unknown,
-      _noteScript: unknown,
-      _noteInputs: unknown,
-    ) {}
+      serialNum: unknown,
+      noteScript: unknown,
+      noteInputs: unknown,
+    ) {
+      noteRecipientCalls.push([serialNum, noteScript, noteInputs]);
+    }
   }
 
   class Note {
@@ -104,8 +106,6 @@ vi.mock('@miden-sdk/miden-sdk', () => {
     constructor(faucet: unknown, amount: bigint) {
       mockFungibleAssetConstructor(faucet, amount);
     }
-
-    static fromVaultKey = mockFromVaultKey;
   }
 
   class NoteArray {
@@ -152,6 +152,7 @@ vi.mock('@miden-sdk/miden-sdk', () => {
     NoteStorage,
     NoteScript: {
       p2id: vi.fn(() => ({ kind: 'p2id-script' })),
+      p2ide: vi.fn(() => ({ kind: 'p2ide-script' })),
     },
     NoteTag: {
       withAccountTarget: vi.fn(() => ({ kind: 'tag' })),
@@ -182,31 +183,20 @@ vi.mock('../utils/random.js', () => ({
 }));
 
 import { buildP2idTransactionRequest, parseP2idNoteType, p2idNoteTypeToMetadata } from './p2id.js';
-import type { Account } from '@miden-sdk/miden-sdk';
+import { NoteType } 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;
+    noteRecipientCalls.length = 0;
+    noteStorageCalls.length = 0;
   });
 
   it('derives serial number from salt felts plus four zero felts', () => {
@@ -217,7 +207,6 @@ describe('buildP2idTransactionRequest', () => {
       '0x8a65fc5a39e4cd106d648e3eb4ab5f',
       FAUCET_ID,
       10n,
-      mockAccount,
       { salt },
     );
 
@@ -239,28 +228,120 @@ describe('buildP2idTransactionRequest', () => {
     buildP2idTransactionRequest(
       '0x7bfb0f38b0fafa103f86a805594170',
       '0x8a65fc5a39e4cd106d648e3eb4ab5f',
-      '0x7bfb0f38b0fafa103f86a805594171',
+      FAUCET_ID,
       10n,
-      mockAccount,
     );
 
     expect(noteMetadataCalls).toHaveLength(1);
     expect(noteMetadataCalls[0][1]).toBe(NoteType.Public);
   });
 
+  it('builds the asset from the faucet id, whose callback flag it carries since Miden 0.16', () => {
+    buildP2idTransactionRequest(
+      '0x7bfb0f38b0fafa103f86a805594170',
+      '0x8a65fc5a39e4cd106d648e3eb4ab5f',
+      FAUCET_ID,
+      10n,
+    );
+
+    expect(mockFungibleAssetConstructor).toHaveBeenCalledTimes(1);
+    const [faucet, amount] = mockFungibleAssetConstructor.mock.calls[0] as [{ hex: string }, bigint];
+    expect(faucet.hex).toBe(FAUCET_ID);
+    expect(amount).toBe(10n);
+  });
+
   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);
   });
+
+  it('builds a plain P2ID note without heights: p2id script, 2 storage items', () => {
+    buildP2idTransactionRequest(
+      '0x7bfb0f38b0fafa103f86a805594170',
+      '0x8a65fc5a39e4cd106d648e3eb4ab5f',
+      FAUCET_ID,
+      10n,
+    );
+
+    expect(noteRecipientCalls).toHaveLength(1);
+    expect(noteRecipientCalls[0][1]).toEqual({ kind: 'p2id-script' });
+    const [storageInputs] = noteStorageCalls[0] as [{ values: unknown[] }];
+    expect(storageInputs.values).toEqual([2, 1]);
+  });
+
+  it('builds a P2IDE note when reclaimHeight is set (issue #366)', () => {
+    buildP2idTransactionRequest(
+      '0x7bfb0f38b0fafa103f86a805594170',
+      '0x8a65fc5a39e4cd106d648e3eb4ab5f',
+      FAUCET_ID,
+      10n,
+      { reclaimHeight: 12345 },
+    );
+
+    expect(noteRecipientCalls).toHaveLength(1);
+    expect(noteRecipientCalls[0][1]).toEqual({ kind: 'p2ide-script' });
+
+    // P2IDE storage layout: [suffix, prefix, reclaim, timelock], 0 = unset.
+    const [storageInputs] = noteStorageCalls[0] as [{ values: unknown[] }];
+    expect(storageInputs.values).toHaveLength(4);
+    expect(storageInputs.values.slice(0, 2)).toEqual([2, 1]);
+    expect((storageInputs.values[2] as { value: bigint }).value).toBe(12345n);
+    expect((storageInputs.values[3] as { value: bigint }).value).toBe(0n);
+  });
+
+  it('builds a P2IDE note when only timelockHeight is set (issue #366)', () => {
+    buildP2idTransactionRequest(
+      '0x7bfb0f38b0fafa103f86a805594170',
+      '0x8a65fc5a39e4cd106d648e3eb4ab5f',
+      FAUCET_ID,
+      10n,
+      { timelockHeight: 777 },
+    );
+
+    expect(noteRecipientCalls[0][1]).toEqual({ kind: 'p2ide-script' });
+    const [storageInputs] = noteStorageCalls[0] as [{ values: unknown[] }];
+    expect((storageInputs.values[2] as { value: bigint }).value).toBe(0n);
+    expect((storageInputs.values[3] as { value: bigint }).value).toBe(777n);
+  });
+
+  it('carries both heights into the P2IDE storage (issue #366)', () => {
+    buildP2idTransactionRequest(
+      '0x7bfb0f38b0fafa103f86a805594170',
+      '0x8a65fc5a39e4cd106d648e3eb4ab5f',
+      FAUCET_ID,
+      10n,
+      { reclaimHeight: 500, timelockHeight: 400 },
+    );
+
+    const [storageInputs] = noteStorageCalls[0] as [{ values: unknown[] }];
+    expect((storageInputs.values[2] as { value: bigint }).value).toBe(500n);
+    expect((storageInputs.values[3] as { value: bigint }).value).toBe(400n);
+  });
+
+  it.each([
+    ['zero', 0],
+    ['negative', -5],
+    ['fractional', 1.5],
+    ['above u32::MAX', 0x1_0000_0000],
+  ])('rejects a %s height instead of building a divergent note (issue #366)', (_label, height) => {
+    expect(() =>
+      buildP2idTransactionRequest(
+        '0x7bfb0f38b0fafa103f86a805594170',
+        '0x8a65fc5a39e4cd106d648e3eb4ab5f',
+        FAUCET_ID,
+        10n,
+          { reclaimHeight: height },
+      ),
+    ).toThrow(/unsupported reclaimHeight/);
+  });
 });
 
 describe('parseP2idNoteType', () => {

package/src/transaction/p2id.ts

@@ -1,6 +1,7 @@
-import type { Account, TransactionRequest, Word } from '@miden-sdk/miden-sdk';
+import type { TransactionRequest, Word } from '@miden-sdk/miden-sdk';
 import {
   AccountId,
+  Felt,
   FeltArray,
   FungibleAsset,
   MidenArrays,
@@ -20,8 +21,21 @@ 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';
+import { parseP2ideHeight } from '../types/proposal.js';
 
-export interface P2idTransactionOptions extends SignatureOptions {
+/**
+ * P2IDE execution constraints (issue #366). Presence of either height builds
+ * a P2IDE note instead of a plain P2ID note, mirroring the Miden SDK's
+ * `reclaimAfter`/`timelockUntil` semantics on `SendOptions`.
+ */
+export interface P2ideHeightOptions {
+  /** Absolute block height at which the sender may reclaim the note. */
+  reclaimHeight?: number;
+  /** Absolute block height before which the note cannot be consumed. */
+  timelockHeight?: number;
+}
+
+export interface P2idTransactionOptions extends SignatureOptions, P2ideHeightOptions {
   /** Visibility of the created note. Defaults to `NoteType.Public`. */
   noteType?: NoteType;
 }
@@ -60,47 +74,35 @@ 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,
   noteAssets: NoteAssets,
   noteType: NoteType,
   saltHex: string,
+  heights: P2ideHeightOptions = {},
 ): Note {
   const salt = WordType.fromHex(normalizeHexWord(saltHex));
   const serialNum = deriveP2idSerialNumber(salt);
 
-  const noteScript = NoteScript.p2id();
-  const noteStorage = new NoteStorage(new FeltArray([
+  const reclaimHeight = parseP2ideHeight('reclaimHeight', heights.reclaimHeight);
+  const timelockHeight = parseP2ideHeight('timelockHeight', heights.timelockHeight);
+  const isP2ide = reclaimHeight !== undefined || timelockHeight !== undefined;
+
+  // P2IDE storage layout (miden-standards `P2ideNoteStorage`): the P2ID
+  // storage plus reclaim/timelock heights as felts, 0 encoding "unset".
+  const noteScript = isP2ide ? NoteScript.p2ide() : NoteScript.p2id();
+  const storageFelts = [
     recipient.suffix(),
     recipient.prefix(),
-  ]));
+  ];
+  if (isP2ide) {
+    storageFelts.push(
+      new Felt(BigInt(reclaimHeight ?? 0)),
+      new Felt(BigInt(timelockHeight ?? 0)),
+    );
+  }
+  const noteStorage = new NoteStorage(new FeltArray(storageFelts));
 
   const noteRecipient = new NoteRecipient(serialNum, noteScript, noteStorage);
   const noteTag = NoteTag.withAccountTarget(recipient);
@@ -117,26 +119,26 @@ function buildP2idNote(
 /**
  * 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.
+ * proposal produces on execution. Since Miden 0.16, the asset
+ * callback flag is encoded in the faucet account ID.
  */
 export function buildP2idNoteFromMetadata(
   senderId: string,
   recipientId: string,
   faucetId: string,
   amount: bigint,
-  account: Account,
   noteType: NoteType,
   saltHex: string,
+  heights: P2ideHeightOptions = {},
 ): Note {
   const sender = AccountId.fromHex(senderId);
   const recipient = AccountId.fromHex(recipientId);
   const faucet = AccountId.fromHex(faucetId);
 
-  const asset = resolveFungibleAssetFromVault(account, faucet, amount);
+  const asset = new FungibleAsset(faucet, amount);
   const noteAssets = new NoteAssets([asset]);
 
-  return buildP2idNote(sender, recipient, noteAssets, noteType, saltHex);
+  return buildP2idNote(sender, recipient, noteAssets, noteType, saltHex, heights);
 }
 
 export function buildP2idTransactionRequest(
@@ -144,7 +146,6 @@ export function buildP2idTransactionRequest(
   recipientId: string,
   faucetId: string,
   amount: bigint,
-  account: Account,
   options: P2idTransactionOptions = {},
 ): { request: TransactionRequest; salt: Word } {
   const authSaltHex = options.salt ? options.salt.toHex() : randomWord().toHex();
@@ -154,9 +155,9 @@ export function buildP2idTransactionRequest(
     recipientId,
     faucetId,
     amount,
-    account,
     options.noteType ?? NoteType.Public,
     authSaltHex,
+    { reclaimHeight: options.reclaimHeight, timelockHeight: options.timelockHeight },
   );
 
   const outputNotes = new MidenArrays.NoteArray([note]);

package/src/transaction/summary.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it, vi } from 'vitest';
+
+vi.mock('@miden-sdk/miden-sdk', () => ({
+  AccountId: { fromHex: vi.fn() },
+  Word: {
+    newFromFelts: vi.fn((felts: unknown[]) => ({ felts })),
+  },
+}));
+
+vi.mock('../raw-client.js', () => ({
+  getRawMidenClient: vi.fn(),
+}));
+
+const { summarySalt } = await import('./summary.js');
+
+describe('summarySalt', () => {
+  it('reads the salt from the trailing four user params', () => {
+    const summary = {
+      userParams: () => [0, 0, 0, 11, 22, 33, 44],
+    } as never;
+
+    expect(summarySalt(summary)).toEqual({ felts: [11, 22, 33, 44] });
+  });
+
+  it('ignores the leading three user params the auth component zeroes', () => {
+    const summary = {
+      userParams: () => [7, 8, 9, 11, 22, 33, 44],
+    } as never;
+
+    expect(summarySalt(summary)).toEqual({ felts: [11, 22, 33, 44] });
+  });
+});