Prop firms,
deployed as contracts

A proprietary trading firm sells evaluations: pay a fee, trade to a set of rules, and if you clear them you trade a funded account and keep a share of what you make. The category has a reputation problem, because the operator writing the rules is also the party who pays out, and can change one to avoid the other.

DecentralProp makes the firm a deployment rather than a company. An operator pays a one-time fee and gets branding, a storefront and pricing; every firm then runs on the same three pieces. SimCore fills orders against real live market data while the exposure itself never leaves the simulation, so nothing is ever routed to an exchange. The Autonomous Risk Engine watches each firm's financial health and moves payout speed, evaluation difficulty and leverage on its own, identically for every firm. And settlement is on chain, so a firm's treasury and its trade history are not rows an operator can quietly edit.

Less than you would expect, which is the design. The evaluation rulebook is fixed for every firm on the protocol and cannot be loosened to sell more evaluations:

• 7% profit target to pass an evaluation.
• 10% maximum drawdown, and 5% in any one day.
• Four trading days minimum, so a single lucky session does not pass.
• Leverage is set by the platform and cut by the risk engine under stress. A firm cannot raise it.

What is left to the operator is branding, pricing within a guided range, and which profit split they offer. Results, risk and payouts belong to the protocol.

Most of the protocol was never chain-specific. The engine, the risk engine and the scheduled jobs that police every firm import no chain library at all. A firm deploys against a chain adapter: one object that knows how to open a treasury, price an evaluation, settle a result and deliver a payout on its particular chain. On Solana that adapter wraps five Anchor programs. On DecentralChain it is two RIDE contracts, and nothing above the adapter had to be told the difference.

FirmRegistry holds the shared logic: deploy a firm, purchase an evaluation, commit a settlement root, settle it, queue a payout and deliver it. FirmVault is the per-firm account the money actually sits in. Both are on mainnet, and the sequence that matters ran end to end there: a firm deployed, an evaluation was bought against it, the evaluation settled, and the payout went out through the same multi-way stakeholder split the protocol uses on Solana.

The load-bearing guarantee in the whole design is that a firm's treasury is an account nobody holds the key to. On Solana that falls out of address arithmetic: you derive an address that no private key can produce. DecentralChain has no equivalent, so the port had to reach the same place from the opposite direction.

The vault is given a verifier that always returns false. A key for that account does exist, and it is powerless, because the network rejects every transaction it signs. Money leaves only through the contract's own logic. The guarantee is identical; the mechanism is inverted.

It arrives stronger here than on Solana, for a reason particular to this chain. Changing a contract on DecentralChain requires a transaction sent from that contract's own account, so an account that refuses all of its own transactions can never be re-scripted. Keyless and permanent are the same act. On Solana a program stays upgradeable until someone deliberately gives that up.

The registry keeps its entire state in data entries on its own account, so none of the above has to be taken on this page's word. No key and no account:

curl -s https://mainnet-node.decentralchain.io/addresses/data/3DZasW6UoAzc6wxdpPDpzDvdvD4qv4J9NT8

The keys are readable without a decoder. A firm: entry marks a firm ACTIVE and binds it to its vault, a chal: entry records how an evaluation resolved, and a wd: entry records a payout as DELIVERED. Read at the time of writing, the registry holds two active firms, two passed evaluations and a delivered payout, which is the loop described above with nothing else in front of it.

DecentralProp grades its two chains separately, and is straight about which is which. The protocol as a whole runs on Solana devnet, where the full money spine is proven against deployed programs but the money is test money and Solana mainnet has not opened. DecentralChain is the exception: the loop above ran on real mainnet, for real, and was checked against the chain's own state afterwards rather than read back from the tool that ran it.