wative-core 1.2.2 → 2.2.0

package/package.json

@@ -1,58 +1,104 @@
 {
   "name": "wative-core",
-  "version": "1.2.2",
-  "description": "An agile keystore management toolkit",
-  "main": "lib/index.umd.js",
-  "module": "lib/index.esm.js",
-  "types": "lib/index.d.ts",
-  "scripts": {
-    "test": "jest",
-    "compile": "tsc",
-    "build": "rollup --config"
+  "version": "2.2.0",
+  "description": "Hyperscale crypto wallet management library — multi-workspace, multi-chain, originally designed for on-chain market makers",
+  "type": "module",
+  "main": "./dist/index.node.cjs",
+  "module": "./dist/index.node.js",
+  "types": "./dist/index.node.d.ts",
+  "exports": {
+    ".": {
+      "browser": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "node": {
+        "import": {
+          "types": "./dist/index.node.d.ts",
+          "default": "./dist/index.node.js"
+        },
+        "require": {
+          "types": "./dist/index.node.d.cts",
+          "default": "./dist/index.node.cjs"
+        }
+      },
+      "default": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./node": {
+      "import": {
+        "types": "./dist/node/index.d.ts",
+        "default": "./dist/node/index.js"
+      },
+      "require": {
+        "types": "./dist/node/index.d.cts",
+        "default": "./dist/node/index.cjs"
+      }
+    },
+    "./artifacts/evm": {
+      "import": {
+        "types": "./dist/artifacts/evm/index.d.ts",
+        "default": "./dist/artifacts/evm/index.js"
+      },
+      "require": {
+        "types": "./dist/artifacts/evm/index.d.cts",
+        "default": "./dist/artifacts/evm/index.cjs"
+      }
+    },
+    "./artifacts/svm": {
+      "import": {
+        "types": "./dist/artifacts/svm/index.d.ts",
+        "default": "./dist/artifacts/svm/index.js"
+      },
+      "require": {
+        "types": "./dist/artifacts/svm/index.d.cts",
+        "default": "./dist/artifacts/svm/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=22.12"
   },
   "repository": {
     "type": "git",
-    "url": ""
+    "url": "git+https://github.com/braady/wative-core.git"
   },
   "bugs": {
-    "url": "https://github.com"
+    "url": "https://github.com/braady/wative-core/issues"
   },
-  "homepage": "https://github.com",
+  "homepage": "https://github.com/braady/wative-core#readme",
   "keywords": [
+    "wallet",
     "keystore",
-    "wallet"
+    "ethereum",
+    "evm",
+    "solana",
+    "svm",
+    "crypto",
+    "hd-wallet",
+    "multi-account"
   ],
-  "author": "",
-  "license": "ISC",
+  "author": "Brady <brady.c@hedgue.com>",
+  "license": "SEE LICENSE IN LICENSE",
   "files": [
-    "src/",
-    "lib/"
+    "dist/",
+    "CHANGELOG.md",
+    "tests/"
   ],
   "dependencies": {
     "@coral-xyz/anchor": "0.30.1",
-    "@solana/web3.js": "1.91.8",
-    "crypto-js": "4.2.0",
-    "ethereumjs-wallet": "1.0.2",
+    "@noble/ciphers": "^2.2.0",
+    "@noble/curves": "^1.9.7",
+    "@noble/hashes": "^1.8.0",
+    "@scure/bip39": "^2.2.0",
+    "@solana/web3.js": "1.98.4",
+    "bs58": "5.0.0",
+    "ethers": "6.17.0",
     "micro-ed25519-hdkey": "0.1.2",
-    "rpc-websockets": "7.10.0",
     "tslib": "2.6.2",
-    "tweetnacl": "1.0.3",
-    "web3": "1.7.3",
-    "web3-core": "4.3.2"
-  },
-  "devDependencies": {
-    "@babel/plugin-transform-modules-commonjs": "7.24.1",
-    "@rollup/plugin-commonjs": "21.0.1",
-    "rollup": "2.79.1",
-    "rollup-plugin-terser": "7.0.2",
-    "rollup-plugin-typescript2": "0.31.2",
-    "typescript": "4.9.5",
-    "jest": "27.5.1",
-    "@types/node": "24.2.0",
-    "@types/bs58": "4.0.4",
-    "@types/crypto-js": "4.2.2"
-  },
-  "optionalDependencies": {
-    "nodejs-threadpool": "1.0.1"
+    "tweetnacl": "1.0.3"
   }
 }

package/tests/01-quick-start.test.cjs

@@ -0,0 +1,37 @@
+// 01 — Quick start. Open a workspace, create an HD account, derive wallets,
+// lock down. The shortest end-to-end demo.
+
+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("quick start — open, create HD account, derive wallets, lock", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-quickstart-"));
+  const password = "your-workspace-password";
+
+  const ws = await Workspace.open({ path: root, password });
+  assert.strictEqual(ws.locked, false);
+
+  const account = await ws.accounts.create(
+    "Trading Desk",
+    password,
+    "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
+  );
+  assert.strictEqual(account.wallets.length, 1);
+
+  await account.deriveWallets(4);
+  assert.strictEqual(account.wallets.length, 5);
+
+  const wallet = account.wallets[0];
+  const evm = wallet.addresses.find((a) => a.vm === "evm");
+  const svm = wallet.addresses.find((a) => a.vm === "svm");
+  assert.ok(evm && evm.publicKey.startsWith("0x"));
+  assert.ok(svm && svm.publicKey.length >= 32);
+
+  await ws.lock();
+  assert.strictEqual(ws.locked, true);
+});

package/tests/02-hd-account.test.cjs

@@ -0,0 +1,71 @@
+// 02 — HD account flows. derive / slice wallets, dump mnemonic, reset password,
+// reopen a locked workspace.
+
+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("HD account — derive, slice, dump mnemonic", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-hd-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const acc = await ws.accounts.create("Desk", "wsp-pwd", MNEMONIC);
+  await acc.deriveWallets(10);
+  assert.strictEqual(acc.wallets.length, 11);
+
+  await acc.sliceWallets(6);
+  assert.strictEqual(acc.wallets.length, 6);
+
+  assert.strictEqual(acc.dumpMnemonic(), MNEMONIC);
+
+  await ws.lock();
+});
+
+test("HD account — own password + resetPassword", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-hd-pwd-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const sub = await ws.accounts.create("SubAccount", "sub-pwd", MNEMONIC, undefined, {
+    hasOwnPassword: true,
+  });
+  assert.strictEqual(sub.locked, false);
+
+  sub.lock();
+  assert.strictEqual(sub.locked, true);
+
+  await assert.rejects(sub.tryUnlock("wrong"), (err) => err.code === "BAD_PASSWORD");
+  await sub.tryUnlock("sub-pwd");
+
+  await sub.resetPassword("sub-pwd", "new-sub-pwd");
+  sub.lock();
+  await assert.rejects(sub.tryUnlock("sub-pwd"), (err) => err.code === "BAD_PASSWORD");
+  await sub.tryUnlock("new-sub-pwd");
+
+  await ws.lock();
+});
+
+test("HD account — round-trip across lock + reopen", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-hd-reopen-"));
+  let ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const acc = await ws.accounts.create("Persistent", "wsp-pwd", MNEMONIC);
+  await acc.deriveWallets(2);
+  const firstAddr = acc.wallets[0].addresses[0].publicKey;
+
+  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.wallets.length, 3);
+  assert.strictEqual(reopened.wallets[0].addresses[0].publicKey, firstAddr);
+
+  await ws.lock();
+});

package/tests/03-pk-account.test.cjs

@@ -0,0 +1,59 @@
+// 03 — PK account flows. Heterogeneous private keys, one wallet per import.
+
+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 EVM_PK = "0x4f3edf983ac636a65a842ce7c78d9aa706d3b113bce9c46f30d7d21715b23b1d";
+const SVM_PK = "xtGWcHvQsr5ue8zG2F5fm31bW8vyn597Y92gUWaZZg3S1Z6FeJMATL8KU3xJMGbLfALnokcct9y5wYtCRrwNXZW";
+
+test("PK account — create from EVM key + import a Solana key", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-pk-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const acc = await ws.accounts.create(
+    "External Hot Wallet",
+    "wsp-pwd",
+    EVM_PK,
+    undefined,
+    { kind: "PK" },
+  );
+  assert.strictEqual(acc.organizationType, "PK");
+  assert.strictEqual(acc.wallets.length, 1);
+  assert.strictEqual(acc.wallets[0].addresses[0].vm, "evm");
+
+  await acc.importPrivateKey(SVM_PK, "svm");
+  assert.strictEqual(acc.wallets.length, 2);
+  assert.strictEqual(acc.wallets[1].addresses[0].vm, "svm");
+
+  await ws.lock();
+});
+
+test("PK account — duplicate import is rejected", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-pk-dup-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const acc = await ws.accounts.create("HotWallet", "wsp-pwd", EVM_PK, undefined, { kind: "PK" });
+  await assert.rejects(acc.importPrivateKey(EVM_PK, "evm"), (err) => err.code === "PARAMETER_ERROR");
+
+  await ws.lock();
+});
+
+test("PK account — drop a wallet (account keeps at least one)", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-pk-drop-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const acc = await ws.accounts.create("HotWallet", "wsp-pwd", EVM_PK, undefined, { kind: "PK" });
+  await acc.importPrivateKey(SVM_PK, "svm");
+
+  await acc.wallets.drop(acc.wallets[1]);
+  assert.strictEqual(acc.wallets.length, 1);
+
+  await assert.rejects(acc.wallets.drop(acc.wallets[0]), (err) => err.code === "UNSUPPORTED_OP");
+
+  await ws.lock();
+});

package/tests/04-network-management.test.cjs

@@ -0,0 +1,94 @@
+// 04 — Network management. Pre-loaded networks, add custom networks,
+// override an existing network's RPC URL, drop user networks.
+
+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");
+
+test("network — 10 pre-loaded networks ship at workspace open", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-net-builtin-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const slugs = ws.networks.map((n) => n.slug).sort();
+  assert.deepStrictEqual(slugs, [
+    "arbitrum", "arbitrum-sepolia", "base", "bnbchain", "ethereum", "optimism",
+    "sepolia", "solana", "solana-devnet", "solana-testnet",
+  ]);
+
+  assert.strictEqual(Network.ArbitrumSepolia.chainId, 421614);
+  assert.strictEqual(Network.Ethereum.chainId, 1);
+  assert.strictEqual(Network.Solana.vm, "svm");
+  assert.strictEqual(ws.networks.bySlug("ethereum").chainId, 1);
+  assert.strictEqual(ws.networks.bySlug("arbitrum-sepolia").vm, "evm");
+  assert.strictEqual(ws.networks.byChainId(8453).slug, "base");
+
+  await ws.lock();
+});
+
+test("network — add a brand-new user network", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-net-add-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const monad = new Network({
+    slug: "monad-testnet",
+    name: "Monad Testnet",
+    chainId: 10143,
+    rpcUrl: "https://testnet-rpc.monad.xyz",
+    nativeCurrency: { name: "Monad", symbol: "MON", decimals: 18 },
+    vm: "evm",
+  });
+  await ws.networks.add(monad);
+
+  assert.strictEqual(ws.networks.length, 11);
+  assert.strictEqual(ws.networks.bySlug("monad-testnet").chainId, 10143);
+  await assert.rejects(ws.networks.add(monad), (err) => err.code === "PARAMETER_ERROR");
+
+  await ws.lock();
+});
+
+test("network — override a pre-loaded RPC URL via update()", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-net-override-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const eth = ws.networks.bySlug("ethereum");
+  const customEth = new Network({
+    ...eth,
+    rpcUrl: "https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY",
+  });
+  await ws.networks.update(customEth);
+
+  assert.strictEqual(
+    ws.networks.bySlug("ethereum").rpcUrl,
+    "https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY",
+  );
+  assert.strictEqual(ws.networks.length, 10);
+
+  await ws.lock();
+});
+
+test("network — drop user network; pre-loaded networks reject drop", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-net-drop-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const custom = new Network({
+    slug: "my-net",
+    name: "My Net",
+    chainId: 99999,
+    rpcUrl: "https://rpc.example",
+    nativeCurrency: { name: "Foo", symbol: "FOO", decimals: 18 },
+    vm: "evm",
+  });
+  await ws.networks.add(custom);
+
+  await ws.networks.drop(custom);
+  assert.strictEqual(ws.networks.bySlug("my-net"), null);
+
+  const eth = ws.networks.bySlug("ethereum");
+  await assert.rejects(ws.networks.drop(eth), (err) => err.code === "UNSUPPORTED_OP");
+
+  await ws.lock();
+});

package/tests/05-asset-management.test.cjs

@@ -0,0 +1,117 @@
+// 05 — Asset management. Pre-loaded tokens, add custom tokens,
+// drop user tokens, search via filter.
+
+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");
+
+test("asset — pre-loaded tokens per network", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-asset-builtin-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const ethAssets = await ws.assets(Network.Ethereum);
+  assert.deepStrictEqual(ethAssets.map((a) => a.symbol).sort(), ["ETH", "USDC", "USDT", "WETH"]);
+
+  const solAssets = await ws.assets(Network.Solana);
+  assert.deepStrictEqual(solAssets.map((a) => a.symbol).sort(), ["SOL", "USDC", "USDT", "WSOL"]);
+
+  const sepoliaAssets = await ws.assets("sepolia");
+  assert.strictEqual(sepoliaAssets.length, 1);
+
+  const arbSepoliaAssets = await ws.assets("arbitrum-sepolia");
+  const arbSepoliaUsdc = arbSepoliaAssets.find((a) => a.symbol === "USDC");
+  assert.ok(arbSepoliaUsdc);
+  assert.strictEqual(arbSepoliaUsdc.decimals, 6);
+  assert.strictEqual(arbSepoliaUsdc.contractAddress, "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d");
+  assert.strictEqual(arbSepoliaUsdc.native, false);
+
+  await ws.lock();
+});
+
+test("asset — add a custom user token", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-asset-add-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const pepe = new Asset({
+    id: 200,
+    symbol: "PEPE",
+    name: "Pepe",
+    decimals: 18,
+    contractAddress: "0x6982508145454Ce325dDbE47a25d4ec3d2311933",
+    network: Network.Ethereum,
+  });
+  await ws.addAsset(pepe);
+
+  const ethAssets = await ws.assets(Network.Ethereum);
+  assert.strictEqual(ethAssets.length, 5);
+  assert.ok(ethAssets.some((a) => a.id === 200 && a.symbol === "PEPE"));
+
+  await ws.lock();
+});
+
+test("asset — id and address collisions are rejected", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-asset-collide-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const dupId = new Asset({
+    id: 1,
+    symbol: "FAKE",
+    name: "Fake",
+    decimals: 18,
+    contractAddress: "0x1234567890123456789012345678901234567890",
+    network: Network.Ethereum,
+  });
+  await assert.rejects(ws.addAsset(dupId), (err) => err.code === "PARAMETER_ERROR");
+
+  const dupAddr = new Asset({
+    id: 201,
+    symbol: "USDC2",
+    name: "Other USDC",
+    decimals: 6,
+    contractAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    network: Network.Ethereum,
+  });
+  await assert.rejects(ws.addAsset(dupAddr), (err) => err.code === "PARAMETER_ERROR");
+
+  await ws.lock();
+});
+
+test("asset — drop user token; pre-loaded tokens reject drop", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-asset-drop-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const my = new Asset({
+    id: 300,
+    symbol: "MINE",
+    name: "Mine",
+    decimals: 18,
+    contractAddress: "0x1111111111111111111111111111111111111111",
+    network: Network.Ethereum,
+  });
+  await ws.addAsset(my);
+  await ws.dropAsset(300);
+
+  const ethAssets = await ws.assets(Network.Ethereum);
+  assert.ok(!ethAssets.some((a) => a.id === 300));
+
+  await assert.rejects(ws.dropAsset(1), (err) => err.code === "UNSUPPORTED_OP");
+
+  await ws.lock();
+});
+
+test("asset — workspace.filter('Asset', q) finds by symbol or contract address", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-asset-filter-"));
+  const ws = await Workspace.open({ path: root, password: "wsp-pwd" });
+
+  const bySymbol = await ws.filter("USDC", "Asset");
+  assert.ok(bySymbol && bySymbol.symbol === "USDC");
+
+  const byAddr = await ws.filter("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", "Asset");
+  assert.ok(byAddr && byAddr.symbol === "USDC");
+
+  await ws.lock();
+});

package/tests/06-address-signing.test.cjs

@@ -0,0 +1,55 @@
+// 06 — Address signing. Sign personal messages and build transactions
+// fully offline.
+
+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("address — signMessage on EVM and SVM", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-sign-msg-"));
+  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 svm = acc.wallets[0].addresses.find((a) => a.vm === "svm");
+
+  const evmSig = evm.signMessage("hello");
+  const svmSig = svm.signMessage("hello");
+
+  assert.ok(typeof evmSig === "string" && evmSig.startsWith("0x"));
+  assert.ok(typeof svmSig === "string" && svmSig.length > 0);
+  assert.notStrictEqual(evmSig, svmSig);
+
+  await ws.lock();
+});
+
+test("address — buildTransaction convenience helper (offline)", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wative-build-tx-"));
+  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 tx = await evm.buildTransaction({
+    to: "0x1234567890123456789012345678901234567890",
+    value: 1_000_000_000_000_000n,
+    chainId: 1,
+    nonce: 0,
+    gasLimit: 21000n,
+    maxFeePerGas: 50_000_000_000n,
+    maxPriorityFeePerGas: 1_000_000_000n,
+    type: 2,
+    network: Network.Ethereum,
+  });
+
+  assert.strictEqual(tx.from.toLowerCase(), evm.publicKey.toLowerCase());
+
+  await ws.lock();
+});