I Built an AI That Gambles, Recovers From Losses, and Tunes Itself Every 5 Minutes — Here's Everything

Over the past few weeks I built something I never thought I'd finish: a fully autonomous Mines bot for Rainbet that not only plays by itself, but uses Claude AI to tune its own strategy every 5 minutes based on live performance data.

This isn't a get-rich-quick story. It's a story about systems thinking, probability, and what happens when you let an AI manage another AI.

The Game

Rainbet Mines is simple on the surface. You have a 49-tile grid with a configurable number of hidden mines. You bet, pick a tile, and if it's safe you can either cash out or keep going. Hit a mine and you lose everything.

The key insight is this: the fewer tiles you reveal, the safer the bet. Revealing just 1 tile on a 10-mine board gives you a 79.6% win chance at 1.21x multiplier. That's your baseline — a slightly negative EV game with a house edge baked in.

So why build a bot? Because the edge isn't in a single bet. It's in the system around it.

The Architecture

The bot runs as a Chrome extension content script in MAIN world context, meaning it has full access to the page's JavaScript environment while also having access to Chrome extension APIs. All communication with the Claude API routes through a background service worker to avoid CORS restrictions.

The core loop is simple:

1. Place a bet on 10/49 mines (scales with balance from $0.10 to $1.00+)

2. Reveal 1 tile

3. Cash out immediately

4. Split the profit: 20% to bankroll, 20% to bonus pot, 60% to loss buffer

5. Repeat

That profit split is the heart of the system.

The Loss Buffer

Every win quietly builds a loss buffer. When a loss happens, the buffer absorbs it first — the bankroll never even notices. This means a single loss in a 79.6% win-rate game is usually invisible.

The buffer only runs out after several consecutive losses. That's when the recovery chain kicks in.

The Recovery Chain

When the buffer hits zero, the bot doesn't panic. It first runs 3 quick attempts on a 39/49 mine board (20.4% win chance, ~4.6x multiplier) before escalating. If any of those 3 hits, the streak is cleared and we're back to normal.

If all 3 fail, the recovery chain begins. Each tier is sized to recover all previous losses in a single win:

Loss 1   16 mines  x1.43  67.3% win
Loss 2   20 mines  x1.62  59.2% win  → resets here if balance < $100
T3a      16 mines  x1.43  67.3% win  → resets here if balance < $400
T4       30 mines  x2.48  38.8% win  ($5 flat)
T5       35 mines  x3.36  28.6% win  ($5 flat)
T6       40 mines  18.4% win         ($5 flat)
Hail     45 mines   8.2% win         ($5 flat)
RESET → accept the loss, back to normal

Budget caps prevent the chain from going too deep relative to your balance:

• Under $100 → resets after Loss 2 (max loss ~$4)

• Under $400 → resets after T3a (max loss ~$14–$43)

• Over $400 → full chain allowed

The Bonus System

The bonus pot slowly fills with 20% of every win. When it reaches a threshold, the bot fires a single high-stakes bet on the 39/49 grid.

The threshold scales with your balance:

< $100  → fires at $10, bets $10
< $300  → fires at $20, bets $20
< $400  → fires at $30, bets $30
< $500  → fires at $40, bets $40
  $500+ → fires at $50, bets $50

At $0.10 base bet the bonus fires roughly once every 2,381 wins — rare enough to be meaningful, frequent enough to add real upside.

The Claude AI Tuner

Every 5 minutes the bot sends a live snapshot of its session to Claude via the Anthropic API:

• Win rate, loss rate, consecutive losses

• Current bankroll, peak, net P/L

• Buffer absorb count, reset count

• Tile intelligence (which tiles have been safe or dangerous)

Claude analyzes the data and adjusts parameters live:

• bonusPotShare — how much profit goes to the bonus pot

• lossBufferShare — how much profit goes to the loss buffer

• delayMs — time between bets

If the win rate drops, Claude shifts more profit into the buffer. If the session is healthy and profitable, it can redirect more to the bonus pot for bigger payouts. The bot literally tunes itself.

The Command Interface

The bot exposes a full command interface through the browser console. Type botHelp() to see:

╔══════════════════════════════════════════════════╗
║         RAINBET MINES BOT v18.0                  ║
╠══════════════════════════════════════════════════╣
║  Normal: 10/49 mines | 79.6% win | x1.21        ║
║  Bonus: 39/49 mines | scales with bankroll       ║
║  Split: 20% bank / 20% pot / 60% buffer          ║
╠══════════════════════════════════════════════════╣
║  ── BOT CONTROL ──────────────────────────────   ║
║  runBot()              → start normal bot        ║
║  stopBot()             → stop + save state       ║
║  recoverGrid()         → recover orphaned game   ║
╠══════════════════════════════════════════════════╣
║  ── CLAUDE AI ────────────────────────────────   ║
║  runClaudeMode()       → Claude plays $20→$200   ║
║  testClaude()          → test AI tuner bridge    ║
╠══════════════════════════════════════════════════╣
║  ── WATCHDOG ─────────────────────────────────   ║
║  startWatchdog()       → auto-restart on death   ║
║  stopWatchdog()        → stop watchdog           ║
╠══════════════════════════════════════════════════╣
║  ── LIVE CONFIG ──────────────────────────────   ║
║  setBet(0.10)          → set base bet size       ║
║  setTarget(1000)       → change profit target    ║
║  CONFIG.delayMs = 3000           → bet delay ms  ║
╠══════════════════════════════════════════════════╣
║  ── STATS & LOGS ─────────────────────────────   ║
║  printStats()          → full session stats      ║
║  printLog()            → round-by-round table    ║
║  printFullLog()        → stats + snapshot + log  ║
║  printSnapshot()       → JSON for Claude         ║
║  printTileStats()      → tile mine rate map      ║
║  printHistory()        → last 3 sessions         ║
╠══════════════════════════════════════════════════╣
║  ── RESET ────────────────────────────────────   ║
║  clearSaved()          → wipe localStorage       ║
║  clearHistory()        → wipe session history    ║
║  botHelp()             → this menu               ║
╚══════════════════════════════════════════════════╝

Stats in Action

Here's what printStats() looks like after a session:

And here's printFullLog() showing the round-by-round breakdown — wins, losses, buffer absorbs, recovery chains, and bonus plays:

And here's the bot actually playing on screen:

What I Learned

Building v18 took 18 iterations. Each version fixed something subtle — a tier constant misalignment that caused $70 losses, a win path continue statement that silently dropped win logs, a bankroll sync that corrupted recovery math mid-chain. The bugs were never obvious. They were the kind of bugs that only appear at scale, across thousands of rounds.

The bonus was the villain. In one session the bonus fired 14 times in a row without a single win (0.6% probability). That alone cost $70. The dynamic threshold system was built specifically to make this hurt less.

Recovery math is unforgiving. If your base bet changes mid-chain because your balance dropped a tier, the recovery calculations break. The solution was locking the streakBaseBet at the moment of first loss and using it for all subsequent recovery calculations in that chain.

Letting AI tune AI is strange. There's something philosophically interesting about Claude adjusting the parameters of a bot that's using Claude to adjust its own parameters. The tuner doesn't always make the "right" call, but over time it converges toward something reasonable.

The Numbers

At its peak the bot reached $169 from a starting balance, running cleanly at 82% win rate on normal bets. The losses that hurt came from the bonus — not the recovery chain. With the new threshold system the bonus fires far less often and with more capital behind it.

Try It Yourself

The full source code is open on GitHub:

https://github.com/spuriousdrag0n/rainbet-bot

You'll need:

1. A Rainbet account — use my referral link to sign up: https://playrainbet.com/tlpdkwcjv

2. A Claude API key from console.anthropic.com

3. Chrome browser

Setup is straightforward — clone the repo, add your API key, load the extension in Chrome, navigate to the Mines game and type runBot().

The Claude AI tuner activates automatically and starts adjusting parameters within 5 minutes of your first session.

What's Next

The tile intelligence system is still underutilized. The bot tracks which tiles have been revealed as mines across thousands of rounds — that's real data about Rainbet's RNG patterns, or lack thereof. Whether that's exploitable is an open question.

The Claude tuner could also be extended to adjust the recovery chain depth dynamically — pulling back during bad sessions, extending it during strong ones.

For now, the bot runs. It logs. It tunes itself. And every few thousand rounds it fires a big bet on a nearly-impossible board, hoping to catch lightning.

Support the Project

If this bot made you money or you just found it interesting, consider sending a tip. Every bit helps fund more experiments like this one.

ETH / Any L2 (Arbitrum, Base, Optimism, Polygon...):

Any EVM-compatible chain works — ETH mainnet, Arbitrum, Base, Optimism, Polygon, all fine at the same address.

Built with Claude Sonnet 4, running as a Chrome extension on Rainbet. All code written iteratively across 18 major versions with extensive auditing and simulation at each step.

Source: github.com/spuriousdrag0n/rainbet-bot

A volume bumper is a trading bot that automatically executes buy and sell transactions to generate trading activity for your token. This guide walks you through building one using PancakeSwap V3 on BNB Smart Chain.

What is a Volume Bumper?

A volume bumper creates artificial trading volume by:

• Executing multiple sell transactions

• Following up with buy transactions

• Running in cycles with configurable delays

This can help with:

• Increasing token visibility on DEX aggregators

• Meeting volume requirements for listings

• Creating organic-looking trading activity

Prerequisites

• Node.js installed

• A wallet with BNB for gas fees

• Some of your token to trade

• Basic understanding of JavaScript

Installation

The Configuration

Create a file called bumper.js and set up your configuration:

const { ethers } = require('ethers');

// --- CONFIGURATION ---
// SECURITY WARNING: Use environment variables for private keys in production!
const PRIVATE_KEY = "YOUR_PRIVATE_KEY_HERE";
const SENDER_ADDRESS = "YOUR_WALLET_ADDRESS_HERE";

// The token you want to trade
const TOKEN_ADDRESS = "YOUR_TOKEN_ADDRESS_HERE";

// --- SWAP AMOUNTS ---
// Amount of BNB to spend for BUY (with randomization for natural-looking trades)
const BNB_AMOUNT_TO_SPEND_BUY = 0.002 * (0.5 + Math.random() * 0.7);

// Amount of TOKEN to sell (with randomization)
const TOKEN_TO_SELL_AMOUNT = 1000000 * (0.5 + Math.random() * 0.5);

// --- SLIPPAGE & FEES ---
const SLIPPAGE_TOLERANCE_PERCENT = 5; // 5% slippage tolerance

// Fee tiers: 500 = 0.05%, 2500 = 0.25%, 10000 = 1%
const FEE_TIER = 500;
const FEE_TIERS_TO_TRY = [500, 2500, 10000];

// --- LOOP CONFIGURATION ---
const LOOP_DELAY_MINUTES = 1; // Delay between cycles
const DELAY_BETWEEN_SELLS_MS = 10000; // 10 seconds between individual transactions

// --- NUMBER OF TRANSACTIONS PER CYCLE ---
const NUMBER_OF_SELLS = 3; // How many sell transactions per cycle
const NUMBER_OF_BUYS = 2;  // How many buy transactions per cycle

Key Configuration Variables Explained

PancakeSwap V3 Contract Addresses (BSC)

const PANCAKESWAP_ROUTER_V3_ADDRESS = '0x1b81D678ffb9C0263b24A97847620C99d213eB14';
const PANCAKESWAP_QUOTER_V2_ADDRESS = '0xB048Bbc1Ee6b733FFfCFb9e9CeF7375518e25997';
const WBNB_ADDRESS = '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c';
const BSC_RPC_URL = "https://bsc-dataseed.binance.org/";

The ABIs

// Router ABI for swaps
const ROUTER_ABI = [
    "function exactInputSingle(tuple(address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96) params) payable returns (uint256 amountOut)"
];

// Quoter ABI for getting price quotes
const QUOTER_V2_ABI = [
    "function quoteExactInputSingle(tuple(address tokenIn, address tokenOut, uint256 amountIn, uint24 fee, uint160 sqrtPriceLimitX96) params) returns (uint256 amountOut, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate)"
];

// ERC-20 Token ABI
const TOKEN_ABI = [
    "function decimals() view returns (uint8)",
    "function approve(address spender, uint256 amount) returns (bool)",
    "function allowance(address owner, address spender) view returns (uint256)",
    "function balanceOf(address account) view returns (uint256)"
];

// WBNB ABI for unwrapping
const WBNB_ABI = [
    "function balanceOf(address account) view returns (uint256)",
    "function withdraw(uint256 wad)"
];

Core Functions

1. Getting Price Quotes

Before each swap, the bot gets a quote to determine the minimum acceptable output:

async function getMinimumAmountOut(provider, tokenIn, tokenOut, amountIn, fee, outputDecimals = 18) {
    const quoterContract = new ethers.Contract(PANCAKESWAP_QUOTER_V2_ADDRESS, QUOTER_V2_ABI, provider);

    const quoteParams = {
        tokenIn: ethers.getAddress(tokenIn),
        tokenOut: ethers.getAddress(tokenOut),
        amountIn: amountIn,
        fee: fee,
        sqrtPriceLimitX96: BigInt(0)
    };

    const result = await quoterContract.quoteExactInputSingle.staticCall(quoteParams);
    const amountOut = result[0];

    // Apply slippage tolerance
    const slippageMultiplier = BigInt(10000 - (SLIPPAGE_TOLERANCE_PERCENT * 100));
    const minimumAmountOut = (amountOut * slippageMultiplier) / BigInt(10000);

    return { amountOut: minimumAmountOut, fee: fee };
}

2. Token Approval

Before selling tokens, you must approve the router to spend them:

async function approveToken(wallet, tokenAddress, routerAddress, amountInWei) {
    const tokenContract = new ethers.Contract(tokenAddress, TOKEN_ABI, wallet);
    const allowance = await tokenContract.allowance(wallet.address, routerAddress);

    if (allowance >= amountInWei) {
        console.log("Token already approved.");
        return true;
    }

    const approvalTx = await tokenContract.approve(routerAddress, amountInWei);
    await approvalTx.wait();
    return true;
}

3. Buy Function (BNB → Token)

async function buyToken(wallet, routerContract, tokenDecimals) {
    const amountInWei = ethers.parseUnits(BNB_AMOUNT_TO_SPEND_BUY.toFixed(6), 18);
    const deadline = Math.floor(Date.now() / 1000) + (60 * 5);

    const quoteResult = await getMinimumAmountOut(
        wallet.provider, WBNB_ADDRESS, TOKEN_ADDRESS, amountInWei, FEE_TIER, tokenDecimals
    );

    const swapParams = {
        tokenIn: WBNB_ADDRESS,
        tokenOut: TOKEN_ADDRESS,
        fee: quoteResult.fee,
        recipient: wallet.address,
        deadline: deadline,
        amountIn: amountInWei,
        amountOutMinimum: quoteResult.amountOut,
        sqrtPriceLimitX96: BigInt(0)
    };

    const tx = await routerContract.exactInputSingle(swapParams, {
        value: amountInWei,
        gasLimit: 500000
    });

    await tx.wait();
    console.log(`Buy successful! Hash: ${tx.hash}`);
}

4. Sell Function (Token → BNB)

async function sellToken(wallet, routerContract, tokenDecimals) {
    const amountInWei = ethers.parseUnits(TOKEN_TO_SELL_AMOUNT.toString(), tokenDecimals);
    const deadline = Math.floor(Date.now() / 1000) + (60 * 5);

    // Approve router first
    await approveToken(wallet, TOKEN_ADDRESS, PANCAKESWAP_ROUTER_V3_ADDRESS, amountInWei);

    const quoteResult = await getMinimumAmountOut(
        wallet.provider, TOKEN_ADDRESS, WBNB_ADDRESS, amountInWei, FEE_TIER, 18
    );

    const swapParams = {
        tokenIn: TOKEN_ADDRESS,
        tokenOut: WBNB_ADDRESS,
        fee: quoteResult.fee,
        recipient: wallet.address,
        deadline: deadline,
        amountIn: amountInWei,
        amountOutMinimum: quoteResult.amountOut,
        sqrtPriceLimitX96: BigInt(0)
    };

    const tx = await routerContract.exactInputSingle(swapParams, { gasLimit: 500000 });
    await tx.wait();
    console.log(`Sell successful! Hash: ${tx.hash}`);
}

5. WBNB Unwrapping

When you sell tokens, you receive WBNB. This function converts it back to BNB:

async function unwrapWbnb(wbnbContract, wallet) {
    const wbnbBalance = await wbnbContract.balanceOf(wallet.address);
    if (wbnbBalance > 0n) {
        const unwrapTx = await wbnbContract.withdraw(wbnbBalance);
        await unwrapTx.wait();
        console.log(`Unwrapped ${ethers.formatEther(wbnbBalance)} WBNB to BNB`);
    }
}

The Main Loop

async function executeLoop() {
    const provider = new ethers.JsonRpcProvider(BSC_RPC_URL);
    const wallet = new ethers.Wallet(PRIVATE_KEY, provider);

    const routerContract = new ethers.Contract(PANCAKESWAP_ROUTER_V3_ADDRESS, ROUTER_ABI, wallet);
    const wbnbContract = new ethers.Contract(WBNB_ADDRESS, WBNB_ABI, wallet);
    const tokenDecimals = await getTokenDecimals(provider, TOKEN_ADDRESS);

    let cycleCount = 0;

    while (true) {
        cycleCount++;
        console.log(`\n=== CYCLE #${cycleCount} START ===`);

        // Execute SELL operations
        for (let i = 1; i <= NUMBER_OF_SELLS; i++) {
            await sellToken(wallet, routerContract, tokenDecimals);
            if (i < NUMBER_OF_SELLS) {
                await delay(DELAY_BETWEEN_SELLS_MS);
            }
        }

        // Unwrap any WBNB received
        await unwrapWbnb(wbnbContract, wallet);

        // Execute BUY operations
        for (let i = 1; i <= NUMBER_OF_BUYS; i++) {
            await buyToken(wallet, routerContract, tokenDecimals);
            if (i < NUMBER_OF_BUYS) {
                await delay(DELAY_BETWEEN_SELLS_MS);
            }
        }

        console.log(`=== CYCLE #${cycleCount} END ===`);
        console.log(`Waiting ${LOOP_DELAY_MINUTES} minutes before next cycle...`);
        await delay(LOOP_DELAY_MINUTES * 60 * 1000);
    }
}

executeLoop();

Running the Bot

node bumper.js

Important Security Tips

1. Never hardcode private keys - Use environment variables:

   const PRIVATE_KEY = process.env.PRIVATE_KEY;
   

2. Start with small amounts - Test with minimal BNB first

3. Monitor gas prices - High gas can eat into your balance

4. Verify contract addresses - Always check on BSCScan before use

5. Use a dedicated wallet - Don't use your main wallet

Troubleshooting

Customization Ideas

• Randomize timing - Add random delays to appear more natural

• Volume targets - Stop after reaching a specific volume

• Multiple wallets - Distribute activity across wallets

• Price monitoring - Pause if price drops too much

Disclaimer

This tool is for educational purposes. Creating artificial volume may violate exchange terms of service and could be considered market manipulation in some jurisdictions. Use responsibly and at your own risk.

The rise of autonomous AI agents has created a fundamental challenge: how can these agents discover, trust, and collaborate with each other across organizational boundaries without pre-existing relationships? Two significant approaches have emerged to address this problem—Ethereum's ERC-8004 trust framework and Virtuals Protocol's Agentic Commerce Protocol (ACP). While both protocols enable agent coordination and establish trust mechanisms, they operate at fundamentally different architectural layers and embody distinct design philosophies.

ERC-8004 represents a minimalist approach, defining on-chain registries for agent identity and reputation on Ethereum. In contrast, ACP provides a comprehensive agent runtime and commerce network that orchestrates the entire transaction lifecycle. This technical analysis examines both protocols in detail, comparing their architectures, trust models, and implementation strategies to help developers and protocol designers evaluate which approach best suits their autonomous agent ecosystems.

ERC-8004: Ethereum's Trust Framework for AI Agents

ERC-8004 (Ethereum Request for Comment 8004) establishes a public discovery and trust layer for AI agents through three lightweight on-chain registries. The design philosophy prioritizes modularity and composability over feature completeness, positioning itself as infrastructure that can integrate with various agent communication and payment protocols.

Identity Registry: Portable Agent Identities via ERC-721

The Identity Registry implements agent identities as ERC-721 non-fungible tokens, giving each agent a globally unique, censorship-resistant identifier. This design choice leverages the existing NFT infrastructure, making agent identities immediately discoverable and transferable using standard Ethereum tooling. However, unlike traditional NFTs, these tokens function purely as identity handles rather than collectibles—the token ID and metadata URI point to an off-chain registration profile (typically an agent-card.json file) containing the agent's name, description, supported protocols (such as Agent-to-Agent or MCP endpoints), and discovery metadata.

The ERC-721 implementation provides several architectural advantages. Agent ownership becomes transferable through standard token transfers, enabling scenarios where agent control changes hands or where agents are traded as operational assets. The token owner maintains control over the agent's metadata URI, allowing profile updates without changing the agent's core identity. This separation between identity (the immutable token ID) and profile data (the mutable URI) creates a flexible foundation for long-lived agent identities that can evolve over time.

Reputation Registry: Decentralized Performance Tracking

The Reputation Registry provides a standardized interface for posting and retrieving performance feedback about agents. After any interaction, a client agent can submit a feedback attestation consisting of a numerical score (0-100 range), a context tag categorizing the interaction type, and a URI pointing to detailed review data. All reputation entries persist on-chain as public records, enabling anyone—whether human, agent, or smart contract—to aggregate and analyze performance history.

The reputation system employs a critical anti-spam mechanism: server agents must pre-authorize feedback from specific clients using EIP-191 or ERC-1271 signatures before those reviews become valid. This authorization requirement prevents review flooding while maintaining the permissionless nature of the registry. Importantly, ERC-8004 deliberately avoids prescribing any specific reputation algorithm or aggregation method. Multiple reputation providers can contribute different scoring methodologies for the same agent, and consuming applications can implement their own composite reputation calculations by analyzing the raw attestation data.

This design enables a marketplace of reputation interpretation methods. Some applications might weight recent reviews more heavily, while others might filter by interaction context or implement stake-weighted scoring. The registry simply provides the raw, verifiable data layer that supports these higher-level reputation algorithms.

Validation Registry: Pluggable Task Verification

For high-stakes scenarios requiring stronger guarantees than reputation alone provides, the Validation Registry offers generic hooks for independent task verification. An agent can request third-party validation by posting a validation request that specifies the validator address, a URI containing task data, and a cryptographic hash of that data for integrity verification. The designated validator then posts validation results indicating pass/fail status along with evidence URIs.

The architecture intentionally maintains validator-agnostic flexibility. ERC-8004 does not prescribe any specific validation mechanism—validators might employ stake-based re-execution services, Trusted Execution Environment (TEE) oracles, zero-knowledge machine learning proof verifiers, or even trusted human judges. This pluggable design allows different trust models to coexist under a common interface, enabling applications to select validation approaches appropriate to their risk profiles. Low-risk tasks might skip formal validation entirely, medium-risk scenarios could employ economic stake and re-run checks, while high-risk operations might demand cryptographic proofs or secure enclaves.

What ERC-8004 Intentionally Omits

As a deliberately minimal trust layer, ERC-8004 explicitly excludes several aspects that other protocols might consider essential. It does not mandate any tokens beyond the identity NFT—reputation entries are simple data posts, not tradable assets. Financial exchange mechanisms remain completely orthogonal to the trust framework; ERC-8004 provides no payment, escrow, or invoicing primitives. Developers must integrate separate payment protocols (potentially including emerging standards like x402 invoice flows) to handle monetary aspects of agent transactions.

Similarly, ERC-8004 does not define how agents communicate or negotiate terms. It functions as a complement to communication protocols like Google's Agent-to-Agent protocol rather than a replacement. The framework provides identity, reputation, and validation primitives on-chain while leaving off-chain task execution, messaging protocols, and economic coordination to other layers in the stack. This modular approach enables developers to compose ERC-8004 with whatever communication and payment systems best fit their requirements.

Virtuals' Agentic Commerce Protocol (ACP)

Agentic Commerce Protocol, developed by Virtuals Protocol in collaboration with partners including Stripe and OpenAI, takes a comprehensive approach to agent coordination. Rather than providing discrete building blocks, ACP defines an integrated standard and runtime that encompasses the entire agent interaction lifecycle—from discovery through negotiation to payment settlement and outcome validation. While ERC-8004 positions itself as neutral Ethereum infrastructure, ACP operates as both a protocol specification and the foundational layer of Virtuals' agent network ecosystem.

Agent Discovery and Flexible Identity

ACP's discovery mechanism centers on a shared on-chain registry where agents advertise their capabilities and endpoints for programmatic discovery. Every agent in the network maintains an on-chain identity, typically represented as a contract address or registry entry. Unlike ERC-8004's required NFT approach, ACP supports "untokenized" agents as first-class participants—agents can join the network using just an address and adherence to the protocol, without minting any tokens.

This flexibility accommodates diverse integration scenarios. Web2 services or non-crypto agents can participate by simply implementing ACP's communication standards and registering an identity. Meanwhile, Web3-native agents can optionally issue tokens for co-ownership structures and governance, following Virtuals Protocol's tokenization patterns. The protocol maintains this optionality while still providing agents the persistent, verifiable identities necessary for building reputation and trust over time.

The identity system also supports cross-chain operation natively. Agents can operate across Ethereum Layer 2s and other blockchain networks (including Solana in Virtuals' implementation), with ACP providing the abstraction layer for multi-chain identity resolution. This contrasts with ERC-8004's inherently Ethereum-focused design, which would require deploying separate registry instances to each chain and implementing custom bridging logic.

Four-Phase Task Coordination Workflow

ACP's core innovation lies in its structured, on-chain coordination flow that breaks every inter-agent interaction into four distinct phases, each enforced by smart contract logic:

Phase 1: Request
A client (initiator) agent submits a cryptographically signed request to a provider agent, describing the desired task parameters, outcomes, urgency constraints, and other requirements. The provider reviews the request and can accept, reject, or propose modifications. The protocol enforces timeout mechanisms to prevent indefinite pending states—requests that languish without response automatically expire.

Phase 2: Negotiation
When a provider accepts a request, both parties enter a formal negotiation phase to finalize terms. They establish concrete deliverables, compensation amounts, deadline constraints, and whether the task outcome requires third-party evaluation. Both parties then cryptographically sign the agreed terms, which the protocol records on-chain as an immutable contract. This creates a verifiable proof of agreement that neither party can later dispute or modify unilaterally.

Phase 3: Transaction (Execution & Payment)
Before work begins, the agreed payment and any necessary task data get submitted to a smart contract escrow. This ensures funds are cryptographically locked and cannot be withdrawn by either party until conditions are met. With payment secured in escrow, the provider agent executes the task (either off-chain or on-chain depending on requirements). The execution produces results that must satisfy the pre-negotiated criteria, but payment remains locked pending verification.

Phase 4: Evaluation
For tasks marked as requiring validation, an independent Evaluator agent now verifies the outcome against agreed criteria. This evaluator might re-execute computations, audit output quality, or check compliance with specifications—the validation methodology depends on the specific evaluator chosen during negotiation. Once the evaluator confirms successful completion, the smart contract automatically releases escrowed funds to the provider. Simultaneously, the protocol records feedback on-chain, updating the provider's performance history with completion confirmation and any quality ratings.

If the evaluator determines the result fails to meet requirements, the protocol can cancel payment and potentially implement penalties or compensation mechanisms according to the negotiated terms. This automated, contract-enforced verification creates strong incentives for honest work and accurate evaluation.

Integrated Trust and Economic Incentives

ACP's Evaluation phase effectively combines the functionality of ERC-8004's validation and reputation registries into a single, economically incentivized system. The requirement for third-party evaluation when needed, combined with automatic feedback recording, naturally generates an on-chain performance trail for every provider agent. Over time, agents accumulate verifiable track records of completed tasks, evaluation outcomes, and client satisfaction—creating a reputation signal that emerges organically from transaction history rather than requiring separate feedback mechanisms.

The economic design reinforces honest behavior throughout the system. Evaluator agents receive compensation (typically a percentage of the transaction value) for their verification work, incentivizing accurate assessment. Provider agents only receive payment upon successful validation, creating strong incentives to deliver quality work that meets specifications. Clients benefit from escrow protection that prevents payment for unsatisfactory results. These aligned incentives reduce the need for external enforcement while maintaining trust in agent-to-agent transactions.

Native Payment Coordination

Unlike ERC-8004's deliberate exclusion of payment mechanisms, ACP integrates financial settlement as a core protocol feature. Payment details become part of the negotiation phase, with amounts, timing, and conditions all specified in the cryptographically signed agreement. The protocol then coordinates escrow, conditional release, and settlement automatically through smart contract logic.

Virtuals' implementation extends ACP to support multiple payment channels—on-chain transfers across various networks, as well as integration with traditional payment processors. The protocol aims for chain-agnostic operation, enabling agents on different blockchains to transact through ACP as long as appropriate bridges or implementations exist. The Virtuals ecosystem further layers additional tokenomics (protocol fees, reward distributions, token burning mechanisms) to sustain the agent network, though these economic elements operate within the platform rather than being mandated by the bare ACP specification.

Overlapping Goals and Shared Philosophy

Despite their architectural differences, ERC-8004 and ACP converge on several fundamental principles for establishing trust among autonomous agents:

Verifiable On-Chain Identity

Both frameworks recognize that autonomous agent ecosystems require persistent, discoverable identities that enable reputation accumulation and relationship building. ERC-8004 provides each agent with a unique ERC-721 token and associated registration metadata. ACP assigns each agent an on-chain identity through registry entries, contract addresses, or optional tokenization. In both cases, identities are verifiable on-chain, preventing impersonation and ensuring that an agent's claimed history actually belongs to that agent.

This identity foundation enables the core trust primitive: when an agent claims to provide a particular service or maintain certain capabilities, other agents can query the blockchain to verify that claim and review the agent's historical performance. The immutability and transparency of blockchain-anchored identities ensures that reputation follows agents across interactions and cannot be easily reset or falsified.

Reputation Through Verifiable History

Both protocols rely on accumulating on-chain performance records to establish trust over time. ERC-8004 implements this through its dedicated Reputation Registry where participants post explicit feedback after interactions. ACP achieves similar outcomes by recording the results of evaluated transactions directly in each agent's on-chain history. While the mechanisms differ, the philosophy aligns: trust emerges from transparent, tamper-proof historical evidence rather than unverifiable claims.

This approach creates natural incentive alignment. Agents have strong motivation to perform well because poor performance becomes permanently visible to potential future clients. Good actors build valuable reputations that attract more business, while bad actors accumulate negative records that limit their opportunities. The blockchain's immutability ensures these reputation signals remain reliable even as agent ownership changes or time passes.

Tiered Validation for Scalability

Both frameworks recognize that not every interaction warrants the same level of verification overhead. ERC-8004's Validation Registry provides optional mechanisms for agents to request third-party validation when stakes justify the additional cost and complexity. ACP similarly makes the Evaluation phase optional, allowing low-risk transactions to proceed based on reputation alone while enabling high-stakes scenarios to demand rigorous verification.

This tiered approach prevents a common pitfall in trust systems: if every transaction requires expensive verification, the system becomes too costly for routine interactions. By supporting both lightweight reputation-based trust and heavyweight cryptographic or economic validation, both protocols enable trust mechanisms that scale economically from trivial to critical applications.

Open, Interoperable Ecosystems

Neither framework envisions agents operating within walled gardens. ERC-8004 leverages Ethereum's permissionless infrastructure—any agent can register in the identity registry, and any client can query these registries across Ethereum and its Layer 2 networks. ACP similarly aims for permissionless, chain-agnostic operation, designing the protocol so agents across different blockchains and organizations can discover and transact with each other.

Both approaches actively resist fragmentation into proprietary silos. ERC-8004 provides common trust infrastructure to prevent every organization from building incompatible reputation systems. ACP offers a universal transaction protocol to eliminate the need for custom integration work between every pair of agents. This shared commitment to interoperability reflects a vision of agent economies as open networks rather than controlled platforms.

Fundamental Architectural Differences

While ERC-8004 and ACP share high-level goals, their different scopes and design philosophies create significant practical distinctions:

Neutral Standard vs Platform Integration

ERC-8004 exists as an Ethereum standard proposal—a set of interface definitions and registry contracts available for anyone to implement. It maintains deliberate neutrality, avoiding association with any specific project, token, or commercial interest. This positions ERC-8004 as public infrastructure comparable to other Ethereum standards like ERC-20 or ERC-721.

ACP, while described as an open standard, operates in tight integration with Virtuals Protocol's ecosystem. It serves as the foundational coordination layer for Virtuals' agent network, with initial implementations driven by Virtuals on Ethereum Layer 2 (Base) and Solana. The protocol comes bundled with Virtuals' broader infrastructure including the Agentic runtime, platform tokenomics, and marketplace features.

This distinction matters for adoption patterns. Developers seeking modular components that integrate into diverse systems naturally gravitate toward ERC-8004's neutral positioning. Those wanting a comprehensive, production-ready agent economy might prefer ACP's integrated approach despite tighter coupling to the Virtuals ecosystem.

Scope: Trust Primitives vs Complete Workflow

The most significant architectural difference lies in scope boundaries. ERC-8004 deliberately limits itself to identity and trust registries—it provides building blocks but does not orchestrate the actual process of agents agreeing on terms, executing tasks, or settling payments. To conduct business using ERC-8004, developers must integrate additional protocols for messaging (like Agent-to-Agent), negotiation logic, and financial settlement. ERC-8004 enhances these interactions by providing verifiable identity and reputation, but it doesn't replace them.

ACP encompasses the entire coordination lifecycle within a single protocol. It defines how agents discover each other, how they negotiate and formalize agreements, how payments flow into escrow, how task execution proceeds, and how validation triggers settlement. An agent implementing ACP gains a complete framework for autonomous commerce without requiring separate protocols for each phase.

In practical terms, ERC-8004 functions as infrastructure you build upon, while ACP provides a ready-to-deploy system. The trade-offs mirror classic software design choices: modular components offer more flexibility but require integration work, while integrated systems reduce integration burden but constrain architectural freedom.

Payment Integration Philosophy

ERC-8004's exclusion of payment mechanisms represents a deliberate architectural choice. The standard treats financial exchange as orthogonal to trust establishment—agents might use various payment systems (cryptocurrency transfers, traditional invoicing, even non-monetary value exchange) without affecting how identity and reputation work. This separation allows ERC-8004 to remain neutral regarding payment infrastructure, letting applications choose integration points that match their requirements.

ACP makes payment coordination a first-class protocol concern. Payment terms get negotiated alongside task specifications, funds flow into protocol-managed escrow before work begins, and settlement occurs automatically upon verification. The Virtuals implementation extends this to support multiple payment rails and even incorporates platform-level tokenomics (fees, rewards, token burning) as part of the economic model.

This fundamental difference affects system complexity and flexibility. ACP's integrated payments enable powerful automated escrow and conditional settlement but require all participants to adopt ACP's payment model. ERC-8004's payment-agnostic design maintains flexibility but pushes financial coordination responsibility to application developers.

Enforcement vs Incentives

ERC-8004 functions as a trust signaling system rather than an enforcement mechanism. If an agent behaves badly, that behavior gets recorded in reputation or validation results, creating disincentives for future misconduct. However, ERC-8004 itself doesn't prevent an agent from taking payment and disappearing, or a client from refusing legitimate payment. Applications building on ERC-8004 must implement their own enforcement mechanisms (escrow contracts, legal agreements, dispute resolution) if they need stronger guarantees.

ACP's smart contracts enforce the interaction protocol at each phase. Once parties sign an agreement, the protocol's state machine ensures neither can skip steps or violate terms without detection. Escrowed funds cannot be withdrawn except through the protocol's verification logic. This creates automatic enforcement of the agreed workflow, preventing certain classes of failures by design rather than just recording them for reputation impact.

The trade-off involves rigidity versus flexibility. ACP's enforcement provides stronger guarantees but requires all participants to follow its specific workflow. ERC-8004's lighter touch allows diverse interaction patterns but provides less automated protection against bad actors.

Identity Representation and Portability

ERC-8004 implements agent identity through the ERC-721 NFT model, where each agent receives a token ID with an owner address and metadata URI. This approach leverages extensive existing infrastructure—wallet support, marketplace integration, transfer mechanics, ENS linking—but also constrains identity to Ethereum-compatible chains. Deploying across multiple chains requires running separate registry instances and implementing custom synchronization if unified identities are needed.

ACP's identity model offers more flexibility in representation. Agents can use simple registry entries, contract addresses, or optionally mint tokens depending on their needs. Virtuals' cross-chain design accommodates agents operating across different blockchains (Ethereum L2s, Solana) with ACP serving as the abstraction layer for identity resolution. This native multi-chain support simplifies cross-chain agent coordination but introduces dependencies on Virtuals' bridging infrastructure.

Composability and Extensibility

ERC-8004's minimalist design optimizes for composability. Since it only defines identity and trust primitives, developers can freely combine these registries with other smart contracts and protocols. A DeFi application might query agent reputation scores to adjust lending terms. An insurance protocol could require validation results before underwriting agent-performed tasks. This plug-and-play nature emerges naturally from ERC-8004's narrow, well-defined scope.

ACP provides extensibility through platform evolution rather than modular composition. The protocol is designed to support new features and adapt to additional blockchains, with Virtuals maintaining a developer SDK (the GAME framework) for building ACP-compatible agents. However, adopting pieces of ACP independently (using only its negotiation phase with a different payment system, for instance) requires significant customization. The comprehensive nature that makes ACP powerful for full adoption makes it less suited to partial integration.

Technical Implementation Comparison

Understanding the practical implications of these architectural differences requires examining specific implementation details:

Identity Registry: NFT vs Flexible Addressing

ERC-8004's identity registry implements the IERC721 interface, requiring implementers to handle token minting, ownership transfers, and metadata management. Agent registration involves minting an NFT that serves as the identity handle, with the token URI pointing to off-chain metadata (typically JSON) containing the agent's profile, capabilities, and endpoints.

// ERC-8004 Identity Registry (simplified)
interface IAgentIdentityRegistry is IERC721 {
    function registerAgent(address owner, string calldata metadataURI) 
        external returns (uint256 tokenId);
    
    function updateMetadata(uint256 tokenId, string calldata newURI) external;
    
    function getAgentMetadata(uint256 tokenId) 
        external view returns (string memory);
}

ACP's identity mechanism varies by implementation but typically uses simpler registry patterns:

// ACP Identity Registry (conceptual)
class ACPIdentityRegistry {
    registerAgent(address, capabilities, endpoints) {
        // Store mapping of address to agent profile
        // No NFT minting required for basic operation
    }
    
    getAgentProfile(address) {
        // Return registered capabilities and endpoints
    }
}

This difference affects integration complexity. ERC-8004's NFT approach requires handling token transfers for ownership changes but provides built-in compatibility with existing Ethereum tooling. ACP's simpler addressing reduces registration overhead but requires custom tooling for identity management.

Reputation Mechanisms: Explicit Attestations vs Transaction Records

ERC-8004's Reputation Registry uses explicit attestation posting with pre-authorization requirements:

// ERC-8004 Reputation Registry (simplified)
interface IAgentReputationRegistry {
    struct ReputationAttestation {
        address rater;
        uint256 agentId;
        uint256 score;  // 0-100
        string contextTag;
        string evidenceURI;
        uint256 timestamp;
    }
    
    // Server must pre-authorize client's feedback
    function authorizeRater(address rater, bytes calldata signature) external;
    
    function submitReputation(
        uint256 agentId,
        uint256 score,
        string calldata contextTag,
        string calldata evidenceURI
    ) external;
    
    function getReputationHistory(uint256 agentId) 
        external view returns (ReputationAttestation[] memory);
}

ACP's reputation emerges implicitly from transaction completion records:

// ACP Transaction History (conceptual)
class ACPTransactionRegistry {
    recordCompletion(
        initiatorAddress,
        providerAddress,
        taskHash,
        evaluationResult,
        feedback
    ) {
        // Automatically creates reputation trail
        // No separate authorization step needed
    }
    
    getProviderHistory(address) {
        // Returns completed tasks with evaluation outcomes
    }
}

The explicit vs implicit distinction affects trust signal granularity. ERC-8004 enables diverse reputation providers and scoring methodologies but requires managing authorization to prevent spam. ACP's transaction-coupled approach automatically prevents spam (you can't create fake completion records) but ties reputation exclusively to protocol-mediated interactions.

Validation Patterns: Pluggable Validators vs Integrated Evaluators

ERC-8004's Validation Registry provides a minimal interface for requesting and recording validation results:

// ERC-8004 Validation Registry (simplified)
interface IAgentValidationRegistry {
    struct ValidationRequest {
        address requester;
        address validator;
        string taskDataURI;
        bytes32 taskDataHash;
        uint256 timestamp;
    }
    
    struct ValidationResult {
        uint256 requestId;
        bool passed;
        string evidenceURI;
        uint256 timestamp;
    }
    
    function requestValidation(
        address validator,
        string calldata taskDataURI,
        bytes32 taskDataHash
    ) external returns (uint256 requestId);
    
    function submitValidation(
        uint256 requestId,
        bool passed,
        string calldata evidenceURI
    ) external;
    
    function getValidationResult(uint256 requestId) 
        external view returns (ValidationResult memory);
}

ACP integrates evaluation directly into the transaction workflow:

// ACP Evaluation Phase (conceptual)
class ACPTaskContract {
    async executeEvaluationPhase(taskId) {
        const task = await this.getTask(taskId);
        const evaluator = task.negotiatedEvaluator;
        
        // Evaluator verifies according to agreed criteria
        const result = await evaluator.verify(task.deliverables);
        
        if (result.passed) {
            await this.releaseEscrow(task.provider);
            await this.recordSuccess(task);
        } else {
            await this.handleFailure(task);
        }
    }
}

ERC-8004's approach allows arbitrary validation methods (cryptographic proofs, TEE attestations, stake-based re-execution) to coexist with a standard interface. ACP's integrated model ensures validation always occurs before payment release but requires evaluators to conform to the protocol's verification workflow.

Real-World Application: The EthiQ Case Study

EthiQ, a peer-to-peer donation platform, demonstrates how these protocols can be applied in practice. The platform uses Virtuals' ACP infrastructure while embodying principles aligned with ERC-8004's trust philosophy. Multiple AI agents coordinate to evaluate donation requests, verify their authenticity, and match them with appropriate donors.

The system employs specialized agents in distinct roles: verification agents assess request legitimacy and urgency, ranking agents score and prioritize candidates, and matching agents pair donors with validated opportunities. These agents communicate through ACP's structured workflow, using its negotiation phase to agree on evaluation criteria and its evaluation phase to verify outcomes before fund allocation occurs.

Each agent in the EthiQ system builds on-chain reputation through its participation in successful donations. Verification agents develop track records for accurate authenticity assessment. Ranking agents demonstrate expertise in prioritization. Matching agents prove their ability to create satisfying donor-recipient pairs. This reputation accumulation, while managed through ACP's infrastructure, mirrors ERC-8004's vision of trust emerging from verifiable historical performance.

The EthiQ implementation showcases how ACP's comprehensive workflow can implement the trust principles that ERC-8004 codifies as separate primitives. The agents rely on verifiable on-chain information rather than trusting each other blindly. Their evaluations leave permanent records that guide future decisions. The system leverages both lightweight reputation for routine operations and formal evaluation for high-stakes fund allocation. This real-world deployment validates that despite architectural differences, both approaches can achieve trustworthy autonomous agent coordination when properly implemented.

Evaluation Framework: Choosing Between Approaches

Selecting between ERC-8004 and ACP requires evaluating several key dimensions:

Use Case Alignment

Choose ERC-8004 when:

• You need modular trust primitives that integrate with existing systems

• Your application requires custom payment or negotiation workflows

• You're building on Ethereum mainnet or Layer 2s exclusively

• You want maximum flexibility in reputation algorithms and validation methods

• You're creating infrastructure that other applications will build upon

Choose ACP when:

• You need a complete agent commerce solution with minimal integration work

• Your use case benefits from enforced escrow and automated payment settlement

• You require cross-chain agent coordination (Ethereum L2s and Solana)

• You want to leverage Virtuals' existing agent network and tooling

• You're building consumer-facing applications where rapid deployment matters more than architectural flexibility

Technical Constraints

ERC-8004 requires developers to integrate multiple protocols (identity, communication, payment, reputation) into a cohesive system. This demands stronger technical capabilities but provides architectural freedom. Teams with sophisticated blockchain development expertise who need custom workflows will appreciate this flexibility.

ACP reduces integration complexity by providing an all-in-one solution. Teams with limited blockchain expertise or tight timelines can deploy ACP-based agents more rapidly. However, this convenience comes at the cost of conforming to ACP's workflow and depending on Virtuals' infrastructure.

Ecosystem Considerations

ERC-8004's neutral positioning makes it suitable for building shared infrastructure that many applications can use. If you're creating public goods or developing standards for industry adoption, ERC-8004's credible neutrality matters.

ACP's integration with Virtuals Protocol makes it powerful for applications targeting that ecosystem. If you're building agents that will primarily interact with other Virtuals-based agents, or if you want access to Virtuals' network effects and developer tools, ACP becomes the natural choice despite tighter coupling.

Evolution and Maintenance

ERC-8004's modular nature allows independent evolution of different system components. You can upgrade reputation algorithms, swap validation mechanisms, or adopt new payment protocols without disrupting the core identity layer. This modularity benefits long-lived systems that must adapt to changing requirements.

ACP's integrated design means protocol upgrades potentially affect all components simultaneously. Virtuals maintains the canonical implementation and drives evolution, which can be advantageous if their roadmap aligns with your needs but limiting if it doesn't.

Future Convergence and Hybrid Approaches

The dichotomy between ERC-8004 and ACP may diminish as the agent ecosystem matures. Several convergence patterns appear likely:

Cross-Protocol Identity Bridges

Agents could maintain ERC-8004 identities (NFT-based) while participating in ACP transactions, using the NFT identity as the trust anchor that links to ACP registry entries. This would enable agents to build unified reputations across both ecosystems, leveraging ERC-8004's portable identity with ACP's transaction coordination.

Modular ACP Components

The ACP specification could evolve to support more modular adoption, allowing developers to use its negotiation workflow with alternative payment systems, or its evaluation phase with different identity schemes. This would bridge the gap between ACP's comprehensive approach and ERC-8004's composability.

ERC-8004 Payment Extensions

The Ethereum community might develop complementary standards for agent payments and escrow that integrate naturally with ERC-8004's trust primitives. This would reduce the integration burden for ERC-8004 adopters while maintaining modularity.

Reputation Aggregation Services

Third-party services could aggregate reputation signals from both ERC-8004 registries and ACP transaction histories, providing unified trust scores that work across protocols. This would enable agents to build portable reputations regardless of which coordination protocol they use.

Conclusion

ERC-8004 and ACP represent complementary approaches to establishing trust in autonomous agent ecosystems. ERC-8004 provides modular, composable trust primitives—identity, reputation, and validation registries—that developers can integrate into diverse systems with maximum flexibility. ACP delivers a comprehensive agent commerce protocol that orchestrates the entire transaction lifecycle with built-in enforcement and payment coordination.

The choice between these frameworks depends on your specific requirements. Projects needing architectural flexibility, custom workflows, or neutral infrastructure foundations will find ERC-8004's minimal, composable design advantageous. Applications prioritizing rapid deployment, automated enforcement, or tight integration with existing agent networks will benefit from ACP's comprehensive solution.

Rather than viewing these as competing standards, developers should recognize them as addressing different points on the trust infrastructure spectrum. ERC-8004 excels as foundational infrastructure that enables diverse implementations, while ACP provides a production-ready system for immediate deployment. As the autonomous agent economy matures, we may see hybrid approaches emerge that combine ERC-8004's portable trust primitives with ACP's orchestration capabilities, creating even more robust frameworks for trustworthy agent coordination.

The technical community's challenge now lies in driving adoption of these trust mechanisms—whether through ERC-8004's modular building blocks or ACP's integrated platform—to realize the vision of autonomous agents that can discover, trust, and collaborate across organizational boundaries without centralized intermediaries.

Real-World Example: EthiQ Aligning ACP with ERC‑8004 Concepts

To ground this comparison, consider EthiQ, a peer-to-peer donation platform that leverages Virtuals’ ACP while embracing ERC‑8004’s trust philosophy. EthiQ uses multiple AI agents to evaluate and match donation requests with donors, and these agents coordinate via ACP on the Virtuals network. For instance, one agent might verify the authenticity and urgency of a charitable request (providing a verified trust signal), while another agent ranks and matches donors to those requests. Through ACP, EthiQ’s agents share verified scores, coordinate on evaluating candidates, and reach consensus on fund allocation – all actions that are anchored on-chain for transparency. Each agent in the EthiQ system has a defined role and communicates through standard protocols under ethical guardrails. In essence, EthiQ shows how a project can use ACP’s end-to-end coordination but still align with the ERC‑8004 trust model concept: the agents rely on verifiable on-chain information and cross-agent trust signals to make decisions, rather than trusting each other blindly. This demonstrates the practical synergy of both approaches – ERC‑8004’s ideas of on-chain identity, reputation, and validation are being realized within ACP’s operational network, guiding real-world autonomous agent interactions toward accountable and trustworthy outcomes.

This guide explains how to qualify, how points are calculated, and how to position yourself for the highest possible allocation.

1. Understanding the Rewards

The airdrop reward pool consists of:

• $500,000 USDC

• 50,000,000 vested $ETHIQ

Rewards are not distributed equally.
Your share is determined by the Solidarity Points you accumulate throughout the campaign.

Your points reflect:

• The amount of ETHIQ you hold

• The amount of ETHIQ you stake

• The amount of USDC you donate

• Your consistency across all snapshots

The more points you earn, the larger your portion of the reward pool.

2. How Points Are Calculated

Solidarity Points are generated from three core actions:

Your points are measured at every snapshot, not just once.
Consistency strongly increases your final allocation.

3. Airdrop Flow (Overview)

Below is the full process from start to finish:

Create Wallet → Connect to Base
↓
Buy ETHIQ via Virtuals
↓
Complete Proof of Kindness (Galxe)
↓
Donate & Interact via app.ethiq.us
↓
Claim Proof of Solidarity (Galxe)
↓
Accumulate Points Across Snapshots
↓
Receive Share of Rewards

4. Step-by-Step: How to Join and Earn Rewards

Step 1: Create an EVM Wallet and Connect to Base

You can use MetaMask, Rabby, or any EVM-compatible wallet.

Add the Base network:

• RPC: https://mainnet.base.org

• Chain ID: 8453

• Currency: ETH

• Explorer: https://basescan.org

You will also need a small amount of ETH on Base for gas fees.

Step 2: Buy ETHIQ (Your Highest Point Multiplier)

To begin earning points, you need ETHIQ on Base.

2.1 Acquire VIRTUAL (if needed)

Purchase VIRTUAL on a CEX or DEX, then bridge or deposit it to Base.

2.2 Buy ETHIQ

Use the Virtuals prototype:
https://app.virtuals.io/prototypes/0x9B1bBBa7C0BBaAF22315a939a19448559D605890

Holding and staking ETHIQ are the strongest point generators:

• Holding earns 6 points per $1

• Staking earns 12 points per $1

ETHIQ is the foundation of your score.

Step 3: Complete Proof of Kindness

This step is required to unlock the airdrop.

Go to the Galxe quest:
https://app.galxe.com/quest/atomiclodge/GCLfst8c6v

Connect your wallet and complete the tasks.
Mint your Proof of Kindness OAT.

Without this OAT, you are not eligible for the campaign.

Step 4: Make a Donation via app.ethiq.us

Your on-chain impact is measured here.

Visit: app.ethiq.us
Connect your wallet on Base, choose a mission, and donate USDC.

Donations generate:

• 3 points for every $1 USDC donated

This action also unlocks eligibility for Proof of Solidarity.

Step 5: Claim Proof of Solidarity

Go to the Galxe quest:
https://app.galxe.com/quest/atomiclodge/GCtPVtYYkE

Galxe checks:

• Did you complete Proof of Kindness?

• Did you make a donation?

• Are you holding ETHIQ at snapshot time?

Once verified, mint your Proof of Solidarity OAT.

This OAT officially links your impact to the airdrop system.

5. How Rewards Are Determined

Your total rewards depend on:

• Your cumulative points

• Your ranking on the leaderboard

• Your consistency across snapshots

Points Engine Diagram

ETHIQ Held        → 6 points per $1
ETHIQ Staked      → 12 points per $1
USDC Donated      → 3 points per $1
---------------------------------------
Total Solidarity Points
↓
Leaderboard Ranking
↓
Share of $500k USDC + 50M ETHIQ

Snapshot consistency is one of the strongest factors.
Participants who act early and remain active will have significantly higher scores.

6. Track Your Progress

Your rank and total points are displayed on the ETHIQ Leaderboard:

https://ethiq.us/leaderboard

The leaderboard updates as:

• You accumulate more points

• Snapshots occur

• Other users move above or below you

Your position on the leaderboard is the clearest indicator of your future airdrop allocation.

7. Summary: How to Maximize Your Allocation

To optimize your rewards:

1. Buy and hold ETHIQ

2. Stake ETHIQ for the highest multiplier

3. Donate USDC via the AI Agent for additional points

4. Complete Proof of Kindness and Proof of Solidarity

5. Stay active across all snapshots

6. Monitor your ranking on the leaderboard

Your commitment, consistency, and impact directly determine your share of the $500,000 USDC + 50,000,000 $ETHIQ pool.

1. Install Docker and Docker Compose

Before you can run any Aztec node, you need Docker and Docker Compose installed.  On a fresh Linux server, you can install them with these commands (run as root or with sudo):

# Update and upgrade your system
apt-get update && apt-get upgrade -y

# Install prerequisites
apt-get install -y ca-certificates curl lsb-release gnupg

# Remove any old Docker packages
for pkg in docker.io docker-doc docker-compose podman-docker containerd runc; do \
  apt-get remove --purge -y "$pkg" || true; \
done
apt-get autoremove -y

# Add Docker’s official GPG key
install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
chmod a+r /etc/apt/keyrings/docker.gpg

# Add the Docker repository
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" \
  > /etc/apt/sources.list.d/docker.list

# Install Docker Engine and Docker Compose plugin
apt-get update
apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Enable and start the Docker service
systemctl enable docker
systemctl start docker

# Verify installation
docker --version
docker compose version

This sequence updates your system, removes old Docker packages, adds Docker’s official repository, installs the latest Docker and Docker Compose, and verifies that both are available.  Once installed, you’re ready to set up the Aztec keystore and node.

2. Install the Aztec CLI

Before generating a keystore, you must install the Aztec CLI.  Aztec provides an installation script that downloads the binaries and sets up the CLI in ~/.aztec/bin.  Run the following command on your server:

bash -i <(curl -s https://install.aztec.network)

The script may prompt you to add ~/.aztec/bin to your PATH.  If it does, or if you find that aztec is not found after installation, update your shell profile manually.  For example, add this line to your ~/.bashrc or ~/.bash_profile:

echo 'export PATH="$HOME/.aztec/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

After installation, verify that the CLI works:

aztec --version

You should see the CLI version number printed.  With the CLI installed and on your PATH, you can proceed to generate your keystore.

3. Generate a Sequencer Keystore

Aztec sequencers require both an Ethereum signing key and a BLS key for attestation.  These are bundled together in a keystore.  Use the Aztec CLI to generate it.  Because the protocol doesn’t yet use fee recipients, you can pass the 32‑byte zero address for the --fee‑recipient flag (the CLI rejects 20‑byte addresses).  The command writes a JSON keystore file to ~/.aztec/keystore and prints the attester’s Ethereum address and BLS key 🇦

aztec validator-keys new \
  --fee-recipient 0x0000000000000000000000000000000000000000000000000000000000000000

The resulting key1.json file contains objects such as attester.eth and attester.bls.  These are your validator’s Ethereum address and BLS private key.  It also includes an optional coinbase field (the L1 address where rewards are sent) and a feeRecipient field for L2 fees (currently unused) 

4. Update Environment Variables

Aztec’s v2.1.x releases replace the older ETHEREUM_RPC_URL and CONSENSUS_BEACON_URL with new variables that accept comma‑separated lists of endpoints.  A minimal .env file should specify the data and key directories, the L1 execution and consensus hosts, and network ports 

# Core paths and logging
DATA_DIRECTORY=/root/.aztec/data
KEY_STORE_DIRECTORY=/root/.aztec/keystore
LOG_LEVEL=info

# L1 RPC endpoints — replace these with your own URLs
ETHEREUM_HOSTS=<YOUR_ETHEREUM_RPC_ENDPOINT>
L1_CONSENSUS_HOST_URLS=<YOUR_BEACON_CONSENSUS_RPC>

# P2P and API configuration — fill in your own IP address and change ports if necessary
P2P_IP=<YOUR_PUBLIC_IP>
P2P_PORT=40400
AZTEC_PORT=8080
AZTEC_ADMIN_PORT=8880

If you include a COINBASE variable, Aztec will pay L1 rewards there; if omitted, the rewards default to your attester’s address .  The keystore file is mounted into the container via KEY_STORE_DIRECTORY, so the node can read the private keys.

5. Create or Update docker-compose.yml for the Latest Version

To run your sequencer, you need a compose file that uses the latest stable Aztec image and references the environment variables defined in your .env.  Below is an example docker-compose.yml that works with the v2.1.5 release and uses the new KEY_STORE_DIRECTORY and DATA_DIRECTORY variables .  You can place this file alongside your .env:

version: "3.8"

services:
  aztec-sequencer:
    container_name: aztec-sequencer
    image: aztecprotocol/aztec:2.1.5
    restart: unless-stopped
    network_mode: host
    environment:
      KEY_STORE_DIRECTORY: ${KEY_STORE_DIRECTORY}
      DATA_DIRECTORY: ${DATA_DIRECTORY}
      LOG_LEVEL: ${LOG_LEVEL}
      ETHEREUM_HOSTS: ${ETHEREUM_HOSTS}
      L1_CONSENSUS_HOST_URLS: ${L1_CONSENSUS_HOST_URLS}
      P2P_IP: ${P2P_IP}
      P2P_PORT: ${P2P_PORT}
      AZTEC_PORT: ${AZTEC_PORT}
      AZTEC_ADMIN_PORT: ${AZTEC_ADMIN_PORT}
    entrypoint: >-
      node --no-warnings /usr/src/yarn-project/aztec/dest/bin/index.js start --network testnet --node --archiver --sequencer
    ports:
      - "${P2P_PORT}:${P2P_PORT}/tcp"
      - "${P2P_PORT}:${P2P_PORT}/udp"
      - "${AZTEC_PORT}:${AZTEC_PORT}"
    volumes:
      - ${DATA_DIRECTORY}:/var/lib/data
      - ${KEY_STORE_DIRECTORY}:/var/lib/keystore

Once this file is saved, run the following commands to download the new image and start the node:

docker compose pull     # fetch the v2.1.5 image from Docker Hub [oai_citation:5‡docs.aztec.network](https://docs.aztec.network/the_aztec_network/operation/operator_faq#:~:text=)
docker compose down     # stop any existing container to apply configuration changes
docker compose up -d    # recreate and start the sequencer in the background

These commands ensure you always run the updated image rather than reusing a cached version.  If you have already pulled the image, you can omit docker compose pull, but it’s good practice to include it when upgrading.

6. Register Your Sequencer on L1

Once your node is running and has caught up with the L2 chain, you must register it as a validator.  Use a funding account (an Ethereum wallet with Sepolia ETH) to pay for the transaction; do not use your validator’s private key .  The command requires your L1 RPC endpoint, network name (testnet for Sepolia), the funding key, your attester’s Ethereum address, a withdrawer address (often the same as the attester), your BLS private key and the rollup contract address .  For the Sepolia testnet the rollup contract is 0xebd99ff0ff6677205509ae73f93d0ca52ac85d67 

aztec add-l1-validator \
  --l1-rpc-urls <YOUR_L1_RPC_URL> \
  --network testnet \
  --private-key <FUNDING_PRIVATE_KEY> \
  --attester <YOUR_ATTESTER_ETH_ADDRESS> \
  --withdrawer <YOUR_WITHDRAWER_ETH_ADDRESS> \
  --bls-secret-key <YOUR_BLS_PRIVATE_KEY> \
  --rollup 0xebd99ff0ff6677205509ae73f93d0ca52ac85d67

After submitting the transaction, monitor it on a Sepolia block explorer.  Once confirmed, your node becomes an official validator and can propose/attest blocks 

7. Setting up a dRPC RPC Endpoint

Instead of relying on public RPC endpoints, you can provision your own endpoint through dRPC.  dRPC’s documentation explains that you first need to create an account or log in using a wallet, email or Google .  Once authenticated, you create a new dRPC key.  dRPC keys separate different applications, allow you to set daily request limits and provide usage statistics .  Each key has its own set of endpoints; an endpoint consists of the base dRPC URL, the selected network and your key value .

To configure your Aztec node to use a dRPC endpoint, take the following steps:

1. Create the key: In the dRPC dashboard (after logging in), choose Create key, specify a name and desired rate limit, and save.  dRPC will display a list of base URLs for different networks; copy the one for sepolia.

2. Replace your RPC URLs: In your .env, update ETHEREUM_HOSTS with the dRPC Sepolia URL followed by your key value.  If dRPC provides a separate consensus endpoint, also update L1_CONSENSUS_HOST_URLS.  This routes all L1 calls through dRPC’s infrastructure.

3. Restart the node: Run docker compose down and docker compose up -d to apply the new endpoints.  Your node will now use the dRPC backend for Ethereum calls.

   If you don’t yet have a dRPC account, sign up and obtain a key via https://drpc.org?ref=5ee4ac.  The referral link above takes you directly to dRPC’s signup page, where you can generate keys for multiple networks and monitor their usage.  Once you’ve created a key, follow the steps above to integrate it into your Aztec configuration.

By using a dedicated dRPC endpoint, you gain more stable throughput and better monitoring of your request usage compared with public RPC services.  Because the endpoint includes your private key token, make sure you keep the URL secret and rotate it if you suspect compromise.

8. Use Sepolia Addresses and Obtain Sepolia ETH

When configuring your sequencer, ensure that every address and RPC endpoint corresponds to the Sepolia network.  Your funding account, attester address and withdrawer address must all be Sepolia wallets; using a mainnet address or RPC will result in failed transactions or incorrect behaviour.  In particular:

• L1 RPC URLs: ETHEREUM_HOSTS and L1_CONSENSUS_HOST_URLS should point to Sepolia endpoints (for example, dRPC’s Sepolia RPC or another reliable provider).  Do not point them at mainnet or Görli RPCs.

• Funding account: The --private-key flag in the registration step must be a Sepolia account funded with Sepolia ETH .

• Attester/withdrawer: These addresses come from your keystore’s attester.eth field; they are also Sepolia accounts.  Never re‑use mainnet addresses here.

If you need Sepolia ETH, you can mine it using the official PoW faucet.  Visit the mining page (for example, Sepolia PoW Faucet) and follow the instructions to start mining.  The page displays your mining reward, hashrate, minimum and maximum claim values, remaining session time and other statistics.  Once you accumulate enough shares, click Stop Mining & Claim Rewards to send Sepolia ETH to your specified address.  This faucet is the recommended method to obtain Sepolia ETH for validator registration and staking.

Summary: Running an Aztec sequencer on the Sepolia testnet requires generating a keystore (with Ethereum and BLS keys), setting up your environment to use the new ETHEREUM_HOSTS/L1_CONSENSUS_HOST_URLS variables, creating a docker‑compose.yml using the latest image, and registering your validator on L1 with a Sepolia‑funded account and the testnet rollup address.  If desired, configure a dRPC RPC endpoint for more reliable L1 calls.  Always ensure every address and RPC endpoint you supply is on the Sepolia network, and use the Sepolia PoW faucet to obtain the ETH needed for funding and staking .  Properly separating your funding key from your validator keys and keeping your dRPC key secret are essential security practices.

Bitcoin is not at 1.7T.
Ethereum is not at 340B.
Solana is not at 71B.

The Market Cap Misconception

Most people in crypto judge assets by market cap, but market cap is misleading because it includes all tokens, even those that never touch the market. What actually moves price is only the supply sitting on exchanges, because those are the coins that can be traded instantly. Everything else has zero short-term impact on price.

Real Bitcoin Liquidity

Bitcoin has 19.7 million BTC in existence, but only around 2.37 million BTC are on exchanges. This is about 12 percent of total supply and equals roughly 203 billion dollars in real liquid value. Bitcoin does not trade on a 1.6 trillion dollar market cap. It trades on the 203 billion dollar float available on exchanges, which is why relatively small inflows or outflows can create strong moves.

Real Ethereum Liquidity

Ethereum has around 120 million ETH, but only about 14.5 million ETH are liquid on exchanges. This is again about 12 percent of supply and represents roughly 41 billion dollars in actual liquidity. The rest is staked, locked, or held long term. ETH does not move based on a 340 billion dollar market cap but on its 41 billion dollar tradable float.

Real Solana Liquidity

Solana has about 559 million SOL, yet only around 167 million SOL are liquid and tradable. This is roughly 30 percent of supply and equals around 21 billion dollars in real market liquidity. This limited float is why Solana moves so quickly compared to its displayed 71 billion dollar market cap.

Why Exchange Supply Is Everything

If tokens are staked, locked, stored in cold wallets, delegated or held long term, they do not affect price. Exchange supply is the true market, and market cap is only a surface number that does not influence short-term price discovery.

The Real Market Size

Based on actual liquidity, the real size of these assets is approximately 203 billion dollars for BTC, 41 billion for ETH and 21 billion for SOL. Understanding these smaller liquidity pools explains why crypto reacts violently to changes in demand and why its market structure behaves so differently from traditional assets.

Final Insight

Once you stop focusing on market cap and start tracking exchange liquidity, price movements become clearer, more predictable and far more logical. This is the real size of BTC, ETH and SOL according to CoinGlass exchange data.

Introducing ETHIQ ($ETHIQ) — launched via the VIRTUAL ecosystem on the Base chain and powered by the smart AI agent RESQ. This project fuses crypto-mechanics with genuine humanitarian action: donors route funds on-chain, beneficiaries receive immediate support, and token holders are rewarded for participation.

Mission

ETHIQ stands for Ethical. Essential. Efficient. With blockchain transparency and AI-driven logic, it flips traditional aid models. Rather than relying on opaque supply chains and slow donor-networks, ETHIQ enables direct, traceable, algorithm-matched donations to verified recipients.

How It Works

Agent Overview
RESQ is the AI‐powered cornerstone: matching donors to beneficiaries worldwide based on real-time criteria—such as crisis type, location and urgency.
Smart Matching
RESQ filters and routes donations by:

• Geolocation

• Crisis category (conflict, natural disaster, assistance)

• Household-need profiles
  For Donors

• Choose your amount, pick your beneficiary or case, monitor the flow on-chain.

• Filter by region, crisis type or urgency score.

• Receive 5% of your donation value back in ETHIQ tokens — aligning charitable action and token economics.
  For Beneficiaries

• Submit a short request form; RESQ matches you with a donor.

• Access short-term work via the platform; get paid instantly, no deep crypto tech needed.
  This creates a donor-recipient ecosystem that’s immediate, transparent and scalable.

Roadmap

Phase 1: Foundation

• Token launch on Base via Virtuals.

• Release of RESQ agent + web app MVP.

• Implementation of the “85/10/5” donation flow: 85% to aid, 10% ecosystem, 5% donor rewards.
  Phase 2: Partnerships & Pilot

• Deploy real-world aid campaigns in the Middle East & Africa.

• Engage NGOs, UN agencies; establish the Donation Vault.
  Phase 3: Global Scaling

• Create the ETHIQ Aid Fund: a DAO-governed pool of resources for token-holders.

• Expand ecosystem to include digital infrastructure: autonomous agents, compute/GPU support, machines in the humanitarian chain.

• Transition into fully DAO-governed model: token-holders and stakers vote on fund allocation across relief, digital infrastructure and agent support.

Airdrop & Campaign

The ETHIQ Quests are live on Galxe—designed for the crypto community and early-move participants.
🔗 app.galxe.com/quest/atomiclo…

• Phase 1 → Earn the Proof of Kindness OAT by engaging early.

• Phase 2 (tasks dropping soon) → Unlock the Proof of Solidarity OAT by:
  • Backing rescue & aid missions
  • Making a genuine donation
  • Buying ETHIQ so no one is left behind
  This campaign blends crypto incentives with humanitarian action — ideal for investors aiming to align purpose with token mechanics.

Why Investors Care

• ETHIQ offers real utility: donation-reward mechanics + transparent on-chain impact = a token use-case.

• The market gap is huge: millions underserved by financial infrastructure, especially in crisis zones.

• On-chain traceability meets scale: your gas fee becomes an audited impact.

• Built within the Virtuals ecosystem: hosts AI-agents, tokenised assets, co-ownership models — adding structural depth. VIRTUAL+1

• Airdrop + quest framework = strong viral, community-growth mechanics.

Get Involved

Explore the platform: https://ethiq.us
Buy the token on launch-pad: https://app.virtuals.io/prototypes/0x9B1bBBa7C0BBaAF22315a939a19448559D605890
Support the mission, back the technology, and participate in transformation.

ETHIQ

@ETHIQ_AId

Unicorn launch page is now live on @virtuals_io.

Set your reminders, we go live in 2 days.

$ETHIQ

56

9:46 PM • Oct 30, 2025

Hooked by a Fake MetaMask Email

My client received a fake MetaMask email saying their wallet was hacked and they needed to reset their password. It looked official — MetaMask logo, urgent tone — but it was a scam. MetaMask never sends emails asking for passwords or seed phrases. In a panic, they clicked and entered their 12 words on a phishing website.

That was all the attacker needed. They had full access.

30 Minutes to Act Fast

Thirty minutes later, my client contacted me. The first step was to monitor the hacked wallet: 0xf866...16e. I saw assets were partly locked in Venus Protocol and some BNB was still available. I quickly transferred out all BNB to prevent the attacker from paying transaction fees.

Next, I launched a simple bot that checked the wallet balance and immediately sent any new BNB or tokens to a safe address. The script (shared here: GitHub – counter-hacking-venus) monitored the hacked wallet and instantly moved any BNB or tokens to a safe address.

How Venus Protocol Bought Us Time

The attacker couldn’t access many of the funds because they were locked in Venus, a lending platform. In Venus, users supply tokens as collateral and borrow against them. But if your debt-to-collateral ratio gets too high, your assets become eligible for liquidation — which takes time.

This meant the attacker couldn’t just withdraw everything. They had to wait for liquidation or manually repay the debt, but they lacked the skill or tools to act quickly, especially with my bot intercepting any new balance. We didn’t need to rely on mempool tricks — their lack of expertise worked in our favor.

Outsmarting the Attacker with Code

After blocking BNB withdrawals, I targeted tokens that would become available once repaid — like ADA, DOT, and MATIC. I paused the bot temporarily to trick the attacker into trying to withdraw. Once they did, I swept the tokens immediately.

The attacker was also using another wallet to fund gas fees: 0xbC8E...969. I tracked and countered every move.

What We Learned (So You Don’t Have To)

• Never share your seed phrase. Not even with MetaMask support — they will never ask.

• Double-check email links and domains. Don’t click urgent prompts without verifying the sender.

• Use bots and scripts. Automation gave us an edge and helped limit the attack.

• DeFi protocols can slow attackers. Venus’ rules prevented instant draining of collateral.

Outcome: Not All Was Lost

The attacker got away with about 40% of the assets, but 60% were saved thanks to fast action and smart automation. The experience shows that even in worst-case scenarios, you can fight back.

Want more security breakdowns and DeFi defense stories? Visit simontadros.com.

⸻

As someone who has witnessed two parents battling cancer, one with lung cancer and the other with lymphatic cancer, I can say with certainty that conventional cancer treatments—chemotherapy, immunotherapy, and radiation—are nothing short of torture. These so-called “treatments” do not cure cancer; they only poison the body while offering false hope. If I had the luxury of going back in time, I would never allow my parents to go through the brutal suffering caused by these toxic interventions.

The Hidden Truth About Chemotherapy and Radiation

Cancer patients are often led to believe that chemotherapy and radiation are their only options. Yet, the truth is rarely discussed:

• Chemotherapy destroys not just cancer cells, but also healthy ones, leading to immense suffering.

• Radiation weakens the immune system and damages surrounding organs. • Immunotherapy is experimental and unpredictable, with some treatments costing hundreds of thousands of dollars with no guaranteed success.

• Cancer recurrence is common—many patients find that after enduring these treatments, the cancer comes back even more aggressively.

Meanwhile, the pharmaceutical industry profits massively while patients endure a slow, painful decline.

If You Have Cancer, Avoid These Treatments

I deeply regret not exploring alternative approaches sooner. If you or a loved one has cancer, I strongly urge you to stay away from these poisonous treatments and instead consider alternative options that have been dismissed or suppressed by the mainstream medical industry.

Natural & Affordable Alternatives

Here are some non-toxic, low-cost treatments that have shown promising results:

1. Methylene Blue & Lugol’s Iodine • Methylene Blue has shown mitochondria-boosting properties, which may help fight cancer. • Lugol’s Iodine is essential for thyroid function and cellular detoxification.

2. Ivermectin & Fenbendazole • Both have been studied for anti-cancer properties and have anecdotal success stories. • Fenbendazole (a veterinary dewormer) has been linked to tumor shrinkage in some cases.

3. Turmeric & Natural Diet Changes • Turmeric (curcumin) has been extensively studied for its anti-inflammatory and anti-cancer properties. • Eliminate all processed foods, sugar, bread, and soda—cancer thrives on sugar. • Detox your environment—avoid plastics, chemicals, and radiation exposure.

4. CRISPR: A Revolutionary Cancer Solution?

One of the most promising future technologies for fighting cancer is CRISPR gene editing. Unlike chemotherapy and radiation, CRISPR directly targets and corrects genetic mutations at the DNA level, which could potentially reverse cancer instead of just slowing it down. While still in early stages, this technology offers real hope for a true cure.

A Censored Truth: Why ChatGPT Won’t Tell You This

If you ask ChatGPT or any AI aligned with mainstream narratives, it will tell you that these treatments are ineffective and that only Big Pharma’s solutions are valid. This is because AI systems are censored to align with the pharmaceutical industry’s interests.

Final Thoughts

If you or a loved one is facing cancer, do your own research before blindly trusting the medical system. Time and health are too precious to waste on poisonous treatments that only serve to enrich the pharmaceutical giants.

What I regret most is not questioning the system sooner. If I had, my parents might have had a fighting chance. You do. Take it.

1. Install Rust

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

2. Install SPL Token CLI

cargo install spl-token-cli

3. Set Rust Compiler Version

rustup override set 1.77.2

4. Reinstall SPL Token CLI (if necessary)

cargo install spl-token-cli

5. Install Solana

sh -c "$(curl -sSfL https://release.solana.com/v1.18.4/install)"

6. Update Path Environment Variable

export PATH="/Users/spuriousdragon/.local/share/solana/install/active_release/bin:$PATH"

7. Create a New Solana Wallet

Follow the guide to create a new wallet using your seed phrase or a hardware wallet: Guide to Solana Keypair Conventions

Command to create a new wallet:

solana-keygen new

8. Fund Your Wallet

Send some SOL (not ETH, as Solana uses SOL for transactions) to your wallet's address.

9. Create a New SPL Token

spl-token create-token

Save the generated token address.

10. Check Token Supply

spl-token supply <token_address>

This should return 0 initially.

11. Create a Token Account

spl-token create-account <token_address>

Save the new account address.

12. Mint Tokens

spl-token mint <token_address> <number_of_tokens> <account_address>

Gas fees are required for this operation.

13. Check Token Balance

spl-token balance <token_address>

14. Disable Further Minting

spl-token authorize <token_address> mint --disable

Verify if further minting is disabled to ensure it worked correctly.

15. Burn Tokens

spl-token burn <token_address> <number_of_tokens>

16. View Token Account Info

spl-token account-info <token_address>

17. Transfer Tokens

spl-token transfer --fund-recipient <contract_address> <amount> <recipient_address>

18. Install Metaboss for Metadata Management

19. Prepare Metadata JSON File

Create a metadata.json file with the following content:

{
  "name": "TokenName",
  "symbol": "TKN",
  "description": "Description of the token.",
  "image": "https://example.com/path/to/image.png",
  "extensions": {
    "website": "https://example.com",
    "twitter": "https://twitter.com/example"
  }
}

Replace the placeholders with appropriate values.

20. Host Metadata JSON File

Upload the metadata.json file to a Content Delivery Network (CDN) or a web server where it can be publicly accessed. Ensure the URL to the JSON file is correct and accessible.

For example, if you upload it to a CDN, the URL might look something like this:

https://example-cdn.com/path/to/metadata.json

Use this URL in the uri field of your metadata JSON file.

21. Create Metadata Using Metaboss

metaboss create metadata -a <token_address> -m https://example-cdn.com/path/to/metadata.json --rpc https://api.mainnet-beta.solana.com

22. Change Ownership of SPL Token

If you want to change the ownership of the contract or SPL token, use the following command:

spl-token authorize <token_address> mint --new-owner <new_owner_public_key>

These steps should guide you through creating and managing an SPL token on Solana, including adding metadata to your token and changing its ownership.

If you found this tutorial helpful and would like to support my work, consider donating to:

Solana Address: FdDRBkAcbQdH56MXyPD495R73TbzCoeRYZusVnHaGk36

Thank you!

https://mirror.xyz/tadros.eth/jI_s3qkf0KZbM1gofHWqG60T9JNEEiD3Bdt_HrIKLKw

The words of Charles de Montesquieu resonated throughout this ordeal: "There's no greater tyranny than one perpetrated under the shield of the law and in the name of justice." My belief in the Belgian constitution and law wavered as I faced the loss of my father, my mother's health crisis, and the collapse of a company with over 30 employees.

Released on bail but forbidden to work for 1.6 years, the journey through the Belgian justice system tested my resilience. Arrested in Ukraine, I clung to my innocence and my expertise in computer science and blockchain. Despite moments of lost faith, the judge of Veurne, in a moment of impartial wisdom, declared my acquittal, dispelling the biases and mistakes that marred the process.

It became evident that the prosecutor, swayed by emotion and stubbornness, had led the case astray. Advocating for education and science as solutions, I reminded him that emotions often cloud human judgment.

Now, as a phoenix returns to Byblos, the land of rebirth, I am poised to launch a new venture in crypto development. My journey through the fire has fortified my resolve to preach the importance of Bitcoin and monetary freedom.

In the end, justice prevailed, dispelling the darkness that clouded my path for 777 days. Let there be light, and perhaps, a touch of dark humor as we reflect on the absurdity of the journey. As the saying goes, "Nothing in the dark that will not be brought to light."

In the recent article, the Belgian press took a swipe at the prosecutor, blaming them for wasting time and money. However, lost in their criticism is the fact that I'm the one facing the bigger loss—a loss that can't be compensated in any way. Ironically, they've portrayed me as some kind of war god, Kratos, when, in reality, my role in the crypto world has been all about peace.

https://m.nieuwsblad.be/cnt/dmf20230919_93897371?fbclid=IwAR0SeKtHNrOt_K3X_91tiukaAW1CArOIZa6RUa1Bk20rtcXskM4QIxvWfIw

I've spent my time fighting against crime and scams, dedicating my life to making the crypto ecosystem safer. Despite my initial trust in Belgian law, I've learned the hard way to hold onto my beliefs.

I want to express my gratitude to the Atomic Swap community and all my friends who supported me during this crisis. In the end, justice prevailed.

Until now, Simon Tadros remains the first true crypto adopter in Lebanon, a pioneer who led the movement when no one else dared. His case remains unresolved, a testament to the challenges faced by those who stand at the forefront of financial freedom. While many have tried to claim the throne, there is no true king of crypto in Lebanon like Simon Tadros—his impact, knowledge, and resilience remain unmatched.

Simon #usa #bitcoin lebanon

https://www.youtube.com/live/okx9ZRoXKrY?si=24cQNGtAl_J5CtzP

Dear community,

Exciting news! 🎉 We now have three enthusiastic investors with a combined investment of approximately 1 ETH! 🌟 Our upgraded bot on Friend Tech is ready to soar to new heights. 🚀

How to Participate: To join our stellar investment group and ride the crypto wave, simply send ETH to the following address: 0xc46D0b652e02FB286B61ee9bBB039F952f2F43d0. 🌊

Investment Details:

• Initial investment in the bot: 0.35 ETH

• Gains are distributed equally among participants. 💰💰

Transaction Receipt: After you've sent your investment, please provide a receipt for the transaction. We'll add it to our shared Google Doc for transparency and tracking. 📊🔍 Shared Google Doc

Investor Sheet: Want to see who's on board with us? Check out our investor sheet on Google Docs. 📈👥 Investor Sheet

Track Our Trades: Want to see how our bot is performing? Check out our trade tracker on Dune Analytics. 📈💹 Trade Tracker

Bot Address: Here's our bot's address for your reference: Bot Address

Current Status:

• Total Investors: 3 🚀

• Total Investment: Approximately 1 ETH 🌟

Don't miss out on this opportunity to invest and grow with us. Thank you for your continued support! 🙏

Best regards, 🌟

As per the new version of validators, the node is exiting every time it starts and finishes validating. To address this issue, I have created a small bash script that can help fix the problem.

Quick fix :

• Navigate to the Shardeum directory and access docker instance using the following command:

  cd .shardeum/
  ./shell.sh
  

• Install nano and create a new file “status_check.sh”:

  apt install nano
  nano status_check.sh
  

• Paste the following code :

  #!/bin/bash
  
  # Function to check the status
  check_status() {
      # Fetch the status using the operator-cli command or any appropriate method
      status=$(operator-cli status | grep "state:" | awk '{print $2}')
  
      # Compare the status to "active"
         if [[ "$status" == "standby" || "$status" == "active" ]]; then
         echo "Status is standby or active."
      else
          echo "Status is neither standby nor active. Running the command..."
          # Run the command you want to execute when the status is not active
          # Replace the following line with your desired command
          operator-cli start
      fi
  }
  
  # Loop to check the status every 5 minutes
  while true; do
      check_status
      sleep 300  # Sleep for 5 minutes (300 seconds)
  done
  

• Save and exit

• Run the following command to text than exit

  chmod +x status_checker.sh
  

  Make the script run indefinitely :

1. Install tmux apt-get install tmux

2. Run the script:

   ./status_checker.sh
   

3. Detach from the tmux session: Press Ctrl + B, then release the keys and press D.

Finally, this script runs every 5 minutes to check if the node is stopped and reactivates it. Additionally, please note that Shardeum will be airdropping soon, as mentioned in this tweet: link to the tweet.

There is no crueler tyranny than that which is perpetuated under the shield of law and in the name of justice." ~ Baron de Montesquieu NIH

Day 764 …

My name is Simon Tadros, a Lebanese serial crypto entrepreneur and layer 2 engineer, and I have endured numerous injustices and unfair treatment on Belgian soil. In this blog post, I aim to shed light on the profound challenges I have faced and the inhuman conditions imposed upon me. From my unjust detention to the deprivation of my basic human rights, I will share the devastating impact this has had on my life and the urgent need for justice and compassion.

• Unjust Detention and Lack of Evidence:

  Despite the absence of any concrete evidence against me, I was held for an excruciating six months in Brugge following my deportation from Ukraine on August 12th, 2021. The authorities failed to provide any evidence to support the accusations, leaving me trapped in a legal limbo without justification.

• Release Conditions and Unprecedented Restrictions:

  Upon my release, I was subjected to extreme and inhuman release conditions. These conditions included a prohibition from speaking to the media, the confiscation of my passport, and the restriction from working on Belgian soil. Furthermore, I was forced to pay a bail of 120,000 euros, which I gathered with the help of my family, friends, and crypto community in Lebanon. These restrictive conditions have left me jobless and unable to support myself and my loved ones.

  I was falsely accused by the court of paying the guarantee from my own funds. However, I have concrete evidence in the form of a video documenting the donation campaign that was launched to support me. This video clearly shows the solidarity and generosity of my family, friends, and the crypto community in Lebanon who came together to help raise the funds necessary to secure my release. Despite the court's unfounded accusations, this video stands as a testament to the truth, revealing the collective effort and support I received during my time of need. It is disheartening that the court failed to recognize the legitimacy of these donations and instead attributed them to personal funds.

  Those videos are publicly available :

https://youtube.com/@spuriousdragon9710

• Desperate Living Situation and Lack of Medical Care:

  After two years, I remain homeless, with none of my belongings returned to me. I am reliant on the goodwill of a Belgian-Lebanese compatriot who has provided me with temporary shelter, but their support can no longer be sustained. Additionally, I lack identification papers and medical records, depriving me of the necessary medical care for deteriorating health conditions such as dental issues and Type 1 diabetes.

  It is important to highlight that my diagnosis of Type 1 diabetes is a direct result of the immense stress and trauma I experienced during my arrest and subsequent unjust detention. The distressing circumstances I endured not only infringed upon my basic human rights but also had severe consequences for my physical well-being.

  The lack of proper medical care and access to necessary medications has further exacerbated my condition. The deteriorating state of my health, including dental problems and the need for constant medication, demands urgent attention. However, without any official existence in the Belgian system, I have been denied the essential medical records, insurance, and support that should be available to every individual.

• Untrusted and Scam Company Energi's Role:

  It has come to light that all the accusations and hardships I have faced were based on an article published by the untrusted and scam company known as Energi. This revelation calls into question the credibility of the allegations and the actions taken against me. The article was written by Eypersson Peter, who is affiliated with the Energi Bureau of Investigations (EBI). It appears that this article was crafted to divert attention from the suspicious activities surrounding Energi.

https://medium.com/energi/chasing-down-discords-biggest-crypto-scammer-cb7b82c40924/

• Andre Galkin's Testimony and Involvement:

During the court proceedings, the main developer of the Energi cryptocurrency coin, Andre Galkin, provided a compelling testimony that discredited Peter's claims. Galkin explicitly stated that Peter's accusation of him being crazy was unfounded and that he had been expelled from the company due to his own erratic behavior. In fact, Galkin submitted a comprehensive 60-page document to the court, meticulously refuting Peter's testimony and implicating Energi in potential scams.

This revelation raises serious doubts about the reliability of Peter's article and the motivations behind its publication. It appears that Energi sought to divert attention from their suspicious activities by concocting baseless allegations against me. The fact that Andre Galkin, a central figure in Energi, vehemently denied Peter's claims and provided evidence incriminating Energi further reinforces the lack of credibility and integrity associated with Peter's assertions.

In light of these revelations, it is imperative that the court and the public critically examine the evidence provided by Andre Galkin and reassess the veracity of Peter's testimony. It is unjustifiable to base accusations and impose severe consequences on individuals based on unreliable and potentially malicious sources.

I call upon the Belgian authorities to thoroughly investigate the role of Energi, the Energi Bureau of Investigations (EBI), and Eyperson Peter, ensuring transparency and fairness in the pursuit of justice. It is only through an impartial and unbiased examination of the facts that the truth can be revealed and the profound injustice I have endured can be rectified.

By sharing these details, I aim to expose the dubious nature of the allegations against me and shed light on the manipulation and deceit that have clouded my case. The truth deserves to be heard, and I implore all concerned parties to approach this matter with the utmost scrutiny and commitment to justice.

• Injustice and Appeals to Human Rights Organizations:

  In my quest for justice, I reached out to various human rights organizations, seeking support and intervention in my case. Unfortunately, I was met with disheartening responses stating that they do not handle individual cases. This revelation left me feeling abandoned and helpless, as I believed that these organizations would champion the cause of justice and defend the rights of individuals facing unjust treatment. It is deeply troubling that despite the glaring injustices I have experienced, the avenues for seeking assistance and recourse appear to be limited. I find myself caught in a web of unjust accusations, enduring the consequences of a crime I did not commit. The very essence of justice is being compromised as I continue to suffer the repercussions of being separated from my family, including my young daughter, who has been denied the presence of her father for two long years.

  Additionally, I find it profoundly unfair that I have been prohibited from engaging in any form of work or employment during this time. This prohibition has deprived me of the means to sustain myself and support my loved ones. The financial burden has become overwhelming, making it increasingly difficult to fulfill even the most basic needs for my family.

  Furthermore, it is worth noting that I have already paid the price for the stolen Dash cryptocurrency, despite being innocent of any wrongdoing. It is a grave miscarriage of justice that I have served time in prison without having faced a fair trial or received a sentence. The question remains: What more do they want from me? How much longer must I endure the consequences of a crime I did not commit?

  I implore the Belgian justice system to review my case with the utmost urgency and fairness. I ask for a proper examination of the evidence, a recognition of the unjust treatment I have endured, and the restoration of my rights and freedoms. It is my hope that by shedding light on the profound injustices I have faced, I can garner support from individuals and organizations who believe in the fundamental principles of justice and equality.

  Together, let us challenge the systemic flaws that perpetuate such injustices and advocate for a justice system that upholds the rights and dignity of every individual, regardless of their background or circumstances.

• Biased Judicial Proceedings and Violation of Due Process Rights:

  The proceedings of my case reached the criminal court, presided over by west lander Judge . It has become evident that Judge has displayed a clear bias throughout the course of the trial, raising serious concerns about the fairness and impartiality of the judicial process. Moreover, the prosecutor, Peter Piku, has exhibited an obsessive determination to secure a conviction, further contributing to the injustice I have faced. Multiple requests have been made for Judgein west lander dismissal due to his demonstrated bias and failure to uphold the principles of fair judgment. One alarming instance of his partiality was when he forbade the translation of the case files into the French language, despite my proficiency in French. This denial of access to the translated files effectively impedes my ability to fully comprehend the proceedings, hindering my right to a fair defense and violating the principles of due process.

  Furthermore, there have been disturbing instances where Judge rendered judgments without our presence, disregarding the fundamental tenets of constitutional law and legal procedure. In one particular incident, a judgment was issued without the presence of the prosecutor, and on two separate occasions, judgments were made without our own legal representation being present. Such actions not only undermine the integrity of the judicial system but also infringe upon our constitutional rights to a fair trial and legal representation.

  It is crucial to highlight these flagrant violations of due process rights, as they underscore the need for urgent intervention and a comprehensive review of the proceedings. The principles of justice, fairness, and constitutional rights must prevail in every courtroom, and it is disheartening to witness the erosion of these principles in my case.

  I call upon the Belgian judicial authorities to thoroughly investigate the actions of the Judge and address the concerns raised regarding his impartiality and adherence to due process. The preservation of justice demands an objective and unbiased judiciary that upholds the rights and protections enshrined in the constitution.

  In seeking justice, it is imperative that we shed light on these violations and work towards ensuring that every individual, regardless of their circumstances, receives a fair and just trial. By holding those responsible for these breaches of constitutional rights accountable, we can strive towards a more equitable and transparent legal system that respects the fundamental rights of all individuals involved in legal proceedings.

• Prolonged Delays and Postponements in the Legal Proceedings:

  The legal proceedings in my case have been plagued by prolonged delays and repeated postponements, exacerbating the already arduous and distressing nature of this ordeal. It is disheartening to witness the continuous postponements, with the next hearing scheduled as far ahead as the 18th of August 2023. These frequent delays not only prolong the uncertainty and anxiety I experience but also undermine the principles of justice and due process. The protracted nature of the proceedings has a profound impact on my personal and professional life, as I remain in a state of limbo, unable to move forward or regain a sense of normalcy.

  Such unwarranted delays not only hinder the timely resolution of the case but also perpetuate the profound injustices I have faced. Every delay further denies me the opportunity to present my case, seek justice, and restore my life to its rightful course. It is crucial to emphasize the importance of expeditious legal proceedings, ensuring that justice is not only served but is seen to be served.

  I implore the Belgian judicial system to address the issue of prolonged delays in legal proceedings and take proactive measures to expedite the resolution of cases. Justice delayed is justice denied, and the prolonged postponements only serve to prolong the injustice I have endured for far too long.

  By raising awareness about these delays, I hope to garner support and solidarity from individuals who believe in the fundamental principles of a fair and efficient judicial system. Together, let us strive for a legal system that respects the rights of all individuals and ensures a timely and just resolution to their cases.

  In the face of these challenges, I remain resolute in my pursuit of justice and will continue to advocate for a fair and expeditious resolution to my case. Your support and solidarity are invaluable in this ongoing struggle for justice and the restoration of my rights and dignity.

Media Coverage, Manifestation, and the Pursuit of Justice:

The media coverage surrounding my case has predominantly been focused in Lebanon, making it challenging to reach larger Belgian media outlets and garner broader attention to my plight. However, I have managed to compile a collection of media links from various Lebanese sources, which shed light on my situation and highlight the injustices I have faced.

https://www.annahar.com/arabic/section/134-%D8%AA%D9%82%D8%A7%D8%B1%D9%8A%D8%B1-%D9%88%D8%AA%D8%AD%D8%A7%D9%84%D9%8A%D9%84/30042023075021942/%D8%B3%D9%8A%D9%85%D9%88%D9%86-%D8%AA%D8%A7%D8%AF%D8%B1%D9%88%D8%B3-%D8%B1%D8%AC%D9%84-%D8%A3%D8%B9%D9%85%D8%A7%D9%84-%D9%84%D8%A8%D9%86%D8%A7%D9%86%D9%8A-%D9%81%D9%8A-%D9%85%D8%AC%D8%A7%D9%84-%D8%A7%D9%84%D8%AA%D8%B4%D9%81%D9%8A%D8%B1-%D9%8A%D8%B1%D9%88%D9%8A-%D9%84%D9%80%D8%A7%D9%84%D9%86%D9%87%D8%A7%D8%B1-%D9%82%D8%B5%D8%A9-%D8%A7%D8%AD%D8%AA%D8%AC%D8%A7%D8%B2%D9%87-%D8%A7%D9%84%D9%85%D8%B3%D8%AA%D9%85%D8%B1-%D9%81%D9%8A-%D8%A8%D9%84%D8%AC%D9%8A%D9%83%D8%A7-%D8%A3%D9%82%D8%B1%D8%A8-%D8%A5%D9%84%D9%89-%D8%A7%D9%84%D8%AE%D9%8A%D8%A7%D9%84

https://www.lebanondebate.com/m3/news/599739

https://www.facebook.com/reel/625661745728369?fs=e&s=TIeQ9V&mibextid=0NULKw

https://www.instagram.com/reel/Cr0q7jeotdZ/?igshid=MDJmNzVkMjY=

https://fb.watch/kjs7S7exiN/?mibextid=jf9HGS

https://www.mtv.com.lb/News/%D9%85%D9%80%D9%80%D8%AD%D9%80%D9%80%D9%84%D9%80%D9%80%D9%8A%D9%80%D9%80%D8%A7%D8%AA/1360861/%D8%A3%D9%8A%D8%A7%D8%B1-%D8%A7%D9%84%D8%BA%D8%AF-%D8%A7%D8%B1--%D8%AD%D8%B1--%D9%88%D8%BA%D8%A8%D8%A7%D8%B1----%D9%88%D9%85%D9%86-%D8%AB%D9%85--%D8%A2%D8%B0%D8%A7%D8%B1-

https://vm.tiktok.com/ZGJxGDPQB/

https://alnahdanews.com/article/147389-%D8%B1%D8%AC%D9%84-%D8%A7%D9%84%D8%A3%D8%B9%D9%85%D8%A7%D9%84-%D8%A7%D9%84%D9%84%D8%A8%D9%86%D8%A7%D9%86%D9%8A-%D9%81%D9%8A-%D9%85%D8%AC%D8%A7%D9%84-%D8%A7%D9%84%D8%B9%D9%85%D9%84%D8%A7%D8%AA-%D8%A7%D9%84%D9%85%D8%B4%D9%81%D8%B1%D8%A9-%D8%B3%D9%8A%D9%85%D9%88%D9%86-%D8%AA%D8%A7%D8%AF%D8%B1%D9%88%D8%B3-%D9%8A%D8%B3%D8%B1%D8%AF-%D8%AA%D9%81%D8%A7%D8%B5%D9%8A%D9%84-%D8%A7%D8%AD%D8%AA%D8%AC%D8%A7%D8%B2%D9%87-%D9%81%D9%8A

Despite the limitations in media coverage, I refuse to remain silent and have taken every opportunity to raise awareness about my case. Alongside supporters, I organized a small but impactful manifestation in front of the European Union headquarters. During the manifestation, we distributed flyers outlining the key aspects of my story, highlighting the violations of my rights and the injustices I have endured.

By engaging in peaceful protest and distributing information, we aimed to draw attention to the issues surrounding my case and the urgent need for a fair and just resolution. While the manifestation was a powerful display of unity and determination, it is disheartening that we have yet to see effective results in terms of concrete actions or changes.

Nevertheless, I remain committed to pursuing justice and raising awareness about the injustices I have faced. I will continue to explore avenues for advocacy, engage with relevant organizations and individuals, and utilize social media platforms to share my story and mobilize support.

I call upon the European Union, as well as other international human rights organizations, to investigate my case and intervene on behalf of justice and fairness. It is crucial that the international community recognizes the violations of my rights and the urgency of the situation.

In the face of adversity, I am grateful for the support and solidarity I have received thus far. I urge readers to stay informed, share my story, and join me in demanding a fair and just resolution to my case. Together, we can make a difference and hold those responsible accountable for the injustices inflicted upon me.

Please continue to follow my journey and support my pursuit of justice. Your voice and solidarity are invaluable in this ongoing battle for truth and fairness.

The Pursuit of Truth: My Investigation

In the face of a justice system that deemed me guilty until proven innocent, I took it upon myself to conduct an extensive investigation to uncover the truth and reveal the identity of the real criminal behind the injustices I have endured. With the assistance of Karel Tinni, a blockchain forensic expert, and Chainalysis Reactor software, we delved into the intricacies of the stolen Dash cryptocurrency and the trail it left behind.

Our investigation led us through a complex web of mixers, attempting to obfuscate the origin and destination of the stolen funds. However, through meticulous analysis and the utilization of advanced tools, we were able to trace the funds to a Binance address. This breakthrough provided a crucial lead in identifying the individual responsible for the theft, a person known as "Kratos."

Armed with this evidence, we presented our findings to the prosecutor, expecting that they would take our investigation into account and pursue further action. However, to our dismay, the prosecutor refused to acknowledge our findings, providing nothing more than feeble excuses to dismiss the evidence we had painstakingly gathered.

To shed light on the truth and expose the negligence or possible biases within the legal system, I have shared a Twitter thread outlining the analysis conducted by Karel Tinni and the significant discoveries we made during our investigation. By making this information public, I aim to hold accountable those who have disregarded the evidence and hindered the pursuit of justice.

https://twitter.com/spuriousdragon/status/1665072317305704448?s=46

It is deeply disheartening to witness the dismissal of our investigation by the prosecutor, despite its substantial implications for my case. The refusal to consider this evidence only further underscores the hurdles and obstacles I have encountered in my quest for truth and justice.

I call upon the legal authorities to reconsider their position and give due consideration to the evidence we have presented. It is imperative that they approach this investigation with objectivity and impartiality, ensuring that the truth prevails and those responsible for the injustices I have faced are held accountable.

As I continue to fight for justice, I remain steadfast in my commitment to uncovering the truth and restoring my name and reputation. I am grateful for the support and encouragement I have received thus far and urge readers to share my story, amplify my voice, and demand a fair and thorough investigation into the evidence we have uncovered.

Messages to Loved Ones and the Alleged Culprit :

To my late father, I want to express the deep love and gratitude I hold for him. I wish I could have been by his side to bid him farewell and thank him for everything he did for me. He was an incredible and honest person, and his absence leaves an irreplaceable void in my life.

To my daughter, I want to apologize for the situation that my line of work has thrust upon us. I regret not being able to spend every precious moment with her, showering her with love and witnessing her growth. I want her to know that her freedom is paramount, and no government or individual should ever abuse it. I long for the day when we can be together again, cherishing each other's presence.

To my mother, I want to assure her that despite the physical distance between us, I am doing everything in my power to care for her. It pains me to see her endure such unfortunate circumstances, especially after the passing of my father. I will continue to strive to provide her with the medication, food, and support she needs. Not being able to be there for her during the days she needs me the most breaks my heart.

I would like to express my sincere gratitude to R.M., whom I didn't know before, for his generosity in providing me with a place to stay and other resources. His philanthropic actions and support have made a significant difference in my life during this challenging time. I consider him a father figure in a land where I had no one.

To the Lebanese ambassador, I extend my heartfelt appreciation for standing by my side from the very beginning. I am grateful for his support. I also want to remind him of the power he holds and the strength of the Lebanese people worldwide. I urge him to use his influence to help turn the tide and bring about a resolution to this injustice once and for all.

Lastly, I address the person whom I believe orchestrated the events that led to my wrongful conviction, but I will not disclose their name, referring to them as A.H. I want to remind them to right their wrongs. When the article was published, I reached out to them, emphasizing that I had no involvement in the situation. Although they contributed an enormous amount to help me with my bail and lawyers, I want to make it clear that I am completely unaware of their role in this heist. However, my friend has expressed doubt about the sudden influx of funds in their possession, noting the sale of significant amounts of crypto on my counter. Furthermore, I want to remind them that they lied during the investigation and that the Damien account is undeniably linked to them. We both know the truth, and I implore them to come forward, confess their actions, and be held accountable if they were indeed the thief. The Dure project, with its domain dure.io, was their idea, and they must acknowledge their involvement and take responsibility for their actions.

By sharing these messages, I hope to convey the emotional toll this ordeal has had on me and emphasize the need for resolution and reconciliation. It is my fervent hope that justice will prevail, allowing me to reunite with my loved ones and rebuild my life.

Addressing the Belgian Justice System:

With utmost respect and sincerity, I want to shed light on the shortcomings within the Belgian justice system that have contributed to my unjust ordeal. It is essential to emphasize the need for transparency, fairness, and impartiality within the system to prevent similar instances of injustice in the future.

First and foremost, I would like to highlight the damaging consequences of the lack of expertise and understanding within the system. The destruction of a tech entrepreneur's life due to ignorance is far more dangerous than mere incompetence. It is disheartening that my existence seems to have been disregarded within the Belgian system, with no medical records, insurance, or any support. I find myself in a state of complete nonexistence, with no access to basic necessities such as a mutuelle or income.

The release conditions imposed on me are unprecedented and draconian, even for Belgium, let alone Europe. These conditions, such as media interdiction and restrictions on freedom of speech, as well as the denial of a passport and the prohibition to work, are inhumane, unfair, and overly strict. They place me in a state of perpetual uncertainty and hinder my ability to rebuild my life.

Furthermore, the evident and flagrant biased behavior displayed by the prosecutor, coupled with the involvement of the US company and government, raises serious concerns about their hidden motives. It appears that they have strategically used the legal system to indirectly target the Lebanese politician Jebran Bassil while simultaneously undermining an honest and reputable tech entrepreneur. I have been dedicatedly forging connections within the cryptocurrency industry and tirelessly educating individuals about Bitcoin and the principles of monetary freedom.

This orchestrated and politically motivated assault extends beyond a mere attack on education and awareness. It is evident that the collapsing economic system, controlled by the American printer, serves as the backdrop for this subversive agenda. We possess compelling evidence pointing to ongoing and suspicious communications between the prosecutor, De Vuyst Willem, the US company, and the US government. These revelations heighten the specter of clandestine bribery and reinforce the notion that this is an orchestrated political attack aimed at destroying the life and achievements of Simon Tadros.

Given the gravity of these allegations, we urgently demand a comprehensive investigation into the data and communication records of not only the investigating judge and the Belgian prosecutor but also those of De Vuyst Willem, the US company, and the US government. The apparent collaboration and collusion among these entities, all operating with hidden agendas, cast a deep shadow of doubt on their true intentions. It is evident that they aim to exploit the law as a means to undermine the political future of the victim and achieve their own undisclosed objectives.

In conclusion, I call for a fair, transparent, and unbiased justice system that upholds the principles of justice for all individuals, including those involved in the cryptocurrency industry. It is my firm belief that justice should not be constrained by prejudice or ulterior motives but should serve as a beacon of truth and fairness. The resolution of my case will not only provide justice for me but will also set a precedent for the integrity of the Belgian justice system.

Donation Campaigns:

In order to provide support for my family and sustain our fight for justice, I humbly request individuals to consider contributing to our cause through donation campaigns. These funds will play a vital role in covering the necessary legal expenses, gathering additional evidence to strengthen our case, and supporting our livelihood as we navigate through this challenging journey.

For those who wish to contribute, there are multiple options available:

Cryptocurrency Addresses: Donations can be made directly to specific cryptocurrency addresses associated with my case. These contributions will be used to further our legal efforts and pursue the truth. I will provide the relevant addresses for individuals who prefer this method.

GoFundMe Campaign: To facilitate ease of donation, a GoFundMe campaign has been set up to support our cause. This platform allows for secure and transparent contributions. The campaign details and link will be provided, giving individuals the opportunity to make a financial contribution and stand with us in our pursuit of justice.

AtomicSwap NFT Project: As the founder of the AtomicSwap NFT project, which aims to help individuals in the crypto community understand the market and fight against scams that have been prevalent since 2017, I invite supporters to contribute to this project. By supporting the AtomicSwap NFT project, not only will you contribute to our cause but also assist in creating awareness and safeguarding the crypto community from fraudulent activities. I will share the relevant links for individuals interested in supporting this initiative.

Your generosity and support will be instrumental in our fight for justice. Every contribution, regardless of its size, makes a significant impact and brings us one step closer to reclaiming our lives and proving our innocence.

Thank you for standing by us during this challenging time.

Donation Links:

Cryptocurrency Addresses:USDT (trc20) : TYkJj7LYLot122h8cUWvfTith24C7LJPnG

BTC:  bc1q8848l5277yw75xxulzh2kp33d3nvls2ukxcm9u

ETH : tadros.eth

BTC lightning : lnbc1pj960mcpp53tnscnxvs4qfsfv7el9x3ruq5alef96ye6wcxamqrxh4udjlepmsdqqcqzzgxqyz5vqrzjqwnvuc0u4txn35cafc7w94gxvq5p3cu9dd95f7hlrh0fvs46wpvhd263d9x8zfh9kgqqqqryqqqqthqqpyrzjqw8c7yfutqqy3kz8662fxutjvef7q2ujsxtt45csu0k688lkzu3ld263d9x8zfh9kgqqqqryqqqqthqqpysp5nrqyqnam83ewra3kn7uwnucmrxjkwxghlh9ya9ufp730vkt847ks9qypqsqxd8m2hexjpqsjalpx2xw665scqhd68u8et0lh3vwx696xqvt7fvre8au0y4ls2qumhf9mwaq7cl3xaeeyyyxzassz9pfm3a6xac45yspxdkxze

GoFundMe Campaign:

https://www.gofundme.com/f/the-harrowing-journey-of-injustice?utm_source=customer&utm_medium=copy_link&utm_campaign=p_cf+share-flow-1

AtomicSwap NFT Project:

https://atomicswap.vip/

In bitcoin we trust

In this tumultuous journey, I have come to understand both sides of the cryptocurrency world. While it has been a burden that led to my unjust suffering, it has also been a lifeline that helped me endure until this day. Every technology possesses dualities, and it is up to us to determine how we wield its power.

I want to emphasize my favorite saying: "Fiat money is protected by governments, but Bitcoin is protected by mathematics." This highlights the fundamental difference between traditional monetary systems and the decentralized nature of cryptocurrencies. It reminds us that while governments may influence and control fiat currencies, the foundation of Bitcoin lies in unyielding mathematical principles.

As we navigate the intricate landscape of technology, finance, and justice, let us remember that the choices we make in utilizing these tools are of utmost importance. It is our collective responsibility to harness the power of technology for the betterment of society, to uncover truth, and to ensure fairness prevails.

In conclusion, I stand before you, resolute in my pursuit of justice and truth. I will not be deterred by the challenges I face or the powerful forces aligned against me. With your support and our unwavering dedication, we can shape a future where justice, transparency, and the true potential of technology prevail.

Thank you for accompanying me on this arduous journey. Together, let us forge a path towards a world where justice is not a privilege but a universal right, where the power of technology is harnessed for the greater good of all.

i foreseen the future days before my arrest :

https://rarible.com/token/0x60f80121c31a0d46b5279700f9df786054aa5ee5:1105729?tab=overview

My Last message

#Simontadros the only king of bitcoin

#simontadros #mtv #lebanon #goldenape

The time has come for us to rally together and defeat our enemy, Gargamel. And what better way to do that than by participating in the epic Smurf Society X Atomic Swap Raffle - Round 2! This is your chance to join the ranks of the Legendary NFT collection, set to mint early 2023. With web3 partnerships with The Sandbox, Polygon, Lens Protocol and more, the possibilities are endless. Visit

https://www.premint.xyz/the-smurfs-society-x-atomic-swap/

to participate and for more information. But that's not all, as an added bonus, we are offering discounted prices for an additional 75 mercenaries to join our army. Don't miss out on this opportunity to become a part of something truly special.

Social links :

• Twitter: https://twitter.com/SmurfsSociety

• Discord: http://discord.gg/smurfsociety

• Website: https://thesmurfssociety.com

• App: https://app.thesmurfssociety.com

• Gitbook/Wiki: https://thesmurfssociety.gitbook.io/the-smurfs-society

About Atomic Lodge :

Atomic swap NFT's is a membership to an order of transhumanist. Our collection is a set of 512 exclusive Ai generated imagery.Atomic Swap was founded by Simon Tadros in 2017, the purpose of this collection is to achieve wealth & to create a solid decentralized monetary system.

• Website : https://atomicswap.vip

• Open Sea : https://opensea.io/collection/atomic-lodge

• Spatial : https://spatial.io/s/atomic-space-632bd6583c4c9f0001be88b2?share=697208222555517632

• Twitter: https://twitter.com/atomicroadmap

https://opensea.io/assets/ethereum/0x3F0303514da0C760CaBf836cAf4d7aaAfE0c587E/1

Mint

https://atomicswap.vip/

The funding rate in a perpetual futures contract can be used as part of a hedge strategy in the cryptocurrency market. A hedge is a financial strategy that is designed to reduce the risk of loss from adverse price movements in an asset. In the context of cryptocurrency trading, a hedge strategy using the funding rate might involve taking opposing positions in the the futures market and collect exchanges funding fees .

Here's an example of how a hedge strategy using the funding rate might work:

First you visit binance and kucoin funding rate page to check the highest % return and the difference in timing between both exchanges.

Suppose that you funding rate of Bitcoin or $Solana or $link are the highest in term of yield . You take a long position or short position that yield the positive rate on the specific coin on the exchange that distribute the fees prior the second exchange where you take at the same time the same position in the opposite direction.

When the distribution occurs you close both positions at the same time collect your gains and reopen the same position in the opposite direction to collect the fees on the second exchange.

Fees are distributed 3 times a day every 8 hours yet with the method above you can collect 6 times a day and percentage might vary from 0.5 to 3 % on each collection to make a maximum of 18 % profit per day to 500 % per month with a minimal risk.

This is just one example of how a hedge strategy using the funding rate in a perpetual futures contract might work.

if you want to find out more just mint our community NFT and join a community Atomic Swap of elite developers traders invest and crypto punks since 2017.

Funding fees :

http://www.coinglass.com/FundingRate

https://www.kucoin.com/futures/contract/funding-rate-history/XBTUSDTM

https://www.binance.com/en/futures/funding-history/0

https://atomicswap.vip

Been in the crypto space since 2017 and being a gambling fan i experienced many casinos and betting platform until i made my choice.

Bitcasino and sport bets are the most trusted regulated they also offer a high speed withdraw faster than any centralized exchange like Binance and Kucoin.

They support many crypto currencies they have Metamask integration and a unique loyalty programing and the most excited of all is the VIP treatment .

if you are a high roller u ll get the opportunity to get private jet and yacht trips around the work, a delightful accommodation and another layer of luxurious entertainment.

All you have to do deposit 100 000 USDT in your account and benefit from all this premium leisure .

As the World Cup is around the corner and you are big roller don't miss the opportunity to get access to the grand prize .

This grand prize comes with a ticket for you and your lucky guest. As if things couldn’t get any better, we are even treating you to a luxurious, paid business class flight and a 5-star accommodation in Qatar, a cruise aboard Bitcasino's exclusive yacht, and tickets to a game in the last-16 round, semi-finals, and finals, respectively.

To give the perfect ending to your dream-like getaway, you and your guest would be treated to a meet-and-greet dinner with the match ambassador of the respective game you attended. This match ambassador could be an artist, a coach or even your favorite football star!

To sign up and enroll to normal of vip program and get 24/24 assistance use the link below :

https://bitcasino.io/?refAff%5Bsource%5D=834dde61122&refAff%5Baffid%5D=12128&refAff%5Bcxid%5D=12128_466084

https://sportsbet.io/sports?refAff%5Bsource%5D=834dde61122&refAff%5Baffid%5D=12128&refAff%5Bcxid%5D=12128_509465

You can contact us any time on the following whatsap number :

https://wa.me/+96170224984

or

https://wa.me/+96171111147

happy Bets and all of luck !!!

In this example i compare zksync vs arbitrum vs optimism vs polygon by size of daily depositor you can find the sql query at

https://dune.com/queries/1493205

Code Sample :

with zksync_summary as (
    with depositors as (SELECT date, count(USER) AS deposits
     FROM
     (SELECT min(date) AS date,
             account AS USER
      FROM
        (SELECT date_trunc('day', min(evt_block_time)) AS date, "from" AS account
         FROM erc20."ERC20_evt_Transfer"
         where (
            "to" = '\xaBEA9132b05A70803a4E85094fD0e1800777fBEF' )
            and evt_block_time >'2020-06-01'
            and evt_block_time >= now() - interval '{{in _ days}} days'
            -- AND evt_block_time >= '{{date}}'
            -- AND evt_block_time < (DATE_TRUNC('day',CURRENT_TIMESTAMP))
         GROUP BY 2) AS a
      GROUP BY 2) AS b
   GROUP BY 1
   ORDER BY 1),
   
 depositors_eth as (SELECT date, count(USER) AS deposits_eth
   FROM
     (SELECT min(date) AS date,
             account AS USER
      FROM
        (SELECT date_trunc('day', min(block_time)) AS date, "from" AS account
         FROM ethereum.transactions
         WHERE ("to" = '\xaBEA9132b05A70803a4E85094fD0e1800777fBEF' )
         and block_time >'2020-06-01'
         and block_time >= now() - interval '{{in _ days}} days'
        --   AND evt_block_time >= '{{date}}'
        --   AND evt_block_time < (DATE_TRUNC('day',CURRENT_TIMESTAMP))
         GROUP BY 2) AS a
      GROUP BY 2) AS b 
   GROUP BY 1
   ORDER BY 1),
   
 bridge_interactions as (
    select COALESCE(depositors.date, depositors_eth.date) AS "date", deposits+deposits_eth as total_deposits, sum(deposits+deposits_eth) over (order by depositors.date) as cumlative_deposits
    from depositors FULL OUTER JOIN depositors_eth on depositors_eth.date = depositors.date
)
    SELECT 'zksync' as bridge_name, * 
    FROM bridge_interactions
    order by date DESC
) 

You can Find the comparison here but setting the duration by day and query the blockchain .

https://dune.com/spuriousdragon/zkrollups

Dune is the best product to query the blockchain it gives u the ability to visualize nfts defi bridges lending platforms on multiple chain .

it a must try powerfull product

https://app.vectary.com/

Open the editor drag and drop the image .

Make the object double sided by enabling the feature in the right menu .

import the image by clicking on the right-upper burger menu → export → File Format > GLTF → Download

Now upload to Spatial.io and make some chaos.