Skip to main content

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.

Testnet first, and the lane is open there since proposal 37

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.

ItemRuleLive value (testnet)
Rent per yeardata size in bytes times lamports_per_byte3,480 lamports per byte
Rent-exempt minimumrent per year times rent_exemption_multimultiplier 2.0
Funded at or above the minimumnever charged rent
Funded below the minimumrent is deducted each epoch
Balance reaches zerothe 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.

ParameterLive valueIn plain terms
max_custody_uqor10,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_uqor1,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_uqor10,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​

LimitParameterLive value (testnet)
Compute units per instructioncompute_budget_max1,400,000
Program size (ELF)max_program_size10,485,760 bytes (10 MiB)
Data account sizemax_account_data_size10,485,760 bytes (10 MiB)
Nested program callsmax_cpi4
Default signature schemedefault_sig_scheme0 (Ed25519)
Slot offsetsvm_slot_offset0 (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:

  • getLatestBlockhash returns the blockhash as 64 hexadecimal characters, not as base58 the way Solana nodes do (read on 12 November 2026: blockhash e8d4...d449, lastValidBlockHeight 9944659). A client that expects base58 has to convert it. The chain team has scheduled a change.
  • Solana wire-format sendTransaction from standard Solana tooling is not supported yet on the public endpoint. Programs are deployed and called with the Cosmos messages MsgDeployProgram and MsgExecuteProgram, 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 feature svm-relayed-chain-bound; @qorechain/wallet-adapter 0.6.0 builds it with authSignBytesV3, and resolveSvmAuthVersion reads which form the network wants.

Errors and refusals​

What you seeMeaningWhat 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 yetCreate the account first, then register its key
MsgRegisterSVMPQCKey refused while the lane is closedLane closedRegister after the lane opens
Write method refused on svm.qore.host or svm-testnet.qore.hostPublic endpoints are read-onlyUse your own node
svm custody cap exceeded (code 23)The pool is at its capRetry 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 oldFetch a fresh one and sign again
svm simulation slots busy, retry later (code 24)Simulations are bounded; it never occurs in a blockRetry the simulation
HTTP 501 on /qorechain/svm/v1/account/...Route not implemented on the public endpointUse getAccountInfo

Tested on the testnet​

Run on qorechain-diana on 12 November 2026 (release v3.2.8) after proposal 37 passed.

StepResult
GET /cosmos/circuit/v1/disable_listOnly /cosmwasm.wasm.v1.MsgStoreCode
GET /qorechain/svm/v1/paramsenabled 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 yetRefused: 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​