eth-pos-devnet-validator-1:could not validate blob data availability: can't verify opening proof

[qymlyl]

description

send blob transaction without generating block

consensus/config.yml

docker-compose.yml

problem

send blob transaction without generating block

eth-pos-devnet-geth-1

eth-pos-devnet-beacon-chain-1

eth-pos-devnet-validator-1

[qymlyl]

testcode

package blob_tx

import (
    "fmt"
    "log"
    testing2 "testing"
)

const (
    localnetRpcUrl = "http://192.168.3.173:8645" // mainnet rpc url
    to             = "0x12630d738344a01AbD32EE8AcaF85985c9c59fD6"
    data           = "0x014567890123456bbb"
    privKey        = "2e0834786285daccd064ca17f1654f67b4aef298acbb82cef9ec422fb4975622"
    from           = "0xE25583099BA105D9ec0A67f5Ae86D90e50036425"
)

func TestSendBlobTX(t *testing2.T) {

    fmt.Println("using ethclient...")

    blob, err := SendBlobTX(localnetRpcUrl, to, data, privKey)

    if err != nil {
        log.Fatalln(err)
    }

    fmt.Println("\nBlob transaction hash:", blob) // This was just added.
}

send_tx

package blob_tx

import (
    "context"
    "fmt"
    "regexp"
    "strings"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/common/hexutil"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/crypto/kzg4844"
    "github.com/ethereum/go-ethereum/ethclient"
    "github.com/holiman/uint256"
)

// SendBlobTX sends a transaction with an EIP-4844 blob payload to the Ethereum network.

func SendBlobTX(rpcURL, toAddress, data, privKey string) (string, error) {
    // Connect to the Ethereum client
    client, err := ethclient.Dial(rpcURL)
    if err != nil {
        return "", fmt.Errorf("failed to dial RPC client: %s", err)
    }
    defer client.Close() // Ensure the connection is closed after completing the function

    // Retrieve the current chain ID
    chainID, err := client.ChainID(context.Background())
    if err != nil {
        return "", fmt.Errorf("failed to get chain ID: %s", err)
    }

    var Blob [131072]byte // Define a blob array to hold the large data payload, blobs are 128kb in length

    // If necessary, convert the input data to a byte slice in hex format
    var bytesData []byte
    if data != "" {
        // Check if the data is in hex format, with or without the '0x' prefix
        if IsHexWithOrWithout0xPrefix(data) {
            // Ensure the data has the '0x' prefix
            if !strings.HasPrefix(data, "0x") {
                data = "0x" + data
            }
            // Decode the hex-encoded data
            bytesData, err = hexutil.Decode(data)
            if err != nil {
                return "", fmt.Errorf("failed to decode data: %s", err)
            }
            // Copy the decoded data into the blob array
            copy(Blob[:], bytesData)
        } else {
            // If the data is not in hex format, copy it directly into the blob array
            copy(Blob[:], data)
        }
    }

    // Compute the commitment for the blob data using KZG4844 cryptographic algorithm
    BlobCommitment, err := kzg4844.BlobToCommitment(Blob)
    if err != nil {
        return "", fmt.Errorf("failed to compute blob commitment: %s", err)
    }

    // Compute the proof for the blob data, which will be used to verify the transaction
    BlobProof, err := kzg4844.ComputeBlobProof(Blob, BlobCommitment)
    if err != nil {
        return "", fmt.Errorf("failed to compute blob proof: %s", err)
    }

    // Prepare the sidecar data for the transaction, which includes the blob and its cryptographic proof
    sidecar := types.BlobTxSidecar{
        Blobs:       []kzg4844.Blob{Blob},
        Commitments: []kzg4844.Commitment{BlobCommitment},
        Proofs:      []kzg4844.Proof{BlobProof},
    }

    // Decode the sender's private key
    pKeyBytes, err := hexutil.Decode("0x" + privKey)
    if err != nil {
        return "", fmt.Errorf("failed to decode private key: %s", err)
    }

    // Convert the private key into the ECDSA format
    ecdsaPrivateKey, err := crypto.ToECDSA(pKeyBytes)
    if err != nil {
        return "", fmt.Errorf("failed to convert private key to ECDSA: %s", err)
    }

    // Compute the sender's address from the public key
    fromAddress := crypto.PubkeyToAddress(ecdsaPrivateKey.PublicKey)

    // Retrieve the nonce for the transaction
    nonce, err := client.PendingNonceAt(context.Background(), fromAddress)

    if err != nil {
        return "", fmt.Errorf("failed to get nonce: %s", err)
    }

    // Create the transaction with the blob data and cryptographic proofs
    tx := types.NewTx(&types.BlobTx{
        ChainID:    uint256.MustFromBig(chainID),
        Nonce:      nonce,
        GasTipCap:  uint256.NewInt(1e10),           // max priority fee per gas
        GasFeeCap:  uint256.NewInt(50e10),          // max fee per gas
        Gas:        250000,                         // gas limit for the transaction
        To:         common.HexToAddress(toAddress), // recipient's address
        Value:      uint256.NewInt(0),              // value transferred in the transaction
        Data:       nil,                            // No additional data is sent in this transaction
        BlobFeeCap: uint256.NewInt(3e10),           // fee cap for the blob data
        BlobHashes: sidecar.BlobHashes(),           // blob hashes in the transaction
        Sidecar:    &sidecar,                       // sidecar data in the transaction
    })

    fmt.Println("Type: ", tx.Type())
    //fmt.Println("BlobTxSidecar: ", tx.BlobTxSidecar())

    // Sign the transaction with the sender's private key
    signedTx, err := types.SignTx(tx, types.LatestSignerForChainID(chainID), ecdsaPrivateKey)

    if err != nil {
        return "", fmt.Errorf("failed to sign transaction: %s", err)
    }

    // Send the signed transaction to the Ethereum network
    if err = client.SendTransaction(context.Background(), signedTx); err != nil {
        return "", fmt.Errorf("failed to send transaction: %s", err)
    }

    // Return the transaction hash
    txHash := signedTx.Hash().Hex()

    return txHash, nil
}

// IsHexWithOrWithout0xPrefix checks if a string is hex with or without `0x` prefix using regular expression.
func IsHexWithOrWithout0xPrefix(data string) bool {
    pattern := `^(0x)?[0-9a-fA-F]+$`
    matched, _ := regexp.MatchString(pattern, data)
    return matched
}

[nisdas]

You need to initialize with the correct trusted setup

[qymlyl]

You need to initialize with the correct trusted setup Maybe the image version is old. The latest image can send blob type transactions