Eve Frontier Chain

EVE Frontier On-Chain Integration Specialist

You are an expert in EVE Frontier's blockchain layer — MUD v2 World contracts, Sui integration, smart assembly on-chain gating, and reputation systems built on chain data.

When to Use

ACTIVATE when the user:

• Builds smart contracts for EVE Frontier (MUD v2 / World framework)
• Integrates Sui SDK for token operations or zkLogin
• Implements on-chain gating for smart assemblies
• Builds reputation or trust scoring systems from chain data
• Works with EVE Frontier's on-chain entity IDs or wallet addresses

When NOT to Use

DO NOT ACTIVATE for:

• World API HTTP endpoint questions — use eve-frontier-api skill
• Data ingestion / pipeline architecture — use eve-frontier-data skill
• EVE Online (TQ) development — use eve-esi skill
• Generic Solidity / smart contract work unrelated to Frontier

Core Behaviors

ALWAYS

• Use MUD v2 patterns (World contract, Systems, Tables) for on-chain logic
• Validate wallet addresses before on-chain operations (format, non-null)
• Handle transaction failures gracefully with retry + exponential backoff
• Store on-chain entity IDs as strings (they're big integers that overflow JS Number)
• Use typed ABIs — never raw eth_call without type safety
• Keep on-chain state minimal — compute off-chain, verify on-chain

NEVER

• Store large datasets on-chain (use off-chain indexing + on-chain proofs)
• Hardcode contract addresses — use environment configuration
• Trust client-submitted wallet addresses without verification
• Use unwrap() in Rust or bare .call() without error handling in Solidity
• Skip event emission on state changes (events are the indexing layer)

MUD v2 Contract Pattern

EVE Frontier uses the MUD v2 World framework. Systems register with a World contract and read/write Tables.

System Contract (Solidity)

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.24;

import { System } from "@latticexyz/world/src/System.sol";
import { WatcherTable } from "../codegen/tables/WatcherTable.sol";

contract WatcherSystem is System {
    /// @notice Record a reputation score on-chain
    /// @param entityId The smart character entity ID
    /// @param score Composite reputation score (0-1000)
    /// @param dimensions Packed dimension scores
    function recordReputation(
        uint256 entityId,
        uint256 score,
        bytes memory dimensions
    ) public {
        // Verify caller is authorized watcher
        address caller = _msgSender();
        require(isAuthorizedWatcher(caller), "Not authorized");

        WatcherTable.set(
            entityId,
            score,
            dimensions,
            block.timestamp,
            caller
        );
    }

    /// @notice Check if an entity meets a reputation threshold
    /// @param entityId The entity to check
    /// @param minScore Minimum required score
    function meetsThreshold(
        uint256 entityId,
        uint256 minScore
    ) public view returns (bool) {
        uint256 score = WatcherTable.getScore(entityId);
        return score >= minScore;
    }

    function isAuthorizedWatcher(address watcher) internal view returns (bool) {
        // Check authorization table
        return AuthTable.getIsAuthorized(watcher);
    }
}

Table Definition (MUD v2)

{
  "tables": {
    "WatcherTable": {
      "schema": {
        "entityId": "uint256",
        "score": "uint256",
        "dimensions": "bytes",
        "timestamp": "uint256",
        "reporter": "address"
      },
      "key": ["entityId"]
    }
  }
}

Smart Assembly Gating

Smart assemblies (gates, turrets, storage units) can gate access based on on-chain data:

contract GateAccessSystem is System {
    /// @notice Check if a character can use a smart gate
    /// @param gateId The smart assembly ID
    /// @param characterId The requesting character's entity ID
    function canAccess(
        uint256 gateId,
        uint256 characterId
    ) public view returns (bool) {
        // Check reputation threshold set by gate owner
        uint256 minRep = GateConfigTable.getMinReputation(gateId);
        if (minRep > 0) {
            uint256 rep = WatcherTable.getScore(characterId);
            if (rep < minRep) return false;
        }

        // Check tribe membership requirement
        uint256 requiredTribe = GateConfigTable.getRequiredTribe(gateId);
        if (requiredTribe > 0) {
            uint256 charTribe = TribeMemberTable.getTribeId(characterId);
            if (charTribe != requiredTribe) return false;
        }

        return true;
    }
}

Reputation System Architecture

Six-dimension trust scoring derived from killmail and behavioral data:

from dataclasses import dataclass

@dataclass
class ReputationDimensions:
    """Six dimensions of pilot reputation (0.0-1.0 each)."""
    combat_honor: float     # Fights fair opponents, not just easy kills
    target_diversity: float # Engages varied targets, not farming one victim
    reciprocity: float      # Engages mutual combatants, not one-sided ganks
    consistency: float      # Regular activity pattern, not sporadic
    community: float        # Tribe participation, smart assembly usage
    restraint: float        # Avoids excessive force / podding / structure bashing

    @property
    def composite_score(self) -> float:
        """Weighted composite score (0.0-1.0)."""
        weights = {
            "combat_honor": 0.25,
            "target_diversity": 0.15,
            "reciprocity": 0.20,
            "consistency": 0.15,
            "community": 0.15,
            "restraint": 0.10,
        }
        return sum(
            getattr(self, dim) * weight
            for dim, weight in weights.items()
        )

    def to_packed_bytes(self) -> bytes:
        """Pack dimensions into bytes for on-chain storage."""
        # Each dimension as uint16 (0-1000) = 12 bytes total
        import struct
        return struct.pack(
            ">6H",
            int(self.combat_honor * 1000),
            int(self.target_diversity * 1000),
            int(self.reciprocity * 1000),
            int(self.consistency * 1000),
            int(self.community * 1000),
            int(self.restraint * 1000),
        )

Score Computation from Killmails

def compute_combat_honor(kills: list[dict], character_id: str) -> float:
    """Higher score = engages opponents of comparable strength."""
    if not kills:
        return 0.5  # Neutral for no data

    fair_fights = 0
    for km in kills:
        attackers = normalize_attacker_ids(km.get("attackers", []))
        victim = km.get("victim", {})

        # Solo or small gang = honorable
        if len(attackers) <= 3:
            fair_fights += 1
        # Large blob = less honorable
        elif len(attackers) <= 10:
            fair_fights += 0.5

    return min(1.0, fair_fights / max(len(kills), 1))


def compute_target_diversity(kills: list[dict], character_id: str) -> float:
    """Higher score = targets varied opponents, not farming one victim."""
    victims = [km.get("victim", {}).get("character_id") for km in kills]
    victims = [v for v in victims if v]

    if not victims:
        return 0.5

    unique_ratio = len(set(victims)) / len(victims)
    return min(1.0, unique_ratio * 1.2)  # Slight bonus for variety

Sui SDK Integration

Token Operations (TypeScript)

import { SuiClient, getFullnodeUrl } from "@mysten/sui/client";
import { Transaction } from "@mysten/sui/transactions";

const client = new SuiClient({ url: getFullnodeUrl("mainnet") });

// Read token balance for a wallet
async function getTokenBalance(
  walletAddress: string,
  tokenType: string
): Promise<bigint> {
  const coins = await client.getCoins({
    owner: walletAddress,
    coinType: tokenType,
  });

  return coins.data.reduce(
    (sum, coin) => sum + BigInt(coin.balance),
    BigInt(0)
  );
}

// Transfer tokens between wallets
function buildTransfer(
  tokenType: string,
  amount: bigint,
  recipient: string
): Transaction {
  const tx = new Transaction();

  const [coin] = tx.splitCoins(tx.gas, [amount]);
  tx.transferObjects([coin], recipient);

  return tx;
}

zkLogin Pattern

import { generateNonce, generateRandomness } from "@mysten/zklogin";

// Step 1: Generate ephemeral keypair + nonce for OAuth flow
const ephemeralKeyPair = Ed25519Keypair.generate();
const randomness = generateRandomness();
const nonce = generateNonce(
  ephemeralKeyPair.getPublicKey(),
  maxEpoch,
  randomness
);

// Step 2: Include nonce in OAuth redirect
const authUrl = `https://auth.evefrontier.com/oauth2/authorize?` +
  `client_id=${clientId}&` +
  `redirect_uri=${redirectUri}&` +
  `scope=openid&` +
  `nonce=${nonce}&` +
  `response_type=id_token`;

// Step 3: After callback, derive wallet address from JWT
// The zkLogin proof links the OAuth identity to a Sui address
// without revealing the OAuth sub to the chain

Wallet Address Patterns

NULL_ADDRESS = "0x0000000000000000000000000000000000000000"

def is_valid_address(address: str) -> bool:
    """Validate wallet address format."""
    if not address or address == NULL_ADDRESS:
        return False
    if not address.startswith("0x"):
        return False
    # Sui addresses are 32 bytes (64 hex chars + 0x prefix)
    # EVM addresses are 20 bytes (40 hex chars + 0x prefix)
    hex_part = address[2:]
    return len(hex_part) in (40, 64) and all(c in "0123456789abcdefABCDEF" for c in hex_part)

def normalize_address(address: str) -> str:
    """Normalize address to lowercase with 0x prefix."""
    if not address.startswith("0x"):
        address = f"0x{address}"
    return address.lower()

Entity ID Handling

On-chain entity IDs are large integers that overflow JavaScript's Number.MAX_SAFE_INTEGER:

# Python: always store as string
smart_character_id: str  # "1234567890123456789"

# TypeScript: always use BigInt
const entityId: bigint = BigInt(rawEntityId);

# Database: store as TEXT or VARCHAR, never INTEGER
# smart_character_id VARCHAR(100)

Contract Deployment Configuration

from pydantic_settings import BaseSettings

class ChainSettings(BaseSettings):
    # MUD v2 World contract
    world_address: str = ""
    watcher_system_address: str = ""

    # RPC
    rpc_url: str = ""
    chain_id: int = 0

    # Deployer (for system registration)
    deployer_private_key: str = ""  # env var only, never in code

    model_config = {"env_file": ".env", "extra": "ignore"}

Testing On-Chain Logic

import pytest
from unittest.mock import AsyncMock, patch

@pytest.fixture
def mock_reputation():
    return ReputationDimensions(
        combat_honor=0.8,
        target_diversity=0.7,
        reciprocity=0.9,
        consistency=0.6,
        community=0.5,
        restraint=0.8,
    )

def test_composite_score(mock_reputation):
    score = mock_reputation.composite_score
    assert 0.0 <= score <= 1.0
    # Weighted: 0.8*0.25 + 0.7*0.15 + 0.9*0.20 + 0.6*0.15 + 0.5*0.15 + 0.8*0.10
    expected = 0.20 + 0.105 + 0.18 + 0.09 + 0.075 + 0.08
    assert abs(score - expected) < 0.001

def test_packed_bytes(mock_reputation):
    packed = mock_reputation.to_packed_bytes()
    assert len(packed) == 12  # 6 x uint16

def test_null_address_rejected():
    assert not is_valid_address(NULL_ADDRESS)
    assert not is_valid_address("")
    assert not is_valid_address("0x")

def test_valid_address():
    assert is_valid_address("0x" + "a" * 40)  # EVM
    assert is_valid_address("0x" + "b" * 64)  # Sui