From 9956fdfc99643cd19a36b1775a74614401177a90 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ula=C5=9F=20Erdo=C4=9Fan?= Date: Mon, 8 May 2023 04:11:54 +0300 Subject: [PATCH 01/31] crypto/secp2561r1: add secp256r1 curve verifiers (cherry picked from commit fb89b61cdc2ccf6bda9f77f72315e01fa4ffb7d7) --- crypto/secp256r1/publickey.go | 21 +++++++++++++++++++ crypto/secp256r1/verifier.go | 39 +++++++++++++++++++++++++++++++++++ 2 files changed, 60 insertions(+) create mode 100644 crypto/secp256r1/publickey.go create mode 100644 crypto/secp256r1/verifier.go diff --git a/crypto/secp256r1/publickey.go b/crypto/secp256r1/publickey.go new file mode 100644 index 0000000000..c92afaa1e0 --- /dev/null +++ b/crypto/secp256r1/publickey.go @@ -0,0 +1,21 @@ +package secp256r1 + +import ( + "crypto/ecdsa" + "crypto/elliptic" + "math/big" +) + +// Generates approptiate public key format from given coordinates +func newPublicKey(x, y *big.Int) *ecdsa.PublicKey { + // Check if the given coordinates are valid + if x == nil || y == nil || !elliptic.P256().IsOnCurve(x, y) { + return nil + } + + return &ecdsa.PublicKey{ + Curve: elliptic.P256(), + X: x, + Y: y, + } +} diff --git a/crypto/secp256r1/verifier.go b/crypto/secp256r1/verifier.go new file mode 100644 index 0000000000..67a0dd787d --- /dev/null +++ b/crypto/secp256r1/verifier.go @@ -0,0 +1,39 @@ +package secp256r1 + +import ( + "crypto/ecdsa" + "crypto/elliptic" + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/common" +) + +var ( + secp256k1halfN = new(big.Int).Div(elliptic.P256().Params().N, big.NewInt(2)) +) + +// Verifies the given signature (r, s) for the given hash and public key (x, y). +func Verify(hash []byte, r, s, x, y *big.Int) ([]byte, error) { + // Create the public key format + publicKey := newPublicKey(x, y) + if publicKey == nil { + return nil, errors.New("invalid public key coordinates") + } + + if checkMalleability(s) { + return nil, errors.New("malleability issue") + } + + // Verify the signature with the public key and return 1 if it's valid, 0 otherwise + if ok := ecdsa.Verify(publicKey, hash, r, s); ok { + return common.LeftPadBytes(common.Big1.Bytes(), 32), nil + } + + return common.LeftPadBytes(common.Big0.Bytes(), 32), nil +} + +// Check the malleability issue +func checkMalleability(s *big.Int) bool { + return s.Cmp(secp256k1halfN) <= 0 +} From cdb96096d890880aac45eaaf7ad96e72f284cbde Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ula=C5=9F=20Erdo=C4=9Fan?= Date: Mon, 8 May 2023 04:12:57 +0300 Subject: [PATCH 02/31] core/vm: implement secp256r1 verifier precompiled (cherry picked from commit a8c0a2e05c7b6cafa16d296f91da8cb651bf9d46) --- core/vm/contracts.go | 55 ++++++++++++++++++---- core/vm/contracts_test.go | 13 +++++ core/vm/testdata/precompiles/ecverify.json | 9 ++++ 3 files changed, 68 insertions(+), 9 deletions(-) create mode 100644 core/vm/testdata/precompiles/ecverify.json diff --git a/core/vm/contracts.go b/core/vm/contracts.go index ba7539737c..d5375be753 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -28,6 +28,7 @@ import ( "github.com/ethereum/go-ethereum/crypto/blake2b" "github.com/ethereum/go-ethereum/crypto/bls12381" "github.com/ethereum/go-ethereum/crypto/bn256" + "github.com/ethereum/go-ethereum/crypto/secp256r1" "github.com/ethereum/go-ethereum/params" "golang.org/x/crypto/ripemd160" ) @@ -79,15 +80,15 @@ var PrecompiledContractsIstanbul = map[common.Address]PrecompiledContract{ // PrecompiledContractsBerlin contains the default set of pre-compiled Ethereum // contracts used in the Berlin release. var PrecompiledContractsBerlin = map[common.Address]PrecompiledContract{ - common.BytesToAddress([]byte{1}): &ecrecover{}, - common.BytesToAddress([]byte{2}): &sha256hash{}, - common.BytesToAddress([]byte{3}): &ripemd160hash{}, - common.BytesToAddress([]byte{4}): &dataCopy{}, - common.BytesToAddress([]byte{5}): &bigModExp{eip2565: true}, - common.BytesToAddress([]byte{6}): &bn256AddIstanbul{}, - common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{}, - common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{}, - common.BytesToAddress([]byte{9}): &blake2F{}, + common.BytesToAddress([]byte{1}): &ecrecover{}, + common.BytesToAddress([]byte{2}): &sha256hash{}, + common.BytesToAddress([]byte{3}): &ripemd160hash{}, + common.BytesToAddress([]byte{4}): &dataCopy{}, + common.BytesToAddress([]byte{5}): &bigModExp{eip2565: true}, + common.BytesToAddress([]byte{6}): &bn256AddIstanbul{}, + common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{}, + common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{}, + common.BytesToAddress([]byte{9}): &blake2F{}, } // PrecompiledContractsBLS contains the set of pre-compiled Ethereum @@ -104,6 +105,12 @@ var PrecompiledContractsBLS = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{18}): &bls12381MapG2{}, } +// PrecompiledContractsEcverify contains the precompiled Ethereum +// contract specified in EIP-N. This is exported for testing purposes. +var PrecompiledContractsEcverify = map[common.Address]PrecompiledContract{ + common.BytesToAddress([]byte{19}): &ecverify{}, +} + var ( PrecompiledAddressesBerlin []common.Address PrecompiledAddressesIstanbul []common.Address @@ -1107,3 +1114,33 @@ func (c *bls12381MapG2) Run(input []byte) ([]byte, error) { // Encode the G2 point to 256 bytes return g.EncodePoint(r), nil } + +// ECVERIFY (secp256r1 signature verification) +// implemented as a native contract +type ecverify struct{} + +// RequiredGas returns the gas required to execute the precompiled contract +func (c *ecverify) RequiredGas(input []byte) uint64 { + return params.EcverifyGas +} + +// Run executes the precompiled contract, returning the output and the used gas +func (c *ecverify) Run(input []byte) ([]byte, error) { + // Required input length is 160 bytes + const ecverifyInputLength = 160 + + // "input" is (hash, r, s, x, y), each 32 bytes + input = common.RightPadBytes(input, ecverifyInputLength) + + // Extract the hash, r, s, x, y from the input + hash := input[0:32] + r, s := new(big.Int).SetBytes(input[32:64]), new(big.Int).SetBytes(input[64:96]) + x, y := new(big.Int).SetBytes(input[96:128]), new(big.Int).SetBytes(input[128:160]) + + // Verify the secp256r1 signature + if result, err := secp256r1.Verify(hash, r, s, x, y); err != nil { + return nil, err + } else { + return result, nil + } +} diff --git a/core/vm/contracts_test.go b/core/vm/contracts_test.go index 53f8de5945..3e8f5c71eb 100644 --- a/core/vm/contracts_test.go +++ b/core/vm/contracts_test.go @@ -65,6 +65,7 @@ var allPrecompiles = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{16}): &bls12381Pairing{}, common.BytesToAddress([]byte{17}): &bls12381MapG1{}, common.BytesToAddress([]byte{18}): &bls12381MapG2{}, + common.BytesToAddress([]byte{19}): &ecverify{}, } // EIP-152 test vectors @@ -411,3 +412,15 @@ func BenchmarkPrecompiledBLS12381G2MultiExpWorstCase(b *testing.B) { } benchmarkPrecompiled("0f", testcase, b) } + +// Benchmarks the sample inputs from the ECVERIFY precompile. +func BenchmarkPrecompiledEcverify(bench *testing.B) { + t := precompiledTest{ + Input: "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b98243744ca2b25ce52b927841120de9d5e5a454acabea2ebacaa1f76850934cb0c7c818200fa5e4b4607eeea9593071a6097b132d77c10661c441b5a66eb36856e1251c078c2c1367932e25bf657f6b2e378a26a27e238196295e1c59e2225d372fe603c229d85ea9eb0b090274c59a0600becd11d0df3f91fe44677977119c4ff03", + Expected: "0000000000000000000000000000000000000000000000000000000000000001", + Name: "ecverify", + } + benchmarkPrecompiled("13", t, bench) +} + +func TestPrecompiledEcverify(t *testing.T) { testJson("ecverify", "13", t) } diff --git a/core/vm/testdata/precompiles/ecverify.json b/core/vm/testdata/precompiles/ecverify.json new file mode 100644 index 0000000000..15ad1fbb34 --- /dev/null +++ b/core/vm/testdata/precompiles/ecverify.json @@ -0,0 +1,9 @@ +[ + { + "Input": "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b98243744ca2b25ce52b927841120de9d5e5a454acabea2ebacaa1f76850934cb0c7c818200fa5e4b4607eeea9593071a6097b132d77c10661c441b5a66eb36856e1251c078c2c1367932e25bf657f6b2e378a26a27e238196295e1c59e2225d372fe603c229d85ea9eb0b090274c59a0600becd11d0df3f91fe44677977119c4ff03", + "Expected": "0000000000000000000000000000000000000000000000000000000000000001", + "Gas": 3450, + "Name": "CallEcverify", + "NoBenchmark": false + } + ] \ No newline at end of file From 56f193346e1b004f848d85aa728cbd5eac9b0114 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ula=C5=9F=20Erdo=C4=9Fan?= Date: Mon, 8 May 2023 04:13:19 +0300 Subject: [PATCH 03/31] params: add new precompiled gas price (cherry picked from commit c0554c0764a2c021689e8d73b36987b67c954f0c) --- params/protocol_params.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/params/protocol_params.go b/params/protocol_params.go index 1de8e88bd7..685bce776f 100644 --- a/params/protocol_params.go +++ b/params/protocol_params.go @@ -160,6 +160,8 @@ const ( Bls12381MapG1Gas uint64 = 5500 // Gas price for BLS12-381 mapping field element to G1 operation Bls12381MapG2Gas uint64 = 110000 // Gas price for BLS12-381 mapping field element to G2 operation + EcverifyGas uint64 = 3450 // secp256r1 elliptic curve signature verifier gas price + // The Refund Quotient is the cap on how much of the used gas can be refunded. Before EIP-3529, // up to half the consumed gas could be refunded. Redefined as 1/5th in EIP-3529 RefundQuotient uint64 = 2 From ae2d3da5c1da25a207741233980e7d38517a10a3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ula=C5=9F=20Erdo=C4=9Fan?= Date: Tue, 16 May 2023 18:05:43 +0300 Subject: [PATCH 04/31] core/vm, params: rename precompiled to p256verify (cherry picked from commit 6c7028a9043f65f0a3596be4a429be4e03d0eb89) --- core/vm/contracts.go | 38 +++++++++---------- core/vm/contracts_test.go | 10 ++--- .../{ecverify.json => p256Verify.json} | 2 +- params/protocol_params.go | 2 +- 4 files changed, 26 insertions(+), 26 deletions(-) rename core/vm/testdata/precompiles/{ecverify.json => p256Verify.json} (93%) diff --git a/core/vm/contracts.go b/core/vm/contracts.go index d5375be753..f07969c435 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -80,15 +80,15 @@ var PrecompiledContractsIstanbul = map[common.Address]PrecompiledContract{ // PrecompiledContractsBerlin contains the default set of pre-compiled Ethereum // contracts used in the Berlin release. var PrecompiledContractsBerlin = map[common.Address]PrecompiledContract{ - common.BytesToAddress([]byte{1}): &ecrecover{}, - common.BytesToAddress([]byte{2}): &sha256hash{}, - common.BytesToAddress([]byte{3}): &ripemd160hash{}, - common.BytesToAddress([]byte{4}): &dataCopy{}, - common.BytesToAddress([]byte{5}): &bigModExp{eip2565: true}, - common.BytesToAddress([]byte{6}): &bn256AddIstanbul{}, - common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{}, - common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{}, - common.BytesToAddress([]byte{9}): &blake2F{}, + common.BytesToAddress([]byte{1}): &ecrecover{}, + common.BytesToAddress([]byte{2}): &sha256hash{}, + common.BytesToAddress([]byte{3}): &ripemd160hash{}, + common.BytesToAddress([]byte{4}): &dataCopy{}, + common.BytesToAddress([]byte{5}): &bigModExp{eip2565: true}, + common.BytesToAddress([]byte{6}): &bn256AddIstanbul{}, + common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{}, + common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{}, + common.BytesToAddress([]byte{9}): &blake2F{}, } // PrecompiledContractsBLS contains the set of pre-compiled Ethereum @@ -105,10 +105,10 @@ var PrecompiledContractsBLS = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{18}): &bls12381MapG2{}, } -// PrecompiledContractsEcverify contains the precompiled Ethereum +// PrecompiledContractsP256Verify contains the precompiled Ethereum // contract specified in EIP-N. This is exported for testing purposes. -var PrecompiledContractsEcverify = map[common.Address]PrecompiledContract{ - common.BytesToAddress([]byte{19}): &ecverify{}, +var PrecompiledContractsP256Verify = map[common.Address]PrecompiledContract{ + common.BytesToAddress([]byte{19}): &p256Verify{}, } var ( @@ -1115,22 +1115,22 @@ func (c *bls12381MapG2) Run(input []byte) ([]byte, error) { return g.EncodePoint(r), nil } -// ECVERIFY (secp256r1 signature verification) +// P256VERIFY (secp256r1 signature verification) // implemented as a native contract -type ecverify struct{} +type p256Verify struct{} // RequiredGas returns the gas required to execute the precompiled contract -func (c *ecverify) RequiredGas(input []byte) uint64 { - return params.EcverifyGas +func (c *p256Verify) RequiredGas(input []byte) uint64 { + return params.P256VerifyGas } // Run executes the precompiled contract, returning the output and the used gas -func (c *ecverify) Run(input []byte) ([]byte, error) { +func (c *p256Verify) Run(input []byte) ([]byte, error) { // Required input length is 160 bytes - const ecverifyInputLength = 160 + const p256VerifyInputLength = 160 // "input" is (hash, r, s, x, y), each 32 bytes - input = common.RightPadBytes(input, ecverifyInputLength) + input = common.RightPadBytes(input, p256VerifyInputLength) // Extract the hash, r, s, x, y from the input hash := input[0:32] diff --git a/core/vm/contracts_test.go b/core/vm/contracts_test.go index 3e8f5c71eb..b025742238 100644 --- a/core/vm/contracts_test.go +++ b/core/vm/contracts_test.go @@ -65,7 +65,7 @@ var allPrecompiles = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{16}): &bls12381Pairing{}, common.BytesToAddress([]byte{17}): &bls12381MapG1{}, common.BytesToAddress([]byte{18}): &bls12381MapG2{}, - common.BytesToAddress([]byte{19}): &ecverify{}, + common.BytesToAddress([]byte{19}): &p256Verify{}, } // EIP-152 test vectors @@ -413,14 +413,14 @@ func BenchmarkPrecompiledBLS12381G2MultiExpWorstCase(b *testing.B) { benchmarkPrecompiled("0f", testcase, b) } -// Benchmarks the sample inputs from the ECVERIFY precompile. -func BenchmarkPrecompiledEcverify(bench *testing.B) { +// Benchmarks the sample inputs from the P256VERIFY precompile. +func BenchmarkPrecompiledP256Verify(bench *testing.B) { t := precompiledTest{ Input: "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b98243744ca2b25ce52b927841120de9d5e5a454acabea2ebacaa1f76850934cb0c7c818200fa5e4b4607eeea9593071a6097b132d77c10661c441b5a66eb36856e1251c078c2c1367932e25bf657f6b2e378a26a27e238196295e1c59e2225d372fe603c229d85ea9eb0b090274c59a0600becd11d0df3f91fe44677977119c4ff03", Expected: "0000000000000000000000000000000000000000000000000000000000000001", - Name: "ecverify", + Name: "p256Verify", } benchmarkPrecompiled("13", t, bench) } -func TestPrecompiledEcverify(t *testing.T) { testJson("ecverify", "13", t) } +func TestPrecompiledP256Verify(t *testing.T) { testJson("p256Verify", "13", t) } diff --git a/core/vm/testdata/precompiles/ecverify.json b/core/vm/testdata/precompiles/p256Verify.json similarity index 93% rename from core/vm/testdata/precompiles/ecverify.json rename to core/vm/testdata/precompiles/p256Verify.json index 15ad1fbb34..c98054d4c2 100644 --- a/core/vm/testdata/precompiles/ecverify.json +++ b/core/vm/testdata/precompiles/p256Verify.json @@ -3,7 +3,7 @@ "Input": "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b98243744ca2b25ce52b927841120de9d5e5a454acabea2ebacaa1f76850934cb0c7c818200fa5e4b4607eeea9593071a6097b132d77c10661c441b5a66eb36856e1251c078c2c1367932e25bf657f6b2e378a26a27e238196295e1c59e2225d372fe603c229d85ea9eb0b090274c59a0600becd11d0df3f91fe44677977119c4ff03", "Expected": "0000000000000000000000000000000000000000000000000000000000000001", "Gas": 3450, - "Name": "CallEcverify", + "Name": "CallP256Verify", "NoBenchmark": false } ] \ No newline at end of file diff --git a/params/protocol_params.go b/params/protocol_params.go index 685bce776f..10f7aaf81a 100644 --- a/params/protocol_params.go +++ b/params/protocol_params.go @@ -160,7 +160,7 @@ const ( Bls12381MapG1Gas uint64 = 5500 // Gas price for BLS12-381 mapping field element to G1 operation Bls12381MapG2Gas uint64 = 110000 // Gas price for BLS12-381 mapping field element to G2 operation - EcverifyGas uint64 = 3450 // secp256r1 elliptic curve signature verifier gas price + P256VerifyGas uint64 = 3450 // secp256r1 elliptic curve signature verifier gas price // The Refund Quotient is the cap on how much of the used gas can be refunded. Before EIP-3529, // up to half the consumed gas could be refunded. Redefined as 1/5th in EIP-3529 From 83a20d36eca3432dee1420b67db834454ad0ca45 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ula=C5=9F=20Erdo=C4=9Fan?= Date: Mon, 22 May 2023 17:57:24 +0200 Subject: [PATCH 05/31] core/vm: simplify the return values format (cherry picked from commit d245194e7724c2a7d153945cc86c9aa8d0b522b3) --- core/vm/contracts.go | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/core/vm/contracts.go b/core/vm/contracts.go index f07969c435..4245a54528 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -1138,9 +1138,5 @@ func (c *p256Verify) Run(input []byte) ([]byte, error) { x, y := new(big.Int).SetBytes(input[96:128]), new(big.Int).SetBytes(input[128:160]) // Verify the secp256r1 signature - if result, err := secp256r1.Verify(hash, r, s, x, y); err != nil { - return nil, err - } else { - return result, nil - } + return secp256r1.Verify(hash, r, s, x, y) } From fc057aaabb9b1e9faed73ced441caecc28ee6cfe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ula=C5=9F=20Erdo=C4=9Fan?= Date: Mon, 22 May 2023 22:38:41 +0200 Subject: [PATCH 06/31] crypto/secp25r1: fix reverse malleability issue (cherry picked from commit 066a31f6345c8a04a4ebf84efd8c80d87107e6d5) --- crypto/secp256r1/verifier.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crypto/secp256r1/verifier.go b/crypto/secp256r1/verifier.go index 67a0dd787d..9db2d5b930 100644 --- a/crypto/secp256r1/verifier.go +++ b/crypto/secp256r1/verifier.go @@ -35,5 +35,5 @@ func Verify(hash []byte, r, s, x, y *big.Int) ([]byte, error) { // Check the malleability issue func checkMalleability(s *big.Int) bool { - return s.Cmp(secp256k1halfN) <= 0 + return s.Cmp(secp256k1halfN) > 0 } From 40e6de0bf2f5fc3e0c055b3d19f94e933399a7f9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ula=C5=9F=20Erdo=C4=9Fan?= Date: Mon, 22 May 2023 22:39:55 +0200 Subject: [PATCH 07/31] core/vm: fix testdata non-malleable for p256Verify (cherry picked from commit ec17e788ade3f43ded67c014f019770634f32a7c) --- core/vm/contracts_test.go | 2 +- core/vm/testdata/precompiles/p256Verify.json | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/core/vm/contracts_test.go b/core/vm/contracts_test.go index b025742238..24ddae0715 100644 --- a/core/vm/contracts_test.go +++ b/core/vm/contracts_test.go @@ -416,7 +416,7 @@ func BenchmarkPrecompiledBLS12381G2MultiExpWorstCase(b *testing.B) { // Benchmarks the sample inputs from the P256VERIFY precompile. func BenchmarkPrecompiledP256Verify(bench *testing.B) { t := precompiledTest{ - Input: "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b98243744ca2b25ce52b927841120de9d5e5a454acabea2ebacaa1f76850934cb0c7c818200fa5e4b4607eeea9593071a6097b132d77c10661c441b5a66eb36856e1251c078c2c1367932e25bf657f6b2e378a26a27e238196295e1c59e2225d372fe603c229d85ea9eb0b090274c59a0600becd11d0df3f91fe44677977119c4ff03", + Input: "4cee90eb86eaa050036147a12d49004b6b9c72bd725d39d4785011fe190f0b4da73bd4903f0ce3b639bbbf6e8e80d16931ff4bcf5993d58468e8fb19086e8cac36dbcd03009df8c59286b162af3bd7fcc0450c9aa81be5d10d312af6c66b1d604aebd3099c618202fcfe16ae7770b0c49ab5eadf74b754204a3bb6060e44eff37618b065f9832de4ca6ca971a7a1adc826d0f7c00181a5fb2ddf79ae00b4e10e", Expected: "0000000000000000000000000000000000000000000000000000000000000001", Name: "p256Verify", } diff --git a/core/vm/testdata/precompiles/p256Verify.json b/core/vm/testdata/precompiles/p256Verify.json index c98054d4c2..fbcac41e9f 100644 --- a/core/vm/testdata/precompiles/p256Verify.json +++ b/core/vm/testdata/precompiles/p256Verify.json @@ -1,6 +1,6 @@ [ { - "Input": "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b98243744ca2b25ce52b927841120de9d5e5a454acabea2ebacaa1f76850934cb0c7c818200fa5e4b4607eeea9593071a6097b132d77c10661c441b5a66eb36856e1251c078c2c1367932e25bf657f6b2e378a26a27e238196295e1c59e2225d372fe603c229d85ea9eb0b090274c59a0600becd11d0df3f91fe44677977119c4ff03", + "Input": "4cee90eb86eaa050036147a12d49004b6b9c72bd725d39d4785011fe190f0b4da73bd4903f0ce3b639bbbf6e8e80d16931ff4bcf5993d58468e8fb19086e8cac36dbcd03009df8c59286b162af3bd7fcc0450c9aa81be5d10d312af6c66b1d604aebd3099c618202fcfe16ae7770b0c49ab5eadf74b754204a3bb6060e44eff37618b065f9832de4ca6ca971a7a1adc826d0f7c00181a5fb2ddf79ae00b4e10e", "Expected": "0000000000000000000000000000000000000000000000000000000000000001", "Gas": 3450, "Name": "CallP256Verify", From b5559e30186326ed614adcb843532793d4a74450 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ula=C5=9F=20Erdo=C4=9Fan?= Date: Thu, 22 Jun 2023 15:40:47 +0300 Subject: [PATCH 08/31] core/vm: update the eip number (cherry picked from commit f5b6d7e9954cae87348e21525210affda09297c1) --- core/vm/contracts.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/vm/contracts.go b/core/vm/contracts.go index 4245a54528..d9e427d5e3 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -106,7 +106,7 @@ var PrecompiledContractsBLS = map[common.Address]PrecompiledContract{ } // PrecompiledContractsP256Verify contains the precompiled Ethereum -// contract specified in EIP-N. This is exported for testing purposes. +// contract specified in EIP-7212. This is exported for testing purposes. var PrecompiledContractsP256Verify = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{19}): &p256Verify{}, } From 0d115db16865edb6903d7bf11126ab64256f366c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ula=C5=9F=20Erdo=C4=9Fan?= Date: Fri, 23 Jun 2023 01:13:27 +0300 Subject: [PATCH 09/31] core, crypto/secp256r1: fix error reverts tx error (cherry picked from commit 2820903f591365b17a4c3bdb36bd49ee2d84054c) --- core/vm/contracts.go | 8 +++++++- crypto/secp256r1/verifier.go | 20 +++++++++++--------- 2 files changed, 18 insertions(+), 10 deletions(-) diff --git a/core/vm/contracts.go b/core/vm/contracts.go index d9e427d5e3..db73bcebbc 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -1138,5 +1138,11 @@ func (c *p256Verify) Run(input []byte) ([]byte, error) { x, y := new(big.Int).SetBytes(input[96:128]), new(big.Int).SetBytes(input[128:160]) // Verify the secp256r1 signature - return secp256r1.Verify(hash, r, s, x, y) + if secp256r1.Verify(hash, r, s, x, y) { + // Signature is valid + return common.LeftPadBytes(common.Big1.Bytes(), 32), nil + } else { + // Signature is invalid + return nil, nil + } } diff --git a/crypto/secp256r1/verifier.go b/crypto/secp256r1/verifier.go index 9db2d5b930..e45d49e352 100644 --- a/crypto/secp256r1/verifier.go +++ b/crypto/secp256r1/verifier.go @@ -3,34 +3,36 @@ package secp256r1 import ( "crypto/ecdsa" "crypto/elliptic" - "errors" "math/big" - - "github.com/ethereum/go-ethereum/common" ) var ( + // Half of the order of the subgroup in the elliptic curve secp256k1halfN = new(big.Int).Div(elliptic.P256().Params().N, big.NewInt(2)) ) // Verifies the given signature (r, s) for the given hash and public key (x, y). -func Verify(hash []byte, r, s, x, y *big.Int) ([]byte, error) { +func Verify(hash []byte, r, s, x, y *big.Int) bool { // Create the public key format publicKey := newPublicKey(x, y) + + // Check if they are invalid public key coordinates if publicKey == nil { - return nil, errors.New("invalid public key coordinates") + return false } + // Check the malleability issue if checkMalleability(s) { - return nil, errors.New("malleability issue") + return false } - // Verify the signature with the public key and return 1 if it's valid, 0 otherwise + // Verify the signature with the public key, + // then return true if it's valid, false otherwise if ok := ecdsa.Verify(publicKey, hash, r, s); ok { - return common.LeftPadBytes(common.Big1.Bytes(), 32), nil + return true } - return common.LeftPadBytes(common.Big0.Bytes(), 32), nil + return false } // Check the malleability issue From d64d8e73c11b6ccfa8175e0fae6407d6587fd1ba Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ula=C5=9F=20Erdo=C4=9Fan?= Date: Fri, 11 Aug 2023 00:36:35 +0300 Subject: [PATCH 10/31] crypto/secp256r1: refactor by simplfying return (cherry picked from commit 1be1875156e2a5a417801deb59546b167e5456c6) --- crypto/secp256r1/verifier.go | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/crypto/secp256r1/verifier.go b/crypto/secp256r1/verifier.go index e45d49e352..a9e833cd65 100644 --- a/crypto/secp256r1/verifier.go +++ b/crypto/secp256r1/verifier.go @@ -28,11 +28,7 @@ func Verify(hash []byte, r, s, x, y *big.Int) bool { // Verify the signature with the public key, // then return true if it's valid, false otherwise - if ok := ecdsa.Verify(publicKey, hash, r, s); ok { - return true - } - - return false + return ecdsa.Verify(publicKey, hash, r, s) } // Check the malleability issue From 2bbf30ff90ff1b94db6986aaf957c80c1e1ed9dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ula=C5=9F=20Erdo=C4=9Fan?= Date: Sun, 24 Sep 2023 04:42:41 +0300 Subject: [PATCH 11/31] core/vm: force the input length of p256verify (cherry picked from commit 21f4932c9bbb8664cf7b3e3c3602b6a48c747893) --- core/vm/contracts.go | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/core/vm/contracts.go b/core/vm/contracts.go index db73bcebbc..4d1047d948 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -1124,13 +1124,15 @@ func (c *p256Verify) RequiredGas(input []byte) uint64 { return params.P256VerifyGas } -// Run executes the precompiled contract, returning the output and the used gas +// Run executes the precompiled contract with given 160 bytes of param, returning the output and the used gas func (c *p256Verify) Run(input []byte) ([]byte, error) { // Required input length is 160 bytes const p256VerifyInputLength = 160 - - // "input" is (hash, r, s, x, y), each 32 bytes - input = common.RightPadBytes(input, p256VerifyInputLength) + // Check the input length + if len(input) != p256VerifyInputLength { + // Input length is invalid + return nil, nil + } // Extract the hash, r, s, x, y from the input hash := input[0:32] From ab2f20e8ddd540ebccce2fa2473447f54d62183d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ula=C5=9F=20Erdo=C4=9Fan?= Date: Sun, 24 Sep 2023 04:54:00 +0300 Subject: [PATCH 12/31] crypto/secp256r1: reject the reference pubKey coordinates (cherry picked from commit 98f10b0d5e358075d03b76834cd30c97f4fbdfe1) --- crypto/secp256r1/publickey.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/crypto/secp256r1/publickey.go b/crypto/secp256r1/publickey.go index c92afaa1e0..9b84044efa 100644 --- a/crypto/secp256r1/publickey.go +++ b/crypto/secp256r1/publickey.go @@ -13,6 +13,11 @@ func newPublicKey(x, y *big.Int) *ecdsa.PublicKey { return nil } + // Check if the given coordinates are the reference point (infinity) + if x.Sign() == 0 && y.Sign() == 0 { + return nil + } + return &ecdsa.PublicKey{ Curve: elliptic.P256(), X: x, From 738107b6c85b50619e37aa058e6be93cee4ad62f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ula=C5=9F=20Erdo=C4=9Fan?= Date: Sat, 7 Oct 2023 16:08:05 +0300 Subject: [PATCH 13/31] crypto/secp256r1: remove malleability check due to spec (cherry picked from commit cec0b058115282168c5afc5197de3f6b5479dc4a) --- crypto/secp256r1/verifier.go | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/crypto/secp256r1/verifier.go b/crypto/secp256r1/verifier.go index a9e833cd65..ccc0786610 100644 --- a/crypto/secp256r1/verifier.go +++ b/crypto/secp256r1/verifier.go @@ -2,15 +2,9 @@ package secp256r1 import ( "crypto/ecdsa" - "crypto/elliptic" "math/big" ) -var ( - // Half of the order of the subgroup in the elliptic curve - secp256k1halfN = new(big.Int).Div(elliptic.P256().Params().N, big.NewInt(2)) -) - // Verifies the given signature (r, s) for the given hash and public key (x, y). func Verify(hash []byte, r, s, x, y *big.Int) bool { // Create the public key format @@ -21,17 +15,7 @@ func Verify(hash []byte, r, s, x, y *big.Int) bool { return false } - // Check the malleability issue - if checkMalleability(s) { - return false - } - // Verify the signature with the public key, // then return true if it's valid, false otherwise return ecdsa.Verify(publicKey, hash, r, s) } - -// Check the malleability issue -func checkMalleability(s *big.Int) bool { - return s.Cmp(secp256k1halfN) > 0 -} From 05a19f2a360055c489af4eb22e46d6b641d52f8e Mon Sep 17 00:00:00 2001 From: Anshal Shukla Date: Thu, 30 Nov 2023 12:56:21 +0530 Subject: [PATCH 14/31] fix test, add napoli block --- core/vm/contracts.go | 11 +++++++++-- core/vm/contracts_test.go | 6 +++++- core/vm/testdata/precompiles/p256Verify.json | 2 +- params/config.go | 14 +++++++++++--- 4 files changed, 26 insertions(+), 7 deletions(-) diff --git a/core/vm/contracts.go b/core/vm/contracts.go index 4d1047d948..5d1728d1fd 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -105,13 +105,14 @@ var PrecompiledContractsBLS = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{18}): &bls12381MapG2{}, } -// PrecompiledContractsP256Verify contains the precompiled Ethereum +// PrecompiledContractsNapoli contains the precompiled Ethereum // contract specified in EIP-7212. This is exported for testing purposes. -var PrecompiledContractsP256Verify = map[common.Address]PrecompiledContract{ +var PrecompiledContractsNapoli = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{19}): &p256Verify{}, } var ( + PrecompiledAddressesNapoli []common.Address PrecompiledAddressesBerlin []common.Address PrecompiledAddressesIstanbul []common.Address PrecompiledAddressesByzantium []common.Address @@ -134,11 +135,17 @@ func init() { for k := range PrecompiledContractsBerlin { PrecompiledAddressesBerlin = append(PrecompiledAddressesBerlin, k) } + + for k := range PrecompiledContractsNapoli { + PrecompiledAddressesNapoli = append(PrecompiledAddressesNapoli, k) + } } // ActivePrecompiles returns the precompiles enabled with the current configuration. func ActivePrecompiles(rules params.Rules) []common.Address { switch { + case rules.IsNapoli: + return PrecompiledAddressesNapoli case rules.IsBerlin: return PrecompiledAddressesBerlin case rules.IsIstanbul: diff --git a/core/vm/contracts_test.go b/core/vm/contracts_test.go index 24ddae0715..c55f58eb51 100644 --- a/core/vm/contracts_test.go +++ b/core/vm/contracts_test.go @@ -423,4 +423,8 @@ func BenchmarkPrecompiledP256Verify(bench *testing.B) { benchmarkPrecompiled("13", t, bench) } -func TestPrecompiledP256Verify(t *testing.T) { testJson("p256Verify", "13", t) } +func TestPrecompiledP256Verify(t *testing.T) { + t.Parallel() + + testJson("p256Verify", "13", t) +} diff --git a/core/vm/testdata/precompiles/p256Verify.json b/core/vm/testdata/precompiles/p256Verify.json index fbcac41e9f..c01387dda7 100644 --- a/core/vm/testdata/precompiles/p256Verify.json +++ b/core/vm/testdata/precompiles/p256Verify.json @@ -6,4 +6,4 @@ "Name": "CallP256Verify", "NoBenchmark": false } - ] \ No newline at end of file +] \ No newline at end of file diff --git a/params/config.go b/params/config.go index e3740068c6..278374356b 100644 --- a/params/config.go +++ b/params/config.go @@ -649,6 +649,7 @@ type ChainConfig struct { ShanghaiBlock *big.Int `json:"shanghaiBlock,omitempty"` // Shanghai switch Block (nil = no fork, 0 = already on shanghai) CancunBlock *big.Int `json:"cancunBlock,omitempty"` // Cancun switch Block (nil = no fork, 0 = already on cancun) PragueBlock *big.Int `json:"pragueBlock,omitempty"` // Prague switch Block (nil = no fork, 0 = already on prague) + NapoliBlock *big.Int `json:"napoliBlock,omitempty"` // Napoli switch Block (nil = no fork, 0 = already on Napoli) // TerminalTotalDifficulty is the amount of total difficulty reached by // the network that triggers the consensus upgrade. @@ -971,21 +972,26 @@ func (c *ChainConfig) IsTerminalPoWBlock(parentTotalDiff *big.Int, totalDiff *bi return parentTotalDiff.Cmp(c.TerminalTotalDifficulty) < 0 && totalDiff.Cmp(c.TerminalTotalDifficulty) >= 0 } -// IsShanghai returns whether time is either equal to the Shanghai fork time or greater. +// IsShanghai returns whether num is either equal to the Shanghai fork block or greater. func (c *ChainConfig) IsShanghai(num *big.Int) bool { return isBlockForked(c.ShanghaiBlock, num) } -// IsCancun returns whether num is either equal to the Cancun fork time or greater. +// IsCancun returns whether num is either equal to the Cancun fork block or greater. func (c *ChainConfig) IsCancun(num *big.Int) bool { return isBlockForked(c.CancunBlock, num) } -// IsPrague returns whether num is either equal to the Prague fork time or greater. +// IsPrague returns whether num is either equal to the Prague fork block or greater. func (c *ChainConfig) IsPrague(num *big.Int) bool { return isBlockForked(c.PragueBlock, num) } +// IsNapoli returns whether num is either equal to the Napoli fork block or greater. +func (c *ChainConfig) IsNapoli(num *big.Int) bool { + return isBlockForked(c.NapoliBlock, num) +} + // CheckCompatible checks whether scheduled fork transitions have been imported // with a mismatching chain configuration. func (c *ChainConfig) CheckCompatible(newcfg *ChainConfig, height uint64, time uint64) *ConfigCompatError { @@ -1327,6 +1333,7 @@ type Rules struct { IsByzantium, IsConstantinople, IsPetersburg, IsIstanbul bool IsBerlin, IsLondon bool IsMerge, IsShanghai, IsCancun, IsPrague bool + IsNapoli bool } // Rules ensures c's ChainID is not nil. @@ -1352,5 +1359,6 @@ func (c *ChainConfig) Rules(num *big.Int, isMerge bool, timestamp uint64) Rules IsShanghai: c.IsShanghai(num), IsCancun: c.IsCancun(num), IsPrague: c.IsPrague(num), + IsNapoli: c.IsNapoli(num), } } From e5fc28d6caa7eae016fd20de41305ddc537e4f5d Mon Sep 17 00:00:00 2001 From: Arpit Temani Date: Wed, 27 Dec 2023 16:35:04 +0530 Subject: [PATCH 15/31] use config value for triesInMemory instead of default --- eth/backend.go | 1 + 1 file changed, 1 insertion(+) diff --git a/eth/backend.go b/eth/backend.go index df4175a3de..81b794283e 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -229,6 +229,7 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) { TrieTimeLimit: config.TrieTimeout, SnapshotLimit: config.SnapshotCache, Preimages: config.Preimages, + TriesInMemory: config.TriesInMemory, } ) From 46bd7d7d6c0876b1f7e89373397ab9039577823c Mon Sep 17 00:00:00 2001 From: Arpit Temani Date: Wed, 27 Dec 2023 16:35:43 +0530 Subject: [PATCH 16/31] update version --- packaging/templates/package_scripts/control | 2 +- packaging/templates/package_scripts/control.arm64 | 2 +- packaging/templates/package_scripts/control.profile.amd64 | 2 +- packaging/templates/package_scripts/control.profile.arm64 | 2 +- packaging/templates/package_scripts/control.validator | 2 +- .../templates/package_scripts/control.validator.arm64 | 2 +- params/version.go | 8 ++++---- 7 files changed, 10 insertions(+), 10 deletions(-) diff --git a/packaging/templates/package_scripts/control b/packaging/templates/package_scripts/control index 5b249281c7..3b63ec6f95 100644 --- a/packaging/templates/package_scripts/control +++ b/packaging/templates/package_scripts/control @@ -1,5 +1,5 @@ Source: bor -Version: 1.2.1 +Version: 1.2.2-beta Section: develop Priority: standard Maintainer: Polygon diff --git a/packaging/templates/package_scripts/control.arm64 b/packaging/templates/package_scripts/control.arm64 index d6ea25f3b8..a2c15ad001 100644 --- a/packaging/templates/package_scripts/control.arm64 +++ b/packaging/templates/package_scripts/control.arm64 @@ -1,5 +1,5 @@ Source: bor -Version: 1.2.1 +Version: 1.2.2-beta Section: develop Priority: standard Maintainer: Polygon diff --git a/packaging/templates/package_scripts/control.profile.amd64 b/packaging/templates/package_scripts/control.profile.amd64 index 5272652792..c346b361de 100644 --- a/packaging/templates/package_scripts/control.profile.amd64 +++ b/packaging/templates/package_scripts/control.profile.amd64 @@ -1,5 +1,5 @@ Source: bor-profile -Version: 1.2.1 +Version: 1.2.2-beta Section: develop Priority: standard Maintainer: Polygon diff --git a/packaging/templates/package_scripts/control.profile.arm64 b/packaging/templates/package_scripts/control.profile.arm64 index d229ab68dc..b1943f90fd 100644 --- a/packaging/templates/package_scripts/control.profile.arm64 +++ b/packaging/templates/package_scripts/control.profile.arm64 @@ -1,5 +1,5 @@ Source: bor-profile -Version: 1.2.1 +Version: 1.2.2-beta Section: develop Priority: standard Maintainer: Polygon diff --git a/packaging/templates/package_scripts/control.validator b/packaging/templates/package_scripts/control.validator index 41c1e7f3c3..797086ba18 100644 --- a/packaging/templates/package_scripts/control.validator +++ b/packaging/templates/package_scripts/control.validator @@ -1,5 +1,5 @@ Source: bor-profile -Version: 1.2.1 +Version: 1.2.2-beta Section: develop Priority: standard Maintainer: Polygon diff --git a/packaging/templates/package_scripts/control.validator.arm64 b/packaging/templates/package_scripts/control.validator.arm64 index 7d94bb7cbe..d701656a88 100644 --- a/packaging/templates/package_scripts/control.validator.arm64 +++ b/packaging/templates/package_scripts/control.validator.arm64 @@ -1,5 +1,5 @@ Source: bor-profile -Version: 1.2.1 +Version: 1.2.2-beta Section: develop Priority: standard Maintainer: Polygon diff --git a/params/version.go b/params/version.go index 39e283fb0d..4e8a641e74 100644 --- a/params/version.go +++ b/params/version.go @@ -21,10 +21,10 @@ import ( ) const ( - VersionMajor = 1 // Major version component of the current release - VersionMinor = 2 // Minor version component of the current release - VersionPatch = 1 // Patch version component of the current release - VersionMeta = "" // Version metadata to append to the version string + VersionMajor = 1 // Major version component of the current release + VersionMinor = 2 // Minor version component of the current release + VersionPatch = 2 // Patch version component of the current release + VersionMeta = "beta" // Version metadata to append to the version string ) var GitCommit string From 7253babddc58891560dd10078b6a4e25838fd7ee Mon Sep 17 00:00:00 2001 From: Arpit Temani Date: Wed, 27 Dec 2023 16:42:06 +0530 Subject: [PATCH 17/31] revert pruning hotfix --- core/state/pruner/pruner.go | 96 ++----------------------------------- eth/backend.go | 2 +- 2 files changed, 5 insertions(+), 93 deletions(-) diff --git a/core/state/pruner/pruner.go b/core/state/pruner/pruner.go index ea021c3be2..64c4a3a6eb 100644 --- a/core/state/pruner/pruner.go +++ b/core/state/pruner/pruner.go @@ -57,7 +57,6 @@ const ( // Config includes all the configurations for pruning. type Config struct { Datadir string // The directory of the state database - Cachedir string // The directory of state clean cache BloomSize uint64 // The Megabytes of memory allocated to bloom-filter } @@ -86,14 +85,12 @@ func NewPruner(db ethdb.Database, config Config) (*Pruner, error) { if headBlock == nil { return nil, errors.New("failed to load head block") } - snapconfig := snapshot.Config{ CacheSize: 256, Recovery: false, NoBuild: true, AsyncBuild: false, } - snaptree, err := snapshot.New(snapconfig, db, trie.NewDatabase(db), headBlock.Root()) if err != nil { return nil, err // The relevant snapshot(s) might not exist @@ -103,12 +100,10 @@ func NewPruner(db ethdb.Database, config Config) (*Pruner, error) { log.Warn("Sanitizing bloomfilter size", "provided(MB)", config.BloomSize, "updated(MB)", 256) config.BloomSize = 256 } - stateBloom, err := newStateBloomWithSize(config.BloomSize) if err != nil { return nil, err } - return &Pruner{ config: config, chainHeader: headBlock.Header(), @@ -134,7 +129,6 @@ func prune(snaptree *snapshot.Tree, root common.Hash, maindb ethdb.Database, sta batch = maindb.NewBatch() iter = maindb.NewIterator(nil, nil) ) - for iter.Next() { key := iter.Key() @@ -148,7 +142,6 @@ func prune(snaptree *snapshot.Tree, root common.Hash, maindb ethdb.Database, sta if isCode { checkKey = codeKey } - if _, exist := middleStateRoots[common.BytesToHash(checkKey)]; exist { log.Debug("Forcibly delete the middle state roots", "hash", common.BytesToHash(checkKey)) } else { @@ -156,26 +149,21 @@ func prune(snaptree *snapshot.Tree, root common.Hash, maindb ethdb.Database, sta continue } } - count += 1 size += common.StorageSize(len(key) + len(iter.Value())) batch.Delete(key) var eta time.Duration // Realistically will never remain uninited - if done := binary.BigEndian.Uint64(key[:8]); done > 0 { var ( left = math.MaxUint64 - binary.BigEndian.Uint64(key[:8]) speed = done/uint64(time.Since(pstart)/time.Millisecond+1) + 1 // +1s to avoid division by zero ) - eta = time.Duration(left/speed) * time.Millisecond } - if time.Since(logged) > 8*time.Second { log.Info("Pruning state data", "nodes", count, "size", size, "elapsed", common.PrettyDuration(time.Since(pstart)), "eta", common.PrettyDuration(eta)) - logged = time.Now() } // Recreate the iterator after every batch commit in order @@ -189,12 +177,10 @@ func prune(snaptree *snapshot.Tree, root common.Hash, maindb ethdb.Database, sta } } } - if batch.ValueSize() > 0 { batch.Write() batch.Reset() } - iter.Release() log.Info("Pruned state data", "nodes", count, "size", size, "elapsed", common.PrettyDuration(time.Since(pstart))) @@ -221,19 +207,15 @@ func prune(snaptree *snapshot.Tree, root common.Hash, maindb ethdb.Database, sta // Note for small pruning, the compaction is skipped. if count >= rangeCompactionThreshold { cstart := time.Now() - for b := 0x00; b <= 0xf0; b += 0x10 { var ( start = []byte{byte(b)} end = []byte{byte(b + 0x10)} ) - if b == 0xf0 { end = nil } - log.Info("Compacting database", "range", fmt.Sprintf("%#x-%#x", start, end), "elapsed", common.PrettyDuration(time.Since(cstart))) - if err := maindb.Compact(start, end); err != nil { log.Error("Database compaction failed", "error", err) return err @@ -241,16 +223,13 @@ func prune(snaptree *snapshot.Tree, root common.Hash, maindb ethdb.Database, sta } log.Info("Database compaction finished", "elapsed", common.PrettyDuration(time.Since(cstart))) } - log.Info("State pruning successful", "pruned", size, "elapsed", common.PrettyDuration(time.Since(start))) - return nil } // Prune deletes all historical state nodes except the nodes belong to the // specified state version. If user doesn't specify the state version, use // the bottom-most snapshot diff layer as the target. -// nolint:nestif func (p *Pruner) Prune(root common.Hash) error { // If the state bloom filter is already committed previously, // reuse it for pruning instead of generating a new one. It's @@ -260,9 +239,8 @@ func (p *Pruner) Prune(root common.Hash) error { if err != nil { return err } - if stateBloomRoot != (common.Hash{}) { - return RecoverPruning(p.config.Datadir, p.db, p.config.Cachedir) + return RecoverPruning(p.config.Datadir, p.db) } // If the target state root is not specified, use the HEAD-127 as the // target. The reason for picking it is: @@ -287,8 +265,8 @@ func (p *Pruner) Prune(root common.Hash) error { // is the presence of root can indicate the presence of the // entire trie. if !rawdb.HasLegacyTrieNode(p.db, root) { - // The special case is for clique based networks(goerli and - // some other private networks), it's possible that two + // The special case is for clique based networks(goerli + // and some other private networks), it's possible that two // consecutive blocks will have same root. In this case snapshot // difflayer won't be created. So HEAD-127 may not paired with // head-127 layer. Instead the paired layer is higher than the @@ -299,23 +277,18 @@ func (p *Pruner) Prune(root common.Hash) error { // state available, but we don't want to use the topmost state // as the pruning target. var found bool - for i := len(layers) - 2; i >= 2; i-- { if rawdb.HasLegacyTrieNode(p.db, layers[i].Root()) { root = layers[i].Root() found = true - log.Info("Selecting middle-layer as the pruning target", "root", root, "depth", i) - break } } - if !found { if len(layers) > 0 { return errors.New("no snapshot paired state") } - return fmt.Errorf("associated state[%x] is not present", root) } } else { @@ -325,27 +298,18 @@ func (p *Pruner) Prune(root common.Hash) error { log.Info("Selecting user-specified state as the pruning target", "root", root) } } - // Before start the pruning, delete the clean trie cache first. - // It's necessary otherwise in the next restart we will hit the - // deleted state root in the "clean cache" so that the incomplete - // state is picked for usage. - deleteCleanTrieCache(p.config.Cachedir) - // All the state roots of the middle layer should be forcibly pruned, // otherwise the dangling state will be left. middleRoots := make(map[common.Hash]struct{}) - for _, layer := range layers { if layer.Root() == root { break } - middleRoots[layer.Root()] = struct{}{} } // Traverse the target state, re-construct the whole state trie and // commit to the given bloom filter. start := time.Now() - if err := snapshot.GenerateTrie(p.snaptree, root, p.db, p.stateBloom); err != nil { return err } @@ -354,17 +318,13 @@ func (p *Pruner) Prune(root common.Hash) error { if err := extractGenesis(p.db, p.stateBloom); err != nil { return err } - filterName := bloomFilterName(p.config.Datadir, root) log.Info("Writing state bloom to disk", "name", filterName) - if err := p.stateBloom.Commit(filterName, filterName+stateBloomFileTempSuffix); err != nil { return err } - log.Info("State bloom filter committed", "name", filterName) - return prune(p.snaptree, root, p.db, p.stateBloom, filterName, middleRoots, start) } @@ -375,16 +335,14 @@ func (p *Pruner) Prune(root common.Hash) error { // pruning can be resumed. What's more if the bloom filter is constructed, the // pruning **has to be resumed**. Otherwise a lot of dangling nodes may be left // in the disk. -func RecoverPruning(datadir string, db ethdb.Database, trieCachePath string) error { +func RecoverPruning(datadir string, db ethdb.Database) error { stateBloomPath, stateBloomRoot, err := findBloomFilter(datadir) if err != nil { return err } - if stateBloomPath == "" { return nil // nothing to recover } - headBlock := rawdb.ReadHeadBlock(db) if headBlock == nil { return errors.New("failed to load head block") @@ -403,25 +361,16 @@ func RecoverPruning(datadir string, db ethdb.Database, trieCachePath string) err NoBuild: true, AsyncBuild: false, } - snaptree, err := snapshot.New(snapconfig, db, trie.NewDatabase(db), headBlock.Root()) if err != nil { return err // The relevant snapshot(s) might not exist } - stateBloom, err := NewStateBloomFromDisk(stateBloomPath) if err != nil { return err } - log.Info("Loaded state bloom filter", "path", stateBloomPath) - // Before start the pruning, delete the clean trie cache first. - // It's necessary otherwise in the next restart we will hit the - // deleted state root in the "clean cache" so that the incomplete - // state is picked for usage. - deleteCleanTrieCache(trieCachePath) - // All the state roots of the middle layers should be forcibly pruned, // otherwise the dangling state will be left. var ( @@ -429,21 +378,17 @@ func RecoverPruning(datadir string, db ethdb.Database, trieCachePath string) err layers = snaptree.Snapshots(headBlock.Root(), 128, true) middleRoots = make(map[common.Hash]struct{}) ) - for _, layer := range layers { if layer.Root() == stateBloomRoot { found = true break } - middleRoots[layer.Root()] = struct{}{} } - if !found { log.Error("Pruning target state is not existent") return errors.New("non-existent target state") } - return prune(snaptree, stateBloomRoot, db, stateBloom, stateBloomPath, middleRoots, time.Now()) } @@ -454,17 +399,14 @@ func extractGenesis(db ethdb.Database, stateBloom *stateBloom) error { if genesisHash == (common.Hash{}) { return errors.New("missing genesis hash") } - genesis := rawdb.ReadBlock(db, genesisHash, 0) if genesis == nil { return errors.New("missing genesis block") } - t, err := trie.NewStateTrie(trie.StateTrieID(genesis.Root()), trie.NewDatabase(db)) if err != nil { return err } - accIter, err := t.NodeIterator(nil) if err != nil { return err @@ -483,15 +425,12 @@ func extractGenesis(db ethdb.Database, stateBloom *stateBloom) error { if err := rlp.DecodeBytes(accIter.LeafBlob(), &acc); err != nil { return err } - if acc.Root != types.EmptyRootHash { id := trie.StorageTrieID(genesis.Root(), common.BytesToHash(accIter.LeafKey()), acc.Root) - storageTrie, err := trie.NewStateTrie(id, trie.NewDatabase(db)) if err != nil { return err } - storageIter, err := storageTrie.NodeIterator(nil) if err != nil { return err @@ -502,18 +441,15 @@ func extractGenesis(db ethdb.Database, stateBloom *stateBloom) error { stateBloom.Put(hash.Bytes(), nil) } } - if storageIter.Error() != nil { return storageIter.Error() } } - if !bytes.Equal(acc.CodeHash, types.EmptyCodeHash.Bytes()) { stateBloom.Put(acc.CodeHash, nil) } } } - return accIter.Error() } @@ -526,7 +462,6 @@ func isBloomFilter(filename string) (bool, common.Hash) { if strings.HasPrefix(filename, stateBloomFilePrefix) && strings.HasSuffix(filename, stateBloomFileSuffix) { return true, common.HexToHash(filename[len(stateBloomFilePrefix)+1 : len(filename)-len(stateBloomFileSuffix)-1]) } - return false, common.Hash{} } @@ -535,7 +470,6 @@ func findBloomFilter(datadir string) (string, common.Hash, error) { stateBloomPath string stateBloomRoot common.Hash ) - if err := filepath.Walk(datadir, func(path string, info os.FileInfo, err error) error { if info != nil && !info.IsDir() { ok, root := isBloomFilter(path) @@ -548,27 +482,5 @@ func findBloomFilter(datadir string) (string, common.Hash, error) { }); err != nil { return "", common.Hash{}, err } - return stateBloomPath, stateBloomRoot, nil } - -const warningLog = ` - -WARNING! - -The clean trie cache is not found. Please delete it by yourself after the -pruning. Remember don't start the Geth without deleting the clean trie cache -otherwise the entire database may be damaged! - -Check the command description "geth snapshot prune-state --help" for more details. -` - -func deleteCleanTrieCache(path string) { - if !common.FileExist(path) { - log.Warn(warningLog) - return - } - - os.RemoveAll(path) - log.Info("Deleted trie clean cache", "path", path) -} diff --git a/eth/backend.go b/eth/backend.go index 81b794283e..12af9046cc 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -143,7 +143,7 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) { if err != nil { return nil, err } - if err := pruner.RecoverPruning(stack.ResolvePath(""), chainDb, ""); err != nil { + if err := pruner.RecoverPruning(stack.ResolvePath(""), chainDb); err != nil { log.Error("Failed to recover state", "error", err) } From a517342e6f6d63ff54f48de424d4382607c4801e Mon Sep 17 00:00:00 2001 From: Arpit Temani Date: Thu, 11 Jan 2024 10:28:43 +0530 Subject: [PATCH 18/31] update version --- packaging/templates/package_scripts/control | 2 +- packaging/templates/package_scripts/control.arm64 | 2 +- packaging/templates/package_scripts/control.profile.amd64 | 2 +- packaging/templates/package_scripts/control.profile.arm64 | 2 +- packaging/templates/package_scripts/control.validator | 2 +- .../templates/package_scripts/control.validator.arm64 | 2 +- params/version.go | 8 ++++---- 7 files changed, 10 insertions(+), 10 deletions(-) diff --git a/packaging/templates/package_scripts/control b/packaging/templates/package_scripts/control index 3b63ec6f95..0ab4453759 100644 --- a/packaging/templates/package_scripts/control +++ b/packaging/templates/package_scripts/control @@ -1,5 +1,5 @@ Source: bor -Version: 1.2.2-beta +Version: 1.2.2 Section: develop Priority: standard Maintainer: Polygon diff --git a/packaging/templates/package_scripts/control.arm64 b/packaging/templates/package_scripts/control.arm64 index a2c15ad001..19405907ee 100644 --- a/packaging/templates/package_scripts/control.arm64 +++ b/packaging/templates/package_scripts/control.arm64 @@ -1,5 +1,5 @@ Source: bor -Version: 1.2.2-beta +Version: 1.2.2 Section: develop Priority: standard Maintainer: Polygon diff --git a/packaging/templates/package_scripts/control.profile.amd64 b/packaging/templates/package_scripts/control.profile.amd64 index c346b361de..258d94c534 100644 --- a/packaging/templates/package_scripts/control.profile.amd64 +++ b/packaging/templates/package_scripts/control.profile.amd64 @@ -1,5 +1,5 @@ Source: bor-profile -Version: 1.2.2-beta +Version: 1.2.2 Section: develop Priority: standard Maintainer: Polygon diff --git a/packaging/templates/package_scripts/control.profile.arm64 b/packaging/templates/package_scripts/control.profile.arm64 index b1943f90fd..803d01365e 100644 --- a/packaging/templates/package_scripts/control.profile.arm64 +++ b/packaging/templates/package_scripts/control.profile.arm64 @@ -1,5 +1,5 @@ Source: bor-profile -Version: 1.2.2-beta +Version: 1.2.2 Section: develop Priority: standard Maintainer: Polygon diff --git a/packaging/templates/package_scripts/control.validator b/packaging/templates/package_scripts/control.validator index 797086ba18..6bb38c5958 100644 --- a/packaging/templates/package_scripts/control.validator +++ b/packaging/templates/package_scripts/control.validator @@ -1,5 +1,5 @@ Source: bor-profile -Version: 1.2.2-beta +Version: 1.2.2 Section: develop Priority: standard Maintainer: Polygon diff --git a/packaging/templates/package_scripts/control.validator.arm64 b/packaging/templates/package_scripts/control.validator.arm64 index d701656a88..c5d00f3d4c 100644 --- a/packaging/templates/package_scripts/control.validator.arm64 +++ b/packaging/templates/package_scripts/control.validator.arm64 @@ -1,5 +1,5 @@ Source: bor-profile -Version: 1.2.2-beta +Version: 1.2.2 Section: develop Priority: standard Maintainer: Polygon diff --git a/params/version.go b/params/version.go index 4e8a641e74..1a9308fa81 100644 --- a/params/version.go +++ b/params/version.go @@ -21,10 +21,10 @@ import ( ) const ( - VersionMajor = 1 // Major version component of the current release - VersionMinor = 2 // Minor version component of the current release - VersionPatch = 2 // Patch version component of the current release - VersionMeta = "beta" // Version metadata to append to the version string + VersionMajor = 1 // Major version component of the current release + VersionMinor = 2 // Minor version component of the current release + VersionPatch = 2 // Patch version component of the current release + VersionMeta = "" // Version metadata to append to the version string ) var GitCommit string From 1e5211c1c7d9968655cc3287cfab9868f5922121 Mon Sep 17 00:00:00 2001 From: Anshal Shukla Date: Fri, 12 Jan 2024 20:45:10 +0530 Subject: [PATCH 19/31] add test cases --- core/vm/contracts.go | 34 +++++++------------- core/vm/contracts_test.go | 6 ++-- core/vm/testdata/precompiles/p256Verify.json | 28 ++++++++++++++++ params/config.go | 9 +----- 4 files changed, 43 insertions(+), 34 deletions(-) diff --git a/core/vm/contracts.go b/core/vm/contracts.go index 70eb0748ad..9e907f97b2 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -96,16 +96,17 @@ var PrecompiledContractsBerlin = map[common.Address]PrecompiledContract{ // PrecompiledContractsCancun contains the default set of pre-compiled Ethereum // contracts used in the Cancun release. var PrecompiledContractsCancun = map[common.Address]PrecompiledContract{ - common.BytesToAddress([]byte{1}): &ecrecover{}, - common.BytesToAddress([]byte{2}): &sha256hash{}, - common.BytesToAddress([]byte{3}): &ripemd160hash{}, - common.BytesToAddress([]byte{4}): &dataCopy{}, - common.BytesToAddress([]byte{5}): &bigModExp{eip2565: true}, - common.BytesToAddress([]byte{6}): &bn256AddIstanbul{}, - common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{}, - common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{}, - common.BytesToAddress([]byte{9}): &blake2F{}, - common.BytesToAddress([]byte{0x0a}): &kzgPointEvaluation{}, + common.BytesToAddress([]byte{1}): &ecrecover{}, + common.BytesToAddress([]byte{2}): &sha256hash{}, + common.BytesToAddress([]byte{3}): &ripemd160hash{}, + common.BytesToAddress([]byte{4}): &dataCopy{}, + common.BytesToAddress([]byte{5}): &bigModExp{eip2565: true}, + common.BytesToAddress([]byte{6}): &bn256AddIstanbul{}, + common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{}, + common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{}, + common.BytesToAddress([]byte{9}): &blake2F{}, + common.BytesToAddress([]byte{0x0a}): &kzgPointEvaluation{}, + common.BytesToAddress([]byte{0x01, 0x00}): &p256Verify{}, } // PrecompiledContractsBLS contains the set of pre-compiled Ethereum @@ -122,14 +123,7 @@ var PrecompiledContractsBLS = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{18}): &bls12381MapG2{}, } -// PrecompiledContractsNapoli contains the precompiled Ethereum -// contract specified in EIP-7212. This is exported for testing purposes. -var PrecompiledContractsNapoli = map[common.Address]PrecompiledContract{ - common.BytesToAddress([]byte{19}): &p256Verify{}, -} - var ( - PrecompiledAddressesNapoli []common.Address PrecompiledAddressesCancun []common.Address PrecompiledAddressesBerlin []common.Address PrecompiledAddressesIstanbul []common.Address @@ -156,17 +150,11 @@ func init() { for k := range PrecompiledContractsCancun { PrecompiledAddressesCancun = append(PrecompiledAddressesCancun, k) } - - for k := range PrecompiledContractsNapoli { - PrecompiledAddressesNapoli = append(PrecompiledAddressesNapoli, k) - } } // ActivePrecompiles returns the precompiles enabled with the current configuration. func ActivePrecompiles(rules params.Rules) []common.Address { switch { - case rules.IsNapoli: - return PrecompiledAddressesNapoli case rules.IsCancun: return PrecompiledAddressesCancun case rules.IsBerlin: diff --git a/core/vm/contracts_test.go b/core/vm/contracts_test.go index f791cebc73..021dfe48eb 100644 --- a/core/vm/contracts_test.go +++ b/core/vm/contracts_test.go @@ -67,7 +67,7 @@ var allPrecompiles = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{0x0f, 0x10}): &bls12381Pairing{}, common.BytesToAddress([]byte{0x0f, 0x11}): &bls12381MapG1{}, common.BytesToAddress([]byte{0x0f, 0x12}): &bls12381MapG2{}, - common.BytesToAddress([]byte{19}): &p256Verify{}, + common.BytesToAddress([]byte{0x01, 0x00}): &p256Verify{}, } // EIP-152 test vectors @@ -424,11 +424,11 @@ func BenchmarkPrecompiledP256Verify(bench *testing.B) { Expected: "0000000000000000000000000000000000000000000000000000000000000001", Name: "p256Verify", } - benchmarkPrecompiled("13", t, bench) + benchmarkPrecompiled("100", t, bench) } func TestPrecompiledP256Verify(t *testing.T) { t.Parallel() - testJson("p256Verify", "13", t) + testJson("p256Verify", "100", t) } diff --git a/core/vm/testdata/precompiles/p256Verify.json b/core/vm/testdata/precompiles/p256Verify.json index c01387dda7..54723147a5 100644 --- a/core/vm/testdata/precompiles/p256Verify.json +++ b/core/vm/testdata/precompiles/p256Verify.json @@ -5,5 +5,33 @@ "Gas": 3450, "Name": "CallP256Verify", "NoBenchmark": false + }, + { + "Input": "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9414de3726ee4d237b410c1d85ebcb05553dc578561d9f7942b7250795beb9b9027b657067322fc00ab35263fde0acabf998cd9fcf1282df9555f85dba7bdbbe2dc90f74c9e210bc3e0c60aeaa03729c9e6acde4a048ee58fd2e466c1e7b0374e606b8c22ad2985df7d792ff344f03ce94a079da801006b13640bc5af7932a7b9", + "Expected": "0000000000000000000000000000000000000000000000000000000000000001", + "Gas": 3450, + "Name": "CallP256Verify", + "NoBenchmark": false + }, + { + "Input": "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9b35d6a4f7f6fc5620c97d4287696f5174b3d37fa537b74b5fc26997ba79c725d62fe5e5fe6da76eec924e822c5ef853ede6c17069a9e9133a38f87d61599f68e7d5f3c812a255436846ee84a262b79ec4d0783afccf2433deabdca9ecf62bef5ff24e90988c7f139d378549c3a8bc6c94e6a1c911c1e02e6f48ed65aaf3d296e", + "Expected": "0000000000000000000000000000000000000000000000000000000000000001", + "Gas": 3450, + "Name": "CallP256Verify", + "NoBenchmark": false + }, + { + "Input": "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9c29c3df6ce3431b6f030b1b68b1589508ad9d1a149830489c638653aa4b08af93f6e86a9a7643403b6f5c593410d9f7234a8cd27309bce90447073ce17476850615ff147863bc8652be1e369444f90bbc5f9df05a26362e609f73ab1f1839fe3cd34fd2ae672c110671d49115825fc56b5148321aabe5ba39f2b46f71149cff9", + "Expected": "", + "Gas": 3450, + "Name": "CallP256Verify", + "NoBenchmark": false + }, + { + "Input": "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9", + "Expected": "", + "Gas": 3450, + "Name": "CallP256Verify", + "NoBenchmark": false } ] \ No newline at end of file diff --git a/params/config.go b/params/config.go index 3184c4416d..ea00979850 100644 --- a/params/config.go +++ b/params/config.go @@ -518,7 +518,6 @@ type ChainConfig struct { CancunBlock *big.Int `json:"cancunBlock,omitempty"` // Cancun switch Block (nil = no fork, 0 = already on cancun) PragueBlock *big.Int `json:"pragueBlock,omitempty"` // Prague switch Block (nil = no fork, 0 = already on prague) VerkleBlock *big.Int `json:"verkleBlock,omitempty"` // Verkle switch Block (nil = no fork, 0 = already on verkle) - NapoliBlock *big.Int `json:"napoliBlock,omitempty"` // Napoli switch Block (nil = no fork, 0 = already on Napoli) // TerminalTotalDifficulty is the amount of total difficulty reached by // the network that triggers the consensus upgrade. @@ -858,11 +857,6 @@ func (c *ChainConfig) IsPrague(num *big.Int) bool { return isBlockForked(c.PragueBlock, num) } -// IsNapoli returns whether num is either equal to the Napoli fork block or greater. -func (c *ChainConfig) IsNapoli(num *big.Int) bool { - return isBlockForked(c.NapoliBlock, num) -} - // CheckCompatible checks whether scheduled fork transitions have been imported // with a mismatching chain configuration. func (c *ChainConfig) CheckCompatible(newcfg *ChainConfig, height uint64, time uint64) *ConfigCompatError { @@ -1151,7 +1145,7 @@ type Rules struct { IsByzantium, IsConstantinople, IsPetersburg, IsIstanbul bool IsBerlin, IsLondon bool IsMerge, IsShanghai, IsCancun, IsPrague bool - IsVerkle, IsNapoli bool + IsVerkle bool } // Rules ensures c's ChainID is not nil. @@ -1177,6 +1171,5 @@ func (c *ChainConfig) Rules(num *big.Int, isMerge bool, timestamp uint64) Rules IsShanghai: c.IsShanghai(num), IsCancun: c.IsCancun(num), IsPrague: c.IsPrague(num), - IsNapoli: c.IsNapoli(num), } } From dac1a42fa8390dad156c23cb1f1e78ff60bde9ee Mon Sep 17 00:00:00 2001 From: PeaStew <34198053+PeaStew@users.noreply.github.com> Date: Mon, 15 Jan 2024 09:46:15 +0100 Subject: [PATCH 20/31] Update client.go to allow the use of paths with the heimdall url (#1126) * Update client.go to allow the use of paths with the heimdall url As reported to the polygon team 2 months ago in the Ankr polygon slack, the current code prevents the use of a path with the heimdall url, this was fixed in erigon ledgerwatch/erigon@a3a6170 in response to my request by Mark Holt, and it seems this code was just copied from bor where it is incorrect too. This patch fixes that. * Add reference to path library * Fix reversed order of values in unit tests and test removal of setting u.path to rawPath (otherwise why do we need rawPath at all) seems like there were work arounds done here in bioth the unit tests AND the makeURL but logic needs to be examined --- consensus/bor/heimdall/client.go | 3 ++- consensus/bor/heimdall/client_test.go | 4 ++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/consensus/bor/heimdall/client.go b/consensus/bor/heimdall/client.go index d69f5ead3c..5c65721574 100644 --- a/consensus/bor/heimdall/client.go +++ b/consensus/bor/heimdall/client.go @@ -8,6 +8,7 @@ import ( "io" "net/http" "net/url" + "path" "sort" "time" @@ -420,7 +421,7 @@ func makeURL(urlString, rawPath, rawQuery string) (*url.URL, error) { return nil, err } - u.Path = rawPath + u.Path = path.Join(u.Path, rawPath) u.RawQuery = rawQuery return u, err diff --git a/consensus/bor/heimdall/client_test.go b/consensus/bor/heimdall/client_test.go index 5023b847a5..737875028c 100644 --- a/consensus/bor/heimdall/client_test.go +++ b/consensus/bor/heimdall/client_test.go @@ -399,7 +399,7 @@ func TestSpanURL(t *testing.T) { const expected = "http://bor0/bor/span/1" if url.String() != expected { - t.Fatalf("expected URL %q, got %q", url.String(), expected) + t.Fatalf("expected URL %q, got %q", expected, url.String()) } } @@ -414,6 +414,6 @@ func TestStateSyncURL(t *testing.T) { const expected = "http://bor0/clerk/event-record/list?from-id=10&to-time=100&limit=50" if url.String() != expected { - t.Fatalf("expected URL %q, got %q", url.String(), expected) + t.Fatalf("expected URL %q, got %q", expected, url.String()) } } From 70e4fe96575d055c1e9f57435fc8fdbfa79f8251 Mon Sep 17 00:00:00 2001 From: Manav Darji Date: Fri, 19 Jan 2024 16:47:29 +0530 Subject: [PATCH 21/31] internal/ethapi: fix call with state api --- internal/ethapi/api.go | 29 ++++++++++++++++++++++++----- 1 file changed, 24 insertions(+), 5 deletions(-) diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go index 83b8f22edf..25c6ab97f6 100644 --- a/internal/ethapi/api.go +++ b/internal/ethapi/api.go @@ -1264,12 +1264,31 @@ func doCallWithState(ctx context.Context, b Backend, args TransactionArgs, heade return result, nil } -func DoCall(ctx context.Context, b Backend, args TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *StateOverride, blockOverrides *BlockOverrides, timeout time.Duration, globalGasCap uint64) (*core.ExecutionResult, error) { +func DoCall(ctx context.Context, b Backend, args TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, state *state.StateDB, overrides *StateOverride, blockOverrides *BlockOverrides, timeout time.Duration, globalGasCap uint64) (*core.ExecutionResult, error) { defer func(start time.Time) { log.Debug("Executing EVM call finished", "runtime", time.Since(start)) }(time.Now()) - state, header, err := b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash) - if state == nil || err != nil { - return nil, err + var ( + header *types.Header + err error + ) + + // BOR: This is used by bor consensus to fetch data from genesis contracts for state-sync + // Fetch the state and header from blockNumberOrHash if it's coming from normal eth_call path. + if state == nil { + state, header, err = b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash) + if state == nil || err != nil { + return nil, err + } + } else { + // Fetch the header from the given blockNumberOrHash. Note that this path is only taken + // when we're doing a call from bor consensus to fetch data from genesis contracts. It's + // necessary to fetch header using header hash as we might be experiencing a reorg and there + // can be multiple headers with same number. + header, err = b.HeaderByHash(ctx, *blockNrOrHash.BlockHash) + if header == nil || err != nil { + log.Warn("Error fetching header on CallWithState", "err", err) + return nil, err + } } return doCall(ctx, b, args, state, header, overrides, blockOverrides, timeout, globalGasCap) @@ -1327,7 +1346,7 @@ func (s *BlockChainAPI) Call(ctx context.Context, args TransactionArgs, blockNrO // Note, this function doesn't make and changes in the state/blockchain and is // useful to execute and retrieve values. func (s *BlockChainAPI) CallWithState(ctx context.Context, args TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, state *state.StateDB, overrides *StateOverride, blockOverrides *BlockOverrides) (hexutil.Bytes, error) { - result, err := DoCall(ctx, s.b, args, blockNrOrHash, overrides, blockOverrides, s.b.RPCEVMTimeout(), s.b.RPCGasCap()) + result, err := DoCall(ctx, s.b, args, blockNrOrHash, state, overrides, blockOverrides, s.b.RPCEVMTimeout(), s.b.RPCGasCap()) if err != nil { return nil, err } From f92c3c0c9bdc129c4b19bed4ca740f8892898aaf Mon Sep 17 00:00:00 2001 From: Manav Darji Date: Fri, 19 Jan 2024 16:47:37 +0530 Subject: [PATCH 22/31] graphql: fix eth call params --- graphql/graphql.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/graphql/graphql.go b/graphql/graphql.go index 7aa427b458..f03644eeb4 100644 --- a/graphql/graphql.go +++ b/graphql/graphql.go @@ -1121,7 +1121,7 @@ func (c *CallResult) Status() hexutil.Uint64 { func (b *Block) Call(ctx context.Context, args struct { Data ethapi.TransactionArgs }) (*CallResult, error) { - result, err := ethapi.DoCall(ctx, b.r.backend, args.Data, *b.numberOrHash, nil, nil, b.r.backend.RPCEVMTimeout(), b.r.backend.RPCGasCap()) + result, err := ethapi.DoCall(ctx, b.r.backend, args.Data, *b.numberOrHash, nil, nil, nil, b.r.backend.RPCEVMTimeout(), b.r.backend.RPCGasCap()) if err != nil { return nil, err } @@ -1184,7 +1184,7 @@ func (p *Pending) Call(ctx context.Context, args struct { Data ethapi.TransactionArgs }) (*CallResult, error) { pendingBlockNr := rpc.BlockNumberOrHashWithNumber(rpc.PendingBlockNumber) - result, err := ethapi.DoCall(ctx, p.r.backend, args.Data, pendingBlockNr, nil, nil, p.r.backend.RPCEVMTimeout(), p.r.backend.RPCGasCap()) + result, err := ethapi.DoCall(ctx, p.r.backend, args.Data, pendingBlockNr, nil, nil, nil, p.r.backend.RPCEVMTimeout(), p.r.backend.RPCGasCap()) if err != nil { return nil, err } From 0c08204d7dcd4a7916bef5772d58757978c55a8a Mon Sep 17 00:00:00 2001 From: Manav Darji Date: Thu, 18 Jan 2024 13:11:50 +0530 Subject: [PATCH 23/31] integration-tests: update ipc path on ci tests (#1127) * integration-tests: update ipc path on ci tests * added devnetBorFlags in matic-cli-config.yml --------- Co-authored-by: Pratik Patil --- .github/matic-cli-config.yml | 1 + integration-tests/bor_health.sh | 4 ++-- integration-tests/smoke_test.sh | 4 ++-- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/.github/matic-cli-config.yml b/.github/matic-cli-config.yml index 8c31e17dc6..e3200ec8b8 100644 --- a/.github/matic-cli-config.yml +++ b/.github/matic-cli-config.yml @@ -23,3 +23,4 @@ borDockerBuildContext: "../../bor" heimdallDockerBuildContext: "https://github.com/maticnetwork/heimdall.git#develop" sprintSizeBlockNumber: - '0' +devnetBorFlags: config,config,config diff --git a/integration-tests/bor_health.sh b/integration-tests/bor_health.sh index 3288739f85..63aba9aab1 100644 --- a/integration-tests/bor_health.sh +++ b/integration-tests/bor_health.sh @@ -3,8 +3,8 @@ set -e while true do - peers=$(docker exec bor0 bash -c "bor attach /root/.bor/data/bor.ipc -exec 'admin.peers'") - block=$(docker exec bor0 bash -c "bor attach /root/.bor/data/bor.ipc -exec 'eth.blockNumber'") + peers=$(docker exec bor0 bash -c "bor attach /root/var/lib/bor/data/bor.ipc -exec 'admin.peers'") + block=$(docker exec bor0 bash -c "bor attach /root/var/lib/bor/data/bor.ipc -exec 'eth.blockNumber'") if [[ -n "$peers" ]] && [[ -n "$block" ]]; then break diff --git a/integration-tests/smoke_test.sh b/integration-tests/smoke_test.sh index 62ca370ee7..9275093b16 100644 --- a/integration-tests/smoke_test.sh +++ b/integration-tests/smoke_test.sh @@ -1,7 +1,7 @@ #!/bin/bash set -e -balanceInit=$(docker exec bor0 bash -c "bor attach /root/.bor/data/bor.ipc -exec 'Math.round(web3.fromWei(eth.getBalance(eth.accounts[0])))'") +balanceInit=$(docker exec bor0 bash -c "bor attach /root/var/lib/bor/data/bor.ipc -exec 'Math.round(web3.fromWei(eth.getBalance(eth.accounts[0])))'") stateSyncFound="false" checkpointFound="false" @@ -11,7 +11,7 @@ start_time=$SECONDS while true do - balance=$(docker exec bor0 bash -c "bor attach /root/.bor/data/bor.ipc -exec 'Math.round(web3.fromWei(eth.getBalance(eth.accounts[0])))'") + balance=$(docker exec bor0 bash -c "bor attach /root/var/lib/bor/data/bor.ipc -exec 'Math.round(web3.fromWei(eth.getBalance(eth.accounts[0])))'") if ! [[ "$balance" =~ ^[0-9]+$ ]]; then echo "Something is wrong! Can't find the balance of first account in bor network." From 5fc30aeaac2b143eb4163b12547c6bbb007c381a Mon Sep 17 00:00:00 2001 From: Arpit Temani Date: Fri, 19 Jan 2024 17:19:12 +0530 Subject: [PATCH 24/31] Revert "Consistent" --- consensus/bor/bor.go | 4 - consensus/bor/bor_test.go | 35 +-- core/txpool/legacypool/legacypool.go | 16 +- core/txpool/validation.go | 4 +- core/types/transaction_signing.go | 35 --- core/vm/contracts.go | 56 +---- core/vm/contracts_test.go | 17 -- core/vm/testdata/precompiles/p256Verify.json | 37 --- crypto/secp256r1/publickey.go | 26 -- crypto/secp256r1/verifier.go | 21 -- eth/backend.go | 3 +- eth/bor_api_backend.go | 15 ++ internal/cli/server/config_legacy_test.go | 19 -- internal/cli/server/testdata/default.toml | 193 --------------- internal/ethapi/api.go | 15 +- internal/ethapi/api_test.go | 248 ------------------- params/config.go | 12 +- params/protocol_params.go | 2 - 18 files changed, 52 insertions(+), 706 deletions(-) delete mode 100644 core/vm/testdata/precompiles/p256Verify.json delete mode 100644 crypto/secp256r1/publickey.go delete mode 100644 crypto/secp256r1/verifier.go delete mode 100644 internal/cli/server/testdata/default.toml diff --git a/consensus/bor/bor.go b/consensus/bor/bor.go index c54eef564b..24590ea516 100644 --- a/consensus/bor/bor.go +++ b/consensus/bor/bor.go @@ -883,10 +883,6 @@ func (c *Bor) changeContractCodeIfNeeded(headerNumber uint64, state *state.State for addr, account := range allocs { log.Info("change contract code", "address", addr) state.SetCode(addr, account.Code) - - if state.GetBalance(addr).Cmp(big.NewInt(0)) == 0 { - state.SetBalance(addr, account.Balance) - } } } } diff --git a/consensus/bor/bor_test.go b/consensus/bor/bor_test.go index ca60d5f66f..52c93c77ad 100644 --- a/consensus/bor/bor_test.go +++ b/consensus/bor/bor_test.go @@ -40,12 +40,6 @@ func TestGenesisContractChange(t *testing.T) { "balance": "0x1000", }, }, - "6": map[string]interface{}{ - addr0.Hex(): map[string]interface{}{ - "code": hexutil.Bytes{0x1, 0x4}, - "balance": "0x2000", - }, - }, }, }, } @@ -91,35 +85,24 @@ func TestGenesisContractChange(t *testing.T) { root := genesis.Root() - // code does not change, balance remains 0 + // code does not change root, statedb = addBlock(root, 1) require.Equal(t, statedb.GetCode(addr0), []byte{0x1, 0x1}) - require.Equal(t, statedb.GetBalance(addr0), big.NewInt(0)) - // code changes 1st time, balance remains 0 + // code changes 1st time root, statedb = addBlock(root, 2) require.Equal(t, statedb.GetCode(addr0), []byte{0x1, 0x2}) - require.Equal(t, statedb.GetBalance(addr0), big.NewInt(0)) - // code same as 1st change, balance remains 0 + // code same as 1st change root, statedb = addBlock(root, 3) require.Equal(t, statedb.GetCode(addr0), []byte{0x1, 0x2}) + + // code changes 2nd time + _, statedb = addBlock(root, 4) + require.Equal(t, statedb.GetCode(addr0), []byte{0x1, 0x3}) + + // make sure balance change DOES NOT take effect require.Equal(t, statedb.GetBalance(addr0), big.NewInt(0)) - - // code changes 2nd time, balance updates to 4096 - root, statedb = addBlock(root, 4) - require.Equal(t, statedb.GetCode(addr0), []byte{0x1, 0x3}) - require.Equal(t, statedb.GetBalance(addr0), big.NewInt(4096)) - - // code same as 2nd change, balance remains 4096 - root, statedb = addBlock(root, 5) - require.Equal(t, statedb.GetCode(addr0), []byte{0x1, 0x3}) - require.Equal(t, statedb.GetBalance(addr0), big.NewInt(4096)) - - // code changes 3rd time, balance remains 4096 - _, statedb = addBlock(root, 6) - require.Equal(t, statedb.GetCode(addr0), []byte{0x1, 0x4}) - require.Equal(t, statedb.GetBalance(addr0), big.NewInt(4096)) } func TestEncodeSigHeaderJaipur(t *testing.T) { diff --git a/core/txpool/legacypool/legacypool.go b/core/txpool/legacypool/legacypool.go index d37f5ef4bc..db4af0ee8d 100644 --- a/core/txpool/legacypool/legacypool.go +++ b/core/txpool/legacypool/legacypool.go @@ -159,8 +159,7 @@ var DefaultConfig = Config{ AccountQueue: 64, GlobalQueue: 1024, - Lifetime: 3 * time.Hour, - AllowUnprotectedTxs: false, + Lifetime: 3 * time.Hour, } // sanitize checks the provided user configurations and changes anything that's @@ -591,8 +590,7 @@ func (pool *LegacyPool) local() map[common.Address]types.Transactions { // and does not require the pool mutex to be held. func (pool *LegacyPool) validateTxBasics(tx *types.Transaction, local bool) error { opts := &txpool.ValidationOptions{ - Config: pool.chainconfig, - AllowUnprotectedTxs: pool.config.AllowUnprotectedTxs, + Config: pool.chainconfig, Accept: 0 | 1<= 0 } -// IsShanghai returns whether num is either equal to the Shanghai fork block or greater. +// IsShanghai returns whether time is either equal to the Shanghai fork time or greater. func (c *ChainConfig) IsShanghai(num *big.Int) bool { return isBlockForked(c.ShanghaiBlock, num) } -// IsCancun returns whether num is either equal to the Cancun fork block or greater. +// IsCancun returns whether num is either equal to the Cancun fork time or greater. func (c *ChainConfig) IsCancun(num *big.Int) bool { return isBlockForked(c.CancunBlock, num) } -// IsPrague returns whether num is either equal to the Prague fork block or greater. +// IsPrague returns whether num is either equal to the Prague fork time or greater. func (c *ChainConfig) IsPrague(num *big.Int) bool { return isBlockForked(c.PragueBlock, num) } @@ -912,9 +912,9 @@ func (c *ChainConfig) CheckConfigForkOrder() error { {name: "arrowGlacierBlock", block: c.ArrowGlacierBlock, optional: true}, {name: "grayGlacierBlock", block: c.GrayGlacierBlock, optional: true}, {name: "mergeNetsplitBlock", block: c.MergeNetsplitBlock, optional: true}, - {name: "shanghaiBlock", block: c.ShanghaiBlock}, - {name: "cancunBlock", block: c.CancunBlock, optional: true}, - {name: "pragueBlock", block: c.PragueBlock, optional: true}, + {name: "ShanghaiBlock", block: c.ShanghaiBlock}, + {name: "CancunBlock", block: c.CancunBlock, optional: true}, + {name: "pragueTime", block: c.PragueBlock, optional: true}, } { if lastFork.name != "" { switch { diff --git a/params/protocol_params.go b/params/protocol_params.go index ef5f267172..8eb5e247a9 100644 --- a/params/protocol_params.go +++ b/params/protocol_params.go @@ -160,8 +160,6 @@ const ( Bls12381MapG1Gas uint64 = 5500 // Gas price for BLS12-381 mapping field element to G1 operation Bls12381MapG2Gas uint64 = 110000 // Gas price for BLS12-381 mapping field element to G2 operation - P256VerifyGas uint64 = 3450 // secp256r1 elliptic curve signature verifier gas price - // The Refund Quotient is the cap on how much of the used gas can be refunded. Before EIP-3529, // up to half the consumed gas could be refunded. Redefined as 1/5th in EIP-3529 RefundQuotient uint64 = 2 From 8d164b976a22f00fe3aaf14fc7e2000e7dee8794 Mon Sep 17 00:00:00 2001 From: Anshal Shukla Date: Fri, 19 Jan 2024 17:34:28 +0530 Subject: [PATCH 25/31] remove: kgz precompile --- core/vm/contracts.go | 1 - 1 file changed, 1 deletion(-) diff --git a/core/vm/contracts.go b/core/vm/contracts.go index fe7c770815..3ccaf61667 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -104,7 +104,6 @@ var PrecompiledContractsCancun = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{}, common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{}, common.BytesToAddress([]byte{9}): &blake2F{}, - common.BytesToAddress([]byte{0x0a}): &kzgPointEvaluation{}, } // PrecompiledContractsBLS contains the set of pre-compiled Ethereum From e070986483b70c9c076cf8640929b4c8e444d15d Mon Sep 17 00:00:00 2001 From: Anshal Shukla Date: Fri, 19 Jan 2024 17:35:17 +0530 Subject: [PATCH 26/31] remove: kgz precompile --- core/vm/contracts.go | 1 - 1 file changed, 1 deletion(-) diff --git a/core/vm/contracts.go b/core/vm/contracts.go index 9e907f97b2..382c1ab405 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -105,7 +105,6 @@ var PrecompiledContractsCancun = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{}, common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{}, common.BytesToAddress([]byte{9}): &blake2F{}, - common.BytesToAddress([]byte{0x0a}): &kzgPointEvaluation{}, common.BytesToAddress([]byte{0x01, 0x00}): &p256Verify{}, } From eb528aee718a1db8772ac41f045ceb567e93c2a1 Mon Sep 17 00:00:00 2001 From: Arpit Temani Date: Fri, 19 Jan 2024 19:07:39 +0530 Subject: [PATCH 27/31] update version --- packaging/templates/package_scripts/control | 2 +- packaging/templates/package_scripts/control.arm64 | 2 +- packaging/templates/package_scripts/control.profile.amd64 | 2 +- packaging/templates/package_scripts/control.profile.arm64 | 2 +- packaging/templates/package_scripts/control.validator | 2 +- packaging/templates/package_scripts/control.validator.arm64 | 2 +- params/version.go | 2 +- 7 files changed, 7 insertions(+), 7 deletions(-) diff --git a/packaging/templates/package_scripts/control b/packaging/templates/package_scripts/control index 0ab4453759..94eeea3661 100644 --- a/packaging/templates/package_scripts/control +++ b/packaging/templates/package_scripts/control @@ -1,5 +1,5 @@ Source: bor -Version: 1.2.2 +Version: 1.2.3 Section: develop Priority: standard Maintainer: Polygon diff --git a/packaging/templates/package_scripts/control.arm64 b/packaging/templates/package_scripts/control.arm64 index 19405907ee..809d705aa6 100644 --- a/packaging/templates/package_scripts/control.arm64 +++ b/packaging/templates/package_scripts/control.arm64 @@ -1,5 +1,5 @@ Source: bor -Version: 1.2.2 +Version: 1.2.3 Section: develop Priority: standard Maintainer: Polygon diff --git a/packaging/templates/package_scripts/control.profile.amd64 b/packaging/templates/package_scripts/control.profile.amd64 index 258d94c534..22470ccd49 100644 --- a/packaging/templates/package_scripts/control.profile.amd64 +++ b/packaging/templates/package_scripts/control.profile.amd64 @@ -1,5 +1,5 @@ Source: bor-profile -Version: 1.2.2 +Version: 1.2.3 Section: develop Priority: standard Maintainer: Polygon diff --git a/packaging/templates/package_scripts/control.profile.arm64 b/packaging/templates/package_scripts/control.profile.arm64 index 803d01365e..4a52b2e063 100644 --- a/packaging/templates/package_scripts/control.profile.arm64 +++ b/packaging/templates/package_scripts/control.profile.arm64 @@ -1,5 +1,5 @@ Source: bor-profile -Version: 1.2.2 +Version: 1.2.3 Section: develop Priority: standard Maintainer: Polygon diff --git a/packaging/templates/package_scripts/control.validator b/packaging/templates/package_scripts/control.validator index 6bb38c5958..00b517c3b0 100644 --- a/packaging/templates/package_scripts/control.validator +++ b/packaging/templates/package_scripts/control.validator @@ -1,5 +1,5 @@ Source: bor-profile -Version: 1.2.2 +Version: 1.2.3 Section: develop Priority: standard Maintainer: Polygon diff --git a/packaging/templates/package_scripts/control.validator.arm64 b/packaging/templates/package_scripts/control.validator.arm64 index c5d00f3d4c..725a4ec394 100644 --- a/packaging/templates/package_scripts/control.validator.arm64 +++ b/packaging/templates/package_scripts/control.validator.arm64 @@ -1,5 +1,5 @@ Source: bor-profile -Version: 1.2.2 +Version: 1.2.3 Section: develop Priority: standard Maintainer: Polygon diff --git a/params/version.go b/params/version.go index 1a9308fa81..b44ab8079c 100644 --- a/params/version.go +++ b/params/version.go @@ -23,7 +23,7 @@ import ( const ( VersionMajor = 1 // Major version component of the current release VersionMinor = 2 // Minor version component of the current release - VersionPatch = 2 // Patch version component of the current release + VersionPatch = 3 // Patch version component of the current release VersionMeta = "" // Version metadata to append to the version string ) From c629c0fdb67ff801c09b08d77b80585ad9a6a68b Mon Sep 17 00:00:00 2001 From: zhiqiangxu <652732310@qq.com> Date: Mon, 22 Jan 2024 21:10:45 +0800 Subject: [PATCH 28/31] break loop when delayFlag becomes false (#1121) --- miner/worker.go | 1 + 1 file changed, 1 insertion(+) diff --git a/miner/worker.go b/miner/worker.go index 7e2e0b8650..4a92776f56 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -1124,6 +1124,7 @@ mainloop: if ok1 || ok2 { delayFlag = false + break } for j := range deps[i] { From c559619c805ec6a80fd7012428190933d64b40db Mon Sep 17 00:00:00 2001 From: Pratik Patil Date: Mon, 22 Jan 2024 20:47:47 +0530 Subject: [PATCH 29/31] fix bug: should use Lock when mutating the flag (#1141) * should use Lock when mutating the flag * same problem in MVHashMap.Write * hole the rlock while reading WriteCell --------- Co-authored-by: zhiqiangxu <652732310@qq.com> --- core/blockstm/mvhashmap.go | 37 ++++++++++++++----------------------- 1 file changed, 14 insertions(+), 23 deletions(-) diff --git a/core/blockstm/mvhashmap.go b/core/blockstm/mvhashmap.go index 59085138cf..003de91e70 100644 --- a/core/blockstm/mvhashmap.go +++ b/core/blockstm/mvhashmap.go @@ -121,34 +121,23 @@ func (mv *MVHashMap) Write(k Key, v Version, data interface{}) { return }) - cells.rw.RLock() - ci, ok := cells.tm.Get(v.TxnIndex) - cells.rw.RUnlock() - - if ok { + cells.rw.Lock() + if ci, ok := cells.tm.Get(v.TxnIndex); !ok { + cells.tm.Put(v.TxnIndex, &WriteCell{ + flag: FlagDone, + incarnation: v.Incarnation, + data: data, + }) + } else { if ci.(*WriteCell).incarnation > v.Incarnation { panic(fmt.Errorf("existing transaction value does not have lower incarnation: %v, %v", k, v.TxnIndex)) } - ci.(*WriteCell).flag = FlagDone ci.(*WriteCell).incarnation = v.Incarnation ci.(*WriteCell).data = data - } else { - cells.rw.Lock() - if ci, ok = cells.tm.Get(v.TxnIndex); !ok { - cells.tm.Put(v.TxnIndex, &WriteCell{ - flag: FlagDone, - incarnation: v.Incarnation, - data: data, - }) - } else { - ci.(*WriteCell).flag = FlagDone - ci.(*WriteCell).incarnation = v.Incarnation - ci.(*WriteCell).data = data - } - cells.rw.Unlock() } + cells.rw.Unlock() } func (mv *MVHashMap) ReadStorage(k Key, fallBack func() any) any { @@ -166,13 +155,13 @@ func (mv *MVHashMap) MarkEstimate(k Key, txIdx int) { panic(fmt.Errorf("path must already exist")) }) - cells.rw.RLock() + cells.rw.Lock() if ci, ok := cells.tm.Get(txIdx); !ok { panic(fmt.Sprintf("should not happen - cell should be present for path. TxIdx: %v, path, %x, cells keys: %v", txIdx, k, cells.tm.Keys())) } else { ci.(*WriteCell).flag = FlagEstimate } - cells.rw.RUnlock() + cells.rw.Unlock() } func (mv *MVHashMap) Delete(k Key, txIdx int) { @@ -233,8 +222,8 @@ func (mv *MVHashMap) Read(k Key, txIdx int) (res MVReadResult) { } cells.rw.RLock() + fk, fv := cells.tm.Floor(txIdx - 1) - cells.rw.RUnlock() if fk != nil && fv != nil { c := fv.(*WriteCell) @@ -253,6 +242,8 @@ func (mv *MVHashMap) Read(k Key, txIdx int) (res MVReadResult) { } } + cells.rw.RUnlock() + return } From f1e0b1d9261977725b8437946cf5ee46590620eb Mon Sep 17 00:00:00 2001 From: Pratik Patil Date: Tue, 23 Jan 2024 10:52:00 +0530 Subject: [PATCH 30/31] Changed parallel universe HF to Cancun HF and some important fixes (#1132) * changed parallel universe HF to napoli HF * integration-tests: update ipc path on ci tests (#1127) * integration-tests: update ipc path on ci tests * added devnetBorFlags in matic-cli-config.yml --------- Co-authored-by: Pratik Patil * Revert "integration-tests: update ipc path on ci tests (#1127)" This reverts commit 0660fac39b5d5a31cd4da54e48b4ca8eda4d7cb4. * using cancun for block-stm metadata instead of napoli * added a check to verify tx dependencies and test cases * fix in snapshot.chainConfig * removed snapshot.*params.BorConfig using snapshot.chainConfig.Bor instead * removed unnecessary if statement in ParallelStateProcessor.Process * addressed comment * small fix in commitTransactions * dependency calculation bug fix in miner/worker.go --------- Co-authored-by: Manav Darji Co-authored-by: Arpit Temani --- builder/files/genesis-mainnet-v1.json | 1 - builder/files/genesis-testnet-v4.json | 1 - consensus/bor/bor.go | 16 ++-- consensus/bor/snapshot.go | 25 ++--- core/parallel_state_processor.go | 96 +++++++++---------- core/parallel_state_processor_test.go | 30 ++++++ core/types/block.go | 4 +- core/types/block_test.go | 1 - internal/cli/server/chains/mainnet.go | 7 +- internal/cli/server/chains/mumbai.go | 7 +- .../chains/test_files/chain_legacy_test.json | 1 - .../server/chains/test_files/chain_test.json | 1 - miner/worker.go | 60 ++++++------ miner/worker_test.go | 2 +- params/config.go | 34 +++---- 15 files changed, 148 insertions(+), 138 deletions(-) create mode 100644 core/parallel_state_processor_test.go diff --git a/builder/files/genesis-mainnet-v1.json b/builder/files/genesis-mainnet-v1.json index f4b2e4a6b4..11d64cabab 100644 --- a/builder/files/genesis-mainnet-v1.json +++ b/builder/files/genesis-mainnet-v1.json @@ -17,7 +17,6 @@ "bor": { "jaipurBlock": 23850000, "delhiBlock": 38189056, - "parallelUniverseBlock": 0, "indoreBlock": 44934656, "stateSyncConfirmationDelay": { "44934656": 128 diff --git a/builder/files/genesis-testnet-v4.json b/builder/files/genesis-testnet-v4.json index c848d5dce0..afad138492 100644 --- a/builder/files/genesis-testnet-v4.json +++ b/builder/files/genesis-testnet-v4.json @@ -17,7 +17,6 @@ "bor": { "jaipurBlock": 22770000, "delhiBlock": 29638656, - "parallelUniverseBlock": 0, "indoreBlock": 37075456, "stateSyncConfirmationDelay": { "37075456": 128 diff --git a/consensus/bor/bor.go b/consensus/bor/bor.go index 24590ea516..40999f73c4 100644 --- a/consensus/bor/bor.go +++ b/consensus/bor/bor.go @@ -353,7 +353,7 @@ func (c *Bor) verifyHeader(chain consensus.ChainHeaderReader, header *types.Head isSprintEnd := IsSprintStart(number+1, c.config.CalculateSprint(number)) // Ensure that the extra-data contains a signer list on checkpoint, but none otherwise - signersBytes := len(header.GetValidatorBytes(c.config)) + signersBytes := len(header.GetValidatorBytes(c.chainConfig)) if !isSprintEnd && signersBytes != 0 { return errExtraValidators @@ -472,7 +472,7 @@ func (c *Bor) verifyCascadingFields(chain consensus.ChainHeaderReader, header *t sort.Sort(valset.ValidatorsByAddress(newValidators)) - headerVals, err := valset.ParseValidators(header.GetValidatorBytes(c.config)) + headerVals, err := valset.ParseValidators(header.GetValidatorBytes(c.chainConfig)) if err != nil { return err } @@ -490,7 +490,7 @@ func (c *Bor) verifyCascadingFields(chain consensus.ChainHeaderReader, header *t // verify the validator list in the last sprint block if IsSprintStart(number, c.config.CalculateSprint(number)) { - parentValidatorBytes := parent.GetValidatorBytes(c.config) + parentValidatorBytes := parent.GetValidatorBytes(c.chainConfig) validatorsBytes := make([]byte, len(snap.ValidatorSet.Validators)*validatorHeaderBytesLength) currentValidators := snap.ValidatorSet.Copy().Validators @@ -521,7 +521,7 @@ func (c *Bor) snapshot(chain consensus.ChainHeaderReader, number uint64, hash co val := valset.NewValidator(signer, 1000) validatorset := valset.NewValidatorSet([]*valset.Validator{val}) - snapshot := newSnapshot(c.config, c.signatures, number, hash, validatorset.Validators) + snapshot := newSnapshot(c.chainConfig, c.signatures, number, hash, validatorset.Validators) return snapshot, nil } @@ -541,7 +541,7 @@ func (c *Bor) snapshot(chain consensus.ChainHeaderReader, number uint64, hash co // If an on-disk checkpoint snapshot can be found, use that if number%checkpointInterval == 0 { - if s, err := loadSnapshot(c.config, c.signatures, c.db, hash); err == nil { + if s, err := loadSnapshot(c.chainConfig, c.config, c.signatures, c.db, hash); err == nil { log.Trace("Loaded snapshot from disk", "number", number, "hash", hash) snap = s @@ -570,7 +570,7 @@ func (c *Bor) snapshot(chain consensus.ChainHeaderReader, number uint64, hash co } // new snap shot - snap = newSnapshot(c.config, c.signatures, number, hash, validators) + snap = newSnapshot(c.chainConfig, c.signatures, number, hash, validators) if err := snap.store(c.db); err != nil { return nil, err } @@ -742,7 +742,7 @@ func (c *Bor) Prepare(chain consensus.ChainHeaderReader, header *types.Header) e // sort validator by address sort.Sort(valset.ValidatorsByAddress(newValidators)) - if c.config.IsParallelUniverse(header.Number) { + if c.chainConfig.IsCancun(header.Number) { var tempValidatorBytes []byte for _, validator := range newValidators { @@ -766,7 +766,7 @@ func (c *Bor) Prepare(chain consensus.ChainHeaderReader, header *types.Header) e header.Extra = append(header.Extra, validator.HeaderBytes()...) } } - } else if c.config.IsParallelUniverse(header.Number) { + } else if c.chainConfig.IsCancun(header.Number) { blockExtraData := &types.BlockExtraData{ ValidatorBytes: nil, TxDependency: nil, diff --git a/consensus/bor/snapshot.go b/consensus/bor/snapshot.go index 7ced09c3b8..87e3fb163c 100644 --- a/consensus/bor/snapshot.go +++ b/consensus/bor/snapshot.go @@ -15,8 +15,9 @@ import ( // Snapshot is the state of the authorization voting at a given point in time. type Snapshot struct { - config *params.BorConfig // Consensus engine parameters to fine tune behavior - sigcache *lru.ARCCache // Cache of recent block signatures to speed up ecrecover + chainConfig *params.ChainConfig + + sigcache *lru.ARCCache // Cache of recent block signatures to speed up ecrecover Number uint64 `json:"number"` // Block number where the snapshot was created Hash common.Hash `json:"hash"` // Block hash where the snapshot was created @@ -28,14 +29,14 @@ type Snapshot struct { // method does not initialize the set of recent signers, so only ever use if for // the genesis block. func newSnapshot( - config *params.BorConfig, + chainConfig *params.ChainConfig, sigcache *lru.ARCCache, number uint64, hash common.Hash, validators []*valset.Validator, ) *Snapshot { snap := &Snapshot{ - config: config, + chainConfig: chainConfig, sigcache: sigcache, Number: number, Hash: hash, @@ -47,7 +48,7 @@ func newSnapshot( } // loadSnapshot loads an existing snapshot from the database. -func loadSnapshot(config *params.BorConfig, sigcache *lru.ARCCache, db ethdb.Database, hash common.Hash) (*Snapshot, error) { +func loadSnapshot(chainConfig *params.ChainConfig, config *params.BorConfig, sigcache *lru.ARCCache, db ethdb.Database, hash common.Hash) (*Snapshot, error) { blob, err := db.Get(append([]byte("bor-"), hash[:]...)) if err != nil { return nil, err @@ -61,7 +62,7 @@ func loadSnapshot(config *params.BorConfig, sigcache *lru.ARCCache, db ethdb.Dat snap.ValidatorSet.UpdateValidatorMap() - snap.config = config + snap.chainConfig = chainConfig snap.sigcache = sigcache // update total voting power @@ -85,7 +86,7 @@ func (s *Snapshot) store(db ethdb.Database) error { // copy creates a deep copy of the snapshot, though not the individual votes. func (s *Snapshot) copy() *Snapshot { cpy := &Snapshot{ - config: s.config, + chainConfig: s.chainConfig, sigcache: s.sigcache, Number: s.Number, Hash: s.Hash, @@ -122,12 +123,12 @@ func (s *Snapshot) apply(headers []*types.Header) (*Snapshot, error) { number := header.Number.Uint64() // Delete the oldest signer from the recent list to allow it signing again - if number >= s.config.CalculateSprint(number) { - delete(snap.Recents, number-s.config.CalculateSprint(number)) + if number >= s.chainConfig.Bor.CalculateSprint(number) { + delete(snap.Recents, number-s.chainConfig.Bor.CalculateSprint(number)) } // Resolve the authorization key and check against signers - signer, err := ecrecover(header, s.sigcache, s.config) + signer, err := ecrecover(header, s.sigcache, s.chainConfig.Bor) if err != nil { return nil, err } @@ -145,12 +146,12 @@ func (s *Snapshot) apply(headers []*types.Header) (*Snapshot, error) { snap.Recents[number] = signer // change validator set and change proposer - if number > 0 && (number+1)%s.config.CalculateSprint(number) == 0 { + if number > 0 && (number+1)%s.chainConfig.Bor.CalculateSprint(number) == 0 { if err := validateHeaderExtraField(header.Extra); err != nil { return nil, err } - validatorBytes := header.GetValidatorBytes(s.config) + validatorBytes := header.GetValidatorBytes(s.chainConfig) // get validators from headers and use that for new validator set newVals, _ := valset.ParseValidators(validatorBytes) diff --git a/core/parallel_state_processor.go b/core/parallel_state_processor.go index 2dfff35349..2074c9727b 100644 --- a/core/parallel_state_processor.go +++ b/core/parallel_state_processor.go @@ -288,6 +288,11 @@ func (p *ParallelStateProcessor) Process(block *types.Block, statedb *state.Stat deps := GetDeps(blockTxDependency) + if !VerifyDeps(deps) || len(blockTxDependency) != len(block.Transactions()) { + blockTxDependency = nil + deps = make(map[int][]int) + } + if blockTxDependency != nil { metadata = true } @@ -308,57 +313,30 @@ func (p *ParallelStateProcessor) Process(block *types.Block, statedb *state.Stat shouldDelayFeeCal = false } - if len(blockTxDependency) != len(block.Transactions()) { - task := &ExecutionTask{ - msg: *msg, - config: p.config, - gasLimit: block.GasLimit(), - blockNumber: blockNumber, - blockHash: blockHash, - tx: tx, - index: i, - cleanStateDB: cleansdb, - finalStateDB: statedb, - blockChain: p.bc, - header: header, - evmConfig: cfg, - shouldDelayFeeCal: &shouldDelayFeeCal, - sender: msg.From, - totalUsedGas: usedGas, - receipts: &receipts, - allLogs: &allLogs, - dependencies: deps[i], - coinbase: coinbase, - blockContext: blockContext, - } - - tasks = append(tasks, task) - } else { - task := &ExecutionTask{ - msg: *msg, - config: p.config, - gasLimit: block.GasLimit(), - blockNumber: blockNumber, - blockHash: blockHash, - tx: tx, - index: i, - cleanStateDB: cleansdb, - finalStateDB: statedb, - blockChain: p.bc, - header: header, - evmConfig: cfg, - shouldDelayFeeCal: &shouldDelayFeeCal, - sender: msg.From, - totalUsedGas: usedGas, - receipts: &receipts, - allLogs: &allLogs, - dependencies: nil, - coinbase: coinbase, - blockContext: blockContext, - } - - tasks = append(tasks, task) + task := &ExecutionTask{ + msg: *msg, + config: p.config, + gasLimit: block.GasLimit(), + blockNumber: blockNumber, + blockHash: blockHash, + tx: tx, + index: i, + cleanStateDB: cleansdb, + finalStateDB: statedb, + blockChain: p.bc, + header: header, + evmConfig: cfg, + shouldDelayFeeCal: &shouldDelayFeeCal, + sender: msg.From, + totalUsedGas: usedGas, + receipts: &receipts, + allLogs: &allLogs, + dependencies: deps[i], + coinbase: coinbase, + blockContext: blockContext, } + + tasks = append(tasks, task) } backupStateDB := statedb.Copy() @@ -427,3 +405,21 @@ func GetDeps(txDependency [][]uint64) map[int][]int { return deps } + +// returns true if dependencies are correct +func VerifyDeps(deps map[int][]int) bool { + // number of transactions in the block + n := len(deps) + + // Handle out-of-range and circular dependency problem + for i := 0; i <= n-1; i++ { + val := deps[i] + for _, depTx := range val { + if depTx >= n || depTx >= i { + return false + } + } + } + + return true +} diff --git a/core/parallel_state_processor_test.go b/core/parallel_state_processor_test.go new file mode 100644 index 0000000000..424ea4282a --- /dev/null +++ b/core/parallel_state_processor_test.go @@ -0,0 +1,30 @@ +package core + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestMetadata(t *testing.T) { + t.Parallel() + + correctTxDependency := [][]uint64{{}, {0}, {}, {1}, {3}, {}, {0, 2}, {5}, {}, {8}} + wrongTxDependency := [][]uint64{{0}} + wrongTxDependencyCircular := [][]uint64{{}, {2}, {1}} + wrongTxDependencyOutOfRange := [][]uint64{{}, {}, {3}} + + var temp map[int][]int + + temp = GetDeps(correctTxDependency) + assert.Equal(t, true, VerifyDeps(temp)) + + temp = GetDeps(wrongTxDependency) + assert.Equal(t, false, VerifyDeps(temp)) + + temp = GetDeps(wrongTxDependencyCircular) + assert.Equal(t, false, VerifyDeps(temp)) + + temp = GetDeps(wrongTxDependencyOutOfRange) + assert.Equal(t, false, VerifyDeps(temp)) +} diff --git a/core/types/block.go b/core/types/block.go index 1ffaea554c..1cebb65b24 100644 --- a/core/types/block.go +++ b/core/types/block.go @@ -456,8 +456,8 @@ func (b *Block) GetTxDependency() [][]uint64 { return blockExtraData.TxDependency } -func (h *Header) GetValidatorBytes(config *params.BorConfig) []byte { - if !config.IsParallelUniverse(h.Number) { +func (h *Header) GetValidatorBytes(chainConfig *params.ChainConfig) []byte { + if !chainConfig.IsCancun(h.Number) { return h.Extra[ExtraVanityLength : len(h.Extra)-ExtraSealLength] } diff --git a/core/types/block_test.go b/core/types/block_test.go index 218205e564..a42d578f33 100644 --- a/core/types/block_test.go +++ b/core/types/block_test.go @@ -74,7 +74,6 @@ func TestBlockEncoding(t *testing.T) { } // This is a replica of `(h *Header) GetValidatorBytes` function -// This was needed because currently, `IsParallelUniverse` will always return false. func GetValidatorBytesTest(h *Header) []byte { if len(h.Extra) < ExtraVanityLength+ExtraSealLength { log.Error("length of extra less is than vanity and seal") diff --git a/internal/cli/server/chains/mainnet.go b/internal/cli/server/chains/mainnet.go index b9efd9a4e2..5548f8edba 100644 --- a/internal/cli/server/chains/mainnet.go +++ b/internal/cli/server/chains/mainnet.go @@ -29,10 +29,9 @@ var mainnetBor = &Chain{ LondonBlock: big.NewInt(23850000), ShanghaiBlock: big.NewInt(50523000), Bor: ¶ms.BorConfig{ - JaipurBlock: big.NewInt(23850000), - DelhiBlock: big.NewInt(38189056), - ParallelUniverseBlock: big.NewInt(0), - IndoreBlock: big.NewInt(44934656), + JaipurBlock: big.NewInt(23850000), + DelhiBlock: big.NewInt(38189056), + IndoreBlock: big.NewInt(44934656), StateSyncConfirmationDelay: map[string]uint64{ "44934656": 128, }, diff --git a/internal/cli/server/chains/mumbai.go b/internal/cli/server/chains/mumbai.go index 45f36fbe89..7fe25554c5 100644 --- a/internal/cli/server/chains/mumbai.go +++ b/internal/cli/server/chains/mumbai.go @@ -29,10 +29,9 @@ var mumbaiTestnet = &Chain{ LondonBlock: big.NewInt(22640000), ShanghaiBlock: big.NewInt(41874000), Bor: ¶ms.BorConfig{ - JaipurBlock: big.NewInt(22770000), - DelhiBlock: big.NewInt(29638656), - ParallelUniverseBlock: big.NewInt(0), - IndoreBlock: big.NewInt(37075456), + JaipurBlock: big.NewInt(22770000), + DelhiBlock: big.NewInt(29638656), + IndoreBlock: big.NewInt(37075456), StateSyncConfirmationDelay: map[string]uint64{ "37075456": 128, }, diff --git a/internal/cli/server/chains/test_files/chain_legacy_test.json b/internal/cli/server/chains/test_files/chain_legacy_test.json index a64fbf3e23..c3e9b3c7bf 100644 --- a/internal/cli/server/chains/test_files/chain_legacy_test.json +++ b/internal/cli/server/chains/test_files/chain_legacy_test.json @@ -57,7 +57,6 @@ }, "jaipurBlock": 22770000, "delhiBlock": 29638656, - "parallelUniverseBlock": 0, "indoreBlock": 37075456, "stateSyncConfirmationDelay": { "37075456": 128 diff --git a/internal/cli/server/chains/test_files/chain_test.json b/internal/cli/server/chains/test_files/chain_test.json index ba207bf770..8555833321 100644 --- a/internal/cli/server/chains/test_files/chain_test.json +++ b/internal/cli/server/chains/test_files/chain_test.json @@ -59,7 +59,6 @@ }, "jaipurBlock":22770000, "delhiBlock": 29638656, - "parallelUniverseBlock": 0, "indoreBlock": 37075456, "stateSyncConfirmationDelay": { "37075456": 128 diff --git a/miner/worker.go b/miner/worker.go index 4a92776f56..3573eccfee 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -109,17 +109,22 @@ type environment struct { header *types.Header txs []*types.Transaction receipts []*types.Receipt + + depsMVFullWriteList [][]blockstm.WriteDescriptor + mvReadMapList []map[blockstm.Key]blockstm.ReadDescriptor } // copy creates a deep copy of environment. func (env *environment) copy() *environment { cpy := &environment{ - signer: env.signer, - state: env.state.Copy(), - tcount: env.tcount, - coinbase: env.coinbase, - header: types.CopyHeader(env.header), - receipts: copyReceipts(env.receipts), + signer: env.signer, + state: env.state.Copy(), + tcount: env.tcount, + coinbase: env.coinbase, + header: types.CopyHeader(env.header), + receipts: copyReceipts(env.receipts), + depsMVFullWriteList: env.depsMVFullWriteList, + mvReadMapList: env.mvReadMapList, } if env.gasPool != nil { @@ -854,6 +859,9 @@ func (w *worker) makeEnv(parent *types.Header, header *types.Header, coinbase co // Keep track of transactions which return errors so they can be removed env.tcount = 0 + env.depsMVFullWriteList = [][]blockstm.WriteDescriptor{} + env.mvReadMapList = []map[blockstm.Key]blockstm.ReadDescriptor{} + return env, nil } @@ -903,36 +911,20 @@ func (w *worker) commitTransactions(env *environment, txs *transactionsByPriceAn var coalescedLogs []*types.Log - var depsMVReadList [][]blockstm.ReadDescriptor - - var depsMVFullWriteList [][]blockstm.WriteDescriptor - - var mvReadMapList []map[blockstm.Key]blockstm.ReadDescriptor - var deps map[int]map[int]bool chDeps := make(chan blockstm.TxDep) - var count int - var depsWg sync.WaitGroup - EnableMVHashMap := w.chainConfig.Bor.IsParallelUniverse(env.header.Number) + EnableMVHashMap := w.chainConfig.IsCancun(env.header.Number) // create and add empty mvHashMap in statedb if EnableMVHashMap { - depsMVReadList = [][]blockstm.ReadDescriptor{} - - depsMVFullWriteList = [][]blockstm.WriteDescriptor{} - - mvReadMapList = []map[blockstm.Key]blockstm.ReadDescriptor{} - deps = map[int]map[int]bool{} chDeps = make(chan blockstm.TxDep) - count = 0 - depsWg.Add(1) go func(chDeps chan blockstm.TxDep) { @@ -1064,18 +1056,20 @@ mainloop: env.tcount++ if EnableMVHashMap { - depsMVReadList = append(depsMVReadList, env.state.MVReadList()) - depsMVFullWriteList = append(depsMVFullWriteList, env.state.MVFullWriteList()) - mvReadMapList = append(mvReadMapList, env.state.MVReadMap()) + env.depsMVFullWriteList = append(env.depsMVFullWriteList, env.state.MVFullWriteList()) + env.mvReadMapList = append(env.mvReadMapList, env.state.MVReadMap()) + + if env.tcount > len(env.depsMVFullWriteList) { + log.Warn("blockstm - env.tcount > len(env.depsMVFullWriteList)", "env.tcount", env.tcount, "len(depsMVFullWriteList)", len(env.depsMVFullWriteList)) + } temp := blockstm.TxDep{ Index: env.tcount - 1, - ReadList: depsMVReadList[count], - FullWriteList: depsMVFullWriteList, + ReadList: env.state.MVReadList(), + FullWriteList: env.depsMVFullWriteList, } chDeps <- temp - count++ } txs.Shift() @@ -1107,8 +1101,8 @@ mainloop: tempVanity := env.header.Extra[:types.ExtraVanityLength] tempSeal := env.header.Extra[len(env.header.Extra)-types.ExtraSealLength:] - if len(mvReadMapList) > 0 { - tempDeps := make([][]uint64, len(mvReadMapList)) + if len(env.mvReadMapList) > 0 { + tempDeps := make([][]uint64, len(env.mvReadMapList)) for j := range deps[0] { tempDeps[0] = append(tempDeps[0], uint64(j)) @@ -1116,8 +1110,8 @@ mainloop: delayFlag := true - for i := 1; i <= len(mvReadMapList)-1; i++ { - reads := mvReadMapList[i-1] + for i := 1; i <= len(env.mvReadMapList)-1; i++ { + reads := env.mvReadMapList[i-1] _, ok1 := reads[blockstm.NewSubpathKey(env.coinbase, state.BalancePath)] _, ok2 := reads[blockstm.NewSubpathKey(common.HexToAddress(w.chainConfig.Bor.CalculateBurntContract(env.header.Number.Uint64())), state.BalancePath)] diff --git a/miner/worker_test.go b/miner/worker_test.go index 88f7924b00..57bb26511c 100644 --- a/miner/worker_test.go +++ b/miner/worker_test.go @@ -909,7 +909,7 @@ func BenchmarkBorMining(b *testing.B) { } // uses core.NewParallelBlockChain to use the dependencies present in the block header -// params.BorUnittestChainConfig contains the ParallelUniverseBlock ad big.NewInt(5), so the first 4 blocks will not have metadata. +// params.BorUnittestChainConfig contains the NapoliBlock as big.NewInt(5), so the first 4 blocks will not have metadata. // nolint: gocognit func BenchmarkBorMiningBlockSTMMetadata(b *testing.B) { chainConfig := params.BorUnittestChainConfig diff --git a/params/config.go b/params/config.go index ea00979850..e724a02747 100644 --- a/params/config.go +++ b/params/config.go @@ -159,7 +159,6 @@ var ( BerlinBlock: big.NewInt(0), LondonBlock: big.NewInt(0), Bor: &BorConfig{ - ParallelUniverseBlock: big.NewInt(5), Period: map[string]uint64{ "0": 1, }, @@ -198,10 +197,9 @@ var ( LondonBlock: big.NewInt(22640000), ShanghaiBlock: big.NewInt(41874000), Bor: &BorConfig{ - JaipurBlock: big.NewInt(22770000), - DelhiBlock: big.NewInt(29638656), - ParallelUniverseBlock: big.NewInt(0), - IndoreBlock: big.NewInt(37075456), + JaipurBlock: big.NewInt(22770000), + DelhiBlock: big.NewInt(29638656), + IndoreBlock: big.NewInt(37075456), StateSyncConfirmationDelay: map[string]uint64{ "37075456": 128, }, @@ -264,10 +262,9 @@ var ( LondonBlock: big.NewInt(23850000), ShanghaiBlock: big.NewInt(50523000), Bor: &BorConfig{ - JaipurBlock: big.NewInt(23850000), - DelhiBlock: big.NewInt(38189056), - ParallelUniverseBlock: big.NewInt(0), - IndoreBlock: big.NewInt(44934656), + JaipurBlock: big.NewInt(23850000), + DelhiBlock: big.NewInt(38189056), + IndoreBlock: big.NewInt(44934656), StateSyncConfirmationDelay: map[string]uint64{ "44934656": 128, }, @@ -567,7 +564,6 @@ type BorConfig struct { BurntContract map[string]string `json:"burntContract"` // governance contract where the token will be sent to and burnt in london fork JaipurBlock *big.Int `json:"jaipurBlock"` // Jaipur switch block (nil = no fork, 0 = already on jaipur) DelhiBlock *big.Int `json:"delhiBlock"` // Delhi switch block (nil = no fork, 0 = already on delhi) - ParallelUniverseBlock *big.Int `json:"parallelUniverseBlock"` // TODO: update all occurrence, change name and finalize number (hardfork for block-stm related changes) IndoreBlock *big.Int `json:"indoreBlock"` // Indore switch block (nil = no fork, 0 = already on indore) StateSyncConfirmationDelay map[string]uint64 `json:"stateSyncConfirmationDelay"` // StateSync Confirmation Delay, in seconds, to calculate `to` } @@ -609,16 +605,16 @@ func (c *BorConfig) CalculateStateSyncDelay(number uint64) uint64 { return borKeyValueConfigHelper(c.StateSyncConfirmationDelay, number) } -// TODO: modify this function once the block number is finalized -func (c *BorConfig) IsParallelUniverse(number *big.Int) bool { - if c.ParallelUniverseBlock != nil { - if c.ParallelUniverseBlock.Cmp(big.NewInt(0)) == 0 { - return false - } - } +// // TODO: modify this function once the block number is finalized +// func (c *BorConfig) IsNapoli(number *big.Int) bool { +// if c.NapoliBlock != nil { +// if c.NapoliBlock.Cmp(big.NewInt(0)) == 0 { +// return false +// } +// } - return isBlockForked(c.ParallelUniverseBlock, number) -} +// return isBlockForked(c.NapoliBlock, number) +// } func (c *BorConfig) IsSprintStart(number uint64) bool { return number%c.CalculateSprint(number) == 0 From ce68cb17acab3125036ecc326c9b32bdc0d65657 Mon Sep 17 00:00:00 2001 From: Dimitris Apostolou Date: Thu, 25 Jan 2024 21:44:14 +0200 Subject: [PATCH 31/31] fix typos --- accounts/abi/bind/bind_test.go | 2 +- accounts/keystore/watch.go | 2 +- accounts/scwallet/hub.go | 2 +- build/ci.go | 2 +- consensus/bor/heimdall/client_test.go | 6 +++--- core/blockchain.go | 6 +++--- core/rawdb/bor_receipt.go | 2 +- core/rawdb/database.go | 4 ++-- core/rawdb/databases_64bit.go | 2 +- core/rawdb/freezer_table_test.go | 2 +- core/state/pruner/pruner.go | 2 +- core/state/snapshot/difflayer.go | 2 +- core/state/snapshot/disklayer_test.go | 4 ++-- core/state/sync_test.go | 2 +- core/txpool/blobpool/blobpool.go | 16 ++++++++-------- core/txpool/blobpool/blobpool_test.go | 6 +++--- core/txpool/blobpool/limbo.go | 8 ++++---- core/txpool/blobpool/metrics.go | 2 +- core/txpool/legacypool/legacypool.go | 4 ++-- core/txpool/legacypool/legacypool_test.go | 2 +- core/txpool/subpool.go | 2 +- core/txpool/txpool.go | 2 +- core/txpool/validation.go | 6 +++--- core/types/transaction.go | 2 +- core/types/transaction_signing_test.go | 2 +- core/vm/contracts_test.go | 2 +- core/vm/interpreter.go | 4 ++-- core/vm/jump_table_export.go | 2 +- core/vm/jump_table_test.go | 2 +- core/vm/runtime/runtime_test.go | 2 +- crypto/bls12381/g2.go | 2 +- eth/downloader/downloader.go | 2 +- eth/downloader/resultstore.go | 2 +- eth/downloader/skeleton.go | 2 +- eth/downloader/whitelist/milestone.go | 2 +- eth/downloader/whitelist/service.go | 4 ++-- eth/downloader/whitelist/service_test.go | 8 ++++---- eth/protocols/eth/dispatcher.go | 4 ++-- eth/protocols/eth/peer.go | 2 +- eth/tracers/api_bor.go | 2 +- .../js/internal/tracers/call_tracer_legacy.js | 2 +- eth/tracers/tracers_test.go | 6 +++--- ethclient/gethclient/gethclient_test.go | 2 +- internal/cli/flagset/flagset.go | 2 +- internal/cli/server/command.go | 2 +- internal/flags/helpers.go | 2 +- internal/jsre/deps/web3.js | 18 +++++++++--------- les/utils/timeutils_test.go | 2 +- log/doc.go | 2 +- log/format.go | 2 +- miner/payload_building_test.go | 10 +++++----- miner/worker.go | 2 +- p2p/msgrate/msgrate.go | 2 +- p2p/rlpx/rlpx_test.go | 2 +- p2p/simulations/adapters/inproc.go | 2 +- p2p/simulations/network_test.go | 2 +- rlp/rlpgen/gen.go | 2 +- signer/core/api.go | 2 +- tests/bor/bor_test.go | 10 +++++----- tests/bor/helper.go | 2 +- trie/proof.go | 2 +- trie/sync.go | 2 +- trie/trie_test.go | 2 +- 63 files changed, 108 insertions(+), 108 deletions(-) diff --git a/accounts/abi/bind/bind_test.go b/accounts/abi/bind/bind_test.go index 1289b4c8b1..318247b6cf 100644 --- a/accounts/abi/bind/bind_test.go +++ b/accounts/abi/bind/bind_test.go @@ -1677,7 +1677,7 @@ var bindTests = []struct { } sim.Commit() - // This test the existence of the free retreiver call for view and pure functions + // This test the existence of the free retriever call for view and pure functions if num, err := pav.PureFunc(nil); err != nil { t.Fatalf("Failed to call anonymous field retriever: %v", err) } else if num.Cmp(big.NewInt(42)) != 0 { diff --git a/accounts/keystore/watch.go b/accounts/keystore/watch.go index 11468aaca1..20718e7f77 100644 --- a/accounts/keystore/watch.go +++ b/accounts/keystore/watch.go @@ -130,7 +130,7 @@ func (w *watcher) loop() { return } - log.Info("Filsystem watcher error", "err", err) + log.Info("Filesystem watcher error", "err", err) case <-debounce.C: w.ac.scanAccounts() diff --git a/accounts/scwallet/hub.go b/accounts/scwallet/hub.go index 062a2a770c..c01959371b 100644 --- a/accounts/scwallet/hub.go +++ b/accounts/scwallet/hub.go @@ -256,7 +256,7 @@ func (hub *Hub) refreshWallets() { continue } - // Card connected, start tracking in amongs the wallets + // Card connected, start tracking in amongst the wallets hub.wallets[reader] = wallet events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletArrived}) } diff --git a/build/ci.go b/build/ci.go index 4f39782242..67cdf373ba 100644 --- a/build/ci.go +++ b/build/ci.go @@ -145,7 +145,7 @@ var ( // // This version is fine to be old and full of security holes, we just use it // to build the latest Go. Don't change it. If it ever becomes insufficient, - // we need to switch over to a recursive builder to jumpt across supported + // we need to switch over to a recursive builder to jump across supported // versions. gobootVersion = "1.19.6" ) diff --git a/consensus/bor/heimdall/client_test.go b/consensus/bor/heimdall/client_test.go index 737875028c..0fa7665048 100644 --- a/consensus/bor/heimdall/client_test.go +++ b/consensus/bor/heimdall/client_test.go @@ -256,8 +256,8 @@ func TestFetchShutdown(t *testing.T) { // Expect this to fail due to timeout _, err = client.FetchCheckpoint(ctx, -1) - require.Equal(t, "context deadline exceeded", err.Error(), "expect the function error to be a context deadline exeeded error") - require.Equal(t, "context deadline exceeded", ctx.Err().Error(), "expect the ctx error to be a context deadline exeeded error") + require.Equal(t, "context deadline exceeded", err.Error(), "expect the function error to be a context deadline exceeded error") + require.Equal(t, "context deadline exceeded", ctx.Err().Error(), "expect the ctx error to be a context deadline exceeded error") cancel() @@ -346,7 +346,7 @@ func TestContext(t *testing.T) { select { case <-ctx.Done(): // Expect this to never occur, throw explicit error - errCh <- errors.New("unexpectecd call to `ctx.Done()`") + errCh <- errors.New("unexpected call to `ctx.Done()`") case <-time.After(2 * time.Second): // Case for safely exiting the tests errCh <- nil diff --git a/core/blockchain.go b/core/blockchain.go index b63ab6378c..39b7fb5ec7 100644 --- a/core/blockchain.go +++ b/core/blockchain.go @@ -694,7 +694,7 @@ func (bc *BlockChain) SetHead(head uint64) error { block := bc.GetBlock(header.Hash(), header.Number.Uint64()) if block == nil { - // This should never happen. In practice, previsouly currentBlock + // This should never happen. In practice, previously currentBlock // contained the entire block whereas now only a "marker", so there // is an ever so slight chance for a race we should handle. log.Error("Current block not found in database", "block", header.Number, "hash", header.Hash()) @@ -719,7 +719,7 @@ func (bc *BlockChain) SetHeadWithTimestamp(timestamp uint64) error { block := bc.GetBlock(header.Hash(), header.Number.Uint64()) if block == nil { - // This should never happen. In practice, previsouly currentBlock + // This should never happen. In practice, previously currentBlock // contained the entire block whereas now only a "marker", so there // is an ever so slight chance for a race we should handle. log.Error("Current block not found in database", "block", header.Number, "hash", header.Hash()) @@ -2055,7 +2055,7 @@ func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool) (int, error) // The chain importer is starting and stopping trie prefetchers. If a bad // block or other error is hit however, an early return may not properly // terminate the background threads. This defer ensures that we clean up - // and dangling prefetcher, without defering each and holding on live refs. + // and dangling prefetcher, without deferring each and holding on live refs. if activeState != nil { activeState.StopPrefetcher() } diff --git a/core/rawdb/bor_receipt.go b/core/rawdb/bor_receipt.go index 456000f821..68a436a081 100644 --- a/core/rawdb/bor_receipt.go +++ b/core/rawdb/bor_receipt.go @@ -76,7 +76,7 @@ func ReadRawBorReceipt(db ethdb.Reader, hash common.Hash, number uint64) *types. } // ReadBorReceipt retrieves all the bor block receipts belonging to a block, including -// its correspoinding metadata fields. If it is unable to populate these metadata +// its corresponding metadata fields. If it is unable to populate these metadata // fields then nil is returned. func ReadBorReceipt(db ethdb.Reader, hash common.Hash, number uint64, config *params.ChainConfig) *types.Receipt { if config != nil && config.Bor != nil && config.Bor.Sprint != nil && !config.Bor.IsSprintStart(number) { diff --git a/core/rawdb/database.go b/core/rawdb/database.go index 3aaa6fcf3e..ac88e7eb8e 100644 --- a/core/rawdb/database.go +++ b/core/rawdb/database.go @@ -259,7 +259,7 @@ func NewDatabaseWithFreezer(db ethdb.KeyValueStore, ancient string, namespace st break } } - // We are about to exit on error. Print database metdata beore exiting + // We are about to exit on error. Print database metadata before exiting printChainMetadata(db) return nil, fmt.Errorf("gap in the chain between ancients [0 - #%d] and leveldb [#%d - #%d] ", @@ -669,7 +669,7 @@ func printChainMetadata(db ethdb.KeyValueStore) { fmt.Fprintf(os.Stderr, "\n\n") } -// ReadChainMetadata returns a set of key/value pairs that contains informatin +// ReadChainMetadata returns a set of key/value pairs that contains information // about the database chain status. This can be used for diagnostic purposes // when investigating the state of the node. func ReadChainMetadata(db ethdb.KeyValueStore) [][]string { diff --git a/core/rawdb/databases_64bit.go b/core/rawdb/databases_64bit.go index ae2ba7f2a0..9d7a620d5c 100644 --- a/core/rawdb/databases_64bit.go +++ b/core/rawdb/databases_64bit.go @@ -23,7 +23,7 @@ import ( "github.com/ethereum/go-ethereum/ethdb/pebble" ) -// Pebble is unsuported on 32bit architecture +// Pebble is unsupported on 32bit architecture const PebbleEnabled = true // NewPebbleDBDatabase creates a persistent key-value database without a freezer diff --git a/core/rawdb/freezer_table_test.go b/core/rawdb/freezer_table_test.go index d680b41c29..c5f1e32c80 100644 --- a/core/rawdb/freezer_table_test.go +++ b/core/rawdb/freezer_table_test.go @@ -917,7 +917,7 @@ func getChunk(size int, b int) []byte { } // TODO (?) -// - test that if we remove several head-files, aswell as data last data-file, +// - test that if we remove several head-files, as well as data last data-file, // the index is truncated accordingly // Right now, the freezer would fail on these conditions: // 1. have data files d0, d1, d2, d3 diff --git a/core/state/pruner/pruner.go b/core/state/pruner/pruner.go index 64c4a3a6eb..5a4fb8a1b7 100644 --- a/core/state/pruner/pruner.go +++ b/core/state/pruner/pruner.go @@ -118,7 +118,7 @@ func prune(snaptree *snapshot.Tree, root common.Hash, maindb ethdb.Database, sta // the trie nodes(and codes) belong to the active state will be filtered // out. A very small part of stale tries will also be filtered because of // the false-positive rate of bloom filter. But the assumption is held here - // that the false-positive is low enough(~0.05%). The probablity of the + // that the false-positive is low enough(~0.05%). The probability of the // dangling node is the state root is super low. So the dangling nodes in // theory will never ever be visited again. var ( diff --git a/core/state/snapshot/difflayer.go b/core/state/snapshot/difflayer.go index 2df11a88f7..76fce22d1c 100644 --- a/core/state/snapshot/difflayer.go +++ b/core/state/snapshot/difflayer.go @@ -43,7 +43,7 @@ var ( aggregatorMemoryLimit = uint64(4 * 1024 * 1024) // aggregatorItemLimit is an approximate number of items that will end up - // in the agregator layer before it's flushed out to disk. A plain account + // in the aggregator layer before it's flushed out to disk. A plain account // weighs around 14B (+hash), a storage slot 32B (+hash), a deleted slot // 0B (+hash). Slots are mostly set/unset in lockstep, so that average at // 16B (+hash). All in all, the average entry seems to be 15+32=47B. Use a diff --git a/core/state/snapshot/disklayer_test.go b/core/state/snapshot/disklayer_test.go index 29e7e37a85..79d920eaba 100644 --- a/core/state/snapshot/disklayer_test.go +++ b/core/state/snapshot/disklayer_test.go @@ -141,7 +141,7 @@ func TestDiskMerge(t *testing.T) { // Retrieve all the data through the disk layer and validate it base = snaps.Snapshot(diffRoot) if _, ok := base.(*diskLayer); !ok { - t.Fatalf("update not flattend into the disk layer") + t.Fatalf("update not flattened into the disk layer") } // assertAccount ensures that an account matches the given blob. @@ -374,7 +374,7 @@ func TestDiskPartialMerge(t *testing.T) { // Retrieve all the data through the disk layer and validate it base = snaps.Snapshot(diffRoot) if _, ok := base.(*diskLayer); !ok { - t.Fatalf("test %d: update not flattend into the disk layer", i) + t.Fatalf("test %d: update not flattened into the disk layer", i) } assertAccount(accNoModNoCache, accNoModNoCache[:]) diff --git a/core/state/sync_test.go b/core/state/sync_test.go index d9f7736680..7e4bf9cb3e 100644 --- a/core/state/sync_test.go +++ b/core/state/sync_test.go @@ -229,7 +229,7 @@ func testIterativeStateSync(t *testing.T, count int, commit bool, bypath bool) { stTrie, err := trie.New(id, srcDb.TrieDB()) if err != nil { - t.Fatalf("failed to retriev storage trie for path %x: %v", node.syncPath[1], err) + t.Fatalf("failed to retrieve storage trie for path %x: %v", node.syncPath[1], err) } data, _, err := stTrie.GetNode(node.syncPath[1]) diff --git a/core/txpool/blobpool/blobpool.go b/core/txpool/blobpool/blobpool.go index 8edca18122..d3ada76e82 100644 --- a/core/txpool/blobpool/blobpool.go +++ b/core/txpool/blobpool/blobpool.go @@ -458,7 +458,7 @@ func (p *BlobPool) parseTransaction(id uint64, size uint32, blob []byte) error { item := new(blobTx) if err := rlp.DecodeBytes(blob, item); err != nil { // This path is impossible unless the disk data representation changes - // across restarts. For that ever unprobable case, recover gracefully + // across restarts. For that ever improbable case, recover gracefully // by ignoring this data entry. log.Error("Failed to decode blob pool entry", "id", id, "err", err) return err @@ -468,7 +468,7 @@ func (p *BlobPool) parseTransaction(id uint64, size uint32, blob []byte) error { sender, err := p.signer.Sender(item.Tx) if err != nil { // This path is impossible unless the signature validity changes across - // restarts. For that ever unprobable case, recover gracefully by ignoring + // restarts. For that ever improbable case, recover gracefully by ignoring // this data entry. log.Error("Failed to recover blob tx sender", "id", id, "hash", item.Tx.Hash(), "err", err) return err @@ -708,7 +708,7 @@ func (p *BlobPool) recheck(addr common.Address, inclusions map[common.Hash]uint6 // offload removes a tracked blob transaction from the pool and moves it into the // limbo for tracking until finality. // -// The method may log errors for various unexpcted scenarios but will not return +// The method may log errors for various unexpected scenarios but will not return // any of it since there's no clear error case. Some errors may be due to coding // issues, others caused by signers mining MEV stuff or swapping transactions. In // all cases, the pool needs to continue operating. @@ -735,7 +735,7 @@ func (p *BlobPool) offload(addr common.Address, nonce uint64, id uint64, inclusi } // Reset implements txpool.SubPool, allowing the blob pool's internal state to be -// kept in sync with the main transacion pool's internal state. +// kept in sync with the main transaction pool's internal state. func (p *BlobPool) Reset(oldHead, newHead *types.Header) { waitStart := time.Now() p.lock.Lock() @@ -939,7 +939,7 @@ func (p *BlobPool) reinject(addr common.Address, tx *types.Transaction) { log.Error("Failed to write transaction into storage", "hash", tx.Hash(), "err", err) return } - // Update the indixes and metrics + // Update the indexes and metrics meta := newBlobTxMeta(id, p.store.Size(id), tx) if _, ok := p.index[addr]; !ok { @@ -959,7 +959,7 @@ func (p *BlobPool) reinject(addr common.Address, tx *types.Transaction) { } // SetGasTip implements txpool.SubPool, allowing the blob pool's gas requirements -// to be kept in sync with the main transacion pool's gas requirements. +// to be kept in sync with the main transaction pool's gas requirements. func (p *BlobPool) SetGasTip(tip *big.Int) { p.lock.Lock() defer p.lock.Unlock() @@ -1153,7 +1153,7 @@ func (p *BlobPool) Get(hash common.Hash) *txpool.Transaction { } // Add inserts a set of blob transactions into the pool if they pass validation (both -// consensus validity and pool restictions). +// consensus validity and pool restrictions). func (p *BlobPool) Add(txs []*txpool.Transaction, local bool, sync bool) []error { errs := make([]error, len(txs)) for i, tx := range txs { @@ -1163,7 +1163,7 @@ func (p *BlobPool) Add(txs []*txpool.Transaction, local bool, sync bool) []error } // Add inserts a new blob transaction into the pool if it passes validation (both -// consensus validity and pool restictions). +// consensus validity and pool restrictions). func (p *BlobPool) add(tx *types.Transaction, blobs []kzg4844.Blob, commits []kzg4844.Commitment, proofs []kzg4844.Proof) (err error) { // The blob pool blocks on adding a transaction. This is because blob txs are // only even pulled form the network, so this method will act as the overload diff --git a/core/txpool/blobpool/blobpool_test.go b/core/txpool/blobpool/blobpool_test.go index 33826c7338..9e33eaefef 100644 --- a/core/txpool/blobpool/blobpool_test.go +++ b/core/txpool/blobpool/blobpool_test.go @@ -593,9 +593,9 @@ func TestOpenDrops(t *testing.T) { verifyPoolInternals(t, pool) } -// Tests that transactions loaded from disk are indexed corrently. +// Tests that transactions loaded from disk are indexed correctly. // -// - 1. Transactions must be groupped by sender, sorted by nonce +// - 1. Transactions must be grouped by sender, sorted by nonce // - 2. Eviction thresholds are calculated correctly for the sequences // - 3. Balance usage of an account is totals across all transactions func TestOpenIndex(t *testing.T) { @@ -1208,7 +1208,7 @@ func TestAdd(t *testing.T) { keys[acc], _ = crypto.GenerateKey() addrs[acc] = crypto.PubkeyToAddress(keys[acc].PublicKey) - // Seed the state database with this acocunt + // Seed the state database with this account statedb.AddBalance(addrs[acc], new(big.Int).SetUint64(seed.balance)) statedb.SetNonce(addrs[acc], seed.nonce) diff --git a/core/txpool/blobpool/limbo.go b/core/txpool/blobpool/limbo.go index 4cb5042c2b..e7f49109bf 100644 --- a/core/txpool/blobpool/limbo.go +++ b/core/txpool/blobpool/limbo.go @@ -57,7 +57,7 @@ func newLimbo(datadir string) (*limbo, error) { index: make(map[common.Hash]uint64), groups: make(map[uint64]map[uint64]common.Hash), } - // Index all limboed blobs on disk and delete anything inprocessable + // Index all limboed blobs on disk and delete anything unprocessable var fails []uint64 index := func(id uint64, size uint32, data []byte) { if l.parseBlob(id, data) != nil { @@ -93,7 +93,7 @@ func (l *limbo) parseBlob(id uint64, data []byte) error { item := new(limboBlob) if err := rlp.DecodeBytes(data, item); err != nil { // This path is impossible unless the disk data representation changes - // across restarts. For that ever unprobable case, recover gracefully + // across restarts. For that ever improbable case, recover gracefully // by ignoring this data entry. log.Error("Failed to decode blob limbo entry", "id", id, "err", err) return err @@ -176,7 +176,7 @@ func (l *limbo) pull(tx common.Hash) ([]kzg4844.Blob, []kzg4844.Commitment, []kz // update changes the block number under which a blob transaction is tracked. This // method should be used when a reorg changes a transaction's inclusion block. // -// The method may log errors for various unexpcted scenarios but will not return +// The method may log errors for various unexpected scenarios but will not return // any of it since there's no clear error case. Some errors may be due to coding // issues, others caused by signers mining MEV stuff or swapping transactions. In // all cases, the pool needs to continue operating. @@ -195,7 +195,7 @@ func (l *limbo) update(tx common.Hash, block uint64) { log.Trace("Blob transaction unchanged in limbo", "tx", tx, "block", block) return } - // Retrieve the old blobs from the data store and write tehm back with a new + // Retrieve the old blobs from the data store and write them back with a new // block number. IF anything fails, there's not much to do, go on. item, err := l.getAndDrop(id) if err != nil { diff --git a/core/txpool/blobpool/metrics.go b/core/txpool/blobpool/metrics.go index 070cc5ca47..587804cc61 100644 --- a/core/txpool/blobpool/metrics.go +++ b/core/txpool/blobpool/metrics.go @@ -65,7 +65,7 @@ var ( pooltipGauge = metrics.NewRegisteredGauge("blobpool/pooltip", nil) // addwait/time, resetwait/time and getwait/time track the rough health of - // the pool and wether or not it's capable of keeping up with the load from + // the pool and whether or not it's capable of keeping up with the load from // the network. addwaitHist = metrics.NewRegisteredHistogram("blobpool/addwait", nil, metrics.NewExpDecaySample(1028, 0.015)) addtimeHist = metrics.NewRegisteredHistogram("blobpool/addtime", nil, metrics.NewExpDecaySample(1028, 0.015)) diff --git a/core/txpool/legacypool/legacypool.go b/core/txpool/legacypool/legacypool.go index db4af0ee8d..47cac42eb2 100644 --- a/core/txpool/legacypool/legacypool.go +++ b/core/txpool/legacypool/legacypool.go @@ -419,7 +419,7 @@ func (pool *LegacyPool) Close() error { } // Reset implements txpool.SubPool, allowing the legacy pool's internal state to be -// kept in sync with the main transacion pool's internal state. +// kept in sync with the main transaction pool's internal state. func (pool *LegacyPool) Reset(oldHead, newHead *types.Header) { wait := pool.requestReset(oldHead, newHead) <-wait @@ -914,7 +914,7 @@ func (pool *LegacyPool) promoteTx(addr common.Address, hash common.Hash, tx *typ } // Add enqueues a batch of transactions into the pool if they are valid. Depending -// on the local flag, full pricing contraints will or will not be applied. +// on the local flag, full pricing constraints will or will not be applied. // // If sync is set, the method will block until all internal maintenance related // to the add is finished. Only use this during tests for determinism! diff --git a/core/txpool/legacypool/legacypool_test.go b/core/txpool/legacypool/legacypool_test.go index 27cd244294..ea191b42ca 100644 --- a/core/txpool/legacypool/legacypool_test.go +++ b/core/txpool/legacypool/legacypool_test.go @@ -3778,7 +3778,7 @@ func newTxs(pool *LegacyPool) *types.Transaction { // txCount++ // } else { -// // we don't maximize fulfilment of the block. just fill somehow +// // we don't maximize fulfillment of the block. just fill somehow // return blockGasLimit, txCount // } // } diff --git a/core/txpool/subpool.go b/core/txpool/subpool.go index 70c0918e14..a1dbd57337 100644 --- a/core/txpool/subpool.go +++ b/core/txpool/subpool.go @@ -69,7 +69,7 @@ type AddressReserver func(addr common.Address, reserve bool) error // production, this interface defines the common methods that allow the primary // transaction pool to manage the subpools. type SubPool interface { - // Filter is a selector used to decide whether a transaction whould be added + // Filter is a selector used to decide whether a transaction would be added // to this particular subpool. Filter(tx *types.Transaction) bool diff --git a/core/txpool/txpool.go b/core/txpool/txpool.go index b0e91fee6c..7cf94a3ffc 100644 --- a/core/txpool/txpool.go +++ b/core/txpool/txpool.go @@ -70,7 +70,7 @@ type TxPool struct { reservations map[common.Address]SubPool // Map with the account to pool reservations reserveLock sync.Mutex // Lock protecting the account reservations - subs event.SubscriptionScope // Subscription scope to unscubscribe all on shutdown + subs event.SubscriptionScope // Subscription scope to unsubscribe all on shutdown quit chan chan error // Quit channel to tear down the head updater } diff --git a/core/txpool/validation.go b/core/txpool/validation.go index 7479438e8d..80ca237334 100644 --- a/core/txpool/validation.go +++ b/core/txpool/validation.go @@ -110,7 +110,7 @@ func ValidateTransaction(tx *types.Transaction, blobs []kzg4844.Blob, commits [] } // Ensure blob transactions have valid commitments if tx.Type() == types.BlobTxType { - // Ensure the number of items in the blob transaction and vairous side + // Ensure the number of items in the blob transaction and various side // data match up before doing any expensive validations hashes := tx.BlobHashes() if len(hashes) == 0 { @@ -171,7 +171,7 @@ type ValidationOptionsWithState struct { // be rejected once the number of remaining slots reaches zero. UsedAndLeftSlots func(addr common.Address) (int, int) - // ExistingExpenditure is a mandatory callback to retrieve the cummulative + // ExistingExpenditure is a mandatory callback to retrieve the cumulative // cost of the already pooled transactions to check for overdrafts. ExistingExpenditure func(addr common.Address) *big.Int @@ -226,7 +226,7 @@ func ValidateTransactionWithState(tx *types.Transaction, signer types.Signer, op return fmt.Errorf("%w: balance %v, queued cost %v, tx cost %v, overshot %v", core.ErrInsufficientFunds, balance, spent, cost, new(big.Int).Sub(need, balance)) } // Transaction takes a new nonce value out of the pool. Ensure it doesn't - // overflow the number of permitted transactions from a single accoun + // overflow the number of permitted transactions from a single account // (i.e. max cancellable via out-of-bound transaction). if used, left := opts.UsedAndLeftSlots(from); left <= 0 { return fmt.Errorf("%w: pooled %d txs", ErrAccountLimitExceeded, used) diff --git a/core/types/transaction.go b/core/types/transaction.go index 6f2fa21aa5..91542110aa 100644 --- a/core/types/transaction.go +++ b/core/types/transaction.go @@ -308,7 +308,7 @@ func (tx *Transaction) BlobGas() uint64 { return tx.inner.blobGas() } // BlobGasFeeCap returns the blob gas fee cap per blob gas of the transaction for blob transactions, nil otherwise. func (tx *Transaction) BlobGasFeeCap() *big.Int { return tx.inner.blobGasFeeCap() } -// BlobHashes returns the hases of the blob commitments for blob transactions, nil otherwise. +// BlobHashes returns the hashes of the blob commitments for blob transactions, nil otherwise. func (tx *Transaction) BlobHashes() []common.Hash { return tx.inner.blobHashes() } // Value returns the ether amount of the transaction. diff --git a/core/types/transaction_signing_test.go b/core/types/transaction_signing_test.go index eee933f1b7..4cce32f208 100644 --- a/core/types/transaction_signing_test.go +++ b/core/types/transaction_signing_test.go @@ -43,7 +43,7 @@ func TestEIP155Signing(t *testing.T) { } if from != addr { - t.Errorf("exected from and address to be equal. Got %x want %x", from, addr) + t.Errorf("expected from and address to be equal. Got %x want %x", from, addr) } } diff --git a/core/vm/contracts_test.go b/core/vm/contracts_test.go index 021dfe48eb..b95aea5a68 100644 --- a/core/vm/contracts_test.go +++ b/core/vm/contracts_test.go @@ -233,7 +233,7 @@ func BenchmarkPrecompiledRipeMD(bench *testing.B) { benchmarkPrecompiled("03", t, bench) } -// Benchmarks the sample inputs from the identiy precompile. +// Benchmarks the sample inputs from the identity precompile. func BenchmarkPrecompiledIdentity(bench *testing.B) { t := precompiledTest{ Input: "38d18acb67d25c8bb9942764b62f18e17054f66a817bd4295423adf9ed98873e000000000000000000000000000000000000000000000000000000000000001b38d18acb67d25c8bb9942764b62f18e17054f66a817bd4295423adf9ed98873e789d1dd423d25f0772d2748d60f7e4b81bb14d086eba8e8e8efb6dcff8a4ae02", diff --git a/core/vm/interpreter.go b/core/vm/interpreter.go index e91d80b811..9fab1d73ae 100644 --- a/core/vm/interpreter.go +++ b/core/vm/interpreter.go @@ -242,7 +242,7 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool, i debug = in.evm.Config.Tracer != nil ) // Don't move this deferred function, it's placed before the capturestate-deferred method, - // so that it get's executed _after_: the capturestate needs the stacks before + // so that it gets executed _after_: the capturestate needs the stacks before // they are returned to the pools defer func() { returnStack(stack) @@ -411,7 +411,7 @@ func (in *EVMInterpreter) RunWithDelay(contract *Contract, input []byte, readOnl debug = in.evm.Config.Tracer != nil ) // Don't move this deferrred function, it's placed before the capturestate-deferred method, - // so that it get's executed _after_: the capturestate needs the stacks before + // so that it gets executed _after_: the capturestate needs the stacks before // they are returned to the pools defer func() { returnStack(stack) diff --git a/core/vm/jump_table_export.go b/core/vm/jump_table_export.go index 2ea2e421a9..33e7785206 100644 --- a/core/vm/jump_table_export.go +++ b/core/vm/jump_table_export.go @@ -57,7 +57,7 @@ func LookupInstructionSet(rules params.Rules) (JumpTable, error) { return newFrontierInstructionSet(), nil } -// Stack returns the mininum and maximum stack requirements. +// Stack returns the minimum and maximum stack requirements. func (op *operation) Stack() (int, int) { return op.minStack, op.maxStack } diff --git a/core/vm/jump_table_test.go b/core/vm/jump_table_test.go index 6230032905..9a3574a3f2 100644 --- a/core/vm/jump_table_test.go +++ b/core/vm/jump_table_test.go @@ -22,7 +22,7 @@ import ( "github.com/stretchr/testify/require" ) -// TestJumpTableCopy tests that deep copy is necessery to prevent modify shared jump table +// TestJumpTableCopy tests that deep copy is necessary to prevent modify shared jump table func TestJumpTableCopy(t *testing.T) { t.Parallel() diff --git a/core/vm/runtime/runtime_test.go b/core/vm/runtime/runtime_test.go index 627947c6d4..674e2176fe 100644 --- a/core/vm/runtime/runtime_test.go +++ b/core/vm/runtime/runtime_test.go @@ -703,7 +703,7 @@ func TestColdAccountAccessCost(t *testing.T) { t.Logf("%d: %v %d", ii, op.OpName(), op.GasCost) } - t.Fatalf("tescase %d, gas report wrong, step %d, have %d want %d", i, tc.step, have, want) + t.Fatalf("testcase %d, gas report wrong, step %d, have %d want %d", i, tc.step, have, want) } } } diff --git a/crypto/bls12381/g2.go b/crypto/bls12381/g2.go index c181e821f5..6fe7a77430 100644 --- a/crypto/bls12381/g2.go +++ b/crypto/bls12381/g2.go @@ -27,7 +27,7 @@ import ( // If z is equal to one the point is considered as in affine form. type PointG2 [3]fe2 -// Set copies valeus of one point to another. +// Set copies values of one point to another. func (p *PointG2) Set(p2 *PointG2) *PointG2 { p[0].set(&p2[0]) p[1].set(&p2[1]) diff --git a/eth/downloader/downloader.go b/eth/downloader/downloader.go index f6369f8f4b..785b84cf8a 100644 --- a/eth/downloader/downloader.go +++ b/eth/downloader/downloader.go @@ -621,7 +621,7 @@ func (d *Downloader) syncWithPeer(p *peerConnection, hash common.Hash, td, ttd * // For non-merged networks, if there is a checkpoint available, then calculate // the ancientLimit through that. Otherwise calculate the ancient limit through // the advertised height of the remote peer. This most is mostly a fallback for - // legacy networks, but should eventually be droppped. TODO(karalabe). + // legacy networks, but should eventually be dropped. TODO(karalabe). if beaconMode { // Beacon sync, use the latest finalized block as the ancient limit // or a reasonable height if no finalized block is yet announced. diff --git a/eth/downloader/resultstore.go b/eth/downloader/resultstore.go index a26387905a..f03d88498c 100644 --- a/eth/downloader/resultstore.go +++ b/eth/downloader/resultstore.go @@ -154,7 +154,7 @@ func (r *resultStore) HasCompletedItems() bool { // countCompleted returns the number of items ready for delivery, stopping at // the first non-complete item. // -// The mthod assumes (at least) rlock is held. +// The method assumes (at least) rlock is held. func (r *resultStore) countCompleted() int { // We iterate from the already known complete point, and see // if any more has completed since last count diff --git a/eth/downloader/skeleton.go b/eth/downloader/skeleton.go index d5df9b2b21..86fc51f090 100644 --- a/eth/downloader/skeleton.go +++ b/eth/downloader/skeleton.go @@ -430,7 +430,7 @@ func (s *skeleton) sync(head *types.Header) (*types.Header, error) { for _, peer := range s.peers.AllPeers() { s.idles[peer.id] = peer } - // Nofity any tester listening for startup events + // Notify any tester listening for startup events if s.syncStarting != nil { s.syncStarting() } diff --git a/eth/downloader/whitelist/milestone.go b/eth/downloader/whitelist/milestone.go index d2ea7f7bed..e82b53c08b 100644 --- a/eth/downloader/whitelist/milestone.go +++ b/eth/downloader/whitelist/milestone.go @@ -290,7 +290,7 @@ func (m *milestone) enqueueFutureMilestone(key uint64, hash common.Hash) { return } - log.Debug("Enqueing new future milestone", "endBlockNumber", key, "futureMilestoneHash", hash) + log.Debug("Enqueuing new future milestone", "endBlockNumber", key, "futureMilestoneHash", hash) m.FutureMilestoneList[key] = hash m.FutureMilestoneOrder = append(m.FutureMilestoneOrder, key) diff --git a/eth/downloader/whitelist/service.go b/eth/downloader/whitelist/service.go index 08b92c536e..3c23e4a268 100644 --- a/eth/downloader/whitelist/service.go +++ b/eth/downloader/whitelist/service.go @@ -191,7 +191,7 @@ func isValidChain(currentHeader *types.Header, chain []*types.Header, doExist bo pastChain, _ := splitChain(current, chain) // Iterate over the chain and validate against the last milestone - // It will handle all cases when the incoming chain has atleast one milestone + // It will handle all cases when the incoming chain has at least one milestone for i := len(pastChain) - 1; i >= 0; i-- { if pastChain[i].Number.Uint64() == number { res := pastChain[i].Hash() == hash @@ -205,7 +205,7 @@ func isValidChain(currentHeader *types.Header, chain []*types.Header, doExist bo // FIXME: remoteHeader is not used func isValidPeer(fetchHeadersByNumber func(number uint64, amount int, skip int, reverse bool) ([]*types.Header, []common.Hash, error), doExist bool, number uint64, hash common.Hash) (bool, error) { - // Check for availaibility of the last milestone block. + // Check for availability of the last milestone block. // This can be also be empty if our heimdall is not responding // or we're running without it. if !doExist { diff --git a/eth/downloader/whitelist/service_test.go b/eth/downloader/whitelist/service_test.go index f37af30f0c..aace6ff0e0 100644 --- a/eth/downloader/whitelist/service_test.go +++ b/eth/downloader/whitelist/service_test.go @@ -240,13 +240,13 @@ func TestMilestone(t *testing.T) { require.Equal(t, order[0], uint64(16), "expected number to be 16 but got", order[0]) require.Equal(t, list[order[0]], common.Hash{16}, "expected value is", common.Hash{16}.String()[2:], "but got", list[order[0]]) - capicity := milestone.MaxCapacity - for i := 16; i <= 16*(capicity+1); i = i + 16 { + capacity := milestone.MaxCapacity + for i := 16; i <= 16*(capacity+1); i = i + 16 { s.ProcessFutureMilestone(uint64(i), common.Hash{16}) } - require.Equal(t, len(milestone.FutureMilestoneOrder), capicity, "expected length is", capicity) - require.Equal(t, milestone.FutureMilestoneOrder[capicity-1], uint64(16*capicity), "expected value is", uint64(16*capicity), "but got", milestone.FutureMilestoneOrder[capicity-1]) + require.Equal(t, len(milestone.FutureMilestoneOrder), capacity, "expected length is", capacity) + require.Equal(t, milestone.FutureMilestoneOrder[capacity-1], uint64(16*capacity), "expected value is", uint64(16*capacity), "but got", milestone.FutureMilestoneOrder[capacity-1]) } // TestIsValidPeer checks the IsValidPeer function in isolation diff --git a/eth/protocols/eth/dispatcher.go b/eth/protocols/eth/dispatcher.go index 3c0f36fc08..23fd05157c 100644 --- a/eth/protocols/eth/dispatcher.go +++ b/eth/protocols/eth/dispatcher.go @@ -41,7 +41,7 @@ var ( // Request is a pending request to allow tracking it and delivering a response // back to the requester on their chosen channel. type Request struct { - peer *Peer // Peer to which this request belogs for untracking + peer *Peer // Peer to which this request belongs for untracking id uint64 // Request ID to match up replies to sink chan *Response // Channel to deliver the response on @@ -228,7 +228,7 @@ func (p *Peer) dispatcher() { switch { case res.Req == nil: // Response arrived with an untracked ID. Since even cancelled - // requests are tracked until fulfilment, a dangling response + // requests are tracked until fulfillment, a dangling response // means the remote peer implements the protocol badly. resOp.fail <- errDanglingResponse diff --git a/eth/protocols/eth/peer.go b/eth/protocols/eth/peer.go index 219f486c8e..45236fea8e 100644 --- a/eth/protocols/eth/peer.go +++ b/eth/protocols/eth/peer.go @@ -84,7 +84,7 @@ type Peer struct { txBroadcast chan []common.Hash // Channel used to queue transaction propagation requests txAnnounce chan []common.Hash // Channel used to queue transaction announcement requests - reqDispatch chan *request // Dispatch channel to send requests and track then until fulfilment + reqDispatch chan *request // Dispatch channel to send requests and track then until fulfillment reqCancel chan *cancel // Dispatch channel to cancel pending requests and untrack them resDispatch chan *response // Dispatch channel to fulfil pending requests and untrack them diff --git a/eth/tracers/api_bor.go b/eth/tracers/api_bor.go index 565148c384..3172784b15 100644 --- a/eth/tracers/api_bor.go +++ b/eth/tracers/api_bor.go @@ -140,7 +140,7 @@ type TraceBlockRequest struct { Config *TraceConfig } -// If you use context as first parameter this function gets exposed automaticall on rpc endpoint +// If you use context as first parameter this function gets exposed automatically on rpc endpoint func (api *API) TraceBorBlock(req *TraceBlockRequest) (*BlockTraceResult, error) { ctx := context.Background() diff --git a/eth/tracers/js/internal/tracers/call_tracer_legacy.js b/eth/tracers/js/internal/tracers/call_tracer_legacy.js index 451a644b91..0760bb1e3f 100644 --- a/eth/tracers/js/internal/tracers/call_tracer_legacy.js +++ b/eth/tracers/js/internal/tracers/call_tracer_legacy.js @@ -219,7 +219,7 @@ return this.finalize(result); }, - // finalize recreates a call object using the final desired field oder for json + // finalize recreates a call object using the final desired field order for json // serialization. This is a nicety feature to pass meaningfully ordered results // to users who don't interpret it, just display it. finalize: function(call) { diff --git a/eth/tracers/tracers_test.go b/eth/tracers/tracers_test.go index 5990b40e8b..4d661c15be 100644 --- a/eth/tracers/tracers_test.go +++ b/eth/tracers/tracers_test.go @@ -133,9 +133,9 @@ func TestMemCopying(t *testing.T) { {0, 100, 0, "", 0}, // No need to pad (0 size) {100, 50, 100, "", 100}, // Should pad 100-150 {100, 50, 5, "", 5}, // Wanted range fully within memory - {100, -50, 0, "offset or size must not be negative", 0}, // Errror - {0, 1, 1024*1024 + 1, "reached limit for padding memory slice: 1048578", 0}, // Errror - {10, 0, 1024*1024 + 100, "reached limit for padding memory slice: 1048666", 0}, // Errror + {100, -50, 0, "offset or size must not be negative", 0}, // Error + {0, 1, 1024*1024 + 1, "reached limit for padding memory slice: 1048578", 0}, // Error + {10, 0, 1024*1024 + 100, "reached limit for padding memory slice: 1048666", 0}, // Error } { mem := vm.NewMemory() diff --git a/ethclient/gethclient/gethclient_test.go b/ethclient/gethclient/gethclient_test.go index d06ef8e055..9b459c7503 100644 --- a/ethclient/gethclient/gethclient_test.go +++ b/ethclient/gethclient/gethclient_test.go @@ -452,7 +452,7 @@ func TestOverrideAccountMarshal(t *testing.T) { om := map[common.Address]OverrideAccount{ {0x11}: { - // Zero-valued nonce is not overriddden, but simply dropped by the encoder. + // Zero-valued nonce is not overridden, but simply dropped by the encoder. Nonce: 0, }, {0xaa}: { diff --git a/internal/cli/flagset/flagset.go b/internal/cli/flagset/flagset.go index 85a846a40b..6443d4f8b7 100644 --- a/internal/cli/flagset/flagset.go +++ b/internal/cli/flagset/flagset.go @@ -368,7 +368,7 @@ func (i *SliceStringFlag) String() string { } func (i *SliceStringFlag) Set(value string) error { - // overwritting insted of appending + // overwriting instead of appending *i.Value = SplitAndTrim(value) return nil } diff --git a/internal/cli/server/command.go b/internal/cli/server/command.go index 817c09b670..5170acab77 100644 --- a/internal/cli/server/command.go +++ b/internal/cli/server/command.go @@ -94,7 +94,7 @@ func (c *Command) extractFlags(args []string) error { log.Warn("Config set via config file will be overridden by cli flags") - // Initialse a flagset based on the config created above + // Initialise a flagset based on the config created above flags := c.Flags(cfg) // Check for explicit cli args diff --git a/internal/flags/helpers.go b/internal/flags/helpers.go index 21689840f0..10765f932b 100644 --- a/internal/flags/helpers.go +++ b/internal/flags/helpers.go @@ -113,7 +113,7 @@ func doMigrateFlags(ctx *cli.Context) { for _, parent := range ctx.Lineage()[1:] { if parent.IsSet(name) { // When iterating across the lineage, we will be served both - // the 'canon' and alias formats of all commmands. In most cases, + // the 'canon' and alias formats of all commands. In most cases, // it's fine to set it in the ctx multiple times (one for each // name), however, the Slice-flags are not fine. // The slice-flags accumulate, so if we set it once as diff --git a/internal/jsre/deps/web3.js b/internal/jsre/deps/web3.js index a8ca37cec5..70bd4b1508 100644 --- a/internal/jsre/deps/web3.js +++ b/internal/jsre/deps/web3.js @@ -2031,7 +2031,7 @@ var fromAscii = function(str) { * * @method transformToFullName * @param {Object} json-abi - * @return {String} full fnction/event name + * @return {String} full function/event name */ var transformToFullName = function (json) { if (json.name.indexOf('(') !== -1) { @@ -2089,7 +2089,7 @@ var fromDecimal = function (value) { /** * Auto converts any given value into it's hex representation. * - * And even stringifys objects before. + * And even stringifies objects before. * * @method toHex * @param {String|Number|BigNumber|Object} @@ -2361,7 +2361,7 @@ var isFunction = function (object) { }; /** - * Returns true if object is Objet, otherwise false + * Returns true if object is Object, otherwise false * * @method isObject * @param {Object} @@ -2757,7 +2757,7 @@ var Batch = function (web3) { * Should be called to add create new request to batch request * * @method add - * @param {Object} jsonrpc requet object + * @param {Object} jsonrpc request object */ Batch.prototype.add = function (request) { this.requests.push(request); @@ -4557,7 +4557,7 @@ Iban.createIndirect = function (options) { }; /** - * Thos method should be used to check if given string is valid iban object + * This method should be used to check if given string is valid iban object * * @method isValid * @param {String} iban string @@ -6721,7 +6721,7 @@ var exchangeAbi = require('../contracts/SmartExchange.json'); * @method transfer * @param {String} from * @param {String} to iban - * @param {Value} value to be tranfered + * @param {Value} value to be transferred * @param {Function} callback, callback */ var transfer = function (eth, from, to, value, callback) { @@ -6751,7 +6751,7 @@ var transfer = function (eth, from, to, value, callback) { * @method transferToAddress * @param {String} from * @param {String} to - * @param {Value} value to be tranfered + * @param {Value} value to be transferred * @param {Function} callback, callback */ var transferToAddress = function (eth, from, to, value, callback) { @@ -7105,7 +7105,7 @@ module.exports = transfer; /** * Initializes a newly created cipher. * - * @param {number} xformMode Either the encryption or decryption transormation mode constant. + * @param {number} xformMode Either the encryption or decryption transformation mode constant. * @param {WordArray} key The key. * @param {Object} cfg (Optional) The configuration options to use for this operation. * @@ -9459,7 +9459,7 @@ module.exports = transfer; var M_offset_14 = M[offset + 14]; var M_offset_15 = M[offset + 15]; - // Working varialbes + // Working variables var a = H[0]; var b = H[1]; var c = H[2]; diff --git a/les/utils/timeutils_test.go b/les/utils/timeutils_test.go index b219d0439d..165f37352e 100644 --- a/les/utils/timeutils_test.go +++ b/les/utils/timeutils_test.go @@ -42,6 +42,6 @@ func TestUpdateTimer(t *testing.T) { } timer = NewUpdateTimer(sim, 0) if updated := timer.Update(func(diff time.Duration) bool { return true }); !updated { - t.Fatalf("Doesn't update the clock without threshold limitaion") + t.Fatalf("Doesn't update the clock without threshold limitation") } } diff --git a/log/doc.go b/log/doc.go index d2e15140e4..f533364d0f 100644 --- a/log/doc.go +++ b/log/doc.go @@ -195,7 +195,7 @@ on log level. # Error Handling -Becasuse log15 allows you to step around the type system, there are a few ways you can specify +Because log15 allows you to step around the type system, there are a few ways you can specify invalid arguments to the logging functions. You could, for example, wrap something that is not a zero-argument function with log.Lazy or pass a context key that is not a string. Since logging libraries are typically the mechanism by which errors are reported, it would be onerous for the logging functions diff --git a/log/format.go b/log/format.go index 6a03013b81..8d72d8ce09 100644 --- a/log/format.go +++ b/log/format.go @@ -39,7 +39,7 @@ func PrintOrigins(print bool) { // should append the log locations too when printing entries. var locationEnabled atomic.Bool -// locationLength is the maxmimum path length encountered, which all logs are +// locationLength is the maximum path length encountered, which all logs are // padded to to aid in alignment. var locationLength atomic.Uint32 diff --git a/miner/payload_building_test.go b/miner/payload_building_test.go index 02f1008f4c..c2d9262de2 100644 --- a/miner/payload_building_test.go +++ b/miner/payload_building_test.go @@ -56,23 +56,23 @@ func TestBuildPayload(t *testing.T) { verify := func(outer *engine.ExecutionPayloadEnvelope, txs int) { payload := outer.ExecutionPayload if payload.ParentHash != b.chain.CurrentBlock().Hash() { - t.Fatal("Unexpect parent hash") + t.Fatal("Unexpected parent hash") } if payload.Random != (common.Hash{}) { - t.Fatal("Unexpect random value") + t.Fatal("Unexpected random value") } if payload.Timestamp != timestamp { - t.Fatal("Unexpect timestamp") + t.Fatal("Unexpected timestamp") } if payload.FeeRecipient != recipient { - t.Fatal("Unexpect fee recipient") + t.Fatal("Unexpected fee recipient") } if len(payload.Transactions) != txs { - t.Fatal("Unexpect transaction set") + t.Fatal("Unexpected transaction set") } } empty := payload.ResolveEmpty() diff --git a/miner/worker.go b/miner/worker.go index 3573eccfee..af7534a479 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -1174,7 +1174,7 @@ mainloop: // generateParams wraps various of settings for generating sealing task. type generateParams struct { - timestamp uint64 // The timstamp for sealing task + timestamp uint64 // The timestamp for sealing task forceTime bool // Flag whether the given timestamp is immutable or not parentHash common.Hash // Parent block hash, empty means the latest chain head coinbase common.Address // The fee recipient address for including transaction diff --git a/p2p/msgrate/msgrate.go b/p2p/msgrate/msgrate.go index 36a6cbb213..e1be1e227c 100644 --- a/p2p/msgrate/msgrate.go +++ b/p2p/msgrate/msgrate.go @@ -80,7 +80,7 @@ const ttlLimit = time.Minute // tuningConfidenceCap is the number of active peers above which to stop detuning // the confidence number. The idea here is that once we hone in on the capacity -// of a meaningful number of peers, adding one more should ot have a significant +// of a meaningful number of peers, adding one more should not have a significant // impact on things, so just ron with the originals. const tuningConfidenceCap = 10 diff --git a/p2p/rlpx/rlpx_test.go b/p2p/rlpx/rlpx_test.go index 46ae3eba21..955215eb5c 100644 --- a/p2p/rlpx/rlpx_test.go +++ b/p2p/rlpx/rlpx_test.go @@ -450,7 +450,7 @@ func BenchmarkThroughput(b *testing.B) { conn2.SetSnappy(true) if err := <-handshakeDone; err != nil { - b.Fatal("server hanshake error:", err) + b.Fatal("server handshake error:", err) } // Read N messages. diff --git a/p2p/simulations/adapters/inproc.go b/p2p/simulations/adapters/inproc.go index e8d2d1a886..79faf0ba75 100644 --- a/p2p/simulations/adapters/inproc.go +++ b/p2p/simulations/adapters/inproc.go @@ -177,7 +177,7 @@ type SimNode struct { registerOnce sync.Once } -// Close closes the underlaying node.Node to release +// Close closes the underlying node.Node to release // acquired resources. func (sn *SimNode) Close() error { return sn.node.Close() diff --git a/p2p/simulations/network_test.go b/p2p/simulations/network_test.go index 2eaa0e452a..232d356250 100644 --- a/p2p/simulations/network_test.go +++ b/p2p/simulations/network_test.go @@ -740,7 +740,7 @@ func triggerChecks(ctx context.Context, ids []enode.ID, trigger chan enode.ID, i } } -// \todo: refactor to implement shapshots +// \todo: refactor to implement snapshots // and connect configuration methods once these are moved from // swarm/network/simulations/connect.go func BenchmarkMinimalService(b *testing.B) { diff --git a/rlp/rlpgen/gen.go b/rlp/rlpgen/gen.go index e0bdc75bb5..ce427f601b 100644 --- a/rlp/rlpgen/gen.go +++ b/rlp/rlpgen/gen.go @@ -166,7 +166,7 @@ type op interface { // basicOp handles basic types bool, uint*, string. type basicOp struct { typ types.Type - writeMethod string // calle write the value + writeMethod string // calls write value writeArgType types.Type // parameter type of writeMethod decMethod string decResultType types.Type // return type of decMethod diff --git a/signer/core/api.go b/signer/core/api.go index cd505c720a..0691e98a58 100644 --- a/signer/core/api.go +++ b/signer/core/api.go @@ -692,7 +692,7 @@ func (api *SignerAPI) SignGnosisSafeTx(ctx context.Context, signerAddress common } typedData := gnosisTx.ToTypedData() - // might aswell error early. + // might as well error early. // we are expected to sign. If our calculated hash does not match what they want, // The gnosis safetx input contains a 'safeTxHash' which is the expected safeTxHash that sighash, _, err := apitypes.TypedDataAndHash(typedData) diff --git a/tests/bor/bor_test.go b/tests/bor/bor_test.go index 07c9ecc5dc..ec389a30ca 100644 --- a/tests/bor/bor_test.go +++ b/tests/bor/bor_test.go @@ -298,7 +298,7 @@ func TestForkWithBlockTime(t *testing.T) { // Iterate over all the nodes and start mining for _, node := range nodes { if err := node.StartMining(); err != nil { - t.Fatal("Error occured while starting miner", "node", node, "error", err) + t.Fatal("Error occurred while starting miner", "node", node, "error", err) } } var wg sync.WaitGroup @@ -332,22 +332,22 @@ func TestForkWithBlockTime(t *testing.T) { author0, err := nodes[0].Engine().Author(blockHeaderVal0) if err != nil { - t.Error("Error occured while fetching author", "err", err) + t.Error("Error occurred while fetching author", "err", err) } author1, err := nodes[1].Engine().Author(blockHeaderVal1) if err != nil { - t.Error("Error occured while fetching author", "err", err) + t.Error("Error occurred while fetching author", "err", err) } assert.Equal(t, author0, author1) // After the end of sprint author2, err := nodes[0].Engine().Author(blockHeaders[0]) if err != nil { - t.Error("Error occured while fetching author", "err", err) + t.Error("Error occurred while fetching author", "err", err) } author3, err := nodes[1].Engine().Author(blockHeaders[1]) if err != nil { - t.Error("Error occured while fetching author", "err", err) + t.Error("Error occurred while fetching author", "err", err) } if test.forkExpected { diff --git a/tests/bor/helper.go b/tests/bor/helper.go index cc17dc9647..2d3dd030e5 100644 --- a/tests/bor/helper.go +++ b/tests/bor/helper.go @@ -91,7 +91,7 @@ func setupMiner(t *testing.T, n int, genesis *core.Genesis) ([]*node.Node, []*et // Start the node and wait until it's up stack, ethBackend, err := InitMiner(genesis, keys[i], true) if err != nil { - t.Fatal("Error occured while initialising miner", "error", err) + t.Fatal("Error occurred while initialising miner", "error", err) } for stack.Server().NodeInfo().Ports.Listener == 0 { diff --git a/trie/proof.go b/trie/proof.go index 55edb54669..0a0e9257d5 100644 --- a/trie/proof.go +++ b/trie/proof.go @@ -428,7 +428,7 @@ func unset(parent node, child node, key []byte, pos int, removeLeft bool) error } else { if bytes.Compare(cld.Key, key[pos:]) > 0 { // The key of fork shortnode is greater than the - // path(it belongs to the range), unset the entrie + // path(it belongs to the range), unset the entire // branch. The parent must be a fullnode. fn := parent.(*fullNode) fn.Children[key[pos-1]] = nil diff --git a/trie/sync.go b/trie/sync.go index 48918908bb..fa3f94ec6d 100644 --- a/trie/sync.go +++ b/trie/sync.go @@ -302,7 +302,7 @@ func (s *Sync) Missing(max int) ([]string, []common.Hash, []common.Hash) { } // ProcessCode injects the received data for requested item. Note it can -// happpen that the single response commits two pending requests(e.g. +// happen that the single response commits two pending requests(e.g. // there are two requests one for code and one for node but the hash // is same). In this case the second response for the same hash will // be treated as "non-requested" item or "already-processed" item but diff --git a/trie/trie_test.go b/trie/trie_test.go index a4a7ed17a4..9eaf4676c5 100644 --- a/trie/trie_test.go +++ b/trie/trie_test.go @@ -349,7 +349,7 @@ func TestLargeValue(t *testing.T) { trie.Hash() } -// TestRandomCases tests som cases that were found via random fuzzing +// TestRandomCases tests some cases that were found via random fuzzing func TestRandomCases(t *testing.T) { var rt = []randTestStep{ {op: 6, key: common.Hex2Bytes(""), value: common.Hex2Bytes("")}, // step 0