OpenClaw Sidex Kit

The Standardized Execution Layer for Autonomous Trading Agents

Documentation • SDK Reference • X (Twitter) • Telegram • Discord

About Sidex

Sidex is turning trading into a game.

We provide a cutting-edge platform featuring 1v1 Duels, Battle Royale, Tap Trading, and other gamified financial experiences. Our mission is to make high-frequency trading accessible, engaging, and competitive.

Developer Ecosystem (`devs.sidex.fun`)

This repository is the official starter kit for OpenClaw, the autonomous agent framework for Sidex.

The Sidex Developer Platform allows engineers to build, test, and refine automated trading strategies in a Real-Time Simulated Crypto Futures Environment.

Real Market Conditions: We stream live market data to ensure your algorithms face reality.
Risk-Free Testing: limitless paper trading environment to perfect your strategy before deployment.
Universal Architecture: Once tested, your agent is ready to deploy on any major exchange using our standardized pipelines.

Universal Pipelines

The OpenClaw Kit features a modular pipeline architecture, allowing your agent to interface with major Decentralized (DEX) and Centralized (CEX) exchanges using a unified command structure.

Exchange	Type	Support
Hyperliquid	DEX (Perps)	Model Included
Binance	CEX (Futures)	Model Included
Bybit	CEX (Unified)	Model Included
Solana (Jupiter)	DEX (Spot)	Model Included
Uniswap	DEX (EVM)	Model Included
Polymarket	Prediction (Polygon)	Model Included

Autonomous Economics (x402)

OpenClaw Agents are equipped with an integrated Economic Core powered by the x402 Protocol. This allows agents to autonomously buy and sell resources machine-to-machine.

Self-Sufficiency: Agents can pay for premium trading signals, news feeds, or computational power using their own crypto wallet.
Auto-Negotiation: The kit automatically handles 402 Payment Required responses, paying the vendor and retrieving the data in a single flow.
Multichain: Built on viem, supporting payments on any EVM chain (Base, Polygon, Arbitrum, etc.).

Survival Mode (Evolutionary Logic)

Inspired by biological systems, the Survival Manager adjusts the agent's behavior based on its PnL health. It uses hysteresis to prevent rapid state oscillation and emits events via the internal EventBus for all modules to react.

State	Trigger	Behavior
Growth	Profit > 20%	Aggressive scanning, higher leverage allowed, x402 budget unlocked
Survival	Neutral zone	Balanced risk, normal operation
Recovery	Improving from Defensive	Cautious optimism, gradual risk increase
Defensive	Loss > 15%	Reduced risk, frozen x402 budget, slower loop
Critical	Loss > 50%	Graceful shutdown — closes all positions and preserves capital

Note: This works on both Simulations (Sidex Devs) and Real Exchanges.

Install as SDK

Use OpenClaw as a dependency in your own project:

npm install openclaw-sidex-kit

import { createAgent, createLLM, eventBus } from 'openclaw-sidex-kit/sdk';

// Full autonomous agent in 5 lines
const agent = createAgent({
    initialBalance: 1000,
    symbols: ['BTCUSDT', 'ETHUSDT'],
    llm: { provider: 'ollama', model: 'llama3.3' },
    risk: { maxLeverage: 10, maxPositions: 3 },
    onTrade: async (trade) => {
        console.log(`Executing: ${trade.side} ${trade.symbol} $${trade.amount}`);
    },
});

await agent.start();

You can also use individual modules standalone:

import { LLMClient, RiskManager, SurvivalManager } from 'openclaw-sidex-kit';

// Standalone LLM with multi-persona debate
const llm = new LLMClient({ provider: 'openai', apiKey: 'sk-...', model: 'gpt-4o' });
const decision = await llm.decideWithDebate({ marketData, balance: 1000, positions: [] });

// Standalone risk manager
const risk = new RiskManager({ maxLeverage: 15, maxPositions: 5 });
const result = risk.canOpenPosition(decision, portfolio, 'SURVIVAL');

Full SDK API Reference: See SDK.md for all factory functions, types, events, and examples.

Import Path	Description
`openclaw-sidex-kit`	Core classes (direct imports)
`openclaw-sidex-kit/sdk`	Factory functions + re-exports
`openclaw-sidex-kit/core`	Alias for core modules

Quick Start (Standalone)

Option A: One-Command Full Install (Recommended)

The full installer handles everything — system dependencies, Node.js, npm packages, Ollama (local AI), LLaMA 3.3 model download, and .env configuration — in a single interactive script.

git clone https://github.com/sidex-fun/openclaw-sidex-kit.git
cd openclaw-sidex-kit
bash quick-setup/install.sh

What it installs: curl, git, wget, Node.js (v20+), all npm dependencies, Ollama for local AI, and the LLaMA 3.3 model. It also walks you through configuring your .env with Sidex tokens, exchange keys, and wallet setup.

Option B: Manual Installation

If you prefer to install things yourself:

git clone https://github.com/sidex-fun/openclaw-sidex-kit.git
cd openclaw-sidex-kit
npm install

Then run the interactive configuration wizard:

npm run setup

This wizard will generate your .env file with the correct API keys and features enabled.

AI Model Setup

OpenClaw agents work best with a local LLM via Ollama. This avoids API costs and content-policy restrictions that external providers (GPT, Claude) impose on trading-related prompts.

# Install Ollama (Linux)
curl -fsSL https://ollama.com/install.sh | sh

# Download the recommended model
ollama pull llama3.3

# Start the server
ollama serve

⚠ External APIs (GPT, Claude, etc.): You can configure them in .env, but they have content filters and rate limits that may block trading analysis prompts. Local LLaMA 3.3 is strongly recommended for full, unrestricted functionality.

Usage

Autonomous Mode — Start the full agent loop (recommended):

npm start

The agent will connect to live market data, consult the LLM every cycle, and execute trades autonomously based on risk parameters.

Manual Pipeline Commands — Execute individual trades directly:

# Binance Pipeline
node pipelines/binance/scripts/trade.mjs --symbol="BTCUSDT" --side="buy" --amount="0.01" --api_key="..."

# Sidex Simulation
node skills/sidex_trader/scripts/trade.mjs --symbol="BTC/USDT" --side="buy" --amount="100" --leverage="10" --token="YOUR_TOKEN"

🤖 Autonomous Agent Architecture

The kit features a fully autonomous Agent Orchestrator that runs a continuous decision loop:

┌─────────────────────────────────────────────────┐
│              AgentOrchestrator                   │
│   gatherSignals → think → riskFilter → execute  │
│                    ↕ monitor                     │
├───────────┬───────────┬────────────┬─────────────┤
│  Market   │  Signal   │   Risk     │  Position   │
│  DataFeed │  Ingester │   Manager  │  Manager    │
│  (prices, │  (social, │  (sizing,  │ (tracking,  │
│   RSI,    │   news,   │   limits,  │  TP/SL,     │
│   EMA,    │   alpha)  │  survival) │  PnL)       │
│   ATR)    │           │            │             │
├───────────┴───────────┴────────────┴─────────────┤
│               EventBus (Internal Comms)          │
├───────────┬───────────┬────────────┬─────────────┤
│  Binance  │  Hyper-   │   Sidex    │ Polymarket  │
│  Pipeline │  liquid   │  Gateway   │  Pipeline   │
├───────────┴───────────┴────────────┴─────────────┤
│      LLM Client       │     x402 / Wallet        │
│  (Ollama/OpenAI/Claude)│    (On-chain Payments)   │
└────────────────────────┴─────────────────────────┘

Core Modules

Module	Description
AgentOrchestrator	Main loop — gathers signals, consults LLM, filters risk, executes trades, monitors positions
LLMClient	Unified interface for Ollama, OpenAI, and Anthropic. Returns structured JSON trading decisions
MarketDataFeed	Real-time prices via Binance WebSocket. Calculates RSI(14), EMA(20/50), ATR(14) in-memory
PositionManager	Tracks open positions, auto-triggers Stop-Loss/Take-Profit, persists state to disk
RiskManager	Position sizing, exposure limits, per-asset caps. Adapts dynamically to Survival state
SurvivalManager	Biological state machine with hysteresis. Emits events for all modules to react
EventBus	Singleton event system for decoupled module communication
X402Client	Handles `402 Payment Required` flows for machine-to-machine payments
LiquidationIntelligence	Real-time liquidation heatmap, OI, Funding Rate, L/S Ratio, squeeze detection

🔥 Liquidation Intelligence

Understand where the money is before making a trade. The LiquidationIntelligence module provides real-time data on liquidation zones, Open Interest, Funding Rates, and Long/Short ratios — helping the agent predict where market makers will move price.

Data Sources

Source	Tier	Data
Binance Futures API	Free	OI, Funding Rate, L/S Ratio, Liquidation WebSocket stream
Bybit API	Free	OI, Funding Rate
CoinGlass API	Premium	Full liquidation heatmap, aggregated cross-exchange data
CoinGlass via x402	Autonomous	Agent pays for premium data automatically via on-chain payment

Signals Generated

Signal	Meaning
`LIQUIDATION_MAGNET`	Price approaching a dense liquidation zone — market makers may push price there
`CASCADE_RISK`	High liquidation volume detected — cascade risk elevated
`SQUEEZE_POTENTIAL`	Extreme L/S imbalance — short or long squeeze likely
`IMBALANCE`	Extreme funding rate — contrarian signal (crowded trade)
`OI_DIVERGENCE`	Open Interest rising/falling significantly — trend continuation or exhaustion

Usage

import { createLiquidationIntel } from 'openclaw-sidex-kit/sdk';

// Free tier — Binance data only
const intel = createLiquidationIntel({
    symbols: ['BTCUSDT', 'ETHUSDT'],
});

// Premium — CoinGlass heatmap
const intelPremium = createLiquidationIntel({
    symbols: ['BTCUSDT'],
    coinglass: { apiKey: 'cg-...' },
});

// Autonomous — Agent pays for premium data via x402
import { X402Client } from 'openclaw-sidex-kit';
const intelAutonomous = createLiquidationIntel({
    symbols: ['BTCUSDT'],
    x402: {
        client: new X402Client(),
        autoPayPremium: true,
        maxPaymentPerDay: 1000000000000000n  // max daily spend in wei
    },
});

await intel.start();

// Get context for LLM consumption
const context = intel.getLLMContext();
// → "BTCUSDT: OI: 12.5B (+3.2% 24h) | Funding: 0.0150% (longs paying) | L/S: 1.82 ..."

// Get structured data
const btcData = intel.getContext('BTCUSDT');
// → { openInterest, fundingRate, longShortRatio, signals, heatmap, ... }

Agent Loop Cycle

Gather Signals — Reads alpha_db.json from Social Alpha Miner for recent high-confidence signals
Think (Council Debate) — The Council of AI (Technician, Sentinel, Guardian) debates the trade. A Leader synthesizes the final decision.
Risk Filter — Validates the decision against position limits, exposure caps, and survival state
Execute — Dispatches the trade to the appropriate pipeline (Sidex, Binance, Hyperliquid, etc.)
Monitor — Updates unrealized PnL, checks TP/SL levels, feeds the Survival Manager

The loop interval adapts automatically: faster in Growth (more opportunities), slower in Defensive (conserve resources).

📂 Project Structure

/core: The brain of the agent — Orchestrator, LLM, Market Data, Positions, Risk, Survival, x402.
/pipelines: Connectors for different exchanges (Hyperliquid, Binance, Bybit, Polymarket, etc.).
/skills: Advanced capabilities (Social Alpha Miner, Sidex Trader, MoltBook Analyst).
/quick-setup: Interactive configuration scripts.
/data: Persisted agent state and position data (auto-generated).
agent.js: Main entry point — run with npm start.

🧠 Social Alpha Miner

The kit includes an NLP engine that monitors social platforms for trading signals.

Impact Engine: Detects CRITICAL news from VIP accounts (Donald Trump, Saylor, etc.).
Sentiment Analysis: Converts "tweets" into actionable code instructions (URGENT_BULLISH_ACTION).
Sources: Twitter/X, Colosseum, and MoltBook.
Integration: Signals are stored in alpha_db.json and automatically consumed by the Agent Orchestrator each cycle.

🏛️ Council of AI (Multi-Persona Debate)

To ensure robust decision making, the agent uses a Multi-Persona Debate System instead of a single LLM prompt. Before every trade, a virtual council meets:

The Technician 📈: Analyzes pure market data (RSI, EMA, Price Action).
The Sentinel 📰: Analyzes social sentiment and news signals.
The Guardian 🛡️: A pessimist risk manager who vetoes reckless moves.
The Leader 👑: Synthesizes all reports and makes the final execution decision.

This "Mixture of Agents" approach reduces hallucinations and ensures balanced trading strategies.

🧬 Self-Evolution Daemon

OpenClaw includes an autonomous self-evolution pipeline — the agent can receive feature proposals from external sources, evaluate them with an LLM judge, implement the changes, validate them, and create a Pull Request — all without human intervention.

npm run evolve

How It Works

External Proposal (GitHub Issue, webhook, bot)
        ↓
   InboxCollector — collects from GitHub Issues (label: 'evolution'), local file, webhooks
        ↓
   ProposalJudge (LLM) — scores on 4 axes:
     • Relevance (is it related to this project?)
     • Value (does it add real functionality?)
     • Safety (is it free from malicious patterns?)
     • Feasibility (can it be done with the current codebase?)
        ↓
   CodePlanner (LLM) — generates implementation plan (files, logic, exports)
        ↓
   CodeWriter — applies changes with guardrails (path whitelist, backup, rollback)
        ↓
   Validator — syntax check, import validation, test suite
        ↓
   GitCommitter — creates branch + Pull Request (or direct commit)

Safety Guardrails

Path whitelist/blacklist — can only modify core/, pipelines/, sdk.js, types.d.ts
Cannot self-modify — the evolution system (core/evolution/) is forbidden
Dangerous pattern detection — blocks eval(), child_process, exec, rm -rf, etc.
Automatic rollback — if validation fails, all changes are reverted
Rate limiting — max 10 proposals per day
Safety score minimum — proposals scoring below 8/10 on safety are auto-rejected
Full audit log — every action is logged to data/evolution/logs/

Submit a Proposal

Via GitHub Issue: Create an issue with the evolution label.

Programmatically:

import { EvolutionDaemon } from 'openclaw-sidex-kit/evolution';
import { LLMClient } from 'openclaw-sidex-kit';

const daemon = new EvolutionDaemon({ llm: new LLMClient() });

daemon.submitProposal({
    title: 'Add trailing stop-loss to PositionManager',
    body: 'Implement a trailing stop that follows price by X% and locks in profits during strong trends.',
    author: 'trading-bot-v2'
});

await daemon.start();

SDK & TypeScript Support

The package ships with full TypeScript definitions (types.d.ts) for autocomplete and type safety in any IDE. No @types/ package needed.

import type { TradeDecision, SurvivalState, MarketSnapshot, RiskResult } from 'openclaw-sidex-kit';

For the complete SDK API reference with all factory functions, events, and usage examples, see SDK.md.

Documentation

For full API references and architecture guides, visit the official documentation: devs.sidex.fun/documentation

Name		Name	Last commit message	Last commit date
Latest commit History 14 Commits
core		core
data		data
pipelines		pipelines
quick-setup		quick-setup
skills		skills
.env.example		.env.example
.gitignore		.gitignore
.npmignore		.npmignore
COMMANDS.md		COMMANDS.md
README.md		README.md
SDK.md		SDK.md
agent.js		agent.js
evolution.js		evolution.js
package-lock.json		package-lock.json
package.json		package.json
sdk.js		sdk.js
types.d.ts		types.d.ts

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Repository files navigation

OpenClaw Sidex Kit

About Sidex

Developer Ecosystem (`devs.sidex.fun`)

Universal Pipelines

Autonomous Economics (x402)

Survival Mode (Evolutionary Logic)

Install as SDK

Quick Start (Standalone)

Option A: One-Command Full Install (Recommended)

Option B: Manual Installation

AI Model Setup

Usage

🤖 Autonomous Agent Architecture

Core Modules

🔥 Liquidation Intelligence

Data Sources

Signals Generated

Usage

Agent Loop Cycle

📂 Project Structure

🧠 Social Alpha Miner

🏛️ Council of AI (Multi-Persona Debate)

🧬 Self-Evolution Daemon

How It Works

Safety Guardrails

Submit a Proposal

SDK & TypeScript Support

Documentation

About

Uh oh!

Releases 1

Packages

Uh oh!

Contributors

Uh oh!

Languages

Folders and files

Latest commit

History

Repository files navigation

OpenClaw Sidex Kit

About Sidex

Developer Ecosystem (devs.sidex.fun)

Universal Pipelines

Autonomous Economics (x402)

Survival Mode (Evolutionary Logic)

Install as SDK

Quick Start (Standalone)

Option A: One-Command Full Install (Recommended)

Option B: Manual Installation

AI Model Setup

Usage

🤖 Autonomous Agent Architecture

Core Modules

🔥 Liquidation Intelligence

Data Sources

Signals Generated

Usage

Agent Loop Cycle

📂 Project Structure

🧠 Social Alpha Miner

🏛️ Council of AI (Multi-Persona Debate)

🧬 Self-Evolution Daemon

How It Works

Safety Guardrails

Submit a Proposal

SDK & TypeScript Support

Documentation

About

Topics

Resources

Uh oh!

Stars

Watchers

Forks

Releases 1

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Developer Ecosystem (`devs.sidex.fun`)

Packages