megaethss-developer

End-to-end MegaETH development playbook (Feb 2026). Covers Foundry project setup with MegaETH-specific config, wallet operations, token swaps (Kyber Network)...

Security Scan

The SKILL.md claims a MegaETH development playbook but the shipped files include an unrelated X (Twitter) search script that calls api.x.ai and expects an undeclared XAI_API_KEY environment variable — the code and declared requirements are inconsistent.

Purpose & Capability

The skill claims to be an end-to-end MegaETH development playbook, but the repository includes a Python 'search.py' that implements an X (Twitter) search using the xAI Grok API (API_URL=https://api.x.ai/v1/responses). That script and its functionality (searching X via x.ai) are unrelated to MegaETH development and to the SKILL.md's described capabilities. Additionally the script requires an XAI_API_KEY but the skill metadata declares no required environment variables.

Instruction Scope

SKILL.md provides detailed runtime guidance for MegaETH development (RPC methods, eth_sendRawTransactionSync, Foundry workflows, etc.) but does not reference the included search utility. The included script will read XAI_API_KEY from the environment and POST queries to api.x.ai, which means running the bundled code will transmit data (and use a secret) to an external service unrelated to the stated purpose. The instructions in SKILL.md do not disclose this network activity or the env var dependency.

Install Mechanism

There is no install spec (instruction-only), so nothing is automatically downloaded or installed. However, two Python files are packaged with the skill; while that is low-install risk, including executable scripts without declaring their purpose or required credentials is still an incoherence risk.

Credentials

The packaged script requires the environment variable XAI_API_KEY to contact api.x.ai, but the skill metadata lists no required env vars or primary credential. Requesting or reading an API key for x.ai is not justified by the MegaETH-focused description. This is an undeclared credential dependency and therefore disproportionate and suspicious.

Persistence & Privilege

The skill does not request persistent privileges (always is false) and does not declare any system-wide config changes. It is user-invocable and allows model invocation by default, which is normal; nothing indicates forced persistence or modification of other skills.

What to consider before installing

This package is inconsistent: it advertises MegaETH development guidance but includes an unrelated Python script that calls the x.ai Grok API and expects an XAI_API_KEY that isn't declared. Before installing or running anything: (1) Ask the publisher/source to explain why an X search utility is bundled with a MegaETH playbook and to declare required env vars. (2) Do not run the Python scripts until you inspect them locally; they will send requests (and require an API key) to api.x.ai. (3) If you must run, do so in an isolated environment and ensure no sensitive keys (AWS, GitHub, personal tokens) are present in the environment. (4) Prefer a version from a known author/homepage or remove the unrelated scripts if they are not needed. If the author provides a clear justification and updates metadata to declare XAI_API_KEY, the incoherence would be resolved.

MegaETH Development Skill

What this Skill is for

Use this Skill when the user asks for:

• Foundry project setup targeting MegaETH
• Writing and running tests (unit, fuzz, invariant) on MegaETH
• Deploying and verifying contracts on MegaETH
• Wallet setup and management on MegaETH
• Sending transactions, checking balances, token operations
• Token swaps via Kyber Network aggregator
• MegaETH dApp frontend (React / Next.js with real-time updates)
• RPC configuration and transaction flow optimization
• Smart contract development with MegaEVM considerations
• Storage optimization (transient storage, Solady patterns)
• Gas estimation and fee configuration
• Testing and debugging MegaETH transactions
• WebSocket subscriptions and mini-block streaming
• Bridging ETH from Ethereum to MegaETH
• Privy integration for headless/automated signing
• Meridian / x402 payments on MegaETH
• Ultra-low latency transaction patterns
• ERC-7710 delegations (scoped permissions, spending limits, redelegation chains)
• MetaMask Smart Accounts (ERC-4337 accounts, signers, user operations)
• Advanced permissions (ERC-7715) via MetaMask
• MegaNames (.mega naming service) — registration, resolution, subdomains, subdomain marketplace, text records

Chain Configuration

Network	Chain ID	RPC	Explorer
Mainnet	4326	https://mainnet.megaeth.com/rpc	https://mega.etherscan.io
Testnet	6343	https://carrot.megaeth.com/rpc	https://megaeth-testnet-v2.blockscout.com

Default stack decisions (opinionated)

1. Transaction submission: eth_sendRawTransactionSync first

• Use eth_sendRawTransactionSync (EIP-7966) — returns receipt in <10ms
• Eliminates polling for eth_getTransactionReceipt
• Docs: https://docs.megaeth.com/realtime-api

2. RPC: Multicall for eth_call batching (v2.0.14+)

• Prefer Multicall (aggregate3) for batching multiple eth_call requests
• As of v2.0.14, eth_call is 2-10x faster; Multicall amortizes per-RPC overhead
• Still avoid mixing slow methods (eth_getLogs) with fast ones in same request

Note: Earlier guidance recommended JSON-RPC batching over Multicall for caching benefits. With v2.0.14's performance improvements, Multicall is now preferred.

3. WebSocket: keepalive required

• Send eth_chainId every 30 seconds
• 50 connections per VIP endpoint, 10 subscriptions per connection
• Use miniBlocks subscription for real-time data

4. Storage: slot reuse patterns

• SSTORE 0→non-zero costs 2M gas × multiplier (expensive)
• Use Solady's RedBlackTreeLib instead of Solidity mappings
• Design for slot reuse, not constant allocation

5. Gas: skip estimation when possible

• Base fee stable at 0.001 gwei, no EIP-1559 adjustment
• Ignore eth_maxPriorityFeePerGas (returns 0)
• Hardcode gas limits to save round-trip
• Always use remote eth_estimateGas (MegaEVM costs differ from standard EVM)

6. Debugging: mega-evme CLI

• Replay transactions with full traces
• Profile gas by opcode
• https://github.com/megaeth-labs/mega-evm

Operating procedure

1. Classify the task layer

• Frontend/WebSocket layer
• RPC/transaction layer
• Smart contract layer
• Testing/debugging layer

2. Pick the right patterns

• Frontend: single WebSocket → broadcast to users (not per-user connections)
• Transactions: sign locally → eth_sendRawTransactionSync → done
• Contracts: check SSTORE patterns, avoid volatile data access limits
• Testing: use mega-evme for replay, Foundry with --skip-simulation
• Delegations: create scoped permissions → sign → share → redeem via eth_sendRawTransactionSync

3. Implement with MegaETH-specific correctness

Always be explicit about:

• Chain ID (4326 mainnet, 6343 testnet)
• Gas limit (hardcode when possible)
• Base fee (0.001 gwei, no buffer)
• Storage costs (new slots are expensive)
• Volatile data limits (20M total compute gas cap, retroactive, when block.timestamp accessed)

4. Deliverables expectations

When implementing changes, provide:

• Exact files changed + diffs
• Commands to build/test/deploy
• Gas cost notes for storage-heavy operations
• RPC optimization notes if applicable

Progressive disclosure (read when needed)

• Foundry setup & deploy: foundry-config.md
• Wallet operations: wallet-operations.md
• Frontend patterns: frontend-patterns.md
• Privy integration: privy-integration.md
• Meridian payments: meridian.md
• RPC methods reference: rpc-methods.md
• Smart contract patterns: smart-contracts.md
• Storage optimization: storage-optimization.md
• Gas model: gas-model.md
• Testing & debugging: testing.md
• Security considerations: security.md
• ERC-7710 delegations: erc7710-delegations.md
• MetaMask Smart Accounts: smart-accounts.md
• Warren Protocol (on-chain websites): warren.md
• MegaNames (.mega naming): meganames.md
• Reference links & attribution: resources.md