Axiom: Bridging the Gap in Web3 Data Access, Empowering Smart Contracts with New Capabilities
TechFlow Selected TechFlow Selected
Axiom: Bridging the Gap in Web3 Data Access, Empowering Smart Contracts with New Capabilities
Axiom aims to address the challenge of lackluster Web3 applications caused by unreliable access to data and computation.
Navigating Web3 tides with focused insightsAuthor: camiinthisthang
Translation: TechFlow
“Putting everything on-chain” has always felt somewhat forced to me. There’s little reason to place many things on-chain since, aside from permanent storage, you can’t do much with that data. While The Graph and similar protocols enable querying on-chain data for frontend integration—including full-text search and filtering—these operations are performed client-side. This means you cannot actually leverage this data at the smart contract level to build logic based on it. This limitation leads to flattened and monotonous Web3 applications—they can only utilize real-time interaction data such as account balances and current block numbers.
Traditional applications thrive by leveraging users’ online activities to curate personalized and immersive experiences. Unfortunately, Web3 has not yet figured out how to do this, which largely contributes to the widespread perception that Web3 struggles to deliver meaningful applications that resonate with users.
Iconic applications shaping the digital landscape—Instagram, TikTok, Spotify, YouTube, etc.—showcase users’ past activities within their interfaces and use this data to power recommendation algorithms, serve personalized ads, and connect users with creators matching their preferences. This dynamic design space is conspicuously absent in Web3.
The reason Web3 cannot achieve this is because we lack tools that allow trustless access to on-chain data at the smart contract level. Surprisingly, smart contracts have no way to read data from archive nodes—such as historical NFT ownership or account balances at specific block heights—and use that data to drive conditional logic within their operations. Enabling such data access in smart contracts involves various trade-offs concerning security and cost:
-
Application developers manually put the data on-chain via an EOA or multisig, fully trusted;
-
Relying on Chainlink to support the specific data type you need;
-
Caching the data within your contract (paying extra for contract storage).
Axiom enables trustless reads and computations
Over recent months, the emergence of several high-performance ZK teams has ushered in a new era of possibilities for the Ethereum ecosystem. Among them is Axiom, a zk project aiming to address the dullness of web3 applications caused by the lack of reliable data access and computation. Its alpha version is now live on the Ethereum mainnet.
Developers can submit queries to Axiom to trustlessly access any block header, account, or storage value across Ethereum's entire history via storage proofs. Axiom uses zk to generate validity proofs for all query results, which are then verified on-chain—meaning smart contracts can directly act upon these results without additional trust assumptions.
Axiom abstracts away much of the math-heavy knowledge traditionally required to work with zk. What’s most exciting about Axiom is that it allows developers to write Solidity smart contracts that query Axiom’s contract and then verify the responses they receive, using that data directly within their own contracts.
Axiom provides a TypeScript SDK and its AxiomV1Query smart contract, enabling developers to create and submit queries on-chain, then use the verified responses in their smart contracts. The interaction works as follows:
-
Send on-chain query: Use the Axiom SDK to create a query and submit it to the AxiomV1Query smart contract.
-
Wait for query completion: Off-chain provers will index the query, generate the result, and produce a ZK proof of its validity. The proof is verified on-chain, and the result is written into the AxiomV1Query contract storage in Merkle form.
-
Read query result: Once the result is verified on-chain, use the SDK to retrieve the query result from contract storage and trustlessly use it within your smart contract application.
In my mental model, using Axiom involves two main components:
-
Constructing queries and sending them to the Axiom smart contract.
-
Reading and verifying responses from the Axiom smart contract.
Building and sending queries
The first step is to send a query to the Axiom contract from a Node/Next.js project using the TS SDK:
Developers can create and send queries using four methods:
-
newQueryBuilder – creates a new instance of a query;
-
append – passes in the address, storage slot, and/or block number you want to prove;
-
build – retrieves the keccakQueryResponse and serializes the query;
-
sendQuery – sends the query to the AxiomV1Query contract.
Reading and verifying responses
Once the Prover generates the ZK proof, it writes that the “keccakQueryResponse” for the query has been satisfied and triggers a “QueryFulfilled” event. Developers read the response from Axiom’s contract storage and use these SDK methods to verify the results on-chain:
-
getValidationWitness – allows users to prove that the data they claim was indeed committed to the keccakQueryResponse;
-
areResponsesValid – checks whether your provided data matches the hash stored on-chain.
Once you’ve verified the response is valid, you can pass this response as a parameter to any smart contract function, which will impose restrictions based on this process and pass along the verified proof within the function call.
Will ZK finally enable us to build apps that regular users care about?
You can now not only generate storage proofs and use them in smart contracts to write logic based on historical on-chain activity—but for the first time, use this historical data to create rich experiences similar to those in Web2.
As more users, activities, and data move on-chain, tools like Axiom will be essential for creating rich user experiences without sacrificing security.
Some project ideas for inspiration, drawn from Axiom’s blog:
-
Autonomous airdrops via smart contracts based on on-chain activity, without centralized entities.
-
On-chain loyalty systems based on verifiable engagement scores.
-
Solver-driven DeFi protocols that settle markets using provable off-chain solvers.
-
NFT floor price oracles referencing past transactions to support underwriting for NFT lending and derivatives.
-
Randomness oracles leveraging randomness from mining.
-
Trusted volatility oracles used to adjust fees in AMMs or LTV in lending protocols.
-
Generative NFTs proven within ZK to be generated from claimed algorithms.
Join TechFlow official community to stay tuned
Telegram:https://t.me/TechFlowDaily
X (Twitter):https://x.com/TechFlowPost
X (Twitter) EN:https://x.com/BlockFlow_News
@camiinthisthang
