The Montra RPC

1. 1
   Your wallet signs

   Exactly as on any chain. The RPC never sees a key and can't change what you signed.
2. 2
   The RPC forwards it to the inbox

   It doesn't go straight to Elysium's sequencer, the service that normally takes a chain's transactions and puts them in order, where direct access is limited to a few parties. The RPC checks your signed transaction and posts it into Elysium's inbox, a contract on HyperEVM, the chain Elysium settles to. Montra pays that gas.
3. 3
   Elysium runs it

   Elysium reads the inbox and runs your transaction from your own address, usually within 30 seconds. You pay Elysium's gas in HYPE, as on any chain.

Reads come from Elysium nodes, Montra's own and a partner's, each checked every couple of seconds and passed over when it falls behind.

Sends start in your wallet, which signs the transaction as on any chain. The RPC reads it from its bytes and checks it against everything that would make Elysium drop it without a word: a nonce out of turn, a fee cap the base fee could pass, too little HYPE for its gas and value, an account with code. It runs it once, so a revert is told now rather than paid for, then posts it into Elysium's inbox on HyperEVM, alone or in one message with others' that arrive together, and answers with its hash, the hash Elysium gives it. Elysium reads its inbox in order and runs it, usually within 30 seconds.

What it carries is what Montra's pages send, each transaction read for what it really does before anything is run:

• Montra's contracts. Calls to the factory, a hook the registry names, Montra's tokens and splitters, and the quote assets they trade in.
• LaunchRouter. swapExactIn alone, of a pool whose key names a Montra hook.
• Uniswap's Universal Router. An execute that really trades a Montra pool: every swap goes through one and through no one else's hook, with no hook data, naming only HYPE, listed quotes and Montra's tokens, its permits for that router alone. It may swap, settle, take, wrap, unwrap, sweep and pay a portion, in the standard ABI encoding, at most 6 commands, 8 actions and 4 hops.
• Permit2. Its approve alone, of a Montra token or a listed quote, for the Universal Router.
• ArbSys. withdrawEth(destination) alone, a withdrawal to HyperEVM.
• Plain HYPE. A transfer with no calldata goes to any address on at most 100,000 gas, enough for a Safe's receive. On more, only to an address with no code or to one of Montra's contracts.

Anything else is refused with scope before it is run, and nothing is sent: a new contract, a launcher or router of your own, liquidity through Uniswap's position manager, the fee market's fills. Post those through the inbox yourself, under Scripts and agents. A builder's code at the end of the calldata (ERC-8021) changes none of this.

It never asks for a key, cannot sign, cannot change what you signed, and holds nothing of yours. Montra pays the HyperEVM gas of each post from an account used for nothing else.

The Montra RPC sees your signed transaction before it is public and posts it as it arrives, alone or in one message with others' that arrive together. Montra holds a key to Elysium's sequencer for its own operations; it is never used for your transactions.

• It waits in public from its post until it runs: usually under 30 seconds, sometimes minutes. In that time your signed transaction can be read by anyone watching HyperEVM, and the few parties with direct access to Elysium's sequencer could trade ahead of it. Set slippage as you would in a public mempool: the minimum you sign for is what protects you.
• One at a time. Send each after the last has landed. Speed up and cancel do nothing: a transaction posted runs, or is dropped, as it was signed, and the RPC refuses a second one at a nonce already on its way.
• It is still yours. Elysium runs the transaction you signed, from your address. Holders and holder rewards count it as yours, as they would one sent any other way: Montra's posting account exists only on HyperEVM and appears nowhere on Elysium.
• A dropped one costs nothing. If Elysium reads it and does not run it (another transaction of yours took its nonce, say), nothing is spent. The site says so, and your wallet may show it pending until you clear its activity. One the RPC lost track of after its post may still land: the site says it hasn't reached Elysium yet, and checks whether it ran before your next send.

Past a read budget a request answers HTTP 429 with retry-after in seconds and a JSON-RPC error of code -32005, its data naming montra: "limit", a scope of client, site or all, and retryAfter; there are no other rate-limit headers. A batch of more than 50 calls is refused whole, with code -32600.

A well-formed request otherwise answers HTTP 200, a batch with a reply per call, each its own result or error, so check every reply. A sixth log read in a batch, a node too busy for one call, or a batch's answer grown too large fails that call alone, with code -32005, and the calls around it are answered.

Everyone's sends share five lanes a minute, none able to spend another's room, so a flood of cheap transfers refuses no trade and no one's money leaving.

Lane

Trades

Everyone, a minute200

What goes in itLaunches, and trades through a Montra pool.

Money leaving

Everyone, a minute60

What goes in itA withdrawal of 0.001 HYPE or more, and a claim of what is really owed. At most 3 a minute per account, 6 per connection and 20 per IPv4 /24 or IPv6 /32. Past those and attempts, no limit of a connection's or a network's applies, so a neighbour's trades on your address don't use it up.

Approvals and cancels

Everyone, a minute120

What goes in itAn approval of a Montra token or a listed quote for the router, Permit2 or the factory, and a wallet's cancel. At most 5 a minute per account, 10 per connection and 40 per IPv4 /24 or IPv6 /32.

Montra's other calls

Everyone, a minute60

What goes in itThe rest of what Montra's pages send: dividing fees, a claim of nothing, a hook's and a splitter's settings.

Low-value

Everyone, a minute40

What goes in itPlain HYPE transfers, smaller withdrawals, trades under 0.001 HYPE where the quote is HYPE, Permit2's own approve, a token's own moves, and a trade or a claim that would not run yet, behind one of yours still on its way.

A refused send is a JSON-RPC error whose data.montra says why, beside words for a wallet to show, which may change. One that reverts when the RPC runs it carries no code: its data is the revert's bytes. Each answers HTTP 200, and but for not-posted nothing was sent. While sending is switched off, every send answers -32003.

data.montra

limit

Code-32005

What it meansA limit above: scope says whose, retryAfter when it allows again, in seconds.

budget

Code-32005

What it meansMontra's gas for posting is spent: scope is day or hour, reason budget-spent or budget-hour, retryAfter in seconds.

paused

Code-32005

What it meansSends are paused for everyone: reason is inbox-stalled, inbox-refused, poster-unfunded, hyperevm-gas or hyperevm-disagree.

busy

Code-32005

What it meansA moment the RPC can't take it: its queue or its checks are full, or only accounts it knows are being served. Nothing was sent.

nodes

Code-32005

What it meansElysium's nodes couldn't answer its checks. Nothing was sent.

not-posted

Code-32005

What it meansIt couldn't post the transaction, or couldn't confirm it did, so it may yet land: check before sending another.

barred

Code-32005

What it meansIt holds an account's sends for an hour after 3 drops of its own doing in an hour, a connection's after 9.

in-flight

Code-32005

What it means4 of the account's are on their way; or an earlier one waits to be posted again, with retryAfter.

nonce-low, nonce-high

Code-32000

What it meansThe nonce is out of turn: next is the one to use.

nonce-blocked

Code-32000

What it meansThe send at next never ran (dropped, its hash), and must be cleared before anything after it runs.

nonce-pending

Code-32000

What it meansThat nonce is already on its way, and can't be replaced.

fee-low

Code-32000

What it meansThe fee cap is under the base fee and 10%: need, in wei.

funds

Code-32000

What it meansToo little for gas and value, beyond what is on its way: balance, in wei.

gas-limit, gas-low

Code-32000

What it meansOver the 32,000,000 a transaction may ask for, or too little to run.

contract-sender

Code-32000

What it meansThe account has code, and Elysium runs no transaction signed for it (an EIP-7702 delegation is fine).

guard

Code-32000

What it meansA Safe's launch, or a call setting the registry's montra: these never go through the inbox.

invalid

Code-32000, -32602

What it meansIt can't run as it is: malformed, another chain, a blob or EIP-7702 transaction, over the size cap, a high-s signature, or a second send in one batch.

scope

Code-32003

What it meansA transaction it doesn't carry, as under What it does. It won't be taken however often it is sent.

Whose limit a limit met, by its scope:

GET /health says what a trade would hear now: sends.reason is one of the paused reasons, budget-spent, budget-hour, off (sending switched off) or null, and sends.retryAfter the seconds until a budget has room, or null. Money leaving keeps a reserve past budget-spent and budget-hour, so don't hold a withdrawal or a claim back for those: send it, and read the answer.

montra_sendStatus, given the hash, says where a send it took is: queued, posted (its post on HyperEVM as l1Hash, in the inbox once messageIndex is set), landed, dropped or failed, the last two with a code (nonce-used, not-run, not-posted, lost).

Any Elysium node serves reads. The site reads through the Montra RPC whatever a wallet uses, and asks the wallet which RPC it uses: the Montra RPC answers a call to an empty address (0x…6d6f6e747261, the word montra in hex) with its name, where any other RPC answers nothing. That is a hint, not proof.

A wallet that already has Elysium keeps its own RPC when the network is added again: MetaMask adds the new one to the network's list and goes on using the old until you choose it (its menu, Networks, the line under Elysium), and other wallets need the network's RPC edited by hand.

A script reads through the Montra RPC as it would through any RPC, and sends what it carries the same way: eth_sendRawTransaction with a signed transaction, then its receipt. For anything else, or by choice, it posts through the inbox itself, paying its own HyperEVM gas: sign the Elysium transaction without sending it, then send sendL2Message on the inbox with 0x04 followed by the signed bytes. Its hash on Elysium is the hash of those bytes.

1. 1

   Through the Montra RPC

   A wallet or a script points at it as Elysium's RPC. A fee cap of twice the base fee leaves room for the seconds in the inbox; only the base fee is charged.

   ShellCopyCopiedNot copied

   cast balance <address> --ether --rpc-url https://rpc.montramarkets.xyz
   cast send <to> --value 0.001ether --rpc-url https://rpc.montramarkets.xyz --account mywallet

2. 2

   Through the inbox yourself

   Every field given, so cast mktx signs without asking any node. Check the transaction's receipt on Elysium: a dropped one leaves no trace there.

   ShellCopyCopiedNot copied

   INBOX=0xce59f8B65ad41C9DAE4c07A0571a39824bD92cff
   RAW=$(cast mktx --chain 99901 --nonce <nonce> --gas-limit 500000 --gas-price 1gwei --priority-gas-price 0 \
     <to> --value 0.001ether --account mywallet)
   cast send $INBOX "sendL2Message(bytes)" 0x04${RAW#0x} --rpc-url https://rpc.hyperliquid.xyz/evm --account mywallet
   cast keccak $RAW   # its hash on Elysium

3. 3

   Deposit HYPE

   From a plain wallet on HyperEVM; it lands at the same address on Elysium.

   ShellCopyCopiedNot copied

   cast send $INBOX "depositEth()" --value 0.05ether --rpc-url https://rpc.hyperliquid.xyz/evm --account mywallet

1. 1
   Start it on Elysium

   withdrawEth(destination) on ArbSys (0x…64), paying the HYPE as value.

   under a minute
2. 2
   Wait for a confirmed assertion

   Elysium's state is asserted on HyperEVM about every six hours; each assertion is final after 483,840 HyperEVM blocks, about 5.5 days. A withdrawal is claimable once a confirmed assertion's send count passes its position.

   about 6 days
3. 3
   Claim on HyperEVM

   executeTransaction on the rollup's outbox, with a proof any Elysium node builds (constructOutboxProof(size, leaf) on NodeInterface, 0x…c8), the size being the confirmed send count. Anyone may send it; it pays only the destination.

   seconds, HyperEVM gas