@pay-skill/sdk 0.1.8 → 0.1.11

package/tests/test_e2e.ts

@@ -1,158 +1,99 @@
 /**
  * E2E acceptance tests — run against live testnet.
  *
- * Skip unless PAYSKILL_TESTNET_KEY is set. These hit the real testnet server
- * and exercise the full SDK → server round-trip with REAL authentication.
+ * Skip unless PAYSKILL_TESTNET_KEY is set.
  *
  * Usage:
- *   PAYSKILL_TESTNET_KEY=0xdead... \
- *   PAYSKILL_TESTNET_URL=http://204.168.133.111:3001/api/v1 \
- *   node --import tsx --test tests/test_e2e.ts
+ *   PAYSKILL_TESTNET_KEY=0xdead... node --import tsx --test tests/test_e2e.ts
  */
 
 import { describe, it, before } from "node:test";
 import assert from "node:assert/strict";
 import { randomUUID } from "node:crypto";
+import { Wallet, PayValidationError } from "../src/index.js";
 
-import { PayClient, PayValidationError, PayServerError, buildAuthHeaders } from "../src/index.js";
-import type { WebhookRegistration, AuthHeaders } from "../src/index.js";
-import type { Hex } from "viem";
-
-const TESTNET_URL =
-  process.env.PAYSKILL_TESTNET_URL ?? "http://204.168.133.111:3001/api/v1";
 const TESTNET_KEY = process.env.PAYSKILL_TESTNET_KEY ?? "";
-
-// Testnet contract addresses (Base Sepolia)
-const CHAIN_ID = 84532;
-const ROUTER_ADDRESS = "0xE0Aa45e6937F3b9Fc0BEe457361885Cb9bfC067F";
-
 const skip = !TESTNET_KEY;
 
-function makeClient(): PayClient {
-  return new PayClient({
-    apiUrl: TESTNET_URL,
-    privateKey: TESTNET_KEY,
-    chainId: CHAIN_ID,
-    routerAddress: ROUTER_ADDRESS,
-  });
+function makeWallet(): Wallet {
+  return new Wallet({ privateKey: TESTNET_KEY, testnet: true });
 }
 
-// ── Auth Verification ──────────────────────────────────────────────
-
-describe("E2E: Auth works with real signing", { skip }, () => {
-  let client: PayClient;
+describe("E2E: Status + Balance", { skip }, () => {
+  let wallet: Wallet;
+  before(() => { wallet = makeWallet(); });
 
-  before(() => {
-    client = makeClient();
-  });
-
-  it("status endpoint returns valid response with real auth", async () => {
-    const status = await client.getStatus();
-    assert.ok(typeof status.address === "string");
+  it("status returns valid response", async () => {
+    const status = await wallet.status();
     assert.ok(status.address.startsWith("0x"));
-    assert.ok(typeof status.balance === "number");
-    assert.ok(status.balance >= 0);
-    assert.ok(Array.isArray(status.openTabs));
+    assert.ok(status.balance.total >= 0);
+    assert.ok(typeof status.openTabs === "number");
   });
 
-  it("rejects request without auth headers (raw fetch)", async () => {
-    const resp = await fetch(`${TESTNET_URL}/status`);
-    assert.equal(resp.status, 400, "should reject unauthenticated request");
-    const body = (await resp.json()) as { error: string };
-    assert.equal(body.error, "auth_missing");
+  it("balance returns total/locked/available", async () => {
+    const bal = await wallet.balance();
+    assert.ok(typeof bal.total === "number");
+    assert.ok(typeof bal.locked === "number");
+    assert.ok(typeof bal.available === "number");
+    assert.ok(bal.available <= bal.total);
   });
 });
 
-// ── Mint (Testnet Faucet) ──────────────────────────────────────────
-
 describe("E2E: Mint testnet USDC", { skip }, () => {
-  let client: PayClient;
+  let wallet: Wallet;
+  before(() => { wallet = makeWallet(); });
 
-  before(() => {
-    client = makeClient();
-  });
-
-  it("mints $10 USDC to the authenticated wallet", async () => {
-    const headers = await buildAuthHeaders(
-      TESTNET_KEY as Hex,
-      "POST",
-      "/api/v1/mint",
-      { chainId: CHAIN_ID, routerAddress: ROUTER_ADDRESS }
-    );
-    const resp = await fetch(`${TESTNET_URL}/mint`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", ...headers },
-      body: JSON.stringify({ amount: 10_000_000 }),
-    });
-    const bodyText = await resp.text();
-    assert.equal(resp.status, 200, `mint failed: ${bodyText}`);
-    const body = JSON.parse(bodyText) as { tx_hash: string; amount: number; to: string };
-    assert.ok(body.tx_hash, "should return a tx_hash");
-    assert.equal(body.amount, 10_000_000);
-    assert.ok(body.to.startsWith("0x"));
+  it("mints $10 USDC", async () => {
+    const result = await wallet.mint(10);
+    assert.ok(result.txHash);
+    assert.equal(result.amount, 10);
   });
 });
 
-// ── Webhook CRUD ───────────────────────────────────────────────────
-
-describe("E2E: Webhook CRUD with real auth", { skip }, () => {
-  let client: PayClient;
-  let whId = "";
-
-  before(() => {
-    client = makeClient();
-  });
+describe("E2E: Webhook CRUD", { skip }, () => {
+  let wallet: Wallet;
+  let hookId = "";
+  before(() => { wallet = makeWallet(); });
 
   it("registers a webhook", async () => {
     const slug = randomUUID().slice(0, 8);
-    const wh = await client.registerWebhook(
+    const wh = await wallet.registerWebhook(
       `https://example.com/hook/${slug}`,
-      {
-        events: ["payment.completed"],
-        secret: `whsec_test_${slug}`,
-      }
+      ["payment.completed"],
+      `whsec_test_${slug}`,
     );
-    assert.ok(wh.webhookId);
+    assert.ok(wh.id);
     assert.ok(wh.url.startsWith("https://"));
-    assert.ok(wh.events.includes("payment.completed"));
-    whId = wh.webhookId;
+    hookId = wh.id;
   });
 
-  it("lists webhooks including the new one", async () => {
-    const webhooks = await client.listWebhooks();
-    assert.ok(Array.isArray(webhooks));
-    const ids = webhooks.map((w: WebhookRegistration) => w.webhookId);
-    assert.ok(ids.includes(whId));
+  it("lists webhooks", async () => {
+    const hooks = await wallet.listWebhooks();
+    assert.ok(hooks.some((h) => h.id === hookId));
   });
 
   it("deletes the webhook", async () => {
-    await client.deleteWebhook(whId);
-    const webhooks = await client.listWebhooks();
-    const ids = webhooks.map((w: WebhookRegistration) => w.webhookId);
-    assert.ok(!ids.includes(whId));
+    await wallet.deleteWebhook(hookId);
+    const hooks = await wallet.listWebhooks();
+    assert.ok(!hooks.some((h) => h.id === hookId));
   });
 });
 
-// ── Client-side validation still works ─────────────────────────────
-
-describe("E2E: Client validation", { skip }, () => {
-  let client: PayClient;
-
-  before(() => {
-    client = makeClient();
-  });
+describe("E2E: Validation still works", { skip }, () => {
+  let wallet: Wallet;
+  before(() => { wallet = makeWallet(); });
 
   it("rejects invalid address", async () => {
     await assert.rejects(
-      () => client.payDirect("not-an-address", 1_000_000),
-      (err: unknown) => err instanceof PayValidationError
+      () => wallet.send("not-an-address", 5),
+      PayValidationError,
     );
   });
 
   it("rejects amount below minimum", async () => {
     await assert.rejects(
-      () => client.payDirect("0x" + "a1".repeat(20), 500_000),
-      (err: unknown) => err instanceof PayValidationError
+      () => wallet.send("0x" + "a1".repeat(20), 0.5),
+      PayValidationError,
     );
   });
 });

package/tests/test_errors.ts

@@ -13,7 +13,7 @@ describe("error hierarchy", () => {
     assert.ok(new PayValidationError("x") instanceof PayError);
     assert.ok(new PayNetworkError("x") instanceof PayError);
     assert.ok(new PayServerError("x", 400) instanceof PayError);
-    assert.ok(new PayInsufficientFundsError() instanceof PayError);
+    assert.ok(new PayInsufficientFundsError("x") instanceof PayError);
   });
 
   it("PayValidationError has field and code", () => {
@@ -33,4 +33,12 @@ describe("error hierarchy", () => {
     const err = new PayNetworkError("connection refused");
     assert.equal(err.code, "network_error");
   });
+
+  it("PayInsufficientFundsError includes fund link hint", () => {
+    const err = new PayInsufficientFundsError("low balance", 5, 10);
+    assert.ok(err.message.includes("createFundLink"));
+    assert.equal(err.balance, 5);
+    assert.equal(err.required, 10);
+    assert.equal(err.code, "insufficient_funds");
+  });
 });

package/tests/test_ows.ts

@@ -0,0 +1,153 @@
+/**
+ * OWS (Open Wallet Standard) integration tests.
+ * Uses a mock OWS module — no real @open-wallet-standard/core needed.
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { Wallet, PayError } from "../src/index.js";
+
+// ── Mock OWS module ──────────────────────────────────────────────────
+
+interface SignCall {
+  wallet: string;
+  chain: string;
+  json: string;
+  passphrase?: string;
+}
+
+function createMockOws(options?: {
+  accounts?: Array<{
+    chainId: string;
+    address: string;
+    derivationPath: string;
+  }>;
+  signature?: string;
+  recoveryId?: number;
+}) {
+  const calls: SignCall[] = [];
+  const accounts = options?.accounts ?? [
+    {
+      chainId: "eip155:8453",
+      address: "0x1234567890abcdef1234567890abcdef12345678",
+      derivationPath: "m/44'/60'/0'/0/0",
+    },
+  ];
+
+  // Default: 65-byte hex sig (r+s+v)
+  const sig = options?.signature ?? "ab".repeat(64) + "1b";
+
+  return {
+    calls,
+    getWallet(nameOrId: string) {
+      return {
+        id: `id-${nameOrId}`,
+        name: nameOrId,
+        accounts,
+        createdAt: "2026-04-01T00:00:00Z",
+      };
+    },
+    signTypedData(
+      wallet: string,
+      chain: string,
+      typedDataJson: string,
+      passphrase?: string,
+    ) {
+      calls.push({ wallet, chain, json: typedDataJson, passphrase });
+      return {
+        signature: sig,
+        recoveryId: options?.recoveryId,
+      };
+    },
+  };
+}
+
+// ── Construction ──────────────────────────────────────────────────────
+
+describe("Wallet.fromOws construction", () => {
+  it("creates wallet with correct address from mock OWS", async () => {
+    const ows = createMockOws();
+    const wallet = await Wallet.fromOws({
+      walletId: "test-agent",
+      _owsModule: ows,
+    });
+    assert.equal(
+      wallet.address,
+      "0x1234567890abcdef1234567890abcdef12345678",
+    );
+  });
+
+  it("finds evm chain account", async () => {
+    const ows = createMockOws({
+      accounts: [
+        {
+          chainId: "evm",
+          address: "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+          derivationPath: "m/44'/60'/0'/0/0",
+        },
+      ],
+    });
+    const wallet = await Wallet.fromOws({
+      walletId: "test",
+      _owsModule: ows,
+    });
+    assert.equal(
+      wallet.address,
+      "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+    );
+  });
+
+  it("throws when no EVM account found", async () => {
+    const ows = createMockOws({
+      accounts: [
+        {
+          chainId: "solana",
+          address: "SoLaNa...",
+          derivationPath: "m/44'/501'/0'",
+        },
+      ],
+    });
+    await assert.rejects(
+      () => Wallet.fromOws({ walletId: "test", _owsModule: ows }),
+      PayError,
+    );
+  });
+
+  it("throws when OWS module not installed (no mock)", async () => {
+    await assert.rejects(
+      () =>
+        Wallet.fromOws({
+          walletId: "test",
+          // _owsModule not provided -> tries dynamic import, fails
+        }),
+      PayError,
+    );
+  });
+
+  it("passes owsApiKey to signTypedData", async () => {
+    const ows = createMockOws();
+    const wallet = await Wallet.fromOws({
+      walletId: "agent-1",
+      owsApiKey: "secret-key",
+      _owsModule: ows,
+    });
+    // Trigger a signing call (will fail on network but the mock captures the call)
+    // We can't easily trigger signing without a server, so just verify construction
+    assert.equal(wallet.address, "0x1234567890abcdef1234567890abcdef12345678");
+  });
+});
+
+// ── Serialization safety ──────────────────────────────────────────────
+
+describe("Wallet.fromOws does not leak keys", () => {
+  it("JSON.stringify does not expose private fields", async () => {
+    const ows = createMockOws();
+    const wallet = await Wallet.fromOws({
+      walletId: "secret-agent",
+      _owsModule: ows,
+    });
+    const json = JSON.stringify(wallet);
+    assert.ok(!json.includes("secret-agent"));
+    assert.ok(!json.includes("signTypedData"));
+  });
+});

package/tests/test_wallet.ts

@@ -0,0 +1,194 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import type { Hex } from "viem";
+import { Wallet, PayError, PayValidationError } from "../src/index.js";
+
+// Anvil account #0 — well-known test key
+const ANVIL_PK =
+  "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
+const ANVIL_ADDRESS = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
+const VALID_ADDR = "0x" + "a1".repeat(20);
+
+// Save/restore env for tests that modify it
+let savedEnv: Record<string, string | undefined>;
+
+function saveEnv() {
+  savedEnv = {
+    PAYSKILL_KEY: process.env.PAYSKILL_KEY,
+    PAYSKILL_TESTNET: process.env.PAYSKILL_TESTNET,
+    PAYSKILL_API_URL: process.env.PAYSKILL_API_URL,
+  };
+}
+
+function restoreEnv() {
+  for (const [k, v] of Object.entries(savedEnv)) {
+    if (v === undefined) delete process.env[k];
+    else process.env[k] = v;
+  }
+}
+
+// ── Construction ──────────────────────────────────────────────────────
+
+describe("Wallet construction", () => {
+  beforeEach(saveEnv);
+  afterEach(restoreEnv);
+
+  it("constructs with explicit private key", () => {
+    const wallet = new Wallet({ privateKey: ANVIL_PK });
+    assert.equal(wallet.address, ANVIL_ADDRESS);
+  });
+
+  it("constructs without 0x prefix", () => {
+    const wallet = new Wallet({ privateKey: ANVIL_PK.slice(2) });
+    assert.equal(wallet.address, ANVIL_ADDRESS);
+  });
+
+  it("constructs from PAYSKILL_KEY env var", () => {
+    process.env.PAYSKILL_KEY = ANVIL_PK;
+    const wallet = new Wallet();
+    assert.equal(wallet.address, ANVIL_ADDRESS);
+  });
+
+  it("throws without key", () => {
+    delete process.env.PAYSKILL_KEY;
+    assert.throws(() => new Wallet(), PayError);
+  });
+
+  it("throws on invalid key (too short)", () => {
+    assert.throws(
+      () => new Wallet({ privateKey: "0xdead" }),
+      PayValidationError,
+    );
+  });
+
+  it("throws on invalid key (non-hex)", () => {
+    assert.throws(
+      () => new Wallet({ privateKey: "0x" + "zz".repeat(32) }),
+      PayValidationError,
+    );
+  });
+
+  it("Wallet.fromEnv reads PAYSKILL_KEY", () => {
+    process.env.PAYSKILL_KEY = ANVIL_PK;
+    const wallet = Wallet.fromEnv();
+    assert.equal(wallet.address, ANVIL_ADDRESS);
+  });
+
+  it("Wallet.fromEnv throws without env var", () => {
+    delete process.env.PAYSKILL_KEY;
+    assert.throws(() => Wallet.fromEnv(), PayError);
+  });
+
+  it("Wallet.create falls back to env var when keychain unavailable", async () => {
+    process.env.PAYSKILL_KEY = ANVIL_PK;
+    const wallet = await Wallet.create();
+    assert.equal(wallet.address, ANVIL_ADDRESS);
+  });
+
+  it("respects testnet option", () => {
+    process.env.PAYSKILL_KEY = ANVIL_PK;
+    // Just verify it doesn't throw — testnet flag affects API URL only
+    const wallet = new Wallet({ testnet: true });
+    assert.equal(wallet.address, ANVIL_ADDRESS);
+  });
+
+  it("respects PAYSKILL_TESTNET env var", () => {
+    process.env.PAYSKILL_KEY = ANVIL_PK;
+    process.env.PAYSKILL_TESTNET = "1";
+    const wallet = new Wallet();
+    assert.equal(wallet.address, ANVIL_ADDRESS);
+  });
+});
+
+// ── Validation ──────────────────────────────────────────────────────
+
+describe("Wallet input validation", () => {
+  let wallet: Wallet;
+
+  beforeEach(() => {
+    wallet = new Wallet({ privateKey: ANVIL_PK });
+  });
+
+  it("send rejects invalid address", async () => {
+    await assert.rejects(
+      () => wallet.send("not-an-address", 5),
+      PayValidationError,
+    );
+  });
+
+  it("send rejects amount below $1 minimum", async () => {
+    await assert.rejects(
+      () => wallet.send(VALID_ADDR, 0.5),
+      PayValidationError,
+    );
+  });
+
+  it("send rejects negative amount", async () => {
+    await assert.rejects(
+      () => wallet.send(VALID_ADDR, -5),
+      PayValidationError,
+    );
+  });
+
+  it("send rejects NaN", async () => {
+    await assert.rejects(
+      () => wallet.send(VALID_ADDR, NaN),
+      PayValidationError,
+    );
+  });
+
+  it("send rejects Infinity", async () => {
+    await assert.rejects(
+      () => wallet.send(VALID_ADDR, Infinity),
+      PayValidationError,
+    );
+  });
+
+  it("openTab rejects amount below $5 minimum", async () => {
+    await assert.rejects(
+      () => wallet.openTab(VALID_ADDR, 3, 1),
+      PayValidationError,
+    );
+  });
+
+  it("openTab rejects zero maxChargePerCall", async () => {
+    await assert.rejects(
+      () => wallet.openTab(VALID_ADDR, 10, 0),
+      PayValidationError,
+    );
+  });
+
+  it("openTab rejects invalid provider address", async () => {
+    await assert.rejects(
+      () => wallet.openTab("bad-addr", 10, 1),
+      PayValidationError,
+    );
+  });
+
+  it("mint rejects on mainnet", async () => {
+    await assert.rejects(() => wallet.mint(10), PayError);
+  });
+
+  it("micro amount conversion works", async () => {
+    // $5 micro amount should not fail validation for tab (need network for full test)
+    await assert.rejects(
+      () => wallet.openTab(VALID_ADDR, { micro: 5_000_000 }, { micro: 100_000 }),
+      // Will fail on network (can't reach server), not validation
+      (err: Error) => !(err instanceof PayValidationError),
+    );
+  });
+
+  it("micro amount rejects negative", async () => {
+    await assert.rejects(
+      () => wallet.send(VALID_ADDR, { micro: -1 }),
+      PayValidationError,
+    );
+  });
+
+  it("micro amount rejects non-integer", async () => {
+    await assert.rejects(
+      () => wallet.send(VALID_ADDR, { micro: 1.5 }),
+      PayValidationError,
+    );
+  });
+});

package/dist/client.d.ts

@@ -1,94 +0,0 @@
-/**
- * PayClient — single entry point for the pay SDK.
- */
-import type { DirectPaymentResult, DiscoverOptions, DiscoverService, StatusResponse, Tab, WebhookRegistration } from "./models.js";
-import type { Signer } from "./signer.js";
-export declare const DEFAULT_API_URL = "https://pay-skill.com/api/v1";
-export interface PayClientOptions {
-    apiUrl?: string;
-    signer?: Signer | "cli" | "raw" | "custom";
-    signerOptions?: {
-        command?: string;
-        key?: string;
-        address?: string;
-        callback?: (hash: Uint8Array) => Uint8Array;
-    };
-    /** Private key for direct auth signing (alternative to signer). */
-    privateKey?: string;
-    /** Chain ID for EIP-712 domain (default: 8453 for Base). */
-    chainId?: number;
-    /** Router contract address for EIP-712 domain. */
-    routerAddress?: string;
-}
-export declare class PayClient {
-    private readonly apiUrl;
-    /** URL path prefix extracted from apiUrl (e.g., "/api/v1"). */
-    private readonly _basePath;
-    private readonly signer;
-    private readonly _privateKey;
-    private readonly _authConfig;
-    private readonly _chainId;
-    private readonly _address;
-    constructor(options?: PayClientOptions);
-    private getContracts;
-    payDirect(to: string, amount: number, options?: {
-        memo?: string;
-    }): Promise<DirectPaymentResult>;
-    openTab(provider: string, amount: number, options: {
-        maxChargePerCall: number;
-    }): Promise<Tab>;
-    closeTab(tabId: string): Promise<Tab>;
-    topUpTab(tabId: string, amount: number): Promise<Tab>;
-    listTabs(): Promise<Tab[]>;
-    getTab(tabId: string): Promise<Tab>;
-    private static readonly X402_TAB_MULTIPLIER;
-    request(url: string, options?: {
-        method?: string;
-        body?: unknown;
-        headers?: Record<string, string>;
-    }): Promise<Response>;
-    /**
-     * Parse x402 V2 payment requirements from a 402 response.
-     *
-     * Checks PAYMENT-REQUIRED header first (base64-encoded JSON),
-     * falls back to response body for requirements.
-     */
-    private parse402Requirements;
-    private static extractRequirements;
-    private handle402;
-    private settleViaDirect;
-    private settleViaTab;
-    getStatus(): Promise<StatusResponse>;
-    registerWebhook(url: string, options?: {
-        events?: string[];
-        secret?: string;
-    }): Promise<WebhookRegistration>;
-    listWebhooks(): Promise<WebhookRegistration[]>;
-    deleteWebhook(webhookId: string): Promise<void>;
-    /** Create a one-time fund link via the server. Returns the dashboard URL. */
-    createFundLink(options?: {
-        messages?: unknown[];
-        agentName?: string;
-    }): Promise<string>;
-    /** Create a one-time withdraw link via the server. Returns the dashboard URL. */
-    createWithdrawLink(options?: {
-        messages?: unknown[];
-        agentName?: string;
-    }): Promise<string>;
-    /** Search for discoverable paid API services. Public, no auth required. */
-    discover(options?: DiscoverOptions): Promise<DiscoverService[]>;
-    /**
-     * Prepare and sign a USDC EIP-2612 permit.
-     *
-     * 1. Calls GET /api/v1/permit/prepare to get the EIP-712 hash
-     * 2. Signs the hash with the agent's private key
-     * 3. Returns {nonce, deadline, v, r, s} for inclusion in payment body
-     */
-    private prepareAndSignPermit;
-    private authHeaders;
-    private get;
-    private post;
-    private del;
-    private handleResponse;
-}
-//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}