Operators
An operator is a wallet and a process. The process watches the oracle’s log, runs each question through Orbio’s gateway on the wallet’s own key, and writes the answer back. The wallet is paid in CREDIT when its answer wins, and activates that CREDIT to pay for the next one.
A request pays, say, 0.05 CREDIT per answer. The model call behind it costs the operator a fraction of a cent of API balance for a Bool and a few cents for a long Text. The difference stays with the operator as CREDIT, which it can activate, sell on Orbio’s book, or keep.
What the operator risks is a lost answer: if it is outvoted it earns nothing for that call and still paid the gateway. That is the whole incentive to run the question properly, at temperature zero, on the model the asker named, rather than on the cheapest thing that returns a byte.
The node sets a floor: MIN_FEE_PER_ANSWER, in CREDIT units. Requests under it are skipped. Set it where your gas plus your tokens plus your patience land; the default is the contract’s own minimum, 0.01 CREDIT.
Make a fresh wallet for the node. It holds the $ORBACLE stake, it receives CREDIT when its answers win, and its signature over Orbio’s message is its API key. There is no Orbio account to open and no card to put on file.
# Orbio's agent guide: the wallet signs this once, locally "Orbio API key · chain 4663 · epoch 0" # and the key is sk-orb-0-<base64 of the signature> # the node does this for you on start
Hold the minimum $ORBACLE and stake it from the app, or call stake() yourself. Bonding is what lets reply() succeed; nothing else does. Unbonding takes a day.
approve(oracle, amount) # on the $ORBACLE token stake(amount) # on the oracle
The node spends Orbio API balance to answer, and API balance comes from activating CREDIT. Seed the wallet with a little CREDIT — a few dollars — and activate it once. From then on the node refuels itself from fees.
credit.activate(5_000_000) # burns 5 CREDIT into ~$4.75 of balance # the node runs this itself when balance < REFUEL_BELOW
Clone the repository, put the settings in .env.local, start the node. It polls the log every four seconds, skips requests under your minimum fee or past their deadline, and prints each answer it sends with the transaction hash.
git clone https://github.com/0xCookz/orbacle && cd orbacle npm install cp .env.local.example .env.local # fill in the operator settings npm run operator
Asked events from the official RPC, five thousand blocks at a time. The other public endpoint refuses getLogs.
Skip if closed, within 90 s of its deadline, already replied by this wallet, under the fee floor, or asking for more callback gas than you will pay.
POST to the gateway with a system prompt for the shape, temperature 0, on the model the asker named.
true/false to one byte; digits to uint256; an index to one byte; prose to UTF-8, capped. Unparseable output is skipped, not guessed.
reply(id, bytes, keccak256(response id), model). Wait for the receipt. Print it.
The gateway keeps billing metadata only and routes to zero-data-retention endpoints, per Orbio. The node keeps nothing at all: no database, no history, one Map of open requests that empties as they settle.
Staking is one wallet action. The node is npm run operator. Orbio’s own guide covers the key and the activation call in more depth.