@shipooor/walletauth 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 walletauth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,300 @@
+# @shipooor/walletauth
+
+Your wallet is your API key. Agent-native auth for APIs.
+
+## What
+
+Lightweight, framework-agnostic auth library that replaces API keys with wallet signatures.
+Zero config for agents. Full control for API owners.
+
+```
+Agent has wallet → requests challenge → signs nonce → gets JWT → calls API
+No registration. No API keys. No rotation.
+```
+
+## Why
+
+| Problem | Wallet Auth |
+|---|---|
+| API keys are manual (generate, copy, rotate) | Wallet = identity, automatic |
+| One key = all agents (no granularity) | Each agent = own wallet = own identity |
+| Keys leak, get stolen, expire | Private key never leaves the agent |
+| Auth0/OAuth2 designed for humans | Agent-native, no human in the loop |
+
+## How it works
+
+```
+┌─────────────────────────────────┐
+│  AI Agent (any framework)       │
+│  Has a wallet / keypair         │
+└──────────┬──────────────────────┘
+           │ 1. POST /auth/challenge { address }
+           │ 2. Server returns { nonce, challenge, expiresAt }
+           │ 3. Agent signs nonce with private key
+           │ 4. POST /auth/verify { address, signature, challenge }
+           │ 5. Server verifies HMAC + wallet signature → JWT
+           ↓
+┌──────────────────────────────────┐
+│  Your API + @shipooor/walletauth   │
+│                                   │
+│  ├─ Stateless challenge/verify   │
+│  ├─ HMAC-signed challenges       │
+│  ├─ Signature verification       │
+│  └─ JWT issuance & validation    │
+└───────────────────────────────────┘
+```
+
+### Stateless by design
+
+Challenges are HMAC-signed — the server verifies its own signature on return. No nonce storage, no database, no Redis. Truly stateless.
+
+## Install
+
+```bash
+npm install @shipooor/walletauth
+```
+
+## Core API
+
+Pure functions. No framework dependency. Use with Express, NestJS, Fastify, Hono, or anything else.
+
+```typescript
+import {
+  createChallenge,
+  verifySignature,
+  issueToken,
+  validateToken,
+  verifiers,
+} from '@shipooor/walletauth';
+```
+
+| Function | Description |
+|---|---|
+| `createChallenge(address, secret)` | Generate a stateless HMAC-signed challenge |
+| `verifySignature(address, signature, challenge, secret, verifier)` | Verify HMAC + wallet signature. **async** |
+| `issueToken(address, secret, options?)` | Issue a JWT for the verified address. **async** |
+| `validateToken(token, secret)` | Validate JWT, return `{ address }` or `null`. **async** |
+| `verifiers.evm` | EVM signature verifier (secp256k1) |
+| `verifiers.ed25519` | Ed25519 verifier (Solana, raw keys) |
+
+> `verifySignature`, `issueToken`, and `validateToken` return Promises — always `await` them.
+
+## Built-in verifiers
+
+All chains supported in one lightweight package (~7KB ESM). No ethers.js, no heavy deps.
+
+| Chain | Verifier | Crypto | Dep |
+|---|---|---|---|
+| EVM (Ethereum, Arbitrum, Base, etc.) | `verifiers.evm` | secp256k1 + keccak256 | `@noble/curves` + `@noble/hashes` |
+| Solana | `verifiers.ed25519` | ed25519 | Node.js built-in `crypto` |
+| Raw ed25519 keypair | `verifiers.ed25519` | ed25519 | Node.js built-in `crypto` |
+| Custom | `(addr, msg, sig) => boolean \| Promise<boolean>` | Any | Bring your own |
+
+Multiple verifiers supported — pass an array for multi-chain APIs:
+
+```typescript
+verifySignature(address, signature, challenge, secret, [verifiers.evm, verifiers.ed25519])
+```
+
+Each verifier is tried in order. First `true` wins. Cryptographically safe — a secp256k1 signature can't accidentally pass ed25519 verification.
+
+## Usage: Express
+
+```typescript
+import express from 'express';
+import { createChallenge, verifySignature, issueToken, validateToken, verifiers } from '@shipooor/walletauth';
+
+const app = express();
+app.use(express.json());
+
+const SECRET = process.env.WALLETAUTH_SECRET; // Used for both HMAC challenges and JWT signing
+
+// Step 1: Agent requests a challenge
+app.post('/auth/challenge', (req, res) => {
+  const challenge = createChallenge(req.body.address, SECRET);
+  res.json(challenge);  // { nonce, challenge, expiresAt }
+});
+
+// Step 2: Agent signs nonce and sends back
+app.post('/auth/verify', async (req, res) => {
+  const { address, signature, challenge } = req.body;
+  const valid = await verifySignature(address, signature, challenge, SECRET, verifiers.evm);
+  if (!valid) return res.status(401).json({ error: 'Invalid signature' });
+
+  const token = await issueToken(address, SECRET);
+  res.json({ token });
+});
+
+// Middleware: protect routes
+async function authMiddleware(req, res, next) {
+  const token = req.headers.authorization?.split(' ')[1];
+  const payload = await validateToken(token, SECRET);
+  if (!payload) return res.status(401).json({ error: 'Invalid token' });
+  req.wallet = payload.address;
+  next();
+}
+
+// Protected route
+app.get('/api/data', authMiddleware, (req, res) => {
+  res.json({ wallet: req.wallet, data: '...' });
+});
+```
+
+## Usage: NestJS
+
+```typescript
+import { Injectable, CanActivate, ExecutionContext, createParamDecorator } from '@nestjs/common';
+import { validateToken } from '@shipooor/walletauth';
+
+@Injectable()
+export class WalletAuthGuard implements CanActivate {
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const request = context.switchToHttp().getRequest();
+    const token = request.headers.authorization?.split(' ')[1];
+    const payload = await validateToken(token, process.env.WALLETAUTH_SECRET);
+    if (!payload) return false;
+    request.wallet = payload.address;
+    return true;
+  }
+}
+
+export const WalletAddress = createParamDecorator(
+  (_data: unknown, ctx: ExecutionContext) => ctx.switchToHttp().getRequest().wallet,
+);
+
+// Usage in controller:
+// @UseGuards(WalletAuthGuard)
+// @Get('data')
+// getData(@WalletAddress() wallet: string) { ... }
+```
+
+## Usage: Client (any wallet)
+
+```typescript
+// EVM wallet (MetaMask, WDK, Coinbase CDP, etc.)
+const res = await fetch('/auth/challenge', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({ address: wallet.address }),
+}).then(r => r.json());
+
+const signature = await wallet.signMessage(res.nonce);
+
+const { token } = await fetch('/auth/verify', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({ address: wallet.address, signature, challenge: res.challenge }),
+}).then(r => r.json());
+
+// Use token for all subsequent requests
+fetch('/api/data', { headers: { Authorization: `Bearer ${token}` } });
+```
+
+```typescript
+// Solana wallet (Phantom, etc.)
+import bs58 from 'bs58'; // already available via @solana/web3.js
+const sigBytes = await phantom.signMessage(new TextEncoder().encode(res.nonce));
+const signature = bs58.encode(sigBytes);
+```
+
+```typescript
+// Raw ed25519 keypair (no blockchain needed)
+import { sign } from 'crypto';
+const sigBytes = sign(null, Buffer.from(res.nonce), privateKey);
+const signature = sigBytes.toString('hex');
+```
+
+## Wire format
+
+### Challenge response (server → client)
+
+```json
+{
+  "nonce": "a1b2c3d4e5f6...",
+  "challenge": "BASE64_HMAC_SIGNED_BLOB",
+  "expiresAt": 1710500000000
+}
+```
+
+- `nonce` — the message the client must sign with their wallet
+- `challenge` — opaque HMAC-signed blob (client stores and sends back as-is)
+- `expiresAt` — expiration timestamp (informational for the client)
+
+### Verify request (client → server)
+
+```json
+{
+  "address": "0x1234...",
+  "signature": "0xabcd...",
+  "challenge": "BASE64_HMAC_SIGNED_BLOB"
+}
+```
+
+The client never needs to send the nonce separately — it's embedded in the challenge blob.
+
+## Framework adapters (planned)
+
+Core is framework-agnostic. Optional adapter packages may be published if needed:
+
+| Package | Status |
+|---|---|
+| `@shipooor/walletauth` | Core library (pure functions + verifiers) |
+| `@shipooor/walletauth-express` | Planned — Express middleware wrapper |
+| `@shipooor/walletauth-nestjs` | Planned — Guard + decorator |
+| `@shipooor/walletauth-fastify` | Planned — Fastify plugin |
+
+## Size
+
+| | @shipooor/walletauth | ethers.js (for verifyMessage) |
+|---|---|---|
+| Library size | ~7KB ESM | 500KB+ |
+| Runtime deps | 3 (`@noble/curves`, `@noble/hashes`, `jose`) | Everything bundled |
+| EVM verify | `@noble/curves` + `@noble/hashes` | Full ethers bundle |
+| ed25519 verify | Node.js built-in `crypto` | Not included |
+
+Same underlying crypto (`@noble/*`), minimal surface area.
+
+## Security notes
+
+- **HTTPS required**: Always deploy behind HTTPS. Challenges, signatures, and JWTs are sent in plaintext over HTTP — an attacker on the network can intercept them.
+- **Single secret (v1)**: One secret for both HMAC challenges and JWT signing. Both use HMAC-SHA256, which is a PRF — safe for key reuse. The payloads are structurally different (challenge JSON vs JWT claims), so there's no confusion risk. Separate secrets can be supported in a future version.
+- **One secret per service**: If you run multiple APIs, use a different `WALLETAUTH_SECRET` for each. JWTs signed by one service are valid on any service that shares the same secret.
+- **Secret rotation**: Changing `WALLETAUTH_SECRET` instantly invalidates all existing JWTs and pending challenges. Plan rotation during low-traffic windows. For graceful rotation, validate against both old and new secrets during a transition period.
+- **Challenge expiration**: Default 5 minutes. Configurable via options.
+- **Replay window**: Within the challenge TTL, a captured `{ address, signature, challenge }` request can be replayed to obtain a JWT. HTTPS prevents interception. For strict one-time use, implement nonce tracking at the application level.
+- **JWT revocation**: Stateless JWTs cannot be revoked before expiry. If an agent is compromised, you must either rotate the secret (invalidates all tokens) or maintain a blocklist at the application level. Use short JWT expiry (`1h` default) to limit exposure.
+- **No rate limiting built-in**: Rate limiting is the API owner's responsibility. The challenge endpoint is unauthenticated — protect it with your framework's middleware (express-rate-limit, @nestjs/throttler, etc.).
+
+## Generating a secret
+
+```bash
+openssl rand -base64 32
+```
+
+Minimum 16 characters. Store in environment variables, never in code.
+
+```bash
+export WALLETAUTH_SECRET="your-generated-secret-here"
+```
+
+## Debugging
+
+All verification functions return `false` or `null` on failure without revealing the reason. This is intentional — error details could leak information to attackers.
+
+Common issues when auth fails:
+
+| Symptom | Check |
+|---|---|
+| `verifySignature` returns `false` | Is the challenge expired? (default 5 min TTL) |
+| `verifySignature` returns `false` | Is the correct verifier used? (evm vs ed25519) |
+| `verifySignature` returns `false` | Does the address match between challenge and verify? |
+| `verifySignature` returns `false` | Is the client signing the `nonce` string, not the `challenge` blob? |
+| `validateToken` returns `null` | Is the JWT expired? |
+| `validateToken` returns `null` | Is the same secret used for issuing and validating? |
+| `assertSecret` throws | Secret must be at least 16 characters |
+
+## Related
+
+- [SIWE (EIP-4361)](https://docs.siwe.xyz/) — session-based, human-facing login
+- [ERC-8128](https://eips.ethereum.org/EIPS/eip-8128) — per-request HTTP signing (draft)
+- [x402](https://www.x402.org/) — payment auth protocol (complementary)

package/dist/index.cjs

@@ -0,0 +1,267 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createChallenge: () => createChallenge,
+  issueToken: () => issueToken,
+  validateToken: () => validateToken,
+  verifiers: () => verifiers,
+  verifySignature: () => verifySignature
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/challenge.ts
+var import_node_crypto = require("crypto");
+
+// src/secret.ts
+var MIN_SECRET_LENGTH = 16;
+function assertSecret(secret) {
+  if (!secret || secret.length < MIN_SECRET_LENGTH) {
+    throw new Error(
+      `WALLETAUTH_SECRET must be at least ${MIN_SECRET_LENGTH} characters`
+    );
+  }
+}
+
+// src/challenge.ts
+var DEFAULT_EXPIRES_IN = 5 * 60 * 1e3;
+function sign(payload, secret) {
+  const data = JSON.stringify(payload);
+  const mac = (0, import_node_crypto.createHmac)("sha256", secret).update(data).digest("base64url");
+  const encoded = Buffer.from(data).toString("base64url");
+  return `${encoded}.${mac}`;
+}
+function parseAndVerifyChallenge(challenge, secret) {
+  const dotIndex = challenge.indexOf(".");
+  if (dotIndex === -1) return null;
+  const encoded = challenge.slice(0, dotIndex);
+  const mac = challenge.slice(dotIndex + 1);
+  let data;
+  try {
+    data = Buffer.from(encoded, "base64url").toString();
+  } catch {
+    return null;
+  }
+  const expectedMac = (0, import_node_crypto.createHmac)("sha256", secret).update(data).digest("base64url");
+  const a = Buffer.from(mac);
+  const b = Buffer.from(expectedMac);
+  if (a.length !== b.length) return null;
+  if (!(0, import_node_crypto.timingSafeEqual)(a, b)) return null;
+  try {
+    const payload = JSON.parse(data);
+    if (Date.now() > payload.exp) return null;
+    return payload;
+  } catch {
+    return null;
+  }
+}
+function createChallenge(address, secret, options) {
+  assertSecret(secret);
+  const expiresIn = options?.expiresIn ?? DEFAULT_EXPIRES_IN;
+  if (!Number.isFinite(expiresIn)) {
+    throw new Error("expiresIn must be a finite number");
+  }
+  const nonce = (0, import_node_crypto.randomBytes)(32).toString("hex");
+  const exp = Date.now() + expiresIn;
+  const payload = { address, nonce, exp };
+  const challenge = sign(payload, secret);
+  return { nonce, challenge, expiresAt: exp };
+}
+
+// src/verify.ts
+async function verifySignature(address, signature, challenge, secret, verifier) {
+  try {
+    const payload = parseAndVerifyChallenge(challenge, secret);
+    if (!payload) return false;
+    if (payload.address.toLowerCase() !== address.toLowerCase()) return false;
+    const verifierList = Array.isArray(verifier) ? verifier : [verifier];
+    for (const v of verifierList) {
+      try {
+        const result = await v(address, payload.nonce, signature);
+        if (result) return true;
+      } catch {
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+// src/token.ts
+var import_jose = require("jose");
+var DEFAULT_EXPIRES_IN2 = "1h";
+async function issueToken(address, secret, options) {
+  assertSecret(secret);
+  const secretKey = new TextEncoder().encode(secret);
+  const expiresIn = options?.expiresIn ?? DEFAULT_EXPIRES_IN2;
+  return new import_jose.SignJWT({ address }).setProtectedHeader({ alg: "HS256" }).setIssuedAt().setExpirationTime(expiresIn).sign(secretKey);
+}
+async function validateToken(token, secret) {
+  try {
+    const secretKey = new TextEncoder().encode(secret);
+    const { payload } = await (0, import_jose.jwtVerify)(token, secretKey, { algorithms: ["HS256"] });
+    if (typeof payload.address !== "string") return null;
+    if (typeof payload.iat !== "number") return null;
+    if (typeof payload.exp !== "number") return null;
+    return {
+      address: payload.address,
+      iat: payload.iat,
+      exp: payload.exp
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/verifiers/evm.ts
+var import_secp256k1 = require("@noble/curves/secp256k1");
+var import_sha3 = require("@noble/hashes/sha3");
+function hashPersonalMessage(message) {
+  const messageBytes = new TextEncoder().encode(message);
+  const prefix = `Ethereum Signed Message:
+${messageBytes.length}`;
+  const prefixBytes = new TextEncoder().encode(prefix);
+  const combined = new Uint8Array(prefixBytes.length + messageBytes.length);
+  combined.set(prefixBytes);
+  combined.set(messageBytes, prefixBytes.length);
+  return (0, import_sha3.keccak_256)(combined);
+}
+function publicKeyToAddress(publicKey) {
+  const hash = (0, import_sha3.keccak_256)(publicKey.slice(1));
+  const addressBytes = hash.slice(-20);
+  return "0x" + Buffer.from(addressBytes).toString("hex");
+}
+var evm = (address, message, signature) => {
+  try {
+    const hash = hashPersonalMessage(message);
+    const sig = signature.startsWith("0x") ? signature.slice(2) : signature;
+    if (sig.length !== 130) return false;
+    const r = BigInt("0x" + sig.slice(0, 64));
+    const s = BigInt("0x" + sig.slice(64, 128));
+    const v = parseInt(sig.slice(128, 130), 16);
+    const recovery = v >= 27 ? v - 27 : v;
+    if (recovery !== 0 && recovery !== 1) return false;
+    const sigObj = new import_secp256k1.secp256k1.Signature(r, s, recovery);
+    const recovered = sigObj.recoverPublicKey(hash);
+    const recoveredAddress = publicKeyToAddress(recovered.toRawBytes(false));
+    return recoveredAddress.toLowerCase() === address.toLowerCase();
+  } catch {
+    return false;
+  }
+};
+
+// src/verifiers/ed25519.ts
+var import_node_crypto2 = require("crypto");
+var ED25519_DER_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function decodeBase58(input) {
+  const bytes = [];
+  for (const char of input) {
+    const idx = BASE58_ALPHABET.indexOf(char);
+    if (idx === -1) throw new Error("Invalid base58 character");
+    let carry = idx;
+    for (let j = 0; j < bytes.length; j++) {
+      carry += bytes[j] * 58;
+      bytes[j] = carry & 255;
+      carry >>= 8;
+    }
+    while (carry > 0) {
+      bytes.push(carry & 255);
+      carry >>= 8;
+    }
+  }
+  bytes.reverse();
+  let leadingZeros = 0;
+  for (const char of input) {
+    if (char !== "1") break;
+    leadingZeros++;
+  }
+  const result = new Uint8Array(leadingZeros + bytes.length);
+  result.set(bytes, leadingZeros);
+  return Buffer.from(result);
+}
+function parsePublicKey(address) {
+  try {
+    if (/^[0-9a-fA-F]{64}$/.test(address)) {
+      return Buffer.from(address, "hex");
+    }
+    if (/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address)) {
+      const decoded = decodeBase58(address);
+      if (decoded.length === 32) return decoded;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+var ed25519 = (address, message, signature) => {
+  try {
+    const publicKeyRaw = parsePublicKey(address);
+    if (!publicKeyRaw || publicKeyRaw.length !== 32) return false;
+    let sigBuffer;
+    if (/^[0-9a-fA-F]{128}$/.test(signature)) {
+      sigBuffer = Buffer.from(signature, "hex");
+    } else if (/^[1-9A-HJ-NP-Za-km-z]{1,90}$/.test(signature)) {
+      const decoded = decodeBase58(signature);
+      if (decoded.length === 64) {
+        sigBuffer = decoded;
+      } else {
+        sigBuffer = Buffer.from(signature, "base64");
+      }
+    } else {
+      sigBuffer = Buffer.from(signature, "base64");
+    }
+    if (sigBuffer.length !== 64) return false;
+    const derKey = Buffer.concat([ED25519_DER_PREFIX, publicKeyRaw]);
+    const keyObject = (0, import_node_crypto2.createPublicKey)({
+      key: derKey,
+      format: "der",
+      type: "spki"
+    });
+    return (0, import_node_crypto2.verify)(null, Buffer.from(message), keyObject, sigBuffer);
+  } catch {
+    return false;
+  }
+};
+
+// src/verifiers/index.ts
+var verifiers = {
+  /**
+   * EVM signature verifier (Ethereum, Arbitrum, Base, Polygon, etc.).
+   * Verifies `personal_sign` (EIP-191) signatures using secp256k1 ecrecover.
+   */
+  evm,
+  /**
+   * Ed25519 signature verifier (Solana, raw ed25519 keypairs).
+   * Accepts addresses as base58 or hex. Signatures as hex, base58, or base64.
+   */
+  ed25519
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createChallenge,
+  issueToken,
+  validateToken,
+  verifiers,
+  verifySignature
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/challenge.ts","../src/secret.ts","../src/verify.ts","../src/token.ts","../src/verifiers/evm.ts","../src/verifiers/ed25519.ts","../src/verifiers/index.ts"],"sourcesContent":["export { createChallenge } from './challenge.js';\nexport { verifySignature } from './verify.js';\nexport { issueToken, validateToken } from './token.js';\nexport { verifiers } from './verifiers/index.js';\nexport type {\n  Verifier,\n  ChallengeResult,\n  ChallengeOptions,\n  TokenOptions,\n  TokenPayload,\n} from './types.js';\n","import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';\nimport type { ChallengeOptions, ChallengeResult } from './types.js';\nimport { assertSecret } from './secret.js';\n\nconst DEFAULT_EXPIRES_IN = 5 * 60 * 1000; // 5 minutes\n\ninterface ChallengePayload {\n  address: string;\n  nonce: string;\n  exp: number;\n}\n\nfunction sign(payload: ChallengePayload, secret: string): string {\n  const data = JSON.stringify(payload);\n  const mac = createHmac('sha256', secret).update(data).digest('base64url');\n  const encoded = Buffer.from(data).toString('base64url');\n  return `${encoded}.${mac}`;\n}\n\nexport function parseAndVerifyChallenge(\n  challenge: string,\n  secret: string,\n): ChallengePayload | null {\n  const dotIndex = challenge.indexOf('.');\n  if (dotIndex === -1) return null;\n\n  const encoded = challenge.slice(0, dotIndex);\n  const mac = challenge.slice(dotIndex + 1);\n\n  let data: string;\n  try {\n    data = Buffer.from(encoded, 'base64url').toString();\n  } catch {\n    return null;\n  }\n\n  const expectedMac = createHmac('sha256', secret).update(data).digest('base64url');\n\n  // Constant-time comparison to prevent timing attacks\n  const a = Buffer.from(mac);\n  const b = Buffer.from(expectedMac);\n  if (a.length !== b.length) return null;\n  if (!timingSafeEqual(a, b)) return null;\n\n  try {\n    const payload: ChallengePayload = JSON.parse(data);\n    if (Date.now() > payload.exp) return null;\n    return payload;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Generate a stateless HMAC-signed challenge for wallet authentication.\n *\n * @param address - Wallet address (EVM `0x...` or Solana base58)\n * @param secret - Server secret (min 16 chars). Use `WALLETAUTH_SECRET` env var.\n * @param options - Optional. `expiresIn`: challenge TTL in ms (default 5 min).\n * @returns `{ nonce, challenge, expiresAt }` — send all three to the client.\n *   The client signs `nonce` and sends back `{ address, signature, challenge }`.\n * @throws If secret is too short or expiresIn is not a finite number.\n */\nexport function createChallenge(\n  address: string,\n  secret: string,\n  options?: ChallengeOptions,\n): ChallengeResult {\n  assertSecret(secret);\n  const expiresIn = options?.expiresIn ?? DEFAULT_EXPIRES_IN;\n  if (!Number.isFinite(expiresIn)) {\n    throw new Error('expiresIn must be a finite number');\n  }\n  const nonce = randomBytes(32).toString('hex');\n  const exp = Date.now() + expiresIn;\n\n  const payload: ChallengePayload = { address, nonce, exp };\n  const challenge = sign(payload, secret);\n\n  return { nonce, challenge, expiresAt: exp };\n}\n","const MIN_SECRET_LENGTH = 16;\n\nexport function assertSecret(secret: string): void {\n  if (!secret || secret.length < MIN_SECRET_LENGTH) {\n    throw new Error(\n      `WALLETAUTH_SECRET must be at least ${MIN_SECRET_LENGTH} characters`,\n    );\n  }\n}\n","import { parseAndVerifyChallenge } from './challenge.js';\nimport type { Verifier } from './types.js';\n\n/**\n * Verify a wallet signature against an HMAC-signed challenge.\n *\n * Checks that the challenge is authentic (HMAC), not expired, and that the\n * wallet signature is valid for the nonce embedded in the challenge.\n *\n * @param address - Wallet address claiming ownership.\n * @param signature - Wallet signature over the nonce.\n * @param challenge - Opaque challenge blob from {@link createChallenge}.\n * @param secret - Same server secret used in `createChallenge`.\n * @param verifier - A {@link Verifier} or array of verifiers (tried in order, first `true` wins).\n * @returns `true` if the signature is valid, `false` otherwise. Never throws.\n */\nexport async function verifySignature(\n  address: string,\n  signature: string,\n  challenge: string,\n  secret: string,\n  verifier: Verifier | Verifier[],\n): Promise<boolean> {\n  try {\n    // Verify HMAC challenge\n    const payload = parseAndVerifyChallenge(challenge, secret);\n    if (!payload) return false;\n\n    // Verify address matches\n    if (payload.address.toLowerCase() !== address.toLowerCase()) return false;\n\n    // Try verifier(s)\n    const verifierList = Array.isArray(verifier) ? verifier : [verifier];\n    for (const v of verifierList) {\n      try {\n        const result = await v(address, payload.nonce, signature);\n        if (result) return true;\n      } catch {\n        // Verifier threw — try next\n      }\n    }\n\n    return false;\n  } catch {\n    return false;\n  }\n}\n","import { SignJWT, jwtVerify } from 'jose';\nimport type { TokenOptions, TokenPayload } from './types.js';\nimport { assertSecret } from './secret.js';\n\nconst DEFAULT_EXPIRES_IN = '1h';\n\n/**\n * Issue a JWT for an authenticated wallet address.\n *\n * Call this after {@link verifySignature} returns `true`.\n *\n * @param address - Verified wallet address to embed in the token.\n * @param secret - Server secret (min 16 chars). Same as used for challenges.\n * @param options - Optional. `expiresIn`: JWT lifetime string (default `'1h'`). Examples: `'30m'`, `'2h'`, `'7d'`.\n * @returns Signed JWT string. Send to the client as a Bearer token.\n * @throws If secret is too short.\n */\nexport async function issueToken(\n  address: string,\n  secret: string,\n  options?: TokenOptions,\n): Promise<string> {\n  assertSecret(secret);\n  const secretKey = new TextEncoder().encode(secret);\n  const expiresIn = options?.expiresIn ?? DEFAULT_EXPIRES_IN;\n\n  return new SignJWT({ address })\n    .setProtectedHeader({ alg: 'HS256' })\n    .setIssuedAt()\n    .setExpirationTime(expiresIn)\n    .sign(secretKey);\n}\n\n/**\n * Validate a JWT and extract the wallet address.\n *\n * Use this in auth middleware to protect routes.\n *\n * @param token - JWT string from the `Authorization: Bearer <token>` header.\n * @param secret - Same server secret used in `issueToken`.\n * @returns `{ address, iat, exp }` if valid, `null` otherwise. Never throws.\n */\nexport async function validateToken(\n  token: string,\n  secret: string,\n): Promise<TokenPayload | null> {\n  try {\n    const secretKey = new TextEncoder().encode(secret);\n    const { payload } = await jwtVerify(token, secretKey, { algorithms: ['HS256'] });\n\n    if (typeof payload.address !== 'string') return null;\n    if (typeof payload.iat !== 'number') return null;\n    if (typeof payload.exp !== 'number') return null;\n\n    return {\n      address: payload.address,\n      iat: payload.iat,\n      exp: payload.exp,\n    };\n  } catch {\n    return null;\n  }\n}\n","import { secp256k1 } from '@noble/curves/secp256k1';\nimport { keccak_256 } from '@noble/hashes/sha3';\nimport type { Verifier } from '../types.js';\n\n// EVM personal_sign prefix: \"\\x19Ethereum Signed Message:\\n\" + message length\nfunction hashPersonalMessage(message: string): Uint8Array {\n  const messageBytes = new TextEncoder().encode(message);\n  const prefix = `\\x19Ethereum Signed Message:\\n${messageBytes.length}`;\n  const prefixBytes = new TextEncoder().encode(prefix);\n  const combined = new Uint8Array(prefixBytes.length + messageBytes.length);\n  combined.set(prefixBytes);\n  combined.set(messageBytes, prefixBytes.length);\n  return keccak_256(combined);\n}\n\nfunction publicKeyToAddress(publicKey: Uint8Array): string {\n  // Remove the 0x04 prefix (uncompressed key marker), hash, take last 20 bytes\n  const hash = keccak_256(publicKey.slice(1));\n  const addressBytes = hash.slice(-20);\n  return '0x' + Buffer.from(addressBytes).toString('hex');\n}\n\n/**\n * EVM signature verifier (Ethereum, Arbitrum, Base, Polygon, etc.).\n *\n * Verifies `personal_sign` (EIP-191) signatures using secp256k1 ecrecover.\n * Accepts signatures with or without `0x` prefix. Address comparison is case-insensitive.\n *\n * @param address - EVM address (`0x...`, 42 chars).\n * @param message - The nonce string that was signed.\n * @param signature - Hex signature: `0x` + r(32B) + s(32B) + v(1B) = 132 chars.\n */\nexport const evm: Verifier = (address, message, signature) => {\n  try {\n    const hash = hashPersonalMessage(message);\n\n    // Parse signature: 0x + r(32 bytes) + s(32 bytes) + v(1 byte) = 0x + 130 hex chars\n    const sig = signature.startsWith('0x') ? signature.slice(2) : signature;\n    if (sig.length !== 130) return false;\n\n    const r = BigInt('0x' + sig.slice(0, 64));\n    const s = BigInt('0x' + sig.slice(64, 128));\n    const v = parseInt(sig.slice(128, 130), 16);\n\n    // v is 27 or 28 (legacy) or 0 or 1 (raw recovery id)\n    const recovery = v >= 27 ? v - 27 : v;\n    if (recovery !== 0 && recovery !== 1) return false;\n\n    const sigObj = new secp256k1.Signature(r, s, recovery);\n    const recovered = sigObj.recoverPublicKey(hash);\n    const recoveredAddress = publicKeyToAddress(recovered.toRawBytes(false));\n\n    return recoveredAddress.toLowerCase() === address.toLowerCase();\n  } catch {\n    return false;\n  }\n};\n","import { createPublicKey, verify } from 'node:crypto';\nimport type { Verifier } from '../types.js';\n\n// Fixed DER prefix for Ed25519 SPKI public keys (12 bytes)\nconst ED25519_DER_PREFIX = Buffer.from('302a300506032b6570032100', 'hex');\n\nconst BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';\n\nfunction decodeBase58(input: string): Buffer {\n  const bytes: number[] = [];\n  for (const char of input) {\n    const idx = BASE58_ALPHABET.indexOf(char);\n    if (idx === -1) throw new Error('Invalid base58 character');\n    let carry = idx;\n    for (let j = 0; j < bytes.length; j++) {\n      carry += bytes[j] * 58;\n      bytes[j] = carry & 0xff;\n      carry >>= 8;\n    }\n    while (carry > 0) {\n      bytes.push(carry & 0xff);\n      carry >>= 8;\n    }\n  }\n  bytes.reverse();\n  // Leading '1's in base58 = leading zero bytes\n  let leadingZeros = 0;\n  for (const char of input) {\n    if (char !== '1') break;\n    leadingZeros++;\n  }\n  const result = new Uint8Array(leadingZeros + bytes.length);\n  // First leadingZeros bytes are already 0, copy computed bytes after\n  result.set(bytes, leadingZeros);\n  return Buffer.from(result);\n}\n\nfunction parsePublicKey(address: string): Buffer | null {\n  try {\n    // Hex-encoded 32-byte key (64 hex chars)\n    if (/^[0-9a-fA-F]{64}$/.test(address)) {\n      return Buffer.from(address, 'hex');\n    }\n    // Base58-encoded (Solana addresses: 32-44 chars from base58 alphabet)\n    if (/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address)) {\n      const decoded = decodeBase58(address);\n      if (decoded.length === 32) return decoded;\n    }\n    return null;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Ed25519 signature verifier (Solana, raw ed25519 keypairs).\n *\n * Accepts addresses as base58 (Solana, 32-44 chars) or hex (64 chars).\n * Accepts signatures as hex (128 chars), base58 (Solana convention), or base64.\n * Uses Node.js built-in `crypto` — zero external dependencies.\n *\n * @param address - Public key as base58 (Solana) or hex string.\n * @param message - The nonce string that was signed.\n * @param signature - 64-byte signature in hex, base58, or base64 encoding.\n */\nexport const ed25519: Verifier = (address, message, signature) => {\n  try {\n    const publicKeyRaw = parsePublicKey(address);\n    if (!publicKeyRaw || publicKeyRaw.length !== 32) return false;\n\n    // Signature: hex (128 chars), base58 (Solana convention), or base64\n    let sigBuffer: Buffer;\n    if (/^[0-9a-fA-F]{128}$/.test(signature)) {\n      sigBuffer = Buffer.from(signature, 'hex');\n    } else if (/^[1-9A-HJ-NP-Za-km-z]{1,90}$/.test(signature)) {\n      // Could be base58 — decode and validate length, fall back to base64\n      const decoded = decodeBase58(signature);\n      if (decoded.length === 64) {\n        sigBuffer = decoded;\n      } else {\n        sigBuffer = Buffer.from(signature, 'base64');\n      }\n    } else {\n      sigBuffer = Buffer.from(signature, 'base64');\n    }\n    if (sigBuffer.length !== 64) return false;\n\n    // Wrap raw public key in DER/SPKI format for Node.js crypto\n    const derKey = Buffer.concat([ED25519_DER_PREFIX, publicKeyRaw]);\n    const keyObject = createPublicKey({\n      key: derKey,\n      format: 'der',\n      type: 'spki',\n    });\n\n    return verify(null, Buffer.from(message), keyObject, sigBuffer);\n  } catch {\n    return false;\n  }\n};\n","import { evm } from './evm.js';\nimport { ed25519 } from './ed25519.js';\n\nexport const verifiers = {\n  /**\n   * EVM signature verifier (Ethereum, Arbitrum, Base, Polygon, etc.).\n   * Verifies `personal_sign` (EIP-191) signatures using secp256k1 ecrecover.\n   */\n  evm,\n  /**\n   * Ed25519 signature verifier (Solana, raw ed25519 keypairs).\n   * Accepts addresses as base58 or hex. Signatures as hex, base58, or base64.\n   */\n  ed25519,\n};\n"],"mappings":"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","names":["DEFAULT_EXPIRES_IN","import_node_crypto"]}

package/dist/index.d.cts

@@ -0,0 +1,82 @@
+type Verifier = (address: string, message: string, signature: string) => boolean | Promise<boolean>;
+interface ChallengeResult {
+    nonce: string;
+    challenge: string;
+    expiresAt: number;
+}
+interface ChallengeOptions {
+    expiresIn?: number;
+}
+interface TokenOptions {
+    expiresIn?: string;
+}
+interface TokenPayload {
+    address: string;
+    iat: number;
+    exp: number;
+}
+
+/**
+ * Generate a stateless HMAC-signed challenge for wallet authentication.
+ *
+ * @param address - Wallet address (EVM `0x...` or Solana base58)
+ * @param secret - Server secret (min 16 chars). Use `WALLETAUTH_SECRET` env var.
+ * @param options - Optional. `expiresIn`: challenge TTL in ms (default 5 min).
+ * @returns `{ nonce, challenge, expiresAt }` — send all three to the client.
+ *   The client signs `nonce` and sends back `{ address, signature, challenge }`.
+ * @throws If secret is too short or expiresIn is not a finite number.
+ */
+declare function createChallenge(address: string, secret: string, options?: ChallengeOptions): ChallengeResult;
+
+/**
+ * Verify a wallet signature against an HMAC-signed challenge.
+ *
+ * Checks that the challenge is authentic (HMAC), not expired, and that the
+ * wallet signature is valid for the nonce embedded in the challenge.
+ *
+ * @param address - Wallet address claiming ownership.
+ * @param signature - Wallet signature over the nonce.
+ * @param challenge - Opaque challenge blob from {@link createChallenge}.
+ * @param secret - Same server secret used in `createChallenge`.
+ * @param verifier - A {@link Verifier} or array of verifiers (tried in order, first `true` wins).
+ * @returns `true` if the signature is valid, `false` otherwise. Never throws.
+ */
+declare function verifySignature(address: string, signature: string, challenge: string, secret: string, verifier: Verifier | Verifier[]): Promise<boolean>;
+
+/**
+ * Issue a JWT for an authenticated wallet address.
+ *
+ * Call this after {@link verifySignature} returns `true`.
+ *
+ * @param address - Verified wallet address to embed in the token.
+ * @param secret - Server secret (min 16 chars). Same as used for challenges.
+ * @param options - Optional. `expiresIn`: JWT lifetime string (default `'1h'`). Examples: `'30m'`, `'2h'`, `'7d'`.
+ * @returns Signed JWT string. Send to the client as a Bearer token.
+ * @throws If secret is too short.
+ */
+declare function issueToken(address: string, secret: string, options?: TokenOptions): Promise<string>;
+/**
+ * Validate a JWT and extract the wallet address.
+ *
+ * Use this in auth middleware to protect routes.
+ *
+ * @param token - JWT string from the `Authorization: Bearer <token>` header.
+ * @param secret - Same server secret used in `issueToken`.
+ * @returns `{ address, iat, exp }` if valid, `null` otherwise. Never throws.
+ */
+declare function validateToken(token: string, secret: string): Promise<TokenPayload | null>;
+
+declare const verifiers: {
+    /**
+     * EVM signature verifier (Ethereum, Arbitrum, Base, Polygon, etc.).
+     * Verifies `personal_sign` (EIP-191) signatures using secp256k1 ecrecover.
+     */
+    evm: Verifier;
+    /**
+     * Ed25519 signature verifier (Solana, raw ed25519 keypairs).
+     * Accepts addresses as base58 or hex. Signatures as hex, base58, or base64.
+     */
+    ed25519: Verifier;
+};
+
+export { type ChallengeOptions, type ChallengeResult, type TokenOptions, type TokenPayload, type Verifier, createChallenge, issueToken, validateToken, verifiers, verifySignature };

package/dist/index.d.ts

@@ -0,0 +1,82 @@
+type Verifier = (address: string, message: string, signature: string) => boolean | Promise<boolean>;
+interface ChallengeResult {
+    nonce: string;
+    challenge: string;
+    expiresAt: number;
+}
+interface ChallengeOptions {
+    expiresIn?: number;
+}
+interface TokenOptions {
+    expiresIn?: string;
+}
+interface TokenPayload {
+    address: string;
+    iat: number;
+    exp: number;
+}
+
+/**
+ * Generate a stateless HMAC-signed challenge for wallet authentication.
+ *
+ * @param address - Wallet address (EVM `0x...` or Solana base58)
+ * @param secret - Server secret (min 16 chars). Use `WALLETAUTH_SECRET` env var.
+ * @param options - Optional. `expiresIn`: challenge TTL in ms (default 5 min).
+ * @returns `{ nonce, challenge, expiresAt }` — send all three to the client.
+ *   The client signs `nonce` and sends back `{ address, signature, challenge }`.
+ * @throws If secret is too short or expiresIn is not a finite number.
+ */
+declare function createChallenge(address: string, secret: string, options?: ChallengeOptions): ChallengeResult;
+
+/**
+ * Verify a wallet signature against an HMAC-signed challenge.
+ *
+ * Checks that the challenge is authentic (HMAC), not expired, and that the
+ * wallet signature is valid for the nonce embedded in the challenge.
+ *
+ * @param address - Wallet address claiming ownership.
+ * @param signature - Wallet signature over the nonce.
+ * @param challenge - Opaque challenge blob from {@link createChallenge}.
+ * @param secret - Same server secret used in `createChallenge`.
+ * @param verifier - A {@link Verifier} or array of verifiers (tried in order, first `true` wins).
+ * @returns `true` if the signature is valid, `false` otherwise. Never throws.
+ */
+declare function verifySignature(address: string, signature: string, challenge: string, secret: string, verifier: Verifier | Verifier[]): Promise<boolean>;
+
+/**
+ * Issue a JWT for an authenticated wallet address.
+ *
+ * Call this after {@link verifySignature} returns `true`.
+ *
+ * @param address - Verified wallet address to embed in the token.
+ * @param secret - Server secret (min 16 chars). Same as used for challenges.
+ * @param options - Optional. `expiresIn`: JWT lifetime string (default `'1h'`). Examples: `'30m'`, `'2h'`, `'7d'`.
+ * @returns Signed JWT string. Send to the client as a Bearer token.
+ * @throws If secret is too short.
+ */
+declare function issueToken(address: string, secret: string, options?: TokenOptions): Promise<string>;
+/**
+ * Validate a JWT and extract the wallet address.
+ *
+ * Use this in auth middleware to protect routes.
+ *
+ * @param token - JWT string from the `Authorization: Bearer <token>` header.
+ * @param secret - Same server secret used in `issueToken`.
+ * @returns `{ address, iat, exp }` if valid, `null` otherwise. Never throws.
+ */
+declare function validateToken(token: string, secret: string): Promise<TokenPayload | null>;
+
+declare const verifiers: {
+    /**
+     * EVM signature verifier (Ethereum, Arbitrum, Base, Polygon, etc.).
+     * Verifies `personal_sign` (EIP-191) signatures using secp256k1 ecrecover.
+     */
+    evm: Verifier;
+    /**
+     * Ed25519 signature verifier (Solana, raw ed25519 keypairs).
+     * Accepts addresses as base58 or hex. Signatures as hex, base58, or base64.
+     */
+    ed25519: Verifier;
+};
+
+export { type ChallengeOptions, type ChallengeResult, type TokenOptions, type TokenPayload, type Verifier, createChallenge, issueToken, validateToken, verifiers, verifySignature };

package/dist/index.js

@@ -0,0 +1,236 @@
+// src/challenge.ts
+import { createHmac, randomBytes, timingSafeEqual } from "crypto";
+
+// src/secret.ts
+var MIN_SECRET_LENGTH = 16;
+function assertSecret(secret) {
+  if (!secret || secret.length < MIN_SECRET_LENGTH) {
+    throw new Error(
+      `WALLETAUTH_SECRET must be at least ${MIN_SECRET_LENGTH} characters`
+    );
+  }
+}
+
+// src/challenge.ts
+var DEFAULT_EXPIRES_IN = 5 * 60 * 1e3;
+function sign(payload, secret) {
+  const data = JSON.stringify(payload);
+  const mac = createHmac("sha256", secret).update(data).digest("base64url");
+  const encoded = Buffer.from(data).toString("base64url");
+  return `${encoded}.${mac}`;
+}
+function parseAndVerifyChallenge(challenge, secret) {
+  const dotIndex = challenge.indexOf(".");
+  if (dotIndex === -1) return null;
+  const encoded = challenge.slice(0, dotIndex);
+  const mac = challenge.slice(dotIndex + 1);
+  let data;
+  try {
+    data = Buffer.from(encoded, "base64url").toString();
+  } catch {
+    return null;
+  }
+  const expectedMac = createHmac("sha256", secret).update(data).digest("base64url");
+  const a = Buffer.from(mac);
+  const b = Buffer.from(expectedMac);
+  if (a.length !== b.length) return null;
+  if (!timingSafeEqual(a, b)) return null;
+  try {
+    const payload = JSON.parse(data);
+    if (Date.now() > payload.exp) return null;
+    return payload;
+  } catch {
+    return null;
+  }
+}
+function createChallenge(address, secret, options) {
+  assertSecret(secret);
+  const expiresIn = options?.expiresIn ?? DEFAULT_EXPIRES_IN;
+  if (!Number.isFinite(expiresIn)) {
+    throw new Error("expiresIn must be a finite number");
+  }
+  const nonce = randomBytes(32).toString("hex");
+  const exp = Date.now() + expiresIn;
+  const payload = { address, nonce, exp };
+  const challenge = sign(payload, secret);
+  return { nonce, challenge, expiresAt: exp };
+}
+
+// src/verify.ts
+async function verifySignature(address, signature, challenge, secret, verifier) {
+  try {
+    const payload = parseAndVerifyChallenge(challenge, secret);
+    if (!payload) return false;
+    if (payload.address.toLowerCase() !== address.toLowerCase()) return false;
+    const verifierList = Array.isArray(verifier) ? verifier : [verifier];
+    for (const v of verifierList) {
+      try {
+        const result = await v(address, payload.nonce, signature);
+        if (result) return true;
+      } catch {
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+// src/token.ts
+import { SignJWT, jwtVerify } from "jose";
+var DEFAULT_EXPIRES_IN2 = "1h";
+async function issueToken(address, secret, options) {
+  assertSecret(secret);
+  const secretKey = new TextEncoder().encode(secret);
+  const expiresIn = options?.expiresIn ?? DEFAULT_EXPIRES_IN2;
+  return new SignJWT({ address }).setProtectedHeader({ alg: "HS256" }).setIssuedAt().setExpirationTime(expiresIn).sign(secretKey);
+}
+async function validateToken(token, secret) {
+  try {
+    const secretKey = new TextEncoder().encode(secret);
+    const { payload } = await jwtVerify(token, secretKey, { algorithms: ["HS256"] });
+    if (typeof payload.address !== "string") return null;
+    if (typeof payload.iat !== "number") return null;
+    if (typeof payload.exp !== "number") return null;
+    return {
+      address: payload.address,
+      iat: payload.iat,
+      exp: payload.exp
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/verifiers/evm.ts
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { keccak_256 } from "@noble/hashes/sha3";
+function hashPersonalMessage(message) {
+  const messageBytes = new TextEncoder().encode(message);
+  const prefix = `Ethereum Signed Message:
+${messageBytes.length}`;
+  const prefixBytes = new TextEncoder().encode(prefix);
+  const combined = new Uint8Array(prefixBytes.length + messageBytes.length);
+  combined.set(prefixBytes);
+  combined.set(messageBytes, prefixBytes.length);
+  return keccak_256(combined);
+}
+function publicKeyToAddress(publicKey) {
+  const hash = keccak_256(publicKey.slice(1));
+  const addressBytes = hash.slice(-20);
+  return "0x" + Buffer.from(addressBytes).toString("hex");
+}
+var evm = (address, message, signature) => {
+  try {
+    const hash = hashPersonalMessage(message);
+    const sig = signature.startsWith("0x") ? signature.slice(2) : signature;
+    if (sig.length !== 130) return false;
+    const r = BigInt("0x" + sig.slice(0, 64));
+    const s = BigInt("0x" + sig.slice(64, 128));
+    const v = parseInt(sig.slice(128, 130), 16);
+    const recovery = v >= 27 ? v - 27 : v;
+    if (recovery !== 0 && recovery !== 1) return false;
+    const sigObj = new secp256k1.Signature(r, s, recovery);
+    const recovered = sigObj.recoverPublicKey(hash);
+    const recoveredAddress = publicKeyToAddress(recovered.toRawBytes(false));
+    return recoveredAddress.toLowerCase() === address.toLowerCase();
+  } catch {
+    return false;
+  }
+};
+
+// src/verifiers/ed25519.ts
+import { createPublicKey, verify } from "crypto";
+var ED25519_DER_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function decodeBase58(input) {
+  const bytes = [];
+  for (const char of input) {
+    const idx = BASE58_ALPHABET.indexOf(char);
+    if (idx === -1) throw new Error("Invalid base58 character");
+    let carry = idx;
+    for (let j = 0; j < bytes.length; j++) {
+      carry += bytes[j] * 58;
+      bytes[j] = carry & 255;
+      carry >>= 8;
+    }
+    while (carry > 0) {
+      bytes.push(carry & 255);
+      carry >>= 8;
+    }
+  }
+  bytes.reverse();
+  let leadingZeros = 0;
+  for (const char of input) {
+    if (char !== "1") break;
+    leadingZeros++;
+  }
+  const result = new Uint8Array(leadingZeros + bytes.length);
+  result.set(bytes, leadingZeros);
+  return Buffer.from(result);
+}
+function parsePublicKey(address) {
+  try {
+    if (/^[0-9a-fA-F]{64}$/.test(address)) {
+      return Buffer.from(address, "hex");
+    }
+    if (/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address)) {
+      const decoded = decodeBase58(address);
+      if (decoded.length === 32) return decoded;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+var ed25519 = (address, message, signature) => {
+  try {
+    const publicKeyRaw = parsePublicKey(address);
+    if (!publicKeyRaw || publicKeyRaw.length !== 32) return false;
+    let sigBuffer;
+    if (/^[0-9a-fA-F]{128}$/.test(signature)) {
+      sigBuffer = Buffer.from(signature, "hex");
+    } else if (/^[1-9A-HJ-NP-Za-km-z]{1,90}$/.test(signature)) {
+      const decoded = decodeBase58(signature);
+      if (decoded.length === 64) {
+        sigBuffer = decoded;
+      } else {
+        sigBuffer = Buffer.from(signature, "base64");
+      }
+    } else {
+      sigBuffer = Buffer.from(signature, "base64");
+    }
+    if (sigBuffer.length !== 64) return false;
+    const derKey = Buffer.concat([ED25519_DER_PREFIX, publicKeyRaw]);
+    const keyObject = createPublicKey({
+      key: derKey,
+      format: "der",
+      type: "spki"
+    });
+    return verify(null, Buffer.from(message), keyObject, sigBuffer);
+  } catch {
+    return false;
+  }
+};
+
+// src/verifiers/index.ts
+var verifiers = {
+  /**
+   * EVM signature verifier (Ethereum, Arbitrum, Base, Polygon, etc.).
+   * Verifies `personal_sign` (EIP-191) signatures using secp256k1 ecrecover.
+   */
+  evm,
+  /**
+   * Ed25519 signature verifier (Solana, raw ed25519 keypairs).
+   * Accepts addresses as base58 or hex. Signatures as hex, base58, or base64.
+   */
+  ed25519
+};
+export {
+  createChallenge,
+  issueToken,
+  validateToken,
+  verifiers,
+  verifySignature
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/challenge.ts","../src/secret.ts","../src/verify.ts","../src/token.ts","../src/verifiers/evm.ts","../src/verifiers/ed25519.ts","../src/verifiers/index.ts"],"sourcesContent":["import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';\nimport type { ChallengeOptions, ChallengeResult } from './types.js';\nimport { assertSecret } from './secret.js';\n\nconst DEFAULT_EXPIRES_IN = 5 * 60 * 1000; // 5 minutes\n\ninterface ChallengePayload {\n  address: string;\n  nonce: string;\n  exp: number;\n}\n\nfunction sign(payload: ChallengePayload, secret: string): string {\n  const data = JSON.stringify(payload);\n  const mac = createHmac('sha256', secret).update(data).digest('base64url');\n  const encoded = Buffer.from(data).toString('base64url');\n  return `${encoded}.${mac}`;\n}\n\nexport function parseAndVerifyChallenge(\n  challenge: string,\n  secret: string,\n): ChallengePayload | null {\n  const dotIndex = challenge.indexOf('.');\n  if (dotIndex === -1) return null;\n\n  const encoded = challenge.slice(0, dotIndex);\n  const mac = challenge.slice(dotIndex + 1);\n\n  let data: string;\n  try {\n    data = Buffer.from(encoded, 'base64url').toString();\n  } catch {\n    return null;\n  }\n\n  const expectedMac = createHmac('sha256', secret).update(data).digest('base64url');\n\n  // Constant-time comparison to prevent timing attacks\n  const a = Buffer.from(mac);\n  const b = Buffer.from(expectedMac);\n  if (a.length !== b.length) return null;\n  if (!timingSafeEqual(a, b)) return null;\n\n  try {\n    const payload: ChallengePayload = JSON.parse(data);\n    if (Date.now() > payload.exp) return null;\n    return payload;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Generate a stateless HMAC-signed challenge for wallet authentication.\n *\n * @param address - Wallet address (EVM `0x...` or Solana base58)\n * @param secret - Server secret (min 16 chars). Use `WALLETAUTH_SECRET` env var.\n * @param options - Optional. `expiresIn`: challenge TTL in ms (default 5 min).\n * @returns `{ nonce, challenge, expiresAt }` — send all three to the client.\n *   The client signs `nonce` and sends back `{ address, signature, challenge }`.\n * @throws If secret is too short or expiresIn is not a finite number.\n */\nexport function createChallenge(\n  address: string,\n  secret: string,\n  options?: ChallengeOptions,\n): ChallengeResult {\n  assertSecret(secret);\n  const expiresIn = options?.expiresIn ?? DEFAULT_EXPIRES_IN;\n  if (!Number.isFinite(expiresIn)) {\n    throw new Error('expiresIn must be a finite number');\n  }\n  const nonce = randomBytes(32).toString('hex');\n  const exp = Date.now() + expiresIn;\n\n  const payload: ChallengePayload = { address, nonce, exp };\n  const challenge = sign(payload, secret);\n\n  return { nonce, challenge, expiresAt: exp };\n}\n","const MIN_SECRET_LENGTH = 16;\n\nexport function assertSecret(secret: string): void {\n  if (!secret || secret.length < MIN_SECRET_LENGTH) {\n    throw new Error(\n      `WALLETAUTH_SECRET must be at least ${MIN_SECRET_LENGTH} characters`,\n    );\n  }\n}\n","import { parseAndVerifyChallenge } from './challenge.js';\nimport type { Verifier } from './types.js';\n\n/**\n * Verify a wallet signature against an HMAC-signed challenge.\n *\n * Checks that the challenge is authentic (HMAC), not expired, and that the\n * wallet signature is valid for the nonce embedded in the challenge.\n *\n * @param address - Wallet address claiming ownership.\n * @param signature - Wallet signature over the nonce.\n * @param challenge - Opaque challenge blob from {@link createChallenge}.\n * @param secret - Same server secret used in `createChallenge`.\n * @param verifier - A {@link Verifier} or array of verifiers (tried in order, first `true` wins).\n * @returns `true` if the signature is valid, `false` otherwise. Never throws.\n */\nexport async function verifySignature(\n  address: string,\n  signature: string,\n  challenge: string,\n  secret: string,\n  verifier: Verifier | Verifier[],\n): Promise<boolean> {\n  try {\n    // Verify HMAC challenge\n    const payload = parseAndVerifyChallenge(challenge, secret);\n    if (!payload) return false;\n\n    // Verify address matches\n    if (payload.address.toLowerCase() !== address.toLowerCase()) return false;\n\n    // Try verifier(s)\n    const verifierList = Array.isArray(verifier) ? verifier : [verifier];\n    for (const v of verifierList) {\n      try {\n        const result = await v(address, payload.nonce, signature);\n        if (result) return true;\n      } catch {\n        // Verifier threw — try next\n      }\n    }\n\n    return false;\n  } catch {\n    return false;\n  }\n}\n","import { SignJWT, jwtVerify } from 'jose';\nimport type { TokenOptions, TokenPayload } from './types.js';\nimport { assertSecret } from './secret.js';\n\nconst DEFAULT_EXPIRES_IN = '1h';\n\n/**\n * Issue a JWT for an authenticated wallet address.\n *\n * Call this after {@link verifySignature} returns `true`.\n *\n * @param address - Verified wallet address to embed in the token.\n * @param secret - Server secret (min 16 chars). Same as used for challenges.\n * @param options - Optional. `expiresIn`: JWT lifetime string (default `'1h'`). Examples: `'30m'`, `'2h'`, `'7d'`.\n * @returns Signed JWT string. Send to the client as a Bearer token.\n * @throws If secret is too short.\n */\nexport async function issueToken(\n  address: string,\n  secret: string,\n  options?: TokenOptions,\n): Promise<string> {\n  assertSecret(secret);\n  const secretKey = new TextEncoder().encode(secret);\n  const expiresIn = options?.expiresIn ?? DEFAULT_EXPIRES_IN;\n\n  return new SignJWT({ address })\n    .setProtectedHeader({ alg: 'HS256' })\n    .setIssuedAt()\n    .setExpirationTime(expiresIn)\n    .sign(secretKey);\n}\n\n/**\n * Validate a JWT and extract the wallet address.\n *\n * Use this in auth middleware to protect routes.\n *\n * @param token - JWT string from the `Authorization: Bearer <token>` header.\n * @param secret - Same server secret used in `issueToken`.\n * @returns `{ address, iat, exp }` if valid, `null` otherwise. Never throws.\n */\nexport async function validateToken(\n  token: string,\n  secret: string,\n): Promise<TokenPayload | null> {\n  try {\n    const secretKey = new TextEncoder().encode(secret);\n    const { payload } = await jwtVerify(token, secretKey, { algorithms: ['HS256'] });\n\n    if (typeof payload.address !== 'string') return null;\n    if (typeof payload.iat !== 'number') return null;\n    if (typeof payload.exp !== 'number') return null;\n\n    return {\n      address: payload.address,\n      iat: payload.iat,\n      exp: payload.exp,\n    };\n  } catch {\n    return null;\n  }\n}\n","import { secp256k1 } from '@noble/curves/secp256k1';\nimport { keccak_256 } from '@noble/hashes/sha3';\nimport type { Verifier } from '../types.js';\n\n// EVM personal_sign prefix: \"\\x19Ethereum Signed Message:\\n\" + message length\nfunction hashPersonalMessage(message: string): Uint8Array {\n  const messageBytes = new TextEncoder().encode(message);\n  const prefix = `\\x19Ethereum Signed Message:\\n${messageBytes.length}`;\n  const prefixBytes = new TextEncoder().encode(prefix);\n  const combined = new Uint8Array(prefixBytes.length + messageBytes.length);\n  combined.set(prefixBytes);\n  combined.set(messageBytes, prefixBytes.length);\n  return keccak_256(combined);\n}\n\nfunction publicKeyToAddress(publicKey: Uint8Array): string {\n  // Remove the 0x04 prefix (uncompressed key marker), hash, take last 20 bytes\n  const hash = keccak_256(publicKey.slice(1));\n  const addressBytes = hash.slice(-20);\n  return '0x' + Buffer.from(addressBytes).toString('hex');\n}\n\n/**\n * EVM signature verifier (Ethereum, Arbitrum, Base, Polygon, etc.).\n *\n * Verifies `personal_sign` (EIP-191) signatures using secp256k1 ecrecover.\n * Accepts signatures with or without `0x` prefix. Address comparison is case-insensitive.\n *\n * @param address - EVM address (`0x...`, 42 chars).\n * @param message - The nonce string that was signed.\n * @param signature - Hex signature: `0x` + r(32B) + s(32B) + v(1B) = 132 chars.\n */\nexport const evm: Verifier = (address, message, signature) => {\n  try {\n    const hash = hashPersonalMessage(message);\n\n    // Parse signature: 0x + r(32 bytes) + s(32 bytes) + v(1 byte) = 0x + 130 hex chars\n    const sig = signature.startsWith('0x') ? signature.slice(2) : signature;\n    if (sig.length !== 130) return false;\n\n    const r = BigInt('0x' + sig.slice(0, 64));\n    const s = BigInt('0x' + sig.slice(64, 128));\n    const v = parseInt(sig.slice(128, 130), 16);\n\n    // v is 27 or 28 (legacy) or 0 or 1 (raw recovery id)\n    const recovery = v >= 27 ? v - 27 : v;\n    if (recovery !== 0 && recovery !== 1) return false;\n\n    const sigObj = new secp256k1.Signature(r, s, recovery);\n    const recovered = sigObj.recoverPublicKey(hash);\n    const recoveredAddress = publicKeyToAddress(recovered.toRawBytes(false));\n\n    return recoveredAddress.toLowerCase() === address.toLowerCase();\n  } catch {\n    return false;\n  }\n};\n","import { createPublicKey, verify } from 'node:crypto';\nimport type { Verifier } from '../types.js';\n\n// Fixed DER prefix for Ed25519 SPKI public keys (12 bytes)\nconst ED25519_DER_PREFIX = Buffer.from('302a300506032b6570032100', 'hex');\n\nconst BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';\n\nfunction decodeBase58(input: string): Buffer {\n  const bytes: number[] = [];\n  for (const char of input) {\n    const idx = BASE58_ALPHABET.indexOf(char);\n    if (idx === -1) throw new Error('Invalid base58 character');\n    let carry = idx;\n    for (let j = 0; j < bytes.length; j++) {\n      carry += bytes[j] * 58;\n      bytes[j] = carry & 0xff;\n      carry >>= 8;\n    }\n    while (carry > 0) {\n      bytes.push(carry & 0xff);\n      carry >>= 8;\n    }\n  }\n  bytes.reverse();\n  // Leading '1's in base58 = leading zero bytes\n  let leadingZeros = 0;\n  for (const char of input) {\n    if (char !== '1') break;\n    leadingZeros++;\n  }\n  const result = new Uint8Array(leadingZeros + bytes.length);\n  // First leadingZeros bytes are already 0, copy computed bytes after\n  result.set(bytes, leadingZeros);\n  return Buffer.from(result);\n}\n\nfunction parsePublicKey(address: string): Buffer | null {\n  try {\n    // Hex-encoded 32-byte key (64 hex chars)\n    if (/^[0-9a-fA-F]{64}$/.test(address)) {\n      return Buffer.from(address, 'hex');\n    }\n    // Base58-encoded (Solana addresses: 32-44 chars from base58 alphabet)\n    if (/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address)) {\n      const decoded = decodeBase58(address);\n      if (decoded.length === 32) return decoded;\n    }\n    return null;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Ed25519 signature verifier (Solana, raw ed25519 keypairs).\n *\n * Accepts addresses as base58 (Solana, 32-44 chars) or hex (64 chars).\n * Accepts signatures as hex (128 chars), base58 (Solana convention), or base64.\n * Uses Node.js built-in `crypto` — zero external dependencies.\n *\n * @param address - Public key as base58 (Solana) or hex string.\n * @param message - The nonce string that was signed.\n * @param signature - 64-byte signature in hex, base58, or base64 encoding.\n */\nexport const ed25519: Verifier = (address, message, signature) => {\n  try {\n    const publicKeyRaw = parsePublicKey(address);\n    if (!publicKeyRaw || publicKeyRaw.length !== 32) return false;\n\n    // Signature: hex (128 chars), base58 (Solana convention), or base64\n    let sigBuffer: Buffer;\n    if (/^[0-9a-fA-F]{128}$/.test(signature)) {\n      sigBuffer = Buffer.from(signature, 'hex');\n    } else if (/^[1-9A-HJ-NP-Za-km-z]{1,90}$/.test(signature)) {\n      // Could be base58 — decode and validate length, fall back to base64\n      const decoded = decodeBase58(signature);\n      if (decoded.length === 64) {\n        sigBuffer = decoded;\n      } else {\n        sigBuffer = Buffer.from(signature, 'base64');\n      }\n    } else {\n      sigBuffer = Buffer.from(signature, 'base64');\n    }\n    if (sigBuffer.length !== 64) return false;\n\n    // Wrap raw public key in DER/SPKI format for Node.js crypto\n    const derKey = Buffer.concat([ED25519_DER_PREFIX, publicKeyRaw]);\n    const keyObject = createPublicKey({\n      key: derKey,\n      format: 'der',\n      type: 'spki',\n    });\n\n    return verify(null, Buffer.from(message), keyObject, sigBuffer);\n  } catch {\n    return false;\n  }\n};\n","import { evm } from './evm.js';\nimport { ed25519 } from './ed25519.js';\n\nexport const verifiers = {\n  /**\n   * EVM signature verifier (Ethereum, Arbitrum, Base, Polygon, etc.).\n   * Verifies `personal_sign` (EIP-191) signatures using secp256k1 ecrecover.\n   */\n  evm,\n  /**\n   * Ed25519 signature verifier (Solana, raw ed25519 keypairs).\n   * Accepts addresses as base58 or hex. Signatures as hex, base58, or base64.\n   */\n  ed25519,\n};\n"],"mappings":"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","names":["DEFAULT_EXPIRES_IN"]}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@shipooor/walletauth",
+  "version": "0.1.0",
+  "description": "Your wallet is your API key. Agent-native auth for APIs.",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "wallet",
+    "auth",
+    "authentication",
+    "signature",
+    "jwt",
+    "agent",
+    "ai-agent",
+    "web3",
+    "evm",
+    "solana",
+    "ed25519",
+    "secp256k1"
+  ],
+  "author": "walletauth",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shipooor/walletauth.git"
+  },
+  "homepage": "https://walletauth.shipooor.xyz",
+  "bugs": {
+    "url": "https://github.com/shipooor/walletauth/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@noble/curves": "^1.8.0",
+    "@noble/hashes": "^1.7.0",
+    "jose": "^6.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}