@sogni-ai/sogni-client 4.0.0-alpha.5 → 4.0.0-alpha.50

package/src/Account/index.ts

@@ -29,11 +29,11 @@ enum ErrorCode {
 }
 /**
  * Account API methods that let you interact with the user's account.
- * Can be accessed via `client.account`. Look for more samples below.
+ * Can be accessed via `sogni.account`. Look for more samples below.
  *
  * @example Retrieve the current account balance
  * ```typescript
- * const balance = await client.account.refreshBalance();
+ * const balance = await sogni.account.refreshBalance();
  * console.log(balance);
  * ```
  *
@@ -43,7 +43,12 @@ class AccountApi extends ApiGroup {
 
   constructor(config: ApiConfig) {
     super(config);
+    this.currentAccount._update({
+      networkStatus: this.client.socket.isConnected ? 'connected' : 'disconnected',
+      network: this.client.socket.supernetType
+    });
     this.client.socket.on('balanceUpdate', this.handleBalanceUpdate.bind(this));
+    this.client.socket.on('changeNetwork', this.handleChangeNetwork.bind(this));
     this.client.on('connected', this.handleServerConnected.bind(this));
     this.client.on('disconnected', this.handleServerDisconnected.bind(this));
     this.client.auth.on('updated', this.handleAuthUpdated.bind(this));
@@ -53,6 +58,10 @@ class AccountApi extends ApiGroup {
     this.currentAccount._update({ balance: data });
   }
 
+  private handleChangeNetwork({ network }: { network: SupernetType }) {
+    this.currentAccount._update({ network, networkStatus: 'connected' });
+  }
+
   private handleServerConnected({ network }: { network: SupernetType }) {
     this.currentAccount._update({
       networkStatus: 'connected',
@@ -70,6 +79,8 @@ class AccountApi extends ApiGroup {
   private handleAuthUpdated(isAuthenticated: boolean) {
     if (!isAuthenticated) {
       this.currentAccount._clear();
+    } else {
+      this.me();
     }
   }
 
@@ -92,7 +103,7 @@ class AccountApi extends ApiGroup {
    *
    * @example Create a wallet from username and password
    * ```typescript
-   * const wallet = client.account.getWallet('username', 'password');
+   * const wallet = sogni.account.getWallet('username', 'password');
    * console.log(wallet.address);
    * ```
    *
@@ -137,7 +148,6 @@ class AccountApi extends ApiGroup {
     } else {
       await auth.authenticate();
     }
-    await this.me();
     return res.data;
   }
 
@@ -146,7 +156,7 @@ class AccountApi extends ApiGroup {
    *
    * @example Login with username and password
    * ```typescript
-   * await client.account.login('username', 'password');
+   * await sogni.account.login('username', 'password');
    * console.log('Logged in');
    * ```
    *
@@ -173,7 +183,6 @@ class AccountApi extends ApiGroup {
     } else {
       await auth.authenticate();
     }
-    await this.me();
     return res.data;
   }
 
@@ -182,12 +191,20 @@ class AccountApi extends ApiGroup {
    *
    * @example Logout the user
    * ```typescript
-   * await client.account.logout();
+   * await sogni.account.logout();
    * console.log('Logged out');
    * ```
    */
   async logout(): Promise<void> {
-    await this.client.rest.post('/v1/account/logout');
+    try {
+      await this.client.rest.post('/v1/account/logout');
+    } catch (e) {
+      if (e instanceof ApiError && e.status === 401) {
+        this.client.logger.warn('Failed to logout, probably already logged out');
+      } else {
+        throw e;
+      }
+    }
     this.client.auth.clear();
   }
 
@@ -200,7 +217,7 @@ class AccountApi extends ApiGroup {
    *
    * @example Refresh user account balance
    * ```typescript
-   * const balance = await client.account.refreshBalance();
+   * const balance = await sogni.account.refreshBalance();
    * console.log(balance);
    * ```
    */
@@ -216,7 +233,7 @@ class AccountApi extends ApiGroup {
    *
    * @example Get the account balance of the current user
    * ```typescript
-   * const balance = await client.account.accountBalance();
+   * const balance = await sogni.account.accountBalance();
    * console.log(balance);
    * ```
    */
@@ -232,19 +249,21 @@ class AccountApi extends ApiGroup {
    *
    * @example Get the balance of the wallet address
    * ```typescript
-   * const address = client.account.currentAccount.walletAddress;
-   * const balance = await client.account.walletBalance(address);
+   * const address = sogni.account.currentAccount.walletAddress;
+   * const balance = await sogni.account.walletBalance(address);
    * console.log(balance);
    * // { token: '100.000000', ether: '0.000000' }
    * ```
    *
    * @param walletAddress
+   * @param provider - blockchain provider, 'base' or 'etherlink' defaults to 'base'
    */
-  async walletBalance(walletAddress: string) {
+  async walletBalance(walletAddress: string, provider: 'base' | 'etherlink' = 'base') {
     const res = await this.client.rest.get<
       ApiResponse<{ sogni: string; spark: string; ether: string }>
     >('/v2/wallet/balance', {
-      walletAddress
+      walletAddress,
+      provider
     });
     return res.data;
   }
@@ -287,9 +306,9 @@ class AccountApi extends ApiGroup {
    *
    * @example Switch to the fast network
    * ```typescript
-   * await client.account.switchNetwork('fast');
+   * await sogni.account.switchNetwork('fast');
    * console.log('Switched to the fast network, now lets wait until we get list of models');
-   * await client.projects.waitForModels();
+   * await sogni.projects.waitForModels();
    * ```
    * @param network - Network type to switch to
    */
@@ -311,10 +330,10 @@ class AccountApi extends ApiGroup {
    *
    * @example Get the transaction history
    * ```typescript
-   * const { entries, next } = await client.account.transactionHistory({
+   * const { entries, next } = await sogni.account.transactionHistory({
    *  status: 'completed',
    *  limit: 10,
-   *  address: client.account.currentAccount.walletAddress
+   *  address: sogni.account.currentAccount.walletAddress
    * });
    * ```
    *
@@ -420,7 +439,7 @@ class AccountApi extends ApiGroup {
    * Withdraw funds from the current account to wallet.
    * @example withdraw to current wallet address
    * ```typescript
-   * await client.account.withdraw('your-account-password', 100);
+   * await sogni.account.withdraw('your-account-password', 100);
    * ```
    *
    * @param password - account password
@@ -452,7 +471,7 @@ class AccountApi extends ApiGroup {
    * Deposit tokens from wallet to account
    * @example withdraw to current wallet address
    * ```typescript
-   * await client.account.deposit('your-account-password', 100);
+   * await sogni.account.deposit('your-account-password', 100);
    * ```
    *
    * @param password - account password

package/src/ApiClient/WebSocketClient/BrowserWebSocketClient/ChannelCoordinator.ts

@@ -0,0 +1,426 @@
+import getUUID from '../../../lib/getUUID';
+import { Logger } from '../../../lib/DefaultLogger';
+
+const PRIMARY_HEARTBEAT_INTERVAL = 2000;
+const PRIMARY_TIMEOUT = 4000;
+const ACK_TIMEOUT = 5000;
+
+enum MessageType {
+  ELECTION = 'election',
+  ELECTION_RESPONSE = 'election_response',
+  PRIMARY_ANNOUNCE = 'primary_announce',
+  PRIMARY_HEARTBEAT = 'primary_heartbeat',
+  BROADCAST = 'broadcast',
+  REQUEST = 'request',
+  REQUEST_ACK = 'request_ack'
+}
+
+interface Election {
+  type: MessageType.ELECTION;
+  payload: { priority: number };
+}
+
+interface ElectionResponse {
+  type: MessageType.ELECTION_RESPONSE;
+  payload: { id: string; priority: number };
+}
+
+interface PrimaryAnnounce {
+  type: MessageType.PRIMARY_ANNOUNCE;
+  payload: { id: string; priority: number };
+}
+
+interface PrimaryHeartbeat {
+  type: MessageType.PRIMARY_HEARTBEAT;
+  payload: { id: string; priority: number };
+}
+
+interface BroadcastMessage {
+  type: MessageType.BROADCAST;
+  payload: any;
+}
+
+interface RequestMessage {
+  type: MessageType.REQUEST;
+  payload: any;
+}
+
+interface RequestAckMessage {
+  type: MessageType.REQUEST_ACK;
+  payload: { id: string; error?: any };
+}
+
+type Message =
+  | Election
+  | ElectionResponse
+  | PrimaryAnnounce
+  | PrimaryHeartbeat
+  | BroadcastMessage
+  | RequestMessage
+  | RequestAckMessage;
+
+interface Envelope {
+  id: string;
+  senderId: string;
+  recipientId?: string;
+  timestamp: number;
+  message: Message;
+}
+
+const CHANNEL_NAME = 'sogni-websocket-channel';
+
+let isActiveTab = false;
+if (typeof window !== 'undefined' && window.location.protocol === 'https:') {
+  isActiveTab = window.document.visibilityState === 'visible';
+  window.addEventListener(
+    'visibilitychange',
+    () => (isActiveTab = window.document.visibilityState === 'visible')
+  );
+}
+
+interface Callbacks<M, N> {
+  onRoleChange: (isPrimary: boolean) => void;
+  onMessage: (message: M) => Promise<void>;
+  onNotification: (notification: N) => void;
+}
+
+interface Options<M, N> {
+  callbacks: Callbacks<M, N>;
+  logger: Logger;
+}
+
+/**
+ * A class responsible for coordinating communication across browser tabs or windows via BroadcastChannel API.
+ * It handles the role election of the primary (leader) tab, message broadcasting, heartbeats for primary tab monitoring,
+ * and message acknowledgment for reliable communication.
+ *
+ * The `ChannelCoordinator` ensures that one tab per session is assigned as the primary, while allowing others to act as secondaries,
+ * utilizing various message types for communication and coordination.
+ *
+ * Message is sent by secondary tabs to the primary tab via the `sendMessage` method. By sending message
+ * tab can tell primary to connect, disconnect, send message to socket etc.
+ *
+ * Notification is type of message broadcasted by primary to secondary tabs. This is mostly used to
+ * broadcast socket events from primary to secondary tabs.
+ *
+ * @template M - The type of messages being broadcast to other tabs/windows.
+ * @template N - The type of notifications being handled within the coordinator.
+ */
+class ChannelCoordinator<M, N> {
+  private readonly id: string = getUUID();
+  private priority = Date.now();
+  private readonly channel = new BroadcastChannel(CHANNEL_NAME);
+
+  private _isPrimary = false;
+  private callbacks: Callbacks<M, N>;
+  private logger: Logger;
+
+  private ackCallbacks: Record<string, (error?: any) => void> = {};
+
+  // User to handle election of primary tab
+  private electionInProgress: boolean = false;
+  private electionResponses: Map<string, number> = new Map();
+
+  // Heartbeat to detect primary tab death
+  private lastPrimaryHeartbeat: number = Date.now();
+  private heartbeatTimer: NodeJS.Timeout | null = null;
+  private primaryCheckTimer: NodeJS.Timeout | null = null;
+  private readyCallback: () => void | null = () => {};
+  private readonly readyPromise: Promise<void>;
+
+  constructor({ callbacks, logger }: Options<M, N>) {
+    this.readyPromise = new Promise((resolve) => {
+      let called = false;
+      this.readyCallback = () => {
+        if (!called) {
+          called = true;
+          resolve();
+        }
+      };
+    });
+    this.callbacks = callbacks;
+    this.logger = logger;
+    this.channel.addEventListener('message', (event) => this.handleMessage(event.data));
+    this.startElections();
+    this.startPrimaryMonitor();
+    // Listen for tab closing to gracefully release primary role
+    if (typeof window !== 'undefined') {
+      window.addEventListener('beforeunload', () => {
+        this.priority = 0;
+        this.startElections();
+      });
+    }
+  }
+
+  get isPrimary() {
+    return this._isPrimary;
+  }
+
+  private get currentPriority() {
+    return isActiveTab ? this.priority * 10 : this.priority;
+  }
+
+  isReady() {
+    return this.readyPromise;
+  }
+
+  private startElections() {
+    this.logger.debug(
+      `Start primary elections, my priority is ${this.currentPriority}, tab visibility is ${isActiveTab}`
+    );
+    this.electionInProgress = true;
+    this.electionResponses.clear();
+    this.electionResponses.set(this.id, this.currentPriority);
+    this.broadcast({
+      type: MessageType.ELECTION,
+      payload: { priority: this.currentPriority }
+    });
+    setTimeout(() => {
+      this.finishElections();
+    }, 500);
+  }
+
+  private finishElections() {
+    if (!this.electionInProgress) {
+      return;
+    }
+    // Find highest priority
+    let highestPriority = -Infinity;
+    let winnerId: string | null = null;
+
+    for (const [id, priority] of this.electionResponses) {
+      if (priority > highestPriority || (priority === highestPriority && id > (winnerId || ''))) {
+        highestPriority = priority;
+        winnerId = id;
+      }
+    }
+
+    if (winnerId === this.id) {
+      this.becomePrimary();
+      this.logger.debug(`Won elections! ${winnerId}`);
+    } else {
+      this.logger.debug(`Lost elections! Winner is ${winnerId}`);
+    }
+
+    this.electionInProgress = false;
+    this.electionResponses.clear();
+  }
+
+  private becomePrimary() {
+    this._isPrimary = true;
+    this.lastPrimaryHeartbeat = Date.now();
+    this.broadcast({
+      type: MessageType.PRIMARY_ANNOUNCE,
+      payload: { id: this.id, priority: this.currentPriority }
+    });
+    this.startHeartbeat();
+    this.callbacks.onRoleChange(true);
+    this.readyCallback();
+  }
+
+  private startHeartbeat(): void {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+    }
+
+    this.heartbeatTimer = setInterval(() => {
+      if (this._isPrimary) {
+        this.broadcast({
+          type: MessageType.PRIMARY_HEARTBEAT,
+          payload: { id: this.id, priority: this.currentPriority }
+        });
+      } else {
+        this.stopHeartbeat();
+      }
+    }, PRIMARY_HEARTBEAT_INTERVAL);
+  }
+
+  private stopHeartbeat(): void {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+
+  private startPrimaryMonitor(): void {
+    if (this.primaryCheckTimer) {
+      clearInterval(this.primaryCheckTimer);
+    }
+    this.primaryCheckTimer = setInterval(() => {
+      if (!this._isPrimary) {
+        const timeSinceLastHeartbeat = Date.now() - this.lastPrimaryHeartbeat;
+        if (timeSinceLastHeartbeat > PRIMARY_TIMEOUT) {
+          this.startElections();
+        }
+      } else {
+        this.lastPrimaryHeartbeat = Date.now();
+      }
+    }, PRIMARY_HEARTBEAT_INTERVAL);
+  }
+
+  private handleMessage(envelope: Envelope) {
+    const { senderId, recipientId, message } = envelope;
+    const isForOtherClient = recipientId && recipientId !== this.id;
+    if (senderId === this.id || isForOtherClient) {
+      return;
+    }
+    switch (message.type) {
+      case MessageType.ELECTION:
+        return this.handleElection(message);
+      case MessageType.ELECTION_RESPONSE:
+        return this.handleElectionResponse(message);
+      case MessageType.PRIMARY_ANNOUNCE:
+        return this.handlePrimaryAnnounce(message);
+      case MessageType.PRIMARY_HEARTBEAT:
+        return this.handlePrimaryHeartbeat();
+      case MessageType.BROADCAST:
+        return this.handleBroadcast(message);
+      case MessageType.REQUEST:
+        return this.handleRequest(message, envelope);
+      case MessageType.REQUEST_ACK:
+        return this.handleRequestAck(message);
+    }
+  }
+
+  private handleElection(message: Election) {
+    this.broadcast({
+      type: MessageType.ELECTION_RESPONSE,
+      payload: { id: this.id, priority: this.currentPriority }
+    });
+    if (this.currentPriority > message.payload.priority && !this.electionInProgress) {
+      this.startElections();
+    }
+  }
+
+  private handleElectionResponse(message: ElectionResponse) {
+    if (this.electionInProgress) {
+      this.electionResponses.set(message.payload.id, message.payload.priority);
+    }
+  }
+
+  private handlePrimaryAnnounce(message: PrimaryAnnounce) {
+    this.logger.debug(`Primary announced: ${message.payload.id}`);
+    const wasPrimary = this._isPrimary;
+    this._isPrimary = false;
+    this.lastPrimaryHeartbeat = Date.now();
+    this.electionInProgress = false;
+    this.electionResponses.clear();
+
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (wasPrimary) {
+      this.callbacks.onRoleChange(false);
+    }
+    this.readyCallback();
+  }
+
+  private handlePrimaryHeartbeat() {
+    this.lastPrimaryHeartbeat = Date.now();
+  }
+
+  private handleBroadcast(message: BroadcastMessage) {
+    this.logger.debug(`Received broadcast from primary`, message.payload);
+    this.callbacks.onNotification(message.payload);
+  }
+
+  private handleRequest(message: RequestMessage, envelope: Envelope) {
+    if (!this.isPrimary) {
+      return;
+    }
+    this.logger.debug(`Received request from secondary`, message.payload);
+    this.callbacks
+      .onMessage(message.payload)
+      .then(() => {
+        this.send(
+          {
+            type: MessageType.REQUEST_ACK,
+            payload: { id: envelope.id }
+          },
+          envelope.senderId
+        );
+      })
+      .catch((error) => {
+        this.send(
+          {
+            type: MessageType.REQUEST_ACK,
+            payload: { id: envelope.id, error }
+          },
+          envelope.senderId
+        );
+      });
+  }
+
+  private handleRequestAck(message: RequestAckMessage) {
+    const ackCallback = this.ackCallbacks[message.payload.id];
+    if (ackCallback) {
+      ackCallback(message.payload.error);
+      delete this.ackCallbacks[message.payload.id];
+    }
+  }
+
+  private async send(
+    message: RequestMessage | RequestAckMessage,
+    recipientId?: string
+  ): Promise<void> {
+    const envelope: Envelope = {
+      id: getUUID(),
+      senderId: this.id,
+      recipientId,
+      timestamp: Date.now(),
+      message: message
+    };
+    if (message.type !== MessageType.REQUEST) {
+      this.channel.postMessage(envelope);
+      return;
+    }
+    return new Promise<void>((resolve, reject) => {
+      const ackTimeout = setTimeout(() => {
+        if (this.ackCallbacks[envelope.id]) {
+          this.ackCallbacks[envelope.id](new Error('Message delivery timeout'));
+          delete this.ackCallbacks[envelope.id];
+        }
+      }, ACK_TIMEOUT);
+      this.ackCallbacks[envelope.id] = (error?: any) => {
+        clearTimeout(ackTimeout);
+        delete this.ackCallbacks[envelope.id];
+        if (error) {
+          reject(error);
+        } else {
+          resolve();
+        }
+      };
+      this.channel.postMessage(envelope);
+    });
+  }
+
+  private broadcast(message: Message) {
+    const envelope: Envelope = {
+      id: getUUID(),
+      senderId: this.id,
+      timestamp: Date.now(),
+      message: message
+    };
+    this.channel.postMessage(envelope);
+    return envelope.id;
+  }
+
+  public async sendMessage(message: M): Promise<any> {
+    this.logger.debug(`Sending message to primary`, message);
+    return this.send({
+      type: MessageType.REQUEST,
+      payload: message
+    });
+  }
+
+  public notify(message: N) {
+    this.logger.debug(`Sending notification to secondary tabs`, message);
+    this.broadcast({
+      type: MessageType.BROADCAST,
+      payload: message
+    });
+  }
+}
+
+export default ChannelCoordinator;