@miden-sdk/miden-sdk 0.15.3 → 0.15.5

package/dist/mt/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, 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, 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, initThreadPool, mtProbeAsync, mtProbeSync, parallelSumBench, rayonThreadCount, sequentialSumBench, setupLogging, wbg_rayon_PoolBuilder, wbg_rayon_start_worker } from './Cargo-D2qNRrNR.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, 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, initThreadPool, mtProbeAsync, mtProbeSync, parallelSumBench, rayonThreadCount, sequentialSumBench, setupLogging, wbg_rayon_PoolBuilder, wbg_rayon_start_worker } from './Cargo-C001gt8g.js';
 
 const WorkerAction = Object.freeze({
   INIT: "init",
@@ -622,6 +622,97 @@ 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();
@@ -640,6 +731,24 @@ 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();
@@ -802,6 +911,10 @@ 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;
@@ -846,6 +959,163 @@ 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(
@@ -873,18 +1143,7 @@ class TransactionsResource {
       );
     }
 
-    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 };
+    return { accountId, request: builder.build() };
   }
 
   async executeProgram(opts) {
@@ -1057,6 +1316,24 @@ 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];
@@ -2487,6 +2764,17 @@ 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.
@@ -2639,6 +2927,7 @@ const SYNC_METHODS = new Set([
   "buildSwapTag",
   "createCodeBuilder",
   "lastAuthError",
+  "newB2AggTransactionRequest",
   "newConsumeTransactionRequest",
   "newMintTransactionRequest",
   "newPswapCancelTransactionRequest",