@mingderwang/wallet 0.1.0 → 0.1.1

package/package.json

@@ -1,15 +1,18 @@
 {
-  "name": "@mingderwang/wallet",
-  "version": "0.1.0",
-  "description": "Encrypted Ethereum keystore (scrypt + AES-256-GCM) and wallet signing helpers.",
+"name": "@mingderwang/wallet",
+  "version": "0.1.1",
+  "description": "Ethereum wallet + encrypted keystore helpers (scrypt + AES-256-GCM) built on ethers v6.",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
   },
-  "files": ["dist", "README.md"],
+  "files": ["dist", "src", "README.md"],
   "engines": {
     "node": ">=18.0.0"
   },

package/src/index.ts

@@ -0,0 +1,105 @@
+import { readFileSync, writeFileSync, mkdirSync, rmSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { Wallet, HDNodeWallet } from 'ethers';
+import {
+  encryptPrivateKey,
+  decryptPrivateKey,
+  verifyPassword,
+  randomBytesHex,
+  type EncryptedKeystore,
+} from './keystore';
+
+export { encryptPrivateKey, decryptPrivateKey, verifyPassword, randomBytesHex };
+export type { EncryptedKeystore };
+
+export const NETWORKS = {
+  ethereumMainnet: { networkId: 'ethereum-mainnet', chainId: 1 },
+  ethereumSepolia: { networkId: 'ethereum-sepolia', chainId: 11155111 },
+  base: { networkId: 'base', chainId: 8453 },
+  baseSepolia: { networkId: 'base-sepolia', chainId: 84532 },
+} as const;
+
+export const USDC: Record<string, { address: string; decimals: number; symbol: string }> = {
+  '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' },
+};
+
+export function rpcUrl(networkId: string): string {
+  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}`);
+  }
+}
+
+export type SigningWallet = Wallet | HDNodeWallet;
+
+export function createWallet(): { wallet: HDNodeWallet; privateKey: string; address: string } {
+  const wallet = Wallet.createRandom();
+  return { wallet, privateKey: wallet.privateKey, address: wallet.address };
+}
+
+export function importWallet(secret: string): { wallet: SigningWallet; privateKey: string; address: string } {
+  const wallet: SigningWallet = /^[a-f0-9]{64}$/i.test(secret.replace(/^0x/, ''))
+    ? new Wallet(secret)
+    : Wallet.fromPhrase(secret);
+  return { wallet, privateKey: wallet.privateKey, address: wallet.address };
+}
+
+export function loadWallet(keystore: EncryptedKeystore, password: string): Wallet {
+  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;
+}
+
+export function saveKeystore(keystore: EncryptedKeystore, path: string): void {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(keystore, null, 2), { mode: 0o600 });
+}
+
+export function readKeystore(path: string): EncryptedKeystore {
+  return JSON.parse(readFileSync(path, 'utf8')) as EncryptedKeystore;
+}
+
+export function deleteFile(path: string): void {
+  rmSync(path, { force: true });
+}
+
+export async function getBalances(walletOrAddress: string | Wallet, networkId: string): Promise<{ eth: string; usdc: string }> {
+  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 as unknown as { balanceOf: (a: string) => Promise<bigint> }).balanceOf;
+    usdcBalance = await balanceOf(address);
+  }
+  return { eth: eth.toString(), usdc: usdcBalance.toString() };
+}
+
+export function formatAmount(amountWei: bigint | string | number, decimals: number): string {
+  return (Number(amountWei) / 10 ** decimals).toFixed(decimals);
+}
+
+const 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)',
+] as const;

package/src/keystore.ts

@@ -0,0 +1,101 @@
+import { randomBytes, randomUUID, scryptSync, createCipheriv, createDecipheriv } from 'node:crypto';
+
+export interface EncryptedKeystore {
+  version: 1;
+  id: string;
+  type: 'scrypt-aes-256-gcm';
+  params: {
+    n: number;
+    r: number;
+    p: number;
+    dkLen: number;
+    salt: string; // hex
+    iv: string; // hex
+    tag: string; // hex
+  };
+  ciphertext: string; // hex
+  address: string;
+}
+
+const PARAMS = { n: 2 ** 15, r: 8, p: 1, dkLen: 32 };
+
+// Coerce the (pre-generics) Buffer type into the stricter Uint8Array<ArrayBufferLike>
+// the current node crypto typings demand. Runtime-identical to the input buffer.
+function bytes(b: Buffer): Uint8Array<ArrayBufferLike> {
+  return b as unknown as Uint8Array<ArrayBufferLike>;
+}
+
+function deriveKey(password: string, salt: Buffer): Buffer {
+  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: Buffer): string {
+  return buf.toString('hex');
+}
+
+export function encryptPrivateKey(privateKey: string, password: string, address: string): EncryptedKeystore {
+  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()] as unknown as Uint8Array<ArrayBufferLike>[]);
+  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,
+  };
+}
+
+export function decryptPrivateKey(keystore: EncryptedKeystore, password: string): string {
+  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()] as unknown as Uint8Array<ArrayBufferLike>[]);
+    return '0x' + plain.toString('hex');
+  } catch {
+    throw new Error('Incorrect password or corrupted keystore.');
+  }
+}
+
+export function verifyPassword(keystore: EncryptedKeystore, password: string): boolean {
+  try {
+    decryptPrivateKey(keystore, password);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function bytesToHex(b: Uint8Array): string {
+  return '0x' + Buffer.from(b).toString('hex');
+}
+
+export function randomBytesHex(len = 32): string {
+  return '0x' + randomBytes(len).toString('hex');
+}