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

package/src/Account/CurrentAccount.ts

@@ -0,0 +1,101 @@
+import DataEntity from '../lib/DataEntity';
+import { BalanceData } from './types';
+import { jwtDecode } from 'jwt-decode';
+import { SupernetType } from '../ApiClient/WebSocketClient/types';
+/**
+ * @inline
+ */
+export interface AccountData {
+  token: string | null;
+  networkStatus: 'connected' | 'disconnected' | 'connecting';
+  network: SupernetType | null;
+  balance: BalanceData;
+  walletAddress?: string;
+  expiresAt?: Date;
+  username?: string;
+}
+
+function getDefaults(): AccountData {
+  return {
+    token: null,
+    networkStatus: 'disconnected',
+    network: null,
+    balance: {
+      credit: '0',
+      debit: '0',
+      net: '0',
+      settled: '0'
+    }
+  };
+}
+
+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)
+  };
+}
+
+/**
+ * Current account data.
+ * @expand
+ */
+class CurrentAccount extends DataEntity<AccountData> {
+  constructor(data?: AccountData) {
+    super(data || getDefaults());
+  }
+
+  _update<K extends keyof AccountData>(delta: Partial<AccountData>) {
+    this.data = { ...this.data, ...(delta as Partial<AccountData>) };
+    const keys = Object.keys(delta);
+    if (delta.hasOwnProperty('token')) {
+      if (delta.token) {
+        Object.assign(this.data, decodeToken(delta.token));
+      } else {
+        delete this.data.walletAddress;
+        delete this.data.expiresAt;
+      }
+      keys.push('walletAddress', 'expiresAt');
+    }
+    this.emit('updated', keys);
+  }
+
+  _clear() {
+    this._update(getDefaults());
+  }
+
+  get isAuthenicated() {
+    return !!this.data.token && !!this.data.expiresAt && this.data.expiresAt > new Date();
+  }
+
+  get networkStatus() {
+    return this.data.networkStatus;
+  }
+
+  get network() {
+    return this.data.network;
+  }
+
+  get balance() {
+    return this.data.balance;
+  }
+
+  get walletAddress() {
+    return this.data.walletAddress;
+  }
+
+  get expiresAt() {
+    return this.data.expiresAt;
+  }
+
+  get username() {
+    return this.data.username;
+  }
+
+  get token() {
+    return this.data.token;
+  }
+}
+
+export default CurrentAccount;

package/src/Account/index.ts

@@ -0,0 +1,367 @@
+import {
+  AccountCreateData,
+  BalanceData,
+  LoginData,
+  Nonce,
+  Reward,
+  RewardRaw,
+  TxHistoryData,
+  TxHistoryEntry,
+  TxHistoryParams
+} from './types';
+import ApiGroup, { ApiConfig } from '../ApiGroup';
+import { Wallet, pbkdf2, toUtf8Bytes } from 'ethers';
+import { ApiError, ApiReponse } from '../ApiClient';
+import CurrentAccount from './CurrentAccount';
+import { SupernetType } from '../ApiClient/WebSocketClient/types';
+
+/**
+ * Account API methods that let you interact with the user's account.
+ * Can be accessed via `client.account`. Look for more samples below.
+ *
+ * @example Retrieve the current account balance
+ * ```typescript
+ * const balance = await client.account.refreshBalance();
+ * console.log(balance);
+ * ```
+ *
+ */
+class AccountApi extends ApiGroup {
+  readonly currentAccount = new CurrentAccount();
+
+  constructor(config: ApiConfig) {
+    super(config);
+    this.client.socket.on('balanceUpdate', this.handleBalanceUpdate.bind(this));
+    this.client.on('connected', this.handleServerConnected.bind(this));
+    this.client.on('disconnected', this.handleServerDisconnected.bind(this));
+  }
+
+  private handleBalanceUpdate(data: BalanceData) {
+    this.currentAccount._update({ balance: data });
+  }
+
+  private handleServerConnected({ network }: { network: SupernetType }) {
+    this.currentAccount._update({
+      networkStatus: 'connected',
+      network
+    });
+  }
+
+  private handleServerDisconnected() {
+    this.currentAccount._clear();
+  }
+
+  private async getNonce(walletAddress: string): Promise<string> {
+    const res = await this.client.rest.post<ApiReponse<Nonce>>('/v1/account/nonce', {
+      walletAddress
+    });
+    return res.data.nonce;
+  }
+
+  /**
+   * Create Ethers.js Wallet instance from username and password.
+   * This method is used internally to create a wallet for the user.
+   * You can use this method to create a wallet if you need to sign transactions.
+   *
+   * @example Create a wallet from username and password
+   * ```typescript
+   * const wallet = client.account.getWallet('username', 'password');
+   * console.log(wallet.address);
+   * ```
+   *
+   * @param username - Sogni account username
+   * @param password - Sogni account password
+   */
+  getWallet(username: string, password: string): Wallet {
+    const pwd = toUtf8Bytes(username.toLowerCase() + password);
+    const salt = toUtf8Bytes('sogni-salt-value');
+    const pkey = pbkdf2(pwd, salt, 10000, 32, 'sha256');
+    return new Wallet(pkey, this.provider);
+  }
+
+  /**
+   * Create a new account with the given username, email, and password.
+   * @internal
+   *
+   * @param username
+   * @param email
+   * @param password
+   * @param subscribe
+   * @param referralCode
+   */
+  async create(
+    username: string,
+    email: string,
+    password: string,
+    subscribe = false,
+    referralCode?: string
+  ): Promise<AccountCreateData> {
+    const wallet = this.getWallet(username, password);
+    const nonce = await this.getNonce(wallet.address);
+    const payload = {
+      appid: this.client.appId,
+      username,
+      email,
+      subscribe: subscribe ? 1 : 0,
+      walletAddress: wallet.address
+    };
+    const signature = await this.eip712.signTypedData(wallet, 'signup', { ...payload, nonce });
+    const res = await this.client.rest.post<ApiReponse<AccountCreateData>>('/v1/account/create', {
+      ...payload,
+      referralCode,
+      signature
+    });
+    this.setToken(username, res.data.token);
+    return res.data;
+  }
+
+  /**
+   * Restore session with username and access 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 } = await client.account.login('username', 'password');
+   * localStorage.setItem('sogni-username', username);
+   * localStorage.setItem('sogni-token', token);
+   * ```
+   *
+   * @example Restore session from local storage
+   * ```typescript
+   * const username = localStorage.getItem('sogni-username');
+   * const token = localStorage.getItem('sogni-token');
+   * if (username && token) {
+   *  client.account.setToken(username, token);
+   *  console.log('Session restored');
+   * }
+   * ```
+   *
+   * @param username
+   * @param token
+   */
+  setToken(username: string, token: string): void {
+    this.client.authenticate(token);
+    this.currentAccount._update({
+      token,
+      username
+    });
+  }
+
+  /**
+   * Login with username and password. WebSocket connection is established after successful login.
+   *
+   * @example Login with username and password
+   * ```typescript
+   * await client.account.login('username', 'password');
+   * console.log('Logged in');
+   * ```
+   *
+   * @param username
+   * @param password
+   */
+  async login(username: string, password: string): Promise<LoginData> {
+    const wallet = this.getWallet(username, password);
+    const nonce = await this.getNonce(wallet.address);
+    const signature = await this.eip712.signTypedData(wallet, 'authentication', {
+      walletAddress: wallet.address,
+      nonce
+    });
+    const res = await this.client.rest.post<ApiReponse<LoginData>>('/v1/account/login', {
+      walletAddress: wallet.address,
+      signature
+    });
+    this.setToken(username, res.data.token);
+    return res.data;
+  }
+
+  /**
+   * Logout the user and close the WebSocket connection.
+   *
+   * @example Logout the user
+   * ```typescript
+   * await client.account.logout();
+   * console.log('Logged out');
+   * ```
+   */
+  async logout(): Promise<void> {
+    this.client.rest.post('/v1/account/logout').catch((e) => {
+      this.client.logger.error('Failed to logout', e);
+    });
+    this.client.removeAuth();
+    this.currentAccount._clear();
+  }
+
+  /**
+   * Refresh the balance of the current account.
+   *
+   * Usually, you don't need to call this method manually. Balance is updated automatically
+   * through WebSocket events. But you can call this method to force a balance refresh.
+   *
+   * @example Refresh user account balance
+   * ```typescript
+   * const balance = await client.account.refreshBalance();
+   * console.log(balance);
+   * // { net: '100.000000', settled: '100.000000', credit: '0.000000', debit: '0.000000' }
+   * ```
+   */
+  async refreshBalance(): Promise<BalanceData> {
+    const res = await this.client.rest.get<ApiReponse<BalanceData>>('/v1/account/balance');
+    this.currentAccount._update({ balance: res.data });
+    return res.data;
+  }
+
+  /**
+   * Get the balance of the wallet address.
+   *
+   * This method is used to get the balance of the wallet address. It returns $SOGNI and ETH balance.
+   *
+   * @example Get the balance of the wallet address
+   * ```typescript
+   * const address = client.account.currentAccount.walletAddress;
+   * const balance = await client.account.walletBalance(address);
+   * console.log(balance);
+   * // { token: '100.000000', ether: '0.000000' }
+   * ```
+   *
+   * @param walletAddress
+   */
+  async walletBalance(walletAddress: string) {
+    const res = await this.client.rest.get<ApiReponse<{ token: string; ether: string }>>(
+      '/v1/wallet/balance',
+      {
+        walletAddress
+      }
+    );
+    return res.data;
+  }
+
+  /**
+   * Validate the username before signup
+   * @internal
+   * @param username
+   */
+  async validateUsername(username: string) {
+    try {
+      return await this.client.rest.post<ApiReponse<undefined>>('/v1/account/username/validate', {
+        username
+      });
+    } catch (e) {
+      if (e instanceof ApiError) {
+        // Username is already taken
+        if (e.payload.errorCode === 108) {
+          return e.payload;
+        }
+      }
+      throw e;
+    }
+  }
+
+  /**
+   * Switch between fast and relaxed networks.
+   * Note: This method will close the current WebSocket connection and establish a new one.
+   * Do not call this method if you have any active projects.
+   *
+   * @example Switch to the fast network
+   * ```typescript
+   * client.apiClient.once('connected', ({ network }) => {
+   *  console.log('Switched to the network:', network);
+   * });
+   * await client.account.switchNetwork('fast');
+   * ```
+   * @param network
+   */
+  async switchNetwork(network: SupernetType) {
+    this.currentAccount._update({
+      networkStatus: 'connecting',
+      network: null
+    });
+    this.client.socket.switchNetwork(network);
+  }
+
+  /**
+   * Get the transaction history of the current account.
+   *
+   * @example Get the transaction history
+   * ```typescript
+   * const { entries, next } = await client.account.transactionHistory({
+   *  status: 'completed',
+   *  limit: 10,
+   *  address: client.account.currentAccount.walletAddress
+   * });
+   * ```
+   *
+   * @param params - Transaction history query parameters
+   * @returns Transaction history entries and next query parameters
+   */
+  async transactionHistory(
+    params: TxHistoryParams
+  ): Promise<{ entries: TxHistoryEntry[]; next: TxHistoryParams }> {
+    const res = await this.client.rest.get<ApiReponse<TxHistoryData>>('/v1/transactions/list', {
+      status: params.status,
+      address: params.address,
+      limit: params.limit.toString()
+    });
+
+    return {
+      entries: res.data.transactions.map(
+        (tx): TxHistoryEntry => ({
+          id: tx.id,
+          address: tx.address,
+          createTime: new Date(tx.createTime),
+          updateTime: new Date(tx.updateTime),
+          status: tx.status,
+          role: tx.role,
+          amount: tx.amount,
+          description: tx.description,
+          source: tx.source,
+          endTime: new Date(tx.endTime),
+          type: tx.type
+        })
+      ),
+      next: {
+        ...params,
+        offset: res.data.next
+      }
+    };
+  }
+
+  /**
+   * Get the rewards of the current account.
+   * @internal
+   */
+  async rewards(): Promise<Reward[]> {
+    const r =
+      await this.client.rest.get<ApiReponse<{ rewards: RewardRaw[] }>>('/v2/account/rewards');
+
+    return r.data.rewards.map(
+      (raw: RewardRaw): Reward => ({
+        id: raw.id,
+        type: raw.type,
+        title: raw.title,
+        description: raw.description,
+        amount: raw.amount,
+        claimed: !!raw.claimed,
+        canClaim: !!raw.canClaim,
+        lastClaim: new Date(raw.lastClaimTimestamp * 1000),
+        nextClaim:
+          raw.lastClaimTimestamp && raw.claimResetFrequencySec > -1
+            ? new Date(raw.lastClaimTimestamp * 1000 + raw.claimResetFrequencySec * 1000)
+            : null
+      })
+    );
+  }
+
+  /**
+   * Claim rewards by reward IDs.
+   * @internal
+   * @param rewardIds
+   */
+  async claimRewards(rewardIds: string[]): Promise<void> {
+    await this.client.rest.post('/v2/account/reward/claim', {
+      claims: rewardIds
+    });
+  }
+}
+
+export default AccountApi;

package/src/Account/types.ts

@@ -0,0 +1,90 @@
+export interface Nonce {
+  nonce: string;
+}
+
+export interface AccountCreateData {
+  token: string;
+}
+
+export interface LoginData {
+  token: string;
+  username: string;
+}
+
+export interface BalanceData {
+  settled: string;
+  credit: string;
+  debit: string;
+  net: string;
+}
+
+export interface TxHistoryParams {
+  status: 'completed';
+  address: string;
+  limit: number;
+  offset?: number;
+}
+
+export interface TxHistoryData {
+  transactions: TxRaw[];
+  next: number;
+}
+
+export interface TxRaw {
+  _id: string;
+  id: string;
+  SID: number;
+  address: string;
+  createTime: number;
+  updateTime: number;
+  status: 'completed';
+  role: 'artist' | 'worker';
+  clientSID: number;
+  addressSID: number;
+  amount: number;
+  description: string;
+  source: 'project' | string;
+  sourceSID: string;
+  endTime: number;
+  type: 'debit' | string;
+}
+
+export interface TxHistoryEntry {
+  id: string;
+  address: string;
+  createTime: Date;
+  updateTime: Date;
+  status: 'completed';
+  role: 'artist' | 'worker';
+  amount: number;
+  description: string;
+  source: 'project' | string;
+  endTime: Date;
+  type: 'debit' | string;
+}
+
+export type RewardType = 'instant' | 'conditioned';
+
+export interface RewardRaw {
+  id: string;
+  type: RewardType;
+  title: string;
+  description: string;
+  amount: string;
+  claimed: number;
+  canClaim: number;
+  lastClaimTimestamp: number;
+  claimResetFrequencySec: number;
+}
+
+export interface Reward {
+  id: string;
+  type: RewardType;
+  title: string;
+  description: string;
+  amount: string;
+  claimed: boolean;
+  canClaim: boolean;
+  lastClaim: Date;
+  nextClaim: Date | null;
+}

package/src/ApiClient/WebSocketClient/ErrorCode.ts

@@ -0,0 +1,15 @@
+export enum ErrorCode {
+  // App ID is blocked from connecting
+  APP_ID_BLOCKED = 4010,
+  // New connection from same app-id,  server will switch to it
+  SWITCH_CONNECTION = 4015,
+  // Authentication error happened
+  AUTH_ERROR = 4021
+}
+
+export function isNotRecoverable(code: ErrorCode) {
+  //check if code is in 4xxx
+  return code >= 4000 && code < 5000;
+}
+
+export default ErrorCode;

package/src/ApiClient/WebSocketClient/events.ts

@@ -0,0 +1,94 @@
+import { SupernetType } from './types';
+
+export type BalanceData = {
+  settled: string;
+  credit: string;
+  debit: string;
+  net: string;
+};
+
+export type JobErrorData = {
+  jobID: string;
+  imgID?: string;
+  isFromWorker: boolean;
+  error_message: string;
+  error: number;
+};
+
+export type JobProgressData = {
+  jobID: string;
+  imgID: string;
+  hasImage: boolean;
+  step: number;
+  stepCount: number;
+};
+
+export type JobResultData = {
+  jobID: string;
+  imgID: string;
+  performedStepCount: number;
+  lastSeed: string;
+  userCanceled: boolean;
+  triggeredNSFWFilter: boolean;
+};
+
+export type JobStateData =
+  | {
+      type: 'initiatingModel' | 'jobStarted';
+      jobID: string;
+      imgID: string;
+      workerName: string;
+    }
+  | {
+      jobID: string;
+      type: 'queued';
+      queuePosition: number;
+    }
+  | {
+      type: 'jobCompleted';
+      jobID: string;
+    };
+
+export type ServerConnectData = {
+  network: SupernetType;
+};
+
+export type ServerDisconnectData = {
+  code: number;
+  reason: string;
+};
+
+export type SocketEventMap = {
+  /**
+   * @event WebSocketClient#balanceUpdate - Received balance update
+   */
+  balanceUpdate: BalanceData;
+  /**
+   * @event WebSocketClient#jobError - Job error occurred
+   */
+  jobError: JobErrorData;
+  /**
+   * @event WebSocketClient#jobProgress - Job progress update
+   */
+  jobProgress: JobProgressData;
+  /**
+   * @event WebSocketClient#jobResult - Job result received
+   */
+  jobResult: JobResultData;
+  /**
+   * @event WebSocketClient#jobState - Job state changed
+   */
+  jobState: JobStateData;
+  /**
+   * @event WebSocketClient#swarmModels - Received swarm model count
+   */
+  swarmModels: Record<string, number>;
+  /**
+   * @event WebSocketClient#connected - WebSocket connection opened
+   */
+  connected: ServerConnectData;
+  /**
+   * @event WebSocketClient#disconnected - WebSocket connection was closed
+   */
+  disconnected: ServerDisconnectData;
+};