@4mica/sdk 0.5.0 → 0.5.2

package/src/errors.ts

@@ -1,40 +0,0 @@
-export class FourMicaError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = this.constructor.name;
-  }
-}
-
-export class ConfigError extends FourMicaError {}
-export class RpcError extends FourMicaError {
-  readonly status?: number;
-  readonly body?: unknown;
-
-  constructor(message: string, options?: { status?: number; body?: unknown }) {
-    super(message);
-    this.status = options?.status;
-    this.body = options?.body;
-  }
-}
-export class ClientInitializationError extends FourMicaError {}
-export class SigningError extends FourMicaError {}
-export class ContractError extends FourMicaError {}
-export class VerificationError extends FourMicaError {}
-export class X402Error extends FourMicaError {}
-
-export class AuthError extends FourMicaError {}
-export class AuthUrlError extends AuthError {}
-export class AuthTransportError extends AuthError {}
-export class AuthDecodeError extends AuthError {}
-export class AuthApiError extends AuthError {
-  readonly status?: number;
-  readonly body?: unknown;
-
-  constructor(message: string, options?: { status?: number; body?: unknown }) {
-    super(message);
-    this.status = options?.status;
-    this.body = options?.body;
-  }
-}
-export class AuthConfigError extends AuthError {}
-export class AuthMissingConfigError extends AuthConfigError {}

package/src/guarantee.ts

@@ -1,96 +0,0 @@
-import { AbiCoder, getBytes } from 'ethers';
-import { VerificationError } from './errors';
-import { PaymentGuaranteeClaims } from './models';
-import { parseU256 } from './utils';
-
-const CLAIM_TYPES = [
-  'bytes32',
-  'uint256',
-  'uint256',
-  'address',
-  'address',
-  'uint256',
-  'uint256',
-  'address',
-  'uint64',
-  'uint64',
-];
-
-const coder = AbiCoder.defaultAbiCoder();
-
-function ensureDomainBytes(domain: string | Uint8Array): Uint8Array {
-  const bytes = typeof domain === 'string' ? getBytes(domain) : domain;
-  if (bytes.length !== 32) {
-    throw new VerificationError('domain separator must be 32 bytes');
-  }
-  return bytes;
-}
-
-export function encodeGuaranteeClaims(claims: PaymentGuaranteeClaims): string {
-  if (claims.version !== 1) {
-    throw new VerificationError(`unsupported guarantee claims version: ${claims.version}`);
-  }
-
-  const domain = ensureDomainBytes(claims.domain);
-  const encoded = coder.encode(CLAIM_TYPES, [
-    domain,
-    parseU256(claims.tabId),
-    parseU256(claims.reqId),
-    claims.userAddress,
-    claims.recipientAddress,
-    parseU256(claims.amount),
-    parseU256(claims.totalAmount),
-    claims.assetAddress,
-    BigInt(claims.timestamp),
-    BigInt(claims.version),
-  ]);
-  return coder.encode(['uint64', 'bytes'], [BigInt(claims.version), encoded]);
-}
-
-export function decodeGuaranteeClaims(data: string | Uint8Array): PaymentGuaranteeClaims {
-  const rawBytes = typeof data === 'string' ? getBytes(data) : data;
-  const [version, encoded] = coder.decode(['uint64', 'bytes'], rawBytes) as unknown as [
-    bigint,
-    string,
-  ];
-  if (version !== 1n) {
-    throw new VerificationError(`unsupported guarantee claims version: ${version}`);
-  }
-
-  const [
-    domain,
-    tabId,
-    reqId,
-    user,
-    recipient,
-    amount,
-    totalAmount,
-    asset,
-    timestamp,
-    claimsVersion,
-  ] = coder.decode(CLAIM_TYPES, encoded) as unknown as [
-    string,
-    bigint,
-    bigint,
-    string,
-    string,
-    bigint,
-    bigint,
-    string,
-    bigint,
-    bigint,
-  ];
-
-  return {
-    domain: getBytes(domain),
-    userAddress: user,
-    recipientAddress: recipient,
-    tabId: parseU256(tabId),
-    reqId: parseU256(reqId),
-    amount: parseU256(amount),
-    totalAmount: parseU256(totalAmount),
-    assetAddress: asset,
-    timestamp: Number(timestamp),
-    version: Number(claimsVersion),
-  };
-}

package/src/index.ts

@@ -1,12 +0,0 @@
-export * from './errors';
-export * from './config';
-export * from './utils';
-export * from './models';
-export * from './signing';
-export * from './rpc';
-export * from './auth';
-export * from './contract';
-export * from './guarantee';
-export * from './bls';
-export * from './x402/index';
-export * from './client';

package/src/models.ts

@@ -1,309 +0,0 @@
-import { normalizeAddress, parseU256 } from './utils';
-
-export enum SigningScheme {
-  EIP712 = 'eip712',
-  EIP191 = 'eip191',
-}
-
-export const ADMIN_API_KEY_HEADER = 'x-api-key';
-export const ADMIN_API_KEY_PREFIX = 'ak_';
-export const ADMIN_SCOPE_SUSPEND_USERS = 'user_suspension:write';
-export const ADMIN_SCOPE_MANAGE_KEYS = 'admin_api_keys:manage';
-
-export interface PaymentSignature {
-  signature: string;
-  scheme: SigningScheme;
-}
-
-export class PaymentGuaranteeRequestClaims {
-  userAddress: string;
-  recipientAddress: string;
-  tabId: bigint;
-  reqId: bigint;
-  amount: bigint;
-  timestamp: number;
-  assetAddress: string;
-
-  constructor(init: {
-    userAddress: string;
-    recipientAddress: string;
-    tabId: bigint;
-    reqId?: bigint;
-    amount: bigint;
-    timestamp: number;
-    assetAddress: string;
-  }) {
-    this.userAddress = init.userAddress;
-    this.recipientAddress = init.recipientAddress;
-    this.tabId = init.tabId;
-    this.reqId = init.reqId ?? 0n;
-    this.amount = init.amount;
-    this.timestamp = init.timestamp;
-    this.assetAddress = init.assetAddress;
-  }
-
-  static new(
-    userAddress: string,
-    recipientAddress: string,
-    tabId: number | bigint | string,
-    amount: number | bigint | string,
-    timestamp: number,
-    erc20Token?: string | null,
-    reqId?: number | bigint | string
-  ): PaymentGuaranteeRequestClaims {
-    const asset = erc20Token ?? '0x0000000000000000000000000000000000000000';
-    return new PaymentGuaranteeRequestClaims({
-      userAddress: normalizeAddress(userAddress),
-      recipientAddress: normalizeAddress(recipientAddress),
-      tabId: parseU256(tabId),
-      reqId: reqId !== undefined ? parseU256(reqId) : 0n,
-      amount: parseU256(amount),
-      timestamp: Number(timestamp),
-      assetAddress: normalizeAddress(asset),
-    });
-  }
-}
-
-export interface PaymentGuaranteeClaims {
-  domain: Uint8Array;
-  userAddress: string;
-  recipientAddress: string;
-  tabId: bigint;
-  reqId: bigint;
-  amount: bigint;
-  totalAmount: bigint;
-  assetAddress: string;
-  timestamp: number;
-  version: number;
-}
-
-export interface BLSCert {
-  claims: string;
-  signature: string;
-}
-
-export interface TabPaymentStatus {
-  paid: bigint;
-  remunerated: boolean;
-  asset: string;
-}
-
-export interface UserInfo {
-  asset: string;
-  collateral: bigint;
-  withdrawalRequestAmount: bigint;
-  withdrawalRequestTimestamp: number;
-}
-
-export class UserSuspensionStatus {
-  constructor(
-    public userAddress: string,
-    public suspended: boolean,
-    public updatedAt: number
-  ) {}
-
-  static fromRpc(raw: Record<string, unknown>): UserSuspensionStatus {
-    return new UserSuspensionStatus(
-      (getAny(raw, 'user_address', 'userAddress') ?? '') as string,
-      Boolean(getAny(raw, 'suspended')),
-      Number(getAny(raw, 'updated_at', 'updatedAt') ?? 0)
-    );
-  }
-}
-
-export class AdminApiKeyInfo {
-  constructor(
-    public id: string,
-    public name: string,
-    public scopes: string[],
-    public createdAt: number,
-    public revokedAt?: number | null
-  ) {}
-
-  static fromRpc(raw: Record<string, unknown>): AdminApiKeyInfo {
-    const revoked = getAny(raw, 'revoked_at', 'revokedAt');
-    return new AdminApiKeyInfo(
-      (getAny(raw, 'id') ?? '') as string,
-      (getAny(raw, 'name') ?? '') as string,
-      ((getAny(raw, 'scopes') ?? []) as string[]).map(String),
-      Number(getAny(raw, 'created_at', 'createdAt') ?? 0),
-      revoked === undefined || revoked === null ? null : Number(revoked)
-    );
-  }
-}
-
-export class AdminApiKeySecret {
-  constructor(
-    public id: string,
-    public name: string,
-    public scopes: string[],
-    public createdAt: number,
-    public apiKey: string
-  ) {}
-
-  static fromRpc(raw: Record<string, unknown>): AdminApiKeySecret {
-    return new AdminApiKeySecret(
-      (getAny(raw, 'id') ?? '') as string,
-      (getAny(raw, 'name') ?? '') as string,
-      ((getAny(raw, 'scopes') ?? []) as string[]).map(String),
-      Number(getAny(raw, 'created_at', 'createdAt') ?? 0),
-      (getAny(raw, 'api_key', 'apiKey') ?? '') as string
-    );
-  }
-}
-
-function getAny<T>(raw: Record<string, unknown>, ...keys: string[]): T | undefined {
-  for (const key of keys) {
-    if (key in raw) return raw[key] as T;
-  }
-  return undefined;
-}
-
-export class TabInfo {
-  constructor(
-    public tabId: bigint,
-    public userAddress: string,
-    public recipientAddress: string,
-    public assetAddress: string,
-    public startTimestamp: number,
-    public ttlSeconds: number,
-    public status: string,
-    public settlementStatus: string,
-    public createdAt: number,
-    public updatedAt: number
-  ) {}
-
-  static fromRpc(raw: Record<string, unknown>): TabInfo {
-    return new TabInfo(
-      parseU256((getAny(raw, 'tab_id', 'tabId') ?? 0) as number | bigint | string),
-      (getAny(raw, 'user_address', 'userAddress') ?? '') as string,
-      (getAny(raw, 'recipient_address', 'recipientAddress') ?? '') as string,
-      (getAny(raw, 'asset_address', 'assetAddress') ?? '') as string,
-      Number(getAny(raw, 'start_timestamp', 'startTimestamp')),
-      Number(getAny(raw, 'ttl_seconds', 'ttlSeconds')),
-      (getAny(raw, 'status') ?? '') as string,
-      (getAny(raw, 'settlement_status', 'settlementStatus') ?? '') as string,
-      Number(getAny(raw, 'created_at', 'createdAt')),
-      Number(getAny(raw, 'updated_at', 'updatedAt'))
-    );
-  }
-}
-
-export class GuaranteeInfo {
-  constructor(
-    public tabId: bigint,
-    public reqId: bigint,
-    public fromAddress: string,
-    public toAddress: string,
-    public assetAddress: string,
-    public amount: bigint,
-    public timestamp: number,
-    public certificate?: string | null
-  ) {}
-
-  static fromRpc(raw: Record<string, unknown>): GuaranteeInfo {
-    return new GuaranteeInfo(
-      parseU256((getAny(raw, 'tab_id', 'tabId') ?? 0) as number | bigint | string),
-      parseU256((getAny(raw, 'req_id', 'reqId') ?? 0) as number | bigint | string),
-      (getAny(raw, 'from_address', 'fromAddress') ?? '') as string,
-      (getAny(raw, 'to_address', 'toAddress') ?? '') as string,
-      (getAny(raw, 'asset_address', 'assetAddress') ?? '') as string,
-      parseU256((getAny(raw, 'amount') ?? 0) as number | bigint | string),
-      Number(getAny(raw, 'start_timestamp', 'startTimestamp', 'timestamp') ?? 0),
-      getAny(raw, 'certificate')
-    );
-  }
-}
-
-export class PendingRemunerationInfo {
-  constructor(
-    public tab: TabInfo,
-    public latestGuarantee?: GuaranteeInfo | null
-  ) {}
-
-  static fromRpc(raw: Record<string, unknown>): PendingRemunerationInfo {
-    const latest = getAny<Record<string, unknown>>(raw, 'latest_guarantee', 'latestGuarantee');
-    return new PendingRemunerationInfo(
-      TabInfo.fromRpc(getAny(raw, 'tab') ?? {}),
-      latest ? GuaranteeInfo.fromRpc(latest) : null
-    );
-  }
-}
-
-export class CollateralEventInfo {
-  constructor(
-    public id: string,
-    public userAddress: string,
-    public assetAddress: string,
-    public amount: bigint,
-    public eventType: string,
-    public tabId?: bigint | null,
-    public reqId?: bigint | null,
-    public txId?: string | null,
-    public createdAt: number = 0
-  ) {}
-
-  static fromRpc(raw: Record<string, unknown>): CollateralEventInfo {
-    const tabId = getAny(raw, 'tab_id', 'tabId');
-    const reqId = getAny(raw, 'req_id', 'reqId');
-    return new CollateralEventInfo(
-      (getAny(raw, 'id') ?? '') as string,
-      (getAny(raw, 'user_address', 'userAddress') ?? '') as string,
-      (getAny(raw, 'asset_address', 'assetAddress') ?? '') as string,
-      parseU256((getAny(raw, 'amount') ?? 0) as number | bigint | string),
-      (getAny(raw, 'event_type', 'eventType') ?? '') as string,
-      tabId !== undefined && tabId !== null ? parseU256(tabId as number | bigint | string) : null,
-      reqId !== undefined && reqId !== null ? parseU256(reqId as number | bigint | string) : null,
-      getAny(raw, 'tx_id', 'txId'),
-      Number(getAny(raw, 'created_at', 'createdAt') ?? 0)
-    );
-  }
-}
-
-export class AssetBalanceInfo {
-  constructor(
-    public userAddress: string,
-    public assetAddress: string,
-    public total: bigint,
-    public locked: bigint,
-    public version: number,
-    public updatedAt: number
-  ) {}
-
-  static fromRpc(raw: Record<string, unknown>): AssetBalanceInfo {
-    return new AssetBalanceInfo(
-      (getAny(raw, 'user_address', 'userAddress') ?? '') as string,
-      (getAny(raw, 'asset_address', 'assetAddress') ?? '') as string,
-      parseU256((getAny(raw, 'total') ?? 0) as number | bigint | string),
-      parseU256((getAny(raw, 'locked') ?? 0) as number | bigint | string),
-      Number(getAny(raw, 'version') ?? 0),
-      Number(getAny(raw, 'updated_at', 'updatedAt') ?? 0)
-    );
-  }
-}
-
-export class RecipientPaymentInfo {
-  constructor(
-    public userAddress: string,
-    public recipientAddress: string,
-    public txHash: string,
-    public amount: bigint,
-    public verified: boolean,
-    public finalized: boolean,
-    public failed: boolean,
-    public createdAt: number
-  ) {}
-
-  static fromRpc(raw: Record<string, unknown>): RecipientPaymentInfo {
-    return new RecipientPaymentInfo(
-      (getAny(raw, 'user_address', 'userAddress') ?? '') as string,
-      (getAny(raw, 'recipient_address', 'recipientAddress') ?? '') as string,
-      (getAny(raw, 'tx_hash', 'txHash') ?? '') as string,
-      parseU256((getAny(raw, 'amount') ?? 0) as number | bigint | string),
-      Boolean(getAny(raw, 'verified')),
-      Boolean(getAny(raw, 'finalized')),
-      Boolean(getAny(raw, 'failed')),
-      Number(getAny(raw, 'created_at', 'createdAt') ?? 0)
-    );
-  }
-}

package/src/rpc.ts

@@ -1,225 +0,0 @@
-import {
-  ADMIN_API_KEY_HEADER,
-  AdminApiKeyInfo,
-  AdminApiKeySecret,
-  UserSuspensionStatus,
-} from './models';
-import { CorePublicParameters } from './signing';
-import { RpcError } from './errors';
-
-export type FetchFn = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-export type BearerTokenProvider = () => string | Promise<string>;
-
-function serializeTabId(tabId: number | bigint): string {
-  return `0x${BigInt(tabId).toString(16)}`;
-}
-
-export class RpcProxy {
-  private baseUrl: string;
-  private adminApiKey?: string;
-  private bearerToken?: string;
-  private bearerTokenProvider?: BearerTokenProvider;
-  private fetchFn: FetchFn;
-
-  constructor(endpoint: string, adminApiKey?: string, fetchFn: FetchFn = fetch) {
-    this.baseUrl = endpoint.endsWith('/') ? endpoint.slice(0, -1) : endpoint;
-    this.adminApiKey = adminApiKey;
-    this.fetchFn = fetchFn;
-  }
-
-  async aclose(): Promise<void> {
-    // no-op for symmetry with Python SDK
-  }
-
-  withBearerToken(token: string): RpcProxy {
-    this.bearerToken = token;
-    return this;
-  }
-
-  withTokenProvider(provider: BearerTokenProvider): RpcProxy {
-    this.bearerTokenProvider = provider;
-    return this;
-  }
-
-  private async headers(): Promise<Record<string, string>> {
-    const headers: Record<string, string> = {};
-    if (this.adminApiKey) {
-      headers[ADMIN_API_KEY_HEADER] = this.adminApiKey;
-    }
-    const token = await this.resolveBearerToken();
-    if (token) {
-      headers['Authorization'] = token;
-    }
-    return headers;
-  }
-
-  private async resolveBearerToken(): Promise<string | undefined> {
-    let token = this.bearerToken;
-    if (!token && this.bearerTokenProvider) {
-      token = await this.bearerTokenProvider();
-    }
-    if (!token) {
-      return undefined;
-    }
-    const trimmed = token.trim();
-    if (/^bearer\s+/i.test(trimmed)) {
-      return trimmed;
-    }
-    return `Bearer ${trimmed}`;
-  }
-
-  private async decode<T>(response: Response): Promise<T> {
-    let payload: unknown;
-    try {
-      payload = await response.json();
-    } catch (err) {
-      if (response.ok) {
-        throw new RpcError(`invalid JSON response from ${response.url}: ${String(err)}`);
-      }
-      payload = await response.text();
-    }
-
-    if (response.ok) {
-      return payload as T;
-    }
-
-    let message = 'unknown error';
-    if (payload && typeof payload === 'object') {
-      const record = payload as Record<string, unknown>;
-      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 RpcError(`${response.status}: ${message}`, {
-      status: response.status,
-      body: payload,
-    });
-  }
-
-  private async get<T>(path: string): Promise<T> {
-    const resp = await this.fetchFn(`${this.baseUrl}${path}`, {
-      headers: await this.headers(),
-      method: 'GET',
-    });
-    return this.decode<T>(resp);
-  }
-
-  private async post<T>(path: string, body: Record<string, unknown>): Promise<T> {
-    const resp = await this.fetchFn(`${this.baseUrl}${path}`, {
-      headers: { 'content-type': 'application/json', ...(await this.headers()) },
-      method: 'POST',
-      body: JSON.stringify(body),
-    });
-    return this.decode<T>(resp);
-  }
-
-  async getPublicParams(): Promise<CorePublicParameters> {
-    const data = await this.get<Record<string, unknown>>('/core/public-params');
-    return CorePublicParameters.fromRpc(data);
-  }
-
-  async issueGuarantee(body: Record<string, unknown>): Promise<Record<string, unknown>> {
-    return this.post<Record<string, unknown>>('/core/guarantees', body);
-  }
-
-  async createPaymentTab(body: Record<string, unknown>): Promise<Record<string, unknown>> {
-    return this.post<Record<string, unknown>>('/core/payment-tabs', body);
-  }
-
-  async listSettledTabs(recipientAddress: string): Promise<Record<string, unknown>[]> {
-    return this.get<Record<string, unknown>[]>(`/core/recipients/${recipientAddress}/settled-tabs`);
-  }
-
-  async listPendingRemunerations(recipientAddress: string): Promise<Record<string, unknown>[]> {
-    return this.get<Record<string, unknown>[]>(
-      `/core/recipients/${recipientAddress}/pending-remunerations`
-    );
-  }
-
-  async getTab(tabId: number | bigint): Promise<Record<string, unknown> | null> {
-    return this.get<Record<string, unknown> | null>(`/core/tabs/${serializeTabId(tabId)}`);
-  }
-
-  async listRecipientTabs(
-    recipientAddress: string,
-    settlementStatuses?: string[]
-  ): Promise<Record<string, unknown>[]> {
-    let query = '';
-    if (settlementStatuses?.length) {
-      query =
-        '?' + settlementStatuses.map((s) => `settlement_status=${encodeURIComponent(s)}`).join('&');
-    }
-    return this.get<Record<string, unknown>[]>(`/core/recipients/${recipientAddress}/tabs${query}`);
-  }
-
-  async getTabGuarantees(tabId: number | bigint): Promise<Record<string, unknown>[]> {
-    return this.get<Record<string, unknown>[]>(`/core/tabs/${serializeTabId(tabId)}/guarantees`);
-  }
-
-  async getLatestGuarantee(tabId: number | bigint): Promise<Record<string, unknown> | null> {
-    return this.get<Record<string, unknown> | null>(
-      `/core/tabs/${serializeTabId(tabId)}/guarantees/latest`
-    );
-  }
-
-  async getGuarantee(
-    tabId: number | bigint,
-    reqId: number | bigint
-  ): Promise<Record<string, unknown> | null> {
-    return this.get<Record<string, unknown> | null>(
-      `/core/tabs/${serializeTabId(tabId)}/guarantees/${reqId}`
-    );
-  }
-
-  async listRecipientPayments(recipientAddress: string): Promise<Record<string, unknown>[]> {
-    return this.get<Record<string, unknown>[]>(`/core/recipients/${recipientAddress}/payments`);
-  }
-
-  async getCollateralEventsForTab(tabId: number | bigint): Promise<Record<string, unknown>[]> {
-    return this.get<Record<string, unknown>[]>(
-      `/core/tabs/${serializeTabId(tabId)}/collateral-events`
-    );
-  }
-
-  async getUserAssetBalance(
-    userAddress: string,
-    assetAddress: string
-  ): Promise<Record<string, unknown> | null> {
-    return this.get<Record<string, unknown> | null>(
-      `/core/users/${userAddress}/assets/${assetAddress}`
-    );
-  }
-
-  async updateUserSuspension(
-    userAddress: string,
-    suspended: boolean
-  ): Promise<UserSuspensionStatus> {
-    const data = await this.post<Record<string, unknown>>(`/core/users/${userAddress}/suspension`, {
-      suspended,
-    });
-    return UserSuspensionStatus.fromRpc(data);
-  }
-
-  async createAdminApiKey(body: Record<string, unknown>): Promise<AdminApiKeySecret> {
-    const data = await this.post<Record<string, unknown>>('/core/admin/api-keys', body);
-    return AdminApiKeySecret.fromRpc(data);
-  }
-
-  async listAdminApiKeys(): Promise<AdminApiKeyInfo[]> {
-    const data = await this.get<Record<string, unknown>[]>('/core/admin/api-keys');
-    return data.map((entry) => AdminApiKeyInfo.fromRpc(entry));
-  }
-
-  async revokeAdminApiKey(keyId: string): Promise<AdminApiKeyInfo> {
-    const data = await this.post<Record<string, unknown>>(
-      `/core/admin/api-keys/${keyId}/revoke`,
-      {}
-    );
-    return AdminApiKeyInfo.fromRpc(data);
-  }
-}