@openzeppelin/miden-multisig-client 0.16.1 → 0.17.0-rc.1

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] });
+  });
+});

package/src/transaction/summary.ts

@@ -4,28 +4,107 @@ import type {
   TransactionSummary,
   WasmWebClient,
 } from '@miden-sdk/miden-sdk';
-import { AccountId } from '@miden-sdk/miden-sdk';
+import { AccountId, ChainAnchor, Word } from '@miden-sdk/miden-sdk';
 import { getRawMidenClient } from '../raw-client.js';
+import { base64ToUint8Array, uint8ArrayToBase64 } from '../utils/encoding.js';
 
+/**
+ * Index of the first user param carrying the auth-arg salt. The guarded-multisig
+ * auth component zeroes user params 0-2 and fills 3-6 with the auth args, matching
+ * `push.0.0.0` ahead of `multisig::auth_tx` in `guarded_multisig.masm`.
+ */
+const SALT_USER_PARAM_OFFSET = 3;
+
+/**
+ * Captures a `ChainAnchor` for the request at the current sync height and
+ * executes the transaction against it to obtain the summary awaiting
+ * authorization. The anchor is returned alongside the summary so the proposer
+ * can ship it with the signed data; cosigners and the executor then reproduce
+ * the summary — which binds the reference block commitment since protocol
+ * 0.16 — with {@link executeForSummaryAt} regardless of their own sync height.
+ */
 export function executeForSummary(
   client: MidenClient,
   accountId: string,
   txRequest: TransactionRequest,
   midenRpcEndpoint: string,
-): Promise<TransactionSummary>;
+): Promise<{ summary: TransactionSummary; anchor: ChainAnchor }>;
 export function executeForSummary(
   client: WasmWebClient,
   accountId: string,
   txRequest: TransactionRequest,
   midenRpcEndpoint?: string,
-): Promise<TransactionSummary>;
+): Promise<{ summary: TransactionSummary; anchor: ChainAnchor }>;
 export async function executeForSummary(
   client: MidenClient | WasmWebClient,
   accountId: string,
   txRequest: TransactionRequest,
   midenRpcEndpoint?: string,
+): Promise<{ summary: TransactionSummary; anchor: ChainAnchor }> {
+  const acc = AccountId.fromHex(accountId);
+  const rawClient = await getRawMidenClient(client, midenRpcEndpoint);
+  const anchor = await rawClient.chainAnchorForRequest(txRequest);
+  const summary = await rawClient.executeForSummaryAt(acc, txRequest, anchor);
+  return { summary, anchor };
+}
+
+/**
+ * Executes a transaction at the given `ChainAnchor`'s reference block to
+ * obtain the summary awaiting authorization — the anchored counterpart of
+ * {@link executeForSummary} for cosigners and executors holding a proposal's
+ * anchor.
+ */
+export function executeForSummaryAt(
+  client: MidenClient,
+  accountId: string,
+  txRequest: TransactionRequest,
+  anchor: ChainAnchor,
+  midenRpcEndpoint: string,
+): Promise<TransactionSummary>;
+export function executeForSummaryAt(
+  client: WasmWebClient,
+  accountId: string,
+  txRequest: TransactionRequest,
+  anchor: ChainAnchor,
+  midenRpcEndpoint?: string,
+): Promise<TransactionSummary>;
+export async function executeForSummaryAt(
+  client: MidenClient | WasmWebClient,
+  accountId: string,
+  txRequest: TransactionRequest,
+  anchor: ChainAnchor,
+  midenRpcEndpoint?: string,
 ): Promise<TransactionSummary> {
   const acc = AccountId.fromHex(accountId);
   const rawClient = await getRawMidenClient(client, midenRpcEndpoint);
-  return rawClient.executeForSummary(acc, txRequest);
+  return rawClient.executeForSummaryAt(acc, txRequest, anchor);
+}
+
+/**
+ * Serializes a `ChainAnchor` to base64 for the proposal wire payload.
+ */
+export function chainAnchorToBase64(anchor: ChainAnchor): string {
+  return uint8ArrayToBase64(anchor.serialize());
+}
+
+/**
+ * Deserializes a `ChainAnchor` from its base64 wire form. `ChainAnchor`
+ * deserialization validates the header/chain consistency internally, so a
+ * decoded anchor only needs its block commitment checked against the signed
+ * transaction summary before it is safe to execute against.
+ */
+export function chainAnchorFromBase64(anchorBase64: string): ChainAnchor {
+  return ChainAnchor.deserialize(base64ToUint8Array(anchorBase64));
+}
+
+/**
+ * Reads the auth-arg salt back out of a transaction summary.
+ *
+ * Since miden-protocol 0.16-rc the summary binds seven user-defined elements
+ * instead of a dedicated salt word. The guarded-multisig auth component zeroes
+ * the leading three and passes the auth args as the trailing four, so the salt
+ * is the tail of `userParams()`.
+ */
+export function summarySalt(summary: TransactionSummary): Word {
+  return Word.newFromFelts(summary.userParams().slice(SALT_USER_PARAM_OFFSET));
 }

package/src/transaction/updateGuardian.ts

@@ -1,6 +1,4 @@
 import {
-  AdviceMap,
-  FeltArray,
   type MidenClient,
   TransactionRequest,
   TransactionRequestBuilder,
@@ -9,37 +7,38 @@ import {
   Word,
   Word as WordType,
 } from '@miden-sdk/miden-sdk';
-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 { authSchemeId } from '../utils/signature.js';
 import type { MidenClientSignatureOptions, SignatureOptions } from './options.js';
 import type { SignatureScheme } from '../types.js';
 
 async function buildUpdateGuardianScript(
   client: MidenClient | WasmWebClient,
+  newGuardianPubkey: string,
   signatureScheme: SignatureScheme,
   midenRpcEndpoint?: string,
 ): Promise<TransactionScript> {
-  const guardianLibraryPath = 'oz_guardian::guardian';
-  const guardianMasm = signatureScheme === 'ecdsa' ? GUARDIAN_ECDSA_MASM : GUARDIAN_MASM;
+  // A word literal preserves the key's element order on the operand stack.
+  const keyLiteral = normalizeHexWord(newGuardianPubkey);
+  const schemeId = authSchemeId(signatureScheme);
 
+  // Calling the origin procedure yields the same MAST root as its component re-export.
   const scriptSource = `
-use oz_guardian::guardian
+use miden::standards::auth::guardian
 
-begin
-    adv.push_mapval
-    dropw
+@transaction_script
+pub proc main
+    push.${keyLiteral}
+    push.${schemeId}
     call.guardian::update_guardian_public_key
+    drop
+    dropw
 end
   `;
 
-  return compileTxScript(
-    client,
-    scriptSource,
-    [{ namespace: guardianLibraryPath, code: guardianMasm }],
-    midenRpcEndpoint,
-  );
+  return compileTxScript(client, scriptSource, [], midenRpcEndpoint);
 }
 
 export function buildUpdateGuardianTransactionRequest(
@@ -60,25 +59,16 @@ export async function buildUpdateGuardianTransactionRequest(
   const signatureScheme = options.signatureScheme ?? 'falcon';
   const script = await buildUpdateGuardianScript(
     client,
+    newGuardianPubkey,
     signatureScheme,
     options.midenRpcEndpoint,
   );
 
   const authSaltHex = options.salt ? options.salt.toHex() : randomWord().toHex();
-
-  const pubkeyWordForAdvice = WordType.fromHex(normalizeHexWord(newGuardianPubkey));
-  const pubkeyWordForFelts = WordType.fromHex(normalizeHexWord(newGuardianPubkey));
-  const pubkeyWordForScript = WordType.fromHex(normalizeHexWord(newGuardianPubkey));
-
-  const advice = new AdviceMap();
-  advice.insert(pubkeyWordForAdvice, new FeltArray(pubkeyWordForFelts.toFelts()));
-
   const authSaltForBuilder = WordType.fromHex(normalizeHexWord(authSaltHex));
 
   let txBuilder = new TransactionRequestBuilder();
   txBuilder = txBuilder.withCustomScript(script);
-  txBuilder = txBuilder.withScriptArg(pubkeyWordForScript);
-  txBuilder = txBuilder.extendAdviceMap(advice);
   txBuilder = txBuilder.withAuthArg(authSaltForBuilder);
 
   if (options.signatureAdviceMap) {