wative-core 1.2.1 → 2.2.0

package/tests/07-custom-provider.test.cjs

@@ -0,0 +1,164 @@
+// 07 — Custom storage backend. Extend the abstract `Provider` class to plug
+// `Workspace.open()` into any storage system. This example uses an in-memory
+// key-value store with a trivial XOR cipher; real custom Providers should use
+// an authenticated cipher (AES-GCM, ChaCha20-Poly1305).
+
+const test = require("node:test");
+const assert = require("node:assert");
+
+const { Workspace, Provider, Record, WativeError } = require("wative-core");
+
+/**
+ * In-memory `Provider` implementation. Stores records in a Map under
+ * filesystem-style paths, encrypted with a single-byte-header XOR scheme.
+ */
+class InMemoryProvider extends Provider {
+  #store = new Map();
+  #dirs = new Set();
+  #password = null;
+
+  constructor(label) {
+    super(label);
+    this.#dirs.add("/");
+    this.#dirs.add("/accounts");
+  }
+
+  _exist(path) { return this.#store.has(path) || this.#dirs.has(path); }
+  _read(path) {
+    const v = this.#store.get(path);
+    if (!v) throw new WativeError("RECORD_NOT_FOUND", `no entry at ${path}`);
+    return v;
+  }
+  _write(path, data) { this.#store.set(path, data); }
+  _remove(path) { this.#store.delete(path); }
+  _ensureDir(path) { this.#dirs.add(path); }
+  _listItems(path) {
+    const prefix = path.endsWith("/") ? path : path + "/";
+    const out = new Set();
+    for (const k of this.#store.keys()) {
+      if (k.startsWith(prefix)) {
+        const head = k.slice(prefix.length).split("/")[0];
+        if (head) out.add(head);
+      }
+    }
+    return Array.from(out);
+  }
+
+  async unlockContainer(password) {
+    if (typeof password !== "string" || password.length === 0) return false;
+    const path = this.#pathFor("CONFIG", "config");
+    if (this.#store.has(path)) {
+      try { this.#decrypt(this.#store.get(path), password); }
+      catch { return false; }
+    }
+    this.#password = password;
+    return true;
+  }
+  async lockContainer() { this.#password = null; }
+  isContainerUnlocked() { return this.#password !== null; }
+
+  async loadRecord(type, slug) {
+    if (this.#password === null) throw new WativeError("PROVIDER_IO", "container locked");
+    const eff = slug ?? this.#defaultSlug(type);
+    const path = this.#pathFor(type, eff);
+    if (!this.#store.has(path)) throw new WativeError("RECORD_NOT_FOUND", path);
+    const encrypted = this.#store.get(path);
+    const value = JSON.parse(new TextDecoder().decode(this.#decrypt(encrypted, this.#password)));
+    return new Record(eff, path, {
+      provider: this,
+      recordType: type,
+      encrypted,
+      value,
+      password: this.#password,
+      decrypt: (ct, pwd) => this.#decrypt(ct, pwd),
+      persist: async (val, pwd) => {
+        this.#store.set(path, this.#encrypt(JSON.stringify(val), pwd));
+      },
+    });
+  }
+  async loadRecords(type) {
+    if (type !== "ACCOUNTS") {
+      const r = await this.loadRecord(type).catch((e) => {
+        if (e instanceof WativeError && e.code === "RECORD_NOT_FOUND") return null;
+        throw e;
+      });
+      return r ? [r] : [];
+    }
+    const items = this._listItems("/accounts").filter((n) => n.endsWith(".kv"));
+    return Promise.all(items.map((n) => this.loadRecord("ACCOUNTS", n.slice(0, -3))));
+  }
+  async writeRecord(type, slug, value) {
+    if (this.#password === null) throw new WativeError("PROVIDER_IO", "container locked");
+    this.#store.set(this.#pathFor(type, slug), this.#encrypt(JSON.stringify(value), this.#password));
+  }
+  async dropRecord(type, slug) { this.#store.delete(this.#pathFor(type, slug)); }
+  async close() { this.#password = null; }
+
+  #defaultSlug(type) {
+    return ({ CONFIG: "config", NETWORK: "network", ASSET: "asset", LOG: "log", ACCOUNTS: "" })[type] || "";
+  }
+  #pathFor(type, slug) {
+    if (type === "ACCOUNTS") return `/accounts/${slug}.kv`;
+    return `/${this.#defaultSlug(type)}`;
+  }
+  #encrypt(plaintext, password) {
+    const data = new TextEncoder().encode(plaintext);
+    const stream = this.#streamFor(password, data.length);
+    const out = new Uint8Array(data.length + 1);
+    out[0] = 0x42;
+    for (let i = 0; i < data.length; i++) out[i + 1] = data[i] ^ stream[i];
+    return out;
+  }
+  #decrypt(blob, password) {
+    if (blob.length < 1 || blob[0] !== 0x42) throw new WativeError("DECRYPT_FAILED", "bad header");
+    const ct = blob.subarray(1);
+    const stream = this.#streamFor(password, ct.length);
+    const out = new Uint8Array(ct.length);
+    for (let i = 0; i < ct.length; i++) out[i] = ct[i] ^ stream[i];
+    try { JSON.parse(new TextDecoder().decode(out)); }
+    catch (e) { throw new WativeError("BAD_PASSWORD", "non-JSON after decrypt", { cause: e }); }
+    return out;
+  }
+  #streamFor(password, length) {
+    const seed = new TextEncoder().encode("salt|" + password);
+    const out = new Uint8Array(length);
+    for (let i = 0; i < length; i++) out[i] = seed[i % seed.length] ^ ((i * 7) & 0xff);
+    return out;
+  }
+}
+
+test("custom provider — full lifecycle against an in-memory backend", async () => {
+  const provider = new InMemoryProvider("memory://desk-1");
+
+  let ws = await Workspace.open({ provider, password: "wsp-pwd" });
+  assert.strictEqual(ws.locked, false);
+
+  const slugs = ws.networks.map((n) => n.slug).sort();
+  assert.strictEqual(slugs.length, 10);
+  assert.ok(slugs.includes("ethereum"));
+  assert.ok(slugs.includes("arbitrum-sepolia"));
+
+  const acc = await ws.accounts.create(
+    "Trader",
+    "wsp-pwd",
+    "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
+  );
+  await acc.deriveWallets(2);
+  assert.strictEqual(acc.wallets.length, 3);
+
+  await ws.lock();
+  ws = await Workspace.open({ provider, password: "wsp-pwd" });
+  const reopened = ws.accounts.bySlug(acc.slug);
+  assert.ok(reopened);
+  assert.strictEqual(reopened.wallets.length, 3);
+
+  await ws.lock();
+});
+
+test("custom provider — bad password is rejected", async () => {
+  const provider = new InMemoryProvider("memory://desk-2");
+  const ws = await Workspace.open({ provider, password: "right-pwd" });
+  await ws.lock();
+
+  await assert.rejects(Workspace.open({ provider, password: "wrong-pwd" }), (err) => err.code === "BAD_PASSWORD");
+});

package/tests/08-persistence.test.cjs

@@ -0,0 +1,105 @@
+// 08 — Persistence. Verify that accounts, networks, custom assets, and the
+// logger configuration all round-trip correctly across `lock()` + reopen.
+
+const test = require("node:test");
+const assert = require("node:assert");
+const { mkdtempSync } = require("node:fs");
+const { tmpdir } = require("node:os");
+const { join } = require("node:path");
+
+const { Workspace, Network, Asset } = require("wative-core");
+
+const MNEMONIC =
+  "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
+
+test("persistence — multiple HD + PK accounts round-trip", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-persist-acc-"));
+  let ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const hd = await ws.accounts.create("Desk One", "wsp-pwd", MNEMONIC);
+  await hd.deriveWallets(3);
+
+  const pk = await ws.accounts.create(
+    "Hot Wallet",
+    "wsp-pwd",
+    "0x4f3edf983ac636a65a842ce7c78d9aa706d3b113bce9c46f30d7d21715b23b1d",
+    undefined,
+    { kind: "PK" },
+  );
+
+  await ws.lock();
+  ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+  assert.strictEqual(ws.accounts.length, 2);
+  const reopenHd = ws.accounts.bySlug(hd.slug);
+  const reopenPk = ws.accounts.bySlug(pk.slug);
+  assert.ok(reopenHd && reopenPk);
+  assert.strictEqual(reopenHd.organizationType, "HD");
+  assert.strictEqual(reopenPk.organizationType, "PK");
+  assert.strictEqual(reopenHd.wallets.length, 4);
+  assert.strictEqual(reopenPk.wallets.length, 1);
+
+  await ws.lock();
+});
+
+test("persistence — added user network round-trips with all fields", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-persist-net-"));
+  let ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  await ws.networks.add(new Network({
+    slug: "monad-testnet",
+    name: "Monad Testnet",
+    chainId: 10143,
+    rpcUrl: "https://testnet-rpc.monad.xyz",
+    nativeCurrency: { name: "Monad", symbol: "MON", decimals: 18 },
+    color: "#7e22ce",
+    vm: "evm",
+  }));
+
+  await ws.lock();
+  ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+  const monad = ws.networks.bySlug("monad-testnet");
+  assert.ok(monad);
+  assert.strictEqual(monad.chainId, 10143);
+  assert.strictEqual(monad.rpcUrl, "https://testnet-rpc.monad.xyz");
+  assert.strictEqual(monad.nativeCurrency.symbol, "MON");
+  assert.strictEqual(monad.color, "#7e22ce");
+
+  await ws.lock();
+});
+
+test("persistence — custom user asset round-trips", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-persist-asset-"));
+  let ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  await ws.addAsset(new Asset({
+    id: 250,
+    symbol: "PEPE",
+    name: "Pepe",
+    decimals: 18,
+    contractAddress: "0x6982508145454Ce325dDbE47a25d4ec3d2311933",
+    network: Network.Ethereum,
+  }));
+
+  await ws.lock();
+  ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+  const ethAssets = await ws.assets(Network.Ethereum);
+  const pepe = ethAssets.find((a) => a.id === 250);
+  assert.ok(pepe);
+  assert.strictEqual(pepe.symbol, "PEPE");
+  assert.strictEqual(pepe.decimals, 18);
+
+  await ws.lock();
+});
+
+test("persistence — custom logger config round-trips", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-persist-log-"));
+  let ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  await ws.logger.setLevel("debug");
+
+  await ws.lock();
+  ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+  assert.strictEqual(ws.logger.config.minLevel, "debug");
+
+  await ws.lock();
+});

package/tests/09-workspace-filter.test.cjs

@@ -0,0 +1,84 @@
+// 09 — Workspace search. `filter(query, objective)` returns the live object
+// matching `query` for the given objective: Wallet, Address, Account, or Asset.
+
+const test = require("node:test");
+const assert = require("node:assert");
+const { mkdtempSync } = require("node:fs");
+const { tmpdir } = require("node:os");
+const { join } = require("node:path");
+
+const { Workspace } = require("wative-core");
+
+const MNEMONIC =
+  "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
+
+test("filter — find an Account by displayName or slug", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-filter-acc-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const acc = await ws.accounts.create("Trading Desk", "wsp-pwd", MNEMONIC);
+
+  const byName = await ws.filter("Trading Desk", "Account");
+  const bySlug = await ws.filter(acc.slug, "Account");
+  assert.ok(byName && byName.slug === acc.slug);
+  assert.ok(bySlug && bySlug.slug === acc.slug);
+
+  const missing = await ws.filter("nonexistent", "Account");
+  assert.strictEqual(missing, null);
+
+  await ws.lock();
+});
+
+test("filter — find a Wallet by id or by tag", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-filter-wallet-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const acc = await ws.accounts.create("Desk", "wsp-pwd", MNEMONIC);
+  await acc.deriveWallets(2);
+
+  await acc.wallets[1].addTag("alpha-strategy");
+
+  const byId = await ws.filter("1", "Wallet");
+  assert.ok(byId);
+  assert.strictEqual(byId.id, 1);
+
+  const byTag = await ws.filter("alpha-strategy", "Wallet");
+  assert.ok(byTag);
+  assert.strictEqual(byTag.id, 1);
+
+  await ws.lock();
+});
+
+test("filter — find an Address by its public key (case-insensitive for EVM)", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-filter-addr-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const acc = await ws.accounts.create("Desk", "wsp-pwd", MNEMONIC);
+  const evm = acc.wallets[0].addresses.find((a) => a.vm === "evm");
+
+  const found = await ws.filter(evm.publicKey, "Address");
+  assert.ok(found);
+  assert.strictEqual(found.publicKey, evm.publicKey);
+
+  const foundLower = await ws.filter(evm.publicKey.toLowerCase(), "Address");
+  assert.ok(foundLower);
+  assert.strictEqual(foundLower.publicKey, evm.publicKey);
+
+  await ws.lock();
+});
+
+test("filter — find an Asset; returns null for unknown query", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-filter-asset-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const usdc = await ws.filter("USDC", "Asset");
+  assert.ok(usdc && usdc.symbol === "USDC");
+
+  const usdt = await ws.filter("0xdAC17F958D2ee523a2206206994597C13D831ec7", "Asset");
+  assert.ok(usdt && usdt.symbol === "USDT");
+
+  const missing = await ws.filter("DOES-NOT-EXIST", "Asset");
+  assert.strictEqual(missing, null);
+
+  await ws.lock();
+});

package/tests/10-default-network.test.cjs

@@ -0,0 +1,70 @@
+// 10 — Account default network. `account.setDefaultNetwork(value)` accepts
+// a slug, a chain id, a hex chain id, or a Network instance — and the choice
+// persists across reopen.
+
+const test = require("node:test");
+const assert = require("node:assert");
+const { mkdtempSync } = require("node:fs");
+const { tmpdir } = require("node:os");
+const { join } = require("node:path");
+
+const { Workspace, Network } = require("wative-core");
+
+const MNEMONIC =
+  "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
+
+test("setDefaultNetwork — accepts slug, chainId, hex chainId, and Network instance", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-default-net-forms-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const acc = await ws.accounts.create("Desk", "wsp-pwd", MNEMONIC);
+
+  await acc.setDefaultNetwork("base");
+  assert.strictEqual(acc.defaultNetwork, "base");
+
+  await acc.setDefaultNetwork(8453);
+  assert.strictEqual(acc.defaultNetwork, "base");
+
+  await acc.setDefaultNetwork("0xa");
+  assert.strictEqual(acc.defaultNetwork, "optimism");
+
+  await acc.setDefaultNetwork(Network.Arbitrum);
+  assert.strictEqual(acc.defaultNetwork, "arbitrum");
+
+  await ws.lock();
+});
+
+test("setDefaultNetwork — rejects an unknown network", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-default-net-bad-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const acc = await ws.accounts.create("Desk", "wsp-pwd", MNEMONIC);
+
+  await assert.rejects(
+    acc.setDefaultNetwork("does-not-exist"),
+    (err) => err.code === "UNSUPPORTED_NETWORK",
+  );
+  await assert.rejects(
+    acc.setDefaultNetwork(99999999),
+    (err) => err.code === "UNSUPPORTED_NETWORK",
+  );
+
+  await ws.lock();
+});
+
+test("setDefaultNetwork — choice persists across lock + reopen", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-default-net-persist-"));
+  let ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const acc = await ws.accounts.create("Desk", "wsp-pwd", MNEMONIC);
+  await acc.setDefaultNetwork(Network.Solana);
+  assert.strictEqual(acc.defaultNetwork, "solana");
+
+  await ws.lock();
+  ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+  const reopened = ws.accounts.bySlug(acc.slug);
+  assert.ok(reopened);
+  assert.strictEqual(reopened.defaultNetwork, "solana");
+
+  await ws.lock();
+});

package/tests/11-subpath-imports.test.cjs

@@ -0,0 +1,21 @@
+// 11 — Subpath imports. Heavier chain helpers ship under `wative-core/artifacts/evm`
+// and `wative-core/artifacts/svm` so they're only pulled in when used. In your
+// own project: require("wative-core/artifacts/evm") / require("wative-core/artifacts/svm").
+
+const test = require("node:test");
+const assert = require("node:assert");
+
+const evmArtifacts = require("../dist/artifacts/evm/index.cjs");
+const svmArtifacts = require("../dist/artifacts/svm/index.cjs");
+
+test("subpath import — evm artifacts expose a usable ERC20 contract", () => {
+  assert.ok(evmArtifacts.ERC20);
+  assert.strictEqual(typeof evmArtifacts.ERC20.encode, "function");
+});
+
+test("subpath import — svm artifacts expose TokenProgram and Token2022Program", () => {
+  assert.ok(svmArtifacts.TokenProgram);
+  assert.ok(svmArtifacts.Token2022Program);
+  assert.strictEqual(typeof svmArtifacts.TokenProgram.encodeInstruction, "function");
+  assert.strictEqual(typeof svmArtifacts.Token2022Program.encodeInstruction, "function");
+});

package/tests/12-logger.test.cjs

@@ -0,0 +1,44 @@
+// 12 — Logger. Workspace exposes `ws.logger` after unlock. Write structured
+// logs at any level, change the level via `ws.logger.setLevel(...)`, and the
+// configuration persists across reopen.
+
+const test = require("node:test");
+const assert = require("node:assert");
+const { mkdtempSync } = require("node:fs");
+const { tmpdir } = require("node:os");
+const { join } = require("node:path");
+
+const { Workspace } = require("wative-core");
+
+test("logger — write at every level + change minLevel at runtime", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-logger-write-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  ws.logger.trace("trace event", { phase: "init" });
+  ws.logger.debug("debug event", { phase: "init" });
+  ws.logger.info("info event", { phase: "init" });
+  ws.logger.warn("warn event", { phase: "init" });
+  ws.logger.error("error event", { phase: "init" });
+
+  await ws.logger.setLevel("warn");
+  assert.strictEqual(ws.logger.config.minLevel, "warn");
+
+  ws.logger.warn("still works");
+  ws.logger.info("filtered out below minLevel");
+
+  await ws.lock();
+});
+
+test("logger — config persists across reopen", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-logger-persist-"));
+  let ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  await ws.logger.setLevel("error");
+  assert.strictEqual(ws.logger.config.minLevel, "error");
+
+  await ws.lock();
+  ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+  assert.strictEqual(ws.logger.config.minLevel, "error");
+
+  await ws.lock();
+});

package/tests/13-workspace-config.test.cjs

@@ -0,0 +1,43 @@
+// 13 — Workspace config public API. Consumers should never need Provider
+// record access to update business-wide settings.
+
+const test = require("node:test");
+const assert = require("node:assert");
+const { mkdtempSync } = require("node:fs");
+const { tmpdir } = require("node:os");
+const { join } = require("node:path");
+
+const { Workspace } = require("wative-core");
+
+test("workspace config — setBusinessTimezone/getConfig work from release dist", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-config-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  await ws.setBusinessTimezone("UTC");
+  assert.deepStrictEqual(await ws.getConfig(), { businessTimezone: "UTC" });
+
+  await ws.setBusinessTimezone("Etc/UTC");
+  assert.deepStrictEqual(await ws.getConfig(), { businessTimezone: "Etc/UTC" });
+
+  await assert.rejects(ws.setBusinessTimezone("Not/AZone"), (err) => (
+    err.code === "PARAMETER_ERROR"
+    && /INVALID_BUSINESS_TIMEZONE/.test(err.message)
+    && !err.message.includes("Not/AZone")
+  ));
+
+  // `config` hands back a frozen snapshot, not the live object. Assigning to it
+  // does not change the workspace — read config through `config` / `getConfig()`
+  // and change it through the setters.
+  const snapshot = ws.config;
+  assert.strictEqual(Object.isFrozen(snapshot), true);
+  snapshot.settlementWindow = "ny-close";
+  assert.strictEqual(snapshot.settlementWindow, undefined);
+
+  await ws.setBusinessTimezone("America/New_York");
+  assert.deepStrictEqual(await ws.getConfig(), { businessTimezone: "America/New_York" });
+
+  assert.strictEqual(Object.prototype.hasOwnProperty.call(ws, "_provider"), false);
+  assert.strictEqual("_provider" in ws, false);
+
+  await ws.lock();
+});

package/tests/14-esm-runtime.test.mjs

@@ -0,0 +1,81 @@
+import assert from "node:assert/strict";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+
+async function importDist() {
+  // Import by PACKAGE SPECIFIER, not by file path. The root entry is
+  // condition-split: a raw path to dist/index.js bypasses the exports map and
+  // lands on the browser build, which deliberately has no filesystem backend.
+  // "wative-core" resolves through the node condition, which is what an ESM
+  // consumer actually gets — and still loads real ESM, so this keeps testing
+  // that the dist needs no CJS require shims.
+  return import("wative-core");
+}
+
+const PASSWORD = "wsp-pwd";
+const MNEMONIC = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
+const EVM_PK = "0x4f3edf983ac636a65a842ce7c78d9aa706d3b113bce9c46f30d7d21715b23b1d";
+
+test("ESM dist consumer creates HD and PK accounts without global require shims", async () => {
+  const { Workspace } = await importDist();
+  assert.equal(globalThis.require, undefined);
+  const root = await mkdtemp(path.join(tmpdir(), "wative-core-esm-runtime-"));
+  const ws = await Workspace.open({ path: root, password: PASSWORD });
+
+  const hd = await ws.accounts.create("ESM HD", PASSWORD, MNEMONIC, undefined, { kind: "HD" });
+  const pk = await ws.accounts.create("ESM PK", PASSWORD, EVM_PK, undefined, { kind: "PK" });
+
+  assert.equal(hd.organizationType, "HD");
+  assert.equal(pk.organizationType, "PK");
+});
+
+test("ESM dist consumer signs EVM transactions without global require shims", async () => {
+  const { Workspace } = await importDist();
+  assert.equal(globalThis.require, undefined);
+  const root = await mkdtemp(path.join(tmpdir(), "wative-core-esm-tx-sign-"));
+  const ws = await Workspace.open({ path: root, password: PASSWORD });
+  const account = await ws.accounts.create("ESM TX PK", PASSWORD, EVM_PK, undefined, { kind: "PK" });
+  await account.tryUnlock(PASSWORD);
+  const address = account.wallets[0].addresses.find((candidate) => candidate.vm === "evm");
+
+  const tx = address.buildTransaction({
+    to: "0x000000000000000000000000000000000000dEaD",
+    value: "0",
+    nonce: 0,
+    chainId: 1,
+    gasLimit: "21000",
+    maxFeePerGas: "2000000000",
+    maxPriorityFeePerGas: "1000000000",
+  });
+  await tx.sign();
+
+  assert.match(tx.rawTransaction, /^0x[0-9a-fA-F]+$/);
+});
+
+test("ESM dist consumer signs SVM transactions without global require shims", async () => {
+  // Regression: the SVM signing path used require() for @solana/web3.js, bs58
+  // and tweetnacl, which throws "Dynamic require ... is not supported" under
+  // native ESM. These are now static imports like web3 on the EVM side.
+  const { Workspace } = await importDist();
+  assert.equal(globalThis.require, undefined);
+  const root = await mkdtemp(path.join(tmpdir(), "wative-core-esm-svm-sign-"));
+  const ws = await Workspace.open({ path: root, password: PASSWORD });
+  const account = await ws.accounts.create("ESM SVM HD", PASSWORD, MNEMONIC, undefined, { kind: "HD" });
+  await account.tryUnlock(PASSWORD);
+  const svm = account.wallets[0].addresses.find((candidate) => candidate.vm === "svm");
+  assert.ok(svm, "wallet exposes an SVM address");
+
+  const tx = svm.buildTransaction({
+    recipient: "11111111111111111111111111111111",
+    amount: "1000000",
+    recentBlockhash: "11111111111111111111111111111111",
+  });
+  await tx.sign();
+  assert.equal(tx.status, "signed");
+  assert.ok(typeof tx.hash === "string" && tx.hash.length > 0);
+});