@sogni-ai/sogni-client 0.3.2 → 0.4.0-aplha.1

package/src/Projects/types/EstimationResponse.ts

@@ -0,0 +1,45 @@
+export interface EstimationResponse {
+  request: Request;
+  rate: Rate;
+  quote: Quote;
+}
+
+export interface Quote {
+  model: Model;
+  job: Job;
+  project: Job;
+}
+
+export interface Job {
+  costInRenderSec: string;
+  costInUSD: string;
+  costInToken: string;
+  calculatedStepCount?: number;
+}
+
+export interface Model {
+  weight: string;
+  secPerStep: string;
+  secPerPreview: string;
+  secForCN: string;
+}
+
+export interface Rate {
+  costPerBaseHQRenderInUSD: string;
+  tokenMarkePriceUSD: string;
+  costPerRenderSecUSD: string;
+  costPerRenderSecToken: string;
+  network: string;
+  networkCostMultiplier: string;
+}
+
+export interface Request {
+  model: string;
+  name: string;
+  imageCount: number;
+  stepCount: number;
+  previewCount: number;
+  cnEnabled: boolean;
+  denoiseStrength: string;
+  time: Date;
+}

package/src/Projects/types/events.ts

@@ -0,0 +1,80 @@
+import { AvailableModel } from './index';
+import ErrorData from '../../types/ErrorData';
+
+export interface ProjectEventBase {
+  projectId: string;
+}
+
+export interface ProjectQueued extends ProjectEventBase {
+  type: 'queued';
+  queuePosition: number;
+}
+
+export interface ProjectCompleted extends ProjectEventBase {
+  type: 'completed';
+}
+
+export interface ProjectError extends ProjectEventBase {
+  type: 'error';
+  error: ErrorData;
+}
+
+export type ProjectEvent = ProjectQueued | ProjectCompleted | ProjectError;
+
+export interface JobEventBase {
+  projectId: string;
+  jobId: string;
+}
+
+export interface JobInitiating extends JobEventBase {
+  type: 'initiating';
+  workerName: string;
+}
+
+export interface JobStarted extends JobEventBase {
+  type: 'started';
+  workerName: string;
+}
+
+export interface JobProgress extends JobEventBase {
+  type: 'progress';
+  step: number;
+  stepCount: number;
+}
+
+export interface JobPreview extends JobEventBase {
+  type: 'preview';
+  url: string;
+}
+
+export interface JobCompleted extends JobEventBase {
+  type: 'completed';
+  steps: number;
+  seed: number;
+  /**
+   * URL to the result image, could be null if the job was canceled or triggered NSFW filter while
+   * it was not disabled by the user
+   */
+  resultUrl: string | null;
+  isNSFW: boolean;
+  userCanceled: boolean;
+}
+
+export interface JobError extends JobEventBase {
+  type: 'error';
+  error: ErrorData;
+}
+
+export type JobEvent =
+  | JobInitiating
+  | JobStarted
+  | JobProgress
+  | JobPreview
+  | JobCompleted
+  | JobError;
+
+export interface ProjectApiEvents {
+  availableModels: AvailableModel[];
+  project: ProjectEvent;
+  job: JobEvent;
+}

package/src/Projects/types/index.ts

@@ -0,0 +1,146 @@
+import { SupernetType } from '../../ApiClient/WebSocketClient/types';
+
+export interface AvailableModel {
+  id: string;
+  name: string;
+  workerCount: number;
+}
+
+export interface AiModel {
+  isSD3: boolean;
+  modelShortName: string;
+  isIOSslowest: boolean;
+  hasOriginalVersionOnly: boolean;
+  isUserModel: boolean;
+  isTurboXL: boolean;
+  isRealistic: boolean;
+  isArtistic: boolean;
+  tier: string;
+  splitAttentionSuffix: string;
+  isSD3XL: boolean;
+  originalAttentionSuffix: string;
+  isLCM: boolean;
+  zipWeight: number;
+  modelId: string;
+  modelVersion: string;
+  parentId: string;
+  quantized: boolean;
+  isXL: boolean;
+  splitAttentionV2Suffix: string;
+  supportsAttentionV2: boolean;
+  supportsControlNet: boolean;
+  supportsEncoder: boolean;
+  onlySplitEinsumV2available: boolean;
+  customSize?: number[];
+}
+
+export type Scheduler =
+  | 'DPM Solver Multistep (DPM-Solver++)'
+  | 'PNDM (Pseudo-linear multi-step)'
+  | 'LCM (Latent Consistency Model)'
+  | 'Discrete Flow Scheduler (SD3)'
+  | 'Euler'; // Used by Flux
+
+export type TimeStepSpacing = 'Karras' | 'Leading' | 'Linear';
+
+export interface ProjectParams {
+  /**
+   * ID of the model to use, available models are available in the `availableModels` property of the `ProjectsApi` instance.
+   */
+  modelId: string;
+  /**
+   * Prompt for what to be created
+   */
+  positivePrompt: string;
+  /**
+   * Prompt for what to be avoided
+   */
+  negativePrompt: string;
+  /**
+   * Image style prompt
+   */
+  stylePrompt: string;
+  /**
+   * Number of steps. For most Stable Diffusion models, optimal value is 20
+   */
+  steps: number;
+  /**
+   * Guidance scale. For most Stable Diffusion models, optimal value is 7.5
+   */
+  guidance: number;
+  /**
+   * Disable NSFW filter for Project. Default is false, meaning NSFW filter is enabled.
+   * If image triggers NSFW filter, it will not be available for download.
+   */
+  disableNSFWFilter?: boolean;
+  /**
+   * Seed for one of images in project. Other will get random seed. Must be Uint32
+   */
+  seed?: number;
+  /**
+   * Number of images to generate
+   */
+  numberOfImages: number;
+  /**
+   * Generate images based on starting image.
+   * `File` - file object from input[type=file]
+   * `Buffer` - buffer object with image data
+   * `Blob` - blob object with image data
+   */
+  startingImage?: File | Buffer | Blob;
+  /**
+   * How strong effect of starting image should be. From 0 to 1, default 0.5
+   */
+  startingImageStrength?: number;
+  /**
+   * Number of previews to generate. Note that previews affect project cost\
+   */
+  numberOfPreviews?: number;
+  /**
+   * Scheduler to use
+   */
+  scheduler?: Scheduler;
+  /**
+   * Time step spacing method
+   */
+  timeStepSpacing?: TimeStepSpacing;
+}
+
+export type ImageUrlParams = {
+  imageId: string;
+  jobId: string;
+  type: 'preview' | 'complete' | 'startingImage' | 'cnImage';
+  // This seems to be unused currently
+  startContentType?: string;
+};
+
+export interface EstimateRequest {
+  /**
+   * Network to use. Can be 'fast' or 'relaxed'
+   */
+  network: SupernetType;
+  /**
+   * Model ID
+   */
+  model: string;
+  /**
+   * Number of images to generate
+   */
+  imageCount: number;
+  /**
+   * Number of steps
+   */
+  stepCount: number;
+  /**
+   * Number of preview images to generate
+   */
+  previewCount: number;
+  /**
+   * Control network enabled
+   */
+  cnEnabled?: boolean;
+  /**
+   * How strong effect of starting image should be. From 0 to 1, default 0.5
+   */
+  startingImageStrength?: number;
+}

package/src/Stats/index.ts

@@ -0,0 +1,15 @@
+import ApiGroup from '../ApiGroup';
+import { ApiReponse } from '../ApiClient';
+import { LeaderboardItem, LeaderboardParams } from './types';
+
+class StatsApi extends ApiGroup {
+  async leaderboard(params: LeaderboardParams) {
+    const res = await this.client.rest.get<ApiReponse<LeaderboardItem[]>>(
+      '/v1/leaderboard/',
+      params
+    );
+    return res.data;
+  }
+}
+
+export default StatsApi;

package/src/Stats/types.ts

@@ -0,0 +1,34 @@
+export type LeaderboardType =
+  | 'renderUSDCompleteWorker'
+  | 'renderUSDCompleteArtist'
+  | 'renderSecCompleteWorker'
+  | 'renderSecCompleteArtist'
+  | 'renderTokenCompleteWorker'
+  | 'renderTokenCompleteArtist'
+  | 'jobCompleteWorker'
+  | 'jobCompleteArtist'
+  | 'projectCompleteArtist'
+  | 'uloginWorker'
+  | 'uloginArtist'
+  | 'tokenVolume'
+  | 'referral';
+
+export interface LeaderboardParams {
+  type: LeaderboardType;
+  period: 'day' | 'lifetime';
+  username?: string;
+  network?: 'fast' | 'relaxed' | 'all';
+  page?: number;
+  limit?: number;
+  date?: number;
+  address?: string;
+}
+
+export interface LeaderboardItem {
+  rank: number;
+  username: string;
+  address: string;
+  country: string;
+  value: string;
+  role: string;
+}

package/src/events.ts

@@ -0,0 +1,5 @@
+export type { ApiClientEvents } from './ApiClient/events';
+export type { ProjectApiEvents } from './Projects/types/events';
+export type { EntityEvents } from './lib/DataEntity';
+export type { JobEventMap } from './Projects/Job';
+export type { ProjectEventMap } from './Projects/Project';

package/src/index.ts

@@ -0,0 +1,120 @@
+import { AbstractProvider, JsonRpcProvider, getDefaultProvider } from 'ethers';
+// Account API
+import AccountApi from './Account';
+import CurrentAccount from './Account/CurrentAccount';
+// ApiClient
+import ApiClient, { ApiError } from './ApiClient';
+import { SupernetType } from './ApiClient/WebSocketClient/types';
+import { ApiConfig } from './ApiGroup';
+// Utils
+import { DefaultLogger, Logger, LogLevel } from './lib/DefaultLogger';
+import EIP712Helper from './lib/EIP712Helper';
+// Projects API
+import ProjectsApi from './Projects';
+import Job, { JobStatus } from './Projects/Job';
+import Project, { ProjectStatus } from './Projects/Project';
+import { AvailableModel, ProjectParams, Scheduler, TimeStepSpacing } from './Projects/types';
+// Stats API
+import StatsApi from './Stats';
+// Base Types
+import ErrorData from './types/ErrorData';
+
+export type {
+  AvailableModel,
+  ErrorData,
+  JobStatus,
+  Logger,
+  LogLevel,
+  ProjectParams,
+  ProjectStatus,
+  Scheduler,
+  SupernetType,
+  TimeStepSpacing
+};
+
+export { ApiError, CurrentAccount, Job, Project };
+
+export interface SogniClientConfig {
+  /**
+   * The application ID string. Must be unique, multiple connections with the same ID will be rejected.
+   */
+  appId: string;
+  /**
+   * Override the default REST API endpoint
+   * @internal
+   */
+  restEndpoint?: string;
+  /**
+   * Override the default WebSocket API endpoint
+   * @internal
+   */
+  socketEndpoint?: string;
+  /**
+   * Which network to use after logging in. Can be 'fast' or 'relaxed'
+   */
+  network: SupernetType;
+  /**
+   * Logger to use. If not provided, a default console logger will be used
+   */
+  logger?: Logger;
+  /**
+   * Log level to use. This option is ignored if a logger is provided
+   * @default 'warn'
+   **/
+  logLevel?: LogLevel;
+  /**
+   * If provided, the client will connect to this JSON-RPC endpoint to interact with the blockchain
+   */
+  jsonRpcUrl?: string;
+  /**
+   * If true, the client will connect to the testnet. Ignored if jsonRpcUrl is provided
+   */
+  testnet?: boolean;
+}
+
+export class SogniClient {
+  account: AccountApi;
+  projects: ProjectsApi;
+  stats: StatsApi;
+
+  apiClient: ApiClient;
+
+  private constructor(config: ApiConfig) {
+    this.account = new AccountApi(config);
+    this.projects = new ProjectsApi(config);
+    this.stats = new StatsApi(config);
+
+    this.apiClient = config.client;
+  }
+
+  get currentAccount() {
+    return this.account.currentAccount;
+  }
+
+  /**
+   * Instance creation may involve async operations, so we use a static method
+   * @param config
+   */
+  static async createInstance(config: SogniClientConfig): Promise<SogniClient> {
+    const restEndpoint = config.restEndpoint || 'https://api.sogni.ai';
+    const socketEndpoint = config.socketEndpoint || 'wss://socket.sogni.ai';
+    const network = config.network || 'fast';
+    const logger = config.logger || new DefaultLogger(config.logLevel || 'warn');
+    const isTestnet = config.testnet !== undefined ? config.testnet : true;
+
+    const client = new ApiClient(restEndpoint, socketEndpoint, config.appId, network, logger);
+    let provider: AbstractProvider;
+    if ('jsonRpcUrl' in config) {
+      provider = new JsonRpcProvider(config.jsonRpcUrl);
+    } else {
+      provider = getDefaultProvider(isTestnet ? 84532 : 8453);
+    }
+    const chainId = await provider.getNetwork().then((network) => network.chainId);
+    const eip712 = new EIP712Helper({
+      name: 'Sogni-testnet',
+      version: '1',
+      chainId: chainId.toString()
+    });
+    return new SogniClient({ client, provider, eip712 });
+  }
+}

package/src/lib/DataEntity.ts

@@ -0,0 +1,38 @@
+import { cloneDeep } from 'lodash';
+import TypedEventEmitter from './TypedEventEmitter';
+
+/**
+ * @inline
+ */
+export interface EntityEvents {
+  updated: string[];
+}
+
+abstract class DataEntity<D, E extends EntityEvents = EntityEvents> extends TypedEventEmitter<E> {
+  protected data: D;
+
+  constructor(data: D) {
+    super();
+    this.data = data;
+  }
+
+  /**
+   * @internal
+   * @param delta
+   */
+  _update(delta: Partial<D>) {
+    //@ts-ignore
+    const changedKeys = Object.keys(delta).filter((key) => this.data[key] !== delta[key]);
+    this.data = { ...this.data, ...delta };
+    this.emit('updated', changedKeys);
+  }
+
+  /**
+   * Get a copy of the entity's data
+   */
+  toJSON(): D {
+    return cloneDeep(this.data);
+  }
+}
+
+export default DataEntity;

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/EIP712Helper.ts

@@ -0,0 +1,57 @@
+import { AbstractSigner, TypedDataDomain, TypedDataField } from 'ethers';
+
+type EIP712Types = Record<string, TypedDataField[]>;
+type SupportedTypes = 'authentication' | 'signup';
+
+const EIP712_TYPES: Record<SupportedTypes, EIP712Types> = {
+  authentication: {
+    Authentication: [
+      { name: 'walletAddress', type: 'address' },
+      { name: 'nonce', type: 'string' }
+    ]
+  },
+  signup: {
+    Signup: [
+      { name: 'appid', type: 'string' },
+      { name: 'username', type: 'string' },
+      { name: 'email', type: 'string' },
+      { name: 'subscribe', type: 'uint256' },
+      { name: 'walletAddress', type: 'address' },
+      { name: 'nonce', type: 'string' }
+    ]
+  }
+};
+
+interface Options {
+  name: string;
+  version: string;
+  chainId: string;
+}
+
+class EIP712Helper {
+  private readonly EIP712Domain: TypedDataDomain;
+
+  constructor(options: Options) {
+    this.EIP712Domain = {
+      name: options.name,
+      version: options.version,
+      chainId: options.chainId,
+      verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC'
+    };
+  }
+
+  signTypedData(
+    signer: AbstractSigner,
+    type: SupportedTypes,
+    data: Record<string, string | number>
+  ) {
+    const types = EIP712_TYPES[type];
+    if (!types) {
+      throw new Error(`Unknown type: ${type}`);
+    }
+
+    return signer.signTypedData(this.EIP712Domain, types, data);
+  }
+}
+
+export default EIP712Helper;

package/src/lib/RestClient.ts

@@ -0,0 +1,76 @@
+import { ApiError, ApiErrorResponse } from '../ApiClient';
+import TypedEventEmitter, { EventMap } from './TypedEventEmitter';
+import { JSONValue } from '../types/json';
+import { Logger } from './DefaultLogger';
+
+export interface AuthData {
+  token: string;
+}
+
+class RestClient<E extends EventMap = never> extends TypedEventEmitter<E> {
+  readonly baseUrl: string;
+  protected _auth: AuthData | null = null;
+  protected _logger: Logger;
+
+  constructor(baseUrl: string, logger: Logger) {
+    super();
+    this.baseUrl = baseUrl;
+    this._logger = logger;
+  }
+
+  get auth(): AuthData | null {
+    return this._auth;
+  }
+
+  set auth(auth: AuthData | null) {
+    this._auth = 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 request<T = JSONValue>(url: string, options: RequestInit = {}): Promise<T> {
+    return fetch(url, {
+      ...options,
+      headers: {
+        ...(options.headers || {}),
+        ...(this.auth ? { Authorization: this.auth.token } : {})
+      }
+    }).then((r) => this.processResponse(r) as T);
+  }
+
+  private async processResponse(response: Response): Promise<JSONValue> {
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch (e) {
+      this._logger.error('Failed to parse response:', e);
+      throw new Error('Failed to parse response');
+    }
+    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), 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;