@4mica/sdk 0.5.0 → 0.5.1

package/src/abi/erc20.json

@@ -1,187 +0,0 @@
-{
-  "abi": [
-    {
-      "type": "function",
-      "name": "allowance",
-      "inputs": [
-        {
-          "name": "owner",
-          "type": "address",
-          "internalType": "address"
-        },
-        {
-          "name": "spender",
-          "type": "address",
-          "internalType": "address"
-        }
-      ],
-      "outputs": [
-        {
-          "name": "",
-          "type": "uint256",
-          "internalType": "uint256"
-        }
-      ],
-      "stateMutability": "view"
-    },
-    {
-      "type": "function",
-      "name": "approve",
-      "inputs": [
-        {
-          "name": "spender",
-          "type": "address",
-          "internalType": "address"
-        },
-        {
-          "name": "value",
-          "type": "uint256",
-          "internalType": "uint256"
-        }
-      ],
-      "outputs": [
-        {
-          "name": "",
-          "type": "bool",
-          "internalType": "bool"
-        }
-      ],
-      "stateMutability": "nonpayable"
-    },
-    {
-      "type": "function",
-      "name": "balanceOf",
-      "inputs": [
-        {
-          "name": "account",
-          "type": "address",
-          "internalType": "address"
-        }
-      ],
-      "outputs": [
-        {
-          "name": "",
-          "type": "uint256",
-          "internalType": "uint256"
-        }
-      ],
-      "stateMutability": "view"
-    },
-    {
-      "type": "function",
-      "name": "totalSupply",
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "",
-          "type": "uint256",
-          "internalType": "uint256"
-        }
-      ],
-      "stateMutability": "view"
-    },
-    {
-      "type": "function",
-      "name": "transfer",
-      "inputs": [
-        {
-          "name": "to",
-          "type": "address",
-          "internalType": "address"
-        },
-        {
-          "name": "value",
-          "type": "uint256",
-          "internalType": "uint256"
-        }
-      ],
-      "outputs": [
-        {
-          "name": "",
-          "type": "bool",
-          "internalType": "bool"
-        }
-      ],
-      "stateMutability": "nonpayable"
-    },
-    {
-      "type": "function",
-      "name": "transferFrom",
-      "inputs": [
-        {
-          "name": "from",
-          "type": "address",
-          "internalType": "address"
-        },
-        {
-          "name": "to",
-          "type": "address",
-          "internalType": "address"
-        },
-        {
-          "name": "value",
-          "type": "uint256",
-          "internalType": "uint256"
-        }
-      ],
-      "outputs": [
-        {
-          "name": "",
-          "type": "bool",
-          "internalType": "bool"
-        }
-      ],
-      "stateMutability": "nonpayable"
-    },
-    {
-      "type": "event",
-      "name": "Approval",
-      "inputs": [
-        {
-          "name": "owner",
-          "type": "address",
-          "indexed": true,
-          "internalType": "address"
-        },
-        {
-          "name": "spender",
-          "type": "address",
-          "indexed": true,
-          "internalType": "address"
-        },
-        {
-          "name": "value",
-          "type": "uint256",
-          "indexed": false,
-          "internalType": "uint256"
-        }
-      ],
-      "anonymous": false
-    },
-    {
-      "type": "event",
-      "name": "Transfer",
-      "inputs": [
-        {
-          "name": "from",
-          "type": "address",
-          "indexed": true,
-          "internalType": "address"
-        },
-        {
-          "name": "to",
-          "type": "address",
-          "indexed": true,
-          "internalType": "address"
-        },
-        {
-          "name": "value",
-          "type": "uint256",
-          "indexed": false,
-          "internalType": "uint256"
-        }
-      ],
-      "anonymous": false
-    }
-  ]
-}

package/src/auth.ts

@@ -1,325 +0,0 @@
-import type { FetchFn } from './rpc';
-import {
-  AuthApiError,
-  AuthConfigError,
-  AuthDecodeError,
-  AuthMissingConfigError,
-  AuthTransportError,
-  AuthUrlError,
-} from './errors';
-import { ValidationError, validateUrl } from './utils';
-import { EvmSigner } from './signing';
-
-export type AuthTokens = {
-  accessToken: string;
-  refreshToken: string;
-  expiresIn: number;
-};
-
-export type SiweTemplate = {
-  domain: string;
-  uri: string;
-  chainId: number;
-  statement: string;
-  expiration: string;
-  issuedAt: string;
-};
-
-export type AuthNonceResponse = {
-  nonce: string;
-  siwe: SiweTemplate;
-};
-
-type RecordValue = Record<string, unknown>;
-
-const isRecord = (value: unknown): value is RecordValue =>
-  Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-
-const readString = (value: unknown, label: string): string => {
-  if (typeof value === 'string' && value.trim()) {
-    return value;
-  }
-  throw new AuthDecodeError(`invalid auth response: missing ${label}`);
-};
-
-const readNumber = (value: unknown, label: string): number => {
-  if (typeof value === 'number' && Number.isFinite(value)) {
-    return value;
-  }
-  if (typeof value === 'string' && value.trim()) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) {
-      return parsed;
-    }
-  }
-  throw new AuthDecodeError(`invalid auth response: missing ${label}`);
-};
-
-const parseTokens = (payload: RecordValue): AuthTokens => {
-  const accessToken = readString(payload.access_token ?? payload.accessToken, 'access_token');
-  const refreshToken = readString(payload.refresh_token ?? payload.refreshToken, 'refresh_token');
-  const expiresIn = readNumber(payload.expires_in ?? payload.expiresIn, 'expires_in');
-  return { accessToken, refreshToken, expiresIn };
-};
-
-const parseSiweTemplate = (payload: RecordValue): SiweTemplate => {
-  const domain = readString(payload.domain, 'siwe.domain');
-  const uri = readString(payload.uri, 'siwe.uri');
-  const chainId = readNumber(payload.chain_id ?? payload.chainId, 'siwe.chain_id');
-  const statement = readString(payload.statement, 'siwe.statement');
-  const expiration = readString(payload.expiration, 'siwe.expiration');
-  const issuedAt = readString(payload.issued_at ?? payload.issuedAt, 'siwe.issued_at');
-  return { domain, uri, chainId, statement, expiration, issuedAt };
-};
-
-const parseNonceResponse = (payload: unknown): AuthNonceResponse => {
-  if (!isRecord(payload)) {
-    throw new AuthDecodeError('invalid auth response: nonce payload');
-  }
-  const nonce = readString(payload.nonce, 'nonce');
-  if (!isRecord(payload.siwe)) {
-    throw new AuthDecodeError('invalid auth response: missing siwe template');
-  }
-  return { nonce, siwe: parseSiweTemplate(payload.siwe) };
-};
-
-export function buildSiweMessage(input: {
-  domain: string;
-  address: string;
-  statement: string;
-  uri: string;
-  chainId: number | string;
-  nonce: string;
-  issuedAt: string;
-  expiration: string;
-}): string {
-  const chainId = String(input.chainId);
-  return `${input.domain} wants you to sign in with your Ethereum account:\n${input.address}\n\n${input.statement}\n\nURI: ${input.uri}\nVersion: 1\nChain ID: ${chainId}\nNonce: ${input.nonce}\nIssued At: ${input.issuedAt}\nExpiration Time: ${input.expiration}`;
-}
-
-export class AuthClient {
-  private baseUrl: string;
-  private fetchFn: FetchFn;
-
-  constructor(endpoint: string, fetchFn: FetchFn = fetch) {
-    try {
-      const validated = validateUrl(endpoint);
-      this.baseUrl = validated.endsWith('/') ? validated.slice(0, -1) : validated;
-    } catch (err) {
-      if (err instanceof ValidationError) {
-        throw new AuthUrlError(err.message);
-      }
-      throw err;
-    }
-    this.fetchFn = fetchFn;
-  }
-
-  async getNonce(address: string): Promise<AuthNonceResponse> {
-    const payload = await this.post('/auth/nonce', { address });
-    return parseNonceResponse(payload);
-  }
-
-  async verify(address: string, message: string, signature: string): Promise<AuthTokens> {
-    const payload = await this.post('/auth/verify', { address, message, signature });
-    if (!isRecord(payload)) {
-      throw new AuthDecodeError('invalid auth response: verify payload');
-    }
-    return parseTokens(payload);
-  }
-
-  async refresh(refreshToken: string): Promise<AuthTokens> {
-    const payload = await this.post('/auth/refresh', { refresh_token: refreshToken });
-    if (!isRecord(payload)) {
-      throw new AuthDecodeError('invalid auth response: refresh payload');
-    }
-    return parseTokens(payload);
-  }
-
-  async logout(refreshToken: string): Promise<void> {
-    await this.post('/auth/logout', { refresh_token: refreshToken });
-  }
-
-  private async post(path: string, body: Record<string, unknown>): Promise<unknown> {
-    return this.request(path, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify(body),
-    });
-  }
-
-  private async request(path: string, init: RequestInit): Promise<unknown> {
-    let response: Response;
-    try {
-      response = await this.fetchFn(`${this.baseUrl}${path}`, init);
-    } catch (err) {
-      throw new AuthTransportError(`auth request failed: ${String(err)}`);
-    }
-
-    let text: string;
-    try {
-      text = await response.text();
-    } catch (err) {
-      throw new AuthDecodeError(`invalid response from ${response.url}: ${String(err)}`);
-    }
-
-    let payload: unknown = text;
-    if (text) {
-      try {
-        payload = JSON.parse(text) as unknown;
-      } catch (err) {
-        if (response.ok) {
-          throw new AuthDecodeError(`invalid JSON response from ${response.url}: ${String(err)}`);
-        }
-      }
-    } else {
-      payload = null;
-    }
-
-    if (response.ok) {
-      return payload;
-    }
-
-    let message = 'unknown error';
-    if (payload && typeof payload === 'object') {
-      const record = payload as RecordValue;
-      const error = record.error;
-      const msg = record.message;
-      message =
-        (typeof error === 'string' && error) ||
-        (typeof msg === 'string' && msg) ||
-        JSON.stringify(record, (_k, v) => v);
-    } else if (typeof payload === 'string' && payload.trim()) {
-      message = payload.trim();
-    }
-
-    throw new AuthApiError(`${response.status}: ${message}`, {
-      status: response.status,
-      body: payload,
-    });
-  }
-}
-
-export class AuthSession {
-  private authClient: AuthClient;
-  private signer: EvmSigner;
-  private refreshMarginSecs: number;
-  private tokens?: { accessToken: string; refreshToken: string; expiresAt: number };
-  private inFlight?: Promise<string>;
-  private loginPromise?: Promise<AuthTokens>;
-
-  constructor(options: {
-    authUrl: string;
-    signer: EvmSigner;
-    refreshMarginSecs?: number;
-    fetchFn?: FetchFn;
-  }) {
-    if (!options.authUrl) {
-      throw new AuthMissingConfigError('missing auth_url');
-    }
-    this.authClient = new AuthClient(options.authUrl, options.fetchFn);
-    this.signer = options.signer;
-
-    const margin = options.refreshMarginSecs ?? 60;
-    if (!Number.isFinite(margin) || margin < 0) {
-      throw new AuthConfigError('refresh margin must be non-negative');
-    }
-    this.refreshMarginSecs = margin;
-  }
-
-  async accessToken(): Promise<string> {
-    if (this.tokens && !this.isExpiringSoon()) {
-      return this.tokens.accessToken;
-    }
-    if (this.inFlight) {
-      return this.inFlight;
-    }
-    this.inFlight = this.refreshOrLogin();
-    try {
-      return await this.inFlight;
-    } finally {
-      this.inFlight = undefined;
-    }
-  }
-
-  async login(): Promise<AuthTokens> {
-    if (this.loginPromise) {
-      return this.loginPromise;
-    }
-    this.loginPromise = this.performLogin();
-    try {
-      return await this.loginPromise;
-    } finally {
-      this.loginPromise = undefined;
-    }
-  }
-
-  async logout(): Promise<void> {
-    if (!this.tokens?.refreshToken) {
-      return;
-    }
-    await this.authClient.logout(this.tokens.refreshToken);
-    this.tokens = undefined;
-  }
-
-  private async refreshOrLogin(): Promise<string> {
-    if (this.tokens?.refreshToken) {
-      try {
-        const tokens = await this.refreshTokens();
-        return tokens.accessToken;
-      } catch (err) {
-        if (err instanceof AuthApiError && err.status === 401) {
-          const tokens = await this.login();
-          return tokens.accessToken;
-        }
-        throw err;
-      }
-    }
-    const tokens = await this.login();
-    return tokens.accessToken;
-  }
-
-  private async performLogin(): Promise<AuthTokens> {
-    const address = this.signer.address;
-    const nonce = await this.authClient.getNonce(address);
-    const message = buildSiweMessage({
-      domain: nonce.siwe.domain,
-      address,
-      statement: nonce.siwe.statement,
-      uri: nonce.siwe.uri,
-      chainId: nonce.siwe.chainId,
-      nonce: nonce.nonce,
-      issuedAt: nonce.siwe.issuedAt,
-      expiration: nonce.siwe.expiration,
-    });
-    const signature = await this.signer.signMessage({ message });
-    const tokens = await this.authClient.verify(address, message, signature);
-    this.cacheTokens(tokens);
-    return tokens;
-  }
-
-  private async refreshTokens(): Promise<AuthTokens> {
-    if (!this.tokens?.refreshToken) {
-      throw new AuthMissingConfigError('missing refresh token');
-    }
-    const tokens = await this.authClient.refresh(this.tokens.refreshToken);
-    this.cacheTokens(tokens);
-    return tokens;
-  }
-
-  private cacheTokens(tokens: AuthTokens): void {
-    const now = Date.now() / 1000;
-    this.tokens = {
-      accessToken: tokens.accessToken,
-      refreshToken: tokens.refreshToken,
-      expiresAt: now + tokens.expiresIn,
-    };
-  }
-
-  private isExpiringSoon(): boolean {
-    if (!this.tokens) {
-      return true;
-    }
-    const now = Date.now() / 1000;
-    return now + this.refreshMarginSecs >= this.tokens.expiresAt;
-  }
-}

package/src/bls.ts

@@ -1,76 +0,0 @@
-import { getBytes } from 'ethers';
-import { VerificationError } from './errors';
-
-type BlsField = { value?: string | number | bigint } | string | number | bigint;
-
-type BlsModule = {
-  bls12_381: {
-    G2: {
-      ProjectivePoint: {
-        fromHex(bytes: Uint8Array): {
-          toAffine(): {
-            x: { c: readonly [BlsField, BlsField] };
-            y: { c: readonly [BlsField, BlsField] };
-          };
-        };
-      };
-    };
-  };
-};
-
-function splitFp(value: bigint): [Uint8Array, Uint8Array] {
-  const be48 = value.toString(16).padStart(96, '0');
-  const bytes = getBytes(`0x${be48}`);
-  const hi = new Uint8Array(32);
-  hi.set(bytes.slice(0, 16), 16);
-  const lo = bytes.slice(16);
-  return [hi, lo];
-}
-
-/**
- * Expand a compressed G2 signature into the tuple expected by the contract.
- * This mirrors the Python helper and requires the optional `@noble/curves` dependency.
- */
-export function signatureToWords(signatureHex: string): Uint8Array[] {
-  let curves: BlsModule;
-  try {
-    // Lazy require to keep the dependency optional.
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    curves = require('@noble/curves/bls12-381') as BlsModule;
-  } catch {
-    throw new VerificationError(
-      'BLS decoding requires @noble/curves; install it to enable remuneration'
-    );
-  }
-
-  const toBigint = (field: BlsField): bigint => {
-    if (typeof field === 'bigint' || typeof field === 'number' || typeof field === 'string') {
-      return BigInt(field);
-    }
-    if (field && typeof field === 'object' && 'value' in field && field.value !== undefined) {
-      const value = field.value;
-      if (typeof value === 'bigint' || typeof value === 'number' || typeof value === 'string') {
-        return BigInt(value);
-      }
-    }
-    throw new VerificationError('invalid BLS field element');
-  };
-
-  try {
-    const sigBytes = getBytes(signatureHex);
-    const point = curves.bls12_381.G2.ProjectivePoint.fromHex(sigBytes);
-    const affine = point.toAffine();
-    const [x0, x1] = affine.x.c;
-    const [y0, y1] = affine.y.c;
-    const coords = [x0, x1, y0, y1].map((fp) => toBigint(fp));
-    const words: Uint8Array[] = [];
-    coords.forEach((coord) => {
-      const [hi, lo] = splitFp(coord);
-      words.push(hi, lo);
-    });
-    return words;
-  } catch (err: unknown) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new VerificationError(`invalid BLS signature: ${message}`);
-  }
-}