@4mica/sdk 0.5.0 → 0.5.2

package/tests/auth.integration.test.ts

@@ -1,97 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { Wallet } from 'ethers';
-import { AuthSession } from '../src/auth';
-import { Client } from '../src/client';
-import { ConfigBuilder } from '../src/config';
-import { RpcError } from '../src/errors';
-
-const DEFAULT_RPC_URL = 'http://127.0.0.1:3000';
-const DEFAULT_AUTH_URL = 'http://127.0.0.1:3000';
-const DEFAULT_PAYER_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
-
-const integrationEnabled = process.env['4MICA_INTEGRATION'] === '1';
-const describeIntegration = integrationEnabled ? describe : describe.skip;
-
-const resolveRpcUrl = (): string => process.env['4MICA_RPC_URL'] ?? DEFAULT_RPC_URL;
-const resolveAuthUrl = (rpcUrl: string): string =>
-  process.env['4MICA_AUTH_URL'] ?? rpcUrl ?? DEFAULT_AUTH_URL;
-const resolvePrivateKey = (): string =>
-  process.env['PAYER_KEY'] ?? process.env['4MICA_WALLET_PRIVATE_KEY'] ?? DEFAULT_PAYER_KEY;
-
-const isUnauthorized = (err: unknown): boolean => err instanceof RpcError && err.status === 401;
-
-const resolveBearerToken = async (authUrl: string, privateKey: string): Promise<string> => {
-  const token = process.env['4MICA_BEARER_TOKEN'];
-  if (token) {
-    return token;
-  }
-  const session = new AuthSession({ authUrl, privateKey });
-  try {
-    const tokens = await session.login();
-    return tokens.accessToken;
-  } finally {
-    await session.logout();
-  }
-};
-
-describeIntegration('Auth integration', () => {
-  it('auth login allows core request', async () => {
-    const rpcUrl = resolveRpcUrl();
-    const authUrl = resolveAuthUrl(rpcUrl);
-    const privateKey = resolvePrivateKey();
-
-    const cfg = new ConfigBuilder()
-      .rpcUrl(rpcUrl)
-      .walletPrivateKey(privateKey)
-      .authUrl(authUrl)
-      .enableAuth()
-      .build();
-
-    const client = await Client.new(cfg);
-    try {
-      const tokens = await client.login();
-      expect(tokens.accessToken).toBeTruthy();
-      expect(tokens.refreshToken).toBeTruthy();
-
-      const userAddress = new Wallet(privateKey).address;
-      const asset = process.env['ASSET_ADDRESS'] ?? '0x0000000000000000000000000000000000000000';
-      try {
-        await client.rpc.getUserAssetBalance(userAddress, asset);
-      } catch (err) {
-        if (isUnauthorized(err)) {
-          throw err;
-        }
-      }
-    } finally {
-      await client.aclose();
-    }
-  });
-
-  it('bearer token allows core request', async () => {
-    const rpcUrl = resolveRpcUrl();
-    const authUrl = resolveAuthUrl(rpcUrl);
-    const privateKey = resolvePrivateKey();
-    const bearerToken = await resolveBearerToken(authUrl, privateKey);
-
-    const cfg = new ConfigBuilder()
-      .rpcUrl(rpcUrl)
-      .walletPrivateKey(privateKey)
-      .bearerToken(bearerToken)
-      .build();
-
-    const client = await Client.new(cfg);
-    try {
-      const userAddress = new Wallet(privateKey).address;
-      const asset = process.env['ASSET_ADDRESS'] ?? '0x0000000000000000000000000000000000000000';
-      try {
-        await client.rpc.getUserAssetBalance(userAddress, asset);
-      } catch (err) {
-        if (isUnauthorized(err)) {
-          throw err;
-        }
-      }
-    } finally {
-      await client.aclose();
-    }
-  });
-});

package/tests/auth.test.ts

@@ -1,292 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { AuthClient, AuthSession, buildSiweMessage } from '../src/auth';
-import { AuthApiError, AuthConfigError, AuthDecodeError, AuthTransportError } from '../src/errors';
-import type { FetchFn } from '../src/rpc';
-import { createLocalSigner, ValidationError } from '../src';
-
-const PRIVATE_KEY = '0x59c6995e998f97a5a0044976f7be35d5ad91c0cfa55b5cfb20b07a1c60f4c5bc';
-
-const noncePayload = {
-  nonce: 'nonce-123',
-  siwe: {
-    domain: 'example.com',
-    uri: 'https://example.com/login',
-    chain_id: 1,
-    statement: 'Sign in',
-    expiration: '2024-01-01T00:00:00Z',
-    issued_at: '2024-01-01T00:00:00Z',
-  },
-};
-
-describe('buildSiweMessage', () => {
-  it('formats message for signing', () => {
-    const message = buildSiweMessage({
-      domain: 'example.com',
-      address: '0xabc',
-      statement: 'Sign in',
-      uri: 'https://example.com',
-      chainId: 1,
-      nonce: 'nonce',
-      issuedAt: '2024-01-01T00:00:00Z',
-      expiration: '2024-01-02T00:00:00Z',
-    });
-    expect(message).toBe(
-      [
-        'example.com wants you to sign in with your Ethereum account:',
-        '0xabc',
-        '',
-        'Sign in',
-        '',
-        'URI: https://example.com',
-        'Version: 1',
-        'Chain ID: 1',
-        'Nonce: nonce',
-        'Issued At: 2024-01-01T00:00:00Z',
-        'Expiration Time: 2024-01-02T00:00:00Z',
-      ].join('\n')
-    );
-  });
-});
-
-describe('AuthClient', () => {
-  it('parses siwe templates in snake_case and camelCase', async () => {
-    const snakeFetch = vi.fn<FetchFn>(async () => {
-      return new Response(JSON.stringify(noncePayload), { status: 200 });
-    });
-    const snakeClient = new AuthClient('https://auth.example.com', snakeFetch);
-    const snake = await snakeClient.getNonce('0x123');
-    expect(snake.siwe.chainId).toBe(1);
-    expect(snake.siwe.issuedAt).toBe('2024-01-01T00:00:00Z');
-
-    const camelFetch = vi.fn<FetchFn>(async () => {
-      return new Response(
-        JSON.stringify({
-          nonce: 'nonce-456',
-          siwe: {
-            domain: 'example.com',
-            uri: 'https://example.com/login',
-            chainId: 5,
-            statement: 'Sign in',
-            expiration: '2024-02-01T00:00:00Z',
-            issuedAt: '2024-02-01T00:00:00Z',
-          },
-        }),
-        { status: 200 }
-      );
-    });
-    const camelClient = new AuthClient('https://auth.example.com', camelFetch);
-    const camel = await camelClient.getNonce('0x123');
-    expect(camel.siwe.chainId).toBe(5);
-    expect(camel.siwe.issuedAt).toBe('2024-02-01T00:00:00Z');
-  });
-
-  it('throws on invalid JSON responses', async () => {
-    const fetchMock = vi.fn<FetchFn>(async () => new Response('not-json', { status: 200 }));
-    const client = new AuthClient('https://auth.example.com', fetchMock);
-    await expect(client.getNonce('0x123')).rejects.toThrow(AuthDecodeError);
-  });
-
-  it('surfaces non-2xx errors with json bodies', async () => {
-    const fetchMock = vi.fn<FetchFn>(async () => {
-      return new Response(JSON.stringify({ error: 'nope' }), { status: 401 });
-    });
-    const client = new AuthClient('https://auth.example.com', fetchMock);
-    await expect(client.getNonce('0x123')).rejects.toThrow(AuthApiError);
-  });
-
-  it('surfaces non-2xx errors with text bodies', async () => {
-    const fetchMock = vi.fn<FetchFn>(async () => new Response('nope', { status: 500 }));
-    const client = new AuthClient('https://auth.example.com', fetchMock);
-    await expect(client.getNonce('0x123')).rejects.toThrow(AuthApiError);
-  });
-
-  it('wraps transport errors', async () => {
-    const fetchMock = vi.fn<FetchFn>(async () => {
-      throw new Error('boom');
-    });
-    const client = new AuthClient('https://auth.example.com', fetchMock);
-    await expect(client.getNonce('0x123')).rejects.toThrow(AuthTransportError);
-  });
-});
-
-describe('AuthSession', () => {
-  it('caches tokens and refreshes when expiring', async () => {
-    let nowMs = 0;
-    const nowSpy = vi.spyOn(Date, 'now').mockImplementation(() => nowMs);
-
-    try {
-      const calls = { nonce: 0, verify: 0, refresh: 0 };
-      const fetchMock: FetchFn = async (input, init) => {
-        const path = new URL(input.toString()).pathname;
-        if (path === '/auth/nonce') {
-          calls.nonce += 1;
-          const body = JSON.parse(init?.body as string);
-          expect(body.address).toBeTruthy();
-          return new Response(JSON.stringify(noncePayload), { status: 200 });
-        }
-        if (path === '/auth/verify') {
-          calls.verify += 1;
-          const body = JSON.parse(init?.body as string);
-          expect(body.address).toBeTruthy();
-          return new Response(
-            JSON.stringify({
-              access_token: 'access-1',
-              refresh_token: 'refresh-1',
-              expires_in: 120,
-            }),
-            { status: 200 }
-          );
-        }
-        if (path === '/auth/refresh') {
-          calls.refresh += 1;
-          return new Response(
-            JSON.stringify({
-              access_token: 'access-2',
-              refresh_token: 'refresh-2',
-              expires_in: 120,
-            }),
-            { status: 200 }
-          );
-        }
-        return new Response('not found', { status: 404 });
-      };
-
-      const session = new AuthSession({
-        authUrl: 'https://auth.example.com',
-        signer: createLocalSigner(PRIVATE_KEY),
-        refreshMarginSecs: 30,
-        fetchFn: fetchMock,
-      });
-
-      const first = await session.accessToken();
-      expect(first).toBe('access-1');
-      expect(calls.nonce).toBe(1);
-      expect(calls.verify).toBe(1);
-
-      nowMs = 10_000;
-      const cached = await session.accessToken();
-      expect(cached).toBe('access-1');
-      expect(calls.refresh).toBe(0);
-
-      nowMs = 100_000;
-      const refreshed = await session.accessToken();
-      expect(refreshed).toBe('access-2');
-      expect(calls.refresh).toBe(1);
-    } finally {
-      nowSpy.mockRestore();
-    }
-  });
-
-  it('falls back to login when refresh returns 401', async () => {
-    let nowMs = 0;
-    const nowSpy = vi.spyOn(Date, 'now').mockImplementation(() => nowMs);
-
-    try {
-      const calls = { nonce: 0, verify: 0, refresh: 0 };
-      const fetchMock: FetchFn = async (input, init) => {
-        const path = new URL(input.toString()).pathname;
-        if (path === '/auth/nonce') {
-          calls.nonce += 1;
-          const body = JSON.parse(init?.body as string);
-          expect(body.address).toBeTruthy();
-          return new Response(JSON.stringify(noncePayload), { status: 200 });
-        }
-        if (path === '/auth/verify') {
-          calls.verify += 1;
-          const body = JSON.parse(init?.body as string);
-          expect(body.address).toBeTruthy();
-          return new Response(
-            JSON.stringify({
-              access_token: `access-${calls.verify}`,
-              refresh_token: `refresh-${calls.verify}`,
-              expires_in: 5,
-            }),
-            { status: 200 }
-          );
-        }
-        if (path === '/auth/refresh') {
-          calls.refresh += 1;
-          return new Response('unauthorized', { status: 401 });
-        }
-        return new Response('not found', { status: 404 });
-      };
-
-      const session = new AuthSession({
-        authUrl: 'https://auth.example.com',
-        signer: createLocalSigner(PRIVATE_KEY),
-        refreshMarginSecs: 0,
-        fetchFn: fetchMock,
-      });
-
-      const first = await session.accessToken();
-      expect(first).toBe('access-1');
-
-      nowMs = 10_000;
-      const second = await session.accessToken();
-      expect(second).toBe('access-2');
-      expect(calls.refresh).toBe(1);
-      expect(calls.verify).toBe(2);
-      expect(calls.nonce).toBe(2);
-    } finally {
-      nowSpy.mockRestore();
-    }
-  });
-
-  it('single-flights concurrent accessToken calls', async () => {
-    const calls = { nonce: 0, verify: 0 };
-    const fetchMock: FetchFn = async (input, init) => {
-      const path = new URL(input.toString()).pathname;
-      if (path === '/auth/nonce') {
-        calls.nonce += 1;
-        const body = JSON.parse(init?.body as string);
-        expect(body.address).toBeTruthy();
-        return new Response(JSON.stringify(noncePayload), { status: 200 });
-      }
-      if (path === '/auth/verify') {
-        calls.verify += 1;
-        const body = JSON.parse(init?.body as string);
-        expect(body.address).toBeTruthy();
-        return new Response(
-          JSON.stringify({
-            access_token: 'access-1',
-            refresh_token: 'refresh-1',
-            expires_in: 120,
-          }),
-          { status: 200 }
-        );
-      }
-      return new Response('not found', { status: 404 });
-    };
-
-    const session = new AuthSession({
-      authUrl: 'https://auth.example.com',
-      signer: createLocalSigner(PRIVATE_KEY),
-      fetchFn: fetchMock,
-    });
-
-    const [first, second] = await Promise.all([session.accessToken(), session.accessToken()]);
-    expect(first).toBe('access-1');
-    expect(second).toBe('access-1');
-    expect(calls.nonce).toBe(1);
-    expect(calls.verify).toBe(1);
-  });
-
-  it('rejects invalid private keys and negative refresh margins', () => {
-    expect(
-      () =>
-        new AuthSession({
-          authUrl: 'https://auth.example.com',
-          signer: createLocalSigner('0x1234'),
-        })
-    ).toThrow(ValidationError);
-
-    expect(
-      () =>
-        new AuthSession({
-          authUrl: 'https://auth.example.com',
-          signer: createLocalSigner(PRIVATE_KEY),
-          refreshMarginSecs: -1,
-        })
-    ).toThrow(AuthConfigError);
-  });
-});

package/tests/config.test.ts

@@ -1,56 +0,0 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
-import { ConfigBuilder } from '../src/config';
-import { ConfigError } from '../src/errors';
-
-describe('ConfigBuilder', () => {
-  beforeEach(() => {
-    vi.resetModules();
-  });
-
-  afterEach(() => {
-    delete process.env['4MICA_RPC_URL'];
-    delete process.env['4MICA_WALLET_PRIVATE_KEY'];
-    delete process.env['4MICA_ETHEREUM_HTTP_RPC_URL'];
-    delete process.env['4MICA_CONTRACT_ADDRESS'];
-    delete process.env['4MICA_ADMIN_API_KEY'];
-    delete process.env['4MICA_AUTH_URL'];
-    delete process.env['4MICA_AUTH_REFRESH_MARGIN_SECS'];
-    delete process.env['4MICA_BEARER_TOKEN'];
-  });
-
-  it('reads from env', () => {
-    process.env['4MICA_RPC_URL'] = 'https://example.com';
-    process.env['4MICA_WALLET_PRIVATE_KEY'] = '11'.repeat(32);
-    const cfg = new ConfigBuilder().fromEnv().build();
-    expect(cfg.rpcUrl).toBe('https://example.com');
-    expect(cfg.walletPrivateKey.startsWith('0x11')).toBe(true);
-  });
-
-  it('requires private key', () => {
-    delete process.env['4MICA_WALLET_PRIVATE_KEY'];
-    const builder = new ConfigBuilder().fromEnv();
-    expect(() => builder.build()).toThrow(ConfigError);
-  });
-
-  it('rejects invalid private key', () => {
-    const builder = new ConfigBuilder().walletPrivateKey('0x1234');
-    expect(() => builder.build()).toThrow(ConfigError);
-  });
-
-  it('reads auth env defaults', () => {
-    process.env['4MICA_RPC_URL'] = 'https://example.com';
-    process.env['4MICA_WALLET_PRIVATE_KEY'] = '11'.repeat(32);
-    process.env['4MICA_AUTH_REFRESH_MARGIN_SECS'] = '90';
-    const cfg = new ConfigBuilder().fromEnv().build();
-    expect(cfg.authUrl).toBe('https://example.com');
-    expect(cfg.authRefreshMarginSecs).toBe(90);
-  });
-
-  it('reads bearer token', () => {
-    process.env['4MICA_RPC_URL'] = 'https://example.com';
-    process.env['4MICA_WALLET_PRIVATE_KEY'] = '11'.repeat(32);
-    process.env['4MICA_BEARER_TOKEN'] = 'token';
-    const cfg = new ConfigBuilder().fromEnv().build();
-    expect(cfg.bearerToken).toBe('token');
-  });
-});

package/tests/guarantee.test.ts

@@ -1,26 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { decodeGuaranteeClaims, encodeGuaranteeClaims } from '../src/guarantee';
-import { PaymentGuaranteeClaims } from '../src/models';
-
-describe('guarantee codec', () => {
-  it('round trips guarantee claims', () => {
-    const claims: PaymentGuaranteeClaims = {
-      domain: new Uint8Array(32),
-      userAddress: '0x0000000000000000000000000000000000000001',
-      recipientAddress: '0x0000000000000000000000000000000000000002',
-      tabId: 1n,
-      reqId: 2n,
-      amount: 3n,
-      totalAmount: 4n,
-      assetAddress: '0x0000000000000000000000000000000000000000',
-      timestamp: 123456,
-      version: 1,
-    };
-    const encoded = encodeGuaranteeClaims(claims);
-    const decoded = decodeGuaranteeClaims(encoded);
-    expect(decoded.userAddress).toBe(claims.userAddress);
-    expect(decoded.recipientAddress).toBe(claims.recipientAddress);
-    expect(decoded.tabId).toBe(claims.tabId);
-    expect(decoded.amount).toBe(claims.amount);
-  });
-});

package/tests/rpc.test.ts

@@ -1,76 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { RpcProxy } from '../src/rpc';
-import type { FetchFn } from '../src/rpc';
-import { RpcError } from '../src/errors';
-
-describe('RpcProxy', () => {
-  it('round trips public params', async () => {
-    const params = {
-      publicKey: [1, 2, 3],
-      contractAddress: '0x1234567890abcdef1234567890abcdef12345678',
-      ethereumHttpRpcUrl: 'http://localhost:8545',
-      eip712Name: '4mica',
-      eip712Version: '1',
-      chainId: 1337,
-    };
-    const fetchMock = vi.fn<FetchFn>(async (input) => {
-      const url = input.toString();
-      expect(url.endsWith('/core/public-params')).toBe(true);
-      return new Response(JSON.stringify(params), { status: 200 });
-    });
-
-    const proxy = new RpcProxy('http://example.com', undefined, fetchMock);
-    const got = await proxy.getPublicParams();
-    expect(got.chainId).toBe(1337);
-    expect(got.contractAddress).toBe(params.contractAddress);
-    expect(got.ethereumHttpRpcUrl).toBe(params.ethereumHttpRpcUrl);
-  });
-
-  it('surfaces api errors', async () => {
-    const fetchMock = vi.fn<FetchFn>(async (input) => {
-      expect(input.toString()).toContain('settlement_status=unknown');
-      return new Response(JSON.stringify({ error: 'invalid settlement status: unknown' }), {
-        status: 400,
-      });
-    });
-    const proxy = new RpcProxy('http://example.com', undefined, fetchMock);
-    await expect(proxy.listRecipientTabs('0xdeadbeef', ['unknown'])).rejects.toThrow(RpcError);
-  });
-
-  it('returns decode error on invalid json', async () => {
-    const fetchMock = vi.fn<FetchFn>(async () => {
-      return new Response('not-json', { status: 200 });
-    });
-    const proxy = new RpcProxy('http://example.com', undefined, fetchMock);
-    await expect(proxy.getPublicParams()).rejects.toThrow(RpcError);
-  });
-
-  it('adds bearer tokens without double prefixing', async () => {
-    const params = {
-      publicKey: [1, 2, 3],
-      contractAddress: '0x1234567890abcdef1234567890abcdef12345678',
-      ethereumHttpRpcUrl: 'http://localhost:8545',
-      eip712Name: '4mica',
-      eip712Version: '1',
-      chainId: 1337,
-    };
-
-    const fetchRaw = vi.fn<FetchFn>(async (_input, init) => {
-      const headers = init?.headers as Record<string, string>;
-      expect(headers.Authorization).toBe('Bearer token');
-      return new Response(JSON.stringify(params), { status: 200 });
-    });
-    await new RpcProxy('http://example.com', undefined, fetchRaw)
-      .withBearerToken('token')
-      .getPublicParams();
-
-    const fetchPrefixed = vi.fn<FetchFn>(async (_input, init) => {
-      const headers = init?.headers as Record<string, string>;
-      expect(headers.Authorization).toBe('Bearer token');
-      return new Response(JSON.stringify(params), { status: 200 });
-    });
-    await new RpcProxy('http://example.com', undefined, fetchPrefixed)
-      .withBearerToken('Bearer token')
-      .getPublicParams();
-  });
-});

package/tests/signing.test.ts

@@ -1,52 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { PaymentGuaranteeRequestClaims, SigningScheme } from '../src/models';
-import { CorePublicParameters, createLocalSigner, PaymentSigner } from '../src/signing';
-import { SigningError } from '../src/errors';
-
-function buildParams(): CorePublicParameters {
-  return new CorePublicParameters(
-    new Uint8Array(),
-    '0x0000000000000000000000000000000000000000',
-    'https://example.com',
-    '4Mica',
-    '1',
-    1
-  );
-}
-
-describe('PaymentSigner', () => {
-  it('rejects address mismatch', async () => {
-    const signer = new PaymentSigner(createLocalSigner('11'.repeat(32)));
-    const claims = PaymentGuaranteeRequestClaims.new(
-      '0x0000000000000000000000000000000000000011',
-      '0x0000000000000000000000000000000000000002',
-      1,
-      5,
-      1234,
-      null,
-      7
-    );
-    await expect(signer.signRequest(buildParams(), claims, SigningScheme.EIP712)).rejects.toThrow(
-      SigningError
-    );
-  });
-
-  it('produces eip712 signature', async () => {
-    const privateKey = '0x59c6995e998f97a5a0044976f7be35d5ad91c0cfa55b5cfb20b07a1c60f4c5bc';
-    const localSigner = createLocalSigner(privateKey);
-    const signer = new PaymentSigner(localSigner);
-    const accountAddress = localSigner.address.toLowerCase();
-    const claims = PaymentGuaranteeRequestClaims.new(
-      accountAddress,
-      '0x0000000000000000000000000000000000000002',
-      42,
-      123,
-      999,
-      null,
-      2
-    );
-    const sig = await signer.signRequest(buildParams(), claims, SigningScheme.EIP712);
-    expect(sig.scheme).toBe(SigningScheme.EIP712);
-    expect(sig.signature.length).toBe(132);
-  });
-});

package/tests/utils.test.ts

@@ -1,35 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  ValidationError,
-  normalizeAddress,
-  normalizePrivateKey,
-  parseU256,
-  serializeU256,
-  validateUrl,
-} from '../src/utils';
-
-describe('utils', () => {
-  it('validateUrl rejects bad input', () => {
-    expect(() => validateUrl('not-a-url')).toThrow(ValidationError);
-  });
-
-  it('normalizePrivateKey strips prefix and lowercases', () => {
-    const key = normalizePrivateKey('0xABCDEF' + '0'.repeat(58));
-    expect(key).toBe('0xabcdef' + '0'.repeat(58));
-  });
-
-  it('parseU256 accepts hex strings and serializes back', () => {
-    const value = parseU256('0x10');
-    expect(value).toBe(16n);
-    expect(serializeU256(value)).toBe('0x10');
-  });
-
-  it('normalizeAddress round trips checksum', () => {
-    const addr = '0x0000000000000000000000000000000000000001';
-    expect(normalizeAddress(addr)).toBe('0x0000000000000000000000000000000000000001');
-  });
-
-  it('parseU256 rejects negatives', () => {
-    expect(() => parseU256(-1)).toThrow(ValidationError);
-  });
-});