iQrypto / Publications

QryptoRand: quantum randomness for Solidity applications

Explore iQrypto's QryptoRand prototype: a Rust bridge from QRNG hardware to Solidity contracts, with Tremplin Web3 context, source code and integration questions.

QRNG evaluationblockchainSolidityRustTremplin Web3

QryptoRand explores how a quantum random-number generator can supply values to a Solidity application. iQrypto’s public prototype connects an off-chain source to on-chain storage through a Rust controller. It gives developers concrete contracts and an integration example to inspect alongside the engineering questions that arise when physical randomness reaches a blockchain.

This case study brings together the Tremplin Web3 project context, the published implementation and a practical route for discussing an evaluation with iQrypto.

The Tremplin Web3 project

Digital Wallonia’s 2024 selection announcement lists iQrypto among the selected projects. It describes an intended verifiable-random-function demonstrator based on quantum random numbers, together with a white paper.

The later DigitalWallonia4.Trust programme results, published on 23 December 2025, describe the wider programme’s proof-of-concept work and lessons from blockchain experimentation. That programme report provides context; it is not an independent validation of QryptoRand’s security or performance.

The public technical resource is the iQrypto/QryptoRand repository, whose initial publication is dated 18 August 2025. The implementation described here is the revision fcb98e9, reviewed for this article on 31 October 2026. The repository labels the project alpha.

The application: bringing external randomness into Solidity

A Solidity contract cannot directly open a connection to a physical QRNG. An off-chain service must obtain values and submit transactions that make them available on-chain. Ethereum’s developer documentation describes this general role as an oracle.

A useful evaluation case is randomized selection in an application: obtain a value, then use it to select an item from a defined set. The QryptoRand tutorial illustrates this with a list of strings. Games and randomized allocations raise the same integration question, but their fairness also depends on when choices are fixed, when values become visible and who can influence delivery.

Solidity’s security guidance points out that contract data is public, including variables marked private. The complete application must therefore account for observers and transaction ordering when using randomness.

From the source to the contract

  1. Off-chain sourceA hardware adapter obtains random values and the associated hash, signature and proof data. A separate development mode uses a PRNG.
  2. Rust controllerThe controller follows contract events, requests values and submits them through the generated Solidity bindings.
  3. Solidity storage and consumerThe storage contract checks submissions and maintains a pool. A consumer requests stored values, with an optional VRF verification path.
Conceptual flow of the published QryptoRand prototype. Hardware access and on-chain verification are separate parts of the system.

The Rust controller listens for capacity and consumption events. Its supporting library packages values, hashes, signatures and proofs for single or batch submission. The hardware path is written around a TCP interface.

The storage contract includes owner-managed generator-key registration, hash and signature checks, nonces, and single or multiple-value requests. The prototype also contains token-accounting logic. This article describes its software architecture; it does not offer a token product.

At the consumer interface, askRandomNumber(bool verifyProof) retrieves a value from the pool. Setting the proof flag selects the verification path implemented by the contract. It does not turn the request into a fresh, secret, request-bound hardware measurement.

Read the code and Solidity example

The resources are available without an enquiry form:

  • Project README and source code: architecture, setup and the separate hardware and PRNG modes. The repository carries an MIT licence.
  • Solidity integration tutorial: linking contracts, requesting a stored value and selecting an entry from a list.
  • Consumer example: the corresponding Solidity source. Check example calls against the storage contract at the same revision.
  • Reviewed source snapshot: the revision used for this article, so later repository changes can be distinguished from this explanation.

The documented local workflow uses Foundry’s Anvil development chain. The PRNG mode is useful for exploring the software path without hardware; it does not provide quantum entropy. The public crate’s hardware-backend dependency is commented out, so a hardware evaluation also needs compatible backend software and configuration. Contact iQrypto to discuss that integration.

What an application evaluation needs to establish

The prototype makes the hardware-to-contract interfaces inspectable. Its alpha status and public code do not establish an audited production service. Before choosing an architecture, define the following with the application team:

  • Visibility and timing. Values submitted to on-chain storage are public before a later consumer retrieves them. A game or allocation protocol needs a design that prevents participants from exploiting that visibility.
  • Delivery and control. Decide who operates the source and controller, registers keys, submits transactions and handles missing or delayed values.
  • Proof and source assessment. A signature authenticates a message under a key; a VRF proof checks a cryptographic relation. Neither independently proves that the physical source supplied the claimed quantum entropy.
  • Integration behaviour. Check nonces, replay handling, proof-to-value binding, access control, transaction ordering and failure recovery across the complete path.
  • Operational evidence. Measure latency, transaction overhead and capacity on the chosen chain and hardware, and review the contracts before use with assets or consequential decisions.

These are questions for evaluating the whole application. A QRNG source alone does not make a blockchain application quantum-resistant or remove trust in the delivery system.

Discuss a QryptoRand evaluation

Contact iQrypto with questions about QryptoRand, the source code or the hardware interface. Useful starting details are your Solidity or EVM environment, the decision that consumes randomness, when participants commit their inputs, and the evidence you need from an evaluation.

If your first step is a hardware assessment, VERA-Q’s evaluation page explains the current shortlist-access route. Compatibility with this prototype’s hardware backend should be discussed separately. The entropy-source explanation and integration-path guide provide the broader QRNG background.

Sources

Discuss your application

Ask about QryptoRand

Tell us what you need.

Share your contact details and what you want to evaluate. Project details are optional.

Add project details (optional)