test basic kzg usage from sys core

syscoin · Jun 2, 2022 · 7f691b2 · 7f691b2
1 parent 439bd64
commit 7f691b2
Show file tree

Hide file tree

Showing 7 changed files with 94 additions and 68 deletions.
diff --git a/core/types/data_blob.go b/core/types/data_blob.go
@@ -122,7 +122,7 @@ func (n *NEVMBlob) FromWire(NEVMBlobWire *wire.NEVMBlob) error {
 	if lenBlob%32 != 0 {
 		return errors.New("Blob should be a factor of 32")
 	}
-	n.Blob = make([]bls.Fr, params.FieldElementsPerBlob)
+	n.Blob = make([]bls.Fr, params.FieldElementsPerBlob, params.FieldElementsPerBlob)
 	numElements := lenBlob/32
 	var inputPoint [32]byte
 	for i := 0; i < numElements; i++ {
@@ -148,7 +148,7 @@ func (n *NEVMBlob) FromBytes(blob []byte) error {
 	if lenBlob%32 != 0 {
 		return errors.New("Blob should be a factor of 32")
 	}
-	n.Blob = make([]bls.Fr, params.FieldElementsPerBlob)
+	n.Blob = make([]bls.Fr, params.FieldElementsPerBlob, params.FieldElementsPerBlob)
 	numElements := lenBlob/32
 	var inputPoint [32]byte
 	for i := 0; i < numElements; i++ {
@@ -163,7 +163,7 @@ func (n *NEVMBlob) FromBytes(blob []byte) error {
 	n.Commitment = kzg.BlobToKzg(n.Blob)
 	// need the full field elements array above to properly calculate and validate blob to kzg, 
 	// can splice it after for network purposes and later when deserializing will again create full elements array to input spliced data from network
-	n.Blob = n.Blob[0:lenBlob]
+	n.Blob = n.Blob[0:numElements]
 	var compressedCommitment KZGCommitment
 	copy(compressedCommitment[:], bls.ToCompressedG1(n.Commitment))
 	n.VersionHash = compressedCommitment.ComputeVersionedHash()
@@ -189,13 +189,11 @@ func (n *NEVMBlob) Serialize() ([]byte, error) {
 	NEVMBlobWire.VersionHash = n.VersionHash.Bytes()
 	var tmpCommit KZGCommitment
 	lenBlobData := len(n.Blob)*32
-	NEVMBlobWire.Blob = make([]byte, tmpCommit.FixedLength(), lenBlobData + int(tmpCommit.FixedLength()) )
-	copy(NEVMBlobWire.Blob[:], bls.ToCompressedG1(n.Commitment))
+	NEVMBlobWire.Blob = make([]byte, 0, lenBlobData + int(tmpCommit.FixedLength()) )
+	NEVMBlobWire.Blob = append(NEVMBlobWire.Blob, bls.ToCompressedG1(n.Commitment)...)
 	for _, fr := range n.Blob {
 		bBytes := bls.FrTo32(&fr)
-		sliceBytes := make([]byte, 32)
-		copy(sliceBytes[:], bBytes[:])
-		NEVMBlobWire.Blob = append(NEVMBlobWire.Blob, sliceBytes...)
+		NEVMBlobWire.Blob = append(NEVMBlobWire.Blob, bBytes[:]...)
 	}
 	var buffer bytes.Buffer
 	err = NEVMBlobWire.Serialize(&buffer)
@@ -216,10 +214,12 @@ func (n *NEVMBlobs) Deserialize(bytesIn []byte) error {
 	numBlobs := len(NEVMBlobsWire.Blobs)
 	n.Blobs = make([]*NEVMBlob, numBlobs)
 	for i := 0; i < int(numBlobs); i++ {
-		err = n.Blobs[i].FromWire(NEVMBlobsWire.Blobs[i])
+		var blob NEVMBlob
+		err = blob.FromWire(NEVMBlobsWire.Blobs[i])
 		if err != nil {
 			return err
 		}
+		n.Blobs[i] = &blob
 	}
 	return nil
 }

diff --git a/crypto/kzg/kzg.go b/crypto/kzg/kzg.go
@@ -103,9 +103,19 @@ type JSONTrustedSetup struct {
 }
 
 // Initialize KZG subsystem (load the trusted setup data)
-func init() {
+func SetupKZG() {
+	var parsedSetup = JSONTrustedSetup{}
+	// TODO: This is dirty. KZG setup should be loaded using an actual config file directive
+	err := json.Unmarshal([]byte(KZGSetupStr), &parsedSetup)
+	if err != nil {
+		panic(err)
+	}
+	KzgSetupG2 = parsedSetup.SetupG2
+	KzgSetupLagrange = parsedSetup.SetupLagrange
+	KzgSetupG1 = parsedSetup.SetupG1
+}
+/*func init() {
 	var parsedSetup = JSONTrustedSetup{}
-
 	// TODO: This is dirty. KZG setup should be loaded using an actual config file directive
 	err := json.Unmarshal([]byte(KZGSetupStr), &parsedSetup)
 	if err != nil {
@@ -114,4 +124,4 @@ func init() {
 	KzgSetupG2 = parsedSetup.SetupG2
 	KzgSetupLagrange = parsedSetup.SetupLagrange
 	KzgSetupG1 = parsedSetup.SetupG1
-}
+}*/
diff --git a/eth/zmqpubsub.go b/eth/zmqpubsub.go
@@ -23,6 +23,7 @@ import (
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/go-zeromq/zmq4"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto/kzg"
 	"strconv"
 )
 
@@ -32,6 +33,7 @@ type ZMQRep struct {
 	rep            zmq4.Socket
 	nevmIndexer    NEVMIndex
 	inited         bool
+	kzgloaded         bool
 }
 
 func (zmq *ZMQRep) Close() {
@@ -118,42 +120,42 @@ func (zmq *ZMQRep) Init(nevmEP string) error {
 				zmq.rep.SendMulti(msgSend)
 			} else if strTopic == "nevmcheckblobs" {
 				result := "success"
-				var nevmBlobs types.NEVMBlobs
-				err = nevmBlobs.Deserialize(msg.Frames[1])
-				if err != nil {
-					log.Error("nevmcheckblobsSub Deserialize", "err", err)
-					result = err.Error()
+				if zmq.kzgloaded == false {
+					result = "KZG not initialized, please try again later..."
 				} else {
-					err = nevmBlobs.Verify()
+					var nevmBlobs types.NEVMBlobs
+					err = nevmBlobs.Deserialize(msg.Frames[1])
 					if err != nil {
-						log.Error("nevmcheckblobsSub VerifyData", "err", err)
+						log.Error("nevmcheckblobsSub Deserialize", "err", err)
 						result = err.Error()
+					} else {
+						err = nevmBlobs.Verify()
+						if err != nil {
+							log.Error("nevmcheckblobsSub VerifyData", "err", err)
+							result = err.Error()
+						}
 					}
 				}
 				msgSend := zmq4.NewMsgFrom([]byte("nevmcheckblobs"), []byte(result))
 				zmq.rep.SendMulti(msgSend)
 			} else if strTopic == "nevmcreateblob" {
 				var nevmBlobBytes []byte
 				var nevmBlob types.NEVMBlob
-				err = nevmBlob.FromBytes(msg.Frames[1])
-				if err != nil {
-					log.Error("nevmcreateblob Deserialize", "err", err)
+				if zmq.kzgloaded == false {
 					nevmBlobBytes = make([]byte, 0)
 				} else {
-					var blobs types.NEVMBlobs
-					blobs.Blobs = make([]*types.NEVMBlob, 1)
-					blobs.Blobs[0] = &nevmBlob
-					err = blobs.Verify()
+					err = nevmBlob.FromBytes(msg.Frames[1])
 					if err != nil {
-						log.Error("nevmcreateblob VerifyData", "err", err)
+						log.Error("nevmcreateblob Deserialize", "err", err)
 						nevmBlobBytes = make([]byte, 0)
+					} else {
+						nevmBlobBytes, err = nevmBlob.Serialize()
+						if err != nil {
+							log.Error("nevmcreateblob", "err", err)
+							nevmBlobBytes = make([]byte, 0)
+						}
 					}
 				}
-				nevmBlobBytes, err := nevmBlob.Serialize()
-				if err != nil {
-					log.Error("nevmcreateblob", "err", err)
-					nevmBlobBytes = make([]byte, 0)
-				}
 				msgSend := zmq4.NewMsgFrom([]byte("nevmcreateblob"), nevmBlobBytes)
 				zmq.rep.SendMulti(msgSend)
 			} 
@@ -171,6 +173,11 @@ func NewZMQRep(stackIn *node.Node, ethIn *Ethereum, NEVMPubEP string, nevmIndexe
 		rep:            zmq4.NewRep(ctx),
 		nevmIndexer:    nevmIndexerIn,
 	}
+	log.Info("zmq Init")
 	zmq.Init(NEVMPubEP)
+	log.Info("Setup KZG")
+	kzg.SetupKZG()
+	log.Info("Setup KZG Done!")
+	zmq.kzgloaded = true
 	return zmq
 }
diff --git a/go.mod b/go.mod
@@ -62,7 +62,7 @@ require (
 	github.com/status-im/keycard-go v0.0.0-20190316090335-8537d3370df4
 	github.com/stretchr/testify v1.7.0
 	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7
-	github.com/syscoin/btcd v0.0.0-20220524063342-4ef6e5fee929
+	github.com/syscoin/btcd v0.0.0-20220602033731-acb16df49df2
 	github.com/tklauser/go-sysconf v0.3.5 // indirect
 	github.com/tyler-smith/go-bip39 v1.0.1-0.20181017060643-dbb3b84ba2ef
 	golang.org/x/crypto v0.0.0-20210921155107-089bfa567519

diff --git a/go.sum b/go.sum
@@ -418,8 +418,8 @@ github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5Cc
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
-github.com/syscoin/btcd v0.0.0-20220524063342-4ef6e5fee929 h1:Suo+cisPvOtBq0TxGy4P+iluDqNqEN58tyDFmhZkhIQ=
-github.com/syscoin/btcd v0.0.0-20220524063342-4ef6e5fee929/go.mod h1:xr4h8KaM4ibpFGPLDJLRhjZtKZet/Q14YgPk3T0F9FE=
+github.com/syscoin/btcd v0.0.0-20220602033731-acb16df49df2  h1:3lyb+8he+jhGe7Fj9ehgg+9L704aEbdQ+IZiYuG95PM=
+github.com/syscoin/btcd v0.0.0-20220602033731-acb16df49df2/go.mod h1:xr4h8KaM4ibpFGPLDJLRhjZtKZet/Q14YgPk3T0F9FE=
 github.com/tinylib/msgp v1.0.2/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE=
 github.com/tklauser/go-sysconf v0.3.5 h1:uu3Xl4nkLzQfXNsWn15rPc/HQCJKObbt1dKJeWp3vU4=
 github.com/tklauser/go-sysconf v0.3.5/go.mod h1:MkWzOF4RMCshBAMXuhXJs64Rte09mITnppBXY/rYEFI=

diff --git a/les/zmqpubsub.go b/les/zmqpubsub.go
@@ -23,15 +23,17 @@ import (
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/go-zeromq/zmq4"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto/kzg"
 	"strconv"
 )
 
 type ZMQRep struct {
 	stack 	  	   *node.Node
-	leth           *LightEthereum
+	eth            *LightEthereum
 	rep            zmq4.Socket
 	nevmIndexer    LightNEVMIndex
 	inited         bool
+	kzgloaded      bool
 }
 
 func (zmq *ZMQRep) Close() {
@@ -70,7 +72,7 @@ func (zmq *ZMQRep) Init(nevmEP string) error {
 					return
 				}
 				if string(msg.Frames[1]) == "\fstartnetwork" {
-					zmq.leth.Downloader().StartNetworkEvent()
+					zmq.eth.Downloader().StartNetworkEvent()
 				}
 				msgSend := zmq4.NewMsgFrom([]byte("nevmcomms"), []byte("ack"))
 				zmq.rep.SendMulti(msgSend)
@@ -82,7 +84,7 @@ func (zmq *ZMQRep) Init(nevmEP string) error {
 					log.Error("addBlockSub Deserialize", "err", err)
 					result = err.Error()
 				} else {
-					err = zmq.nevmIndexer.AddBlock(&nevmBlockConnect, zmq.leth)
+					err = zmq.nevmIndexer.AddBlock(&nevmBlockConnect, zmq.eth)
 					if err != nil {
 						log.Error("addBlockSub AddBlock", "err", err)
 						result = err.Error()
@@ -92,9 +94,10 @@ func (zmq *ZMQRep) Init(nevmEP string) error {
 				zmq.rep.SendMulti(msgSend)
 			} else if strTopic == "nevmdisconnect" {
 				result := "disconnected"
-				errMsg := zmq.nevmIndexer.DeleteBlock(string(msg.Frames[1]), zmq.leth)
-				if errMsg != nil {
-					result = errMsg.Error()
+				err := zmq.nevmIndexer.DeleteBlock(string(msg.Frames[1]), zmq.eth)
+				if err != nil {
+					log.Error("deleteBlockSub", "err", err)
+					result = err.Error()
 				}
 				msgSend := zmq4.NewMsgFrom([]byte("nevmdisconnect"), []byte(result))
 				zmq.rep.SendMulti(msgSend)
@@ -103,65 +106,69 @@ func (zmq *ZMQRep) Init(nevmEP string) error {
 				msgSend := zmq4.NewMsgFrom([]byte("nevmblock"), nevmBlockConnectBytes)
 				zmq.rep.SendMulti(msgSend)
 			}  else if strTopic == "nevmblockinfo" {
-				str := strconv.FormatUint(zmq.leth.blockchain.CurrentHeader().Number.Uint64(), 10)
+				str := strconv.FormatUint(zmq.eth.blockchain.CurrentHeader().Number.Uint64(), 10)
 				msgSend := zmq4.NewMsgFrom([]byte("nevmblockinfo"), []byte(str))
 				zmq.rep.SendMulti(msgSend)
 			} else if strTopic == "nevmcheckblobs" {
 				result := "success"
-				var nevmBlobs types.NEVMBlobs
-				err = nevmBlobs.Deserialize(msg.Frames[1])
-				if err != nil {
-					log.Error("nevmcheckblobsSub Deserialize", "err", err)
-					result = err.Error()
+				if zmq.kzgloaded == false {
+					result = "KZG not initialized, please try again later..."
 				} else {
-					err = nevmBlobs.Verify()
+					var nevmBlobs types.NEVMBlobs
+					err = nevmBlobs.Deserialize(msg.Frames[1])
 					if err != nil {
-						log.Error("nevmcheckblobsSub VerifyData", "err", err)
+						log.Error("nevmcheckblobsSub Deserialize", "err", err)
 						result = err.Error()
+					} else {
+						err = nevmBlobs.Verify()
+						if err != nil {
+							log.Error("nevmcheckblobsSub VerifyData", "err", err)
+							result = err.Error()
+						}
 					}
 				}
 				msgSend := zmq4.NewMsgFrom([]byte("nevmcheckblobs"), []byte(result))
 				zmq.rep.SendMulti(msgSend)
 			} else if strTopic == "nevmcreateblob" {
 				var nevmBlobBytes []byte
 				var nevmBlob types.NEVMBlob
-				// pass in blob and return nevm blob including kzg information
-				err = nevmBlob.FromBytes(msg.Frames[1])
-				if err != nil {
-					log.Error("nevmcreateblob Deserialize", "err", err)
+				if zmq.kzgloaded == false {
 					nevmBlobBytes = make([]byte, 0)
 				} else {
-					var blobs types.NEVMBlobs
-					blobs.Blobs = make([]*types.NEVMBlob, 1)
-					blobs.Blobs[0] = &nevmBlob
-					err = blobs.Verify()
+					err = nevmBlob.FromBytes(msg.Frames[1])
 					if err != nil {
-						log.Error("nevmcreateblob VerifyData", "err", err)
+						log.Error("nevmcreateblob Deserialize", "err", err)
 						nevmBlobBytes = make([]byte, 0)
+					} else {
+						nevmBlobBytes, err = nevmBlob.Serialize()
+						if err != nil {
+							log.Error("nevmcreateblob", "err", err)
+							nevmBlobBytes = make([]byte, 0)
+						}
 					}
 				}
-				nevmBlobBytes, err := nevmBlob.Serialize()
-				if err != nil {
-					log.Error("nevmcreateblob", "err", err)
-					nevmBlobBytes = make([]byte, 0)
-				}
 				msgSend := zmq4.NewMsgFrom([]byte("nevmcreateblob"), nevmBlobBytes)
 				zmq.rep.SendMulti(msgSend)
-			}
+			} 
 		}
 	}(zmq)
 	zmq.inited = true
 	return nil
 }
 
-func NewZMQRep(stackIn *node.Node, lethIn *LightEthereum, NEVMPubEP string, nevmIndexerIn LightNEVMIndex) *ZMQRep {
+func NewZMQRep(stackIn *node.Node, ethIn *LightEthereum, NEVMPubEP string, nevmIndexerIn LightNEVMIndex) *ZMQRep {
 	ctx := context.Background()
 	zmq := &ZMQRep{
 		stack:			stackIn,
-		leth:           lethIn,
+		eth:            ethIn,
 		rep:            zmq4.NewRep(ctx),
 		nevmIndexer:    nevmIndexerIn,
 	}
+	log.Info("zmq Init")
 	zmq.Init(NEVMPubEP)
+	log.Info("Setup KZG")
+	kzg.SetupKZG()
+	log.Info("Setup KZG Done!")
+	zmq.kzgloaded = true
 	return zmq
 }
diff --git a/tests/kzg_test.go b/tests/kzg_test.go
@@ -17,7 +17,6 @@ import (
 	gokzg "github.com/protolambda/go-kzg"
 	"github.com/protolambda/go-kzg/bls"
 )
-
 // Helper: invert the divisor, then multiply
 func polyFactorDiv(dst *bls.Fr, a *bls.Fr, b *bls.Fr) {
 	// TODO: use divmod instead.
@@ -246,7 +245,10 @@ func TestBlobVerificationTestVector(t *testing.T) {
 	var inputPoint [32]byte
 	for i := 0; i < params.FieldElementsPerBlob; i++ {
 		copy(inputPoint[:32], data[i*32:(i+1)*32])
-		bls.FrFrom32(&inputPoints[i], inputPoint)
+		ok := bls.FrFrom32(&inputPoints[i], inputPoint)
+		if !ok {
+			t.Fatalf("Invalid chunk")
+		}
 	}
 
 	var commitment types.KZGCommitment