vantiv.io 1.0.0

package/src/classes/WebApi/Category/User.js

@@ -0,0 +1,88 @@
+const convertAvatarToPNG = require("../../../utils/ConvertSvgToPng");
+
+class UserCategory {
+    constructor(webapi, AxiosError) {
+        this.webapi = webapi;
+        this.logger = webapi.logger;
+        this.base = webapi.base;
+        this.AxiosErrorHandler = AxiosError
+    }
+
+    async get(identifier) {
+        const method = 'bot.webapi.user.get'
+
+        try {
+            if (!identifier || typeof identifier !== 'string') {
+                throw new TypeError('identifier must be a non-empty string');
+            }
+
+            const response = await this.base.get(`/users/${identifier}`);
+            if (response.status === 200 && response.data?.user) {
+                const { outfit, ...userData } = response.data.user;
+                return this._formatUserData(userData);
+            }
+            return null;
+        } catch (error) {
+            if (error instanceof TypeError) {
+                this.logger.error(method, `TypeError: ${error.message}`, { identifier }, error);
+            } else {
+                return this.AxiosErrorHandler.handle(error, this.logger, method, { identifier });
+            }
+        }
+    }
+
+    async getUserAvatar(identifier, imagePath = 'avatar.png') {
+    const method = `bot.webapi.user.getUserAvatar`
+    try {
+        if (!identifier || typeof identifier !== 'string') {
+            throw new TypeError('identifier must be a non-empty string');
+        }
+
+        if (imagePath && !imagePath.endsWith('.png')) {
+            throw new TypeError(`imagePath extension must be .png`);
+        }
+
+        const UserData = await this.get(identifier);
+        
+        if (!UserData || !UserData.svg) {
+            throw new Error('User not found or no avatar available');
+        }
+
+        const svg = UserData.svg;
+        
+        const status = await convertAvatarToPNG(svg, imagePath);
+        return status;
+
+    } catch (error) {
+        if (error instanceof TypeError) {
+            this.logger.error(method, `TypeError: ${error.message}`, { identifier }, error);
+        } else {
+            this.logger.error(method, `Failed to get user avatar: ${error.message}`, { identifier }, error);
+        }
+        return null;
+    }
+}
+
+    _formatUserData(userData) {
+        return {
+            id: userData.user_id,
+            username: userData.username,
+            bio: userData.bio || '',
+            joinedAt: this.webapi._formatDate(userData.created_at),
+            lastOnline: this.webapi._formatDate(userData.last_online),
+            followers: userData.follower_count || 0,
+            following: userData.following_count || 0,
+            friends: userData.friend_count || 0,
+            currentRoom: userData.current_room || '',
+            country: userData.country || '',
+            crew: userData.crew || '',
+            voiceEnabled: userData.voice_enabled || false,
+            discordConnected: userData.discord_connected || false,
+            avatar: userData.profile_photo || '',
+            icon: userData.photo_id || '',
+            svg: userData.avatar_svg || ''
+        };
+    }
+}
+
+module.exports = UserCategory

package/src/classes/WebApi/webapi.js

@@ -0,0 +1,52 @@
+const axios = require('axios')
+const UserAgent = require('user-agents')
+const { AxiosErrorHandler } = require('../Handlers/AxiosErrorHandler')
+const UserCategory = require('./Category/User')
+const RoomCategory = require('./Category/Room')
+const PostCategory = require('./Category/Post')
+const ItemCategory = require('./Category/Item')
+const GrabCategory = require('./Category/Grab')
+
+class WebApi {
+    constructor(bot) {
+        this.bot = bot
+        this.logger = bot.utils.logger
+        this.base = axios.create({
+            baseURL: 'https://webapi.highrise.game',
+            timeout: 30000,
+            headers: {
+                'Content-Type': 'application/json',
+                'User-Agent': new UserAgent().toString()
+            }
+        });
+
+        this.user = new UserCategory(this, AxiosErrorHandler);
+        this.room = new RoomCategory(this, AxiosErrorHandler);
+        this.post = new PostCategory(this, AxiosErrorHandler);
+        this.item = new ItemCategory(this, AxiosErrorHandler);
+        this.grab = new GrabCategory(this, AxiosErrorHandler);
+    }
+
+    _formatDate(dateString) {
+        if (!dateString) return null;
+        try {
+            const date = new Date(dateString);
+            return isNaN(date.getTime()) ? null : date.toISOString();
+        } catch (error) {
+            return null;
+        }
+    }
+
+    _formatInventory(inventory) {
+        if (!inventory || !Array.isArray(inventory.items)) return null;
+        return {
+            items: inventory.items.map(item => ({
+                itemId: item.item_id,
+                activePalette: item.active_palette || null,
+                accountBound: item.account_bound || false
+            }))
+        };
+    }
+}
+
+module.exports = { WebApi };

package/src/constants/TypesConstants.js

@@ -0,0 +1,89 @@
+const reactions = ['clap', 'heart', 'thumbs', 'wave', 'wink'];
+const gold_bars = [1, 5, 10, 50, 100, 500, 1000, 5000, 10000]
+const payment_methods = ["bot_wallet_only", "bot_wallet_priority", "user_wallet_only"]
+const default_skin = [
+    {
+        type: 'clothing',
+        amount: 1,
+        id: 'hair_front-n_malenew05',
+        account_bound: false,
+        active_palette: 1
+    },
+    {
+        type: 'clothing',
+        amount: 1,
+        id: 'hair_back-n_malenew05',
+        account_bound: false,
+        active_palette: 1
+    },
+    {
+        type: 'clothing',
+        amount: 1,
+        id: 'body-flesh',
+        account_bound: false,
+        active_palette: 27
+    },
+    {
+        type: 'clothing',
+        amount: 1,
+        id: 'eye-n_basic2018malesquaresleepy',
+        account_bound: false,
+        active_palette: 7
+    },
+    {
+        type: 'clothing',
+        amount: 1,
+        id: 'eyebrow-n_basic2018newbrows07',
+        account_bound: false,
+        active_palette: 0
+    },
+    {
+        type: 'clothing',
+        amount: 1,
+        id: 'nose-n_basic2018newnose05',
+        account_bound: false,
+        active_palette: 0
+    },
+    {
+        type: 'clothing',
+        amount: 1,
+        id: 'mouth-basic2018chippermouth',
+        account_bound: false,
+        active_palette: -1
+    },
+    {
+        type: 'clothing',
+        amount: 1,
+        id: 'freckle-n_basic2018freckle04',
+        account_bound: false,
+        active_palette: 0
+    },
+    {
+        type: 'clothing',
+        amount: 1,
+        id: 'shirt-n_room32019denimjackethoodie',
+        account_bound: false,
+        active_palette: 0
+    },
+    {
+        type: 'clothing',
+        amount: 1,
+        id: 'pants-n_starteritems2019cuffedjeanswhite',
+        account_bound: false,
+        active_palette: 0
+    },
+    {
+        type: 'clothing',
+        amount: 1,
+        id: 'shoes-n_room32019socksneakersgrey',
+        account_bound: false,
+        active_palette: 0
+    }
+]
+
+module.exports = {
+    reactions,
+    gold_bars,
+    default_skin,
+    payment_methods
+}

package/src/constants/WebSocketConstants.js

@@ -0,0 +1,80 @@
+const WebSocketConstants = {
+    // Connection
+    KEEPALIVE_INTERVAL: 15000,
+    MAX_RECONNECT_DELAY: 300000, // 5 minutes
+    RECONNECT_BACKOFF_FACTOR: 1.5,
+    DEFAULT_RECONNECT_DELAY: 5000,
+    DEFAULT_AUTO_RECONNECT: true,
+    MAX_RECONNECT_ATTEMPTS: 10,
+    RECONNECT_BACKOFF_FACTOR: 1.5,
+
+    // Logger Options
+    DEFAULT_LOGGER_OPTIONS: {
+        SHOW_TIMESTAMP: true,
+        SHOW_METHODS_NAME: true,
+        SHOW_COLORS: true
+    },
+
+    // Metrics
+    METRICS_UPDATE_INTERVAL: 5000,
+    INACTIVE_USER_THRESHOLD: 30000, // 30 seconds
+
+    // Request/Response
+    DEFAULT_TIMEOUT: 10000,
+    DEFAULT_MAX_RETRIES: 2,
+    DEFAULT_RETRY_DELAY: 100,
+
+    // Validation
+    TOKEN_LENGTH: 64,
+    ROOM_ID_LENGTH: 24,
+
+    // Endpoints
+    BASE_WS_URL: 'wss://highrise.game/web/botapi',
+
+    // Headers
+    HEADERS: {
+        API_TOKEN: 'api-token',
+        ROOM_ID: 'room-id',
+        CONTENT_TYPE: 'Content-Type',
+        USER_AGENT: 'User-Agent'
+    },
+
+    // Events
+    DEFAULT_EVENTS: [
+        'SessionMetadata', 'ChatEvent', 'WhisperEvent',
+        'UserMovedEvent', 'UserJoinedEvent', 'UserLeftEvent',
+        'MessageEvent', 'TipReactionEvent', 'RoomModeratedEvent'
+    ],
+
+    // Error Codes
+    ERROR_CODES: {
+        NORMAL_CLOSURE: 1000,
+        GOING_AWAY: 1001,
+        PROTOCOL_ERROR: 1002,
+        UNSUPPORTED_DATA: 1003,
+        NO_STATUS_RECEIVED: 1005,
+        ABNORMAL_CLOSURE: 1006,
+        INVALID_FRAME_PAYLOAD_DATA: 1007,
+        POLICY_VIOLATION: 1008,
+        MESSAGE_TOO_BIG: 1009,
+        MISSING_EXTENSION: 1010,
+        INTERNAL_ERROR: 1011,
+        SERVICE_RESTART: 1012,
+        TRY_AGAIN_LATER: 1013,
+        BAD_GATEWAY: 1014,
+        TLS_HANDSHAKE_FAILED: 1015
+    },
+
+    // Closing Codes
+    CLOSE_CODES: {
+        NORMAL: 1000,
+        AUTH_FAILED: 4001,
+        INVALID_TOKEN: 4003,
+        INVALID_ROOM: 4004,
+        RATE_LIMITED: 4009,
+        BANNED: 4029,
+        SERVER_ERROR: 5000
+    }
+};
+
+module.exports = WebSocketConstants;

package/src/core/Highrise.js

@@ -0,0 +1,123 @@
+const HighriseWebsocket = require('highrise-core/src/core/HighriseWebsocket');
+const { ConfigValidator } = require('highrise-core/src/validators/ConfigValidator');
+const { checkVersion } = require('highrise-core/src/utils/versionCheck');
+const WebSocketConstants = require('highrise-core/src/constants/WebSocketConstants')
+const Utils = require('highrise-core/src/classes/Actions/Utils');
+
+class Highrise extends HighriseWebsocket {
+    constructor(events, userOptions = {}) {
+        const userLoggerOptions = userOptions.LoggerOptions || {};
+
+        const options = {
+            LoggerOptions: {
+                showTimestamp: userLoggerOptions.showTimestamp !== undefined
+                    ? userLoggerOptions.showTimestamp
+                    : WebSocketConstants.DEFAULT_LOGGER_OPTIONS.SHOW_TIMESTAMP,
+
+                showMethodName: userLoggerOptions.showMethodName !== undefined
+                    ? userLoggerOptions.showMethodName
+                    : WebSocketConstants.DEFAULT_LOGGER_OPTIONS.SHOW_METHODS_NAME,
+
+                colors: userLoggerOptions.colors !== undefined
+                    ? userLoggerOptions.colors
+                    : WebSocketConstants.DEFAULT_LOGGER_OPTIONS.SHOW_COLORS
+            },
+
+            autoReconnect: userOptions.autoReconnect !== undefined
+                ? userOptions.autoReconnect
+                : WebSocketConstants.DEFAULT_AUTO_RECONNECT,
+
+            reconnectDelay: userOptions.reconnectDelay !== undefined
+                ? userOptions.reconnectDelay
+                : WebSocketConstants.DEFAULT_RECONNECT_DELAY,
+
+            customRoles: Array.isArray(userOptions.customRoles)
+                ? userOptions.customRoles
+                : [],
+
+            music: {
+                enabled: userOptions.music.enabled || false,
+            }
+        };
+
+        const eventsValidation = ConfigValidator.validateEvents(events);
+        const optionsValidation = ConfigValidator.validateHighriseOptions(options);
+
+        if (!eventsValidation.success) {
+            throw new Error(`Events validation failed: ${eventsValidation.errors.join(', ')}`);
+        }
+
+        if (!optionsValidation.success) {
+            throw new Error(`Options validation failed: ${optionsValidation.errors.join(', ')}`);
+        }
+
+        super(eventsValidation.validatedEvents, optionsValidation.validatedConfig);
+
+        this.utils = new Utils(this, {
+            ...options.LoggerOptions,
+            customRoles: options.customRoles
+        });
+
+        this._setupPublicAPI();
+
+        if (options.music.enabled) {
+            try {
+                const MusicClass = require('../classes/Actions/Music');
+                this.music = new MusicClass(this, options.music)
+            } catch (error) {
+                console.error('Failed to initialize MusicClass:', error);
+                this.music = null;
+            }
+        } else {
+            this.music = null;
+        }
+
+        checkVersion(this.utils.logger);
+    }
+
+    _setupPublicAPI() {
+        const { MessageClass } = require('../classes/Actions/Public');
+        const { WhisperClass } = require('../classes/Actions/Public');
+        const { DirectClass } = require('../classes/Actions/Direct');
+        const { PlayerClass } = require('../classes/Actions/Player');
+        const { RoomClass } = require('../classes/Actions/Room');
+        const { ChannelClass } = require('../classes/Actions/Channel');
+        const { InventoryClass } = require('../classes/Actions/Inventory');
+        const { WebApi } = require('../classes/WebApi/webapi');
+
+        this.message = new MessageClass(this);
+        this.whisper = new WhisperClass(this);
+        this.direct = new DirectClass(this);
+        this.player = new PlayerClass(this);
+        this.room = new RoomClass(this);
+        this.inventory = new InventoryClass(this);
+        this.webapi = new WebApi(this);
+        this.channel = new ChannelClass(this);
+
+        this.cache = {
+            position: this.movementCache
+        };
+    }
+
+    login(token, roomId) {
+        const credentialsValidation = ConfigValidator.validateCredentials(token, roomId);
+        if (!credentialsValidation.success) {
+            throw new Error(`Login validation failed: ${credentialsValidation.errors.join(', ')}`);
+        }
+
+        this.connect(token, roomId);
+    }
+
+    disconnect() {
+        if (this.music) {
+            this.music.destroy();
+        }
+
+        this.utils.DanceFloor.destroy();
+        this.channel.clear();
+        this.utils.permissions.clearAll()
+        super.disconnect(1000, 'Graceful shutdown');
+    }
+}
+
+module.exports = Highrise;

package/src/core/HighriseWebsocket.js

@@ -0,0 +1,228 @@
+const EventEmitter = require('events');
+
+const ConnectionManager = require('highrise-core/src/classes/Managers/Networking/ConnectionManager');
+const KeepAliveManager = require('highrise-core/src/classes/Managers/Networking/KeepAliveManager');
+const MessageHandler = require('highrise-core/src/classes/Managers/Networking/MessageHandler');
+const EventsManager = require('highrise-core/src/classes/Managers/Networking/EventsManager');
+const { FireAndForgetSender, RequestResponseSender } = require('highrise-core/src/classes/Managers/Networking/Request');
+
+const MetricsManager = require('highrise-core/src/classes/Managers/Helpers/MetricsManager');
+const CleanupManager = require('highrise-core/src/classes/Managers/Helpers/CleanupManager');
+
+const ChannelManager = require('highrise-core/src/classes/Managers/ChannelManager');
+const ConnectionValidator = require('highrise-core/src/validators/ConnectionValidator');
+const WebSocketHandlers = require('highrise-core/src/classes/Handlers/WebSocketHandlers');
+
+const { DirectClass } = require('highrise-core/src/classes/Actions/Direct');
+const { MovementCache } = require('highrise-core/src/classes/Caches/MovementCache');
+const AwaitClass = require('highrise-core/src/classes/Actions/Awaiter');
+const { Logger } = require('highrise-core/src/classes/Managers/Helpers/LoggerManager');
+
+class HighriseWebsocket extends EventEmitter {
+    constructor(events, options = {}) {
+        super();
+
+        this.events = ConnectionValidator.validateEvents(events);
+        this.options = ConnectionValidator.validateOptions(options);
+
+        this._initializeProperties();
+        this._setupManagers();
+        this._setupErrorHandlers();
+    }
+
+    _initializeProperties() {
+        this._connected = false;
+        this._info = {
+            user: { id: null, username: null },
+            room: { id: null, name: null, owner_id: null }
+        };
+    }
+
+    _setupManagers() {
+        this.logger = new Logger(this, this.options.LoggerOptions || {});
+
+        this.await = new AwaitClass(this);
+        this.metrics = new MetricsManager();
+        this.cleanupManager = new CleanupManager();
+        this.eventsManager = new EventsManager(this)
+        this.connectionManager = new ConnectionManager(this, this.logger, this.options);
+        this.keepAliveManager = new KeepAliveManager(this.connectionManager, this.logger);
+        this._fireAndForget = new FireAndForgetSender(this);
+        this._requestResponse = new RequestResponseSender(this);
+        this.messageHandler = new MessageHandler(this);
+        this._channelManager = new ChannelManager(this);
+
+        this._direct = new DirectClass(this);
+        this._movementCache = new MovementCache();
+
+        this.cleanupManager.registerResource(this._movementCache);
+        this.cleanupManager.registerResource(this._fireAndForget);
+        this.cleanupManager.registerResource(this._requestResponse);
+        this.cleanupManager.registerResource(this._channelManager);
+
+        const metricsInterval = setInterval(() => this._updateMetrics(), 5000);
+        this.cleanupManager.registerInterval(metricsInterval);
+
+        this._setupEventListeners();
+    }
+
+    _setupEventListeners() {
+        this.cleanupManager.registerListener(
+            this.connectionManager,
+            'connected',
+            this._handleConnected.bind(this)
+        );
+
+        this.cleanupManager.registerListener(
+            this.connectionManager,
+            'disconnected',
+            this._handleDisconnected.bind(this)
+        );
+
+        this.cleanupManager.registerListener(
+            this.connectionManager,
+            'message',
+            (data) => this.messageHandler.handle(data)
+        );
+
+        this.cleanupManager.registerListener(
+            this.connectionManager,
+            'error',
+            (error) => this.emit('error', error)
+        );
+    }
+
+    _setupErrorHandlers() {
+        this.webSocketHandlers = new WebSocketHandlers(this);
+        this.processHandlers = this.webSocketHandlers.setupErrorHandlers();
+        this.cleanupManager.registerResource({
+            cleanup: () => this.webSocketHandlers.removeErrorHandlers(this.processHandlers)
+        });
+    }
+
+    _handleConnected() {
+        this._connected = true;
+        this.keepAliveManager.start();
+        this.emit('connected');
+    }
+
+    _handleDisconnected(details) {
+        this._connected = false;
+        this.keepAliveManager.stop();
+        this.emit('disconnected', details);
+    }
+
+    connect(token, roomId) {
+        try {
+            ConnectionValidator.validateCredentials(token, roomId);
+
+            this._info.room.id = roomId;
+            this.connectionManager.connect(token, roomId, this.events);
+
+        } catch (error) {
+            this.logger.error('HighriseWebsocket.connect', `Connection failed ${error.message}`, {
+                tokenLength: token?.length,
+                roomIdLength: roomId?.length
+            }, error);
+
+            this.emit('error', error);
+            throw error;
+        }
+    }
+
+    disconnect(code = 1000, reason = 'Manual disconnect') {
+        this.logger.info('HighriseWebsocket.disconnect', 'Disconnecting...');
+
+        this.connectionManager.disconnect(code, reason);
+        this.cleanupManager.cleanup();
+
+        this._connected = false;
+        this.logger.success('HighriseWebsocket.disconnect', 'Disconnected successfully');
+        this.emit('disconnected', { code, reason, manual: true });
+    }
+
+    send(data) {
+        return this.connectionManager.send(data);
+    }
+
+    isConnected() {
+        return this.connectionManager.isConnected();
+    }
+
+    getMetrics() {
+        const cacheStats = this._movementCache.getStats();
+        const metrics = this.metrics.getSnapshot();
+
+        return {
+            ...metrics,
+            connected: this.isConnected(),
+            room: this._info.room.name || 'Unknown',
+            cache: {
+                users: cacheStats.totalUsers,
+                memory: this.metrics.formatBytes(cacheStats.memoryUsage),
+                active: cacheStats.activeUsers,
+                changes: cacheStats.changesProcessed
+            },
+            pendingReq: {
+                fireForget: this._fireAndForget.getPendingCount(),
+                reqRes: this._requestResponse.getPendingCount()
+            },
+            keepAlive: this.keepAliveManager.getStats(),
+            cleanup: this.cleanupManager.getStats()
+        };
+    }
+
+    configureSenders(config = {}) {
+        if (config.defaultTimeout !== undefined) {
+            this._requestResponse.setConfig({ defaultTimeout: config.defaultTimeout });
+        }
+
+        if (config.maxRetries !== undefined) {
+            this._requestResponse.setConfig({ maxRetries: config.maxRetries });
+            this._fireAndForget.setRetryConfig({ maxRetries: config.maxRetries });
+        }
+
+        if (config.retryDelay !== undefined) {
+            this._requestResponse.setConfig({ retryDelay: config.retryDelay });
+            this._fireAndForget.setRetryConfig({ retryDelay: config.retryDelay });
+        }
+
+        this.logger.info('HighriseWebsocket.configureSenders', 'Sender configuration updated', config);
+    }
+
+    getSenderStats() {
+        return {
+            fireAndForget: { pending: this._fireAndForget.getPendingCount() },
+            requestResponse: { pending: this._requestResponse.getPendingCount() }
+        };
+    }
+
+    _updateMetrics() {
+        const cacheStats = this._movementCache.getStats();
+        this.metrics.updateCacheStats(cacheStats);
+    }
+
+    get info() {
+        return { ...this._info };
+    }
+
+    get movementCache() {
+        return this._movementCache;
+    }
+
+    get fireAndForget() {
+        return this._fireAndForget;
+    }
+
+    get requestResponse() {
+        return this._requestResponse;
+    }
+
+    destroy() {
+        this.disconnect();
+        this.removeAllListeners();
+        this.cleanupManager.cleanup();
+    }
+}
+
+module.exports = HighriseWebsocket;