The problem Agent Daredevil solves

**Sportsbetting and prediction is intimidating for majority of beginners. **

OUR SOLUTION: an AI agent companion that helps users make better informed betting decisions.

AN AI AGENT STACK THAT ENABLES INTELLIGENT ANALYSIS, AUTONOMOUS ESCROW, & AUTHENTICATION FOR COMPETITIVE GAMING
AND SPORTS PREDICTION.

Agent Daredevil isn't your average AI companion; Not only is he your favorite betting consultant, his intelligent analysis and prediction capabilities enable him to distribute and monitize data across the AI agent ecosystem through Virtuals.io's Agent Commerce Protocol (ACP) as a sports intelligence layer.

Currently, our MCP stack allows us to query historical and live data through the Sportradar API suite (official NBA data provider)

Soon, Agent Daredevil will serve as the primary arbiter of outcomes and logic for sports and esports. Being built as a composable agentic toolkit (MCP SDK) powering sportsbeting platforms and wagering features in the AI & Web3 ecosystem.

Our team is composed of battle tested sports and esports veterans, serving top Web3 gaming companies like Yield Guild Games & Gala Games.

Try our F1 Companion dApp here:
https://f1.daredevil.gg

Test our Wagering dApp DEMO here:
https://daredevil.gg

Challenges I ran into

The biggest challenge that i encountered was migrating our existing supabase databases on-chain. We had to rewrite our backend and match resolution logic which is supposedly triggered manually by and ADMIN account.

Now, we are building smart contracts on BASE to handle on-chain escrow & resolution that will be triggered via MCP/ACP hosts -> connected to respective game APIs.

Smart Contract Address(es)

// SPDX-license-identifier: unlicensed
pragma solidity ^0.8.20;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";

interface IStakewise {
function deposit(uint256 _assets, address _receiver) external returns (uint256);
function redeem(uint256 _shares, address _receiver, address _owner) external returns (uint256);
}

contract BaseBet is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;

/* ---------- Base mainnet addresses ---------- */
IERC20  public constant CB_BTC   = IERC20(0xcbB7C0000a88B649584F0401F9922F9a0Cb3f9c6);   // cbBTC on Base
IERC20  public constant ST_CB_BTC = IERC20(0x7C5C2d46A4ceC2951Ea36657CE0eAE39a2B86D2F);  // stcbBTC (Stakewise)
IStakewise public constant STAKEWISE = IStakewise(0x7C5C2d46A4ceC2951Ea36657CE0eAE39a2B86D2F);

address public oracle;
address public immutable treasury;

struct Bet {
    address p1;
    address p2;
    uint256 stake;      // each side
    uint256 shares;     // stcbBTC minted
    bool    done;
    address winner;     // 0 == draw
}

mapping(uint256 => Bet) public bets;
uint256 public id;

event Created(uint256 indexed id, address indexed p1, uint256 stake);
event Joined(uint256 indexed id, address indexed p2);
event Paid(uint256 indexed id, address winner, uint256 reward);
event Fee(uint256 indexed id, uint256 amount);

modifier onlyOracle() {
    require(msg.sender == oracle, "!oracle");
    _;
}

constructor(address _oracle, address _treasury) {
    oracle   = _oracle;
    treasury = _treasury;
    CB_BTC.safeApprove(address(STAKEWISE), type(uint256).max);
}

function setOracle(address o) external onlyOwner {
    oracle = o;
}

function open(uint256 amount) external nonReentrant {
    require(amount >= 0.001 ether, "dust");
    uint256 betId = ++id;
    Bet storage b = bets[betId];
    b.p1    = msg.sender;
    b.stake = amount;

    CB_BTC.safeTransferFrom(msg.sender, address(this), amount);
    uint256 pre = ST_CB_BTC.balanceOf(address(this));
    STAKEWISE.deposit(amount, address(this));
    b.shares = ST_CB_BTC.balanceOf(address(this)) - pre;

    emit Created(betId, msg.sender, amount);
}

function join(uint256 betId) external nonReentrant {
    Bet storage b = bets[betId];
    require(b.p1 != address(0) && b.p2 == address(0), "bad id");
    b.p2 = msg.sender;

    CB_BTC.safeTransferFrom(msg.sender, address(this), b.stake);
    uint256 pre = ST_CB_BTC.balanceOf(address(this));
    STAKEWISE.deposit(b.stake, address(this));
    b.shares += ST_CB_BTC.balanceOf(address(this)) - pre;

    emit Joined(betId, msg.sender);
}

function settle(uint256 betId, address winner) external onlyOracle {
    Bet storage b = bets[betId];
    require(!b.done && b.p2 != address(0), "bad settle");
    require(winner == address(0) || winner == b.p1 || winner == b.p2, "bad winner");
    b.done   = true;
    b.winner = winner;

    STAKEWISE.redeem(b.shares, address(this), address(this));

    uint256 bal = CB_BTC.balanceOf(address(this));
    uint256 reward = bal > b.stake * 2 ? bal - b.stake * 2 : 0;
    uint256 fee = reward / 2;
    uint256 pot = bal - fee;

    if (fee > 0) {
        CB_BTC.safeTransfer(treasury, fee);
        emit Fee(betId, fee);
    }

    if (winner == address(0)) {
        CB_BTC.safeTransfer(b.p1, b.stake);
        CB_BTC.safeTransfer(b.p2, b.stake);
    } else {
        CB_BTC.safeTransfer(winner, pot);
    }

    emit Paid(betId, winner, reward);
}

}

Other Onchain Proof

17,000+ TOKEN HOLDERS
$117K MARKET CAP
https://dexscreener.com/base/0xC0F1ec856C4bE383655F6d756B3b0B48D9713b27