@sogni-ai/sogni-client 3.0.0-alpha.4 → 3.0.0-alpha.40

package/src/Account/index.ts

@@ -1,22 +1,31 @@
 import {
   AccountCreateData,
   AccountCreateParams,
-  BalanceData,
+  Balances,
+  ClaimOptions,
+  FullBalances,
   LoginData,
   Nonce,
   Reward,
   RewardRaw,
+  RewardsQuery,
   TxHistoryData,
   TxHistoryEntry,
   TxHistoryParams
 } from './types';
 import ApiGroup, { ApiConfig } from '../ApiGroup';
-import { Wallet, pbkdf2, toUtf8Bytes, Signature, parseEther } from 'ethers';
-import { ApiError, ApiReponse } from '../ApiClient';
+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';
 
+const MAX_DEPOSIT_ATTEMPTS = 4;
+enum ErrorCode {
+  INSUFFICIENT_BALANCE = 123,
+  INSUFFICIENT_ALLOWANCE = 149
+}
 /**
  * Account API methods that let you interact with the user's account.
  * Can be accessed via `client.account`. Look for more samples below.
@@ -39,7 +48,7 @@ class AccountApi extends ApiGroup {
     this.client.auth.on('updated', this.handleAuthUpdated.bind(this));
   }
 
-  private handleBalanceUpdate(data: BalanceData) {
+  private handleBalanceUpdate(data: Balances) {
     this.currentAccount._update({ balance: data });
   }
 
@@ -62,8 +71,13 @@ class AccountApi extends ApiGroup {
     }
   }
 
-  private async getNonce(walletAddress: string): Promise<string> {
-    const res = await this.client.rest.post<ApiReponse<Nonce>>('/v1/account/nonce', {
+  /**
+   * Get the nonce for the given wallet address.
+   * @param walletAddress
+   * @internal
+   */
+  async getNonce(walletAddress: string): Promise<string> {
+    const res = await this.client.rest.post<ApiResponse<Nonce>>('/v1/account/nonce', {
       walletAddress
     });
     return res.data.nonce;
@@ -87,7 +101,7 @@ class AccountApi extends ApiGroup {
     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);
+    return new Wallet(pkey);
   }
 
   /**
@@ -113,7 +127,7 @@ class AccountApi extends ApiGroup {
       turnstileToken
     };
     const signature = await this.eip712.signTypedData(wallet, 'signup', { ...payload, nonce });
-    const res = await this.client.rest.post<ApiReponse<AccountCreateData>>('/v1/account/create', {
+    const res = await this.client.rest.post<ApiResponse<AccountCreateData>>('/v1/account/create', {
       ...payload,
       referralCode,
       signature
@@ -176,7 +190,7 @@ class AccountApi extends ApiGroup {
       walletAddress: wallet.address,
       nonce
     });
-    const res = await this.client.rest.post<ApiReponse<LoginData>>('/v1/account/login', {
+    const res = await this.client.rest.post<ApiResponse<LoginData>>('/v1/account/login', {
       walletAddress: wallet.address,
       signature
     });
@@ -205,18 +219,33 @@ class AccountApi extends ApiGroup {
    * 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.
+   * through WebSocket events. But you can call this method to force a balance refresh. Note that
+   * will also trigger updated event on the current account.
    *
    * @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 });
+  async refreshBalance(): Promise<Balances> {
+    const balance = await this.accountBalance();
+    this.currentAccount._update({ balance: balance });
+    return balance;
+  }
+
+  /**
+   * Get the account balance of the current account.
+   * This method returns the account balance of the current user, including settled, credit, debit, and unclaimed earnings amounts.
+   *
+   * @example Get the account balance of the current user
+   * ```typescript
+   * const balance = await client.account.accountBalance();
+   * console.log(balance);
+   * ```
+   */
+  async accountBalance(): Promise<FullBalances> {
+    const res = await this.client.rest.get<ApiResponse<FullBalances>>('/v3/account/balance');
     return res.data;
   }
 
@@ -236,12 +265,11 @@ class AccountApi extends ApiGroup {
    * @param walletAddress
    */
   async walletBalance(walletAddress: string) {
-    const res = await this.client.rest.get<ApiReponse<{ token: string; ether: string }>>(
-      '/v1/wallet/balance',
-      {
-        walletAddress
-      }
-    );
+    const res = await this.client.rest.get<
+      ApiResponse<{ sogni: string; spark: string; ether: string }>
+    >('/v2/wallet/balance', {
+      walletAddress
+    });
     return res.data;
   }
 
@@ -252,7 +280,7 @@ class AccountApi extends ApiGroup {
    */
   async validateUsername(username: string) {
     try {
-      return await this.client.rest.post<ApiReponse<undefined>>('/v1/account/username/validate', {
+      return await this.client.rest.post<ApiResponse<undefined>>('/v1/account/username/validate', {
         username
       });
     } catch (e) {
@@ -310,11 +338,21 @@ class AccountApi extends ApiGroup {
   async transactionHistory(
     params: TxHistoryParams
   ): Promise<{ entries: TxHistoryEntry[]; next: TxHistoryParams }> {
-    const res = await this.client.rest.get<ApiReponse<TxHistoryData>>('/v1/transactions/list', {
+    const query: Record<string, string> = {
       status: params.status,
       address: params.address,
       limit: params.limit.toString()
-    });
+    };
+    if (params.offset) {
+      query.offset = params.offset.toString();
+    }
+    if (params.provider) {
+      query.provider = params.provider;
+    }
+    const res = await this.client.rest.get<ApiResponse<TxHistoryData>>(
+      '/v1/transactions/list',
+      query
+    );
 
     return {
       entries: res.data.transactions.map(
@@ -326,6 +364,7 @@ class AccountApi extends ApiGroup {
           status: tx.status,
           role: tx.role,
           amount: tx.amount,
+          tokenType: tx.tokenType,
           description: tx.description,
           source: tx.source,
           endTime: new Date(tx.endTime),
@@ -343,9 +382,11 @@ class AccountApi extends ApiGroup {
    * 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');
+  async rewards(query: RewardsQuery = {}): Promise<Reward[]> {
+    const r = await this.client.rest.get<ApiResponse<{ rewards: RewardRaw[] }>>(
+      '/v4/account/rewards',
+      query
+    );
 
     return r.data.rewards.map(
       (raw: RewardRaw): Reward => ({
@@ -354,9 +395,11 @@ class AccountApi extends ApiGroup {
         title: raw.title,
         description: raw.description,
         amount: raw.amount,
+        tokenType: raw.tokenType,
         claimed: !!raw.claimed,
         canClaim: !!raw.canClaim,
         lastClaim: new Date(raw.lastClaimTimestamp * 1000),
+        provider: query.provider || 'base',
         nextClaim:
           raw.lastClaimTimestamp && raw.claimResetFrequencySec > -1
             ? new Date(raw.lastClaimTimestamp * 1000 + raw.claimResetFrequencySec * 1000)
@@ -369,11 +412,22 @@ class AccountApi extends ApiGroup {
    * Claim rewards by reward IDs.
    * @internal
    * @param rewardIds
+   * @param options - Options for claiming rewards
+   * @param options.turnstileToken - Turnstile token for anti-bot protection
+   * @param options.provider - Provider name for the rewards
    */
-  async claimRewards(rewardIds: string[]): Promise<void> {
-    await this.client.rest.post('/v2/account/reward/claim', {
-      claims: rewardIds
-    });
+  async claimRewards(
+    rewardIds: string[],
+    { turnstileToken, provider }: ClaimOptions = {}
+  ): Promise<void> {
+    const payload: Record<string, any> = {
+      claims: rewardIds,
+      provider: provider || 'base'
+    };
+    if (turnstileToken) {
+      payload.turnstileToken = turnstileToken;
+    }
+    await this.client.rest.post('/v3/account/reward/claim', payload);
   }
 
   /**
@@ -394,6 +448,13 @@ class AccountApi extends ApiGroup {
       walletAddress: walletAddress,
       amount: parseEther(amount.toString()).toString()
     };
+    if (walletAddress !== this.currentAccount.walletAddress) {
+      throw new ApiError(400, {
+        status: 'error',
+        message: 'Incorrect password',
+        errorCode: 0
+      });
+    }
     const signature = await this.eip712.signTypedData(wallet, 'withdraw', { ...payload, nonce });
     await this.client.rest.post('/v1/account/token/withdraw', {
       ...payload,
@@ -412,34 +473,79 @@ class AccountApi extends ApiGroup {
    * @param amount - amount to transfer
    */
   async deposit(password: string, amount: number): Promise<void> {
+    return this._deposit(password, amount, 1);
+  }
+
+  private async _deposit(
+    password: string,
+    amount: number,
+    attemptCount: number = 1
+  ): Promise<void> {
     const wallet = this.getWallet(this.currentAccount.username!, password);
-    const walletAddress = wallet.address;
-    const nonce = await this.getNonce(walletAddress);
-    const payload = {
-      walletAddress,
-      amount: parseEther(amount.toString()).toString()
-    };
-    const { data } = await this.client.rest.post<ApiReponse<any>>(
-      '/v1/account/token/deposit/permit',
-      payload
+    if (wallet.address !== this.currentAccount.walletAddress) {
+      throw new ApiError(400, {
+        status: 'error',
+        message: 'Incorrect password',
+        errorCode: 0
+      });
+    }
+    try {
+      await this.client.rest.post('/v3/account/token/deposit', {
+        walletAddress: wallet.address,
+        amount: parseEther(amount.toString()).toString(),
+        provider: 'base'
+      });
+    } catch (error) {
+      if (error instanceof ApiError) {
+        if (error.payload.errorCode === ErrorCode.INSUFFICIENT_ALLOWANCE) {
+          // If this is the first attempt, we need to approve the token usage,
+          // otherwise we can retry the deposit directly.
+          if (attemptCount === 1) {
+            await this.approveTokenUsage(password, 'account');
+          }
+          if (attemptCount >= MAX_DEPOSIT_ATTEMPTS) {
+            throw error;
+          }
+          await delay(10000); // Wait for the approval transaction to be processed
+          await this._deposit(password, amount, attemptCount + 1);
+          return;
+        }
+        throw error;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Approve SOGNI token usage for the specified spender.
+   * @internal
+   *
+   * @param password - user account password
+   * @param spender - Spender type, either 'account' for deposit or 'staker' for staking contract
+   * @param provider - Provider name, defaults to 'base', can be 'base', 'etherlink', etc.
+   */
+  async approveTokenUsage(
+    password: string,
+    spender: 'account' | 'staker',
+    provider: string = 'base'
+  ): Promise<void> {
+    const wallet = this.getWallet(this.currentAccount.username!, password);
+    const permitR = await this.client.rest.post<{ data: Record<string, any> }>(
+      '/v1/contract/token/approve/permit',
+      {
+        walletAddress: wallet.address,
+        spender: spender,
+        provider: provider
+      }
     );
-    const { deadline } = data.message;
-    const permitSig = await wallet.signTypedData(data.domain, data.types, data.message);
-    const permitSignature = Signature.from(permitSig);
-    const depositPayload = {
-      ...payload,
-      deadline,
-      v: permitSignature.v,
-      r: permitSignature.r,
-      s: permitSignature.s
-    };
-    const depositSignature = await this.eip712.signTypedData(wallet, 'deposit', {
-      ...depositPayload,
-      nonce
-    });
-    await this.client.rest.post('/v1/account/token/deposit', {
-      ...depositPayload,
-      signature: depositSignature
+    const { domain, types, message } = permitR.data;
+    const signature = await wallet.signTypedData(domain, types, message);
+    await this.client.rest.post('/v1/contract/token/approve', {
+      walletAddress: wallet.address,
+      spender: spender,
+      provider: provider,
+      deadline: message.deadline,
+      approveSignature: signature
     });
   }
 }

package/src/Account/types.ts

@@ -1,3 +1,5 @@
+import { TokenType } from '../types/token';
+
 export interface Nonce {
   nonce: string;
 }
@@ -27,12 +29,22 @@ export interface BalanceData {
   credit: string;
   debit: string;
   net: string;
+  /**
+   * Unclaimed worker earnings amount
+   * @experimental Socket messages do not provide this field yet, so it may not be available in all cases.
+   */
+  unclaimed?: string;
 }
 
+export type Balances = Record<TokenType, BalanceData>;
+
+export type FullBalances = Record<TokenType, Required<BalanceData>>;
+
 export interface TxHistoryParams {
   status: 'completed';
   address: string;
   limit: number;
+  provider?: string;
   offset?: number;
 }
 
@@ -58,6 +70,7 @@ export interface TxRaw {
   sourceSID: string;
   endTime: number;
   type: 'debit' | string;
+  tokenType: TokenType;
 }
 
 export interface TxHistoryEntry {
@@ -68,6 +81,7 @@ export interface TxHistoryEntry {
   status: 'completed';
   role: 'artist' | 'worker';
   amount: number;
+  tokenType: TokenType;
   description: string;
   source: 'project' | string;
   endTime: Date;
@@ -82,20 +96,32 @@ export interface RewardRaw {
   title: string;
   description: string;
   amount: string;
+  tokenType: TokenType;
   claimed: number;
   canClaim: number;
   lastClaimTimestamp: number;
   claimResetFrequencySec: number;
 }
 
+export interface RewardsQuery {
+  provider?: string;
+}
+
 export interface Reward {
   id: string;
   type: RewardType;
   title: string;
   description: string;
   amount: string;
+  tokenType: TokenType;
   claimed: boolean;
   canClaim: boolean;
   lastClaim: Date;
   nextClaim: Date | null;
+  provider?: string;
+}
+
+export interface ClaimOptions {
+  turnstileToken?: string;
+  provider?: string;
 }

package/src/ApiClient/WebSocketClient/events.ts

@@ -1,11 +1,36 @@
 import { SupernetType } from './types';
+import { Balances } from '../../Account/types';
 
-export type BalanceData = {
-  settled: string;
-  credit: string;
-  debit: string;
-  net: string;
-};
+export interface AuthenticatedData {
+  id: string;
+  clientType: 'artist' | 'worker';
+  username: string;
+  address: string;
+  SID: number;
+  clientSID: number;
+  addressSID: number;
+  balanceVersion: 2;
+  tokens: {
+    sogni: {
+      settled: string;
+      credit: string;
+      debit: string;
+      net: string;
+    };
+    spark: {
+      settled: string;
+      credit: string;
+      debit: string;
+      net: string;
+    };
+  };
+  activeProjects: [];
+  unclaimedCompletedProjects: [];
+  isMainnet: boolean;
+  accountWasMigrated: boolean;
+  hasUnclaimedAirdrop: boolean;
+  firstLoginAfterMigration: boolean;
+}
 
 export type JobErrorData = {
   jobID: string;
@@ -38,6 +63,9 @@ export type JobStateData =
       jobID: string;
       imgID: string;
       workerName: string;
+      positivePrompt?: string;
+      negativePrompt?: string;
+      jobIndex?: number;
     }
   | {
       jobID: string;
@@ -58,11 +86,29 @@ export type ServerDisconnectData = {
   reason: string;
 };
 
+export type ToastMessage = {
+  type: 'info' | 'success' | 'warning' | 'error';
+  message: string;
+  // Number of milliseconds to show the toast
+  autoClose: number;
+  stickyID: string;
+};
+
+export type ArtistCancelConfirmation = {
+  didCancel: boolean;
+  error_message: string;
+  jobID: string;
+};
+
 export type SocketEventMap = {
+  /**
+   * @event WebSocketClient#authenticated - Received after successful connection to the WebSocket server
+   */
+  authenticated: AuthenticatedData;
   /**
    * @event WebSocketClient#balanceUpdate - Received balance update
    */
-  balanceUpdate: BalanceData;
+  balanceUpdate: Balances;
   /**
    * @event WebSocketClient#changeNetwork - Default network changed
    */
@@ -95,4 +141,10 @@ export type SocketEventMap = {
    * @event WebSocketClient#disconnected - WebSocket connection was closed
    */
   disconnected: ServerDisconnectData;
+  /**
+   * @event WebSocketClient#toastMessage - Toast message received
+   */
+  toastMessage: ToastMessage;
+
+  artistCancelConfirmation: ArtistCancelConfirmation;
 };

package/src/ApiClient/WebSocketClient/index.ts

@@ -9,7 +9,7 @@ import { LIB_VERSION } from '../../version';
 import { Logger } from '../../lib/DefaultLogger';
 import AuthManager from '../../lib/AuthManager';
 
-const PROTOCOL_VERSION = '0.4.3';
+const PROTOCOL_VERSION = '3.0.0';
 
 const PING_INTERVAL = 15000;
 

package/src/ApiClient/index.ts

@@ -11,7 +11,7 @@ import AuthManager, { Tokens } from '../lib/AuthManager';
 
 const WS_RECONNECT_ATTEMPTS = 5;
 
-export interface ApiReponse<D = JSONValue> {
+export interface ApiResponse<D = JSONValue> {
   status: 'success';
   data: D;
 }
@@ -40,13 +40,15 @@ class ApiClient extends TypedEventEmitter<ApiClientEvents> {
   private _socket: WebSocketClient;
   private _auth: AuthManager;
   private _reconnectAttempts = WS_RECONNECT_ATTEMPTS;
+  private _disableSocket: boolean = false;
 
   constructor(
     baseUrl: string,
     socketUrl: string,
     appId: string,
     networkType: SupernetType,
-    logger: Logger
+    logger: Logger,
+    disableSocket: boolean = false
   ) {
     super();
     this.appId = appId;
@@ -54,6 +56,7 @@ class ApiClient extends TypedEventEmitter<ApiClientEvents> {
     this._auth = new AuthManager(baseUrl, 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._socket.on('connected', this.handleSocketConnect.bind(this));
@@ -76,14 +79,22 @@ class ApiClient extends TypedEventEmitter<ApiClientEvents> {
     return this._rest;
   }
 
+  get socketEnabled(): boolean {
+    return !this._disableSocket;
+  }
+
   async authenticate(tokens: Tokens) {
     await this.auth.setTokens(tokens);
-    await this.socket.connect();
+    if (!this._disableSocket) {
+      await this.socket.connect();
+    }
   }
 
   removeAuth() {
     this.auth.clear();
-    this.socket.disconnect();
+    if (this.socket.isConnected) {
+      this.socket.disconnect();
+    }
   }
 
   handleSocketConnect({ network }: ServerConnectData) {

package/src/ApiGroup.ts

@@ -1,23 +1,19 @@
-import { AbstractProvider } from 'ethers';
 import ApiClient from './ApiClient';
 import EIP712Helper from './lib/EIP712Helper';
 import TypedEventEmitter, { EventMap } from './lib/TypedEventEmitter';
 
 export interface ApiConfig {
   client: ApiClient;
-  provider: AbstractProvider;
   eip712: EIP712Helper;
 }
 
 abstract class ApiGroup<E extends EventMap = {}> extends TypedEventEmitter<E> {
   protected client: ApiClient;
-  protected provider: AbstractProvider;
   protected eip712: EIP712Helper;
 
   constructor(config: ApiConfig) {
     super();
     this.client = config.client;
-    this.provider = config.provider;
     this.eip712 = config.eip712;
   }
 }