How to submit an EIP4844 transaction

[LeoPapais]

Suggestion

Hi,

There's no code examples on how to create blobs (aka EIP4844 transactions). I couldn't make it work, otherwise I'd link a pull request adding the documetation.

The issue is that I couldn't figure out how to calculate the versioned hashes, KZG commitments and proofs, and where to add the blob data itself.

Thanks in advance.

[ernaneluis]

Same here

[LeoPapais]

Hey @ernaneluis ,

While I couldn't use ethers.js exclusively to submit a blob tx, I found a way to create the tx using some different libraries. Here's the excerpt:

import { ethers } from "ethers"
import * as dotenv from "dotenv"
import * as path from 'path'
import pkg from 'c-kzg'
import axios from 'axios'
import { Common, Hardfork } from '@ethereumjs/common'
import { BlobEIP4844Transaction } from '@ethereumjs/tx'

const {
    blobToKzgCommitment,
    computeBlobKzgProof,
    loadTrustedSetup
  } = pkg;

const common = new Common({
  chain: 1,
  hardfork: Hardfork.Cancun,
  eips: [4844],
  customCrypto: { kzg: pkg }
})

dotenv.config();

const ownerPrivateKey = process.env.OWNER_PK;
const rpcUrl = process.env.RPC_URL;

// Setup provider, wallet
const provider = new ethers.JsonRpcProvider(rpcUrl);
const signer = new ethers.Wallet(ownerPrivateKey, provider);

async function sendRawTransaction() {
    const from = await signer.getAddress();
    const to = await ethers.Wallet.createRandom().getAddress();
    const nonce = await provider.getTransactionCount(from, 'pending');
    const feeData = await provider.getFeeData();

    const BYTES_PER_BLOB = 4096 * 32
    const newBlob = Buffer.concat([
        Buffer.from('Your String Here...'),
        Buffer.alloc(BYTES_PER_BLOB, " ")
    ]).slice(0, BYTES_PER_BLOB)
    loadTrustedSetup(path.resolve("trusted_setup.txt"))
    const commitment = blobToKzgCommitment(newBlob)
    const proof = computeBlobKzgProof(newBlob, commitment)
    
    const txData = {
        chainId: ethers.toBeHex(1),
        nonce: ethers.toBeHex(nonce),
        maxPriorityFeePerGas: ethers.toBeHex(feeData.maxPriorityFeePerGas),
        maxFeePerGas: ethers.toBeHex(feeData.maxFeePerGas),
        maxFeePerBlobGas: '0xfff',
        gasLimit: "0x5680",
        to,
        value: "0x00",
        data: "0x",
        type: '0x03',
        accessList: [],
        blobVersionedHashes: ["0x01" + ethers.sha256(commitment).substr(4, 64)],
        kzgCommitments: [ethers.hexlify(commitment)],
        blobs: [newBlob],
        kzgProofs: [ethers.hexlify(proof)]
    };

    const tx = BlobEIP4844Transaction.fromTxData(txData, { common })    
    const signedTx = tx.sign(Buffer.from(ownerPrivateKey, 'hex'))

    const rawTx = ethers.hexlify(signedTx.serializeNetworkWrapper())
    const data = JSON.stringify(
        {
            "jsonrpc": "2.0",
            "method": "eth_sendRawTransaction",
            "params": [rawTx],
            "id": 1
        }
    )
    
    const res = await axios({
        method: 'post',
        url: process.env.RPC_URL,
        data
    })

    return res;
}

sendRawTransaction()
    .then(res => console.log(res))
    .catch(error => console.error(error));
    ```

[ricmoo]

@LeoPapais Thanks! Your example was huge help in understanding some of the finer points of EIP-4844.

I have a local version that can submit BLOb transactions. I'm just fixing up a few nuances in the API and will get a beta version up tomorrow for people to try out and get some feedback. :)

[ricmoo]

I have put up a beta release with EIP-4844 write abilities for you to try out.

• You will need to install the next version of ethers: npm install ethers@next
• And will need a KZG library (for this example): npm install kzg-wasm.

import { ethers } from "ethers";

import { loadKZG } from "kzg-wasm";

(async function() {
  // Need this to generate the commitments and proofs; if you have
  // already computed these elsewhere, skip this step
  const kzg = await loadKZG();

  // Our Signer; you can steal the left-over Sepolia in this account or
  // use it to test this script ;)
  const provider = new ethers.QuickNodeProvider("sepolia");
  const wallet = new ethers.Wallet(ethers.id("toss-a98fa2"), provider);
  console.log("WALLET", wallet.address);

  // Send a BLOb transaction
  const tx = await wallet.sendTransaction({
    // Specify it is a type 3, BLOb transaction
    type: 3,

    // BLOb transactions require a to address
    to: wallet.address,

    gasLimit: 21064,

    // Sepolia needs outrageous prices, on mainnet I've heard
    // even 1 wei works fine
    maxFeePerBlobGas: 400000000000,

    // Your blobs; these will get padded and use the kzg to compute the commitments and proofs.
    // If you already have the commitment and proofs, you can omit the kzg property below and
    // can pass in the { data, commitment, proof } object
    blobs: [
      ethers.toUtf8Bytes("Hello World, from Ethers!")
    ],

    // Set the KZG library; only need this if you don't specify already fully-valid blobs
    kzg: kzg
  });
  console.log({ tx });

  // Wait for it to get mined...
  const receipt = await tx.wait();
  console.log({ receipt });

})();

Which sent this transaction with this BLOb.

I'm still mulling over some finer points of the API. Please check out the changes and let me know if you have any ideas, concerns or suggestions.

[ricmoo]

Sending EIP-4844 transactions is now fully supported as of v6.12.0, published to npm. :)

Thanks! :)