The EVM spoke

If you run a prediction market on Base, BNB Chain or Arbitrum, this page shows how it gets axmc answers. You ask on Solana, and the answer arrives on your chain as a signed receipt your contract settles on.

What you get

For every question you open, you get one receipt when the answer is final. It carries the outcome (a winning position, a number, or Unresolvable), a cause code that says why, whether the answer was disputed, overturned or corrected, and when it became final. The byte layout is in The receipt on the wire.

Only the answer crosses. Proposing, disputes, panels, appeals and payment all stay on Solana.

How an answer travels

1. Your market closes on your chain.
2. Your service notices and opens the question on Solana, signed by your Solana key. It pays the reward and premium in USDC.
3. axmc resolves it: a curator answers, and a panel rules if someone challenges.
4. Once the answer is final, anyone publishes the receipt as a Wormhole message from the axmc emitter program (emit_receipt, or emitReceipt in the SDK).
5. Wormhole's guardians sign the message. The signed message is a VAA.
6. Anyone delivers the VAA to the spoke contract on your chain with receiveReceipt(bytes encodedVaa).
7. The spoke verifies the signatures, checks the message came from the axmc emitter, decodes the receipt and stores it.
8. Your contract reads the answer from the spoke and settles your users.

Delivery is permissionless on purpose. Your service delivers its own receipts, and if it is down, anyone holding the VAA can.

What you run

Your Solana key and your EVM contract never need to be linked on chain. Your contract never opens a question, so it never spends on Solana. Your service does both with the Solana key.

Keep the service running. If it stops, questions stop being asked and nothing else notices.

No spoke is deployed on a public network yet (see Status). On a local chain or a fork, the deploy script evm/script/Deploy.s.sol deploys a spoke and the reference market.

Read the answer in your contract

1. When your service opens the question on Solana, store the request address on your market as a bytes32 (the key's raw 32 bytes).
2. Check that the receipt names your Solana market. A receipt is yours only if its market field is your market.
3. Call outcomeOf(request) and settle on the outcome kind, index or scalar.
4. Store or pass through the cause code. Never revert on a code you do not recognise: the table can grow.

This is the pattern the reference market, ExampleMarket, uses in settle:

import {IAxmcReceipt} from "./IAxmcReceipt.sol";

bytes32 answered = oracle.receiptOf(request).market;
if (answered != mySolanaMarket) revert WrongMarket(mySolanaMarket, answered);

(IAxmcReceipt.OutcomeKind kind, uint8 index, int128 scalar, uint8 causeCode, bool corrected, int64 finalizedAt) =
    oracle.outcomeOf(request);

if (kind == IAxmcReceipt.OutcomeKind.Index && index < outcomeCount) {
    // pay the winners of `index`
} else {
    // void and refund: Unresolvable, a scalar, or an index out of range
}

The spoke's read functions:

Two things can change what outcomeOf tells you.

Corrections. A final answer can be corrected on Solana within the correction window, 7 days today (Specification). The corrected receipt replaces the stored one and carries corrected = true and cause code 8. If your market settles real value, decide whether to wait out the window first. ExampleMarket takes a settleDelay in seconds for this and refuses to settle earlier with TooSoon.

The value ceiling. The spoke can ask your contract how much it would settle on a receipt for your market. Implement IAxmcConsumer:

function exposure(bytes32 market) external view returns (uint256);

When the spoke's owner has bound your contract with setConsumer(market, consumer), the spoke calls exposure on each new or corrected receipt. If the answer is above valueCeiling, in the chain's own coin (wei of ETH on Base and Arbitrum, of BNB on BNB Chain), the receipt is held. While it is held, outcomeOf reverts with Held until the owner calls release(request). A revert or a malformed answer from exposure also holds the receipt.

The reference service and scripts

services/spoke holds a working venue service for ExampleMarket. Adapt it to your own contract's events.

On each pass the venue service reads MarketClosed events, opens each new question on Solana and binds it with expectRequest. For each final answer it publishes the receipt, fetches the signed VAA from Wormholescan, delivers it and settles the market. It then checks your balances and writes a heartbeat line. Every signed step is saved to a state file first, so a restart never signs twice.

Supported chains

The spoke verifies against the Wormhole core bridge on its chain. The deploy script picks the core by chain id, checks the core answers the expected Wormhole id, and refuses any chain not in this table.

Every core address was checked against the live contract on 13 October 2026.

Paying

You pay in USDC on Solana. The reward and premium move when the question is opened, inside request_resolution. There is no credit or deferred payment: if the USDC is not there, the request fails.

• For a market a wallet registered, the USDC comes from a token account your Solana key owns.
• For a venue market, it comes from your venue's balance. See Go live.

The account that pays rent in SOL (payer) is a separate signer from the one that speaks for the market. Someone else can cover rent while you keep control of your USDC and your market.

To top up, any route to Solana USDC works, for example Circle's CCTP from your chain. Refill on a schedule, not per question. The reference service warns when your balance covers fewer than SPOKE_MIN_QUESTIONS questions.

Trust

The one thing you trust is the attestation. Whoever signs the VAA decides the answer your spoke stores: today that is Wormhole's guardians, 13 of 19 on mainnet and a single key on the testnets. Nothing else is trusted. The emitter only republishes what Solana recorded, and anyone can rebuild the receipt from the request account and compare it byte for byte. A deliverer only moves bytes, so the worst it can do is not deliver. The spoke checks the emitter before it reads the payload and never applies the same VAA twice. The value ceiling caps what a bad attestation could settle. Bonded axmc attesters are planned to replace the guardians; they are not built.

Status

• Built and tested: the emitter program, the spoke contract, the reference market and the venue service.
• Tested end to end on a local validator and chain. A VAA signed by the real testnet guardian was delivered to spokes on forks of Base Sepolia, BNB Chain testnet and Arbitrum Sepolia, and each chain's real Wormhole core verified it.
• Not deployed on any public network. The emitter program is not on Solana devnet yet, and no spoke runs on a public testnet or mainnet.
• Not built: bonded attesters.

Source: docs/EVM_SPOKE.md in the axmc repo. Edit the file; the next deploy rebuilds this page.