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

package/src/procedures.ts

@@ -11,12 +11,12 @@
  * human-readable encoding and should not be copied into this table.
  */
 export const PROCEDURE_ROOTS = {
-  update_signers: '0xa261cfd3c8791ac5abe1e78e14eade2f20789d73ab1c23c430418de59bc3380e',
-  update_procedure_threshold: '0x97587c61d49313b1d5a3c8b7437e0080e67ed9bd9d3e7206bcae562f934ccd03',
-  auth_tx: '0x43fb07d62ed26993b7b13c7b411db62c5b5acffa2813e989608c41a72d7185ec',
-  update_guardian: '0x0a614ff7c81a561cbd2a4c2d9482031a7a841ca5de33349daed23a9d871b3675',
-  send_asset: '0x595bc83258726a66bd904912cfd5186c07cbd902dfbc115b7d6bc8105efc57e3',
-  receive_asset: '0x34a56dd18f6fe5aab63198b9dcfc6467e793ebabb37d56b994b902504635da13',
+  update_signers: '0xe39b380d435dd42206fd625fcddfd26a379a2312cfef0271e9b5f18cbdec67e5',
+  update_procedure_threshold: '0x5de3563f30c5dd130da49c8fdd86d867fed6dbbd928363021c53ef99d8034bac',
+  auth_tx: '0xf988ff88c7a9c2104d77862d580239ec40e060a9b4d2d96028135abeb8cc58bc',
+  update_guardian: '0x93dedb135fd5bb7112c07aacf4a5680ddc76e45ecf043bfc42ea735b6d971911',
+  send_asset: '0x936e9920bffd7f458cc9ba2c4bbcc018fc4d3561511d79635955129268039dd7',
+  receive_asset: '0xd7416b798a70aabbca510c3cd0f48ba35473b5d76dc302375157c6f563fffc15',
 } as const;
 
 /**
@@ -33,7 +33,7 @@ export type ProcedureName = keyof typeof PROCEDURE_ROOTS;
  * @example
  * ```typescript
  * const root = getProcedureRoot('send_asset');
- * // '0x6d30df4312a2c44ec842db1bee227cc045396ca91e2c47d756dcb607f2bf5f89'
+ * // '0x936e9920bffd7f458cc9ba2c4bbcc018fc4d3561511d79635955129268039dd7'
  * ```
  */
 export function getProcedureRoot(name: ProcedureName): string {

package/src/proposal/factory.ts

@@ -92,6 +92,7 @@ export class ProposalFactory {
       txSummary: delta.deltaPayload.txSummary.data,
       signatures,
       metadata: resolvedMetadata,
+      verification: { status: 'unchecked' },
     };
   }
 
@@ -117,6 +118,10 @@ export class ProposalFactory {
             `Invalid imported proposal signatures: ECDSA signature for ${signature.commitment} is missing publicKey`,
           );
         }
+        if (signature.messageFormat !== undefined &&
+          (scheme !== 'ecdsa' || signature.messageFormat !== 'eip712')) {
+          throw new Error('Invalid imported proposal signatures: unsupported message format');
+        }
 
         return {
           signerId: signature.commitment,
@@ -126,6 +131,7 @@ export class ProposalFactory {
                   scheme,
                   signature: signature.signatureHex,
                   publicKey: signature.publicKey,
+                  ...(signature.messageFormat ? { messageFormat: signature.messageFormat } : {}),
                 }
               : {
                   scheme,
@@ -148,6 +154,7 @@ export class ProposalFactory {
       txSummary: exported.txSummaryBase64,
       signatures,
       metadata,
+      verification: { status: 'unchecked' },
     };
   }
 

package/src/prover/workflow.ts

@@ -1,6 +1,5 @@
 import type {
   AccountId,
-  ChainAnchor,
   MidenClient,
   TransactionRequest,
 } from '@miden-sdk/miden-sdk';
@@ -15,15 +14,13 @@ export class ProverWorkflow {
     private readonly runtime?: RetryRuntime,
   ) {}
 
-  /** 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,
-    });
+  /**
+   * Executes a request at the chain tip, then proves, submits, and applies it.
+   * A multisig proposal's request declares the block its summary binds, so the
+   * signed summary reproduces at the tip.
+   */
+  async submit(accountId: AccountId, request: TransactionRequest): Promise<void> {
+    const execution = await this.client.transactions.executeRequest(accountId, request);
     const proof = await proveWithRetry(execution, this.config, this.runtime);
     const submission = await proof.submit();
     await submission.apply();

package/src/raw-client.ts

@@ -29,7 +29,7 @@ export function requireMidenRpcEndpoint(endpoint?: string): string {
   return requireConfigValue('midenRpcEndpoint', endpoint);
 }
 
-function isPublicMidenClient(client: RawClientSource): client is MidenClient {
+export function isPublicMidenClient(client: RawClientSource): client is MidenClient {
   return 'accounts' in client && 'sync' in client;
 }
 
@@ -47,16 +47,20 @@ export async function getRawMidenClient(
   }
 
   const endpoint = requireMidenRpcEndpoint(rpcUrl);
-  const rawClient = WasmWebClient.createClient(
-    endpoint,
-    undefined,
-    undefined,
-    await client.storeIdentifier(),
-  );
+  const rawClient = createRawClient(client, endpoint);
   rawClientCache.set(client, rawClient);
   return rawClient;
 }
 
+/**
+ * Opens the WASM client behind `client` on the same store. The protocol
+ * configuration comes from the node with every sync and is read from that
+ * shared store, so the shadow needs no fee faucet of its own.
+ */
+async function createRawClient(client: MidenClient, endpoint: string): Promise<WasmWebClient> {
+  return WasmWebClient.createClient(endpoint, undefined, undefined, await client.storeIdentifier());
+}
+
 export function getTransactionProver(client: RawClientSource): TransactionProver | null {
   return isPublicMidenClient(client) ? client.defaultProver : null;
 }

package/src/recovery/publicNoteBackfill.ts

@@ -102,7 +102,7 @@ export function screenNoteForAccount(note: Note, account: AccountId): ScreenVerd
     items[index].asInt() === suffix &&
     items[index + 1].asInt() === prefix;
   if (root === normalizeHexWord(NoteScript.p2id().root().toHex())) {
-    // P2ID note storage: [target.suffix, target.prefix].
+    // P2ID note storage: [target.suffix, target.prefix, salt_0, salt_1].
     return accountAt(0) ? 'relevant' : 'irrelevant';
   }
   if (root === normalizeHexWord(NoteScript.p2ide().root().toHex())) {

package/src/retry/classify.ts

@@ -15,7 +15,7 @@ type ErrorRecord = {
   message?: unknown;
 };
 
-type StructuredEvidence = 'transient' | 'permanent' | 'indeterminate';
+export type StructuredEvidence = 'transient' | 'permanent' | 'indeterminate';
 
 const TRANSIENT_GRPC = new Set([
   'cancelled',
@@ -96,7 +96,7 @@ function httpEvidence(value: unknown): StructuredEvidence | undefined {
   return TRANSIENT_HTTP.has(value) ? 'transient' : 'permanent';
 }
 
-function httpMessageEvidence(message: string): StructuredEvidence | undefined {
+export function httpMessageEvidence(message: string): StructuredEvidence | undefined {
   let hasTransient = false;
   for (const match of message.matchAll(
     /(?:\bhttp(?:\s+status)?|\bstatus)(?:\s+code)?\s*:?\s*(\d{3})\b/g,
@@ -110,7 +110,7 @@ function httpMessageEvidence(message: string): StructuredEvidence | undefined {
   return hasTransient ? 'transient' : undefined;
 }
 
-function grpcMessageEvidence(message: string): StructuredEvidence | undefined {
+export function grpcMessageEvidence(message: string): StructuredEvidence | undefined {
   const normalized = message.replaceAll(/[^a-z0-9]/g, '');
   let hasTransient = false;
   for (const { token, evidence } of GRPC_MESSAGE_TOKENS) {

package/src/signer.ts

@@ -1,4 +1,5 @@
 export { FalconSigner } from './signers/falcon.js';
 export { EcdsaSigner } from './signers/ecdsa.js';
+export { Eip712Signer, LedgerSigner, type Eip1193SignerProvider } from './signers/ledger.js';
 export { ParaSigner, type ParaSigningContext } from './signers/para.js';
 export { MidenWalletSigner, type WalletSigningContext } from './signers/miden-wallet.js';

package/src/signers/index.ts

@@ -1,4 +1,5 @@
 export { FalconSigner } from './falcon.js';
 export { EcdsaSigner } from './ecdsa.js';
+export { Eip712Signer, LedgerSigner, type Eip1193SignerProvider } from './ledger.js';
 export { ParaSigner, type ParaSigningContext } from './para.js';
 export { MidenWalletSigner, type WalletSigningContext } from './miden-wallet.js';

package/src/signers/ledger.ts

@@ -0,0 +1,122 @@
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { keccak_256 } from '@noble/hashes/sha3.js';
+import type { RequestAuthPayload, Signer } from '@openzeppelin/guardian-client';
+import { AuthDigest } from '../utils/digest.js';
+import { lookupAuthDigest } from '../lookupAuth.js';
+import { EcdsaFormat } from '../utils/ecdsa.js';
+import { bytesToHex, hexToBytes } from '../utils/encoding.js';
+import {
+  guardianKeyDiscoveryTypedData,
+  guardianLookupTypedData,
+  guardianRequestTypedData,
+  midenTransactionTypedData,
+  typedDataDigest,
+} from '../utils/eip712.js';
+import { tryComputeEcdsaCommitmentHex } from '../utils/signature.js';
+import { wordToBytes } from '../utils/word.js';
+
+export interface Eip1193SignerProvider {
+  request(args: { method: string; params: unknown[] }): Promise<unknown>;
+}
+
+export class Eip712Signer implements Signer {
+  readonly scheme = 'ecdsa';
+  readonly requestAuthFormat = 'eip712';
+  readonly proposalMessageFormat = 'eip712';
+  readonly publicKey: string;
+  readonly commitment: string;
+  readonly address: string;
+
+  static async connect(provider: Eip1193SignerProvider): Promise<Eip712Signer> {
+    const accounts = await provider.request({ method: 'eth_requestAccounts', params: [] });
+    if (!Array.isArray(accounts) || typeof accounts[0] !== 'string') {
+      throw new Error('Wallet did not provide an Ethereum address');
+    }
+    const address = accounts[0];
+    const challenge = crypto.getRandomValues(new Uint8Array(32));
+    const data = guardianKeyDiscoveryTypedData(challenge);
+    const result = await provider.request({
+      method: 'eth_signTypedData_v4',
+      params: [address, JSON.stringify(data)],
+    });
+    if (typeof result !== 'string' || !/^0x[0-9a-fA-F]{130}$/.test(result)) {
+      throw new Error('Wallet returned an invalid key-discovery signature');
+    }
+    const signature = hexToBytes(EcdsaFormat.normalizeRecoveryByte(result));
+    if (signature[64] !== 0 && signature[64] !== 1) {
+      throw new Error('Wallet returned an invalid recovery ID');
+    }
+    const publicKey = secp256k1.Signature.fromCompact(signature.slice(0, 64))
+      .addRecoveryBit(signature[64])
+      .recoverPublicKey(typedDataDigest(data))
+      .toRawBytes(true);
+    return new Eip712Signer(provider, bytesToHex(publicKey), address);
+  }
+
+  constructor(
+    private readonly provider: Eip1193SignerProvider,
+    publicKey: string,
+    address: string,
+  ) {
+    if (!EcdsaFormat.isValidPublicKeyPoint(publicKey)) {
+      throw new Error('Invalid wallet public key');
+    }
+    this.publicKey = EcdsaFormat.compressPublicKey(publicKey);
+    const commitment = tryComputeEcdsaCommitmentHex(this.publicKey);
+    if (!commitment) {
+      throw new Error('Cannot derive the Miden commitment for the wallet public key');
+    }
+    this.commitment = commitment;
+
+    const uncompressed = secp256k1.ProjectivePoint.fromHex(this.publicKey.slice(2)).toRawBytes(false);
+    const derivedAddress = bytesToHex(keccak_256(uncompressed.slice(1)).slice(-20));
+    if (derivedAddress.toLowerCase() !== address.toLowerCase()) {
+      throw new Error('Wallet address does not match its public key');
+    }
+    this.address = address;
+  }
+
+  signAccountIdWithTimestamp(): Promise<string> {
+    throw new Error('Eip712Signer requires request-bound Guardian authentication');
+  }
+
+  async signRequest(
+    accountId: string,
+    timestamp: number,
+    requestPayload: RequestAuthPayload,
+  ): Promise<string> {
+    const requestHash = AuthDigest.fromRequest(accountId, timestamp, requestPayload);
+    return this.signTypedData(guardianRequestTypedData(wordToBytes(requestHash)));
+  }
+
+  async signLookupMessage(keyCommitmentHex: string, timestampMs: number): Promise<string> {
+    const lookupHash = lookupAuthDigest(timestampMs, keyCommitmentHex);
+    return this.signTypedData(guardianLookupTypedData(wordToBytes(lookupHash)));
+  }
+
+  async signCommitment(commitmentHex: string): Promise<string> {
+    const commitment = AuthDigest.fromCommitmentHex(commitmentHex);
+    return this.signTypedData(midenTransactionTypedData(wordToBytes(commitment)));
+  }
+
+  private async signTypedData(data: ReturnType<typeof guardianRequestTypedData>): Promise<string> {
+    const result = await this.provider.request({
+      method: 'eth_signTypedData_v4',
+      params: [this.address, JSON.stringify(data)],
+    });
+    if (typeof result !== 'string' || !/^0x[0-9a-fA-F]{130}$/.test(result)) {
+      throw new Error('Wallet returned an invalid EIP-712 signature');
+    }
+    const signatureHex = EcdsaFormat.normalizeRecoveryByte(result);
+    const signature = hexToBytes(signatureHex);
+    if (signature[64] !== 0 && signature[64] !== 1) {
+      throw new Error('Wallet returned an invalid ECDSA recovery ID');
+    }
+    if (!secp256k1.verify(signature.slice(0, 64), typedDataDigest(data), hexToBytes(this.publicKey))) {
+      throw new Error('Wallet signature was produced by a different key');
+    }
+    return signatureHex;
+  }
+}
+
+export { Eip712Signer as LedgerSigner };

package/src/state/adopt.ts

@@ -0,0 +1,132 @@
+/**
+ * Deciding when GUARDIAN-provided account state may replace the local store.
+ *
+ * Both entry points that pull an account from GUARDIAN need this: `syncState`,
+ * which refreshes an account already in hand, and `MultisigClient.load`, which
+ * rebuilds one. Sharing the rule is the point. Deciding it twice is how the two
+ * paths came to disagree, with `load` keeping whatever the store held whenever
+ * it held anything, so a caller that had touched the account before read stale
+ * state with no error.
+ */
+
+import { Account, AccountId, Endpoint, RpcClient } from '@miden-sdk/miden-sdk';
+
+import { retryRpcRead } from '../rpc/retry.js';
+import type { ResolvedRpcConfig } from '../rpc/config.js';
+import { normalizeHexWord } from '../utils/encoding.js';
+
+const ZERO_COMMITMENT = `0x${'0'.repeat(64)}`;
+
+/**
+ * The account's commitment as the node reports it, or `null` when the account
+ * is not deployed yet. An undeployed account is not an error: it has no
+ * on-chain commitment to disagree with.
+ */
+export async function readOnChainCommitment(
+  midenRpcEndpoint: string,
+  accountId: AccountId,
+  rpcConfig: ResolvedRpcConfig,
+): Promise<string | null> {
+  const rpcClient = new RpcClient(new Endpoint(midenRpcEndpoint));
+
+  try {
+    const accountDetails = await retryRpcRead(
+      () => rpcClient.getAccountDetails(accountId),
+      rpcConfig,
+    );
+    if (!accountDetails) {
+      return null;
+    }
+    const commitment = normalizeHexWord(accountDetails.commitment().toHex());
+    return commitment === ZERO_COMMITMENT ? null : commitment;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (
+      message.includes('null pointer passed to rust') ||
+      message.includes('No account header record found for given ID') ||
+      message.toLowerCase().includes('not found')
+    ) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+/**
+ * Decide whether GUARDIAN-provided state may overwrite the local store.
+ *
+ * Returns `false`, rather than throwing, when the GUARDIAN state is simply
+ * *behind* local (lower nonce). That happens whenever the execution delta the
+ * client pushed has not been canonicalized by GUARDIAN's background worker yet
+ * (see OpenZeppelin/guardian#316), or permanently if that candidate was
+ * discarded (#312 / #319). In that case the local account is already ahead and
+ * is independently verifiable against chain (`verifyStateCommitment`), so it is
+ * authoritative and must be kept, not clobbered; the caller keeps local and
+ * refreshes config from it.
+ *
+ * Still throws for genuine divergence: an incoming state at the *same* nonce as
+ * local but a different commitment, or an incoming state whose commitment does
+ * not match the on-chain commitment.
+ *
+ * Callers must only reach here once they know the two states differ. At equal
+ * nonce this treats the pair as divergent, which is true only when the
+ * commitments already disagree.
+ */
+export async function isSafeToAdoptGuardianState(params: {
+  accountId: string;
+  incomingAccount: Account;
+  localAccount?: Account;
+  readCommitment: () => Promise<string | null>;
+}): Promise<boolean> {
+  const { accountId, incomingAccount, localAccount, readCommitment } = params;
+
+  if (localAccount) {
+    const localNonce = localAccount.nonce().asInt();
+    const incomingNonce = incomingAccount.nonce().asInt();
+
+    if (incomingNonce < localNonce) {
+      return false;
+    }
+
+    if (incomingNonce === localNonce) {
+      throw new Error(
+        `Refusing to overwrite local state: incoming nonce ${incomingNonce.toString()} equals local nonce ${localNonce.toString()} but commitments differ for account ${accountId}`
+      );
+    }
+  }
+
+  const onChainCommitment = await readCommitment();
+  if (!onChainCommitment) {
+    // No on-chain commitment means the account is not deployed, and an
+    // undeployed account has nothing to disagree with. That reading is only
+    // safe when the account has never transacted: `readOnChainCommitment`
+    // reports a missing account by matching `not found` in the error text, and
+    // a proxy or gateway 404 says exactly that. An account with a non-zero
+    // nonce has transacted, so it is deployed, so this is an RPC failure rather
+    // than an undeployed account, and adopting on it would skip the commitment
+    // check entirely.
+    // Keyed on the *local* nonce only. An account this client has transacted is
+    // deployed, so a node reporting nothing for it is an RPC failure rather
+    // than an undeployed account, and adopting there would skip the check
+    // against chain. The incoming nonce is GUARDIAN's claim rather than
+    // evidence, and `syncState` legitimately meets a higher incoming nonce with
+    // no local history; the caller that has no local record at all applies its
+    // own rule.
+    const transacted = localAccount?.nonce().asInt() ?? BigInt(0);
+    if (transacted > BigInt(0)) {
+      throw new Error(
+        `Refusing to overwrite local state: account ${accountId} has transacted (nonce ${transacted.toString()}) but the node reported no on-chain commitment, so the incoming state could not be checked against chain`
+      );
+    }
+    return true;
+  }
+
+  const incomingCommitment = normalizeHexWord(incomingAccount.to_commitment().toHex());
+  if (incomingCommitment !== onChainCommitment) {
+    throw new Error(
+      `Refusing to overwrite local state: incoming commitment does not match on-chain commitment for account ${accountId}`
+    );
+  }
+
+  return true;
+}

package/src/transaction/authArgs.ts

@@ -0,0 +1,142 @@
+import type { Felt, TransactionRequest, TransactionRequestBuilder, Word } from '@miden-sdk/miden-sdk';
+import { AccountId, Word as WordType } from '@miden-sdk/miden-sdk';
+import { MultisigAuthArgsMissingError } from '../multisig/authArgErrors.js';
+import { getRawMidenClient, isPublicMidenClient, type RawClientSource } from '../raw-client.js';
+import { normalizeHexWord } from '../utils/encoding.js';
+import { randomWord } from '../utils/random.js';
+import type { MultisigRequestOptions } from './options.js';
+
+/**
+ * Layout of the multisig auth-args preimage the auth arg commits to, in felts:
+ * `[bound_block_num, approval_expiration_block_num, 0, 0, SALT, CONVERSION_INFO]`.
+ */
+const AUTH_ARGS_BOUND_BLOCK_INDEX = 0;
+const AUTH_ARGS_SALT_OFFSET = 4;
+const AUTH_ARGS_NUM_ELEMENTS = 12;
+
+/**
+ * A request under construction that already carries the multisig auth args,
+ * and the salt they commit to as normalized hex.
+ */
+export interface MultisigRequestDraft {
+  builder: TransactionRequestBuilder;
+  saltHex: string;
+}
+
+/**
+ * Starts a request carrying the multisig auth args for `options.accountId`:
+ * the three-word preimage in the advice map and its commitment as the auth
+ * arg, which miden-client then leaves alone.
+ *
+ * The salt is `options.salt` or a fresh one. `approvalExpirationDelta` left
+ * out means the approval never expires, the upstream default. `boundBlockNum`
+ * left out binds the store's sync height, which is what a proposer wants; a
+ * rebuild pins the proposal's anchor block and the expiration the summary
+ * already binds.
+ *
+ * The salt is moved across the WASM boundary, so a handle is built here from
+ * the hex rather than taken from the caller, and nothing frees it afterwards.
+ */
+export async function multisigRequestBuilder(
+  client: RawClientSource,
+  options: MultisigRequestOptions,
+): Promise<MultisigRequestDraft> {
+  const { accountId, boundBlockNum, approvalExpirationDelta, midenRpcEndpoint } = options;
+  assertApprovalExpirationDelta(approvalExpirationDelta);
+  const saltHex = normalizeHexWord(options.salt ? options.salt.toHex() : randomWord().toHex());
+  const salt = WordType.fromHex(saltHex);
+  if (isPublicMidenClient(client)) {
+    const builder = await client.feeAwareTransactionRequestBuilder(accountId, {
+      feeConversionSalt: salt,
+      boundBlockNum,
+      approvalExpirationDelta,
+    });
+    return { builder, saltHex };
+  }
+  const rawClient = await getRawMidenClient(client, midenRpcEndpoint);
+  const builder = await rawClient.feeAwareTransactionRequestBuilder(
+    AccountId.fromHex(accountId),
+    approvalExpirationDelta ?? null,
+    salt,
+    boundBlockNum ?? null,
+  );
+  return { builder, saltHex };
+}
+
+/**
+ * The furthest a transaction may expire after its reference block
+ * (`MAX_EXPIRATION_BLOCK_DELTA` in the transaction kernel). The auth procedure
+ * clamps the approval expiration it applies to this, so a longer approval would
+ * outlive the transaction it authorizes: the summary would still say "valid"
+ * while the node already refuses the submission as expired.
+ */
+export const MAX_APPROVAL_EXPIRATION_DELTA = 65_535;
+
+/**
+ * Zero is not "no expiration": the kernel reads it as expired at the bound
+ * block and rejects the transaction. Refused here, where the caller can see why,
+ * together with a delta the auth procedure would silently clamp.
+ */
+function assertApprovalExpirationDelta(delta: number | undefined): void {
+  if (delta === undefined) {
+    return;
+  }
+  if (!Number.isInteger(delta) || delta < 1 || delta > MAX_APPROVAL_EXPIRATION_DELTA) {
+    throw new Error(
+      `approvalExpirationDelta must be a whole number of blocks between 1 and ${MAX_APPROVAL_EXPIRATION_DELTA}, ` +
+        `got ${delta}; omit it for an approval that does not expire`,
+    );
+  }
+}
+
+/**
+ * Builds the request and hands back the salt it commits to as a fresh handle
+ * the caller owns. Refuses a request that carries no auth arg:
+ * `feeAwareTransactionRequestBuilder` hands back an untouched builder for an
+ * account it cannot classify as a multisig, typically one the client's store
+ * does not hold, and such a request would only fail later, inside the VM,
+ * while the auth procedure pipes a preimage that is not there.
+ */
+export function buildMultisigRequest(
+  builder: TransactionRequestBuilder,
+  saltHex: string,
+  accountId: string,
+): { request: TransactionRequest; salt: Word } {
+  const request = builder.build();
+  if (!request.authArg()) {
+    throw new MultisigAuthArgsMissingError(accountId);
+  }
+  return { request, salt: WordType.fromHex(saltHex) };
+}
+
+/**
+ * The block a multisig request's summary binds, read from the auth-args
+ * preimage the request carries. `undefined` when the request carries none.
+ */
+export function requestBoundBlockNum(request: TransactionRequest): number | undefined {
+  const preimage = authArgsPreimage(request);
+  return preimage ? Number(preimage[AUTH_ARGS_BOUND_BLOCK_INDEX].asInt()) : undefined;
+}
+
+/**
+ * The salt a multisig request's summary binds, read from the auth-args
+ * preimage the request carries. `undefined` when the request carries none.
+ */
+export function requestSaltHex(request: TransactionRequest): string | undefined {
+  const preimage = authArgsPreimage(request);
+  if (!preimage) {
+    return undefined;
+  }
+  return WordType.newFromFelts(
+    preimage.slice(AUTH_ARGS_SALT_OFFSET, AUTH_ARGS_SALT_OFFSET + 4),
+  ).toHex();
+}
+
+function authArgsPreimage(request: TransactionRequest): Felt[] | undefined {
+  const authArg = request.authArg();
+  if (!authArg) {
+    return undefined;
+  }
+  const felts = request.adviceMap().get(authArg);
+  return felts && felts.length === AUTH_ARGS_NUM_ELEMENTS ? felts : undefined;
+}