hackchat-engine 1.1.6 → 1.1.8

package/Client.js

@@ -10,10 +10,8 @@ import SocketController from './websocket/SocketController.js';
 import EventsManager from './events/EventsManager.js';
 import ExtMap from './util/ExtMap.js';
 
-const util = new Util();
-
 /**
-  * Main client interface
+  * Main client interface for the hack.chat protocol
   * @extends {EventEmitter}
   */
 class Client extends EventEmitter {
@@ -33,26 +31,26 @@ class Client extends EventEmitter {
     };
 
     /**
-      * Create the websocket manager for this client
-      * @type {SocketController}
-      */
+     * Create the websocket manager for this client
+     * @type {SocketController}
+     */
     this.ws = new SocketController(this);
 
     /**
-      * Create the event manager for this client
+      * Create the event manager for this client, responsible for data structure mapping
       * @type {EventsManager}
       */
     this.events = new EventsManager(this);
 
     /**
       * Stored time that the client was last ready
-      * @type {Date}
+      * @type {Date|null}
       */
     this.readyAt = null;
 
     /**
       * User info for this client
-      * @type {ClientStruct}
+      * @type {ClientStruct|null}
       */
     this.myUser = null;
 
@@ -69,23 +67,25 @@ class Client extends EventEmitter {
     this.channels = new ExtMap();
 
     /**
-      * Active timeouts set on this client
-      * @type {Set}
+      * Active timeouts set on this client, managed for destruction
+      * @type {Set<Timeout>}
       */
     this.timeouts = new Set();
 
     /**
-      * Active intervals set on this client
+      * Active intervals set on this client, managed for destruction
       * @type {Set<Timeout>}
       */
     this.intervals = new Set();
 
     /**
       * Internal check to see if this code is run in node or a browser
-      * @type {Set<Timeout>}
+      * @type {boolean}
       */
     this.isBrowser = typeof window !== 'undefined';
 
+    this.util = new Util();
+
     /**
       * Initiate websocket connection
       */
@@ -108,7 +108,7 @@ class Client extends EventEmitter {
 
   /**
     * How long this client has been connected, in milliseconds
-    * @type {number}
+    * @type {number|null}
     * @readonly
     */
   get uptime() {
@@ -117,7 +117,7 @@ class Client extends EventEmitter {
 
   /**
     * Timestamp of the time the client when it was last ready
-    * @type {number}
+    * @type {number|null}
     * @readonly
     */
   get readyTimestamp() {
@@ -137,7 +137,7 @@ class Client extends EventEmitter {
     * Sends a join event to the hackchat server
     * @param {string} name Name to join with
     * @param {string} password Optional password to create trip code
-    * @param {string} channel Channel to auto join
+    * @param {string} channel Channel to join
     * @returns {void}
     */
   join(name = false, password = '', channel = false) {
@@ -167,11 +167,11 @@ class Client extends EventEmitter {
 
   /**
     * Establishes communication with a hackchat server
+    * @returns {Promise<void>}
     */
   async connectToWebSocket() {
     try {
-      // eslint-disable-next-line no-async-promise-executor
-      return new Promise(async (resolve, reject) => { // anti-pattern my ass
+      return new Promise((resolve, reject) => {
         this.emit(Events.DEBUG, '[client] Initiating connection. . .');
 
         const timeout = this.setTimeout(
@@ -179,23 +179,32 @@ class Client extends EventEmitter {
           1000 * 300,
         );
 
-        let { gateway } = this.options.ws;
+        const { gateway } = this.options.ws;
 
-        if (this.browser) {
-          this.emit(Events.DEBUG, '[client] Fetching ws config');
-          const conf = await util.fetchWebsocketConfig();
-          gateway = conf.gateway;
-        }
+        const initiateConnection = (gw) => {
+          this.emit(Events.DEBUG, `[client] Using gateway ${gw}`);
 
-        this.emit(Events.DEBUG, `[client] Using gateway ${gateway}`);
+          const success = this.ws.connect(gw);
+          if (!success) {
+            return reject(new Error('Connection failed to start (Socket likely not IDLE)'));
+          }
 
-        this.ws.connect(gateway);
-        this.ws.connection.once('error', reject);
+          this.ws.connection.once('error', reject);
 
-        this.once(Events.READY, () => {
-          this.clearTimeout(timeout);
-          resolve();
-        });
+          this.once(Events.READY, () => {
+            this.clearTimeout(timeout);
+            resolve();
+          });
+        };
+
+        if (this.browser) {
+          this.emit(Events.DEBUG, '[client] Fetching ws config');
+          this.util.fetchWebsocketConfig()
+            .then((conf) => initiateConnection(conf.gateway))
+            .catch(reject);
+        } else {
+          initiateConnection(gateway);
+        }
       });
     } catch (e) {
       this.destroy();
@@ -205,20 +214,21 @@ class Client extends EventEmitter {
 
   /**
     * Terminates the websocket connection and destroys the client
-    * @returns {Promise}
+    * @returns {Promise<void>}
     */
   destroy() {
     for (const t of this.timeouts) clearTimeout(t); // eslint-disable-line no-restricted-syntax
     for (const i of this.intervals) clearInterval(i); // eslint-disable-line no-restricted-syntax
     this.timeouts.clear();
     this.intervals.clear();
+    this.ws.destroy();
     return Promise.resolve();
   }
 
   /**
     * Create a managed timeout
     * @param {Function} func Target function to call
-    * @param {number} delay Wait time before calling func
+    * @param {number} delay Wait time before calling func (in ms)
     * @param {...*} args Optional arguments to pass to func
     * @returns {Timeout}
     */
@@ -245,7 +255,7 @@ class Client extends EventEmitter {
   /**
     * Create a managed interval
     * @param {Function} func Target function to call
-    * @param {number} delay Wait time before calling func
+    * @param {number} delay Wait time before calling func (in ms)
     * @param {...*} args Optional arguments to pass to func
     * @returns {Timeout}
     */
@@ -333,6 +343,68 @@ class Client extends EventEmitter {
       channel,
     });
   }
+
+  /**
+    * Registers a handler for a specific, unmapped command (cmd)
+    * This allows the client to process custom packets without needing the 'raw' event
+    * @param {string} cmd The command string from the server (e.g., 'signMessage')
+    * @param {function(object): void} handler The function to execute when the command is received
+    *
+    * @example
+    * import { Client } from 'hackchat-engine';
+    * const hcClient = new Client({
+    *   isBot: false,
+    * });
+    * hcClient.onCommand('example', (payload) => {
+    *   // This function only fires when { cmd: 'example' } is received
+    *   console.log(payload);
+    * });
+    */
+  onCommand(cmd, handler) {
+    if (!this.ws.connection || !this.ws.connection.packetRouter) {
+      this.emit(Events.WARN, `Cannot register command '${cmd}': Router not initialized.`);
+      return;
+    }
+
+    this.ws.connection.packetRouter.registerCustomCommand(cmd, handler);
+  }
+
+  /**
+    * Sends a Solana signature and the signed message back to the server for verification
+    * @param {string} signature The base64 or hex encoded signature from the client's wallet
+    * @param {string} signedMessage The original human-readable message that was signed
+    */
+  requestSiw(wallet, address) {
+    this.ws.send({
+      cmd: OPCodes.REQUEST_SIW,
+      wallet,
+      address,
+    });
+  }
+
+  /**
+    * Sends a Solana signature and the signed message back to the server for verification
+    * @param {string} signature The base64 or hex encoded signature from the client's wallet
+    * @param {string} signedMessage The original human-readable message that was signed
+    */
+  sendSignature(signature, signedMessage) {
+    this.ws.send({
+      cmd: OPCodes.SIGN_SIW,
+      signature,
+      signedMessage,
+    });
+  }
+
+  /**
+    * Sends a signed transaction back to the server for broadcasting
+    * @param {string} signedTransaction The base64 encoded signed transaction object
+    */
+  sendSignedTransaction(signedTransaction) {
+    this.ws.send({
+      cmd: OPCodes.CONFIRM_TX,
+      signedTransaction,
+    });
+  }
 }
 
 export default Client;

package/events/EventsManager.js

@@ -10,6 +10,10 @@ import UserLeave from './UserLeave.js';
 import UpdateUser from './UpdateUser.js';
 import Warning from './Warning.js';
 import Whisper from './Whisper.js';
+import PublicChannels from './PublicChannels.js';
+import HackAttempt from './HackAttempt.js';
+import SignMessage from './SignMessage.js';
+import SignTransaction from './SignTransaction.js';
 
 /**
   * This class routes incoming event data to it's proper handler
@@ -34,6 +38,10 @@ class EventsManager {
     this.UpdateUser = new UpdateUser(this.client);
     this.Warning = new Warning(this.client);
     this.Whisper = new Whisper(this.client);
+    this.PublicChannels = new PublicChannels(this.client);
+    this.HackAttempt = new HackAttempt(this.client);
+    this.SignMessage = new SignMessage(this.client);
+    this.SignTransaction = new SignTransaction(this.client);
   }
 }
 

package/events/HackAttempt.js

@@ -0,0 +1,24 @@
+import AbstractEvent from './AbstractEvent.js';
+import HackAttemptStruct from '../structures/HackAttemptStruct.js';
+
+/**
+  * This class handles an incoming `hackattempt` event from the server
+  * @private
+  */
+class PublicChannels extends AbstractEvent {
+  /**
+    * Event handler function
+    * @param {object} data Incoming event data
+    * @returns {object}
+    */
+  handle(data) {
+    const { client } = this;
+    const message = new HackAttemptStruct(client, data);
+
+    return {
+      message,
+    };
+  }
+}
+
+export default PublicChannels;

package/events/PublicChannels.js

@@ -0,0 +1,24 @@
+import AbstractEvent from './AbstractEvent.js';
+import PubChannelsStruct from '../structures/PubChannelsStruct.js';
+
+/**
+  * This class handles an incoming `publicchannels` event from the server
+  * @private
+  */
+class PublicChannels extends AbstractEvent {
+  /**
+    * Event handler function
+    * @param {object} data Incoming event data
+    * @returns {object}
+    */
+  handle(data) {
+    const { client } = this;
+    const message = new PubChannelsStruct(client, data);
+
+    return {
+      message,
+    };
+  }
+}
+
+export default PublicChannels;

package/events/SignMessage.js

@@ -0,0 +1,23 @@
+import AbstractEvent from './AbstractEvent.js';
+
+/**
+  * This class handles an incoming `signMessage` event from the server
+  * @private
+  */
+class SignMessage extends AbstractEvent {
+  /**
+    * Event handler function
+    * @param {object} data Incoming event data
+    * @returns {object}
+    */
+  handle(data) {
+    const { client } = this;
+    client.lastMsg = data;
+
+    return {
+      data,
+    };
+  }
+}
+
+export default SignMessage;

package/events/SignTransaction.js

@@ -0,0 +1,23 @@
+import AbstractEvent from './AbstractEvent.js';
+
+/**
+  * This class handles an incoming `signTransaction` event from the server
+  * @private
+  */
+class SignTransaction extends AbstractEvent {
+  /**
+    * Event handler function
+    * @param {object} data Incoming event data
+    * @returns {object}
+    */
+  handle(data) {
+    const { client } = this;
+    client.lastSign = data;
+
+    return {
+      data,
+    };
+  }
+}
+
+export default SignTransaction;

package/package.json

@@ -59,5 +59,5 @@
     "lintfix": "eslint --fix --ignore-path .gitignore .",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "version": "1.1.6"
+  "version": "1.1.8"
 }

package/structures/HackAttemptStruct.js

@@ -0,0 +1,76 @@
+/**
+  * This class handles parsing of the data of a `hackAttempt` event
+  */
+class HackAttemptStruct {
+  /**
+    * @param {Channel} channel Channel that the hackAttempt was sent through
+    * @param {Number} fromId User id of requester
+    * @param {User} from User whomst'd sent the hackAttempt
+    * @param {String} fromNick User name of whomst'd sent the hackAttempt
+    * @param {String} lib Target library
+    * @param {Client} client Main client reference
+    */
+  constructor(client, data) {
+    /**
+      * Add client reference
+      * @type {Client}
+      * @readonly
+      */
+    Object.defineProperty(this, 'client', { value: client });
+
+    if (data) this.setup(data);
+  }
+
+  /**
+    * Fill in this structure with provided data
+    * @param {object} data Incoming event data
+    * @returns {void}
+    */
+  setup(data) {
+    /**
+      * Origin channel of the request
+      * @type {string}
+      */
+    this.channel = data.channel;
+
+    /**
+      * Userid of request sender
+      * @type {number}
+      */
+    this.fromId = data.from;
+
+    /**
+      * The user who sent the whisper
+      * @type {User}
+      */
+    this.from = this.client.users.find((val) => val.userid === data.from);
+
+    /**
+      * Name of request sender
+      * @type {string}
+      */
+    this.fromNick = data.fromNick;
+
+    /**
+      * URL to requested library
+      * @type {string}
+      */
+    this.lib = data.lib;
+
+    /**
+      * The timestamp the publicchannels was sent at
+      * @type {number}
+      */
+    this.timestamp = new Date();
+  }
+
+  /**
+    * When referenced as a string, output the content instead of an object type
+    * @returns {string}
+    */
+  toString() {
+    return `${this.fromNick} suggested ${this.lib}`;
+  }
+}
+
+export default HackAttemptStruct;

package/structures/MessageStruct.js

@@ -62,7 +62,7 @@ class MessageStruct {
   }
 
   /**
-    * Reply to the message.
+    * Reply to the message
     * @param {string} text The content for the message
     * @returns {Promise}
     * @example

package/structures/PubChannelsStruct.js

@@ -0,0 +1,47 @@
+/**
+  * This class handles parsing of the data of a `publicchannels` event
+  */
+class PubChannelsStruct {
+  /**
+    * @param {Array} list Array of objects containing channel name and population
+    */
+  constructor(client, data) {
+    /**
+      * Add client reference
+      * @type {Client}
+      * @readonly
+      */
+    Object.defineProperty(this, 'client', { value: client });
+
+    if (data) this.setup(data);
+  }
+
+  /**
+    * Fill in this structure with provided data
+    * @param {object} data Incoming event data
+    * @returns {void}
+    */
+  setup(data) {
+    /**
+      * Array of objects containing channel name and population
+      * @type {array}
+      */
+    this.list = data.list;
+
+    /**
+      * The timestamp the publicchannels was sent at
+      * @type {number}
+      */
+    this.timestamp = new Date();
+  }
+
+  /**
+    * When referenced as a string, output the content instead of an object type
+    * @returns {string}
+    */
+  toString() {
+    return this.list.join(', ');
+  }
+}
+
+export default PubChannelsStruct;

package/structures/UserStruct.js

@@ -106,6 +106,12 @@ class User {
       */
     this.nickColor = data.color || false;
 
+    /**
+      * User's color
+      * @type {string}
+      */
+    this.flair = data.flair || '';
+
     /**
       * Numeric permission level
       * @type {number}
@@ -260,6 +266,7 @@ class User {
     this.userlevel = data.uType;
     this.bot = data.isBot;
     this.nickColor = data.color;
+    this.flair = data.flair;
     this.permissionLevel = data.level;
   }
 

package/util/Constants.js

@@ -73,6 +73,9 @@ export const OPCodes = {
   LOCK_ROOM: 'lockroom',
   UNLOCK_ROOM: 'unlockroom',
   WHISPER: 'whisper',
+  REQUEST_SIW: 'siw',
+  SIGN_SIW: 'signsiw',
+  CONFIRM_TX: 'confirmtx',
 };
 
 /**
@@ -100,6 +103,10 @@ export const Events = {
   ERROR: 'error',
   WARN: 'warn',
   DEBUG: 'debug',
+  PUB_CHANS: 'publicchannels',
+  HACK_ATTEMPT: 'hackAttempt',
+  SIGN_MESSAGE: 'signMessage',
+  SIGN_TRANSACTION: 'signTransaction',
 };
 
 /**
@@ -108,6 +115,7 @@ export const Events = {
   */
 export const WSEvents = {
   SESSION: 'session',
+  PUB_CHANS: 'publicchannels',
   NEW_MESSAGE: 'chat',
   CHANNEL_INFO: 'info',
   CHANNEL_EMOTE: 'emote',
@@ -119,4 +127,7 @@ export const WSEvents = {
   CHANNEL_CAPTCHA: 'captcha',
   CHANNEL_INVITE: 'invite',
   CHANNEL_WHISPER: 'whisper',
+  HACK_ATTEMPT: 'hackAttempt',
+  SIGN_MESSAGE: 'signMessage',
+  SIGN_TRANSACTION: 'signTransaction',
 };

package/websocket/SocketHandler.js

@@ -168,6 +168,11 @@ class SocketHandler extends EventEmitter {
     * @returns {void}
     */
   send(data) {
+    if (this.packetQueue.queue.length > 500) {
+      this.debug('Packet queue full, dropping message');
+      return;
+    }
+
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
       this.debug(`[socket handler] No connection, failed to send: ${data}`);
       return;
@@ -189,7 +194,7 @@ class SocketHandler extends EventEmitter {
       this.client.setTimeout(() => {
         this.connect(gateway, 0, force);
       },
-      after);
+        after);
 
       return false;
     }
@@ -221,7 +226,7 @@ class SocketHandler extends EventEmitter {
   }
 
   /**
-    * Destroys the connection.
+    * Destroys the connection
     * @returns {boolean}
     */
   destroy() {
@@ -290,9 +295,9 @@ class SocketHandler extends EventEmitter {
     this.debug(`[socket handler] Connected to gateway ${this.gateway}`);
 
     /**
-       * Emitted when websocket has been connected
-       * @event Client#connected
-       */
+      * Emitted when websocket has been connected
+      * @event Client#connected
+      */
     this.client.emit(Events.CONNECTED, this.client);
 
     this.sessionStart();
@@ -337,7 +342,7 @@ class SocketHandler extends EventEmitter {
       this.closeExpected = false;
 
       /**
-        * Emitted when the client's WebSocket disconnects and will no longer attempt to reconnect.
+        * Emitted when the client's WebSocket disconnects and will no longer attempt to reconnect
         * @event Client#disconnect
         * @param {CloseEvent} event Close event
         */

package/websocket/packets/PacketRouter.js

@@ -1,5 +1,9 @@
 /* eslint global-require: 0 */
-import { Status, WSEvents } from '../../util/Constants.js';
+import {
+  Status,
+  WSEvents,
+  Events,
+} from '../../util/Constants.js';
 
 import SessionHandler from './handlers/SessionHandler.js';
 import ChatHandler from './handlers/ChatHandler.js';
@@ -13,9 +17,14 @@ import UserLeaveHandler from './handlers/UserLeaveHandler.js';
 import UpdateUserHandler from './handlers/UpdateUserHandler.js';
 import CaptchaHandler from './handlers/CaptchaHandler.js';
 import WhisperHandler from './handlers/WhisperHandler.js';
+import PubChannelsHandler from './handlers/PubChannelsHandler.js';
+import HackAttemptHandler from './handlers/HackAttemptHandler.js';
+import SignMessageHandler from './handlers/SignMessageHandler.js';
+import SignTransactionHandler from './handlers/SignTransactionHandler.js';
 
 const BeforeReadyWhitelist = [
   WSEvents.SESSION,
+  WSEvents.PUB_CHANS,
 ];
 
 /**
@@ -45,6 +54,12 @@ class PacketRouter {
       */
     this.queue = [];
 
+    /**
+      * Custom handlers registered by the user for unmapped commands
+      * @type {Map<string, function(object): void>}
+      */
+    this.customHandlers = new Map();
+
     // Register all events
     this.registerEvent(WSEvents.SESSION, SessionHandler);
     this.registerEvent(WSEvents.NEW_MESSAGE, ChatHandler);
@@ -58,6 +73,10 @@ class PacketRouter {
     this.registerEvent(WSEvents.USER_UPDATE, UpdateUserHandler);
     this.registerEvent(WSEvents.CHANNEL_CAPTCHA, CaptchaHandler);
     this.registerEvent(WSEvents.CHANNEL_WHISPER, WhisperHandler);
+    this.registerEvent(WSEvents.PUB_CHANS, PubChannelsHandler);
+    this.registerEvent(WSEvents.HACK_ATTEMPT, HackAttemptHandler);
+    this.registerEvent(WSEvents.SIGN_MESSAGE, SignMessageHandler);
+    this.registerEvent(WSEvents.SIGN_TRANSACTION, SignTransactionHandler);
   }
 
   /**
@@ -69,6 +88,15 @@ class PacketRouter {
     return this.ws.client;
   }
 
+  /**
+    * Registers a custom command handler
+    * @param {string} cmd The command string
+    * @param {function(object): void} handler The function to execute
+    */
+  registerCustomCommand(cmd, handler) {
+    this.customHandlers.set(cmd, handler);
+  }
+
   /**
     * Register an event handler module
     * @param {string} eventname Event name constant
@@ -107,7 +135,17 @@ class PacketRouter {
     }
 
     if (!queue && this.queue.length > 0) this.processQueue();
+
     if (this.handlers[packet.cmd]) return this.handlers[packet.cmd].handle(packet);
+
+    const customHandler = this.customHandlers.get(packet.cmd);
+    if (customHandler) {
+      this.client.emit(Events.DEBUG, `[router] Executing custom handler for cmd: ${packet.cmd}`);
+      customHandler(packet);
+
+      return true;
+    }
+
     return false;
   }
 }

package/websocket/packets/handlers/EmoteHandler.js

@@ -16,7 +16,7 @@ class EmoteHandler extends AbstractHandler {
     const response = client.events.Emote.handle(packet);
 
     /**
-      * Emitted when the client recives an emote packet
+      * Emitted when the client receives an emote packet
       * @event Client#emote
       * @param {Emote} message The created message
       */

package/websocket/packets/handlers/HackAttemptHandler.js

@@ -0,0 +1,30 @@
+import AbstractHandler from './AbstractHandler.js';
+import { Events } from '../../../util/Constants.js';
+
+/**
+  * Handles an incoming hackAttempt
+  * @private
+  */
+class HackAttemptHandler extends AbstractHandler {
+  /**
+    * Parses incoming packet data and emits related events
+    * @param {object} packet Incoming packet data
+    * @returns {void}
+    */
+  handle(packet) {
+    const { client } = this.packetRouter;
+    const response = client.events.HackAttempt.handle(packet);
+
+    /**
+      * Emitted when the client receives a hackAttempt packet
+      * @event Client#hackAttempt
+      * @param {HackAttemptStruct} message The hack attempt event
+      */
+    client.emit(Events.HACK_ATTEMPT, response.message);
+
+    // Emit debug info
+    client.emit(Events.DEBUG, `[${Events.HACK_ATTEMPT}]: ${packet}`);
+  }
+}
+
+export default HackAttemptHandler;

package/websocket/packets/handlers/InfoHandler.js

@@ -16,7 +16,7 @@ class InfoHandler extends AbstractHandler {
     const response = client.events.Info.handle(packet);
 
     /**
-      * Emitted when the client recives an info packet
+      * Emitted when the client receives an info packet
       * @event Client#information
       * @param {Information} message The created message
       */

package/websocket/packets/handlers/InviteHandler.js

@@ -16,7 +16,7 @@ class InviteHandler extends AbstractHandler {
     const response = client.events.Invite.handle(packet);
 
     /**
-      * Emitted when the client recives an invite packet
+      * Emitted when the client receives an invite packet
       * @event Client#invite
       * @param {Invite} message The created message
       */

package/websocket/packets/handlers/PubChannelsHandler.js

@@ -0,0 +1,30 @@
+import AbstractHandler from './AbstractHandler.js';
+import { Events } from '../../../util/Constants.js';
+
+/**
+  * Handles an incoming public channels event
+  * @private
+  */
+class PubChannelsHandler extends AbstractHandler {
+  /**
+    * Parses incoming packet data and emits related events
+    * @param {object} packet Incoming packet data
+    * @returns {void}
+    */
+  handle(packet) {
+    const { client } = this.packetRouter;
+    const response = client.events.PublicChannels.handle(packet);
+
+    /**
+      * Emitted when the client receives a publicchannels packet
+      * @event Client#publicchannels
+      * @param {PubChannelsStruct} message The publicchannels event
+      */
+    client.emit(Events.PUB_CHANS, response.message);
+
+    // Emit debug info
+    client.emit(Events.DEBUG, `[${Events.PUB_CHANS}]: ${packet}`);
+  }
+}
+
+export default PubChannelsHandler;

package/websocket/packets/handlers/SignMessageHandler.js

@@ -0,0 +1,34 @@
+import AbstractHandler from './AbstractHandler.js';
+import { Events } from '../../../util/Constants.js';
+
+/**
+  * Handles an incoming custom `signMessage` event from the server
+  * @private
+  */
+class SignMessageHandler extends AbstractHandler {
+  /**
+    * Parses incoming packet data and emits related events
+    * @param {object} packet Incoming packet data
+    * @returns {void}
+    */
+  handle(packet) {
+    const { client } = this.packetRouter;
+
+    /**
+      * Emitted when the server requests the client to sign a message
+      * This is used for Sign-In with Solana (SIWS) authentication
+      * @event Client#signMessage
+      * @param {object} payload The payload containing the wallet and message
+      * @param {string} payload.wallet The public key of the wallet to sign with
+      * @param {string} payload.message The human-readable message to be signed
+      */
+    client.emit(Events.SIGN_MESSAGE, {
+      wallet: packet.wallet,
+      message: packet.message,
+    });
+
+    client.emit(Events.DEBUG, `[${Events.SIGN_MESSAGE}]: Request received for wallet ${packet.wallet}`);
+  }
+}
+
+export default SignMessageHandler;

package/websocket/packets/handlers/SignTransactionHandler.js

@@ -0,0 +1,36 @@
+import AbstractHandler from './AbstractHandler.js';
+import { Events } from '../../../util/Constants.js';
+
+/**
+  * Handles an incoming custom `signTransaction` event from the server
+  * @private
+  */
+class SignTransactionHandler extends AbstractHandler {
+  /**
+    * Parses incoming packet data and emits related events
+    * @param {object} packet Incoming packet data
+    * @returns {void}
+    */
+  handle(packet) {
+    const { client } = this.packetRouter;
+
+    /**
+      * Emitted when the server requests the client to sign a transaction
+      * @event Client#signTransaction
+      * @param {object} payload The payload containing the tx and type
+      * @param {string} payload.tx The base64 encoded transaction payload
+      * @param {string} payload.type The transaction type
+      * @param {string} payload.channel The channel which invoked the event
+      */
+    client.emit(Events.SIGN_TRANSACTION, {
+      tx: packet.tx,
+      type: packet.type,
+      channel: packet.channel,
+      from: packet.from,
+    });
+
+    client.emit(Events.DEBUG, `[${Events.SIGN_TRANSACTION}]: signTransaction requested`);
+  }
+}
+
+export default SignTransactionHandler;

package/websocket/packets/handlers/WhisperHandler.js

@@ -16,7 +16,7 @@ class WhisperHandler extends AbstractHandler {
     const response = client.events.Whisper.handle(packet);
 
     /**
-      * Emitted when the client recives a whisper packet
+      * Emitted when the client receives a whisper packet
       * @event Client#whisper
       * @param {WhisperStruct} message The whisper event
       */