@remitmd/sdk 0.1.0

package/tests/test_mock.ts

@@ -0,0 +1,217 @@
+import { describe, it, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+
+import { MockRemit } from "../src/testing/mock.js";
+import { InsufficientBalanceError } from "../src/errors.js";
+
+describe("MockRemit", () => {
+  let mock: MockRemit;
+
+  beforeEach(() => {
+    mock = new MockRemit();
+  });
+
+  it("createWallet returns wallet with correct balance", async () => {
+    const wallet = mock.createWallet(500);
+    const bal = await wallet.balance();
+    assert.equal(bal, 500);
+  });
+
+  it("payDirect transfers funds", async () => {
+    const payer = mock.createWallet(100);
+    const payee = mock.createWallet(0);
+    const tx = await payer.payDirect(payee.address, 30);
+    assert.equal(tx.status, "confirmed");
+    assert.equal(await payer.balance(), 70);
+    assert.equal(await payee.balance(), 30);
+  });
+
+  it("payDirect throws on insufficient balance", async () => {
+    const payer = mock.createWallet(10);
+    const payee = mock.createWallet(0);
+    await assert.rejects(
+      () => payer.payDirect(payee.address, 100),
+      InsufficientBalanceError,
+    );
+  });
+
+  it("escrow: fund, release", async () => {
+    const payer = mock.createWallet(200);
+    const payee = mock.createWallet(0);
+
+    const tx = await payer.pay({
+      id: "inv-001",
+      from: payer.address,
+      to: payee.address,
+      amount: 100,
+      chain: "base",
+      status: "pending",
+      paymentType: "escrow",
+      createdAt: Math.floor(Date.now() / 1000),
+    });
+
+    assert(tx.txHash);
+    assert.equal(await payer.balance(), 100); // deducted on fund
+
+    const releaseTx = await payer.releaseEscrow("inv-001");
+    assert.equal(releaseTx.status, "confirmed");
+    assert.equal(await payee.balance(), 100);
+  });
+
+  it("escrow: fund, cancel — refunds payer", async () => {
+    const payer = mock.createWallet(200);
+    const payee = mock.createWallet(0);
+
+    await payer.pay({
+      id: "inv-002",
+      from: payer.address,
+      to: payee.address,
+      amount: 50,
+      chain: "base",
+      status: "pending",
+      paymentType: "escrow",
+      createdAt: Math.floor(Date.now() / 1000),
+    });
+
+    assert.equal(await payer.balance(), 150);
+    await payer.cancelEscrow("inv-002");
+    assert.equal(await payer.balance(), 200); // refunded
+    assert.equal(await payee.balance(), 0);
+  });
+
+  it("tab: open, close — refunds unspent", async () => {
+    const payer = mock.createWallet(100);
+    const payee = mock.createWallet(0);
+
+    const tab = await payer.openTab({ to: payee.address, limit: 50, perUnit: 5 });
+    assert.equal(tab.status, "open");
+    assert.equal(await payer.balance(), 50); // limit deducted
+
+    const closeTx = await payer.closeTab(tab.id);
+    assert.equal(closeTx.status, "confirmed");
+    // No charges — full refund
+    assert.equal(await payer.balance(), 100);
+    assert.equal(await payee.balance(), 0);
+  });
+
+  it("tab throws when tab not found", async () => {
+    const payer = mock.createWallet(100);
+    await assert.rejects(() => payer.closeTab("nonexistent"), /TAB_NOT_FOUND|Tab not found/);
+  });
+
+  it("stream: open, close after time advance — correct accounting", async () => {
+    const payer = mock.createWallet(1000);
+    const payee = mock.createWallet(0);
+
+    const stream = await payer.openStream({ to: payee.address, rate: 1, maxDuration: 100 });
+    assert.equal(stream.status, "active");
+    assert.equal(await payer.balance(), 900); // reserve of 100 deducted
+
+    mock.advanceTime(30);
+    await payer.closeStream(stream.id);
+
+    const payerBal = await payer.balance();
+    const payeeBal = await payee.balance();
+    assert(payerBal > 960 && payerBal <= 970, `payer balance ${payerBal} should be ~970`);
+    assert(payeeBal >= 30 && payeeBal <= 40, `payee balance ${payeeBal} should be ~30`);
+  });
+
+  it("bounty: post, award", async () => {
+    const poster = mock.createWallet(100);
+    const winner = mock.createWallet(0);
+    const deadline = Math.floor(Date.now() / 1000) + 86400;
+
+    const bounty = await poster.postBounty({ amount: 50, task: "Write tests", deadline });
+    assert.equal(bounty.status, "open");
+    assert.equal(await poster.balance(), 50);
+
+    await winner.submitBounty(bounty.id, "0xevidence");
+    await poster.awardBounty(bounty.id, 1);
+    const b = mock.getBounty(bounty.id);
+    assert.equal(b.status, "awarded");
+    assert.equal(b.winner, winner.address);
+    assert.equal(await winner.balance(), 50);
+  });
+
+  it("deposit: locks funds", async () => {
+    const payer = mock.createWallet(100);
+    const payee = mock.createWallet(0);
+
+    const deposit = await payer.placeDeposit({ to: payee.address, amount: 30, expires: 3600 });
+    assert.equal(deposit.status, "locked");
+    assert.equal(await payer.balance(), 70);
+  });
+
+  it("status includes balance and tier", async () => {
+    const wallet = mock.createWallet(555);
+    const status = await wallet.status();
+    assert.equal(parseFloat(status.balance), 555);
+    assert(status.tier.length > 0);
+  });
+
+  it("reputation returns valid profile", async () => {
+    const wallet = mock.createWallet();
+    const rep = await wallet.getReputation(wallet.address);
+    assert.equal(rep.address, wallet.address);
+    assert(rep.score >= 0);
+  });
+
+  it("setBehavior forces next operation to fail", async () => {
+    const payer = mock.createWallet(100);
+    const payee = mock.createWallet(0);
+    mock.setBehavior(payer.address, "INSUFFICIENT_BALANCE");
+    await assert.rejects(() => payer.payDirect(payee.address, 1));
+    // Second call should succeed (error was consumed)
+    const tx = await payer.payDirect(payee.address, 1);
+    assert.equal(tx.status, "confirmed");
+  });
+
+  it("advanceTime affects stream accounting", async () => {
+    const payer = mock.createWallet(1000);
+    const payee = mock.createWallet(0);
+
+    const stream = await payer.openStream({ to: payee.address, rate: 10, maxDuration: 60 });
+    mock.advanceTime(60); // full duration
+    await payer.closeStream(stream.id);
+
+    assert.equal(await payee.balance(), 600); // 10/s * 60s
+    assert.equal(await payer.balance(), 400); // 1000 - 600
+  });
+
+  it("listBounties filters by status", async () => {
+    const poster = mock.createWallet(1000);
+    const w2 = mock.createWallet(0);
+    const deadline = Math.floor(Date.now() / 1000) + 86400;
+
+    const b1 = await poster.postBounty({ amount: 10, task: "Task A", deadline });
+    await poster.postBounty({ amount: 10, task: "Task B", deadline });
+    await w2.submitBounty(b1.id, "0xevidence");
+    await poster.awardBounty(b1.id, 1);
+
+    const open = mock.listBounties("open");
+    const awarded = mock.listBounties("awarded");
+    assert.equal(open.length, 1);
+    assert.equal(awarded.length, 1);
+  });
+
+  it("requestTestnetFunds adds 100 USDC", async () => {
+    const wallet = mock.createWallet(0);
+    await wallet.requestTestnetFunds();
+    assert.equal(await wallet.balance(), 100);
+  });
+
+  it("registerWebhook returns webhook object", async () => {
+    const wallet = mock.createWallet();
+    const wh = await wallet.registerWebhook("https://example.com/hook", ["payment.completed"]);
+    assert.equal(wh.url, "https://example.com/hook");
+    assert(wh.id.length > 0);
+  });
+
+  it("wallet toJSON does not expose private key", () => {
+    const wallet = mock.createWallet();
+    const json = JSON.stringify(wallet);
+    // Should not contain anything resembling a private key
+    assert(!json.includes("0x") || json.includes(wallet.address));
+    assert(json.includes(wallet.address));
+  });
+});

package/tests/test_permit.ts

@@ -0,0 +1,216 @@
+/**
+ * Tests for EIP-2612 permit signing (signUsdcPermit / signPermit).
+ *
+ * Verifies:
+ * - signUsdcPermit produces valid v/r/s format
+ * - Domain matches MockUSDC (name="USD Coin", version="2")
+ * - Signature is recoverable to the signer's address
+ * - signPermit computes correct raw amounts from USDC decimals
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { hashTypedData, recoverTypedDataAddress } from "viem";
+
+import { Wallet } from "../src/wallet.js";
+
+// Anvil test wallet #0
+const TEST_KEY = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
+const TEST_ADDR = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
+
+// Known contract addresses (Base Sepolia)
+const USDC_ADDRESS = "0x142aD61B8d2edD6b3807D9266866D97C35Ee0317";
+const ROUTER_ADDRESS = "0xb3E96ebE54138d1c0caea00Ae098309C7E0138eC";
+const ESCROW_ADDRESS = "0x9AC531dd432d5dcF637D288290E5A23F2eE36594";
+
+// EIP-2612 permit types
+const PERMIT_TYPES = {
+  Permit: [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+  ],
+} as const;
+
+const USDC_DOMAIN = {
+  name: "USD Coin",
+  version: "2",
+  chainId: 84532,
+  verifyingContract: USDC_ADDRESS as `0x${string}`,
+};
+
+describe("signUsdcPermit", () => {
+  const wallet = new Wallet({
+    privateKey: TEST_KEY,
+    chain: "base-sepolia",
+  });
+
+  it("returns valid PermitSignature shape", async () => {
+    const permit = await wallet.signUsdcPermit({
+      spender: ROUTER_ADDRESS,
+      value: BigInt(1_000_000), // 1 USDC
+      deadline: 1999999999,
+      nonce: 0,
+    });
+
+    assert.equal(typeof permit.value, "number");
+    assert.equal(permit.value, 1_000_000);
+    assert.equal(permit.deadline, 1999999999);
+    assert.equal(typeof permit.v, "number");
+    assert(permit.v === 27 || permit.v === 28, `v must be 27 or 28, got ${permit.v}`);
+    assert.match(permit.r, /^0x[0-9a-f]{64}$/i, "r must be 32 bytes hex");
+    assert.match(permit.s, /^0x[0-9a-f]{64}$/i, "s must be 32 bytes hex");
+  });
+
+  it("signature recovers to the wallet address", async () => {
+    const spender = ESCROW_ADDRESS;
+    const value = BigInt(5_000_000); // 5 USDC
+    const deadline = 2000000000;
+    const nonce = 0;
+
+    const permit = await wallet.signUsdcPermit({
+      spender,
+      value,
+      deadline,
+      nonce,
+    });
+
+    // Reconstruct the full signature hex
+    const rHex = permit.r.slice(2);
+    const sHex = permit.s.slice(2);
+    const vHex = permit.v.toString(16).padStart(2, "0");
+    const fullSig = `0x${rHex}${sHex}${vHex}` as `0x${string}`;
+
+    const recovered = await recoverTypedDataAddress({
+      domain: USDC_DOMAIN,
+      types: PERMIT_TYPES,
+      primaryType: "Permit",
+      message: {
+        owner: TEST_ADDR as `0x${string}`,
+        spender: spender as `0x${string}`,
+        value,
+        nonce: BigInt(nonce),
+        deadline: BigInt(deadline),
+      },
+      signature: fullSig,
+    });
+
+    assert.equal(
+      recovered.toLowerCase(),
+      TEST_ADDR.toLowerCase(),
+      "recovered address must match signer",
+    );
+  });
+
+  it("different nonces produce different signatures", async () => {
+    const base = {
+      spender: ROUTER_ADDRESS,
+      value: BigInt(1_000_000),
+      deadline: 1999999999,
+    };
+
+    const sig0 = await wallet.signUsdcPermit({ ...base, nonce: 0 });
+    const sig1 = await wallet.signUsdcPermit({ ...base, nonce: 1 });
+
+    assert.notEqual(sig0.r, sig1.r, "different nonces must produce different r");
+  });
+
+  it("different spenders produce different signatures", async () => {
+    const base = {
+      value: BigInt(1_000_000),
+      deadline: 1999999999,
+      nonce: 0,
+    };
+
+    const sigRouter = await wallet.signUsdcPermit({ ...base, spender: ROUTER_ADDRESS });
+    const sigEscrow = await wallet.signUsdcPermit({ ...base, spender: ESCROW_ADDRESS });
+
+    assert.notEqual(sigRouter.r, sigEscrow.r, "different spenders must produce different r");
+  });
+
+  it("uses correct EIP-712 domain (USD Coin v2)", async () => {
+    // Hash the typed data ourselves and verify the wallet's signature matches
+    const spender = ROUTER_ADDRESS;
+    const value = BigInt(2_500_000); // 2.5 USDC
+    const deadline = 2000000000;
+    const nonce = 0;
+
+    const expectedHash = hashTypedData({
+      domain: USDC_DOMAIN,
+      types: PERMIT_TYPES,
+      primaryType: "Permit",
+      message: {
+        owner: TEST_ADDR as `0x${string}`,
+        spender: spender as `0x${string}`,
+        value,
+        nonce: BigInt(nonce),
+        deadline: BigInt(deadline),
+      },
+    });
+
+    // Just verify the hash is deterministic — domain is correct if recovery works
+    assert.match(expectedHash, /^0x[0-9a-f]{64}$/i);
+
+    const permit = await wallet.signUsdcPermit({
+      spender,
+      value,
+      deadline,
+      nonce,
+    });
+
+    // Verify recovery with the domain we used
+    const rHex = permit.r.slice(2);
+    const sHex = permit.s.slice(2);
+    const vHex = permit.v.toString(16).padStart(2, "0");
+    const fullSig = `0x${rHex}${sHex}${vHex}` as `0x${string}`;
+
+    const recovered = await recoverTypedDataAddress({
+      domain: USDC_DOMAIN,
+      types: PERMIT_TYPES,
+      primaryType: "Permit",
+      message: {
+        owner: TEST_ADDR as `0x${string}`,
+        spender: spender as `0x${string}`,
+        value,
+        nonce: BigInt(nonce),
+        deadline: BigInt(deadline),
+      },
+      signature: fullSig,
+    });
+
+    assert.equal(
+      recovered.toLowerCase(),
+      TEST_ADDR.toLowerCase(),
+      "must recover with USD Coin v2 domain",
+    );
+  });
+});
+
+describe("PermitSignature value ranges", () => {
+  const wallet = new Wallet({
+    privateKey: TEST_KEY,
+    chain: "base-sepolia",
+  });
+
+  it("handles zero value", async () => {
+    const permit = await wallet.signUsdcPermit({
+      spender: ROUTER_ADDRESS,
+      value: BigInt(0),
+      deadline: 1999999999,
+      nonce: 0,
+    });
+    assert.equal(permit.value, 0);
+  });
+
+  it("handles large value ($2,500 = 2_500_000_000 raw)", async () => {
+    const permit = await wallet.signUsdcPermit({
+      spender: ROUTER_ADDRESS,
+      value: BigInt(2_500_000_000),
+      deadline: 1999999999,
+      nonce: 0,
+    });
+    assert.equal(permit.value, 2_500_000_000);
+  });
+});