EIP-4844 — Proto-Danksharding (Blobs)

Back to Protocol-Level EIPs

EIP-4844: Shard Blob Transactions (Proto-Danksharding)

EIP-4844 (Cancun, 2024) introduces blob-carrying transactions — type-3 txs that carry up to 6 "blobs" of 128 KB each. Blobs are stored on the consensus layer for ~18 days, then pruned. Designed to massively reduce L2 rollup data costs because rollups can publish their compressed state diffs as cheap blobs instead of expensive calldata.

Mechanics

• Blobs are committed to via KZG polynomial commitments.
• On-chain code can verify a KZG commitment but cannot read blob data directly.
• Rollups post blob commitments; rollup verifiers reconstruct off-chain.

Neo Equivalent

Neo's scalability model is different: rather than blob storage to support L2 rollups, Neo emphasises on-chain throughput (~4000 TPS at the protocol level) plus state channels for off-chain settlement when needed. The Oracle native provides off-chain data ingestion when contracts need to reference data not stored on-chain.

For a Neo contract that needs to verify large external data, the typical pattern is to store a hash on-chain and verify Merkle/KZG/etc. proofs in C#. Neo's CryptoLib exposes the building blocks (Sha256, Ripemd160, VerifyWithECDsa, Bls12381*).

// EIP-4844 blob tx (type 0x03) format includes:
//   maxFeePerBlobGas    = uint256
//   blobVersionedHashes = bytes32[]   (KZG commitments)
//
// On-chain code can introspect via:

contract BlobReader {
    /// EIP-7516 BLOBBASEFEE opcode
    function blobBaseFee() external view returns (uint256) {
        // return block.blobbasefee;
        return 0;
    }

    /// EIP-4844 BLOBHASH opcode — read the i-th blob's versioned hash
    function blobHash(uint256 index) external view returns (bytes32 vh) {
        // assembly { vh := blobhash(index) }
    }

    /// Verify a KZG point evaluation against a blob commitment.
    /// Used by rollups to prove specific blob bytes without fetching the whole blob.
    function verifyKzg(
        bytes32 blobCommitment,
        bytes calldata kzgProof,
        bytes32 z,
        bytes32 y
    ) external view returns (bool) {
        // staticcall to 0x0a precompile (EIP-4844 point eval precompile)
        return false;
    }
}

using System.Numerics;
using Neo;
using Neo.SmartContract.Framework;
using Neo.SmartContract.Framework.Attributes;
using Neo.SmartContract.Framework.Native;
using Neo.SmartContract.Framework.Services;

namespace R3E.Examples;

[DisplayName("LargeDataAttestation")]
[ContractPermission("*", "*")]
public class LargeDataAttestation : SmartContract
{
    private const byte Prefix_Attestation = 0x01;

    [DisplayName("DataAttested")]
    public static event System.Action<ByteString, ByteString, BigInteger> OnAttested;

    /// <summary>
    /// Pattern: contracts attest to large off-chain data by storing a hash.
    /// Verifiers fetch the data off-chain (IPFS, CDN, side-channel) and verify
    /// the hash matches before accepting.
    /// </summary>
    public static void AttestDataHash(ByteString contentId, ByteString sha256Hash, BigInteger size)
    {
        if (!Runtime.CheckWitness(GetAdmin())) throw new Exception("admin only");
        Storage.Put(Storage.CurrentContext,
            new byte[] { Prefix_Attestation }.Concat(contentId),
            StdLib.Serialize(new object[] { sha256Hash, size, Runtime.Time }));
        OnAttested(contentId, sha256Hash, size);
    }

    /// <summary>Verify that a blob of bytes matches a previously-attested hash.</summary>
    public static bool VerifyData(ByteString contentId, ByteString data)
    {
        var raw = Storage.Get(Storage.CurrentContext,
                              new byte[] { Prefix_Attestation }.Concat(contentId));
        if (raw == null) return false;
        var attest = (object[])StdLib.Deserialize(raw);
        var expected = (ByteString)attest[0];
        return CryptoLib.Sha256(data).Equals(expected);
    }

    /// <summary>
    /// For BLS / KZG style commitments, CryptoLib exposes BLS12-381 ops directly.
    /// Used by zk-rollups, threshold signatures, KZG proofs.
    /// </summary>
    public static bool VerifyBls(ByteString message, ByteString signature, ByteString publicKey)
    {
        var sig = (BLS12_381)signature;
        var pk  = (BLS12_381)publicKey;
        // Application-specific BLS verification flow
        return true;
    }

    private static UInt160 GetAdmin() => (UInt160)"0x0000000000000000000000000000000000000000";
}

Neo's Approach to Scaling

Neo emphasises high base-layer throughput rather than rollup-style data availability. For DApps that need off-chain compute or state, the canonical Neo pattern is:

1. Store hashes on-chain.
2. Use the Oracle native for verifiable off-chain data fetches.
3. Use BLS/Merkle/KZG primitives in CryptoLib for cryptographic proofs.

If/when Neo adopts a sharding model, blob-style data availability would slot in as a new transaction attribute or native contract — the architecture supports incremental extension.