Code Plugin

// If Query Events returns { events: [...] }, this becomes valid JS:
const events = {{QueryEvents.events}};
// Resolves to: const events = [{"from":"0x...","value":100}, ...];

const response = await fetch("https://api.example.com/prices");
if (!response.ok) {
  throw new Error(`Request failed with ${response.status}`);
}
const prices = await response.json();

sandbox fetch: SSRF blocked (hostname -> resolved_ip)

Trigger (Event: Transfer)
-> Query Events: get recent transfers

-> Run Code (Analyze Transfers):
     const events = {{QueryEvents.events}};
     const threshold = BigInt('1000000000000000000'); // 1 ETH in wei
     const large = events.filter(e => BigInt(e.value) > threshold);
     const total = large.reduce((sum, e) => sum + BigInt(e.value), 0n);
     return {
       count: large.length,
       total: total.toString(),
       addresses: large.map(e => e.from)
     };

-> Condition: {{@code:Run Code.result.count}} > 0
-> Discord: "{{@code:Run Code.result.count}} large transfers totaling {{@code:Run Code.result.total}} wei"

Trigger (Schedule, every 5m)
-> Read Contract (Oracle): latestAnswer on price feed

-> Run Code (Enrich Price):
     const onChainPrice = {{ReadContract.result}};
     const res = await fetch('https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd');
     const data = await res.json();
     const marketPrice = data.ethereum.usd;
     const oraclePrice = Number(onChainPrice) / 1e8;
     const deviation = Math.abs(oraclePrice - marketPrice) / marketPrice * 100;
     return {
       oraclePrice: oraclePrice.toFixed(2),
       marketPrice: marketPrice.toFixed(2),
       deviationPct: deviation.toFixed(2)
     };

-> Condition: {{@code:Run Code.result.deviationPct}} > 5
-> Discord: "Oracle deviation: {{@code:Run Code.result.deviationPct}}% (oracle: ${{@code:Run Code.result.oraclePrice}}, market: ${{@code:Run Code.result.marketPrice}})"

Trigger (Webhook)
-> Database Query: get user preferences
-> Read Contract: get current token balance

-> Run Code (Build Alert):
     const user = {{DatabaseQuery.rows}}[0];
     const balance = {{ReadContract.result}};
     const balanceEth = (Number(balance) / 1e18).toFixed(4);
     const timestamp = new Date().toISOString();
     const msg = [
       `Wallet: ${user.wallet_address}`,
       `Balance: ${balanceEth} ETH`,
       `Threshold: ${user.alert_threshold} ETH`,
       `Time: ${timestamp}`
     ].join('\n');
     return { message: msg, shouldAlert: Number(balanceEth) < user.alert_threshold };

-> Condition: {{@code:Run Code.result.shouldAlert}} == true
-> SendGrid: send email with {{@code:Run Code.result.message}}

Trigger (Schedule, hourly)
-> Query Events: get last hour of Swap events

-> Run Code (Process Swaps):
     const swaps = {{QueryEvents.events}};
     // Deduplicate by transaction hash
     const seen = new Set();
     const unique = swaps.filter(s => {
       if (seen.has(s.transactionHash)) return false;
       seen.add(s.transactionHash);
       return true;
     });
     // Sort by value descending
     unique.sort((a, b) => Number(BigInt(b.value) - BigInt(a.value)));
     // Take top 10
     const top = unique.slice(0, 10).map((s, i) => ({
       rank: i + 1,
       tx: s.transactionHash,
       value: (Number(s.value) / 1e18).toFixed(4)
     }));
     return { total: unique.length, duplicatesRemoved: swaps.length - unique.length, top };

-> Discord: "{{@code:Run Code.result.total}} unique swaps ({{@code:Run Code.result.duplicatesRemoved}} dupes removed)"

Trigger (Webhook): receives { "alerts": [...], "source": "grafana" }

-> Run Code (Transform):
     const payload = {{Webhook.input}};
     const alerts = payload.alerts || [];
     const critical = alerts.filter(a => a.severity === 'critical');
     const summary = critical.map(a => ({
       title: a.labels.alertname,
       description: a.annotations.description,
       startsAt: a.startsAt
     }));
     // Base64 encode for downstream API that expects it
     const encoded = btoa(JSON.stringify(summary));
     return { count: critical.length, summary, encoded };

-> Condition: {{@code:Run Code.result.count}} > 0
-> HTTP Request: POST to incident API with body {{@code:Run Code.result.encoded}}

Trigger (Schedule, daily)
-> Database Query: get monitored addresses with labels
-> For Each: iterate addresses
   -> Read Contract (Balance): balanceOf for each address

-> Run Code (Join Results):
     const addresses = {{DatabaseQuery.rows}};
     const balances = {{ForEach.results}};
     const report = addresses.map((addr, i) => {
       const bal = balances[i]?.result ?? '0';
       const balFormatted = (Number(bal) / 1e18).toFixed(4);
       return { label: addr.label, address: addr.address, balance: balFormatted };
     });
     const totalBal = report.reduce((s, r) => s + parseFloat(r.balance), 0);
     report.sort((a, b) => parseFloat(b.balance) - parseFloat(a.balance));
     return { report, totalBalance: totalBal.toFixed(4), walletCount: report.length };

-> Discord: "Daily report: {{@code:Run Code.result.walletCount}} wallets, total {{@code:Run Code.result.totalBalance}} ETH"

Trigger (Event: Transfer)
-> Database Query: get last 24h transfer values

-> Run Code (Detect Anomaly):
     const history = {{DatabaseQuery.rows}};
     const currentValue = {{Trigger.value}};
     if (history.length < 5) {
       return { isAnomaly: false, reason: 'insufficient data' };
     }
     const values = history.map(r => Number(r.value));
     const mean = values.reduce((s, v) => s + v, 0) / values.length;
     const variance = values.reduce((s, v) => s + (v - mean) ** 2, 0) / values.length;
     const stdDev = Math.sqrt(variance);
     const zScore = Math.abs((Number(currentValue) - mean) / stdDev);
     return {
       isAnomaly: zScore > 3,
       zScore: zScore.toFixed(2),
       mean: mean.toFixed(2),
       stdDev: stdDev.toFixed(2),
       currentValue: Number(currentValue).toFixed(2)
     };

-> Condition: {{@code:Run Code.result.isAnomaly}} == true
-> Discord: "Anomaly detected: value {{@code:Run Code.result.currentValue}} (z-score: {{@code:Run Code.result.zScore}}, mean: {{@code:Run Code.result.mean}})"