842 lines
30 KiB
JavaScript
842 lines
30 KiB
JavaScript
// ==UserScript==
|
|
// @name Binance Alpha Farm Agent
|
|
// @namespace http://baf.thuanle.me
|
|
// @version 2025.08.01
|
|
// @author TL
|
|
// @description Automated trading agent for Binance Alpha Farm
|
|
// @match https://www.binance.com/*
|
|
// @match https://accounts.binance.com/*
|
|
// @run-at document-idle
|
|
// @grant GM_setValue
|
|
// @grant GM_getValue
|
|
// @grant GM_registerMenuCommand
|
|
// @grant GM_notification
|
|
// @grant GM_xmlhttpRequest
|
|
// @grant GM_log
|
|
// @connect baf.thuanle.me
|
|
// @connect localhost
|
|
// @downloadURL https://git.thuanle.me/public/binance-alpha-farm-agent/raw/branch/main/agent.user.js
|
|
// @updateURL https://git.thuanle.me/public/binance-alpha-farm-agent/raw/branch/main/agent.user.js
|
|
// ==/UserScript==
|
|
|
|
(async () => {
|
|
'use strict';
|
|
|
|
// ====== CONFIGURATION ======
|
|
const CONFIG = {
|
|
heartbeat_interval: 10000,
|
|
task_poll_interval: 10000,
|
|
is_debug: true,
|
|
servers: {
|
|
local: { label: '🏠 Local', url: 'http://localhost:3000' },
|
|
prod: { label: '🌐 Prod', url: 'https://baf.thuanle.me' },
|
|
}
|
|
};
|
|
|
|
// ====== STATE MANAGEMENT ======
|
|
class AppState {
|
|
constructor() {
|
|
this.data = {
|
|
// Server configuration
|
|
server_mode: 'prod',
|
|
server: null,
|
|
|
|
// Page state
|
|
current_page: null,
|
|
is_logged_in: false,
|
|
|
|
// Bot status
|
|
bot_status: BOT_STATUS.READY_FOR_NEW_TASKS,
|
|
|
|
// Task state
|
|
current_task: null,
|
|
task_data: null,
|
|
current_step: null,
|
|
step_data: null,
|
|
|
|
// UI state
|
|
is_loading: false,
|
|
error_message: null
|
|
};
|
|
|
|
this.observers = new Map();
|
|
this.initialized = false;
|
|
}
|
|
|
|
// Initialize state from storage and page detection
|
|
async initialize() {
|
|
if (this.initialized) return;
|
|
|
|
// Load from storage
|
|
this.data.server_mode = await STORAGE.getServerMode();
|
|
this.data.server = CONFIG.servers[this.data.server_mode] || CONFIG.servers.prod;
|
|
this.data.bot_status = await STORAGE.getBotStatus();
|
|
|
|
// Detect current page and login state
|
|
this.data.current_page = BINANCE.detectPage();
|
|
this.data.is_logged_in = await BINANCE.isLoggedIn();
|
|
|
|
this.initialized = true;
|
|
TL.debug('STATE', 'Initialized', this.data);
|
|
}
|
|
|
|
// Get current state
|
|
getData() {
|
|
return { ...this.data };
|
|
}
|
|
|
|
// Update state with partial update
|
|
async update(updates) {
|
|
const oldData = { ...this.data };
|
|
|
|
// Apply updates
|
|
Object.assign(this.data, updates);
|
|
|
|
// Notify observers
|
|
await this.notifyObservers(oldData, this.data);
|
|
|
|
TL.debug('STATE', 'Updated', updates);
|
|
}
|
|
|
|
// Subscribe to state changes
|
|
subscribe(key, callback) {
|
|
if (!this.observers.has(key)) {
|
|
this.observers.set(key, []);
|
|
}
|
|
this.observers.get(key).push(callback);
|
|
}
|
|
|
|
// Unsubscribe from state changes
|
|
unsubscribe(key, callback) {
|
|
const callbacks = this.observers.get(key);
|
|
if (callbacks) {
|
|
const index = callbacks.indexOf(callback);
|
|
if (index > -1) {
|
|
callbacks.splice(index, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Notify all observers
|
|
async notifyObservers(oldData, newData) {
|
|
for (const [key, callbacks] of this.observers) {
|
|
const oldValue = oldData[key];
|
|
const newValue = newData[key];
|
|
|
|
if (oldValue !== newValue) {
|
|
for (const callback of callbacks) {
|
|
try {
|
|
await callback(oldValue, newValue, newData);
|
|
} catch (error) {
|
|
TL.error('STATE', `Observer error for ${key}:`, error);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ====== STORAGE MODULE ======
|
|
const STORAGE = {
|
|
key_token: 'baf-agent-token',
|
|
key_server_mode: 'baf-server-mode',
|
|
key_bot_status: 'baf-bot-status',
|
|
|
|
getToken: () => GM_getValue(STORAGE.key_token, ''),
|
|
setToken: token => GM_setValue(STORAGE.key_token, String(token || '').trim().replace(/^Bearer\s+/i, '')),
|
|
|
|
getServerMode: () => GM_getValue(STORAGE.key_server_mode, 'prod'),
|
|
setServerMode: (mode) => GM_setValue(STORAGE.key_server_mode, mode),
|
|
|
|
getBotStatus: () => GM_getValue(STORAGE.key_bot_status, BOT_STATUS.READY_FOR_NEW_TASKS),
|
|
setBotStatus: (status) => GM_setValue(STORAGE.key_bot_status, status),
|
|
};
|
|
|
|
// ====== UTILITY MODULE ======
|
|
const TL = {
|
|
debug: (tag, msg, ...args) => CONFIG.is_debug && GM_log(`[TL] [${tag}]\n${msg}`, ...args),
|
|
log: (tag, msg, ...args) => GM_log(`[TL] [${tag}]\n${msg}`, ...args),
|
|
error: (tag, msg, ...args) => GM_log(`[TL] [ERROR] [${tag}] ❌\n${msg}`, ...args),
|
|
|
|
noti: (title, text, timeout = 2500) => {
|
|
if (typeof GM_notification === 'function') {
|
|
GM_notification({ title, text, timeout });
|
|
return true;
|
|
}
|
|
alert(`${title}\n${text}`);
|
|
return false;
|
|
},
|
|
|
|
delay: (ms) => new Promise(resolve => setTimeout(resolve, ms)),
|
|
};
|
|
|
|
// DOM helpers
|
|
TL.dom = {
|
|
isVisible: (el) => {
|
|
if (!el) return false;
|
|
const cs = getComputedStyle(el);
|
|
if (cs.display === 'none' || cs.visibility === 'hidden' || cs.opacity === '0') return false;
|
|
return (el.offsetWidth + el.offsetHeight) > 0;
|
|
},
|
|
|
|
isDisabled: (el) => {
|
|
return el?.disabled === true || el?.getAttribute('aria-disabled') === 'true';
|
|
},
|
|
|
|
isInViewport: (el) => {
|
|
if (!el) return false;
|
|
const rect = el.getBoundingClientRect();
|
|
return (
|
|
rect.top >= 0 &&
|
|
rect.left >= 0 &&
|
|
rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) &&
|
|
rect.right <= (window.innerWidth || document.documentElement.clientWidth)
|
|
);
|
|
},
|
|
|
|
click: (el) => {
|
|
if (el && typeof el.click === 'function') el.click();
|
|
},
|
|
|
|
scrollToView: (el, behavior = 'smooth') => {
|
|
el?.scrollIntoView?.({ behavior, block: 'center' });
|
|
},
|
|
};
|
|
|
|
// Network helpers
|
|
TL.net = {
|
|
gmRequest(url, init = {}) {
|
|
const headersToObject = (h) => {
|
|
const o = {};
|
|
(h || new Headers()).forEach((v, k) => { o[k] = v; });
|
|
return o;
|
|
};
|
|
return new Promise((resolve, reject) => {
|
|
GM_xmlhttpRequest({
|
|
url,
|
|
method: (init.method || 'GET').toUpperCase(),
|
|
headers: headersToObject(init.headers),
|
|
data: init.body,
|
|
onload: (resp) => {
|
|
const text = resp.responseText || '';
|
|
let data = text;
|
|
const isJSON = /content-type:\s*application\/json/i.test(resp.responseHeaders || '');
|
|
if (isJSON) { try { data = JSON.parse(text); } catch { } }
|
|
TL.debug(`net`,`${init.method} ${resp.status} ${url}`, data);
|
|
resolve({
|
|
status: resp.status,
|
|
ok: resp.status >= 200 && resp.status < 300,
|
|
data,
|
|
rawText: text,
|
|
headers: null
|
|
});
|
|
},
|
|
onerror: reject,
|
|
ontimeout: () => reject(new Error('GM_xmlhttpRequest timeout')),
|
|
});
|
|
});
|
|
}
|
|
};
|
|
|
|
// ====== BAF API MODULE ======
|
|
const BAF = {
|
|
getServer: async () => {
|
|
const data = APP_STATE.getData();
|
|
return CONFIG.servers[data.server_mode] || CONFIG.servers.prod;
|
|
},
|
|
|
|
getHost: async () => {
|
|
const s = await BAF.getServer();
|
|
return s.url;
|
|
},
|
|
|
|
request: async (method, path, { params, body, headers } = {}) => {
|
|
const base = await BAF.getHost();
|
|
const url = new URL(path, base);
|
|
if (params) for (const [k, v] of Object.entries(params)) url.searchParams.append(k, v);
|
|
|
|
const h = new Headers(headers || {});
|
|
const token = await STORAGE.getToken();
|
|
if (token && !h.has('Authorization')) h.set('Authorization', `Bearer ${token}`);
|
|
|
|
const init = { method, headers: h };
|
|
if (body !== undefined && body !== null) {
|
|
if (!(body instanceof FormData) && !h.has('Content-Type')) h.set('Content-Type', 'application/json');
|
|
init.body = (h.get('Content-Type') || '').includes('application/json') && typeof body !== 'string'
|
|
? JSON.stringify(body)
|
|
: body;
|
|
}
|
|
return TL.net.gmRequest(url.toString(), init);
|
|
},
|
|
|
|
get: (path, params, init = {}) => BAF.request('GET', path, { params, headers: init.headers }),
|
|
post: (path, body, init = {}) => BAF.request('POST', path, { body, headers: init.headers }),
|
|
|
|
ping: (status) => BAF.post('/agent/ping', status),
|
|
|
|
getTasks: () => BAF.get('/agent/tasks'),
|
|
submitTaskResult: (taskId, result) => BAF.post(`/agent/tasks/${taskId}/result`, result),
|
|
};
|
|
|
|
// ====== BINANCE MODULE ======
|
|
const BINANCE_PAGES = {
|
|
LOGIN: 'login',
|
|
ALPHA_SWAP: 'alpha-swap',
|
|
ALPHA_ORDER_HISTORY: 'alpha-order-history',
|
|
UNKNOWN: 'unknown'
|
|
};
|
|
|
|
const BINANCE = {
|
|
detectPage: () => {
|
|
const pathname = window.location.pathname;
|
|
const hostname = window.location.hostname;
|
|
|
|
if (hostname === 'accounts.binance.com') {
|
|
if (pathname.includes('/login')) {
|
|
return BINANCE_PAGES.LOGIN;
|
|
}
|
|
}
|
|
|
|
if (hostname === 'www.binance.com') {
|
|
if (pathname.includes('/alpha/bsc/')) {
|
|
return BINANCE_PAGES.ALPHA_SWAP;
|
|
}
|
|
if (pathname.includes('/my/orders/alpha/orderhistory')) {
|
|
return BINANCE_PAGES.ALPHA_ORDER_HISTORY;
|
|
}
|
|
}
|
|
|
|
return BINANCE_PAGES.UNKNOWN;
|
|
},
|
|
|
|
isOnLoginPage: () => BINANCE.detectPage() === BINANCE_PAGES.LOGIN,
|
|
isOnAlphaSwapPage: () => BINANCE.detectPage() === BINANCE_PAGES.ALPHA_SWAP,
|
|
isOnAlphaOrderHistoryPage: () => BINANCE.detectPage() === BINANCE_PAGES.ALPHA_ORDER_HISTORY,
|
|
|
|
detectLoginState: () => {
|
|
if (BINANCE.isOnLoginPage()) {
|
|
return false;
|
|
}
|
|
|
|
const loginBtn = document.querySelector('#toLoginPage');
|
|
const regBtn = document.querySelector('#toRegisterPage');
|
|
|
|
if (TL.dom.isVisible?.(loginBtn) || TL.dom.isVisible?.(regBtn)) return false;
|
|
if (!loginBtn && !regBtn) return true;
|
|
|
|
return null;
|
|
},
|
|
|
|
isLoggedIn: async (timeoutMs = 6000, pollMs = 200) => {
|
|
const deadline = Date.now() + timeoutMs;
|
|
TL.debug(`BINANCE`,`isLoggedIn: Checking login state...`);
|
|
while (Date.now() < deadline) {
|
|
const state = BINANCE.detectLoginState();
|
|
if (state !== null) {
|
|
return state;
|
|
}
|
|
TL.debug(`BINANCE`,`isLoggedIn: not found. Sleeping...`);
|
|
await TL.delay(pollMs);
|
|
}
|
|
|
|
const fallback = BINANCE.detectLoginState() ?? false;
|
|
TL.debug(`BINANCE`,`isLoggedIn (timeout, fallback) => ${fallback ? 'true' : 'false'}`);
|
|
return fallback;
|
|
},
|
|
|
|
navigateToLogin: () => {
|
|
const loginBtn = document.querySelector('#toLoginPage');
|
|
if (TL.dom.isVisible?.(loginBtn)) {
|
|
TL.dom.click(loginBtn);
|
|
}
|
|
},
|
|
|
|
navigateToAlphaSwap: () => {
|
|
if (!BINANCE.isOnAlphaSwapPage()) {
|
|
window.location.href = 'https://www.binance.com/alpha/bsc/';
|
|
}
|
|
},
|
|
|
|
navigateToAlphaOrderHistory: () => {
|
|
if (!BINANCE.isOnAlphaOrderHistoryPage()) {
|
|
window.location.href = 'https://www.binance.com/en/my/orders/alpha/orderhistory';
|
|
}
|
|
},
|
|
};
|
|
|
|
// ====== TASK & STEP SYSTEM ======
|
|
|
|
// Task Types Enum
|
|
const TASK_TYPES = {
|
|
LOGIN: 'login',
|
|
GET_ORDER_HISTORY: 'get_order_history',
|
|
GET_BALANCE: 'get_balance',
|
|
SWAP: 'swap',
|
|
NO_TASK: 'no_task'
|
|
};
|
|
|
|
// Bot Status Enum
|
|
const BOT_STATUS = {
|
|
READY_FOR_NEW_TASKS: 'ready-for-new-tasks',
|
|
PAUSE_AUTOMATION: 'pause-automation',
|
|
PERFORMING_TASKS: 'performing-tasks'
|
|
};
|
|
|
|
// Login Method Enum
|
|
const LOGIN_METHOD = {
|
|
QR_CODE: 'qr_code',
|
|
PASSWORD: 'password',
|
|
EMAIL: 'email'
|
|
};
|
|
|
|
// Order Type Enum
|
|
const ORDER_TYPE = {
|
|
SWAP: 'swap',
|
|
LIMIT: 'limit',
|
|
MARKET: 'market'
|
|
};
|
|
|
|
// Order Status Enum
|
|
const ORDER_STATUS = {
|
|
COMPLETED: 'completed',
|
|
PENDING: 'pending',
|
|
CANCELLED: 'cancelled'
|
|
};
|
|
|
|
// Balance Format Enum
|
|
const BALANCE_FORMAT = {
|
|
JSON: 'json',
|
|
CSV: 'csv'
|
|
};
|
|
|
|
// Gas Fee Type Enum
|
|
const GAS_FEE_TYPE = {
|
|
AUTO: 'auto',
|
|
FAST: 'fast',
|
|
SLOW: 'slow'
|
|
};
|
|
|
|
const STEP_TYPES = {
|
|
// Login task steps
|
|
NAVIGATE_TO_LOGIN: 'navigate_to_login',
|
|
SELECT_QR_CODE: 'select_qr_code',
|
|
SEND_TO_SERVER: 'send_to_server',
|
|
WAIT_FOR_LOGIN: 'wait_for_login',
|
|
REPORT_RESULT: 'report_result',
|
|
|
|
// Order history task steps
|
|
NAVIGATE_TO_ORDER_HISTORY: 'navigate_to_order_history',
|
|
EXTRACT_ORDER_DATA: 'extract_order_data',
|
|
SEND_ORDER_DATA: 'send_order_data',
|
|
|
|
// Balance task steps
|
|
NAVIGATE_TO_BALANCE: 'navigate_to_balance',
|
|
EXTRACT_BALANCE_DATA: 'extract_balance_data',
|
|
SEND_BALANCE_DATA: 'send_balance_data',
|
|
|
|
// Swap task steps
|
|
NAVIGATE_TO_SWAP: 'navigate_to_swap',
|
|
FILL_SWAP_FORM: 'fill_swap_form',
|
|
CONFIRM_SWAP: 'confirm_swap',
|
|
WAIT_FOR_SWAP: 'wait_for_swap',
|
|
|
|
// Common steps
|
|
WAIT: 'wait',
|
|
ERROR_HANDLING: 'error_handling'
|
|
};
|
|
|
|
// ====== TASK RUNNER ======
|
|
const TaskRunner = {
|
|
// Helper function to validate enum values
|
|
validateEnum(value, enumObj, defaultValue) {
|
|
const validValues = Object.values(enumObj);
|
|
if (validValues.includes(value)) {
|
|
return value;
|
|
}
|
|
TL.debug('TASK', `Invalid enum value: ${value}, using default: ${defaultValue}`);
|
|
return defaultValue;
|
|
},
|
|
|
|
// Helper function to validate and merge task data with defaults
|
|
validateTaskData(taskType, taskData = {}) {
|
|
const mergedData = { ...taskData };
|
|
|
|
// Validate enum fields if present
|
|
if (taskType === TASK_TYPES.LOGIN && mergedData.method) {
|
|
mergedData.method = this.validateEnum(mergedData.method, LOGIN_METHOD, LOGIN_METHOD.QR_CODE);
|
|
}
|
|
|
|
if (taskType === TASK_TYPES.GET_ORDER_HISTORY) {
|
|
if (mergedData.order_types) {
|
|
mergedData.order_types = mergedData.order_types.map(type =>
|
|
this.validateEnum(type, ORDER_TYPE, ORDER_TYPE.SWAP)
|
|
);
|
|
}
|
|
if (mergedData.status) {
|
|
mergedData.status = mergedData.status.map(status =>
|
|
this.validateEnum(status, ORDER_STATUS, ORDER_STATUS.COMPLETED)
|
|
);
|
|
}
|
|
}
|
|
|
|
if (taskType === TASK_TYPES.GET_BALANCE && mergedData.format) {
|
|
mergedData.format = this.validateEnum(mergedData.format, BALANCE_FORMAT, BALANCE_FORMAT.JSON);
|
|
}
|
|
|
|
if (taskType === TASK_TYPES.SWAP && mergedData.gas_fee && typeof mergedData.gas_fee === 'string') {
|
|
mergedData.gas_fee = this.validateEnum(mergedData.gas_fee, GAS_FEE_TYPE, GAS_FEE_TYPE.AUTO);
|
|
}
|
|
|
|
TL.debug('TASK', `Validated task data for ${taskType}:`, mergedData);
|
|
return mergedData;
|
|
},
|
|
|
|
// Helper function to get current task data
|
|
getCurrentTaskData() {
|
|
const data = APP_STATE.getData();
|
|
return data.task_data || {};
|
|
},
|
|
|
|
// Helper function to update task data
|
|
async updateTaskData(newData) {
|
|
const currentData = this.getCurrentTaskData();
|
|
const updatedData = { ...currentData, ...newData };
|
|
await APP_STATE.update({ task_data: updatedData });
|
|
return updatedData;
|
|
},
|
|
|
|
// Helper function to check if current task is of specific type
|
|
isCurrentTaskType(taskType) {
|
|
const data = APP_STATE.getData();
|
|
return data.current_task?.type === taskType;
|
|
},
|
|
|
|
// Helper function to get current task type
|
|
getCurrentTaskType() {
|
|
const data = APP_STATE.getData();
|
|
return data.current_task?.type || null;
|
|
},
|
|
async checkForNewTasks() {
|
|
try {
|
|
const data = APP_STATE.getData();
|
|
if (data.bot_status !== BOT_STATUS.READY_FOR_NEW_TASKS) {
|
|
TL.debug('TASK', 'Bot not ready for new tasks, status:', data.bot_status);
|
|
return;
|
|
}
|
|
|
|
const response = await BAF.getTasks();
|
|
if (response.ok && response.data.task) {
|
|
const task = response.data.task;
|
|
TL.log('TASK', `Received new task: ${task.type}`, task);
|
|
|
|
// Validate and merge task data with defaults
|
|
const validatedTaskData = TaskRunner.validateTaskData(task.type, task.data);
|
|
|
|
await APP_STATE.update({
|
|
current_task: task,
|
|
task_data: validatedTaskData,
|
|
current_step: task.steps?.[0] || null,
|
|
bot_status: BOT_STATUS.PERFORMING_TASKS
|
|
});
|
|
|
|
// Start executing the task
|
|
await this.executeTask(task);
|
|
} else if (response.ok && response.data.no_task) {
|
|
TL.debug('TASK', 'No new tasks available');
|
|
// Sleep for interval then check again
|
|
setTimeout(() => this.checkForNewTasks(), CONFIG.task_poll_interval);
|
|
}
|
|
} catch (error) {
|
|
TL.error('TASK', 'Failed to check for new tasks:', error);
|
|
// Retry after interval
|
|
setTimeout(() => this.checkForNewTasks(), CONFIG.task_poll_interval);
|
|
}
|
|
},
|
|
|
|
async executeTask(task) {
|
|
TL.log('TASK', `Executing task: ${task.type}`, task);
|
|
|
|
try {
|
|
await APP_STATE.update({ is_loading: true });
|
|
|
|
let result = null;
|
|
|
|
switch (task.type) {
|
|
case TASK_TYPES.LOGIN:
|
|
result = await this.executeLoginTask(task);
|
|
break;
|
|
case TASK_TYPES.GET_ORDER_HISTORY:
|
|
result = await this.executeGetOrderHistoryTask(task);
|
|
break;
|
|
case TASK_TYPES.GET_BALANCE:
|
|
result = await this.executeGetBalanceTask(task);
|
|
break;
|
|
case TASK_TYPES.SWAP:
|
|
result = await this.executeSwapTask(task);
|
|
break;
|
|
default:
|
|
throw new Error(`Unknown task type: ${task.type}`);
|
|
}
|
|
|
|
// Submit result to server
|
|
await BAF.submitTaskResult(task.id, result);
|
|
|
|
// Task completed, return to ready state
|
|
await APP_STATE.update({
|
|
current_task: null,
|
|
task_data: null,
|
|
current_step: null,
|
|
step_data: null,
|
|
bot_status: BOT_STATUS.READY_FOR_NEW_TASKS,
|
|
is_loading: false
|
|
});
|
|
|
|
// Check for next task after a short delay
|
|
setTimeout(() => this.checkForNewTasks(), 1000);
|
|
|
|
} catch (error) {
|
|
TL.error('TASK', `Task execution failed:`, error);
|
|
await APP_STATE.update({
|
|
error_message: error.message,
|
|
bot_status: BOT_STATUS.READY_FOR_NEW_TASKS,
|
|
is_loading: false
|
|
});
|
|
|
|
// Retry after interval
|
|
setTimeout(() => this.checkForNewTasks(), CONFIG.task_poll_interval);
|
|
}
|
|
},
|
|
|
|
async executeLoginTask(task) {
|
|
const taskData = this.getCurrentTaskData();
|
|
TL.log('TASK', 'Executing login task', taskData);
|
|
|
|
// Implementation for login task with steps
|
|
// taskData contains: { method: 'qr_code' | 'password', credentials: {...}, timeout: 300000, retry_count: 3 }
|
|
|
|
// Example: Update task data during execution
|
|
await this.updateTaskData({
|
|
start_time: Date.now(),
|
|
attempts: 0
|
|
});
|
|
|
|
return { success: true, message: 'Login task completed' };
|
|
},
|
|
|
|
async executeGetOrderHistoryTask(task) {
|
|
const taskData = this.getCurrentTaskData();
|
|
TL.log('TASK', 'Executing get order history task', taskData);
|
|
|
|
// Implementation for get order history task
|
|
// taskData contains: { limit: 100, offset: 0, date_range: {...}, order_types: [...], status: [...] }
|
|
|
|
return { success: true, order_history: [] };
|
|
},
|
|
|
|
async executeGetBalanceTask(task) {
|
|
const taskData = this.getCurrentTaskData();
|
|
TL.log('TASK', 'Executing get balance task', taskData);
|
|
|
|
// Implementation for get balance task
|
|
// taskData contains: { currencies: ['USDT', 'BTC'], include_zero: false, include_locked: true, format: 'json' }
|
|
|
|
return { success: true, balance: {} };
|
|
},
|
|
|
|
async executeSwapTask(task) {
|
|
const taskData = this.getCurrentTaskData();
|
|
TL.log('TASK', 'Executing swap task', taskData);
|
|
|
|
// Implementation for swap task
|
|
// taskData contains: { from_token: 'USDT', to_token: 'BTC', amount: 100, slippage: 0.5, gas_fee: 'auto', deadline: 300, auto_confirm: true }
|
|
|
|
return { success: true, swap_result: {} };
|
|
}
|
|
};
|
|
|
|
// ====== STATE OBSERVERS ======
|
|
const StateWatchers = {
|
|
// Storage observer - saves state changes to storage
|
|
async onServerModeChange(oldValue, newValue, data) {
|
|
TL.debug('OBSERVER', `Server mode changed: ${oldValue} -> ${newValue}`);
|
|
await STORAGE.setServerMode(newValue);
|
|
|
|
// Update server info
|
|
await APP_STATE.update({
|
|
server: CONFIG.servers[newValue] || CONFIG.servers.prod
|
|
});
|
|
|
|
// Reload page after a short delay
|
|
setTimeout(() => location.reload(), 500);
|
|
},
|
|
|
|
async onBotStatusChange(oldValue, newValue, data) {
|
|
TL.debug('OBSERVER', `Bot status changed: ${oldValue} -> ${newValue}`);
|
|
await STORAGE.setBotStatus(newValue);
|
|
|
|
// Handle status-specific logic
|
|
if (newValue === BOT_STATUS.READY_FOR_NEW_TASKS) {
|
|
// Start checking for new tasks
|
|
TaskRunner.checkForNewTasks();
|
|
}
|
|
},
|
|
|
|
async onCurrentPageChange(oldValue, newValue, data) {
|
|
TL.debug('OBSERVER', `Page changed: ${oldValue} -> ${newValue}`);
|
|
|
|
// Handle page-specific logic for current task
|
|
if (data.current_task && data.current_step) {
|
|
// Continue with current step based on page change
|
|
await TaskRunner.continueCurrentStep();
|
|
}
|
|
},
|
|
|
|
async onLoginStateChange(oldValue, newValue, data) {
|
|
TL.debug('OBSERVER', `Login state changed: ${oldValue} -> ${newValue}`);
|
|
|
|
// Handle login state change for current task
|
|
if (data.current_task && data.current_step) {
|
|
await TaskRunner.continueCurrentStep();
|
|
}
|
|
}
|
|
};
|
|
|
|
// ====== MENU SYSTEM ======
|
|
async function createGM_Menu() {
|
|
const data = APP_STATE.getData();
|
|
const curSrv = data.server;
|
|
|
|
GM_registerMenuCommand(`Server: ${curSrv.label} (${curSrv.url})`, async () => {
|
|
try {
|
|
const next = (data.server_mode === 'local') ? 'prod' : 'local';
|
|
await APP_STATE.update({ server_mode: next });
|
|
|
|
const nsv = CONFIG.servers[next];
|
|
const msg = `Switched to ${nsv.label} (${nsv.url})`;
|
|
TL.debug(`BAF`, msg);
|
|
TL.noti('BAF Server Switched', msg);
|
|
} catch (e) {
|
|
TL.error('BAF', 'switch server error', e);
|
|
TL.noti('BAF Server Switched', `Switch server error: ${e.message}`);
|
|
}
|
|
});
|
|
|
|
GM_registerMenuCommand('Token', async () => {
|
|
try {
|
|
const curToken = await STORAGE.getToken();
|
|
const input = prompt('Bearer token:', curToken || '');
|
|
if (input !== null && input.trim() && input.trim() !== curToken) {
|
|
await STORAGE.setToken(input);
|
|
}
|
|
const s = await BAF.getServer();
|
|
const res = await BAF.ping();
|
|
const resStr =
|
|
`Server: ${s.label} (${s.url})\n` +
|
|
`Status: ${res.ok ? 'Connected ✅' : 'Failed ❌'} (${res.status})`;
|
|
TL.debug(`BAF`, resStr);
|
|
TL.noti('BAF Server', resStr);
|
|
} catch (e) {
|
|
const resStr = `ping error: ${e.message}`;
|
|
TL.error('BAF', resStr);
|
|
TL.noti('BAF Server', resStr);
|
|
}
|
|
});
|
|
|
|
GM_registerMenuCommand('Bot Status', async () => {
|
|
const data = APP_STATE.getData();
|
|
const statusOptions = [
|
|
BOT_STATUS.READY_FOR_NEW_TASKS,
|
|
BOT_STATUS.PAUSE_AUTOMATION,
|
|
BOT_STATUS.PERFORMING_TASKS
|
|
];
|
|
const currentIndex = statusOptions.indexOf(data.bot_status);
|
|
const nextIndex = (currentIndex + 1) % statusOptions.length;
|
|
const nextStatus = statusOptions[nextIndex];
|
|
|
|
await APP_STATE.update({ bot_status: nextStatus });
|
|
TL.noti('Bot Status', `Changed to: ${nextStatus}`);
|
|
});
|
|
|
|
GM_registerMenuCommand('Get Tasks', async () => {
|
|
await TaskRunner.checkForNewTasks();
|
|
});
|
|
}
|
|
|
|
// ====== HEARTBEAT ======
|
|
async function heartbeat_report() {
|
|
try {
|
|
const data = APP_STATE.getData();
|
|
const status = {
|
|
logged_in: data.is_logged_in,
|
|
current_page: data.current_page,
|
|
bot_status: data.bot_status,
|
|
current_task: data.current_task?.type || null,
|
|
task_data: data.task_data || null,
|
|
current_step: data.current_step || null,
|
|
has_current_task: !!data.current_task
|
|
};
|
|
|
|
TL.debug(`HEARTBEAT`, `${JSON.stringify(status, null, 2)}`);
|
|
await BAF.ping(status);
|
|
return status;
|
|
} catch (e) {
|
|
TL.error('HEARTBEAT', e.message);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// ====== PAGE MONITOR ======
|
|
async function monitorPageChanges() {
|
|
let lastPage = APP_STATE.getData().current_page;
|
|
|
|
setInterval(async () => {
|
|
const currentPage = BINANCE.detectPage();
|
|
if (currentPage !== lastPage) {
|
|
await APP_STATE.update({ current_page: currentPage });
|
|
lastPage = currentPage;
|
|
}
|
|
}, 1000);
|
|
}
|
|
|
|
// ====== INITIALIZATION ======
|
|
const APP_STATE = new AppState();
|
|
|
|
async function initialize() {
|
|
// Initialize state
|
|
await APP_STATE.initialize();
|
|
|
|
// Register observers
|
|
APP_STATE.subscribe('server_mode', StateWatchers.onServerModeChange);
|
|
APP_STATE.subscribe('bot_status', StateWatchers.onBotStatusChange);
|
|
APP_STATE.subscribe('current_page', StateWatchers.onCurrentPageChange);
|
|
APP_STATE.subscribe('is_logged_in', StateWatchers.onLoginStateChange);
|
|
|
|
// Create menu
|
|
await createGM_Menu();
|
|
|
|
// Start monitoring
|
|
monitorPageChanges();
|
|
|
|
// Start heartbeat
|
|
setInterval(heartbeat_report, CONFIG.heartbeat_interval);
|
|
|
|
// Welcome message
|
|
const ping_res = await BAF.ping();
|
|
const data = APP_STATE.getData();
|
|
const res =
|
|
`Server: ${data.server.label} (${data.server.url})\n` +
|
|
`Status: ${ping_res.ok ? 'Connected ✅' : 'Failed ❌'} (${ping_res.status})\n` +
|
|
`Page: ${data.current_page || 'unknown'} (${window.location.href})\n` +
|
|
`Bot Status: ${data.bot_status}`;
|
|
|
|
TL.log(`BAF`, res);
|
|
|
|
// Start initial task checking if ready
|
|
if (data.bot_status === BOT_STATUS.READY_FOR_NEW_TASKS) {
|
|
TaskRunner.checkForNewTasks();
|
|
}
|
|
}
|
|
|
|
// Start the application
|
|
await initialize();
|
|
})(); |