The chain is the infrastructure. The smart contracts are the API services. The subject signs.
SCaaS treats a smart-contract chain as infrastructure, its smart contracts as API services, and each contract function as an API function. Users authorize every valuable call with their own signature; open relayers carry the call to the chain and pay its gas; the contract checks everything itself.
This page explains the idea from the ground up and points to the detailed docs. It defines no rules: the rules live
in the component docs under docs/, each with an id and a reason in
docs/decisions.md.
Docs map · Architecture · Contracts · Node · Networks · ERP integration · Decisions
Contents
| The idea | How it works | Reference |
|---|---|---|
| 1. A smart chain is infrastructure | 7. Universal Accounts | 13. Chains and families |
| 2. Smart contracts are API services | 8. Meta-transactions and EIP-1776 | 14. Components and where to read more |
| 3. Contracts: what is built on what | 9. Who pays the fee | 15. How the design evolved |
| 4. Governance: who holds which power | 10. Meta-transactions and liquidity | 16. Repository layout |
| 5. Shared code, delegate call, separate data | 11. Open relayers | 17. Use cases |
| 6. What the traditional model gets wrong | 12. Zether and PQ Zether | 18. Free Pay |
The usual pitch for blockchains is a "decentralized, immutable ledger". That description does not help when building on a smart-contract chain, and much of it is not even true in practice (see below). SCaaS looks at a smart chain the way an engineer looks at a cloud platform: a shared infrastructure that sells four services.
flowchart LR
subgraph CHAIN["Smart chain = infrastructure"]
direction TB
EX["Execution<br/>a VM runs contract code"]
ST["Storage<br/>contract state"]
PAY["Payment<br/>native fee on every call"]
AUTH["Authentication<br/>client-side signatures"]
end
APP["Your application"] -->|"signed call"| CHAIN
CHAIN -->|"result + events"| APP
| Service | What the chain provides | Examples |
|---|---|---|
| Execution | A virtual machine that runs contract code deterministically; every validator gets the same result | EVM, Move VM (Aptos, Sui), Soroban WASM, CosmWasm, TVM (GRAM, formerly TON), SVM (Solana), NEAR WASM, AVM (Algorand) |
| Storage | Durable state owned by each contract, read and written only through its code | EVM key-value storage, Sui objects, Soroban persistent/temporary entries with a rent (TTL), Solana accounts |
| Payment | Metering and billing are part of the protocol: every transaction pays a native fee, on the chain, at once — no invoice, no payment processor | ETH/xDAI gas, HBAR, SUI, XLM, GRAM, SOL, NEAR, ALGO; some chains bill in stablecoins (Gnosis xDAI, Celo fee currencies) or peg fees to USD (Hedera) |
| Authentication | Every call carries a digital signature made on the client side; the chain verifies it. There are no server sessions and no passwords | secp256k1, ed25519, P-256 (passkeys), BLS, post-quantum schemes |
Three supporting services complete the picture:
- Ordering and commit — consensus orders transactions; finality is the point after which a result will not be undone (seconds on BFT chains, minutes on some proof-of-stake chains).
- Notifications — contracts emit events; anyone can subscribe.
- API endpoints — every chain exposes RPC to submit, read and simulate a call before paying for it.
If a smart chain is infrastructure, it should be judged next to the infrastructure people already use: a cloud VM (IaaS, e.g. EC2, Compute Engine) and a hosted backend (BaaS, e.g. Supabase, Firebase). The chain loses on speed and wins on money, authority and trustworthy records; the five tables below — a) to e) — say which, and f) sums up.
a) Code and data — for computing and storing data, the chain is slower, smaller and dearer
| Cloud VM (e.g. EC2, Compute Engine) | Hosted backend (e.g. Supabase, Firebase) | Smart chain + SCaaS | |
|---|---|---|---|
| Compute | Your code on virtual machines you rent | A managed database per project plus serverless functions (Supabase: V8 isolates at the edge; Firebase: Cloud Functions) | Contract code in the chain's VM, run identically by every validator |
| Storage and its price | Disks and databases, per GB-month | Rows and files, per plan or usage | Contract state, paid in gas per write (some chains add rent) |
| Latency of a write | Milliseconds | Milliseconds | Seconds to minutes, until finality |
| Throughput | Grows with what you rent | Grows with the plan | Bounded by the chain's block space, shared with everyone |
| Reads | Your server answers | API with row-level rules | Free: RPC, node feeds or an indexer; no signature needed |
| Changing code | Redeploy at will | Migrate at will | Immutable at deploy; new behaviour is a new version (section 5) |
For computing and storing data, the chain is slower, smaller and dearer. Application data and logic stay where they are.
b) Money and billing — only the chain has payment inside the infrastructure itself
| Cloud VM | Hosted backend | Smart chain + SCaaS | |
|---|---|---|---|
| How the service is paid | A monthly invoice | A monthly plan or usage invoice | A native fee inside every transaction, settled at once |
| Who pays | The application owner | The application owner | Whoever submits: a relayer, the subject or the payee; it can be passed on in the token (section 9) |
| Moving value between parties | Needs a bank or a payment processor | Same | Built into the protocol: a payment is an ordinary call |
Only the chain has payment inside the infrastructure itself.
c) Operations and reliability — no single operator, but the chain itself cannot be swapped
| Cloud VM | Hosted backend | Smart chain + SCaaS | |
|---|---|---|---|
| Who operates it | One provider, plus you | One provider | Many independent validators; anyone can run a SCaaS node and relayer |
| Availability | Provider SLA and your redundancy | Provider SLA | The chain's liveness; a relayer outage only delays, and the subject can switch relayer or submit itself |
| When a write is safe | When your database commits; backups | Same | After finality; before it a reorg can undo the write, so SCaaS reports only final results |
| Lock-in | Provider APIs and migration effort | Provider-specific auth, rules and APIs | Contracts and data are public and any node can serve them; the lock-in is to the chain itself |
No single operator controls the service, but the chain is the one dependency that cannot be swapped without a migration.
d) Who holds the power — the core difference, and where the chain wins
| Cloud VM | Hosted backend | Smart chain + SCaaS | |
|---|---|---|---|
| Who signs a write | The application server, for the user, with a token it issued | The backend's auth service issues the token; the database writes | The subject, on its own device (passkey or wallet); the relayer holds no user key |
| Trust root | Operator, cloud IAM, whoever holds the token-signing key | Operator, whoever holds the JWT secret or the admin (service-role) key | The user's authenticator, chain consensus, immutable contract code |
| Who can forge a user's write | Anyone with the signing key, database access or a compromised server | Anyone with the JWT secret or the admin key | Nobody without the user's private key; relayers can only refuse or delay |
| Proof and audit | Logs the operator writes and can edit | Same | Each operation carries a signature anyone can verify, forever |
| Where permissions are enforced | Application code (an endpoint is easy to miss) | Row-level rules (the admin key bypasses them) | Contract code on every call: signature, nonce, expiry, limits |
| Revoking a key | Easy: short TTLs, deny lists, rotation | Easy: rotate the secret, revoke refresh tokens | Harder: on-chain rotation, guardians, backup keys (per family) |
| Typical breach | Leaked signing key: every user impersonated | Leaked JWT secret or admin key: every user, rules bypassed | Leaked key of one user: that user only, within its mandate limits |
This is where the chain wins, and why SCaaS exists. The full comparison and how the ERP trusts finalized events are in docs/architecture.md; the bounded admin powers are in section 4 and docs/contracts/README.md.
e) Privacy and data — confidential amounts, and records nobody can rewrite
| Cloud VM | Hosted backend | Smart chain + SCaaS | |
|---|---|---|---|
| Who can see the data | The operator, and whomever it grants | The provider, and whomever it grants | Amounts and balances hidden by Zether, and by PQ Zether (post-quantum, on the SCaaS testnet), both unaudited and both on EVM only; who transacts stays visible |
| Changing a record | Rows can be edited or deleted, often without a trace | Same | Immutable: a mistake is fixed by a new entry that references it — a wrong invoice gets a correcting invoice, never an edit — so the history is its own audit trail |
| A private setup | A private network | Self-hosting | A private or permissioned chain with admitted peers only |
Because nothing on a chain can be deleted, personal data never goes on chain — only commitments, references and (hidden) amounts (docs/integration.md).
f) Which to use for what. Use the chain for write authority, value and records nobody may rewrite: every valuable create or update — a payment, a trade, a grant of rights, a key registration — carries the subject's signature, and no server ever holds a key to sign for a subject. Keep reads, reports and business workflows on ordinary infrastructure with ordinary sessions. The chain does not replace the application's database; it replaces the server's power to act for the user.
Important
What a chain is not. Building on the four services means being honest about their limits:
- Results can be undone until finality. Blocks can be reorganized; SCaaS reports nothing before its finality gate (docs/node/indexer-feeds.md).
- Contracts are not automatically immutable. Most platforms let a deployer keep an upgrade key. Immutability is a deployment decision (section 5).
- A private chain with one block signer is a signed database, not a decentralized network. SCaaS uses one (SCaaS testnet) and names it as such (docs/networks/evm.md).
- Validators can delay or censor a transaction; they cannot forge it.
- Everything is public by default, including amounts and balances — which is why Zether exists.
On top of that infrastructure, SCaaS ships the business services as smart contracts: payments, spending mandates, tokens and wrappers, an order-book DEX, sealed-bid tenders, vesting and distributions, confidential transfers. Each contract is an API service; each of its functions is an API function. ERPs, web portals, mobile apps and AI agents call them like any other API.
| Web API | SCaaS |
|---|---|
| Service endpoint | A contract address on a chain |
API function (POST /payments) |
A contract function (mtxPay(...), mtxExchange(...), mtxConfidentialTransfer(...), or any allowlisted function of any SCaaS contract) |
| Bearer token issued by the server | The subject's own signature over exactly this call (EIP-712 on EVM) |
| Quotas and limits | Caps inside the contract: per-payment and per-period mandate limits, expiry on every signature |
| API versioning | A version catalogue in the factory; each deployed contract stays fixed (section 5) |
| Billing | Gas, paid by a relayer; optionally a fee in the token (section 9) |
| Commit acknowledgement | A finalized event, delivered by the node as a feed |
The one difference from an ordinary web API is who authorizes a write. In a web API the server decides and signs; anyone holding the server's keys can act for any user. In SCaaS the subject — the person, company, device or AI agent whose value moves — signs each call on its own device (a passkey or a wallet key). A server only carries the signed call to the chain and reads the result back.
sequenceDiagram
autonumber
participant S as Subject (device)
participant R as Relayer (scaas-node)
participant C as Contract (API service)
participant E as ERP / app
S->>S: sign the call (passkey or wallet)
S->>R: signed intent
R->>R: simulate, check policy
R->>C: submit, pay gas
C->>C: verify signature, nonce, expiry, limits
C-->>R: event
R-->>E: finalized event (feed)
Read more: the authority model and why it differs from IaaS/BaaS — docs/architecture.md; the product overview — docs/README.md.
SCaaS contracts inherit from the standard contracts instead of reinventing them. On EVM they are built on OpenZeppelin (version pinned in CI) and the ERC/EIP interfaces, so wallets, explorers and other contracts see an ordinary ERC-20 token; the gasless layer is an extension of the standard, not a fork of it. Every product sits on the same few layers:
flowchart TB
STD["Standards<br/>ERC-20 · EIP-712<br/>ERC-1271 · EIP-1167"]
LIB["Shared libraries<br/>signatures · fees<br/>multisig · BLS<br/>hash-to-curve"]
BASE["Bases<br/>gasless token<br/>confidential token"]
subgraph BUILT["Built"]
direction LR
F["Factory"]
T["Tokens and<br/>wrappers"]
D["Tradable tokens<br/>and DEX"]
A["Mandates and<br/>accounts"]
U["Universal Account<br/>registry"]
subgraph CONF["Confidential tokens"]
direction LR
Z["Zether<br/>(BLS12-381)"]
P["PQZ<br/>(post-quantum)"]
end
end
subgraph SPEC["Specified"]
direction LR
AS["Asset suite"]
TD["Tender"]
end
STD --> LIB --> BASE
BASE --> BUILT
BASE -.-> SPEC
Every EVM token comes from one base tree: the kind is code, the features are flags chosen at creation, and heavy logic sits in external libraries (CTR-TOK-21, CTR-TOK-24).
The catalogue (EVM) — every contract area with what it is built on, its status and where to read
| Area | Contracts | Built on | Status | Read |
|---|---|---|---|---|
| Factory | OpenFactory (one factory) |
EIP-1167 clones at CREATE2 addresses: shared code, separate data (section 5); the version catalogue | BUILT as OpenFactory (createToken; kinds NORMAL, WRAPPED, NORMAL_ZETHER, WRAPPED_ZETHER (P3) and NORMAL_PQZ, WRAPPED_PQZ once enabled (setKindEnabled), gated by PqzSafety (P6g); releases deployed by the factory on versioned envs (5g-Z2)); the v1 line OpenFactoryV1 is in legacy/p5/ (P5) |
token-wrappers |
| Gasless contracts | MetaTxBase (any SCaaS contract) → ERC20MetaTx (every token) → MetaTokenBase |
EIP712; mtxExecute runs a signed MetaTransaction as a self-call on a selector allowlist; tokens add ERC20 + IERC20MetaTx and the typed MetaTransfer (CTR-MTX-22, CTR-MTX-23) |
BUILT (P1a–P1c): MetaTxBase, ERC20MetaTx, MetaTokenBase; the v1 line is in legacy/ (P5) |
metatx |
| Payments | a signed MetaTransfer with an entryRef (mtxPay), or IERC20Payment.payWithFee; both emit PaymentSettled |
IERC20MetaTx |
BUILT: MetaTransfer and mtxPay on MetaTokenBase |
metatx |
| Token kinds | six kinds by code: NormalToken (NORMAL), WrappedToken (WRAPPED, 1–8 legs, the native coin allowed), NormalZetherToken, WrappedZetherToken (the two *_ZETHER kinds), NormalPqzToken, WrappedPqzToken (the two *_PQZ kinds); *_ZETHER_PQZ reserved. Features by flags fixed at creation: payable, mint (on a wrapped kind the hybrid mint under maxSupply), burn, adjustable rate, wrap-disable, freeze, force, pause, allowlist, denylist, rescue, moderate (CTR-TOK-21) |
MetaTokenBase |
NORMAL and WRAPPED BUILT (P1c–P1d) with GovernanceLib (was AdminLib), WrappedLib, HederaLib (over the old EIP-170 limit); *_ZETHER kinds with ZetherLib BUILT, unaudited (P3); *_PQZ kinds with the four PQZ libraries (PqzStateLib, PqzTransferLib, PqzBurnLib, PqzViewLib) BUILT, unaudited, deployed on the SCaaS testnet (P6g); every kind is over EIP-170, and WrappedPqzToken (72,160 B) is above 65,536 B, so it runs only on a chain whose code limit its operator raises (CTR-GOV-19) |
token-wrappers |
| Tradable tokens | mtxTrade: the token pulls a signed TradeOrder into the DEX named in it |
IERC20MetaTx |
BUILT (TradeLib, P2; the trade op and the legacy MetaTxDex are in legacy/p5/, P5) |
metatx, legacy DEX |
| DEX | SCaaSDex, DexPuller |
EIP712 + ReentrancyGuardTransient; one taker against many makers per call on two paths, no maker allowance; mtxExchange fills the same orders against AMMs (Uniswap v2 and v3 by interactions, v3 and v4 through the reference executor), multi-hop or in a cycle, surplus to the signers (CTR-DEX-20) |
BUILT (P2c: the exchange path on the new SCaaSDex) |
dex |
| Mandates | MandateWallet |
MetaTxBase + IERC1271 |
BUILT (on MetaTxBase, P4) |
mandates |
| Smart account (optional) | SmartKeyAccount, SmartKeyAccountFactory |
MetaTxBase + IERC1271; P-256 passkeys; signs its own calls as itself (CTR-ACC-10) |
BUILT (on MetaTxBase, P4) |
accounts |
| Universal Accounts | the UA registry with one verifier per kind (smartcontracts/evm/src/ua/UARegistry.sol; the Zether kind since UA-3; the old Zether-only registry is backed up in smartcontracts/evm/legacy/ua3/, not built), and the UA ledger in the token base |
the signature, multisig, BLS and hash-to-curve libraries | UA registry BUILT and deployed on the SCaaS testnet (P6g; the post-quantum kinds since P6c); the UA ledger in the token base BUILT (UA-4), UA receivers / wrap (UA-5a) and UA trade orders / DEX legs (UA-5b) BUILT; UA-5c SPECIFIED | accounts |
| Zether | the *_ZETHER kinds (ZetherLayer + ZetherLib), ZetherStatements, the transfer, burn and inner-product verifiers, BLS12-381 only (ZetherTransferVerifier*, ZetherBurnVerifier*, ZetherInnerProductVerifier*), ITransferDisclosure |
MetaTokenBase; EIP-196/197 and EIP-2537 precompiles |
BUILT, unaudited (P3) | zether |
| PQZ (post-quantum Zether) | the *_PQZ kinds (PqzLayer + the four libraries + PqzCore), PqzCt, PqzSafety (precompile self-test; no chain allowlist), PqzKeyVerifier (the pqz-mlwe scheme, a PQZ key carried by a post-quantum signing UA) |
MetaTokenBase, relayed like Zether (CTR-PQZ-21); the PQZ precompile (PQZL lattice / PQZH hash-based proofs, pqz-core) live on the SCaaS testnet — public chains once they offer one |
BUILT, unaudited, deployed on the SCaaS testnet with real PQZL proofs end to end (P6g); the multi-recipient transfer (op 7) is in the proof engine and being activated on the SCaaS testnet (P6-ANON S8) | pq-zero-knowledge |
| Asset suite | ComplianceRegistry, VestingGrant, Distribution, ExchangeOffer |
regulated flags 5–8 on ordinary token kinds (CTR-AS-17); ERC-7201 namespaced storage | SPECIFIED | asset-suite |
| Tender | SealedBidTender |
commit and reveal with deposits | SPECIFIED | tender |
| Sponsorship | SponsorshipPool |
opt-in gas sponsorship contract | PLANNED | sponsorship |
| Hedera | NORMAL and WRAPPED with IS_HEDERA set, HederaMandateWallet; the Zether and PQZ kinds refuse a Hedera release |
the same EVM contracts plus HIP-632 for native Hedera keys | BUILT: IS_HEDERA and HederaLib on the same token contracts (CTR-TOK-23); the Hedera*UnderlyingToken children are gone |
hedera |
Tradable tokens: where they came from. The first SCaaS code had an ERC1776Tradeable token: a trade order signed
against the token itself (MtxTradeOrder: amount, receive token, receive amount, relayer, fee) that only a DEX could
pull, matched one taker against several makers in one call. The design returns to that shape: the signed
TradeOrder keeps those fields, the token moves funds only into the dex named in the order, and the DEX settles one
taker against many makers, either pulling exactly the matched part of a resting order or pulling the whole amount and
refunding the rest (section 15).
Standards — the standards SCaaS builds on, the wallet and client standards, and those deliberately not used
Standards used:
| Standard | What for |
|---|---|
| ERC-20 (OpenZeppelin) | Every token stays an ordinary ERC-20 |
| EIP-712, ERC-5267 | Typed, readable signatures; the domain is published by eip712Domain() |
| ERC-1271 | Contract accounts (Safe, SmartKeyAccount) sign like users |
| EIP-1167 | Cheap, immutable clones from the factory |
| ERC-7201 | Namespaced storage for the regulated module |
| EIP-196/197, EIP-2537 | bn254 and BLS12-381 precompiles for Zether, BLS and Schnorr |
| EIP-7951 (RIP-7212) | P-256 precompile for passkeys, with a Solidity fallback |
| RFC 9380 | Hash-to-curve for BLS |
| BIP-340, BIP-327, RFC 9591 | Schnorr, MuSig2 and FROST Universal Accounts |
| FIPS 204, FIPS 206 | ML-DSA and FN-DSA (Falcon) post-quantum Universal Accounts |
Wallet and client standards — how signers and apps reach the user's keys (docs/clients/signers-clientkeys.md):
| Standard | What for |
|---|---|
| EIP-1193 | The browser wallet provider interface (window.ethereum as the fallback) |
| EIP-6963 | Discover every installed browser wallet, let the user choose one, remember the choice — no wallet library |
| EIP-712 | The wallet shows each field of what it signs |
| Wallet Standard | Sui, Aptos and Solana browser wallets |
| WalletConnect, TON Connect | Mobile and GRAM (formerly TON) wallets (interfaces reserved; the TON Connect HTTP bridge is not wired yet) |
| WebAuthn | Passkeys (P-256) that sign on the user's device |
| BIP-39, BIP-32, BIP-43, SLIP-10, SLIP-44 | One 24-word seed; per-network and per-kind key paths (Universal Account tree m/22776'/…) |
| EIP-2333, EIP-2334 | BLS and bn254 key derivation for BLS and Schnorr Universal Accounts |
| RFC 6979 | Deterministic ECDSA for server-side signing: re-signing after a restart gives the same signature |
| OIDC with RFC 9207 | Console login to a node's admin API, with issuer pinning |
Standards deliberately not used:
| Standard | Why not |
|---|---|
| ERC-2771 trusted forwarder | A forwarder sits outside the token, can swallow a failed call after charging for it, and needs a trusted address; the meta-transaction lives inside the token instead (section 8) |
| ERC-4337 bundlers and paymasters | An extra mempool, bundler and entry point for something the token already does; SCaaS follows EIP-1776 |
| UUPS, Transparent, Beacon or Diamond proxies | An upgrade key is an admin key over every balance (section 5) |
| Approvals by ordinary accounts | The classic drain: only a contract may call approve on a SCaaS token (section 6) |
Other families fill the same roles — value under signed operations, a mandate, a DEX, a relay fee — on their own standards (docs/networks/README.md). Only the EVM has wrappers, the exchange path against AMMs, and the confidential tokens: classical Zether and PQZ exist on EVM alone. Aptos, Sui and Solana have no token of their own: they run over the chain's own coins and tokens. Each row is contracts and tests in this repository; the deploy state differs per family (docs/networks/), and the family's own page is the reference.
| Family | Chains | Language | Token | Mandate and DEX | Relay fee | Accounts | Universal Account |
|---|---|---|---|---|---|---|---|
| EVM | SCaaS testnet; draft profiles Gnosis, Celo, BSC, Polygon, Base; TRON planned | Solidity | MetaTokenBase kinds (ERC-20) |
MandateWallet, SCaaSDex (order book, exchange path) |
RelayFeeRouter and RelayFeeExecutor |
ERC-1271, passkey, native | registry and ledger |
| Hedera (on the EVM path) | Hedera | Solidity | NORMAL, WRAPPED with IS_HEDERA |
HederaMandateWallet, SCaaSDex |
the same router | native keys by HIP-632 | the same code; no round of its own |
| Cosmos | CosmWasm chains | Rust (CosmWasm) | token (CW20) + metaop |
mandate, dex (two-leg) |
relayfee + relayexec |
ADR-036 secp256k1, passkey | none: base contracts only |
| Soroban | Stellar, Pi Network | Rust (WASM) | token (SEP-41) |
mandate, dex (two-leg, partial fills) |
relay-fee + relay-executor |
smart-key-account with __check_auth |
ua-registry and a UA ledger, on a local network |
| Aptos | Aptos | Move | no token: any fungible asset, meta |
mandate, dex (two-leg) |
relayfee wrappers |
auth, p256 |
none: base contracts only |
| Sui | Sui | Move | no token: any Coin<T> in a shared Account<T>, meta |
mandate, dex (two-leg) |
relayfee wrappers |
auth |
none: base contracts only |
| GRAM (ex-TON) | GRAM | Tact | jetton (TEP-74) |
mandate, dex (escrow) |
relayfee + executor |
wallet signature, passkey | none: base contracts only |
| Solana | Solana | Rust | no token: SPL and Token-2022 accounts, program scaas |
same program (two-leg) | in the program, with wrappers | ed25519, P-256 | none: base contracts only |
| NEAR | NEAR | Rust (near-sdk) | token (NEP-141) |
mandate inside token, dex (escrow) |
relayfee + relayexec |
SCaaS key records: ed25519, secp256k1, passkey, msig; never an access key |
a UA ledger with lazy records, no registry; its UA rounds are open |
| Algorand | Algorand | Algorand Python | token (ARC-200 in boxes, not an ASA) |
mandate, dex (atomic) |
relayfee + a LogicSig executor |
one shared account app: ed25519, secp256k1, passkey, msig |
a UA ledger with lazy records, no registry; its UA rounds are open |
Off the EVM the built signed form is MetaOp v1: Relay on Cosmos, relay_pay on Move, SignedOp on GRAM, mtx_* entries on NEAR and Algorand, host authorization on Soroban. One MetaCall and one typed
MetaTransfer with mtx names on every family is SPECIFIED (NET-ALL-26,
NET-ALL-27, NET-ALL-28).
A SCaaS contract never lets anyone move a user's funds at will. But a token issuer, a DEX operator and a wrapper need some powers: mint, list a market, change a rate. This section says who holds them and how they change hands.
Important
BUILT on branch governance, EVM only, UNAUDITED (owner rulings CTR-GOV-01 to
CTR-GOV-19). The regulated implementations are SPECIFIED, the other families PLANNED.
The rules in one place: docs/contracts/README.md, Governance.
The model answers five questions with five words, the same way at every address, in one layer, GovernanceBase, inherited by the six token kinds and SCaaSDex
and by any third-party contract.
| Question | Answer | In short |
|---|---|---|
| Does the right exist here? | a bit | Bits 0–127 mean the same on every SCaaS contract, so a wallet names one without reading the contract (governance_bits.json gives each bit's name and disclosure sentence); bits 128–255 belong to each application contract, with a label; no band is refused |
| Who has it? | a holder | An owner appoints holders per bit. Some bits have no holder: they bind or serve everyone (anyone may pay; anyone may rescue a stray asset to the address fixed at creation) |
| Within what? | a grant | An optional limit on one holder: a band on the number the contract acts on, a total, a budget per window, an expiry, a use count, a scope the contract interprets. One level of narrower sub-grants; a sub-grant also spends its parent's budget |
| Who changes that, and when? | the owner, after a delay | A new holder or a wider grant takes two calls by the owner, grantDelay apart (fixed at creation, at most 30 days), and is dead if not confirmed in time. Using a power, narrowing, revoking and transferring ownership are not delayed |
| Can it be made permanent? | a lock | A locked bit can never be cleared: the power exists for good, and a wallet says so. An owner cannot give up the contract while a bit that is not locked still has a live holder |
The DEX's owner hands listing (bit 11) and the fee split (bit 12) to holders like any other power; it can transfer or renounce ownership. A wrapped token may also be a hybrid: its issuer mints unbacked units under a cap fixed at creation, and redemption runs while the reserve lasts, first come (CTR-GOV-12). A wrapped token refuses a SCaaS leg whose issuer can move balances. A plain transfer reads no governance slot, pinned on every kind. The complete list of powers is in docs/contracts/README.md.
Every owner and holder is a Universal Account id. A plain account is its own address as a UA id and calls the contract directly. A derived UA, a post-quantum key or an
msig of such keys signs a typed operation that a relayer sends, at fee 0, to the chain's one GovernanceRouter; the router has the UA registry verify the signature and calls
the token or the DEX, which asks the router whom it authenticated. The router has no owner and holds nothing. That is how a threshold of post-quantum keys becomes an owner,
within the verification budget of section 7.
flowchart LR
M["msig of PQ members<br/>threshold signs"] -->|"typed operation"| R["Relayer<br/>fee 0"]
R --> GR["GovernanceRouter<br/>one per chain and UA registry"]
GR -->|"registry verifies<br/>the members"| G["UA registry"]
GR -->|"the operation"| T["Token or DEX<br/>asks the router: who?"]
Relayed administration. An owner or holder operation has one direct entry on the governed contract and no gasless twin there. Its signed, typed, gasless form lives once, in the router, so a contract near its size limit pays nothing for it, and a wallet shows each field. An owner that keeps the power on a plain account and calls directly pays its own gas.
Regulated tokens (SPECIFIED, not built). Freeze, forced transfer against a recorded order, pause, a receiver allowlist and a receiver denylist are bits 5–9, refused at creation today (asset suite). A plain transfer gains no gas: a regulated token is a separate implementation, one per kind, never one per feature (CTR-GOV-03); the enum already holds their ids. The regulated confidential kinds have their rules decided and are not designed in detail (CTR-GOV-17).
Code size. The whole record is built on every kind; WrappedPqzToken (72,160 B) is above 65,536 B, so it runs only on a chain whose code limit its operator raises: the
SCaaS testnet's next reset (CTR-GOV-19).
Background: the research docs/research/governance/permission-model.md, its open gaps and the full matrix of what is fixed, set at creation or changeable permission-model-gaps.md, and how it compares with other systems, weaknesses included model-comparison.md.
A contract is two things: code (what it does) and data (its balances and settings). They do not have to live
in the same place. With DELEGATECALL a small contract keeps only its own data and runs code that lives in another
contract, the implementation:
flowchart LR
C1["Token A<br/>(its data)"] -->|"DELEGATECALL"| I["One implementation<br/>(the code)"]
C2["Token B<br/>(its data)"] -->|"DELEGATECALL"| I
C3["Token C<br/>(its data)"] -->|"DELEGATECALL"| I
I -->|"linked library"| L["Shared library<br/>(more code)"]
The same DELEGATECALL serves two very different purposes. What separates them is one question: can the pointer
to the code change after deploy?
| Reuse: clone (EIP-1167) | Upgrade: proxy (UUPS, Transparent, Beacon, Diamond) | |
|---|---|---|
| Pointer to the code | Fixed at deploy, part of the clone's own bytecode | Stored in a slot that an admin can rewrite |
| Who can change the rules | Nobody | Whoever holds the upgrade key |
| What users must trust | The code they can read today | The code today and every future decision of the key holder |
| A bug fix | A new version, plus a voluntary migration by the balance owners | Repoint the proxy; every balance follows at once |
The common habit is "deploy everything behind a UUPS proxy so it can be patched". That habit means whoever holds
the upgrade key can rewrite the rules over every user's balance. SCaaS uses DELEGATECALL only to reuse code,
never to upgrade it.
Every SCaaS token is a 45-byte EIP-1167 clone whose only code is a fixed pointer to its implementation; the clone holds only its own balances and settings (token-wrappers). Subject accounts, vesting grants, distributions and the other action contracts are clones too, and large shared logic (the regulated module) sits in a library linked once per chain.
| Benefit | Why |
|---|---|
| Cheap to create | A clone stores 45 bytes of code instead of tens of kilobytes. Creating a token, its first state included, measured about 1.3 M gas under Amsterdam's state pricing |
| Light on the chain's nodes | The implementation's code is stored once per chain — clients keep code by its hash — and each new clone adds 45 bytes plus its own storage. The one implementation, called by every clone, stays hot in the clients' code caches, and state grows more slowly |
| One audited code base | Auditing and verifying one implementation covers every clone; all clones of a version share one code hash, so anyone can check which code a token runs |
| Versions without upgrades | A new version is a new implementation added to the factory's catalogue; it applies only to contracts created after it, and existing clones keep their pointer and their rules |
The cost is one extra DELEGATECALL per call (a cold address access the first time in a transaction). The original
requirement — share code through delegation, keep separate data, support several versions — is met without an
upgrade key.
Whether a program can be changed later is not a property of the chain; it is decided when the program is
deployed. Every platform offers a way to keep an upgrade key: proxies on EVM, an UpgradeCap on Sui, a package
upgrade policy on Aptos, an upgrade authority on Solana, a contract admin on CosmWasm. SCaaS decides:
- Every program that holds user value is deployed immutable (CTR-GEN-02). Users verify once what a contract does and can rely on it for good.
- New behaviour is a new version, not a patch (above). A bug fix is a new deployment plus a voluntary migration.
- The deploy gate enforces it, in part. SPECIFIED on every family (docs/networks/README.md). Built today: the NEAR and Algorand deploy runs fail unless the program is frozen,
and their node adapters halt at start; Sui freezes in the run; Aptos by its
Move.tomlpolicy. The Solana, Cosmos and GRAM steps, and the node's re-check for the other families, are not built.
The price is that there is no hotfix in place. That is deliberate: an upgrade key is an admin key over every balance.
Every family separates shared code from per-user data in its own way, and each has its own switch to freeze the code:
| Family | Code stored once | Data per contract or user | Frozen at deploy by (rule; see above for what is built) |
|---|---|---|---|
| EVM, Hedera | one implementation per version | 45-byte EIP-1167 clones with their own storage | clones have no upgrade path; no proxy anywhere |
| Cosmos (CosmWasm) | store the WASM once (code_id) |
each instantiate is a contract with its own state |
instantiate with --no-admin |
| Soroban | install the WASM once (by hash) | each instance references that hash | contracts are immutable as built |
| Solana | one program | data in separate accounts (subject account, lanes) | upgrade authority set to None |
| Move (Aptos, Sui) | one package | objects and resources per user or token | Aptos immutable policy; Sui make_immutable on the UpgradeCap |
| GRAM | one jetton-wallet code | each wallet deployed with the same code cell in its state_init |
code is immutable as built |
| NEAR | one WASM per contract account (no global contract) | contract state | every access key deleted; the run fails otherwise |
| Algorand | one program per app | boxes; one shared account app |
programs reject update and delete; hashes gated |
Five habits of the usual blockchain, token and wallet model are the source of most losses and most of the friction that keeps blockchains out of everyday use. SCaaS designs each of them out.
This is the root problem. Before you can do anything on a blockchain, you have to buy its native coin — ETH, BNB, SOL and so on — just to pay the fee. Picture a coffee shop asking every customer to open a crypto exchange account before they can collect points. Nobody would. That one requirement has kept blockchains out of most everyday applications.
There are workarounds: sponsored transactions, ERC-2771 forwarders, ERC-4337 paymasters, fee-bump and fee-grant features. They help in places, but they do not remove the problem.
Grab is a good example. In September 2023 it launched the Grab Web3 Wallet for its users in Singapore: a pilot with Circle on Polygon, holding NFT vouchers and paying in the XSGD stablecoin, part of the Monetary Authority of Singapore's Project Orchid. A month later it tried Circle's Gas Station, so Grab paid the gas instead of the user (The Defiant, EDB). Even so, users still had to open that particular wallet. It worked on one chain (Polygon PoS) with two kinds of asset, and every sponsored transaction went through one provider's paymaster. The fee problem had moved, not gone away.
With SCaaS, users never need a native coin. They sign what they want to do, a relayer sends it to the chain and pays the gas, and the relayer is paid in the token being used — or the merchant pays (section 8). A company like Grab would not need a special wallet, and it would never sign on its customers' behalf: each customer signs with a key they already have (a passkey or an existing wallet), any relayer submits, and the company pays the fees in its own token, on whichever chain it uses.
The same works for loyalty points, prepaid cards, vouchers and prepaid service passes (one token = one visit, session or ride) at a spa, a bakery, a gym or a coffee chain. Each one is just a token that any wallet or app can hold, and the business does not have to run any blockchain infrastructure of its own (use cases, "Retail and loyalty").
On every chain a normal transaction is built for the sender's own account and its sequence number (EVM nonce, Stellar sequence, Cosmos account sequence, GRAM wallet seqno), at the moment it is sent. That means:
- the user must be online, at that moment (and, as above, hold native coins for gas);
- the transactions of one account run strictly one after another: one stuck transaction blocks every later operation of that account, on every contract (head-of-line blocking);
- a call cannot be signed now and executed later by someone else.
"Someone pays the fee for me" does not fix this. The native sponsorship features — Hedera payer accounts, Sui
sponsored transactions, Stellar fee-bump, Cosmos feegrant, GRAM wallet extensions — and the EVM add-ons ERC-2771
(trusted forwarder) and ERC-4337 (bundlers and paymasters) move the fee to another party, but the operation is
still a transaction of the subject's own account (so its sequence still orders everything), or it needs both parties
to co-sign at submit time, or it runs through an external forwarder that can swallow a failed call after charging
for it.
SCaaS: the subject signs an intent — "this operation, on this contract, valid until this time" — and anyone may execute it later, from their own account (NET-ALL-02). Each contract keeps its own two-dimensional nonce space (a lane and a sequence inside it), so independent operations never wait for each other (section 8).
A chain wants many transactions and deep liquidity, because that is what makes it useful and what pays its validators. Yet the common design burns part of every fee (EIP-1559's base fee and its imitators) to make the native coin scarcer and dearer — and a dearer coin makes every transaction more expensive, which means fewer transactions. The two goals pull against each other. Burning is not needed for either goal: a chain earns more by carrying more transactions, not by destroying its coin, and when blocks are full the gas price already rises by itself, which is enough to ration space.
If the aim is to hold back inflation of the native coin, the direct levers are different: lower the new coins issued as validator rewards, and let fees from a larger volume of transactions pay the validators instead — which is exactly what meta-transactions bring, by letting people use the chain without first buying its coin.
SCaaS burns nothing: the fee of an operation goes to whoever executes it, in the token used, and the cost of a payment does not depend on the price of a coin the user never holds.
The standard ERC-20 flow is approve(spender, amount), then the dApp's call (which uses transferFrom), then — if the
user remembers — revoke. Two things are wrong with it:
- The allowance outlives its purpose. It is often "unlimited", often granted to a plain address, and stays until the user revokes it. A phishing site or a compromised dApp can drain the balance at any later time; forgotten approvals are one of the largest causes of losses for non-expert users.
- It makes every dApp interaction slow and expensive: approve → call → revoke is three transactions, three signatures and three fees for one action.
SCaaS: only a contract may call approve — an ordinary account never grants an allowance on a SCaaS token, in any
form — and only a contract may spend one (docs/contracts/token-wrappers.md).
Everyday payments need no allowance at all: the payer signs one pay for one amount, to one payee, with an expiry.
When a contract does need to hand tokens to another contract, it approves inside the same call and takes the allowance
back at once: the SCaaS DEX approves an outside router only within the route it executes and revokes every such
allowance (approve(spender, 0), which is what a "revoke" is in ERC-20) before the transaction ends
(increaseAllowance and Permit2 approvals are refused). An outside token
(for example USDC) still follows its own ERC-20 rules; its holders approve only the DEX's DexPuller, which pulls
nothing without the holder's signed order.
In a classic web or custody setup, the server signs on the user's behalf. Whoever controls that server — or steals its keys — can move funds, and the audit log is whatever the server wrote. In SCaaS no server holds a key that can sign for a subject (docs/architecture.md).
On a chain, an account is simply whoever can produce a valid signature. But each chain natively understands only its own key types — an EVM chain knows secp256k1 addresses and nothing else. Real users and organizations need much more: passkeys on phones, HSMs, ed25519 keys, Schnorr and BLS keys, multisig and threshold groups, post-quantum keys, and confidential (Zether) keys.
A Universal Account (UA) is the actor — a person, an organization, a device or a group — that signs, and answers for, every write to a smart contract, tokens included. Its signature may come from a native account, a single key of any kind, a BLS key, a group or threshold key, or an m-of-n multisig; it is named by a 32-byte id derived from that key data or policy: an EOA address generalized to every signature scheme (docs/contracts/accounts.md, CTR-UA-30 in decisions). A UA holds its public and its confidential balances under the same id. Reading needs no UA; whatever cannot sign a write is not a UA but an attribute of one: a classical Zether key is itself a UA (it signs by Schnorr, and its proof authorizes a spend), while a post-quantum PQZ key, which cannot sign, is an attribute of a post-quantum signing UA.
flowchart LR
K["Key data or policy<br/>(passkey, BLS, multisig…)"] -->|"hash with kind tag"| U["UA id<br/>32 bytes"]
U -->|"register once per chain<br/>with proof of possession"| R["UA registry<br/>(no admin)"]
R --> F["Contract functions<br/>accept the kinds they need"]
N["Native account<br/>(EVM address, Safe…)"] -.->|"no registration"| F
What makes it work:
- It is an identifier, not a contract. Nothing is deployed per user: creating a UA is free and deterministic, and the same key data gives the same id on every family with UA ids (EVM, Hedera, Soroban, NEAR, Algorand) (CTR-UA-02).
- Native accounts are used as they are. An EVM address, a contract account (Safe,
SmartKeyAccount) or a native account of another family is already a UA and never registers. Every other kind registers once per chain, with a proof that the registrant holds the key; the registry has no admin and never forgets. NEAR and Algorand have no registry yet: a UA opens there on its first signed operation. - Ids never collide. Every derived id carries a versioned kind tag and is 32 bytes, so a passkey UA can never equal an EVM address or a UA of another kind over the same key (CTR-UA-03).
- One key, one purpose. The same key is never used for two kinds — wallets derive a separate key per kind, and the registry refuses a key already registered under another kind (CTR-UA-10).
- Each function accepts the kinds it needs. A payment accepts any signing kind; a classical confidential transfer accepts only Zether kinds, a PQ confidential transfer only a post-quantum signer that carries a PQZ key (CTR-UA-14).
- An encryption key belongs to one UA. A Zether key or a PQZ key is registered under one UA only, multisig included; a second registration of the same key is refused.
What a UA can hold — native accounts, single keys, BLS, n-of-n groups, t-of-n thresholds, multisig, post-quantum and confidential kinds
| Use | Kinds | What it gives |
|---|---|---|
| Native accounts | EVM address, contract account (Safe, SmartKeyAccount), Hedera, Solana, Stellar, Aptos, Sui, Cosmos, GRAM, NEAR, Algorand accounts |
Work as they are; no registration |
| Sign with one key | webauthn-p256 (passkey), p256 (HSM, secure enclave), ed25519, secp256k1, bip340 (Schnorr), schnorr-bn254, schnorr-bls12381 |
Sign from any device or HSM, on any EVM chain, not only with secp256k1 |
| BLS | bls12381-minsig, bls-bn254-minsig |
Short signatures that aggregate; one pairing check on chain |
| n-of-n group | musig2-secp256k1, musig2-bn254 |
Several parties produce one aggregate signature; the registry recomputes the group key |
| t-of-n threshold | frost-secp256k1, frost-bn254 |
Any t of n parties sign; the chain checks one signature; key-generation proofs checked at registration |
| Multisig policy | msig |
A weighted threshold over up to 16 members of any signing kind, or other msigs, two levels only (EVM; other families in their own rounds) — e.g. two passkeys plus an HSM, or a director's passkey plus a company EOA |
| Post-quantum signing | mldsa44, mldsa65, fndsa512 (Falcon), slhdsa128s (hash-based) |
Authorization that survives a quantum computer; such a UA (or a multisig whose non-PQ members' weight stays below the threshold) may carry a PQZ key for PQ confidential balances; slhdsa128s signs but is not a direct holder of one |
| Classical confidential balances | zether-bls12381 |
The Zether key is itself the UA: it signs every write by Schnorr with its secret x, and its Zether proof alone authorizes a spend; its public and confidential balances share one id |
Threshold ECDSA from MPC custody providers needs no kind of its own: its output is an ordinary ECDSA signature, so it is a plain EVM address.
Ways to use it: sign alone (one key); sign together (msig, weighted); aggregate (MuSig2, BLS); share a key by
threshold (FROST); hold a confidential balance (a Zether key UA, or a PQ signer with a PQZ key); and, optionally,
attach verifiable credentials (eKYC) to any account, native or derived — never mandatory, and never parsed on chain
(credentials).
Rotation and recovery. A UA is its key data, so a new key is a new UA and funds move to it. Users who need a stable
address across key changes, guardian recovery, or compatibility with contracts that only understand addresses use the
optional smart account SmartKeyAccount — itself a native contract UA
(CTR-ACC-09).
Status, per family. EVM: the UA registry is BUILT and deployed on the SCaaS testnet (signing, BLS, group, threshold, multisig,
post-quantum and Zether kinds), with the UA ledger in the token base, UA receivers and wrap and UA
trade orders. The identity rule above (owner, 2026-10-20, CTR-UA-30) is built: a PQZ key is carried by the PQ signer, the Zether authRef is gone and the bn254 Zether line is in legacy/
(function → kinds). Hedera runs the same code. Soroban: registry and ledger BUILT on a local network. NEAR and Algorand: a UA ledger and lazily opened records BUILT, no registry, their UA rounds open, each on its own. Cosmos, Aptos, Sui, GRAM and Solana: base contracts only, no UA yet.
A meta-transaction separates who authorizes an operation from who submits and pays for it. SCaaS puts it inside the contract itself, following the design of EIP-1776 (native meta-transactions with a fee paid in the token to whoever submits). EIP-1776 never became a final standard; SCaaS uses its design deliberately, instead of ERC-2771 forwarders or ERC-4337 bundlers (NET-ALL-02).
Why it matters:
- No native coin needed. Users hold only the token they use; a relayer pays the gas.
- Asynchronous by design. A signed intent is a self-contained, expiring authorization. It can be carried by QR code, message or file, and executed by any relayer — or by the payee — until it expires.
- No head-of-line blocking. Nonces are two-dimensional (
batch,nonce): independent operations use different lanes (a payment's lane is derived from its random reference), dependent steps share one lane in order. - Any function of any SCaaS contract, gasless. Not only token transfers: a contract that keeps a family tree, a
mandate wallet or a token all accept a signed call of one of their own allowlisted functions —
addPerson,wrap,unwrap,burn…mtxExecutelets the contract call itself with the signer's calldata; it never calls another contract on the signer's behalf: no forwarder. A token transfer is a special case with its own typed struct, so wallets show the amount and the recipient. - All or nothing. The call and the fee succeed together or revert together: the user never pays for an operation that did not happen, and no failure is swallowed.
- Readable signatures. EIP-712 typed data: the wallet shows every field instead of 32 opaque bytes.
The signed structures on EVM (docs/contracts/metatx.md): MetaTransaction for every
contract and, on tokens only, the typed MetaTransfer (CTR-MTX-23). Both share
the lanes, so one signature spends one lane slot whichever struct carries it. Beside them every operation has a named entry point with its own typed struct and explicit parameters (mtxUnwrap, mtxCancelOrder, mtxConfidentialTransfer*, …; CTR-MTX-28, CTR-MTX-29): the wallet shows the operation's own fields. The generic mtxExecute / mtxBatch / uaExecute / uaBatch stay for a mixed batch or an operation with no named entry, and the node's job API takes the named entries as explicit JSON (job-api.md).
| Field | Purpose |
|---|---|
from |
The subject who signs; the authority the call runs under |
data (MetaTransaction) |
The contract's own allowlisted function to call (its calldata) |
to, value, entryRef (MetaTransfer) |
Recipient, amount, and the payment reference (0 = a plain transfer) |
batch, nonce |
Two-dimensional nonce: the lane, and the sequence inside it |
validUntil |
Every signature expires |
mode |
Relayer and fee-recipient binding, and the fee mode (NONE, PERCENT, FIXED) |
relayer, fee, feeRecipient |
Who may submit (if bound), how much fee, to whom (only tokens charge a fee; other contracts accept fee NONE, and a relay fee pays for such a call, section 9) |
mode decides how open the intent is. With no binding, any relayer may submit and earn the fee — the open
market. With MODE_RESTRICT_RELAYER, only the named relayer may submit — the typical B2B setting with fee = 0.
MODE_RESTRICT_FEE_RECIPIENT fixes who receives the fee whoever submits.
Names. Every entry point a relayer submits on a subject's behalf starts with mtx: mtxExecute (with
executeMetaTransaction kept as an alias, the EIP-1776 name), mtxExecuteTransfer, mtxTransfer, mtxPay, mtxBatch,
mtxBatchTransfer, mtxTrade, mtxExchange…
The signing domain carries chainId, the contract and salt = chain_uid, so a signature is valid on exactly one chain.
One model, not yet one form. On every family a subject signs and a relayer submits from its own account, with the family's own signature formats and replay protection. The forms still differ: MetaOp v1 off the EVM,
one MetaCall and MetaTransfer SPECIFIED (NET-ALL-26, section 3).
Because authorization and payment are separate, SCaaS can offer every reasonable answer to "who pays?". All of them use the same signed intent; only the fee fields and the submitter differ.
Every model in detail — how it works, who bears the cost, status and where to read
| Model | How it works | Who bears the cost | Status |
|---|---|---|---|
| Self-paid | The subject calls the contract from its own account with native coins (always possible; the fallback when no relayer serves it) | Subject | BUILT |
| Sponsored by a company relayer | Subject signs with fee = 0, bound to the company's relayer. Gas is the company's operating cost |
Company | BUILT (portal default) |
| Fee in the token | Subject offers a fee in the token (percentage or fixed, capped at 1 %); any relayer that submits earns it | Subject, in the token it already holds | BUILT |
| Direct settlement (payee self-relay) | The payer signs offline and hands the signature to the payee — QR, NFC, message, file. The payee submits it and pays the gas. The signature works like an expiring electronic cheque | Payee | BUILT on EVM (inbound) |
| Payee fee | The payer signs a payment of N; the payee co-signs a fee authorization from its own balance; one transaction delivers N and pays the relayer |
Payee | BUILT on EVM (mtxPayWithPayeeFee, payee fee) |
| Gas sponsorship policy | A node rule such as "inbound to wallet W, value ≥ X ⇒ accept at fee 0, book the gas to account Y" | The sponsor | SPECIFIED (docs/node/sponsorship.md); an on-chain sponsorship pool is PLANNED |
| Sponsored call of a non-token contract | A service company relays the user's signed call of, say, a family-tree contract and pays the native gas; the contract takes no fee (NONE), the company bills off chain |
The service company | SPECIFIED (CTR-MTX-22) |
| Relay fee | The payer signs a token payment bound to one call that has no fee of its own, on any contract; the relayer pays the gas and receives the token (CTR-MTX-27) | The payer, in a token | BUILT on every family |
| Enterprise inbound gateway | Partners post signed intents to the company's gateway; the company relays them with its own lanes | Company | BUILT on EVM (docs/node/gateway.md) |
The chain's own billing can help too: on chains that bill gas in stablecoins (Gnosis xDAI, Celo fee currencies) or peg fees to USD (Hedera), the relayer's cost is predictable. Confidential (Zether) operations use the same envelope with a public fee taken from the public balance (docs/contracts/zether.md). The break-even of a fee-earning relayer and the B2B default are in docs/architecture.md.
Here liquidity means transaction flow: how many transactions actually happen on the chain, how often and by how many participants. A chain is only as useful as the flow of calls into its contracts. The traditional model throttles that flow at the source; meta-transactions open it up.
flowchart LR
H["Token holders<br/>without native coin"] -->|"sign"| P["Signed intents"]
AG["AI agents and ERPs"] -->|"sign"| P
OFF["Offline payers"] -->|"sign"| P
P --> R1["Relayer A"]
P --> R2["Relayer B"]
P --> R3["Payee"]
R1 -->|"parallel lanes"| C["More transactions<br/>on the chain"]
R2 -->|"parallel lanes"| C
R3 --> C
| What limits the flow today | What meta-transactions change |
|---|---|
| Every user must first buy the chain's native coin; most never do | A user needs only the token it already holds; a relayer pays the gas, so every holder can transact from day one |
| The user must be online, with a funded wallet, at the moment of sending | An intent is signed once and executed later by any relayer or by the payee — offline payments, scheduled steps and AI-agent actions all reach the chain |
| One account = one sequence: transactions queue one by one, and one stuck transaction stops the rest | Two-dimensional nonces: independent operations run in parallel lanes; a relayer spreads work over many lane accounts |
| Small transactions are not worth a user's own gas | Sponsored (fee 0) and fee-in-token models make micro-payments, loyalty points and B2B line items economic |
| Submission depends on one operator | Any relayer may submit; relayers share intents over the mesh and gossip, so more submitters carry more flow |
| Trading needs native gas for every order and cancel | Orders and cancels are signatures in an off-chain book; only matches go on chain, several pairs per transaction on EVM, per family elsewhere (docs/contracts/dex.md) |
| A new venue starts with an empty book | On EVM the same signed order also fills against existing AMMs (Uniswap v2, v3 and v4), through several pools or in a cycle, and any surplus above the signed price goes to the signer (CTR-DEX-20, CTR-DEX-21) |
| Existing tokens were not built for gasless use | A wrapper makes any existing token gasless (docs/contracts/token-wrappers.md), so its holders join the flow too |
The result is more participants, more operations per participant and more parties able to submit them — all under the same contract rules and the same subject signatures.
Anyone can run scaas-node as a relayer, with their own policies. A relayer is a business, not a gatekeeper:
- It cannot forge or change an intent. It can only submit, delay or refuse it. The subject can always go to another relayer, or submit the call itself.
- Each operator sets its own policy: what to accept, what fee to require, what to sponsor, whom to peer with, its own SLOs and monitoring (docs/node/README.md).
- Relayers compete on price and speed. An unbound intent with a fee is open to every relayer; the first to land it earns the fee. Relayers that want the order flow must be cheaper and faster than the others.
- Relayers cooperate through the mesh. Admitted partners share intents over authenticated links with a short, round-robin exclusivity window so they do not race each other wastefully; the open network uses gossip in the style of 0x-mesh — validate before forwarding, any relayer may race to land (docs/node/mesh.md, docs/node/gossip.md). Private chains never leave the admitted set.
- The only reward is the intent's own fee. There is no relayer token, no stake and no protocol subsidy (NODE-MESH-05). A sponsor that wants to pay for others' gas does it by policy or by an opt-in sponsorship contract.
One intent, step by step. The envelope, its signatures and the acceptance checks are BUILT as a library; the bus, gossip and the scheduler that turn them into a network are SPECIFIED (docs/node/mesh.md, docs/node/gossip.md, docs/architecture.md).
sequenceDiagram
participant S as Subject
participant A as Relayer A (origin)
participant B as Relayer B (admitted partner)
participant O as Open relayers (gossip)
participant C as Chain
S->>A: signed intent to the gateway (door A)
A->>A: check it, store it, sign hub.sig with an exclusive window for B (round-robin, about 7 s)
B->>A: pull new intents over the bus (mTLS or QUIC, pinned keys)
B->>B: run the same checks before it stores the intent
opt public chain and the origin opted in
A->>O: publish once on gossip
O->>O: each hop validates before it forwards
end
alt inside the window
B->>C: submit from its own lane and pay the gas
else after the window
O->>C: any eligible relayer may race to land
end
Note over C: the intent's fee goes to whoever landed it
Note over A,O: The others simulate before submitting, see the used nonce and spend nothing. On gossip, a landed hint tells them sooner
The economics are modest by design. A meta-transaction on Gnosis costs about $0.00015 of gas; even at a 10× markup a relayer needs roughly 40,000 transactions a month to cover a small server and an RPC plan. Many relayers will therefore be run by parties with a business reason — the issuer, distributors, partners, the payee — alongside open, fee-earning ones. Both kinds serve the same contracts under the same rules (docs/architecture.md).
On a public chain every amount and balance is visible to competitors. Mixers hide who paid whom, which breaks audit and anti-money-laundering duties. Zether hides the opposite: amounts and balances are encrypted, identities stay visible. Auditors can still see that company A paid company B, and disclosure to the sender, the receiver or a named auditor opens any single transfer.
Warning
Zether and PQ Zether are BUILT on EVM and unaudited. Zether is open on every chain with EIP-2537 once the kind is enabled (owner ruling 2026-10-31), never on Hedera.
PQ Zether needs the PQZ precompile, on the SCaaS testnet today. No other family has either.
| Zether (classical) | PQ Zether | |
|---|---|---|
| Protects | Amounts and balances, against today's attackers | The same, also against a future quantum computer — both reading balances later ("harvest now, decrypt later") and forging proofs to mint |
| Encryption | ElGamal on BLS12-381 | Module-lattice (LWE) encryption |
| Proofs | Σ-protocol + two Bulletproofs range proofs | One lattice proof (LNP22) per operation, verified by a native precompile |
| Authorization | The Zether key UA itself (Schnorr by x, the proof authorizes a spend) |
The post-quantum signing UA that carries the PQZ key: ML-DSA-65 by default, or a multisig whose non-PQ weight is below the threshold (CTR-UA-30) |
| Gas per transfer | ≈ 3.3 M (measured) | ≈ 2.8 M (estimate; calldata-bound, ≈ 77 KB per transfer) |
| Gasless | Yes — IERC20MetaTx envelope, public fee |
Yes — the same envelope, plus a post-quantum payer |
| Where | Every EVM chain with EIP-2537 (BLS12-381), kind enabled per chain (owner ruling 2026-10-31); never on Hedera | Any chain whose PQZ precompile passes the self-test (today the SCaaS testnet; no chain-id lock, owner ruling 2026-10-31) |
| Status | BUILT, unaudited | BUILT, unaudited, on the SCaaS testnet |
Read more: docs/contracts/zether.md, docs/contracts/pq-zero-knowledge.md, docs/contracts/accounts.md.
SCaaS groups chains into eight families (the owner's taxonomy, docs/networks/README.md): one contract code base per family, with one node adapter per chain kind (Move has one for Aptos and one for Sui; Hedera has its own beside the EVM's).
| Family | Chains | Execution | How the meta-transaction is done |
|---|---|---|---|
| EVM | SCaaS testnet; draft profiles Gnosis, Celo, BSC, Polygon, Base; Hedera; TRON planned | EVM (Solidity) | EIP-712 intent inside the token |
| Cosmos | CosmWasm chains | CosmWasm (Rust) | Relay{payload, auth} to the contract |
| Soroban | Stellar, Pi Network | Soroban WASM (Rust) | native authorization entries |
| Move | Aptos, Sui | Move VM | an account object per subject, lanes inside |
| GRAM (formerly TON) | GRAM | TVM (Tact) | a custom jetton wallet checks the signed operation |
| Solana | Solana | SVM (Rust) | program-level, subject account + lane accounts |
| NEAR | NEAR | WASM (Rust, near-sdk) | MetaOp v1 in Borsh, checked by the NEP-141 token against SCaaS key records |
| Algorand | Algorand | AVM (Algorand Python) | MetaOp v1 in ARC-4, ARC-200 in boxes, one shared account app |
Other EVM chains can be added as profiles. Finality, signing domains, passkeys and the availability of each feature per family: docs/networks/README.md. Every contract an EVM deploy leaves on a remote chain is source-verified on that chain's explorer (Blockscout, Etherscan v2 or Sourcify; NET-EVM-12).
Deployment shapes: public chains (your relayer, partners' and open relayers serve the same contracts); a private or permissioned chain (your nodes and admitted peers only); a consortium (each member runs a node) (docs/architecture.md).
The overview figure at the top of this page shows how the parts connect: clients sign, relayers submit and pay gas, contracts run on the chains. Finalized events travel back the same way: the node indexes the chain, waits for finality and serves the result to clients as feeds.
| Component | What it is | Read |
|---|---|---|
| Docs map | Reading order, precedence, status tags | docs/README.md |
| Product overview | Who SCaaS is for, what it offers | docs/README.md |
| Architecture | Authority, service and trust models, topology, economics, glossary | docs/architecture.md |
| Smart contracts | Meta-transactions, tokens and wrappers, accounts and mandates, DEX, tender, asset suite, Zether, PQ Zether, Universal Account | docs/contracts/README.md |
| Node | Relayer and indexer: job API, gateway, submit lanes, finality-gated feeds, admin, sponsorship, DEX venue, mesh, gossip, operations | docs/node/README.md |
| Networks | The common model and one page per family | docs/networks/README.md |
| Clients | Passkey and seed-vault signers, wallet connectors, console and dApp | docs/clients/signers-clientkeys.md, docs/clients/app.md |
| Integration | How an ERP or back office uses SCaaS: outbox, push and sync, references, reconciliation | docs/integration.md |
| Decisions | Every rule's id, reason and cost if wrong; old-id aliases | docs/decisions.md |
| History | Frozen designs and the original requirements note with its trace | docs/history/README.md |
Where to start, by role:
- Integrating an ERP → docs/integration.md
- Running a node → docs/node/README.md, then docs/node/runbooks.md
- Building a wallet or app → docs/clients/
- Reviewing contracts → docs/contracts/README.md and your chain's page under docs/networks/
Note
Every section of the component docs is tagged BUILT (code with tests), SPECIFIED (rules fixed, code pending) or PLANNED (direction only).
SCaaS did not start from a blank page. Two early prototypes shaped it: a wrapped ERC-20 with meta-transactions, then the ERC1776 token family with tradable tokens and a DEX. Most of their ideas survive; some were changed once they proved unsafe.
flowchart LR
P1["Prototype 1<br/>wrapped ERC-20<br/>with meta-transactions"] --> P2["Prototype 2<br/>ERC1776 family<br/>tradable tokens, DEX"]
P2 --> NOW["SCaaS today<br/>contracts as API services"]
Idea by idea — prototype 1, prototype 2 and today, side by side
| Idea | Prototype 1: wrapped ERC-20 | Prototype 2: ERC1776 family | Today |
|---|---|---|---|
| Meta-transaction inside the token | executeMetaTransaction, mtxTransfer; one nonce per account; chain id and token address signed |
mtxTransfer with a two-dimensional nonce (batch, nonce), validUntil, a bound relayer or any relayer (address(0)) |
A pinned EIP-712 MetaTransaction for a call of any allowlisted function of any SCaaS contract, plus a typed MetaTransfer on tokens: lanes and nonces, expiry, mode flags; chain and contract in the domain (section 8) |
| Signature format | EIP-712 typed data | Ethereum signed-message prefix | EIP-712 only, low-s, ERC-1271 for contract accounts |
| Fees | The sender chooses the fee amount and its recipient, both signed, at most 1 % of the amount | A fee in parts per million inside each trade order | Fee modes NONE / PERCENT / FIXED, capped at 1 %, recipient optionally bound (section 9) |
| Payment reference | mtxPay with a sender-chosen payId and a Payment event |
— | pay(entryRef) emits PaymentSettled; a random entryRef also picks the lane, which makes each payment pay-once |
| Wrappers | No underlying, one underlying at a numerator/denominator rate, several underlyings with a rate each | — | The same shapes as two kinds (NormalToken, WrappedToken with 1–8 legs) with fixed or adjustable rates; basket legs fixed at creation; optional confidential variants (*_ZETHER, *_PQZ) |
| Factory | A factory with new, one wrapper per underlying |
— | An open factory of immutable EIP-1167 clones and a version catalogue |
| Code reuse | Every wrapper deployed with its full code | — | The requirements note asked to "share code through delegation, keep separate data, support several versions": clones DELEGATECALL one fixed implementation per version (section 5) |
approve |
Only contracts may call approve (code-size check) |
The same rule, also on the NFT | Only a contract may call approve, decided by explicit rules instead of a code-size guess (CTR-TOK-01) |
| Trading | — | ERC1776Tradeable + Dex: one taker against several makers, partial fills, refunds of the unmatched part, at least 50 % of the wanted amount, a fee per side |
TradeOrder (the old MtxTradeOrder fields) pulled only into the named DEX; one taker against many makers per call, resting orders filled in parts or immediate orders refunded; a 50 % minimum fill; the same orders fill against AMMs through mtxExchange (section 3) |
| A contract receiving tokens | — | ERC1776Holder pulls a signed transfer into itself |
Any contract can be the recipient of a signed pay or transfer |
| NFTs | — | ERC1776Nft721: safeTransferFrom by meta-transaction |
PLANNED with the asset suite (asset-suite) |
| Admin powers | An Ownable owner per wrapper |
ERC1776Adminable (an admin moves its own tokens by signature), Rescuable (an owner or rescuer withdraws stuck tokens) |
No one can move a user's funds; only bounded powers chosen at creation (section 4) |
| Upgrades | — | — | Immutable at deploy (section 5) |
Lessons that changed the design:
- Executing signed calldata is right; calling out is wrong. The first prototype forwarded signed calldata to
another contract, which then saw the token as
msg.sender, so a signedtransfermoved the token's own balance. The fix is not to give up generic execution but to keep it inside:mtxExecutecalls the token itself, with the signer carried in transient storage, on a fixed allowlist (docs/contracts/metatx.md). - A meta-transaction shaped like a token transfer is too narrow.
toandvaluemeant nothing for a call such as "add a person to a family tree", and a contract without a balance could not even take the fee. The signed call is now generic (MetaTransaction, any SCaaS contract), and a transfer is its typed special case (MetaTransfer) (CTR-MTX-22). - One nonce per account is a queue. A single stuck signature blocks every later one. Two-dimensional nonces came in with the second prototype and are now the rule on every family (NET-ALL-02).
- Guessing "is this an ordinary account?" from code size fails: a contract under construction has no code yet, and an account delegated with EIP-7702 has a few bytes of code but is still a key holder. The contract-only spender rule now names each case and its treatment; since the 2026-10-30 rulings a 7702 account signs by its own key only and cannot call SCaaS directly while delegated (CTR-UA-24).
- A signed-message prefix shows 32 opaque bytes to the user. EIP-712 shows every field.
- An owner on every token is an admin key over balances. Prototype owners, admin moves and rescue functions are gone. A wrapper owned by its factory could not even be configured. A token's owner is optional and bounded, and flags can only be cleared (section 4).
- A basket wrapper whose owner can add underlyings at will can be drained by adding a weak one and unwrapping into the strong ones. Today the legs and their initial rates are fixed at creation, each unwrap is bounded by that leg's own reserve, and a guardian can only stop inflow into a depegged leg (token-wrappers).
Top-level folders — smartcontracts/, scaas-node/, pqz-core/, clients/, docs/, scripts/
| Path | What |
|---|---|
smartcontracts/ |
On-chain code by family: evm/ (Foundry; Gnosis, Celo, private chain, Hedera), move/{aptos,sui}, soroban/, cosmos/, ton/ (GRAM, formerly TON), solana/, near/, algorand/, vectors/; scripts/{build,test,deploy,devnet}.sh <family>. See smartcontracts/README.md, smartcontracts/evm/README.md and docs/contracts/ |
scaas-node/ |
Rust relayer node: gateway, submit lanes, indexer, admin, mesh. See scaas-node/README.md and docs/node/ |
clients/ |
Everything that runs on the user's side: clientkeys/ (browser signers: passkey, seed vault, Zether keys; signers-clientkeys.md), zether-prover/ (Rust/WASM prover for Zether proofs, balance reading and disclosure; zether.md), and the Universal Account identity libraries ua-rs/ (Rust), ua-c/ (C), ua-cxx/ (C++), ua-qt/ (QML), ua-dart-frb/ (Dart over Rust), ua-py/, ua-go/, ua-cs/ (C#) and ua-dart/ (pure Dart) (ua-libraries.md). The console and dApp app/ (React + Vite) is planned (app.md) |
pqz-core/ |
The post-quantum proof engine: pqzl, pqzh, the statements, the FFI and the node plugin. See pqz-core/README.md |
docs/ |
Product docs — start at docs/README.md. Check: python3 scripts/docs_check.py check |
scripts/ |
capped: run a heavy build in a 4 GB systemd scope, two at a time machine-wide; docs_check.py: the docs checker; size_gate.py: the contract size gate |
SCaaS depends on no ERP. One worked ERP connector lives in a separate repository and is described as an example in docs/integration-odoo-example.md.
What people can build by combining SCaaS contracts with meta-transactions, in eight groups. Each row names the parts it uses, who can pay the fee and the status. BUILT, SPECIFIED and PLANNED are the docs' own tags; NOT SPECIFIED means no SCaaS doc covers the use case yet: it is an idea the parts could support, not a feature.
Who can pay the fee names the realistic payers of the gas in each case, using the models of
section 9; most cases allow more than one. Tokens can take the fee in the token
itself; contracts outside the token set (MandateWallet, SmartKeyAccount, a registry on MetaTxBase) take no fee
on chain, so whoever relays their calls pays the gas and bills off chain, if at all
(CTR-MTX-22).
Templates. Every use case, commercial contracts included (escrow with an arbiter, milestone service contracts,
sale with delivery, leases, installment loans, subscriptions, revenue sharing), is meant to ship as a template: an
implementation deployed once per chain, from which anyone creates an instance with their own parameters as an
EIP-1167 clone at a CREATE2 address through a factory, then uses it by meta-transaction — the pattern of today's
OpenFactory.createToken and createDex (factory,
CTR-DEX-24). Off-chain presets are only parameter sets for those factories
(CTR-AS-14). A template library beyond tokens and the DEX is PLANNED
(owner, 2026-10-12).
a) Retail and loyalty — loyalty and cashback, prepaid points, game points, item and credit conversion recipes, membership cards, prepaid service passes, point exchange
| Use case | How SCaaS maps it | Who can pay the fee | Status |
|---|---|---|---|
| Loyalty and cashback for supermarkets and store chains | The chain issues points as a NORMAL token with its own minter (loyalty template). Members receive and spend points without holding any native coin; the store's relayer pays the gas at fee 0, and one atomic mtxBatchTransfer carries many signed credits (CTR-MTX-24). Campaign payouts as a Distribution are specified |
The store's relayer at fee 0; or the member, as a fee in points | BUILT; Distribution SPECIFIED |
| Prepaid points (PPP, like gift-card points) used for payment | A wrapper of a stablecoin at a fixed rate (say 1 USDC → 100 points) is a prepaid point backed by its own reserve (rates). Customers pay merchants with a signed mtxPay that carries the payment reference (section 8). The voucher template, where expiry is the end of a closable redemption offer, is specified (templates) |
The merchant (payee fee, or it submits the customer's signed payment itself); the issuer's relayer at fee 0; or the customer, in points | BUILT; voucher redemption SPECIFIED |
| Virtual points in games | In-game points are a NORMAL token minted by the game's own contract or treasury; players sign gasless and the game's relayer pays the gas. In-game items as NFTs (ERC-721/1155 with meta-transactions) are planned (asset suite) |
The game's relayer at fee 0; or the player, in points | BUILT (points); NFTs PLANNED |
| Item and credit economies: conversion recipes that burn some tokens and mint others (games, stamps, bundles; no NFTs needed) | Every kind of item or credit is its own decimals 0 NORMAL token, and one unit is one item: a holder's inventory is simply its balances. A recipe burns given amounts of some tokens and mints given amounts of others — in general m·X + n·Y + … → k·Z (+ l·W …), any number of inputs and outputs — and recipes compose into a multi-level graph: an output of one recipe is an input of the next, so tiers chain (in a game: 3 stone axes → 1 iron axe, then iron axe + 2 iron ingots → steel axe; or wood + ore → tool → better tool). The same shape covers merging (many low-value units into one of higher value), splitting (a bundle into single units, a large voucher into small ones), plain exchanges between kinds, and uses outside games (10 stamps → 1 reward, a season pass → its single visits). Optional conditions fit it too: a catalyst that must be held but is not burned, a random output, cooldowns, per-holder limits, an expiry. Because any token in the graph can be both produced and consumed, every token of the set is created with both MINTABLE and BURNABLE, and the recipe contract the operator deploys holds the minter role on all of them (the role is a set: the game server or shop can hold it too); a conversion takes the holder's signed transfers of the inputs, burns them and mints the outputs in one transaction — whole or not at all, several recipe steps in a row included — and the recipe table it enforces is public. The table must be checked for loops that create value from nothing (X → Y → X ending with more X than it started with); the contract can refuse such tables by requiring the recipe graph to be acyclic or value-weighted. Holders trade or swap items on a SCaaSDex market or by direct signed transfers, without native coin. Units of one kind are interchangeable; an item that needs its own identity or stats (a numbered or worn sword) needs an NFT, which is PLANNED. The recipe contract and its recipe format are not specified; a step-by-step guide for game builders is docs/guides/item-economies.md |
The operator's relayer at fee 0; or the holder, as a fee in one of the tokens; DEX trades: the trader's signed order fee | Tokens with mint and burn BUILT; DEX BUILT on EVM; recipe contract NOT SPECIFIED; NFTs PLANNED |
| Membership cards and event tickets | A card or ticket is a decimals 0 token the organizer mints; at the door the holder's passkey (a SmartKeyAccount key) can sign a transfer of the ticket back to the organizer, and the gate submits it. Limiting who may receive a card needs the receiver allowlist of the regulated flags (regulated controls); fully non-transferable tokens and NFTs are not available, and no ticketing flow is specified |
The organizer: its relayer at fee 0, or the gate submitting the holder's signed check-in | Tokens and SmartKeyAccount BUILT; allowlist SPECIFIED; NFTs PLANNED; ticketing NOT SPECIFIED |
| Prepaid service passes: one token = one visit, session or ride (spa, gym, car wash, lessons, laundry, parking, punch cards) | A business sells packages up front, off chain or for a stablecoin by mtxPay, and mints the visits as a decimals 0 NORMAL token: say a spa issues 100 tokens to 10 customers who bought 10 sessions each. A customer redeems a session by signing a transfer of 1 token back to the business, for example with a passkey at the counter, and the counter submits it; the customer can also give or sell unused sessions to someone else by an ordinary signed transfer. Everyone sees, at any time, how many sessions each holder has left and how many the business has outstanding. An expiry is the end of a closable redemption offer (templates); passes that may not change hands need the receiver allowlist (regulated controls); a Zether or PQ Zether token hides how many sessions someone holds. Booking, refunds of unused sessions and the business's own terms stay off chain and are not specified |
The business: its relayer at fee 0, or the counter submitting the customer's signed redemption; a gift between customers: the giver, as a fee in tokens, or the business's relayer | Tokens, meta-transactions and SmartKeyAccount BUILT; expiry and allowlist SPECIFIED; booking and refund flow NOT SPECIFIED |
| Cross-brand point exchange | Each brand's points trade on a SCaaSDex market that the DEX operator lists; members sign orders gaslessly, with no allowance, and the same orders can fill against Uniswap pools (dex). The rate is the book's price; a fixed-rate agreement between brands is not specified |
Each trader, as its signed order fee (≤ 1 %, from what it receives); or fee 0 on a brand's own venue | BUILT on EVM |
b) Payments and collections — payroll, direct debit, deposit with periodic withdrawal, split settlement, cross-border payment
| Use case | How SCaaS maps it | Who can pay the fee | Status |
|---|---|---|---|
| Payroll and commissions in batches | The employer signs one payment per payee, each with its own entryRef, and a relayer lands the run in one atomic mtxBatchTransfer (CTR-MTX-24). Every item carries its own signature; a SmartKeyAccount payer covers the whole run with one signature over a Merkle root of the digests (CTR-ACC-02) |
The employer: its relayer at fee 0, or self-paid | BUILT |
| Recurring collection and direct debit (utilities, tuition, subscriptions) | The payer deposits into its MandateWallet and makes the biller the delegate, with the biller's account as payee, per-payment and per-period caps and an expiry; the biller signs each payUnderMandate with its own entryRef, and the payer can revoke at any time (mandates) |
The biller's relayer (the wallet takes no fee on chain); or the payer, self-paid | BUILT |
| Deposit, then withdraw a fixed amount per period (allowance, pension-like payout, savings plan, vesting, subscription budget) | Two parts fit. A VestingGrant is one funded contract per grant whose linear schedule with a step interval (or up to 16 tranches) releases a fixed amount per interval; anyone may call release(), which pays only the beneficiary, and the grantor can take back the unvested part only if the grant was made revocable (CTR-AS-10). A MandateWallet is the revocable variant: the owner deposits, and a delegate (who may pay to its own address if the owner approves it as payee) pays up to maxPerPeriod per period until an expiry; unused budget does not carry over, and the owner can revoke or pay out by hand at any time (mandates). An open-ended plan topped up over time is not specified |
Grant: whoever calls release() — the grantor's relayer, any relayer or the beneficiary. Mandate: the delegate's or payee's relayer, or the owner, self-paid |
MandateWallet BUILT; VestingGrant SPECIFIED; open-ended plan NOT SPECIFIED |
| Pocket money and household spending | A parent funds a MandateWallet per child and makes the child's key its delegate, with a weekly cap, a per-payment cap and payees limited to approved shops; the parent can revoke at any time (mandates) |
The shop, submitting the child's signed payment; or the parent's relayer | BUILT |
| Multi-party split settlement (marketplace, food delivery, tax remittance to the state) | The buyer signs one payment per party — seller, rider, platform, tax authority — each with its own entryRef, and a relayer lands them in one atomic mtxBatchTransfer, so all parts settle or none (CTR-MTX-24). Computing the shares or the tax, enforcing the split and reconciling with the authority are not specified |
The platform's relayer at fee 0; or the buyer, as a fee in the token | Batch BUILT; split and tax rules NOT SPECIFIED |
| Sales: the seller pays the fee to receive a CBDC or stablecoin | Payee fee: the buyer signs a payment of N, the seller co-signs a fee from its own balance, and one transaction delivers N and pays the relayer (payee fee). Or the seller submits the buyer's signed payment itself and pays the gas. A stablecoin takes part through a SCaaS wrapper; a CBDC token needs the regulated flags |
The seller: payee fee, or payee self-relay | BUILT on EVM; CBDC token SPECIFIED |
| Cross-border buying, selling and payment through licensed deposit and withdrawal gateways | The parts: 1:1 stablecoin wrappers that holders wrap and unwrap against the reserve (token-wrappers), gasless payments with references, and an enterprise inbound gateway a licensed company can run (gateway). The bank side — deposits, withdrawals, licensing and customer checks — is not specified | The licensed company (gateway, fee 0); or the customer, as a fee in the wrapper token | NOT SPECIFIED (parts BUILT) |
| Micro-insurance payouts and social benefits | An insurer or agency pays claims or benefits in a mtxBatchTransfer to people who hold only a passkey: a SmartKeyAccount with P-256 passkeys and guardian recovery, or a webauthn-p256 UA on the UA ledger (accounts). Recipients spend without native coin. Claim, eligibility and payout rules are not specified |
The insurer or agency, at fee 0; when recipients spend: the merchant, or a fee in the token | Batch, SmartKeyAccount and passkey UA BUILT on EVM; claim rules NOT SPECIFIED |
c) Commercial contracts — escrow and deposits, milestone services, sales with delivery, leases, installment loans
| Use case | How SCaaS maps it | Who can pay the fee | Status |
|---|---|---|---|
| Escrow and deposits (rent, car rental, bookings) | Holding a deposit and releasing it to either side, by both parties or an arbiter, needs an escrow contract; none is specified, and the asset suite leaves escrow with an arbiter out of its scope (scope). The parts: the deposit is a signed payment with a reference, and the contract would be a MetaTxBase contract like the mandate wallet (CTR-MTX-22) |
The landlord or rental company's relayer; or the depositor, as a fee in the token | NOT SPECIFIED (parts BUILT) |
| Milestone service contracts, sale with delivery, leases, installment loans, revenue sharing | Parts exist: tranches released by an approver (a milestone VestingGrant), installments and subscriptions by mandate, revenue shares as a Distribution to holders of a share token (asset suite). No contract or template for any of them is specified |
The party that relays — usually the seller, lessor or lender, at fee 0; payers may add a fee in the token | Mandates BUILT; VestingGrant, Distribution SPECIFIED; the contracts NOT SPECIFIED |
d) Accounts and authority — passkey accounts, multi-signature approval, AI agents under a mandate
| Use case | How SCaaS maps it | Who can pay the fee | Status |
|---|---|---|---|
| Passwordless accounts that survive a lost device | A SmartKeyAccount holds WebAuthn P-256 passkeys beside secp256k1 keys; when a device is lost, the guardian adds a new key after a 2-day delay that any existing key can cancel (CTR-ACC-03). A passkey can also be a UA on its own (webauthn-p256), but a single-key UA has no recovery: a new key is a new UA; an msig UA over several passkeys, with a threshold below their total weight, survives the loss of one (section 7) |
The service's relayer (account calls take no fee on chain); for payments: the user in the token, or the payee | SmartKeyAccount, passkey and msig UAs BUILT on EVM |
| Multi-signature spending approval for a company | Large payments need a quorum: an msig UA (a weighted threshold over up to 16 members of any signing kind) or a FROST t-of-n / MuSig2 n-of-n group key whose one signature the chain checks once; a Safe already signs through ERC-1271. Small everyday spends go through a MandateWallet delegate within its caps (mandates) |
The company's relayer at fee 0; or self-paid | Safe, mandates, msig, FROST and MuSig2 UAs BUILT on EVM |
| AI agents spending on a user's behalf | The agent holds the delegate key of the user's MandateWallet: it pays only approved payees, within per-payment and per-period caps, until the expiry, and the user revokes at once. Several delegates per token, per-payee caps, a co-sign threshold and an MCP adapter are a research direction only (node-ai-agents) |
The merchant or the agent platform's relayer; or the owner, self-paid | MandateWallet BUILT; agent features NOT SPECIFIED (research) |
e) Business and supply chain — invoice finance, confidential payroll, hidden-amount tenders, enterprise relayers
| Use case | How SCaaS maps it | Who can pay the fee | Status |
|---|---|---|---|
| Supply-chain finance (invoice tokens) | A receivable becomes a token whose units are the invoice's face value; the supplier sells it to financiers at a discount on a listed SCaaSDex market, and at the due date the buyer redeems it at face, for example through a redemption ExchangeOffer like a bond's, funded on time from its MandateWallet (dex, templates). Invoice checks, double financing and the redemption contract terms are not specified |
Traders: the signed order fee (≤ 1 %); redemption: the buyer's or the financier's relayer | DEX and mandates BUILT; ExchangeOffer SPECIFIED; invoice financing NOT SPECIFIED |
| Confidential payroll with Zether | Salaries move as Zether transfers, so amounts are encrypted while payer and payees stay visible; one multi-recipient transfer pays several employees (multi-recipient). A token created with an auditor key also encrypts every amount to the auditor, and sender or receiver can disclose single transfers (auditor mode, disclosure) | The employer's relayer at fee 0; or a public fee from the employer's public balance | BUILT, unaudited; PQ Zether BUILT, unaudited, on the SCaaS testnet |
| Contract tenders with hidden amounts (Zether / PQ Zether) | SealedBidTender keeps every bid a salted commitment, bonded by a deposit, until the deadline; bids are revealed afterwards and honest losers' deposits return without anyone's approval (tender). Bids that stay hidden after the reveal, with Zether or PQ Zether deposits, are outside the tender's scope |
The buyer's relayer or a sponsor (sponsorship policy, SPECIFIED); or a bidder submitting its own commit and reveal | SPECIFIED (sealed until reveal); confidential bids NOT SPECIFIED |
| Enterprises running their own relayer | A company runs scaas-node: partners post signed intents to its gateway and it relays them on its own lanes (gateway); it pays gas for its own customers at fee 0 or by a sponsorship policy (sponsorship); the relayers of a business group exchange intents over the mesh's pull bus (mesh) |
The company (gateway at fee 0, or a sponsorship policy); partners may add a fee in the token | Gateway BUILT on EVM; sponsorship policy SPECIFIED; mesh envelope BUILT, bus SPECIFIED |
f) Assets and investment — shares and bonds, pooled funds, tokenized real-world assets, decentralized trading
| Use case | How SCaaS maps it | Who can pay the fee | Status |
|---|---|---|---|
| Issuing shares and bonds on chain, public or private | Equity and bond templates: a token with the regulated flags, eligibility in a ComplianceRegistry, dividends and coupons as a Distribution, redemption at maturity as an ExchangeOffer, trading on a managed DEX market (templates). A private chain keeps intents among admitted nodes (profiles) |
The issuer's relayer at fee 0; trades on a managed market carry no relayer fee on regulated legs, so the venue pays (managed markets) | SPECIFIED |
| Pooled investment funds and capital contributions | Members contribute stablecoins and receive fund units (the equity template covers units of a fund); profits go out as a Distribution, and an exit is a buyback ExchangeOffer of units for stablecoins (templates). Contribution terms, valuation and the fund's governance are not specified |
The fund manager's relayer at fee 0; or members, as a fee in the token | SPECIFIED; fund rules NOT SPECIFIED |
| Tokenized real-world assets (fractional real estate, gold, warehoused produce) | Fractions are a token the issuer mints, with the regulated flags and eligibility where the law requires them (regulated controls); an asset already tokenized on chain (a gold token, say) can be wrapped in a reserve-backed SCaaS wrapper, gasless and redeemable from a reserve anyone can read (token-wrappers). Custody of the physical asset, appraisal and legal title are off chain and not specified | The issuer's relayer at fee 0; or holders, as a fee in the token | Tokens and wrappers BUILT; regulated flags SPECIFIED; custody and title NOT SPECIFIED |
| Decentralized trading of digital assets | Orders and cancels are signatures in the node's off-chain book; SCaaSDex settles one taker against many makers, with no allowance for SCaaS tokens and no gas for traders, and the same orders fill against Uniswap v2, v3 and v4 pools (dex, DEX venue). Book gossip between relayers is specified |
Each trader, as its signed order fee (≤ 1 %, from what it receives), shared with the relayer | BUILT on EVM; book gossip SPECIFIED |
g) Public sector and community — CBDC, public budgets, donations, group funds, voting
| Use case | How SCaaS maps it | Who can pay the fee | Status |
|---|---|---|---|
| A CBDC issued by the state on a public chain, under strict state control | The docs list central-bank digital currency as a use of the regulated flags: freeze, forced transfer against a recorded order, bounded pause and a receiver allowlist, chosen at creation and disclosed, with eligibility in a ComplianceRegistry (permissionless vs controlled, regulated controls). Holders still pay without native coin. Today a token refuses these flags (FeatureNotBuilt) until the asset suite is built |
The central bank's or a bank's relayer at fee 0, or a sponsorship policy (SPECIFIED); the merchant, by payee fee | SPECIFIED |
| Transparent public budget and aid disbursement | Every payment carries a reference and lands on a public chain, so anyone can follow the flows; contracts can be awarded by sealed tender (tender), and recipients spend through a MandateWallet limited to approved payees and per-period caps (mandates). References are random by default; the agency publishes what they mean off chain. Budget rules are not specified |
The agency's relayer at fee 0; suppliers, by submitting payments to themselves | Payments and mandates BUILT; tender SPECIFIED; budget rules NOT SPECIFIED |
| Transparent donations for temples and charities | Donations to a public address and their spending are public flows with references. A donor who wants to hide the amount can give in a Zether token: the amount is encrypted, donor and recipient stay visible (Zether) | The charity's relayer at fee 0; or the donor, as a fee in the token | Payments BUILT; Zether BUILT, unaudited; donation rules NOT SPECIFIED |
| Group fund management | The fund sits in a MandateWallet: delegates pay within per-payment and per-period caps, to approved payees, until an expiry, revocable at any time (mandates). A SmartKeyAccount holds several keys with guardian recovery; a weighted-multisig Universal Account gives one id for a group of keys (accounts). Contribution, voting and pay-out rules of a fund are not specified |
A delegate's or member's relayer (the wallet takes no fee on chain); or self-paid | BUILT on EVM (mandates, smart account, UA multisig); fund rules NOT SPECIFIED |
| Shareholder and member voting | Members sign their votes with their own UA, so anyone can check each vote; records kept for decades can be signed with post-quantum kinds (see the last row). No voting contract, weighting or tally rules are specified | The organizer's relayer (sponsored call, SPECIFIED); or a member, self-paid | NOT SPECIFIED (UA BUILT on EVM) |
h) Data and records — family tree, provenance and traceability, long-lived quantum-resistant records
| Use case | How SCaaS maps it | Who can pay the fee | Status |
|---|---|---|---|
| Family tree (permanently stored data) | A family-tree registry built on MetaTxBase stores every record in full on chain — people, names, dates, relations and their changes — so the tree outlives any company or server. Members sign calls such as addPerson without holding a native coin; a service company relays them, pays the gas and bills off chain (CTR-MTX-22). This use case deliberately departs from the platform's default of no personal data on chain (data protection): what is written can never be erased, and on a public chain anyone can read it, so a deployment needs the consent of the living people it records; a private chain limits who can read the tree |
The service company (sponsored call, SPECIFIED); or a member, self-paid | MetaTxBase BUILT; sponsored call SPECIFIED; the registry itself NOT SPECIFIED |
| Provenance and traceability on a public chain (farm to table, medicines, luxury goods, certificates of origin) | A provenance registry built on MetaTxBase records signed events per batch — harvested, processed, tested, shipped, sold — so a buyer can check a product's history without trusting the brand's server. Producers and inspectors sign gaslessly; the brand or a service company relays and pays (CTR-MTX-22). Product data (batch, origin, test results, certificates) is not personal data and can be stored in full or as hashes of off-chain documents; names of people stay off chain by default (data protection) |
The brand or a service company (sponsored call, SPECIFIED); or a producer, self-paid | MetaTxBase BUILT; sponsored call SPECIFIED; the registry itself NOT SPECIFIED |
| Long-lived, quantum-resistant records | Records that must stay valid for decades (titles, diplomas, contracts, minutes) are signed with post-quantum UA kinds — ML-DSA, or the hash-based SLH-DSA as a backup if lattice assumptions fall — so a future quantum computer cannot forge them (CTR-UA-23). The verifiers are built but unaudited (labelled so; an audit is not a deploy gate, owner 2026-10-31) and costly in Solidity (ML-DSA-44 ≈ 11.4 M gas, measured); the record contract is not specified | The record keeper (sponsored call, SPECIFIED); or the signer, self-paid | PQ verifiers and kinds BUILT on EVM, unaudited; record contract NOT SPECIFIED |
If you find SCaaS useful, you can pay for it. This is not a donation: the developer does not need donations. Pay any amount you want, whenever you want, or not at all.
Free Pay carries no warranty and no obligation, and nothing is bound to it: it buys no support, no rights and no license terms. The license is the same whether you pay or not.
You can Free Pay to Tu Viện Chơn Như (Chơn Như Monastery): https://www.tuvienchonnhu.net/lien-he/.
Or to the developer's EVM wallet: 0x0389f77E846ff687d44db57bcC9DCB55dd6f4131.
SCaaS is licensed under the Vegan Community License 1.0 (summary in Vietnamese: LICENSE.vi.md). Free with the freedoms of MIT or Apache-2.0 for companies whose own revenue is below USD 10 million and for vegan organizations of any size: a company in a sector where animal products are customary (food, food service, cosmetics, fashion, household products, pharmaceuticals, pet food, agriculture) whose products are all vegan, or an animal-protection organization, or a company in any sector whose products, own operations (canteens, events, gifts, procurement) and published policy are all vegan. Not available, at any scale, to a company that kills animals, runs a food business serving products from killed animals, fertilized eggs or bee products, trades in silk, leather or fur products (new or second-hand), processes or finances such products or killing, sells or transports live animals for slaughter, or trades in human-derived products outside donation for medical treatment; nor to a company earning more than 10% of its own revenue from selling, distributing, marketing or transporting such products. Everything applies per company, not to its whole group, and a general-purpose service open to all (running a blockchain, a node or a relayer, hosting) is not excluded because one of its users is; that user stays excluded. Everyone else needs a Vegan Enterprise License (contact ha@dad.vn); the license has the exact terms. Contributions are accepted under the CLA in CONTRIBUTING.md. Third-party components keep their own licenses.
No patents. The authors have filed no patent application on this work and will not file one. It is published as prior art, so that it stays free for everyone to use and nobody can patent it. This covers the authors' own rights only: third-party patents have not been cleared (see G-LIC).