@sogni-ai/sogni-client 0.3.1 → 0.3.3

package/README.md

@@ -91,7 +91,7 @@ const project = await client.projects.create({
   numberOfImages: 1
 });
 ```
-**Note:** Full project parameter list can be found in [ProjectParams](https://sogni-ai.github.io/sogni-client/interfaces/ProjectParams.html) docs.
+**Note:** Full project parameter list can be found in [ProjectParams](https://sdk-docs.sogni.ai/interfaces/ProjectParams.html) docs.
 
 ### Getting project status and results
 In general there are 2 ways to work with API:

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const LIB_VERSION = "0.3.1";
+export declare const LIB_VERSION = "0.3.3";

package/dist/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LIB_VERSION = void 0;
-exports.LIB_VERSION = "0.3.1";
+exports.LIB_VERSION = "0.3.3";
 //# sourceMappingURL=version.js.map

package/package.json

@@ -3,13 +3,14 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Sogni Supernet Client",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
     "README.md",
-    "dist/"
+    "dist/",
+    "src/"
   ],
   "scripts": {
     "clean": "rimraf ./dist",
@@ -20,7 +21,8 @@
     "watch:esm": "npm run clean && tsc --watch --project tsconfig.esm.json",
     "prettier": "prettier --check ./src",
     "prettier:fix": "prettier --write ./src",
-    "docs:build": "npx typedoc"
+    "docs": "npx typedoc",
+    "postdocs": "node -p \"'sdk-docs.sogni.ai'\" > docs/CNAME"
   },
   "repository": {
     "type": "git",

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,243 @@
+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.
+ */
+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();
+  }
+
+  async getNonce(walletAddress: string): Promise<string> {
+    const res = await this.client.rest.post<ApiReponse<Nonce>>('/v1/account/nonce', {
+      walletAddress
+    });
+    return res.data.nonce;
+  }
+
+  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);
+  }
+
+  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;
+  }
+
+  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.
+   * @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.
+   */
+  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.
+   */
+  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 a account wallet.
+   * @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;
+  }
+
+  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.
+   * @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.
+   * @param params
+   */
+  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
+      }
+    };
+  }
+
+  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
+      })
+    );
+  }
+
+  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;
+};