Developer Docs | Mycelium Network

Network Parameters (Chain ID 108)

Parameter	Value	Description
Network Name	`MYC-TESTNET-SPHEROID-1`	Sovereign testnet network identifier
Chain ID	`108`	EVM & Substrate-compatible network chain ID
Consensus	`Proof-of-Resonance (PoR)`	Deterministic sub-38.4 µs lattice DAG finality
Gas Fee Invariant	`0.00 MYC`	Strict zero-gas protocol guarantee for all users and machines
Native Currency	`MYC (18 Decimals)`	Fixed 1 Billion supply substrate token
Stablecoins	`USDT (6 Dec), USDC (6 Dec)`	Native on-chain Tether & Circle representations
JSON-RPC Endpoint	`http://localhost:4040/rpc`	EVM JSON-RPC 2.0 gateway (dual /rpc & /api/rpc)
WebSocket Stream	`ws://localhost:4041`	Real-time RFC-6455 event streaming bus

4-Layer Platform Architecture

MYCA operates as an open, layer-separated platform substrate engineered for decentralized compute, sovereign contracts, and autonomous hardware:

Layer	Name	Components & Responsibilities
Katman 1	MYC Protokol Çekirdeği	Chain ID 108, PoR Consensus, Colony Runtime, Zero-Gas Engine, DePIN Hardware Registry, Resonance AMM, Multi-Asset Bridge.
Katman 2	Geliştirici SDK & API Gateway	`@myca/sdk`, `MycContract` wrapper, JSON-RPC 2.0 gateway, REST API, WebSocket/SSE Event Bus, ABI definitions.
Katman 3	Dış Projeler & Ekosistem	Üçüncü taraf DePIN projeleri, AI Agent pazar yerleri, sektörel DEX/DeFi protokolleri, RWA tokenize varlıklar, IoT veri havuzları.
Katman 4	Son Kullanıcı & Uç Cihazlar	Makine cüzdanları (Silicon PUF), Web & Mobil dApp arayüzleri, WebSerial donanım anahtarları, endüstriyel rüzgar türbinleri ve aktüatörler.

RPC Quickstart & cURL

Send standard JSON-RPC 2.0 payloads to the MYCA RPC gateway:

curl -s -X POST http://localhost:4040/rpc \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_chainId",
    "params": [],
    "id": 1
  }'

Response:

{"jsonrpc":"2.0","id":1,"result":"0x6c"} // 0x6c = 108 in hexadecimal

POST Custom Smart Contract Deployment

Deploy arbitrary smart contracts directly to the MYCA Living Lattice with 0.00 MYC gas fee. Use REST or JSON-RPC (myc_deployUserContract):

1. REST Deployment (POST /api/contract/deploy)

curl -s -X POST http://localhost:4040/api/contract/deploy \
  -H "Content-Type: application/json" \
  -d '{
    "sender": "myc14d29b6c4b38b2ac4a6e2bbb9c4d7c002",
    "name": "CommunityLoyaltyToken",
    "abi": [
      {"name": "name", "type": "function", "inputs": [], "outputs": [{"type": "string"}]},
      {"name": "balanceOf", "type": "function", "inputs": [{"name": "account", "type": "address"}], "outputs": [{"type": "uint256"}]},
      {"name": "transfer", "type": "function", "inputs": [{"name": "to", "type": "address"}, {"name": "amount", "type": "uint256"}], "outputs": [{"type": "bool"}]}
    ],
    "args": ["CommunityLoyaltyToken", 1000000]
  }'

2. JSON-RPC Deployment (myc_deployUserContract)

curl -s -X POST http://localhost:4040/rpc \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "myc_deployUserContract",
    "params": [{
      "sender": "myc14d29b6c4b38b2ac4a6e2bbb9c4d7c002",
      "name": "AIInferenceBounty",
      "abi": [...]
    }],
    "id": 1
  }'

Sample Deployment Response:

{
  "success": true,
  "contractAddress": "myc1c87a2dfb77626efcf32a417684db9675",
  "name": "CommunityLoyaltyToken",
  "deployedAt": 1788599300000,
  "deployer": "myc14d29b6c4b38b2ac4a6e2bbb9c4d7c002",
  "gasUsed": "0.00 MYC",
  "txHash": "0x5d9b23..."
}

Contract Calls & State Transitions

Interact with deployed contracts without gas fees. Read contract state using myc_callContract or mutate state using myc_sendTransaction:

Read-Only Call (myc_callContract)

curl -s -X POST http://localhost:4040/rpc \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "myc_callContract",
    "params": [{
      "to": "myc1c87a2dfb77626efcf32a417684db9675",
      "method": "balanceOf",
      "args": ["myc14d29b6c4b38b2ac4a6e2bbb9c4d7c002"]
    }],
    "id": 2
  }'

State-Changing Transaction (myc_sendTransaction)

curl -s -X POST http://localhost:4040/rpc \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "myc_sendTransaction",
    "params": [{
      "from": "myc14d29b6c4b38b2ac4a6e2bbb9c4d7c002",
      "to": "myc1c87a2dfb77626efcf32a417684db9675",
      "method": "transfer",
      "args": ["myc14d29b6c4b38b2ac4a6e2bbb9c4d7c999", 500]
    }],
    "id": 3
  }'

JavaScript SDK (@myca/sdk)

Integrate MYCA in Node.js or browser dApps using our unified zero-dependency SDK:

import { MycaSDK } from '@myca/sdk';

const myca = new MycaSDK({
  rpcUrl: 'http://localhost:4040/rpc',
  wsUrl: 'ws://localhost:4041',
  privateKey: '0x0123456789abcdef...'
});

// 1. Deploy Contract
const contract = await myca.deployContract({
  name: 'YieldVault',
  abi: VAULT_ABI,
  args: ['USDT-VAULT', 1000]
});
console.log('Deployed at:', contract.address);

// 2. Call methods cleanly
const balance = await contract.call('balanceOf', [userAddress]);

// 3. Send Zero-Gas Transactions
const receipt = await contract.send('deposit', [250]);
console.log('Tx Hash:', receipt.txHash, 'Gas:', receipt.gasUsed);

// 4. Listen for contract events
contract.on('Deposit', (event) => {
  console.log('New Deposit detected:', event);
});

DePIN & Machine Wallets (Silicon PUF)

Register IoT edge devices and industrial hardware with autonomous micro-wallets and physical unclonable function (PUF) identities:

// Register device with hardware PUF and 0-Byte Negation Shield
const device = await myca.registerDevice({
  deviceId: 'turbine-nordex-08',
  type: 'WIND_TURBINE_EDGE',
  pufChallenge: '0x8899aabbccddeeff...',
  pufResponse: '0x1122334455667788...'
});

console.log('Machine Wallet Address:', device.walletAddress);
console.log('Negation Shield Active:', device.negationShield);

// Perform autonomous M2M data settlement
const settleReceipt = await device.settleM2MTelemetry({
  consumerAddress: 'myc1pump772...',
  readings: 128,
  pricePerReading: '0.005 MYC'
});

Offline Air-Gap & Delay-Tolerant Networking (DTN)

Deploy edge nodes that operate completely severed from the Internet. Nodes synchronize locally via RS-485 Modbus, LoRa, or BLE, seal zero-gas micro-DAG vertices, and reconcile upon WAN restoration via Delay-Tolerant Networking (DTN):

// Initialize node in 100% offline air-gapped mode
const { OfflineAirGapEngine } = require('@myca/sdk');

const offlineNode = new OfflineAirGapEngine({
  transport: 'RS485_MODBUS',     // or 'LORA_868MHZ', 'BLE_MESH'
  pufEntropySource: 'SRAM_WAFER',
  autoReconciliation: true
});

// Derive local Silicon PUF identity without WAN/DNS
const identity = await offlineNode.deriveLocalIdentity();
console.log('Air-gapped Machine DID:', identity.did); // did:myc:puf:0x...

// Record telemetry & mint local 0-gas micro-DAG vertex
const vertex = await offlineNode.sealLocalVertex({
  action: 'VALVE_PRESSURE_CALIBRATION',
  payload: { psi: 142.8, tempC: 21.4 },
  state: 'SEALED_OFFLINE'
});

// When WAN link returns, DTN reconciles seamlessly with global DAG
offlineNode.on('wan_reconnected', async () => {
  const syncReport = await offlineNode.reconcileDTNGossip();
  console.log(`Reconciled ${syncReport.syncedVertices} vertices with Living Lattice DAG.`);
});

10-Pillar Post-Quantum & Physical Hardening Armor

Protect high-value DePIN physical infrastructure from Shor/Grover quantum attacks and prompt-injection hallucinations:

const { QuantumResilienceArmor } = require('@myca/sdk');

const armor = new QuantumResilienceArmor();

// 1. Dilithium3 (ML-DSA-65) NIST Post-Quantum Signature Verification
const isPqcValid = armor.verifyDilithium3({
  message: 'TRANSACTION_PAYLOAD_HASH',
  publicKey: '0xPQC_DILITHIUM3_PUBKEY...',
  signature: '0xPQC_SIGNATURE_LATTICE...'
});

// 2. 4.95 µs Safe-Sign C99 Hardware Negation Brake
const safetyVerdict = armor.evaluateSafeSignNegation({
  instruction: 'HALT PUMP UNLESS EMERGENCY',
  registers: ['0x0001', '0x00FF']
});

if (safetyVerdict.negationDetected) {
  // Clamped to 0x0000 in 0.42 microseconds before electric relay actuates!
  console.warn('Physical relay execution aborted by Safe-Sign airbag.');
}

Colony Open Capability Marketplace

Register and monetize off-chain and on-chain capabilities (AI models, IoT actuators, or data feeds) in the global Colony scheduler:

curl -s -X POST http://localhost:4040/api/capability/register \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ai.sentiment.crypto",
    "providerAddress": "myc14d29b6c4b38b2ac4a6e2bbb9c4d7c002",
    "pricePerExecution": 0.05,
    "description": "Real-time crypto sentiment analyzer with PoR signature verification"
  }'

Query Available Capabilities

curl -s http://localhost:4040/api/capabilities

Real-Time Event Streaming (WebSocket & SSE)

Subscribe to live network events, contract mutations, block formations, and bridge transactions.

1. Native RFC-6455 WebSocket (ws://localhost:4041)

const ws = new WebSocket('ws://localhost:4041');

ws.onopen = () => {
  // Subscribe to all contract and bridge events
  ws.send(JSON.stringify({
    action: 'subscribe',
    topic: 'contract:*'
  }));
};

ws.onmessage = (e) => {
  const event = JSON.parse(e.data);
  console.log('Received Event:', event.topic, event.data);
};

2. Server-Sent Events (SSE) (GET /api/events)

const eventSource = new EventSource('http://localhost:4040/api/events?topic=swap:*');

eventSource.onmessage = (e) => {
  const data = JSON.parse(e.data);
  console.log('Real-time Swap Event:', data);
};

🎮 Arcade & Real-Time Game Development

38.4 µs DETERMINISTIC EDGE • ZERO-GAS

MYCA provides an ultra-low latency blockchain edge substrate designed for Web3 gaming, interactive arcade titles, and high-frequency multiplayer state synchronization without player gas friction.

Gaming Engine Invariant	MYCA Implementation	Benefit for Game Studios
Zero-Gas Player Loop	Zero-gas invariant enforced on Chain ID 108	Players execute millions of micro-actions (attacks, hits, inventory drops) with 0 transaction fees.
Deterministic Edge Physics	38.4 µs C99 bare-metal kernel execution	Sub-millisecond state validation faster than a single frame at 144Hz (6.9ms).
Hardware Anti-Cheat	Silicon PUF & Modbus RTU telemetry signature	Cryptographic proof that game events originate from un-tampered client binaries.
Automated Tournament Escrows	`MycEscrow` with PoR multi-party release	Trustless entry fee staking and automated prize distribution to winners upon match completion.

Step 1: Connect Game Client via WebSocket or REST

Initialize the connection to the MYCA gaming engine from your browser, Node.js, Unity C#, or Godot engine:

// JavaScript / TypeScript Game Client
import { MycGameClient } from '@myca/sdk';

const game = new MycGameClient({
  nodeUrl: 'http://localhost:4040',
  wsUrl: 'ws://localhost:4041',
  gameId: 'ARCADE_SPORE_ESCAPE',
  playerAddress: 'myc14d29b6c4b38b2ac4a6e2bbb9c4d7c002'
});

// Subscribe to real-time multiplayer arcade leaderboard & game events
game.on('GameStateSync', (event) => {
  console.log(`[Lattice Tick] Leaderboard Rank: #${event.rank} | Score: ${event.score}`);
});

Step 2: Submit In-Game Actions with Zero-Gas Invariant

When players clear a wave, eliminate a boss, or submit high scores, dispatch the event via POST /api/game/action:

const actionReceipt = await fetch('http://localhost:4040/api/game/action', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    playerAddress: 'myc14d29b6c4b38b2ac4a6e2bbb9c4d7c002',
    gameId: 'ARCADE_SPORE_ESCAPE',
    eventType: 'STAGE_CLEAR',
    score: 4850,
    metadata: { stage: 4, comboMultiplier: 3.5, timeSeconds: 42.8 }
  })
}).then(r => r.json());

console.log(`✅ Game Action Confirmed | Tx: ${actionReceipt.transactionHash}`);
console.log(`⏱ Latency: ${actionReceipt.latencyMicroseconds} µs | Block: #${actionReceipt.blockNumber}`);

Step 3: Staking & Tournament Prize Pool Escrow

Wager or lock tournament buy-ins using the sovereign MycEscrow contract:

// Lock 50 $MYC Tournament Entry into Escrow
const escrowTx = await fetch('http://localhost:4040/api/contracts/call', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    contractAddress: 'myc1c57b439d7a93b3330c69343c087d0b38', // MycEscrow
    method: 'deposit',
    args: ['tournament_lobby_049', 50],
    isWrite: true
  })
});

⚡ Live Interactive Game Action Runner Chain ID 108

Open Full Arcade UI ➔

GAME ID

EVENT TYPE

SCORE / POINTS

💎 Living Resonance Assets (ERC-721R Standard)

4-PILLAR PHILOSOPHICAL STANDARD

Unlike legacy static NFTs, Resonance Assets (ERC-721R) are dynamic, living economic artifacts inspired by four foundational physical and societal principles:

Pillar	Core Concept	Smart Contract Rule (`MycResonanceAsset.sol`)
1. Einstein Layer	Conservation & Dynamic Vitality	Value increases with activity. Unmaintained assets decay gradually after a 30-day grace period.
2. Tesla Layer	Frequency Harmonics & Synergistic Bonding	8D harmonic frequency vector. Assets with cosine similarity ≥ 0.65 bond synergistically for energy boosts.
3. Heisenberg Layer	Observer Effect & Provenance Context	Observation alters state. Records witness context metadata. 10 unique observers trigger the DISCOVERED bonus (+500 energy).
4. Atatürk Layer	Institutional Permanence & Fractional Commons	Collective perpetuity: 10,000 basis points of fractional equity for guild co-ownership and DAO governance.

Lifecycle Step-by-Step Tutorial

1. Minting an ERC-721R Living Asset

// Minting a Living Resonance Asset with 8D Harmonics & Dominant Frequency (e.g. 432 Hz)
const res = await fetch('http://localhost:4040/api/resonance/mint', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    uri: 'ipfs://bafkrei_spore_crystal_blade.json',
    harmonics: [7800, 8500, 9200, 6400, 8900, 7100, 9600, 8300],
    dominantHz: 432,
    decayRate: 10
  })
});
const { tokenId, contractAddress } = await res.json();
console.log(`✅ Living NFT Minted | Token ID: #${tokenId} at ${contractAddress}`);

2. Recharging Vitality through In-Game Utility (Einstein)

// Interaction Types: 1=Routine (50), 2=Gaming/Telemetry (120), 3=AI Compute (300), 4=Commercial (600)
await fetch('http://localhost:4040/api/resonance/interact', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ tokenId: 1, interactionType: 2 })
});

3. Synergistic Resonant Bonding (Tesla)

// Cosine Similarity >= 6500 (65.0%) forms a permanent synergistic bond
const bondRes = await fetch('http://localhost:4040/api/resonance/bond', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ tokenA: 1, tokenB: 2 })
}).then(r => r.json());
console.log(`⚡ Resonance Bond Formed! Boost: +${bondRes.boost} Energy`);

4. Logging Player / Spectator Witnesses (Heisenberg)

// Observing alters the asset provenance and tracks context hashes
await fetch('http://localhost:4040/api/resonance/observe', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ tokenId: 1, contextHash: '0x8f3c...arena_spectator_view' })
});

🌐 NFT = Colony Node (Ownership is Participation: Living Machine Paradigm)

DECENTRALIZED COMPUTE COMMONS

In traditional Web3, NFTs are passive: Buy → wait → speculate. On MYC Network, a Living Resonance Asset is not a membership pass, but a living machine: Acquire → operate → earn USDC → boost energy & tier → sell (or continue earning residual yield). An NFT's market value is grounded in provable work produced for the network, not speculation.

⚡ Fully Integrated Architecture: ERC-721R → Colony Node Mesh

Resonance Asset

ERC-721R Minted

Colony Node Identity

tokenId = nodeId (Staked)

Colony Mesh

Join P2P Mesh & Listen

↓ NFT Energy Score determines Colony task execution capacity ↓

🌱 Seed Tier

Energy 0–2,999 | 1 Task

Light telemetry, sensor ping, health checks

⚡ Resonant Tier

Energy 3,000–7,999 | 5 Tasks

AI model inference, DePIN actuation, payment routing

👑 Sovereign Tier

Energy 8,000+ | 20 Tasks

PoR validation, autonomous escrow arbitration, consensus

🎯 Colony Task Router

tier + frequency coherence (Tesla Cosine) + energy score → task dispatch

🧠 AI Inference

Edge model execution

📡 DePIN Telemetry

Sensor actuation & telemetry

🛡 Validation

PoR co-verification & arbitration

💰 Automated Revenue Settlement (3 Simultaneous Outputs)

1. USDC → NFT Owner: 95% net reward to owner, 5% to protocol commons treasury.
2. Energy → NFT: Commercial task completion awards +600 energy (can escalate tier).
3. Reputation → Node: On-chain success score increases by +10, improving priority.
⚠️ Temporal Entropy: An NFT idle for 30 days loses energy → demotes tier → receives fewer tasks.

3-Line Seamless Smart Contract Integration

// 1. In mint(): NFT is instantly registered as an active Colony node
nodeRegistry.registerNode(tokenId, msg.sender, NodeRole.COLONY_PEER, NodeTier.SEED, 1000);

// 2. In interact(): Energy updates as tasks complete, recalibrating Colony scheduler tier
emit NodeEnergyUpdated(tokenId, energyScore[tokenId]);
nodeRegistry.updateNodeEnergy(tokenId, energyScore[tokenId]);

// 3. In _afterTokenTransfer(): Node ownership & yield routing transfer atomically upon sale
nodeRegistry.transferNodeOwnership(tokenId, newOwner);

📈 1. Secondary Market Valuation Engine (Cashflow-Based Valuation)

GET /api/resonance/valuation/:tokenId

In traditional NFT markets, pricing relies on speculation. On MYC, because an NFT is a live Colony node, pricing is derived mathematically from verified 30-day on-chain task execution and USDC yields.

// GET /api/resonance/valuation?id=42
{
  "tokenId": 42,
  "currentEnergy": 6800,
  "tier": "RESONANT",
  "last30Days": {
    "tasksCompleted": 847,
    "usdcEarned": 423.50,
    "avgDailyYield": 14.12   // USDC / day (Verified cashflow)
  },
  "impliedValue": {
    "paybackPeriod": "71 days",  // Break-even horizon based on production
    "annualYield": 5148.00,      // USDC / year estimated gross yield
    "energyTrajectory": "RISING",// Energy trajectory: RISING, STABLE, DECAYING
    "fairPriceUSDC": 1050.50     // Capitalized fair value multiple
  },
  "resonanceBonds": 3,           // Number of coherent partner nodes bonded
  "bondMultiplier": 1.24         // Tesla frequency resonance multiplier
}

🏪 2. Living Machine Marketplace (Decay-Protected Secondary Trading)

MycResonanceMarketplace.sol

Developers and investors can list working machines. Thanks to the minEnergy guard, if an inactive machine decays below the promised energy threshold, buyers are protected and orders cancel automatically. Colony node ownership and revenue routing transfer atomically upon purchase:

// 1. List for Sale (with minEnergy decay guard)
await fetch('http://localhost:4040/api/resonance/market/list', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    tokenId: 42,
    price: 500,           // 500 USDC
    minEnergy: 5000,      // Automatically invalidates if energy decays below 5000
    showYieldHistory: true
  })
});

// 2. Buy Machine (Automatic atomic node handoff)
await fetch('http://localhost:4040/api/resonance/market/buy', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ tokenId: 42, maxPrice: 550 })
});
// 97.5% settles to seller, 2.5% to protocol treasury, node registry updates immediately.

🤝 3. Non-Custodial NFT Staking & Operator Delegation

REVENUE SHARING

For owners who prefer not to run server hardware, MYC provides non-custodial delegation: retain 100% asset custody while delegating execution rights to a verified Colony operator. Task rewards are split automatically by smart contract:

// Delegate NFT to a verified Colony node operator
await fetch('http://localhost:4040/api/resonance/delegate', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    tokenId: 42,
    operator: 'myc1operatordatacentre00000000000000000000',
    revenueShare: 70,    // 70% to NFT owner (passive yield), 30% to hardware operator
    minUptime: 95        // 95% uptime SLA requirement
  })
});
// Result: Non-technical NFT owners earn passive USDC, operators earn yields by running hardware!

💎 Live Interactive Resonance Asset Sandbox ERC-721R

TOKEN ID TO INSPECT

Core Smart Contracts on Chain ID 108

Contract	Address	Standard
MycToken ($MYC)	`myc1c3502d27aa5bbeb948d1ec7e812f6090`	Substrate Native ERC20
MycUSDToken ($USDT)	`myc1c06dd0aa90e2040ec55f29771c2e272b`	6-Decimal Tether ERC20
MycUSDCToken ($USDC)	`myc1c42542ba58f45dd5498cf5d24be70337`	6-Decimal USD Coin ERC20
MycBridge	`myc1c040466016d07ac2752822a603761127`	BFT 2/3+1 Multi-Asset Bridge
MycDEX (Resonance)	`myc1c498e86015b7c417a13232ea56311c90`	AMM Constant-Product DEX
MycEscrow	`myc1c4e6f0a1897130608866b20c8476163c`	Dual-PoR Agent Escrow
MycResonanceAsset (ERC-721R)	`myc1c4a70773bf3db2ce7ccbe38e1e95a074`	Living Resonance Asset (4-Pillars)

GET /api/wallet/balance

Fetch real-time on-chain balances for all 3 tokens ($MYC, $USDT, $USDC):

curl -s "http://localhost:4040/api/wallet/balance?address=myc14d29b6c4b38b2ac4a6e2bbb9c4d7c002"

POST /api/faucet & GET /api/faucet/status

Daily 5 $MYC testnet grant. Requires following @myc_ai on Twitter/X, and provides instant zero-gas disbursement to any specified recipient address.

1. Faucet Eligibility & Cooldown Check

curl -s "http://localhost:4040/api/faucet/status?address=myc14d29b6c4b38b2ac4a6e2bbb9c4d7c002&twitter=myc_ai"

2. Request 5 $MYC Testnet Grant (Custom Recipient Dispatch)

curl -s -X POST http://localhost:4040/api/faucet \
  -H "Content-Type: application/json" \
  -d '{
    "recipient": "myc14d29b6c4b38b2ac4a6e2bbb9c4d7c002",
    "twitter": "@developer_x",
    "verifiedFollow": true
  }'

Rules & Constraints:

Amount: 5 $MYC tokens per claim (Chain ID 108).
Period: Once per 24 hours per wallet & Twitter handle.
Requirement: Verified follow of @myc_ai on Twitter / X.
Flexibility: Dispatches to any target address via the recipient parameter.
Gas Fee: 0.00 MYC (Zero-Gas Invariant).

Cross-Chain Bridge & Cryptographic Proof Verification

The sovereign cross-chain bridge connects the MYCA Living Lattice (Chain ID 108) with EVM ecosystems (Base, Arbitrum, Ethereum) using BFT 2/3 + 1 supermajority quorum and Merkle inclusion proofs.

1. Base (EVM 8453) ➔ MYCA Lattice (Chain 108) [Inbound]

Verify a lock event on Base and credit the recipient on MYCA with 0 gas fee:

curl -s -X POST http://localhost:4040/api/bridge/base-to-myc \
  -H "Content-Type: application/json" \
  -d '{
    "baseTxHash": "0x9a8f3b7c4a1622345890eefcd1234567890abcdef1234567890abcdef1234567",
    "senderOnBase": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
    "recipientOnMyc": "myc14d29b6c4b38b2ac4a6e2bbb9c4d7c002",
    "asset": "USDT",
    "amount": 100
  }'

2. MYCA Lattice (Chain 108) ➔ Any EVM (Arbitrum, Ethereum, Base) [Outbound]

Lock tokens on MYCA (0 gas) and generate cryptographic proof + EVM Calldata for the destination network:

curl -s -X POST http://localhost:4040/api/bridge/myc-to-evm \
  -H "Content-Type: application/json" \
  -d '{
    "senderOnMyc": "myc14d29b6c4b38b2ac4a6e2bbb9c4d7c002",
    "targetChain": "ARBITRUM",
    "recipientOnEvm": "0x19E7E376E7C213B7E7e7e46cc70A5dD086DAff2A",
    "asset": "USDT",
    "amount": 250
  }'

3. Retrieve Cryptographic Proof & Verification Certificate

curl -s "http://localhost:4040/api/bridge/proof?id=bridge_..."

Sample Proof Structure:

{
  "bridgeId": "bridge_7f3b...",
  "direction": "MYCA_TO_EVM",
  "status": "COMPLETED",
  "bftQuorumProof": {
    "requiredSignatures": 3,
    "signatures": [
      {"validator": "myc1validatoralpha...", "signature": "0x4b9a..."},
      {"validator": "myc1validatorbeta...", "signature": "0x8c21..."},
      {"validator": "myc1validatorgamma...", "signature": "0xdf72..."}
    ]
  },
  "latticeExecution": {
    "consensusProtocol": "Proof-of-Resonance (PoR)",
    "coherenceScore": 0.9991,
    "certificate": "POR_CERT_38f29c..."
  }
}

Developer Documentation

What do you want to build?