@miden-sdk/miden-sdk 0.15.3 → 0.15.5

package/README.md

@@ -423,6 +423,26 @@ console.log(faucet.id().toString());
 console.log(faucet.isFaucet()); // true
 ```
 
+### Read Faucet Metadata
+
+`BasicFungibleFaucetComponent` extracts the on-chain token metadata from a faucet account. The same
+component backs both basic and network-style faucets, so it works for either:
+
+```typescript
+import { BasicFungibleFaucetComponent } from "@miden-sdk/miden-sdk";
+
+const faucet = BasicFungibleFaucetComponent.fromAccount(account);
+
+faucet.symbol().toString();       // "DAG"
+faucet.tokenName();               // "DAG Token"
+faucet.decimals();                // 8
+faucet.maxSupply().toString();    // "10000000"
+faucet.tokenSupply().toString();  // amount minted so far, e.g. "0"
+faucet.description();             // string | undefined
+faucet.logoUri();                 // string | undefined
+faucet.externalLink();            // string | undefined
+```
+
 ### Send Tokens
 
 ```typescript
@@ -452,6 +472,38 @@ const balance = await client.accounts.getBalance(wallet, dagToken);
 console.log(`Balance: ${balance}`);
 ```
 
+### Batch Operations
+
+Submit multiple operations against a single account as one atomic batch — every transaction in the batch lands together or none does. Each operation builds its own `TransactionRequest` internally; you don't have to assemble or serialize them yourself.
+
+```typescript
+const { blockNumber } = await client.transactions.batch({
+  account: wallet,
+  operations: [
+    { kind: "send", to: alice, token: dagToken, amount: 50n, type: "public" },
+    { kind: "send", to: bob,   token: dagToken, amount: 30n, type: "public" },
+    { kind: "consume", notes: pendingNotes },
+  ],
+  waitForConfirmation: true,
+});
+console.log(`Batch landed in block ${blockNumber}`);
+```
+
+Operations are discriminated by `kind`: `"send"`, `"mint"`, `"consume"`, `"swap"`, `"execute"`, and `"custom"` (escape hatch for a pre-built `TransactionRequest`). The shape of each operation mirrors the singular options object (`SendOptions`, `MintOptions`, …) minus the `account` field, which is set once at the batch level.
+
+V1 supports only same-account batches — every operation must execute against the `account` passed at the top level. Mixing accounts in one batch is not supported.
+
+For callers that already hold pre-built `TransactionRequest`s, `submitBatch` skips the high-level builders:
+
+```typescript
+const { blockNumber } = await client.transactions.submitBatch(wallet, [
+  request1,
+  request2,
+]);
+```
+
+The V1 batch primitive returns only the block number — there are no per-tx ids in the result. `waitForConfirmation` polls local sync height until it reaches `blockNumber` (rather than per-tx polling like singular `send` / `consume`).
+
 ### Partial-Swap (PSWAP) Orders
 
 A partial-swap note offers one asset for another and can be filled by multiple
@@ -491,6 +543,39 @@ await client.pswap.cancelByOrder({ orderId, waitForConfirmation: true });
 `client.pswap.lineage(orderId)` returns one order's lineage, or `null` if it is
 not tracked.
 
+### Bridge out (AggLayer)
+
+`client.transactions.bridge(...)` bridges a fungible asset out to another network via the AggLayer. It emits a single public B2AGG note that the bridge account consumes, burning the asset so it can be claimed at the destination Ethereum address on the AggLayer-assigned network.
+
+```typescript
+await client.transactions.bridge({
+  account: wallet, // sender (executes the transaction)
+  bridgeAccount: bridge, // consumes the note and burns the asset
+  token: dagToken, // faucet of the asset being bridged
+  amount: 100n,
+  destinationNetwork: 1, // AggLayer-assigned network id
+  destinationAddress: "0x000000000000000000000000000000000000dEaD"
+});
+```
+
+The 20-byte destination is also available as an `EthAddress` (`EthAddress.fromHex("0x…")`) for the lower-level builders `Note.createB2AggNote(...)` and `client.newB2AggTransactionRequest(...)`.
+
+### Network Notes
+
+A network note is a Public note carrying a `NetworkAccountTarget` attachment; a public network account auto-consumes it once the note lands on-chain — no manual `consume` call needed on the target side.
+
+```typescript
+const { txId, note } = await client.transactions.createNetworkNote({
+  account: senderId,
+  target: networkAccountId,
+  script: myNoteScript, // or: recipient: myRecipient
+  waitForConfirmation: true,
+});
+console.log(note.isNetworkNote()); // true
+```
+
+Provide exactly one of `script` or `recipient`. Notes are always Public — the attachment, not the tag, is what a network account matches on. The standalone `buildNetworkNote(opts)` builds the same note without submitting.
+
 ### Cleanup
 
 When you're finished using a MidenClient instance, call `terminate()` to release its Web Worker: