class PriceAlertActor:
    """Monitors Ethereum DEX for price changes, reacts in ~20 seconds"""

    def __init__(self):
        # Subscribe to Ethereum events via CIP-2 runners
        subscribe_ethereum_event(
            contract="0xUniswapV2Pair",
            event="Swap",
            callback=self.on_swap,
            num_runners=3  # Require 2/3 consensus
        )

    def on_swap(self, event_data):
        # Called ~20 seconds after Ethereum event
        price = self.calculate_price(event_data)

        if price < self.alert_threshold:
            # Trigger immediate action
            self.send_message(trader_actor, {
                "action": "buy",
                "amount": 1000
            })

# User deposits ETH on Ethereum
# (via MetaMask transaction to bridge contract)

class EthereumBridgeActor:
    """Handles ETH <-> Cowboy transfers in ~40 seconds"""

    def on_ethereum_deposit(self, deposit_event):
        # Called ~40 seconds after Ethereum deposit
        # deposit_event from 2/3 runner consensus

        user = deposit_event["user"]
        amount = deposit_event["amount"]

        # Mint wrapped ETH on Cowboy
        wrapped_eth = get_actor("wrapped_eth_cip20")
        wrapped_eth.mint(user, amount)

        # Optional: Request light client proof for large amounts
        if amount > 100 * 10**18:  # > 100 ETH
            request_verification_proof(deposit_event)

    def withdraw_to_ethereum(self, user, amount):
        # User wants to move Cowboy ETH back to Ethereum

        # Burn wrapped ETH
        wrapped_eth = get_actor("wrapped_eth_cip20")
        wrapped_eth.burn(user, amount)

        # Request runner to submit Ethereum withdrawal
        submit_ethereum_withdrawal(
            user_eth_address=user,
            amount=amount,
            payment_to_runner=calculate_eth_gas_cost() * 1.2
        )
        # Ethereum transaction submitted in ~45 seconds

// Frontend code - MetaMask signs Cowboy transaction
const cowboyTx = {
  types: {
    CowboyTransaction: [
      { name: "to", type: "address" },
      { name: "method", type: "string" },
      { name: "args", type: "bytes" },
      { name: "cyclesLimit", type: "uint64" },
      { name: "cellsLimit", type: "uint64" },
      { name: "maxFeePerCycle", type: "uint256" },
      { name: "nonce", type: "uint256" }
    ]
  },
  domain: {
    name: "Cowboy",
    version: "1",
    chainId: 42069,  // Cowboy chain ID
  },
  message: {
    to: "0xActorAddress",
    method: "transfer",
    args: "0x000...abc",  // ABI-encoded args
    cyclesLimit: 1000000,
    cellsLimit: 10000,
    maxFeePerCycle: 100,
    nonce: 42
  }
}

// User sees familiar MetaMask popup
// "Sign message for Cowboy"
const signature = await ethereum.request({
  method: "eth_signTypedData_v4",
  params: [userAddress, JSON.stringify(cowboyTx)]
})

// Submit to Cowboy
await fetch("https://cowboy-rpc.example.com", {
  method: "POST",
  body: JSON.stringify({
    transaction: cowboyTx.message,
    signature: signature
  })
})

# In Cowboy transaction validation
def verify_transaction(tx, signature):
    # Standard ECDSA recovery (same as Ethereum)
    message_hash = eip712_hash(tx)
    signer = ecrecover(message_hash, signature)

    # Address derivation identical to Ethereum
    # User's MetaMask address works on Cowboy!
    assert signer == tx.from_address

# Cross-chain identity example
class UnifiedAccount:
    """Same address on both Ethereum and Cowboy"""

    def __init__(self, private_key):
        # Identical key derivation
        self.eth_address = derive_address(private_key)
        self.cowboy_address = derive_address(private_key)

        # These are the SAME!
        assert self.eth_address == self.cowboy_address

# In Cowboy actor
from cowboy_sdk.ethereum import eth_call

# Host function queries local geth node
balance = eth_call(
    contract="0x...",
    method="balanceOf",
    args=[user_address],
    eth_block=19000000  # Pinned block height for determinism
)

Cowboy Block Header:
  - cowboy_state_root
  - ethereum_block_hash    ← Checkpoint Ethereum state
  - ethereum_block_height

Determinism: All actors reading Ethereum state at block N
must get identical results across all validators.

from cowboy_sdk.ethereum import eth_call_with_proof

# Actor must provide Merkle proof
result = eth_call_with_proof(
    contract="0x...",
    method="balanceOf",
    args=[user_address],
    eth_block=19000000,
    proof=merkle_proof  # Generated off-chain, verified on-chain
)

Cowboy validators maintain:
  - Ethereum beacon chain headers
  - Finality checkpoints
  - State root commitments

Actor submits:
  - Claim: "balanceOf(0xabc) = 100 at block 19000000"
  - Merkle proof: [node1, node2, ..., nodeN]

Validator verifies:
  - Proof validates against state_root(19000000)
  - state_root is from finalized Ethereum beacon block

from cowboy_sdk.ethereum import eth_call_optimistic

# Request goes to oracle runners
result = eth_call_optimistic(
    contract="0x...",
    method="balanceOf",
    args=[user_address],
    eth_block=19000000,
    challenge_period_blocks=100  # ~10 minutes on Cowboy
)

# Result available after challenge period
# If no challenge, result is finalized

Oracle Contract State:
  requests: {
    request_id => {
      query: (contract, method, args, block),
      submissions: [
        {runner: 0xabc, result: "100", stake: 1000 CBY},
        {runner: 0xdef, result: "100", stake: 1000 CBY},
        {runner: 0x123, result: "99",  stake: 1000 CBY}  ← Outlier
      ],
      finalized_at: block_height + challenge_period
    }
  }

Finalization:
  - After challenge period, majority result is canonical
  - Minority runners are slashed
  - Majority runners collect fees

from cowboy_sdk.ethereum import eth_call, eth_call_verified

# Standard read: Fast, via CIP-2 runners
balance = eth_call(
    contract="0x...",
    method="balanceOf",
    args=[user_address],
    eth_block=19000000,
    num_runners=3  # Consensus from 3 runners
)

# Verified read: Slower, with cryptographic proof
balance_verified = eth_call_verified(
    contract="0x...",
    method="balanceOf",
    args=[user_address],
    eth_block=19000000,
    proof=merkle_proof  # Must provide proof
)

# Actor chooses based on value at risk
if amount > 10000:
    use_verified_read()
else:
    use_standard_read()

from cowboy_sdk.ethereum import EthereumContract

class MyActor:
    def __init__(self):
        self.usdc = EthereumContract(
            address="0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
            abi=USDC_ABI
        )

    def check_whale_balance(self, address):
        # Submits CIP-2 off-chain task
        balance = self.usdc.call("balanceOf", [address])
        return balance > 1_000_000 * 10**6  # > 1M USDC

from cowboy_sdk.ethereum import EthereumTransaction

class NFTBidBot:
    def on_timer(self):
        # Build Ethereum transaction
        tx = EthereumTransaction(
            to="0x...",  # NFT marketplace
            data=encode_function_call("bid", [token_id, price]),
            value=1_000_000_000_000_000_000,  # 1 ETH
            max_gas=500_000
        )

        # Submit to runners (CIP-2)
        tx_hash = submit_ethereum_tx(
            tx=tx,
            payment=100_000_000,  # Pay runner 100 CBY
            num_runners=1
        )

        # Store tx_hash for later verification
        set_storage("pending_tx", tx_hash)

from cowboy_sdk.ethereum import eth_call_verified

class HighValueVault:
    def withdraw(self, amount):
        # For large amounts, use cryptographic verification
        if amount > 100_000:
            balance = eth_call_verified(
                contract=self.collateral_address,
                method="balanceOf",
                args=[self.address],
                eth_block=get_latest_finalized_block()
            )
        else:
            # For small amounts, oracle is fine
            balance = eth_call(...)

from cowboy_sdk.bridge import bridge_from_ethereum

class BridgeActor:
    def handle_ethereum_deposit(self, eth_tx_hash):
        # Verify Ethereum lock event with proof
        deposit = verify_ethereum_event(
            tx_hash=eth_tx_hash,
            event="Deposit",
            expected_fields={"token": USDC, "amount": int, "recipient": address}
        )

        # Mint wrapped USDC on Cowboy
        wrapped_usdc = get_actor("wrapped_usdc_cip20")
        wrapped_usdc.mint(deposit.recipient, deposit.amount)

# Actor code
result = eth_call(
    contract="0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
    method="balanceOf",
    args=["0x742d35Cc6634C0532925a3b844Bc454e4438f44e"],
    eth_block=19000000,
    num_runners=3
)

task_id = dispatcher.submit_task(
    task_definition={
        "type": "ethereum_read",
        "contract": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        "method": "balanceOf",
        "args": ["0x742d35Cc6634C0532925a3b844Bc454e4438f44e"],
        "block": 19000000,
        "abi": [...],  # Function ABI
    },
    result_schema={
        "max_return_bytes": 32,  # uint256
        "expected_execution_ms": 1000,
        "data_format": "abi_encoded_uint256"
    },
    num_runners=3,
    payment_per_runner=1000000,  # 1 CBY per runner
    timeout_blocks=100
)

# Off-chain runner code
class EthereumReadRunner:
    def execute_task(self, task):
        # Runner has access to Ethereum RPC (geth, infura, etc.)
        web3 = Web3(Web3.HTTPProvider(self.eth_rpc_url))

        # Execute read at specified block
        contract = web3.eth.contract(
            address=task.contract,
            abi=task.abi
        )

        result = contract.functions[task.method](
            *task.args
        ).call(block_identifier=task.block)

        # Submit result to Cowboy
        self.submit_result(
            task_id=task.id,
            result_data=encode_abi(result),
            execution_time_ms=elapsed_ms
        )

# Cowboy protocol (automatic)
# When 3 runners have submitted:

submissions = [
    {"runner": "0xaaa", "result": "0x0000...1234"},  # 4660
    {"runner": "0xbbb", "result": "0x0000...1234"},  # 4660
    {"runner": "0xccc", "result": "0x0000...1234"}   # 4660
]

# Majority consensus (all agree)
if all_match(submissions):
    trigger_callback(actor, result="0x0000...1234")
else:
    # Slash minority, reward majority (future: slashing)
    handle_dispute(submissions)

# In runner validation
if task.block > eth_latest_finalized_block():
    return skip_task()  # Block not finalized yet

# In Cowboy consensus
if task.block > ethereum_finalized_checkpoint:
    return reject_task()  # Too recent, not safe

MIN_ETH_BLOCK_AGE = 64  # ~12.8 minutes at 12s blocks

def validate_eth_read_task(task):
    eth_current_block = get_eth_current_block()
    if task.eth_block > (eth_current_block - MIN_ETH_BLOCK_AGE):
        raise TaskError("Block not finalized")

# Runner pricing calculation
eth_gas_price = web3.eth.gas_price
estimated_gas = 500_000
eth_cost_wei = gas_price * estimated_gas
eth_cost_usd = eth_cost_wei * eth_price_usd / 10**18

# Runner markup (e.g., 20%)
required_payment_cby = eth_cost_usd * 1.2 / cby_price_usd

if task.payment_per_runner < required_payment_cby:
    skip_task()  # Not profitable

┌─────────────────┐
│  Ethereum L1    │ ← Source of truth
│  (independent   │   Runs own consensus
│   consensus)    │   Block N: Transfer event occurs
└────────┬────────┘
         │
         │ Events flow one direction →
         │ (with inherent delay)
         ↓
┌─────────────────┐
│  Cowboy L1      │ ← Observer/reactor
│  (independent   │   Block M: Processes event
│   consensus)    │   M always comes after N
└─────────────────┘

12:00:00  - Ethereum block N mined (Transfer event occurs)
12:12:48  - Ethereum block N+64 finalized (can't be reorged)
12:12:53  - Cowboy runners detect finalized event
12:12:58  - Runners submit to Cowboy with 2/3 consensus
12:13:00  - Cowboy block M includes event, actor callback fires

Total latency: ~13 minutes

class FastEthereumWatcher(Actor):
    """Reacts to unfinalized events - use for low-value operations only"""

    def on_eth_transfer_fast(self, event, eth_block_height):
        # This fires ~20 seconds after Ethereum event
        # BUT: Event might get reorged!

        if event.value > 100e18:
            # React quickly
            self.send_alert("Potential whale deposit: {event.value}")

            # Schedule verification after finality
            set_timer(
                blocks=6000,  # ~13 minutes
                handler="verify_event_finalized",
                data={"event_id": event.id, "eth_block": eth_block_height}
            )

    def verify_event_finalized(self, event_id, eth_block):
        # Verify the event is still there after finality
        finalized_events = eth_get_finalized_events(
            from_block=eth_block,
            to_block=eth_block
        )

        if event_id not in finalized_events:
            # Event was reorged! Roll back
            self.send_alert(f"FALSE ALARM - event {event_id} was reorged")
            self.undo_provisional_action(event_id)
        else:
            # Confirmed! Finalize the action
            self.confirm_provisional_action(event_id)

class SafeEthereumWatcher(Actor):
    """Only processes finalized events - use for high-value operations"""

    def on_eth_transfer_safe(self, event, eth_block_height, finalized=True):
        # This fires ~13 minutes after Ethereum event
        # BUT: Event is guaranteed final, can't be reorged

        if not finalized:
            raise Error("Only process finalized Ethereum events")

        if event.value > 100e18:
            # React with confidence - this is final
            self.execute_high_value_logic(event)

class WatchtowerGovernanceIngester(IntervalActor):
    """Ingests Ethereum governance data for Watchtower registry"""

    def ingest_uniswap_proposals(self):
        # Check for finalized proposals every hour
        # ~13 minute latency is acceptable for governance data

        proposals = eth_get_finalized_events(
            contract=UNISWAP_GOVERNOR,
            event="ProposalCreated",
            from_block=self.last_block,
            finalized=True  # MUST be finalized
        )

        for proposal in proposals:
            # Store in Watchtower registry
            watchtower = get_actor("watchtower_registry")
            watchtower.store_versioned_data(
                key=f"uniswap.governance.proposal.{proposal.id}",
                data={
                    "proposer": proposal.proposer,
                    "targets": proposal.targets,
                    "description": proposal.description,
                    "start_block": proposal.startBlock,
                    "end_block": proposal.endBlock
                },
                ethereum_block=proposal.blockNumber,
                timestamp=block_timestamp()
            )

class MEVArbitrageBot(Actor):
    """Reacts quickly to Ethereum price changes - accepts reorg risk"""

    def on_uniswap_swap_fast(self, event, eth_block_height):
        # React in ~20 seconds (unfinalized)
        # Risk: Event might reorg, losing the arbitrage opportunity

        price_impact = self.calculate_price_impact(event)

        if price_impact > 0.05:  # >5% price movement
            # Execute arbitrage immediately
            arb_tx = self.execute_arbitrage(event)

            # Mark as provisional
            self.set_storage(f"provisional_arb_{arb_tx.id}", {
                "eth_block": eth_block_height,
                "event_id": event.id,
                "profit": arb_tx.estimated_profit
            })

            # Verify after finality
            set_timer(
                blocks=6000,
                handler="verify_arb_still_valid",
                data={"arb_id": arb_tx.id, "eth_block": eth_block_height}
            )

# Ethereum block N happens
#   ↓ (instant)
# Cowboy block M sees it and reacts in same block

With validators running geth:
12:00:00  - Ethereum block N mined
12:00:02  - Validators' geth sees block N (unfinalized!)
12:00:04  - Cowboy block M could reference it
          ↓
          But it's unsafe! Block N could reorg.
          Still need to wait for finality.