github.com/0xPolygon/supernets2-node@v0.0.0-20230711153321-2fe574524eaa/state/state_test.go (about) 1 package state_test 2 3 import ( 4 "context" 5 "encoding/json" 6 "fmt" 7 "io" 8 "math" 9 "math/big" 10 "os" 11 "path/filepath" 12 "strconv" 13 "strings" 14 "testing" 15 "time" 16 17 "github.com/0xPolygon/supernets2-node/db" 18 "github.com/0xPolygon/supernets2-node/encoding" 19 "github.com/0xPolygon/supernets2-node/event" 20 "github.com/0xPolygon/supernets2-node/event/nileventstorage" 21 "github.com/0xPolygon/supernets2-node/hex" 22 "github.com/0xPolygon/supernets2-node/log" 23 "github.com/0xPolygon/supernets2-node/merkletree" 24 mtDBclientpb "github.com/0xPolygon/supernets2-node/merkletree/pb" 25 "github.com/0xPolygon/supernets2-node/state" 26 "github.com/0xPolygon/supernets2-node/state/metrics" 27 "github.com/0xPolygon/supernets2-node/state/runtime" 28 "github.com/0xPolygon/supernets2-node/state/runtime/executor" 29 executorclientpb "github.com/0xPolygon/supernets2-node/state/runtime/executor/pb" 30 "github.com/0xPolygon/supernets2-node/test/contracts/bin/Counter" 31 "github.com/0xPolygon/supernets2-node/test/dbutils" 32 "github.com/0xPolygon/supernets2-node/test/operations" 33 "github.com/0xPolygon/supernets2-node/test/testutils" 34 "github.com/ethereum/go-ethereum/accounts/abi/bind" 35 "github.com/ethereum/go-ethereum/common" 36 "github.com/ethereum/go-ethereum/core/types" 37 "github.com/ethereum/go-ethereum/crypto" 38 "github.com/ethereum/go-ethereum/ethclient" 39 "github.com/ethereum/go-ethereum/rlp" 40 "github.com/ethereum/go-ethereum/trie" 41 "github.com/jackc/pgx/v4/pgxpool" 42 "github.com/stretchr/testify/assert" 43 "github.com/stretchr/testify/require" 44 "google.golang.org/grpc" 45 ) 46 47 const ( 48 ether155V = 27 49 ) 50 51 var ( 52 testState *state.State 53 stateTree *merkletree.StateTree 54 stateDb *pgxpool.Pool 55 err error 56 stateDBCfg = dbutils.NewStateConfigFromEnv() 57 ctx = context.Background() 58 stateCfg = state.Config{ 59 MaxCumulativeGasUsed: 800000, 60 ChainID: 1000, 61 ForkIDIntervals: []state.ForkIDInterval{{ 62 FromBatchNumber: 0, 63 ToBatchNumber: math.MaxUint64, 64 ForkId: 0, 65 Version: "", 66 }}, 67 } 68 forkID uint64 = 2 69 executorClient executorclientpb.ExecutorServiceClient 70 mtDBServiceClient mtDBclientpb.StateDBServiceClient 71 executorClientConn, mtDBClientConn *grpc.ClientConn 72 batchResources = state.BatchResources{ 73 ZKCounters: state.ZKCounters{ 74 UsedKeccakHashes: 1, 75 }, 76 Bytes: 1, 77 } 78 closingReason = state.GlobalExitRootDeadlineClosingReason 79 ) 80 81 func TestMain(m *testing.M) { 82 initOrResetDB() 83 84 stateDb, err = db.NewSQLDB(stateDBCfg) 85 if err != nil { 86 panic(err) 87 } 88 defer stateDb.Close() 89 90 zkProverURI := testutils.GetEnv("ZKPROVER_URI", "localhost") 91 92 executorServerConfig := executor.Config{URI: fmt.Sprintf("%s:50071", zkProverURI)} 93 var executorCancel context.CancelFunc 94 executorClient, executorClientConn, executorCancel = executor.NewExecutorClient(ctx, executorServerConfig) 95 s := executorClientConn.GetState() 96 log.Infof("executorClientConn state: %s", s.String()) 97 defer func() { 98 executorCancel() 99 executorClientConn.Close() 100 }() 101 102 mtDBServerConfig := merkletree.Config{URI: fmt.Sprintf("%s:50061", zkProverURI)} 103 var mtDBCancel context.CancelFunc 104 mtDBServiceClient, mtDBClientConn, mtDBCancel = merkletree.NewMTDBServiceClient(ctx, mtDBServerConfig) 105 s = mtDBClientConn.GetState() 106 log.Infof("stateDbClientConn state: %s", s.String()) 107 defer func() { 108 mtDBCancel() 109 mtDBClientConn.Close() 110 }() 111 112 stateTree = merkletree.NewStateTree(mtDBServiceClient) 113 114 eventStorage, err := nileventstorage.NewNilEventStorage() 115 if err != nil { 116 panic(err) 117 } 118 eventLog := event.NewEventLog(event.Config{}, eventStorage) 119 120 testState = state.NewState(stateCfg, state.NewPostgresStorage(stateDb), executorClient, stateTree, eventLog) 121 122 result := m.Run() 123 124 os.Exit(result) 125 } 126 127 func TestAddBlock(t *testing.T) { 128 // Init database instance 129 initOrResetDB() 130 131 // ctx := context.Background() 132 fmt.Println("db: ", stateDb) 133 tx, err := testState.BeginStateTransaction(ctx) 134 require.NoError(t, err) 135 block := &state.Block{ 136 BlockNumber: 1, 137 BlockHash: common.HexToHash("0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9f1"), 138 ParentHash: common.HexToHash("0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9f1"), 139 ReceivedAt: time.Now(), 140 } 141 err = testState.AddBlock(ctx, block, tx) 142 assert.NoError(t, err) 143 // Add the second block 144 block.BlockNumber = 2 145 err = testState.AddBlock(ctx, block, tx) 146 assert.NoError(t, err) 147 err = tx.Commit(ctx) 148 require.NoError(t, err) 149 // Get the last block 150 lastBlock, err := testState.GetLastBlock(ctx, nil) 151 assert.NoError(t, err) 152 assert.Equal(t, uint64(2), lastBlock.BlockNumber) 153 assert.Equal(t, block.BlockHash, lastBlock.BlockHash) 154 assert.Equal(t, block.ParentHash, lastBlock.ParentHash) 155 // Get the previous block 156 prevBlock, err := testState.GetPreviousBlock(ctx, 1, nil) 157 assert.NoError(t, err) 158 assert.Equal(t, uint64(1), prevBlock.BlockNumber) 159 } 160 161 func TestProcessCloseBatch(t *testing.T) { 162 // Init database instance 163 initOrResetDB() 164 165 ctx := context.Background() 166 dbTx, err := testState.BeginStateTransaction(ctx) 167 require.NoError(t, err) 168 // Set genesis batch 169 _, err = testState.SetGenesis(ctx, state.Block{}, state.Genesis{}, dbTx) 170 require.NoError(t, err) 171 // Open batch #1 172 // processingCtx1 := state.ProcessingContext{ 173 // BatchNumber: 1, 174 // Coinbase: common.HexToAddress("1"), 175 // Timestamp: time.Now().UTC(), 176 // globalExitRoot: common.HexToHash("a"), 177 // } 178 // Txs for batch #1 179 // rawTxs := "f84901843b9aca00827b0c945fbdb2315678afecb367f032d93f642f64180aa380a46057361d00000000000000000000000000000000000000000000000000000000000000048203e9808073efe1fa2d3e27f26f32208550ea9b0274d49050b816cadab05a771f4275d0242fd5d92b3fb89575c070e6c930587c520ee65a3aa8cfe382fcad20421bf51d621c" 180 //TODO Finish and fix this test 181 // err = testState.ProcessAndStoreClosedBatch(ctx, processingCtx1, common.Hex2Bytes(rawTxs), dbTx, state.SynchronizerCallerLabel) 182 // require.NoError(t, err) 183 require.NoError(t, dbTx.Commit(ctx)) 184 } 185 186 func TestOpenCloseBatch(t *testing.T) { 187 // Init database instance 188 initOrResetDB() 189 190 ctx := context.Background() 191 dbTx, err := testState.BeginStateTransaction(ctx) 192 require.NoError(t, err) 193 // Set genesis batch 194 _, err = testState.SetGenesis(ctx, state.Block{}, state.Genesis{}, dbTx) 195 require.NoError(t, err) 196 // Open batch #1 197 processingCtx1 := state.ProcessingContext{ 198 BatchNumber: 1, 199 Coinbase: common.HexToAddress("1"), 200 Timestamp: time.Now().UTC(), 201 GlobalExitRoot: common.HexToHash("a"), 202 } 203 err = testState.OpenBatch(ctx, processingCtx1, dbTx) 204 require.NoError(t, err) 205 require.NoError(t, dbTx.Commit(ctx)) 206 dbTx, err = testState.BeginStateTransaction(ctx) 207 require.NoError(t, err) 208 // Fail opening batch #2 (#1 is still open) 209 processingCtx2 := state.ProcessingContext{ 210 BatchNumber: 2, 211 Coinbase: common.HexToAddress("2"), 212 Timestamp: time.Now().UTC(), 213 GlobalExitRoot: common.HexToHash("b"), 214 } 215 err = testState.OpenBatch(ctx, processingCtx2, dbTx) 216 assert.Equal(t, state.ErrLastBatchShouldBeClosed, err) 217 // Fail closing batch #1 (it has no txs yet) 218 receipt1 := state.ProcessingReceipt{ 219 BatchNumber: 1, 220 StateRoot: common.HexToHash("1"), 221 LocalExitRoot: common.HexToHash("1"), 222 ClosingReason: closingReason, 223 BatchResources: batchResources, 224 } 225 err = testState.CloseBatch(ctx, receipt1, dbTx) 226 require.NoError(t, err) 227 require.NoError(t, dbTx.Rollback(ctx)) 228 dbTx, err = testState.BeginStateTransaction(ctx) 229 require.NoError(t, err) 230 // Add txs to batch #1 231 tx1 := *types.NewTransaction(0, common.HexToAddress("0"), big.NewInt(0), 0, big.NewInt(0), []byte("aaa")) 232 tx2 := *types.NewTransaction(1, common.HexToAddress("1"), big.NewInt(1), 0, big.NewInt(1), []byte("bbb")) 233 txsBatch1 := []*state.ProcessTransactionResponse{ 234 { 235 TxHash: tx1.Hash(), 236 Tx: tx1, 237 }, 238 { 239 TxHash: tx2.Hash(), 240 Tx: tx2, 241 }, 242 } 243 244 data, err := state.EncodeTransactions([]types.Transaction{tx1, tx2}) 245 require.NoError(t, err) 246 receipt1.BatchL2Data = data 247 248 err = testState.StoreTransactions(ctx, 1, txsBatch1, dbTx) 249 require.NoError(t, err) 250 // Close batch #1 251 err = testState.CloseBatch(ctx, receipt1, dbTx) 252 require.NoError(t, err) 253 require.NoError(t, dbTx.Commit(ctx)) 254 dbTx, err = testState.BeginStateTransaction(ctx) 255 require.NoError(t, err) 256 // Fail opening batch #3 (should open batch #2) 257 processingCtx3 := state.ProcessingContext{ 258 BatchNumber: 3, 259 Coinbase: common.HexToAddress("3"), 260 Timestamp: time.Now().UTC(), 261 GlobalExitRoot: common.HexToHash("c"), 262 } 263 err = testState.OpenBatch(ctx, processingCtx3, dbTx) 264 require.ErrorIs(t, err, state.ErrUnexpectedBatch) 265 // Fail opening batch #2 (invalid timestamp) 266 processingCtx2.Timestamp = processingCtx1.Timestamp.Add(-1 * time.Second) 267 err = testState.OpenBatch(ctx, processingCtx2, dbTx) 268 require.Equal(t, state.ErrTimestampGE, err) 269 processingCtx2.Timestamp = time.Now() 270 require.NoError(t, dbTx.Rollback(ctx)) 271 dbTx, err = testState.BeginStateTransaction(ctx) 272 require.NoError(t, err) 273 // Open batch #2 274 err = testState.OpenBatch(ctx, processingCtx2, dbTx) 275 require.NoError(t, err) 276 // Get batch #1 from DB and compare with on memory batch 277 actualBatch, err := testState.GetBatchByNumber(ctx, 1, dbTx) 278 require.NoError(t, err) 279 batchL2Data, err := state.EncodeTransactions([]types.Transaction{tx1, tx2}) 280 require.NoError(t, err) 281 assertBatch(t, state.Batch{ 282 BatchNumber: 1, 283 Coinbase: processingCtx1.Coinbase, 284 BatchL2Data: batchL2Data, 285 StateRoot: receipt1.StateRoot, 286 LocalExitRoot: receipt1.LocalExitRoot, 287 Timestamp: processingCtx1.Timestamp, 288 GlobalExitRoot: processingCtx1.GlobalExitRoot, 289 }, *actualBatch) 290 require.NoError(t, dbTx.Commit(ctx)) 291 } 292 293 func assertBatch(t *testing.T, expected, actual state.Batch) { 294 assert.Equal(t, expected.Timestamp.Unix(), actual.Timestamp.Unix()) 295 actual.Timestamp = expected.Timestamp 296 assert.Equal(t, expected, actual) 297 } 298 299 func TestAddForcedBatch(t *testing.T) { 300 // Init database instance 301 initOrResetDB() 302 303 ctx := context.Background() 304 tx, err := testState.BeginStateTransaction(ctx) 305 require.NoError(t, err) 306 block := &state.Block{ 307 BlockNumber: 1, 308 BlockHash: common.HexToHash("0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9f1"), 309 ParentHash: common.HexToHash("0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9f1"), 310 ReceivedAt: time.Now(), 311 } 312 err = testState.AddBlock(ctx, block, tx) 313 assert.NoError(t, err) 314 b := common.Hex2Bytes("0x617b3a3528F9") 315 assert.NoError(t, err) 316 forcedBatch := state.ForcedBatch{ 317 BlockNumber: 1, 318 ForcedBatchNumber: 2, 319 GlobalExitRoot: common.HexToHash("0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9f1"), 320 Sequencer: common.HexToAddress("0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D"), 321 RawTxsData: b, 322 ForcedAt: time.Now(), 323 } 324 err = testState.AddForcedBatch(ctx, &forcedBatch, tx) 325 require.NoError(t, err) 326 fb, err := testState.GetForcedBatch(ctx, 2, tx) 327 require.NoError(t, err) 328 err = tx.Commit(ctx) 329 require.NoError(t, err) 330 assert.Equal(t, forcedBatch.BlockNumber, fb.BlockNumber) 331 assert.Equal(t, forcedBatch.ForcedBatchNumber, fb.ForcedBatchNumber) 332 assert.NotEqual(t, time.Time{}, fb.ForcedAt) 333 assert.Equal(t, forcedBatch.GlobalExitRoot, fb.GlobalExitRoot) 334 assert.Equal(t, forcedBatch.RawTxsData, fb.RawTxsData) 335 // Test GetNextForcedBatches 336 tx, err = testState.BeginStateTransaction(ctx) 337 require.NoError(t, err) 338 forcedBatch = state.ForcedBatch{ 339 BlockNumber: 1, 340 ForcedBatchNumber: 3, 341 GlobalExitRoot: common.HexToHash("0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9f1"), 342 Sequencer: common.HexToAddress("0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D"), 343 RawTxsData: b, 344 ForcedAt: time.Now(), 345 } 346 err = testState.AddForcedBatch(ctx, &forcedBatch, tx) 347 require.NoError(t, err) 348 349 _, err = testState.PostgresStorage.Exec(ctx, "INSERT INTO state.batch (batch_num, forced_batch_num) VALUES (2, 2)") 350 assert.NoError(t, err) 351 virtualBatch := state.VirtualBatch{ 352 BlockNumber: 1, 353 BatchNumber: 2, 354 TxHash: common.HexToHash("0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9f1"), 355 Coinbase: common.HexToAddress("0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D"), 356 } 357 err = testState.AddVirtualBatch(ctx, &virtualBatch, tx) 358 require.NoError(t, err) 359 360 batches, err := testState.GetNextForcedBatches(ctx, 1, tx) 361 require.NoError(t, err) 362 assert.Equal(t, forcedBatch.BlockNumber, batches[0].BlockNumber) 363 assert.Equal(t, forcedBatch.ForcedBatchNumber, batches[0].ForcedBatchNumber) 364 assert.NotEqual(t, time.Time{}, batches[0].ForcedAt) 365 assert.Equal(t, forcedBatch.GlobalExitRoot, batches[0].GlobalExitRoot) 366 assert.Equal(t, forcedBatch.RawTxsData, batches[0].RawTxsData) 367 require.NoError(t, tx.Commit(ctx)) 368 } 369 370 func TestAddVirtualBatch(t *testing.T) { 371 // Init database instance 372 initOrResetDB() 373 374 ctx := context.Background() 375 tx, err := testState.BeginStateTransaction(ctx) 376 require.NoError(t, err) 377 block := &state.Block{ 378 BlockNumber: 1, 379 BlockHash: common.HexToHash("0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9f1"), 380 ParentHash: common.HexToHash("0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9f1"), 381 ReceivedAt: time.Now(), 382 } 383 err = testState.AddBlock(ctx, block, tx) 384 assert.NoError(t, err) 385 _, err = testState.PostgresStorage.Exec(ctx, "INSERT INTO state.batch (batch_num) VALUES (1)") 386 assert.NoError(t, err) 387 virtualBatch := state.VirtualBatch{ 388 BlockNumber: 1, 389 BatchNumber: 1, 390 TxHash: common.HexToHash("0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9f1"), 391 Coinbase: common.HexToAddress("0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D"), 392 } 393 err = testState.AddVirtualBatch(ctx, &virtualBatch, tx) 394 require.NoError(t, err) 395 require.NoError(t, tx.Commit(ctx)) 396 } 397 398 func TestGetTxsHashesToDelete(t *testing.T) { 399 initOrResetDB() 400 401 ctx := context.Background() 402 tx, err := testState.BeginStateTransaction(ctx) 403 require.NoError(t, err) 404 block1 := &state.Block{ 405 BlockNumber: 1, 406 BlockHash: common.HexToHash("0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9f1"), 407 ParentHash: common.HexToHash("0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9f1"), 408 ReceivedAt: time.Now(), 409 } 410 err = testState.AddBlock(ctx, block1, tx) 411 assert.NoError(t, err) 412 block2 := &state.Block{ 413 BlockNumber: 2, 414 BlockHash: common.HexToHash("0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9f1"), 415 ParentHash: common.HexToHash("0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9f1"), 416 ReceivedAt: time.Now(), 417 } 418 err = testState.AddBlock(ctx, block2, tx) 419 assert.NoError(t, err) 420 421 _, err = testState.PostgresStorage.Exec(ctx, "INSERT INTO state.batch (batch_num) VALUES (1)") 422 assert.NoError(t, err) 423 require.NoError(t, err) 424 virtualBatch1 := state.VirtualBatch{ 425 BlockNumber: 1, 426 BatchNumber: 1, 427 TxHash: common.HexToHash("0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9f1"), 428 Coinbase: common.HexToAddress("0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D"), 429 } 430 431 _, err = testState.PostgresStorage.Exec(ctx, "INSERT INTO state.batch (batch_num) VALUES (2)") 432 assert.NoError(t, err) 433 virtualBatch2 := state.VirtualBatch{ 434 BlockNumber: 1, 435 BatchNumber: 2, 436 TxHash: common.HexToHash("0x132"), 437 Coinbase: common.HexToAddress("0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D"), 438 } 439 err = testState.AddVirtualBatch(ctx, &virtualBatch1, tx) 440 require.NoError(t, err) 441 err = testState.AddVirtualBatch(ctx, &virtualBatch2, tx) 442 require.NoError(t, err) 443 require.NoError(t, tx.Commit(ctx)) 444 445 _, err = testState.Exec(ctx, "INSERT INTO state.l2block (block_num, block_hash, received_at, batch_num, created_at) VALUES ($1, $2, $3, $4, $5)", 1, "0x423", time.Now(), 1, time.Now().UTC()) 446 require.NoError(t, err) 447 l2Tx1 := types.NewTransaction(1, common.Address{}, big.NewInt(10), 21000, big.NewInt(1), []byte{}) 448 _, err = testState.Exec(ctx, "INSERT INTO state.transaction (l2_block_num, encoded, hash) VALUES ($1, $2, $3)", 449 virtualBatch1.BatchNumber, fmt.Sprintf("encoded-%d", virtualBatch1.BatchNumber), l2Tx1.Hash().Hex()) 450 require.NoError(t, err) 451 452 _, err = testState.Exec(ctx, "INSERT INTO state.l2block (block_num, block_hash, received_at, batch_num, created_at) VALUES ($1, $2, $3, $4, $5)", 2, "0x423", time.Now(), 2, time.Now().UTC()) 453 require.NoError(t, err) 454 l2Tx2 := types.NewTransaction(2, common.Address{}, big.NewInt(10), 21000, big.NewInt(1), []byte{}) 455 _, err = testState.Exec(ctx, "INSERT INTO state.transaction (l2_block_num, encoded, hash) VALUES ($1, $2, $3)", 456 virtualBatch2.BatchNumber, fmt.Sprintf("encoded-%d", virtualBatch2.BatchNumber), l2Tx2.Hash().Hex()) 457 require.NoError(t, err) 458 txHashes, err := testState.GetTxsOlderThanNL1Blocks(ctx, 1, nil) 459 require.NoError(t, err) 460 require.Equal(t, l2Tx1.Hash().Hex(), txHashes[0].Hex()) 461 } 462 463 func TestExecuteTransaction(t *testing.T) { 464 var chainIDSequencer = new(big.Int).SetInt64(400) 465 var sequencerAddress = common.HexToAddress("0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D") 466 var sequencerPvtKey = "0x28b2b0318721be8c8339199172cd7cc8f5e273800a35616ec893083a4b32c02e" 467 var sequencerBalance = 4000000 468 scCounterByteCode, err := testutils.ReadBytecode("Counter/Counter.bin") 469 require.NoError(t, err) 470 471 // Deploy counter.sol 472 tx := types.NewTx(&types.LegacyTx{ 473 Nonce: 0, 474 To: nil, 475 Value: new(big.Int), 476 Gas: uint64(sequencerBalance), 477 GasPrice: new(big.Int).SetUint64(0), 478 Data: common.Hex2Bytes(scCounterByteCode), 479 }) 480 481 privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(sequencerPvtKey, "0x")) 482 require.NoError(t, err) 483 auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainIDSequencer) 484 require.NoError(t, err) 485 486 signedTx, err := auth.Signer(auth.From, tx) 487 require.NoError(t, err) 488 489 // Encode transaction 490 v, r, s := signedTx.RawSignatureValues() 491 sign := 1 - (v.Uint64() & 1) 492 493 txCodedRlp, err := rlp.EncodeToBytes([]interface{}{ 494 signedTx.Nonce(), 495 signedTx.GasPrice(), 496 signedTx.Gas(), 497 signedTx.To(), 498 signedTx.Value(), 499 signedTx.Data(), 500 signedTx.ChainId(), uint(0), uint(0), 501 }) 502 require.NoError(t, err) 503 504 newV := new(big.Int).Add(big.NewInt(ether155V), big.NewInt(int64(sign))) 505 newRPadded := fmt.Sprintf("%064s", r.Text(hex.Base)) 506 newSPadded := fmt.Sprintf("%064s", s.Text(hex.Base)) 507 newVPadded := fmt.Sprintf("%02s", newV.Text(hex.Base)) 508 batchL2Data, err := hex.DecodeString(hex.EncodeToString(txCodedRlp) + newRPadded + newSPadded + newVPadded) 509 require.NoError(t, err) 510 511 // Create Batch 512 processBatchRequest := &executorclientpb.ProcessBatchRequest{ 513 OldBatchNum: 0, 514 Coinbase: sequencerAddress.String(), 515 BatchL2Data: batchL2Data, 516 OldStateRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 517 GlobalExitRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 518 OldAccInputHash: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 519 EthTimestamp: uint64(time.Now().Unix()), 520 UpdateMerkleTree: 1, 521 ChainId: stateCfg.ChainID, 522 ForkId: forkID, 523 } 524 525 log.Debugf("%v", processBatchRequest) 526 527 processBatchResponse, err := executorClient.ProcessBatch(ctx, processBatchRequest) 528 require.NoError(t, err) 529 log.Debug(processBatchResponse) 530 // TODO: assert processBatchResponse to make sure that the response makes sense 531 } 532 533 func TestCheckSupersetBatchTransactions(t *testing.T) { 534 tcs := []struct { 535 description string 536 existingTxHashes []common.Hash 537 processedTxs []*state.ProcessTransactionResponse 538 expectedError bool 539 expectedErrorMsg string 540 }{ 541 { 542 description: "empty existingTxHashes and processedTx is successful", 543 existingTxHashes: []common.Hash{}, 544 processedTxs: []*state.ProcessTransactionResponse{}, 545 }, 546 { 547 description: "happy path", 548 existingTxHashes: []common.Hash{ 549 common.HexToHash("0x8a84686634729c57532b9ffa4e632e241b2de5c880c771c5c214d5e7ec465b1c"), 550 common.HexToHash("0x30c6a361ba88906ef2085d05a2aeac15e793caff2bdc1deaaae2f4910d83de52"), 551 common.HexToHash("0x0d3453b6d17841b541d4f79f78d5fa22fff281551ed4012c7590b560b2969e7f"), 552 }, 553 processedTxs: []*state.ProcessTransactionResponse{ 554 {TxHash: common.HexToHash("0x8a84686634729c57532b9ffa4e632e241b2de5c880c771c5c214d5e7ec465b1c")}, 555 {TxHash: common.HexToHash("0x30c6a361ba88906ef2085d05a2aeac15e793caff2bdc1deaaae2f4910d83de52")}, 556 {TxHash: common.HexToHash("0x0d3453b6d17841b541d4f79f78d5fa22fff281551ed4012c7590b560b2969e7f")}, 557 }, 558 }, 559 { 560 description: "existingTxHashes bigger than processedTx gives error", 561 existingTxHashes: []common.Hash{common.HexToHash(""), common.HexToHash("")}, 562 processedTxs: []*state.ProcessTransactionResponse{{}}, 563 expectedError: true, 564 expectedErrorMsg: state.ErrExistingTxGreaterThanProcessedTx.Error(), 565 }, 566 { 567 description: "processedTx not present in existingTxHashes gives error", 568 existingTxHashes: []common.Hash{ 569 common.HexToHash("0x8a84686634729c57532b9ffa4e632e241b2de5c880c771c5c214d5e7ec465b1c"), 570 common.HexToHash("0x30c6a361ba88906ef2085d05a2aeac15e793caff2bdc1deaaae2f4910d83de52"), 571 }, 572 processedTxs: []*state.ProcessTransactionResponse{ 573 {TxHash: common.HexToHash("0x8a84686634729c57532b9ffa4e632e241b2de5c880c771c5c214d5e7ec465b1c")}, 574 {TxHash: common.HexToHash("0x0d3453b6d17841b541d4f79f78d5fa22fff281551ed4012c7590b560b2969e7f")}, 575 }, 576 expectedError: true, 577 expectedErrorMsg: state.ErrOutOfOrderProcessedTx.Error(), 578 }, 579 { 580 description: "out of order processedTx gives error", 581 existingTxHashes: []common.Hash{ 582 common.HexToHash("0x8a84686634729c57532b9ffa4e632e241b2de5c880c771c5c214d5e7ec465b1c"), 583 common.HexToHash("0x30c6a361ba88906ef2085d05a2aeac15e793caff2bdc1deaaae2f4910d83de52"), 584 common.HexToHash("0x0d3453b6d17841b541d4f79f78d5fa22fff281551ed4012c7590b560b2969e7f"), 585 }, 586 processedTxs: []*state.ProcessTransactionResponse{ 587 {TxHash: common.HexToHash("0x8a84686634729c57532b9ffa4e632e241b2de5c880c771c5c214d5e7ec465b1c")}, 588 {TxHash: common.HexToHash("0x0d3453b6d17841b541d4f79f78d5fa22fff281551ed4012c7590b560b2969e7f")}, 589 {TxHash: common.HexToHash("0x30c6a361ba88906ef2085d05a2aeac15e793caff2bdc1deaaae2f4910d83de52")}, 590 }, 591 expectedError: true, 592 expectedErrorMsg: state.ErrOutOfOrderProcessedTx.Error(), 593 }, 594 } 595 for _, tc := range tcs { 596 // tc := tc 597 t.Run(tc.description, func(t *testing.T) { 598 require.NoError(t, testutils.CheckError( 599 state.CheckSupersetBatchTransactions(tc.existingTxHashes, tc.processedTxs), 600 tc.expectedError, 601 tc.expectedErrorMsg, 602 )) 603 }) 604 } 605 } 606 607 func TestGetTxsHashesByBatchNumber(t *testing.T) { 608 // Init database instance 609 initOrResetDB() 610 611 ctx := context.Background() 612 dbTx, err := testState.BeginStateTransaction(ctx) 613 require.NoError(t, err) 614 // Set genesis batch 615 _, err = testState.SetGenesis(ctx, state.Block{}, state.Genesis{}, dbTx) 616 require.NoError(t, err) 617 // Open batch #1 618 processingCtx1 := state.ProcessingContext{ 619 BatchNumber: 1, 620 Coinbase: common.HexToAddress("1"), 621 Timestamp: time.Now().UTC(), 622 GlobalExitRoot: common.HexToHash("a"), 623 } 624 err = testState.OpenBatch(ctx, processingCtx1, dbTx) 625 require.NoError(t, err) 626 627 // Add txs to batch #1 628 tx1 := *types.NewTransaction(0, common.HexToAddress("0"), big.NewInt(0), 0, big.NewInt(0), []byte("aaa")) 629 tx2 := *types.NewTransaction(1, common.HexToAddress("1"), big.NewInt(1), 0, big.NewInt(1), []byte("bbb")) 630 txsBatch1 := []*state.ProcessTransactionResponse{ 631 { 632 TxHash: tx1.Hash(), 633 Tx: tx1, 634 }, 635 { 636 TxHash: tx2.Hash(), 637 Tx: tx2, 638 }, 639 } 640 err = testState.StoreTransactions(ctx, 1, txsBatch1, dbTx) 641 require.NoError(t, err) 642 643 txs, err := testState.GetTxsHashesByBatchNumber(ctx, 1, dbTx) 644 require.NoError(t, err) 645 646 require.Equal(t, len(txsBatch1), len(txs)) 647 for i := range txsBatch1 { 648 require.Equal(t, txsBatch1[i].TxHash, txs[i]) 649 } 650 require.NoError(t, dbTx.Commit(ctx)) 651 } 652 653 func TestGenesis(t *testing.T) { 654 block := state.Block{ 655 BlockNumber: 1, 656 BlockHash: state.ZeroHash, 657 ParentHash: state.ZeroHash, 658 ReceivedAt: time.Now(), 659 } 660 661 actions := []*state.GenesisAction{ 662 { 663 Address: "0xb1D0Dc8E2Ce3a93EB2b32f4C7c3fD9dDAf1211FA", 664 Type: int(merkletree.LeafTypeBalance), 665 Value: "1000", 666 }, 667 { 668 Address: "0xb1D0Dc8E2Ce3a93EB2b32f4C7c3fD9dDAf1211FB", 669 Type: int(merkletree.LeafTypeBalance), 670 Value: "2000", 671 }, 672 { 673 Address: "0xb1D0Dc8E2Ce3a93EB2b32f4C7c3fD9dDAf1211FA", 674 Type: int(merkletree.LeafTypeNonce), 675 Value: "1", 676 }, 677 { 678 Address: "0xb1D0Dc8E2Ce3a93EB2b32f4C7c3fD9dDAf1211FB", 679 Type: int(merkletree.LeafTypeNonce), 680 Value: "1", 681 }, 682 { 683 Address: "0xae4bb80be56b819606589de61d5ec3b522eeb032", 684 Type: int(merkletree.LeafTypeCode), 685 Bytecode: "608060405234801561001057600080fd5b50600436106100675760003560e01c806333d6247d1161005057806333d6247d146100a85780633ed691ef146100bd578063a3c573eb146100d257600080fd5b806301fd90441461006c5780633381fe9014610088575b600080fd5b61007560015481565b6040519081526020015b60405180910390f35b6100756100963660046101c7565b60006020819052908152604090205481565b6100bb6100b63660046101c7565b610117565b005b43600090815260208190526040902054610075565b6002546100f29073ffffffffffffffffffffffffffffffffffffffff1681565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200161007f565b60025473ffffffffffffffffffffffffffffffffffffffff1633146101c2576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603460248201527f476c6f62616c45786974526f6f744d616e616765724c323a3a7570646174654560448201527f786974526f6f743a204f4e4c595f425249444745000000000000000000000000606482015260840160405180910390fd5b600155565b6000602082840312156101d957600080fd5b503591905056fea2646970667358221220d6ed73b81f538d38669b0b750b93be08ca365978fae900eedc9ca93131c97ca664736f6c63430008090033", 686 }, 687 { 688 Address: "0xae4bb80be56b819606589de61d5ec3b522eeb032", 689 Type: int(merkletree.LeafTypeStorage), 690 StoragePosition: "0x0000000000000000000000000000000000000000000000000000000000000002", 691 Value: "0x9d98deabc42dd696deb9e40b4f1cab7ddbf55988", 692 }, 693 } 694 695 genesis := state.Genesis{ 696 GenesisActions: actions, 697 } 698 699 initOrResetDB() 700 701 dbTx, err := testState.BeginStateTransaction(ctx) 702 require.NoError(t, err) 703 stateRoot, err := testState.SetGenesis(ctx, block, genesis, dbTx) 704 require.NoError(t, err) 705 require.NoError(t, dbTx.Commit(ctx)) 706 707 for _, action := range actions { 708 address := common.HexToAddress(action.Address) 709 switch action.Type { 710 case int(merkletree.LeafTypeBalance): 711 balance, err := stateTree.GetBalance(ctx, address, stateRoot) 712 require.NoError(t, err) 713 require.Equal(t, action.Value, balance.String()) 714 case int(merkletree.LeafTypeNonce): 715 nonce, err := stateTree.GetNonce(ctx, address, stateRoot) 716 require.NoError(t, err) 717 require.Equal(t, action.Value, nonce.String()) 718 case int(merkletree.LeafTypeCode): 719 sc, err := stateTree.GetCode(ctx, address, stateRoot) 720 require.NoError(t, err) 721 require.Equal(t, common.Hex2Bytes(action.Bytecode), sc) 722 case int(merkletree.LeafTypeStorage): 723 st, err := stateTree.GetStorageAt(ctx, address, new(big.Int).SetBytes(common.Hex2Bytes(action.StoragePosition)), stateRoot) 724 require.NoError(t, err) 725 require.Equal(t, new(big.Int).SetBytes(common.Hex2Bytes(action.Value)), st) 726 } 727 } 728 } 729 730 func TestExecutor(t *testing.T) { 731 var expectedNewRoot = "0xa2b0ad9cc19e2a4aa9a6d7e14b15e5e951e319ed17b619878bec201b4d064c3e" 732 733 db := map[string]string{ 734 "2dc4db4293af236cb329700be43f08ace740a05088f8c7654736871709687e90": "00000000000000000000000000000000000000000000000000000000000000000d1f0da5a7b620c843fd1e18e59fd724d428d25da0cb1888e31f5542ac227c060000000000000000000000000000000000000000000000000000000000000000", 735 "e31f5542ac227c06d428d25da0cb188843fd1e18e59fd7240d1f0da5a7b620c8": "ed22ec7734d89ff2b2e639153607b7c542b2bd6ec2788851b7819329410847833e63658ee0db910d0b3e34316e81aa10e0dc203d93f4e3e5e10053d0ebc646020000000000000000000000000000000000000000000000000000000000000000", 736 "b78193294108478342b2bd6ec2788851b2e639153607b7c5ed22ec7734d89ff2": "16dde42596b907f049015d7e991a152894dd9dadd060910b60b4d5e9af514018b69b044f5e694795f57d81efba5d4445339438195426ad0a3efad1dd58c2259d0000000000000001000000000000000000000000000000000000000000000000", 737 "3efad1dd58c2259d339438195426ad0af57d81efba5d4445b69b044f5e694795": "00000000dea000000000000035c9adc5000000000000003600000000000000000000000000000000000000000000000000000000000000000000000000000000", 738 "e10053d0ebc64602e0dc203d93f4e3e50b3e34316e81aa103e63658ee0db910d": "66ee2be0687eea766926f8ca8796c78a4c2f3e938869b82d649e63bfe1247ba4b69b044f5e694795f57d81efba5d4445339438195426ad0a3efad1dd58c2259d0000000000000001000000000000000000000000000000000000000000000000", 739 } 740 741 // Create Batch 742 processBatchRequest := &executorclientpb.ProcessBatchRequest{ 743 OldBatchNum: 0, 744 Coinbase: common.HexToAddress("0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D").String(), 745 BatchL2Data: common.Hex2Bytes("ee80843b9aca00830186a0944d5cf5032b2a844602278b01199ed191a86c93ff88016345785d8a0000808203e880801cee7e01dc62f69a12c3510c6d64de04ee6346d84b6a017f3e786c7d87f963e75d8cc91fa983cd6d9cf55fff80d73bd26cd333b0f098acc1e58edb1fd484ad731b"), 746 OldStateRoot: common.Hex2Bytes("2dc4db4293af236cb329700be43f08ace740a05088f8c7654736871709687e90"), 747 GlobalExitRoot: common.Hex2Bytes("090bcaf734c4f06c93954a827b45a6e8c67b8e0fd1e0a35a1c5982d6961828f9"), 748 OldAccInputHash: common.Hex2Bytes("17c04c3760510b48c6012742c540a81aba4bca2f78b9d14bfd2f123e2e53ea3e"), 749 EthTimestamp: uint64(1944498031), 750 UpdateMerkleTree: 0, 751 Db: db, 752 ChainId: stateCfg.ChainID, 753 ForkId: forkID, 754 } 755 756 processBatchResponse, err := executorClient.ProcessBatch(ctx, processBatchRequest) 757 require.NoError(t, err) 758 759 assert.Equal(t, common.HexToHash(expectedNewRoot), common.BytesToHash(processBatchResponse.NewStateRoot)) 760 } 761 762 func TestExecutorRevert(t *testing.T) { 763 var chainIDSequencer = new(big.Int).SetInt64(1000) 764 var sequencerAddress = common.HexToAddress("0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D") 765 var sequencerPvtKey = "0x28b2b0318721be8c8339199172cd7cc8f5e273800a35616ec893083a4b32c02e" 766 var scAddress = common.HexToAddress("0x1275fbb540c8efC58b812ba83B0D0B8b9917AE98") 767 var sequencerBalance = 4000000 768 scRevertByteCode, err := testutils.ReadBytecode("Revert2/Revert2.bin") 769 require.NoError(t, err) 770 771 // Set Genesis 772 block := state.Block{ 773 BlockNumber: 0, 774 BlockHash: state.ZeroHash, 775 ParentHash: state.ZeroHash, 776 ReceivedAt: time.Now(), 777 } 778 779 genesis := state.Genesis{ 780 GenesisActions: []*state.GenesisAction{ 781 { 782 Address: sequencerAddress.String(), 783 Type: int(merkletree.LeafTypeBalance), 784 Value: "10000000", 785 }, 786 }, 787 } 788 789 initOrResetDB() 790 791 dbTx, err := testState.BeginStateTransaction(ctx) 792 require.NoError(t, err) 793 stateRoot, err := testState.SetGenesis(ctx, block, genesis, dbTx) 794 require.NoError(t, err) 795 796 // Deploy revert.sol 797 tx0 := types.NewTx(&types.LegacyTx{ 798 Nonce: 0, 799 To: nil, 800 Value: new(big.Int), 801 Gas: uint64(sequencerBalance), 802 GasPrice: new(big.Int).SetUint64(0), 803 Data: common.Hex2Bytes(scRevertByteCode), 804 }) 805 806 privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(sequencerPvtKey, "0x")) 807 require.NoError(t, err) 808 auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainIDSequencer) 809 require.NoError(t, err) 810 811 signedTx0, err := auth.Signer(auth.From, tx0) 812 require.NoError(t, err) 813 814 // Call SC method 815 tx1 := types.NewTransaction(1, scAddress, new(big.Int), 40000, new(big.Int).SetUint64(1), common.Hex2Bytes("4abbb40a")) 816 signedTx1, err := auth.Signer(auth.From, tx1) 817 require.NoError(t, err) 818 819 batchL2Data, err := state.EncodeTransactions([]types.Transaction{*signedTx0, *signedTx1}) 820 require.NoError(t, err) 821 822 // Create Batch 823 processBatchRequest := &executorclientpb.ProcessBatchRequest{ 824 OldBatchNum: 0, 825 Coinbase: sequencerAddress.String(), 826 BatchL2Data: batchL2Data, 827 OldStateRoot: stateRoot, 828 GlobalExitRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 829 OldAccInputHash: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 830 EthTimestamp: uint64(time.Now().Unix()), 831 UpdateMerkleTree: 0, 832 ChainId: stateCfg.ChainID, 833 ForkId: forkID, 834 } 835 836 processBatchResponse, err := executorClient.ProcessBatch(ctx, processBatchRequest) 837 require.NoError(t, err) 838 assert.Equal(t, runtime.ErrExecutionReverted, executor.RomErr(processBatchResponse.Responses[1].Error)) 839 840 // Unsigned 841 receipt := &types.Receipt{ 842 Type: uint8(signedTx0.Type()), 843 PostState: processBatchResponse.Responses[0].StateRoot, 844 CumulativeGasUsed: processBatchResponse.Responses[0].GasUsed, 845 BlockNumber: big.NewInt(0), 846 GasUsed: processBatchResponse.Responses[0].GasUsed, 847 TxHash: signedTx0.Hash(), 848 TransactionIndex: 0, 849 Status: types.ReceiptStatusSuccessful, 850 } 851 852 receipt1 := &types.Receipt{ 853 Type: uint8(signedTx1.Type()), 854 PostState: processBatchResponse.Responses[1].StateRoot, 855 CumulativeGasUsed: processBatchResponse.Responses[0].GasUsed + processBatchResponse.Responses[1].GasUsed, 856 BlockNumber: big.NewInt(0), 857 GasUsed: signedTx1.Gas(), 858 TxHash: signedTx1.Hash(), 859 TransactionIndex: 1, 860 Status: types.ReceiptStatusSuccessful, 861 } 862 863 header := &types.Header{ 864 Number: big.NewInt(1), 865 ParentHash: state.ZeroHash, 866 Coinbase: state.ZeroAddress, 867 Root: common.BytesToHash(processBatchResponse.NewStateRoot), 868 GasUsed: receipt1.GasUsed, 869 GasLimit: receipt1.GasUsed, 870 Time: uint64(time.Now().Unix()), 871 } 872 873 receipts := []*types.Receipt{receipt, receipt1} 874 875 transactions := []*types.Transaction{signedTx0, signedTx1} 876 877 // Create block to be able to calculate its hash 878 l2Block := types.NewBlock(header, transactions, []*types.Header{}, receipts, &trie.StackTrie{}) 879 l2Block.ReceivedAt = time.Now() 880 881 receipt.BlockHash = l2Block.Hash() 882 883 err = testState.AddL2Block(ctx, 0, l2Block, receipts, dbTx) 884 require.NoError(t, err) 885 l2Block, err = testState.GetL2BlockByHash(ctx, l2Block.Hash(), dbTx) 886 require.NoError(t, err) 887 888 require.NoError(t, dbTx.Commit(ctx)) 889 890 lastL2BlockNumber := l2Block.NumberU64() 891 892 unsignedTx := types.NewTransaction(2, scAddress, new(big.Int), 40000, new(big.Int).SetUint64(1), common.Hex2Bytes("4abbb40a")) 893 894 result, err := testState.ProcessUnsignedTransaction(ctx, unsignedTx, auth.From, &lastL2BlockNumber, false, nil) 895 require.NoError(t, err) 896 require.NotNil(t, result.Err) 897 assert.Equal(t, fmt.Errorf("execution reverted: Today is not juernes").Error(), result.Err.Error()) 898 } 899 900 // 901 //func TestExecutorLogs(t *testing.T) { 902 // var chainIDSequencer = new(big.Int).SetInt64(1000) 903 // var sequencerAddress = common.HexToAddress("0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D") 904 // var sequencerPvtKey = "0x28b2b0318721be8c8339199172cd7cc8f5e273800a35616ec893083a4b32c02e" 905 // var sequencerBalance = 4000000 906 // var scAddress = common.HexToAddress("0x1275fbb540c8efC58b812ba83B0D0B8b9917AE98") 907 // scLogsByteCode, err := testutils.ReadBytecode("EmitLog2/EmitLog2.bin") 908 // require.NoError(t, err) 909 // 910 // // Genesis DB 911 // genesisDB := map[string]string{ 912 // "2dc4db4293af236cb329700be43f08ace740a05088f8c7654736871709687e90": "00000000000000000000000000000000000000000000000000000000000000000d1f0da5a7b620c843fd1e18e59fd724d428d25da0cb1888e31f5542ac227c060000000000000000000000000000000000000000000000000000000000000000", 913 // "e31f5542ac227c06d428d25da0cb188843fd1e18e59fd7240d1f0da5a7b620c8": "ed22ec7734d89ff2b2e639153607b7c542b2bd6ec2788851b7819329410847833e63658ee0db910d0b3e34316e81aa10e0dc203d93f4e3e5e10053d0ebc646020000000000000000000000000000000000000000000000000000000000000000", 914 // "b78193294108478342b2bd6ec2788851b2e639153607b7c5ed22ec7734d89ff2": "16dde42596b907f049015d7e991a152894dd9dadd060910b60b4d5e9af514018b69b044f5e694795f57d81efba5d4445339438195426ad0a3efad1dd58c2259d0000000000000001000000000000000000000000000000000000000000000000", 915 // "3efad1dd58c2259d339438195426ad0af57d81efba5d4445b69b044f5e694795": "00000000dea000000000000035c9adc5000000000000003600000000000000000000000000000000000000000000000000000000000000000000000000000000", 916 // "e10053d0ebc64602e0dc203d93f4e3e50b3e34316e81aa103e63658ee0db910d": "66ee2be0687eea766926f8ca8796c78a4c2f3e938869b82d649e63bfe1247ba4b69b044f5e694795f57d81efba5d4445339438195426ad0a3efad1dd58c2259d0000000000000001000000000000000000000000000000000000000000000000", 917 // } 918 // 919 // // Deploy Emitlog2.sol 920 // tx0 := types.NewTx(&types.LegacyTx{ 921 // Nonce: 0, 922 // To: nil, 923 // Value: new(big.Int), 924 // Gas: uint64(sequencerBalance), 925 // GasPrice: new(big.Int).SetUint64(0), 926 // Data: common.Hex2Bytes(scLogsByteCode), 927 // }) 928 // 929 // privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(sequencerPvtKey, "0x")) 930 // require.NoError(t, err) 931 // auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainIDSequencer) 932 // require.NoError(t, err) 933 // 934 // signedTx0, err := auth.Signer(auth.From, tx0) 935 // require.NoError(t, err) 936 // 937 // // Call SC method 938 // tx1 := types.NewTransaction(1, scAddress, new(big.Int), 40000, new(big.Int).SetUint64(1), common.Hex2Bytes("7966b4f6")) 939 // signedTx1, err := auth.Signer(auth.From, tx1) 940 // require.NoError(t, err) 941 // 942 // batchL2Data, err := state.EncodeTransactions([]types.Transaction{*signedTx0, *signedTx1}) 943 // require.NoError(t, err) 944 // 945 // // Create Batch 946 // processBatchRequest := &executorclientpb.ProcessBatchRequest{ 947 // OldBatchNum: 0, 948 // Coinbase: sequencerAddress.String(), 949 // BatchL2Data: batchL2Data, 950 // OldStateRoot: common.Hex2Bytes("2dc4db4293af236cb329700be43f08ace740a05088f8c7654736871709687e90"), 951 // GlobalExitRoot: common.Hex2Bytes("090bcaf734c4f06c93954a827b45a6e8c67b8e0fd1e0a35a1c5982d6961828f9"), 952 // OldAccInputHash: common.Hex2Bytes("17c04c3760510b48c6012742c540a81aba4bca2f78b9d14bfd2f123e2e53ea3e"), 953 // EthTimestamp: uint64(1944498031), 954 // UpdateMerkleTree: 0, 955 // Db: genesisDB, 956 // ChainId: stateCfg.ChainID, 957 // ForkId: forkID, 958 // } 959 // 960 // processBatchResponse, err := executorClient.ProcessBatch(ctx, processBatchRequest) 961 // require.NoError(t, err) 962 // 963 // assert.Equal(t, scAddress, common.HexToAddress(string(processBatchResponse.Responses[0].CreateAddress))) 964 // 965 // assert.Equal(t, 0, len(processBatchResponse.Responses[0].Logs)) 966 // assert.Equal(t, 4, len(processBatchResponse.Responses[1].Logs)) 967 // assert.Equal(t, 4, len(processBatchResponse.Responses[1].Logs[0].Topics)) 968 // assert.Equal(t, 2, len(processBatchResponse.Responses[1].Logs[1].Topics)) 969 // assert.Equal(t, 1, len(processBatchResponse.Responses[1].Logs[2].Topics)) 970 // assert.Equal(t, 0, len(processBatchResponse.Responses[1].Logs[3].Topics)) 971 //} 972 973 func TestExecutorTransfer(t *testing.T) { 974 var chainID = new(big.Int).SetInt64(1000) 975 var senderAddress = common.HexToAddress("0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D") 976 var senderPvtKey = "0x28b2b0318721be8c8339199172cd7cc8f5e273800a35616ec893083a4b32c02e" 977 var receiverAddress = common.HexToAddress("0xb1D0Dc8E2Ce3a93EB2b32f4C7c3fD9dDAf1211FB") 978 979 // Set Genesis 980 block := state.Block{ 981 BlockNumber: 0, 982 BlockHash: state.ZeroHash, 983 ParentHash: state.ZeroHash, 984 ReceivedAt: time.Now(), 985 } 986 987 genesis := state.Genesis{ 988 GenesisActions: []*state.GenesisAction{ 989 { 990 Address: "0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D", 991 Type: int(merkletree.LeafTypeBalance), 992 Value: "10000000", 993 }, 994 }, 995 } 996 997 initOrResetDB() 998 999 dbTx, err := testState.BeginStateTransaction(ctx) 1000 require.NoError(t, err) 1001 stateRoot, err := testState.SetGenesis(ctx, block, genesis, dbTx) 1002 require.NoError(t, err) 1003 require.NoError(t, dbTx.Commit(ctx)) 1004 1005 // Create transaction 1006 tx := types.NewTx(&types.LegacyTx{ 1007 Nonce: 0, 1008 To: &receiverAddress, 1009 Value: new(big.Int).SetUint64(2), 1010 Gas: uint64(30000), 1011 GasPrice: new(big.Int).SetUint64(1), 1012 Data: nil, 1013 }) 1014 1015 privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(senderPvtKey, "0x")) 1016 require.NoError(t, err) 1017 auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainID) 1018 require.NoError(t, err) 1019 1020 signedTx, err := auth.Signer(auth.From, tx) 1021 require.NoError(t, err) 1022 1023 batchL2Data, err := state.EncodeTransactions([]types.Transaction{*signedTx}) 1024 require.NoError(t, err) 1025 1026 // Create Batch 1027 processBatchRequest := &executorclientpb.ProcessBatchRequest{ 1028 OldBatchNum: 0, 1029 Coinbase: receiverAddress.String(), 1030 BatchL2Data: batchL2Data, 1031 OldStateRoot: stateRoot, 1032 GlobalExitRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 1033 OldAccInputHash: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 1034 EthTimestamp: uint64(0), 1035 UpdateMerkleTree: 1, 1036 ChainId: stateCfg.ChainID, 1037 ForkId: forkID, 1038 } 1039 1040 // Read Sender Balance before execution 1041 balance, err := stateTree.GetBalance(ctx, senderAddress, processBatchRequest.OldStateRoot) 1042 require.NoError(t, err) 1043 require.Equal(t, uint64(10000000), balance.Uint64()) 1044 1045 // Read Receiver Balance before execution 1046 balance, err = stateTree.GetBalance(ctx, receiverAddress, processBatchRequest.OldStateRoot) 1047 require.NoError(t, err) 1048 require.Equal(t, uint64(0), balance.Uint64()) 1049 1050 // Process batch 1051 processBatchResponse, err := executorClient.ProcessBatch(ctx, processBatchRequest) 1052 require.NoError(t, err) 1053 1054 // Read Sender Balance 1055 balance, err = stateTree.GetBalance(ctx, senderAddress, processBatchResponse.Responses[0].StateRoot) 1056 require.NoError(t, err) 1057 require.Equal(t, uint64(9978998), balance.Uint64()) 1058 1059 // Read Receiver Balance 1060 balance, err = stateTree.GetBalance(ctx, receiverAddress, processBatchResponse.Responses[0].StateRoot) 1061 require.NoError(t, err) 1062 require.Equal(t, uint64(21002), balance.Uint64()) 1063 1064 // Read Modified Addresses directly from response 1065 readWriteAddresses := processBatchResponse.ReadWriteAddresses 1066 log.Debug(receiverAddress.String()) 1067 data := readWriteAddresses[strings.ToLower(receiverAddress.String())] 1068 require.Equal(t, "21002", data.Balance) 1069 1070 // Read Modified Addresses from converted response 1071 converted, err := testState.TestConvertToProcessBatchResponse([]types.Transaction{*signedTx}, processBatchResponse) 1072 require.NoError(t, err) 1073 convertedData := converted.ReadWriteAddresses[receiverAddress] 1074 require.Equal(t, uint64(21002), convertedData.Balance.Uint64()) 1075 require.Equal(t, receiverAddress, convertedData.Address) 1076 require.Equal(t, (*uint64)(nil), convertedData.Nonce) 1077 } 1078 1079 func TestExecutorTxHashAndRLP(t *testing.T) { 1080 // Test Case 1081 type TxHashTestCase struct { 1082 Nonce string `json:"nonce"` 1083 GasPrice string `json:"gasPrice"` 1084 GasLimit string `json:"gasLimit"` 1085 To string `json:"to"` 1086 Value string `json:"value"` 1087 Data string `json:"data"` 1088 ChainID string `json:"chainId"` 1089 V string `json:"v"` 1090 R string `json:"r"` 1091 S string `json:"s"` 1092 From string `json:"from"` 1093 Hash string `json:"hash"` 1094 Link string `json:"link"` 1095 } 1096 1097 var testCases, testCases2 []TxHashTestCase 1098 1099 jsonFile, err := os.Open(filepath.Clean("test/vectors/src/tx-hash-ethereum/uniswap_formated.json")) 1100 require.NoError(t, err) 1101 defer func() { _ = jsonFile.Close() }() 1102 1103 bytes, err := io.ReadAll(jsonFile) 1104 require.NoError(t, err) 1105 1106 err = json.Unmarshal(bytes, &testCases) 1107 require.NoError(t, err) 1108 1109 jsonFile2, err := os.Open(filepath.Clean("test/vectors/src/tx-hash-ethereum/rlp.json")) 1110 require.NoError(t, err) 1111 defer func() { _ = jsonFile2.Close() }() 1112 1113 bytes2, err := io.ReadAll(jsonFile2) 1114 require.NoError(t, err) 1115 1116 err = json.Unmarshal(bytes2, &testCases2) 1117 require.NoError(t, err) 1118 testCases = append(testCases, testCases2...) 1119 1120 for x, testCase := range testCases { 1121 var stateRoot = state.ZeroHash 1122 var receiverAddress = common.HexToAddress(testCase.To) 1123 receiver := &receiverAddress 1124 if testCase.To == "0x" { 1125 receiver = nil 1126 } 1127 1128 v, ok := new(big.Int).SetString(testCase.V, 0) 1129 require.Equal(t, true, ok) 1130 1131 r, ok := new(big.Int).SetString(testCase.R, 0) 1132 require.Equal(t, true, ok) 1133 1134 s, ok := new(big.Int).SetString(testCase.S, 0) 1135 require.Equal(t, true, ok) 1136 1137 var value *big.Int 1138 1139 if testCase.Value != "0x" { 1140 value, ok = new(big.Int).SetString(testCase.Value, 0) 1141 require.Equal(t, true, ok) 1142 } 1143 1144 gasPrice, ok := new(big.Int).SetString(testCase.GasPrice, 0) 1145 require.Equal(t, true, ok) 1146 1147 gasLimit, ok := new(big.Int).SetString(testCase.GasLimit, 0) 1148 require.Equal(t, true, ok) 1149 1150 nonce, ok := new(big.Int).SetString(testCase.Nonce, 0) 1151 require.Equal(t, true, ok) 1152 1153 // Create transaction 1154 tx := types.NewTx(&types.LegacyTx{ 1155 Nonce: nonce.Uint64(), 1156 To: receiver, 1157 Value: value, 1158 Gas: gasLimit.Uint64(), 1159 GasPrice: gasPrice, 1160 Data: common.Hex2Bytes(strings.TrimPrefix(testCase.Data, "0x")), 1161 V: v, 1162 R: r, 1163 S: s, 1164 }) 1165 t.Log("chainID: ", tx.ChainId()) 1166 t.Log("txHash: ", tx.Hash()) 1167 1168 require.Equal(t, testCase.Hash, tx.Hash().String()) 1169 1170 batchL2Data, err := state.EncodeTransactions([]types.Transaction{*tx}) 1171 require.NoError(t, err) 1172 1173 // Create Batch 1174 processBatchRequest := &executorclientpb.ProcessBatchRequest{ 1175 OldBatchNum: uint64(x), 1176 Coinbase: receiverAddress.String(), 1177 BatchL2Data: batchL2Data, 1178 OldStateRoot: stateRoot.Bytes(), 1179 GlobalExitRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 1180 OldAccInputHash: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 1181 EthTimestamp: uint64(0), 1182 UpdateMerkleTree: 1, 1183 ChainId: stateCfg.ChainID, 1184 ForkId: forkID, 1185 } 1186 1187 // Process batch 1188 processBatchResponse, err := executorClient.ProcessBatch(ctx, processBatchRequest) 1189 require.NoError(t, err) 1190 1191 // TX Hash 1192 log.Debugf("TX Hash=%v", tx.Hash().String()) 1193 log.Debugf("Response TX Hash=%v", common.BytesToHash(processBatchResponse.Responses[0].TxHash).String()) 1194 1195 // RPL Encoding 1196 b, err := tx.MarshalBinary() 1197 require.NoError(t, err) 1198 log.Debugf("TX RLP=%v", hex.EncodeToHex(b)) 1199 log.Debugf("Response TX RLP=%v", "0x"+common.Bytes2Hex(processBatchResponse.Responses[0].RlpTx)) 1200 1201 require.Equal(t, tx.Hash(), common.BytesToHash(processBatchResponse.Responses[0].TxHash)) 1202 require.Equal(t, hex.EncodeToHex(b), "0x"+common.Bytes2Hex(processBatchResponse.Responses[0].RlpTx)) 1203 } 1204 } 1205 1206 func TestExecutorInvalidNonce(t *testing.T) { 1207 chainID := new(big.Int).SetInt64(1000) 1208 senderPvtKey := "0x28b2b0318721be8c8339199172cd7cc8f5e273800a35616ec893083a4b32c02e" 1209 receiverAddress := common.HexToAddress("0xb1D0Dc8E2Ce3a93EB2b32f4C7c3fD9dDAf1211FB") 1210 1211 // authorization 1212 privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(senderPvtKey, "0x")) 1213 require.NoError(t, err) 1214 auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainID) 1215 require.NoError(t, err) 1216 senderAddress := auth.From 1217 1218 type testCase struct { 1219 name string 1220 currentNonce uint64 1221 txNonce uint64 1222 } 1223 1224 testCases := []testCase{ 1225 { 1226 name: "tx nonce is greater than expected", 1227 currentNonce: 1, 1228 txNonce: 2, 1229 }, 1230 { 1231 name: "tx nonce is less than expected", 1232 currentNonce: 5, 1233 txNonce: 4, 1234 }, 1235 } 1236 1237 for _, testCase := range testCases { 1238 t.Run(testCase.name, func(t *testing.T) { 1239 initOrResetDB() 1240 1241 // Set Genesis 1242 block := state.Block{ 1243 BlockNumber: 0, 1244 BlockHash: state.ZeroHash, 1245 ParentHash: state.ZeroHash, 1246 ReceivedAt: time.Now(), 1247 } 1248 genesis := state.Genesis{ 1249 GenesisActions: []*state.GenesisAction{ 1250 { 1251 Address: senderAddress.String(), 1252 Type: int(merkletree.LeafTypeBalance), 1253 Value: "10000000", 1254 }, 1255 { 1256 Address: senderAddress.String(), 1257 Type: int(merkletree.LeafTypeNonce), 1258 Value: strconv.FormatUint(testCase.currentNonce, encoding.Base10), 1259 }, 1260 }, 1261 } 1262 dbTx, err := testState.BeginStateTransaction(ctx) 1263 require.NoError(t, err) 1264 stateRoot, err := testState.SetGenesis(ctx, block, genesis, dbTx) 1265 require.NoError(t, err) 1266 require.NoError(t, dbTx.Commit(ctx)) 1267 1268 // Read Sender Balance 1269 currentNonce, err := stateTree.GetNonce(ctx, senderAddress, stateRoot) 1270 require.NoError(t, err) 1271 assert.Equal(t, testCase.currentNonce, currentNonce.Uint64()) 1272 1273 // Create transaction 1274 tx := types.NewTransaction(testCase.txNonce, receiverAddress, new(big.Int).SetUint64(2), uint64(30000), big.NewInt(1), nil) 1275 signedTx, err := auth.Signer(auth.From, tx) 1276 require.NoError(t, err) 1277 1278 // encode txs 1279 batchL2Data, err := state.EncodeTransactions([]types.Transaction{*signedTx}) 1280 require.NoError(t, err) 1281 1282 // Create Batch 1283 processBatchRequest := &executorclientpb.ProcessBatchRequest{ 1284 OldBatchNum: 0, 1285 Coinbase: receiverAddress.String(), 1286 BatchL2Data: batchL2Data, 1287 OldStateRoot: stateRoot, 1288 GlobalExitRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 1289 OldAccInputHash: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 1290 EthTimestamp: uint64(0), 1291 UpdateMerkleTree: 1, 1292 ChainId: stateCfg.ChainID, 1293 ForkId: forkID, 1294 } 1295 1296 // Process batch 1297 processBatchResponse, err := executorClient.ProcessBatch(ctx, processBatchRequest) 1298 require.NoError(t, err) 1299 1300 transactionResponses := processBatchResponse.GetResponses() 1301 assert.Equal(t, true, executor.IsIntrinsicError(transactionResponses[0].Error), "invalid tx Error, it is expected to be INVALID TX") 1302 }) 1303 } 1304 } 1305 1306 func TestGenesisNewLeafType(t *testing.T) { 1307 // Set Genesis 1308 block := state.Block{ 1309 BlockNumber: 0, 1310 BlockHash: state.ZeroHash, 1311 ParentHash: state.ZeroHash, 1312 ReceivedAt: time.Now(), 1313 } 1314 1315 genesis := state.Genesis{ 1316 GenesisActions: []*state.GenesisAction{ 1317 { 1318 Address: "0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D", 1319 Type: int(merkletree.LeafTypeBalance), 1320 Value: "100000000000000000000", 1321 }, 1322 { 1323 Address: "0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D", 1324 Type: int(merkletree.LeafTypeNonce), 1325 Value: "0", 1326 }, 1327 { 1328 Address: "0x4d5Cf5032B2a844602278b01199ED191A86c93ff", 1329 Type: int(merkletree.LeafTypeBalance), 1330 Value: "200000000000000000000", 1331 }, 1332 { 1333 Address: "0x4d5Cf5032B2a844602278b01199ED191A86c93ff", 1334 Type: int(merkletree.LeafTypeNonce), 1335 Value: "0", 1336 }, 1337 { 1338 Address: "0x03e75d7dd38cce2e20ffee35ec914c57780a8e29", 1339 Type: int(merkletree.LeafTypeBalance), 1340 Value: "0", 1341 }, 1342 { 1343 Address: "0x03e75d7dd38cce2e20ffee35ec914c57780a8e29", 1344 Type: int(merkletree.LeafTypeNonce), 1345 Value: "0", 1346 }, 1347 { 1348 Address: "0x03e75d7dd38cce2e20ffee35ec914c57780a8e29", 1349 Type: int(merkletree.LeafTypeCode), 1350 Bytecode: "60606040525b600080fd00a165627a7a7230582012c9bd00152fa1c480f6827f81515bb19c3e63bf7ed9ffbb5fda0265983ac7980029", 1351 }, 1352 }, 1353 } 1354 1355 initOrResetDB() 1356 1357 dbTx, err := testState.BeginStateTransaction(ctx) 1358 require.NoError(t, err) 1359 stateRoot, err := testState.SetGenesis(ctx, block, genesis, dbTx) 1360 require.NoError(t, err) 1361 require.NoError(t, dbTx.Commit(ctx)) 1362 1363 log.Debug(string(stateRoot)) 1364 log.Debug(common.BytesToHash(stateRoot)) 1365 log.Debug(common.BytesToHash(stateRoot).String()) 1366 log.Debug(new(big.Int).SetBytes(stateRoot)) 1367 log.Debug(common.Bytes2Hex(stateRoot)) 1368 1369 require.Equal(t, "49461512068930131501252998918674096186707801477301326632372959001738876161218", new(big.Int).SetBytes(stateRoot).String()) 1370 } 1371 1372 // TEST COMMENTED BECAUSE IT IS NOT STABLE WHEN RUNNING ON GITHUB ACTIONS 1373 // WE NEED TO DOUBLE CHECK THE DEFER FUNC TO MAKE SURE IT WILL NOT 1374 // DESTROY THE DB AND MAKE OTHER TESTS TO FAIL. 1375 // 1376 // func TestFromMock(t *testing.T) { 1377 // executorClientBack := executorClient 1378 1379 // executorServerConfig := executor.Config{URI: "127.0.0.1:43071"} 1380 // var executorCancel context.CancelFunc 1381 // executorClient, executorClientConn, executorCancel = executor.NewExecutorClient(ctx, executorServerConfig) 1382 // log.Infof("executorClientConn state: %s", executorClientConn.GetState().String()) 1383 1384 // testState = state.NewState(stateCfg, state.NewPostgresStorage(stateDb), executorClient, stateTree) 1385 1386 // defer func() { 1387 // executorCancel() 1388 // executorClientConn.Close() 1389 // executorClient = executorClientBack 1390 // testState = state.NewState(stateCfg, state.NewPostgresStorage(stateDb), executorClient, stateTree) 1391 // }() 1392 1393 // mtDBServiceClientBack := mtDBServiceClient 1394 // mtDBServerConfig := merkletree.Config{URI: "127.0.0.1:43061"} 1395 // var mtDBCancel context.CancelFunc 1396 // mtDBServiceClient, mtDBClientConn, mtDBCancel = merkletree.NewMTDBServiceClient(ctx, mtDBServerConfig) 1397 // log.Infof("stateDbClientConn state: %s", mtDBClientConn.GetState().String()) 1398 1399 // stateTree = merkletree.NewStateTree(mtDBServiceClient) 1400 // testState = state.NewState(stateCfg, state.NewPostgresStorage(stateDb), executorClient, stateTree) 1401 1402 // defer func() { 1403 // mtDBCancel() 1404 // mtDBClientConn.Close() 1405 // mtDBServiceClient = mtDBServiceClientBack 1406 // stateTree = merkletree.NewStateTree(mtDBServiceClient) 1407 // testState = state.NewState(stateCfg, state.NewPostgresStorage(stateDb), executorClient, stateTree) 1408 // }() 1409 1410 // tvContainer, err := testvector.NewContainer("../test/vectors/src", afero.NewOsFs()) 1411 // require.NoError(t, err) 1412 1413 // tv := tvContainer.E2E.Items[0] 1414 1415 // balances := map[common.Address]*big.Int{} 1416 // nonces := map[common.Address]*big.Int{} 1417 // smartContracts := map[common.Address][]byte{} 1418 // storage := map[common.Address]map[*big.Int]*big.Int{} 1419 1420 // for _, item := range tv.GenesisRaw { 1421 // address := common.HexToAddress(item.Address) 1422 // switch item.Type { 1423 // case int(merkletree.LeafTypeBalance): 1424 // balance, ok := new(big.Int).SetString(item.Value, 10) 1425 // require.True(t, ok) 1426 // balances[address] = balance 1427 // case int(merkletree.LeafTypeNonce): 1428 // nonce, ok := new(big.Int).SetString(item.Value, 10) 1429 // require.True(t, ok) 1430 // nonces[address] = nonce 1431 // case int(merkletree.LeafTypeCode): 1432 // if strings.HasPrefix(item.Bytecode, "0x") { // nolint 1433 // item.Bytecode = item.Bytecode[2:] 1434 // } 1435 // bytecodeSlice := common.Hex2Bytes(item.Bytecode) 1436 // smartContracts[address] = bytecodeSlice 1437 // case int(merkletree.LeafTypeStorage): 1438 // if strings.HasPrefix(item.StoragePosition, "0x") { // nolint 1439 // item.StoragePosition = item.StoragePosition[2:] 1440 // } 1441 // storageKey, ok := new(big.Int).SetString(item.StoragePosition, 16) 1442 // require.True(t, ok) 1443 // storageValue, ok := new(big.Int).SetString(item.Value, 10) 1444 // require.True(t, ok) 1445 // if storage[address] == nil { 1446 // storage[address] = map[*big.Int]*big.Int{} 1447 // } 1448 // storage[address][storageKey] = storageValue 1449 1450 // // Currently the test vector includes storage values in base10 format, 1451 // // our SetGenesisAccountsBalance requires base16 values. 1452 // item.Value = hex.EncodeBig(storageValue) 1453 // } 1454 // } 1455 1456 // block := state.Block{ 1457 // BlockNumber: 1, 1458 // BlockHash: state.ZeroHash, 1459 // ParentHash: state.ZeroHash, 1460 // ReceivedAt: time.Now(), 1461 // } 1462 1463 // genesis := state.Genesis{ 1464 // Actions: tv.GenesisRaw, 1465 // } 1466 1467 // require.NoError(t, dbutils.InitOrReset(cfg)) 1468 1469 // dbTx, err := testState.BeginStateTransaction(ctx) 1470 // require.NoError(t, err) 1471 // stateRoot, err := testState.SetGenesisAccountsBalance(ctx, block, genesis, dbTx) 1472 // require.NoError(t, err) 1473 // require.NoError(t, dbTx.Commit(ctx)) 1474 1475 // expectedRoot := tv.GenesisRaw[len(tv.GenesisRaw)-1].Root 1476 // require.Equal(t, expectedRoot, hex.EncodeToHex(stateRoot)) 1477 1478 // // Check Balances 1479 // for address, expectedBalance := range balances { 1480 // actualBalance, err := stateTree.GetBalance(ctx, address, stateRoot) 1481 // require.NoError(t, err) 1482 // require.Equal(t, expectedBalance, actualBalance) 1483 // } 1484 1485 // // Check Nonces 1486 // for address, expectedNonce := range nonces { 1487 // actualNonce, err := stateTree.GetNonce(ctx, address, stateRoot) 1488 // require.NoError(t, err) 1489 // require.Equal(t, expectedNonce, actualNonce) 1490 // } 1491 1492 // // Check smart contracts 1493 // for address, expectedBytecode := range smartContracts { 1494 // actualBytecode, err := stateTree.GetCode(ctx, address, stateRoot) 1495 // require.NoError(t, err) 1496 // require.Equal(t, expectedBytecode, actualBytecode) 1497 // } 1498 1499 // // Check Storage 1500 // for address, storageMap := range storage { 1501 // for expectedKey, expectedValue := range storageMap { 1502 // actualValue, err := stateTree.GetStorageAt(ctx, address, expectedKey, stateRoot) 1503 // require.NoError(t, err) 1504 1505 // require.Equal(t, expectedValue, actualValue) 1506 // } 1507 // } 1508 1509 // processCtx := state.ProcessingContext{ 1510 // BatchNumber: tv.Traces.NumBatch, 1511 // Coinbase: common.HexToAddress(tv.Traces.SequencerAddr), 1512 // Timestamp: time.Unix(int64(tv.Traces.Timestamp), 0), 1513 // globalExitRoot: common.HexToHash(tv.globalExitRoot), 1514 // } 1515 1516 // if strings.HasPrefix(tv.BatchL2Data, "0x") { // nolint 1517 // tv.BatchL2Data = tv.BatchL2Data[2:] 1518 // } 1519 // dbTx, err = testState.BeginStateTransaction(ctx) 1520 // require.NoError(t, err) 1521 1522 // err = testState.ProcessAndStoreClosedBatch(ctx, processCtx, common.Hex2Bytes(tv.BatchL2Data), dbTx) // nolint:ineffassign,staticcheck 1523 // // TODO: actually check for nil err in ProcessAndStoreClosedBatch return value, 1524 // // currently blocked by the issue about the mismatched tx hashes described here 1525 // // https://github.com/0xPolygon/supernets2-node/issues/1033 1526 // // require.NoError(t, err) 1527 1528 // // TODO: currently the db tx is marked as invalid after the first error, once 1529 // // testState.ProcessAndStoreClosedBatch works properly we should make assertions 1530 // // about the database contents: batches, blocksL2, logs, receipts, .... 1531 // } 1532 1533 func TestExecutorUnsignedTransactions(t *testing.T) { 1534 // Init database instance 1535 initOrResetDB() 1536 1537 var chainIDSequencer = new(big.Int).SetInt64(1000) 1538 var sequencerAddress = common.HexToAddress("0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D") 1539 var sequencerPvtKey = "0x28b2b0318721be8c8339199172cd7cc8f5e273800a35616ec893083a4b32c02e" 1540 var gasLimit = uint64(4000000) 1541 var scAddress = common.HexToAddress("0x1275fbb540c8efC58b812ba83B0D0B8b9917AE98") 1542 scByteCode, err := testutils.ReadBytecode("Counter/Counter.bin") 1543 require.NoError(t, err) 1544 1545 // auth 1546 privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(sequencerPvtKey, "0x")) 1547 require.NoError(t, err) 1548 auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainIDSequencer) 1549 require.NoError(t, err) 1550 1551 // signed tx to deploy SC 1552 unsignedTxDeploy := types.NewTx(&types.LegacyTx{ 1553 Nonce: 0, 1554 To: nil, 1555 Value: new(big.Int), 1556 Gas: gasLimit, 1557 GasPrice: new(big.Int), 1558 Data: common.Hex2Bytes(scByteCode), 1559 }) 1560 signedTxDeploy, err := auth.Signer(auth.From, unsignedTxDeploy) 1561 require.NoError(t, err) 1562 1563 incrementFnSignature := crypto.Keccak256Hash([]byte("increment()")).Bytes()[:4] 1564 retrieveFnSignature := crypto.Keccak256Hash([]byte("getCount()")).Bytes()[:4] 1565 1566 // signed tx to call SC 1567 unsignedTxFirstIncrement := types.NewTx(&types.LegacyTx{ 1568 Nonce: 1, 1569 To: &scAddress, 1570 Value: new(big.Int), 1571 Gas: gasLimit, 1572 GasPrice: new(big.Int), 1573 Data: incrementFnSignature, 1574 }) 1575 signedTxFirstIncrement, err := auth.Signer(auth.From, unsignedTxFirstIncrement) 1576 require.NoError(t, err) 1577 1578 unsignedTxFirstRetrieve := types.NewTx(&types.LegacyTx{ 1579 Nonce: 2, 1580 To: &scAddress, 1581 Value: new(big.Int), 1582 Gas: gasLimit, 1583 GasPrice: new(big.Int), 1584 Data: retrieveFnSignature, 1585 }) 1586 signedTxFirstRetrieve, err := auth.Signer(auth.From, unsignedTxFirstRetrieve) 1587 require.NoError(t, err) 1588 1589 dbTx, err := testState.BeginStateTransaction(context.Background()) 1590 require.NoError(t, err) 1591 // Set genesis 1592 genesis := state.Genesis{GenesisActions: []*state.GenesisAction{ 1593 { 1594 Address: sequencerAddress.Hex(), 1595 Type: int(merkletree.LeafTypeBalance), 1596 Value: "100000000000000000000000", 1597 }, 1598 }} 1599 _, err = testState.SetGenesis(ctx, state.Block{}, genesis, dbTx) 1600 require.NoError(t, err) 1601 batchCtx := state.ProcessingContext{ 1602 BatchNumber: 1, 1603 Coinbase: sequencerAddress, 1604 Timestamp: time.Now(), 1605 } 1606 err = testState.OpenBatch(context.Background(), batchCtx, dbTx) 1607 require.NoError(t, err) 1608 signedTxs := []types.Transaction{ 1609 *signedTxDeploy, 1610 *signedTxFirstIncrement, 1611 *signedTxFirstRetrieve, 1612 } 1613 1614 batchL2Data, err := state.EncodeTransactions(signedTxs) 1615 require.NoError(t, err) 1616 1617 processBatchResponse, err := testState.ProcessSequencerBatch(context.Background(), 1, batchL2Data, metrics.SequencerCallerLabel, dbTx) 1618 require.NoError(t, err) 1619 // assert signed tx do deploy sc 1620 assert.Nil(t, processBatchResponse.Responses[0].RomError) 1621 assert.Equal(t, scAddress, processBatchResponse.Responses[0].CreateAddress) 1622 1623 // assert signed tx to increment counter 1624 assert.Nil(t, processBatchResponse.Responses[1].RomError) 1625 1626 // assert signed tx to increment counter 1627 assert.Nil(t, processBatchResponse.Responses[2].RomError) 1628 assert.Equal(t, "0000000000000000000000000000000000000000000000000000000000000001", hex.EncodeToString(processBatchResponse.Responses[2].ReturnValue)) 1629 1630 // Add txs to DB 1631 err = testState.StoreTransactions(context.Background(), 1, processBatchResponse.Responses, dbTx) 1632 require.NoError(t, err) 1633 // Close batch 1634 err = testState.CloseBatch( 1635 context.Background(), 1636 state.ProcessingReceipt{ 1637 BatchNumber: 1, 1638 StateRoot: processBatchResponse.NewStateRoot, 1639 LocalExitRoot: processBatchResponse.NewLocalExitRoot, 1640 }, dbTx, 1641 ) 1642 require.NoError(t, err) 1643 require.NoError(t, dbTx.Commit(context.Background())) 1644 1645 unsignedTxSecondRetrieve := types.NewTx(&types.LegacyTx{ 1646 Nonce: 0, 1647 To: &scAddress, 1648 Value: new(big.Int), 1649 Gas: gasLimit, 1650 GasPrice: new(big.Int), 1651 Data: retrieveFnSignature, 1652 }) 1653 l2BlockNumber := uint64(3) 1654 1655 result, err := testState.ProcessUnsignedTransaction(context.Background(), unsignedTxSecondRetrieve, common.HexToAddress("0x1000000000000000000000000000000000000000"), &l2BlockNumber, true, nil) 1656 require.NoError(t, err) 1657 // assert unsigned tx 1658 assert.Nil(t, result.Err) 1659 assert.Equal(t, "0000000000000000000000000000000000000000000000000000000000000001", hex.EncodeToString(result.ReturnValue)) 1660 } 1661 1662 func TestAddGetL2Block(t *testing.T) { 1663 // Init database instance 1664 initOrResetDB() 1665 1666 ctx := context.Background() 1667 dbTx, err := testState.BeginStateTransaction(ctx) 1668 require.NoError(t, err) 1669 block := &state.Block{ 1670 BlockNumber: 1, 1671 BlockHash: common.HexToHash("0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9f1"), 1672 ParentHash: common.HexToHash("0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9f1"), 1673 ReceivedAt: time.Now(), 1674 } 1675 err = testState.AddBlock(ctx, block, dbTx) 1676 assert.NoError(t, err) 1677 1678 batchNumber := uint64(1) 1679 _, err = testState.PostgresStorage.Exec(ctx, "INSERT INTO state.batch (batch_num) VALUES ($1)", batchNumber) 1680 assert.NoError(t, err) 1681 1682 time := time.Now() 1683 blockNumber := big.NewInt(1) 1684 1685 tx := types.NewTx(&types.LegacyTx{ 1686 Nonce: 0, 1687 To: nil, 1688 Value: new(big.Int), 1689 Gas: 0, 1690 GasPrice: big.NewInt(0), 1691 }) 1692 1693 receipt := &types.Receipt{ 1694 Type: uint8(tx.Type()), 1695 PostState: state.ZeroHash.Bytes(), 1696 CumulativeGasUsed: 0, 1697 BlockNumber: blockNumber, 1698 GasUsed: tx.Gas(), 1699 TxHash: tx.Hash(), 1700 TransactionIndex: 0, 1701 Status: types.ReceiptStatusSuccessful, 1702 } 1703 1704 header := &types.Header{ 1705 Number: big.NewInt(1), 1706 ParentHash: state.ZeroHash, 1707 Coinbase: state.ZeroAddress, 1708 Root: state.ZeroHash, 1709 GasUsed: 1, 1710 GasLimit: 10, 1711 Time: uint64(time.Unix()), 1712 } 1713 transactions := []*types.Transaction{tx} 1714 1715 receipts := []*types.Receipt{receipt} 1716 1717 // Create block to be able to calculate its hash 1718 l2Block := types.NewBlock(header, transactions, []*types.Header{}, receipts, &trie.StackTrie{}) 1719 l2Block.ReceivedAt = time 1720 1721 receipt.BlockHash = l2Block.Hash() 1722 1723 err = testState.AddL2Block(ctx, batchNumber, l2Block, receipts, dbTx) 1724 require.NoError(t, err) 1725 result, err := testState.GetL2BlockByHash(ctx, l2Block.Hash(), dbTx) 1726 require.NoError(t, err) 1727 1728 assert.Equal(t, l2Block.Hash(), result.Hash()) 1729 1730 result, err = testState.GetL2BlockByNumber(ctx, l2Block.NumberU64(), dbTx) 1731 require.NoError(t, err) 1732 1733 assert.Equal(t, l2Block.Hash(), result.Hash()) 1734 assert.Equal(t, l2Block.ReceivedAt.Unix(), result.ReceivedAt.Unix()) 1735 assert.Equal(t, l2Block.Time(), result.Time()) 1736 1737 require.NoError(t, dbTx.Commit(ctx)) 1738 } 1739 1740 /* 1741 func TestExecutorUniswapOutOfCounters(t *testing.T) { 1742 // Test Case 1743 type TxHashTestCase struct { 1744 Hash string `json:"hash"` 1745 Encoded string `json:"encoded"` 1746 } 1747 1748 var testCases []TxHashTestCase 1749 1750 jsonFile, err := os.Open(filepath.Clean("test/vectors/src/tx-hash-ethereum/uniswap.json")) 1751 require.NoError(t, err) 1752 defer func() { _ = jsonFile.Close() }() 1753 1754 Bytes, err := ioutil.ReadAll(jsonFile) 1755 require.NoError(t, err) 1756 1757 err = json.Unmarshal(Bytes, &testCases) 1758 require.NoError(t, err) 1759 1760 // Set Genesis 1761 block := state.Block{ 1762 BlockNumber: 0, 1763 BlockHash: state.ZeroHash, 1764 ParentHash: state.ZeroHash, 1765 ReceivedAt: time.Now(), 1766 } 1767 1768 genesis := state.Genesis{ 1769 Actions: []*state.GenesisAction{ 1770 { 1771 Address: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8", 1772 Type: int(merkletree.LeafTypeBalance), 1773 Value: "100000000000000000000000", 1774 }, 1775 { 1776 Address: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", 1777 Type: int(merkletree.LeafTypeBalance), 1778 Value: "100000000000000000000000", 1779 }, 1780 }, 1781 } 1782 1783 initOrResetDB() 1784 1785 dbTx, err := testState.BeginStateTransaction(ctx) 1786 require.NoError(t, err) 1787 stateRoot, err := testState.SetGenesisAccountsBalance(ctx, block, genesis, dbTx) 1788 require.NoError(t, err) 1789 require.NoError(t, dbTx.Commit(ctx)) 1790 1791 transactions := make([]types.Transaction, len(testCases)) 1792 1793 for x, testCase := range testCases { 1794 log.Debugf("Hash:%v", testCase.Hash) 1795 tx, err := state.DecodeTx(strings.TrimLeft(testCase.Encoded, "0x")) 1796 require.NoError(t, err) 1797 transactions[x] = *tx 1798 } 1799 1800 var numBatch uint64 1801 1802 for len(transactions) != 0 { 1803 numBatch++ 1804 log.Debugf("# of transactions to process= %d", len(transactions)) 1805 1806 batchL2Data, err := state.EncodeTransactions(transactions) 1807 require.NoError(t, err) 1808 1809 // Create Batch 1810 processBatchRequest := &executorclientpb.ProcessBatchRequest{ 1811 BatchNum: numBatch, 1812 Coinbase: common.Address{}.String(), 1813 BatchL2Data: batchL2Data, 1814 OldStateRoot: stateRoot, 1815 globalExitRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 1816 OldLocalExitRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 1817 EthTimestamp: uint64(0), 1818 UpdateMerkleTree: 1, 1819 } 1820 1821 var testCases []TxHashTestCase 1822 1823 jsonFile, err := os.Open(filepath.Clean("test/vectors/src/tx-hash-ethereum/uniswap.json")) 1824 require.NoError(t, err) 1825 defer func() { _ = jsonFile.Close() }() 1826 1827 Bytes, err := ioutil.ReadAll(jsonFile) 1828 require.NoError(t, err) 1829 1830 err = json.Unmarshal(Bytes, &testCases) 1831 require.NoError(t, err) 1832 1833 // Set Genesis 1834 block := state.Block{ 1835 BlockNumber: 0, 1836 BlockHash: state.ZeroHash, 1837 ParentHash: state.ZeroHash, 1838 ReceivedAt: time.Now(), 1839 } 1840 1841 genesis := state.Genesis{ 1842 Actions: []*state.GenesisAction{ 1843 { 1844 Address: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8", 1845 Type: int(merkletree.LeafTypeBalance), 1846 Value: "100000000000000000000000", 1847 }, 1848 { 1849 Address: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", 1850 Type: int(merkletree.LeafTypeBalance), 1851 Value: "100000000000000000000000", 1852 }, 1853 }, 1854 } 1855 1856 initOrResetDB() 1857 1858 dbTx, err := testState.BeginStateTransaction(ctx) 1859 require.NoError(t, err) 1860 stateRoot, err := testState.SetGenesisAccountsBalance(ctx, block, genesis, dbTx) 1861 require.NoError(t, err) 1862 require.NoError(t, dbTx.Commit(ctx)) 1863 1864 transactions := make([]types.Transaction, len(testCases)) 1865 1866 for x, testCase := range testCases { 1867 log.Debugf("Hash:%v", testCase.Hash) 1868 tx, err := state.DecodeTx(strings.TrimLeft(testCase.Encoded, "0x")) 1869 require.NoError(t, err) 1870 transactions[x] = *tx 1871 } 1872 1873 var numBatch uint64 1874 1875 for len(transactions) != 0 { 1876 numBatch++ 1877 log.Debugf("# of transactions to process= %d", len(transactions)) 1878 1879 batchL2Data, err := state.EncodeTransactions(transactions) 1880 require.NoError(t, err) 1881 1882 // Create Batch 1883 processBatchRequest := &executorclientpb.ProcessBatchRequest{ 1884 BatchNum: numBatch, 1885 Coinbase: common.Address{}.String(), 1886 BatchL2Data: batchL2Data, 1887 OldStateRoot: stateRoot, 1888 globalExitRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 1889 OldLocalExitRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 1890 EthTimestamp: uint64(0), 1891 UpdateMerkleTree: 1, 1892 ChainId: stateCfg.ChainID, 1893 ForkId: forkID, 1894 } 1895 1896 // Process batch 1897 processBatchResponse, err := executorClient.ProcessBatch(ctx, processBatchRequest) 1898 require.NoError(t, err) 1899 1900 processedTxs := len(processBatchResponse.Responses) 1901 1902 if int32(processBatchResponse.Responses[processedTxs-1].Error) == executor.ERROR_OUT_OF_COUNTERS { 1903 newTransactions := transactions[0 : processedTxs-1] 1904 log.Debugf("# of transactions to reprocess= %d", len(newTransactions)) 1905 1906 batchL2Data, err := state.EncodeTransactions(newTransactions) 1907 require.NoError(t, err) 1908 1909 // Create Batch 1910 processBatchRequest := &executorclientpb.ProcessBatchRequest{ 1911 BatchNum: numBatch, 1912 Coinbase: common.Address{}.String(), 1913 BatchL2Data: batchL2Data, 1914 OldStateRoot: processBatchResponse.NewStateRoot, 1915 globalExitRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 1916 OldLocalExitRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 1917 EthTimestamp: uint64(0), 1918 UpdateMerkleTree: 1, 1919 } 1920 1921 // Process batch 1922 processBatchResponse, err = executorClient.ProcessBatch(ctx, processBatchRequest) 1923 require.NoError(t, err) 1924 1925 processedTxs = len(processBatchResponse.Responses) 1926 } 1927 1928 for _, response := range processBatchResponse.Responses { 1929 require.Equal(t, executor.ERROR_NO_ERROR, int32(response.Error)) 1930 } 1931 1932 transactions = transactions[processedTxs:] 1933 stateRoot = processBatchResponse.NewStateRoot 1934 } 1935 } 1936 } 1937 */ 1938 1939 func initOrResetDB() { 1940 if err := dbutils.InitOrResetState(stateDBCfg); err != nil { 1941 panic(err) 1942 } 1943 } 1944 1945 func TestExecutorEstimateGas(t *testing.T) { 1946 var chainIDSequencer = new(big.Int).SetUint64(stateCfg.ChainID) 1947 var sequencerAddress = common.HexToAddress("0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D") 1948 var sequencerPvtKey = "0x28b2b0318721be8c8339199172cd7cc8f5e273800a35616ec893083a4b32c02e" 1949 var scAddress = common.HexToAddress("0x1275fbb540c8efC58b812ba83B0D0B8b9917AE98") 1950 var sequencerBalance = 4000000 1951 scRevertByteCode, err := testutils.ReadBytecode("Revert2/Revert2.bin") 1952 require.NoError(t, err) 1953 1954 // Set Genesis 1955 block := state.Block{ 1956 BlockNumber: 0, 1957 BlockHash: state.ZeroHash, 1958 ParentHash: state.ZeroHash, 1959 ReceivedAt: time.Now(), 1960 } 1961 1962 genesis := state.Genesis{ 1963 GenesisActions: []*state.GenesisAction{ 1964 { 1965 Address: "0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D", 1966 Type: int(merkletree.LeafTypeBalance), 1967 Value: "100000000000000000000000", 1968 }, 1969 { 1970 Address: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8", 1971 Type: int(merkletree.LeafTypeBalance), 1972 Value: "100000000000000000000000", 1973 }, 1974 { 1975 Address: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", 1976 Type: int(merkletree.LeafTypeBalance), 1977 Value: "100000000000000000000000", 1978 }, 1979 }, 1980 } 1981 1982 initOrResetDB() 1983 1984 dbTx, err := testState.BeginStateTransaction(ctx) 1985 require.NoError(t, err) 1986 stateRoot, err := testState.SetGenesis(ctx, block, genesis, dbTx) 1987 require.NoError(t, err) 1988 require.NoError(t, dbTx.Commit(ctx)) 1989 1990 nonce := uint64(0) 1991 1992 // Deploy revert.sol 1993 tx0 := types.NewTx(&types.LegacyTx{ 1994 Nonce: nonce, 1995 To: nil, 1996 Value: new(big.Int), 1997 Gas: uint64(sequencerBalance), 1998 GasPrice: new(big.Int).SetUint64(0), 1999 Data: common.Hex2Bytes(scRevertByteCode), 2000 }) 2001 2002 privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(sequencerPvtKey, "0x")) 2003 require.NoError(t, err) 2004 auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainIDSequencer) 2005 require.NoError(t, err) 2006 2007 signedTx0, err := auth.Signer(auth.From, tx0) 2008 require.NoError(t, err) 2009 2010 // Call SC method 2011 nonce++ 2012 tx1 := types.NewTransaction(nonce, scAddress, new(big.Int), 40000, new(big.Int).SetUint64(1), common.Hex2Bytes("4abbb40a")) 2013 signedTx1, err := auth.Signer(auth.From, tx1) 2014 require.NoError(t, err) 2015 2016 batchL2Data, err := state.EncodeTransactions([]types.Transaction{*signedTx0, *signedTx1}) 2017 require.NoError(t, err) 2018 2019 // Create Batch 2020 processBatchRequest := &executorclientpb.ProcessBatchRequest{ 2021 OldBatchNum: 0, 2022 Coinbase: sequencerAddress.String(), 2023 BatchL2Data: batchL2Data, 2024 OldStateRoot: stateRoot, 2025 GlobalExitRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 2026 OldAccInputHash: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 2027 EthTimestamp: uint64(time.Now().Unix()), 2028 UpdateMerkleTree: 0, 2029 ChainId: stateCfg.ChainID, 2030 ForkId: forkID, 2031 } 2032 2033 processBatchResponse, err := executorClient.ProcessBatch(ctx, processBatchRequest) 2034 require.NoError(t, err) 2035 assert.NotEqual(t, "", processBatchResponse.Responses[0].Error) 2036 2037 convertedResponse, err := testState.TestConvertToProcessBatchResponse([]types.Transaction{*signedTx0, *signedTx1}, processBatchResponse) 2038 require.NoError(t, err) 2039 log.Debugf("%v", len(convertedResponse.Responses)) 2040 2041 // Store processed txs into the batch 2042 dbTx, err = testState.BeginStateTransaction(ctx) 2043 require.NoError(t, err) 2044 2045 processingContext := state.ProcessingContext{ 2046 BatchNumber: processBatchRequest.OldBatchNum + 1, 2047 Coinbase: common.Address{}, 2048 Timestamp: time.Now(), 2049 GlobalExitRoot: common.BytesToHash(processBatchRequest.GlobalExitRoot), 2050 } 2051 2052 err = testState.OpenBatch(ctx, processingContext, dbTx) 2053 require.NoError(t, err) 2054 2055 err = testState.StoreTransactions(ctx, processBatchRequest.OldBatchNum+1, convertedResponse.Responses, dbTx) 2056 require.NoError(t, err) 2057 2058 processingReceipt := state.ProcessingReceipt{ 2059 BatchNumber: processBatchRequest.OldBatchNum + 1, 2060 StateRoot: convertedResponse.NewStateRoot, 2061 LocalExitRoot: convertedResponse.NewLocalExitRoot, 2062 } 2063 2064 err = testState.CloseBatch(ctx, processingReceipt, dbTx) 2065 require.NoError(t, err) 2066 require.NoError(t, dbTx.Commit(ctx)) 2067 2068 // l2BlockNumber := uint64(2) 2069 nonce++ 2070 tx2 := types.NewTx(&types.LegacyTx{ 2071 Nonce: nonce, 2072 To: nil, 2073 Value: new(big.Int), 2074 Gas: uint64(sequencerBalance), 2075 GasPrice: new(big.Int).SetUint64(0), 2076 Data: common.Hex2Bytes(scRevertByteCode), 2077 }) 2078 signedTx2, err := auth.Signer(auth.From, tx2) 2079 require.NoError(t, err) 2080 2081 blockNumber, err := testState.GetLastL2BlockNumber(ctx, nil) 2082 require.NoError(t, err) 2083 2084 estimatedGas, _, err := testState.EstimateGas(signedTx2, sequencerAddress, &blockNumber, nil) 2085 require.NoError(t, err) 2086 log.Debugf("Estimated gas = %v", estimatedGas) 2087 2088 nonce++ 2089 tx3 := types.NewTransaction(nonce, scAddress, new(big.Int), 40000, new(big.Int).SetUint64(1), common.Hex2Bytes("4abbb40a")) 2090 signedTx3, err := auth.Signer(auth.From, tx3) 2091 require.NoError(t, err) 2092 _, _, err = testState.EstimateGas(signedTx3, sequencerAddress, &blockNumber, nil) 2093 require.Error(t, err) 2094 } 2095 2096 // TODO: Uncomment once the executor properly returns gas refund 2097 /* 2098 func TestExecutorGasRefund(t *testing.T) { 2099 var chainIDSequencer = new(big.Int).SetInt64(1000) 2100 var sequencerAddress = common.HexToAddress("0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D") 2101 var sequencerPvtKey = "0x28b2b0318721be8c8339199172cd7cc8f5e273800a35616ec893083a4b32c02e" 2102 var scAddress = common.HexToAddress("0x1275fbb540c8efC58b812ba83B0D0B8b9917AE98") 2103 var sequencerBalance = 4000000 2104 scStorageByteCode, err := testutils.ReadBytecode("Storage/Storage.bin") 2105 require.NoError(t, err) 2106 2107 // Set Genesis 2108 block := state.Block{ 2109 BlockNumber: 0, 2110 BlockHash: state.ZeroHash, 2111 ParentHash: state.ZeroHash, 2112 ReceivedAt: time.Now(), 2113 } 2114 2115 genesis := state.Genesis{ 2116 Actions: []*state.GenesisAction{ 2117 { 2118 Address: "0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D", 2119 Type: int(merkletree.LeafTypeBalance), 2120 Value: "100000000000000000000000", 2121 }, 2122 { 2123 Address: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8", 2124 Type: int(merkletree.LeafTypeBalance), 2125 Value: "100000000000000000000000", 2126 }, 2127 { 2128 Address: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", 2129 Type: int(merkletree.LeafTypeBalance), 2130 Value: "100000000000000000000000", 2131 }, 2132 }, 2133 } 2134 2135 initOrResetDB() 2136 2137 dbTx, err := testState.BeginStateTransaction(ctx) 2138 require.NoError(t, err) 2139 stateRoot, err := testState.SetGenesisAccountsBalance(ctx, block, genesis, dbTx) 2140 require.NoError(t, err) 2141 require.NoError(t, dbTx.Commit(ctx)) 2142 2143 // Deploy contract 2144 tx0 := types.NewTx(&types.LegacyTx{ 2145 Nonce: 0, 2146 To: nil, 2147 Value: new(big.Int), 2148 Gas: uint64(sequencerBalance), 2149 GasPrice: new(big.Int).SetUint64(0), 2150 Data: common.Hex2Bytes(scStorageByteCode), 2151 }) 2152 2153 privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(sequencerPvtKey, "0x")) 2154 require.NoError(t, err) 2155 auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainIDSequencer) 2156 require.NoError(t, err) 2157 2158 signedTx0, err := auth.Signer(auth.From, tx0) 2159 require.NoError(t, err) 2160 2161 // Call SC method to set value to 123456 2162 tx1 := types.NewTransaction(1, scAddress, new(big.Int), 80000, new(big.Int).SetUint64(0), common.Hex2Bytes("6057361d000000000000000000000000000000000000000000000000000000000001e240")) 2163 signedTx1, err := auth.Signer(auth.From, tx1) 2164 require.NoError(t, err) 2165 2166 batchL2Data, err := state.EncodeTransactions([]types.Transaction{*signedTx0, *signedTx1}) 2167 require.NoError(t, err) 2168 2169 // Create Batch 2170 processBatchRequest := &executorclientpb.ProcessBatchRequest{ 2171 BatchNum: 1, 2172 Coinbase: sequencerAddress.String(), 2173 BatchL2Data: batchL2Data, 2174 OldStateRoot: stateRoot, 2175 globalExitRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 2176 OldLocalExitRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 2177 EthTimestamp: uint64(time.Now().Unix()), 2178 UpdateMerkleTree: 1, 2179 ChainId: stateCfg.ChainID, 2180 ForkId: forkID, 2181 } 2182 2183 processBatchResponse, err := executorClient.ProcessBatch(ctx, processBatchRequest) 2184 require.NoError(t, err) 2185 assert.Equal(t, pb.Error_ERROR_NO_ERROR, processBatchResponse.Responses[0].Error) 2186 assert.Equal(t, pb.Error_ERROR_NO_ERROR, processBatchResponse.Responses[1].Error) 2187 2188 // Preparation to be able to estimate gas 2189 convertedResponse, err := state.TestConvertToProcessBatchResponse([]types.Transaction{*signedTx0, *signedTx1}, processBatchResponse) 2190 require.NoError(t, err) 2191 log.Debugf("%v", len(convertedResponse.Responses)) 2192 2193 // Store processed txs into the batch 2194 dbTx, err = testState.BeginStateTransaction(ctx) 2195 require.NoError(t, err) 2196 2197 processingContext := state.ProcessingContext{ 2198 BatchNumber: processBatchRequest.BatchNum, 2199 Coinbase: common.Address{}, 2200 Timestamp: time.Now(), 2201 globalExitRoot: common.BytesToHash(processBatchRequest.globalExitRoot), 2202 } 2203 2204 err = testState.OpenBatch(ctx, processingContext, dbTx) 2205 require.NoError(t, err) 2206 2207 err = testState.StoreTransactions(ctx, processBatchRequest.BatchNum, convertedResponse.Responses, dbTx) 2208 require.NoError(t, err) 2209 2210 processingReceipt := state.ProcessingReceipt{ 2211 BatchNumber: processBatchRequest.BatchNum, 2212 StateRoot: convertedResponse.NewStateRoot, 2213 LocalExitRoot: convertedResponse.NewLocalExitRoot, 2214 } 2215 2216 err = testState.CloseBatch(ctx, processingReceipt, dbTx) 2217 require.NoError(t, err) 2218 require.NoError(t, dbTx.Commit(ctx)) 2219 2220 // Retrieve Value 2221 tx2 := types.NewTransaction(2, scAddress, new(big.Int), 80000, new(big.Int).SetUint64(0), common.Hex2Bytes("2e64cec1")) 2222 signedTx2, err := auth.Signer(auth.From, tx2) 2223 require.NoError(t, err) 2224 2225 estimatedGas, _, err := testState.EstimateGas(signedTx2, sequencerAddress, nil, nil) 2226 require.NoError(t, err) 2227 log.Debugf("Estimated gas = %v", estimatedGas) 2228 2229 tx2 = types.NewTransaction(2, scAddress, new(big.Int), estimatedGas, new(big.Int).SetUint64(0), common.Hex2Bytes("2e64cec1")) 2230 signedTx2, err = auth.Signer(auth.From, tx2) 2231 require.NoError(t, err) 2232 2233 batchL2Data, err = state.EncodeTransactions([]types.Transaction{*signedTx2}) 2234 require.NoError(t, err) 2235 2236 processBatchRequest = &executorclientpb.ProcessBatchRequest{ 2237 BatchNum: 2, 2238 Coinbase: sequencerAddress.String(), 2239 BatchL2Data: batchL2Data, 2240 OldStateRoot: processBatchResponse.NewStateRoot, 2241 globalExitRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 2242 OldLocalExitRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 2243 EthTimestamp: uint64(time.Now().Unix()), 2244 UpdateMerkleTree: 1, 2245 ChainId: stateCfg.ChainID, 2246 ForkId: forkID, 2247 } 2248 2249 processBatchResponse, err = executorClient.ProcessBatch(ctx, processBatchRequest) 2250 require.NoError(t, err) 2251 assert.Equal(t, pb.Error_ERROR_NO_ERROR, processBatchResponse.Responses[0].Error) 2252 assert.LessOrEqual(t, processBatchResponse.Responses[0].GasUsed, estimatedGas) 2253 assert.NotEqual(t, uint64(0), processBatchResponse.Responses[0].GasRefunded) 2254 assert.Equal(t, new(big.Int).SetInt64(123456), new(big.Int).SetBytes(processBatchResponse.Responses[0].ReturnValue)) 2255 } 2256 */ 2257 2258 func TestExecutorGasEstimationMultisig(t *testing.T) { 2259 var chainIDSequencer = new(big.Int).SetInt64(1000) 2260 var sequencerAddress = common.HexToAddress("0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D") 2261 var sequencerPvtKey = "0x28b2b0318721be8c8339199172cd7cc8f5e273800a35616ec893083a4b32c02e" 2262 var erc20SCAddress = common.HexToAddress("0x1275fbb540c8efC58b812ba83B0D0B8b9917AE98") 2263 var multisigSCAddress = common.HexToAddress("0x85e844b762a271022b692cf99ce5c59ba0650ac8") 2264 var multisigParameter = "00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000004000000000000000000000000617b3a3528F9cDd6630fd3301B9c8911F7Bf063D000000000000000000000000B2D0a21D2b14679331f67F3FAB36366ef2270312000000000000000000000000B2bF7Ef15AFfcd23d99A9FB41a310992a70Ed7720000000000000000000000005b6C62FF5dC5De57e9B1a36B64BE3ef4Ac9b08fb" 2265 var sequencerBalance = 4000000 2266 scERC20ByteCode, err := testutils.ReadBytecode("../compiled/ERC20Token/ERC20Token.bin") 2267 require.NoError(t, err) 2268 scMultiSigByteCode, err := testutils.ReadBytecode("../compiled/MultiSigWallet/MultiSigWallet.bin") 2269 require.NoError(t, err) 2270 2271 // Set Genesis 2272 block := state.Block{ 2273 BlockNumber: 0, 2274 BlockHash: state.ZeroHash, 2275 ParentHash: state.ZeroHash, 2276 ReceivedAt: time.Now(), 2277 } 2278 2279 genesis := state.Genesis{ 2280 GenesisActions: []*state.GenesisAction{ 2281 { 2282 Address: "0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D", 2283 Type: int(merkletree.LeafTypeBalance), 2284 Value: "100000000000000000000000", 2285 }, 2286 { 2287 Address: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8", 2288 Type: int(merkletree.LeafTypeBalance), 2289 Value: "100000000000000000000000", 2290 }, 2291 { 2292 Address: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", 2293 Type: int(merkletree.LeafTypeBalance), 2294 Value: "100000000000000000000000", 2295 }, 2296 }, 2297 } 2298 2299 initOrResetDB() 2300 2301 dbTx, err := testState.BeginStateTransaction(ctx) 2302 require.NoError(t, err) 2303 stateRoot, err := testState.SetGenesis(ctx, block, genesis, dbTx) 2304 require.NoError(t, err) 2305 require.NoError(t, dbTx.Commit(ctx)) 2306 2307 // Deploy contract 2308 tx0 := types.NewTx(&types.LegacyTx{ 2309 Nonce: 0, 2310 To: nil, 2311 Value: new(big.Int), 2312 Gas: uint64(sequencerBalance), 2313 GasPrice: new(big.Int).SetUint64(0), 2314 Data: common.Hex2Bytes(scERC20ByteCode), 2315 }) 2316 2317 privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(sequencerPvtKey, "0x")) 2318 require.NoError(t, err) 2319 auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainIDSequencer) 2320 require.NoError(t, err) 2321 2322 signedTx0, err := auth.Signer(auth.From, tx0) 2323 require.NoError(t, err) 2324 2325 // Deploy contract 2326 tx1 := types.NewTx(&types.LegacyTx{ 2327 Nonce: 1, 2328 To: nil, 2329 Value: new(big.Int), 2330 Gas: uint64(sequencerBalance), 2331 GasPrice: new(big.Int).SetUint64(0), 2332 Data: common.Hex2Bytes(scMultiSigByteCode + multisigParameter), 2333 }) 2334 2335 signedTx1, err := auth.Signer(auth.From, tx1) 2336 require.NoError(t, err) 2337 2338 // Transfer Ownership 2339 tx2 := types.NewTransaction(2, erc20SCAddress, new(big.Int), 80000, new(big.Int).SetUint64(0), common.Hex2Bytes("f2fde38b00000000000000000000000085e844b762a271022b692cf99ce5c59ba0650ac8")) 2340 signedTx2, err := auth.Signer(auth.From, tx2) 2341 require.NoError(t, err) 2342 2343 // Transfer balance to multisig smart contract 2344 tx3 := types.NewTx(&types.LegacyTx{ 2345 Nonce: 3, 2346 To: &multisigSCAddress, 2347 Value: new(big.Int).SetUint64(1000000000), 2348 Gas: uint64(30000), 2349 GasPrice: new(big.Int).SetUint64(1), 2350 Data: nil, 2351 }) 2352 signedTx3, err := auth.Signer(auth.From, tx3) 2353 require.NoError(t, err) 2354 2355 // Submit Transaction 2356 tx4 := types.NewTransaction(4, multisigSCAddress, new(big.Int), 150000, new(big.Int).SetUint64(0), common.Hex2Bytes("c64274740000000000000000000000001275fbb540c8efc58b812ba83b0d0b8b9917ae98000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000014352ca32838ab928d9e55bd7d1a39cb7fbd453ab1000000000000000000000000")) 2357 signedTx4, err := auth.Signer(auth.From, tx4) 2358 require.NoError(t, err) 2359 2360 // Confirm transaction 2361 tx5 := types.NewTransaction(5, multisigSCAddress, new(big.Int), 150000, new(big.Int).SetUint64(0), common.Hex2Bytes("c01a8c840000000000000000000000000000000000000000000000000000000000000000")) 2362 signedTx5, err := auth.Signer(auth.From, tx5) 2363 require.NoError(t, err) 2364 2365 transactions := []types.Transaction{*signedTx0, *signedTx1, *signedTx2, *signedTx3, *signedTx4, *signedTx5} 2366 2367 batchL2Data, err := state.EncodeTransactions(transactions) 2368 require.NoError(t, err) 2369 2370 // Create Batch 2371 processBatchRequest := &executorclientpb.ProcessBatchRequest{ 2372 OldBatchNum: 0, 2373 Coinbase: sequencerAddress.String(), 2374 BatchL2Data: batchL2Data, 2375 OldStateRoot: stateRoot, 2376 GlobalExitRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 2377 OldAccInputHash: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 2378 EthTimestamp: uint64(time.Now().Unix()), 2379 UpdateMerkleTree: 1, 2380 ChainId: stateCfg.ChainID, 2381 ForkId: forkID, 2382 } 2383 2384 processBatchResponse, err := executorClient.ProcessBatch(ctx, processBatchRequest) 2385 require.NoError(t, err) 2386 assert.Equal(t, executorclientpb.RomError_ROM_ERROR_NO_ERROR, processBatchResponse.Responses[0].Error) 2387 assert.Equal(t, executorclientpb.RomError_ROM_ERROR_NO_ERROR, processBatchResponse.Responses[1].Error) 2388 assert.Equal(t, executorclientpb.RomError_ROM_ERROR_NO_ERROR, processBatchResponse.Responses[2].Error) 2389 assert.Equal(t, executorclientpb.RomError_ROM_ERROR_NO_ERROR, processBatchResponse.Responses[3].Error) 2390 assert.Equal(t, executorclientpb.RomError_ROM_ERROR_NO_ERROR, processBatchResponse.Responses[4].Error) 2391 assert.Equal(t, executorclientpb.RomError_ROM_ERROR_NO_ERROR, processBatchResponse.Responses[5].Error) 2392 2393 // Check SC code 2394 // Check Smart Contracts Code 2395 code, err := stateTree.GetCode(ctx, erc20SCAddress, processBatchResponse.NewStateRoot) 2396 require.NoError(t, err) 2397 require.NotEmpty(t, code) 2398 code, err = stateTree.GetCode(ctx, multisigSCAddress, processBatchResponse.NewStateRoot) 2399 require.NoError(t, err) 2400 require.NotEmpty(t, code) 2401 2402 // Check Smart Contract Balance 2403 balance, err := stateTree.GetBalance(ctx, multisigSCAddress, processBatchResponse.NewStateRoot) 2404 require.NoError(t, err) 2405 require.Equal(t, uint64(1000000000), balance.Uint64()) 2406 2407 // Preparation to be able to estimate gas 2408 convertedResponse, err := testState.TestConvertToProcessBatchResponse(transactions, processBatchResponse) 2409 require.NoError(t, err) 2410 log.Debugf("%v", len(convertedResponse.Responses)) 2411 2412 // Store processed txs into the batch 2413 dbTx, err = testState.BeginStateTransaction(ctx) 2414 require.NoError(t, err) 2415 2416 processingContext := state.ProcessingContext{ 2417 BatchNumber: processBatchRequest.OldBatchNum + 1, 2418 Coinbase: common.Address{}, 2419 Timestamp: time.Now(), 2420 GlobalExitRoot: common.BytesToHash(processBatchRequest.GlobalExitRoot), 2421 } 2422 2423 err = testState.OpenBatch(ctx, processingContext, dbTx) 2424 require.NoError(t, err) 2425 2426 err = testState.StoreTransactions(ctx, processBatchRequest.OldBatchNum+1, convertedResponse.Responses, dbTx) 2427 require.NoError(t, err) 2428 2429 processingReceipt := state.ProcessingReceipt{ 2430 BatchNumber: processBatchRequest.OldBatchNum + 1, 2431 StateRoot: convertedResponse.NewStateRoot, 2432 LocalExitRoot: convertedResponse.NewLocalExitRoot, 2433 } 2434 2435 err = testState.CloseBatch(ctx, processingReceipt, dbTx) 2436 require.NoError(t, err) 2437 require.NoError(t, dbTx.Commit(ctx)) 2438 2439 // Revoke Confirmation 2440 tx6 := types.NewTransaction(6, multisigSCAddress, new(big.Int), 50000, new(big.Int).SetUint64(0), common.Hex2Bytes("20ea8d860000000000000000000000000000000000000000000000000000000000000000")) 2441 signedTx6, err := auth.Signer(auth.From, tx6) 2442 require.NoError(t, err) 2443 2444 blockNumber, err := testState.GetLastL2BlockNumber(ctx, nil) 2445 require.NoError(t, err) 2446 2447 estimatedGas, _, err := testState.EstimateGas(signedTx6, sequencerAddress, &blockNumber, nil) 2448 require.NoError(t, err) 2449 log.Debugf("Estimated gas = %v", estimatedGas) 2450 2451 tx6 = types.NewTransaction(6, multisigSCAddress, new(big.Int), estimatedGas, new(big.Int).SetUint64(0), common.Hex2Bytes("20ea8d860000000000000000000000000000000000000000000000000000000000000000")) 2452 signedTx6, err = auth.Signer(auth.From, tx6) 2453 require.NoError(t, err) 2454 2455 batchL2Data, err = state.EncodeTransactions([]types.Transaction{*signedTx6}) 2456 require.NoError(t, err) 2457 2458 processBatchRequest = &executorclientpb.ProcessBatchRequest{ 2459 OldBatchNum: 1, 2460 Coinbase: sequencerAddress.String(), 2461 BatchL2Data: batchL2Data, 2462 OldStateRoot: processBatchResponse.NewStateRoot, 2463 GlobalExitRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 2464 OldAccInputHash: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 2465 EthTimestamp: uint64(time.Now().Unix()), 2466 UpdateMerkleTree: 1, 2467 ChainId: stateCfg.ChainID, 2468 ForkId: forkID, 2469 } 2470 2471 processBatchResponse, err = executorClient.ProcessBatch(ctx, processBatchRequest) 2472 require.NoError(t, err) 2473 assert.Equal(t, executorclientpb.RomError_ROM_ERROR_NO_ERROR, processBatchResponse.Responses[0].Error) 2474 log.Debugf("Used gas = %v", processBatchResponse.Responses[0].GasUsed) 2475 } 2476 2477 func TestExecuteWithoutUpdatingMT(t *testing.T) { 2478 // Init database instance 2479 initOrResetDB() 2480 2481 var chainIDSequencer = new(big.Int).SetUint64(stateCfg.ChainID) 2482 var sequencerAddress = common.HexToAddress("0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D") 2483 var sequencerPvtKey = "0x28b2b0318721be8c8339199172cd7cc8f5e273800a35616ec893083a4b32c02e" 2484 var gasLimit = uint64(4000000) 2485 var scAddress = common.HexToAddress("0x1275fbb540c8efC58b812ba83B0D0B8b9917AE98") 2486 scByteCode, err := testutils.ReadBytecode("Counter/Counter.bin") 2487 require.NoError(t, err) 2488 2489 // auth 2490 privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(sequencerPvtKey, "0x")) 2491 require.NoError(t, err) 2492 auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainIDSequencer) 2493 require.NoError(t, err) 2494 2495 // signed tx to deploy SC 2496 unsignedTxDeploy := types.NewTx(&types.LegacyTx{ 2497 Nonce: 0, 2498 To: nil, 2499 Value: new(big.Int), 2500 Gas: gasLimit, 2501 GasPrice: new(big.Int), 2502 Data: common.Hex2Bytes(scByteCode), 2503 }) 2504 signedTxDeploy, err := auth.Signer(auth.From, unsignedTxDeploy) 2505 require.NoError(t, err) 2506 2507 signedTxs := []types.Transaction{ 2508 *signedTxDeploy, 2509 } 2510 2511 batchL2Data, err := state.EncodeTransactions(signedTxs) 2512 require.NoError(t, err) 2513 2514 // Create Batch 2515 processBatchRequest := &executorclientpb.ProcessBatchRequest{ 2516 OldBatchNum: 0, 2517 Coinbase: sequencerAddress.String(), 2518 BatchL2Data: batchL2Data, 2519 OldStateRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 2520 GlobalExitRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 2521 OldAccInputHash: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 2522 EthTimestamp: uint64(time.Now().Unix()), 2523 UpdateMerkleTree: 0, 2524 ChainId: stateCfg.ChainID, 2525 ForkId: forkID, 2526 } 2527 2528 processBatchResponse, err := executorClient.ProcessBatch(ctx, processBatchRequest) 2529 require.NoError(t, err) 2530 2531 // assert signed tx do deploy sc 2532 assert.Equal(t, executorclientpb.RomError(1), processBatchResponse.Responses[0].Error) 2533 assert.Equal(t, scAddress, common.HexToAddress(processBatchResponse.Responses[0].CreateAddress)) 2534 2535 log.Debug(processBatchResponse) 2536 2537 incrementFnSignature := crypto.Keccak256Hash([]byte("increment()")).Bytes()[:4] 2538 retrieveFnSignature := crypto.Keccak256Hash([]byte("getCount()")).Bytes()[:4] 2539 2540 // signed tx to call SC 2541 unsignedTxFirstIncrement := types.NewTx(&types.LegacyTx{ 2542 Nonce: 1, 2543 To: &scAddress, 2544 Value: new(big.Int), 2545 Gas: gasLimit, 2546 GasPrice: new(big.Int), 2547 Data: incrementFnSignature, 2548 }) 2549 2550 signedTxFirstIncrement, err := auth.Signer(auth.From, unsignedTxFirstIncrement) 2551 require.NoError(t, err) 2552 2553 unsignedTxFirstRetrieve := types.NewTx(&types.LegacyTx{ 2554 Nonce: 2, 2555 To: &scAddress, 2556 Value: new(big.Int), 2557 Gas: gasLimit, 2558 GasPrice: new(big.Int), 2559 Data: retrieveFnSignature, 2560 }) 2561 2562 signedTxFirstRetrieve, err := auth.Signer(auth.From, unsignedTxFirstRetrieve) 2563 require.NoError(t, err) 2564 2565 signedTxs2 := []types.Transaction{ 2566 *signedTxFirstIncrement, 2567 *signedTxFirstRetrieve, 2568 } 2569 2570 batchL2Data2, err := state.EncodeTransactions(signedTxs2) 2571 require.NoError(t, err) 2572 2573 // Create Batch 2 2574 processBatchRequest = &executorclientpb.ProcessBatchRequest{ 2575 OldBatchNum: 1, 2576 Coinbase: sequencerAddress.String(), 2577 BatchL2Data: batchL2Data2, 2578 OldStateRoot: processBatchResponse.NewStateRoot, 2579 GlobalExitRoot: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 2580 OldAccInputHash: common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000"), 2581 EthTimestamp: uint64(time.Now().Unix()), 2582 UpdateMerkleTree: 0, 2583 ChainId: stateCfg.ChainID, 2584 ForkId: forkID, 2585 } 2586 2587 processBatchResponse, err = executorClient.ProcessBatch(ctx, processBatchRequest) 2588 require.NoError(t, err) 2589 2590 log.Debug(processBatchResponse) 2591 2592 // assert signed tx to increment counter 2593 assert.Equal(t, executorclientpb.RomError(1), processBatchResponse.Responses[0].Error) 2594 2595 // assert signed tx to increment counter 2596 assert.Equal(t, executorclientpb.RomError(1), processBatchResponse.Responses[1].Error) 2597 assert.Equal(t, "0000000000000000000000000000000000000000000000000000000000000001", hex.EncodeToString(processBatchResponse.Responses[1].ReturnValue)) 2598 } 2599 2600 func TestExecutorUnsignedTransactionsWithCorrectL2BlockStateRoot(t *testing.T) { 2601 // Init database instance 2602 initOrResetDB() 2603 2604 // auth 2605 privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(operations.DefaultSequencerPrivateKey, "0x")) 2606 require.NoError(t, err) 2607 auth, err := bind.NewKeyedTransactorWithChainID(privateKey, new(big.Int).SetUint64(stateCfg.ChainID)) 2608 require.NoError(t, err) 2609 2610 auth.Nonce = big.NewInt(0) 2611 auth.Value = nil 2612 auth.GasPrice = big.NewInt(0) 2613 auth.GasLimit = uint64(4000000) 2614 auth.NoSend = true 2615 2616 _, scTx, sc, err := Counter.DeployCounter(auth, ðclient.Client{}) 2617 require.NoError(t, err) 2618 2619 auth.Nonce = big.NewInt(1) 2620 tx1, err := sc.Increment(auth) 2621 require.NoError(t, err) 2622 2623 auth.Nonce = big.NewInt(2) 2624 tx2, err := sc.Increment(auth) 2625 require.NoError(t, err) 2626 2627 auth.Nonce = big.NewInt(3) 2628 tx3, err := sc.Increment(auth) 2629 require.NoError(t, err) 2630 2631 dbTx, err := testState.BeginStateTransaction(context.Background()) 2632 require.NoError(t, err) 2633 // Set genesis 2634 genesis := state.Genesis{GenesisActions: []*state.GenesisAction{ 2635 { 2636 Address: operations.DefaultSequencerAddress, 2637 Type: int(merkletree.LeafTypeBalance), 2638 Value: "100000000000000000000000", 2639 }, 2640 }} 2641 _, err = testState.SetGenesis(ctx, state.Block{}, genesis, dbTx) 2642 require.NoError(t, err) 2643 batchCtx := state.ProcessingContext{ 2644 BatchNumber: 1, 2645 Coinbase: common.HexToAddress(operations.DefaultSequencerAddress), 2646 Timestamp: time.Now(), 2647 } 2648 err = testState.OpenBatch(context.Background(), batchCtx, dbTx) 2649 require.NoError(t, err) 2650 signedTxs := []types.Transaction{ 2651 *scTx, 2652 *tx1, 2653 *tx2, 2654 *tx3, 2655 } 2656 2657 batchL2Data, err := state.EncodeTransactions(signedTxs) 2658 require.NoError(t, err) 2659 2660 processBatchResponse, err := testState.ProcessSequencerBatch(context.Background(), 1, batchL2Data, metrics.SequencerCallerLabel, dbTx) 2661 require.NoError(t, err) 2662 // assert signed tx do deploy sc 2663 assert.Nil(t, processBatchResponse.Responses[0].RomError) 2664 assert.NotEqual(t, state.ZeroAddress, processBatchResponse.Responses[0].CreateAddress.Hex()) 2665 assert.Equal(t, tx1.To().Hex(), processBatchResponse.Responses[0].CreateAddress.Hex()) 2666 2667 // assert signed tx to increment counter 2668 assert.Nil(t, processBatchResponse.Responses[1].RomError) 2669 assert.Nil(t, processBatchResponse.Responses[2].RomError) 2670 assert.Nil(t, processBatchResponse.Responses[3].RomError) 2671 2672 // Add txs to DB 2673 err = testState.StoreTransactions(context.Background(), 1, processBatchResponse.Responses, dbTx) 2674 require.NoError(t, err) 2675 // Close batch 2676 err = testState.CloseBatch( 2677 context.Background(), 2678 state.ProcessingReceipt{ 2679 BatchNumber: 1, 2680 StateRoot: processBatchResponse.NewStateRoot, 2681 LocalExitRoot: processBatchResponse.NewLocalExitRoot, 2682 }, dbTx, 2683 ) 2684 require.NoError(t, err) 2685 require.NoError(t, dbTx.Commit(context.Background())) 2686 2687 getCountFnSignature := crypto.Keccak256Hash([]byte("getCount()")).Bytes()[:4] 2688 getCountUnsignedTx := types.NewTx(&types.LegacyTx{ 2689 To: &processBatchResponse.Responses[0].CreateAddress, 2690 Gas: uint64(100000), 2691 Data: getCountFnSignature, 2692 }) 2693 2694 l2BlockNumber := uint64(1) 2695 result, err := testState.ProcessUnsignedTransaction(context.Background(), getCountUnsignedTx, auth.From, &l2BlockNumber, true, nil) 2696 require.NoError(t, err) 2697 // assert unsigned tx 2698 assert.Nil(t, result.Err) 2699 assert.Equal(t, "0000000000000000000000000000000000000000000000000000000000000000", hex.EncodeToString(result.ReturnValue)) 2700 2701 l2BlockNumber = uint64(2) 2702 result, err = testState.ProcessUnsignedTransaction(context.Background(), getCountUnsignedTx, auth.From, &l2BlockNumber, true, nil) 2703 require.NoError(t, err) 2704 // assert unsigned tx 2705 assert.Nil(t, result.Err) 2706 assert.Equal(t, "0000000000000000000000000000000000000000000000000000000000000001", hex.EncodeToString(result.ReturnValue)) 2707 2708 l2BlockNumber = uint64(3) 2709 result, err = testState.ProcessUnsignedTransaction(context.Background(), getCountUnsignedTx, auth.From, &l2BlockNumber, true, nil) 2710 require.NoError(t, err) 2711 // assert unsigned tx 2712 assert.Nil(t, result.Err) 2713 assert.Equal(t, "0000000000000000000000000000000000000000000000000000000000000002", hex.EncodeToString(result.ReturnValue)) 2714 2715 l2BlockNumber = uint64(4) 2716 result, err = testState.ProcessUnsignedTransaction(context.Background(), getCountUnsignedTx, auth.From, &l2BlockNumber, true, nil) 2717 require.NoError(t, err) 2718 // assert unsigned tx 2719 assert.Nil(t, result.Err) 2720 assert.Equal(t, "0000000000000000000000000000000000000000000000000000000000000003", hex.EncodeToString(result.ReturnValue)) 2721 }