SVM Lane: Programs, Accounts and Custody Limits (v3.2.8)
The SVM lane is the Solana-compatible part of QoreChain: you deploy compiled programs, create data accounts and call programs with Solana-style tooling, and the same native QOR balance is visible in lamports. Release v3.2.8 closed the lane at the upgrade until a governance vote reopened it. On the testnet that vote (proposal 37) has passed and the lane is open; its custody is bounded by three governed limits.
This page explains how to read the lane state, how programs, accounts and rent work, how an SVM wallet registers a post-quantum key, what the custody limits mean, and which examples can run today.
v3.2.8 has run on the qorechain-diana testnet since 12 November 2026. Mainnet (qorechain-vladi) runs v3.2.7 (since 12 November 2026), has not applied v3.2.8, and the lane stays off on mainnet. The upgrade closed the lane on the testnet (SVM writes failed, MsgRegisterSVMPQCKey was refused). Governance proposal 37 passed and opened it on qorechain-diana: it set enabled: true, kept the other parameters as they were and lifted the circuit-breaker pause on MsgExecuteProgram and on cross-VM calls. When checked on 12 November 2026 after the vote, GET /qorechain/svm/v1/params showed enabled: true and the circuit breaker list held only /cosmwasm.wasm.v1.MsgStoreCode. The public SVM JSON-RPC stays read-only. Always read the live state first (next section) and do not assume it.
Why it matters
- A client that offers SVM actions while the lane is closed gives users refused transactions. Reading one parameter first avoids that.
- The lane holds real QOR: every lamport in a program, a program-derived address or a data account is backed by uqor held by the SVM module. The three custody limits keep that pool bounded, so a transfer or a deposit can be refused even when the sender has the funds.
- Rent and size limits decide how much it costs to keep state on chain, so they belong in a deployment budget.
Reading the lane state
The lane state is the enabled field of the SVM parameters. Read it from the REST route or the node CLI. The same response carries every other limit on this page, so one call is enough to size a deployment.
curl -s https://api-testnet.qore.host/qorechain/svm/v1/params
Response on qorechain-diana, 12 November 2026, after proposal 37 passed (HTTP 200):
{"params":{"max_program_size":"10485760","max_account_data_size":"10485760","compute_budget_max":"1400000","lamports_per_byte":"3480","rent_exemption_multi":"2.000000000000000000","enabled":true,"svm_slot_offset":"0","default_sig_scheme":0,"max_cpi":4,"max_custody_uqor":"10000000000","max_custody_hard_uqor":"1000000000000","max_account_excess_uqor":"10000000000"}}
On a Linux node (there is no packaged macOS binary), the same read is:
qorechaind query svm params --chain-id qorechain-diana --node https://rpc-testnet.qore.host:443
In TypeScript, with Node 18 or later (no SDK call is needed for this read):
const REST = "https://api-testnet.qore.host";
const { params } = await (await fetch(`${REST}/qorechain/svm/v1/params`)).json();
if (!params.enabled) {
throw new Error("The SVM lane is closed on this network; do not offer SVM actions");
}
console.log("compute units per instruction:", params.compute_budget_max);
A typed helper for these parameters (and a safe builder for a parameters proposal) is part of the SDK draft for v3.2.8, which is not published yet. A later SDK release adds this; use the command line or the REST route until then.
Cluster identity
cluster_info identifies the cluster for wallets and says whether execution is on. It does not change with the lane state in any way other than execution_enabled.
curl -s https://api-testnet.qore.host/qorechain/svm/v1/cluster_info
Response on 12 November 2026, read after proposal 37 passed, with execution_enabled true (HTTP 200):
{"chain_id":"qorechain-diana","genesis_hash":"6Z9pa53SwiprqiAoNCqqUdj5c3C4P1zRw31gQVnF4Czj","caip2_chain_id":"solana:6Z9pa53SwiprqiAoNCqqUdj5c3C4P1zR","derivation":"base58(SHA-256(\"qorechain/svm/genesis-hash/v1\" || 0x00 || chain_id))","execution_enabled":true}
The node CLI has the same query: qorechaind query svm cluster-info. The JSON-RPC method getGenesisHash on https://svm-testnet.qore.host returns the same hash. The hash is derived from the chain id; it is not the genesis hash of a real Solana cluster. The route is also served on mainnet (v3.2.7): on 12 November 2026 https://api.qore.host/qorechain/svm/v1/cluster_info answered 200 with execution_enabled false.
Public SVM RPC is read-only
The public endpoints https://svm.qore.host and https://svm-testnet.qore.host answer reads and refuse write methods (sendTransaction and similar) on the public chain ids, whether or not the lane is open. To submit SVM transactions you run your own node, which serves the Solana-compatible JSON-RPC on port 8899 by default (see SVM Development), and the lane itself must be open on the network that node follows. Reads work now:
# Health, version, cluster hash, slot and a rent quote (all HTTP 200 on 12 November 2026)
curl -s -X POST https://svm-testnet.qore.host -H 'Content-Type: application/json' \
-d '{"jsonrpc":"2.0","id":1,"method":"getHealth","params":[]}'
curl -s -X POST https://svm-testnet.qore.host -H 'Content-Type: application/json' \
-d '{"jsonrpc":"2.0","id":1,"method":"getVersion","params":[]}'
curl -s -X POST https://svm-testnet.qore.host -H 'Content-Type: application/json' \
-d '{"jsonrpc":"2.0","id":1,"method":"getGenesisHash","params":[]}'
curl -s -X POST https://svm-testnet.qore.host -H 'Content-Type: application/json' \
-d '{"jsonrpc":"2.0","id":1,"method":"getMinimumBalanceForRentExemption","params":[1024]}'
getVersion reported solana-core 1.18.0-qorechain together with the chain id, the cluster id and the genesis hash. The rent quote for 1,024 bytes was 8017920 lamports on 12 November 2026. The REST routes GET /qorechain/svm/v1/account/{address}, .../program/{address} and .../slot answered HTTP 501 (not implemented) on the public endpoint; read accounts and programs through the JSON-RPC methods getAccountInfo and getMultipleAccounts, or through the node CLI.
Deploying and calling programs
Once the lane is open, the flow is: build an SBF program with the current Solana toolchain, deploy it, create the accounts it needs, then call it. Every tx svm command is a Cosmos-lane transaction, so it needs an explicit gas limit, a fee of at least gas times 0.1 uqor, and the hybrid post-quantum cosignature (see Post-Quantum Signing).
These are the Linux node CLI commands from the node reference. UNTESTED: the lane opened on the testnet only after proposal 37, and no program deploy, execute or account creation was run for this page.
# 1. Build (platform-tools v1.53, --arch v0 or --arch v3)
cargo build-sbf --arch v3
# 2. Deploy; the response carries the program id in base58
qorechaind tx svm deploy-program ./my_program.so --from mykey \
--gas 2000000 --fees 200000uqor --chain-id qorechain-diana --generate-only > tx.json
qorechaind tx pqc cosign tx.json --from mykey --pqc-key mypqc --chain-id qorechain-diana
# 3. Create a data account owned by the program (space in bytes, lamports for rent)
qorechaind tx svm create-account <owner-base58> <space> <lamports> --from mykey \
--gas 400000 --fees 40000uqor --chain-id qorechain-diana --generate-only > tx.json
# 4. Call the program
qorechaind tx svm execute <program-id-base58> <data-hex> --from mykey \
--gas 400000 --fees 40000uqor --chain-id qorechain-diana --generate-only > tx.json
Reads on a node, available whatever the lane state:
qorechaind query svm account <base58-address>
qorechaind query svm program <base58-address>
qorechaind query svm params
qorechaind query svm slot
TypeScript with @qorechain/svm 0.13.0
@qorechain/svm is a thin layer over @solana/web3.js. It has no loader wrapper: use the node CLI above to deploy, and the package to build and send instructions to a program that already exists. Its public presets set no SVM endpoint on purpose, so give it the URL of your own node.
import { PublicKey, Transaction } from "@solana/web3.js";
import {
createSvmClient,
createInvokeInstruction,
withComputeBudget,
svmKeypairFromSecretKey,
} from "@qorechain/svm";
const client = createSvmClient({ rpcUrl: "http://127.0.0.1:8899" }); // your own node
const payer = svmKeypairFromSecretKey(secretKey64); // 64-byte Solana-style secret key
const programId = new PublicKey("<program-id-base58>");
const dataAccount = new PublicKey("<data-account-base58>");
const tx = new Transaction().add(
createInvokeInstruction(
programId,
[{ pubkey: dataAccount, isSigner: false, isWritable: true }],
Uint8Array.from([0]), // your program's instruction data
),
);
withComputeBudget(tx, { units: 200_000 }); // stay under compute_budget_max
const sim = await client.simulateTransaction(tx); // dry run first
const signature = await client.sendTransaction(tx, [payer]);
UNTESTED: this example needs a node you run (the lane is open on the testnet). Against the public endpoint the send is refused. The read-only calls (client.getBalance, client.getAccountInfo, client.getSignaturesForAddress) work against https://svm-testnet.qore.host because createSvmClient({ rpcUrl }) accepts any URL.
Python, Go, Rust and Java: the SVM adapters for those languages build the same messages; a later SDK release adds the v3.2.8 helpers. Until then use the node CLI above or the raw message. Any Solana client library can also talk to your own node's port 8899 because the method set is Solana-compatible.
Accounts and rent
SVM data accounts pay for the space they use. The numbers come from the live parameters above.
| Item | Rule | Live value (testnet) |
|---|---|---|
| Rent per year | data size in bytes times lamports_per_byte | 3,480 lamports per byte |
| Rent-exempt minimum | rent per year times rent_exemption_multi | multiplier 2.0 |
| Funded at or above the minimum | never charged rent | |
| Funded below the minimum | rent is deducted each epoch | |
| Balance reaches zero | the account is removed |
Lamports and uqor relate as 1 uqor = 1,000 lamports. Ask the node for the exact minimum rather than computing it: getMinimumBalanceForRentExemption returned 8,017,920 lamports for 1,024 bytes (the quote includes the account header). create-account needs at least that many lamports, or the account is not rent exempt.
Addresses: an account's SVM address is its 20 account bytes padded to 32 bytes and written in base58. The qor1..., 0x... and base58 forms name the same account.
Post-quantum key for SVM wallets
An SVM wallet that wants a post-quantum key on chain registers it with MsgRegisterSVMPQCKey. It carries the sender, the 32-byte SVM address and the ML-DSA-87 public key. It is a Cosmos-lane message, so the sender signs it hybrid like any other native transaction. It is refused while the lane is closed, and the SVM account must already exist before its key is registered (see the refusal under Tested on the testnet).
There is no tx svm command for it; use the SDK composer. In TypeScript the composer is msg.svm.registerSvmPqcKey in @qorechain/sdk. UNTESTED for an existing account: the only send was for an address with no account, and it was refused.
import {
createClient,
deriveNativeAccount,
directSignerFromPrivateKey,
derivePqcCanonical,
msg,
} from "@qorechain/sdk";
import { fromBech32 } from "@cosmjs/encoding";
const client = createClient({
network: "testnet",
endpoints: { rest: "https://api-testnet.qore.host", rpc: "https://rpc-testnet.qore.host" },
});
const account = await deriveNativeAccount(mnemonic);
const signer = await directSignerFromPrivateKey(account.privateKey, "qor");
const pqcKeypair = derivePqcCanonical(account.address, mnemonic);
const tx = await client.connectTx(signer, { pqcKeypair }); // signs hybrid
// 20 account bytes padded with zeros to the 32-byte SVM address
const svmAddr = new Uint8Array(32);
svmAddr.set(fromBech32(account.address).data);
await tx.signAndBroadcast(
[msg.svm.registerSvmPqcKey({ sender: account.address, svmAddr, pqcPubKey: pqcKeypair.publicKey })],
"auto",
);
The Python composer is msg.svm.register_svm_pqc_key(sender=, ...) and the Go one is Svm.RegisterPQCKey(sender, svmAddr, pqcPubKey).
Custody limits
Every lamport held by a program, a program-derived address or a data account is backed by uqor that the SVM module holds in one pool, called custody. Three governed parameters bound it. All three are in uqor; 1 QOR is 1,000,000 uqor. Governance changes them with a parameters proposal, and a proposal must send all twelve fields because it replaces the set as a whole.
| Parameter | Live value | In plain terms |
|---|---|---|
max_custody_uqor | 10,000,000,000 (10,000 QOR) | The cap on the SVM pool balance. A transfer that would lift the pool above it is refused with svm custody cap exceeded (code 23). 0 means no cap. |
max_custody_hard_uqor | 1,000,000,000,000 (1,000,000 QOR) | The absolute ceiling on the pool's raw balance, rent reserves, pre-funding and plain donations included. An operation that would leave the balance above it is refused. It must not be below max_custody_uqor, and it must be above zero for the lane to be opened. |
max_account_excess_uqor | 10,000,000,000 (10,000 QOR) | The most a single data account may hold above its rent-exempt minimum. 0 means no per-account cap. |
What this means for an application: keep the value you park in SVM accounts modest and above the rent minimum only by what you need. A deposit that is fine for your balance can still be refused if the pool as a whole is near its cap, so treat code 23 as "try later or with less", not as an invalid transaction. The limits can only grow through a governance vote, never by a user transaction.
Compute budget and size limits
| Limit | Parameter | Live value (testnet) |
|---|---|---|
| Compute units per instruction | compute_budget_max | 1,400,000 |
| Program size (ELF) | max_program_size | 10,485,760 bytes (10 MiB) |
| Data account size | max_account_data_size | 10,485,760 bytes (10 MiB) |
| Nested program calls | max_cpi | 4 |
| Default signature scheme | default_sig_scheme | 0 (Ed25519) |
| Slot offset | svm_slot_offset | 0 (the slot is the block height plus the offset) |
Each frame has a 32 KiB stack and a 256 KiB heap. The values above can change by governance, so read them live. In @qorechain/svm 0.13.0, withComputeBudget(tx, { units }) requests a compute-unit limit; keep it at or below compute_budget_max.
Current limits of the testnet SVM endpoint
The lane is open, but the public SVM JSON-RPC does not yet behave like a full Solana node. Plan around these limits:
getLatestBlockhashreturns the blockhash as 64 hexadecimal characters, not as base58 the way Solana nodes do (read on 12 November 2026:blockhashe8d4...d449,lastValidBlockHeight9944659). A client that expects base58 has to convert it. The chain team has scheduled a change.- Solana wire-format
sendTransactionfrom standard Solana tooling is not supported yet on the public endpoint. Programs are deployed and called with the Cosmos messagesMsgDeployProgramandMsgExecuteProgram, signed with the hybrid signature like any Cosmos-lane transaction (see the TypeScript helpers above). Full parity with Solana tooling is planned for a later release. - A foreign key can authorise an SVM action through a relayer. The authorisation signs a chain-bound digest (domain
qorechain-svm-auth-v3) once the network enables the protocol featuresvm-relayed-chain-bound;@qorechain/wallet-adapter0.6.0 builds it withauthSignBytesV3, andresolveSvmAuthVersionreads which form the network wants.
Errors and refusals
| What you see | Meaning | What to do |
|---|---|---|
SVM module is disabled (code 11) | The lane is closed (mainnet, or the testnet before proposal 37) | Read enabled; do not retry |
MsgRegisterSVMPQCKey refused with SVM account ... not found (codespace svm, code 3) | The SVM account does not exist yet | Create the account first, then register its key |
MsgRegisterSVMPQCKey refused while the lane is closed | Lane closed | Register after the lane opens |
Write method refused on svm.qore.host or svm-testnet.qore.host | Public endpoints are read-only | Use your own node |
svm custody cap exceeded (code 23) | The pool is at its cap | Retry later or with a smaller amount |
airdrop rate limit exceeded (code 19) | requestAirdrop called too often (testnet only) | Wait |
blockhash expired (code 20) | The recent blockhash is too old | Fetch a fresh one and sign again |
svm simulation slots busy, retry later (code 24) | Simulations are bounded; it never occurs in a block | Retry the simulation |
HTTP 501 on /qorechain/svm/v1/account/... | Route not implemented on the public endpoint | Use getAccountInfo |
Tested on the testnet
Run on qorechain-diana on 12 November 2026 (release v3.2.8) after proposal 37 passed.
| Step | Result |
|---|---|
GET /cosmos/circuit/v1/disable_list | Only /cosmwasm.wasm.v1.MsgStoreCode |
GET /qorechain/svm/v1/params | enabled true; max_program_size 10485760, max_account_data_size 10485760, compute_budget_max 1400000, lamports_per_byte 3480, rent_exemption_multi 2, max_cpi 4, max_custody_uqor 10000000000, max_custody_hard_uqor 1000000000000, max_account_excess_uqor 10000000000 |
MsgRegisterSVMPQCKey for an SVM address that does not exist yet | Refused: codespace svm code 3, SVM account ... not found: SVM account not found. The account must exist before its post-quantum key is registered |
Not run (UNTESTED): program deploy, program execute and SVM account creation.
Mainnet
Mainnet stays on v3.2.7 for now, with the SVM lane off, and enabling it on mainnet needs a later release and a governance vote. Plan against the testnet only.
See also
- SVM Development: the lane overview, the JSON-RPC server and native QOR as lamports.
- Solana-Compatible JSON-RPC: the method list.
- Post-Quantum Signing: the hybrid signature every native-lane transaction needs.
- Cross-VM Interoperability: calls between SVM, EVM and QoreChain Native.
- Node Operators: v3.2.8 Checklist: upgrading a node.