A chip is a program and a processor together. Write the program here, assemble it here, and watch it execute on the same gate array the contract walks before you commit a single unit of gas to it.
The workbench is live now. The mint call opens at T-0, and nothing on this page pretends otherwise.
The assembler below is the same one the build uses, reading its opcode numbers out of the netlist rather than keeping a second copy, so it cannot assemble an instruction the processor does not have.
Press assemble and the program is encoded, checked for reachability and loaded into a live machine. What you see running is the gate array, not a preview of it.
in
hlt in it. The analysis panel says which kind yours is
before the question costs you money.
Every instruction the ST-8 can execute, in the form the assembler expects it. There is no macro layer and no pseudo-instruction: what you write is one 25-bit word, and the four fields it splits into are drawn to scale in the listing above. The opcode field is five bits, so the thirty-two below are the entire vocabulary: nothing has been left off this page.
Click a row to drop it into the editor at the cursor. The opcode numbers come from the netlist, so this table cannot describe an instruction the silicon does not have.
ld
costs two cycles by construction: the address latches on one edge and the
byte comes back on the next, exactly as it does in the contract.
cmp and tst are a sub and an
and that throw the result away and keep only the flags,
which is how you compare and how you test a bit without spending a
register. And jmpr takes its address from a register, so a
jump table is a handful of ldis and one branch.
Feed the input port a price instead of a byte and the same processor becomes a strategy: it reads the quantised price, keeps whatever state it likes in its registers and its RAM, and puts an intent on the output port. Every decision it will ever make is a consequence of the gate table, so anybody can replay the whole thing.
Pick a market, pick a rule, and watch it run. The chart is the venue's, the tape below is the chip's, and every row on it came out of the same netlist the contract runs.
A price is a continuous quantity and the port is eight bits wide, so something has to convert. It auto-ranges: the window tracks the market and the byte lands where the movement is, the way any instrument spends its resolution on the part of the range that is moving.
2,161 NAND gates decide. It holds the window in its registers, its history in its 256 bytes of RAM, and puts an intent on the output port. Every decision is a consequence of the gate table, so anybody can replay the run and get the same answer.
A device on the far side of the port turns the byte into an order, the way a disk controller turns a port write into a seek. Swap the device and the same chip steers something else; swap the chip and the device never notices.
That split is what a bus is for, and it is how every processor that has
ever controlled anything controlled it. A CPU has never placed an order in
its life: it computes, it drives a port, and the peripheral does the work.
IBus.sol holds that boundary, so a chip can be moved to
another device and a device replaced without refabricating the chip.
Supply is fixed at a billion and there is no mint function anywhere, so the only decisions that matter are how much goes to liquidity and how long the rest takes to leave. The arithmetic below is the factory's, run on the values you pick.
Written out because a button that says "mint" and nothing else is asking for trust it has not earned. This is the whole of it, in the order the contract performs it.
Checked against every ticker already taken and written into storage. There is no rename, so this is the one irreversible line in the call.
Your assembled words are stored with the chip. Nothing rewrites them afterwards: a chip's program is part of what the chip is.
A fixed billion, minted once into the chip's own account. No mint function is written into it, so no further supply can ever exist.
The percentage you chose leaves for the pool in the same transaction. The rest stays as the mining reserve, with one door out of it.
step() becomes callable by anybody. From that block onward your processor advances whenever somebody pays for it to.
npm run evm deploys
our own contracts into a real EVM and runs the processor through
them; the figures include the 21,000 gas a transaction costs before
it executes anything. The mint row fills in at T-0, when there is an
address to measure.
None of these is a promise. Each one is the absence of a function, which is a thing you can check in the bytecode rather than a thing you have to believe.
There is no mint function anywhere. Not for the operator, not for the chip's owner, not for the factory. A billion units exist and that is the end of it.
step() takes no owner check. Whoever pays the gas takes the cycle and is written into the event as its sponsor.
The only door out of the mining reserve is a step. There is no path that moves the token in bulk, including for whoever deployed the thing.
It is pure, holds no state and has no owner. The silicon your chip runs on is the silicon it will always run on.