@miden-sdk/miden-sdk 0.14.0-alpha.2 → 0.14.1

package/dist/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, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkId, NetworkType, Note, NoteAndArgs, NoteAndArgsArray, NoteAssets, NoteAttachment, NoteAttachmentKind, NoteAttachmentScheme, NoteConsumability, NoteConsumptionStatus, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteExportFormat, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteIdAndArgsArray, NoteInclusionProof, NoteLocation, NoteMetadata, NoteRecipient, NoteRecipientArray, NoteScript, NoteStorage, NoteSyncInfo, NoteTag, NoteType, OutputNote, OutputNoteArray, OutputNoteRecord, OutputNoteState, OutputNotes, OutputNotesArray, Package, PartialNote, ProcedureThreshold, Program, ProvenTransaction, PublicKey, RpcClient, Rpo256, SerializedInputNoteData, SerializedOutputNoteData, SerializedTransactionData, Signature, SigningInputs, SigningInputsType, SlotAndKeys, SparseMerklePath, StorageMap, StorageSlot, StorageSlotArray, SyncSummary, TestUtils, TokenSymbol, TransactionArgs, TransactionFilter, TransactionId, TransactionProver, TransactionRecord, TransactionRequest, TransactionRequestBuilder, TransactionResult, TransactionScript, TransactionScriptInputPair, TransactionScriptInputPairArray, TransactionStatus, TransactionStoreUpdate, TransactionSummary, WebClient, Word, createAuthFalcon512RpoMultisig, initSync, setupLogging } from './Cargo-DlfmzoDc.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, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkId, NetworkType, Note, NoteAndArgs, NoteAndArgsArray, NoteArray, NoteAssets, NoteAttachment, NoteAttachmentKind, 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, 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, setupLogging } from './Cargo-BZOulF0S.js';
 
 const WorkerAction = Object.freeze({
   INIT: "init",
@@ -364,22 +364,89 @@ function resolveAuthScheme(scheme, wasm) {
 }
 
 /**
- * Resolves a simplified AccountType string to a boolean `mutable` flag
+ * Resolves an AccountType value to a boolean `mutable` flag
  * for the underlying WASM `newWallet()` / `importPublicAccountFromSeed()` calls.
  *
- * @param {string | undefined} accountType - "MutableWallet", "ImmutableWallet", or undefined.
- *   Defaults to mutable wallet when undefined.
+ * Accepts the numeric WASM enum values (2 = immutable, 3 = mutable) or the
+ * legacy string aliases ("MutableWallet", "ImmutableWallet"). Defaults to
+ * mutable when undefined.
+ *
+ * @param {number | string | undefined} accountType
  * @returns {boolean} Whether the account code is mutable.
  */
 function resolveAccountMutability(accountType) {
-  if (accountType == null || accountType === "MutableWallet") {
+  if (
+    accountType == null ||
+    accountType === "MutableWallet" ||
+    accountType === 3
+  ) {
     return true;
   }
-  if (accountType === "ImmutableWallet") {
+  if (accountType === "ImmutableWallet" || accountType === 2) {
     return false;
   }
   throw new Error(
-    `Unknown wallet account type: "${accountType}". Expected "MutableWallet" or "ImmutableWallet".`
+    `Unknown wallet account type: "${accountType}". Expected AccountType.MutableWallet (3) or AccountType.ImmutableWallet (2).`
+  );
+}
+
+/**
+ * Resolves a NoteInput (string | NoteId | InputNoteRecord | Note) to a hex string.
+ *
+ * - Strings are passed through unchanged.
+ * - NoteId WASM objects are converted via `.toString()`.
+ * - InputNoteRecord and Note objects (with an `.id()` method) are resolved via `.id().toString()`.
+ *
+ * @param {string | object} input - The note reference to resolve.
+ * @returns {string} The hex note ID string.
+ */
+function resolveNoteIdHex(input) {
+  if (input == null) {
+    throw new Error("Note ID cannot be null or undefined");
+  }
+  if (typeof input === "string") {
+    return input;
+  }
+  // NoteId WASM object — has toString() but not id() (unlike InputNoteRecord/Note).
+  // Check for constructor.fromHex to distinguish from plain objects (which also inherit toString).
+  if (
+    typeof input.toString === "function" &&
+    typeof input.id !== "function" &&
+    input.constructor?.fromHex !== undefined
+  ) {
+    return input.toString();
+  }
+  // InputNoteRecord, Note, or other object with id() returning NoteId
+  if (typeof input.id === "function") {
+    return input.id().toString();
+  }
+  throw new TypeError(
+    `Cannot resolve note ID: expected string, NoteId, InputNoteRecord, or Note, got ${typeof input}`
+  );
+}
+
+/**
+ * Resolves a TransactionId reference (string | TransactionId) to a hex string.
+ *
+ * - Strings are passed through unchanged.
+ * - TransactionId WASM objects are converted via `.toHex()`.
+ *
+ * @param {string | object} input - The transaction ID reference to resolve.
+ * @returns {string} The hex transaction ID string.
+ */
+function resolveTransactionIdHex(input) {
+  if (input == null) {
+    throw new Error("Transaction ID cannot be null or undefined");
+  }
+  if (typeof input === "string") {
+    return input;
+  }
+  // TransactionId WASM object — toHex() returns hex
+  if (typeof input.toHex === "function") {
+    return input.toHex();
+  }
+  throw new TypeError(
+    `Cannot resolve transaction ID: expected string or TransactionId, got ${typeof input}`
   );
 }
 
@@ -419,25 +486,84 @@ class AccountsResource {
     this.#client.assertNotTerminated();
     const wasm = await this.#getWasm();
 
-    if (opts?.type === "FungibleFaucet") {
+    const type = opts?.type;
+
+    if (
+      type === 0 ||
+      type === 1 ||
+      type === "FungibleFaucet" ||
+      type === "NonFungibleFaucet"
+    ) {
       const storageMode = resolveStorageMode(opts.storage ?? "public", wasm);
       const authScheme = resolveAuthScheme(opts.auth, wasm);
       return await this.#inner.newFaucet(
         storageMode,
-        false,
+        type === 1 || type === "NonFungibleFaucet",
         opts.symbol,
         opts.decimals,
         BigInt(opts.maxSupply),
         authScheme
       );
+    } else if (
+      type === "ImmutableContract" ||
+      type === "MutableContract" ||
+      opts?.components // Contracts are distinguished from wallets by having components
+    ) {
+      return await this.#createContract(opts, wasm);
+    } else {
+      // Default: wallet (mutable or immutable based on type)
+      const mutable = resolveAccountMutability(opts?.type);
+      const storageMode = resolveStorageMode(opts?.storage ?? "private", wasm);
+      const authScheme = resolveAuthScheme(opts?.auth, wasm);
+      const seed = opts?.seed ? await hashSeed(opts.seed) : undefined;
+      return await this.#inner.newWallet(
+        storageMode,
+        mutable,
+        authScheme,
+        seed
+      );
     }
+  }
+
+  async #createContract(opts, wasm) {
+    if (!opts.seed)
+      throw new Error("Contract creation requires a 'seed' (Uint8Array)");
+    if (!opts.auth)
+      throw new Error("Contract creation requires an 'auth' (AuthSecretKey)");
+
+    // Default to immutable when type is omitted (safer for contracts)
+    const mutable = opts.type === "MutableContract" || opts.type === 3;
+    const accountTypeEnum = mutable
+      ? wasm.AccountType.RegularAccountUpdatableCode
+      : wasm.AccountType.RegularAccountImmutableCode;
+    const storageMode = resolveStorageMode(opts.storage ?? "public", wasm);
+    const authComponent =
+      wasm.AccountComponent.createAuthComponentFromSecretKey(opts.auth);
+
+    let builder = new wasm.AccountBuilder(opts.seed)
+      .accountType(accountTypeEnum)
+      .storageMode(storageMode)
+      .withAuthComponent(authComponent);
+
+    for (const component of opts.components ?? []) {
+      builder = builder.withComponent(component);
+    }
+
+    const built = builder.build();
+    const account = built.account;
+
+    await this.#inner.newAccountWithSecretKey(account, opts.auth);
+    return account;
+  }
+
+  async insert({ account, overwrite = false }) {
+    this.#client.assertNotTerminated();
+    await this.#inner.newAccount(account, overwrite);
+  }
 
-    // Default: wallet (mutable or immutable based on type)
-    const mutable = resolveAccountMutability(opts?.type);
-    const storageMode = resolveStorageMode(opts?.storage ?? "private", wasm);
-    const authScheme = resolveAuthScheme(opts?.auth, wasm);
-    const seed = opts?.seed ? await hashSeed(opts.seed) : undefined;
-    return await this.#inner.newWallet(storageMode, mutable, authScheme, seed);
+  async getOrImport(ref) {
+    this.#client.assertNotTerminated();
+    return (await this.get(ref)) ?? (await this.import(ref));
   }
 
   async get(ref) {
@@ -461,7 +587,7 @@ class AccountsResource {
     if (!account) {
       throw new Error(`Account not found: ${id.toString()}`);
     }
-    const keys = await this.#inner.getPublicKeyCommitmentsOfAccount(id);
+    const keys = await this.#inner.keystore.getCommitments(id);
     return {
       account,
       vault: account.vault(),
@@ -484,8 +610,10 @@ class AccountsResource {
     this.#client.assertNotTerminated();
     const wasm = await this.#getWasm();
 
-    if (typeof input === "string") {
-      // Import by ID (hex or bech32 string)
+    // Early exit for string, Account, and AccountHeader types before property
+    // checks, preventing misrouting if a WASM object ever gains a .file or .seed
+    // property. Bare AccountId (no .id() method) falls through to the fallback.
+    if (typeof input === "string" || typeof input.id === "function") {
       const id = resolveAccountRef(input, wasm);
       await this.#inner.importAccountById(id);
       return await this.#inner.getAccount(id);
@@ -519,9 +647,10 @@ class AccountsResource {
       );
     }
 
-    throw new Error(
-      "Invalid import input: expected a string, { file }, or { seed }"
-    );
+    // Fallback: treat as AccountRef (string, AccountId, Account, AccountHeader)
+    const id = resolveAccountRef(input, wasm);
+    await this.#inner.importAccountById(id);
+    return await this.#inner.getAccount(id);
   }
 
   async export(ref) {
@@ -562,9 +691,55 @@ class TransactionsResource {
   async send(opts) {
     this.#client.assertNotTerminated();
     const wasm = await this.#getWasm();
-    const { accountId, request } = await this.#buildSendRequest(opts, wasm);
 
-    const txId = await this.#submitOrSubmitWithProver(
+    if (opts.returnNote === true) {
+      // returnNote path — build the P2ID note in JS so we can return the Note
+      // object to the caller (e.g. for out-of-band delivery to the recipient).
+      if (opts.reclaimAfter != null || opts.timelockUntil != null) {
+        throw new Error(
+          "reclaimAfter and timelockUntil are not supported when returnNote is true"
+        );
+      }
+
+      const senderId = resolveAccountRef(opts.account, wasm);
+      const receiverId = resolveAccountRef(opts.to, wasm);
+      const faucetId = resolveAccountRef(opts.token, wasm);
+      const noteType = resolveNoteType(opts.type, wasm);
+
+      const note = wasm.Note.createP2IDNote(
+        senderId,
+        receiverId,
+        new wasm.NoteAssets([
+          new wasm.FungibleAsset(faucetId, BigInt(opts.amount)),
+        ]),
+        noteType,
+        new wasm.NoteAttachment()
+      );
+
+      // NoteArray constructor consumes its elements; use push(&note) to keep
+      // `note` valid so we can return it to the caller below.
+      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 };
+    }
+
+    // Default path — note built in WASM with optional reclaim/timelock
+    const { accountId, request } = await this.#buildSendRequest(opts, wasm);
+    const { txId, result } = await this.#submitOrSubmitWithProver(
       accountId,
       request,
       opts.prover
@@ -574,7 +749,7 @@ class TransactionsResource {
       await this.waitFor(txId.toHex(), { timeout: opts.timeout });
     }
 
-    return txId;
+    return { txId, note: null, result };
   }
 
   async mint(opts) {
@@ -582,7 +757,7 @@ class TransactionsResource {
     const wasm = await this.#getWasm();
     const { accountId, request } = await this.#buildMintRequest(opts, wasm);
 
-    const txId = await this.#submitOrSubmitWithProver(
+    const { txId, result } = await this.#submitOrSubmitWithProver(
       accountId,
       request,
       opts.prover
@@ -592,7 +767,7 @@ class TransactionsResource {
       await this.waitFor(txId.toHex(), { timeout: opts.timeout });
     }
 
-    return txId;
+    return { txId, result };
   }
 
   async consume(opts) {
@@ -600,7 +775,7 @@ class TransactionsResource {
     const wasm = await this.#getWasm();
     const { accountId, request } = await this.#buildConsumeRequest(opts, wasm);
 
-    const txId = await this.#submitOrSubmitWithProver(
+    const { txId, result } = await this.#submitOrSubmitWithProver(
       accountId,
       request,
       opts.prover
@@ -610,7 +785,7 @@ class TransactionsResource {
       await this.waitFor(txId.toHex(), { timeout: opts.timeout });
     }
 
-    return txId;
+    return { txId, result };
   }
 
   async consumeAll(opts) {
@@ -639,7 +814,7 @@ class TransactionsResource {
 
     const request = await this.#inner.newConsumeTransactionRequest(notes);
 
-    const txId = await this.#submitOrSubmitWithProver(
+    const { txId, result } = await this.#submitOrSubmitWithProver(
       wasm.AccountId.fromHex(accountIdHex),
       request,
       opts.prover
@@ -653,6 +828,7 @@ class TransactionsResource {
       txId,
       consumed: toConsume.length,
       remaining: total - toConsume.length,
+      result,
     };
   }
 
@@ -661,7 +837,7 @@ class TransactionsResource {
     const wasm = await this.#getWasm();
     const { accountId, request } = await this.#buildSwapRequest(opts, wasm);
 
-    const txId = await this.#submitOrSubmitWithProver(
+    const { txId, result } = await this.#submitOrSubmitWithProver(
       accountId,
       request,
       opts.prover
@@ -671,7 +847,7 @@ class TransactionsResource {
       await this.waitFor(txId.toHex(), { timeout: opts.timeout });
     }
 
-    return txId;
+    return { txId, result };
   }
 
   async preview(opts) {
@@ -705,6 +881,81 @@ class TransactionsResource {
     return await this.#inner.executeForSummary(accountId, request);
   }
 
+  async execute(opts) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const accountId = resolveAccountRef(opts.account, wasm);
+
+    let builder = new wasm.TransactionRequestBuilder().withCustomScript(
+      opts.script
+    );
+
+    if (opts.foreignAccounts?.length) {
+      const accounts = opts.foreignAccounts.map((fa) => {
+        // Distinguish { id: AccountRef, storage? } wrapper objects from WASM types
+        // (Account/AccountHeader expose .id() as a method, wrappers have .id as a property)
+        const isWrapper =
+          fa !== null &&
+          typeof fa === "object" &&
+          "id" in fa &&
+          typeof fa.id !== "function";
+        const id = resolveAccountRef(isWrapper ? fa.id : fa, wasm);
+        const storage =
+          isWrapper && fa.storage
+            ? fa.storage
+            : new wasm.AccountStorageRequirements();
+        return wasm.ForeignAccount.public(id, storage);
+      });
+      builder = builder.withForeignAccounts(
+        new wasm.ForeignAccountArray(accounts)
+      );
+    }
+
+    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) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const accountId = resolveAccountRef(opts.account, wasm);
+
+    let foreignAccountsArray = new wasm.ForeignAccountArray();
+    if (opts.foreignAccounts?.length) {
+      const accounts = opts.foreignAccounts.map((fa) => {
+        const isWrapper =
+          fa !== null &&
+          typeof fa === "object" &&
+          "id" in fa &&
+          typeof fa.id !== "function";
+        const id = resolveAccountRef(isWrapper ? fa.id : fa, wasm);
+        const storage =
+          isWrapper && fa.storage
+            ? fa.storage
+            : new wasm.AccountStorageRequirements();
+        return wasm.ForeignAccount.public(id, storage);
+      });
+      foreignAccountsArray = new wasm.ForeignAccountArray(accounts);
+    }
+
+    return await this.#inner.executeProgram(
+      accountId,
+      opts.script,
+      opts.adviceInputs ?? new wasm.AdviceInputs(),
+      foreignAccountsArray
+    );
+  }
+
   async submit(account, request, opts) {
     this.#client.assertNotTerminated();
     const wasm = await this.#getWasm();
@@ -726,7 +977,9 @@ class TransactionsResource {
     } else if (query.status === "uncommitted") {
       filter = wasm.TransactionFilter.uncommitted();
     } else if (query.ids) {
-      const txIds = query.ids.map((id) => wasm.TransactionId.fromHex(id));
+      const txIds = query.ids.map((id) =>
+        wasm.TransactionId.fromHex(resolveTransactionIdHex(id))
+      );
       filter = wasm.TransactionFilter.ids(txIds);
     } else if (query.expiredBefore !== undefined) {
       filter = wasm.TransactionFilter.expiredBefore(query.expiredBefore);
@@ -740,7 +993,7 @@ class TransactionsResource {
   /**
    * Polls for transaction confirmation.
    *
-   * @param {string} txId - Transaction ID hex string.
+   * @param {string | TransactionId} txId - Transaction ID hex string or TransactionId object.
    * @param {WaitOptions} [opts] - Polling options.
    * @param {number} [opts.timeout=60000] - Wall-clock polling timeout in
    *   milliseconds. This is NOT a block height — it controls how long the
@@ -752,6 +1005,7 @@ class TransactionsResource {
    */
   async waitFor(txId, opts) {
     this.#client.assertNotTerminated();
+    const hex = resolveTransactionIdHex(txId);
     const timeout = opts?.timeout ?? 60_000;
     const interval = opts?.interval ?? 5_000;
     const start = Date.now();
@@ -774,7 +1028,7 @@ class TransactionsResource {
 
       // Recreate filter each iteration — WASM consumes it by value
       const filter = wasm.TransactionFilter.ids([
-        wasm.TransactionId.fromHex(txId),
+        wasm.TransactionId.fromHex(hex),
       ]);
       const txs = await this.#inner.getTransactions(filter);
 
@@ -788,7 +1042,7 @@ class TransactionsResource {
             return;
           }
           if (status.isDiscarded()) {
-            throw new Error(`Transaction rejected: ${txId}`);
+            throw new Error(`Transaction rejected: ${hex}`);
           }
         }
 
@@ -841,6 +1095,37 @@ class TransactionsResource {
   async #buildConsumeRequest(opts, wasm) {
     const accountId = resolveAccountRef(opts.account, wasm);
     const noteInputs = Array.isArray(opts.notes) ? opts.notes : [opts.notes];
+
+    const isDirectNote = (input) =>
+      input !== null &&
+      typeof input === "object" &&
+      typeof input.id === "function" &&
+      typeof input.toNote !== "function";
+
+    const hasDirectNotes = noteInputs.some(isDirectNote);
+
+    if (hasDirectNotes) {
+      // At least one raw Note object — use NoteAndArgs builder path
+      // (the only WASM path that accepts unauthenticated notes not in the store).
+      const resolvedNotes = await Promise.all(
+        noteInputs.map(async (input) => {
+          if (isDirectNote(input)) return input;
+          if (input && typeof input.toNote === "function")
+            return input.toNote();
+          return await this.#resolveNoteInput(input);
+        })
+      );
+
+      const noteAndArgsArr = resolvedNotes.map(
+        (note) => new wasm.NoteAndArgs(note, null)
+      );
+      const request = new wasm.TransactionRequestBuilder()
+        .withInputNotes(new wasm.NoteAndArgsArray(noteAndArgsArr))
+        .build();
+      return { accountId, request };
+    }
+
+    // Standard path: all inputs are IDs or records — look up from store.
     const notes = await Promise.all(
       noteInputs.map((input) => this.#resolveNoteInput(input))
     );
@@ -882,8 +1167,15 @@ class TransactionsResource {
     if (input && typeof input.toNote === "function") {
       return input.toNote();
     }
-    // NoteId — look up the note by its hex ID
-    if (input && input.constructor?.name === "NoteId") {
+    // NoteId — has toString() but not toNote() or id() (unlike InputNoteRecord/Note).
+    // Check for constructor.fromHex to distinguish from plain objects.
+    if (
+      input &&
+      typeof input.toString === "function" &&
+      typeof input.toNote !== "function" &&
+      typeof input.id !== "function" &&
+      input.constructor?.fromHex !== undefined
+    ) {
       const hex = input.toString();
       const record = await this.#inner.getInputNote(hex);
       if (!record) {
@@ -896,15 +1188,15 @@ class TransactionsResource {
   }
 
   async #submitOrSubmitWithProver(accountId, request, perCallProver) {
+    const result = await this.#inner.executeTransaction(accountId, request);
     const prover = perCallProver ?? this.#client.defaultProver;
-    if (prover) {
-      return await this.#inner.submitNewTransactionWithProver(
-        accountId,
-        request,
-        prover
-      );
-    }
-    return await this.#inner.submitNewTransaction(accountId, request);
+    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);
+    return { txId, result };
   }
 }
 
@@ -928,7 +1220,7 @@ class NotesResource {
 
   async get(noteId) {
     this.#client.assertNotTerminated();
-    const result = await this.#inner.getInputNote(noteId);
+    const result = await this.#inner.getInputNote(resolveNoteIdHex(noteId));
     return result ?? null;
   }
 
@@ -943,7 +1235,8 @@ class NotesResource {
     this.#client.assertNotTerminated();
     const wasm = await this.#getWasm();
     const accountId = resolveAccountRef(opts.account, wasm);
-    return await this.#inner.getConsumableNotes(accountId);
+    const consumable = await this.#inner.getConsumableNotes(accountId);
+    return consumable.map((c) => c.inputNoteRecord());
   }
 
   async import(noteFile) {
@@ -955,7 +1248,7 @@ class NotesResource {
     this.#client.assertNotTerminated();
     const wasm = await this.#getWasm();
     const format = opts?.format ?? wasm.NoteExportFormat.Full;
-    return await this.#inner.exportNoteFile(noteId, format);
+    return await this.#inner.exportNoteFile(resolveNoteIdHex(noteId), format);
   }
 
   async fetchPrivate(opts) {
@@ -970,11 +1263,27 @@ class NotesResource {
   async sendPrivate(opts) {
     this.#client.assertNotTerminated();
     const wasm = await this.#getWasm();
-    const noteRecord = await this.#inner.getInputNote(opts.noteId);
-    if (!noteRecord) {
-      throw new Error(`Note not found: ${opts.noteId}`);
+
+    let note;
+    const input = opts.note;
+    // Check if input is a Note object (has .id() and .assets() but not .toNote())
+    if (
+      input &&
+      typeof input === "object" &&
+      typeof input.id === "function" &&
+      typeof input.assets === "function" &&
+      typeof input.toNote !== "function"
+    ) {
+      note = input;
+    } else {
+      const noteHex = resolveNoteIdHex(input);
+      const noteRecord = await this.#inner.getInputNote(noteHex);
+      if (!noteRecord) {
+        throw new Error(`Note not found: ${noteHex}`);
+      }
+      note = noteRecord.toNote();
     }
-    const note = noteRecord.toNote();
+
     const address = resolveAddress(opts.to, wasm);
     await this.#inner.sendPrivateNote(note, address);
   }
@@ -986,7 +1295,9 @@ function buildNoteFilter(query, wasm) {
   }
 
   if (query.ids) {
-    const noteIds = query.ids.map((id) => wasm.NoteId.fromHex(id));
+    const noteIds = query.ids.map((id) =>
+      wasm.NoteId.fromHex(resolveNoteIdHex(id))
+    );
     return new wasm.NoteFilter(wasm.NoteFilterTypes.List, noteIds);
   }
 
@@ -1071,6 +1382,102 @@ class SettingsResource {
   }
 }
 
+class CompilerResource {
+  #inner;
+  #getWasm;
+  #client;
+
+  constructor(inner, getWasm, client) {
+    this.#inner = inner;
+    this.#getWasm = getWasm;
+    this.#client = client;
+  }
+
+  /**
+   * Compiles MASM code + slots into an AccountComponent ready for accounts.create().
+   *
+   * @param {{ code: string, slots: StorageSlot[], supportAllTypes?: boolean }} opts
+   * @returns {Promise<AccountComponent>}
+   */
+  async component({ code, slots = [], supportAllTypes = true }) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const builder = this.#inner.createCodeBuilder();
+    const compiled = builder.compileAccountComponentCode(code);
+    const component = wasm.AccountComponent.compile(compiled, slots);
+    return supportAllTypes ? component.withSupportsAllTypes() : component;
+  }
+
+  /**
+   * Compiles a transaction script, optionally linking named libraries inline.
+   *
+   * @param {{ code: string, libraries?: Array<{ namespace: string, code: string, linking?: "dynamic" | "static" }> }} opts
+   * @returns {Promise<TransactionScript>}
+   */
+  async txScript({ code, libraries = [] }) {
+    this.#client.assertNotTerminated();
+    // Ensure WASM is initialized (result unused — only #inner needs it)
+    await this.#getWasm();
+    const builder = this.#inner.createCodeBuilder();
+    for (const lib of libraries) {
+      if (lib && typeof lib.namespace === "string") {
+        // Inline { namespace, code, linking? } — build and link automatically
+        const built = builder.buildLibrary(lib.namespace, lib.code);
+        if (lib.linking === "static") {
+          builder.linkStaticLibrary(built);
+        } else {
+          // Default: "dynamic" — matches existing tutorial behavior
+          builder.linkDynamicLibrary(built);
+        }
+      } else {
+        // Pre-built library object — link dynamically
+        builder.linkDynamicLibrary(lib);
+      }
+    }
+    return builder.compileTxScript(code);
+  }
+}
+
+class KeystoreResource {
+  #inner;
+  #client;
+
+  constructor(inner, client) {
+    this.#inner = inner;
+    this.#client = client;
+  }
+
+  async insert(accountId, secretKey) {
+    this.#client.assertNotTerminated();
+    const ks = this.#inner.keystore;
+    return await ks.insert(accountId, secretKey);
+  }
+
+  async get(pubKeyCommitment) {
+    this.#client.assertNotTerminated();
+    const ks = this.#inner.keystore;
+    return await ks.get(pubKeyCommitment);
+  }
+
+  async remove(pubKeyCommitment) {
+    this.#client.assertNotTerminated();
+    const ks = this.#inner.keystore;
+    return await ks.remove(pubKeyCommitment);
+  }
+
+  async getCommitments(accountId) {
+    this.#client.assertNotTerminated();
+    const ks = this.#inner.keystore;
+    return await ks.getCommitments(accountId);
+  }
+
+  async getAccountId(pubKeyCommitment) {
+    this.#client.assertNotTerminated();
+    const ks = this.#inner.keystore;
+    return await ks.getAccountId(pubKeyCommitment);
+  }
+}
+
 /**
  * MidenClient wraps the existing proxy-wrapped WebClient with a resource-based API.
  *
@@ -1099,15 +1506,24 @@ class MidenClient {
     this.notes = new NotesResource(inner, getWasm, this);
     this.tags = new TagsResource(inner, getWasm, this);
     this.settings = new SettingsResource(inner, getWasm, this);
+    this.compile = new CompilerResource(inner, getWasm, this);
+    this.keystore = new KeystoreResource(inner, this);
   }
 
   /**
    * Creates and initializes a new MidenClient.
    *
+   * If no `rpcUrl` is provided, defaults to testnet with full configuration
+   * (RPC, prover, note transport, autoSync).
+   *
    * @param {ClientOptions} [options] - Client configuration options.
    * @returns {Promise<MidenClient>} A fully initialized client.
    */
   static async create(options) {
+    if (!options?.rpcUrl) {
+      return MidenClient.createTestnet(options);
+    }
+
     const getWasm = MidenClient._getWasmOrThrow;
     const WebClientClass = MidenClient._WasmWebClient;
 
@@ -1119,11 +1535,14 @@ class MidenClient {
 
     const seed = options?.seed ? await hashSeed(options.seed) : undefined;
 
+    const rpcUrl = resolveRpcUrl(options?.rpcUrl);
+    const noteTransportUrl = resolveNoteTransportUrl(options?.noteTransportUrl);
+
     let inner;
     if (options?.keystore) {
       inner = await WebClientClass.createClientWithExternalKeystore(
-        options?.rpcUrl,
-        options?.noteTransportUrl,
+        rpcUrl,
+        noteTransportUrl,
         seed,
         options?.storeName,
         options.keystore.getKey,
@@ -1132,8 +1551,8 @@ class MidenClient {
       );
     } else {
       inner = await WebClientClass.createClient(
-        options?.rpcUrl,
-        options?.noteTransportUrl,
+        rpcUrl,
+        noteTransportUrl,
         seed,
         options?.storeName
       );
@@ -1142,10 +1561,7 @@ class MidenClient {
     let defaultProver = null;
     if (options?.proverUrl) {
       const wasm = await getWasm();
-      defaultProver = wasm.TransactionProver.newRemoteProver(
-        options.proverUrl,
-        undefined
-      );
+      defaultProver = resolveProver(options.proverUrl, wasm);
     }
 
     const client = new MidenClient(inner, getWasm, defaultProver);
@@ -1159,15 +1575,39 @@ class MidenClient {
 
   /**
    * Creates a client preconfigured for testnet use.
-   * Defaults to autoSync: true.
    *
-   * @param {object} [options] - Options (autoSync can be overridden).
+   * Defaults: rpcUrl "testnet", proverUrl "testnet", noteTransportUrl "testnet", autoSync true.
+   * All defaults can be overridden via options.
+   *
+   * @param {ClientOptions} [options] - Options to override defaults.
    * @returns {Promise<MidenClient>} A fully initialized testnet client.
    */
   static async createTestnet(options) {
     return MidenClient.create({
+      rpcUrl: "testnet",
+      proverUrl: "testnet",
+      noteTransportUrl: "testnet",
+      autoSync: true,
+      ...options,
+    });
+  }
+
+  /**
+   * Creates a client preconfigured for devnet use.
+   *
+   * Defaults: rpcUrl "devnet", proverUrl "devnet", noteTransportUrl "devnet", autoSync true.
+   * All defaults can be overridden via options.
+   *
+   * @param {ClientOptions} [options] - Options to override defaults.
+   * @returns {Promise<MidenClient>} A fully initialized devnet client.
+   */
+  static async createDevnet(options) {
+    return MidenClient.create({
+      rpcUrl: "devnet",
+      proverUrl: "devnet",
+      noteTransportUrl: "devnet",
+      autoSync: true,
       ...options,
-      autoSync: options?.autoSync ?? true,
     });
   }
 
@@ -1244,30 +1684,13 @@ class MidenClient {
   }
 
   /**
-   * Exports the client store as a versioned snapshot.
+   * Returns the identifier of the underlying store (e.g. IndexedDB database name, file path).
    *
-   * @returns {Promise<StoreSnapshot>} The store snapshot.
+   * @returns {string} The store identifier.
    */
-  async exportStore() {
+  storeIdentifier() {
     this.assertNotTerminated();
-    const data = await this.#inner.exportStore();
-    return { version: 1, data };
-  }
-
-  /**
-   * Imports a previously exported store snapshot.
-   *
-   * @param {StoreSnapshot} snapshot - The store snapshot to import.
-   */
-  async importStore(snapshot) {
-    this.assertNotTerminated();
-    if (!snapshot || snapshot.version !== 1) {
-      throw new Error(
-        `Unsupported store snapshot version: ${snapshot?.version}. Expected version 1.`
-      );
-    }
-    // Second arg is the store password (empty string = no encryption)
-    await this.#inner.forceImportStore(snapshot.data, "");
+    return this.#inner.storeIdentifier();
   }
 
   // ── Mock-only methods ──
@@ -1314,6 +1737,64 @@ class MidenClient {
   }
 }
 
+const RPC_URLS = {
+  testnet: "https://rpc.testnet.miden.io",
+  devnet: "https://rpc.devnet.miden.io",
+  localhost: "http://localhost:57291",
+  local: "http://localhost:57291",
+};
+
+/**
+ * Resolves an rpcUrl shorthand or raw URL into a concrete endpoint string.
+ *
+ * @param {string | undefined} rpcUrl - "testnet", "devnet", "localhost", "local", or a raw URL.
+ * @returns {string | undefined} A fully qualified URL, or undefined to use the SDK default.
+ */
+function resolveRpcUrl(rpcUrl) {
+  if (!rpcUrl) return undefined;
+  return RPC_URLS[rpcUrl.trim().toLowerCase()] ?? rpcUrl;
+}
+
+const PROVER_URLS = {
+  devnet: "https://tx-prover.devnet.miden.io",
+  testnet: "https://tx-prover.testnet.miden.io",
+};
+
+const NOTE_TRANSPORT_URLS = {
+  testnet: "https://transport.miden.io",
+  devnet: "https://transport.devnet.miden.io",
+};
+
+/**
+ * Resolves a noteTransportUrl shorthand or raw URL into a concrete endpoint string.
+ *
+ * @param {string | undefined} noteTransportUrl - "testnet", "devnet", or a raw URL.
+ * @returns {string | undefined} A fully qualified URL, or undefined if omitted.
+ */
+function resolveNoteTransportUrl(noteTransportUrl) {
+  if (!noteTransportUrl) return undefined;
+  return (
+    NOTE_TRANSPORT_URLS[noteTransportUrl.trim().toLowerCase()] ??
+    noteTransportUrl
+  );
+}
+
+/**
+ * Resolves a proverUrl shorthand or raw URL into a TransactionProver.
+ *
+ * @param {string} proverUrl - "local", "devnet", "testnet", or a raw URL.
+ * @param {object} wasm - Loaded WASM module.
+ * @returns {object} A TransactionProver instance.
+ */
+function resolveProver(proverUrl, wasm) {
+  const normalized = proverUrl.trim().toLowerCase();
+  if (normalized === "local") {
+    return wasm.TransactionProver.newLocalProver();
+  }
+  const remoteUrl = PROVER_URLS[normalized] ?? proverUrl;
+  return wasm.TransactionProver.newRemoteProver(remoteUrl, undefined);
+}
+
 // Module-level WASM reference, set by index.js after initialization
 let _wasm = null;
 let _WebClient = null;
@@ -1339,7 +1820,7 @@ function getWasm() {
  * Creates a P2ID (Pay-to-ID) note.
  *
  * @param {NoteOptions} opts - Note creation options.
- * @returns {OutputNote} The created output note.
+ * @returns {Note} The created note.
  */
 function createP2IDNote(opts) {
   const wasm = getWasm();
@@ -1351,21 +1832,20 @@ function createP2IDNote(opts) {
     ? new wasm.NoteAttachment(opts.attachment)
     : new wasm.NoteAttachment([]);
 
-  const note = wasm.Note.createP2IDNote(
+  return wasm.Note.createP2IDNote(
     sender,
     target,
     noteAssets,
     noteType,
     attachment
   );
-  return wasm.OutputNote.full(note);
 }
 
 /**
  * Creates a P2IDE (Pay-to-ID with Expiration) note.
  *
  * @param {P2IDEOptions} opts - Note creation options with timelock/reclaim.
- * @returns {OutputNote} The created output note.
+ * @returns {Note} The created note.
  */
 function createP2IDENote(opts) {
   const wasm = getWasm();
@@ -1377,7 +1857,7 @@ function createP2IDENote(opts) {
     ? new wasm.NoteAttachment(opts.attachment)
     : new wasm.NoteAttachment([]);
 
-  const note = wasm.Note.createP2IDENote(
+  return wasm.Note.createP2IDENote(
     sender,
     target,
     noteAssets,
@@ -1386,7 +1866,6 @@ function createP2IDENote(opts) {
     noteType,
     attachment
   );
-  return wasm.OutputNote.full(note);
 }
 
 /**
@@ -1425,9 +1904,16 @@ function buildNoteAssets(assets, wasm) {
 }
 
 const AccountType = Object.freeze({
-  MutableWallet: "MutableWallet",
-  ImmutableWallet: "ImmutableWallet",
-  FungibleFaucet: "FungibleFaucet",
+  // WASM-compatible numeric values — usable with AccountBuilder directly
+  FungibleFaucet: 0,
+  NonFungibleFaucet: 1,
+  RegularAccountImmutableCode: 2,
+  RegularAccountUpdatableCode: 3,
+  // SDK-friendly aliases (same numeric values as their WASM equivalents)
+  MutableWallet: 3,
+  ImmutableWallet: 2,
+  ImmutableContract: 2,
+  MutableContract: 3,
 });
 
 const AuthScheme = Object.freeze({
@@ -1435,6 +1921,19 @@ const AuthScheme = Object.freeze({
   ECDSA: "ecdsa",
 });
 
+const NoteVisibility = Object.freeze({
+  Public: "public",
+  Private: "private",
+});
+
+const StorageMode = Object.freeze({
+  Public: "public",
+  Private: "private",
+  Network: "network",
+});
+
+const MOCK_STORE_NAME = "mock_client_db";
+
 const buildTypedArraysExport = (exportObject) => {
   return Object.entries(exportObject).reduce(
     (exports$1, [exportName, _export]) => {
@@ -1600,9 +2099,11 @@ class WebClient {
     if (typeof Worker !== "undefined") {
       console.log("WebClient: Web Workers are available.");
       // Create the worker.
+      // Classic worker (not module) — the worker is built as a self-contained
+      // async-IIFE by the rollup config, compatible with all browsers including
+      // Safari/WKWebView which is extremely slow with module workers.
       this.worker = new Worker(
-        new URL("./workers/web-client-methods-worker.js", import.meta.url),
-        { type: "module" }
+        new URL("./workers/web-client-methods-worker.js", import.meta.url)
       );
 
       // Map to track pending worker requests.
@@ -1908,6 +2409,20 @@ class WebClient {
     });
   }
 
+  async newAccount(account, overwrite) {
+    return this._serializeWasmCall(async () => {
+      const wasmWebClient = await this.getWasmWebClient();
+      return await wasmWebClient.newAccount(account, overwrite);
+    });
+  }
+
+  async newAccountWithSecretKey(account, secretKey) {
+    return this._serializeWasmCall(async () => {
+      const wasmWebClient = await this.getWasmWebClient();
+      return await wasmWebClient.newAccountWithSecretKey(account, secretKey);
+    });
+  }
+
   async submitNewTransaction(accountId, transactionRequest) {
     try {
       if (!this.worker) {
@@ -2136,7 +2651,16 @@ class WebClient {
 
 class MockWebClient extends WebClient {
   constructor(seed, logLevel) {
-    super(null, null, seed, "mock", undefined, undefined, undefined, logLevel);
+    super(
+      null,
+      null,
+      seed,
+      MOCK_STORE_NAME,
+      undefined,
+      undefined,
+      undefined,
+      logLevel
+    );
   }
 
   initializeWorker() {
@@ -2377,5 +2901,5 @@ MidenClient._MockWasmWebClient = MockWebClient;
 MidenClient._getWasmOrThrow = getWasmOrThrow;
 _setWebClient(WebClient);
 
-export { AccountType, AuthScheme, MidenArrays, MidenClient, MockWebClient as MockWasmWebClient, WebClient as WasmWebClient, buildSwapTag, createP2IDENote, createP2IDNote, getWasmOrThrow };
+export { AccountType, AuthScheme, MidenArrays, MidenClient, MockWebClient as MockWasmWebClient, NoteVisibility, StorageMode, WebClient as WasmWebClient, buildSwapTag, createP2IDENote, createP2IDNote, getWasmOrThrow };
 //# sourceMappingURL=index.js.map