Developer Ecosystem Portal

EventShield is the world's first dynamic, cryptographic ticketing protocol deployed on Arc Network. Built natively with Circle's USDC for gasless transactions and embedded user-controlled MPC wallets, EventShield completely eradicates bot-scalpers, controls secondary market markups, and redistributes secondary royalties back to content creators.

Dynamic Pass Cryptography

Generates EIP-191 signatures valid for 90s locally in the device enclave, making physical QR screenshot sharing obsolete.

USDC Native Gas Fees

Leverages Arc Network L1 where stable and predictable fees are paid natively in USDC, removing standard ETH/EVM native token volatility.

1. Core Thesis & Protocol Topology

Traditional event ticketing frameworks are broken. Secondary markets are dominated by automated bots that drain primary allocations, inflate ticket resale prices, and leave artists out of secondary trade revenues.

EventShield shifts the ticketing trust model from off-chain database logic to immutable on-chain enforcement. By minting tickets as ERC-721 smart tokens with dynamic, capped transferability limits, EventShield protects fans from markup exploitation and guarantees secondary royalties return back to creators atomically.

System Design Rationale & Tradeoffs

USDC Native Gas: Settling transactions via USDC on the Arc Network bypasses complex gas token bridging and native token volatilities.
On-Chain Resale Limits: Resell listings are capped at original price plus maximum markup percent configuration. Listing attempts above this boundary fail at compilation transaction phase.
EIP-191 Cryptographic Gate Admission: To block screenshot duplication, tickets are not validated by visual QR codes. Instead, gate checkpoints recover dynamic private signatures generated locally by the holder's wallet.

2. Dynamic Resale Commerce & Price Caps

To block scalpers and high-frequency trading bots, EventShield implements on-chain pricing boundaries. When an organizer creates a new event, they define the maximum resale markup percentage (`maxResellMarkupPercent`).

Max Resell Price = Original Price * (100 + maxResellMarkupPercent) / 100

When a buyer calls `purchaseSecondaryTicket(tokenId)`, the contract performs atomic ledger splits in a single transaction:

Seller share89% PayoutTransferred directly to secondary seller.

Artist loyalty10% RoyaltyAtomically routed to artist wallet.

Safety split1% Protocol FeeSecures the dynamic checker escrow.

Warning: Regular ERC-721 direct transfers are locked inside the contract to prevent off-chain scalper swaps. All peer-to-peer ticket transfers must go through the capped resale pool.

3. Cryptographic Gate Admission (EIP-712)

EventShield completely eliminates visual QR code screenshots (the primary vector for ticket replication fraud) by utilizing EIP-712 Typed Structured Data Signatures.

bytes32 digest = keccak256(
    abi.encodePacked(
        "\x19\x01",
        DOMAIN_SEPARATOR,
        keccak256(abi.encode(CHECKIN_TYPEHASH, tokenId, owner, timestamp, checkInNonces[owner]++))
    )
);
address recoveredAddress = ecrecover(digest, v, r, s);
require(recoveredAddress == owner, "Cryptographic signature validation mismatch");

Gate Check-in Replay ProtectionDynamic signatures expire every 90 seconds. The gate scanner terminal recovers the signer address on-chain or off-chain using the timestamp. If the request payload timestamp is more than 90 seconds old, verification fails.

4. Smart Contract API Registry

The primary smart contracts are verified and deployed on the Arc Network. Explore the API interface structure:

Function Signature	Scope	Core Commerce Rule
`createEvent(...)`	Primary	Registers event pricing basis and sets maximum markup and artist royalty percentages.
`purchasePrimaryTicket(...)`	Primary	Direct purchase using USDC. Mints ERC-721 token and routes 100% funds to artist.
`listTicketForResell(...)`	Resale	Checks requested price against markup cap boundary. Fails if boundary is exceeded.
`purchaseSecondaryTicket(...)`	Resale	Performs atomic settlement: seller payout (89%), artist royalty (10%), fee (1%).
`checkInTicket(...)`	Admission	Recovers EIP-712 dynamic signature, asserts 90s expiry boundary, marks ticket used.
`claimLoyaltyReward()`	Rewards	Pays 20 USDC bounty from reward pool to fans with 3+ verified event check-ins.

EventTicket on ArcScan FanRewardRegistry on ArcScan

5. Developer Quickstart Setup

Install the required packages to configure your web client for the EventShield smart contracts:

npm install viem wagmi @rainbow-me/rainbowkit lucide-react

Configure your Viem Chain definition for Arc Testnet (Chain ID: 5042002):

import { defineChain } from 'viem'

export const arcTestnet = defineChain({
  id: 5042002,
  name: 'Arc Testnet',
  nativeCurrency: { name: 'USDC', symbol: 'USDC', decimals: 18 },
  rpcUrls: {
    default: { 
      http: ['https://arc-node.thecanteenapp.com'] 
    },
  },
  blockExplorers: {
    default: { name: 'ArcScan', url: 'https://testnet.arcscan.app' },
  }
})

Generate EIP-712 structured data signatures directly inside your client wallet module:

import { signTypedData } from '@wagmi/core';

const DOMAIN = {
  name: 'EventShield',
  version: '2',
  chainId: 5042002,
  verifyingContract: '0x47e9dfBB189601B0FE25c26d75a11C266b22E82D' as const,
};

const TYPES = {
  CheckInRequest: [
    { name: 'tokenId', type: 'uint256' },
    { name: 'owner', type: 'address' },
    { name: 'timestamp', type: 'uint256' },
    { name: 'nonce', type: 'uint256' }
  ]
} as const;

async function signCheckIn(tokenId: number, owner: `0x${string}`, nonce: number) {
  const timestamp = Math.floor(Date.now() / 1000);
  
  const signature = await signTypedData(config, {
    domain: DOMAIN,
    types: TYPES,
    primaryType: 'CheckInRequest',
    message: {
      tokenId: BigInt(tokenId),
      owner,
      timestamp: BigInt(timestamp),
      nonce: BigInt(nonce)
    }
  });
  return { tokenId, owner, timestamp, signature };
}

6. Modal System & Live Sandbox Playground

EventShield incorporates a unified, state-driven global Modal architecture that eliminates disjointed browser popups. By managing a centralized state queue, it dynamically translates raw RPC errors, displays real-time transaction updates, offers logical Next-Step workflows, and supports accessible keyboard/focus behaviors.

1. Interactive Sandbox (Trigger and Inspect)

2. RPC Error-Decoding Simulator (Translates Raw Reverts)

3. Technical Architecture & Usage Guide

1. Register Provider (Global Root)

import { ModalProvider } from '@/context/ModalContext';

export default function Layout({ children }) {
  return (
    <Web3Provider>
      <ModalProvider>
        {children}
      </ModalProvider>
    </Web3Provider>
  );
}

2. Call inside component hook

import { useModal } from '@/context/ModalContext';

function PurchaseButton() {
  const modal = useModal();
  
  const handleBuy = () => {
    modal.confirm(
      'Confirm Ticket Purchase?',
      'Purchase dynamically with native USDC gas.',
      async () => {
        await writeContract(...);
      }
    );
  };
}

4. Maintenance, Scaling & Accessibility Best Practices

Focus-Trap & Accessibility: Modals incorporate role="dialog" and aria-modal="true" parameters to prevent external window click leakages. Escape-key keyboard listeners automatically handle closing safe non-loading modal enclaves.
Centralized Decoupled Mapping: Avoid hardcoding custom user-facing strings inside Solidity smart-contract reverts. The error system decouples RPC reverts inside decodeWeb3Error(), preserving raw developer stack traces while translating technical reverts into actionable plain text.
Queue Isolation (FIFO): Multi-modal overlaps are natively managed through a First-In-First-Out queue system. Modals are stored within an array stack and resolved sequentially to eliminate layout overlaps.

7. Troubleshooting & Frequently Asked Questions

Q: Why did my check-in transaction revert?

Verify the active cryptographic check-in nonce of the user by calling `checkInNonces(address)` on the contract. Nonce conflicts or timing lags exceeding 90 seconds will automatically revert verification to prevent screenshot sharing abuses.

Q: How do loyalty reward claims work on-chain?

The `FanRewardRegistry` contract exposes `claimLoyaltyReward()`. If you have attended 3 or more verified concerts (logged during gate entry transactions), the contract transfers a 20 USDC bounty directly into your wallet gaslessly.

Q: Can secondary resale tickets be sold for any price?

No. Secondary ticket prices are restricted to original price + markup cap configurations. Resale listings created above this margin revert dynamically inside the EVM registry to completely eliminate ticket scalping.