April 8, 2026·6 min read

First Contract on Omne — Here's the Receipt

A real subscription engine, deployed to block 1, for a fee that rounds to zero.

The receipt

{
  "contractAddress": "contract_5e4b50f74b94f16cf857f69c8703f063ba712249",
  "transactionId": "txn_e42bc940bebd2536965be96254c8a77943e9ade985507d1ccdbab8d9bb70ffa9",
  "blockHeight": 1,
  "status": "deployed",
  "wasmBytes": 779,
  "wasmSha256": "17578a1010bcd948ec1855d461ce9597a6d910115d3f296016b0801d41bb2108",
  "gasUsed": 200000,
  "gasPriceQuar": 5000,
  "totalCostQuar": 1000000000,
  "totalCostOMC": "0.000000001",
  "vmTier": "standard"
}

That's block 1 of the Omne Ignis devnet. The first contract deployed on the chain. It manages subscriptions for a content platform — not a demo, not a toy, not a "Hello World."

Total cost: one nano-OMC. At any plausible token valuation, that rounds to zero.

What this contract does

The contract is a subscription manager for a content platform being built on Omne. It exposes three functions:

subscribe(address, plan_id, start_timestamp) — activate a subscription for a user
is_active(address) — check whether a user's subscription is currently active
get_expiry(address) — return the expiration timestamp for a given address

That's it. 779 bytes of WASM. Three functions. Subscription state lives on-chain — not in a database behind an API you don't control.

Why does this matter? Three reasons:

No payment intermediary for the logic. Stripe, Chargebee, and RevenueCat charge 0.5–3% to manage subscription state. On Omne, that state is trustless and free to query.

Portable across front-ends. Any application can call is_active() — the subscription isn't locked to a single server. A third-party reader, a mobile app, a browser extension can all verify access against the same on-chain state.

Verifiable by anyone. The contract WASM is hashed: 17578a1010...2108. Recompile from source and compare. The state transitions are deterministic and auditable.

In the first post on this blog, we made the case that commerce needs sub-3-second finality and sub-cent fees. This post is the receipt.

The math

Gas used:           200,000
Gas price:          5,000 quar/gas
Total cost:         200,000 × 5,000 = 1,000,000,000 quar

1 OMC = 1,000,000,000,000,000,000 quar (10^18)

Deployment cost:    0.000000001 OMC

Here's what that looks like against the chains your team is probably evaluating:

Chain	Contract Deploy Cost	Confirmation	Fee Token
Ethereum L1	$50–$ 200+	12–15s	ETH
Solana	$2–$ 5 (rent + fees)	~400ms	SOL
Base (L2)	$0.10–$ 0.50	~2s	ETH
Polygon PoS	$0.01–$ 0.10	~2s	MATIC
Omne Ignis	< $0.001	~3s	OMC

The fee split is deterministic: 92% to validators, 8% burned. No MEV. No priority fee auctions. No surprise gas spikes.

779 bytes of WASM

The entire subscription contract — subscribe, check active, check expiry — compiles to 779 bytes of WebAssembly.

For context: this paragraph is longer than the contract bytecode. A typical favicon is 1–4 KB. The contract that manages subscription state for a content platform is smaller than a website's tab icon.

This isn't an accident. WASM is structurally more compact than EVM bytecode. A comparable Solidity contract with the same three functions compiles to 3–8 KB of EVM bytecode before optimization. On Ethereum, that size difference translates directly to deployment cost — you pay per byte of calldata stored.

The contract ships with a SHA-256 hash:

17578a1010bcd948ec1855d461ce9597a6d910115d3f296016b0801d41bb2108

Anyone can recompile the source, hash the output, and verify it byte-for-byte. Bytecode-level auditability, no block explorer required.

Verify it yourself

The Ignis devnet RPC is public. No API keys, no waitlists, no Discord role gates.

# Check the chain is alive
curl -s -X POST https://rpc.ignis.omnechain.network \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"omne_blockNumber","params":[],"id":1}' | jq .
# → Returns a block number that increments every 3 seconds

# Check gas price — this is the number that makes the math work
curl -s -X POST https://rpc.ignis.omnechain.network \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"omne_gasPrice","params":[],"id":2}' | jq .
# → { "gasPrice": 5000, "subsidizationActive": true }

# Get test tokens (10 OMC + 5 OGT) — free, 60-second cooldown
curl -s -X POST https://rpc.ignis.omnechain.network \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"faucet_request","params":["omne1_your_address_here"],"id":3}' | jq .
# → { "omcMinted": "10", "ogtMinted": "5", "status": "funded" }

# Check genesis block
curl -s -X POST https://rpc.ignis.omnechain.network \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"omne_getBlockByNumber","params":[1],"id":4}' | jq .
# → Block 1: commerce layer, 3-second cadence

# Call the deployed contract — proves it exists and resolves
curl -s -X POST https://rpc.ignis.omnechain.network \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"omne_call","params":[{"to":"omne15e4b50f74b94f16cf857f69c8703f063ba712249","data":""}],"id":5}' | jq .
# → Resolves the subscribe entry point; returns "expected 3 arguments"
#   (address, plan_id, start_timestamp) — proving the WASM is live and callable

The block number goes up every 3 seconds. The gas price is protocol-defined, not auction-determined. The faucet is free. And you can call deployed contracts directly from the RPC — no SDK required.

Why a content platform put subscriptions on-chain

This project could have used Stripe Billing. The subscription logic is straightforward — activate, check, expire. Any SaaS billing API handles this.

But every SaaS billing API comes with dependencies:

Provider	Cost Model
Stripe Billing	0.5–0.8% of revenue, on top of 2.9% + $0.30 for payment processing
Chargebee	$0.10/subscription/month minimum
RevenueCat	1–2.5% of tracked revenue

These aren't large percentages for a funded startup. But they compound for a content platform with a long tail of micro-subscriptions — $2/month reading passes,$ 5/month creator plans, $0.50 single-article access.

At those price points, the intermediary's cut isn't a rounding error. It's a structural tax on the business model.

Scenario: a marketplace processing 10,000 transactions per day

Chain	Daily Cost	Monthly Cost	Annual Cost
Ethereum L1	$10,000–$ 50,000	$300K–$ 1.5M	$3.6M–$ 18M
Solana	$25–$ 50	$750–$ 1,500	$9K–$ 18K
Base (L2)	$100–$ 500	$3K–$ 15K	$36K–$ 180K
Polygon PoS	$10–$ 100	$300–$ 3K	$3.6K–$ 36K
Omne	< $10	< $300	< $3,600

On Ethereum, your infrastructure cost is a fundraise-sized line item. On Omne, it's a rounding error.

The trade-off is real: you write your own logic and you manage your own state. There's no Stripe Dashboard for on-chain subscriptions. But for teams building fintech-native products — where the payment layer is the product, not a side concern — the economics are a different category entirely.

Why the fees stay low

"Every chain is cheap on devnet. Mainnet is where fees spike."

Fair objection. Here's why Omne's model is structurally different.

Most L1s: Fees are the primary economic feedback mechanism. Demand increases, fees increase. This is Ethereum's design — it manages blockspace scarcity through price. The fee is a feature, not a bug. But it makes the chain unusable for high-volume, low-value commerce.

Omne: Fees are a fixed-cost anti-spam signal. The base fee is protocol-defined, not auction-determined. There is no fee market. Abuse prevention is handled by non-fee controls:

Per-peer and per-account rate limiting
Stake-weighted quality of service
Mempool circuit breakers for congestion shedding
Per-IP RPC throttling

The result: fees stay microscopic regardless of network load. The 8% burn prevents dust-spam. The 92% validator distribution incentivizes node operators. But the fee itself doesn't flex with demand.

This isn't theoretical. The economic model is published in the whitepaper and implemented in the open-source codebase. The dual-token design (OGT governance + OMC utility), the halving schedule, the fee recycling model, and the Omne Operations Network compute subsidy are all documented and auditable.

What's next

This is the second post on this blog. The first laid out why commerce needs its own chain. This one showed the receipt.

Next in the series:

"Your First ORC-20 Token in 5 Minutes" — deploy a fungible token with the SDK
"3-Second Finality at a Point of Sale" — latency benchmarks with video proof
"Store Encrypted Data On-Chain for Under a Cent" — OMP walkthrough with retrieval proof

Each post includes live receipts, working code, and a public RPC you can verify against.

The Ignis devnet RPC is public at https://rpc.ignis.omnechain.network. The SDK is npm install @omne/sdk. The contract from this post is deployed at contract_5e4b50f74b94f16cf857f69c8703f063ba712249. Everything is verifiable. If it isn't, that's a bug — report it.