@miden-sdk/miden-sdk 0.15.7 → 0.16.0-alpha.1

package/dist/st/index.js

@@ -1,5 +1,5 @@
 import loadWasm from './wasm.js';
-export { Account, AccountArray, AccountBuilder, AccountBuilderResult, AccountCode, AccountComponent, AccountComponentCode, AccountDelta, AccountFile, AccountHeader, AccountId, AccountIdArray, AccountInterface, AccountProof, AccountReader, AccountStatus, AccountStorage, AccountStorageDelta, AccountStorageMode, AccountStorageRequirements, AccountVaultDelta, Address, AdviceInputs, AdviceMap, AssetCallbackFlag, AssetVault, AuthFalcon512RpoMultisigConfig, AuthSecretKey, BasicFungibleFaucetComponent, BlockHeader, CodeBuilder, CommittedNote, ConsumableNoteRecord, Endpoint, EthAddress, ExecutedTransaction, Felt, FeltArray, FetchedAccount, FetchedNote, FlattenedU8Vec, ForeignAccount, ForeignAccountArray, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsSettingMutation, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkAccountTarget, NetworkId, NetworkNoteStatusInfo, NetworkType, Note, NoteAndArgs, NoteAndArgsArray, NoteArray, NoteAssets, NoteAttachment, NoteAttachmentScheme, NoteConsumability, NoteConsumptionStatus, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteExportFormat, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteIdAndArgsArray, NoteInclusionProof, NoteLocation, NoteMetadata, NoteRecipient, NoteRecipientArray, NoteScript, NoteStorage, NoteSyncBlock, NoteSyncInfo, NoteTag, NoteType, OutputNote, OutputNoteArray, OutputNoteRecord, OutputNoteState, OutputNotes, Package, PartialNote, Poseidon2, ProcedureThreshold, Program, ProvenTransaction, PswapLineageRecord, PswapLineageState, PublicKey, RpcClient, Rpo256, SerializedInputNoteData, SerializedOutputNoteData, SerializedTransactionData, Signature, SigningInputs, SigningInputsType, SlotAndKeys, SparseMerklePath, StorageMap, StorageMapEntry, StorageMapEntryJs, StorageMapInfo, StorageMapUpdate, StorageSlot, StorageSlotArray, SyncSummary, TestUtils, TokenSymbol, TransactionArgs, TransactionFilter, TransactionId, TransactionProver, TransactionRecord, TransactionRequest, TransactionRequestBuilder, TransactionResult, TransactionScript, TransactionScriptInputPair, TransactionScriptInputPairArray, TransactionStatus, TransactionStoreUpdate, TransactionSummary, WebClient, WebKeystoreApi, Word, createAuthFalcon512RpoMultisig, exportStore, importStore, initSync, sequentialSumBench, setupLogging } from './Cargo-DR9fiMbE.js';
+export { Account, AccountArray, AccountBuilder, AccountBuilderResult, AccountCode, AccountComponent, AccountComponentCode, AccountDelta, AccountFile, AccountHeader, AccountId, AccountIdArray, AccountInterface, AccountPatch, AccountProof, AccountReader, AccountStatus, AccountStorage, AccountStorageMode, AccountStoragePatch, AccountStorageRequirements, AccountVaultDelta, AccountVaultPatch, Address, AdviceInputs, AdviceMap, AssetVault, AuthFalcon512RpoMultisigConfig, AuthSecretKey, BasicFungibleFaucetComponent, BlockHeader, CodeBuilder, CommittedNote, ConsumableNoteRecord, Endpoint, ExecutedTransaction, Felt, FeltArray, FetchedAccount, FetchedNote, FlattenedU8Vec, ForeignAccount, ForeignAccountArray, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsSettingMutation, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkId, NetworkNoteStatusInfo, NetworkType, Note, NoteAndArgs, NoteAndArgsArray, NoteArray, NoteAssets, NoteAttachment, NoteAttachmentScheme, NoteConsumability, NoteConsumptionStatus, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteExportFormat, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteIdAndArgsArray, NoteInclusionProof, NoteLocation, NoteMetadata, NoteRecipient, NoteRecipientArray, NoteScript, NoteStorage, NoteSyncBlock, NoteSyncInfo, NoteTag, NoteType, OutputNote, OutputNoteArray, OutputNoteRecord, OutputNoteState, OutputNotes, Package, PartialNote, Poseidon2, ProcedureThreshold, Program, ProvenTransaction, PublicKey, RpcClient, Rpo256, SerializedInputNoteData, SerializedOutputNoteData, SerializedTransactionData, Signature, SigningInputs, SigningInputsType, SlotAndKeys, SparseMerklePath, StorageMap, StorageMapEntry, StorageMapEntryJs, StorageMapInfo, StorageMapUpdate, StorageSlot, StorageSlotArray, SyncSummary, TestUtils, TokenSymbol, TransactionArgs, TransactionFilter, TransactionId, TransactionProver, TransactionRecord, TransactionRequest, TransactionRequestBuilder, TransactionResult, TransactionScript, TransactionScriptInputPair, TransactionScriptInputPairArray, TransactionStatus, TransactionStoreUpdate, TransactionSummary, WebClient, WebKeystoreApi, Word, createAuthFalcon512RpoMultisig, exportStore, importStore, initSync, sequentialSumBench, setupLogging } from './Cargo-LwITdlzJ.js';
 
 const WorkerAction = Object.freeze({
   INIT: "init",
@@ -547,26 +547,6 @@ class AccountsResource {
   }
 }
 
-/**
- * Prove an executed transaction, resolving the prover exactly the way the
- * one-shot `submit()` pipeline does: the per-call prover if given, else the
- * client's default prover, else the built-in local prover. Shared by
- * {@link TransactionExecution.prove} and the internal pipeline so the two can
- * never drift.
- *
- * @param {*} inner - The WASM WebClient.
- * @param {*} defaultProver - The client's configured default prover, or null.
- * @param {*} result - The execution result to prove.
- * @param {{ prover?: * }} [opts] - Optional per-call prover override.
- * @returns {Promise<*>} The proven transaction.
- */
-async function proveResult(inner, defaultProver, result, opts) {
-  const prover = opts?.prover ?? defaultProver;
-  return prover
-    ? await inner.proveTransaction(result, prover)
-    : await inner.proveTransaction(result);
-}
-
 class TransactionsResource {
   #inner;
   #getWasm;
@@ -642,97 +622,6 @@ class TransactionsResource {
     return { txId, note: null, result };
   }
 
-  /**
-   * Builds a Public custom-script note carrying a NetworkAccountTarget
-   * attachment, submits it as an own output note, and optionally waits for
-   * confirmation. Provide exactly one of `recipient` or `script`.
-   */
-  async createNetworkNote(opts) {
-    this.#client.assertNotTerminated();
-    const wasm = await this.#getWasm();
-
-    if (opts.recipient && opts.script) {
-      throw new Error(
-        "createNetworkNote requires exactly one of `recipient` or `script`, not both."
-      );
-    }
-
-    const senderId = resolveAccountRef(opts.account, wasm);
-
-    const target =
-      opts.target instanceof wasm.NetworkAccountTarget
-        ? opts.target
-        : new wasm.NetworkAccountTarget(
-            resolveAccountRef(opts.target, wasm),
-            opts.executionHint
-          );
-
-    const noteAssets = opts.assets
-      ? new wasm.NoteAssets(
-          (Array.isArray(opts.assets) ? opts.assets : [opts.assets]).map(
-            (a) =>
-              new wasm.FungibleAsset(
-                resolveAccountRef(a.token, wasm),
-                BigInt(a.amount)
-              )
-          )
-        )
-      : new wasm.NoteAssets();
-
-    const metadata = new wasm.NoteMetadata(
-      senderId,
-      wasm.NoteType.Public,
-      wasm.NoteTag.withAccountTarget(target.targetId())
-    );
-
-    let recipient = opts.recipient;
-    if (!recipient) {
-      if (!opts.script) {
-        throw new Error(
-          "createNetworkNote requires either `recipient` or `script`."
-        );
-      }
-      const storage = new wasm.NoteStorage(
-        new wasm.FeltArray(
-          (opts.inputs ?? []).map((value) => new wasm.Felt(value))
-        )
-      );
-      recipient = wasm.NoteRecipient.fromScript(opts.script, storage);
-    }
-
-    const attachments = [target.toAttachment()];
-    if (opts.attachment) {
-      attachments.push(new wasm.NoteAttachment(opts.attachment));
-    }
-
-    const note = wasm.Note.withAttachments(
-      noteAssets,
-      metadata,
-      recipient,
-      attachments
-    );
-
-    // NoteArray constructor consumes its elements; use push(&note) to keep
-    // `note` valid so we can return it to the caller.
-    const ownOutputs = new wasm.NoteArray();
-    ownOutputs.push(note);
-    const request = new wasm.TransactionRequestBuilder()
-      .withOwnOutputNotes(ownOutputs)
-      .build();
-
-    const { txId, result } = await this.#submitOrSubmitWithProver(
-      senderId,
-      request,
-      opts.prover
-    );
-
-    if (opts.waitForConfirmation) {
-      await this.waitFor(txId.toHex(), { timeout: opts.timeout });
-    }
-
-    return { txId, note, result };
-  }
-
   async mint(opts) {
     this.#client.assertNotTerminated();
     const wasm = await this.#getWasm();
@@ -751,24 +640,6 @@ class TransactionsResource {
     return { txId, result };
   }
 
-  async bridge(opts) {
-    this.#client.assertNotTerminated();
-    const wasm = await this.#getWasm();
-    const { accountId, request } = await this.#buildB2AggRequest(opts, wasm);
-
-    const { txId, result } = await this.#submitOrSubmitWithProver(
-      accountId,
-      request,
-      opts.prover
-    );
-
-    if (opts.waitForConfirmation) {
-      await this.waitFor(txId.toHex(), { timeout: opts.timeout });
-    }
-
-    return { txId, result };
-  }
-
   async consume(opts) {
     this.#client.assertNotTerminated();
     const wasm = await this.#getWasm();
@@ -915,6 +786,14 @@ class TransactionsResource {
     return { txId, result };
   }
 
+  /**
+   * Dry-run a transaction to obtain the TransactionSummary pending
+   * authorization (e.g. a multisig below its signing threshold). Rejects
+   * with an error carrying `code: "TRANSACTION_ALREADY_AUTHORIZED"` (on
+   * Node.js the code prefixes the message instead) when the transaction
+   * executes successfully, since a fully authorized transaction produces
+   * no summary. See {@link PreviewOptions}.
+   */
   async preview(opts) {
     this.#client.assertNotTerminated();
     const wasm = await this.#getWasm();
@@ -931,10 +810,6 @@ class TransactionsResource {
         ({ accountId, request } = await this.#buildMintRequest(opts, wasm));
         break;
       }
-      case "bridge": {
-        ({ accountId, request } = await this.#buildB2AggRequest(opts, wasm));
-        break;
-      }
       case "consume": {
         ({ accountId, request } = await this.#buildConsumeRequest(opts, wasm));
         break;
@@ -979,163 +854,6 @@ class TransactionsResource {
   async execute(opts) {
     this.#client.assertNotTerminated();
     const wasm = await this.#getWasm();
-    const { accountId, request } = this.#buildExecuteRequest(opts, wasm);
-
-    const { txId, result } = await this.#submitOrSubmitWithProver(
-      accountId,
-      request,
-      opts.prover
-    );
-
-    if (opts.waitForConfirmation) {
-      await this.waitFor(txId.toHex(), { timeout: opts.timeout });
-    }
-
-    return { txId, result };
-  }
-
-  /**
-   * Submit a heterogeneous batch of operations against a single account. All
-   * operations are executed, proven individually and as a batch, and submitted
-   * atomically — either every tx in the batch lands or none does.
-   *
-   * @param {BatchOptions} opts - Batch options including the account, operations array, and confirmation settings.
-   * @returns {Promise<BatchSubmitResult>} The block number the batch was accepted into.
-   */
-  async batch(opts) {
-    this.#client.assertNotTerminated();
-    const wasm = await this.#getWasm();
-
-    if (!opts || !opts.account) {
-      throw new Error("batch: `account` is required");
-    }
-    if (!Array.isArray(opts.operations) || opts.operations.length === 0) {
-      throw new Error("batch: `operations` must be a non-empty array");
-    }
-
-    // Build each TransactionRequest. Per-op builders all use the batch-level
-    // `account` — V1 only supports same-account batches, mirroring the Rust
-    // constraint. We forward `opts.account` into each per-op options object so
-    // the existing builders' `resolveAccountRef` produces fresh AccountIds
-    // when needed.
-    const requests = [];
-    for (let i = 0; i < opts.operations.length; i++) {
-      const op = opts.operations[i];
-      let built;
-      switch (op?.kind) {
-        case "send":
-          built = await this.#buildSendRequest(
-            { ...op, account: opts.account },
-            wasm
-          );
-          break;
-        case "mint":
-          built = await this.#buildMintRequest(
-            { ...op, account: opts.account },
-            wasm
-          );
-          break;
-        case "consume":
-          built = await this.#buildConsumeRequest(
-            { ...op, account: opts.account },
-            wasm
-          );
-          break;
-        case "swap":
-          built = await this.#buildSwapRequest(
-            { ...op, account: opts.account },
-            wasm
-          );
-          break;
-        case "execute":
-          built = this.#buildExecuteRequest(
-            { ...op, account: opts.account },
-            wasm
-          );
-          break;
-        case "custom":
-          if (!op.request) {
-            throw new Error(
-              `batch: operation[${i}] of kind "custom" is missing \`request\``
-            );
-          }
-          built = { request: op.request };
-          break;
-        default:
-          throw new Error(
-            `batch: operation[${i}] has unknown kind "${op?.kind}"`
-          );
-      }
-      requests.push(built.request);
-    }
-
-    return this.submitBatch(opts.account, requests, opts);
-  }
-
-  /**
-   * Submit pre-built TransactionRequests as an atomic batch. Lower-level
-   * counterpart of `batch()` — for callers that already have built requests in
-   * hand. Equivalent to `submit()` but plural.
-   *
-   * @param {AccountRef} account - The account executing the batch.
-   * @param {TransactionRequest[]} requests - Pre-built transaction requests.
-   * @param {object} [options] - Optional settings (waitForConfirmation, timeout).
-   *   The batch is proved with the client's configured prover; the V1 batch API
-   *   has no per-call prover override.
-   * @returns {Promise<BatchSubmitResult>} The block number the batch was accepted into.
-   */
-  async submitBatch(account, requests, options) {
-    this.#client.assertNotTerminated();
-    const wasm = await this.#getWasm();
-
-    if (!Array.isArray(requests) || requests.length === 0) {
-      throw new Error("submitBatch: `requests` must be a non-empty array");
-    }
-
-    const accountId = resolveAccountRef(account, wasm);
-    const blockNumber = await this.#inner.submitNewTransactionBatch(
-      accountId,
-      requests.map((r) => r.serialize())
-    );
-
-    if (options?.waitForConfirmation) {
-      await this.#waitForBlock(blockNumber, options);
-    }
-
-    return { blockNumber };
-  }
-
-  /**
-   * Polls until the local sync height reaches `blockNumber` or the timeout
-   * expires. The Rust V1 batch API returns only a block number — there are no
-   * per-tx ids to poll on, so we wait on the chain height instead.
-   *
-   * @param {number} blockNumber - The block height to wait for.
-   * @param {object} [opts] - Polling options (timeout, interval).
-   */
-  async #waitForBlock(blockNumber, opts) {
-    const timeout = opts?.timeout ?? 60_000;
-    const interval = opts?.interval ?? 5_000;
-    const start = Date.now();
-
-    while (true) {
-      if (timeout > 0 && Date.now() - start >= timeout) {
-        throw new Error(
-          `Batch confirmation timed out after ${timeout}ms (waiting for block ${blockNumber})`
-        );
-      }
-      try {
-        await this.#inner.syncStateWithTimeout(0);
-      } catch {
-        // sync may fail transiently; continue polling
-      }
-      const height = await this.#inner.getSyncHeight();
-      if (height >= blockNumber) return;
-      await new Promise((resolve) => setTimeout(resolve, interval));
-    }
-  }
-
-  #buildExecuteRequest(opts, wasm) {
     const accountId = resolveAccountRef(opts.account, wasm);
 
     let builder = new wasm.TransactionRequestBuilder().withCustomScript(
@@ -1163,7 +881,18 @@ class TransactionsResource {
       );
     }
 
-    return { accountId, request: builder.build() };
+    const request = builder.build();
+    const { txId, result } = await this.#submitOrSubmitWithProver(
+      accountId,
+      request,
+      opts.prover
+    );
+
+    if (opts.waitForConfirmation) {
+      await this.waitFor(txId.toHex(), { timeout: opts.timeout });
+    }
+
+    return { txId, result };
   }
 
   async executeProgram(opts) {
@@ -1208,65 +937,6 @@ class TransactionsResource {
     );
   }
 
-  /**
-   * Execute a transaction request locally — nothing is proven, submitted, or
-   * persisted. Returns a {@link TransactionExecution} handle; advance the
-   * lifecycle by chaining `.prove()` → `.submit()` → `.apply()`, benchmarking
-   * or error-handling each stage independently. Use {@link submit} to run every
-   * stage in one call.
-   *
-   * ```ts
-   * const executed  = await client.transactions.executeRequest(account, request);
-   * const proven    = await executed.prove({ prover });
-   * const submitted = await proven.submit();
-   * await submitted.apply();
-   * ```
-   *
-   * The stages are NOT atomic as a group: awaiting other mutating calls on the
-   * same account between them can interleave state. Drive the chain as an
-   * uninterrupted sequence per account.
-   *
-   * @param {AccountRef} account - The account executing the transaction.
-   * @param {TransactionRequest} request - The pre-built transaction request.
-   * @returns {Promise<TransactionExecution>} A handle to the executed
-   *   transaction, ready to prove.
-   */
-  async executeRequest(account, request) {
-    this.#client.assertNotTerminated();
-    const wasm = await this.#getWasm();
-    const accountId = resolveAccountRef(account, wasm);
-    const result = await this.#inner.executeTransaction(accountId, request);
-    return new TransactionExecution(this.#inner, this.#client, this, result);
-  }
-
-  /**
-   * Submit a proof produced somewhere that shares nothing with this client —
-   * e.g. a detached prover that never saw the local store. Returns a
-   * {@link TransactionSubmission} handle; call `.apply()` on it to persist
-   * locally. For the in-process flow prefer
-   * `executeRequest(...)` → `.prove()` → `.submit()`, which threads the proof
-   * and result for you.
-   *
-   * @param {ProvenTransaction} proof - A proof for `result`, proven elsewhere.
-   * @param {TransactionResult} result - The matching execution result.
-   * @returns {Promise<TransactionSubmission>} A handle to the submitted
-   *   transaction, ready to apply.
-   */
-  async submitProven(proof, result) {
-    this.#client.assertNotTerminated();
-    const blockNumber = await this.#inner.submitProvenTransaction(
-      proof,
-      result
-    );
-    return new TransactionSubmission(
-      this.#inner,
-      this.#client,
-      this,
-      result,
-      blockNumber
-    );
-  }
-
   async list(query) {
     this.#client.assertNotTerminated();
     const wasm = await this.#getWasm();
@@ -1395,24 +1065,6 @@ class TransactionsResource {
     return { accountId, request };
   }
 
-  async #buildB2AggRequest(opts, wasm) {
-    const accountId = resolveAccountRef(opts.account, wasm);
-    const bridgeAccountId = resolveAccountRef(opts.bridgeAccount, wasm);
-    const faucetId = resolveAccountRef(opts.token, wasm);
-    const amount = BigInt(opts.amount);
-    const destinationAddress = wasm.EthAddress.fromHex(opts.destinationAddress);
-
-    const request = await this.#inner.newB2AggTransactionRequest(
-      accountId,
-      bridgeAccountId,
-      faucetId,
-      amount,
-      opts.destinationNetwork,
-      destinationAddress
-    );
-    return { accountId, request };
-  }
-
   async #buildConsumeRequest(opts, wasm) {
     const accountId = resolveAccountRef(opts.account, wasm);
     const noteInputs = Array.isArray(opts.notes) ? opts.notes : [opts.notes];
@@ -1557,12 +1209,10 @@ class TransactionsResource {
 
   async #submitOrSubmitWithProver(accountId, request, perCallProver) {
     const result = await this.#inner.executeTransaction(accountId, request);
-    const proven = await proveResult(
-      this.#inner,
-      this.#client.defaultProver,
-      result,
-      { prover: perCallProver }
-    );
+    const prover = perCallProver ?? this.#client.defaultProver;
+    const proven = prover
+      ? await this.#inner.proveTransaction(result, prover)
+      : await this.#inner.proveTransaction(result);
     const txId = result.id();
     const height = await this.#inner.submitProvenTransaction(proven, result);
     await this.#inner.applyTransaction(result, height);
@@ -1570,172 +1220,6 @@ class TransactionsResource {
   }
 }
 
-/**
- * A locally-executed transaction — nothing proven, submitted, or persisted yet.
- * First stage of the manual transaction lifecycle, returned by
- * {@link TransactionsResource.executeRequest}. Advance it with {@link prove}.
- */
-class TransactionExecution {
-  #inner;
-  #client;
-  #resource;
-  #result;
-
-  constructor(inner, client, resource, result) {
-    this.#inner = inner;
-    this.#client = client;
-    this.#resource = resource;
-    this.#result = result;
-  }
-
-  /** The raw execution artifact (account delta, output notes, …). */
-  get result() {
-    return this.#result;
-  }
-
-  /** The executed transaction's id. */
-  get id() {
-    return this.#result.id();
-  }
-
-  /**
-   * Prove this execution. Uses the per-call prover when provided, falling back
-   * to the client's default prover (or the built-in local prover). Pure
-   * computation — touches neither the network nor the local store.
-   *
-   * A `TransactionProver` is consumed by the call: build (or clone) a fresh
-   * prover per `prove()`. Reusing an already-passed prover silently falls back
-   * to the built-in local prover.
-   *
-   * @param {ProveOptions} [opts] - Optional per-call prover override.
-   * @returns {Promise<TransactionProof>} A handle to the proven transaction,
-   *   ready to submit.
-   */
-  async prove(opts) {
-    this.#client.assertNotTerminated();
-    const proven = await proveResult(
-      this.#inner,
-      this.#client.defaultProver,
-      this.#result,
-      opts
-    );
-    return new TransactionProof(
-      this.#inner,
-      this.#client,
-      this.#resource,
-      proven,
-      this.#result
-    );
-  }
-}
-
-/**
- * A proven transaction, ready for the network. Second stage of the manual
- * transaction lifecycle, returned by {@link TransactionExecution.prove}.
- * Advance it with {@link submit}.
- */
-class TransactionProof {
-  #inner;
-  #client;
-  #resource;
-  #proof;
-  #result;
-
-  constructor(inner, client, resource, proof, result) {
-    this.#inner = inner;
-    this.#client = client;
-    this.#resource = resource;
-    this.#proof = proof;
-    this.#result = result;
-  }
-
-  /** The raw proof — e.g. to serialize and submit from a different client. */
-  get proof() {
-    return this.#proof;
-  }
-
-  /** The execution result this proof was produced from. */
-  get result() {
-    return this.#result;
-  }
-
-  /**
-   * Submit the proof to the network. Does NOT persist locally — call
-   * {@link TransactionSubmission.apply} on the returned handle; skipping it
-   * leaves the local store out of sync until the next full sync.
-   *
-   * @returns {Promise<TransactionSubmission>} A handle to the submitted
-   *   transaction, ready to apply.
-   */
-  async submit() {
-    this.#client.assertNotTerminated();
-    const blockNumber = await this.#inner.submitProvenTransaction(
-      this.#proof,
-      this.#result
-    );
-    return new TransactionSubmission(
-      this.#inner,
-      this.#client,
-      this.#resource,
-      this.#result,
-      blockNumber
-    );
-  }
-}
-
-/**
- * A submitted transaction. Final stage of the manual transaction lifecycle,
- * returned by {@link TransactionProof.submit}. Persist it locally with
- * {@link apply}, or block until it commits with {@link waitForConfirmation}.
- */
-class TransactionSubmission {
-  #inner;
-  #client;
-  #resource;
-  #result;
-  #blockNumber;
-
-  constructor(inner, client, resource, result, blockNumber) {
-    this.#inner = inner;
-    this.#client = client;
-    this.#resource = resource;
-    this.#result = result;
-    this.#blockNumber = blockNumber;
-  }
-
-  /** The block height the transaction was submitted at. */
-  get blockNumber() {
-    return this.#blockNumber;
-  }
-
-  /** The execution result that was submitted. */
-  get result() {
-    return this.#result;
-  }
-
-  /**
-   * Persist the transaction into the local store, firing registered
-   * transaction observers (e.g. PSWAP lineage tracking). Until this runs the
-   * local store is unaware of the transaction.
-   *
-   * @returns {Promise<TransactionStoreUpdate>} The pre-apply store update.
-   */
-  async apply() {
-    this.#client.assertNotTerminated();
-    return await this.#inner.applyTransaction(this.#result, this.#blockNumber);
-  }
-
-  /**
-   * Poll local sync height until the transaction commits on-chain. Convenience
-   * wrapper over {@link TransactionsResource.waitFor}.
-   *
-   * @param {WaitOptions} [opts] - Polling options (timeout, interval, onProgress).
-   */
-  async waitForConfirmation(opts) {
-    return await this.#resource.waitFor(this.#result.id().toHex(), opts);
-  }
-}
-
 class NotesResource {
   #inner;
   #getWasm;
@@ -1932,22 +1416,25 @@ class CompilerResource {
   /**
    * Compiles MASM code + slots into an AccountComponent ready for accounts.create().
    *
-   * @param {{ code: string, slots: StorageSlot[], supportAllTypes?: boolean }} opts
+   * @param {{ code: string, namespace?: string, slots: StorageSlot[], supportAllTypes?: boolean }} opts
    * @returns {Promise<AccountComponent>}
    */
-  async component({ code, slots = [], supportAllTypes = true }) {
+  async component({ code, namespace, slots = [], supportAllTypes = true }) {
     this.#client?.assertNotTerminated();
     const wasm = await this.#getWasm();
     const builder = await this.#inner.createCodeBuilder();
-    const compiled = builder.compileAccountComponentCode(code);
+    const compiled = namespace
+      ? builder.compileAccountComponentCodeWithPath(namespace, code)
+      : builder.compileAccountComponentCode(code);
     const component = wasm.AccountComponent.compile(compiled, slots);
     return supportAllTypes ? component.withSupportsAllTypes() : component;
   }
 
   /**
-   * Compiles a transaction script, optionally linking named libraries inline.
+   * Compiles a transaction script, optionally linking named libraries inline or linking the exact
+   * code installed by an AccountComponent.
    *
-   * @param {{ code: string, libraries?: Array<{ namespace: string, code: string, linking?: "dynamic" | "static" }> }} opts
+   * @param {{ code: string, libraries?: Array<Library | { namespace: string, code: string, linking?: "dynamic" | "static" } | { component: AccountComponent, linking?: "dynamic" | "static" }> }} opts
    * @returns {Promise<TransactionScript>}
    */
   async txScript({ code, libraries = [] }) {
@@ -1960,9 +1447,10 @@ class CompilerResource {
   }
 
   /**
-   * Compiles a note script, optionally linking named libraries inline.
+   * Compiles a note script, optionally linking named libraries inline or linking the exact code
+   * installed by an AccountComponent.
    *
-   * @param {{ code: string, libraries?: Array<{ namespace: string, code: string, linking?: "dynamic" | "static" }> }} opts
+   * @param {{ code: string, libraries?: Array<Library | { namespace: string, code: string, linking?: "dynamic" | "static" } | { component: AccountComponent, linking?: "dynamic" | "static" }> }} opts
    * @returns {Promise<NoteScript>}
    */
   async noteScript({ code, libraries = [] }) {
@@ -1974,13 +1462,20 @@ class CompilerResource {
   }
 }
 
-// Builds and links each library entry against `builder`. Inline
-// `{ namespace, code, linking? }` entries are built via `buildLibrary` and
-// linked according to `linking` (defaulting to dynamic, matching tutorial
-// behavior). Pre-built library objects are linked dynamically.
+// Builds and links each library entry against `builder`. Account component entries use the exact
+// compiled code installed by the component. Inline `{ namespace, code, linking? }` entries are
+// built via `buildLibrary`. Linking defaults to dynamic, matching tutorial behavior. Pre-built
+// library objects are also linked dynamically.
 function linkLibraries(builder, libraries) {
   for (const lib of libraries) {
-    if (lib && typeof lib.namespace === "string") {
+    if (lib && lib.component) {
+      const componentCode = lib.component.componentCode();
+      if (lib.linking === "static") {
+        builder.linkStaticAccountComponentCode(componentCode);
+      } else {
+        builder.linkDynamicAccountComponentCode(componentCode);
+      }
+    } else if (lib && typeof lib.namespace === "string") {
       const built = builder.buildLibrary(lib.namespace, lib.code);
       if (lib.linking === "static") {
         builder.linkStaticLibrary(built);
@@ -2048,137 +1543,6 @@ class KeystoreResource {
   }
 }
 
-/**
- * Coerce an `orderId` (string | bigint) to a decimal string for the WASM
- * `u64` parse on the other side.
- *
- * A PSWAP `orderId` is `u64`-shaped and routinely exceeds
- * `Number.MAX_SAFE_INTEGER` (`2^53 - 1`). JS `number` cannot represent the
- * full u64 range without silent precision loss, so it is not accepted — pass
- * `orderId` as a `bigint` or `string` instead.
- *
- * @param {string | bigint} orderId
- * @returns {string}
- */
-function normalizeOrderId(orderId) {
-  if (typeof orderId === "bigint") return orderId.toString();
-  if (typeof orderId === "string") return orderId;
-  throw new TypeError(
-    `PSWAP orderId must be a string or bigint; got ${typeof orderId}`
-  );
-}
-
-/**
- * PswapResource surfaces partial-swap (PSWAP) lineage tracking and creator-side
- * cancellation keyed by a lineage's stable order id.
- *
- * A PSWAP note can be filled by many consumers; each fill advances the lineage
- * to a new remainder note. The client persists that chain locally as it syncs,
- * and the reader methods here expose it. {@link PswapResource#cancelByOrder}
- * reclaims the unfilled offered asset on the current tip of an active lineage,
- * resolving the creator account from the tracked record so the caller only
- * needs the order id.
- */
-class PswapResource {
-  #inner;
-  #getWasm;
-  #client;
-
-  constructor(inner, getWasm, client) {
-    this.#inner = inner;
-    this.#getWasm = getWasm;
-    this.#client = client;
-  }
-
-  /**
-   * Returns every PSWAP lineage tracked by this client.
-   *
-   * @returns {Promise<PswapLineageRecord[]>} All tracked lineages.
-   */
-  async lineages() {
-    this.#client.assertNotTerminated();
-    return await this.#inner.getPswapLineages();
-  }
-
-  /**
-   * Returns lineages created by a specific local account.
-   *
-   * @param {AccountRef} account - Creator account (hex, bech32, Account, or AccountId).
-   * @returns {Promise<PswapLineageRecord[]>} Lineages created by the account.
-   */
-  async lineagesFor(account) {
-    this.#client.assertNotTerminated();
-    const wasm = await this.#getWasm();
-    const accountId = resolveAccountRef(account, wasm);
-    return await this.#inner.getPswapLineagesFor(accountId);
-  }
-
-  /**
-   * Returns the lineage for one order, or null if not tracked.
-   *
-   * @param {string | bigint} orderId - Stable order id. Pass as a `string` or
-   *   `bigint` for the full `u64` range; `number` is rejected because it cannot
-   *   represent ids above `Number.MAX_SAFE_INTEGER` without precision loss.
-   * @returns {Promise<PswapLineageRecord | null>} The lineage, or null.
-   */
-  async lineage(orderId) {
-    this.#client.assertNotTerminated();
-    const result = await this.#inner.getPswapLineage(normalizeOrderId(orderId));
-    return result ?? null;
-  }
-
-  /**
-   * Builds and submits a transaction reclaiming the unfilled offered asset on
-   * the current tip of an Active lineage. The creator account is resolved from
-   * the tracked lineage, so only the order id is required. Runs through the
-   * same execute/prove/submit path as the other transaction helpers.
-   *
-   * Throws before submitting any transaction when:
-   *   - no lineage is tracked for `orderId`, OR
-   *   - the lineage is in a terminal state (`FullyFilled` or `Reclaimed`,
-   *     guarded by the `buildPswapCancelByOrder` binding).
-   *
-   * Concurrency: the lineage-read, build, and submit steps below are not
-   * atomic against external fills. If another consumer — or this client's own
-   * in-flight tx — advances the lineage tip between the build and submit, the
-   * cancel will target an already-consumed note and the kernel will reject
-   * it with a "note already nullified" error. Treat that as a signal to
-   * re-read the lineage and retry against the new tip.
-   *
-   * @param {PswapCancelByOrderOptions} opts - Order id and optional tx options.
-   * @returns {Promise<TransactionSubmitResult>} The submitted transaction.
-   */
-  async cancelByOrder(opts) {
-    this.#client.assertNotTerminated();
-    const orderId = normalizeOrderId(opts.orderId);
-
-    // Fetch the lineage for the creator account (the cancel's submitter).
-    // The terminal-state guard is authoritative in the `buildPswapCancelByOrder`
-    // binding below, so it is not repeated here.
-    const lineage = await this.#inner.getPswapLineage(orderId);
-    if (!lineage) {
-      throw new Error(`No PSWAP lineage tracked for order ${orderId}`);
-    }
-    const accountId = lineage.creatorAccountId();
-
-    const request = await this.#inner.buildPswapCancelByOrder(orderId);
-
-    const { txId, result } = await this.#client.transactions.submit(
-      accountId,
-      request,
-      { prover: opts.prover }
-    );
-
-    if (opts.waitForConfirmation) {
-      await this.#client.transactions.waitFor(txId.toHex(), {
-        timeout: opts.timeout,
-      });
-    }
-
-    return { txId, result };
-  }
-}
-
 /**
  * MidenClient wraps the existing proxy-wrapped WebClient with a resource-based API.
  *
@@ -2209,7 +1573,6 @@ class MidenClient {
     this.settings = new SettingsResource(inner, getWasm, this);
     this.compile = new CompilerResource(inner, getWasm, this);
     this.keystore = new KeystoreResource(inner, this);
-    this.pswap = new PswapResource(inner, getWasm, this);
   }
 
   /**
@@ -2331,7 +1694,7 @@ class MidenClient {
         options.keystore.getKey,
         options.keystore.insertKey,
         options.keystore.sign,
-        options?.debugMode,
+        undefined,
         useWorker
       );
     } else {
@@ -2340,7 +1703,7 @@ class MidenClient {
         noteTransportUrl,
         seed,
         options?.storeName,
-        options?.debugMode,
+        undefined,
         useWorker
       );
     }
@@ -2783,6 +2146,9 @@ function buildSwapTag(opts) {
 
 function buildNoteAssets(assets, wasm) {
   const assetArray = Array.isArray(assets) ? assets : [assets];
+  if (assetArray.length === 0) {
+    throw new TypeError("P2ID and P2IDE notes require at least one asset");
+  }
   const fungibleAssets = assetArray.map((asset) => {
     const faucetId = resolveAccountRef(asset.token, wasm);
     return new wasm.FungibleAsset(faucetId, BigInt(asset.amount));
@@ -3011,17 +2377,6 @@ class StorageResult {
     return this.#word.toFelts();
   }
 
-  /**
-   * Returns all four elements of the stored Word as a BigUint64Array.
-   * Pass-through to Word.toU64s() — ensures code that expects a Word-like
-   * object (e.g., `result.toU64s()[0]`) works on StorageResult.
-   * @returns {BigUint64Array}
-   */
-  toU64s() {
-    if (!this.#word) return new BigUint64Array();
-    return this.#word.toU64s();
-  }
-
   /**
    * The first Felt of the stored Word.
    * Returns the WASM Felt object — use .asInt() to get its BigInt value.
@@ -3170,11 +2525,9 @@ const Linking = Object.freeze({
 // (e.g. newSwapTransactionRequest, newPswapCreateTransactionRequest) are
 // `async fn` in Rust because they take the client's RNG via an async lock.
 const SYNC_METHODS = new Set([
-  "buildPswapCancelByOrder",
   "buildSwapTag",
   "createCodeBuilder",
   "lastAuthError",
-  "newB2AggTransactionRequest",
   "newConsumeTransactionRequest",
   "newMintTransactionRequest",
   "newPswapCancelTransactionRequest",
@@ -3185,7 +2538,6 @@ const SYNC_METHODS = new Set([
   "proveBlock",
   "serializeMockChain",
   "serializeMockNoteTransportNode",
-  "setDebugMode",
   "storeIdentifier",
   "usesMockChain",
 ]);