@sogni-ai/expo-client 1.0.0-alpha.2

package/src/lib/AuthManager/TokenAuthManager.ts

@@ -0,0 +1,179 @@
+import { decodeToken, decodeRefreshToken } from '../utils';
+import { ApiError, ApiErrorResponse } from '../../ApiClient';
+import { Logger } from '../DefaultLogger';
+import AuthManagerBase from './AuthManagerBase';
+import { AuthStorage, ExpoSecureStorage } from './AuthStorage';
+import { SocketAuthData } from '../../ApiClient/WebSocketClient/types';
+
+const STORAGE_KEY = 'sogni.tokens';
+
+export interface TokenAuthData {
+  token: string;
+  refreshToken: string;
+}
+
+class TokenAuthManager extends AuthManagerBase<TokenAuthData | null> {
+  private _token?: string;
+  private _tokenExpiresAt: Date = new Date(0);
+  private _refreshToken?: string;
+  private _refreshTokenExpiresAt: Date = new Date(0);
+  private _baseUrl: string;
+  private _renewTokenPromise?: Promise<string>;
+  private _storage: AuthStorage;
+
+  constructor(baseUrl: string, logger: Logger, storage?: AuthStorage) {
+    super(logger);
+    this._baseUrl = baseUrl;
+    this._storage = storage ?? new ExpoSecureStorage();
+  }
+
+  get isAuthenticated() {
+    return !!this._refreshToken && this._refreshTokenExpiresAt > new Date();
+  }
+
+  /**
+   * Hydrate tokens from secure storage. Called by SogniClient.create() on init.
+   * Returns true if a valid session was restored, false otherwise.
+   */
+  async restore(): Promise<boolean> {
+    let raw: string | null;
+    try {
+      raw = await this._storage.getItem(STORAGE_KEY);
+    } catch (e) {
+      this._logger.warn('Failed to read tokens from secure storage:', e);
+      return false;
+    }
+    if (!raw) return false;
+    try {
+      const tokens: TokenAuthData = JSON.parse(raw);
+      await this.authenticate(tokens);
+      return this.isAuthenticated;
+    } catch (e) {
+      this._logger.warn('Stored tokens are unreadable, clearing:', e);
+      await this._storage.removeItem(STORAGE_KEY).catch(() => undefined);
+      return false;
+    }
+  }
+
+  async backup(): Promise<TokenAuthData | null> {
+    if (this._token && this._refreshToken) {
+      return { token: this._token, refreshToken: this._refreshToken };
+    }
+    return null;
+  }
+
+  async authenticate({ refreshToken, token }: TokenAuthData) {
+    if (token) {
+      const { expiresAt } = decodeToken(token);
+      if (expiresAt > new Date()) {
+        await this._updateTokens({ token, refreshToken });
+        return;
+      }
+    }
+    this._refreshToken = refreshToken;
+    const { expiresAt: refreshExpiresAt } = decodeRefreshToken(refreshToken);
+    this._refreshTokenExpiresAt = refreshExpiresAt;
+    await this._renewTokenSafe();
+  }
+
+  clear() {
+    if (!this._token && !this._refreshToken) {
+      return;
+    }
+    this._refreshToken = undefined;
+    this._refreshTokenExpiresAt = new Date(0);
+    this._token = undefined;
+    this._tokenExpiresAt = new Date(0);
+    this._storage.removeItem(STORAGE_KEY).catch((e) => {
+      this._logger.warn('Failed to clear tokens from secure storage:', e);
+    });
+    this.emit('updated', false);
+  }
+
+  async authenticateRequest(option: RequestInit): Promise<RequestInit> {
+    if (this._token && this._tokenExpiresAt > new Date()) {
+      return { ...option, headers: { ...option.headers, Authorization: this._token } };
+    }
+    if (!this._refreshToken) {
+      return option;
+    }
+    const token = await this._renewTokenSafe();
+    return { ...option, headers: { ...option.headers, Authorization: token } };
+  }
+
+  async socketAuth(): Promise<SocketAuthData> {
+    const token = await this._getToken();
+    if (!token) return {};
+    return { headers: { Authorization: token } };
+  }
+
+  private async _getToken(): Promise<string | undefined> {
+    if (this._token && this._tokenExpiresAt > new Date()) {
+      return this._token;
+    }
+    if (!this._refreshToken) {
+      return undefined;
+    }
+    return this._renewTokenSafe();
+  }
+
+  private async _renewTokenSafe(): Promise<string> {
+    if (this._renewTokenPromise) {
+      return this._renewTokenPromise;
+    }
+    this._renewTokenPromise = this._renewToken();
+    this._renewTokenPromise.finally(() => {
+      this._renewTokenPromise = undefined;
+    });
+    return this._renewTokenPromise;
+  }
+
+  private async _updateTokens({ token, refreshToken }: { token: string; refreshToken: string }) {
+    if (this._token === token && this._refreshToken === refreshToken) {
+      return;
+    }
+    this._token = token;
+    const { expiresAt } = decodeToken(token);
+    this._tokenExpiresAt = expiresAt;
+    this._refreshToken = refreshToken;
+    const { expiresAt: refreshExpiresAt } = decodeRefreshToken(refreshToken);
+    this._refreshTokenExpiresAt = refreshExpiresAt;
+    try {
+      await this._storage.setItem(STORAGE_KEY, JSON.stringify({ token, refreshToken }));
+    } catch (e) {
+      this._logger.warn('Failed to persist tokens to secure storage:', e);
+    }
+    this.emit('updated', true);
+  }
+
+  private async _renewToken(): Promise<string> {
+    if (this._refreshTokenExpiresAt < new Date()) {
+      throw new Error('Refresh token expired');
+    }
+    const url = new URL('/v1/account/refresh-token', this._baseUrl).toString();
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({ refreshToken: this._refreshToken })
+    });
+    let responseData: any;
+    try {
+      responseData = await response.json();
+    } catch (e) {
+      this.clear();
+      this._logger.error('Failed to parse refresh-token response:', e);
+      throw new Error('Failed to parse response');
+    }
+    if (!response.ok) {
+      this.clear();
+      throw new ApiError(response.status, responseData as ApiErrorResponse);
+    }
+    const { token, refreshToken } = responseData.data;
+    await this._updateTokens({ token, refreshToken });
+    return this._token!;
+  }
+}
+
+export default TokenAuthManager;

package/src/lib/AuthManager/index.ts

@@ -0,0 +1,8 @@
+import ApiKeyAuthManager from './ApiKeyAuthManager';
+import TokenAuthManager, { TokenAuthData } from './TokenAuthManager';
+import { AuthStorage, ExpoSecureStorage } from './AuthStorage';
+
+export type { TokenAuthData, AuthStorage };
+export { ApiKeyAuthManager, TokenAuthManager, ExpoSecureStorage };
+
+export type AuthManager = ApiKeyAuthManager | TokenAuthManager;

package/src/lib/Cache.ts

@@ -0,0 +1,45 @@
+interface CacheRecord<V = any> {
+  exp: number;
+  value: V;
+}
+
+export default class Cache<V = any> {
+  readonly ttl: number;
+  private data: Map<string, CacheRecord<V>> = new Map();
+  private interval: ReturnType<typeof setInterval>;
+
+  constructor(defaultTTL: number) {
+    this.ttl = defaultTTL;
+    this.interval = setInterval(() => this.cleanup(), 10000);
+  }
+
+  write(key: string, value: V, ttl?: number) {
+    this.data.set(key, {
+      exp: Date.now() + (ttl || this.ttl),
+      value
+    });
+  }
+
+  read(key: string): V | undefined {
+    const record = this.data.get(key);
+    return record && record.exp > Date.now() ? record.value : undefined;
+  }
+
+  clear() {
+    this.data.clear();
+  }
+
+  dispose() {
+    clearInterval(this.interval);
+    this.data.clear();
+  }
+
+  private cleanup() {
+    const now = Date.now();
+    this.data.forEach((record, key) => {
+      if (record.exp < now) {
+        this.data.delete(key);
+      }
+    });
+  }
+}

package/src/lib/DefaultLogger.ts

@@ -0,0 +1,47 @@
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug';
+
+export const LOG_LEVELS: Record<LogLevel, number> = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3
+};
+
+export interface Logger {
+  error(...args: any[]): void;
+  warn(...args: any[]): void;
+  info(...args: any[]): void;
+  debug(...args: any[]): void;
+}
+
+export class DefaultLogger implements Logger {
+  private _level: number;
+
+  constructor(level: LogLevel = 'warn') {
+    this._level = LOG_LEVELS[level];
+  }
+
+  error(...args: any[]) {
+    if (this._level >= LOG_LEVELS.error) {
+      console.error(...args);
+    }
+  }
+
+  warn(...args: any[]) {
+    if (this._level >= LOG_LEVELS.warn) {
+      console.warn(...args);
+    }
+  }
+
+  info(...args: any[]) {
+    if (this._level >= LOG_LEVELS.info) {
+      console.info(...args);
+    }
+  }
+
+  debug(...args: any[]) {
+    if (this._level >= LOG_LEVELS.debug) {
+      console.debug(...args);
+    }
+  }
+}

package/src/lib/RestClient.ts

@@ -0,0 +1,77 @@
+import { ApiError, ApiErrorResponse } from '../ApiClient';
+import TypedEventEmitter, { EventMap } from './TypedEventEmitter';
+import { JSONValue } from '../types/json';
+import { Logger } from './DefaultLogger';
+import { AuthManager } from './AuthManager';
+
+const REQUEST_TIMEOUT_MS = 30000;
+
+class RestClient<E extends EventMap = never> extends TypedEventEmitter<E> {
+  readonly baseUrl: string;
+  protected _auth: AuthManager;
+  protected _logger: Logger;
+
+  constructor(baseUrl: string, auth: AuthManager, logger: Logger) {
+    super();
+    this.baseUrl = baseUrl;
+    this._auth = auth;
+    this._logger = logger;
+  }
+
+  get auth(): AuthManager {
+    return this._auth;
+  }
+
+  private formatUrl(relativeUrl: string, query: Record<string, string> = {}): string {
+    const url = new URL(relativeUrl, this.baseUrl);
+    Object.keys(query).forEach((key) => {
+      url.searchParams.append(key, query[key]!);
+    });
+    return url.toString();
+  }
+
+  private async request<T = JSONValue>(url: string, options: RequestInit = {}): Promise<T> {
+    const init = await this.auth.authenticateRequest(options);
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+
+    try {
+      const response = await fetch(url, { ...init, signal: controller.signal });
+      return this.processResponse(response) as T;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+
+  private async processResponse(response: Response): Promise<JSONValue> {
+    let responseData: any;
+    try {
+      responseData = await response.json();
+    } catch (e) {
+      this._logger.error('Failed to parse response:', e);
+      throw new Error('Failed to parse response');
+    }
+    if (response.status === 401 && this.auth.isAuthenticated) {
+      this.auth.clear();
+    }
+    if (!response.ok) {
+      throw new ApiError(response.status, responseData as ApiErrorResponse);
+    }
+    return responseData as JSONValue;
+  }
+
+  get<T = JSONValue>(path: string, query: Record<string, any> = {}): Promise<T> {
+    return this.request<T>(this.formatUrl(path, query));
+  }
+
+  post<T = JSONValue>(path: string, body: Record<string, unknown> = {}): Promise<T> {
+    return this.request<T>(this.formatUrl(path), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body)
+    });
+  }
+}
+
+export default RestClient;

package/src/lib/TypedEventEmitter.ts

@@ -0,0 +1,52 @@
+export interface EventMap {
+  [event: string]: any;
+}
+
+export type EventListener<D> = (data: D) => void;
+
+abstract class TypedEventEmitter<E extends EventMap> {
+  protected listeners: { [K in keyof E]?: EventListener<E[K]>[] } = {};
+
+  on<T extends keyof E>(event: T, listener: EventListener<E[T]>) {
+    if (!this.listeners[event]) {
+      this.listeners[event] = [];
+    }
+    this.listeners[event]!.push(listener);
+    return () => {
+      this.off(event, listener);
+    };
+  }
+
+  once<T extends keyof E>(event: T, listener: EventListener<E[T]>) {
+    const remove = this.on(event, (data) => {
+      remove();
+      listener(data);
+    });
+    return remove;
+  }
+
+  off<T extends keyof E>(event: T, listener: EventListener<E[T]>) {
+    if (!this.listeners[event]) {
+      return;
+    }
+    this.listeners[event] = this.listeners[event]!.filter((l) => l !== listener);
+  }
+
+  removeAllListeners<T extends keyof E>(event?: T) {
+    if (event) {
+      delete this.listeners[event];
+    } else {
+      this.listeners = {};
+    }
+  }
+
+  protected emit<T extends keyof E>(event: T, data: E[T]) {
+    const listeners = this.listeners[event];
+    if (!listeners) {
+      return;
+    }
+    listeners.forEach((listener) => listener(data));
+  }
+}
+
+export default TypedEventEmitter;

package/src/lib/base64.ts

@@ -0,0 +1,17 @@
+export function base64Encode(str: string): string {
+  const encoder = new TextEncoder();
+  const uint8Array = encoder.encode(str);
+  const chunkSize = 8192;
+  let binaryString = '';
+  for (let i = 0; i < uint8Array.length; i += chunkSize) {
+    binaryString += String.fromCharCode(...uint8Array.subarray(i, i + chunkSize));
+  }
+  return btoa(binaryString);
+}
+
+export function base64Decode(str: string): string {
+  const binaryString = atob(str);
+  const binaryArray = Uint8Array.from(binaryString, (char) => char.charCodeAt(0));
+  const decoder = new TextDecoder();
+  return decoder.decode(binaryArray);
+}

package/src/lib/getUUID.ts

@@ -0,0 +1,27 @@
+/**
+ * Generate a v4 UUID using crypto.getRandomValues, returned in uppercase form.
+ *
+ * Mac workers in the Sogni Supernet use uppercase UUIDs; the SDK keeps that
+ * convention end-to-end so wire-level comparisons stay simple.
+ *
+ * Requires `crypto.getRandomValues` (polyfilled in Expo via
+ * `expo-standard-web-crypto/polyfill`). SogniClient.create() verifies the
+ * polyfill is present and throws a clear error otherwise.
+ */
+export default function getUUID(): string {
+  const bytes = crypto.getRandomValues(new Uint8Array(16));
+  bytes[6] = (bytes[6]! & 0x0f) | 0x40;
+  bytes[8] = (bytes[8]! & 0x3f) | 0x80;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+  return (
+    hex.slice(0, 8) +
+    '-' +
+    hex.slice(8, 12) +
+    '-' +
+    hex.slice(12, 16) +
+    '-' +
+    hex.slice(16, 20) +
+    '-' +
+    hex.slice(20)
+  ).toUpperCase();
+}

package/src/lib/utils.ts

@@ -0,0 +1,21 @@
+import { jwtDecode } from 'jwt-decode';
+
+export function decodeToken(token: string) {
+  const data = jwtDecode<{ addr: string; env: string; iat: number; exp: number }>(token);
+  return {
+    walletAddress: data.addr,
+    expiresAt: new Date(data.exp * 1000)
+  };
+}
+
+export function decodeRefreshToken(token: string) {
+  const data = jwtDecode<{ type: string; env: string; iat: number; exp: number }>(token);
+  return {
+    env: data.env,
+    expiresAt: new Date(data.exp * 1000)
+  };
+}
+
+export async function delay(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/types/ErrorData.ts

@@ -0,0 +1,7 @@
+interface ErrorData {
+  code: number;
+  originalCode?: string;
+  message: string;
+}
+
+export default ErrorData;

package/src/types/json.ts

@@ -0,0 +1,5 @@
+export type JSONValue = undefined | null | string | number | boolean | JSONObject | JSONArray;
+
+export type JSONObject = { [x: string]: JSONValue };
+
+export type JSONArray = Array<JSONValue>;

package/src/types/token.ts

@@ -0,0 +1 @@
+export type TokenType = 'sogni' | 'spark';

package/src/version.ts

@@ -0,0 +1 @@
+export const LIB_VERSION = '0.1.0';

package/src/wallet.ts

@@ -0,0 +1,6 @@
+export { LIB_VERSION } from './version';
+
+export interface Wallet {
+  privateKey: `0x${string}`;
+  address: `0x${string}`;
+}