@brninpay/sdk 0.1.0

package/test/architecture/architecture-invariants.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest'
+import { readFileSync, readdirSync, statSync } from 'fs'
+import { join, relative } from 'path'
+
+const SRC = join(import.meta.dirname, '../../src')
+
+const nodeBuiltins = [
+  'fs', 'path', 'crypto', 'http', 'https', 'os', 'child_process',
+  'stream', 'net', 'dns', 'buffer', 'events', 'assert', 'tls',
+  'cluster', 'dgram', 'readline', 'repl', 'vm', 'worker_threads',
+  'perf_hooks', 'async_hooks', 'v8', 'inspector', 'wasi',
+  'diagnostics_channel',
+]
+
+function walk(dir: string): string[] {
+  const files: string[] = []
+  try {
+    for (const entry of readdirSync(dir)) {
+      const full = join(dir, entry)
+      if (statSync(full).isDirectory()) {
+        files.push(...walk(full))
+      } else if (entry.endsWith('.ts') && !entry.endsWith('.d.ts')) {
+        files.push(full)
+      }
+    }
+  } catch { /* skip */ }
+  return files
+}
+
+function parseImports(source: string): string[] {
+  const imports: string[] = []
+  const re = /import(?: type)?\s+(?:\{[^}]*\}|[^'"]+)\s+from\s+['"]([^'"]+)['"]/g
+  let m
+  while ((m = re.exec(source)) !== null) imports.push(m[1])
+  return imports
+}
+
+describe('@brninpay/sdk — architecture invariants', () => {
+  const files = walk(SRC)
+  const nodeViolations: { file: string; imp: string }[] = []
+
+  for (const file of files) {
+    const source = readFileSync(file, 'utf8')
+    const imports = parseImports(source)
+    const rel = relative(SRC, file)
+
+    for (const imp of imports) {
+      if (nodeBuiltins.includes(imp.split('/')[0])) {
+        nodeViolations.push({ file: rel, imp })
+      }
+    }
+  }
+
+  it('must not import Node.js builtins (fs, crypto, http, path, etc.)', () => {
+    expect(nodeViolations, fmt('Node builtins', nodeViolations)).toHaveLength(0)
+  })
+})
+
+function fmt(label: string, v: { file: string; imp: string }[]): string {
+  return v.length ? `\n\n${label}:\n${v.map((x) => `  ${x.file} → ${x.imp}`).join('\n')}` : ''
+}

package/test/client.test.ts

@@ -0,0 +1,180 @@
+import { ValidationError } from '@brninpay/core'
+import { describe, expect, it, vi } from 'vitest'
+import { BrninpayClient } from '../src/client.js'
+
+function createJsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: {
+      'content-type': 'application/json',
+    },
+  })
+}
+
+describe('BrninpayClient', () => {
+  it('signs requests with HMAC headers when apiSecret is configured', async () => {
+    const fetchMock = vi.fn(async () => createJsonResponse({ ok: true }))
+    const client = new BrninpayClient({
+      apiKey: 'key_123',
+      apiSecret: 'secret_123',
+      baseUrl: 'http://localhost:3000',
+      fetchImplementation: fetchMock as typeof fetch,
+    })
+
+    await client.request({
+      path: '/v1/health',
+      method: 'POST',
+      body: { hello: 'world' },
+    })
+
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+    const [, requestInit] = fetchMock.mock.calls[0] as [string, RequestInit]
+    const headers = new Headers(requestInit.headers)
+
+    expect(headers.get('X-API-Key')).toBe('key_123')
+    expect(headers.get('X-Signature')).toMatch(/^[0-9a-f]+$/)
+    expect(headers.get('X-Timestamp')).toContain('T')
+    expect(headers.get('X-Nonce')).toHaveLength(32)
+    expect(headers.get('Authorization')).toBeNull()
+  })
+
+  it('retries transient failures with exponential backoff behavior', async () => {
+    const fetchMock = vi
+      .fn<Parameters<typeof fetch>, ReturnType<typeof fetch>>()
+      .mockResolvedValueOnce(createJsonResponse({ error: 'temporary' }, 500))
+      .mockResolvedValueOnce(createJsonResponse({ ok: true }, 200))
+
+    const client = new BrninpayClient({
+      apiKey: 'key_123',
+      baseUrl: 'http://localhost:3000',
+      fetchImplementation: fetchMock as typeof fetch,
+      retryPolicy: {
+        retries: 1,
+        baseDelayMs: 1,
+        maxDelayMs: 1,
+      },
+    })
+
+    const response = await client.request<{ ok: boolean }>({
+      path: '/v1/health',
+      method: 'GET',
+    })
+
+    expect(response.ok).toBe(true)
+    expect(fetchMock).toHaveBeenCalledTimes(2)
+  })
+
+  it('maps API validation errors into typed SDK errors', async () => {
+    const fetchMock = vi.fn(async () =>
+      createJsonResponse(
+        {
+          code: 'validation_error',
+          message: 'invalid payload',
+          details: { field: 'amount' },
+        },
+        400
+      )
+    )
+
+    const client = new BrninpayClient({
+      apiKey: 'key_123',
+      baseUrl: 'http://localhost:3000',
+      fetchImplementation: fetchMock as typeof fetch,
+    })
+
+    await expect(
+      client.request({
+        path: '/v1/payment-intents',
+        method: 'POST',
+        body: { invalid: true },
+      })
+    ).rejects.toBeInstanceOf(ValidationError)
+  })
+
+  it('creates and parses payment intents with bigint amounts', async () => {
+    const fetchMock = vi.fn(async () =>
+      createJsonResponse({
+        id: 'pi_123',
+        workspaceId: 'ws_123',
+        actorId: 'actor_123',
+        status: 'approved',
+        amount: {
+          currency: 'USDC',
+          value: '1500000',
+          decimals: 6,
+        },
+        recipient: {
+          address: '0x1111111111111111111111111111111111111111',
+          chainId: 8453,
+        },
+        createdAt: '2026-07-06T10:00:00.000Z',
+        updatedAt: '2026-07-06T10:00:00.000Z',
+      })
+    )
+
+    const client = new BrninpayClient({
+      apiKey: 'key_123',
+      baseUrl: 'http://localhost:3000',
+      fetchImplementation: fetchMock as typeof fetch,
+    })
+
+    const paymentIntent = await client.paymentIntents.createPaymentIntent({
+      workspaceId: 'ws_123',
+      actorId: 'actor_123',
+      idempotencyKey: 'idem_123',
+      amount: {
+        currency: 'USDC',
+        value: 1500000n,
+      },
+      recipient: {
+        address: '0x1111111111111111111111111111111111111111',
+        chainId: 8453,
+      },
+    })
+
+    expect(paymentIntent.amount.value).toBe(1500000n)
+
+    const [, requestInit] = fetchMock.mock.calls[0] as [string, RequestInit]
+    const headers = new Headers(requestInit.headers)
+    expect(headers.get('Idempotency-Key')).toBe('idem_123')
+  })
+
+  it('lists payment intents and preserves pagination cursors', async () => {
+    const fetchMock = vi.fn(async () =>
+      createJsonResponse({
+        items: [
+          {
+            id: 'pi_123',
+            workspaceId: 'ws_123',
+            actorId: 'actor_123',
+            status: 'submitted',
+            amount: {
+              currency: 'USDC',
+              value: '1500000',
+              decimals: 6,
+            },
+            recipient: {
+              address: '0x1111111111111111111111111111111111111111',
+              chainId: 8453,
+            },
+            createdAt: '2026-07-06T10:00:00.000Z',
+            updatedAt: '2026-07-06T10:00:00.000Z',
+          },
+        ],
+        nextCursor: 'cursor_2',
+      })
+    )
+
+    const client = new BrninpayClient({
+      apiKey: 'key_123',
+      baseUrl: 'http://localhost:3000',
+      fetchImplementation: fetchMock as typeof fetch,
+    })
+
+    const result = await client.paymentIntents.listPaymentIntents({ limit: 10 })
+
+    expect(result.items).toHaveLength(1)
+    expect(result.items[0]?.status).toBe('submitted')
+    expect(result.nextCursor).toBe('cursor_2')
+  })
+})

package/test/conversion.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest'
+import { parseUsdc, formatUsdc } from '../src/conversion.js'
+
+describe('parseUsdc', () => {
+  it('converts whole USDC to smallest unit', () => {
+    expect(parseUsdc('1')).toBe(1_000_000n)
+    expect(parseUsdc('100')).toBe(100_000_000n)
+  })
+
+  it('converts decimal USDC to smallest unit', () => {
+    expect(parseUsdc('0.05')).toBe(50_000n)
+    expect(parseUsdc('1.5')).toBe(1_500_000n)
+  })
+
+  it('handles very small amounts', () => {
+    expect(parseUsdc('0.000001')).toBe(1n)
+  })
+
+  it('throws on invalid input', () => {
+    expect(() => parseUsdc('not-a-number')).toThrow()
+  })
+})
+
+describe('formatUsdc', () => {
+  it('converts smallest unit to whole USDC string', () => {
+    expect(formatUsdc(1_000_000n)).toBe('1')
+    expect(formatUsdc(100_000_000n)).toBe('100')
+  })
+
+  it('converts smallest unit to decimal USDC string', () => {
+    expect(formatUsdc(50_000n)).toBe('0.05')
+    expect(formatUsdc(1_500_000n)).toBe('1.5')
+  })
+
+  it('handles zero', () => {
+    expect(formatUsdc(0n)).toBe('0')
+  })
+
+  it('handles 1 micro USDC', () => {
+    expect(formatUsdc(1n)).toBe('0.000001')
+  })
+})

package/test/runtimee.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it, vi } from 'vitest'
+import { Runtimee } from '../src/runtimee.js'
+import type { RuntimeeConfig } from '../src/types.js'
+
+describe('Runtimee', () => {
+  const config: RuntimeeConfig = {
+    apiKey: 're_test_key',
+    baseUrl: 'http://localhost:3000',
+  }
+
+  it('creates instance with config', () => {
+    const rt = new Runtimee(config)
+    expect(rt).toBeDefined()
+  })
+
+  it('throws without apiKey', () => {
+    expect(() => new Runtimee({} as RuntimeeConfig)).toThrow('apiKey')
+  })
+
+  it('exposes actors namespace', () => {
+    const rt = new Runtimee(config)
+    expect(rt.actors).toBeDefined()
+    expect(rt.paymentIntents).toBeDefined()
+    expect(rt.policies).toBeDefined()
+    expect(typeof rt.actors.create).toBe('function')
+    expect(typeof rt.actors.pay).toBe('function')
+    expect(typeof rt.actors.previewPay).toBe('function')
+    expect(typeof rt.actors.status).toBe('function')
+  })
+})

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "lib": ["ES2022", "DOM"]
+  },
+  "include": ["src"]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    include: ['test/**/*.test.ts'],
+    exclude: ['test/**/*.integration.test.ts', 'test/**/*.e2e.test.ts'],
+  },
+})