Verifying eth_call results using L1 and L2 cryptographic proofs
As the proliferation of decentralized applications (dApps) on the Ethereum network continues to grow, it is becoming increasingly important to ensure the reliability and integrity of static call (eth_call) requests. Currently, the data returned by these calls can only be as reliable as the node or service providing it, which is not always the case.
In this article, we will look at how cryptographic proofs can be used to verify the results of eth_call requests on both Layer 1 (L1) and Layer 2 (L2) networks.
Understanding Ethereum L1 and L2 Networks
Before we dive into the world of cryptography, it is important to understand the two main layers that make up the Ethereum network:
- Level 1 (L1): This refers to the underlying blockchain that is responsible for executing smart contracts. The L1 network is decentralized, meaning there are no intermediaries and all transactions are recorded on a public ledger called the Block Explorer.
- Layer 2 (L2): This layer acts as an intermediary between the L1 network and the Ethereum Virtual Machine (EVM). It offers faster transaction processing, lower fees, and improved scalability. The L2 network is also decentralized.
Unverified data issue
There are several potential issues that can arise when using eth_call requests to access smart contracts on the L1 network:
- Data falsification
: An attacker may be able to falsify the data returned by an eth_call request.
- Missing authentication
: The Ethereum node or service providing the data may not be authenticated, making its integrity difficult to verify.
Using cryptographic proofs for verification
To solve these problems, cryptographic proofs can be used to verify the results of eth_call requests on L1 and L2 networks. Here are some ways to implement it:
L1 Network
Using Web3.js with JSON-LD and GraphQL
Web3.js is a popular JavaScript library that enables interaction with the Ethereum blockchain. Using JSON-LD (JavaScript Object Notation for Linked Data) and GraphQL, you can build a decentralized application (dApp) on the L1 network that provides secure access to smart contracts.
“Javascript
// Import required libraries
const Web3 = require('web3');
const jsonld = require('json-ld');
// Configure your Ethereum node or service
const web3 = new Web3(new Web3.providers.HttpProvider('
// Define a function to execute the eth_call request using JSON-LD and GraphQL
async function executeEthCall(request) {
// Create a GraphQL query using the json-ld library
const schema = new GraphQLSchema({
type definitions: [
{
type: 'query',
arguments: {
contract address: { type: 'string' },
contract function name: { type: 'string' }
},
resolve: async(parent, args) => {
// Execute the eth_call request
const result = await web3.eth.call({
to: args.contractAddress,
data: args.contractFunctionName,
from: '0xYOUR_PROJECT_ID'
});
returns JSON.parse(result);
}
}
]
});
// Use the GraphQL method "executeQuery" to execute the query
const response = wait for schema.executeQuery({
query: {
query:
query {
contractAddress: ${args.contractAddress}
contractFunctionName: ${args.contractFunctionName}
}
`,
variables: arguments
}
});
returns JSON.parse(response.data);
}
// Example of use:
const request = { contractAddress: ‘0xYOUR_CONTRACTADDRESS’, contractFunctionName: ‘myContractFunction’ };
executeEthCall(Request).then((Result) => Console.
