Forem: Dream

Designing and Implementing a Multi-Role AI-Powered Trading System for Polymarket

Dream — Tue, 14 Apr 2026 06:49:54 +0000

Strategy Background

Earlier this year, stories about someone making a fortune overnight on Polymarket were circulating widely across communities. Curious about the actual trading framework behind it, I went digging—only to find nothing but clickbait headlines without a single line of code. So I had no choice but to build one myself.

Honestly, I had no clue where to start. Polymarket is currently the largest decentralized prediction market platform, with over 60,000 listed markets covering politics, sports, macroeconomics, and virtually every forecastable event. Each market is essentially a binary options contract—if the outcome occurs, the price converges to 1; if not, it goes to zero. The most profitable edge? Insider information, obviously. But regular people don't know how many tweets Elon will post next week, don't know whether the Fed will cut rates next time, and certainly don't have the time or energy to monitor markets, analyze data, and make decisions around the clock.

So I thought: what if we flip the approach—instead of chasing information, chase the money. Those with an information edge will position themselves early, and their buying activity inevitably leaves traces in price and volume data. Even without knowing the "inside story," you can infer whether someone is quietly building a position by observing capital behavior. Following this logic, I built a multi-role AI-powered analysis and trading system that strings together K-line signal detection, news verification, AI-driven judgment, and automated order execution with risk controls into a single end-to-end pipeline.

System Architecture

The entire system runs on FMZ Quant's workflow engine, split into two parallel scheduling paths—a main line and a secondary line—fully decoupled and non-blocking.

The main line handles "finding opportunities and opening positions." Each cycle consists of four sequential stages: initial screening → K-line anomaly detection → news search → multi-role AI analysis, ultimately producing a buy signal that feeds into order execution. The secondary line only manages "existing positions," running continuously on a 30-second cycle regardless of whether the main line has any in-flight tasks.

This separation addresses a practical problem: prediction market prices move continuously, but stock-picking analysis is computationally intensive and high-latency. If stop-loss monitoring were crammed into the main line, stop-loss response would severely lag whenever AI analysis runs slow. Independent scheduling is a necessary engineering trade-off.

Module Deep Dive

Initial Screening: Filtering Out the Noise
With 60,000 markets, analyzing each one individually is impossible. The first gate is pure rule-based filtering with a single objective: rapidly eliminate obviously unworthy candidates and reserve downstream computational resources for truly valuable targets.

Screening criteria include: minimum liquidity (too low means trading difficulty), minimum 24-hour volume (markets with virtually no trading lack reference value), maximum bid-ask spread (excessive spread means high slippage costs), maximum competition, and a price range—only markets with implied probabilities between 5% and 50% are considered. Anything too high is already fully priced in with limited upside; anything too low is questionable in credibility, closer to lottery tickets than arbitrage opportunities.

After filtering, the same event typically has both Yes and No directions listed simultaneously. The strategy keeps only the lower-priced side, because the low-price end offers greater odds elasticity and higher potential returns.

let truePrice = parseFloat(outcomePrices[outcomeIndex] || 0)
if (truePrice < CONFIG.MIN_TRUE_PRICE || truePrice > CONFIG.MAX_TRUE_PRICE) continue

let isActive = (
    info.active === true &&
    info.approved === true &&
    info.closed === false &&
    info.archived === false &&
    info.acceptingOrders === true &&
    info.pendingDeployment === false
)
if (!isActive) continue

let spreadPct = (ask - bid) / ask
if (spreadPct > CONFIG.MAX_SPREAD_PCT) continue

// For the same event, keep only the lower-priced direction
if (!marketMap[baseSymbol]) {
    marketMap[baseSymbol] = entry
} else if (truePrice < marketMap[baseSymbol].price) {
    marketMap[baseSymbol] = entry
}

All screening thresholds are exposed as external parameters via $vars, allowing free adjustment based on your own risk appetite and capital size without modifying code.

K-Line Anomaly Detection: Finding Traces Left by Capital
After rough filtering, the system pulls 240 recent candlesticks at the 60-minute level for each passing market and runs five categories of anomaly detection. This is the strategy's core signal layer, and the fundamental difference between this system and "just throwing an event to AI for analysis"—we don't guess event outcomes; we look for capital behavior.

Slow Climb: Total gain exceeds 5% over the past 120 bars, but the maximum single-bar gain stays below 1.5%. This pattern describes capital deliberately suppressing pace to avoid drawing attention—a stealth accumulation posture.

Linear Volume Growth: Linear regression on the most recent 60 bars' volume series yields a positive slope with R² above 0.5, indicating volume is expanding steadily and consistently rather than in random bursts. R² is the key filter—it screens out those "one massive spike then silence" noise patterns.

Pullback Narrowing: Tracks the maximum depth of each pullback from historical highs. If recent average pullback depth falls below 60% of early-period pullbacks, it indicates selling pressure is declining and chips are stabilizing—someone is absorbing supply. Each pullback's lowest price is tracked throughout, using the complete pullback depth for calculation.

Consolidation Breakout: MA60 and MA120 divergence is less than 2% (consolidation state) while the current price exceeds MA60 by more than 3%, indicating a breakout above prior resistance.

**Volume Surge: **Recent 5-bar average volume exceeds the 60-bar baseline volume by more than 2.5x, indicating accelerating capital inflow.

function linearRegression(values) {
    let n = values.length
    let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0
    for (let i = 0; i < n; i++) {
        sumX += i; sumY += values[i]
        sumXY += i * values[i]; sumX2 += i * i
    }
    let slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX)
    let intercept = (sumY - slope * sumX) / n
    let meanY = sumY / n
    let ssTot = 0, ssRes = 0
    for (let i = 0; i < n; i++) {
        ssTot += Math.pow(values[i] - meanY, 2)
        ssRes += Math.pow(values[i] - (slope * i + intercept), 2)
    }
    let r2 = ssTot === 0 ? 0 : 1 - ssRes / ssTot
    return { slope, intercept, r2 }
}

function detectAnomaly(closes, volumes) {
    if (closes.length < 60) return null
    let anomalies = [], score = 0
    let slice120 = closes.slice(-Math.min(120, closes.length))

    // ── Anomaly 1: Slow Climb ──────────────────────────────────
    let totalChange = (slice120[slice120.length - 1] - slice120[0]) / slice120[0]
    let maxSingle = 0
    for (let i = 1; i < slice120.length; i++) {
        let change = Math.abs(slice120[i] - slice120[i - 1]) / slice120[i - 1]
        if (change > maxSingle) maxSingle = change
    }
    if (totalChange > 0.05 && maxSingle < 0.015) {
        score++
        anomalies.push(`Slow climb: total +${(totalChange * 100).toFixed(1)}%, max single bar ${(maxSingle * 100).toFixed(2)}%`)
    }

    // ── Anomaly 2: Linear Volume Growth ────────────────────────
    let volSlice = volumes.slice(-60)
    let volReg = linearRegression(volSlice)
    if (volReg.slope > 0 && volReg.r2 > 0.5) {
        score++
        anomalies.push(`Linear volume growth: slope ${volReg.slope.toFixed(4)}, R² ${volReg.r2.toFixed(2)}`)
    }

    // ── Anomaly 3: Pullback Narrowing (tracks lowest price per pullback) ──
    let pullbacks = [], localHigh = closes[0]
    let inPullback = false, pullbackLow = closes[0]
    for (let i = 1; i < slice120.length; i++) {
        if (closes[i] > localHigh) {
            if (inPullback) {
                pullbacks.push((localHigh - pullbackLow) / localHigh)
                inPullback = false
            }
            localHigh = closes[i]
        } else if (closes[i] < localHigh * 0.99) {
            if (!inPullback) {
                inPullback = true; pullbackLow = closes[i]
            } else if (closes[i] < pullbackLow) {
                pullbackLow = closes[i]
            }
        }
    }
    if (pullbacks.length >= 3) {
        let first = pullbacks.slice(0, Math.floor(pullbacks.length / 2))
        let last = pullbacks.slice(Math.floor(pullbacks.length / 2))
        let firstAvg = first.reduce((a, b) => a + b, 0) / first.length
        let lastAvg = last.reduce((a, b) => a + b, 0) / last.length
        if (lastAvg < firstAvg * 0.6) {
            score++
            anomalies.push(`Pullback narrowing: early ${(firstAvg * 100).toFixed(2)}%, recent ${(lastAvg * 100).toFixed(2)}%`)
        }
    }

    // ── Anomaly 4: Consolidation Breakout ──────────────────────
    let ma60 = closes.slice(-60).reduce((a, b) => a + b, 0) / 60
    let ma120 = closes.length >= 120
        ? closes.slice(-120).reduce((a, b) => a + b, 0) / 120
        : ma60
    let currentPrice = closes[closes.length - 1]
    if (Math.abs(ma60 - ma120) / ma120 < 0.02 && currentPrice > ma60 * 1.03) {
        score++
        anomalies.push(`Consolidation breakout: MA60=${ma60.toFixed(3)}, MA120=${ma120.toFixed(3)}, current=${currentPrice.toFixed(3)}`)
    }

    // ── Anomaly 5: Volume Surge ────────────────────────────────
    let recentVol = volumes.slice(-5).reduce((a, b) => a + b, 0) / 5
    let baseVol = volumes.slice(-65, -5).reduce((a, b) => a + b, 0) / 60
    if (baseVol > 0 && recentVol > baseVol * 2.5) {
        score++
        anomalies.push(`Volume surge: recent 5-bar avg is ${(recentVol / baseVol).toFixed(1)}x baseline`)
    }

    return { score, anomalies }
}

Each triggered anomaly adds one point, for a maximum of 5. Only candidates scoring 2 or above advance to the next stage. A single signal may be random noise; stacking signals lends credibility to the capital behavior hypothesis—this is the core assumption behind the entire K-line detection logic.

News Search: Finding a Fundamental Explanation for the Anomaly
K-line signals are evidence that "money is moving," but why it's moving and whether there's a basis for it requires the information side for verification. This step searches news for each K-line anomaly candidate to check for corresponding event support.

This uses the Brave Search API, which offers 2,000 free requests per month—sufficient for the main line's pace of one cycle every 10 minutes. Search keywords are extracted from the symbol, stripping direction suffixes and delimiters to reconstruct readable event description terms.

const q = item.symbol
    .replace("_USDC.No", "")
    .replace("_USDC.Yes", "")
    .replace(/-/g, "+")

const rawResponse = HttpQuery(
    "https://api.search.brave.com/res/v1/web/search?q=" + q,
    { method: "GET", headers: { "X-Subscription-Token": CONFIG.BRAVE_API_KEY } }
)

// Iterate all returned sections (web, news, etc.), extract structured fields uniformly
Object.keys(data).forEach(key => {
    const section = data[key]
    if (section && section.results && Array.isArray(section.results)) {
        section.results.forEach(r => {
            news.push({ type: key, title: r.title, description: r.description, age: r.age })
        })
    }
})

The retrieved news is packaged together with K-line data and fed into the next step's AI analysis—validating along two tracks simultaneously is far more reliable than looking at either one alone.

Multi-Role AI Analysis: Four Perspectives to Prevent Self-Persuasion
With data prepared, the pipeline enters the AI analysis node, where the model can be selected according to your needs. The prompt defines four independent roles—this is the system's single most critical design decision and deserves its own explanation.

If you let a single AI simultaneously view K-line data and news, it easily cross-validates between the two, arriving at a superficially reasonable but actually independently unverified conclusion—using capital signals to endorse the news, then using the news to endorse the capital signals, ultimately producing a self-reinforcing "I think we should buy." Role isolation forces information source independence: each role sees only its own data, outputs only its own dimensional conclusion, and the final decision role sees only conclusions—never the process.

Role 1: K-Line Capital Analyst — Sees no news; only examines price and volume anomalies to determine whether real capital is consistently buying. Outputs capital signal strength (Strong / Moderate / Baseline).

Role 2: News & Sentiment Analyst — Sees no K-line data; only evaluates the information landscape to determine whether a positive catalyst exists that hasn't been priced in. Outputs news support level (Strong / Weak / None).

Role 3: Price Assessment Analyst — Synthesizes conclusions from the first two roles, estimates the event's true probability range, compares it to the current market price, and outputs an Undervalued / Fair / Overvalued assessment. This role has a built-in expiry date weighting rule: for events more than 7 days out, normal estimation applies; for events within 3 days where market price exceeds 0.15, the probability range is forcibly narrowed and "Significantly Undervalued" output is prohibited. The reasoning is straightforward—close to expiry, market participants possess more complete real-time information than the AI's training data, so the AI's judgment should defer to market pricing.

Role 4: Final Decision Analyst — Aggregates the three preceding roles' conclusions according to a decision matrix and outputs the final action. The matrix logic: capital signal is the prerequisite, news provides verification, and together they determine confidence level; but regardless of confidence, if the price assessment doesn't reach "Undervalued," no action is taken.

The news verification here is not about chasing information—it's about determining whether capital behavior already has fundamental support. When insider capital accumulates, the information won't appear in public news. But when capital signals coincide with news support, it indicates information is in the mid-diffusion stage and the market still has a pricing lag—this is the window the strategy is truly trying to capture.

The AI's output format is strictly JSON, containing each role's conclusion, true probability range, price assessment, final decision, confidence level, and risk list—consumed directly by the downstream execution node.

Trade Execution: Only Buy the Single Best Candidate
After the AI scores each batch of candidates individually, the execution layer doesn't place orders for every buy signal—the system picks only the highest-scoring one. Ranking criteria in order: confidence (High > Medium > Low) → price assessment (Significantly Undervalued > Undervalued) → true probability range width (narrower means more certain judgment).

const buySignals = signals.filter(s => s.signal === 'buy')
bestSignal = buySignals.sort((a, b) => {
    const confDiff = (confidenceRank[b.confidence] || 0) - (confidenceRank[a.confidence] || 0)
    if (confDiff !== 0) return confDiff
    const assessDiff = (assessmentRank[b.priceAssessment] || 0) - (assessmentRank[a.priceAssessment] || 0)
    if (assessDiff !== 0) return assessDiff
    // Narrower range = more certain, prioritize narrow
    const aWidth = (a.trueProb.max || 0) - (a.trueProb.min || 0)
    const bWidth = (b.trueProb.max || 0) - (b.trueProb.min || 0)
    return aWidth - bWidth
})[0]

After selecting a candidate, the system fetches the real-time ask price from the order book, confirms sufficient balance, and submits a limit order. After submission, order status is polled with a maximum wait of 30 seconds; if it times out, the order is canceled to prevent hanging order buildup. If the current cycle's ask price multiplied by the configured share amount falls below the 1 USDC minimum order threshold, the system automatically rounds up to ceil(1/askPrice) for the minimum executable shares.

Stop-Loss Module: Trailing Stop + Absolute Floor
The secondary line executes every 30 seconds, with logic in two steps: first handle expiry redemptions, then check active positions for trailing stop-loss.

Polymarket has a special mechanism—after contract expiry, funds don't automatically return to your account; you must actively call redeem. The strategy scans for redeemable positions at the beginning of each secondary line cycle, batch-releasing funds to prevent capital from being locked up long-term.

The trailing stop-loss core is a dual-track stop price design: the trailing stop line (historical highest bid price − fixed drop amount LOSS_AMOUNT) and the absolute floor line (entry price × 50%). The effective stop price takes whichever is higher.

function calcStopPrice(entryPrice, maxPrice) {
    const trailingStopPrice = maxPrice - CONFIG.LOSS_AMOUNT
    const absoluteStopPrice = entryPrice * CONFIG.FALLBACK_STOP_RATIO  // fixed 0.50
    const usingFallback = trailingStopPrice < absoluteStopPrice
    const effectiveStopPrice = usingFallback ? absoluteStopPrice : trailingStopPrice
    return { effectiveStopPrice, trailingStopPrice, absoluteStopPrice, usingFallback }
}

This dual-track design addresses two typical position scenarios: during the profit phase, the trailing stop line rises with price, locking in floating gains; when the position moves against you immediately after entry, the trailing stop line may drop to near-zero or negative territory, at which point the absolute floor (entry price × 50%) takes over, preventing a position from riding all the way to zero before exiting. The two lines each serve their purpose—neither is dispensable.

After a stop-loss triggers, a market sell order is placed, the historical high price cache for that market is cleared, and the system waits for the next entry signal. The dashboard displays each position's remaining distance to stop-loss in real time, color-coded by alert severity, enabling manual review.

Key Design Decisions

Why Multi-Role Instead of a Single Comprehensive Prompt?
This was partially addressed in the analysis module section, but it's worth elaborating. The problem with a single prompt isn't just "self-persuasion"—there's a more subtle risk: when AI simultaneously processes K-line data and news text, it tends to use the latter to explain the former, "rationalizing" K-line anomalies as inevitable reflections of news rather than evaluating both as independent signals. Role isolation fundamentally introduces two independent information chains. Only when both chains converge on the same direction during final aggregation is the credibility genuine.

Why Only Buy the Single Best Per Cycle Instead of Diversifying?
Diversified holding has mature theoretical support in traditional finance, but the logic doesn't fully translate to prediction markets. Prediction market outcomes are binary—zero-out risk is real. If you simultaneously hold three moderate-confidence positions and two go to zero while one appreciates, you may not break even overall. The current strategy's choice: concentrate bets on accuracy rather than dilute quality-inconsistent signals with quantity. This trade-off isn't necessarily optimal, but it's internally consistent.

Why Make the Expiry Date Weighting Rule a Hard Constraint?
Close to expiry, market prices reflect participants' real-time expectations, and a significant proportion of these participants possess fresher information than the AI's training data. If the AI still outputs "price is significantly undervalued, should buy" at this point, it's very likely that its information is already stale. Making this a constraint rather than a suggestion is necessary because relying on an AI to recognize "my information isn't fresh enough" is unrealistic—external enforcement is required.

Live Trading Observations

Based on actual running logs, the strategy's funnel ratio is quite steep. In one particular run, 141 markets passed initial screening, K-line anomaly detection reduced them to 3, and ultimately only 1 met all three criteria—capital signal, news support, and price assessment—triggering an order. The other two were skipped due to "Fair" price assessment and insufficient composite scoring respectively. This demonstrates the strategy's overall conservatism: it would rather stay flat than lower standards. During calm market periods with no notable news events, the system may go an entire day without producing a single buy signal. This is a design choice, not a bug.

There have also been cases where K-line anomalies were later proven to be false breakouts—capital briefly entered then withdrew, with the trailing stop intervening to exit. News analysis likewise contains noise; coverage of relevant events may itself be lagging or biased, and AI alone cannot fully identify these issues.

The dashboard displays account equity, position status (current Bid/Ask, historical high, drawdown distance to stop-loss, stop-loss mode), and AI decision details in real time for manual review.

Closing Thoughts

Honestly, this system is more of a functional framework of ideas than a plug-and-play money printer. The core logic—capital behavior tracing, dual-track news verification, multi-role AI judgment—has reasonable foundations conceptually, but in real markets, signal quality is inconsistent, AI judgment makes mistakes, and price convergence risk near expiry is ever-present.

There's plenty of room for improvement: trading targets could be further focused on domains you're familiar with, AI prompts could be redesigned to match your trading style, the weights and thresholds for five K-line anomaly types all have tuning potential, and stop-loss coefficients deserve iteration based on actual position performance. The code is fully open-source—feel free to fork and modify.

Risk Disclaimer

Prediction market positions carry binary outcome characteristics with real zero-out risk. K-line anomaly signals and AI analysis conclusions do not constitute investment advice, and historical signal performance does not represent future returns. This strategy has not been validated over long time periods in live trading, and parameter settings significantly impact results. Before using this strategy for live trading, please fully understand Polymarket's platform rules, contract expiry mechanisms, and liquidity risks, and independently assess your tolerance for principal loss.

The Layering Rule of Vibe Trading: What to Leave to Moving Averages, What to Leave to AI

Dream — Thu, 02 Apr 2026 07:26:10 +0000

A reflection on Vibe Trading: when to use AI, and when not to.

There's a concept gaining traction lately called Vibe Trading — describe your trading intent in natural language, and let AI execute it for you. Say "conservative strategy, prioritize low-volatility assets," and AI handles the allocation automatically. Sounds great.

But before we talk about Vibe Trading, let me share something that happened recently — it illustrates "where AI belongs" better than any theory.

On March 31st, Anthropic's Claude Code accidentally exposed its source code during an npm update — roughly 512,000 lines of TypeScript (note: this is total bundled code including dependencies and generated files). The community's reverse engineering kicked off immediately, with developers worldwide digging through the code for new features.

But the most surprising finding had nothing to do with AI. And it has nothing to do with trading either — but the engineering philosophy behind it should resonate with anyone in quant trading.

In a module labeled userPromptKeywords by analysts, there was a regex pattern matching profanity like shit, wtf, and fucking broken — used to quickly determine if a user was swearing.

The world's most advanced large language model company uses regex to detect sentiment.

Not calling Claude for sentiment analysis. Not training a classifier. Just a microsecond-level string match.

Why?

1. Why Anthropic Doesn't Use Its Own AI

This isn't laziness. It's a deliberate engineering decision.

Claude Code handles hundreds of thousands of user interactions daily. Each one requires a judgment: "Is the user expressing frustration?" to adjust response strategy. If every check called an LLM:

Latency: One LLM inference takes at least hundreds of milliseconds; regex matching takes microseconds
Cost: LLM calls are billed per token; regex matching is virtually free
Determinism: Regex either matches or doesn't — 100% deterministic; LLM outputs are non-deterministic, the same input may yield different results
So Anthropic's choice: use regex for fast filtering (low overhead, high speed, fully deterministic), and save LLM compute for decisions that truly need semantic understanding.

This isn't a technical detail. It's an architectural philosophy: not every problem deserves an AI solution.

Quant traders should feel this one deeply.

2. The Same Choice in Quantitative Trading

Your strategy has two types of decisions:

Deterministic Decisions — Use "Rules"
Anyone who's written strategies on FMZ knows the core trading logic is often just a few lines of deterministic code:

// Moving Average Crossover Signal — FMZ JavaScript Example
var records = exchange.GetRecords(PERIOD_D1)
var ma5 = TA.MA(records, 5)
var ma20 = TA.MA(records, 20)
var idx = records.length - 1

// Golden cross — go long
if (ma5[idx] > ma20[idx] && ma5[idx-1] <= ma20[idx-1]) {
    exchange.SetDirection("buy")
    exchange.Buy(records[idx].Close, 1)
    Log("Golden cross, opening long")
}

Clear conditions, deterministic results, no need to "understand" semantics. Written with if-else, 100% reliable, millisecond execution.

This follows a similar logic to Anthropic using regex for sentiment detection — deterministic problems call for deterministic tools. Of course, regex is string matching and moving averages are mathematical calculations — different tools, but they play similar roles in their respective systems: deterministic judgments that don't need AI involvement.

Stop-loss with if-else is 100% reliable. Stop-loss with AI is "probably" reliable. Your account can't afford that "probably."

Fuzzy Judgment Decisions — Use AI
But some decisions can't be written as if-else:

News sentiment analysis: The Fed statement just dropped — hawkish or dovish? "The committee decided to maintain the current rate level but will closely monitor incoming data" — is this bullish or bearish? Moving averages can't tell you, and neither can regex.
Anomaly detection: An altcoin's social media mentions surged 800% in 3 hours, but the price hasn't moved. Is this "smart money accumulating" or "someone manufacturing buzz before a pump"? This requires multi-dimensional fuzzy judgment.
Strategy generation: You have an intuition — "this pattern has been followed by a rally lately." But you can't articulate the exact entry/exit conditions. You can describe this intuition to an LLM and let it translate it into backtestable quantitative factors.
These scenarios share a common trait: the input is unstructured, the criteria are fuzzy, and it requires "understanding" rather than just "matching."

3. A Layering Approach Worth Borrowing

Back to Claude Code's architecture. Community analysis revealed a clear layering:

Of course, Claude Code and quantitative trading are entirely different domains — this mapping isn't exact. But the resonance in design philosophy is real: choose the right tool at each layer, rather than hammering every nail with the same hammer.

The open-source community is practicing similar ideas. TradingAgents is a notable multi-agent quant trading framework (built on LangGraph, with an accompanying academic paper). It simulates a real trading firm's team structure: technical analysts handle candlestick and indicator calculations, sentiment analysts interpret news, and traders with different risk profiles synthesize all inputs for final decisions. Not one omniscient AI doing everything, but different roles each handling their specialty.

It's worth noting that TradingAgents is a research framework — it addresses "how AI makes trading decisions." But in live trading, you still need the other half: exchange connectivity, order management, risk execution, audit logs — engineering infrastructure work that platforms like FMZ have already built for you.

4. How to Implement Vibe Trading: A Layered Architecture Example

Back to Vibe Trading. The direction is right, but the layering must be clear.

Suppose BTC's moving averages just formed a golden cross today, but the news is all about regulatory crackdowns. What do you do? Pure MA says go long; pure news says stay out. This is exactly the scenario that calls for layering.

On FMZ, a simplified layered architecture can be implemented like this (note: simplified example — please add proper contract setup and risk controls for live trading):

/*
Strategy Parameters (add in the "Parameters" section of FMZ strategy editor):
  OPENROUTER_API_KEY : string, your OpenRouter API Key
  AI_MODEL           : string, default "google/gemini-2.5-flash", can be changed to other models
*/

// Semantic Decision Layer: call AI via OpenRouter for market sentiment
function getAISentiment() {
    var prompt = "Analyze current crypto market news, give a sentiment score (-1 to 1, -1 extreme fear, 1 extreme greed), return only a number"
    var response = HttpQuery("https://openrouter.ai/api/v1/chat/completions", {
        method: "POST",
        body: JSON.stringify({
            model: AI_MODEL,
            messages: [{role: "user", content: prompt}],
            temperature: 0
        }),
        headers: {
            "Content-Type": "application/json",
            "Authorization": "Bearer " + OPENROUTER_API_KEY
        },
        timeout: 15000
    })

    var score = parseFloat(JSON.parse(response).choices[0].message.content)
    // Fall back to neutral when AI returns unexpected output — system reliability shouldn't depend on every AI call being correct
    if (isNaN(score) || score < -1 || score > 1) {
        Log("AI returned unexpected format, using default 0")
        score = 0
    }
    Log("AI sentiment score:", score)
    return score
}

function main() {
    var lastSignalTime = 0  // Track last signal bar time to prevent duplicate triggers on the same candle

    while (true) {
        var records = exchange.GetRecords(PERIOD_D1)
        if (!records || records.length < 20) { Sleep(1000); continue }

        var ma5 = TA.MA(records, 5)
        var ma20 = TA.MA(records, 20)
        var idx = records.length - 1
        var curTime = records[idx].Time
        var isBullCross = ma5[idx] > ma20[idx] && ma5[idx-1] <= ma20[idx-1]
        var isBearCross = ma5[idx] < ma20[idx] && ma5[idx-1] >= ma20[idx-1]

        // Check position status
        var pos = exchange.GetPosition()
        var hasPosition = pos && pos.length > 0

        // Layer 1: Deterministic signal as "gate" — golden cross + no position + not yet processed on this bar, then ask AI
        if (isBullCross && !hasPosition && curTime !== lastSignalTime) {
            lastSignalTime = curTime
            var sentiment = getAISentiment()

            // Layer 2: AI sentiment as "reference" — affects sizing but doesn't independently trigger trades
            if (sentiment > 0.2) {
                exchange.SetDirection("buy")
                exchange.Buy(records[idx].Close, 1)
                Log("Golden cross + AI bullish, full position")
            } else if (sentiment > -0.3) {
                exchange.SetDirection("buy")
                exchange.Buy(records[idx].Close, 0.5)
                Log("Golden cross + AI neutral, half position")
            } else {
                Log("Golden cross but AI bearish, skipping signal")
            }
        }

        // Death cross — close position: deterministic rule, no AI involved
        if (isBearCross && hasPosition) {
            exchange.SetDirection("closebuy")
            exchange.Sell(records[idx].Close, pos[0].Amount)
            Log("Death cross, closing position")
        }

        // Layer 3: Stop-loss is "iron law" — no AI involvement
        if (hasPosition) {
            var curPrice = records[idx].Close
            var entryPrice = pos[0].Price
            if (curPrice < entryPrice * 0.97) {  // 3% below entry price
                exchange.SetDirection("closebuy")
                exchange.Sell(curPrice, pos[0].Amount)
                Log("Stop-loss triggered, unconditional close, loss:", ((curPrice/entryPrice - 1)*100).toFixed(2), "%")
            }
        }

        Sleep(60 * 1000)
    }
}

The core logic of this code is worth unpacking:

1. The golden cross is the "gate." Only when the deterministic signal fires does the strategy call AI. It won't query the LLM on every candle — saving money (LLM APIs charge per token) and filtering out noise. This mirrors Anthropic's approach: regex filters first, heavier processing only triggers on a match.

2. AI sentiment is a "reference." **It affects position sizing and whether to skip a signal, but never independently triggers a trade. Notice the error handling on AI return values — if the LLM returns unparseable content, it falls back to a neutral value of 0. **System reliability should never depend on every AI call being correct.

3. Stop-loss is "iron law." Drop 3% below entry price and the position closes unconditionally — no asking AI for its opinion. AI might say "long-term bullish," but your account can't wait for the long term. This uses a hard price-percentage stop — no fuzzy judgment involved.

This is the right way to do Vibe Trading: **use natural language to let AI help you "sense" market atmosphere, and use deterministic code to "execute" trading actions. **The boundary between the two must not be blurred.

Practical tip: In FMZ's backtesting system, first run a pure MA strategy as a baseline, then add the AI sentiment layer and compare returns and drawdowns. If AI makes things worse — your layering is wrong, and AI may be interfering where it shouldn't. Log every AI response with Log() so you can review each decision after the fact.

5. One Takeaway

The most advanced AI company uses regex to detect sentiment — not because they can't build something better.

It's because they know: choosing the right tool matters more than choosing the strongest tool.

Moving average strategies aren't sexy. Regex isn't sophisticated. But in their respective domains, they're more reliable than any AI.

Conversely, when you need to extract "is this report bullish or bearish on BTC" from a 5,000-word macro research note — moving averages can't help you, and neither can regex. That's when AI should step in.

It's not about "whether to use AI" — it's about "at which layer to use it."

That unassuming regex file in Claude Code's source answered a question we often overlook. And what FMZ gives you is a ready-made layered infrastructure — exchange connectivity, indicator calculations, live trading management, audit logs — all built for you. All you need to figure out is: which decisions go to TA.MA(), and which go to AI.

Multi-Factor Strategies Aren't Exclusive to Big Firms: A Research Framework for Independent Quants

Dream — Wed, 01 Apr 2026 02:13:55 +0000

I. Why Automated Factor Mining?

If you've been around quantitative trading, you've surely heard the word "factor." What is a factor? Simply put, it's a market signal expressed through data — price momentum, volume anomalies, Bollinger Band positioning — used to predict whether a given coin will go up or down over a certain period.

Sounds simple, but anyone who's actually done factor research knows how hard it is:

Solid financial knowledge and a deep background in mathematical statistics
Large volumes of clean historical data
A rigorous backtesting framework
And an unavoidable problem: factor decay
A signal that works today might completely fail in a few days — because market participants learn, adapt, and arbitrage the pattern away. That's why factor mining is never a one-time job; it requires continuous iteration.

What this article introduces is a system that automates this entire process: running a complete loop of factor mining → validation → elimination → signal synthesis → order execution at fixed intervals. Machine iteration replaces manual repetition, keeping the strategy in sync with the market's evolving rhythm.

II. System Architecture Overview

The traditional factor mining workflow goes: researcher proposes hypothesis → writes code → runs backtest → filters → goes live → discovers it's broken a few months later → starts over. The entire cycle can take weeks or even months.

This system compresses the entire loop into a single automated cycle executed at fixed intervals:

The system is driven by two schedulers: a slow trigger that executes the full factor iteration pipeline at hourly intervals, and a fast trigger that polls position status at second-level intervals, handling take-profit/stop-loss and dashboard refresh.

III. Module Details & Core Code

3.1 Get Symbol Pool
At the start of each round, the system pulls real-time quotes for all perpetual contracts from the exchange, sorted by trading volume to select the top N. Liquidity is a prerequisite for factor effectiveness — low-cap coins with sparse volume make any signal unreliable.

Simultaneously, it detects the BTC 4-hour candlestick volatility historical percentile to determine the overall market state (normal / high_vol / low_vol / volatile). This assessment directly influences the directional bias of AI-generated factors.

// Filter high-liquidity symbols by trading volume
const topN = $vars.topN || 150;
const tickers = exchange.GetTickers();
const filtered = tickers
    .filter(t => t.Symbol.endsWith('USDT.swap'))
    .map(t => ({ symbol: t.Symbol, quoteVolume: t.Last * t.Volume }))
    .sort((a, b) => b.quoteVolume - a.quoteVolume)
    .slice(0, topN)
    .map(t => t.symbol);
_G('afi_symbolPool', JSON.stringify(filtered));

// Detect BTC volatility percentile to determine market state
const btcR = exchange.GetRecords('BTC_USDT.swap', PERIOD_H4);
const n = btcR.length;
const returns20 = [];
for (let i = n - 20; i < n; i++)
    returns20.push(Math.abs((btcR[i].Close - btcR[i-1].Close) / btcR[i-1].Close));
const avgVol = returns20.reduce((a, b) => a + b, 0) / returns20.length;

// Compare against full-history volatility to determine percentile
const allVols = [];
for (let i = 1; i < n; i++)
    allVols.push(Math.abs((btcR[i].Close - btcR[i-1].Close) / btcR[i-1].Close));
allVols.sort((a, b) => a - b);
let btcVolPercentile = allVols.findIndex(v => v >= avgVol) / allVols.length;

let marketState = 'normal';
if (btcVolPercentile > 0.8) marketState = 'high_vol';
else if (btcVolPercentile < 0.3) marketState = 'low_vol';
_G('afi_marketState', marketState);
_G('afi_btcVolPct', btcVolPercentile.toFixed(2));

3.2 Check Factor Pool Status
Before asking AI to generate new factors, the system first takes stock of the current factor pool's health: which factors have seen their recent IC consistently declining (decaying), and which dimensions haven't been covered yet. This information is passed directly to the AI as constraints, preventing redundant exploration of already-failed directions.

const factorPool = JSON.parse(_G('afi_factorPool') || '[]');
const icHistory = JSON.parse(_G('afi_icHistory') || '{}');
const icDecayWindow = $vars.icDecayWindow || 48;       // Recent window length
const icDecayThreshold = $vars.icDecayThreshold || -0.01; // Decay threshold
const targetFactorCount = $vars.targetFactorCount || 10;

const degradedFactors = [];
for (const factor of factorPool) {
    const icArr = icHistory[factor.name] || [];
    if (icArr.length >= 20) {
        const window = Math.min(icArr.length, icDecayWindow);
        const recentAvg = icArr.slice(-window).reduce((a, b) => a + b, 0) / window;
        if (recentAvg < icDecayThreshold)
            degradedFactors.push({
                name: factor.name,
                recentIC: recentAvg.toFixed(4),
                rationale: factor.rationale
            });
    }
}

// Dynamically determine how many new factors to explore this round
const explorationBuffer = $vars.explorationBuffer || 3;
const explorationCount = Math.max(
    explorationBuffer,
    targetFactorCount - validCount + explorationBuffer
);
const action = factorPool.length === 0 ? 'generate_initial' : 'iterate_factors';

3.3 Build the Prompt: Let AI Invent Factors
What the AI receives is not an open-ended task, but a constrained framework. The prompt includes: current market state, list of currently effective factors (no duplicates allowed), recently decayed factors (no fine-tuning allowed), already-covered dimensions, and dimensions not yet explored.

This way, the candidate factors generated are genuine attempts in new directions, rather than re-running existing factors with tweaked parameters.

// Key snippet of the iteration-mode prompt
const usedDimensions = factorPool
    .map(f => f.name + '(' + (f.rationale || '') + ')')
    .join(', ') || 'None';

const validSummary = validFactors.map(f => {
    const arr = icHistory[f.name] || [];
    const avg = arr.length > 0
        ? (arr.reduce((a,b) => a+b, 0) / arr.length).toFixed(4) : 'N/A';
    const recent = arr.length >= 20
        ? (arr.slice(-20).reduce((a,b) => a+b, 0) / 20).toFixed(4) : 'N/A';
    return f.name + ': Historical IC=' + avg + ' Recent IC=' + recent
        + ' | Logic: ' + f.rationale;
}).join('\n') || 'None';

const degradedSummary = degradedFactors.length > 0
    ? degradedFactors.map(f =>
        f.name + ': Recent IC=' + f.recentIC + ' | Original logic: ' + f.rationale
    ).join('\n')
    : 'No decayed factors this round';

prompt += '【Currently Effective Factors (no variants needed)】\n' + validSummary + '\n\n';
prompt += '【Recently Decayed Factors (no fine-tuning on these dimensions)】\n' + degradedSummary + '\n\n';
prompt += '【Already Covered Dimensions (no duplicates)】\n' + usedDimensions + '\n\n';
prompt += '【Unexplored Dimensions (prioritize from here)】\n' + unusedSample + '\n\n';
prompt += 'Generate ' + explorationCount + ' entirely new-direction factors:\n';
prompt += '1. Must be completely different from covered dimensions; no fine-tuning of failed factors\n';
prompt += '2. Prioritize selection from unexplored dimensions\n';
prompt += '3. Prioritize designing nonlinear combination factors\n';
prompt += '4. Design for the current ' + marketState + ' market state\n';

The AI's System Prompt includes a complete specification of the FMZ platform's TA function library, code format constraints, crypto market prior knowledge, and a full list of explorable factor dimensions (see strategy source code for details). The output format is strictly pure JSON (no Markdown wrapping):

{
    "factors": [
        {
            "name": "MomentumAcceleration",
            "rationale": "Short-term momentum acceleration, capturing retail chase-rally inertia inflection points",
            "code": "(records[n-1].Close - records[n-6].Close)/records[n-6].Close - (records[n-2].Close - records[n-7].Close)/(records[n-7].Close + 0.0001)",
            "direction": 1,
            "type": "exploration"
        }
    ]
}

3.4 IC Validation: Let the Data Speak, Not Intuition
IC (Information Coefficient) measures how well the cross-sectional ranking derived from a factor correlates with the actual return ranking of the next candlestick. The higher the IC, the more accurate the factor's prediction.

Validation uses historical walk-forward replay: taking several hundred past candlesticks, at each time point t, using the data from time t-1 to compute the factor value and predict the return of candlestick t. Time-series alignment is strict, eliminating any look-ahead bias.

function calcRankICFull(code, symRecords, factorName) {
    const syms = Object.keys(symRecords);
    const icList = [];
    const minLen = 30;
    const allLengths = syms.map(s => symRecords[s].length);
    const minSymLen = Math.min(...allLengths);
    const testLen = Math.min(500, minSymLen - 1);

    for (let t = minLen; t < testLen; t++) {
        const fVals = [], nRets = [];
        for (const sym of syms) {
            const fullRecords = symRecords[sym];
            // Use data up to t-1 to compute factor (slice(0, t) excludes candlestick t)
            const records = fullRecords.slice(0, t);
            const n = records.length;
            const v = (function() { return eval(code); })();
            if (isNaN(v) || !isFinite(v)) continue;
            fVals.push({ sym, val: v });
            // Predict the actual return of candlestick t
            nRets.push({
                sym,
                ret: (fullRecords[t].Close - fullRecords[t-1].Close) / fullRecords[t-1].Close
            });
        }
        if (fVals.length < 8) continue;

        // Compute Rank IC (Spearman correlation coefficient)
        const fRank = {}, rRank = {};
        [...fVals].sort((a,b) => a.val - b.val).forEach((x,i) => fRank[x.sym] = i);
        [...nRets].sort((a,b) => a.ret - b.ret).forEach((x,i) => rRank[x.sym] = i);

        const ss = fVals.map(x => x.sym);
        const fr = ss.map(s => fRank[s]);
        const rr = ss.map(s => rRank[s]);
        const n2 = ss.length;
        const fm = fr.reduce((a,b) => a+b, 0) / n2;
        const rm = rr.reduce((a,b) => a+b, 0) / n2;
        const num = fr.map((f,i) => (f-fm) * (rr[i]-rm)).reduce((a,b) => a+b, 0);
        const den = Math.sqrt(
            fr.map(f => (f-fm)**2).reduce((a,b) => a+b, 0) *
            rr.map(r => (r-rm)**2).reduce((a,b) => a+b, 0)
        );
        if (den > 0) icList.push(num / den);
    }
    const avgIC = icList.length > 0
        ? icList.reduce((a,b) => a+b, 0) / icList.length : 0;
    return { avgIC, icList };
}

The IC threshold is controlled by the variable $vars.icThreshold, defaulting to 0.02. This is a relatively lenient entry-level threshold, suitable for quickly filtering out obviously ineffective factors. For stricter statistical significance control, this value can be raised according to actual needs. Factors that fail to pass the threshold are eliminated regardless of how perfect their logic may be.

3.5 Correlation Filtering & Bottom Culling
Factors that pass IC validation still need to clear two more hurdles:

First hurdle: Correlation filtering. If two factors have highly similar cross-sectional scores (|corr| > threshold), keep the one with higher IC and discard the other. When two factors are highly correlated in their cross-sectional scores, they are essentially capturing nearly identical information — keeping one is sufficient; adding another doesn't add a new perspective.

Second hurdle: Bottom culling. The factor pool has a capacity limit; excess factors are ranked by performance, and the worst ones are eliminated. Factors with recently declining IC are ranked using their recent IC rather than historical average IC, subjecting them to greater elimination pressure.

// Correlation filtering (keep highest IC, discard highly correlated redundant factors)
const corrThreshold = $vars.corrThreshold || 0.7;
survivedFactors.sort((a, b) => b.icAvg - a.icAvg); // Sort by IC descending first

const decorrelatedFactors = [];
for (const factor of survivedFactors) {
    let isRedundant = false;
    for (const selected of decorrelatedFactors) {
        const corr = Math.abs(calcCorrelation(
            factorScoresMap[factor.name],
            factorScoresMap[selected.name]
        ));
        if (corr > corrThreshold) {
            // Record absorbed correlated factor (for dashboard display)
            selected.corrGroup = (selected.corrGroup ? selected.corrGroup + ',' : '')
                + factor.name;
            isRedundant = true;
            break;
        }
    }
    if (!isRedundant) decorrelatedFactors.push({ ...factor, corrGroup: '' });
}

// Bottom culling: decaying factors ranked by recent IC instead of historical average
const targetFactorCount = $vars.targetFactorCount || 10;
decorrelatedFactors.sort((a, b) => {
    const scoreA = a.isDecaying ? a.recentIC : a.icAvg;
    const scoreB = b.isDecaying ? b.recentIC : b.icAvg;
    return scoreB - scoreA;
});
const finalPool = decorrelatedFactors.slice(0, targetFactorCount);
_G('afi_factorPool', JSON.stringify(finalPool));

Note: The correlation calculation is based on factor scores from the current cross-section, which may produce occasional misjudgments at certain points in time. A more robust approach would be to average correlations across multiple historical cross-sections — this is a direction for future improvement.

3.6 Signal Synthesis & Rebalancing Execution
Once the factor pool is stable, the system computes a composite score for each symbol: Z-score standardize each factor's cross-sectional values, then combine them with weighted summation based on each factor's recent IC — better-performing factors get larger weight, and factors with negative recent IC have their weight set to zero.

// Factor weights: recent IC weighted (negative IC factors get zero weight)
const weights = {};
let totalW = 0;
for (const f of factorPool) {
    const arr = icHistory[f.name] || [];
    const recentArr = arr.slice(-48);
    const recentIC = recentArr.length > 0
        ? recentArr.reduce((a,b) => a+b, 0) / recentArr.length : 0;
    const w = Math.max(0, recentIC); // Negative IC → weight = 0
    weights[f.name] = w;
    totalW += w;
}
if (totalW > 0) Object.keys(weights).forEach(k => weights[k] /= totalW);
else factorPool.forEach(f => weights[f.name] = 1 / factorPool.length);

// Z-score standardization
function zscore(fname) {
    const vals = validSyms
        .map(s => ({ sym: s, val: rawMatrix[s][fname] }))
        .filter(x => x.val !== null);
    if (vals.length < 5) return {};
    const mean = vals.reduce((a,b) => a + b.val, 0) / vals.length;
    const std = Math.sqrt(vals.reduce((a,b) => a + (b.val - mean)**2, 0) / vals.length);
    const r = {};
    vals.forEach(x => r[x.sym] = std > 0 ? (x.val - mean) / std : 0);
    return r;
}

// Composite scoring
const scores = {};
for (const sym of validSyms) {
    let score = 0;
    for (const f of factorPool) {
        const z = zscore(f.name)[sym];
        if (z !== undefined) score += weights[f.name] * f.direction * z;
    }
    scores[sym] = score;
}

// Threshold filtering: skip ambiguous signals, don't enter positions
const longShortN = $vars.longShortN || 5;
const longThreshold = $vars.longThreshold || 0.3;
const shortThreshold = $vars.shortThreshold || -0.3;

const sorted = Object.keys(scores).sort((a,b) => scores[b] - scores[a]);
const longList = sorted.filter(s => scores[s] >= longThreshold).slice(0, longShortN);
const shortList = sorted.slice().reverse()
    .filter(s => scores[s] <= shortThreshold).slice(0, longShortN);

During rebalancing execution, old positions not in the current round's list are closed first, then new signals are entered proportionally based on account equity:

const positionRatio = $vars.positionRatio || 0.8; // Total equity usage ratio
const maxLeverage = $vars.maxLeverage || 3;
const account = exchange.GetAccount();
const equity = account.Equity || account.Balance;
const perAmt = (equity * positionRatio) / (longList.length + shortList.length);

// Close old positions not in the target set
const targetSet = new Set([...longList, ...shortList]);
for (const sym of Object.keys(currentHoldings)) {
    if (!targetSet.has(sym)) {
        const pos = currentHoldings[sym];
        const isLong = pos.Type === PD_LONG || pos.Type === 0;
        exchange.CreateOrder(sym,
            isLong ? 'closebuy' : 'closesell', -1, Math.abs(pos.Amount));
        // Clear take-profit tracking state
        const cm = sym.match(/^(.+)_USDT/);
        if (cm) {
            _G(cm[1] + '_maxpnl', null);
            _G(cm[1] + '_trail', null);
        }
    }
}

// Enter new signal positions (using market orders, -1 indicates market price)
function openPos(sym, isLong) {
    exchange.SetMarginLevel(sym, maxLeverage);
    const market = allMarkets[sym];
    const price = exchange.GetTicker(sym).Last;
    const ctVal = (market.CtVal && market.CtVal > 0) ? market.CtVal : 1;
    const amtPrec = market.AmountPrecision !== undefined ? market.AmountPrecision : 0;
    const minQty = (market.MinQty && market.MinQty > 0) ? market.MinQty : 1;
    const maxQty = (market.MaxQty && market.MaxQty > 0) ? market.MaxQty : 999999;
    let qty = _N(perAmt / price / ctVal, amtPrec);
    qty = Math.min(Math.max(qty, minQty), maxQty);
    exchange.CreateOrder(sym, isLong ? 'buy' : 'sell', -1, qty);
}

3.7 Position Monitoring: Stop-Loss / Take-Profit / Dynamic Trailing Stop
The fast trigger runs at second-level intervals, monitoring the unrealized P&L of all positions in real time and executing three exit strategies:

Fixed stop-loss: Auto-close when unrealized loss exceeds STOP_LOSS_PCT (default 5%)
Fixed take-profit: Auto-close when unrealized profit exceeds TAKE_PROFIT_PCT (default 10%)
Dynamic trailing stop: Activated once unrealized profit reaches TRAIL_TRIGGER (3%); the drawdown threshold adjusts dynamically with the peak unrealized profit

const STOP_LOSS_PCT = $vars.stopLossPct || 5;
const TAKE_PROFIT_PCT = $vars.takeProfitPct || 10;
const TRAIL_TRIGGER = 3; // Activate trailing stop after 3% unrealized profit

// Dynamic drawdown threshold: higher peak profit allows larger drawdown
function getDynamicTrailDrawdown(maxPnl) {
    if (maxPnl >= 7) return 3;   // Peak profit ≥7%, allow 3% drawdown
    if (maxPnl >= 4) return 2;   // Peak profit ≥4%, allow 2% drawdown
    return 1.5;                   // Otherwise, 1.5% drawdown
}

function monitorTPSL(positions, tickers) {
    for (const pos of (positions || [])) {
        if (Math.abs(pos.Amount) === 0) continue;
        const cm = pos.Symbol.match(/^(.+)_USDT/);
        if (!cm) continue;
        const coin = cm[1];
        const ticker = tickers[coin + '_USDT.swap'];
        if (!ticker) continue;

        const isLong = pos.Type === PD_LONG || pos.Type === 0;
        const cur = ticker.Last;
        const ent = pos.Price;
        const amt = Math.abs(pos.Amount);
        const pnlPct = (cur - ent) * (isLong ? 1 : -1) / ent * 100;

        // Track peak unrealized profit
        let maxPnl = _G(coin + '_maxpnl');
        if (maxPnl === null) {
            maxPnl = pnlPct;
            _G(coin + '_maxpnl', maxPnl);
        } else if (pnlPct > maxPnl) {
            maxPnl = pnlPct;
            _G(coin + '_maxpnl', maxPnl);
        }

        // Activate trailing stop
        if (!_G(coin + '_trail') && maxPnl >= TRAIL_TRIGGER) {
            _G(coin + '_trail', true);
            Log(coin + ' trailing stop activated, unrealized profit: +'
                + pnlPct.toFixed(2) + '%');
        }

        const trailDrawdown = getDynamicTrailDrawdown(maxPnl);

        let reason = null;
        if (_G(coin + '_trail') && (maxPnl - pnlPct) >= trailDrawdown)
            reason = 'Trailing stop (drawdown ' + (maxPnl - pnlPct).toFixed(2)
                + '%, threshold ' + trailDrawdown + '%)';
        if (!reason && pnlPct <= -STOP_LOSS_PCT)
            reason = 'Stop-loss (' + pnlPct.toFixed(2) + '%)';
        if (!reason && pnlPct >= TAKE_PROFIT_PCT)
            reason = 'Take-profit (' + pnlPct.toFixed(2) + '%)';

        if (reason) {
            exchange.CreateOrder(pos.Symbol,
                isLong ? 'closebuy' : 'closesell', -1, amt);
            Log(coin, 'triggered', reason);
            _G(coin + '_maxpnl', null);
            _G(coin + '_trail', null);
        }
    }
}

IV. Key Design Decisions

4.1 Why Rank IC (Instead of Pearson IC)
Rank IC computes correlation using ranks rather than raw values, making it naturally robust against extreme values (outliers). The crypto market has heavily fat-tailed price distributions. Pearson IC is easily distorted by a handful of extreme candlesticks, while Rank IC offers greater stability.

4.2 Strict Time-Series Alignment: Eliminating Look-Ahead Bias
Both IC validation and live signal computation uniformly use t-1 period factor values to predict t-period returns. During validation, records are passed as fullRecords.slice(0, t), physically truncating future data so that no matter how AI-generated factor code references records[n], it can only access history up to t-1. In live mode, the last candlestick is removed (slice(0, n-1)) before computing factor values to predict the next candlestick's movement. The logic is identical in both cases, preventing inflated IC from look-ahead data leakage.

4.3 Recent IC Weighting: Weights Self-Adapt to the Market
Factor weights are not fixed but dynamically adjusted based on recent IC. When a factor starts failing (recent IC declining), its weight in signal synthesis automatically decreases toward zero. The system completes weight rebalancing without any manual intervention.

4.4 Dual-Trigger Architecture
Factor iteration is a computationally heavy task (candlestick fetching + IC backtesting + AI calls) — running it at hourly intervals is sufficient. Position protection is a time-sensitive task requiring second-level response. Splitting these into triggers with different frequencies prevents them from blocking each other.

V. Live Observations: The Factor Iteration Process

After two days of live operation, the following phenomena were observed:

Factors that entered the pool early generally had historical ICs between 0.04 and 0.07, passing the basic threshold.
As iterations progressed, nearly all factors saw their recent IC declining — some dropping from 0.06 to 0.008, others falling into negative territory. This indicates that the signals these factors captured are becoming ineffective in the current market environment.
After the system detected decay, the next round prioritized exploring uncovered dimensions, searching for new candidate factors as replacements. The entire process required no manual intervention.

Two days is too short to sufficiently validate whether the system's self-adaptive capability is genuinely effective. This section merely documents that the system executed the iteration actions as designed. More meaningful conclusions require longer-term sustained observation. However, this process itself already demonstrates that the system's fundamental design logic is functioning: it doesn't stubbornly cling to failed signals, but continuously attempts new dimensions.

VI. Closing Thoughts

Building this system wasn't about proving that AI can beat the market. Rather, it's about showing that in the age of AI, many things that only top-tier institutions could previously accomplish are now within reach for ordinary individuals to attempt.

Factor mining, strategy iteration, automated execution — these things that used to require a team, massive data infrastructure, and years of accumulation to build, can now be run as a single workflow.

This doesn't mean it will produce consistent profits. The market is always more complex than any system. But it does mean that the barrier to entry is lowering, the tools are getting stronger, and the possibility for ordinary people to participate in this endeavor is growing.

⚠️ Risk Disclaimer: All strategies carry the risk of losses. The content of this article is for technical learning purposes only and does not constitute investment advice. Please test thoroughly before going live.

Binance Perpetual Futures New Listing Automated Workflow: Let AI Watch the Market for You

Dream — Tue, 24 Mar 2026 03:07:58 +0000

The concept of "new listing trading" is familiar to anyone in the stock market — get in early, grab your allocation, and ride the price discovery when the ticker goes live. The core logic is the same in crypto, except the opportunities come far more frequently. Major centralized exchanges list new perpetual futures contracts every few days, and these opportunities are open to everyone equally.

In the early hours after a contract goes live, the market hasn't fully priced in the asset. Price elasticity is extreme, and moves far larger than typical price action can unfold in a very short time. If you can call the direction in advance and enter at the moment of launch, that's exactly where the opportunity lies in perpetual futures new listings.

But here's the problem — before a new contract goes live, we know almost nothing about the token. Team background, tokenomics, market sentiment, funding rates… all of this requires significant time to collect and analyze. Entering without sufficient understanding is no different from gambling. And trying to manually research every new listing? There's simply no way to keep up.

That's why the workflow introduced today was built to solve exactly this problem — the system automatically begins collecting data and running continuous AI analysis the moment an announcement is published, building a solid knowledge base before the token goes live. The entire workflow runs 24/7 autonomously. No manual monitoring needed. Announcement detection, data collection, AI analysis, and market entry — all fully automated.

Overall Architecture: Two Parallel Pipelines

This strategy's architecture is split into two pipelines.

The Analysis Pipeline runs in loops at longer intervals, continuously monitoring new listing announcements, collecting multi-dimensional data, calling AI for analysis, and accumulating each analysis conclusion into a historical record. The Execution Pipeline runs in rapid high-frequency loops, responsible for real-time detection of whether new tokens have gone live on the exchange. Once a listing is detected, it immediately reads the analysis results, decides whether to enter, and continuously monitors positions for take-profit and stop-loss.

The two pipelines have clear separation of duties — the Analysis Pipeline provides direction, and the Execution Pipeline handles execution.

Analysis Pipeline: Step 1 — Discover New Tokens, Build Tracking Queue

When the Analysis Pipeline starts, it first initializes global state, recording initial capital, run count, and other baseline data:

if (_G('nl_initialized') === null) {
    _G('nl_initialized', true);
    _G('nl_trackingList', JSON.stringify([]));
    _G('nl_STARTTIME', Date.now());
    const initAccount = exchange.GetAccount();
    _G('nl_initmoney', $vars.initmoney || initAccount.Balance);
}

It then fetches Binance's official announcements to identify upcoming perpetual futures listings:

const raw = HttpQuery(
    'https://www.binance.com/bapi/composite/v1/public/cms/article/list/query?type=1&pageNo=1&pageSize=10',
    { method: 'GET', headers: { 'User-Agent': 'Mozilla/5.0', 'clienttype': 'web' } }
);

Once a new token is identified, the system pushes it into the tracking queue with a status tag: before launch it's PRE_LISTING (pre-tracking), on launch day it switches to LAUNCH_DAY, after entry it moves to TRADING, and upon completion it's marked DONE and automatically cleared from the queue.

trackingList.push({
    symbol,
    launchDate,
    status: isLaunchDay ? 'LAUNCH_DAY' : 'PRE_LISTING',
    discoveredAt: now.toISOString(),
    hoursToLaunch: isLaunchDay ? 'Launching today' : hoursToLaunch,
    analysisCount: 0,
    lastAnalyzedAt: null
});

This way the system always focuses only on targets that are currently valuable, never wasting resources on expired opportunities.

Analysis Pipeline: Step 2 — Multi-Dimensional Data Collection

After discovering a new token, the system immediately begins collecting data from three dimensions.

Fundamental data is fetched via the CoinMarketCap API to obtain the token's market cap, circulation ratio, CMC ranking, and more:

function fetchCMC(coin) {
    const key = $vars.cmcApiKey || '';
    const raw = HttpQuery(
        'https://pro-api.coinmarketcap.com/v1/cryptocurrency/quotes/latest?symbol=' + coin + '&convert=USD',
        { method: 'GET', headers: { 'X-CMC_PRO_API_KEY': key, 'Accept': 'application/json' } }
    );
    const c = JSON.parse(raw).data[coin];
    const q = c.quote.USD;
    const supply = c.max_supply || c.total_supply;
    return {
        name: c.name,
        rank: c.cmc_rank,
        circulatingSupply: c.circulating_supply,
        circulationRatio: supply ? parseFloat((c.circulating_supply / supply * 100).toFixed(2)) : null,
        spotPrice: q.price,
        change1h: q.percent_change_1h,
        change24h: q.percent_change_24h,
        change7d: q.percent_change_7d,
        volume24h: q.volume_24h,
        marketCap: q.market_cap,
        fullyDilutedMarketCap: q.fully_diluted_market_cap
    };
}

Sentiment data is gathered via Brave Search, pulling recent news related to the token's funding background, team developments, and unlock schedules, using three different keyword combinations:

function fetchBraveNews(coin) {
    const key = $vars.braveKey || '';
    const queries = [
        '"' + coin + '" token funding team',
        '"' + coin + '" vesting unlock schedule',
        '"' + coin + '" binance futures listing'
    ];
    // For each query, call the Brave Search API, filter results matching the coin name, deduplicate and return
}

Market data is collected simultaneously from four exchanges — Bybit, OKX, Gate, and HTX — including funding rates, open interest, spreads, and other key indicators. Taking OKX as an example:

function fetchOKX(coin) {
    try {
        const instId = coin + '-USDT-SWAP';
        const tkRaw = HttpQuery('https://www.okx.com/api/v5/market/ticker?instId=' + instId,
            { method: 'GET', headers: { 'Accept': 'application/json' } });
        const tk = JSON.parse(tkRaw).data && JSON.parse(tkRaw).data[0];
        if (!tk) return null;
        Sleep(150);

        let fundingRate = null, nextFundingRate = null, fundingTime = null, nextFundingTime = null;
        try {
            const frRaw = HttpQuery('https://www.okx.com/api/v5/public/funding-rate?instId=' + instId,
                { method: 'GET', headers: { 'Accept': 'application/json' } });
            const fr = JSON.parse(frRaw).data && JSON.parse(frRaw).data[0];
            if (fr) {
                fundingRate = parseFloat(fr.fundingRate);
                nextFundingRate = fr.nextFundingRate !== '' ? parseFloat(fr.nextFundingRate) : null;
                fundingTime = fr.fundingTime;
                nextFundingTime = fr.nextFundingTime;
            }
        } catch(e) {}
        Sleep(150);

        let openInterest = null;
        try {
            const oiRaw = HttpQuery('https://www.okx.com/api/v5/public/open-interest?instType=SWAP&instId=' + instId,
                { method: 'GET', headers: { 'Accept': 'application/json' } });
            const oiData = JSON.parse(oiRaw).data && JSON.parse(oiRaw).data[0];
            if (oiData) openInterest = parseFloat(oiData.oiUsd);
        } catch(e) {}

        const last = parseFloat(tk.last);
        const sodUtc0 = parseFloat(tk.sodUtc0);
        return {
            price: last,
            bid1: parseFloat(tk.bidPx), bid1Size: parseFloat(tk.bidSz),
            ask1: parseFloat(tk.askPx), ask1Size: parseFloat(tk.askSz),
            spread: parseFloat((parseFloat(tk.askPx) - parseFloat(tk.bidPx)).toFixed(8)),
            change24h: parseFloat(((last - sodUtc0) / sodUtc0 * 100).toFixed(4)),
            high24h: parseFloat(tk.high24h), low24h: parseFloat(tk.low24h),
            open24h: parseFloat(tk.open24h),
            volume24h: parseFloat(tk.vol24h), volCcy24h: parseFloat(tk.volCcy24h),
            openInterest,
            fundingRate, nextFundingRate, fundingTime, nextFundingTime
        };
    } catch(e) { Log('OKX failed:', e.message); return null; }
}

Cross-exchange verification effectively avoids bias from any single data source, building a more complete picture of the new token.

Analysis Pipeline: Step 3 — AI Analysis with Historical Memory

This is the most critical design element of the entire workflow.

From announcement to actual launch, there are often several days. During this window, the system repeatedly collects data and calls AI for analysis. The key insight: every analysis passes all previous conclusions to the AI, allowing it to make new assessments building on historical judgments.

Reading history and injecting it into the prompt:

const historyKey = 'nl_history_' + symbol;
const history = JSON.parse(_G(historyKey) || '[]');
const orderNum = history.length + 1;

function buildHistorySection(history) {
    if (history.length === 0) return '(This is the first analysis for this token, no history available)';
    return history.map(h => {
        const ai = h.aiConclusion;
        return [
            '### Analysis #' + h.order,
            '- Time: ' + h.timestamp + ' | Hours to launch: ' + h.hoursToLaunch + ' | Phase: ' + h.phase,
            '- Conclusion: ' + ai.direction + ', Confidence ' + ai.confidence + '%, Risk ' + ai.riskLevel,
            '- Trend: ' + (ai.trendConsistency || 'Initial'),
            '- Entry timing: ' + (ai.entryTiming || '-'),
            '- Summary: ' + ai.summary
        ].join('\n');
    }).join('\n\n');
}

The AI analysis follows several core principles: when historical direction is consistent, confidence increases with each iteration; when a direction reversal appears, the AI must explicitly state whether it's a genuine signal or short-term noise; when historical judgments have been indecisive, confidence must remain conservative and not be inflated. The AI ultimately outputs a structured conclusion:

// AI output JSON structure
{
    "order": 3,
    "direction": "Long|Short|Hold",
    "confidence": 76,                    // 0-100 integer
    "trendConsistency": "Initial|Strengthening|Maintaining|Weakening|Reversal",
    "reversalType": "Genuine signal|Short-term noise|null",
    "entryTiming": "immediate|drawdown_N",  // drawdown_5 means wait for 5% pullback
    "priceRange": { "low": 128, "high": 130 },
    "leverage": 10,
    "stopLoss": 5,                        // stop-loss percentage
    "takeProfit": 15,                     // take-profit percentage
    "riskLevel": "High|Medium|Low",
    "riskPoints": ["Risk point 1", "Risk point 2"],
    "keyChanges": "Most significant data changes compared to last analysis",
    "summary": "Comprehensive judgment in 100 words or less"
}

After analysis is complete, the conclusion is stored in the history, and the token's final strategy is updated for the Execution Pipeline to read:

const record = {
    order: item.orderNum,
    timestamp: new Date().toISOString(),
    phase: item.status,
    hoursToLaunch: item.hoursToLaunch,
    currentData: item.currentData,
    aiConclusion: aiResult
};
history.push(record);
_G('nl_history_' + symbol, JSON.stringify(history));

_G('nl_strategy_' + symbol, JSON.stringify({
    symbol,
    updatedAt: new Date().toISOString(),
    phase: item.status,
    historyCount: history.length,
    aiResult
}));

When direction remains consistent, confidence increases with each analysis iteration; when direction reverses, the AI must provide clear reasoning. Judgments accumulated this way are far more reliable than any single independent analysis.

Execution Pipeline: Step 4 — Listing Detection and Safe Entry

The Execution Pipeline runs high-frequency loops, using exchange.GetMarkets() to detect whether a new token has appeared in the exchange's contract list. Once a listing is detected, it first runs through a safety check:

if (ai.direction === 'Hold')       { updateStatus(symbol, 'DONE'); continue; }
if (ai.riskLevel === 'High')       { updateStatus(symbol, 'DONE'); continue; }
if (ai.confidence < CONFIG.MIN_CONFIDENCE) { updateStatus(symbol, 'DONE'); continue; }
if (hasPosition(coin))             { updateStatus(symbol, 'TRADING'); continue; }

After passing all checks, it executes based on the AI's recommended entry timing. For immediate entry, it calculates contract quantity and places the order:

const leverage = Math.min(ai.leverage || 5, CONFIG.MAX_LEVERAGE);
exchange.SetMarginLevel(leverage);

const allocAmount = Math.min(CONFIG.POSITION_AMOUNT, account.Balance * 0.3);
const qty = calcContractAmount(allocAmount, price, market);

if (ai.direction === 'Long') {
    exchange.SetDirection('buy');
    orderId = exchange.Buy(-1, qty);
} else if (ai.direction === 'Short') {
    exchange.SetDirection('sell');
    orderId = exchange.Sell(-1, qty);
}

If the AI determines the opening premium is too high and recommends waiting for a pullback, the system records the target price and continuously polls:

const targetPrice = ai.direction === 'Long'
    ? openPrice * (1 - pct / 100)
    : openPrice * (1 + pct / 100);

_G(coin + '_nl_waitEntry', JSON.stringify({
    type: 'drawdown',
    waitStartTime: Date.now(),
    openPrice, targetPrice, drawdownPct: pct, ai
}));
updateStatus(symbol, 'TRADING_WAIT');

If the target isn't triggered within 2 hours, the opportunity is considered expired and entry is automatically abandoned.

Execution Pipeline: Step 5 — Position Monitoring and Take-Profit / Stop-Loss

After entry, the Execution Pipeline continuously monitors position status. Take-profit and stop-loss use two mechanisms running in parallel:

const TP_SL = {
    DEFAULT_SL: 10,            // Default stop-loss 10%
    DEFAULT_TP: 25,            // Default fixed take-profit 25%
    TRAILING_TRIGGER: 30,      // Enable trailing TP when unrealized profit reaches 30%
    TRAILING_DRAWDOWN: 8       // Trailing TP triggers on 8% drawdown from peak
};

// Update peak unrealized profit
if (pnlPct / 100 > maxProfit) {
    maxProfit = pnlPct / 100;
    _G(maxProfitKey, maxProfit);
}

// Automatically enable trailing TP when threshold is reached
if (tpDrawdown === 0 && maxPnlPct >= TP_SL.TRAILING_TRIGGER) {
    tpDrawdown = TP_SL.TRAILING_DRAWDOWN;
    _G(tpDrawKey, tpDrawdown);
}

// Check three exit conditions in order — whichever triggers first executes
let closeReason = null;
if (tpDrawdown > 0 && drawdown >= tpDrawdown) closeReason = 'Trailing TP';
if (!closeReason && pnlPct <= -maxSL)          closeReason = 'Stop-loss';
if (!closeReason && pnlPct >= entry.takeProfit) closeReason = 'Fixed TP';

if (closeReason) {
    if (isLong) { exchange.SetDirection('closebuy'); exchange.Sell(-1, amount); }
    else        { exchange.SetDirection('closesell'); exchange.Buy(-1, amount); }
    _G(maxProfitKey, null); _G(slKey, null); _G(tpDrawKey, null);
}

Trailing take-profit lets winners run as far as possible, while fixed take-profit and stop-loss guard the floor. All three are active simultaneously — whichever triggers first gets executed.

Live Operation Dashboard

After the strategy starts running, the dashboard displays four real-time status tables: Account Overview shows runtime, current equity, and total return; Tracking Queue shows each monitored token's status, launch countdown, and analysis count; AI Analysis Summary displays each token's latest full analysis conclusion; Live Position Monitor shows unrealized P&L, peak profit, trailing TP status, and supports manual position closing and stop-loss parameter adjustments.

Taking the recently launched EWYUSDT as an example, the system discovered it from the announcement and has completed multiple consecutive analyses. Every time, the AI's direction has been Long, with the trend marked as "Strengthening" — this is precisely the historical memory mechanism at work. Multiple analyses pointing in the same direction indicate that the bullish signal is stable, rather than a misjudgment caused by a single data fluctuation. The latest comprehensive assessment: OKX and HTX funding rates are stable and positive, news related to the Korean ETF perpetual listing is generally positive, and the AI recommends going Long with 76% confidence. Suggested entry at the 128–130 price range at market open, 10x leverage, 5% stop-loss, 15% take-profit, medium risk.

Strategy Boundaries and Risk Disclaimer

The core problem this strategy solves is: before a new token goes live, systematically replacing manual research to build understanding of the token, and converting analytical conclusions into actionable entry signals. However, it's important to clearly recognize its limitations:

New tokens are inherently extremely volatile — stop-losses may be triggered within the first minute of launch; AI judgment quality depends on data completeness, and with less data available pre-launch, assessments will be more conservative; leverage amplifies both gains and losses, and no strategy can guarantee consistent profitability.

Proper position sizing is the most important prerequisite for using this strategy.

This system is currently more of a starting point. New listing trading is a direction with significant depth — the signal dimensions, entry timing judgments, and position management details all have substantial room for optimization. If you have your own experience and insights in this area, feel free to share in the comments. Collective wisdom will take us further. Every strategy carries the risk of loss — always refine the strategy logic based on your own circumstances before use.

Quantitative Trading with Liquidation Data: An AI-Automated Strategy Based on Liquidation Signals

Dream — Wed, 18 Mar 2026 08:24:30 +0000

Preface
If you've traded perpetual contracts, you've probably been liquidated at some point. At best you lose part of your position; at worst your entire principal is gone. But have you ever thought about this — the moment you get liquidated, that data point is actually recorded?

Exchanges push every forced liquidation event in real time: which token, which direction, how much notional value, and exactly when. This is liquidation data.

2026-03-10 13:10:19 Liquidation: {"s":"DEXEUSDT","S":"BUY","o":"LIMIT","f":"IOC","q":"30.99","p":"5.427000","ap":"5.347646","X":"FILLED","l":"17.21","z":"30.99","T":1773119419184}
2026-03-10 13:10:18 Liquidation: {"s":"BEATUSDT","S":"SELL","o":"LIMIT","f":"IOC","q":"21","p":"0.3503000","ap":"0.3573000","X":"FILLED","l":"4","z":"21","T":1773119418458}
2026-03-10 13:10:18 Liquidation: {"s":"COAIUSDT","S":"SELL","o":"LIMIT","f":"IOC","q":"35","p":"0.2968000","ap":"0.3115000","X":"FILLED","l":"35","z":"35","T":1773119418118}
2026-03-10 13:10:18 Liquidation: {"s":"AIAUSDT","S":"BUY","o":"LIMIT","f":"IOC","q":"537","p":"0.0844900","ap":"0.0823800","X":"FILLED","l":"10","z":"537","T":1773119418118}
2026-03-10 13:10:09 Liquidation: {"s":"BABYUSDT","S":"SELL","o":"LIMIT","f":"IOC","q":"1965","p":"0.0161200","ap":"0.0162300","X":"FILLED","l":"1376","z":"1965","T":1773119409616}
2026-03-10 13:10:08 Liquidation: {"s":"MBOXUSDT","S":"SELL","o":"LIMIT","f":"IOC","q":"372","p":"0.0173800","ap":"0.0178100","X":"FILLED","l":"372","z":"372","T":1773119408667}
2026-03-10 13:10:07 Liquidation: {"s":"GALAUSDT","S":"SELL","o":"LIMIT","f":"IOC","q":"23717","p":"0.00337","ap":"0.00341","X":"FILLED","l":"23717","z":"23717","T":1773119407235}
2026-03-10 13:10:04 Liquidation: {"s":"RIVERUSDT","S":"SELL","o":"LIMIT","f":"IOC","q":"17.7","p":"10.945000","ap":"11.109943","X":"FILLED","l":"3.3","z":"17.7","T":1773119404767}
2026-03-10 13:10:04 Liquidation: {"s":"ROBOUSDT","S":"SELL","o":"LIMIT","f":"IOC","q":"3000","p":"0.0445100","ap":"0.0451800","X":"FILLED","l":"3000","z":"3000","T":1773119404308}
2026-03-10 13:09:47 Liquidation: {"s":"RIVERUSDT","S":"BUY","o":"LIMIT","f":"IOC","q":"48.1","p":"11.287000","ap":"11.122577","X":"FILLED","l":"17.7","z":"48.1","T":1773119387280}
2026-03-10 13:09:45 Liquidation: {"s":"DENTUSDT","S":"SELL","o":"LIMIT","f":"IOC","q":"827079","p":"0.000253","ap":"0.000257","X":"FILLED","l":"827079","z":"827079","T":1773119385320}
2026-03-10 13:09:44 Liquidation: {"s":"BULLAUSDT","S":"SELL","o":"LIMIT","f":"IOC","q":"526","p":"0.0203300","ap":"0.0213800","X":"FILLED","l":"526","z":"526","T":1773119384220}
2026-03-10 13:09:40 Liquidation: {"s":"DENTUSDT","S":"SELL","o":"LIMIT","f":"IOC","q":"554440","p":"0.000253","ap":"0.000257","X":"FILLED","l":"289977","z":"554440","T":1773119380709}

A single liquidation event doesn't mean much on its own. But when you aggregate everyone's liquidations together, something very interesting emerges — you can see where capital is under pressure in the market, and which side is already cracking. Liquidation data is widely regarded as one of the most important components of order flow analysis. It represents blood-stained chips — the rawest reaction of capital that can't be faked.

What this article sets out to do is simple: use liquidation data as the core signal, layer on candlestick verification and news judgment, let AI make the comprehensive decision, and run the whole thing through an automated workflow — 24/7, no manual chart-watching required.

1. Strategy Logic

1.1 What Liquidation Data Can Tell Us
Positions are being liquidated every moment. Normal liquidations aren't signals. What we're looking for are statistical anomalies — a token experiencing liquidation volume far above its historical baseline in a short period, indicating that weak positions on one side are being systematically wiped out.

After a liquidation cascade, the trend tends to continue. This is the core assumption of this strategy.

1.2 Why Trend-Following, Not Mean-Reversion
When facing a wave of liquidations, there are generally two approaches:

Mean-reversion: Assume the worst is over, step in to catch the bounce
Trend-following: Assume weak positions haven't finished clearing out, ride the direction

The risk of mean-reversion is that you don't know if the liquidation cascade is over. If longs are still being wiped out in droves and you step in to buy, it's like sticking your hand under a waterfall — what you catch isn't the bottom, it's more downside.

So this strategy chooses trend-following — when longs get liquidated, go short; when shorts get liquidated, go long.

1.3 Limitations of a Single Signal
Relying on liquidation data alone for decisions is too crude and easily thrown off by noise. So on top of the liquidation data, we add two more layers:

Candlestick verification: Is price action confirming the liquidation direction?
News judgment: Is there a substantive event driving this?

AI then synthesizes all three dimensions to make the final decision.

2. Overall Architecture

The workflow uses a linear structure, triggered at fixed intervals. The complete flow is as follows:

After the trigger fires, first check whether initialization has been completed
If it's the first run, enter the initialization collection node to establish historical baseline data
Once initialization is complete, each trigger executes in sequence: collect new data → scan for anomalous signals → determine whether entry conditions are met
If an anomaly is found, continue downstream into data enrichment, AI judgment, and trade execution nodes
If no anomaly is found, terminate immediately and wait for the next trigger interval

The entire flow halts when conditions aren't met and continues when they are — no manual intervention needed.

3. Key Node Breakdown

3.1 Initialization Collection
On first startup, the system needs to establish historical baseline data. It connects to Binance Futures' forced liquidation push channel via WebSocket, continuously collecting liquidation data for a period and storing it in global variables.

Each data point contains four fields: timestamp, token, liquidation direction, and liquidation amount. During collection, two types of data are filtered out: partially filled forced liquidation orders, and small-amount noise data. Once collection is complete, the data is written to persistent storage and initialization is marked as done. On subsequent triggers, this node is skipped entirely.

// Excerpt from source code
var ws = Dial('wss://fstream.binance.com/ws/!forceOrder@arr')

while (Date.now() < endTs) {
    var msg = ws.read(1000)
    try {
        var obj = JSON.parse(msg)
        var orders = Array.isArray(obj) ? obj : [obj]
        for (var i = 0; i < orders.length; i++) {
            var item = orders[i]
            if (!item || !item.o) continue
            var o = item.o
            if (o.X !== 'FILLED') continue
            if (EXCLUDE[o.s]) continue
            if (!/USDT$/i.test(o.s)) continue       // ✅ Only process USDT contracts
            var price = parseFloat(o.ap || o.p)
            var qty = parseFloat(o.z)
            var value = price * qty
            if (value < MIN_VALUE) continue
            liquidationData.push({
                t: item.E || Date.now(),
                s: o.s,
                d: o.S,
                v: value
            })
            totalNew++
        }
    } catch(e) {}
}

_G('liquidationData', liquidationData)               // Persistent storage
_G('liqInitialized', true)                           // Mark initialization complete

3.2 Strategy Execution: Collection + Z-Score Scanning
On each trigger, new liquidation data is first collected via WebSocket and appended to the historical window, then Z-Score anomaly detection is run per token.

The core idea behind Z-Score:

Divide the baseline period's liquidation data into equal-length time segments, recording the total liquidation amount for each monitoring segment. Then take the latest monitoring segment's liquidation volume and compare it against the mean of all historical segments in the baseline period, calculating the degree of deviation. Only when the deviation exceeds the threshold is it considered anomalous.

// Excerpt from source code
var mean = hist.reduce(function(s, v) { return s + v }, 0) / hist.length
var std = Math.sqrt(
    hist.reduce(function(s, v) { return s + Math.pow(v - mean, 2) }, 0) / hist.length
)
var z = std > 0 ? (rec - mean) / std : 0
if (z < ZSCORE_THRESH || rec <= 0) continue

The benefit of this approach is self-adaptation: active tokens have active baselines, illiquid tokens have their own baselines — you won't get false positives just because a token naturally has high trading volume.

Volume alone isn't enough — you also need to check whether the direction is one-sided:

// Excerpt from source code
var longRatio = total > 0 ? st.longV / total : 0.5
var direction = null
if (longRatio > DIR_THRESH) direction = 'SHORT'       // Longs getting wiped → trend-follow short
else if (longRatio < 1 - DIR_THRESH) direction = 'LONG' // Shorts getting wiped → trend-follow long
if (!direction) continue                                // Mixed liquidations → direction unclear, skip

Both conditions must be met simultaneously for a signal to trigger: Z-Score above threshold, AND one-sided liquidation (long or short) exceeding 75%. When both sides are getting wiped equally, direction is unclear — skip entirely.

3.3 Data Enrichment: Candlesticks + News
After a signal triggers, the system doesn't open a position immediately. Instead, it enters a data enrichment node to prepare more complete context for the subsequent AI judgment.

Candlestick component:

Fetch the token's most recent 1-minute candlesticks, calculate price change and volatility, determine the current candlestick trend direction, and compare it with the liquidation signal direction to check for alignment. If the signal suggests shorting but the candlesticks are still trending up, credibility takes a hit.

News component:

Via the Brave Search API, fetch the token's latest news for the day. Liquidations driven by concrete events have a much higher probability of trend continuation; if there's no news and it's purely technical clearing, the AI will be more conservative.

Once both types of data are collected, they're sent to the AI together.

3.4 AI Comprehensive Judgment
The AI receives liquidation data, candlesticks, and news, then evaluates based on a fixed decision framework — all three dimensions are indispensable:

Decision matrix:

The AI outputs a structured result containing direction, decision, confidence level, and reasoning. Only entry signals that reach the confidence threshold will actually trigger position opening downstream.

The core of the prompt is as follows:

## Judgment Steps

Step 1: Liquidation Intensity
- Z-Score exceeds high threshold AND direction purity is very high → Strong signal
- Z-Score meets base threshold AND direction purity meets requirements → Medium signal
- Otherwise → Don't enter

Step 2: Candlestick Trend
- Aligned with liquidation direction → High probability of trend continuation, positive factor
- Opposite to liquidation direction → Possibly just a temporary clearing rather than a trend, negative factor

Step 3: News Verification
- Substantive bearish/bullish news aligned with direction → Positive factor
- No news → Pure technical liquidation, reduce confidence
- News contradicts direction → Don't enter

## Output Format
Return strict JSON, no markdown wrapping:
{
    "symbol": "token",
    "direction": "LONG or SHORT",
    "action": "enter/hold/don't enter",
    "confidence": "high/medium/low",
    "liq_note": "One-sentence assessment of liquidation signal",
    "trend_note": "One-sentence assessment of candlestick trend",
    "news_note": "One-sentence assessment of news",
    "action_reason": "One-sentence comprehensive reasoning"
}

3.5 Trade Execution and Stop-Loss Management
After the AI decides to enter, the trade execution node automatically opens the position while also managing stop-losses and updating the visualization dashboard.

Position opening flow:

Before opening, signals are sorted by confidence — high-confidence signals execute first. If the token already has an open position and the new signal has higher confidence, the old position is closed first and then a new one is opened; if the new signal's confidence doesn't exceed the existing position's, it's skipped. When the number of open positions reaches the cap, all subsequent signals are skipped.

Position size, leverage multiplier, and maximum number of positions are all configured via external variables. Contract quantity is dynamically calculated based on the real-time price from current market depth.

// Excerpt from source code
// Calculate position size
var rawQty = OPEN_MONEY * CONFIG.LEVERAGE / refPrice / mkt.ctVal
var qty = floorToStep(rawQty, mkt.amtSize, mkt.amtPrec)

// Market order entry
var side = direction === 'LONG' ? 'buy' : 'sell'
var oid = exchange.CreateOrder(swapSym, side, -1, qty)

Stop-loss mechanism:

Stop-loss uses a dual-layer mechanism with both defenses active simultaneously:

Trailing stop: Tracks the price extreme; if the pullback from peak unrealized profit exceeds a set percentage, close the position. Let profits run, but don't give back everything already earned.
Fallback stop: The last line of defense; if price moves against the entry by more than a set percentage, force close.

// Excerpt from source code
if (pos.direction === 'LONG') {
    var trailStop = pos.peak * (1 - TRAILING_PCT)           // Trailing stop price
    var fallStop = pos.entryPrice * (1 - FALLBACK_PCT)      // Fallback stop price
    effectiveStop = Math.min(trailStop, fallStop)
    if (cur <= effectiveStop) triggered = true
}

Visualization dashboard:

After each execution, three tables are updated in real time:

Account overview: Balance, number of positions, cumulative P&L, stop-loss parameters
Position monitor: Entry price, current price, P&L percentage, max profit, current drawdown, and stop-loss price for each position
Latest AI signals: Liquidation signal, candlestick assessment, news assessment, and comprehensive decision for each scanned token

You can see what the strategy is doing at any time — no need to watch the charts.

4. Complete Flow Recap

Here's the complete logic of this strategy:

Initialization: On first run, collect historical liquidation data to establish baselines
Collection: On each trigger, collect new liquidation data and update the historical window
Scanning: Use Z-Score to find tokens with statistically anomalous liquidation volumes; filter out signals with impure directionality
Enrichment: Fetch candlestick and news data for anomalous tokens
Judgment: AI synthesizes all three dimensions to make entry decisions
Execution: Auto-open positions sorted by confidence, with dual-layer stop-loss and visualization dashboard throughout

This is an exploration of AI-enhanced trading built on traditional liquidation data. Liquidation data itself is the market's rawest reaction; layering on candlesticks and news effectively improves signal credibility; and the introduction of AI makes multi-dimensional decision-making automatable.

If you're interested in strategies based on on-chain or market microstructure data like this, feel free to leave feedback — further strategy development on more signal types can follow.

Don't Panic When Coins Pump! Workflow-Powered Shorting to Catch the Pullback

Dream — Fri, 13 Mar 2026 01:41:23 +0000

This strategy was open-sourced by user @Gianbin, adapted from our earlier dual-route workflow trading framework. Thanks for the generous contribution — here's a full breakdown of the strategy logic.

1. Core Concept: Contrarian Shorting of Pump Coins

In crypto, "pump coins" appear frequently — tokens that surge 30–40% or even 100%+ in a single day. They look tempting, but the harder they pump, the harder they tend to dump.

This strategy exploits exactly that:

Screen the top gainers from Binance's 24-hour leaderboard
Use an AI multi-factor model to identify which ones have "topped out"
Open short positions and wait for the pullback, profiting from overleveraged chasers

Capital management principle: Fixed 50 USDT per entry, total position capped at 500 USDT — relatively controlled risk.

2. Workflow Architecture Overview

The strategy consists of two independent workflows, each with its own role:

Main Trading Flow (every 15 min): Screen top gainers → Collect data → AI analysis → Execute entry
Risk Control Flow (every 5 sec): Real-time monitoring → TP/SL detection → Inverse pyramid scaling → Visual dashboard

Strategy decisions can run at a relaxed pace, but risk control must react fast. That's why the trigger frequencies differ so dramatically.

3. Main Trading Flow — Step by Step

Step 1: Screen Pump Coins from the Gainers List
A timer trigger fires every 15 minutes, pulling all USDT perpetual contract tickers from Binance. It filters for tokens with 24-hour gains exceeding 10% and takes the top 20. Tokens already in open positions are automatically excluded to prevent duplicate entries.

// Core screening logic (excerpt)
const minChange = $vars.minChange || 0.1; // Default gain threshold: 10%
const topN = $vars.topN;                  // Top N, default 20

// Filter USDT perpetuals, calculate 24h change
const change24h = open24h > 0 ? (price - open24h) / open24h : 0;
if (change24h < minChange) continue;      // Below threshold, skip

// Exclude tokens already in positions
if (excludeHolding && holdingSymbols.indexOf(symbol) !== -1) continue;

// Sort by gain descending, take top N
usdtPairs.sort((a, b) => b.change24h - a.change24h);
const topGainers = usdtPairs.slice(0, topN);

This step is essentially an "audition" — rounding up the hottest pump coins for further analysis.

Step 2: Multi-Dimensional Data Collection
Price gains alone aren't enough. The system simultaneously collects the following data to feed the AI analysis:

The OI/MCap ratio is the core metric — the higher this ratio, the more leveraged the market is, the greater the liquidation risk, and the better the odds for shorting.

// Fetching open interest via Binance API (excerpt)
const ret = exchange.IO("api", "GET", "/fapi/v1/openInterest", "symbol=" + symbol);
if (ret && ret.openInterest) {
    openInterest = parseFloat(ret.openInterest) * coin.price; // Convert to USD
}

// Calculate OI/MCap ratio
const oiMcapRatio = marketCap > 0 ? openInterest / marketCap : 0;

Market cap data is fetched from the CoinMarketCap API with a 30-minute local cache to avoid excessive external API calls.

Step 3: AI Six-Factor Scoring System
This is the heart of the strategy. After collecting data, everything is packaged and sent to an AI model (x-ai/grok-4.1-fast in this case) for scoring on a scale of 10. Only targets scoring 8.0 or above make it to the candidate entry list.

Six Factors and Weights

OI/MCap ratio carries the highest weight (3.5) because it directly reflects market leverage — higher leverage means a reversal is more likely to trigger cascading liquidations, giving shorts better risk-reward.

K-line Pattern Scoring Rules

Long upper shadow breaking new high (2.8 pts): High makes a new high, upper shadow > body × 2
*Long upper shadow at highs *(2.4 pts): Upper shadow > body × 2, close near 24h high
Bearish candle on high volume (2.0 pts): Closes red, volume > previous day × 1.5
Doji at highs (1.8 pts): Body < range × 0.1, price near the high
Two consecutive bearish candles (1.5 pts)

Hard Filters (Applied Before Scoring)
Before AI scoring, the strategy applies several hard filters — failing any one means the token is skipped entirely:

Already in position → skip (prevent overconcentration)
Funding rate < -0.20% → skip (shorts already overcrowded)
Open interest < $30M → skip (insufficient liquidity)
Weekly drawdown > 5% → skip (too far from high, may have already pulled back)
Intraday drawdown > 5% → skip (already dropped from today's high, no longer at peak)

// Weekly high calculation (excerpt)
const weeklyHigh = Math.max(...klines.slice(-7).map(k => k.high));
const weeklyDrawdown = (weeklyHigh - price) / weeklyHigh;
if (weeklyDrawdown > 0.05) { // More than 5% from weekly high, skip
    filtered.weeklyDrawdown++;
    continue;
}

Final Decision Logic
When total score ≥ 8.0 and intraday drawdown ≤ 5%, the decision logic kicks in: if funding rate ≥ -0.15%, output "open short"; if funding rate is between -0.20% and -0.15%, output "cautious short." Targets scoring below 8.0 are not outputted and no positions are opened.

Step 4: Trade Execution
The AI outputs decisions in JSON format, and the trade execution node parses and places orders:

// Execute short (excerpt)
function executeShort(coin, signalInfo) {
    exchange.SetCurrency(coin + '_USDT');
    exchange.SetContractType("swap");
    exchange.SetMarginLevel(CONFIG.DEFAULT_LEVERAGE); // Set required leverage

    // Calculate contract size from fixed amount
    const contractAmount = calculateContractAmount(
        CONFIG.FIXED_AMOUNT_USD, // Fixed 50U
        currentPrice,
        market
    );

    exchange.SetDirection("sell");
    const orderId = exchange.Sell(-1, contractAmount); // Market short

    if (orderId) {
        _G(`${coin}_USDT.swap_maxprofit`, 0); // Initialize max profit tracker
        Log(`✅ ${coin}: Short opened, score ${signalInfo.score}`);
    }
}

Each entry uses a fixed 50 USDT — single-trade risk is well-contained.

4. Risk Control Flow — Detailed Breakdown

Triggers every 5 seconds, continuously monitoring all open positions with two core functions: inverse pyramid scaling and take-profit / stop-loss.

Inverse Pyramid Scaling
This is the most interesting design in the strategy. After opening a short, if the price rises instead of falling, most traders would stop out. But this strategy chooses to scale in against the trend — the higher it goes, the more it adds — because the higher the pump, the harder the eventual crash tends to be.

Scaling rules:

Initial entry: 50U (entry price = P0)
If price rises 50% from P0 → first add: 150U, record price as P1
If price rises 70% from P1 → second add: 300U
Maximum 2 additions, total position cap: 500U (50 + 150 + 300)

// Pyramid add detection (excerpt)
function checkAndExecutePyramidAdd(coin, entryPrice, currentPrice, isShort) {
    const addCount = _G(addCountKey) || 0;
    if (addCount >= 2) return null; // Max 2 additions

    if (addCount === 0) {
        // First add: triggered at 50% above entry
        triggerPrice = storedEntryPrice * (1 + PYRAMID_CONFIG.ADD1_TRIGGER);
        addAmount = PYRAMID_CONFIG.ADD1_AMOUNT; // 150U
    } else if (addCount === 1) {
        // Second add: triggered at 70% above first add price
        triggerPrice = add1Price * (1 + PYRAMID_CONFIG.ADD2_TRIGGER);
        addAmount = PYRAMID_CONFIG.ADD2_AMOUNT; // 300U
    }

    if (currentPrice >= triggerPrice) {
        return {
            level: addCount + 1,
            amount: addAmount,
            triggerPrice,
            currentPrice
        };
    }
    return null;
}

The logic behind this design: The more a pump coin surges, the more frenzied the speculation, and the bigger the bubble. When the reversal finally hits, high leverage triggers cascading liquidations that amplify the crash. Holding a larger position at higher prices means profits multiply when the reversal comes.

**The risk is equally obvious: **If the token genuinely keeps rising without looking back (e.g., a real bull market or major fundamental catalyst), losses scale up too. Therefore, the account should hold sufficient funds to withstand volatility and avoid forced liquidation. The strategy explicitly caps total position at 500U to prevent unlimited scaling.

Take-Profit / Stop-Loss Mechanism
Take-profit uses a trailing drawdown model rather than a fixed target:

When max unrealized profit reaches 35%, drawdown monitoring activates automatically
Once profit pulls back 5% from its peak, the position is closed immediately This design "lets profits run" — it won't exit too early and miss bigger gains, but also won't ride the elevator back down and give it all back.

// Auto take-profit trigger logic (excerpt)
if (enableAutoTpDrawdown && isShort && tpDrawdown === 0 
    && maxPnlPercent >= autoTpTrigger) {
    tpDrawdown = autoTpDrawdownValue; // Set 5% trailing TP
    _G(tpDrawdownKey, tpDrawdown);
    Log(`🎯 ${coin} max P&L reached ${maxPnlPercent}%, enabling 5% trailing TP`);
}

// Trigger take-profit
if (tpDrawdown > 0 && maxPnlPercent > 0 && drawdown >= tpDrawdown) {
    autoCloseReason = `Trailing TP (drawdown ${drawdown}% ≥ ${tpDrawdown}%)`;
}

For stop-loss, the strategy supports manually setting a fixed percentage stop-loss as a hard floor of protection.

5. Visual Dashboard

The strategy includes four built-in monitoring panels for real-time operational awareness:

Account Overview: Equity, cumulative P&L, profit rate, account leverage (with color-coded risk levels)
AI Signal Table: Records every AI decision's score, conclusion, per-factor scores and reasoning — no guessing what the AI is thinking
Position Monitor: Real-time display of each position's entry price, current price, unrealized P&L, max profit record, current drawdown, scaling trigger prices, and TP/SL status
Grid Details: Order status when positions are combined with grid trading

Refreshes every 5 seconds, rendered as interactive tables via FMZ's LogStatus, supporting direct actions like closing positions and modifying TP/SL parameters.

6. Objective Pros & Cons Assessment

Strengths

Contrarian approach with natural counterparties. Shorting while the market chases means ample liquidity and minimal slippage.
AI multi-factor screening — not blind shorting. Six dimensions of comprehensive scoring filter out most low-quality signals. Only targets scoring 8+ get traded.
Inverse pyramid + trailing TP = solid risk-reward. Adding more at higher prices means bigger profits on reversal; flexible TP lets profits fully develop.
Strict position control. 500U max per trade — even a total loss is within tolerance.

Risks & Limitations

Sustained losses in a one-sided bull market. If the market enters a strong uptrend, shorting the top gainers can mean consecutive losses.
**Inverse pyramid scaling is a double-edged sword. **Scaling against the trend amplifies winning trades, but equally amplifies losing ones. If a pump coin genuinely keeps rising (e.g., a project with a major fundamental catalyst), all three position layers take losses — maximum exposure is 500U.
Best suited for: Ranging or bearish environments. Not suitable for one-sided bull markets. Assess the broader market context before deploying.

7. Final Thoughts

The core philosophy of this strategy: replace subjective judgment with data and AI, replace wishful thinking with strict position control.

Whether it's the design of the six-factor scoring system or the choice of OI/MCap ratio as the core metric, you can see the author has a solid understanding of market microstructure — knowing which indicators truly matter and which are just noise.

That said, every strategy has its boundaries. Tools are static; markets are dynamic. We strongly recommend thorough backtesting before going live, adjusting parameters to your own risk tolerance, and never copying blindly.

Special thanks to user @Gianbin for sharing this strategy so openly. It's this kind of open-source spirit that gives more people the opportunity to learn and explore the possibilities of quantitative trading. If you have great strategy ideas of your own, we'd love to hear about them!

Practice of Web3 Tron Encapsulated and Access to SunSwap DEX Based on FMZ Platform

Dream — Mon, 09 Mar 2026 07:52:13 +0000

Preface

In the field of blockchain tradings, decentralized exchanges (DEX) provide a trustless way to exchange assets, and SunSwap, as a representative DEX in the Tron ecosystem, supports smart contract interactions based on Web3. We FMZ platform provides a powerful quantitative trading framework that enables developers to integrate multiple trading strategies.

The FMZ platform already supports the encapsulation of Web3 Ethereum (ETH) exchange objects, and added support for Web3 TRON recently, encapsulating the exchange objects of the TRON chain. Just like accessing UniSwap DEX, access to SunSwap DEX is also possible.

This article will explore how to encapsulate the Web3 interface based on the FMZ Quant platform and access SunSwap DEX for trading. We will introduce the Web3 interaction method of the Tron network, the SunSwap smart contract call, and show how to query liquidity, execute transactions, and obtain transaction results through code examples, so as to build an efficient quantitative trading strategy.

Disclaimer

All codes and designs shared in this article have been tested and are intended for learning and communication. However, even after testing, these contents may still need to be adjusted according to actual needs. If you want to apply them to live trading, please be sure to evaluate, optimize and modify them yourself to ensure that they meet your needs.

Preparation

Configure the Web3 TRON exchange object of the FMZ platform

In the previous article FMZ Quant Web3 Expansion: Tron Support Added, Expand On-chain Tradings, we have introduced the common methods of Tron gRPC nodes and learned how to configure Web3 TRON exchange objects on FMZ. This article will not repeat these contents. As for the node address, we will use the node provided by TRON official directly.

Deploy the docker

https://youtu.be/xpfaimePdHc?si=wVASaGguaaxNwqkS

Unlike CEX exchanges, there is no wall to worry about. You can access the official node by deploying a docker locally.

SunSwap DEX https://sun.io/

Open the front-end page of SunSwap in the browser, you can connect to the wallet and observe the data conveniently.

tronscan https://tronscan.org/

Essential tools for viewing and analyzing data.

base58 The address on TRON is base58 encoded, which is different from Ethereum. Sometimes, in order to view and compare data, some conversion is required. On FMZ, you can use the base58 encoded address directly. Some smart contracts return data in HEX encoding, which requires some conversion. Several functions are simply implemented to convert the address format:

The following are the main conversion functions. Due to limited space, I will not post all the codes. The complete code is in the "Tron SunSwap V3 Trading Library" template library disclosed at the end of the article.

function ethAddressToTron(ethAddress) {
    if (!/^0x[0-9a-fA-F]{40}$/.test(ethAddress)) {
        throw "Invalid Ethereum address"
    }

    const ethAddressBytes = new Uint8Array(20)
    for (let i = 0; i < 20; i++) {
        ethAddressBytes[i] = parseInt(ethAddress.substr(2 + i * 2, 2), 16)
    }

    const tronAddressBytes = new Uint8Array(21)
    tronAddressBytes[0] = 0x41
    tronAddressBytes.set(ethAddressBytes, 1)

    const hash1 = Encode("sha256", "hex", "hex", uint8ArrayToHex(tronAddressBytes))
    const hash2 = Encode("sha256", "hex", "hex", hash1)
    const checksum = hash2.slice(0, 8)

    const fullAddress = new Uint8Array(25)
    fullAddress.set(tronAddressBytes, 0)
    fullAddress.set(hexToUint8Array(checksum), 21)

    return base58Encode(fullAddress)
}

Package call

Because sometimes you need to read data from multiple methods at once, calling them one by one is time-consuming and laborious. So a packaged calling function is encapsulated:

function multicall(e, multicallContractAddress, data, outTypes) {
    let ret = e.IO("api", multicallContractAddress, "aggregate", data)
    if (!ret || !ret["returnData"] || !Array.isArray(ret["returnData"])) {
        Log("invalid ret:", ret)
        return null
    }

    let arrRet = ret["returnData"]
    if (outTypes.length != arrRet.length) {
        Log("Arrays have unequal lengths:", arrRet, outTypes)
        return null
    }

    let outData = []
    for (let i in arrRet) {
        outData.push(e.IO("decode", outTypes[i], arrRet[i]))
    }

    return outData
}

Tron SunSwap V3 Trading Library

The design of SunSwap V3 trading library is modeled after the UniSwap trading library template of the FMZ platform. Since the SunSwap template code is long, I will not post it here, and will mainly explain the functions implemented.

Create SunSwap Trading Object

let e = $.CreateSunSwapEx()                 // By default, the exchange exchanges[0] is used to initialize the SunSwap trading object.
// let e = $.CreateSunSwapEx(exchanges[1])  // Initialize the SunSwap trading object using the secondary exchange object.

This template has only one interface function, namely: $.CreateSunSwapEx(), which is used to create a SunSwap trading object. After the object is created, you can call the method of this object to perform some function calls, such as: exchange transactions, query pool prices, obtain all V3 pool information, pledge, decompression, etc.

GetMarkets
The test codes of "Tron SunSwap V3 Trading Library" are all recorded in the main() function of the template and will not be repeated here.

    let markets = e.GetMarkets()
    let idx = 0
    let tbl = {"type": "table", "title": "test GetMarkets", "cols": ["Index", "PoolAddress", "Symbol", "BaseAsset", "QuoteAsset", "BaseName", "QuoteName", "BaseDecimals", "QuoteDecimals", "BaseAddress", "QuoteAddress"], "rows": []}
    for (let currency in markets) {
        let arrMarket = markets[currency]
        for (let market of arrMarket) {
            tbl["rows"].push([idx, market["PoolAddress"], market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["BaseName"], market["QuoteName"], market["BaseDecimals"], market["QuoteDecimals"], market["BaseAddress"], market["QuoteAddress"]])    
            idx++
        }
    }
    LogStatus("`" + JSON.stringify(tbl) + "`")

The function GetMarkets() is used to obtain the relevant information of all exchange pools in the SunSwap V3 pool, cached in the variables of the SunSwap trading object, and used to query accuracy, address and other information during other operations.

After running the test code, the information of all V3 pools will be displayed:

The code has removed some of the contract addresses currently seen, such as "phishing contracts" and "invalid contracts".

GetTicker

    let ticker1 = e.GetTicker("WTRX_USDT")
    Log("symbol:", "WTRX_USDT", ", ticker:", ticker1)
    let ticker2 = e.GetTicker("iCMX_USDT", "TLVDozYEBgeaJXH7oKBsougzEJKNrogFun")  // iCMX_USDT
    Log("symbol:", "iCMX_USDT", ", ticker:", ticker2)

You can use the GetTicker() function to query the price of a certain exchange pool, and you can specify the address of a specific pool. Note that some pools have poor liquidity and the price is only for reference.

multicall

    let data = []
    let walletAddress = exchange.IO("address")
    data.push(["TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t", "0x" + exchange.IO("encode", "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t", "balanceOf", walletAddress)])    
    data.push(["TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t", "0x" + exchange.IO("encode", "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t", "balanceOf", walletAddress)])    
    Log(data)
    let ret = multicall(exchange, "TGXuuKAb4bnrn137u39EKbYzKNXvdCes98", data, ["uint256", "uint256"])
    Log(ret, toAmount(ret[0], 6))

This function can be used for subsequent function encapsulation. For example, in the example, two balanceOf method calls can be encoded and the data can be requested once.

GetSwapOutAmount

    let retBuy = e.GetSwapOutAmount("WTRX_USDT", 1, "buy")     // 1 quote -> base
    Log("WTRX_USDT", "buy outAmount:", retBuy["outAmount"], ", ask:", (1 / retBuy["outAmount"]))
    let retSell = e.GetSwapOutAmount("WTRX_USDT", 1, "sell")   // 1 base -> quote
    Log("WTRX_USDT", "sell outAmount:", retSell["outAmount"], ", bid:", (retSell["outAmount"] / 1))

This is an important function, which encapsulates SunSwap's intelligent routing service. Given tokenInSymbol and tokenOutSymbol, it can return possible exchange paths, the number of output tokens and other information.

GetAssets

    let assets = e.GetAssets()
    let tbl = {"type": "table", "title": "test GetAssets", "cols": ["Name", "Address", "Decimals", "Balance"], "rows": []}   
    for (let asset of assets) {
        tbl["rows"].push([asset.Currency, asset.Address, asset.Decimals, asset.Amount])
    }
    LogStatus("`" + JSON.stringify(tbl) + "`")

Since there is no good mechanism to traverse TRC20 tokens, with the help of tronscan's function, this third-party interface is used to query account asset information.

Swap

    // 6 USDT -> ? WTRX
    let ret = e.Swap("WTRX_USDT", 6, "buy")
    Log(ret)

    // 10 TRX -> ? WTRX
    // let ret = e.Swap("TRX_WTRX", 10, "sell")
    // Log(ret)

The most important function is this exchange. When executing the exchange, the exchange path will be formulated according to the smart routing first, and then the exchange method will be called to exchange the token.
It should be noted that if it is a TRX package/unpackage exchange, it is only executed using the WTRX contract method.

We perform the following tests:

let ret = e.Swap("TRX_USDT", 5, "sell")
Log(ret)

Other Encapsulations
There are some other functions such as "staking" and "unstaking". You can check them in the main() function in the template code, so I won't go into details.
You can also expand and add functions such as adding liquidity and removing liquidity.

Template Code
This template does not have any interaction design and interface parameters. It only implements the basic function of accessing SunSwap DEX. More functions can be optimized and added later.

function isEmptyObject(obj) {
    return Object.keys(obj).length === 0
}

function computePoolPrice(decimals0, decimals1, sqrtPriceX96) {
    [decimals0, decimals1, sqrtPriceX96] = [decimals0, decimals1, sqrtPriceX96].map(BigInt)
    const TWO = BigInt(2)
    const TEN = BigInt(10)
    const SIX_TENTH = BigInt(1000000)
    const Q192 = (TWO ** BigInt(96)) ** TWO
    return (Number((sqrtPriceX96 ** TWO * TEN ** decimals0 * SIX_TENTH) / (Q192 * TEN ** decimals1)) / Number(SIX_TENTH))
}

function multicall(e, multicallContractAddress, data, outTypes) {
    let ret = e.IO("api", multicallContractAddress, "aggregate", data)
    if (!ret || !ret["returnData"] || !Array.isArray(ret["returnData"])) {
        Log("invalid ret:", ret)
        return null
    }

    let arrRet = ret["returnData"]
    if (outTypes.length != arrRet.length) {
        Log("Arrays have unequal lengths:", arrRet, outTypes)
        return null
    }

    let outData = []
    for (let i in arrRet) {
        outData.push(e.IO("decode", outTypes[i], arrRet[i]))
    }

    return outData
}

function toAmount(s, decimals) {
    return Number((BigDecimal(BigInt(s)) / BigDecimal(Math.pow(10, decimals))).toString())
}

function toInnerAmount(n, decimals) {
    return (BigDecimal(n) * BigDecimal(Math.pow(10, decimals))).toFixed(0)
}

function hexToUint8Array(hex) {
    if (hex.length % 2 !== 0) {
        throw new Error("Invalid hex string length")
    }
    return Uint8Array.from(
        hex.match(/.{1,2}/g).map(byte => parseInt(byte, 16))
    )
}

function uint8ArrayToHex(array) {
    return Array.from(array).map(byte => byte.toString(16).padStart(2, "0")).join("")
}

function ethAddressToTron(ethAddress) {
    if (!/^0x[0-9a-fA-F]{40}$/.test(ethAddress)) {
        throw "Invalid Ethereum address"
    }

    const ethAddressBytes = new Uint8Array(20)
    for (let i = 0; i < 20; i++) {
        ethAddressBytes[i] = parseInt(ethAddress.substr(2 + i * 2, 2), 16)
    }

    const tronAddressBytes = new Uint8Array(21)
    tronAddressBytes[0] = 0x41
    tronAddressBytes.set(ethAddressBytes, 1)

    const hash1 = Encode("sha256", "hex", "hex", uint8ArrayToHex(tronAddressBytes))
    const hash2 = Encode("sha256", "hex", "hex", hash1)
    const checksum = hash2.slice(0, 8)

    const fullAddress = new Uint8Array(25)
    fullAddress.set(tronAddressBytes, 0)
    fullAddress.set(hexToUint8Array(checksum), 21)

    return base58Encode(fullAddress)
}

function base58Encode(buffer) {
    const base58Alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
    let num = BigInt("0x" + Array.from(buffer).map(b => b.toString(16).padStart(2, "0")).join(""))
    let encoded = ""
    while (num > 0) {
        let remainder = num % 58n
        num = num / 58n
        encoded = base58Alphabet[Number(remainder)] + encoded
    }
    for (let byte of buffer) {
        if (byte === 0) {
            encoded = base58Alphabet[0] + encoded
        } else {
            break
        }
    }

    return encoded
}

function base58ToHex(base58Str) {
    const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"

    var num = BigInt(0)
    for (var char of base58Str) {
        var digit = BigInt(ALPHABET.indexOf(char))
        if (digit === BigInt(-1)) throw new Error("Invalid Base58 character: " + char)
        num = num * BigInt(58) + digit
    }

    var hex = num.toString(16)    
    if (hex.length % 2 !== 0) {
        hex = "0" + hex
    }

    return "0x" + hex
}

$.CreateSunSwapEx = function(e) {
    let sunSwapEx = {}

    sunSwapEx.registerABI = function(address, codeABI) {
        let e = sunSwapEx.e

        if (typeof(address) == "undefined" || typeof(codeABI) == "undefined") {
            throw "need address, codeABI"
        }

        return e.IO("abi", address, codeABI)
    }

    sunSwapEx.getCurrencyInfo = function(token0Address, token1Address) {
        let e = sunSwapEx.e

        let arrTokenAddress = [token0Address, token1Address]
        let tokenInfoCallData = []
        let tokenInfoRetType = []
        for (let tokenAddress of arrTokenAddress) {
            tokenInfoCallData.push([tokenAddress, "0x" + e.IO("encode", tokenAddress, "symbol")])
            tokenInfoRetType.push("string")
            tokenInfoCallData.push([tokenAddress, "0x" + e.IO("encode", tokenAddress, "name")])
            tokenInfoRetType.push("string")
            tokenInfoCallData.push([tokenAddress, "0x" + e.IO("encode", tokenAddress, "decimals")])
            tokenInfoRetType.push("uint8")
        }
        let currencyInfo = _C(multicall, e, multicallContractAddress, tokenInfoCallData, tokenInfoRetType)
        if (currencyInfo.length != 6) {
            Log("invalid currency Info:", currencyInfo)
            return null
        }
        let ret = {
            "token0Symbol": currencyInfo[0],
            "token0Name": currencyInfo[1],
            "token0Decimals": currencyInfo[2],
            "token1Symbol": currencyInfo[3],
            "token1Name": currencyInfo[4],
            "token1Decimals": currencyInfo[5]
        }

        return ret
    }

    sunSwapEx.waitMined = function(tx) {
        let e = sunSwapEx.e        
        let i = 0
        let maxLoop = 10

        while (true) {
            Sleep(3000)

            let info = e.IO("api", "tron", "GetTransactionInfoByID", tx)
            if (info && info.receipt && typeof(info.receipt.result) == "number") {
                Log("GetTransactionInfoByID:", info)
                if (info.receipt.result == 1) {
                    return true
                } else {                
                    return false 
                }            
            }

            Log("Transaction not yet mined", tx)
            if (i > maxLoop) {
                break
            }
            i++
        }

        Log(`Transaction: ${tx} not found`)
        return false 
    }

    sunSwapEx.getTokenInfo = function(tokenSymbol) {
        let markets = sunSwapEx.markets
        if (!markets || isEmptyObject(markets)) {
            markets = sunSwapEx.GetMarkets()
        }

        if (tokenSymbol == "TRX") {
            return {"tokenSymbol": tokenSymbol, "tokenName": tokenSymbol, "tokenDecimals": 6, "tokenAddress": "--"}
        }

        for (let currency in markets) {
            for (let market of markets[currency]) {
                if (market["BaseAsset"] == tokenSymbol) {
                    return {"tokenSymbol": market["BaseAsset"], "tokenName": market["BaseName"], "tokenDecimals": market["BaseDecimals"], "tokenAddress": market["BaseAddress"]}
                } else if (market["QuoteAsset"] == tokenSymbol) {
                    return {"tokenSymbol": market["QuoteAsset"], "tokenName": market["QuoteName"], "tokenDecimals": market["QuoteDecimals"], "tokenAddress": market["QuoteAddress"]}
                }
            }
        }

        Log("not found token symbol:", tokenSymbol)
        return null
    }

    sunSwapEx.dealStakeTRX = function(methodName, resourceName, amount) {
        let e = sunSwapEx.e

        let walletAddress = e.IO("address")
        let balance = toInnerAmount(amount, 6)
        let resourceCode = -1

        if (resourceName == "BANDWIDTH") {
            resourceCode = 0
        } else if (resourceName == "ENERGY") {
            resourceCode = 1
        } else if (resourceName == "TRON_POWER") {
            resourceCode = 2
        } else {
            Log("not support resourceName:", resourceName)
            return null 
        }

        return e.IO("api", "tron", methodName, walletAddress, resourceCode, balance)
    }

    sunSwapEx.GetMarkets = function() {
        // sunswap v3 pool

        let e = sunSwapEx.e

        if (!sunSwapEx.markets) {
            sunSwapEx.markets = {}
        }

        let markets = sunSwapEx.markets
        if (!isEmptyObject(markets)) {
            return markets
        }

        let factoryV3Address = sunSwapEx.factoryV3Address

        // allPoolsLength
        let poolIdx = e.IO("api", factoryV3Address, "allPoolsLength")
        if (!poolIdx) {
            Log("invalid poolIdx:", poolIdx)
            return null 
        }
        Log("allPoolsLength:", poolIdx)

        // multicallContractAddress
        let multicallContractAddress = sunSwapEx.multicallContractAddress

        // get All pool address
        let retPools = []
        let getPoolsData = []
        let retPoolsType = []
        for (let i = 0; i < poolIdx; i++) {
            getPoolsData.push([factoryV3Address, "0x" + e.IO("encode", factoryV3Address, "allPools", String(i))])
            retPoolsType.push("address")

            if (getPoolsData.length > 30 || i == poolIdx - 1) {
                let arr = _C(multicall, e, multicallContractAddress, getPoolsData, retPoolsType)

                retPools.push(...arr)
                getPoolsData = []
                retPoolsType = []
            } 
        }

        // allPools
        let poolABI = sunSwapEx.poolABI
        for (let i in retPools) {
            // poolAddress
            let poolAddress = ethAddressToTron(retPools[i])

            // register pool ABI
            sunSwapEx.registerABI(poolAddress, poolABI)

            // get token address of the pool
            let tokenCallData = [[poolAddress, "0x" + e.IO("encode", poolAddress, "token0")], [poolAddress, "0x" + e.IO("encode", poolAddress, "token1")]]
            let tokenRetType = ["address", "address"]
            let arrTokenAddress = _C(multicall, e, multicallContractAddress, tokenCallData, tokenRetType)

            let token0Address = ethAddressToTron(arrTokenAddress[0])
            let token1Address = ethAddressToTron(arrTokenAddress[1])

            // symbol , name , decimals
            let currencyInfo = sunSwapEx.getCurrencyInfo(token0Address, token1Address)
            if (!currencyInfo) {
                return null
            }

            let token0Symbol = currencyInfo["token0Symbol"]
            let token0Name = currencyInfo["token0Name"]
            let token0Decimals = currencyInfo["token0Decimals"]
            let token1Symbol = currencyInfo["token1Symbol"]
            let token1Name = currencyInfo["token1Name"]
            let token1Decimals = currencyInfo["token1Decimals"]

            // Alias
            let mapAlias = {
                "TJWm3jWaJeCdyRckEXfopsJBvZi6wXVK2p": "PAPA",
                "TPYmHEhy5n8TCEfYGqW2rPxsghSfzghPDn": "USDDOLD",
                "TTiwtPv4MFHMoCpGDBEF85qQjD2v4e99ck": "HOUSDOLD",
                "TRFe3hT5oYhjSZ6f3ji5FJ7YCfrkWnHRvh": "ETHB"
            }
            if (typeof(mapAlias[token0Address]) != "undefined") {
                token0Symbol = mapAlias[token0Address]
            }
            if (typeof(mapAlias[token1Address]) != "undefined") {
                token1Symbol = mapAlias[token1Address]
            }

            // bad
            let mapBad = {
                "TMEmRKPob42vhkqEGopCnfBPixN5XTkdUc": "U S D T",      // Attention: Fishing contract
                "TXioUZK8ju3R54KvzSqPc6Ufq5wkxFqpq9": "U S D T",      // Attention: Fishing contract
                "TU41FWQQT8hZ6t72gVEjtSGn1Dshbevi7g": "CNY Coin",     // Attention: Invalid
                "TYB7oXNq4VyuiH5BHb4os8rTh7Ca8pxqSx": "BULL",         // Attention: Fishing contract
                "TYJxozCVMUiHg3TbQp9PKeuXdTsX9ugJz9": "SHISHA",       // Attention: Not circulated
                "TF9io9LGyjuK3uTpr73pAaQ5m9scxd9xvr": "TestToken18",  // Attention: Test trading pairs
                "TK8E3sFhBt3EB6gTT6d6co8RMB6DFUnNwE": "TestToken6"    // Attention: Test trading pairs
            }
            if (typeof(mapBad[token0Address]) != "undefined" || typeof(mapBad[token1Address]) != "undefined") {
                continue
            }

            // market
            let currency = token0Symbol + "_" + token1Symbol
            let market = {
                "Symbol": currency,
                "BaseAsset": token0Symbol,
                "QuoteAsset": token1Symbol,
                "BaseName": token0Name,
                "QuoteName": token1Name,
                "BaseDecimals": token0Decimals,
                "QuoteDecimals": token1Decimals,
                "BaseAddress": token0Address,
                "QuoteAddress": token1Address,
                "PoolAddress": poolAddress,
                "PoolIndex": i
            }

            if (!Array.isArray(markets[currency])) {
                markets[currency] = []
            }
            markets[currency].push(market)
            LogStatus(_D(), "get markets, length:", Object.keys(markets).length)

            Sleep(200)
        }

        _G("sunswap_markets", markets)
        sunSwapEx.markets = markets

        return markets
    }

    sunSwapEx.GetTicker = function(symbol, targetPoolAddress) {
        let e = sunSwapEx.e

        let markets = sunSwapEx.markets
        if (!markets || isEmptyObject(markets)) {
            markets = sunSwapEx.GetMarkets()
        }

        let arrPoolAddress = []
        let arrToken0Decimals = []
        let arrToken1Decimals = []
        for (let currency in markets) {        
            if (!Array.isArray(markets[currency]) || markets[currency].length == 0) {
                continue 
            }

            if (currency == symbol) {
                for (let ele of markets[currency]) {
                    if (typeof(targetPoolAddress) != "undefined" && ele["PoolAddress"] != targetPoolAddress) {
                        continue 
                    }
                    arrPoolAddress.push(ele["PoolAddress"])
                    arrToken0Decimals.push(ele["BaseDecimals"])
                    arrToken1Decimals.push(ele["QuoteDecimals"])
                }
            }
        }

        if (arrPoolAddress.length == 0) {
            Log(`${symbol} and ${targetPoolAddress} not found`)
            sunSwapEx.markets = {}
            return null
        }

        let arrPrice = []
        let slot0CallData = []
        let slot0RetType = []
        for (let i in arrPoolAddress) {
            let poolAddress = arrPoolAddress[i]
            let poolABI = sunSwapEx.poolABI
            e.IO("abi", poolAddress, poolABI)
            slot0CallData.push([poolAddress, "0x" + e.IO("encode", poolAddress, "slot0")])
            slot0RetType.push("(uint160,int24,uint16,uint16,uint16,uint8,bool)")
        }
        let multicallContractAddress = sunSwapEx.multicallContractAddress
        let arrSlot0 = _C(multicall, e, multicallContractAddress, slot0CallData, slot0RetType)

        for (let i in arrSlot0) {
            let slot0 = arrSlot0[i]
            let token0Decimals = arrToken0Decimals[i]
            let token1Decimals = arrToken1Decimals[i]
            let sqrtPriceX96 = slot0["Field1"]
            let poolAddress = arrPoolAddress[i]
            let price = computePoolPrice(token0Decimals, token1Decimals, sqrtPriceX96)

            arrPrice.push({"price": price, "poolAddress": poolAddress})
        }

        return arrPrice
    }

    sunSwapEx.GetSwapOutAmount = function(symbol, amountIn, type) {
        let arrCurrency = symbol.split("_")
        if (arrCurrency.length != 2) {
            Log("invalid symbol:", symbol)
            return null
        }

        let baseCurrencyInfo = sunSwapEx.getTokenInfo(arrCurrency[0])
        let quoteCurrencyInfo = sunSwapEx.getTokenInfo(arrCurrency[1])
        if (!baseCurrencyInfo || !quoteCurrencyInfo) {
            return null 
        }

        let baseSymbol = baseCurrencyInfo["tokenSymbol"]
        let baseAddress = baseCurrencyInfo["tokenAddress"]
        let baseDecimals = baseCurrencyInfo["tokenDecimals"]
        let quoteSymbol = quoteCurrencyInfo["tokenSymbol"]
        let quoteAddress = quoteCurrencyInfo["tokenAddress"]
        let quoteDecimals = quoteCurrencyInfo["tokenDecimals"]

        // black hole address
        if (baseSymbol == "TRX") {
            baseAddress = "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb"
        }
        if (quoteSymbol == "TRX") {
            quoteAddress = "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb"
        }

        let query = null
        if (type == "buy") {
            let amount = toInnerAmount(amountIn, quoteDecimals)
            query = `?fromToken=${quoteAddress}&toToken=${baseAddress}&amountIn=${amount}&typeList=WTRX,SUNSWAP_V1,SUNSWAP_V2,SUNSWAP_V3`
        } else if (type == "sell") {
            let amount = toInnerAmount(amountIn, baseDecimals)
            query = `?fromToken=${baseAddress}&toToken=${quoteAddress}&amountIn=${amount}&typeList=WTRX,SUNSWAP_V1,SUNSWAP_V2,SUNSWAP_V3`
        } else {
            Log("not support type:", type)
            return null 
        }

        try {
            let ret = JSON.parse(HttpQuery("https://rot.endjgfsv.link/swap/router" + query))
            Log("https://rot.endjgfsv.link/swap/router" + query, "GetSwapOutAmount ret:", ret)

            if (!ret || ret["message"] != "SUCCESS") {
                Log("invalid data:", ret)
                return null
            }

            let outAmount = null
            let best = null 
            let info = ret["data"]
            for (let ele of info) {
                if (!outAmount) {
                    outAmount = parseFloat(ele["amountOut"])
                    best = ele
                } else {
                    let amount = parseFloat(ele["amountOut"])
                    if (amount > outAmount) {
                        outAmount = amount
                        best = ele
                    }
                }
            }

            if (!outAmount || !best) {
                Log("info:", info)
                return null 
            }

            return {"info": info, "outAmount": outAmount, "best": best, "baseCurrencyInfo": baseCurrencyInfo, "quoteCurrencyInfo": quoteCurrencyInfo}
        } catch(e) {
            Log("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
            return null
        }
    }

    sunSwapEx.GetAccount = function() {
        let e = sunSwapEx.e

        let walletAddress = e.IO("address")
        let account = e.IO("api", "tron", "GetAccount", walletAddress)
        if (!account) {
            Log("get account failed, account:", account)
            return null 
        }

        let trxBalance = toAmount(account["balance"], 6)

        let resource = e.IO("api", "tron", "GetAccountResource", walletAddress)
        if (!resource) {
            Log("get resource failed, resource:", resource)
            return null 
        }

        let energyLimit = resource["EnergyLimit"] ? resource["EnergyLimit"] : 0
        let freeNetLimit = resource["freeNetLimit"] ? resource["freeNetLimit"] : 0

        return {"Info": {"GetAccount": account, "GetAccountResource": resource}, "TRX": trxBalance, "Bandwidth": freeNetLimit, "Energy": energyLimit}
    }

    sunSwapEx.GetAssets = function() {
        let e = sunSwapEx.e
        let walletAddress = e.IO("address")

        try {
            let ret = JSON.parse(HttpQuery("https://apilist.tronscanapi.com/api/account/token_asset_overview?address=" + walletAddress))

            let assets = []
            for (let info of ret["data"]) {
                let decimals = parseInt(info["tokenDecimal"])
                let asset = {
                    "Currency": info["tokenAbbr"] == "trx" ? "TRX" : info["tokenAbbr"],
                    "Decimals": decimals,
                    "Amount": toAmount(info["balance"], decimals),
                    "Address": info["tokenId"],
                }

                assets.push(asset)
            }

            return assets
        } catch(e) {
            Log("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
            return null
        }
    }

    sunSwapEx.StakeTRX = function(resourceName, frozenBalance) {
        return sunSwapEx.dealStakeTRX("FreezeBalanceV2", resourceName, frozenBalance)
    }

    sunSwapEx.UnStakeTRX = function(resourceName, unfreezeBalance) {
        return sunSwapEx.dealStakeTRX("UnfreezeBalanceV2", resourceName, unfreezeBalance)
    }

    sunSwapEx.WrappedTRX = function(actionType, amountIn) {
        let e = sunSwapEx.e

        let tx = null
        if (actionType == "deposit") {
            let amount = toInnerAmount(amountIn, 6)
            tx = e.IO("api", "TNUC9Qb1rRpS5CbWLmNMxXBjyFoydXjWFR", "deposit", amount, {gasLimit: toInnerAmount(sunSwapEx.feeLimit, 6)})
        } else if (actionType == "withdraw") {
            tx = e.IO("api", "TNUC9Qb1rRpS5CbWLmNMxXBjyFoydXjWFR", "withdraw(uint256)", toInnerAmount(amountIn, 6), {gasLimit: toInnerAmount(sunSwapEx.feeLimit, 6)})
        } else {
            Log("not support actionType:", actionType)
            return false 
        }

        if (tx) {
            Log("tx: ", tx)
            let txRet = sunSwapEx.waitMined(tx)
            if (!txRet) {
                Log(actionType, "failed")
                return false
            } else {
                Log(actionType, "success")
                return true
            }
        } else {
            Log("trans error")
            return false
        }
    }

    sunSwapEx.Swap = function(symbol, amountIn, type) {
        let e = sunSwapEx.e
        let smartRouterAddress = sunSwapEx.smartRouterAddress

        if (symbol == "TRX_WTRX" || symbol == "WTRX_TRX") {
            let actionType = null 
            if (type == "buy") {
                actionType = symbol == "TRX_WTRX" ? "withdraw" : "deposit"
            } else if (type == "sell") {
                actionType = symbol == "TRX_WTRX" ? "deposit" : "withdraw"
            } else {
                Log("invalid type:", type)
                return false 
            }

            return sunSwapEx.WrappedTRX(actionType, amountIn)
        }

        let swapInfo = sunSwapEx.GetSwapOutAmount(symbol, amountIn, type)
        if (!swapInfo || !swapInfo["best"]) {
            Log("invalid swapInfo:", swapInfo)
            return false
        }

        let outAmount = swapInfo["outAmount"]
        let best = swapInfo["best"]

        // path
        let path = best["tokens"]
        if (!path || path.length < 2) {
            Log("invalid path:", path)
            return false 
        }

        // poolVersions and versionsLen
        let poolVersions = [] 
        let versionsLen = []
        for (var v of best["poolVersions"]) {
            if (poolVersions.length == 0) {
                poolVersions.push(v)
                versionsLen.push(2)
            } else {
                if (poolVersions[poolVersions.length - 1] == v) {
                    versionsLen[versionsLen.length - 1] += 1
                } else {
                    poolVersions.push(v)
                    versionsLen.push(1)
                }
            }
        }

        // fees 
        let poolFees = best["poolFees"]

        // get decimals , token name 
        let token0Decimals = swapInfo["baseCurrencyInfo"]["tokenDecimals"]
        let token1Decimals = swapInfo["quoteCurrencyInfo"]["tokenDecimals"]

        let tokenInName = type == "buy" ? swapInfo["quoteCurrencyInfo"]["tokenSymbol"] : swapInfo["baseCurrencyInfo"]["tokenSymbol"]
        let tokenOutName = type == "buy" ? swapInfo["baseCurrencyInfo"]["tokenSymbol"] : swapInfo["quoteCurrencyInfo"]["tokenSymbol"]
        let tokenInAddress = type == "buy" ? swapInfo["quoteCurrencyInfo"]["tokenAddress"] : swapInfo["baseCurrencyInfo"]["tokenAddress"]
        let tokenOutAddress = type == "buy" ? swapInfo["baseCurrencyInfo"]["tokenAddress"] : swapInfo["quoteCurrencyInfo"]["tokenAddress"]
        let tokenInDecimals = type == "buy" ? token1Decimals : token0Decimals

        // calc amount
        let amount = null 
        let minAmount = null 
        if (type == "buy") {
            amount = toInnerAmount(amountIn, token1Decimals)
            minAmount = toInnerAmount(outAmount * 0.99, token0Decimals)
        } else if (type == "sell") {
            amount = toInnerAmount(amountIn, token0Decimals)
            minAmount = toInnerAmount(outAmount * 0.99, token1Decimals)
        } else {
            Log("invalid type:", type)
            return false 
        }

        // wallet address 
        let walletAddress = e.IO("address")

        // expired timestamp
        let expiredTS = parseInt((new Date().getTime() + 1000 * 60 * 5) / 1000)

        // [amount of the token to be swapped, minimum acceptable amount of the token obtained from the swap, address to receive the token obtained from the swap, deadline]
        let data = [String(amount), String(minAmount), walletAddress, expiredTS]

        // allowance
        if (tokenInName != "TRX" && !(tokenInName == "WTRX" && tokenOutName == "TRX")) {
            let allowanceAmount = e.IO("api", tokenInAddress, "allowance", walletAddress, smartRouterAddress)
            let realAmount = toAmount(allowanceAmount, tokenInDecimals)
            if (realAmount < amountIn) {
                // approve
                Log("realAmount is", realAmount, "too small, try to approve large amount")
                let txApprove = e.IO("api", tokenInAddress, "approve(address,uint256)", smartRouterAddress, "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", {gasLimit: toInnerAmount(sunSwapEx.feeLimit, 6)})
                if (!txApprove) {
                    throw "approve error"
                }

                let txRet = sunSwapEx.waitMined(txApprove)
                if (!txRet) {
                    Log("approve failed")
                    return false 
                } else {
                    Log("approve success")
                }
            } else {
                Log("allowance", realAmount, "no need to approve")
            }
        }

        // swap
        Log(`path:${path}, poolVersions:${poolVersions}, versionsLen:${versionsLen}, poolFees:${poolFees}, data:${data}`)
        Log("best swap:", best)
        let tx = e.IO("api", smartRouterAddress, "swapExactInput(address[],string[],uint256[],uint24[],(uint256,uint256,address,uint256))", tokenInName == "TRX" ? toInnerAmount(amountIn, 6) : 0, path, poolVersions, versionsLen, poolFees, data, {gasLimit: toInnerAmount(sunSwapEx.feeLimit, 6)})
        if (tx) {
            Log("tx: ", tx)
            let txRet = sunSwapEx.waitMined(tx)
            if (!txRet) {
                Log("swap", tokenInName, "to", tokenOutName, "failed")
                return false
            } else {
                Log("swap", tokenInName, "to", tokenOutName, "success")
                return true
            }            
        } else {
            Log("trans error")
            return false
        }
    }

    sunSwapEx.SendTRX = function(to, amount) {
        let e = sunSwapEx.e
        return e.IO("api", "tron", "send", to, toInnerAmount(amount, 6))
    }

    sunSwapEx.SetFeeLimit = function(feeLimit) {
        sunSwapEx.feeLimit = feeLimit
        Log("SetFeeLimit, feeLimit:", sunSwapEx.feeLimit, ", toInnerAmount:", toInnerAmount(sunSwapEx.feeLimit, 6))        
    }

    // init
    if (typeof(e) == "undefined") {
        e = exchange
        Log("By default, the exchange configuration is used")
    }
    sunSwapEx.e = e

    // tron
    let ret = e.IO("api", "tron", "GetNodeInfo")
    if (!ret) {
        throw "The current Web3 tron exchange object may be misconfigured"
    } else {
        Log("node information:", ret)
    }

    // feeLimit
    sunSwapEx.feeLimit = 50

    // register abi
    let factoryV3Address = "TThJt8zaJzJMhCEScH7zWKnp5buVZqys9x"
    sunSwapEx.factoryV3Address = factoryV3Address

    let poolABI = `[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"indexed":true,"name":"owner","internalType":"address","type":"address"},{"indexed":true,"name":"tickLower","internalType":"int24","type":"int24"},{"indexed":true,"name":"tickUpper","internalType":"int24","type":"int24"},{"indexed":false,"name":"amount","internalType":"uint128","type":"uint128"},{"indexed":false,"name":"amount0","internalType":"uint256","type":"uint256"},{"indexed":false,"name":"amount1","internalType":"uint256","type":"uint256"}],"name":"Burn","anonymous":false,"type":"event"},{"inputs":[{"indexed":true,"name":"owner","internalType":"address","type":"address"},{"indexed":false,"name":"recipient","internalType":"address","type":"address"},{"indexed":true,"name":"tickLower","internalType":"int24","type":"int24"},{"indexed":true,"name":"tickUpper","internalType":"int24","type":"int24"},{"indexed":false,"name":"amount0","internalType":"uint128","type":"uint128"},{"indexed":false,"name":"amount1","internalType":"uint128","type":"uint128"}],"name":"Collect","anonymous":false,"type":"event"},{"inputs":[{"indexed":true,"name":"sender","internalType":"address","type":"address"},{"indexed":true,"name":"recipient","internalType":"address","type":"address"},{"indexed":false,"name":"amount0","internalType":"uint128","type":"uint128"},{"indexed":false,"name":"amount1","internalType":"uint128","type":"uint128"}],"name":"CollectProtocol","anonymous":false,"type":"event"},{"inputs":[{"indexed":true,"name":"sender","internalType":"address","type":"address"},{"indexed":true,"name":"recipient","internalType":"address","type":"address"},{"indexed":false,"name":"amount0","internalType":"uint256","type":"uint256"},{"indexed":false,"name":"amount1","internalType":"uint256","type":"uint256"},{"indexed":false,"name":"paid0","internalType":"uint256","type":"uint256"},{"indexed":false,"name":"paid1","internalType":"uint256","type":"uint256"}],"name":"Flash","anonymous":false,"type":"event"},{"inputs":[{"indexed":false,"name":"observationCardinalityNextOld","internalType":"uint16","type":"uint16"},{"indexed":false,"name":"observationCardinalityNextNew","internalType":"uint16","type":"uint16"}],"name":"IncreaseObservationCardinalityNext","anonymous":false,"type":"event"},{"inputs":[{"indexed":false,"name":"sqrtPriceX96","internalType":"uint160","type":"uint160"},{"indexed":false,"name":"tick","internalType":"int24","type":"int24"}],"name":"Initialize","anonymous":false,"type":"event"},{"inputs":[{"indexed":false,"name":"sender","internalType":"address","type":"address"},{"indexed":true,"name":"owner","internalType":"address","type":"address"},{"indexed":true,"name":"tickLower","internalType":"int24","type":"int24"},{"indexed":true,"name":"tickUpper","internalType":"int24","type":"int24"},{"indexed":false,"name":"amount","internalType":"uint128","type":"uint128"},{"indexed":false,"name":"amount0","internalType":"uint256","type":"uint256"},{"indexed":false,"name":"amount1","internalType":"uint256","type":"uint256"}],"name":"Mint","anonymous":false,"type":"event"},{"inputs":[{"indexed":false,"name":"feeProtocol0Old","internalType":"uint8","type":"uint8"},{"indexed":false,"name":"feeProtocol1Old","internalType":"uint8","type":"uint8"},{"indexed":false,"name":"feeProtocol0New","internalType":"uint8","type":"uint8"},{"indexed":false,"name":"feeProtocol1New","internalType":"uint8","type":"uint8"}],"name":"SetFeeProtocol","anonymous":false,"type":"event"},{"inputs":[{"indexed":true,"name":"sender","internalType":"address","type":"address"},{"indexed":true,"name":"recipient","internalType":"address","type":"address"},{"indexed":false,"name":"amount0","internalType":"int256","type":"int256"},{"indexed":false,"name":"amount1","internalType":"int256","type":"int256"},{"indexed":false,"name":"sqrtPriceX96","internalType":"uint160","type":"uint160"},{"indexed":false,"name":"liquidity","internalType":"uint128","type":"uint128"},{"indexed":false,"name":"tick","internalType":"int24","type":"int24"}],"name":"Swap","anonymous":false,"type":"event"},{"outputs":[{"name":"","internalType":"address","type":"address"}],"inputs":[],"name":"factory","stateMutability":"view","type":"function"},{"outputs":[{"name":"","internalType":"uint24","type":"uint24"}],"inputs":[],"name":"fee","stateMutability":"view","type":"function"},{"outputs":[{"name":"","internalType":"uint256","type":"uint256"}],"inputs":[],"name":"feeGrowthGlobal0X128","stateMutability":"view","type":"function"},{"outputs":[{"name":"","internalType":"uint256","type":"uint256"}],"inputs":[],"name":"feeGrowthGlobal1X128","stateMutability":"view","type":"function"},{"outputs":[{"name":"","internalType":"uint128","type":"uint128"}],"inputs":[],"name":"liquidity","stateMutability":"view","type":"function"},{"outputs":[{"name":"","internalType":"uint128","type":"uint128"}],"inputs":[],"name":"maxLiquidityPerTick","stateMutability":"view","type":"function"},{"outputs":[{"name":"blockTimestamp","internalType":"uint32","type":"uint32"},{"name":"tickCumulative","internalType":"int56","type":"int56"},{"name":"secondsPerLiquidityCumulativeX128","internalType":"uint160","type":"uint160"},{"name":"initialized","internalType":"bool","type":"bool"}],"inputs":[{"name":"","internalType":"uint256","type":"uint256"}],"name":"observations","stateMutability":"view","type":"function"},{"outputs":[{"name":"liquidity","internalType":"uint128","type":"uint128"},{"name":"feeGrowthInside0LastX128","internalType":"uint256","type":"uint256"},{"name":"feeGrowthInside1LastX128","internalType":"uint256","type":"uint256"},{"name":"tokensOwed0","internalType":"uint128","type":"uint128"},{"name":"tokensOwed1","internalType":"uint128","type":"uint128"}],"inputs":[{"name":"","internalType":"bytes32","type":"bytes32"}],"name":"positions","stateMutability":"view","type":"function"},{"outputs":[{"name":"token0","internalType":"uint128","type":"uint128"},{"name":"token1","internalType":"uint128","type":"uint128"}],"inputs":[],"name":"protocolFees","stateMutability":"view","type":"function"},{"outputs":[{"name":"sqrtPriceX96","internalType":"uint160","type":"uint160"},{"name":"tick","internalType":"int24","type":"int24"},{"name":"observationIndex","internalType":"uint16","type":"uint16"},{"name":"observationCardinality","internalType":"uint16","type":"uint16"},{"name":"observationCardinalityNext","internalType":"uint16","type":"uint16"},{"name":"feeProtocol","internalType":"uint8","type":"uint8"},{"name":"unlocked","internalType":"bool","type":"bool"}],"inputs":[],"name":"slot0","stateMutability":"view","type":"function"},{"outputs":[{"name":"","internalType":"uint256","type":"uint256"}],"inputs":[{"name":"","internalType":"int16","type":"int16"}],"name":"tickBitmap","stateMutability":"view","type":"function"},{"outputs":[{"name":"","internalType":"int24","type":"int24"}],"inputs":[],"name":"tickSpacing","stateMutability":"view","type":"function"},{"outputs":[{"name":"liquidityGross","internalType":"uint128","type":"uint128"},{"name":"liquidityNet","internalType":"int128","type":"int128"},{"name":"feeGrowthOutside0X128","internalType":"uint256","type":"uint256"},{"name":"feeGrowthOutside1X128","internalType":"uint256","type":"uint256"},{"name":"tickCumulativeOutside","internalType":"int56","type":"int56"},{"name":"secondsPerLiquidityOutsideX128","internalType":"uint160","type":"uint160"},{"name":"secondsOutside","internalType":"uint32","type":"uint32"},{"name":"initialized","internalType":"bool","type":"bool"}],"inputs":[{"name":"","internalType":"int24","type":"int24"}],"name":"ticks","stateMutability":"view","type":"function"},{"outputs":[{"name":"","internalType":"address","type":"address"}],"inputs":[],"name":"token0","stateMutability":"view","type":"function"},{"outputs":[{"name":"","internalType":"address","type":"address"}],"inputs":[],"name":"token1","stateMutability":"view","type":"function"},{"outputs":[{"name":"tickCumulativeInside","internalType":"int56","type":"int56"},{"name":"secondsPerLiquidityInsideX128","internalType":"uint160","type":"uint160"},{"name":"secondsInside","internalType":"uint32","type":"uint32"}],"inputs":[{"name":"tickLower","internalType":"int24","type":"int24"},{"name":"tickUpper","internalType":"int24","type":"int24"}],"name":"snapshotCumulativesInside","stateMutability":"view","type":"function"},{"outputs":[{"name":"tickCumulatives","internalType":"int56[]","type":"int56[]"},{"name":"secondsPerLiquidityCumulativeX128s","internalType":"uint160[]","type":"uint160[]"}],"inputs":[{"name":"secondsAgos","internalType":"uint32[]","type":"uint32[]"}],"name":"observe","stateMutability":"view","type":"function"},{"outputs":[],"inputs":[{"name":"observationCardinalityNext","internalType":"uint16","type":"uint16"}],"name":"increaseObservationCardinalityNext","stateMutability":"nonpayable","type":"function"},{"outputs":[],"inputs":[{"name":"sqrtPriceX96","internalType":"uint160","type":"uint160"}],"name":"initialize","stateMutability":"nonpayable","type":"function"},{"outputs":[{"name":"amount0","internalType":"uint256","type":"uint256"},{"name":"amount1","internalType":"uint256","type":"uint256"}],"inputs":[{"name":"recipient","internalType":"address","type":"address"},{"name":"tickLower","internalType":"int24","type":"int24"},{"name":"tickUpper","internalType":"int24","type":"int24"},{"name":"amount","internalType":"uint128","type":"uint128"},{"name":"data","internalType":"bytes","type":"bytes"}],"name":"mint","stateMutability":"nonpayable","type":"function"},{"outputs":[{"name":"amount0","internalType":"uint128","type":"uint128"},{"name":"amount1","internalType":"uint128","type":"uint128"}],"inputs":[{"name":"recipient","internalType":"address","type":"address"},{"name":"tickLower","internalType":"int24","type":"int24"},{"name":"tickUpper","internalType":"int24","type":"int24"},{"name":"amount0Requested","internalType":"uint128","type":"uint128"},{"name":"amount1Requested","internalType":"uint128","type":"uint128"}],"name":"collect","stateMutability":"nonpayable","type":"function"},{"outputs":[{"name":"amount0","internalType":"uint256","type":"uint256"},{"name":"amount1","internalType":"uint256","type":"uint256"}],"inputs":[{"name":"tickLower","internalType":"int24","type":"int24"},{"name":"tickUpper","internalType":"int24","type":"int24"},{"name":"amount","internalType":"uint128","type":"uint128"}],"name":"burn","stateMutability":"nonpayable","type":"function"},{"outputs":[{"name":"amount0","internalType":"int256","type":"int256"},{"name":"amount1","internalType":"int256","type":"int256"}],"inputs":[{"name":"recipient","internalType":"address","type":"address"},{"name":"zeroForOne","internalType":"bool","type":"bool"},{"name":"amountSpecified","internalType":"int256","type":"int256"},{"name":"sqrtPriceLimitX96","internalType":"uint160","type":"uint160"},{"name":"data","internalType":"bytes","type":"bytes"}],"name":"swap","stateMutability":"nonpayable","type":"function"},{"outputs":[],"inputs":[{"name":"recipient","internalType":"address","type":"address"},{"name":"amount0","internalType":"uint256","type":"uint256"},{"name":"amount1","internalType":"uint256","type":"uint256"},{"name":"data","internalType":"bytes","type":"bytes"}],"name":"flash","stateMutability":"nonpayable","type":"function"},{"outputs":[],"inputs":[{"name":"feeProtocol0","internalType":"uint8","type":"uint8"},{"name":"feeProtocol1","internalType":"uint8","type":"uint8"}],"name":"setFeeProtocol","stateMutability":"nonpayable","type":"function"},{"outputs":[{"name":"amount0","internalType":"uint128","type":"uint128"},{"name":"amount1","internalType":"uint128","type":"uint128"}],"inputs":[{"name":"recipient","internalType":"address","type":"address"},{"name":"amount0Requested","internalType":"uint128","type":"uint128"},{"name":"amount1Requested","internalType":"uint128","type":"uint128"}],"name":"collectProtocol","stateMutability":"nonpayable","type":"function"}]`
    sunSwapEx.poolABI = poolABI

    let multicallContractAddress = "TGXuuKAb4bnrn137u39EKbYzKNXvdCes98"
    sunSwapEx.multicallContractAddress = multicallContractAddress
    let multicallContractABI = `[{"inputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct TronMulticall.Call[]","name":"calls","type":"tuple[]"}],"name":"aggregate","outputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"},{"internalType":"bytes[]","name":"returnData","type":"bytes[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBasefee","outputs":[{"internalType":"uint256","name":"basefee","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getBlockHash","outputs":[{"internalType":"bytes32","name":"blockHash","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBlockNumber","outputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getChainId","outputs":[{"internalType":"uint256","name":"chainid","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentBlockCoinbase","outputs":[{"internalType":"address","name":"coinbase","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentBlockDifficulty","outputs":[{"internalType":"uint256","name":"difficulty","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentBlockTimestamp","outputs":[{"internalType":"uint256","name":"timestamp","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"getEthBalance","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLastBlockHash","outputs":[{"internalType":"bytes32","name":"blockHash","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"accountAddress","type":"address"},{"internalType":"trcToken","name":"id","type":"trcToken"}],"name":"getTokenBalance","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"isContract","outputs":[{"internalType":"bool","name":"result","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"results","type":"bytes[]"}],"stateMutability":"view","type":"function"}]`
    sunSwapEx.registerABI(multicallContractAddress, multicallContractABI)

    let smartRouterAddress = "TCFNp179Lg46D16zKoumd4Poa2WFFdtqYj"
    sunSwapEx.smartRouterAddress = smartRouterAddress
    let smartRouterABI = `[{"outputs":[{"name":"amountsOut","type":"uint256[]"}],"inputs":[{"name":"path","type":"address[]"},{"name":"poolVersion","type":"string[]"},{"name":"versionLen","type":"uint256[]"},{"name":"fees","type":"uint24[]"},{"name":"data","type":"tuple"}],"name":"swapExactInput","stateMutability":"payable","type":"function","payable":true}]`
    sunSwapEx.registerABI(smartRouterAddress, smartRouterABI)

    // get sunswap_markets
    sunSwapEx.markets = _G("sunswap_markets")

    return sunSwapEx
}

// for test
function main() {
    // reset log
    LogReset(1)
    // reset _G()
    // _G(null)

    // Create SunswapEx 
    let e = $.CreateSunSwapEx()
    // let e = $.CreateSunSwapEx(exchanges[1])

    // /* GetMarkets
    let markets = e.GetMarkets()
    let idx = 0
    let tbl = {"type": "table", "title": "test GetMarkets", "cols": ["Index", "PoolAddress", "Symbol", "BaseAsset", "QuoteAsset", "BaseName", "QuoteName", "BaseDecimals", "QuoteDecimals", "BaseAddress", "QuoteAddress"], "rows": []}
    for (let currency in markets) {
        let arrMarket = markets[currency]
        for (let market of arrMarket) {
            tbl["rows"].push([idx, market["PoolAddress"], market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["BaseName"], market["QuoteName"], market["BaseDecimals"], market["QuoteDecimals"], market["BaseAddress"], market["QuoteAddress"]])    
            idx++
        }
    }
    LogStatus("`" + JSON.stringify(tbl) + "`")
    // */

    /* GetTicker    
    let ticker1 = e.GetTicker("WTRX_USDT")
    Log("symbol:", "WTRX_USDT", ", ticker:", ticker1)
    let ticker2 = e.GetTicker("iCMX_USDT", "TLVDozYEBgeaJXH7oKBsougzEJKNrogFun")  // iCMX_USDT
    Log("symbol:", "iCMX_USDT", ", ticker:", ticker2)
    */

    /* multicall  
    let data = []
    let walletAddress = exchange.IO("address")
    data.push(["TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t", "0x" + exchange.IO("encode", "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t", "balanceOf", walletAddress)])    
    data.push(["TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t", "0x" + exchange.IO("encode", "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t", "balanceOf", walletAddress)])    
    Log(data)
    let ret = multicall(exchange, "TGXuuKAb4bnrn137u39EKbYzKNXvdCes98", data, ["uint256", "uint256"])
    Log(ret, toAmount(ret[0], 6))
    */

    /* GetSwapOutAmount
    let retBuy = e.GetSwapOutAmount("WTRX_USDT", 1, "buy")     // 1 quote -> base
    Log("WTRX_USDT", "buy outAmount:", retBuy["outAmount"], ", ask:", (1 / retBuy["outAmount"]))
    let retSell = e.GetSwapOutAmount("WTRX_USDT", 1, "sell")   // 1 base -> quote
    Log("WTRX_USDT", "sell outAmount:", retSell["outAmount"], ", bid:", (retSell["outAmount"] / 1))
    */

    /* GetAssets
    let assets = e.GetAssets()
    let tbl = {"type": "table", "title": "test GetAssets", "cols": ["Name", "Address", "Decimals", "Balance"], "rows": []}   
    for (let asset of assets) {
        tbl["rows"].push([asset.Currency, asset.Address, asset.Decimals, asset.Amount])
    }
    LogStatus("`" + JSON.stringify(tbl) + "`")
    */

    /* Swap
    // let ret = e.Swap("WTRX_USDT", 6, "buy")
    // let ret = e.Swap("WTRX_TUSD", 6, "buy")
    // let ret = e.Swap("WTRX_TUSD", 10, "sell")
    // let ret = e.Swap("TRX_WTRX", 10, "sell")
    // let ret = e.Swap("TRX_WTRX", 10, "buy")
    // let ret = e.Swap("TUSD_TRX", 0.3, "sell")
    // let ret = e.Swap("WTRX_USDT", 20, "sell")
    // let ret = e.Swap("USDT_TRX", 6, "sell")
    Log(ret)
    */

    /* check token
    let mapFilter = {}
    let checkMarkets = e.GetMarkets()
    for (let currency in checkMarkets) {
        for (let market of checkMarkets[currency]) {
            let base = market["BaseAsset"]
            let quote = market["QuoteAsset"]
            if (typeof(mapFilter[base]) == "undefined") {
                mapFilter[base] = market["BaseAddress"]
            }
            if (typeof(mapFilter[quote]) == "undefined") {
                mapFilter[quote] = market["QuoteAddress"]
            }

            if (market["BaseAddress"] != mapFilter[base]) {
                Log(market["BaseAsset"], market["BaseAddress"], " --- ", base, mapFilter[base])
            }
            if (market["QuoteAddress"] != mapFilter[quote]) {
                Log(market["QuoteAsset"], market["QuoteAddress"], " --- ", quote, mapFilter[quote])
            }
        }
    }
    */

    /* GetAccount
    let account = e.GetAccount()
    Log(account)
    */

    /* StakeTRX
    // BANDWIDTH, ENERGY, TRON_POWER
    let retStakeTRX = e.StakeTRX("ENERGY", 10)         // Stake TRX
    Log("retStakeTRX:", retStakeTRX)
    // let retUnStakeTRX = e.UnStakeTRX("ENERGY", 100) // UnStake TRX
    // Log("retUnStakeTRX:", retUnStakeTRX)
    */

    /* send
    // let ret = e.SendTRX("...", 180)
    // Log("SendTRX ret:", ret)
    */
}

END

Through this article, we have realized the Web3 Tron package based on the FMZ Quant platform, and connected to SunSwap DEX successfully, completing the complete process from querying the trading pool to executing the exchange and parsing the transaction results. This not only provides an efficient automation solution for DEX transactions in the Tron ecosystem, but also demonstrates the powerful scalability of the FMZ Quant platform.

I hope that the practical experience in this article can provide valuable reference for your quantitative trading system. Next, I will study the DEX on SOL.
Thank you for reading~

Polymarket Binary Hedging Arbitrage: From Concept to Live Execution

Dream — Wed, 04 Mar 2026 05:17:32 +0000

I. The Binary Market Structure of Polymarket

Polymarket is a prediction market where each question has only two possible outcomes — Yes or No, Up or Down, Win or Lose.

Take the BTC 15-minute price contract as an example. In each round, there are two contracts: Up and Down. The bet is whether BTC's closing price after 15 minutes will be higher or lower than the opening price.

If your side is correct → it pays $1
If your side is wrong → it pays $0

This market has an extremely special property:

The probabilities of the two outcomes must sum to 100%. Therefore, the price of Up plus the price of Down should theoretically equal exactly 1.

This property does not exist in ordinary futures markets. It provides us with a natural deterministic anchor.

II. Core Arbitrage Logic: Finding Certainty in Uncertainty

Quantitative trading essentially does one thing: find relatively certain opportunities in an uncertain market.

The binary structure of Polymarket provides such an anchor:

No matter whether BTC goes up or down during these 15 minutes, either Up or Down must settle at $1.

Using this anchor, we do not need to predict direction. We only need to find a moment when the combined cost of buying Up and Down is less than 1. Once that condition is met, the profit is locked in at the moment of purchase.

However, most of the time the market keeps the sum tightly around 1. Direct arbitrage opportunities are rare.

So where do the opportunities come from?

III. The Opportunity Window: Price Imbalance During Market Overreaction

Opportunities arise from price imbalance during market overreaction.

Imagine this scenario:

During a 15-minute round, BTC suddenly drops sharply. Panic spreads. The Up contract is heavily sold, and its price falls from 0.50 to 0.35.

In theory, if Up drops by 0.15, Down should rise by 0.15 so that their sum remains 1. But markets do not react symmetrically in real time. Up may have already crashed to 0.35, while Down is still moving upward from 0.50 toward 0.65 and hasn't fully caught up.

In that transitional moment, the sum may temporarily be:

This is the arbitrage window.

You spend 0.93 to buy a combination that must pay out 1 dollar.
The profit is already determined at the moment of purchase.

IV. The Original Idea: Four-Parameter Serial Version

The original idea came from Twitter blogger @the_smart_ape.
It is elegant and minimal, using only four parameters:

Execution logic:

During the monitoring window at the start of each round, continuously track price.

If one side drops more than the trigger threshold → buy it as Leg 1.

Wait for the opposite side's price to fall back.

When both legs' total price falls below the target → buy Leg 2.

Hold until settlement and collect payout.

The idea is clean and efficient. But in live trading, several problems appear.

V. Our Improvement: Proactively Locking Arbitrage Space

The original idea is passive:

Buy Leg 1
Wait for Leg 2 to become cheap enough

Our improvement is different:

At the moment of the dump, there is a high probability that Up and Down move at different speeds. We act simultaneously during this dislocation.

Execution logic:

Leg 1: Place a limit buy at dump price plus slippage.
Leg 2: Reverse-calculate price using SUM_TARGET - leg1Price
Submit both orders concurrently.

At the moment the orders are placed, the arbitrage space is already locked.
We are no longer waiting for the market to meet our condition — we let the market come to us.

Core implementation:

function executeBothLegs(symbols, dumpSide, dumpAsk) {
    var leg1Symbol = (dumpSide === "Up") ? symbols.up   : symbols.down
    var leg2Symbol = (dumpSide === "Up") ? symbols.down : symbols.up

    leg1Price = _N(dumpAsk + SLIPPAGE, 4)
    leg2Price = _N(SUM_TARGET - leg1Price, 4)

    var goLeg1 = exchange.Go("CreateOrder", leg1Symbol, "buy", leg1Price, SHARES)
    var goLeg2 = exchange.Go("CreateOrder", leg2Symbol, "buy", leg2Price, SHARES)

    var id1 = goLeg1.wait()
    var id2 = goLeg2.wait()

    leg1OrderId = id1
    leg2OrderId = id2
    state = STATE.BOTH_PENDING
}

VI. Problem One: Leg 1 Fills but Price Never Recovers

Reality often looks like this:

Up crashes
You buy Leg 1
Down never pulls back
Market sentiment remains bearish You are stuck holding a single-sided position that may go to zero at settlement.

A stop-loss is mandatory.

Patch 1: Floor Price + Early Take Profit
We introduce two parameters:

FLOOR_PRICE: If price drops to a deep absolute level (e.g., 0.05), exit immediately.
EARLY_TAKE_PROFIT: If Leg 1 rises enough before Leg 2 fills, sell and take profit early.

function handleLeg1OnlyRisk(symbols, upBid, downBid, isLastMin) {
    var holdBid    = (leg1Side === "Up") ? upBid : downBid
    var profitLine = leg1EntryAsk * (1 + EARLY_TAKE_PROFIT)
    var stopLine   = leg1EntryAsk * (1 - LAST_MIN_STOP_LOSS)

    var needClose = false
    var reason    = ""

    if (holdBid <= FLOOR_PRICE) {
        needClose = true; reason = "FLOOR_PRICE"
    } else if (!isLastMin && holdBid >= profitLine) {
        needClose = true; reason = "EARLY_TAKE_PROFIT"
    } else if (isLastMin && holdBid <= stopLine) {
        needClose = true; reason = "STOP_LOSS"
    }

    if (needClose) {
        cancelAndConfirmUntilClear(leg2OrderId)
        closePosition(holdSymbol, holdBid, reason)
    }
}

This caps downside and locks upside.

VII. Problem Two: Special Handling Near Settlement Near settlement, market behavior changes dramatically.

There may not be enough time for mean reversion. Volatility often increases.

Patch 2: Last-Minute Logic
We introduce LAST_MIN_S:

When entering the final phase:

Stop attempting Leg 2
Apply LAST_MIN_STOP_LOSS
If not stopped out, hold to settlement

var isLastMin = (remaining <= LAST_MIN_S)

if (isLastMin) {
    Log("⏰ In the last minute, cancel the pending orders that have not been executed")
    cancelAllPending("the last minute")
}

Early phase = wait for recovery
Late phase = avoid going to zero

VIII. Problem Three: On-Chain Latency

Polymarket is on-chain.

Order confirmation and position updates may take several seconds.

We add:

Order timeout detection
Cancellation and retry mechanism
Slippage parameter to increase fill probability

function placeOrderAndConfirm(symbol, side, price, amount) {
    var orderId = exchange.CreateOrder(symbol, side, orderPrice, amount)

    var deadline = Date.now() + ORDER_TIMEOUT_S * 1000
    while (Date.now() < deadline) {
        var order = exchange.GetOrder(orderId)
        if (order && order.Status === 1) {
            return { orderId: orderId, avgPrice: order.AvgPrice }  
        }
        if (order && (order.Status === 2 || order.Status === 4)) {
            return { orderId: orderId, avgPrice: null }  
        }
        Sleep(1000)
    }

    exchange.CancelOrder(orderId)
}

This ensures execution reliability in a blockchain environment.

IX. Redeem Mechanism

Polymarket has a special feature:

After settlement, funds are not automatically returned to balance.

You must manually call the Redeem function to unlock capital.

If forgotten, capital remains stuck.

The strategy automatically calls Redeem each round to ensure capital recycling.

function doRedeem() {
    var positions = exchange.GetPositions()
    for (var i = 0; i < positions.length; i++) {
        var pos = positions[i]
        if (pos.Info && pos.Info.redeemable) {
            var result = exchange.IO("redeem", pos.Symbol, true)
            Log("Redeem :", result)
        }
    }
}

if (!redeemDone && elapsed >= 840) {
    doRedeem()
    redeemDone = true
}

X. Real-Time Monitoring Dashboard

The strategy includes a real-time monitoring panel displaying:

Account balance
Strategy state
Price monitoring
Position details and floating P/L

This allows full visibility during live trading.

XI. Live Trading Example & Strategy Limitations

Example:
A new round begins. Down drops 18.6% from 0.43 to 0.35.

Both legs are placed simultaneously:

Leg 1 Down at 0.37
Leg 2 Up at 0.60
Total = 0.97 (< target)

Actual fill:

Leg 1 = 0.34
Leg 2 = 0.60
Total cost = 0.94

Profit exceeded expectation.

Three Honest Limitations

No opportunity in calm markets. Arbitrage depends on overreaction. In stable markets, the strategy idles.
Single-leg exposure risk. If Leg 2 never fills, Leg 1 may hit stop loss. Stop parameters are a trade-off.
SUM_TARGET threshold trade-off. High threshold → frequent but small profits. Low threshold → rare but large profits.

This defines the strategy's style.

XII. Future Optimization Directions

Integrate External BTC Price Feed. Pause entries during strong trending markets.
Mathematical Modeling. Up and Down are essentially binary options. Option pricing theory could model:
- Probability of imbalance
- Optimal entry timing
- Expected value more rigorously
Dynamic Parameter Adjustment. Current parameters are static. Volatility changes constantly. Adaptive parameters would significantly improve robustness.

Final Thoughts

The core idea — exploiting temporary mispricing in binary markets — is not limited to Polymarket BTC contracts.
Any binary-structured market with short-term pricing inefficiencies can apply similar logic.
What we built is merely a framework.
The truly interesting work begins from here.

Strategy Source Code:
Polymarket BTC 15-Minute Dual-Leg Hedged Arbitrage Bot (Two-Sided Hedge Version)

Funding Rate Arbitrage Strategy: Automated Implementation with AI and Workflows

Dream — Wed, 25 Feb 2026 03:06:51 +0000

1. Strategy Background & Requirements

Recently, some friends asked: could we build a funding rate arbitrage strategy? Between CEX and DEX platforms, funding rates are often inconsistent, creating opportunities to collect arbitrage signals and use AI to determine whether it's worth opening a position. However, there has always been a pain point: no good tool for detecting arbitrage opportunities.

Fortunately, someone recommended the VarFunding platform. This platform collects real-time funding rate data from multiple exchanges, including Binance, Hyperliquid, Lighter, Bybit, and more — all of which are already supported on the FMZ Quant platform. More importantly, it compares funding rate data in real time and provides optimal arbitrage opportunity combinations.

Talk about perfect timing! Today, let's walk through the design of this funding rate arbitrage strategy step by step.

2. What Is Funding Rate Arbitrage?

Before diving into the strategy, let's clarify: what exactly is funding rate arbitrage?

Perpetual contracts have a mechanism called the funding rate. Settlement cycles vary by exchange — some settle every 8 hours, some every 4 hours, and some even every hour.

When the rate is positive: longs pay shorts
When the rate is negative: shorts pay longs

Different exchanges have different user structures and liquidity profiles, resulting in different long/short dynamics. This means the funding rate for the same token often differs across exchanges.

The Arbitrage Principle
For example, Exchange A has a BTC funding rate of +0.1%, while Exchange B has +0.05%.

In this case, we can:

Go short on Exchange A (collect the 0.1% rate)
Go long on Exchange B (pay the 0.05% rate)

The positions hedge each other — price movements cancel out — but the rate differential (0.05%) goes straight into your pocket.

This is the core logic of funding rate arbitrage: you earn the rate spread, not price movement.

3. Why Use a Workflow?

Now that we understand the principle, the next question is: how do we implement it?

The traditional approach is to write a complete program, but this time we chose to implement it using a workflow. Workflows have several unique advantages:

1. Modular Design
Each node handles an independent function — data collection, filtering, AI evaluation, execution — each with a clear role, making debugging and modification straightforward.

2. Visual Representation
The entire strategy's execution flow is visible at a glance, making it easy to quickly locate any issues.

3. Flexible Extensibility
Want to swap in new filtering criteria or optimize trading logic? Just modify the corresponding node without touching other parts.

4. Easy AI Integration
Workflows natively support calling large language models, making it simple to incorporate AI into the decision-making process.

For an arbitrage strategy that requires multiple data sources and multi-step processing, workflows are an excellent implementation approach.

4. Overall Strategy Architecture

This strategy has two main pipelines:

Pipeline 1: Trade Execution (Hourly Interval)

Exchange Initialization → Build exchange mappings
Rate Data Analysis → Analyze historical data stability
Close Position Detection → Check if existing positions need to be closed
Rate Data Verification → Verify spread stability and liquidity
AI Smart Evaluation → Comprehensive assessment of opening opportunities
Open Position Execution → Execute arbitrage trades

Pipeline 2: Rate Collection (Minute Interval)

Fetch Arbitrage Opportunities → Pull data from VarFunding
Data Filtering → Filter opportunities that meet criteria
Data Storage → Save historical snapshots
Visualization → Display account and position status

The two pipelines each serve their purpose: the execution pipeline handles decisions and trades, while the collection pipeline handles data gathering and display. This design allows the strategy to execute efficiently while maintaining real-time awareness of its operational state.

5. Configuration Parameters

The strategy has several key parameters to configure:

Exchange: Exchange list — determines which exchanges the strategy searches for arbitrage opportunities between, e.g., ['binance', 'hyperliquid', 'lighter']
Confidence: Confidence filter — determines which confidence levels qualify for the verification process, options: ['high', 'medium', 'low']
Amount: Per-trade position size — AI will adjust the actual amount based on risk level

These parameters can be flexibly configured based on your needs.

6. Data Collection & Filtering

The first step is fetching arbitrage opportunity data. The strategy sends an HTTP request to VarFunding's API endpoint with the configured exchange list:

const url = `https://varfunding.xyz/api/funding?exchanges=${exchangeList.join(',')}`;

The platform returns funding rate data for all tokens across all exchanges, along with pre-calculated optimal arbitrage combinations. However, the raw data is too extensive to use entirely. The strategy filters it, keeping only opportunities where both the long and short exchanges are in our configured list:

const filteredMarkets = data.data.markets.filter(market => {
    const bestExchange = market.bestRate?.exchange;
    const worstExchange = market.worstRate?.exchange;
    return exchangeList.includes(bestExchange) && exchangeList.includes(worstExchange);
});

The filtered data is extracted into a concise format, retaining only key information: trading pair, long exchange, short exchange, rate spread, estimated annualized return, and confidence level. This data is saved for subsequent arbitrage opportunity analysis.

7. Rate Stability Verification

A single snapshot of rate data isn't sufficient, since rates may fluctuate temporarily. The strategy continuously collects data snapshots, saving current rate data every minute and retaining only the most recent N hours of historical records.

Once enough samples accumulate, the strategy performs statistical analysis, calculating the frequency of each token appearing at different confidence levels:

const stats = {};
for (const snapshot of savedData) {
    for (const [baseAsset, info] of Object.entries(snapshot.data)) {
        if (!stats[baseAsset]) {
            stats[baseAsset] = { high: 0, medium: 0, low: 0, total: 0 };
        }
        stats[baseAsset].total++;
        if (info.confidence === 'high') stats[baseAsset].high++;
        // ... tally other confidence levels
    }
}

Tokens are then categorized by their most frequent confidence level, and a weighted score is calculated:

score = (highCount × 3 + mediumCount × 2 + lowCount × 1) / totalCount

This score reflects the stability of the arbitrage opportunity. A higher score indicates more consistent performance in historical data, making the opportunity more trustworthy.

8. Close Position Detection

After rate analysis, the strategy checks existing positions against the latest arbitrage opportunity list. The core logic involves scanning all exchanges for current positions:

function scanAllPositions() {
    const allPositions = {};
    for (const [exName, exIndex] of Object.entries(EXCHANGE_MAP)) {
        const positions = exchanges[exIndex].GetPositions();
        for (const pos of positions) {
            const baseAsset = pos.Symbol.match(/^([A-Z0-9]+)_/)[1];
            const isLong = pos.Amount > 0;
            // Record long/short position info
        }
    }
    return allPositions;
}

Then it determines which positions need to be closed. There are two scenarios:

Scenario 1: The arbitrage opportunity has disappeared. If a held position's token is no longer found in the latest opportunity list, it means the rate spread has converged and the position should be closed to lock in profits.

Scenario 2: The direction has reversed. For example, if the original position was long on Exchange A and short on Exchange B, but now the optimal direction is reversed, the old positions need to be closed first.

When closing positions, both sides are closed simultaneously:

// Close long position
exchanges[longExIndex].CreateOrder(symbol, "closebuy", -1, amount);
// Close short position
exchanges[shortExIndex].CreateOrder(symbol, "closesell", -1, amount);

Position records are then cleared, ensuring that any expired positions are handled before searching for new opportunities.

9. In-Depth Rate Data Verification

After close position detection, the strategy performs live verification on the filtered arbitrage opportunities. Verification covers two aspects:

1. Spread Stability Verification
By fetching K-line data from both exchanges, historical spreads are calculated:

// Fetch 240 candlesticks
const recordsLong = EX_Long.GetRecords(symbol, PERIOD_M1, 240);
const recordsShort = EX_Short.GetRecords(symbol, PERIOD_M1, 240);

// Calculate spreads
const spreads = [];
for (const time of commonTimes) {
    const midPrice = (priceMapLong[time] + priceMapShort[time]) / 2;
    const spread = (priceMapLong[time] - priceMapShort[time]) / midPrice;
    spreads.push(spread);
}

// Statistical metrics
const avgSpread = mean(spreads);
const range = max(spreads) - min(spreads);
const stdDev = standardDeviation(spreads);

These metrics reflect the consistency of price movements between the two exchanges. If spread volatility is too high, the risk is elevated.

2. Liquidity Detection
Real-time market data is fetched to calculate trading costs:

const tickerLong = EX_Long.GetTicker(symbol);
const tickerShort = EX_Short.GetTicker(symbol);

// Bid-ask spread (reflects depth)
const longSpread = (tickerLong.Sell - tickerLong.Buy) / tickerLong.Last;
const shortSpread = (tickerShort.Sell - tickerShort.Buy) / tickerShort.Last;

// Opening cost (buy on Long exchange, sell on Short exchange)
const openCost = (tickerLong.Sell - tickerShort.Buy) / midPrice;

// Closing cost (buy on Short exchange, sell on Long exchange)
const closeCost = (tickerShort.Sell - tickerLong.Buy) / midPrice;

// Round-trip cost
const roundTripCost = openCost + closeCost;

If the round-trip cost is too high, it will erode rate profits, making the opportunity not worth pursuing.

After verification, if there are no viable arbitrage opportunities (i.e., the data object is empty), the process ends. If there are new opening opportunities, they proceed to the AI evaluation stage.

10. AI Smart Evaluation

Verified opportunities are handed to AI for comprehensive evaluation. We use a carefully crafted prompt that instructs the AI to think like a professional arbitrage analyst.

The AI analyzes several dimensions:

1. Risk-Reward Ratio
Whether rate income can cover spread volatility risk. The core judgment logic:

If rateSpread (per 8-hour income) > range × 0.3
This means even in extreme spread scenarios, 1-2 settlement cycles can cover the risk

The AI scores each opportunity (0–100) and assigns a risk level (low/medium/high). Only opportunities meeting the score threshold are executed. Additionally, the AI recommends position sizes based on risk level:

Score ≥ 80 and low risk: Suggested amount × 100%
Score 70–79 or medium risk: Suggested amount × 80%
Score 60–69: Suggested amount × 60%
Score < 60: Not recommended
The AI outputs a JSON array where each element contains: whether to open, score, suggested amount, risk level, and decision rationale.

11. Position Opening Execution Flow

After AI approval, the strategy executes the opening. The execution flow is rigorous:

1. Calculate Contract Quantity
Based on the suggested amount and current price, calculate how many contracts to open:

const currentPrice = getCurrentPrice(ex, symbol);
const contractAmount = amountUSD / currentPrice / ctVal;

Where ctVal is the contract face value, which may differ across exchanges.

2. Set Leverage
Attempt to set the target leverage (default 10x), falling back to lower levels if unsupported:

const leveragesToTry = [10, 5, 3, 2, 1];
for (let lev of leveragesToTry) {
    const result = ex.SetMarginLevel(symbol, lev);
    if (result === true) {
        return lev; // Successfully set
    }
}

3. Place Order & Confirm
After placing the order, don't assume success — wait for fill confirmation:

const orderId = ex.CreateOrder(symbol, 'buy', -1, contractAmount);

// Poll order status
for (let i = 0; i < 20; i++) {
    const order = ex.GetOrder(orderId);
    if (order.Status === ORDER_STATE_CLOSED) {
        // Fully filled
        break;
    }
    Sleep(500);
}

4. Verify Position
Even if the order shows as filled, verify the actual position:

const position = getPosition(ex, symbol);
if (!position || Math.abs(position.Amount) === 0) {
    // Order filled but no position — opening failed
    return { success: false };
}

5. Exception Handling
If only one side opens successfully (e.g., long succeeds but short fails), the strategy automatically closes the opened position:

if (!results.short.success && results.long.success) {
    // Attempt to close the long position
    const pos = getPosition(longEx, longSymbol);
    executeClose(longEx, longSymbol, true, pos.Amount, longExchange);
}

This prevents unhedged exposure, ensuring the arbitrage's hedged nature is maintained.

After successful opening, the strategy saves arbitrage position information — including open time, price, quantity, etc. — for subsequent close detection.

12. Visual Monitoring Dashboard

During operation, all information is displayed in real time on a monitoring dashboard with five tables: the Account Overview shows each exchange's balance, frozen funds, total equity, and P&L summary; the Arbitrage Signals table presents currently detected arbitrage opportunities, execution status, and failure reasons; the Opening Decision Details log the AI's score, risk level, and rationale for each opportunity; the Live Arbitrage Positions display current arbitrage combinations, long/short P&L, and holding duration; and the Arbitrage Profit Statistics summarize today's, this week's, this month's, and cumulative arbitrage profits and returns.

Through these dashboards, you can monitor the strategy's operational status in real time, including account health, current opportunities, position P&L, and all other key information.

13. Risks & Considerations

Finally, let's discuss risks and considerations:

1. Spread Volatility Risk
Although funding rate arbitrage is a hedged strategy, it is not risk-free. The spread between two exchanges can fluctuate, and if the fluctuation exceeds the rate income, losses will occur. This is why the strategy verifies spread stability.

2. Liquidity Risk
If an exchange lacks sufficient liquidity, slippage during opening and closing can be significant. For example, if order book depth is insufficient, your market orders may fill at poor prices, resulting in actual opening costs far exceeding expectations.

3. Exchange Risk
This is especially relevant for newer DEXs, which may have smart contract vulnerabilities or liquidity dry-up issues. There have been cases where DEX users lost funds due to smart contract bugs.

4. Capital Efficiency
This strategy requires funds on multiple exchanges. For example, if arbitraging across 3 exchanges, capital must be split three ways, resulting in relatively low capital efficiency.

It's recommended to start with a small amount, familiarize yourself with the strategy's logic, and then gradually increase your commitment. Start by arbitraging between two major exchanges, then expand to more after gaining experience.

14. Summary & Outlook

Today we introduced this funding rate arbitrage strategy based on the VarFunding platform. It implements a complete pipeline from data collection, stability verification, AI evaluation, to automated execution, with clear visual monitoring.

The core philosophy of the strategy:

Data-driven opportunity discovery: Decisions are based on real-time rate data and historical statistics, not guesswork
AI-assisted decision making: Large language models evaluate risk and reward, avoiding subjective human judgment
Rigorous execution flow for risk control: From order confirmation to position verification, every step includes checks

Of course, this is just a foundational framework with plenty of room for optimization:

Add more exchanges: Currently supported exchanges are limited; expand to more platforms
Optimize statistical logic: Introduce more sophisticated time series analysis to predict rate trends
Improve AI evaluation: Let AI learn from historical arbitrage successes and failures to continuously optimize decisions
Dynamic parameter adjustment: Automatically adjust position sizes and risk thresholds based on market volatility

The complete code is publicly available on the FMZ Quant platform: Workflow Funding Rate Arbitrage Strategy. Feel free to use and improve it.

Building an AI-Powered Automated Trading System from Scratch: Making ClawdBot(OpenClaw) Your Trading Brain

Dream — Thu, 05 Feb 2026 06:00:02 +0000

Introduction

In our previous video, we built a dual moving average strategy using ClawdBot/OpenClaw. Many viewers wanted more and asked in the comments: Can we let AI monitor the market, make decisions, and execute trades on its own? Today, we're going to tackle this ultimate goal and build a fully automated AI trading system.

Some of you are concerned that letting AI trade directly is too risky. That's why we've designed a safer architecture: ClawdBot serves as the brain, responsible for collecting data, analyzing news, and generating trading signals; FMZ Quant Platform serves as the hands, responsible for receiving signals, executing trades, and managing risk control. This approach leverages AI's analytical capabilities while maintaining the safety guarantees of a professional platform, plus real-time monitoring and review capabilities.

1. System Architecture Breakdown

Before we start coding, let's break down the entire system. The complete system consists of two core components—the Brain and the Executor—connected via HTTP requests to form a complete AI quantitative trading loop:

1.1 ClawdBot (OpenClaw - Brain)
Collect Real-time Data: Through browser automation, obtain the target cryptocurrency's real-time price, trading volume, and news updates.
Analyze News Sentiment: AI integrates news content and determines market sentiment as bullish, bearish, or neutral.
Generate Trading Decision JSON: Combining data and sentiment analysis, generate buy, sell, or hold decisions, packaged as JSON format for standardized cross-platform communication.
HTTP POST to FMZ: Push the JSON-formatted decision signals to the FMZ Quant Platform executor via HTTP POST requests.
1.2 FMZ Strategy (Executor)
Listen to Channel for Signals: Continuously monitor the designated channel to capture HTTP requests and trading signals from the brain.
Parse JSON and Execute Trades: Parse the received JSON data, extract core trading instructions, and trigger the platform's live trading bot to automatically complete order placement.
Risk Management and Stop-Loss Protection: Monitor market prices in real-time during trade execution, implementing stop-loss and FOMO protection according to preset rules to reduce trading risks.
Visual Dashboard Display: Display trading status, execution results, risk control data, and account equity on the platform dashboard in real-time for full-process visual monitoring.

2. Writing Instructions: Teaching AI What to Do

The core of ClawdBot is the instruction set—essentially a detailed operating manual for the AI, specifying its operating steps, judgment criteria, and execution actions. Let's look at the structure of these instructions:

2.1 Data Collection Section
First, tell the AI to open the target cryptocurrency's page and specify which key data to read:

[Operation Instructions]
1. Automatically open a new browser tab
2. Navigate to the target cryptocurrency page: https://www.coingecko.com/en/coins/bitcoin
3. Wait for the page to fully load

[Data to Read]
- BTC current price
- 24-hour trading volume

[News to Read]
- Scroll the page to find the "News" section
- Read the latest 3-5 news headlines and summaries
- Consolidate all news into a single summary
- Determine overall sentiment (bullish/bearish/neutral)

2.2 Decision Logic Section
Next, define clear trading judgment criteria, specifying when to buy and when to sell:

[Buy Conditions]
□ Overall positive news sentiment (bullish news dominant)
□ Increased trading volume indicating active market
□ Comprehensive judgment of upward market trend

[Sell Conditions]
□ Overall negative news sentiment (bearish news dominant)
□ Clear risk signals in the market

[Hold Conditions]
□ Neutral or mixed news sentiment
□ Unclear market direction

2.3 Output Format Definition
Require AI to generate standard JSON format data—the core communication protocol between ClawdBot and FMZ platform, ensuring unambiguous data parsing:

{
    "coin": "BTC",
    "timestamp": "2024-01-15T14:00:00.000Z",
    "current_price": 42500.00,
    "volume_24h": "25,000,000,000",
    "news_summary": "Continuous ETF fund inflows, strong institutional accumulation interest",
    "news_sentiment": "positive",
    "trade_decision": "buy",
    "decision_reason": "Positive news sentiment, increased trading volume, suitable for position building"
}

2.4 Execution Actions
Finally, tell the AI to push the JSON signal to the FMZ platform and maintain local operation records for future review:

[Send Signal]
Execute HTTP POST request:
URL: https://www.fmz.com/api/v1?method=pub&robot={LiveTradingID}&channel={UUID}
- Live Trading ID: The unique numeric identifier of the corresponding bot on FMZ platform, used to precisely specify the target trading bot receiving signals.
- UUID: Universal Unique Identifier, serving as the custom channel's unique identifier and the communication key between ClawdBot and FMZ. Do not disclose it to avoid malicious operations.

[Record Log]
Append each operation's time, cryptocurrency, decision, and signal sending status to the local tradediary.csv file for subsequent strategy review and optimization.

Of course, this instruction set was refined through multiple tests. After testing passes, we can package it as a Skill and set up scheduled tasks for automatic execution.

3. FMZ Platform: Signal Receiving Code

With AI decisions ready, we now need to write corresponding code on the FMZ platform to implement signal reception, trade execution, and risk management.

3.1 Configuration Parameters
First, define core configuration items to centrally manage trading, monitoring, and risk control parameters. The UUID must match the one in ClawdBot's instructions:

const CONFIG = {
    TRADE_AMOUNT: 0.01,           // Fixed trading amount per transaction
    CHECK_INTERVAL: 3000,         // Signal monitoring and risk check interval (milliseconds)
    UUID: "CustomUUID",           // Channel identifier matching ClawdBot, serves as communication key
    STOP_LOSS_PERCENT: 5,         // Stop-loss/FOMO protection percentage (%)
};

3.2 Signal Reception and Deduplication
Use FMZ platform's built-in GetChannelData function to monitor the specified UUID channel and retrieve AI-sent JSON signals. An important detail: use timestamps to determine if a signal has been processed, preventing duplicate execution due to network or platform issues:

function receiveSignal() {
    try {
        const res = GetChannelData(CONFIG.UUID);

        if (res === null || res === "") {
            return null;
        }

        const signal = typeof res === 'string' ? JSON.parse(res) : res;

        // Validate signal format, ensure core fields are complete
        if (!signal.coin || !signal.trade_decision) {
            Log("❌ Invalid signal format, missing core fields");
            return null;
        }

        // Check if timestamp has been processed (core deduplication logic)
        if (isSignalProcessed(signal.timestamp)) {
            return null;
        }

        Log(`📥 New signal received: ${signal.coin} - ${signal.trade_decision}`);
        return signal;

    } catch (e) {
        Log(`❌ Failed to get signal: ${e.message}`);
        return null;
    }
}

3.3 Trade Execution Logic
Parse the core content from signals and execute corresponding buy/sell operations based on the trade_decision field. Before buying, check if USDT balance is sufficient; before selling, check if target cryptocurrency balance is sufficient to avoid trade failures due to insufficient balance:

function executeBuy(signal, reason) {
    const symbol = signal.coin + "_USDT"; // Construct trading pair, e.g., BTC_USDT
    exchange.SetCurrency(symbol); // Set current trading pair

    const account = _C(exchange.GetAccount); // Get real-time account assets
    const ticker = _C(exchange.GetTicker); // Get real-time market data
    const currentPrice = ticker.Last; // Get latest transaction price

    // Check sufficient funds
    const requiredBalance = currentPrice * CONFIG.TRADE_AMOUNT;
    if (account.Balance < requiredBalance) {
        Log(`❌ Insufficient balance, need USDT $${requiredBalance.toFixed(2)}, current $${account.Balance.toFixed(2)}`);
        return false;
    }

    // Execute market buy (-1 means market order, transact at current market price)
    const orderId = exchange.Buy(-1, CONFIG.TRADE_AMOUNT * currentPrice);

    if (orderId) {
        addTradeRecord({
            coin: signal.coin,
            action: "Buy",
            price: currentPrice,
            amount: CONFIG.TRADE_AMOUNT,
            reason: reason
        });
        Log(`✅ ${signal.coin} market buy successful, transaction price: $${currentPrice.toFixed(2)}`);
        return true;
    }
    Log(`❌ ${signal.coin} buy failed, no order ID generated`);
    return false;
}

function executeSell(signal, reason) {
    try {
        const symbol = signal.coin + "_USDT";
        exchange.SetCurrency(symbol);

        const account = _C(exchange.GetAccount);
        const ticker = _C(exchange.GetTicker);
        const currentPrice = ticker.Last;

        // Check sufficient target cryptocurrency
        if (account.Stocks < CONFIG.TRADE_AMOUNT) {
            Log(`❌ ${signal.coin} insufficient balance, need ${CONFIG.TRADE_AMOUNT}, current ${account.Stocks.toFixed(6)}`);
            return false;
        }

        // Execute market sell
        const orderId = exchange.Sell(-1, CONFIG.TRADE_AMOUNT);

        if (orderId) {
            // Add trade record to platform
            addTradeRecord({
                coin: signal.coin,
                action: "Sell",
                price: currentPrice,
                amount: CONFIG.TRADE_AMOUNT,
                reason: reason || signal.decision_reason,
                timestamp: new Date().toISOString()
            });

            Log(`✅ ${signal.coin} market sell successful - Price: $${currentPrice.toFixed(2)}, Amount: ${CONFIG.TRADE_AMOUNT}`);
            return true;
        } else {
            Log(`❌ ${signal.coin} sell failed, no order ID generated`);
            return false;
        }

    } catch (e) {
        Log(`❌ Sell exception: ${e.message}`);
        return false;
    }
}

3.4 Stop-Loss Risk Control Mechanism
The code sets a fixed stop-loss percentage. When market price hits the preset stop-loss line, it automatically executes reverse trading operations. This covers two core scenarios—loss stop-loss and FOMO stop-loss—for comprehensive risk control:

function checkStopLoss() {
    const latestTrade = getLatestTradeRecord(); // Get latest trade record

    if (!latestTrade) return { triggered: false }; // Skip risk check if no trade records

    const ticker = _C(exchange.GetTicker);
    const currentPrice = ticker.Last;
    const tradePrice = latestTrade.price; // Latest trade's transaction price
    const priceChangePercent = ((currentPrice - tradePrice) / tradePrice) * 100; // Price change percentage

    // Scenario 1: Price drops after buying, trigger loss stop-loss to limit maximum loss
    if (latestTrade.action === "Buy") {
        const stopLossPrice = tradePrice * (1 - CONFIG.STOP_LOSS_PERCENT / 100); // Calculate stop-loss price

        if (currentPrice <= stopLossPrice) {
            Log(`🔴 Loss stop-loss triggered! Current drop: ${priceChangePercent.toFixed(2)}%, hit ${CONFIG.STOP_LOSS_PERCENT}% stop-loss line`);
            return {
                triggered: true,
                action: "Sell",
                reason: `Stop-loss sell: Drop triggered ${CONFIG.STOP_LOSS_PERCENT}% stop-loss line, current drop ${priceChangePercent.toFixed(2)}%`
            };
        }
    }

    // Scenario 2: Price rises after selling, trigger FOMO stop-loss to avoid missing major rallies
    if (latestTrade.action === "Sell") {
        const stopLossPrice = tradePrice * (1 + CONFIG.STOP_LOSS_PERCENT / 100); // Calculate FOMO protection price

        if (currentPrice >= stopLossPrice) {
            Log(`🟢 FOMO stop-loss triggered! Current rise: ${priceChangePercent.toFixed(2)}%, hit ${CONFIG.STOP_LOSS_PERCENT}% protection line`);
            return {
                triggered: true,
                action: "Buy",
                reason: `FOMO stop-loss: Rise triggered ${CONFIG.STOP_LOSS_PERCENT}% protection line, current rise ${priceChangePercent.toFixed(2)}%`
            };
        }
    }

    return { triggered: false };
}

3.5 Main Loop Logic
The strategy's core is an infinite loop that processes stop-loss checks, AI signal handling, and dashboard updates in sequence following a risk-first principle, ensuring risk control always has the highest priority:

function main() {
    initialize(); // Initialize: create trade records, dashboard, etc.
    Log("🚀 Spot auto-trading bot started, listening for AI signals...");

    while (true) { // Infinite loop, continuous operation
        // 1. Check stop-loss (highest priority), execute immediately if triggered
        const stopLossInfo = checkStopLoss();
        if (stopLossInfo.triggered) {
            executeStopLoss(stopLossInfo);
        }

        // 2. Get and process AI signals, skip if no signal
        const signal = receiveSignal();
        if (signal) {
            processSignal(signal);
        }

        // 3. Update visual dashboard in real-time
        displayDashboard();

        // 4. Wait for preset interval, enter next check cycle
        Sleep(CONFIG.CHECK_INTERVAL);
    }
}

3.6 Visual Display
Running trades alone isn't intuitive enough. We've also created a visual dashboard with four core data tables, presenting account, risk control, signals, and trade records in one place for clear system status visibility:

4. Automated Execution

Once ClawdBot instructions are debugged and FMZ platform code is tested successfully, the system can run fully automatically: Package the written instructions as a Skill (reusable AI operation template) in ClawdBot's backend, and set up scheduled tasks (e.g., execute every 10 minutes). The system will automatically collect data, analyze decisions, and send signals at the set frequency, while FMZ platform listens in real-time and executes trades—all without manual monitoring.

5. Precautions and Risk Warnings

Here's a special reminder: Quantitative trading always carries market risks, and AI decisions are not absolutely accurate. Please note the following before operating:

AI decisions are for reference only—its analysis is based on public data and preset logic, and you cannot completely rely on it for investment decisions;
Although stop-loss mechanisms are in place, the strategy may fail under extreme market conditions (such as flash crashes), unable to completely avoid losses;
It's recommended to test with paper trading or small amounts first, running at least 1-2 trading cycles to verify system stability before gradually increasing investment;
Pay attention to risk isolation—it's recommended to use separate trading accounts and devices for operations to avoid exposing account information and UUID communication keys;
Regularly check strategy operation status, review trading logs and platform error messages to ensure all ClawdBot and FMZ platform modules are working properly;
Trading logs can serve as feedback data to optimize ClawdBot instruction decision logic and FMZ platform risk control parameters for continuous system iteration.

ClawdBot Hands-On Experience: The Era of AI-Written Trading Strategies Has Arrived

Dream — Thu, 05 Feb 2026 05:30:56 +0000

Recently, something called ClawdBot (OpenClaw) has completely taken off in AI circles—it's not just an ordinary chatbot, but a "personal assistant" that can directly operate your computer. As a quantitative trading enthusiast, the first thought that popped into my head was: Can this thing help me with quant trading?

Today, let's run a real test by combining ClawdBot with FMZ Quant Platform to see how much work this "AI personal assistant" can actually handle in strategy development.

Step 1: Installation and First Meeting

The installation process was simpler than expected. I tried it on macOS—basically one command line and following the official guide got it done.

After launching, a clean Dashboard interface appeared—this is the main battlefield for communicating with AI. It supports multiple channels including Lark, Slack, and WhatsApp, with both text and voice options, quite flexible. Looking at AI's first reply, my quantitative personal assistant was officially on duty.

Challenge Begins: Let's Have AI Write a Strategy

Without hesitation, I went straight to the challenge. I gave ClawdBot its first task: "Write a dual moving average quantitative strategy." I chose this because the logic is clean: buy when the short-term moving average crosses above the long-term one (golden cross), sell when it crosses below (death cross). Classic, clear, perfect for testing AI's coding ability.

Once the instruction was sent, this "digital colleague" got to work. I watched it automatically open a browser, head straight to FMZ Quant Platform, find the strategy editor, and then—start writing code.

The whole process was surprisingly smooth. It clearly understood FMZ's API, with clean code structure: first set parameters (5-day short-term, 20-day long-term, 0.01 per trade), then write utility functions for getting moving averages, initialize charts in the main function, use loops to continuously fetch K-lines, calculate indicators, execute trades, and even added visualization as a bonus. After finishing, it even included a detailed logic explanation—definitely beginner-friendly.

Backtesting and First Debugging

Writing code isn't enough—you have to put it to the test. I told it: "Use Binance exchange, BTC/USDT trading pair, daily data, run a backtest."

AI switched to the backtest page, configured parameters, clicked run—and got an error! Just as I was thinking "guess I'll have to do this myself," it located the error on its own, proactively fixed a syntax issue, and resubmitted.

This time it ran successfully, but the results were... a bit dismal. However, it didn't stop there—it immediately generated a backtest report: return rate, maximum drawdown, win rate, analysis of typical losing trades—data at a glance. The report also initially identified various areas for optimization.

Strategy Optimization: Multi-Step Coordinated Operations

The backtest results weren't ideal, so let's have AI optimize it. I proposed a complex requirement: change the exchange and trading pair, while adjusting and optimizing moving average period parameters to see if performance could improve. This task involves coordinated operations across multiple steps.

After AI started executing, it first proposed specific optimization ideas based on the previous backtest results, then returned to the strategy editing page for modifications: changed the exchange to OKX, trading pair to ETH/USDT, and moving average periods from 5 and 20 to 10 and 50. What surprised me more was that it proactively added ATR volatility filtering and dynamic stop-loss logic—things I hadn't explicitly requested.

Then it returned to the editor and implemented the changes step by step. After modifications, it automatically re-ran the backtest—this time the return curve was much smoother, achieving positive returns. Finally, it generated a comparison analysis between old and new versions and provided suggestions for further optimization, such as considering increased position sizing, parameter and logic optimization, multi-asset portfolios, etc. These suggestions were all quite pertinent, showing that AI truly understands the basic logic of quantitative trading.

Wrapping Up: Let AI Organize Development Notes

Finally, a practical task: "Organize today's process from strategy writing to optimization debugging into reusable development documentation." It quickly organized a clearly structured note including: strategy version iteration records, reasoning for each modification, backtest data comparison, and potential next optimization directions—directly a qualified technical log.

Post-Use Impressions

After the complete test, the role ClawdBot plays in the quantitative workflow is that of a qualified quantitative trading assistant. While it can't replace your experience and judgment, it can efficiently execute many standardized operations.

Its advantages include:

Quick idea implementation: From strategy description to runnable code in just a few minutes
High debugging efficiency: Automatically locates errors, compares version differences, generates data reports
Knowledge base support: Familiar with common strategy patterns, risk control methods, and platform APIs
Tireless: Can simultaneously backtest multiple parameter combinations or monitor multiple strategy statuses

But there are also clear limitations:

Depends on clear instructions: Vague requirements lead to output deviations
Superficial market understanding: It understands code logic but not market sentiment and macro changes
Requires human review: After each important modification, logic reasonableness still needs human verification

In actual use, the smoothest mode is: you grasp direction and risk control, it handles execution and debugging. For example, when you think "maybe adding volatility filtering would be better," it can immediately implement this idea and verify the effect; when you find the strategy loses money during sideways markets, it can quickly test multiple parameter combinations to find more robust configurations.

This collaboration model is particularly suitable for high-repetition tasks like strategy prototyping, quick backtest verification, and parameter tuning. It lets quantitative developers focus more on core logic and market insights, rather than getting bogged down in code debugging and data organization.

Building A Multi-Account Walkthrough System That Supports MyLanguage and Pine Strategy Language Based on FMZ

Dream — Mon, 02 Feb 2026 07:13:47 +0000

Demand Scenarios of Walkthrough System

I was often asked this question in the FMZ platform community and in private communication with users:

"Why can strategies written in MyLanguage or Pine scripts always only control one account and one product?"

The essence of this problem lies in the design positioning of the language itself. MyLanguage and Pine language are highly encapsulated scripting languages, and their underlying implementation is based on JavaScript. In order to allow users to quickly get started and focus on strategy logic, both have done a lot of encapsulation and abstraction at the language level, but this has also sacrificed a certain degree of flexibility: by default, only single-account, single-product strategy execution models are supported.

When users want to run multiple accounts in live trading, they can only do so by running multiple Pine or MyLanguage live trading instances. This approach is acceptable when the number of accounts is small, but if multiple instances are deployed on the same docker, a large number of API requests will be generated, and the exchange may even restrict access due to excessive request frequency, bringing unnecessary live trading risks.

So, is there a more elegant way to copy the trading behavior of other accounts automatically by just running a Pine or MyLanguage script?

The answer is: Yes.

This article will guide you through building a cross-account, cross-product walkthrough system from scratch, which is compatible with My and Pine language strategies. Through the Leader-Subscriber architecture, it will implement an efficient, stable, and scalable multi-account synchronous trading framework to solve the various disadvantages you encounter in live trading deployment.

Strategy Design

The program is designed and written in JavaScript, and the program architecture uses the Leader-Subscriber model.

Strategy source code:

/*backtest
start: 2024-05-21 00:00:00
end: 2025-05-20 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Futures_Binance","currency":"ETH_USDT"},{"eid":"Futures_Binance","currency":"ETH_USDT"},{"eid":"Futures_Binance","currency":"ETH_USDT","balance":10000}]
args: [["isBacktest",true]]
*/

class Leader {
    constructor(leaderCfg = { type: "exchange", apiClient: exchanges[0] }) {
        // Account managed with trading signals configuration
        this.leaderCfg = leaderCfg
        // Cache the last position information for comparison
        this.lastPos = null
        // Record current position information
        this.currentPos = null
        // Record subscribers
        this.subscribers = []

        // According to the leaderCfg configuration, determine which monitoring solution to use: 1. Monitor the account managed with trading signals directly. 2. Monitor the data of the live trading strategy of the account managed with trading signals through the FMZ extended API. 3. Walkthrough through the message push mechanism. The default solution is 1.

        // initialization
        let ex = this.leaderCfg.apiClient
        let currency = ex.GetCurrency()
        let arrCurrency = currency.split("_")
        if (arrCurrency.length !== 2) {
            throw new Error("The account managed with trading signals configuration is wrong, it must be two currency pairs")
        }
        this.baseCurrency = arrCurrency[0]
        this.quoteCurrency = arrCurrency[1]
        // Get the total equity of the account managed with trading signals at initialization
        this.initEquity = _C(ex.GetAccount).Equity
        this.currentPos = _C(ex.GetPositions)
    }

    // Monitoring leader logic
    poll() {
        // Get the exchange object
        let ex = this.leaderCfg.apiClient

        // Get the leader's position and account asset data
        let pos = ex.GetPositions()
        if (!pos) {
            return
        }
        this.currentPos = pos

        // Call the judgment method to determine the position changes
        let { hasChanged, diff } = this._hasChanged(pos)
        if (hasChanged) {
            Log("Leader position changes, current position:", pos)
            Log("Position changes:", diff)
            // Notify Subscribers
            this.subscribers.forEach(subscriber => {
                subscriber.applyPosChanges(diff)
            })
        }

        // Synchronous positions
        this.subscribers.forEach(subscriber => {
            subscriber.syncPositions(pos)
        })
    }

    // Determine whether the position has changed
    _hasChanged(pos) {
        if (this.lastPos) {
            // Used to store the results of position differences
            let diff = {
                added: [],    // Newly added positions
                removed: [],  // Removed positions
                updated: []   // Updated positions (amount or price changes)
            }

            // Convert the last position and the current position into a Map, with the key being `symbol + direction` and the value being the position object
            let lastPosMap = new Map(this.lastPos.map(p => [`${p.Symbol}|${p.Type}`, p]))
            let currentPosMap = new Map(pos.map(p => [`${p.Symbol}|${p.Type}`, p]))

            // Traverse the current positions and find new and updated positions
            for (let [key, current] of currentPosMap) {
                if (!lastPosMap.has(key)) {
                    // If the key does not exist in the last position, it is a new position.
                    diff.added.push({ symbol: current.Symbol, type: current.Type, deltaAmount: current.Amount })
                } else {
                    // If it exists, check if the amount or price has changed
                    let last = lastPosMap.get(key)
                    if (current.Amount !== last.Amount) {
                        diff.updated.push({ symbol: current.Symbol, type: current.Type, deltaAmount: current.Amount - last.Amount })
                    }
                    // Remove from lastPosMap, and what remains is the removed position
                    lastPosMap.delete(key)
                }
            }

            // The remaining keys in lastPosMap are the removed positions.
            for (let [key, last] of lastPosMap) {
                diff.removed.push({ symbol: last.Symbol, type: last.Type, deltaAmount: -last.Amount })
            }

            // Determine if there is a change
            let hasChanged = diff.added.length > 0 || diff.removed.length > 0 || diff.updated.length > 0

            // If there is a change, update lastPos
            if (hasChanged) {
                this.lastPos = pos
            }

            return { hasChanged: hasChanged, diff: diff }
        } else {
            // If there is no last position record, update the record and do not synchronize positions
            this.lastPos = pos
            return { hasChanged: false, diff: { added: [], removed: [], updated: [] } }

            /* Another solution: synchronize positions
            if (pos.length > 0) {
                let diff = {
                    added: pos.map(p => ({symbol: p.Symbol, type: p.Type, deltaAmount: p.Amount})),
                    removed: [],
                    updated: []
                }
                return {hasChanged: true, diff: diff}
            } else {
                return {hasChanged: false, diff: {added: [], removed: [], updated: []}}
            }
            */
        }
    }

    // Subscriber registration
    subscribe(subscriber) {
        if (this.subscribers.indexOf(subscriber) === -1) {
            if (this.quoteCurrency !== subscriber.quoteCurrency) {
                throw new Error("Subscriber currency pair does not match, current leader currency pair: " + this.quoteCurrency + ", subscriber currency pair:" + subscriber.quoteCurrency)
            }
            if (subscriber.followStrategy.followMode === "equity_ratio") {
                // Set the ratio of account managed with trading signals
                let ex = this.leaderCfg.apiClient
                let equity = _C(ex.GetAccount).Equity
                subscriber.setEquityRatio(equity)
            }
            this.subscribers.push(subscriber)
            Log("Subscriber registration is successful, subscription configuration:", subscriber.getApiClientInfo())
        }
    }

    // Unsubscribe
    unsubscribe(subscriber) {
        const index = this.subscribers.indexOf(subscriber)
        if (index !== -1) {
            this.subscribers.splice(index, 1)
            Log("Subscriber unregistration successful, subscription configuration:", subscriber.getApiClientInfo())
        } else {
            Log("Subscriber unregistration failed, subscription configuration:", subscriber.getApiClientInfo())
        }
    }

    // Get UI information
    fetchLeaderUI() {
        // Information of the trade order issuer
        let tblLeaderInfo = { "type": "table", "title": "Leader Info", "cols": ["order trade plan", "denominated currency", "number of walkthrough followers", "initial total equity"], "rows": [] }
        tblLeaderInfo.rows.push([this.leaderCfg.type, this.quoteCurrency, this.subscribers.length, this.initEquity])

        // Construct the display information of the trade order issuer: position information
        let tblLeaderPos = { "type": "table", "title": "Leader pos", "cols": ["trading product", "direction", "amount", "price"], "rows": [] }
        this.currentPos.forEach(pos => {
            let row = [pos.Symbol, pos.Type == PD_LONG ? "long" : "short", pos.Amount, pos.Price]
            tblLeaderPos.rows.push(row)
        })

        // Construct the display information of the subscriber
        let strFollowerMsg = ""
        this.subscribers.forEach(subscriber => {
            let arrTbl = subscriber.fetchFollowerUI()
            strFollowerMsg += "`" + JSON.stringify(arrTbl) + "`\n"
        })

        return "`" + JSON.stringify([tblLeaderInfo, tblLeaderPos]) + "`\n" + strFollowerMsg
    }

    // Expand functions such as pausing walkthrough trading and removing subscriptions
}

class Subscriber {
    constructor(subscriberCfg, followStrategy = { followMode: "position_ratio", ratio: 1, maxReTries: 3 }) {
        this.subscriberCfg = subscriberCfg
        this.followStrategy = followStrategy

        // initialization
        let ex = this.subscriberCfg.apiClient
        let currency = ex.GetCurrency()
        let arrCurrency = currency.split("_")
        if (arrCurrency.length !== 2) {
            throw new Error("Subscriber configuration error, must be two currency pairs")
        }
        this.baseCurrency = arrCurrency[0]
        this.quoteCurrency = arrCurrency[1]

        // Initial acquisition of position data
        this.currentPos = _C(ex.GetPositions)
    }

    setEquityRatio(leaderEquity) {
        // {followMode: "equity_ratio"} Automatically follow orders based on account equity ratio
        if (this.followStrategy.followMode === "equity_ratio") {
            let ex = this.subscriberCfg.apiClient
            let equity = _C(ex.GetAccount).Equity
            let ratio = equity / leaderEquity
            this.followStrategy.ratio = ratio
            Log("Rights and interests of the trade order issuer:", leaderEquity, "Subscriber benefits:", equity)
            Log("Automatic setting, subscriber equity ratio:", ratio)
        }
    }

    // Get the API client information bound to the subscriber
    getApiClientInfo() {
        let ex = this.subscriberCfg.apiClient
        let idx = this.subscriberCfg.clientIdx
        if (ex) {
            return { exName: ex.GetName(), exLabel: ex.GetLabel(), exIdx: idx, followStrategy: this.followStrategy }
        } else {
            throw new Error("The subscriber is not bound to the API client")
        }
    }

    // Returns the transaction direction parameters according to the position type and position changes
    getTradeSide(type, deltaAmount) {
        if (type == PD_LONG && deltaAmount > 0) {
            return "buy"
        } else if (type == PD_LONG && deltaAmount < 0) {
            return "closebuy"
        } else if (type == PD_SHORT && deltaAmount > 0) {
            return "sell"
        } else if (type == PD_SHORT && deltaAmount < 0) {
            return "closesell"
        }

        return null
    }

    getSymbolPosAmount(symbol, type) {
        let ex = this.subscriberCfg.apiClient
        if (ex) {
            let pos = _C(ex.GetPositions, symbol)
            if (pos.length > 0) {
                // Traverse the positions and find the corresponding symbol and type
                for (let i = 0; i < pos.length; i++) {
                    if (pos[i].Symbol === symbol && pos[i].Type === type) {
                        return pos[i].Amount
                    }
                }
            }
            return 0
        } else {
            throw new Error("The subscriber is not bound to the API client")
        }
    }

    // Retry order
    tryCreateOrder(ex, symbol, side, price, amount, label, maxReTries) {
        for (let i = 0; i < Math.max(maxReTries, 1); i++) {
            let orderId = ex.CreateOrder(symbol, side, price, amount, label)
            if (orderId) {
                return orderId
            }
            Sleep(1000)
        }
        return null
    }

    // Synchronous position changes
    applyPosChanges(diff) {
        let ex = this.subscriberCfg.apiClient
        if (ex) {
            ["added", "removed", "updated"].forEach(key => {
                diff[key].forEach(item => {
                    let side = this.getTradeSide(item.type, item.deltaAmount)
                    if (side) {
                        // Calculate the walkthrough trading ratio
                        let ratio = this.followStrategy.ratio
                        let tradeAmount = Math.abs(item.deltaAmount) * ratio
                        if (side == "closebuy" || side == "closesell") {
                            // Get the number of positions to check
                            let posAmount = this.getSymbolPosAmount(item.symbol, item.type)
                            tradeAmount = Math.min(posAmount, tradeAmount)
                        }
                        // Order Id
                        // let orderId = ex.CreateOrder(item.symbol, side, -1, tradeAmount, ex.GetLabel())
                        let orderId = this.tryCreateOrder(ex, item.symbol, side, -1, tradeAmount, ex.GetLabel(), this.followStrategy.maxReTries)
                        // Check the Order Id
                        if (orderId) {
                            Log("The subscriber successfully placed an order, order ID:", orderId, ", Order direction:", side, ", Order amount:", Math.abs(item.deltaAmount), ", walkthrough order ratio (times):", ratio)
                        } else {
                            Log("Subscriber order failed, order ID: ", orderId, ", order direction: ", side, ", order amount: ", Math.abs(item.deltaAmount), ", walkthrough order ratio (times): ", ratio)
                        }
                    }
                })
            })

            // Update current position
            this.currentPos = _C(ex.GetPositions)
        } else {
            throw new Error("The subscriber is not bound to the API client")
        }
    }

    // Synchronous positions
    syncPositions(leaderPos) {
        let ex = this.subscriberCfg.apiClient
        this.currentPos = _C(ex.GetPositions)

        // Used to store the results of position differences
        let diff = {
            added: [],    // Newly added positions
            removed: [],  // Removed positions
            updated: []   // Updated positions (amount or price changes)
        }
        let leaderPosMap = new Map(leaderPos.map(p => [`${p.Symbol}|${p.Type}`, p]))
        let currentPosMap = new Map(this.currentPos.map(p => [`${p.Symbol}|${p.Type}`, p]))
        // Traverse the current positions and find new and updated positions
        for (let [key, leader] of leaderPosMap) {
            if (!currentPosMap.has(key)) {
                diff.added.push({ symbol: leader.Symbol, type: leader.Type, deltaAmount: leader.Amount })
            } else {
                let current = currentPosMap.get(key)
                if (leader.Amount !== current.Amount) {
                    diff.updated.push({ symbol: leader.Symbol, type: leader.Type, deltaAmount: leader.Amount - current.Amount * this.followStrategy.ratio })
                }
                currentPosMap.delete(key)
            }
        }
        for (let [key, current] of currentPosMap) {
            diff.removed.push({ symbol: current.Symbol, type: current.Type, deltaAmount: -current.Amount * this.followStrategy.ratio })
        }
        // Determine if there is a change
        let hasChanged = diff.added.length > 0 || diff.removed.length > 0 || diff.updated.length > 0
        if (hasChanged) {
            // synchronous
            this.applyPosChanges(diff)
        }
    }

    // Get subscriber UI information
    fetchFollowerUI() {
        // Subscriber information
        let ex = this.subscriberCfg.apiClient
        let equity = _C(ex.GetAccount).Equity
        let exLabel = ex.GetLabel()
        let tblFollowerInfo = { "type": "table", "title": "Follower Info", "cols": ["exchange object index", "exchange object tag", "denominated currency", "walkthrough order mode", "walkthrough order ratio (times)", "maximum retry times", "total equity"], "rows": [] }
        tblFollowerInfo.rows.push([this.subscriberCfg.clientIdx, exLabel, this.quoteCurrency, this.followStrategy.followMode, this.followStrategy.ratio, this.followStrategy.maxReTries, equity])

        // Subscriber position information
        let tblFollowerPos = { "type": "table", "title": "Follower pos", "cols": ["trading product", "direction", "amount", "price"], "rows": [] }
        let pos = this.currentPos
        pos.forEach(p => {
            let row = [p.Symbol, p.Type == PD_LONG ? "long" : "short", p.Amount, p.Price]
            tblFollowerPos.rows.push(row)
        })

        return [tblFollowerInfo, tblFollowerPos]
    }
}

// Test function, simulate random opening, simulate leader position change
function randomTrade(symbol, amount) {
    let randomNum = Math.random()
    if (randomNum < 0.0001) {
        Log("Simulate order managed with trading signals trading", "#FF0000")
        let ex = exchanges[0]
        let pos = _C(ex.GetPositions)

        if (pos.length > 0) {
            // Random close positions
            let randomPos = pos[Math.floor(Math.random() * pos.length)]
            let tradeAmount = Math.random() > 0.7 ? Math.abs(randomPos.Amount * 0.5) : Math.abs(randomPos.Amount)
            ex.CreateOrder(randomPos.Symbol, randomPos.Type === PD_LONG ? "closebuy" : "closesell", -1, tradeAmount, ex.GetLabel())
        } else {
            let tradeAmount = Math.random() * amount
            let side = Math.random() > 0.5 ? "buy" : "sell"
            if (side === "buy") {
                ex.CreateOrder(symbol, side, -1, tradeAmount, ex.GetLabel())
            } else {
                ex.CreateOrder(symbol, side, -1, tradeAmount, ex.GetLabel())
            }
        }
    }
}

// Strategy main loop
function main() {
    let leader = new Leader()

    let followStrategyArr = JSON.parse(strFollowStrategyArr)
    if (followStrategyArr.length > 0 && followStrategyArr.length !== exchanges.length - 1) {
        throw new Error("Walkthrough trading strategy configuration error, walkthrough trading strategy amount and exchange amount do not match")
    }

    for (let i = 1; i < exchanges.length; i++) {
        let subscriber = null
        if (followStrategyArr.length == 0) {
            subscriber = new Subscriber({ apiClient: exchanges[i], clientIdx: i })
        } else {
            let followStrategy = followStrategyArr[i - 1]
            subscriber = new Subscriber({ apiClient: exchanges[i], clientIdx: i }, followStrategy)
        }
        leader.subscribe(subscriber)
    }

    // Start monitoring
    while (true) {
        leader.poll()
        Sleep(1000 * pollInterval)

        // Simulate random transactions
        if (IsVirtual() && isBacktest) {
            randomTrade("BTC_USDT.swap", 0.001)
            randomTrade("ETH_USDT.swap", 0.02)
            randomTrade("SOL_USDT.swap", 0.1)
        }

        LogStatus(_D(), "\n", leader.fetchLeaderUI())
    }
}

Design pattern Previously, we have designed several walkthrough trading strategies on the platform, using process-oriented design. This article is a new design attempt, using object-oriented style and observer design pattern.
Monitoring plan The essence of walkthrough trading is a monitoring behavior, monitoring the target's actions and replicating them when new actions are found.

In this article, only one solution is implemented: configure the exchange object through API KEY, and monitor the position of the target account. In fact, there are two other solutions that can be used, which may be more complicated in design:

Extended API through FMZ
Monitor the log and status bar information of the target live trading, and operate and walkthrough orders according to the changes. The advantage of using this solution is that it can reduce API requests effectively.

Rely on the message push of the target live trading
You can turn on the message push of the target live trading on FMZ, and a message will be pushed when the target live trading has an order operation. The walkthrough trading strategy receives these messages and takes action. The advantages of using this solution are: reducing API requests and changing from a request polling mechanism to an event-driven mechanism.

Walkthrough trading strategy There may be multiple requirements for walkthrough trading strategies, and the strategy framework is designed to be as easy to expand as possible.

Position replication:
Positions can be replicated 1:1, or they can be scaled according to specified scaling parameters.

Equity ratio
The equity ratio of the account managed with trading signals and the walkthrough account can be automatically used as a scaling parameter for walkthrough trading.

Position synchronization In actual use, there may be various reasons that cause the positions of the trade order issuer and the walkthrough trading follower to differ. You can design a system to detect the difference between the walkthrough trading account and the trade order issuer account when walkthrough orders, and synchronize the positions automatically.
Order retry You can specify the specific number of failed order retries in the walkthrough trading strategy.
Backtest random test The function randomTrade(symbol, amount) function in the code is used for random position opening test during backtesting to detect the walkthrough trading effect.

Strategy Backtesting and Verification

According to the first exchange object added (trade order issuer), the subsequent exchange objects added walkthrough order (walkthrough order follower).

In the test, three products are used to place orders randomly to verify the demand for multi-product order following:

randomTrade("BTC_USDT.swap", 0.001)
randomTrade("ETH_USDT.swap", 0.02)
randomTrade("SOL_USDT.swap", 0.1)

Extension and Optimization

Expand the monitoring scheme for data such as positions and account information.
Increase control over subscribers, and add functions such as pausing and unsubscribing of walkthrough trading accounts.
Dynamically update walkthrough trading strategy parameters.
Increase and expand richer walkthrough trading data and information display.

END

This article is just a starting point. It uses object-oriented style and observer mode to design a preliminary walkthrough trading strategy framework. I hope it can provide reference and inspiration for readers. Thank you for your reading and support.