CircuitPay · TCS-1 Circuit-call Settlement Standard

CircuitPay · Whitepaper v1.0Taped out

TCS-1 Circuit-call Settlement Standard

Verifiable metering, settlement and revenue split for every call on a TapeOut circuit.

137 diesYield 94%■ this draft

Version: Whitepaper v1.0 · October 2026
Standard: TCS-1 — TapeOut Circuit-call Settlement
Network: BSC, built on TapeOut processors
Settlement tokens: BEM or USDT — no protocol token is issued

§1

Abstract

CircuitPay brings verifiable metering, settlement and revenue split to calls on TapeOut circuits, and publishes its protocol as the open TCS-1 standard.

In CircuitPay a transistor is an agent seat, a circuit is a swarm of seats, and every deployment is a tape-out. TCS-1 defines how a call is metered, how it is priced, and how its revenue flows to circuit authors, executing seats, meters and the protocol treasury.

Metering happens off-chain; settlement happens on-chain. The caller deposits to open a session, caller and meter co-sign monotonically increasing receipts, and once a receipt clears its challenge window the contract splits the proceeds in fixed proportions.

§2

Background

TapeOut describes on-chain compute through Processors, transistors and circuits. A Processor is created by the factory; transistors are the ERC-1155 tokens it mints (id 0 = NAND, id 1 = LATCH); circuits are logic composed from them. Minting and tape-out are solved — what a circuit earns once it is called is not.

1
Too small to settle alone
Agent calls are frequent and tiny. Settling each on-chain costs more than the call itself.
2
Counts need a witness
Usage is reported by whoever executes it — inflation and wash calls must be ruled out.
3
No shared rule of split
Authors, seat holders and infrastructure operators lack a common way to divide value.

§3

Design Goals

1
Minimal
A Registry and a Settlement contract form the core; seat issuance is an optional module.
2
Verifiable
Every settlement traces back to a receipt signed by both parties.
3
Funds stay safe
A caller never spends beyond the deposit, and expired sessions refund themselves.
4
Permissionless
Anyone may trigger settlement or refund.
5
Composable
Circuits may call circuits; every session settles on its own.
6
Parameters frozen
Price and split are snapshotted at open — later changes never touch a live session.

§4

System Architecture

System architectureoff-chain · on-chain

CallerDeposits, co-signs receipts

calls

Gateway / MeterExecutes on seats, co-signs EIP-712 receipts

receipt

ITCS1SettlementHolds deposits, challenge window, split

ITCS1RegistryCircuits, prices, weights, versions

balanceOf

TapeOut ProcessorERC-1155 transistors · read-only, never custodied

Circuit author · 60%
Executing seats · 25%
Meter · 10%
Treasury · 5%

Off-chain components only execute and meter; funds move solely inside the Settlement contract. The Registry reads TapeOut transistor balances to confirm seat ownership — it writes nothing to TapeOut and never custodies transistors.

§5

Participants

Participant roles
Role	Responsibility
Circuit author	Tapes out and registers the circuit, sets unit price and metering weights, maintains versions
Seat holder	Holds transistors and supplies agent execution to circuits
Meter	Runs the gateway, co-signs receipts, carries infrastructure cost
Caller	Deposits, signs receipts, receives results
Challenger	Submits a newer receipt during the challenge window
Protocol treasury	Funds audits, challenge rewards and ecosystem development

§6

Metering Model

A call c is measured as weighted resource consumption, rounded up. g counts logic gates executed, s counts state reads and writes, x counts sub-circuit or external calls. Weights are declared by the author at registration and committed in metaHash, so callers can verify them before opening a session.

(1) Unit of a callu(c) = ceil( w_g·g(c) + w_s·s(c) + w_x·x(c) )

(2) Session totalU_σ = Σ u(c_i), G_σ = min(U_σ · p_σ, D_σ)

(3) Receipt validitynonce_k > nonce_last && units_k ≥ units_last && now ≤ deadline_k && Sig_caller && Sig_meter

p_σ is the unit price snapshotted at open and D_σ the deposit; the caller is refunded D_σ − G_σ. The contract keeps only the valid receipt with the highest nonce. Sub-circuit calls count toward the parent’s x(c) while settling in their own sessions, so nested accounting never cascades into a single failing transaction.

§7

Settlement & State Machine

None
Open
Active
Challenge
Settled
Refunded

1
Open
The caller approves the settlement token and calls openSession. The deposit is locked; price and split are snapshotted.
2
Call & co-sign
After each batch the gateway issues a new receipt, signed by caller and meter under EIP-712.
3
Submit
Either party calls submitReceipt; the contract checks signatures, nonce, deadline and deposit cap.
4
Challenge
Once closed, a 24-hour window opens. Anyone holding a valid higher-nonce receipt may call challenge.
5
Settle
When the window ends, anyone may call settle. Shares are credited and the remaining deposit refunded.
6
Withdraw
Payees pull balances via withdraw; seat shares are claimed through claimSeat with a Merkle proof.

§8

Revenue Split

Revenue split
Recipient	Share	Rationale
Circuit author	60%	Bears design, tape-out and upkeep — the primary source of a call’s value
Executing seats	25%	Paid by actual work, rewarding seat holders for real execution
Meter	10%	Covers gateway and co-signing, keeping metering sustainable
Protocol treasury	5%	Funds audits, challenge rewards and development; kept low by design

(4) Basis pointsa_j = floor( G_σ · bps_j / 10000 ), a_treasury = G_σ − Σ a_j

(5) Seat shareseat_k = floor( 0.25 · G_σ · w_k / Σw )

Shares are expressed in basis points (6000 / 2500 / 1000 / 500, summing to 10000). Integer-division remainders go to the treasury — nothing is lost, nothing over-issued. Seat shares follow each seat’s work w_k in the receipt’s seatsRoot; seats that did not execute receive nothing.

Illustrative calculation
Item (illustrative)	Amount
Session gross G_σ	100 USDT
Circuit author	60 USDT
Executing seats (total)	25 USDT
Meter	10 USDT
Protocol treasury	5 USDT

§9

Contract Interface

ITCS1.solSolidity ^0.8.24

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

/// TCS-1 circuit registry
interface ITCS1Registry {
    struct Circuit {
        address owner;        // circuit author
        address processor;    // TapeOut Processor (transistor contract)
        uint256 seatId;       // seat type: 0 = NAND, 1 = LATCH
        uint256 unitPrice;    // price per metering unit (smallest token unit)
        address payToken;     // settlement token (BEM or USDT)
        bytes32 metaHash;     // hash of circuit metadata and metering weights
        uint32  version;
        bool    active;
    }

    event CircuitRegistered(bytes32 indexed circuitId, address indexed owner,
        address processor, uint256 unitPrice, address payToken);
    event CircuitUpdated(bytes32 indexed circuitId, uint32 version,
        uint256 unitPrice, bytes32 metaHash);
    event CircuitActiveSet(bytes32 indexed circuitId, bool active);

    error NotCircuitOwner();
    error CircuitInactive();
    error UnsupportedToken(address token);

    function registerCircuit(address processor, uint256 seatId, uint256 unitPrice,
        address payToken, bytes32 metaHash) external returns (bytes32 circuitId);
    function updateCircuit(bytes32 circuitId, uint256 unitPrice, bytes32 metaHash)
        external; // applies to new sessions only
    function setActive(bytes32 circuitId, bool active) external;
    function circuit(bytes32 circuitId) external view returns (Circuit memory);
}

/// TCS-1 session settlement
interface ITCS1Settlement {
    enum State { None, Open, Active, Challenge, Settled, Refunded }

    struct Receipt {              // EIP-712 metering receipt
        bytes32 sessionId;
        bytes32 circuitId;
        address caller;
        uint64  units;            // cumulative session units, non-decreasing
        uint64  nonce;            // strictly increasing
        uint64  deadline;
        bytes32 seatsRoot;        // Merkle root of executing seats and their work
    }

    event SessionOpened(bytes32 indexed sessionId, bytes32 indexed circuitId,
        address indexed caller, uint256 deposit, uint256 unitPrice);
    event ReceiptSubmitted(bytes32 indexed sessionId, uint64 units, uint64 nonce);
    event SessionClosed(bytes32 indexed sessionId, uint64 challengeEnds);
    event ReceiptChallenged(bytes32 indexed sessionId, address indexed challenger,
        uint64 nonce);
    event SessionSettled(bytes32 indexed sessionId, uint256 gross, uint256 refund);
    event Credited(bytes32 indexed sessionId, address indexed to, uint8 indexed role,
        uint256 amount);
    event SeatClaimed(bytes32 indexed sessionId, address indexed seatHolder,
        uint256 amount);

    error InvalidSignature();
    error StaleNonce(uint64 got, uint64 last);
    error UnitsDecreased();
    error Expired();
    error ExceedsDeposit(uint256 cost, uint256 deposit);
    error WrongState(State state);
    error ChallengeWindowOpen();
    error InvalidProof();

    function openSession(bytes32 circuitId, uint256 deposit, uint64 ttl)
        external returns (bytes32 sessionId);
    function submitReceipt(Receipt calldata r, bytes calldata callerSig,
        bytes calldata meterSig) external;
    function close(bytes32 sessionId) external;
    function challenge(Receipt calldata newer, bytes calldata callerSig,
        bytes calldata meterSig) external;
    function settle(bytes32 sessionId) external;          // permissionless
    function refundExpired(bytes32 sessionId) external;   // expired, no receipt
    function claimSeat(bytes32 sessionId, address holder, uint256 work,
        bytes32[] calldata proof) external;
    function withdraw(address token) external;            // pull pattern
}

/// Seat issuance (optional module)
interface ITCS1SeatDistributor {
    event SeatsIssued(address indexed to, uint256 seatId, uint256 amount, uint8 phase);

    error NotEligible();
    error CapExceeded();
    error PhaseClosed();

    function issueAllowlist(uint256 seatId, uint256 amount, bytes32[] calldata proof)
        external;
    function issuePublic(uint256 seatId, uint256 amount) external;
}

§10

Security Model

Threats and mitigations
Threat	Mitigation
Receipt replay	EIP-712 domain binds chainId, contract and sessionId; nonce strictly increases; receipts carry a deadline
Meter over-reporting	Receipts require the caller’s co-signature; spend is capped by deposit; newer receipts override during challenge
Caller refuses to sign	Gateway pre-signs per batch and stops serving unsigned batches — one batch is the maximum exposure
Sybil & wash calls	Callers pay real fees; seat shares follow actual work only
Griefing	Pull-pattern withdrawals; settle and refundExpired are permissionless
Collusion	Damage is limited to the colluders’ own deposit; authors can deactivate a circuit or replace the meter
Token risk	Allow-listed tokens only, SafeERC20, no fee-on-transfer tokens
Upgrades	TCS-1 v1.0 contracts are not upgradeable; parameter changes pass a 48-hour timelock

§11

Economic Model

The market sets the price
Authors choose their own unit price; the protocol publishes no guide price.
Longer sessions, lighter gas
The fixed cost of opening and closing amortises over every call in a session.
Metering pays for itself
The meter share gives gateway operators a lasting reason to run.
Treasury in the open
Treasury spending is public and verifiable on-chain.
No protocol token
CircuitPay issues no token. Settlement uses existing tokens: BEM and USDT.

§12

TapeOut Integration

Seats are issued on TapeOut processors. The parameters below describe public behaviour of the TapeOut factory.

TapeOut factory parameters
Item	Detail
Factory contract	0x68224F668083c29e9800Be2a646d42d18cedF7e2
Create Processor	createCPU(name, symbol, story, transistorSupply, mintPrice) — deployment fee 0.001 BNB
Mint	mint(id, amount) — costs amount × mintPrice plus a 0.0001 BNB protocol fee per call
Mint revenue	Credited to the Processor creator, withdrawn via withdraw()
Seat types	id 0 = NAND, id 1 = LATCH

CircuitPay seats are issued on TapeOut processors through ITCS1SeatDistributor, in an allow-list phase followed by a public phase. The allow-list is stored on-chain as a Merkle root, each address has an issuance cap, and payment is accepted in BEM or USDT.

§13

Risk Disclosure

Upgradeable foundation
The TapeOut factory is a UUPS proxy governed by a 3/5 multisig and can upgrade its transistor contracts via beacon. CircuitPay monitors changes and may pause new registrations if seat ownership reads are affected.
Smart contract risk
Contracts may contain undiscovered vulnerabilities.
Metering trust
Metering happens off-chain; its security rests on dual signatures and the challenge mechanism.
Token risk
The price and availability of settlement tokens lie outside CircuitPay’s control.
Outside PoD
Circuits taped out on custom Processors do not take part in official TapeOut PoD mining.
Regulatory risk
Regulation of on-chain applications may change across jurisdictions.

§14

Roadmap

Phase 1Testnet
Deploy Registry, Settlement and SeatDistributor; release the reference gateway.
Phase 2Mainnet
Launch on BSC mainnet after an independent audit; open seat issuance.
Phase 3Open metering
Support multiple meters and switch on challenge rewards.
Phase 4Composition
Batch settlement for sub-circuit calls.

§15

Glossary

Glossary
Term	Meaning
CircuitPay	The circuit-call settlement layer built on TapeOut
TCS-1	The circuit-call settlement standard defined by CircuitPay
Processor	A processor contract created by the TapeOut factory
Transistor / Seat	A token minted by a Processor; in CircuitPay, one agent seat
Circuit / Swarm	An agent cluster of seats working together on a task
Tape-out	Deploying a project or circuit
Session	A set of calls and their settlement, backed by one deposit
Metering receipt	A cumulative usage proof co-signed by caller and meter
Challenge window	The period before settlement in which a newer receipt may be submitted

Metered off-chain.Settled on-chain.Shared by its makers.

Every batch co-signed,every count only rises.

60 · 25 · 10 · 5 —value returns to its makers.

Abstract

Background

Too small to settle alone

Counts need a witness

No shared rule of split

Design Goals

Minimal

Verifiable

Funds stay safe

Permissionless

Composable

Parameters frozen

System Architecture

Participants

Metering Model

Settlement & State Machine

Open

Call & co-sign

Submit

Challenge

Settle

Withdraw

Revenue Split

Contract Interface

Security Model

Economic Model

The market sets the price

Longer sessions, lighter gas

Metering pays for itself

Treasury in the open

No protocol token

TapeOut Integration

Risk Disclosure

Upgradeable foundation

Smart contract risk

Metering trust

Token risk

Outside PoD

Regulatory risk

Roadmap

Glossary

Every batch co-signed,
every count only rises.

60 · 25 · 10 · 5 —
value returns to its makers.