@mingderwang/wallet 0.1.0

package/README.md

@@ -0,0 +1,33 @@
+# @mingderwang/wallet
+
+Ethereum wallet + encrypted keystore helpers for Node.js, built on ethers v6.
+
+- Create / import / load wallets (private key + mnemonic)
+- Encrypted keystore: scrypt (N=2^15, r=8, p=1) + AES-256-GCM, stored at a path of your choice
+- Balances for ETH + USDC on `ethereum-sepolia`, `ethereum-mainnet`, `base-sepolia`, `base`
+- Default per-network public RPCs; override any with `X402_RPC_URL`
+
+Used by `@mingderwang/xsift` and `@mingderwang/x402`.
+
+## Install
+
+```bash
+npm install @mingderwang/wallet
+```
+
+## Usage
+
+```ts
+import { createWallet, encryptPrivateKey, saveKeystore, loadWallet, readKeystore, getBalances } from '@mingderwang/wallet';
+
+const { wallet, privateKey, address } = createWallet();
+const keystore = encryptPrivateKey(privateKey, 's3cret', address);
+saveKeystore(keystore, '~/.xsift/wallet.json');
+
+const loaded = loadWallet(readKeystore('~/.xsift/wallet.json'), 's3cret');
+const { eth, usdc } = await getBalances(loaded, 'ethereum-sepolia');
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from '../src/index';

package/dist/index.js

@@ -0,0 +1,175 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/index.ts
+import { readFileSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
+import { dirname } from "node:path";
+import { Wallet } from "ethers";
+
+// src/keystore.ts
+import { randomBytes, randomUUID, scryptSync, createCipheriv, createDecipheriv } from "node:crypto";
+var PARAMS = { n: 2 ** 15, r: 8, p: 1, dkLen: 32 };
+function bytes(b) {
+  return b;
+}
+function deriveKey(password, salt) {
+  return scryptSync(password, bytes(salt), PARAMS.dkLen, {
+    N: PARAMS.n,
+    r: PARAMS.r,
+    p: PARAMS.p,
+    maxmem: 128 * PARAMS.n * PARAMS.r * 2
+  });
+}
+function hexString(buf) {
+  return buf.toString("hex");
+}
+function encryptPrivateKey(privateKey, password, address) {
+  const salt = randomBytes(16);
+  const iv = randomBytes(12);
+  const key = deriveKey(password, salt);
+  const cipher = createCipheriv("aes-256-gcm", bytes(key), bytes(iv));
+  const data = Buffer.from(privateKey.replace(/^0x/, ""), "hex");
+  const ciphertext = Buffer.concat([cipher.update(bytes(data)), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return {
+    version: 1,
+    id: randomUUID(),
+    type: "scrypt-aes-256-gcm",
+    params: {
+      n: PARAMS.n,
+      r: PARAMS.r,
+      p: PARAMS.p,
+      dkLen: PARAMS.dkLen,
+      salt: hexString(salt),
+      iv: hexString(iv),
+      tag: hexString(tag)
+    },
+    ciphertext: hexString(ciphertext),
+    address
+  };
+}
+function decryptPrivateKey(keystore, password) {
+  if (keystore.version !== 1 || keystore.type !== "scrypt-aes-256-gcm") {
+    throw new Error("Unsupported keystore format");
+  }
+  const salt = Buffer.from(keystore.params.salt, "hex");
+  const iv = Buffer.from(keystore.params.iv, "hex");
+  const tag = Buffer.from(keystore.params.tag, "hex");
+  const key = deriveKey(password, salt);
+  const decipher = createDecipheriv("aes-256-gcm", bytes(key), bytes(iv));
+  decipher.setAuthTag(bytes(tag));
+  try {
+    const data = Buffer.from(keystore.ciphertext, "hex");
+    const plain = Buffer.concat([decipher.update(bytes(data)), decipher.final()]);
+    return "0x" + plain.toString("hex");
+  } catch {
+    throw new Error("Incorrect password or corrupted keystore.");
+  }
+}
+function verifyPassword(keystore, password) {
+  try {
+    decryptPrivateKey(keystore, password);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function randomBytesHex(len = 32) {
+  return "0x" + randomBytes(len).toString("hex");
+}
+
+// src/index.ts
+var NETWORKS = {
+  ethereumMainnet: { networkId: "ethereum-mainnet", chainId: 1 },
+  ethereumSepolia: { networkId: "ethereum-sepolia", chainId: 11155111 },
+  base: { networkId: "base", chainId: 8453 },
+  baseSepolia: { networkId: "base-sepolia", chainId: 84532 }
+};
+var USDC = {
+  "ethereum-sepolia": { address: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238", decimals: 6, symbol: "USDC" },
+  "ethereum-mainnet": { address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", decimals: 6, symbol: "USDC" },
+  "base-sepolia": { address: "0x036CbD53842c5426634e7929541eC2318f3dCF7e", decimals: 6, symbol: "USDC" },
+  base: { address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", decimals: 6, symbol: "USDC" }
+};
+function rpcUrl(networkId) {
+  const fromEnv = process.env.X402_RPC_URL;
+  if (fromEnv)
+    return fromEnv;
+  switch (networkId) {
+    case "ethereum-sepolia":
+      return "https://ethereum-sepolia-rpc.publicnode.com";
+    case "ethereum-mainnet":
+      return "https://eth.llamarpc.com";
+    case "base-sepolia":
+      return "https://base-sepolia-rpc.publicnode.com";
+    case "base":
+      return "https://mainnet.base.org";
+    default:
+      throw new Error(`No default RPC for ${networkId}`);
+  }
+}
+function createWallet() {
+  const wallet = Wallet.createRandom();
+  return { wallet, privateKey: wallet.privateKey, address: wallet.address };
+}
+function importWallet(secret) {
+  const wallet = /^[a-f0-9]{64}$/i.test(secret.replace(/^0x/, "")) ? new Wallet(secret) : Wallet.fromPhrase(secret);
+  return { wallet, privateKey: wallet.privateKey, address: wallet.address };
+}
+function loadWallet(keystore, password) {
+  const privateKey = decryptPrivateKey(keystore, password);
+  const wallet = new Wallet(privateKey);
+  if (wallet.address.toLowerCase() !== keystore.address.toLowerCase()) {
+    throw new Error("Keystore address does not match its private key.");
+  }
+  return wallet;
+}
+function saveKeystore(keystore, path) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(keystore, null, 2), { mode: 384 });
+}
+function readKeystore(path) {
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+function deleteFile(path) {
+  rmSync(path, { force: true });
+}
+async function getBalances(walletOrAddress, networkId) {
+  const { JsonRpcProvider, Contract } = await import("ethers");
+  const provider = new JsonRpcProvider(rpcUrl(networkId));
+  const address = typeof walletOrAddress === "string" ? walletOrAddress : walletOrAddress.address;
+  const usdc = USDC[networkId];
+  const eth = await provider.getBalance(address);
+  let usdcBalance = 0n;
+  if (usdc) {
+    const contract = new Contract(usdc.address, ERC20_ABI, provider);
+    const balanceOf = contract.balanceOf;
+    usdcBalance = await balanceOf(address);
+  }
+  return { eth: eth.toString(), usdc: usdcBalance.toString() };
+}
+function formatAmount(amountWei, decimals) {
+  return (Number(amountWei) / 10 ** decimals).toFixed(decimals);
+}
+var ERC20_ABI = [
+  "function balanceOf(address) view returns (uint256)",
+  "function transferWithAuthorization(address from, address to, uint256 value, uint256 validAfter, uint256 validBefore, bytes32 nonce)",
+  "function nonces(address) view returns (uint256)"
+];
+export {
+  verifyPassword,
+  saveKeystore,
+  rpcUrl,
+  readKeystore,
+  randomBytesHex,
+  loadWallet,
+  importWallet,
+  getBalances,
+  formatAmount,
+  encryptPrivateKey,
+  deleteFile,
+  decryptPrivateKey,
+  createWallet,
+  USDC,
+  NETWORKS
+};

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@mingderwang/wallet",
+  "version": "0.1.0",
+  "description": "Encrypted Ethereum keystore (scrypt + AES-256-GCM) and wallet signing helpers.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": ["dist", "README.md"],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "node ./scripts/build.mjs"
+  },
+  "dependencies": {
+    "ethers": "^6.13.4"
+  },
+  "keywords": ["ethereum", "wallet", "keystore", "usdc", "eip-3009"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mingderwang/network-vulnerability-scanner.git"
+  }
+}