The owner selects Ethereum, TRON and XLNC as the three launch jurisdictions. A jurisdiction is the blockchain execution field; a stack is a concrete Depository, EntityProvider and its linked contracts inside that field. Each independently governed launch stack has its own EntityProvider Foundation #1 and onchain shares. Companies are ordinary multisig numbered Entities in the existing EntityProvider, with its existing onchain CONTROL/DIVIDEND shares; do not introduce a separate company factory, wrapper token or index product.
XLNC must have four nodes and a 10-fold lower per-block gas limit than Ethereum mainnet. The owner explicitly replaced the earlier 100-fold request with 10-fold after seeing the deployment and dispute gas measurements. The four-validator topology uses the existing Besu/QBFT prototype; four processes on one host are not four independent failure domains. Pin the reference Ethereum block/hash and gas limit in the final network manifest. A 60,000,000 reference gives 6,000,000 gas per XLNC block; this is a reference calculation, not a claim to have sampled a current Ethereum block. Block period and gas price are separate parameters.
Use normal EVM deployment transactions at the selected limit. Genesis contract predeployment, temporary higher limits and splitting disputes across transactions are not the chosen implementation. Measure complete deployment receipts rather than substituting bytecode-deposit lower bounds for actual gas use.
The earlier 600,000 budget could not fit the current contracts: runtime code storage alone costs 3,802,600 gas for EntityProvider, 4,437,000 for Depository and 4,548,400 for Account, before constructor execution and intrinsic gas. These lower bounds do not block deployment at the new 6,000,000 limit.
The existing BatchBoundsTest.test_gas_disputeFinalizeWithMaxProofTokens measured
733,682 execution gas to start and 2,074,972 to finalize a valid 128-token proof,
plus transaction intrinsic gas. This particular shape no longer demonstrates
an impossible fit at 6,000,000. It does not close the more expensive mixed-proof
and correlated-exit gates recorded below. Keep those gates; do not silently
reduce accepted financial proof bounds or change EVM gas pricing.
The focused test/governance/company/MultisigCompany.test.ts contract scenario
proves 2-of-3 registration and onchain share allocation using the existing EP:
registration 246,829 gas, allocation 198,068 gas. It checks treasury issuance,
insufficient signatures, recipient substitution, replay rejection and exact
balances/nonces. This local contract scenario is not a browser journey or proof
that every possible company board fits XLNC.
The previous producer/verifier prototype and measurements below are historical evidence, not compliance with the new four-validator launch target.
The updated xlnc:prototype passed on Besu 25.9.0 with four separate validator
keys, four full-state processes, a static peer mesh, one-second QBFT blocks and
a 6,000,000 block gas limit throughout. Eight contracts deployed by ordinary
transactions; the ninth transaction bound the share Depository. The largest
receipt used 4,971,259 gas (Account); Depository used 4,905,451 gas. Every deployed
contract’s code matched across all four nodes, as did the block hash/state root.
With validator 4 stopped, the remaining three committed a signed transaction;
validator 4 then restarted on its existing database, caught up and matched roots.
All processes were stopped at the end. No public deployment or real funds.
The first run reached deployment/root equality and chain progress during an
outage but exceeded the 60-second stand limit during restart. The correction
starts nodes concurrently with a full static mesh and sets --sync-min-peers=1:
Besu’s default of five sync peers cannot be met by a four-node network. This
setting changes peer discovery/sync startup, not the QBFT signing quorum.
Receipts and roots and
successful stand log preserve the
local evidence. These same-host nodes do not prove independent-operator fault
tolerance. A separate, existing mixed-proof regression remains red:
test_gas_mixedDefensiveFinalizeWithMaxAccountDimensions uses 17,388,717
execution gas to finalize, before intrinsic gas, exceeding both 6M and its 15M
assertion. Failure evidence.
Reproduced on checkpoint a00835725: 96 Account.addDebt calls consume
8,919,840 execution gas (92,915 each), while settlement delta preparation consumes
4,936,366. Debt insertion alone exceeds the selected block budget. This measured
path requires investigation of debt representation and bounded settlement; a
transformer micro-optimization alone cannot close it. No contract behavior changed.
Current decomposition.
The owner-selected 6M limit is unchanged; full financial launch readiness is not claimed and no proof bounds or dispute semantics were weakened.
The owner now explicitly chooses 5,000,000 gas per EVM dispute transaction and admission before signing, superseding the earlier instruction to preserve all independent dimension maxima. This is a gas ceiling, not a fixed ETH fee. The optional 2M target is not selected: adversarial execution below measures 4.45M.
Both TS and Rust charge the same canonical stock proof:
3,000,000 + 200,000*T + 10,000*C + (50,000 + 4,000*T)*K, where T is token rows,
C is live HTLCs + same-J swaps + pulls, and K is the existing proof builder’s
actual clause count. The 3M base reserves permitted 64-KiB starter arguments,
transaction overhead and authentication. A count-only lock estimate failed on
allowance-induced clause splits and was replaced with this canonical plan.
The charge is deterministic admission policy with measured conservative headroom;
it is not an RPC estimate or a mathematical bound for arbitrary programs.
Custom subcontracts without an established execution bound cannot admit new work.
No durable gas counter, alternate proof encoding or removed financial obligation.
Authoritative J claims remain an explicit exception: this admission policy does
not yet prove a universal 5M exit bound after adversarial onchain account growth.
That release gate must be tested and closed before claiming mainnet-wide bounded
exits; rejecting an authenticated chain fact would not solve it.
An over-budget candidate is discarded before signature. Pull registration checks capacity before enqueueing. A cross-j opening already owned by a paired cohort stays deferred if queue ordering exhausts the budget; no single leg is dropped and no over-budget frame is signed. Chain observations and non-growing resolution of existing obligations remain admitted. Old oversized proofs are not rewritten; the 17.39M legacy fixture still requires more than the new RPC ceiling. Deploy this policy with fresh test state, not as a claim that old 17M exits now fit 5M.
Account’s transformer reserve is now min(2M, 100K + 200K*T) instead of a fixed
2M for every Account. The fixed reserve starved valid small proofs in the 5M call.
Reverts, missing code, malformed output and OOG still revert the full finalization.
The old large-proof forwarding allowance is preserved. Runtime bytecode is
22,791 bytes; only Account bytecode changes, all nine artifact ABIs are unchanged.
Generated artifacts and the Account factory were synchronized.
Bytecode comparison.
Verification: 40 Foundry tests across admission, legacy characterization and strict transformer failures; the admission test includes 128 fuzz cases. Every admitted transaction executes under a hard 5M call budget, with conservative nonzero-byte intrinsic gas and the EIP-7623 floor counted as a floor, not double-counted. Named finalizations: 5 tokens / 32 swaps / 18 pulls with a maximal starter payload, 3,907,784 gas; 7 token debts / 32 payments / 2,000 irrelevant secrets, 4,450,683 gas; 10 wide debts with maximal starter payload, 3,482,802 gas. These are local fixture measurements, not a universal claim across future EVM revisions or arbitrary EP boards. TS/Rust admission and actual React/Svelte receipt assertions complement them. Contract evidence, Svelte journey, React journey.
Date: 2026-09-05. Investigated SHA: b97c454d605e750a08da7ff6baab645330175468.
Status: proposal, no change to consensus, network configuration, or capital limits.
Owner scope clarified 2026-09-30: Ethereum, TRON and XLNC are the initial focus;
Base, Arbitrum and additional compatible EVM Js share the same financial model.
H1–H3 and MM are ours first. The earlier $1 000 proposal below is historical;
the later launch design governs the capital ladder.
Name: “limited mainnet / soft mainnet.”
This is a designation of risk scale, not proof of readiness or security.
A block producer is the J node proposing blocks; consensus validators check/vote on those blocks according to the chosen consensus. A verifier checks the accepted history without participating in block production. These roles are separate from Entity hubs, Account parties and their bilateral consensus. The one-producer/separate-verifier artifact below is an experimental starting point, not a decision about the production validator set or consensus engine.
XLNC is pronounced “excellence”. Its purpose is a compact programmable J for reserves, rights and adjudication, with routine economic activity in accounts. The owner selected conventional stateful EVM execution with roughly 10–20 times less block gas capacity. Ordinary activity uses accounts; J serves rebalances and disputes. Expensive ordinary J execution can reinforce this separation.
The proposed design has five requirements:
No ZK execution, stateless client or execution-witness protocol is required. The earlier witness proposal was an auditor suggestion rejected by the owner; it is not the XLNC architecture.
The emergency sizing condition is concrete: remedies due within a protection window must fit its reserved J execution and byte capacity. Account throughput and low average J load do not prove this correlated-exit bound. Measure it at the actual reduced block gas limit before admitting obligations.
This specification remains proposed. The first production artifact is the producer/verifier round trip below; unrelated core recovery work retains priority.
The ordinary stateful Besu 25.9.0 prototype now runs through
bun run xlnc:prototype <output-directory> with XLNC_BESU_BIN and
JAVA_HOME set. It uses Cancun EVM, a 6M block gas limit and one-second
QBFT blocks. This is 10× below the existing local 60M per-block ceiling;
its different block period prevents claiming 10× lower execution per second.
One producer and one full verifier on the same laptop matched the block hash,
state root and all four contract code hashes. Restart preserved the producer
root. Non-dev deployment created no development tokens; a zero EIP-1559
priority fee succeeded. This establishes a working local J prototype, not
production consensus, phone resources, two-day catch-up or correlated exits.
The complete first run produced /tmp/xlnc-stateful-paid-gas-evidence/evidence.json.
Later repeats matched contracts and roots but hit the 60-second stand limit
during node restart; the latest repeat is not green. Owned node process groups
are now terminated on interruption; both repeats with this cleanup left no
running node groups.
Exit capacity is an open release blocker. The cold maximum-token zero-delta vector used 2,046,965 execution gas. A signed mixed proof with 128 tokens, 32 payments, 32 swaps and 18 unrevealed pulls finalized but used 17,363,517 execution gas plus transaction intrinsic gas. Its regression deliberately fails the existing 15M envelope; it also cannot fit 6M. This is one valid expensive shape, not a universal upper bound. Current Account bounds must not be claimed compatible with the reduced ceiling. Changing admission or J capacity requires an owner decision; no contract limits were silently changed.
The htlc-ack-recovery real-RPC scenario separately proves that a late
preimage, withheld upstream ACK and WAL reopen reach an authenticated J dispute.
It uses three real Entity/Account machines and preserves the transport partition.
This verifies dispute start and retained evidence, not collateral payout or
TS/Rust equivalence of this complete recording.
The earlier 0b25d54ca checkpoint failed the English-source gate. At
1d39fe8e6, bun run check passed, frozen core was unchanged, and the canonical
Chromium catalog recorded 138/138 targets with zero skips through catalog runs
and focused reruns. The final rebuilt ScenarioPlayer regression also passed.
See the implementation handoff and its committed evidence.
The earlier manual localhost /app effect_orphan observation remains a separate,
untriaged development observation; it was not reported by those isolated builds.
These results do not close the XLNC exit-capacity or device-resource gates.
| Boundary | Observation in code | Consequence |
|---|---|---|
| J → Entity | Canonical architecture, J machine | External RPC does not become the reducer’s authority; observations go through canonical validation |
| Adapter | JAdapter: rpc, tron, anvil, browservm |
XLNC does not require a new Account/Entity financial path |
| Finality | rpc-finality.ts: Ethereum 12 blocks, other EVM 2 by default | These numbers do not prove consensus finality; Base/XLNC must not be connected with an implicit default |
| Dev networks | chain-ids.ts: 31337/31338 enable dev behavior | XLNC gets its own chain ID, genesis hash, and release manifest; it is not a renamed Anvil |
| Capital | Current policy: riskCapUsd: null, enforcement absent |
$1 000 is currently an owner decision, not a programmatically enforced limit |
The verified production files contain no runnable XLNC validator/fullnode. The old Xlnomy types with EVM-engine names do not prove a network implementation.
Use an existing EVM client and consensus engine, the canonical xln contracts, and a smaller block gas limit. This is the selected architectural direction, not merely a temporary rig. No XLN-only opcode, transaction allowlist, native financial interpreter or special execution-witness protocol is required.
Set the absolute gas limit and block interval in genesis/network rules. Measure execution, state growth and catch-up with the ordinary client. Account activity avoids per-payment J execution; pricing discourages discretionary J transfers. The exact client and production consensus remain choices to resolve against device measurements and independent-operator requirements.
Besu/QBFT is a concrete candidate for the rig: existing PoA and validator-set management. For Byzantine fault tolerance, Besu requires a minimum of four validators. This is not yet the choice of the XLNC engine. QBFT For a mass desktop bundle, Besu has a significant downside: the private-networks documentation states a minimum JVM of about 4 GB depending on the environment. Measure the real budget before choosing; a small J-load does not prove a small client. Besu requirements
UI → local xln Runtime → JAdapter → local XLNC verifier → XLNC peers
↑
separate node process; no validator/private-wallet keys
Show separately: local verification, verified up to block, bootstrap source, lag, independent operators.
If the node has fallen behind, do not silently switch financial authority to a remote RPC. Recovery/synchronization are available; new operations wait for the needed J readiness.
| Threat | Effect of local full verification |
|---|---|
| RPC returns an incorrect balance/log/state | The node rejects invalid history given a correct client and a trusted genesis |
| A single validator censors settlement/dispute | Does not solve this: a valid block may simply not contain our transaction |
| A validator signs two valid histories | Can be detected upon receiving both; a single local verification cannot pick a common order for everyone |
| The node is isolated from honest peers | Rules are checked, but the currency/availability of the history is not guaranteed |
| Malicious update, compromised host, or key | Does not solve this; bundled monoculture increases the overall blast radius |
Design minimum: loopback-only bind; OS IPC with user permissions where supported; otherwise an authenticated loopback endpoint. Check Host/Origin and WebSocket Origin, close wildcard CORS, restrict methods and request size/rate; separate out wallet signing and the validator/admin API. A local port is accessible to other local processes. CORS does not replace authentication. Do not keep an unlocked signing account on an accessible RPC. Geth RPC, Besu RPC authentication Regression goal: a foreign Origin/Host, an unauthorized WS, and an admin method are rejected; the standard UI reads the chain and only submits an already-signed transaction.
XLNC stores J-operations and the necessary evidence; private Account frames and every off-chain hop are not published there. Limit validation cost, block bytes/gas, and state growth. Cheap gas requires protection against disk filling; “free for everyone without limits” is incompatible with a node at every user. Emergency exit requires an available J and inclusion. Do not promise that a local copy automatically withdraws funds when the single validator has stopped.
| Network | Before admitting capital |
|---|---|
| Ethereum | Verified bytecode/address/domain, live J, withdrawal/dispute, explicit finality policy |
| TRON | Real TVM/write/receipt/resource paths and solidified head; Anvil is not evidence |
| Base | Contract artifacts and separate unsafe/safe/finalized observations; two L2 blocks are not L1-finality |
| Arbitrum | Verified deployment and chosen chain’s DA/finality rules; real dispute and withdrawal behavior |
| XLNC experimental | Genesis/rules/validator manifest, full-node verification, real assets and their issuer/backing |
Base ties the finalized L2 head to L1-finality. Financial admission requires consciously choosing a risk level, not a “ready in N seconds” timer. Base derivation Additional networks add corridor pairs and directions; Ethereum/Base and our H1–H3/MM are not independent sources of risk. Base and Arbitrum require their own verified observation, finality, dispute and withdrawal boundaries rather than a presumed generic EVM default. The first exercise is one minimal real round trip on each new boundary with a withdrawal; the full cross-J matrix remains the final gate. Account for liquidity, gas/resource balances, dispute reserve and deployment fees within the admitted capital stage from launch-design.md; the asset limit is separate from the operating-expense limit. Allocate capital using measured deployment costs, required reserves and useful liquidity across the admitted Js. Additional jurisdiction support does not automatically raise capital authorization. An XLNC token named USDT does not become Tether USDT. An explicit issuer/redemption/collateral is needed; a bridge and a wrapped asset are additional risk, not a free integration. Limits must be applied before admitting an obligation, including quotes/lease/credit and crash recovery; a single UI limit is not sufficient. Capital growth only after a measured round trip, reconciliation, and a separate owner decision.
MML is accounts supporting 51% of world GDP made provable by 2050, including activity not individually submitted to J. Payment turnover is separate from GDP coverage. Measure unique completed operations for adoption evidence: one payment once, one exchange without summing both legs, excluding circular relays and tests. The method for attributing GDP coverage remains open. The nearest useful numbers: successful withdrawals, losses/discrepancies, cost of a completed operation, capital tied up, recovery time, and the share of clients that actually verify locally.