rm blob verification precompile

use point eval in future integrations

Author: jagdeep sidhu

core/vm/contracts.go

@@ -1078,65 +1078,9 @@ func (c *datahash) Run(input []byte, interpreter *EVMInterpreter) ([]byte, error
 }
 
 var PrecompiledContractsDanksharding = map[common.Address]PrecompiledContract{
-	common.BytesToAddress([]byte{0x13}): &blobVerification{},
 	common.BytesToAddress([]byte{0x14}): &pointEvaluation{},
 }
 
-var (
-	errBlobVerificationInputLength = errors.New("invalid input length")
-	errInvalidVersionedHash        = errors.New("invalid versioned hash")
-	errInvalidChunk                = errors.New("invalid chunk")
-	errBadBlobCommitment           = errors.New("versioned hash did not match")
-)
-
-// DOCDOC
-type blobVerification struct{}
-
-// RequiredGas returns the gas required to execute the pre-compiled contract.
-func (c *blobVerification) RequiredGas(input []byte) uint64 {
-	// 4096 (4096*32 + 32) is base gas (BlobVerificationGas), anything above should scale up the cost
-	return params.BlobVerificationGas * (uint64(len(input)) / 131104)
-}
-
-func (c *blobVerification) Run(input []byte, interpreter *EVMInterpreter) ([]byte, error) {
-	if len(input) < 32+(32*32) || len(input) > 32+(32*params.FieldElementsPerBlob) {
-		return nil, errBlobVerificationInputLength
-	}
-
-	var expectedVersionedHash [32]byte
-	copy(expectedVersionedHash[:], input[:32])
-	if expectedVersionedHash[0] != params.BlobCommitmentVersionKZG {
-		return nil, errInvalidVersionedHash
-	}
-
-	input = input[32:] // skip forward to the input points
-	lenInput := len(input)
-	if (lenInput % 32) != 0 {
-		return nil, errInvalidChunk
-	}
-	numElements := lenInput / 32
-	inputPoints := make([]bls.Fr, params.FieldElementsPerBlob)
-	var inputPoint [32]byte
-	for i := 0; i < numElements; i++ {
-		copy(inputPoint[:32], input[i*32:(i+1)*32])
-		ok := bls.FrFrom32(&inputPoints[i], inputPoint)
-		if !ok {
-			return nil, errInvalidChunk
-		}
-	}
-
-	// Get versioned hash out of input points
-	commitment := kzg.BlobToKzg(inputPoints)
-	var compressedCommitment types.KZGCommitment
-	copy(compressedCommitment[:], bls.ToCompressedG1(commitment))
-
-	versionedHash := compressedCommitment.ComputeVersionedHash()
-	if versionedHash != expectedVersionedHash {
-		return nil, errBadBlobCommitment
-	}
-
-	return []byte{}, nil
-}
 
 // DOCDOC
 type pointEvaluation struct{}
@@ -1149,6 +1093,7 @@ var (
 	errPointEvaluationInvalidProof          = errors.New("invalid proof")
 	errPointEvaluationMismatchVersionedHash = errors.New("mismatched versioned hash")
 	errPointEvaluationBadProof              = errors.New("bad proof")
+	errInvalidVersionedHash        = errors.New("invalid versioned hash")
 )
 
 // RequiredGas returns the gas required to execute the pre-compiled contract.

core/vm/contracts_test.go

@@ -66,7 +66,6 @@ var allPrecompiles = map[common.Address]PrecompiledContract{
 	common.BytesToAddress([]byte{16}):   &bls12381Pairing{},
 	common.BytesToAddress([]byte{17}):   &bls12381MapG1{},
 	common.BytesToAddress([]byte{18}):   &bls12381MapG2{},
-	common.BytesToAddress([]byte{0x19}): &blobVerification{},
 	common.BytesToAddress([]byte{0x20}): &pointEvaluation{},
 }
 
@@ -398,5 +397,4 @@ func BenchmarkPrecompiledBLS12381G2MultiExpWorstCase(b *testing.B) {
 	benchmarkPrecompiled("0f", testcase, b)
 }
 
-func TestPrecompiledBlobVerification(t *testing.T) { testJson("blobVerification", "0x19", t) }
 func TestPrecompiledPointEvaluation(t *testing.T)  { testJson("pointEvaluation", "0x20", t) }

core/vm/testdata/precompiles/blobVerification.json

@@ -162,7 +162,6 @@ const (
 	SYSDataHashGas uint64 = 1400 // The cost of data hash retrieval
 
 	FieldElementsPerBlob            = 65536 // each field element is 32 bytes
-	BlobVerificationGas      uint64 = 1800000
 	BlobCommitmentVersionKZG uint8  = 0x01
 	PointEvaluationGas       uint64 = 50000
 )

params/protocol_params.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"io/ioutil"
 	"math"
-	"strings"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -238,38 +237,6 @@ func TestVerify(t *testing.T) {
 	}
 }
 
-// Helper: Create test vector for the BlobVerification precompile
-func TestBlobVerificationTestVector(t *testing.T) {
-	data := []byte(strings.Repeat("HELPMELOVEME ", 322639))[:params.FieldElementsPerBlob*32]
-	t.Logf("test-vector: %x", data)
-	inputPoints := make([]bls.Fr, params.FieldElementsPerBlob)
-
-	var inputPoint [32]byte
-	for i := 0; i < params.FieldElementsPerBlob; i++ {
-		copy(inputPoint[:32], data[i*32:(i+1)*32])
-		ok := bls.FrFrom32(&inputPoints[i], inputPoint)
-		if !ok {
-			t.Fatalf("Invalid chunk")
-		}
-	}
-
-	var commitment types.KZGCommitment
-	copy(commitment[:], bls.ToCompressedG1(kzg.BlobToKzg(inputPoints)))
-	versionedHash := commitment.ComputeVersionedHash()
-
-	calldata := append(versionedHash[:], data[:]...)
-	//t.Logf("test-vector: %x", calldata)
-
-	precompile := vm.PrecompiledContractsDanksharding[common.BytesToAddress([]byte{0x13})]
-	if _, err := precompile.Run(calldata, nil); err != nil {
-		t.Fatalf("expected blob verification to succeed")
-	}
-	// change a byte of the versioned hash
-	calldata[3] ^= 42
-	if _, err := precompile.Run(calldata, nil); err == nil {
-		t.Fatalf("expected blob verification to fail")
-	}
-}
 
 // Helper: Create test vector for the PointEvaluation precompile
 func TestPointEvaluationTestVector(t *testing.T) {