diff --git a/client/client.go b/client/client.go index cf30d0b5..858b5dee 100644 --- a/client/client.go +++ b/client/client.go @@ -3,7 +3,7 @@ package client import ( "context" - "github.com/0xPolygon/cdk-data-availability/sequence" + "github.com/0xPolygon/cdk-data-availability/types" "github.com/ethereum/go-ethereum/common" ) @@ -15,7 +15,7 @@ type ClientFactoryInterface interface { // ClientInterface is the interface that defines the implementation of all the endpoints type ClientInterface interface { GetOffChainData(ctx context.Context, hash common.Hash) ([]byte, error) - SignSequence(signedSequence sequence.SignedSequence) ([]byte, error) + SignSequence(signedSequence types.SignedSequence) ([]byte, error) } // ClientFactory is the implementation of the data committee client factory diff --git a/client/datacom.go b/client/datacom.go index 40165e97..c175ac3c 100644 --- a/client/datacom.go +++ b/client/datacom.go @@ -5,12 +5,12 @@ import ( "fmt" "github.com/0xPolygon/cdk-data-availability/rpc" - "github.com/0xPolygon/cdk-data-availability/sequence" + "github.com/0xPolygon/cdk-data-availability/types" ) // SignSequence sends a request to sign the given sequence by the data committee member // if successful returns the signature. The signature should be validated after using this method! -func (c *Client) SignSequence(signedSequence sequence.SignedSequence) ([]byte, error) { +func (c *Client) SignSequence(signedSequence types.SignedSequence) ([]byte, error) { response, err := rpc.JSONRPCCall(c.url, "datacom_signSequence", signedSequence) if err != nil { return nil, err diff --git a/db/db.go b/db/db.go index 6072a067..c648dc64 100644 --- a/db/db.go +++ b/db/db.go @@ -4,8 +4,8 @@ import ( "context" "errors" - "github.com/0xPolygon/cdk-data-availability/offchaindata" "github.com/0xPolygon/cdk-data-availability/rpc" + "github.com/0xPolygon/cdk-data-availability/types" "github.com/ethereum/go-ethereum/common" "github.com/jackc/pgx/v4" "github.com/jackc/pgx/v4/pgxpool" @@ -34,7 +34,7 @@ func (db *DB) BeginStateTransaction(ctx context.Context) (pgx.Tx, error) { } // StoreOffChainData stores and array of key values in the Db -func (db *DB) StoreOffChainData(ctx context.Context, od []offchaindata.OffChainData, dbTx pgx.Tx) error { +func (db *DB) StoreOffChainData(ctx context.Context, od []types.OffChainData, dbTx pgx.Tx) error { const storeOffChainDataSQL = ` INSERT INTO data_node.offchain_data (key, value) VALUES ($1, $2) diff --git a/services/datacom/datacom.go b/services/datacom/datacom.go index b0f676ee..5b61a035 100644 --- a/services/datacom/datacom.go +++ b/services/datacom/datacom.go @@ -5,8 +5,8 @@ import ( "crypto/ecdsa" "github.com/0xPolygon/cdk-data-availability/rpc" - "github.com/0xPolygon/cdk-data-availability/sequence" "github.com/0xPolygon/cdk-data-availability/synchronizer" + "github.com/0xPolygon/cdk-data-availability/types" "github.com/jackc/pgx/v4" ) @@ -35,7 +35,7 @@ func NewDataComEndpoints( // SignSequence generates the accumulated input hash aka accInputHash of the sequence and sign it. // After storing the data that will be sent hashed to the contract, it returns the signature. // This endpoint is only accessible to the sequencer -func (d *DataComEndpoints) SignSequence(signedSequence sequence.SignedSequence) (interface{}, rpc.Error) { +func (d *DataComEndpoints) SignSequence(signedSequence types.SignedSequence) (interface{}, rpc.Error) { // Verify that the request comes from the sequencer sender, err := signedSequence.Signer() if err != nil { diff --git a/services/datacom/interfaces.go b/services/datacom/interfaces.go index 5df83b5a..b7aaffd8 100644 --- a/services/datacom/interfaces.go +++ b/services/datacom/interfaces.go @@ -3,12 +3,12 @@ package datacom import ( "context" - "github.com/0xPolygon/cdk-data-availability/offchaindata" + "github.com/0xPolygon/cdk-data-availability/types" "github.com/jackc/pgx/v4" ) // DBInterface is the interface needed by the datacom service type DBInterface interface { BeginStateTransaction(ctx context.Context) (pgx.Tx, error) - StoreOffChainData(ctx context.Context, od []offchaindata.OffChainData, dbTx pgx.Tx) error + StoreOffChainData(ctx context.Context, od []types.OffChainData, dbTx pgx.Tx) error } diff --git a/synchronizer/batches.go b/synchronizer/batches.go index fece8dce..8d1eb280 100644 --- a/synchronizer/batches.go +++ b/synchronizer/batches.go @@ -11,8 +11,8 @@ import ( "github.com/0xPolygon/cdk-data-availability/etherman" "github.com/0xPolygon/cdk-data-availability/etherman/smartcontracts/cdkvalidium" "github.com/0xPolygon/cdk-data-availability/log" - "github.com/0xPolygon/cdk-data-availability/offchaindata" "github.com/0xPolygon/cdk-data-availability/rpc" + "github.com/0xPolygon/cdk-data-availability/types" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" ) @@ -211,10 +211,10 @@ func (bs *BatchSynchronizer) handleEvent(event *cdkvalidium.CdkvalidiumSequenceB return nil } - var data []offchaindata.OffChainData + var data []types.OffChainData for _, key := range missing { log.Infof("resolving missing key %v", key.Hex()) - var value offchaindata.OffChainData + var value types.OffChainData value, err = bs.resolve(key) if err != nil { return err @@ -226,14 +226,14 @@ func (bs *BatchSynchronizer) handleEvent(event *cdkvalidium.CdkvalidiumSequenceB return store(bs.db, data) } -func (bs *BatchSynchronizer) resolve(key common.Hash) (offchaindata.OffChainData, error) { +func (bs *BatchSynchronizer) resolve(key common.Hash) (types.OffChainData, error) { log.Debugf("resolving missing data for key %v", key.Hex()) if len(bs.committee) == 0 { // committee is resolved again once all members are evicted. They can be evicted // for not having data, or their config being malformed err := bs.resolveCommittee() if err != nil { - return offchaindata.OffChainData{}, err + return types.OffChainData{}, err } } // pull out the members, iterating will change the map on error @@ -257,5 +257,5 @@ func (bs *BatchSynchronizer) resolve(key common.Hash) (offchaindata.OffChainData } return value, nil } - return offchaindata.OffChainData{}, rpc.NewRPCError(rpc.NotFoundErrorCode, "no data found for key %v", key) + return types.OffChainData{}, rpc.NewRPCError(rpc.NotFoundErrorCode, "no data found for key %v", key) } diff --git a/synchronizer/rpc.go b/synchronizer/rpc.go index 29b8d50b..02aaf90f 100644 --- a/synchronizer/rpc.go +++ b/synchronizer/rpc.go @@ -7,13 +7,13 @@ import ( "github.com/0xPolygon/cdk-data-availability/client" "github.com/0xPolygon/cdk-data-availability/etherman" "github.com/0xPolygon/cdk-data-availability/log" - "github.com/0xPolygon/cdk-data-availability/offchaindata" + "github.com/0xPolygon/cdk-data-availability/types" "github.com/ethereum/go-ethereum/common" ) const rpcTimeout = 3 * time.Second -func resolveWithMember(key common.Hash, member etherman.DataCommitteeMember) (offchaindata.OffChainData, error) { +func resolveWithMember(key common.Hash, member etherman.DataCommitteeMember) (types.OffChainData, error) { cm := client.New(member.URL) ctx, cancel := context.WithTimeout(context.Background(), rpcTimeout) defer cancel() @@ -21,7 +21,7 @@ func resolveWithMember(key common.Hash, member etherman.DataCommitteeMember) (of log.Debugf("trying member %v at %v for key %v", member.Addr.Hex(), member.URL, key.Hex()) bytes, err := cm.GetOffChainData(ctx, key) - return offchaindata.OffChainData{ + return types.OffChainData{ Key: key, Value: bytes, }, err diff --git a/synchronizer/store.go b/synchronizer/store.go index 8c211f91..3164bd59 100644 --- a/synchronizer/store.go +++ b/synchronizer/store.go @@ -6,7 +6,7 @@ import ( "github.com/0xPolygon/cdk-data-availability/db" "github.com/0xPolygon/cdk-data-availability/log" - "github.com/0xPolygon/cdk-data-availability/offchaindata" + "github.com/0xPolygon/cdk-data-availability/types" "github.com/ethereum/go-ethereum/common" "github.com/jackc/pgx/v4" ) @@ -55,7 +55,7 @@ func exists(db *db.DB, key common.Hash) bool { return db.Exists(ctx, key) } -func store(db *db.DB, data []offchaindata.OffChainData) error { +func store(db *db.DB, data []types.OffChainData) error { ctx, cancel := context.WithTimeout(context.Background(), dbTimeout) defer cancel() var ( diff --git a/test/e2e/e2e_test.go b/test/e2e/e2e_test.go index a3bb4e31..352cc143 100644 --- a/test/e2e/e2e_test.go +++ b/test/e2e/e2e_test.go @@ -6,11 +6,10 @@ import ( "errors" "testing" - "github.com/0xPolygon/cdk-data-availability/batch" "github.com/0xPolygon/cdk-data-availability/client" "github.com/0xPolygon/cdk-data-availability/config" cfgTypes "github.com/0xPolygon/cdk-data-availability/config/types" - "github.com/0xPolygon/cdk-data-availability/sequence" + "github.com/0xPolygon/cdk-data-availability/types" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/crypto" "github.com/stretchr/testify/assert" @@ -40,11 +39,11 @@ func TestSignSequence(t *testing.T) { tc, pk := initTest(t) type testSequences struct { name string - sequence sequence.SignedSequence + sequence types.SignedSequence expectedErr error } - expectedSequence := sequence.Sequence{ - Batches: []batch.Batch{ + expectedSequence := types.Sequence{ + Batches: []types.Batch{ { Number: 3, GlobalExitRoot: common.HexToHash("0x678343456734678"), @@ -69,15 +68,15 @@ func TestSignSequence(t *testing.T) { tSequences := []testSequences{ { name: "invalid_signature", - sequence: sequence.SignedSequence{ - Sequence: sequence.Sequence{}, + sequence: types.SignedSequence{ + Sequence: types.Sequence{}, Signature: common.Hex2Bytes("f00"), }, expectedErr: errors.New("-32000 failed to verify sender"), }, { name: "signature_not_from_sender", - sequence: sequence.SignedSequence{ + sequence: types.SignedSequence{ Sequence: expectedSequence, Signature: unexpectedSenderSignedSequence.Signature, }, @@ -85,12 +84,12 @@ func TestSignSequence(t *testing.T) { }, { name: "empty_batch", - sequence: sequence.SignedSequence{}, + sequence: types.SignedSequence{}, expectedErr: nil, }, { name: "success", - sequence: sequence.SignedSequence{ + sequence: types.SignedSequence{ Sequence: expectedSequence, Signature: nil, }, @@ -121,7 +120,7 @@ func newTestClient(url string, addr common.Address) *testClient { } } -func (tc *testClient) signSequence(t *testing.T, expected *sequence.SignedSequence, expectedErr error) { +func (tc *testClient) signSequence(t *testing.T, expected *types.SignedSequence, expectedErr error) { if signature, err := tc.client.SignSequence(*expected); err != nil { assert.Equal(t, expectedErr.Error(), err.Error()) } else { diff --git a/batch/batch.go b/types/batch.go similarity index 99% rename from batch/batch.go rename to types/batch.go index e22e4752..317ff516 100644 --- a/batch/batch.go +++ b/types/batch.go @@ -1,4 +1,4 @@ -package batch +package types import ( "crypto/ecdsa" diff --git a/batch/batch_test.go b/types/batch_test.go similarity index 98% rename from batch/batch_test.go rename to types/batch_test.go index 30a2fa1c..f874a848 100644 --- a/batch/batch_test.go +++ b/types/batch_test.go @@ -1,4 +1,4 @@ -package batch +package types import ( "crypto/ecdsa" @@ -11,7 +11,7 @@ import ( "github.com/stretchr/testify/require" ) -var testCases = []Batch{ +var testBatchCases = []Batch{ { L2Data: common.Hex2Bytes(""), GlobalExitRoot: common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"), @@ -44,14 +44,14 @@ var testCases = []Batch{ }, } -func TestSigning(t *testing.T) { +func TestBatchSigning(t *testing.T) { privKeys := []*ecdsa.PrivateKey{} for i := 0; i < 5; i++ { pk, err := crypto.GenerateKey() require.NoError(t, err) privKeys = append(privKeys, pk) } - for _, c := range testCases { + for _, c := range testBatchCases { for _, pk := range privKeys { signedBatch, err := c.Sign(pk) require.NoError(t, err) diff --git a/offchaindata/offchaindata.go b/types/offchaindata.go similarity index 90% rename from offchaindata/offchaindata.go rename to types/offchaindata.go index 17025217..4a162a7a 100644 --- a/offchaindata/offchaindata.go +++ b/types/offchaindata.go @@ -1,4 +1,4 @@ -package offchaindata +package types import "github.com/ethereum/go-ethereum/common" diff --git a/sequence/sequence.go b/types/sequence.go similarity index 88% rename from sequence/sequence.go rename to types/sequence.go index daf7cd5b..60f2ba0b 100644 --- a/sequence/sequence.go +++ b/types/sequence.go @@ -1,4 +1,4 @@ -package sequence +package types import ( "crypto/ecdsa" @@ -6,8 +6,6 @@ import ( "math/big" "strings" - "github.com/0xPolygon/cdk-data-availability/batch" - "github.com/0xPolygon/cdk-data-availability/offchaindata" "github.com/0xPolygon/cdk-data-availability/rpc" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/crypto" @@ -21,8 +19,8 @@ const ( // Sequence represents the data that the sequencer will send to L1 // and other metadata needed to build the accumulated input hash aka accInputHash type Sequence struct { - Batches []batch.Batch `json:"batches"` - OldAccInputHash common.Hash `json:"oldAccInputhash"` + Batches []Batch `json:"batches"` + OldAccInputHash common.Hash `json:"oldAccInputhash"` } // HashToSign returns the accumulated input hash of the sequence. @@ -88,10 +86,10 @@ func (s *Sequence) Sign(privateKey *ecdsa.PrivateKey) (*SignedSequence, error) { } // OffChainData returns the data that needs to be stored off chain from a given sequence -func (s *Sequence) OffChainData() []offchaindata.OffChainData { - od := []offchaindata.OffChainData{} +func (s *Sequence) OffChainData() []OffChainData { + od := []OffChainData{} for _, b := range s.Batches { - od = append(od, offchaindata.OffChainData{ + od = append(od, OffChainData{ Key: crypto.Keccak256Hash(b.L2Data), Value: b.L2Data, }) diff --git a/sequence/sequence_test.go b/types/sequence_test.go similarity index 97% rename from sequence/sequence_test.go rename to types/sequence_test.go index e7abe2b8..2a59f0d1 100644 --- a/sequence/sequence_test.go +++ b/types/sequence_test.go @@ -1,10 +1,9 @@ -package sequence +package types import ( "crypto/ecdsa" "testing" - "github.com/0xPolygon/cdk-data-availability/batch" "github.com/0xPolygon/cdk-data-availability/rpc" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/crypto" @@ -12,16 +11,16 @@ import ( "github.com/stretchr/testify/require" ) -type testCase struct { +type testSequenceCase struct { s Sequence expectedHash common.Hash } -var testCases = []testCase{ +var testSequenceCases = []testSequenceCase{ { s: Sequence{ OldAccInputHash: common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"), - Batches: []batch.Batch{ + Batches: []Batch{ { L2Data: common.Hex2Bytes(""), GlobalExitRoot: common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"), @@ -41,7 +40,7 @@ var testCases = []testCase{ { s: Sequence{ OldAccInputHash: common.HexToHash("0x2fc6a6ec18e61a98867a2536c306ca7fbdc4da2febd671d9de8fad50b56c6a16"), - Batches: []batch.Batch{ + Batches: []Batch{ { L2Data: common.Hex2Bytes("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"), GlobalExitRoot: common.HexToHash("0xbd6ad630a17775e238d412044d37868838687ba4c6346b917551f4f60def4a2a"), @@ -67,7 +66,7 @@ var testCases = []testCase{ } func TestHashToSign(t *testing.T) { - for _, c := range testCases { + for _, c := range testSequenceCases { assert.Equal( t, c.expectedHash.Hex(), "0x"+common.Bytes2Hex(c.s.HashToSign()), @@ -82,7 +81,7 @@ func TestSigning(t *testing.T) { require.NoError(t, err) privKeys = append(privKeys, pk) } - for _, c := range testCases { + for _, c := range testSequenceCases { for _, pk := range privKeys { signedSequence, err := c.s.Sign(pk) require.NoError(t, err)