In an thrilling growth for the Ethereum and blockchain developer group, Web3j has turn into the primary web3 library to implement help for sending EIP-4844 blob transactions to Ethereum shoppers. This replace brings us one step nearer to the way forward for Ethereum scalability and effectivity, providing a glimpse into what full information sharding might ultimately seem like for the community.
Understanding EIP-4844 and its influence
EIP-4844, identified for introducing “blob-carrying transactions” to Ethereum, is designed to accommodate giant quantities of knowledge that can not be accessed by EVM execution, however whose dedication may be accessed. This progressive strategy permits for important information to be briefly saved on the beacon node, enhancing the community’s capability to deal with giant info.
Full information sharding will nonetheless take a substantial period of time to complete implementing and deploying. This EIP gives a stop-gap resolution till that time by implementing the transaction format that might be utilized in sharding, however not really sharding these transactions. As a substitute, the info from this transaction format is solely a part of the beacon chain and is absolutely downloaded by all consensus nodes (however may be deleted after solely a comparatively quick delay). In comparison with full information sharding, this EIP has a diminished cap on the variety of these transactions that may be included, equivalent to a goal of ~0.375 MB per block and a restrict of ~0.75 MB.
At present L2 networks or Rollups spend loads to be sure that their transaction information is obtainable to all of their nodes and validators. Most rollups do that by writing their information to Ethereum as calldata. That prices about $1000 per megabyte at present costs. Good rollups reduce that to $300 per megabyte through the use of superior information compression. Nonetheless, information posting price makes up the biggest portion of L2 transaction charges. With EIP4844 blob information, Ethereum meets the info availability wants of rollups, so they supply a brand new, and hopefully cheaper, approach for rollups to document their information, which might assist in considerably decreasing the transaction charges on Layer 2 networks like Optimism, Polygon zkEVM, Arbitrum, Starknet, and many others.
New Transaction Sort Spec in EIP-4844
EIP-4844 transactions observe the brand new kind of EIP-2718 transaction, “blob transaction”, the place the TransactionType is BLOB_TX_TYPE = Bytes1(0x03). The fields chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, worth, information, and access_list observe the identical semantics as EIP-1559.
There are two extra added fields max_fee_per_blob_gas is a uint256 and the sphere blob_versioned_hashes represents a listing of hash outputs from kzg_to_versioned_hash.
Networking
We are able to ship a signed EIP-4844 transaction utilizing web3j to eth_sendRawTransaction API and the uncooked kind have to be the community kind. This implies it consists of the tx_payload_body, blobs, KZG commitments, and KZG proofs.
Every of those parts are outlined as follows:
tx_payload_body – is the TransactionPayloadBody of normal EIP-2718 blob transaction
blobs – checklist of Blob gadgets
commitments – checklist of KZGCommitment of the corresponding blobs
proofs – checklist of KZGProof of the corresponding blobs and commitments
Code Instance: Sending a Blob Transaction with Web3j
Earlier than continuing with the next code instance, please make sure that the community you might be working with has EIP-4844 help enabled.
To make the most of the EIP-4844 blob transaction function in Web3j, builders can observe this instance:
public class Web3jEIP4844Example {
public static void most important(String[] args) throws Exception {
// Initialize Web3j and Credentials
Web3j web3j = Web3j.construct(new HttpService(“<nodeUrl>”));
Credentials credentials = Credentials.create(“<privateKey>”);
// Get the present nonce for the account
BigInteger nonce = web3j.ethGetTransactionCount(
credentials.getAddress(), DefaultBlockParameterName.LATEST)
.ship()
.getTransactionCount();
// Get the Present Base Payment Per Blob Fuel worth
BigInteger blobBaseFee = web3j.ethGetBaseFeePerBlobGas();
System.out.println(“blobBaseFee = “ + blobBaseFee);
// Multiply baseFeePerBlobGasValue with acceptable quantity to set it as our maxFeePerBlobGas worth
BigInteger maxFeePerBlobGas = BigInteger.valueOf((lengthy) (web3j.ethGetBaseFeePerBlobGas().longValue() * 1.1));
// Create a blob transaction
RawTransaction rawTransaction = createEip4844Transaction(
nonce, maxFeePerBlobGas);
// Signal the transaction
byte[] signedMessage = TransactionEncoder.signMessage(rawTransaction, credentials);
String hexValue = Numeric.toHexString(signedMessage);
// Ship the transaction
EthSendTransaction ethSendTransaction = web3j.ethSendRawTransaction(hexValue).ship();
System.out.println(“Transaction hash: “ + ethSendTransaction.getTransactionHash());
System.out.println(“Tx Receipt = “ + web3j.ethGetTransactionReceipt(ethSendTransaction.getTransactionHash()).ship().getTransactionReceipt());
}
non-public static RawTransaction createEip4844RawTransaction(BigInteger nonce, BigInteger maxFeePerBlobGas) {
Checklist<Blob> blobs = new ArrayList<>();
blobs.add(new Blob(“<blobData_in_Bytes>”));
return RawTransaction.createTransaction(
blobs,
11155111L,
nonce,
BigInteger.valueOf(10_000_000_000L),
BigInteger.valueOf(50_000_000_000L),
BigInteger.valueOf(3_00_000L),
“<toAddress>”,
BigInteger.valueOf(0),
“”,
maxFeePerBlobGas);
}
}
If we simply need to calculate KZG dedication and KZG proofs from a blob, we will try this utilizing BlobUtils Class capabilities.
Blob blob = new Blob(
Numeric.hexStringToByteArray(
loadResourceAsString(“blob_data.txt”)));
Bytes dedication = BlobUtils.getCommitment(blob);
Bytes proofs = BlobUtils.getProof(blob, dedication);
Bytes versionedHashes = BlobUtils.kzgToVersionedHash(dedication);
BlobUtils.checkProofValidity(blob, dedication, proofs)
For Builders who’re all in favour of trying out the PRs associated to EIP-4844 in web3j –
Implementing Blob Trasnactions – https://github.com/web3j/web3j/pull/2000
Implementing New Block Header format, getting Base Blob Payment, and new Transaction Receipt format – https://github.com/web3j/web3j/pull/2006
These PRs are included in web3j launch model >=4.11.0
Conclusion
The current integration of EIP-4844 blob transactions by Web3j as the primary web3 library to embrace this innovation showcases its dedication to blockchain growth and newest developments.
This weblog put up has delved into the technical intricacies of EIP-4844, from its potential influence on Ethereum’s scalability to the specificities of the brand new transaction kind it introduces.
Moreover, sensible insights into utilising Web3j for sending EIP-4844 transactions present builders with the instruments essential to discover this new frontier.
