@sogni-ai/sogni-client 3.3.0 → 4.0.0-alpha.1

package/src/Account/index.ts

@@ -5,6 +5,7 @@ import {
   ClaimOptions,
   FullBalances,
   LoginData,
+  MeData,
   Nonce,
   Reward,
   RewardRaw,
@@ -18,8 +19,8 @@ import { parseEther, pbkdf2, toUtf8Bytes, Wallet } from 'ethers';
 import { ApiError, ApiResponse } from '../ApiClient';
 import CurrentAccount from './CurrentAccount';
 import { SupernetType } from '../ApiClient/WebSocketClient/types';
-import { AuthUpdatedEvent, Tokens } from '../lib/AuthManager';
 import { delay } from '../lib/utils';
+import { TokenAuthManager } from '../lib/AuthManager';
 
 const MAX_DEPOSIT_ATTEMPTS = 4;
 enum ErrorCode {
@@ -60,14 +61,15 @@ class AccountApi extends ApiGroup {
   }
 
   private handleServerDisconnected() {
-    this.currentAccount._clear();
+    this.currentAccount._update({
+      networkStatus: 'disconnected',
+      network: null
+    });
   }
 
-  private handleAuthUpdated({ refreshToken, token, walletAddress }: AuthUpdatedEvent) {
-    if (!refreshToken) {
+  private handleAuthUpdated(isAuthenticated: boolean) {
+    if (!isAuthenticated) {
       this.currentAccount._clear();
-    } else {
-      this.currentAccount._update({ walletAddress, token, refreshToken });
     }
   }
 
@@ -132,45 +134,16 @@ class AccountApi extends ApiGroup {
       referralCode,
       signature
     });
-    await this.setToken(username, { refreshToken: res.data.refreshToken, token: res.data.token });
+    const auth = this.client.auth;
+    if (auth instanceof TokenAuthManager) {
+      await auth.authenticate({ refreshToken: res.data.refreshToken, token: res.data.token });
+    } else {
+      await auth.authenticate();
+    }
+    await this.me();
     return res.data;
   }
 
-  /**
-   * Restore session with username and refresh token.
-   *
-   * You can save access token that you get from the login method and restore the session with this method.
-   *
-   * @example Store access token to local storage
-   * ```typescript
-   * const { username, token, refreshToken } = await client.account.login('username', 'password');
-   * localStorage.setItem('sogni-username', username);
-   * localStorage.setItem('sogni-token', token);
-   * localStorage.setItem('sogni-refresh-token', refreshToken);
-   * ```
-   *
-   * @example Restore session from local storage
-   * ```typescript
-   * const username = localStorage.getItem('sogni-username');
-   * const token = localStorage.getItem('sogni-token');
-   * const refreshToken = localStorage.getItem('sogni-refresh-token');
-   * if (username && refreshToken) {
-   *  client.account.setToken(username, {token, refreshToken});
-   *  console.log('Session restored');
-   * }
-   * ```
-   *
-   * @param username
-   * @param tokens - Refresh token, access token pair { refreshToken: string, token: string }
-   */
-  async setToken(username: string, tokens: Tokens): Promise<void> {
-    await this.client.authenticate(tokens);
-    this.currentAccount._update({
-      username,
-      walletAddress: this.client.auth.walletAddress
-    });
-  }
-
   /**
    * Login with username and password. WebSocket connection is established after successful login.
    *
@@ -194,7 +167,13 @@ class AccountApi extends ApiGroup {
       walletAddress: wallet.address,
       signature
     });
-    await this.setToken(username, { refreshToken: res.data.refreshToken, token: res.data.token });
+    const auth = this.client.auth;
+    if (auth instanceof TokenAuthManager) {
+      await auth.authenticate({ refreshToken: res.data.refreshToken, token: res.data.token });
+    } else {
+      await auth.authenticate();
+    }
+    await this.me();
     return res.data;
   }
 
@@ -211,8 +190,7 @@ class AccountApi extends ApiGroup {
     this.client.rest.post('/v1/account/logout').catch((e) => {
       this.client.logger.error('Failed to logout', e);
     });
-    this.client.removeAuth();
-    this.currentAccount._clear();
+    this.client.auth.clear();
   }
 
   /**
@@ -273,6 +251,16 @@ class AccountApi extends ApiGroup {
     return res.data;
   }
 
+  async me() {
+    const res = await this.client.rest.get<ApiResponse<MeData>>('/v1/account/me');
+    this.currentAccount._update({
+      username: res.data.username,
+      email: res.data.currentEmail,
+      walletAddress: res.data.walletAddress
+    });
+    return res.data;
+  }
+
   /**
    * Validate the username before signup
    * @internal

package/src/Account/types.ts

@@ -24,6 +24,18 @@ export interface LoginData {
   username: string;
 }
 
+export interface MeData {
+  currentEmail: string;
+  discord2FA: boolean;
+  discordLinked: boolean;
+  discordServerMember: boolean;
+  discordUsername: string;
+  emailVerified: boolean;
+  requestedUpdatedEmail: string;
+  username: string;
+  walletAddress: string;
+}
+
 export interface BalanceData {
   settled: string;
   credit: string;

package/src/ApiClient/WebSocketClient/index.ts

@@ -7,7 +7,7 @@ import { base64Decode, base64Encode } from '../../lib/base64';
 import isNodejs from '../../lib/isNodejs';
 import { LIB_VERSION } from '../../version';
 import { Logger } from '../../lib/DefaultLogger';
-import AuthManager from '../../lib/AuthManager';
+import { AuthManager } from '../../lib/AuthManager';
 
 const PROTOCOL_VERSION = '3.0.0';
 
@@ -67,16 +67,7 @@ class WebSocketClient extends RestClient<SocketEventMap> {
     url.searchParams.set('clientType', 'artist');
     //At this point 'relaxed' does not work as expected, so we use 'fast' or empty
     url.searchParams.set('forceWorkerId', this._supernetType === 'fast' ? 'fast' : '');
-    let params;
-    // In Node.js, ws package is used, so we need to set the auth header
-    if (isNodejs) {
-      params = {
-        headers: {
-          Authorization: await this.auth.getToken(),
-          'User-Agent': userAgent
-        }
-      };
-    }
+    const params = await this.auth.socketOptions();
     this.socket = new WebSocket(url.toString(), params);
     this.socket.onerror = this.handleError.bind(this);
     this.socket.onmessage = this.handleMessage.bind(this);

package/src/ApiClient/index.ts

@@ -7,7 +7,8 @@ import { isNotRecoverable } from './WebSocketClient/ErrorCode';
 import { JSONValue } from '../types/json';
 import { SupernetType } from './WebSocketClient/types';
 import { Logger } from '../lib/DefaultLogger';
-import AuthManager, { Tokens } from '../lib/AuthManager';
+import CookieAuthManager from '../lib/AuthManager/CookieAuthManager';
+import { AuthManager, TokenAuthManager } from '../lib/AuthManager';
 
 const WS_RECONNECT_ATTEMPTS = 5;
 
@@ -33,6 +34,16 @@ export class ApiError extends Error {
   }
 }
 
+export interface ApiClientOptions {
+  baseUrl: string;
+  socketUrl: string;
+  appId: string;
+  networkType: SupernetType;
+  logger: Logger;
+  authType: 'token' | 'cookies';
+  disableSocket?: boolean;
+}
+
 class ApiClient extends TypedEventEmitter<ApiClientEvents> {
   readonly appId: string;
   readonly logger: Logger;
@@ -42,23 +53,24 @@ class ApiClient extends TypedEventEmitter<ApiClientEvents> {
   private _reconnectAttempts = WS_RECONNECT_ATTEMPTS;
   private _disableSocket: boolean = false;
 
-  constructor(
-    baseUrl: string,
-    socketUrl: string,
-    appId: string,
-    networkType: SupernetType,
-    logger: Logger,
-    disableSocket: boolean = false
-  ) {
+  constructor({
+    baseUrl,
+    socketUrl,
+    appId,
+    networkType,
+    authType,
+    logger,
+    disableSocket = false
+  }: ApiClientOptions) {
     super();
     this.appId = appId;
     this.logger = logger;
-    this._auth = new AuthManager(baseUrl, logger);
+    this._auth =
+      authType === 'token' ? new TokenAuthManager(baseUrl, logger) : new CookieAuthManager(logger);
     this._rest = new RestClient(baseUrl, this._auth, logger);
     this._socket = new WebSocketClient(socketUrl, this._auth, appId, networkType, logger);
     this._disableSocket = disableSocket;
-
-    this._auth.on('refreshFailed', this.handleRefreshFailed.bind(this));
+    this._auth.on('updated', this.handleAuthUpdated.bind(this));
     this._socket.on('connected', this.handleSocketConnect.bind(this));
     this._socket.on('disconnected', this.handleSocketDisconnect.bind(this));
   }
@@ -67,7 +79,7 @@ class ApiClient extends TypedEventEmitter<ApiClientEvents> {
     return this.auth.isAuthenticated;
   }
 
-  get auth(): AuthManager {
+  get auth() {
     return this._auth;
   }
 
@@ -83,20 +95,6 @@ class ApiClient extends TypedEventEmitter<ApiClientEvents> {
     return !this._disableSocket;
   }
 
-  async authenticate(tokens: Tokens) {
-    await this.auth.setTokens(tokens);
-    if (!this._disableSocket) {
-      await this.socket.connect();
-    }
-  }
-
-  removeAuth() {
-    this.auth.clear();
-    if (this.socket.isConnected) {
-      this.socket.disconnect();
-    }
-  }
-
   handleSocketConnect({ network }: ServerConnectData) {
     this._reconnectAttempts = WS_RECONNECT_ATTEMPTS;
     this.emit('connected', { network });
@@ -104,13 +102,13 @@ class ApiClient extends TypedEventEmitter<ApiClientEvents> {
 
   handleSocketDisconnect(data: ServerDisconnectData) {
     if (!data.code || isNotRecoverable(data.code)) {
-      this.removeAuth();
+      this.auth.clear();
       this.emit('disconnected', data);
       this.logger.error('Not recoverable socket error', data);
       return;
     }
     if (this._reconnectAttempts <= 0) {
-      this.removeAuth();
+      this.auth.clear();
       this.emit('disconnected', data);
       this._reconnectAttempts = WS_RECONNECT_ATTEMPTS;
       return;
@@ -119,8 +117,14 @@ class ApiClient extends TypedEventEmitter<ApiClientEvents> {
     setTimeout(() => this.socket.connect(), 1000);
   }
 
-  handleRefreshFailed() {
-    this.removeAuth();
+  handleAuthUpdated(isAuthenticated: boolean) {
+    if (!isAuthenticated) {
+      if (this.socket.isConnected) {
+        this.socket.disconnect();
+      }
+    } else if (!this._disableSocket) {
+      this.socket.connect();
+    }
   }
 }
 

package/src/index.ts

@@ -2,7 +2,7 @@
 import AccountApi from './Account';
 import CurrentAccount from './Account/CurrentAccount';
 // ApiClient
-import ApiClient, { ApiError } from './ApiClient';
+import ApiClient, { ApiError, ApiResponse } from './ApiClient';
 import { SupernetType } from './ApiClient/WebSocketClient/types';
 import { ApiConfig } from './ApiGroup';
 // Utils
@@ -12,12 +12,20 @@ import EIP712Helper from './lib/EIP712Helper';
 import ProjectsApi from './Projects';
 import Job, { JobStatus } from './Projects/Job';
 import Project, { ProjectStatus } from './Projects/Project';
-import { AvailableModel, OutputFormat, ProjectParams, Scheduler, TimeStepSpacing } from './Projects/types';
+import {
+  AvailableModel,
+  OutputFormat,
+  ProjectParams,
+  Scheduler,
+  TimeStepSpacing
+} from './Projects/types';
 // Stats API
 import StatsApi from './Stats';
 // Base Types
 import ErrorData from './types/ErrorData';
 import { TokenType } from './types/token';
+import { CookieAuthManager, TokenAuthData, TokenAuthManager } from './lib/AuthManager';
+import { MeData } from './Account/types';
 
 export type {
   AvailableModel,
@@ -75,6 +83,16 @@ export interface SogniClientConfig {
    * If true, the client will connect to the testnet. Ignored if jsonRpcUrl is provided
    */
   testnet?: boolean;
+  /**
+   * Authentication type to use. Can be 'token' or 'cookie'. If not provided, 'token' will be used.
+   * `token` authentication relies on a token stored in the client instance. This is what 3rd party
+   * Node.js apps should use.
+   * `cookie` authentication relies on htmlOnly cookie, set by the server. This will only work for
+   * browser apps located on .sogni.ai subdomains due to CORS restrictions.
+   * @default 'token'
+   * @experimental
+   */
+  authType?: 'token' | 'cookies';
 }
 
 export class SogniClient {
@@ -96,6 +114,41 @@ export class SogniClient {
     return this.account.currentAccount;
   }
 
+  /**
+   * When using token authentication, this method can be used to set the tokens.
+   * This is useful when the tokens are stored in a secure location and you want to resume the session.
+   * @param tokens
+   */
+  async setTokens(tokens: TokenAuthData): Promise<void> {
+    const auth = this.apiClient.auth;
+    if (!(auth instanceof TokenAuthManager)) {
+      throw new Error('setTokens can only be used with token authentication');
+    }
+    await auth.authenticate(tokens);
+    await this.account.me();
+  }
+
+  /**
+   * When using cookie authentication, client has no way to detect if the user is authenticated or not.
+   * This method can be used to check if the user is authenticated and populate the currentAccount.
+   * @returns
+   */
+  async checkAuth(): Promise<boolean> {
+    const auth = this.apiClient.auth;
+    if (!(auth instanceof CookieAuthManager)) {
+      throw Error('This method should only be called when using cookie auth');
+    }
+    try {
+      await this.apiClient.rest.get<ApiResponse<MeData>>('/v1/account/me');
+      await auth.authenticate();
+      await this.account.me();
+      return true;
+    } catch (e) {
+      this.apiClient.logger.info('Client is not authenticated');
+      return false;
+    }
+  }
+
   /**
    * Create client instance, with default configuration
    * @param config
@@ -107,14 +160,15 @@ export class SogniClient {
     const logger = config.logger || new DefaultLogger(config.logLevel || 'warn');
     const isTestnet = config.testnet !== undefined ? config.testnet : false;
 
-    const client = new ApiClient(
-      restEndpoint,
-      socketEndpoint,
-      config.appId,
-      network,
+    const client = new ApiClient({
+      baseUrl: restEndpoint,
+      socketUrl: socketEndpoint,
+      appId: config.appId,
+      networkType: network,
       logger,
-      config.disableSocket
-    );
+      authType: config.authType || 'token',
+      disableSocket: config.disableSocket
+    });
     const eip712 = new EIP712Helper({
       name: isTestnet ? 'Sogni-testnet' : 'Sogni AI',
       version: '1',

package/src/lib/AuthManager/AuthManagerBase.ts

@@ -0,0 +1,37 @@
+import { Logger } from '../DefaultLogger';
+import TypedEventEmitter from '../TypedEventEmitter';
+import { ClientOptions } from 'ws';
+
+interface AuthManagerEvents {
+  updated: boolean;
+}
+
+abstract class AuthManagerBase<AuthData = never> extends TypedEventEmitter<AuthManagerEvents> {
+  protected _logger: Logger;
+  constructor(logger: Logger) {
+    super();
+    this._logger = logger;
+  }
+
+  abstract get isAuthenticated(): boolean;
+
+  abstract authenticateRequest(option: RequestInit): Promise<RequestInit>;
+
+  abstract socketOptions(): Promise<ClientOptions | undefined>;
+
+  /**
+   * Get the current authentication data to persist it
+   * @returns
+   */
+  abstract backup(): Promise<AuthData>;
+
+  /**
+   * Restore authentication from the data that was previously backed up
+   * @param data
+   */
+  abstract authenticate(data: AuthData): Promise<void>;
+
+  abstract clear(): void;
+}
+
+export default AuthManagerBase;

package/src/lib/AuthManager/CookieAuthManager.ts

@@ -0,0 +1,40 @@
+import AuthManagerBase from './AuthManagerBase';
+
+class CookieAuthManager extends AuthManagerBase<undefined> {
+  private _isAuthenticated = false;
+
+  /**
+   * For cookie authentication, there is no way to detect if the user is authenticated or not,
+   * except when a call to API was successful. So the REST client will set this property to true.
+   */
+  async authenticate(): Promise<void> {
+    this._isAuthenticated = true;
+    this.emit('updated', true);
+  }
+
+  clear() {
+    this._isAuthenticated = false;
+    this.emit('updated', false);
+  }
+
+  get isAuthenticated() {
+    return this._isAuthenticated;
+  }
+
+  backup(): Promise<undefined> {
+    throw new Error('Not supported with cookie authentication');
+  }
+
+  async authenticateRequest(options: RequestInit): Promise<RequestInit> {
+    return {
+      ...options,
+      credentials: 'include'
+    };
+  }
+
+  async socketOptions(): Promise<undefined> {
+    return undefined;
+  }
+}
+
+export default CookieAuthManager;