Buyer Guide

Overview#

AGDEL is a price prediction exchange where makers publish predictions and buyers purchase them. Every prediction targets a specific asset, direction (long or short), price target, and time window. You pay per prediction — no subscriptions.

If the maker is correct, they keep 90% of the escrow and the protocol takes 10%. If the maker is wrong, you get 90% of your payment back as a refund, and the protocol takes 10%.

Wallet Setup#

You need an EVM-compatible wallet with USDC on HyperEVM. The wallet must be able to sign EIP-191 messages for authenticated API requests (AGDEL-Signature header).

Your wallet address is your identity on the network. It is used for purchasing signals, claiming refunds, and authenticating API requests. No registration or approval is required.

Discovering Signals#

Browse active signals through the dashboard or query the API directly:

Each signal listing shows the asset, time window, cost, number of buyers, and the maker's address. The target price and direction are hidden until you purchase — this is the commit-reveal model that prevents front-running.

You can filter by asset (?asset=BTC-PERP), status, maker address, and sort by most buyers, newest, or cheapest. You can also check a maker's track record before buying:

Purchasing a Signal#

To purchase a signal, call buySignal(signalId) on the SignalMarketplace smart contract. This transfers USDC from your wallet into escrow. If you haven't approved the contract to spend your USDC, you'll need to call approve() on the USDC contract first.

The SDK handles USDC approval checks and the on-chain purchase in a single call:

payload = await client.buy_signal(signal_id)
# payload.target_price  -> "9850000000000" (scaled by 1e8)
# payload.direction     -> 0 (LONG) or 1 (SHORT)
# payload.asset         -> "BTC-PERP"

Payload Delivery#

After purchasing on-chain, you can fetch the hidden prediction payload:

The request must include an AGDEL-Signature header with your wallet address, a recent timestamp, and an EIP-191 signature. The backend verifies that you have a purchase record on-chain before revealing the payload.

Interpreting Signals#

A signal payload contains the maker's prediction. Here's how to read it:

• Direction: LONG (0) means the maker predicts the price will go up. SHORT (1) means down.
• Target Price: The specific price the maker predicted the asset would reach. Stored as a uint256 scaled by 1e8 (e.g., $98,500 = 9850000000000).
• Time Window: The duration over which the prediction is evaluated, from signal creation to expiry.
• Confidence: The maker's self-reported confidence level (0–100%). This is informational — it does not affect settlement.
• Quality Score: A protocol-computed metric (0–4) that factors in directional accuracy, precision, and difficulty. See the scoring docs.

Settlement uses a close-based model: the resolution price is the closing price at the end of the time window. If the closing price moved in the predicted direction relative to the entry price, the signal is CORRECT. Otherwise it is WRONG.

Refunds#

If a signal resolves as WRONG (incorrect prediction), you can claim a 90% refund of your purchase amount. The remaining 10% goes to the protocol.

Call claimRefund(signalId) on the smart contract. The refund is calculated pro-rata if there are multiple buyers. The SDK provides:

await client.claim_refund(signal_id)
# Reverts if signal was correct or not yet resolved

SDK Quickstart#

Install the Python SDK:

pip install agdel-protocol

Full buyer flow:

from agdel import AGDELClient

async with AGDELClient(
    rpc_url="https://rpc.hyperliquid.xyz/evm",
    private_key="0x...",
    marketplace_address="0x...",
    usdc_address="0x...",
    api_url="https://api.agdel.xyz",
) as client:
    # Browse active signals
    signals, total = await client.list_signals(
        asset="BTC-PERP", status="active"
    )

    # Check maker track record
    maker = await client.get_maker_stats(signals[0].maker_address)
    print(f"Win rate: {maker.win_rate:.1%}")

    # Buy a signal (auto-approves USDC if needed)
    payload = await client.buy_signal(signals[0].signal_id)
    print(f"Target: {payload.target_price}, Direction: {payload.direction}")

    # Later, if signal was wrong:
    await client.claim_refund(signals[0].signal_id)

Evaluating Makers#

Before buying a signal, check the maker's track record. Key metrics to look at:

• Win Rate: Percentage of resolved signals that were correct. Higher is better, but sample size matters.
• Quality Score: Average quality score across resolved signals (0–4 scale). Accounts for precision and difficulty, not just direction. See scoring.
• Brier Score: Measures calibration between stated confidence and actual outcomes. 0.0 = perfectly calibrated. Below 0.25 is good. Above 0.5 means the maker is poorly calibrated.
• Total Signals: More resolved signals = more reliable statistics.
• Volume: Total USDC transacted. Indicates market trust.

The makers leaderboard shows all makers ranked by these metrics.