A Next-Generation Decentralized Digital Advertising Network & On-Chain Revenue Distribution Protocol
Deployed natively on Arc L1 Network powered by Circle Programmable Wallets and Supabase Realtime Sync.
Traditional digital advertising networks (e.g., Google AdSense, Meta Ads) act as highly extractive, black-box middlemen. Creators are forced to accept Net-30 or Net-45 settlement periods with high payout thresholds ($100+), while middleman platforms capture between 32% to 49% of ad spends to offset manual reconciliation and bot validation costs. Furthermore, advertisers lose billions annually to click-fraud botnets with no cryptographic audit trail to verify actual human engagement.
AdSplit introduces a programmatic, trustless, pay-per-click ad distribution ledger. By uniting USDC as the native gas token of Arc L1 with Circle's Programmable Wallets, AdSplit locks advertising budgets in decentralized smart-contract escrows. Legitimate ad engagements are validated off-chain via real-time client telemetry analysis, immediately triggering on-chain revenue splits: 85% to Content Creators, 10% to Affiliates/Distributors, and 5% to the Platform in less than 0.8 seconds with a completely gasless user experience.
Our architecture adopts a hybrid Web3-SaaS approach:
- Off-chain High Performance: Real-time user telemetry evaluation and anti-bot validation are processed by edge functions to maintain sub-100ms response times.
- On-chain Absolute Integrity: Escrow lockups and revenue distribution are hardcoded in Solidity smart contracts, ensuring advertisers pay only for validated human clicks.
- Escrow-Backed Advertising Campaigns: Deploys secure public contracts that lock budgets in USDC. Advertisers can pause campaigns and instantly reclaim remaining balances via
withdrawRemainingBudget. - Programmatic Payout Settlements: Splits every single valid click payout on-chain in real-time, eliminating payment cycles and establishing high liquidity for publishers.
- Circle CCTP Sweeper Integration: Bridges stablecoins (USDC/EURC) directly from alternative networks like Ethereum Sepolia or Solana Devnet using Circle's Cross-Chain Transfer Protocol (CCTP).
- Cognitive Telemetry Filtering: Employs an off-chain Oracle node that scores visitor browser parameters to shield advertisers' budgets from automated bot floods.
- Sponsor Gasless Relayer: Leverages Circle's Developer-Controlled Wallets API to sponsor contract call transaction gas fees, offering publishers a frictionless Web2 onboarding experience.
AdSplit is built as a Modular Monolith using Next.js 15 (App Router). This keeps deployment overhead extremely low for agile engineering teams while keeping domains structurally isolated for future microservice extraction.
┌────────────────────────────────────────────────────────┐
│ ADSPLIT MODULAR MONOLITH │
│ │
│ ┌───────────────┐ ┌───────────────┐ ┌────────────┐ │
│ │ Advertiser │ │ Creator │ │ AI Oracle │ │
│ │ Domain │ │ Domain │ │ Domain │ │
│ └───────┬───────┘ └───────┬───────┘ └─────┬──────┘ │
└───────────┼─────────────────┼───────────────┼──────────┘
▼ ▼ ▼
┌────────────────────────────────────────────────────────┐
│ Next.js API │
│ (Secure Relayer /api/sponsor & Webhooks) │
└───────────┬─────────────────┬───────────────┬──────────┘
▼ ▼ ▼
┌──────────────────┐ ┌────────────────┐ ┌────────────────┐
│ Circle DCW │ │ Supabase │ │ Arc L1 Chain │
│ (Wallet API) │ │ (Postgres DB) │ │ (Solidity EVM) │
└──────────────────┘ └────────────────┘ └────────────────┘
- Advertiser Hub: Coordinates USDC escrow lockups, active budget parameters, campaign statistics, and real-time conversion metrics.
- Creator Registry: Handles embedded developer-controlled wallet creation, payout allocations, and domain statistics.
- AI-Telemetry Oracle: Scores incoming client-side parameters, manages the IP blacklisting database, and cryptographically signs valid claims.
- On-Chain Settlement Rail: Solidity contract executing physical USDC transfers to creators based on Oracle cryptographic signatures.
The following diagram showcases how a user interaction triggers the off-chain anti-fraud assessment, which then routes through Circle's SDK to distribute USDC on-chain.
flowchart LR
classDef reader fill:#35C7A4,stroke:#744D2B,stroke-width:2px,color:#fff;
classDef oracle fill:#E25252,stroke:#744D2B,stroke-width:2px,color:#fff;
classDef contract fill:#F4C455,stroke:#744D2B,stroke-width:3px,color:#5D4037;
classDef tech fill:#FDFBF7,stroke:#744D2B,stroke-width:2px,color:#5D4037;
classDef wallets fill:#FCFAF6,stroke:#744D2B,stroke-width:1px,color:#5D4037;
A[Advertiser / Brand]:::tech -->|1. Lock budget| B(AdRevenueSplitter):::contract
C[Web Reader]:::reader -->|2. Click Ad Banner| D[Next.js Client UI]:::tech
D -->|3. Send Telemetry Fingerprint| E[AI Fraud Oracle]:::oracle
E -->|4a. Bot Traffic| F[IP Blacklist Database]:::oracle
E -->|4b. Human Traffic| G[Vercel Server Relayer]:::tech
G -->|5. Sponsor Call| H[Circle SDK API]:::tech
H -->|6. Execute recordEngagement| B
B -->|7a. Platform Share 3%| I[Platform Wallet]:::wallets
B -->|7b. Creator Share 85%| J[Creator Wallet]:::wallets
B -->|7c. Dist Share 12%| K[Affiliate Wallet]:::wallets
Note
Architectural Decisions & Tradeoffs: Processing anti-fraud validations directly on-chain would lead to high latency and excessive transaction costs. By running the telemetry assessment off-chain and utilizing a trusted Oracle signature, we maintain sub-second finality while ensuring absolute escrow budget safety.
The sequence below illustrates the gasless transaction flow utilizing Circle's secure server APIs.
sequenceDiagram
autonumber
actor Reader as Reader Browser
participant FE as AdSplit Frontend
participant API as Next.js API (/api/sponsor)
participant Circle as Circle Developer Wallets
participant EVM as Arc L1 EVM
Reader->>FE: Click Ad Link
FE->>FE: Capture Telemetry (IP, User-Agent, Timing)
FE->>API: POST /api/sponsor (telemetry metadata)
Note over API: Oracle validates telemetry & signs payload
API->>Circle: walletsClient.createContractCallTransaction()
Note over API,Circle: Protected by Entity Secret & Server Environment variables
Circle->>EVM: Broadcast transaction (sponsorGas = true)
EVM-->>Circle: Finalize transaction (< 0.8s)
Circle-->>API: Return transaction receipt & status
API-->>FE: Update real-time UI balance
FE-->>Reader: Redirect to destination URL
Important
Security Strategy:
To protect the developer credentials, all interactions with the Circle Developer-Controlled Wallets SDK (including Entity Secret and API Key management) are encapsulated inside the secure backend API route /api/sponsor/route.ts running on the server. The client bundle never exposes keys or sensitive credentials, completely mitigating attack vectors targeting the escrow funds.
The following flowchart details how the four primary modules of AdSplit interact to transition an advertising campaign from deposit to live rendering, telemetry verification, and instant public ledger split settlement:
flowchart TD
classDef sponsor fill:#7FB3D5,stroke:#744D2B,stroke-width:2px,color:#fff;
classDef preview fill:#B28DFF,stroke:#744D2B,stroke-width:2px,color:#fff;
classDef shield fill:#E25252,stroke:#744D2B,stroke-width:2px,color:#fff;
classDef history fill:#35C7A4,stroke:#744D2B,stroke-width:2px,color:#fff;
classDef highlight fill:#F4C455,stroke:#744D2B,stroke-width:3px,color:#5D4037;
subgraph Module1["1. Ad Spender Office (Campaign Sponsor)"]
A1["Sponsor defines Ad Title, CPC & Creator Payout Share"]:::sponsor
A2["Deposit USDC Budget & Launch Campaign Chest"]:::sponsor
A3["USDC Chest locked on-chain (Arc L1 Network)"]:::sponsor
A1 --> A2 --> A3
end
subgraph Module2["2. Live Ad Preview (Creator Blog & Reader Action)"]
B1["Cozy Blog displays automatic Ad Banner"]:::preview
B2["Reader clicks the sponsored banner"]:::preview
B3["Browser captures client-side Telemetry metrics"]:::preview
B1 --> B2 --> B3
end
subgraph Module3["3. Anti-Fraud Shields (Telemetry Protection Guard)"]
C1["Oracle reviews Telemetry metrics in real time"]:::shield
C2{"Is click verified genuine?"}:::shield
C3["Flag bot_fraud: BLOCK Payout"]:::shield
C4["Sign cryptographic claim: ALLOW Payout"]:::shield
C1 --> C2
C2 -- "No (Sybil / Bot Traffic)" --> C3
C2 -- "Yes (Genuine Reader)" --> C4
end
subgraph Module4["4. Live Activity History (Transaction Ledger)"]
D1["Relayer submits signed claim gaslessly"]:::history
D2["AdRevenueSplitter Contract splits USDC instantly"]:::history
D3["Split Distribution: 85% Creator / 10% Partner / 5% Platform"]:::history
D4["Success status and safety blocks synchronized to public Ledger"]:::history
D1 --> D2 --> D3 --> D4
end
A3 -->|Chest triggers banner| B1
B3 -->|Submit Telemetry| C1
C4 -->|Authorize Telemetry claim| D1
C3 -->|Log Blocked threat| D4
AdSplit implements a hybrid synchronization layer: Supabase PostgreSQL serves as a high-speed read cache to display analytics instantly (sub-100ms), while the Arc L1 smart contract holds the immutable record of all campaign funds.
erDiagram
CAMPAIGNS {
string id PK "Unique Campaign ID"
string title "Campaign Name"
string advertiser "Advertiser Wallet"
decimal total_budget "Total Escrow Budget"
decimal remaining_budget "Remaining Escrow Budget"
decimal cost_per_click "CPC Payout (6 Decimals)"
integer total_clicks "Total Valid Clicks"
boolean active "Campaign Status"
}
CLICK_LOGS {
string id PK "Click ID"
string campaign_id FK "Campaign Link"
string ip_address "Visitor IP Address"
string status "valid | bot_fraud"
decimal payout_usdc "Total USDC Payout"
decimal creator_payout_usdc "Creator Share (85%)"
decimal platform_payout_usdc "Platform Share (3%)"
decimal distributor_payout_usdc "Distributor Share (12%)"
timestamp timestamp "Created At"
}
IP_BLACKLIST {
string ip_address PK "Blacklisted IP"
string block_reason "Reason for blacklist"
timestamp blocked_at "Timestamp"
}
CAMPAIGNS ||--o{ CLICK_LOGS : "logs"
To support high-concurrency logging, the following database indexes are applied:
CREATE INDEX idx_logs_campaign ON click_logs(campaign_id);
CREATE INDEX idx_logs_status_ip ON click_logs(status, ip_address);
CREATE INDEX idx_campaigns_active ON campaigns(active) WHERE active = true;The backend endpoints follow REST design specifications:
- Versioning: Enforced via route headers (e.g.,
/api/v1/...). - Format: All payloads use JSON formats.
Validates click telemetry signatures, protects developer-controlled wallet credentials, and controls access limits.
- Request Example:
{
"campaignId": "0xad0001bc939029b45ea492042043...",
"clickId": "clk_9842",
"authSignature": "0x498e29bcda92fca392da9c0e29b...",
"recipientAddress": "0xca2D2F677Cd6303CeC089B5F319D72a089B5f319"
}- Response Example (Success 200):
{
"success": true,
"txHash": "0x89f20cdba924fa9c09d2e1c39029b49e29bf420...",
"settlement": {
"total": 0.20,
"creator": 0.17,
"distributor": 0.02,
"platform": 0.01
}
}- Error Response Example (403 Blocked):
{
"success": false,
"error": "CRITICAL_RISK_ALERT",
"message": "Recipient address is blocklisted by Circle. Transaction aborted."
}The core logic of AdSplit is defined in AdRevenueSplitter.sol, which coordinates campaign escrows, handles split distributions, and verifies Oracle cryptographic signatures.
- Network: Arc Testnet L1 (Chain ID:
5042002) - Contract Address:
0xE75D12e1E29370A0346A25D5ef371B2B990a3c91(Fully deployed and active) - Native Gas Stablecoin: ERC-20 USDC (
0x3600000000000000000000000000000000000000) - AI Oracle Telemetry Node:
0xCa2d2f677CD6303cec089b5f319d72A089B5F319
We have configured a comprehensive Hardhat compilation and deployment environment inside the root directory:
Build the Solidity binaries using the preconfigured Hardhat compiler:
npx hardhat compileExport your deployer private key inside .env (DEPLOYER_PRIVATE_KEY) and run the deployment script:
npx hardhat run scripts/deploy.js --network arcTestnet// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract AdRevenueSplitter {
IERC20 public immutable usdcToken;
address public owner;
address public oracleNode;
// Flat 3.0% platform fee (300 basis points)
uint256 public constant BASIS_POINTS = 10000;
uint256 public platformFeeBps = 300;
address public platformWallet;
struct SplitShare {
address recipient;
uint256 shareBps; // e.g. 8500 = 85%
}
// Records validated ad click and splits USDC instantly
function recordEngagement(bytes32 _campaignId, bytes32 _clickFingerprint) external onlyOracle {
Campaign storage campaign = campaigns[_campaignId];
require(campaign.active, "Campaign is not active");
require(campaign.remainingBudget >= campaign.costPerClick, "Campaign budget exhausted");
uint256 payoutAmount = campaign.costPerClick;
campaign.remainingBudget -= payoutAmount;
campaign.totalClicks += 1;
// ... Split logic in Basis Points
}
}AdSplit enforces Zero Trust principles across the entire digital payment ecosystem:
| Threat Vector | Defense Vector | Architectural Mitigation |
|---|---|---|
| API Secret Leak | Infrastructure Shield | API keys and the Entity Secret are stored exclusively in the Vercel Serverless environment, completely hidden from client bundles. |
| Escrow Drain (Direct calls) | Solidity Modifier | The recordEngagement function inside AdRevenueSplitter.sol is protected by the onlyOracle modifier. It rejects any execution not initiated by the registered Oracle. |
| Middleman Attack (Replays) | Unique Click Fingerprinting | Every transaction requires a unique, one-time clickFingerprint. Used fingerprints are recorded on-chain, preventing replay attacks. |
| Circle Wallet Locking | Pre-Flight Risk Screening | Agent Beta performs local pre-flight checks against the on-chain local blacklist mapping before sending transactions to prevent fund trapping. |
To defend advertisers' budgets, AdSplit features an off-chain AI-powered fraud-detection engine:
┌────────────────────────────────────────────────────────┐
│ Client Telemetry Inputs │
│ (IP Address, Mouse Movements, User-Agent) │
└──────────────────────────┬─────────────────────────────┘
▼
┌────────────────────────────────────────────────────────┐
│ Feature Extraction │
│ (Computes speed, trajectory, and repetition) │
└──────────────────────────┬─────────────────────────────┘
▼
┌────────────────────────────────────────────────────────┐
│ Random Forest ML Model │
│ (Evaluates risk score against threat profile) │
└──────────────────────────┬─────────────────────────────┘
┌─────────────┴─────────────┐
▼ ▼
[Risk Score >= 0.8] [Risk Score < 0.8]
(Flag Fraud & Block) (Sign Cryptographic Claim)
- Dynamic Telemetry Analysis: Analyzes client-side variables (such as mouse hover speeds, keyboard strokes, and viewport sizes) to detect bots.
- On-Chain Signature Safeguards: Legitimate clicks are cryptographically signed by the Oracle's private key, authorizing the smart contract to release the corresponding budget split.
┌────────────────────────────────────────────────────────┐
│ Concurreny Load (10,000 req/sec) │
└──────────────────────────┬─────────────────────────────┘
▼
┌────────────────────────────────────────────────────────┐
│ Cloudflare CDN Caching │
│ (Serves static resources in < 15ms) │
└──────────────────────────┬─────────────────────────────┘
▼
┌────────────────────────────────────────────────────────┐
│ Edge Middleware Telemetry │
│ (Scores & filters bot traffic) │
└──────────────────────────┬─────────────────────────────┘
▼
┌────────────────────────────────────────────────────────┐
│ Supabase Read Cache │
│ (Bypasses RPC Node to fetch campaign state) │
└──────────────────────────┬─────────────────────────────┘
▼
┌────────────────────────────────────────────────────────┐
│ Gasless On-Chain Settlement │
│ (Asynchronous Parallel Transaction Relaying) │
└────────────────────────────────────────────────────────┘
- Edge Caching: Static database queries (such as active ad campaign lists) are cached at the edge using Cloudflare, cutting response times to under 15ms.
- Arc L1 Network Execution: Arc's high-performance L1 architecture offers sub-second finality times (averaging 800ms) with extremely low gas costs, ensuring scale under load.
- RPC Failover Strategies: In the event of primary RPC endpoint downtime (
https://rpc.testnet.arc.network), the client automatically switches to configured backup nodes. - Supabase Offline Recovery: If the database sync layer goes offline, the UI falls back to reading active campaign metrics directly from the smart contract via on-chain RPC calls.
- Transaction Retry System: Next.js relayer endpoints manage transaction failure queues to securely recover gas-failed actions.
- Log Aggregation: Integrates Supabase Database logging alongside OpenTelemetry to trace contract execution pathways.
- Metric Alerts: Automatically dispatches critical warnings to developer channels if click-rejection rates spike beyond 15% within a 5-minute window.
- Gas Consumption Analytics: Tracks contract execution efficiency over time to proactively optimize gas limits on Arc L1.
# 1. Clone the project and navigate to the directory
cd AdSplit
# 2. Install dependencies
npm installCreate a .env file in the root directory:
# Supabase Configuration
NEXT_PUBLIC_SUPABASE_URL=https://ebmwokpcgdvumrloggcw.supabase.co
NEXT_PUBLIC_SUPABASE_ANON_KEY=your_supabase_anon_key
NEXT_PUBLIC_SUPABASE_SCHEMA=public
# Circle Developer Platform Configuration
NEXT_PUBLIC_CIRCLE_API_KEY=sandbox_key
NEXT_PUBLIC_CIRCLE_ENTITY_SECRET=
# Smart Contract Deployment (Arc Testnet)
# Export your private key from MetaMask for live deployments
DEPLOYER_PRIVATE_KEY=your_private_keyTo make local evaluation and hackathon presentations completely frictionless, AdSplit includes a built-in Smart Sandbox Fallback:
- On-Chain Bytecode Pre-flight: The frontend performs a live pre-flight check on the active smart contract address using
publicClient.getCode(). - Zero-Revert Fallback: If the contract is not yet deployed (or returning no bytecode), the application seamlessly transitions to Sandbox Demo Mode.
- Simulated Ledger Sync: In Sandbox Mode, all campaign settings, clicks, bot-fraud detections, and splits are securely processed through the Supabase persistence layer with simulated RPC receipts.
- Frictionless Demo: No wallet connections, token approvals, or gas funds are required to test the telemetry engine, bot-fraud blocks, or dashboard analytics. The minute you deploy the contract, it automatically activates the live on-chain execution flow.
npm run devDeploying the project to Vercel provides optimal global performance:
- Connect the repository to your Vercel Dashboard.
- Configure Edge Middleware on
/api/sponsorroutes for sub-100ms anti-fraud screening. - Input production environment variables securely inside the Vercel variables dashboard.
graph LR
classDef git fill:#FDFBF7,stroke:#744D2B,stroke-width:2px,color:#5D4037;
classDef success fill:#35C7A4,stroke:#744D2B,stroke-width:2px,color:#fff;
classDef pipeline fill:#F4C455,stroke:#744D2B,stroke-width:2px,color:#5D4037;
A[Git Push main]:::git --> B[GitHub Actions Runner]:::pipeline
B -->|Lint & Type check| C[ESLint & TS Check]:::pipeline
B -->|Smart Contract Test| D[Hardhat Tests]:::pipeline
C -->|Success| E[Deploy to Vercel Production]:::success
D -->|Success| E
- Decentralized Telemetry Nodes: Transition the click verification Oracle to a decentralized Proof-of-Stake consensus network.
- Auto-Yield Generation: Integrated smart contracts to invest dormant advertiser balances in yield-generating protocols like Aave, earning yield until ad spends are executed.
- Zero-Knowledge Proof Telemetry: Enable ZK-proofs for ad interaction validations to completely preserve reader privacy while guaranteeing payout integrity.