From d2e12f471764fedb1846c7956a4ad689181d8655 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Thu, 12 Dec 2024 00:15:06 +0000 Subject: [PATCH 01/15] build(deps): bump golang.org/x/crypto from 0.24.0 to 0.31.0 Bumps [golang.org/x/crypto](https://github.com/golang/crypto) from 0.24.0 to 0.31.0. - [Commits](https://github.com/golang/crypto/compare/v0.24.0...v0.31.0) --- updated-dependencies: - dependency-name: golang.org/x/crypto dependency-type: direct:production ... Signed-off-by: dependabot[bot] --- go.mod | 8 ++++---- go.sum | 16 ++++++++-------- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/go.mod b/go.mod index ca25d7c9a2..f405138155 100644 --- a/go.mod +++ b/go.mod @@ -93,11 +93,11 @@ require ( go.opentelemetry.io/otel/sdk v1.27.0 go.uber.org/automaxprocs v1.5.3 go.uber.org/goleak v1.3.0 - golang.org/x/crypto v0.24.0 + golang.org/x/crypto v0.31.0 golang.org/x/exp v0.0.0-20240604190554-fc45aab8b7f8 - golang.org/x/sync v0.7.0 - golang.org/x/sys v0.21.0 - golang.org/x/text v0.16.0 + golang.org/x/sync v0.10.0 + golang.org/x/sys v0.28.0 + golang.org/x/text v0.21.0 golang.org/x/time v0.5.0 golang.org/x/tools v0.22.0 google.golang.org/grpc v1.64.1 diff --git a/go.sum b/go.sum index e934a04b80..b3761461a5 100644 --- a/go.sum +++ b/go.sum @@ -2386,8 +2386,8 @@ golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg= golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU= golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs= -golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI= -golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM= +golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U= +golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk= golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= @@ -2617,8 +2617,8 @@ golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.2.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y= golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= -golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M= -golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ= +golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -2759,8 +2759,8 @@ golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws= -golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA= +golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/telemetry v0.0.0-20240208230135-b75ee8823808/go.mod h1:KG1lNk5ZFNssSZLrpVb4sMXKMpGwGXOxSG3rnu2gZQQ= golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE= golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= @@ -2804,8 +2804,8 @@ golang.org/x/text v0.11.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= -golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4= -golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI= +golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo= +golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= From 75ef2a29fead5026cfb94f116e1f0a4f6004ba3c Mon Sep 17 00:00:00 2001 From: Jerry Date: Thu, 2 Jan 2025 08:09:34 -0800 Subject: [PATCH 02/15] Bump version to v1.5.4-beta --- params/version.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/params/version.go b/params/version.go index 3bd5d0572a..fba60aabb2 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 = 5 // Minor version component of the current release - VersionPatch = 3 // 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 = 5 // Minor version component of the current release + VersionPatch = 4 // Patch version component of the current release + VersionMeta = "beta" // Version metadata to append to the version string ) var GitCommit string From 230be40ae206cf27c0b62d0aff3d4fa2a3ff8136 Mon Sep 17 00:00:00 2001 From: Jerry Date: Thu, 9 Jan 2025 23:06:16 -0800 Subject: [PATCH 03/15] Bump default value of txpool global slots Increase the default value in order to reduce the time spent in txpool reorg. When txpool is saturated, txpool reorg can take more than a few seconds to run. This impacts block producer because the producer would need to get the pending txns from txpool, which is blocked by reorg. --- builder/files/config.toml | 6 +++--- docs/cli/server.md | 14 +++++++------- internal/cli/server/config.go | 6 +++--- internal/cli/server/testdata/default.toml | 6 +++--- packaging/templates/mainnet-v1/archive/config.toml | 6 +++--- .../mainnet-v1/sentry/sentry/bor/config.toml | 6 +++--- .../mainnet-v1/sentry/sentry/bor/pbss_config.toml | 6 +++--- .../mainnet-v1/sentry/validator/bor/config.toml | 6 +++--- .../sentry/validator/bor/pbss_config.toml | 6 +++--- .../mainnet-v1/without-sentry/bor/config.toml | 6 +++--- .../mainnet-v1/without-sentry/bor/pbss_config.toml | 6 +++--- 11 files changed, 37 insertions(+), 37 deletions(-) diff --git a/builder/files/config.toml b/builder/files/config.toml index df34031979..d35c46c0b6 100644 --- a/builder/files/config.toml +++ b/builder/files/config.toml @@ -58,9 +58,9 @@ syncmode = "full" nolocals = true pricelimit = 25000000000 accountslots = 16 - globalslots = 32768 - accountqueue = 16 - globalqueue = 32768 + globalslots = 131072 + accountqueue = 64 + globalqueue = 131072 lifetime = "1h30m0s" # locals = [] # journal = "" diff --git a/docs/cli/server.md b/docs/cli/server.md index 243e83406d..aae0c19a8e 100644 --- a/docs/cli/server.md +++ b/docs/cli/server.md @@ -40,7 +40,7 @@ The ```bor server``` command runs the Bor client. - ```eth.requiredblocks```: Comma separated block number-to-hash mappings to require for peering (=) -- ```ethstats```: Reporting URL of an ethstats service (nodename:secret@host:port) +- ```ethstats```: Reporting URL of a ethstats service (nodename:secret@host:port) - ```gcmode```: Blockchain garbage collection mode ("full", "archive") (default: full) @@ -148,7 +148,7 @@ The ```bor server``` command runs the Bor client. - ```graphql```: Enable GraphQL on the HTTP-RPC server. Note that GraphQL can only be started if an HTTP server is started as well. (default: false) -- ```graphql.corsdomain```: Comma separated list of domains from which to accept cross-origin requests (browser enforced) (default: localhost) +- ```graphql.corsdomain```: Comma separated list of domains from which to accept cross origin requests (browser enforced) (default: localhost) - ```graphql.vhosts```: Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard. (default: localhost) @@ -158,7 +158,7 @@ The ```bor server``` command runs the Bor client. - ```http.api```: API's offered over the HTTP-RPC interface (default: eth,net,web3,txpool,bor) -- ```http.corsdomain```: Comma separated list of domains from which to accept cross-origin requests (browser enforced) (default: localhost) +- ```http.corsdomain```: Comma separated list of domains from which to accept cross origin requests (browser enforced) (default: localhost) - ```http.ep-requesttimeout```: Request Timeout for rpc execution pool for HTTP requests (default: 0s) @@ -290,13 +290,13 @@ The ```bor server``` command runs the Bor client. ### Transaction Pool Options -- ```txpool.accountqueue```: Maximum number of non-executable transaction slots permitted per account (default: 16) +- ```txpool.accountqueue```: Maximum number of non-executable transaction slots permitted per account (default: 64) - ```txpool.accountslots```: Minimum number of executable transaction slots guaranteed per account (default: 16) -- ```txpool.globalqueue```: Maximum number of non-executable transaction slots for all accounts (default: 32768) +- ```txpool.globalqueue```: Maximum number of non-executable transaction slots for all accounts (default: 131072) -- ```txpool.globalslots```: Maximum number of executable transaction slots for all accounts (default: 32768) +- ```txpool.globalslots```: Maximum number of executable transaction slots for all accounts (default: 131072) - ```txpool.journal```: Disk journal for local transaction to survive node restarts (default: transactions.rlp) @@ -310,4 +310,4 @@ The ```bor server``` command runs the Bor client. - ```txpool.pricelimit```: Minimum gas price limit to enforce for acceptance into the pool (default: 25000000000) -- ```txpool.rejournal```: Time interval to regenerate the local transaction journal (default: 1h0m0s) +- ```txpool.rejournal```: Time interval to regenerate the local transaction journal (default: 1h0m0s) \ No newline at end of file diff --git a/internal/cli/server/config.go b/internal/cli/server/config.go index 5960fdeab0..89078b30e4 100644 --- a/internal/cli/server/config.go +++ b/internal/cli/server/config.go @@ -658,9 +658,9 @@ func DefaultConfig() *Config { PriceLimit: params.BorDefaultTxPoolPriceLimit, // bor's default PriceBump: 10, AccountSlots: 16, - GlobalSlots: 32768, - AccountQueue: 16, - GlobalQueue: 32768, + GlobalSlots: 131072, + AccountQueue: 64, + GlobalQueue: 131072, LifeTime: 3 * time.Hour, }, Sealer: &SealerConfig{ diff --git a/internal/cli/server/testdata/default.toml b/internal/cli/server/testdata/default.toml index 0df37d610c..fcf2121270 100644 --- a/internal/cli/server/testdata/default.toml +++ b/internal/cli/server/testdata/default.toml @@ -61,9 +61,9 @@ devfakeauthor = false pricelimit = 25000000000 pricebump = 10 accountslots = 16 - globalslots = 32768 - accountqueue = 16 - globalqueue = 32768 + globalslots = 131072 + accountqueue = 64 + globalqueue = 131072 lifetime = "3h0m0s" [miner] diff --git a/packaging/templates/mainnet-v1/archive/config.toml b/packaging/templates/mainnet-v1/archive/config.toml index a62dda85b1..77699dae04 100644 --- a/packaging/templates/mainnet-v1/archive/config.toml +++ b/packaging/templates/mainnet-v1/archive/config.toml @@ -53,9 +53,9 @@ gcmode = "archive" nolocals = true pricelimit = 25000000000 accountslots = 16 - globalslots = 32768 - accountqueue = 16 - globalqueue = 32768 + globalslots = 131072 + accountqueue = 64 + globalqueue = 131072 lifetime = "1h30m0s" # locals = [] # journal = "" diff --git a/packaging/templates/mainnet-v1/sentry/sentry/bor/config.toml b/packaging/templates/mainnet-v1/sentry/sentry/bor/config.toml index 0ee56f339c..9148973338 100644 --- a/packaging/templates/mainnet-v1/sentry/sentry/bor/config.toml +++ b/packaging/templates/mainnet-v1/sentry/sentry/bor/config.toml @@ -53,9 +53,9 @@ syncmode = "full" nolocals = true pricelimit = 25000000000 accountslots = 16 - globalslots = 32768 - accountqueue = 16 - globalqueue = 32768 + globalslots = 131072 + accountqueue = 64 + globalqueue = 131072 lifetime = "1h30m0s" # locals = [] # journal = "" diff --git a/packaging/templates/mainnet-v1/sentry/sentry/bor/pbss_config.toml b/packaging/templates/mainnet-v1/sentry/sentry/bor/pbss_config.toml index 3d1d06400e..7a11e6a7d2 100644 --- a/packaging/templates/mainnet-v1/sentry/sentry/bor/pbss_config.toml +++ b/packaging/templates/mainnet-v1/sentry/sentry/bor/pbss_config.toml @@ -55,9 +55,9 @@ syncmode = "full" nolocals = true pricelimit = 25000000000 accountslots = 16 - globalslots = 32768 - accountqueue = 16 - globalqueue = 32768 + globalslots = 131072 + accountqueue = 64 + globalqueue = 131072 lifetime = "1h30m0s" # locals = [] # journal = "" diff --git a/packaging/templates/mainnet-v1/sentry/validator/bor/config.toml b/packaging/templates/mainnet-v1/sentry/validator/bor/config.toml index bcf19bbcbe..9ab0802d46 100644 --- a/packaging/templates/mainnet-v1/sentry/validator/bor/config.toml +++ b/packaging/templates/mainnet-v1/sentry/validator/bor/config.toml @@ -55,9 +55,9 @@ syncmode = "full" nolocals = true pricelimit = 25000000000 accountslots = 16 - globalslots = 32768 - accountqueue = 16 - globalqueue = 32768 + globalslots = 131072 + accountqueue = 64 + globalqueue = 131072 lifetime = "1h30m0s" # locals = [] # journal = "" diff --git a/packaging/templates/mainnet-v1/sentry/validator/bor/pbss_config.toml b/packaging/templates/mainnet-v1/sentry/validator/bor/pbss_config.toml index 6e71ad1cf9..75954b38e6 100644 --- a/packaging/templates/mainnet-v1/sentry/validator/bor/pbss_config.toml +++ b/packaging/templates/mainnet-v1/sentry/validator/bor/pbss_config.toml @@ -57,9 +57,9 @@ syncmode = "full" nolocals = true pricelimit = 25000000000 accountslots = 16 - globalslots = 32768 - accountqueue = 16 - globalqueue = 32768 + globalslots = 131072 + accountqueue = 64 + globalqueue = 131072 lifetime = "1h30m0s" # locals = [] # journal = "" diff --git a/packaging/templates/mainnet-v1/without-sentry/bor/config.toml b/packaging/templates/mainnet-v1/without-sentry/bor/config.toml index 24d25b4406..d43b87c23e 100644 --- a/packaging/templates/mainnet-v1/without-sentry/bor/config.toml +++ b/packaging/templates/mainnet-v1/without-sentry/bor/config.toml @@ -55,9 +55,9 @@ syncmode = "full" nolocals = true pricelimit = 25000000000 accountslots = 16 - globalslots = 32768 - accountqueue = 16 - globalqueue = 32768 + globalslots = 131072 + accountqueue = 64 + globalqueue = 131072 lifetime = "1h30m0s" # locals = [] # journal = "" diff --git a/packaging/templates/mainnet-v1/without-sentry/bor/pbss_config.toml b/packaging/templates/mainnet-v1/without-sentry/bor/pbss_config.toml index ac23de5789..20a5b02f0a 100644 --- a/packaging/templates/mainnet-v1/without-sentry/bor/pbss_config.toml +++ b/packaging/templates/mainnet-v1/without-sentry/bor/pbss_config.toml @@ -56,9 +56,9 @@ syncmode = "full" nolocals = true pricelimit = 25000000000 accountslots = 16 - globalslots = 32768 - accountqueue = 16 - globalqueue = 32768 + globalslots = 131072 + accountqueue = 64 + globalqueue = 131072 lifetime = "1h30m0s" # locals = [] # journal = "" From 36954c3cfba6e1770a8fd9a98b971a506792baf3 Mon Sep 17 00:00:00 2001 From: Jerry Date: Thu, 9 Jan 2025 07:58:55 -0800 Subject: [PATCH 04/15] Bump version to v1.5.4 --- params/version.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/params/version.go b/params/version.go index fba60aabb2..03cd330b7d 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 = 5 // Minor version component of the current release - VersionPatch = 4 // 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 = 5 // Minor version component of the current release + VersionPatch = 4 // Patch version component of the current release + VersionMeta = "" // Version metadata to append to the version string ) var GitCommit string From c038dd26ceb41fc930753f24ac34568d322c62d2 Mon Sep 17 00:00:00 2001 From: Jerry Date: Tue, 28 Jan 2025 08:49:30 -0800 Subject: [PATCH 05/15] Remove redundant locks from txpool (#1420) --- core/txpool/legacypool/legacypool.go | 8 +- core/txpool/legacypool/list.go | 142 +++------------------------ 2 files changed, 16 insertions(+), 134 deletions(-) diff --git a/core/txpool/legacypool/legacypool.go b/core/txpool/legacypool/legacypool.go index 3808a2bb7f..13e3d453e7 100644 --- a/core/txpool/legacypool/legacypool.go +++ b/core/txpool/legacypool/legacypool.go @@ -100,12 +100,8 @@ var ( localGauge = metrics.NewRegisteredGauge("txpool/local", nil) slotsGauge = metrics.NewRegisteredGauge("txpool/slots", nil) - resetCacheGauge = metrics.NewRegisteredGauge("txpool/resetcache", nil) - reinitCacheGauge = metrics.NewRegisteredGauge("txpool/reinittcache", nil) - hitCacheCounter = metrics.NewRegisteredCounter("txpool/cachehit", nil) - missCacheCounter = metrics.NewRegisteredCounter("txpool/cachemiss", nil) - - reheapTimer = metrics.NewRegisteredTimer("txpool/reheap", nil) + resetCacheGauge = metrics.NewRegisteredGauge("txpool/resetcache", nil) + reheapTimer = metrics.NewRegisteredTimer("txpool/reheap", nil) ) // BlockChain defines the minimal set of methods needed to back a tx pool with diff --git a/core/txpool/legacypool/list.go b/core/txpool/legacypool/list.go index 031b657862..37dd7c6354 100644 --- a/core/txpool/legacypool/list.go +++ b/core/txpool/legacypool/list.go @@ -58,29 +58,22 @@ func (h *nonceHeap) Pop() interface{} { // sortedMap is a nonce->transaction hash map with a heap based index to allow // iterating over the contents in a nonce-incrementing way. type sortedMap struct { - items map[uint64]*types.Transaction // Hash map storing the transaction data - index *nonceHeap // Heap of nonces of all the stored transactions (non-strict mode) - m sync.RWMutex - - cache types.Transactions // Cache of the transactions already sorted - isEmpty bool + items map[uint64]*types.Transaction // Hash map storing the transaction data + index *nonceHeap // Heap of nonces of all the stored transactions (non-strict mode) + cache types.Transactions // Cache of the transactions already sorted cacheMu sync.RWMutex } // newSortedMap creates a new nonce-sorted transaction map. func newSortedMap() *sortedMap { return &sortedMap{ - items: make(map[uint64]*types.Transaction), - index: new(nonceHeap), - isEmpty: true, + items: make(map[uint64]*types.Transaction), + index: new(nonceHeap), } } // Get retrieves the current transactions associated with the given nonce. func (m *sortedMap) Get(nonce uint64) *types.Transaction { - m.m.RLock() - defer m.m.RUnlock() - return m.items[nonce] } @@ -89,28 +82,18 @@ func (m *sortedMap) Has(nonce uint64) bool { return false } - m.m.RLock() - defer m.m.RUnlock() - return m.items[nonce] != nil } // Put inserts a new transaction into the map, also updating the map's nonce // index. If a transaction already exists with the same nonce, it's overwritten. func (m *sortedMap) Put(tx *types.Transaction) { - m.m.Lock() - defer m.m.Unlock() - nonce := tx.Nonce() if m.items[nonce] == nil { heap.Push(m.index, nonce) } - - m.items[nonce] = tx - m.cacheMu.Lock() - m.isEmpty = true - m.cache = nil + m.items[nonce], m.cache = tx, nil m.cacheMu.Unlock() } @@ -118,9 +101,6 @@ func (m *sortedMap) Put(tx *types.Transaction) { // provided threshold. Every removed transaction is returned for any post-removal // maintenance. func (m *sortedMap) Forward(threshold uint64) types.Transactions { - m.m.Lock() - defer m.m.Unlock() - var removed types.Transactions // Pop off heap items until the threshold is reached @@ -133,8 +113,6 @@ func (m *sortedMap) Forward(threshold uint64) types.Transactions { // If we had a cached order, shift the front m.cacheMu.Lock() if m.cache != nil { - hitCacheCounter.Inc(1) - m.cache = m.cache[len(removed):] } m.cacheMu.Unlock() @@ -147,9 +125,6 @@ func (m *sortedMap) Forward(threshold uint64) types.Transactions { // If you want to do several consecutive filterings, it's therefore better to first // do a .filter(func1) followed by .Filter(func2) or reheap() func (m *sortedMap) Filter(filter func(*types.Transaction) bool) types.Transactions { - m.m.Lock() - defer m.m.Unlock() - removed := m.filter(filter) // If transactions were removed, the heap and cache are ruined if len(removed) > 0 { @@ -187,10 +162,7 @@ func (m *sortedMap) filter(filter func(*types.Transaction) bool) types.Transacti if len(removed) > 0 { m.cacheMu.Lock() m.cache = nil - m.isEmpty = true m.cacheMu.Unlock() - - resetCacheGauge.Inc(1) } return removed @@ -199,9 +171,6 @@ func (m *sortedMap) filter(filter func(*types.Transaction) bool) types.Transacti // Cap places a hard limit on the number of items, returning all transactions // exceeding that limit. func (m *sortedMap) Cap(threshold int) types.Transactions { - m.m.Lock() - defer m.m.Unlock() - // Short circuit if the number of items is under the limit if len(m.items) <= threshold { return nil @@ -233,15 +202,11 @@ func (m *sortedMap) Cap(threshold int) types.Transactions { // Remove deletes a transaction from the maintained map, returning whether the // transaction was found. func (m *sortedMap) Remove(nonce uint64) bool { - m.m.Lock() - defer m.m.Unlock() - // Short circuit if no transaction is present _, ok := m.items[nonce] if !ok { return false } - // Otherwise delete the transaction and fix the heap index for i := 0; i < m.index.Len(); i++ { if (*m.index)[i] == nonce { @@ -250,16 +215,11 @@ func (m *sortedMap) Remove(nonce uint64) bool { break } } - delete(m.items, nonce) - m.cacheMu.Lock() m.cache = nil - m.isEmpty = true m.cacheMu.Unlock() - resetCacheGauge.Inc(1) - return true } @@ -271,9 +231,6 @@ func (m *sortedMap) Remove(nonce uint64) bool { // prevent getting into an invalid state. This is not something that should ever // happen but better to be self correcting than failing! func (m *sortedMap) Ready(start uint64) types.Transactions { - m.m.Lock() - defer m.m.Unlock() - // Short circuit if no transactions are available if m.index.Len() == 0 || (*m.index)[0] > start { return nil @@ -290,7 +247,6 @@ func (m *sortedMap) Ready(start uint64) types.Transactions { m.cacheMu.Lock() m.cache = nil - m.isEmpty = true m.cacheMu.Unlock() resetCacheGauge.Inc(1) @@ -300,85 +256,25 @@ func (m *sortedMap) Ready(start uint64) types.Transactions { // Len returns the length of the transaction map. func (m *sortedMap) Len() int { - m.m.RLock() - defer m.m.RUnlock() - return len(m.items) } func (m *sortedMap) flatten() types.Transactions { - // If the sorting was not cached yet, create and cache it m.cacheMu.Lock() defer m.cacheMu.Unlock() - - if m.isEmpty { - m.isEmpty = false // to simulate sync.Once - - m.cacheMu.Unlock() - - m.m.RLock() - - cache := make(types.Transactions, 0, len(m.items)) - + // If the sorting was not cached yet, create and cache it + if m.cache == nil { + m.cache = make(types.Transactions, 0, len(m.items)) for _, tx := range m.items { - cache = append(cache, tx) + m.cache = append(m.cache, tx) } - - m.m.RUnlock() - - // exclude sorting from locks - sort.Sort(types.TxByNonce(cache)) - - m.cacheMu.Lock() - m.cache = cache - - reinitCacheGauge.Inc(1) - missCacheCounter.Inc(1) - } else { - hitCacheCounter.Inc(1) + sort.Sort(types.TxByNonce(m.cache)) } - return m.cache } func (m *sortedMap) lastElement() *types.Transaction { - // If the sorting was not cached yet, create and cache it - m.cacheMu.Lock() - defer m.cacheMu.Unlock() - - cache := m.cache - - if m.isEmpty { - m.isEmpty = false // to simulate sync.Once - - m.cacheMu.Unlock() - - m.m.RLock() - cache = make(types.Transactions, 0, len(m.items)) - - for _, tx := range m.items { - cache = append(cache, tx) - } - - m.m.RUnlock() - - // exclude sorting from locks - sort.Sort(types.TxByNonce(cache)) - - m.cacheMu.Lock() - m.cache = cache - - reinitCacheGauge.Inc(1) - missCacheCounter.Inc(1) - } else { - hitCacheCounter.Inc(1) - } - - ln := len(cache) - if ln == 0 { - return nil - } - + cache := m.flatten() return cache[len(cache)-1] } @@ -657,9 +553,8 @@ func (l *list) subTotalCost(txs []*types.Transaction) { // then the heap is sorted based on the effective tip based on the given base fee. // If baseFee is nil then the sorting is based on gasFeeCap. type priceHeap struct { - baseFee *big.Int // heap should always be re-sorted after baseFee is changed - list []*types.Transaction - baseFeeMu sync.RWMutex + baseFee *big.Int // heap should always be re-sorted after baseFee is changed + list []*types.Transaction } func (h *priceHeap) Len() int { return len(h.list) } @@ -677,19 +572,13 @@ func (h *priceHeap) Less(i, j int) bool { } func (h *priceHeap) cmp(a, b *types.Transaction) int { - h.baseFeeMu.RLock() - if h.baseFee != nil { // Compare effective tips if baseFee is specified if c := a.EffectiveGasTipCmp(b, h.baseFee); c != 0 { - h.baseFeeMu.RUnlock() - return c } } - h.baseFeeMu.RUnlock() - // Compare fee caps if baseFee is not specified or effective tips are equal if c := a.GasFeeCapCmp(b); c != 0 { return c @@ -882,9 +771,6 @@ func (l *pricedList) Reheap() { // SetBaseFee updates the base fee and triggers a re-heap. Note that Removed is not // necessary to call right before SetBaseFee when processing a new block. func (l *pricedList) SetBaseFee(baseFee *big.Int) { - l.urgent.baseFeeMu.Lock() l.urgent.baseFee = baseFee - l.urgent.baseFeeMu.Unlock() - l.Reheap() } From ce4af042a3446c3b7fd41825c419ea0befc1069f Mon Sep 17 00:00:00 2001 From: Krishang Shah <109511742+kamuikatsurgi@users.noreply.github.com> Date: Tue, 28 Jan 2025 23:30:27 +0530 Subject: [PATCH 06/15] Simplify e2e-tests CI by using the consolidated script (#1423) * use the consolidated script for e2e-tests * minor nit --- .github/workflows/ci.yml | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f1ec6f39c6..f9a63f83f8 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -236,15 +236,9 @@ jobs: - name: Launch devnet run: | cd matic-cli/devnet - bash docker-ganache-start.sh - bash docker-heimdall-start-all.sh - bash docker-bor-setup.sh - bash docker-bor-start-all.sh + bash ../docker_devnet.sh cd - timeout 2m bash bor/integration-tests/bor_health.sh - cd - - bash ganache-deployment-bor.sh - bash ganache-deployment-sync.sh - name: Run smoke tests run: | From 984e074a9b44546ed145eb9bc49b1d238acfc777 Mon Sep 17 00:00:00 2001 From: Simone Bologna Date: Thu, 30 Jan 2025 10:26:22 +0100 Subject: [PATCH 07/15] trim trailing / from ancient path (#1400) --- internal/cli/snapshot.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/cli/snapshot.go b/internal/cli/snapshot.go index b610f6b71f..0f4d24bd94 100644 --- a/internal/cli/snapshot.go +++ b/internal/cli/snapshot.go @@ -473,7 +473,7 @@ func checkDeletePermissions(path string) (bool, error) { func (c *PruneBlockCommand) pruneBlock(stack *node.Node, fdHandles int) error { name := "chaindata" - oldAncientPath := c.datadirAncient + oldAncientPath := strings.TrimSuffix(c.datadirAncient, "/") switch { case oldAncientPath == "": From 573c343d54105db2510cbfea1a41ec91c17c6139 Mon Sep 17 00:00:00 2001 From: Manav Darji Date: Thu, 30 Jan 2025 18:41:32 +0530 Subject: [PATCH 08/15] crypto: add IsOnCurve check --- crypto/crypto.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/crypto/crypto.go b/crypto/crypto.go index cce7a5ebe5..9302c96fab 100644 --- a/crypto/crypto.go +++ b/crypto/crypto.go @@ -189,6 +189,9 @@ func UnmarshalPubkey(pub []byte) (*ecdsa.PublicKey, error) { if x == nil { return nil, errInvalidPubkey } + if !S256().IsOnCurve(x, y) { + return nil, errInvalidPubkey + } return &ecdsa.PublicKey{Curve: S256(), X: x, Y: y}, nil } From 983b715f08dcfb386bf7739c6aee09cedf0acd1c Mon Sep 17 00:00:00 2001 From: Manav Darji Date: Thu, 30 Jan 2025 18:43:00 +0530 Subject: [PATCH 09/15] params: bump version to v1.5.5 --- params/version.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/params/version.go b/params/version.go index 03cd330b7d..c139179f0f 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 = 5 // Minor version component of the current release - VersionPatch = 4 // Patch version component of the current release + VersionPatch = 5 // Patch version component of the current release VersionMeta = "" // Version metadata to append to the version string ) From 9da0432ec24ee8ceba9f5af42ff3b6830983badf Mon Sep 17 00:00:00 2001 From: Manav Darji Date: Thu, 30 Jan 2025 22:27:03 +0530 Subject: [PATCH 10/15] miner, consensus, core: remove tracing in mining workflow (#1422) This PR removes open telemetry based tracing from the whole mining workflow. The tracing extended into consensus and core blockchain functions from miner is also removed in this PR. We weren't checking the tracing from a long time and the way it was implemented increased the code complexity a lot. --- consensus/beacon/consensus.go | 5 +- consensus/bor/bor.go | 99 ++------- consensus/clique/clique.go | 3 +- consensus/consensus.go | 3 +- consensus/ethash/ethash.go | 3 +- core/blockchain.go | 10 +- miner/test_backend.go | 381 ++++++++++++-------------------- miner/worker.go | 400 +++++++--------------------------- tests/bor/helper.go | 5 +- 9 files changed, 253 insertions(+), 656 deletions(-) diff --git a/consensus/beacon/consensus.go b/consensus/beacon/consensus.go index dfbd00bbc8..1f01422f05 100644 --- a/consensus/beacon/consensus.go +++ b/consensus/beacon/consensus.go @@ -17,7 +17,6 @@ package beacon import ( - "context" "errors" "fmt" "math/big" @@ -398,9 +397,9 @@ func (beacon *Beacon) FinalizeAndAssemble(chain consensus.ChainHeaderReader, hea // // Note, the method returns immediately and will send the result async. More // than one result may also be returned depending on the consensus algorithm. -func (beacon *Beacon) Seal(ctx context.Context, chain consensus.ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error { +func (beacon *Beacon) Seal(chain consensus.ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error { if !beacon.IsPoSHeader(block.Header()) { - return beacon.ethone.Seal(ctx, chain, block, results, stop) + return beacon.ethone.Seal(chain, block, results, stop) } // The seal verification is done by the external consensus engine, // return directly without pushing any block back. In another word diff --git a/consensus/bor/bor.go b/consensus/bor/bor.go index 829a5f67c4..e54fd36b3b 100644 --- a/consensus/bor/bor.go +++ b/consensus/bor/bor.go @@ -17,13 +17,10 @@ import ( lru "github.com/hashicorp/golang-lru" "github.com/holiman/uint256" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/trace" "golang.org/x/crypto/sha3" "github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/common/tracing" balance_tracing "github.com/ethereum/go-ethereum/core/tracing" "github.com/ethereum/go-ethereum/consensus" @@ -820,30 +817,28 @@ func (c *Bor) Prepare(chain consensus.ChainHeaderReader, header *types.Header) e // Finalize implements consensus.Engine, ensuring no uncles are set, nor block // rewards given. func (c *Bor) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body) { + headerNumber := header.Number.Uint64() + if body.Withdrawals != nil || header.WithdrawalsHash != nil { + return + } + var ( stateSyncData []*types.StateSyncData err error ) - headerNumber := header.Number.Uint64() - - if body.Withdrawals != nil || header.WithdrawalsHash != nil { - return - } - if IsSprintStart(headerNumber, c.config.CalculateSprint(headerNumber)) { start := time.Now() - ctx := context.Background() cx := statefull.ChainContext{Chain: chain, Bor: c} // check and commit span - if err := c.checkAndCommitSpan(ctx, state, header, cx); err != nil { + if err := c.checkAndCommitSpan(state, header, cx); err != nil { log.Error("Error while committing span", "error", err) return } if c.HeimdallClient != nil { // commit states - stateSyncData, err = c.CommitStates(ctx, state, header, cx) + stateSyncData, err = c.CommitStates(state, header, cx) if err != nil { log.Error("Error while committing states", "error", err) return @@ -908,38 +903,28 @@ func (c *Bor) changeContractCodeIfNeeded(headerNumber uint64, state *state.State // FinalizeAndAssemble implements consensus.Engine, ensuring no uncles are set, // nor block rewards given, and returns the final block. func (c *Bor) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt) (*types.Block, error) { - finalizeCtx, finalizeSpan := tracing.StartSpan(context.Background(), "bor.FinalizeAndAssemble") - defer tracing.EndSpan(finalizeSpan) - headerNumber := header.Number.Uint64() - if body.Withdrawals != nil || header.WithdrawalsHash != nil { return nil, consensus.ErrUnexpectedWithdrawals } - stateSyncData := []*types.StateSyncData{} - - var err error + var ( + stateSyncData []*types.StateSyncData + err error + ) if IsSprintStart(headerNumber, c.config.CalculateSprint(headerNumber)) { cx := statefull.ChainContext{Chain: chain, Bor: c} - tracing.Exec(finalizeCtx, "", "bor.checkAndCommitSpan", func(ctx context.Context, span trace.Span) { - // check and commit span - err = c.checkAndCommitSpan(finalizeCtx, state, header, cx) - }) - - if err != nil { + // check and commit span + if err = c.checkAndCommitSpan(state, header, cx); err != nil { log.Error("Error while committing span", "error", err) return nil, err } if c.HeimdallClient != nil { - tracing.Exec(finalizeCtx, "", "bor.checkAndCommitSpan", func(ctx context.Context, span trace.Span) { - // commit states - stateSyncData, err = c.CommitStates(finalizeCtx, state, header, cx) - }) - + // commit states + stateSyncData, err = c.CommitStates(state, header, cx) if err != nil { log.Error("Error while committing states", "error", err) return nil, err @@ -947,19 +932,13 @@ func (c *Bor) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *typ } } - tracing.Exec(finalizeCtx, "", "bor.changeContractCodeIfNeeded", func(ctx context.Context, span trace.Span) { - err = c.changeContractCodeIfNeeded(headerNumber, state) - }) - - if err != nil { + if err = c.changeContractCodeIfNeeded(headerNumber, state); err != nil { log.Error("Error changing contract code", "error", err) return nil, err } // No block rewards in PoA, so the state remains as it is - tracing.Exec(finalizeCtx, "", "bor.IntermediateRoot", func(ctx context.Context, span trace.Span) { - header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number)) - }) + header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number)) // Uncles are dropped header.UncleHash = types.CalcUncleHash(nil) @@ -971,14 +950,6 @@ func (c *Bor) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *typ bc := chain.(core.BorStateSyncer) bc.SetStateSync(stateSyncData) - tracing.SetAttributes( - finalizeSpan, - attribute.Int("number", int(header.Number.Int64())), - attribute.String("hash", header.Hash().String()), - attribute.Int("number of txs", len(body.Transactions)), - attribute.Int("gas used", int(block.GasUsed())), - ) - // return the final block for sealing return block, nil } @@ -994,18 +965,7 @@ func (c *Bor) Authorize(currentSigner common.Address, signFn SignerFn) { // Seal implements consensus.Engine, attempting to create a sealed block using // the local signing credentials. -func (c *Bor) Seal(ctx context.Context, chain consensus.ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error { - _, sealSpan := tracing.StartSpan(ctx, "bor.Seal") - - var endSpan bool = true - - defer func() { - // Only end span in case of early-returns/errors - if endSpan { - tracing.EndSpan(sealSpan) - } - }() - +func (c *Bor) Seal(chain consensus.ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error { header := block.Header() // Sealing the genesis block is not supported number := header.Number.Uint64() @@ -1051,7 +1011,7 @@ func (c *Bor) Seal(ctx context.Context, chain consensus.ChainHeaderReader, block // Wait until sealing is terminated or delay timeout. log.Info("Waiting for slot to sign and propagate", "number", number, "hash", header.Hash, "delay-in-sec", uint(delay), "delay", common.PrettyDuration(delay)) - go func(sealSpan trace.Span) { + go func() { select { case <-stop: log.Debug("Discarding sealing operation for block", "number", number) @@ -1074,27 +1034,13 @@ func (c *Bor) Seal(ctx context.Context, chain consensus.ChainHeaderReader, block "delay", delay, "headerDifficulty", header.Difficulty, ) - - tracing.SetAttributes( - sealSpan, - attribute.Int("number", int(number)), - attribute.String("hash", header.Hash().String()), - attribute.Int("delay", int(delay.Milliseconds())), - attribute.Int("wiggle", int(wiggle.Milliseconds())), - attribute.Bool("out-of-turn", wiggle > 0), - ) - - tracing.EndSpan(sealSpan) } select { case results <- block.WithSeal(header): default: log.Warn("Sealing result was not read by miner", "number", number, "sealhash", SealHash(header, c.config)) } - }(sealSpan) - - // Set the endSpan flag to false, as the go routine will handle it - endSpan = false + }() return nil } @@ -1150,11 +1096,11 @@ func (c *Bor) Close() error { } func (c *Bor) checkAndCommitSpan( - ctx context.Context, state *state.StateDB, header *types.Header, chain core.ChainContext, ) error { + var ctx = context.Background() headerNumber := header.Number.Uint64() span, err := c.spanner.GetCurrentSpan(ctx, header.ParentHash) @@ -1228,7 +1174,6 @@ func (c *Bor) FetchAndCommitSpan( // CommitStates commit states func (c *Bor) CommitStates( - ctx context.Context, state *state.StateDB, header *types.Header, chain statefull.ChainContext, @@ -1269,7 +1214,7 @@ func (c *Bor) CommitStates( "fromID", from, "to", to.Format(time.RFC3339)) - eventRecords, err := c.HeimdallClient.StateSyncEvents(ctx, from, to.Unix()) + eventRecords, err := c.HeimdallClient.StateSyncEvents(context.Background(), from, to.Unix()) if err != nil { log.Error("Error occurred when fetching state sync events", "fromID", from, "to", to.Unix(), "err", err) } diff --git a/consensus/clique/clique.go b/consensus/clique/clique.go index 40508bb3c0..824b915e73 100644 --- a/consensus/clique/clique.go +++ b/consensus/clique/clique.go @@ -19,7 +19,6 @@ package clique import ( "bytes" - "context" "errors" "fmt" "io" @@ -652,7 +651,7 @@ func (c *Clique) Authorize(signer common.Address, signFn SignerFn) { // Seal implements consensus.Engine, attempting to create a sealed block using // the local signing credentials. -func (c *Clique) Seal(ctx context.Context, chain consensus.ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error { +func (c *Clique) Seal(chain consensus.ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error { header := block.Header() // Sealing the genesis block is not supported diff --git a/consensus/consensus.go b/consensus/consensus.go index fcb455e7b2..cd1a01bedf 100644 --- a/consensus/consensus.go +++ b/consensus/consensus.go @@ -18,7 +18,6 @@ package consensus import ( - "context" "math/big" "github.com/ethereum/go-ethereum/common" @@ -103,7 +102,7 @@ type Engine interface { // // Note, the method returns immediately and will send the result async. More // than one result may also be returned depending on the consensus algorithm. - Seal(ctx context.Context, chain ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error + Seal(chain ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error // SealHash returns the hash of a block prior to it being sealed. SealHash(header *types.Header) common.Hash diff --git a/consensus/ethash/ethash.go b/consensus/ethash/ethash.go index 3e74461d98..f37ec26056 100644 --- a/consensus/ethash/ethash.go +++ b/consensus/ethash/ethash.go @@ -18,7 +18,6 @@ package ethash import ( - "context" "time" "github.com/ethereum/go-ethereum/consensus" @@ -81,6 +80,6 @@ func (ethash *Ethash) APIs(chain consensus.ChainHeaderReader) []rpc.API { // Seal generates a new sealing request for the given input block and pushes // the result into the given channel. For the ethash engine, this method will // just panic as sealing is not supported anymore. -func (ethash *Ethash) Seal(ctx context.Context, chain consensus.ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error { +func (ethash *Ethash) Seal(chain consensus.ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error { panic("ethash (pow) sealing not supported any more") } diff --git a/core/blockchain.go b/core/blockchain.go index 3d8a9a4853..a37e4a5f1e 100644 --- a/core/blockchain.go +++ b/core/blockchain.go @@ -1922,18 +1922,18 @@ func (bc *BlockChain) writeBlockWithState(block *types.Block, receipts []*types. // WriteBlockAndSetHead writes the given block and all associated state to the database, // and applies the block as the new chain head. -func (bc *BlockChain) WriteBlockAndSetHead(ctx context.Context, block *types.Block, receipts []*types.Receipt, logs []*types.Log, state *state.StateDB, emitHeadEvent bool) (status WriteStatus, err error) { +func (bc *BlockChain) WriteBlockAndSetHead(block *types.Block, receipts []*types.Receipt, logs []*types.Log, state *state.StateDB, emitHeadEvent bool) (status WriteStatus, err error) { if !bc.chainmu.TryLock() { return NonStatTy, errChainStopped } defer bc.chainmu.Unlock() - return bc.writeBlockAndSetHead(ctx, block, receipts, logs, state, emitHeadEvent) + return bc.writeBlockAndSetHead(block, receipts, logs, state, emitHeadEvent) } // writeBlockAndSetHead is the internal implementation of WriteBlockAndSetHead. // This function expects the chain mutex to be held. -func (bc *BlockChain) writeBlockAndSetHead(ctx context.Context, block *types.Block, receipts []*types.Receipt, logs []*types.Log, state *state.StateDB, emitHeadEvent bool) (status WriteStatus, err error) { +func (bc *BlockChain) writeBlockAndSetHead(block *types.Block, receipts []*types.Receipt, logs []*types.Log, state *state.StateDB, emitHeadEvent bool) (status WriteStatus, err error) { stateSyncLogs, err := bc.writeBlockWithState(block, receipts, logs, state) if err != nil { return NonStatTy, err @@ -2401,7 +2401,7 @@ func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool) (int, error) // Don't set the head, only insert the block _, err = bc.writeBlockWithState(block, receipts, logs, statedb) } else { - status, err = bc.writeBlockAndSetHead(context.Background(), block, receipts, logs, statedb, false) + status, err = bc.writeBlockAndSetHead(block, receipts, logs, statedb, false) } followupInterrupt.Store(true) @@ -2574,7 +2574,7 @@ func (bc *BlockChain) processBlock(block *types.Block, statedb *state.StateDB, s // Don't set the head, only insert the block _, err = bc.writeBlockWithState(block, receipts, logs, statedb) } else { - status, err = bc.writeBlockAndSetHead(context.Background(), block, receipts, logs, statedb, false) + status, err = bc.writeBlockAndSetHead(block, receipts, logs, statedb, false) } if err != nil { return nil, err diff --git a/miner/test_backend.go b/miner/test_backend.go index b18fc1c495..a91422cde1 100644 --- a/miner/test_backend.go +++ b/miner/test_backend.go @@ -3,8 +3,6 @@ package miner import ( "context" "errors" - "fmt" - "os" "sync" "sync/atomic" "time" @@ -12,9 +10,8 @@ import ( // nolint:typecheck "github.com/ethereum/go-ethereum/common" - cmath "github.com/ethereum/go-ethereum/common/math" - "github.com/ethereum/go-ethereum/common/tracing" "github.com/ethereum/go-ethereum/consensus" + "github.com/ethereum/go-ethereum/consensus/misc/eip4844" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/blockstm" "github.com/ethereum/go-ethereum/core/state" @@ -27,10 +24,6 @@ import ( "github.com/ethereum/go-ethereum/rlp" "github.com/holiman/uint256" - "go.opentelemetry.io/otel" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/trace" - lru "github.com/hashicorp/golang-lru" ) @@ -102,12 +95,10 @@ func newWorkerWithDelay(config *Config, chainConfig *params.ChainConfig, engine worker.newpayloadTimeout = newpayloadTimeout - ctx := tracing.WithTracer(context.Background(), otel.GetTracerProvider().Tracer("MinerWorker")) - worker.wg.Add(4) - go worker.mainLoopWithDelay(ctx, delay, opcodeDelay) - go worker.newWorkLoop(ctx, recommit) + go worker.mainLoopWithDelay(delay, opcodeDelay) + go worker.newWorkLoop(recommit) go worker.resultLoop() go worker.taskLoop() @@ -121,7 +112,7 @@ func newWorkerWithDelay(config *Config, chainConfig *params.ChainConfig, engine // mainLoopWithDelay is mainLoop() with extra params to induce artficial delays for tests such as commit-interrupt. // nolint:gocognit -func (w *worker) mainLoopWithDelay(ctx context.Context, delay uint, opcodeDelay uint) { +func (w *worker) mainLoopWithDelay(delay uint, opcodeDelay uint) { defer w.wg.Done() defer w.txsSub.Unsubscribe() defer w.chainHeadSub.Unsubscribe() @@ -137,15 +128,15 @@ func (w *worker) mainLoopWithDelay(ctx context.Context, delay uint, opcodeDelay if w.chainConfig.ChainID.Cmp(params.BorMainnetChainConfig.ChainID) == 0 || w.chainConfig.ChainID.Cmp(params.MumbaiChainConfig.ChainID) == 0 { if w.eth.PeerCount() > 0 { //nolint:contextcheck - w.commitWorkWithDelay(req.ctx, req.interrupt, req.noempty, req.timestamp, delay, opcodeDelay) + w.commitWorkWithDelay(req.interrupt, req.noempty, req.timestamp, delay, opcodeDelay) } } else { //nolint:contextcheck - w.commitWorkWithDelay(req.ctx, req.interrupt, req.noempty, req.timestamp, delay, opcodeDelay) + w.commitWorkWithDelay(req.interrupt, req.noempty, req.timestamp, delay, opcodeDelay) } case req := <-w.getWorkCh: - req.result <- w.generateWork(ctx, req.params) + req.result <- w.generateWork(req.params) case ev := <-w.txsCh: // Apply transactions to the pending state if we're not sealing @@ -187,7 +178,7 @@ func (w *worker) mainLoopWithDelay(ctx context.Context, delay uint, opcodeDelay // submit sealing work here since all empty submission will be rejected // by clique. Of course the advance sealing(empty submission) is disabled. if w.chainConfig.Clique != nil && w.chainConfig.Clique.Period == 0 { - w.commitWork(ctx, nil, true, time.Now().Unix()) + w.commitWork(nil, true, time.Now().Unix()) } } @@ -205,7 +196,7 @@ func (w *worker) mainLoopWithDelay(ctx context.Context, delay uint, opcodeDelay } // commitWorkWithDelay is commitWork() with extra params to induce artficial delays for tests such as commit-interrupt. -func (w *worker) commitWorkWithDelay(ctx context.Context, interrupt *atomic.Int32, noempty bool, timestamp int64, delay uint, opcodeDelay uint) { +func (w *worker) commitWorkWithDelay(interrupt *atomic.Int32, noempty bool, timestamp int64, delay uint, opcodeDelay uint) { // Abort committing if node is still syncing if w.syncing.Load() { return @@ -217,23 +208,20 @@ func (w *worker) commitWorkWithDelay(ctx context.Context, interrupt *atomic.Int3 err error ) - tracing.Exec(ctx, "", "worker.prepareWork", func(ctx context.Context, span trace.Span) { - // Set the coinbase if the worker is running or it's required - var coinbase common.Address - if w.IsRunning() { - coinbase = w.etherbase() - if coinbase == (common.Address{}) { - log.Error("Refusing to mine without etherbase") - return - } + // Set the coinbase if the worker is running or it's required + var coinbase common.Address + if w.IsRunning() { + coinbase = w.etherbase() + if coinbase == (common.Address{}) { + log.Error("Refusing to mine without etherbase") + return } + } - work, err = w.prepareWork(&generateParams{ - timestamp: uint64(timestamp), - coinbase: coinbase, - }) + work, err = w.prepareWork(&generateParams{ + timestamp: uint64(timestamp), + coinbase: coinbase, }) - if err != nil { return } @@ -248,7 +236,7 @@ func (w *worker) commitWorkWithDelay(ctx context.Context, interrupt *atomic.Int3 if !noempty && w.interruptCommitFlag { block := w.chain.GetBlockByHash(w.chain.CurrentBlock().Hash()) - interruptCtx, stopFn = getInterruptTimer(ctx, work, block) + interruptCtx, stopFn = getInterruptTimer(work, block) // nolint : staticcheck interruptCtx = vm.PutCache(interruptCtx, w.interruptedTxCache) // nolint : staticcheck @@ -257,21 +245,13 @@ func (w *worker) commitWorkWithDelay(ctx context.Context, interrupt *atomic.Int3 interruptCtx = context.WithValue(interruptCtx, vm.InterruptCtxOpcodeDelayKey, opcodeDelay) } - ctx, span := tracing.StartSpan(ctx, "commitWork") - defer tracing.EndSpan(span) - - tracing.SetAttributes( - span, - attribute.Int("number", int(work.header.Number.Uint64())), - ) - // Create an empty block based on temporary copied state for // sealing in advance without waiting block execution finished. if !noempty && !w.noempty.Load() { - _ = w.commit(ctx, work.copy(), nil, false, start) + _ = w.commit(work.copy(), nil, false, start) } // Fill pending transactions from the txpool into the block. - err = w.fillTransactionsWithDelay(ctx, interrupt, work, interruptCtx) + err = w.fillTransactionsWithDelay(interrupt, work, interruptCtx) switch { case err == nil: @@ -302,7 +282,7 @@ func (w *worker) commitWorkWithDelay(ctx context.Context, interrupt *atomic.Int3 return } // Submit the generated block for consensus sealing. - _ = w.commit(ctx, work.copy(), w.fullTaskHook, true, start) + _ = w.commit(work.copy(), w.fullTaskHook, true, start) // Swap out the old work with the new one, terminating any leftover // prefetcher processes in the mean time and starting a new one. @@ -315,182 +295,78 @@ func (w *worker) commitWorkWithDelay(ctx context.Context, interrupt *atomic.Int3 // fillTransactionsWithDelay is fillTransactions() with extra params to induce artficial delays for tests such as commit-interrupt. // nolint:gocognit -func (w *worker) fillTransactionsWithDelay(ctx context.Context, interrupt *atomic.Int32, env *environment, interruptCtx context.Context) error { - ctx, span := tracing.StartSpan(ctx, "fillTransactions") - defer tracing.EndSpan(span) +func (w *worker) fillTransactionsWithDelay(interrupt *atomic.Int32, env *environment, interruptCtx context.Context) error { + w.mu.RLock() + tip := w.tip + w.mu.RUnlock() + + // Retrieve the pending transactions pre-filtered by the 1559/4844 dynamic fees + filter := txpool.PendingFilter{ + MinTip: uint256.MustFromBig(tip.ToBig()), + } + + if env.header.BaseFee != nil { + filter.BaseFee = uint256.MustFromBig(env.header.BaseFee) + } + + if env.header.ExcessBlobGas != nil { + filter.BlobFee = uint256.MustFromBig(eip4844.CalcBlobFee(*env.header.ExcessBlobGas)) + } + + var ( + localPlainTxs, remotePlainTxs, localBlobTxs, remoteBlobTxs map[common.Address][]*txpool.LazyTransaction + ) + + filter.OnlyPlainTxs, filter.OnlyBlobTxs = true, false + pendingPlainTxs := w.eth.TxPool().Pending(filter) + + filter.OnlyPlainTxs, filter.OnlyBlobTxs = false, true + pendingBlobTxs := w.eth.TxPool().Pending(filter) + + // Split the pending transactions into locals and remotes. + localPlainTxs, remotePlainTxs = make(map[common.Address][]*txpool.LazyTransaction), pendingPlainTxs + localBlobTxs, remoteBlobTxs = make(map[common.Address][]*txpool.LazyTransaction), pendingBlobTxs + + for _, account := range w.eth.TxPool().Locals() { + if txs := remotePlainTxs[account]; len(txs) > 0 { + delete(remotePlainTxs, account) + localPlainTxs[account] = txs + } + if txs := remoteBlobTxs[account]; len(txs) > 0 { + delete(remoteBlobTxs, account) + localBlobTxs[account] = txs + } + } - // Split the pending transactions into locals and remotes // Fill the block with all available pending transactions. - pending := w.eth.TxPool().Pending(txpool.PendingFilter{}) - localTxs, remoteTxs := make(map[common.Address][]*txpool.LazyTransaction), pending + if len(localPlainTxs) > 0 || len(localBlobTxs) > 0 { + var plainTxs, blobTxs *transactionsByPriceAndNonce - var ( - localTxsCount int - remoteTxsCount int - ) + plainTxs = newTransactionsByPriceAndNonce(env.signer, localPlainTxs, env.header.BaseFee) + blobTxs = newTransactionsByPriceAndNonce(env.signer, localBlobTxs, env.header.BaseFee) - // TODO: move to config or RPC - const profiling = false - - if profiling { - doneCh := make(chan struct{}) - - defer func() { - close(doneCh) - }() - - go func(number uint64) { - closeFn := func() error { - return nil - } - - for { - select { - case <-time.After(150 * time.Millisecond): - // Check if we've not crossed limit - if attempt := atomic.AddInt32(w.profileCount, 1); attempt >= 10 { - log.Info("Completed profiling", "attempt", attempt) - - return - } - - log.Info("Starting profiling in fill transactions", "number", number) - - dir, err := os.MkdirTemp("", fmt.Sprintf("bor-traces-%s-", time.Now().UTC().Format("2006-01-02-150405Z"))) - if err != nil { - log.Error("Error in profiling", "path", dir, "number", number, "err", err) - return - } - - // grab the cpu profile - closeFnInternal, err := startProfiler("cpu", dir, number) - if err != nil { - log.Error("Error in profiling", "path", dir, "number", number, "err", err) - return - } - - closeFn = func() error { - err := closeFnInternal() - - log.Info("Completed profiling", "path", dir, "number", number, "error", err) - - return nil - } - - case <-doneCh: - err := closeFn() - - if err != nil { - log.Info("closing fillTransactions", "number", number, "error", err) - } - - return - } - } - }(env.header.Number.Uint64()) - } - - tracing.Exec(ctx, "", "worker.SplittingTransactions", func(ctx context.Context, span trace.Span) { - prePendingTime := time.Now() - - pending := w.eth.TxPool().Pending(txpool.PendingFilter{}) - remoteTxs = pending - - postPendingTime := time.Now() - - for _, account := range w.eth.TxPool().Locals() { - if txs := remoteTxs[account]; len(txs) > 0 { - delete(remoteTxs, account) - - localTxs[account] = txs - } - } - - postLocalsTime := time.Now() - - tracing.SetAttributes( - span, - attribute.Int("len of local txs", localTxsCount), - attribute.Int("len of remote txs", remoteTxsCount), - attribute.String("time taken by Pending()", fmt.Sprintf("%v", postPendingTime.Sub(prePendingTime))), - attribute.String("time taken by Locals()", fmt.Sprintf("%v", postLocalsTime.Sub(postPendingTime))), - ) - }) - - var ( - localEnvTCount int - remoteEnvTCount int - err error - ) - - if len(localTxs) > 0 { - var txs *transactionsByPriceAndNonce - - tracing.Exec(ctx, "", "worker.LocalTransactionsByPriceAndNonce", func(ctx context.Context, span trace.Span) { - var baseFee *uint256.Int - if env.header.BaseFee != nil { - baseFee = cmath.FromBig(env.header.BaseFee) - } - - txs = newTransactionsByPriceAndNonce(env.signer, localTxs, baseFee.ToBig()) - - tracing.SetAttributes( - span, - attribute.Int("len of tx local Heads", txs.GetTxs()), - ) - }) - - tracing.Exec(ctx, "", "worker.LocalCommitTransactions", func(ctx context.Context, span trace.Span) { - err = w.commitTransactionsWithDelay(env, txs, interrupt, interruptCtx) - }) - - if err != nil { + if err := w.commitTransactionsWithDelay(env, plainTxs, blobTxs, interrupt, new(uint256.Int), interruptCtx); err != nil { return err } - - localEnvTCount = env.tcount } - if len(remoteTxs) > 0 { - var txs *transactionsByPriceAndNonce + if len(remotePlainTxs) > 0 || len(remoteBlobTxs) > 0 { + var plainTxs, blobTxs *transactionsByPriceAndNonce - tracing.Exec(ctx, "", "worker.RemoteTransactionsByPriceAndNonce", func(ctx context.Context, span trace.Span) { - var baseFee *uint256.Int - if env.header.BaseFee != nil { - baseFee = cmath.FromBig(env.header.BaseFee) - } + plainTxs = newTransactionsByPriceAndNonce(env.signer, remotePlainTxs, env.header.BaseFee) + blobTxs = newTransactionsByPriceAndNonce(env.signer, remoteBlobTxs, env.header.BaseFee) - txs = newTransactionsByPriceAndNonce(env.signer, remoteTxs, baseFee.ToBig()) - - tracing.SetAttributes( - span, - attribute.Int("len of tx remote Heads", txs.GetTxs()), - ) - }) - - tracing.Exec(ctx, "", "worker.RemoteCommitTransactions", func(ctx context.Context, span trace.Span) { - err = w.commitTransactionsWithDelay(env, txs, interrupt, interruptCtx) - }) - - if err != nil { + if err := w.commitTransactionsWithDelay(env, plainTxs, blobTxs, interrupt, new(uint256.Int), interruptCtx); err != nil { return err } - - remoteEnvTCount = env.tcount } - tracing.SetAttributes( - span, - attribute.Int("len of final local txs ", localEnvTCount), - attribute.Int("len of final remote txs", remoteEnvTCount), - ) - return nil } // commitTransactionsWithDelay is commitTransactions() with extra params to induce artficial delays for tests such as commit-interrupt. // nolint:gocognit, unparam -func (w *worker) commitTransactionsWithDelay(env *environment, txs *transactionsByPriceAndNonce, interrupt *atomic.Int32, interruptCtx context.Context) error { +func (w *worker) commitTransactionsWithDelay(env *environment, plainTxs, blobTxs *transactionsByPriceAndNonce, interrupt *atomic.Int32, minTip *uint256.Int, interruptCtx context.Context) error { gasLimit := env.header.GasLimit if env.gasPool == nil { env.gasPool = new(core.GasPool).AddGas(gasLimit) @@ -498,35 +374,25 @@ func (w *worker) commitTransactionsWithDelay(env *environment, txs *transactions 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 + var once sync.Once 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{} - + if EnableMVHashMap && w.IsRunning() { deps = map[int]map[int]bool{} chDeps = make(chan blockstm.TxDep) - count = 0 + // Make sure we safely close the channel in case of interrupt + defer once.Do(func() { + close(chDeps) + }) depsWg.Add(1) @@ -543,8 +409,15 @@ func (w *worker) commitTransactionsWithDelay(env *environment, txs *transactions mainloop: for { + // Check interruption signal and abort building if it's fired. + if interrupt != nil { + if signal := interrupt.Load(); signal != commitInterruptNone { + return signalToErr(signal) + } + } + if interruptCtx != nil { - if EnableMVHashMap { + if EnableMVHashMap && w.IsRunning() { env.state.AddEmptyMVHashMap() } @@ -558,19 +431,39 @@ mainloop: } } - // Check interruption signal and abort building if it's fired. - if interrupt != nil { - if signal := interrupt.Load(); signal != commitInterruptNone { - return signalToErr(signal) - } - } // If we don't have enough gas for any further transactions then we're done. if env.gasPool.Gas() < params.TxGas { log.Trace("Not enough gas for further transactions", "have", env.gasPool, "want", params.TxGas) break } + // If we don't have enough blob space for any further blob transactions, + // skip that list altogether + if !blobTxs.Empty() && env.blobs*params.BlobTxBlobGasPerBlob >= params.MaxBlobGasPerBlock { + log.Trace("Not enough blob space for further blob transactions") + blobTxs.Clear() + // Fall though to pick up any plain txs + } // Retrieve the next transaction and abort if all done. - ltx, _ := txs.Peek() + + var ( + ltx *txpool.LazyTransaction + txs *transactionsByPriceAndNonce + ) + pltx, ptip := plainTxs.Peek() + bltx, btip := blobTxs.Peek() + + switch { + case pltx == nil: + txs, ltx = blobTxs, bltx + case bltx == nil: + txs, ltx = plainTxs, pltx + default: + if ptip.Lt(btip) { + txs, ltx = blobTxs, bltx + } else { + txs, ltx = plainTxs, pltx + } + } if ltx == nil { break } @@ -586,6 +479,11 @@ mainloop: txs.Pop() continue } + // If we don't receive enough tip for the next transaction, skip the account + if ptip.Cmp(minTip) < 0 { + log.Trace("Not enough tip for transaction", "hash", ltx.Hash, "tip", ptip, "needed", minTip) + break // If the next-best is too low, surely no better will be available + } // Transaction seems to fit, pull it up from the pool tx := ltx.Resolve() if tx == nil { @@ -594,7 +492,7 @@ mainloop: continue } // Error may be ignored here. The error has already been checked - // during transaction acceptance is the transaction pool. + // during transaction acceptance in the transaction pool. from, _ := types.Sender(env.signer, tx) // not prioritising conditional transaction, yet. @@ -652,19 +550,21 @@ mainloop: coalescedLogs = append(coalescedLogs, logs...) env.tcount++ - if EnableMVHashMap { - depsMVReadList = append(depsMVReadList, env.state.MVReadList()) - depsMVFullWriteList = append(depsMVFullWriteList, env.state.MVFullWriteList()) - mvReadMapList = append(mvReadMapList, env.state.MVReadMap()) + if EnableMVHashMap && w.IsRunning() { + 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() @@ -675,7 +575,7 @@ mainloop: txs.Pop() } - if EnableMVHashMap { + if EnableMVHashMap && w.IsRunning() { env.state.ClearReadMap() env.state.ClearWriteMap() } @@ -683,7 +583,9 @@ mainloop: // nolint:nestif if EnableMVHashMap && w.IsRunning() { - close(chDeps) + once.Do(func() { + close(chDeps) + }) depsWg.Wait() var blockExtraData types.BlockExtraData @@ -691,8 +593,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)) @@ -700,14 +602,15 @@ 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)] if ok1 || ok2 { delayFlag = false + break } for j := range deps[i] { diff --git a/miner/worker.go b/miner/worker.go index 267f9ec309..a930a4f120 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -17,15 +17,10 @@ package miner import ( - "bytes" "context" "errors" "fmt" "math/big" - "os" - "runtime" - "runtime/pprof" - ptrace "runtime/trace" "sync" "sync/atomic" "time" @@ -33,8 +28,6 @@ import ( lru "github.com/hashicorp/golang-lru" "github.com/holiman/uint256" "go.opentelemetry.io/otel" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/trace" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/tracing" @@ -155,8 +148,6 @@ func (env *environment) discard() { // task contains all information for consensus engine sealing and result submitting. type task struct { - //nolint:containedctx - ctx context.Context receipts []*types.Receipt state *state.StateDB block *types.Block @@ -172,8 +163,6 @@ const ( // newWorkReq represents a request for new sealing work submitting with relative interrupt notifier. type newWorkReq struct { - //nolint:containedctx - ctx context.Context interrupt *atomic.Int32 noempty bool timestamp int64 @@ -352,12 +341,10 @@ func newWorker(config *Config, chainConfig *params.ChainConfig, engine consensus worker.newpayloadTimeout = newpayloadTimeout - ctx := tracing.WithTracer(context.Background(), otel.GetTracerProvider().Tracer("MinerWorker")) - worker.wg.Add(4) - go worker.mainLoop(ctx) - go worker.newWorkLoop(ctx, recommit) + go worker.mainLoop() + go worker.newWorkLoop(recommit) go worker.resultLoop() go worker.taskLoop() @@ -483,7 +470,7 @@ func recalcRecommit(minRecommit, prev time.Duration, target float64, inc bool) t // newWorkLoop is a standalone goroutine to submit new sealing work upon received events. // //nolint:gocognit -func (w *worker) newWorkLoop(ctx context.Context, recommit time.Duration) { +func (w *worker) newWorkLoop(recommit time.Duration) { defer w.wg.Done() var ( @@ -498,15 +485,13 @@ func (w *worker) newWorkLoop(ctx context.Context, recommit time.Duration) { // commit aborts in-flight transaction execution with given signal and resubmits a new one. commit := func(noempty bool, s int32) { - ctx, span := tracing.Trace(ctx, "worker.newWorkLoop.commit") - tracing.EndSpan(span) if interrupt != nil { interrupt.Store(s) } interrupt = new(atomic.Int32) select { - case w.newWorkCh <- &newWorkReq{interrupt: interrupt, timestamp: timestamp, ctx: ctx, noempty: noempty}: + case w.newWorkCh <- &newWorkReq{interrupt: interrupt, timestamp: timestamp, noempty: noempty}: case <-w.exitCh: return } @@ -515,9 +500,6 @@ func (w *worker) newWorkLoop(ctx context.Context, recommit time.Duration) { } // clearPending cleans the stale pending tasks. clearPending := func(number uint64) { - _, span := tracing.Trace(ctx, "worker.newWorkLoop.clearPending") - tracing.EndSpan(span) - w.pendingMu.Lock() for h, t := range w.pendingTasks { if t.block.NumberU64()+staleThreshold <= number { @@ -594,7 +576,7 @@ func (w *worker) newWorkLoop(ctx context.Context, recommit time.Duration) { // the received event. It can support two modes: automatically generate task and // submit it or return task according to given parameters for various proposes. // nolint: gocognit, contextcheck -func (w *worker) mainLoop(ctx context.Context) { +func (w *worker) mainLoop() { defer w.wg.Done() defer w.txsSub.Unsubscribe() defer w.chainHeadSub.Unsubscribe() @@ -610,15 +592,15 @@ func (w *worker) mainLoop(ctx context.Context) { if w.chainConfig.ChainID.Cmp(params.BorMainnetChainConfig.ChainID) == 0 || w.chainConfig.ChainID.Cmp(params.MumbaiChainConfig.ChainID) == 0 || w.chainConfig.ChainID.Cmp(params.AmoyChainConfig.ChainID) == 0 { if w.eth.PeerCount() > 0 { //nolint:contextcheck - w.commitWork(req.ctx, req.interrupt, req.noempty, req.timestamp) + w.commitWork(req.interrupt, req.noempty, req.timestamp) } } else { //nolint:contextcheck - w.commitWork(req.ctx, req.interrupt, req.noempty, req.timestamp) + w.commitWork(req.interrupt, req.noempty, req.timestamp) } case req := <-w.getWorkCh: - req.result <- w.generateWork(ctx, req.params) + req.result <- w.generateWork(req.params) case ev := <-w.txsCh: // Apply transactions to the pending state if we're not sealing @@ -663,7 +645,7 @@ func (w *worker) mainLoop(ctx context.Context) { // submit sealing work here since all empty submission will be rejected // by clique. Of course the advance sealing(empty submission) is disabled. if w.chainConfig.Clique != nil && w.chainConfig.Clique.Period == 0 { - w.commitWork(ctx, nil, true, time.Now().Unix()) + w.commitWork(nil, true, time.Now().Unix()) } } @@ -722,7 +704,7 @@ func (w *worker) taskLoop() { w.pendingTasks[sealHash] = task w.pendingMu.Unlock() - if err := w.engine.Seal(task.ctx, w.chain, task.block, w.resultCh, stopCh); err != nil { + if err := w.engine.Seal(w.chain, task.block, w.resultCh, stopCh); err != nil { log.Warn("Block sealing failed", "err", err) w.pendingMu.Lock() delete(w.pendingTasks, sealHash) @@ -783,45 +765,31 @@ func (w *worker) resultLoop() { err error ) - tracing.Exec(task.ctx, "", "resultLoop", func(ctx context.Context, span trace.Span) { - for i, taskReceipt := range task.receipts { - receipt := new(types.Receipt) - receipts[i] = receipt - *receipt = *taskReceipt + for i, taskReceipt := range task.receipts { + receipt := new(types.Receipt) + receipts[i] = receipt + *receipt = *taskReceipt - // add block location fields - receipt.BlockHash = hash - receipt.BlockNumber = block.Number() - receipt.TransactionIndex = uint(i) + // add block location fields + receipt.BlockHash = hash + receipt.BlockNumber = block.Number() + receipt.TransactionIndex = uint(i) - // Update the block hash in all logs since it is now available and not when the - // receipt/log of individual transactions were created. - receipt.Logs = make([]*types.Log, len(taskReceipt.Logs)) + // Update the block hash in all logs since it is now available and not when the + // receipt/log of individual transactions were created. + receipt.Logs = make([]*types.Log, len(taskReceipt.Logs)) - for i, taskLog := range taskReceipt.Logs { - log := new(types.Log) - receipt.Logs[i] = log - *log = *taskLog - log.BlockHash = hash - } - - logs = append(logs, receipt.Logs...) + for i, taskLog := range taskReceipt.Logs { + log := new(types.Log) + receipt.Logs[i] = log + *log = *taskLog + log.BlockHash = hash } - // Commit block and state to database. - tracing.Exec(ctx, "", "resultLoop.WriteBlockAndSetHead", func(ctx context.Context, span trace.Span) { - _, err = w.chain.WriteBlockAndSetHead(ctx, block, receipts, logs, task.state, true) - }) - tracing.SetAttributes( - span, - attribute.String("hash", hash.String()), - attribute.Int("number", int(block.Number().Uint64())), - attribute.Int("txns", block.Transactions().Len()), - attribute.Int("gas used", int(block.GasUsed())), - attribute.Int("elapsed", int(time.Since(task.createdAt).Milliseconds())), - attribute.Bool("error", err != nil), - ) - }) + logs = append(logs, receipt.Logs...) + } + // Commit block and state to database. + _, err = w.chain.WriteBlockAndSetHead(block, receipts, logs, task.state, true) if err != nil { log.Error("Failed writing block to chain", "err", err) @@ -1301,80 +1269,13 @@ func (w *worker) prepareWork(genParams *generateParams) (*environment, error) { return env, nil } -func startProfiler(profile string, filepath string, number uint64) (func() error, error) { - var ( - buf bytes.Buffer - err error - ) - - closeFn := func() {} - - switch profile { - case "cpu": - err = pprof.StartCPUProfile(&buf) - - if err == nil { - closeFn = func() { - pprof.StopCPUProfile() - } - } - case "trace": - err = ptrace.Start(&buf) - - if err == nil { - closeFn = func() { - ptrace.Stop() - } - } - case "heap": - runtime.GC() - - err = pprof.WriteHeapProfile(&buf) - default: - log.Info("Incorrect profile name") - } - - if err != nil { - return func() error { - closeFn() - return nil - }, err - } - - closeFnNew := func() error { - var err error - - closeFn() - - if buf.Len() == 0 { - return nil - } - - f, err := os.Create(filepath + "/" + profile + "-" + fmt.Sprint(number) + ".prof") - if err != nil { - return err - } - - defer f.Close() - - _, err = f.Write(buf.Bytes()) - - return err - } - - return closeFnNew, nil -} - // fillTransactions retrieves the pending transactions from the txpool and fills them // into the given sealing block. The transaction selection and ordering strategy can // be customized with the plugin in the future. // //nolint:gocognit -func (w *worker) fillTransactions(ctx context.Context, interrupt *atomic.Int32, env *environment, interruptCtx context.Context) error { - ctx, span := tracing.StartSpan(ctx, "fillTransactions") - defer tracing.EndSpan(span) - +func (w *worker) fillTransactions(interrupt *atomic.Int32, env *environment, interruptCtx context.Context) error { w.mu.RLock() tip := w.tip w.mu.RUnlock() @@ -1392,179 +1293,59 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *atomic.Int32, filter.BlobFee = uint256.MustFromBig(eip4844.CalcBlobFee(*env.header.ExcessBlobGas)) } - var ( - localPlainTxsCount int - remotePlainTxsCount int - ) - - // TODO: move to config or RPC - const profiling = false - - if profiling { - doneCh := make(chan struct{}) - - defer func() { - close(doneCh) - }() - - go func(number uint64) { - closeFn := func() error { - return nil - } - - for { - select { - case <-time.After(150 * time.Millisecond): - // Check if we've not crossed limit - if attempt := atomic.AddInt32(w.profileCount, 1); attempt >= 10 { - log.Info("Completed profiling", "attempt", attempt) - - return - } - - log.Info("Starting profiling in fill transactions", "number", number) - - dir, err := os.MkdirTemp("", fmt.Sprintf("bor-traces-%s-", time.Now().UTC().Format("2006-01-02-150405Z"))) - if err != nil { - log.Error("Error in profiling", "path", dir, "number", number, "err", err) - return - } - - // grab the cpu profile - closeFnInternal, err := startProfiler("cpu", dir, number) - if err != nil { - log.Error("Error in profiling", "path", dir, "number", number, "err", err) - return - } - - closeFn = func() error { - err := closeFnInternal() - - log.Info("Completed profiling", "path", dir, "number", number, "error", err) - - return nil - } - - case <-doneCh: - err := closeFn() - - if err != nil { - log.Info("closing fillTransactions", "number", number, "error", err) - } - - return - } - } - }(env.header.Number.Uint64()) - } - var ( localPlainTxs, remotePlainTxs, localBlobTxs, remoteBlobTxs map[common.Address][]*txpool.LazyTransaction ) - tracing.Exec(ctx, "", "worker.SplittingTransactions", func(ctx context.Context, span trace.Span) { - prePendingTime := time.Now() + filter.OnlyPlainTxs, filter.OnlyBlobTxs = true, false + pendingPlainTxs := w.eth.TxPool().Pending(filter) - filter.OnlyPlainTxs, filter.OnlyBlobTxs = true, false - pendingPlainTxs := w.eth.TxPool().Pending(filter) + filter.OnlyPlainTxs, filter.OnlyBlobTxs = false, true + pendingBlobTxs := w.eth.TxPool().Pending(filter) - filter.OnlyPlainTxs, filter.OnlyBlobTxs = false, true - pendingBlobTxs := w.eth.TxPool().Pending(filter) + // Split the pending transactions into locals and remotes. + localPlainTxs, remotePlainTxs = make(map[common.Address][]*txpool.LazyTransaction), pendingPlainTxs + localBlobTxs, remoteBlobTxs = make(map[common.Address][]*txpool.LazyTransaction), pendingBlobTxs - // Split the pending transactions into locals and remotes. - localPlainTxs, remotePlainTxs = make(map[common.Address][]*txpool.LazyTransaction), pendingPlainTxs - localBlobTxs, remoteBlobTxs = make(map[common.Address][]*txpool.LazyTransaction), pendingBlobTxs - - postPendingTime := time.Now() - - for _, account := range w.eth.TxPool().Locals() { - if txs := remotePlainTxs[account]; len(txs) > 0 { - delete(remotePlainTxs, account) - localPlainTxs[account] = txs - } - if txs := remoteBlobTxs[account]; len(txs) > 0 { - delete(remoteBlobTxs, account) - localBlobTxs[account] = txs - } + for _, account := range w.eth.TxPool().Locals() { + if txs := remotePlainTxs[account]; len(txs) > 0 { + delete(remotePlainTxs, account) + localPlainTxs[account] = txs } - - postLocalsTime := time.Now() - - tracing.SetAttributes( - span, - attribute.Int("len of local txs", localPlainTxsCount), - attribute.Int("len of remote txs", remotePlainTxsCount), - attribute.String("time taken by Pending()", fmt.Sprintf("%v", postPendingTime.Sub(prePendingTime))), - attribute.String("time taken by Locals()", fmt.Sprintf("%v", postLocalsTime.Sub(postPendingTime))), - ) - }) - - var ( - localEnvTCount int - remoteEnvTCount int - err error - ) + if txs := remoteBlobTxs[account]; len(txs) > 0 { + delete(remoteBlobTxs, account) + localBlobTxs[account] = txs + } + } // Fill the block with all available pending transactions. if len(localPlainTxs) > 0 || len(localBlobTxs) > 0 { var plainTxs, blobTxs *transactionsByPriceAndNonce - tracing.Exec(ctx, "", "worker.LocalTransactionsByPriceAndNonce", func(ctx context.Context, span trace.Span) { - plainTxs = newTransactionsByPriceAndNonce(env.signer, localPlainTxs, env.header.BaseFee) - blobTxs = newTransactionsByPriceAndNonce(env.signer, localBlobTxs, env.header.BaseFee) + plainTxs = newTransactionsByPriceAndNonce(env.signer, localPlainTxs, env.header.BaseFee) + blobTxs = newTransactionsByPriceAndNonce(env.signer, localBlobTxs, env.header.BaseFee) - tracing.SetAttributes( - span, - attribute.Int("len of tx local Heads", plainTxs.GetTxs()), - ) - }) - - tracing.Exec(ctx, "", "worker.LocalCommitTransactions", func(ctx context.Context, span trace.Span) { - err = w.commitTransactions(env, plainTxs, blobTxs, interrupt, new(uint256.Int), interruptCtx) - }) - - if err != nil { + if err := w.commitTransactions(env, plainTxs, blobTxs, interrupt, new(uint256.Int), interruptCtx); err != nil { return err } - - localEnvTCount = env.tcount } if len(remotePlainTxs) > 0 || len(remoteBlobTxs) > 0 { var plainTxs, blobTxs *transactionsByPriceAndNonce - tracing.Exec(ctx, "", "worker.RemoteTransactionsByPriceAndNonce", func(ctx context.Context, span trace.Span) { - plainTxs = newTransactionsByPriceAndNonce(env.signer, remotePlainTxs, env.header.BaseFee) - blobTxs = newTransactionsByPriceAndNonce(env.signer, remoteBlobTxs, env.header.BaseFee) + plainTxs = newTransactionsByPriceAndNonce(env.signer, remotePlainTxs, env.header.BaseFee) + blobTxs = newTransactionsByPriceAndNonce(env.signer, remoteBlobTxs, env.header.BaseFee) - tracing.SetAttributes( - span, - attribute.Int("len of tx remote Heads", plainTxs.GetTxs()), - ) - }) - - tracing.Exec(ctx, "", "worker.RemoteCommitTransactions", func(ctx context.Context, span trace.Span) { - err = w.commitTransactions(env, plainTxs, blobTxs, interrupt, new(uint256.Int), interruptCtx) - }) - - if err != nil { + if err := w.commitTransactions(env, plainTxs, blobTxs, interrupt, new(uint256.Int), interruptCtx); err != nil { return err } - - remoteEnvTCount = env.tcount } - tracing.SetAttributes( - span, - attribute.Int("len of final local txs ", localEnvTCount), - attribute.Int("len of final remote txs", remoteEnvTCount), - ) - return nil } // generateWork generates a sealing block based on the given parameters. -func (w *worker) generateWork(ctx context.Context, params *generateParams) *newPayloadResult { +func (w *worker) generateWork(params *generateParams) *newPayloadResult { work, err := w.prepareWork(params) if err != nil { return &newPayloadResult{err: err} @@ -1582,7 +1363,7 @@ func (w *worker) generateWork(ctx context.Context, params *generateParams) *newP }) defer timer.Stop() - err := w.fillTransactions(ctx, interrupt, work, interruptCtx) + err := w.fillTransactions(interrupt, work, interruptCtx) if errors.Is(err, errBlockInterruptedByTimeout) { log.Warn("Block building is interrupted", "allowance", common.PrettyDuration(w.newpayloadTimeout)) } @@ -1605,7 +1386,7 @@ func (w *worker) generateWork(ctx context.Context, params *generateParams) *newP // commitWork generates several new sealing tasks based on the parent block // and submit them to the sealer. -func (w *worker) commitWork(ctx context.Context, interrupt *atomic.Int32, noempty bool, timestamp int64) { +func (w *worker) commitWork(interrupt *atomic.Int32, noempty bool, timestamp int64) { // Abort committing if node is still syncing if w.syncing.Load() { return @@ -1617,23 +1398,20 @@ func (w *worker) commitWork(ctx context.Context, interrupt *atomic.Int32, noempt err error ) - tracing.Exec(ctx, "", "worker.prepareWork", func(ctx context.Context, span trace.Span) { - // Set the coinbase if the worker is running or it's required - var coinbase common.Address - if w.IsRunning() { - coinbase = w.etherbase() - if coinbase == (common.Address{}) { - log.Error("Refusing to mine without etherbase") - return - } + // Set the coinbase if the worker is running or it's required + var coinbase common.Address + if w.IsRunning() { + coinbase = w.etherbase() + if coinbase == (common.Address{}) { + log.Error("Refusing to mine without etherbase") + return } + } - work, err = w.prepareWork(&generateParams{ - timestamp: uint64(timestamp), - coinbase: coinbase, - }) + work, err = w.prepareWork(&generateParams{ + timestamp: uint64(timestamp), + coinbase: coinbase, }) - if err != nil { return } @@ -1648,26 +1426,18 @@ func (w *worker) commitWork(ctx context.Context, interrupt *atomic.Int32, noempt if !noempty && w.interruptCommitFlag { block := w.chain.GetBlockByHash(w.chain.CurrentBlock().Hash()) - interruptCtx, stopFn = getInterruptTimer(ctx, work, block) + interruptCtx, stopFn = getInterruptTimer(work, block) // nolint : staticcheck interruptCtx = vm.PutCache(interruptCtx, w.interruptedTxCache) } - ctx, span := tracing.StartSpan(ctx, "commitWork") - defer tracing.EndSpan(span) - - tracing.SetAttributes( - span, - attribute.Int("number", int(work.header.Number.Uint64())), - ) - // Create an empty block based on temporary copied state for // sealing in advance without waiting block execution finished. if !noempty && !w.noempty.Load() { - _ = w.commit(ctx, work.copy(), nil, false, start) + _ = w.commit(work.copy(), nil, false, start) } // Fill pending transactions from the txpool into the block. - err = w.fillTransactions(ctx, interrupt, work, interruptCtx) + err = w.fillTransactions(interrupt, work, interruptCtx) switch { case err == nil: @@ -1698,7 +1468,7 @@ func (w *worker) commitWork(ctx context.Context, interrupt *atomic.Int32, noempt return } // Submit the generated block for consensus sealing. - _ = w.commit(ctx, work.copy(), w.fullTaskHook, true, start) + _ = w.commit(work.copy(), w.fullTaskHook, true, start) // Swap out the old work with the new one, terminating any leftover // prefetcher processes in the mean time and starting a new one. @@ -1709,7 +1479,7 @@ func (w *worker) commitWork(ctx context.Context, interrupt *atomic.Int32, noempt w.current = work } -func getInterruptTimer(ctx context.Context, work *environment, current *types.Block) (context.Context, func()) { +func getInterruptTimer(work *environment, current *types.Block) (context.Context, func()) { delay := time.Until(time.Unix(int64(work.header.Time), 0)) interruptCtx, cancel := context.WithTimeout(context.Background(), delay) @@ -1717,13 +1487,10 @@ func getInterruptTimer(ctx context.Context, work *environment, current *types.Bl blockNumber := current.NumberU64() + 1 go func() { - select { - case <-interruptCtx.Done(): - if interruptCtx.Err() != context.Canceled { - log.Info("Commit Interrupt. Pre-committing the current block", "block", blockNumber) - cancel() - } - case <-ctx.Done(): // nothing to do + <-interruptCtx.Done() + if interruptCtx.Err() != context.Canceled { + log.Info("Commit Interrupt. Pre-committing the current block", "block", blockNumber) + cancel() } }() @@ -1734,11 +1501,8 @@ func getInterruptTimer(ctx context.Context, work *environment, current *types.Bl // and commits new work if consensus engine is running. // Note the assumption is held that the mutation is allowed to the passed env, do // the deep copy first. -func (w *worker) commit(ctx context.Context, env *environment, interval func(), update bool, start time.Time) error { +func (w *worker) commit(env *environment, interval func(), update bool, start time.Time) error { if w.IsRunning() { - ctx, span := tracing.StartSpan(ctx, "commit") - defer tracing.EndSpan(span) - if interval != nil { interval() } @@ -1749,21 +1513,13 @@ func (w *worker) commit(ctx context.Context, env *environment, interval func(), block, err := w.engine.FinalizeAndAssemble(w.chain, env.header, env.state, &types.Body{ Transactions: env.txs, }, env.receipts) - tracing.SetAttributes( - span, - attribute.Int("number", int(env.header.Number.Uint64())), - attribute.String("hash", env.header.Hash().String()), - attribute.String("sealhash", w.engine.SealHash(env.header).String()), - attribute.Int("len of env.txs", len(env.txs)), - attribute.Bool("error", err != nil), - ) if err != nil { return err } select { - case w.taskCh <- &task{ctx: ctx, receipts: env.receipts, state: env.state, block: block, createdAt: time.Now()}: + case w.taskCh <- &task{receipts: env.receipts, state: env.state, block: block, createdAt: time.Now()}: fees := totalFees(block, env.receipts) feesInEther := new(big.Float).Quo(new(big.Float).SetInt(fees), big.NewFloat(params.Ether)) log.Info("Commit new sealing work", "number", block.Number(), "sealhash", w.engine.SealHash(block.Header()), diff --git a/tests/bor/helper.go b/tests/bor/helper.go index 73775401d6..917d9bf520 100644 --- a/tests/bor/helper.go +++ b/tests/bor/helper.go @@ -3,7 +3,6 @@ package bor import ( - "context" "crypto/ecdsa" "encoding/hex" "encoding/json" @@ -219,8 +218,6 @@ func buildNextBlock(t *testing.T, _bor consensus.Engine, chain *core.BlockChain, b.addTxWithChain(chain, state, tx, addr) } - ctx := context.Background() - // Finalize and seal the block block, err := _bor.FinalizeAndAssemble(chain, b.header, state, &types.Body{ Transactions: b.txs, @@ -242,7 +239,7 @@ func buildNextBlock(t *testing.T, _bor consensus.Engine, chain *core.BlockChain, res := make(chan *types.Block, 1) - err = _bor.Seal(ctx, chain, block, res, nil) + err = _bor.Seal(chain, block, res, nil) if err != nil { // an error case - sign manually sign(t, header, signer, borConfig) From 8a1e0ec1255131db86a65505059646bb14ef5e95 Mon Sep 17 00:00:00 2001 From: Manav Darji Date: Thu, 30 Jan 2025 23:01:27 +0530 Subject: [PATCH 11/15] Enforce parallel evm via flag (#1425) * (feat): implement --parallelevm.enforce to force using block-stm * core: debug log * docs: update docs with new flag * update all config files * core: modify chain import test to enforce parallel processing --- builder/files/config.toml | 1 + core/blockchain.go | 13 ++++++++++--- core/blockchain_test.go | 11 ++++++++--- core/parallel_state_processor.go | 1 + docs/cli/example_config.toml | 5 +++++ docs/cli/server.md | 2 ++ eth/backend.go | 2 +- internal/cli/server/config.go | 4 ++++ internal/cli/server/flags.go | 7 +++++++ internal/cli/server/testdata/default.toml | 1 + miner/worker_test.go | 2 +- packaging/templates/mainnet-v1/archive/config.toml | 5 +++++ .../mainnet-v1/sentry/sentry/bor/config.toml | 5 +++++ .../mainnet-v1/sentry/sentry/bor/pbss_config.toml | 5 +++++ .../mainnet-v1/sentry/validator/bor/config.toml | 5 +++++ .../sentry/validator/bor/pbss_config.toml | 5 +++++ .../mainnet-v1/without-sentry/bor/config.toml | 5 +++++ .../mainnet-v1/without-sentry/bor/pbss_config.toml | 5 +++++ .../templates/testnet-amoy/archive/config.toml | 5 +++++ .../testnet-amoy/sentry/sentry/bor/config.toml | 5 +++++ .../testnet-amoy/sentry/sentry/bor/pbss_config.toml | 5 +++++ .../testnet-amoy/sentry/validator/bor/config.toml | 5 +++++ .../sentry/validator/bor/pbss_config.toml | 5 +++++ .../testnet-amoy/without-sentry/bor/config.toml | 5 +++++ .../without-sentry/bor/pbss_config.toml | 5 +++++ 25 files changed, 111 insertions(+), 8 deletions(-) diff --git a/builder/files/config.toml b/builder/files/config.toml index a903735e9c..a875a237e3 100644 --- a/builder/files/config.toml +++ b/builder/files/config.toml @@ -179,6 +179,7 @@ syncmode = "full" # [parallelevm] # enable = true # procs = 8 + # enforce = false # [pprof] # pprof = false diff --git a/core/blockchain.go b/core/blockchain.go index a37e4a5f1e..b293f8d4ef 100644 --- a/core/blockchain.go +++ b/core/blockchain.go @@ -281,6 +281,7 @@ type BlockChain struct { processor Processor // Block transaction processor interface parallelProcessor Processor // Parallel block transaction processor interface parallelSpeculativeProcesses int // Number of parallel speculative processes + enforceParallelProcessor bool forker *ForkChoice vmConfig vm.Config logger *tracing.Hooks @@ -551,7 +552,7 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis } // NewParallelBlockChain , similar to NewBlockChain, creates a new blockchain object, but with a parallel state processor -func NewParallelBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis, overrides *ChainOverrides, engine consensus.Engine, vmConfig vm.Config, shouldPreserve func(header *types.Header) bool, txLookupLimit *uint64, checker ethereum.ChainValidator, numprocs int) (*BlockChain, error) { +func NewParallelBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis, overrides *ChainOverrides, engine consensus.Engine, vmConfig vm.Config, shouldPreserve func(header *types.Header) bool, txLookupLimit *uint64, checker ethereum.ChainValidator, numprocs int, enforce bool) (*BlockChain, error) { bc, err := NewBlockChain(db, cacheConfig, genesis, overrides, engine, vmConfig, shouldPreserve, txLookupLimit, checker) if err != nil { @@ -569,6 +570,7 @@ func NewParallelBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis bc.parallelProcessor = NewParallelStateProcessor(chainConfig, bc, engine) bc.parallelSpeculativeProcesses = numprocs + bc.enforceParallelProcessor = enforce return bc, nil } @@ -604,7 +606,12 @@ func (bc *BlockChain) ProcessBlock(block *types.Block, parent *types.Header) (_ parallel bool } - resultChan := make(chan Result, 2) + var resultChanLen int = 2 + if bc.enforceParallelProcessor { + log.Debug("Processing block using Block STM only", "number", block.NumberU64()) + resultChanLen = 1 + } + resultChan := make(chan Result, resultChanLen) processorCount := 0 @@ -631,7 +638,7 @@ func (bc *BlockChain) ProcessBlock(block *types.Block, parent *types.Header) (_ }() } - if bc.processor != nil { + if bc.processor != nil && !bc.enforceParallelProcessor { statedb, err := state.New(parent.Root, bc.stateCache, bc.snaps) if err != nil { return nil, nil, 0, nil, 0, err diff --git a/core/blockchain_test.go b/core/blockchain_test.go index 47738f2bc6..2ce78bc936 100644 --- a/core/blockchain_test.go +++ b/core/blockchain_test.go @@ -195,11 +195,14 @@ func testBlockChainImport(chain types.Blocks, blockchain *BlockChain) error { func TestParallelBlockChainImport(t *testing.T) { t.Parallel() - testParallelBlockChainImport(t, rawdb.HashScheme) - testParallelBlockChainImport(t, rawdb.PathScheme) + testParallelBlockChainImport(t, rawdb.HashScheme, false) + testParallelBlockChainImport(t, rawdb.PathScheme, false) + + testParallelBlockChainImport(t, rawdb.HashScheme, true) + testParallelBlockChainImport(t, rawdb.PathScheme, true) } -func testParallelBlockChainImport(t *testing.T, scheme string) { +func testParallelBlockChainImport(t *testing.T, scheme string, enforceParallelProcessor bool) { db, _, blockchain, err := newCanonical(ethash.NewFaker(), 10, true, scheme) blockchain.parallelProcessor = NewParallelStateProcessor(blockchain.chainConfig, blockchain, blockchain.engine) @@ -207,6 +210,8 @@ func testParallelBlockChainImport(t *testing.T, scheme string) { t.Fatalf("failed to make new canonical chain: %v", err) } + // If required, enforce parallel block processing and skip serial processing completely + blockchain.enforceParallelProcessor = enforceParallelProcessor defer blockchain.Stop() block := blockchain.GetBlockByHash(blockchain.CurrentBlock().Hash()) diff --git a/core/parallel_state_processor.go b/core/parallel_state_processor.go index f521764d28..33ca8595e9 100644 --- a/core/parallel_state_processor.go +++ b/core/parallel_state_processor.go @@ -40,6 +40,7 @@ import ( type ParallelEVMConfig struct { Enable bool SpeculativeProcesses int + Enforce bool } // StateProcessor is a basic Processor, which takes care of transitioning diff --git a/docs/cli/example_config.toml b/docs/cli/example_config.toml index b656a6dc3f..ffc822cc64 100644 --- a/docs/cli/example_config.toml +++ b/docs/cli/example_config.toml @@ -181,6 +181,11 @@ devfakeauthor = false # Run miner without validator set authorization period = 0 # Block period to use in developer mode (0 = mine only if transaction pending) gaslimit = 11500000 # Initial block gas limit +[parallelevm] + enable = true # Enables parallel execution using Block STM + procs = 8 # Number of speculative processes (cores) in Block STM + enforce = false # Use only Block STM for execution and skip serial execution + [pprof] pprof = false # Enable the pprof HTTP server port = 6060 # pprof HTTP server listening port diff --git a/docs/cli/server.md b/docs/cli/server.md index 530ca22975..4c4c86b004 100644 --- a/docs/cli/server.md +++ b/docs/cli/server.md @@ -66,6 +66,8 @@ The ```bor server``` command runs the Bor client. - ```parallelevm.enable```: Enable Block STM (default: true) +- ```parallelevm.enforce```: Enforce block processing via Block STM (default: false) + - ```parallelevm.procs```: Number of speculative processes (cores) in Block STM (default: 8) - ```pprof```: Enable the pprof HTTP server (default: false) diff --git a/eth/backend.go b/eth/backend.go index 818d45cb73..ec50394ca0 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -258,7 +258,7 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) { // check if Parallel EVM is enabled // if enabled, use parallel state processor if config.ParallelEVM.Enable { - eth.blockchain, err = core.NewParallelBlockChain(chainDb, cacheConfig, config.Genesis, &overrides, eth.engine, vmConfig, eth.shouldPreserve, &config.TxLookupLimit, checker, config.ParallelEVM.SpeculativeProcesses) + eth.blockchain, err = core.NewParallelBlockChain(chainDb, cacheConfig, config.Genesis, &overrides, eth.engine, vmConfig, eth.shouldPreserve, &config.TxLookupLimit, checker, config.ParallelEVM.SpeculativeProcesses, config.ParallelEVM.Enforce) } else { eth.blockchain, err = core.NewBlockChain(chainDb, cacheConfig, config.Genesis, &overrides, eth.engine, vmConfig, eth.shouldPreserve, &config.TxLookupLimit, checker) } diff --git a/internal/cli/server/config.go b/internal/cli/server/config.go index 42ad1f20af..1f6e451dbf 100644 --- a/internal/cli/server/config.go +++ b/internal/cli/server/config.go @@ -597,6 +597,8 @@ type ParallelEVMConfig struct { Enable bool `hcl:"enable,optional" toml:"enable,optional"` SpeculativeProcesses int `hcl:"procs,optional" toml:"procs,optional"` + + Enforce bool `hcl:"enforce,optional" toml:"enforce,optional"` } func DefaultConfig() *Config { @@ -794,6 +796,7 @@ func DefaultConfig() *Config { ParallelEVM: &ParallelEVMConfig{ Enable: true, SpeculativeProcesses: 8, + Enforce: false, }, } } @@ -1199,6 +1202,7 @@ func (c *Config) buildEth(stack *node.Node, accountManager *accounts.Manager) (* n.ParallelEVM.Enable = c.ParallelEVM.Enable n.ParallelEVM.SpeculativeProcesses = c.ParallelEVM.SpeculativeProcesses + n.ParallelEVM.Enforce = c.ParallelEVM.Enforce n.RPCReturnDataLimit = c.RPCReturnDataLimit if c.Ancient != "" { diff --git a/internal/cli/server/flags.go b/internal/cli/server/flags.go index 0cf8919b9d..25fc6ce7ba 100644 --- a/internal/cli/server/flags.go +++ b/internal/cli/server/flags.go @@ -986,6 +986,13 @@ func (c *Command) Flags(config *Config) *flagset.Flagset { Value: &c.cliConfig.ParallelEVM.SpeculativeProcesses, Default: c.cliConfig.ParallelEVM.SpeculativeProcesses, }) + f.BoolFlag(&flagset.BoolFlag{ + Name: "parallelevm.enforce", + Usage: "Enforce block processing via Block STM", + Value: &c.cliConfig.ParallelEVM.Enforce, + Default: c.cliConfig.ParallelEVM.Enforce, + }) + f.Uint64Flag(&flagset.Uint64Flag{ Name: "dev.gaslimit", Usage: "Initial block gas limit", diff --git a/internal/cli/server/testdata/default.toml b/internal/cli/server/testdata/default.toml index fc4c04ab86..5f95769546 100644 --- a/internal/cli/server/testdata/default.toml +++ b/internal/cli/server/testdata/default.toml @@ -185,6 +185,7 @@ devfakeauthor = false [parallelevm] enable = true procs = 8 + enforce = false [pprof] pprof = false diff --git a/miner/worker_test.go b/miner/worker_test.go index 1f90c79ec1..1d1fcc32f5 100644 --- a/miner/worker_test.go +++ b/miner/worker_test.go @@ -973,7 +973,7 @@ func BenchmarkBorMiningBlockSTMMetadata(b *testing.B) { db2 := rawdb.NewMemoryDatabase() back.genesis.MustCommit(db2, triedb.NewDatabase(db2, triedb.HashDefaults)) - chain, _ := core.NewParallelBlockChain(db2, nil, back.genesis, nil, engine, vm.Config{}, nil, nil, nil, 8) + chain, _ := core.NewParallelBlockChain(db2, nil, back.genesis, nil, engine, vm.Config{}, nil, nil, nil, 8, false) defer chain.Stop() // Ignore empty commit here for less noise. diff --git a/packaging/templates/mainnet-v1/archive/config.toml b/packaging/templates/mainnet-v1/archive/config.toml index 311c4bc782..0a5c0e1017 100644 --- a/packaging/templates/mainnet-v1/archive/config.toml +++ b/packaging/templates/mainnet-v1/archive/config.toml @@ -169,6 +169,11 @@ gcmode = "archive" # period = 0 # gaslimit = 11500000 +# [parallelevm] + # enable = true + # procs = 8 + # enforce = false + # [pprof] # pprof = false # port = 6060 diff --git a/packaging/templates/mainnet-v1/sentry/sentry/bor/config.toml b/packaging/templates/mainnet-v1/sentry/sentry/bor/config.toml index 556c551092..d4fd25e863 100644 --- a/packaging/templates/mainnet-v1/sentry/sentry/bor/config.toml +++ b/packaging/templates/mainnet-v1/sentry/sentry/bor/config.toml @@ -168,6 +168,11 @@ syncmode = "full" # period = 0 # gaslimit = 11500000 +# [parallelevm] + # enable = true + # procs = 8 + # enforce = false + # [pprof] # pprof = false # port = 6060 diff --git a/packaging/templates/mainnet-v1/sentry/sentry/bor/pbss_config.toml b/packaging/templates/mainnet-v1/sentry/sentry/bor/pbss_config.toml index 7a11e6a7d2..20edf749dc 100644 --- a/packaging/templates/mainnet-v1/sentry/sentry/bor/pbss_config.toml +++ b/packaging/templates/mainnet-v1/sentry/sentry/bor/pbss_config.toml @@ -170,6 +170,11 @@ syncmode = "full" # period = 0 # gaslimit = 11500000 +# [parallelevm] + # enable = true + # procs = 8 + # enforce = false + # [pprof] # pprof = false # port = 6060 diff --git a/packaging/templates/mainnet-v1/sentry/validator/bor/config.toml b/packaging/templates/mainnet-v1/sentry/validator/bor/config.toml index 12d27d2537..a839551c02 100644 --- a/packaging/templates/mainnet-v1/sentry/validator/bor/config.toml +++ b/packaging/templates/mainnet-v1/sentry/validator/bor/config.toml @@ -170,6 +170,11 @@ syncmode = "full" # period = 0 # gaslimit = 11500000 +# [parallelevm] + # enable = true + # procs = 8 + # enforce = false + # [pprof] # pprof = false # port = 6060 diff --git a/packaging/templates/mainnet-v1/sentry/validator/bor/pbss_config.toml b/packaging/templates/mainnet-v1/sentry/validator/bor/pbss_config.toml index 75954b38e6..3f4da5d4f8 100644 --- a/packaging/templates/mainnet-v1/sentry/validator/bor/pbss_config.toml +++ b/packaging/templates/mainnet-v1/sentry/validator/bor/pbss_config.toml @@ -172,6 +172,11 @@ syncmode = "full" # period = 0 # gaslimit = 11500000 +# [parallelevm] + # enable = true + # procs = 8 + # enforce = false + # [pprof] # pprof = false # port = 6060 diff --git a/packaging/templates/mainnet-v1/without-sentry/bor/config.toml b/packaging/templates/mainnet-v1/without-sentry/bor/config.toml index e77c368459..564dc6bbaa 100644 --- a/packaging/templates/mainnet-v1/without-sentry/bor/config.toml +++ b/packaging/templates/mainnet-v1/without-sentry/bor/config.toml @@ -170,6 +170,11 @@ syncmode = "full" # period = 0 # gaslimit = 11500000 +# [parallelevm] + # enable = true + # procs = 8 + # enforce = false + # [pprof] # pprof = false # port = 6060 diff --git a/packaging/templates/mainnet-v1/without-sentry/bor/pbss_config.toml b/packaging/templates/mainnet-v1/without-sentry/bor/pbss_config.toml index 20a5b02f0a..06c4b6b018 100644 --- a/packaging/templates/mainnet-v1/without-sentry/bor/pbss_config.toml +++ b/packaging/templates/mainnet-v1/without-sentry/bor/pbss_config.toml @@ -171,6 +171,11 @@ syncmode = "full" # period = 0 # gaslimit = 11500000 +# [parallelevm] + # enable = true + # procs = 8 + # enforce = false + # [pprof] # pprof = false # port = 6060 diff --git a/packaging/templates/testnet-amoy/archive/config.toml b/packaging/templates/testnet-amoy/archive/config.toml index 7fb2f21476..b571074496 100644 --- a/packaging/templates/testnet-amoy/archive/config.toml +++ b/packaging/templates/testnet-amoy/archive/config.toml @@ -168,6 +168,11 @@ gcmode = "archive" # period = 0 # gaslimit = 11500000 +# [parallelevm] + # enable = true + # procs = 8 + # enforce = false + # [pprof] # pprof = false # port = 6060 diff --git a/packaging/templates/testnet-amoy/sentry/sentry/bor/config.toml b/packaging/templates/testnet-amoy/sentry/sentry/bor/config.toml index 0007e22955..2b98c30cb3 100644 --- a/packaging/templates/testnet-amoy/sentry/sentry/bor/config.toml +++ b/packaging/templates/testnet-amoy/sentry/sentry/bor/config.toml @@ -167,6 +167,11 @@ syncmode = "full" # period = 0 # gaslimit = 11500000 +# [parallelevm] + # enable = true + # procs = 8 + # enforce = false + # [pprof] # pprof = false # port = 6060 diff --git a/packaging/templates/testnet-amoy/sentry/sentry/bor/pbss_config.toml b/packaging/templates/testnet-amoy/sentry/sentry/bor/pbss_config.toml index 6f72c5a3b2..f1b8cabbfe 100644 --- a/packaging/templates/testnet-amoy/sentry/sentry/bor/pbss_config.toml +++ b/packaging/templates/testnet-amoy/sentry/sentry/bor/pbss_config.toml @@ -168,6 +168,11 @@ syncmode = "full" # period = 0 # gaslimit = 11500000 +# [parallelevm] + # enable = true + # procs = 8 + # enforce = false + # [pprof] # pprof = false # port = 6060 diff --git a/packaging/templates/testnet-amoy/sentry/validator/bor/config.toml b/packaging/templates/testnet-amoy/sentry/validator/bor/config.toml index 9e0eec562a..c4db9aed12 100644 --- a/packaging/templates/testnet-amoy/sentry/validator/bor/config.toml +++ b/packaging/templates/testnet-amoy/sentry/validator/bor/config.toml @@ -169,6 +169,11 @@ syncmode = "full" # period = 0 # gaslimit = 11500000 +# [parallelevm] + # enable = true + # procs = 8 + # enforce = false + # pprof = false # port = 6060 # addr = "127.0.0.1" diff --git a/packaging/templates/testnet-amoy/sentry/validator/bor/pbss_config.toml b/packaging/templates/testnet-amoy/sentry/validator/bor/pbss_config.toml index 5a58afd786..bbe422907a 100644 --- a/packaging/templates/testnet-amoy/sentry/validator/bor/pbss_config.toml +++ b/packaging/templates/testnet-amoy/sentry/validator/bor/pbss_config.toml @@ -170,6 +170,11 @@ syncmode = "full" # period = 0 # gaslimit = 11500000 +# [parallelevm] + # enable = true + # procs = 8 + # enforce = false + # pprof = false # port = 6060 # addr = "127.0.0.1" diff --git a/packaging/templates/testnet-amoy/without-sentry/bor/config.toml b/packaging/templates/testnet-amoy/without-sentry/bor/config.toml index fa9f1970e8..cd8f6ef2a8 100644 --- a/packaging/templates/testnet-amoy/without-sentry/bor/config.toml +++ b/packaging/templates/testnet-amoy/without-sentry/bor/config.toml @@ -169,6 +169,11 @@ syncmode = "full" # period = 0 # gaslimit = 11500000 +# [parallelevm] + # enable = true + # procs = 8 + # enforce = false + # [pprof] # pprof = false # port = 6060 diff --git a/packaging/templates/testnet-amoy/without-sentry/bor/pbss_config.toml b/packaging/templates/testnet-amoy/without-sentry/bor/pbss_config.toml index 9b16fd2035..8ea23b8870 100644 --- a/packaging/templates/testnet-amoy/without-sentry/bor/pbss_config.toml +++ b/packaging/templates/testnet-amoy/without-sentry/bor/pbss_config.toml @@ -170,6 +170,11 @@ syncmode = "full" # period = 0 # gaslimit = 11500000 +# [parallelevm] + # enable = true + # procs = 8 + # enforce = false + # [pprof] # pprof = false # port = 6060 From a2f545573c16dccbf73b4374c3d21021da3ccbd8 Mon Sep 17 00:00:00 2001 From: Manav Darji Date: Thu, 30 Jan 2025 23:07:58 +0530 Subject: [PATCH 12/15] miner: get rid of test_backend helper functions (#1424) * initial work for removing tracing from worker * fix more things * miner: sync code with worker.go, remove traces * fix lint * miner, core: get rid of test_backend helper functions * miner: handle delay during tests in block building * fix lint * miner: reset context to get rid of parent timeout context * miner: refactor test --- core/txindexer_test.go | 2 + core/vm/interpreter.go | 6 +- miner/test_backend.go | 665 ----------------------------------------- miner/worker.go | 83 +++-- miner/worker_test.go | 18 +- 5 files changed, 66 insertions(+), 708 deletions(-) delete mode 100644 miner/test_backend.go diff --git a/core/txindexer_test.go b/core/txindexer_test.go index ca1c86a055..cfbec850ef 100644 --- a/core/txindexer_test.go +++ b/core/txindexer_test.go @@ -71,9 +71,11 @@ func TestTxIndexer(t *testing.T) { } verify := func(db ethdb.Database, expTail uint64, indexer *txIndexer) { tail := rawdb.ReadTxIndexTail(db) + //nolint: staticcheck if tail == nil { t.Fatal("Failed to write tx index tail") } + //nolint: staticcheck if *tail != expTail { t.Fatalf("Unexpected tx index tail, want %v, got %d", expTail, *tail) } diff --git a/core/vm/interpreter.go b/core/vm/interpreter.go index 67d247a46f..a7fca75302 100644 --- a/core/vm/interpreter.go +++ b/core/vm/interpreter.go @@ -41,10 +41,12 @@ var ( ErrNoCurrentTx = errors.New("no current tx found in interruptCtx") ) +type InterruptKeyType string + const ( // These are keys for the interruptCtx - InterruptCtxDelayKey = "delay" - InterruptCtxOpcodeDelayKey = "opcodeDelay" + InterruptCtxDelayKey InterruptKeyType = "delay" + InterruptCtxOpcodeDelayKey InterruptKeyType = "opcodeDelay" // InterruptedTxCacheSize is size of lru cache for interrupted txs InterruptedTxCacheSize = 90000 diff --git a/miner/test_backend.go b/miner/test_backend.go deleted file mode 100644 index a91422cde1..0000000000 --- a/miner/test_backend.go +++ /dev/null @@ -1,665 +0,0 @@ -package miner - -import ( - "context" - "errors" - "sync" - "sync/atomic" - "time" - - // nolint:typecheck - - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/consensus" - "github.com/ethereum/go-ethereum/consensus/misc/eip4844" - "github.com/ethereum/go-ethereum/core" - "github.com/ethereum/go-ethereum/core/blockstm" - "github.com/ethereum/go-ethereum/core/state" - "github.com/ethereum/go-ethereum/core/txpool" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/core/vm" - "github.com/ethereum/go-ethereum/event" - "github.com/ethereum/go-ethereum/log" - "github.com/ethereum/go-ethereum/params" - "github.com/ethereum/go-ethereum/rlp" - "github.com/holiman/uint256" - - lru "github.com/hashicorp/golang-lru" -) - -// newWorkerWithDelay is newWorker() with extra params to induce artficial delays for tests such as commit-interrupt. -// nolint:staticcheck -func newWorkerWithDelay(config *Config, chainConfig *params.ChainConfig, engine consensus.Engine, eth Backend, mux *event.TypeMux, isLocalBlock func(header *types.Header) bool, init bool, delay uint, opcodeDelay uint) *worker { - worker := &worker{ - config: config, - chainConfig: chainConfig, - engine: engine, - eth: eth, - chain: eth.BlockChain(), - mux: mux, - isLocalBlock: isLocalBlock, - coinbase: config.Etherbase, - extra: config.ExtraData, - pendingTasks: make(map[common.Hash]*task), - txsCh: make(chan core.NewTxsEvent, txChanSize), - chainHeadCh: make(chan core.ChainHeadEvent, chainHeadChanSize), - newWorkCh: make(chan *newWorkReq), - getWorkCh: make(chan *getWorkReq), - taskCh: make(chan *task), - resultCh: make(chan *types.Block, resultQueueSize), - startCh: make(chan struct{}, 1), - exitCh: make(chan struct{}), - resubmitIntervalCh: make(chan time.Duration), - resubmitAdjustCh: make(chan *intervalAdjust, resubmitAdjustChanSize), - interruptCommitFlag: config.CommitInterruptFlag, - } - worker.noempty.Store(true) - worker.profileCount = new(int32) - // Subscribe for transaction insertion events (whether from network or resurrects) - worker.txsSub = eth.TxPool().SubscribeTransactions(worker.txsCh, true) - // Subscribe events for blockchain - worker.chainHeadSub = eth.BlockChain().SubscribeChainHeadEvent(worker.chainHeadCh) - - interruptedTxCache, err := lru.New(vm.InterruptedTxCacheSize) - if err != nil { - log.Warn("Failed to create interrupted tx cache", "err", err) - } - - worker.interruptedTxCache = &vm.TxCache{ - Cache: interruptedTxCache, - } - - if !worker.interruptCommitFlag { - worker.noempty.Store(false) - } - - // Sanitize recommit interval if the user-specified one is too short. - recommit := worker.config.Recommit - if recommit < minRecommitInterval { - log.Warn("Sanitizing miner recommit interval", "provided", recommit, "updated", minRecommitInterval) - recommit = minRecommitInterval - } - - worker.recommit = recommit - - // Sanitize the timeout config for creating payload. - newpayloadTimeout := worker.config.NewPayloadTimeout - if newpayloadTimeout == 0 { - log.Warn("Sanitizing new payload timeout to default", "provided", newpayloadTimeout, "updated", DefaultConfig.NewPayloadTimeout) - newpayloadTimeout = DefaultConfig.NewPayloadTimeout - } - - if newpayloadTimeout < time.Millisecond*100 { - log.Warn("Low payload timeout may cause high amount of non-full blocks", "provided", newpayloadTimeout, "default", DefaultConfig.NewPayloadTimeout) - } - - worker.newpayloadTimeout = newpayloadTimeout - - worker.wg.Add(4) - - go worker.mainLoopWithDelay(delay, opcodeDelay) - go worker.newWorkLoop(recommit) - go worker.resultLoop() - go worker.taskLoop() - - // Submit first work to initialize pending state. - if init { - worker.startCh <- struct{}{} - } - - return worker -} - -// mainLoopWithDelay is mainLoop() with extra params to induce artficial delays for tests such as commit-interrupt. -// nolint:gocognit -func (w *worker) mainLoopWithDelay(delay uint, opcodeDelay uint) { - defer w.wg.Done() - defer w.txsSub.Unsubscribe() - defer w.chainHeadSub.Unsubscribe() - defer func() { - if w.current != nil { - w.current.discard() - } - }() - - for { - select { - case req := <-w.newWorkCh: - if w.chainConfig.ChainID.Cmp(params.BorMainnetChainConfig.ChainID) == 0 || w.chainConfig.ChainID.Cmp(params.MumbaiChainConfig.ChainID) == 0 { - if w.eth.PeerCount() > 0 { - //nolint:contextcheck - w.commitWorkWithDelay(req.interrupt, req.noempty, req.timestamp, delay, opcodeDelay) - } - } else { - //nolint:contextcheck - w.commitWorkWithDelay(req.interrupt, req.noempty, req.timestamp, delay, opcodeDelay) - } - - case req := <-w.getWorkCh: - req.result <- w.generateWork(req.params) - - case ev := <-w.txsCh: - // Apply transactions to the pending state if we're not sealing - // - // Note all transactions received may not be continuous with transactions - // already included in the current sealing block. These transactions will - // be automatically eliminated. - // nolint : nestif - if !w.IsRunning() && w.current != nil { - // If block is already full, abort - if gp := w.current.gasPool; gp != nil && gp.Gas() < params.TxGas { - continue - } - txs := make(map[common.Address][]*txpool.LazyTransaction, len(ev.Txs)) - for _, tx := range ev.Txs { - acc, _ := types.Sender(w.current.signer, tx) - txs[acc] = append(txs[acc], &txpool.LazyTransaction{ - Pool: w.eth.TxPool(), // We don't know where this came from, yolo resolve from everywhere - Hash: tx.Hash(), - Tx: nil, // Do *not* set this! We need to resolve it later to pull blobs in - Time: tx.Time(), - GasFeeCap: uint256.NewInt(tx.GasFeeCap().Uint64()), - GasTipCap: uint256.NewInt(tx.GasTipCap().Uint64()), - Gas: tx.Gas(), - BlobGas: tx.BlobGas(), - }) - } - txset := newTransactionsByPriceAndNonce(w.current.signer, txs, w.current.header.BaseFee) - tcount := w.current.tcount - w.commitTransactions(w.current, txset, nil, nil, new(uint256.Int), context.Background()) - - // Only update the snapshot if any new transactons were added - // to the pending block - if tcount != w.current.tcount { - w.updateSnapshot(w.current) - } - } else { - // Special case, if the consensus engine is 0 period clique(dev mode), - // submit sealing work here since all empty submission will be rejected - // by clique. Of course the advance sealing(empty submission) is disabled. - if w.chainConfig.Clique != nil && w.chainConfig.Clique.Period == 0 { - w.commitWork(nil, true, time.Now().Unix()) - } - } - - w.newTxs.Add(int32(len(ev.Txs))) - - // System stopped - case <-w.exitCh: - return - case <-w.txsSub.Err(): - return - case <-w.chainHeadSub.Err(): - return - } - } -} - -// commitWorkWithDelay is commitWork() with extra params to induce artficial delays for tests such as commit-interrupt. -func (w *worker) commitWorkWithDelay(interrupt *atomic.Int32, noempty bool, timestamp int64, delay uint, opcodeDelay uint) { - // Abort committing if node is still syncing - if w.syncing.Load() { - return - } - start := time.Now() - - var ( - work *environment - err error - ) - - // Set the coinbase if the worker is running or it's required - var coinbase common.Address - if w.IsRunning() { - coinbase = w.etherbase() - if coinbase == (common.Address{}) { - log.Error("Refusing to mine without etherbase") - return - } - } - - work, err = w.prepareWork(&generateParams{ - timestamp: uint64(timestamp), - coinbase: coinbase, - }) - if err != nil { - return - } - - // nolint:contextcheck - var interruptCtx = context.Background() - - stopFn := func() {} - defer func() { - stopFn() - }() - - if !noempty && w.interruptCommitFlag { - block := w.chain.GetBlockByHash(w.chain.CurrentBlock().Hash()) - interruptCtx, stopFn = getInterruptTimer(work, block) - // nolint : staticcheck - interruptCtx = vm.PutCache(interruptCtx, w.interruptedTxCache) - // nolint : staticcheck - interruptCtx = context.WithValue(interruptCtx, vm.InterruptCtxDelayKey, delay) - // nolint : staticcheck - interruptCtx = context.WithValue(interruptCtx, vm.InterruptCtxOpcodeDelayKey, opcodeDelay) - } - - // Create an empty block based on temporary copied state for - // sealing in advance without waiting block execution finished. - if !noempty && !w.noempty.Load() { - _ = w.commit(work.copy(), nil, false, start) - } - // Fill pending transactions from the txpool into the block. - err = w.fillTransactionsWithDelay(interrupt, work, interruptCtx) - - switch { - case err == nil: - // The entire block is filled, decrease resubmit interval in case - // of current interval is larger than the user-specified one. - w.resubmitAdjustCh <- &intervalAdjust{inc: false} - - case errors.Is(err, errBlockInterruptedByRecommit): - // Notify resubmit loop to increase resubmitting interval if the - // interruption is due to frequent commits. - gaslimit := work.header.GasLimit - - ratio := float64(gaslimit-work.gasPool.Gas()) / float64(gaslimit) - if ratio < 0.1 { - ratio = 0.1 - } - w.resubmitAdjustCh <- &intervalAdjust{ - ratio: ratio, - inc: true, - } - - case errors.Is(err, errBlockInterruptedByNewHead): - // If the block building is interrupted by newhead event, discard it - // totally. Committing the interrupted block introduces unnecessary - // delay, and possibly causes miner to mine on the previous head, - // which could result in higher uncle rate. - work.discard() - return - } - // Submit the generated block for consensus sealing. - _ = w.commit(work.copy(), w.fullTaskHook, true, start) - - // Swap out the old work with the new one, terminating any leftover - // prefetcher processes in the mean time and starting a new one. - if w.current != nil { - w.current.discard() - } - - w.current = work -} - -// fillTransactionsWithDelay is fillTransactions() with extra params to induce artficial delays for tests such as commit-interrupt. -// nolint:gocognit -func (w *worker) fillTransactionsWithDelay(interrupt *atomic.Int32, env *environment, interruptCtx context.Context) error { - w.mu.RLock() - tip := w.tip - w.mu.RUnlock() - - // Retrieve the pending transactions pre-filtered by the 1559/4844 dynamic fees - filter := txpool.PendingFilter{ - MinTip: uint256.MustFromBig(tip.ToBig()), - } - - if env.header.BaseFee != nil { - filter.BaseFee = uint256.MustFromBig(env.header.BaseFee) - } - - if env.header.ExcessBlobGas != nil { - filter.BlobFee = uint256.MustFromBig(eip4844.CalcBlobFee(*env.header.ExcessBlobGas)) - } - - var ( - localPlainTxs, remotePlainTxs, localBlobTxs, remoteBlobTxs map[common.Address][]*txpool.LazyTransaction - ) - - filter.OnlyPlainTxs, filter.OnlyBlobTxs = true, false - pendingPlainTxs := w.eth.TxPool().Pending(filter) - - filter.OnlyPlainTxs, filter.OnlyBlobTxs = false, true - pendingBlobTxs := w.eth.TxPool().Pending(filter) - - // Split the pending transactions into locals and remotes. - localPlainTxs, remotePlainTxs = make(map[common.Address][]*txpool.LazyTransaction), pendingPlainTxs - localBlobTxs, remoteBlobTxs = make(map[common.Address][]*txpool.LazyTransaction), pendingBlobTxs - - for _, account := range w.eth.TxPool().Locals() { - if txs := remotePlainTxs[account]; len(txs) > 0 { - delete(remotePlainTxs, account) - localPlainTxs[account] = txs - } - if txs := remoteBlobTxs[account]; len(txs) > 0 { - delete(remoteBlobTxs, account) - localBlobTxs[account] = txs - } - } - - // Fill the block with all available pending transactions. - if len(localPlainTxs) > 0 || len(localBlobTxs) > 0 { - var plainTxs, blobTxs *transactionsByPriceAndNonce - - plainTxs = newTransactionsByPriceAndNonce(env.signer, localPlainTxs, env.header.BaseFee) - blobTxs = newTransactionsByPriceAndNonce(env.signer, localBlobTxs, env.header.BaseFee) - - if err := w.commitTransactionsWithDelay(env, plainTxs, blobTxs, interrupt, new(uint256.Int), interruptCtx); err != nil { - return err - } - } - - if len(remotePlainTxs) > 0 || len(remoteBlobTxs) > 0 { - var plainTxs, blobTxs *transactionsByPriceAndNonce - - plainTxs = newTransactionsByPriceAndNonce(env.signer, remotePlainTxs, env.header.BaseFee) - blobTxs = newTransactionsByPriceAndNonce(env.signer, remoteBlobTxs, env.header.BaseFee) - - if err := w.commitTransactionsWithDelay(env, plainTxs, blobTxs, interrupt, new(uint256.Int), interruptCtx); err != nil { - return err - } - } - - return nil -} - -// commitTransactionsWithDelay is commitTransactions() with extra params to induce artficial delays for tests such as commit-interrupt. -// nolint:gocognit, unparam -func (w *worker) commitTransactionsWithDelay(env *environment, plainTxs, blobTxs *transactionsByPriceAndNonce, interrupt *atomic.Int32, minTip *uint256.Int, interruptCtx context.Context) error { - gasLimit := env.header.GasLimit - if env.gasPool == nil { - env.gasPool = new(core.GasPool).AddGas(gasLimit) - } - - var coalescedLogs []*types.Log - - var deps map[int]map[int]bool - - chDeps := make(chan blockstm.TxDep) - - var depsWg sync.WaitGroup - var once sync.Once - - EnableMVHashMap := w.chainConfig.IsCancun(env.header.Number) - - // create and add empty mvHashMap in statedb - if EnableMVHashMap && w.IsRunning() { - deps = map[int]map[int]bool{} - - chDeps = make(chan blockstm.TxDep) - - // Make sure we safely close the channel in case of interrupt - defer once.Do(func() { - close(chDeps) - }) - - depsWg.Add(1) - - go func(chDeps chan blockstm.TxDep) { - for t := range chDeps { - deps = blockstm.UpdateDeps(deps, t) - } - - depsWg.Done() - }(chDeps) - } - - var lastTxHash common.Hash - -mainloop: - for { - // Check interruption signal and abort building if it's fired. - if interrupt != nil { - if signal := interrupt.Load(); signal != commitInterruptNone { - return signalToErr(signal) - } - } - - if interruptCtx != nil { - if EnableMVHashMap && w.IsRunning() { - env.state.AddEmptyMVHashMap() - } - - // case of interrupting by timeout - select { - case <-interruptCtx.Done(): - txCommitInterruptCounter.Inc(1) - log.Warn("Tx Level Interrupt", "hash", lastTxHash) - break mainloop - default: - } - } - - // If we don't have enough gas for any further transactions then we're done. - if env.gasPool.Gas() < params.TxGas { - log.Trace("Not enough gas for further transactions", "have", env.gasPool, "want", params.TxGas) - break - } - // If we don't have enough blob space for any further blob transactions, - // skip that list altogether - if !blobTxs.Empty() && env.blobs*params.BlobTxBlobGasPerBlob >= params.MaxBlobGasPerBlock { - log.Trace("Not enough blob space for further blob transactions") - blobTxs.Clear() - // Fall though to pick up any plain txs - } - // Retrieve the next transaction and abort if all done. - - var ( - ltx *txpool.LazyTransaction - txs *transactionsByPriceAndNonce - ) - pltx, ptip := plainTxs.Peek() - bltx, btip := blobTxs.Peek() - - switch { - case pltx == nil: - txs, ltx = blobTxs, bltx - case bltx == nil: - txs, ltx = plainTxs, pltx - default: - if ptip.Lt(btip) { - txs, ltx = blobTxs, bltx - } else { - txs, ltx = plainTxs, pltx - } - } - if ltx == nil { - break - } - lastTxHash = ltx.Hash - // If we don't have enough space for the next transaction, skip the account. - if env.gasPool.Gas() < ltx.Gas { - log.Trace("Not enough gas left for transaction", "hash", ltx.Hash, "left", env.gasPool.Gas(), "needed", ltx.Gas) - txs.Pop() - continue - } - if left := uint64(params.MaxBlobGasPerBlock - env.blobs*params.BlobTxBlobGasPerBlob); left < ltx.BlobGas { - log.Trace("Not enough blob gas left for transaction", "hash", ltx.Hash, "left", left, "needed", ltx.BlobGas) - txs.Pop() - continue - } - // If we don't receive enough tip for the next transaction, skip the account - if ptip.Cmp(minTip) < 0 { - log.Trace("Not enough tip for transaction", "hash", ltx.Hash, "tip", ptip, "needed", minTip) - break // If the next-best is too low, surely no better will be available - } - // Transaction seems to fit, pull it up from the pool - tx := ltx.Resolve() - if tx == nil { - log.Trace("Ignoring evicted transaction", "hash", ltx.Hash) - txs.Pop() - continue - } - // Error may be ignored here. The error has already been checked - // during transaction acceptance in the transaction pool. - from, _ := types.Sender(env.signer, tx) - - // not prioritising conditional transaction, yet. - //nolint:nestif - if options := tx.GetOptions(); options != nil { - if err := env.header.ValidateBlockNumberOptionsPIP15(options.BlockNumberMin, options.BlockNumberMax); err != nil { - log.Trace("Dropping conditional transaction", "from", from, "hash", tx.Hash(), "reason", err) - txs.Pop() - - continue - } - - if err := env.header.ValidateTimestampOptionsPIP15(options.TimestampMin, options.TimestampMax); err != nil { - log.Trace("Dropping conditional transaction", "from", from, "hash", tx.Hash(), "reason", err) - txs.Pop() - - continue - } - - if err := env.state.ValidateKnownAccounts(options.KnownAccounts); err != nil { - log.Trace("Dropping conditional transaction", "from", from, "hash", tx.Hash(), "reason", err) - txs.Pop() - - continue - } - } - - // Check whether the tx is replay protected. If we're not in the EIP155 hf - // phase, start ignoring the sender until we do. - if tx.Protected() && !w.chainConfig.IsEIP155(env.header.Number) { - log.Trace("Ignoring replay protected transaction", "hash", ltx.Hash, "eip155", w.chainConfig.EIP155Block) - txs.Pop() - continue - } - // Start executing the transaction - env.state.SetTxContext(tx.Hash(), env.tcount) - - logs, err := w.commitTransaction(env, tx, interruptCtx) - - if interruptCtx != nil { - if delay := interruptCtx.Value(vm.InterruptCtxDelayKey); delay != nil { - // nolint : durationcheck - time.Sleep(time.Duration(delay.(uint)) * time.Millisecond) - } - } - - switch { - case errors.Is(err, core.ErrNonceTooLow): - // New head notification data race between the transaction pool and miner, shift - log.Trace("Skipping transaction with low nonce", "hash", ltx.Hash, "sender", from, "nonce", tx.Nonce()) - txs.Shift() - - case errors.Is(err, nil): - // Everything ok, collect the logs and shift in the next transaction from the same account - coalescedLogs = append(coalescedLogs, logs...) - env.tcount++ - - if EnableMVHashMap && w.IsRunning() { - 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: env.state.MVReadList(), - FullWriteList: env.depsMVFullWriteList, - } - - chDeps <- temp - } - - txs.Shift() - default: - // Transaction is regarded as invalid, drop all consecutive transactions from - // the same sender because of `nonce-too-high` clause. - log.Debug("Transaction failed, account skipped", "hash", ltx.Hash, "err", err) - txs.Pop() - } - - if EnableMVHashMap && w.IsRunning() { - env.state.ClearReadMap() - env.state.ClearWriteMap() - } - } - - // nolint:nestif - if EnableMVHashMap && w.IsRunning() { - once.Do(func() { - close(chDeps) - }) - depsWg.Wait() - - var blockExtraData types.BlockExtraData - - tempVanity := env.header.Extra[:types.ExtraVanityLength] - tempSeal := env.header.Extra[len(env.header.Extra)-types.ExtraSealLength:] - - if len(env.mvReadMapList) > 0 { - tempDeps := make([][]uint64, len(env.mvReadMapList)) - - for j := range deps[0] { - tempDeps[0] = append(tempDeps[0], uint64(j)) - } - - delayFlag := true - - 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)] - - if ok1 || ok2 { - delayFlag = false - break - } - - for j := range deps[i] { - tempDeps[i] = append(tempDeps[i], uint64(j)) - } - } - - if err := rlp.DecodeBytes(env.header.Extra[types.ExtraVanityLength:len(env.header.Extra)-types.ExtraSealLength], &blockExtraData); err != nil { - log.Error("error while decoding block extra data", "err", err) - return err - } - - if delayFlag { - blockExtraData.TxDependency = tempDeps - } else { - blockExtraData.TxDependency = nil - } - } else { - blockExtraData.TxDependency = nil - } - - blockExtraDataBytes, err := rlp.EncodeToBytes(blockExtraData) - if err != nil { - log.Error("error while encoding block extra data: %v", err) - return err - } - - env.header.Extra = []byte{} - - env.header.Extra = append(tempVanity, blockExtraDataBytes...) - - env.header.Extra = append(env.header.Extra, tempSeal...) - } - - if !w.IsRunning() && len(coalescedLogs) > 0 { - // We don't push the pendingLogsEvent while we are sealing. The reason is that - // when we are sealing, the worker will regenerate a sealing block every 3 seconds. - // In order to avoid pushing the repeated pendingLog, we disable the pending log pushing. - // make a copy, the state caches the logs and these logs get "upgraded" from pending to mined - // logs by filling in the block hash when the block was mined by the local miner. This can - // cause a race condition if a log was "upgraded" before the PendingLogsEvent is processed. - cpy := make([]*types.Log, len(coalescedLogs)) - for i, l := range coalescedLogs { - cpy[i] = new(types.Log) - *cpy[i] = *l - } - - w.pendingLogsFeed.Send(cpy) - } - - return nil -} diff --git a/miner/worker.go b/miner/worker.go index a930a4f120..5cd594f08b 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -261,8 +261,9 @@ type worker struct { fullTaskHook func() // Method to call before pushing the full sealing task. resubmitHook func(time.Duration, time.Duration) // Method to call upon updating resubmitting interval. - profileCount *int32 // Global count for profiling - interruptCommitFlag bool // Interrupt commit ( Default true ) + // Interrupt commit to stop block building on time + interruptCommitFlag bool // Denotes whether interrupt commit is enabled or not + interruptCtx context.Context interruptedTxCache *vm.TxCache // noempty is the flag used to control whether the feature of pre-seal empty @@ -300,7 +301,6 @@ func newWorker(config *Config, chainConfig *params.ChainConfig, engine consensus interruptCommitFlag: config.CommitInterruptFlag, } worker.noempty.Store(true) - worker.profileCount = new(int32) // Subscribe for transaction insertion events (whether from network or resurrects) worker.txsSub = eth.TxPool().SubscribeTransactions(worker.txsCh, true) // Subscribe events for blockchain @@ -311,6 +311,7 @@ func newWorker(config *Config, chainConfig *params.ChainConfig, engine consensus log.Warn("Failed to create interrupted tx cache", "err", err) } + worker.interruptCtx = context.Background() worker.interruptedTxCache = &vm.TxCache{ Cache: interruptedTxCache, } @@ -633,7 +634,7 @@ func (w *worker) mainLoop() { tcount := w.current.tcount - w.commitTransactions(w.current, plainTxs, blobTxs, nil, new(uint256.Int), context.Background()) + w.commitTransactions(w.current, plainTxs, blobTxs, nil, new(uint256.Int)) // Only update the snapshot if any new transactons were added // to the pending block @@ -859,16 +860,14 @@ func (w *worker) updateSnapshot(env *environment) { w.snapshotState = env.state.Copy() } -func (w *worker) commitTransaction(env *environment, tx *types.Transaction, interruptCtx context.Context) ([]*types.Log, error) { +func (w *worker) commitTransaction(env *environment, tx *types.Transaction) ([]*types.Log, error) { var ( snap = env.state.Snapshot() gp = env.gasPool.Gas() ) - // nolint : staticcheck - interruptCtx = vm.SetCurrentTxOnContext(interruptCtx, tx.Hash()) - - receipt, err := core.ApplyTransaction(w.chainConfig, w.chain, &env.coinbase, env.gasPool, env.state, env.header, tx, &env.header.GasUsed, *w.chain.GetVMConfig(), interruptCtx) + w.interruptCtx = vm.SetCurrentTxOnContext(w.interruptCtx, tx.Hash()) + receipt, err := core.ApplyTransaction(w.chainConfig, w.chain, &env.coinbase, env.gasPool, env.state, env.header, tx, &env.header.GasUsed, *w.chain.GetVMConfig(), w.interruptCtx) if err != nil { env.state.RevertToSnapshot(snap) env.gasPool.SetGas(gp) @@ -881,7 +880,7 @@ func (w *worker) commitTransaction(env *environment, tx *types.Transaction, inte return receipt.Logs, nil } -func (w *worker) commitTransactions(env *environment, plainTxs, blobTxs *transactionsByPriceAndNonce, interrupt *atomic.Int32, minTip *uint256.Int, interruptCtx context.Context) error { +func (w *worker) commitTransactions(env *environment, plainTxs, blobTxs *transactionsByPriceAndNonce, interrupt *atomic.Int32, minTip *uint256.Int) error { gasLimit := env.header.GasLimit if env.gasPool == nil { env.gasPool = new(core.GasPool).AddGas(gasLimit) @@ -931,14 +930,14 @@ mainloop: } } - if interruptCtx != nil { + if w.interruptCtx != nil { if EnableMVHashMap && w.IsRunning() { env.state.AddEmptyMVHashMap() } // case of interrupting by timeout select { - case <-interruptCtx.Done(): + case <-w.interruptCtx.Done(): txCommitInterruptCounter.Inc(1) log.Warn("Tx Level Interrupt", "hash", lastTxHash) break mainloop @@ -1045,7 +1044,15 @@ mainloop: // Start executing the transaction env.state.SetTxContext(tx.Hash(), env.tcount) - logs, err := w.commitTransaction(env, tx, interruptCtx) + logs, err := w.commitTransaction(env, tx) + + // Check if we have a `delay` set in interrup context. It's only set during tests. + if w.interruptCtx != nil { + if delay := w.interruptCtx.Value(vm.InterruptCtxDelayKey); delay != nil { + // nolint : durationcheck + time.Sleep(time.Duration(delay.(uint)) * time.Millisecond) + } + } switch { case errors.Is(err, core.ErrNonceTooLow): @@ -1275,7 +1282,7 @@ func (w *worker) prepareWork(genParams *generateParams) (*environment, error) { // //nolint:gocognit -func (w *worker) fillTransactions(interrupt *atomic.Int32, env *environment, interruptCtx context.Context) error { +func (w *worker) fillTransactions(interrupt *atomic.Int32, env *environment) error { w.mu.RLock() tip := w.tip w.mu.RUnlock() @@ -1325,7 +1332,7 @@ func (w *worker) fillTransactions(interrupt *atomic.Int32, env *environment, int plainTxs = newTransactionsByPriceAndNonce(env.signer, localPlainTxs, env.header.BaseFee) blobTxs = newTransactionsByPriceAndNonce(env.signer, localBlobTxs, env.header.BaseFee) - if err := w.commitTransactions(env, plainTxs, blobTxs, interrupt, new(uint256.Int), interruptCtx); err != nil { + if err := w.commitTransactions(env, plainTxs, blobTxs, interrupt, new(uint256.Int)); err != nil { return err } } @@ -1336,7 +1343,7 @@ func (w *worker) fillTransactions(interrupt *atomic.Int32, env *environment, int plainTxs = newTransactionsByPriceAndNonce(env.signer, remotePlainTxs, env.header.BaseFee) blobTxs = newTransactionsByPriceAndNonce(env.signer, remoteBlobTxs, env.header.BaseFee) - if err := w.commitTransactions(env, plainTxs, blobTxs, interrupt, new(uint256.Int), interruptCtx); err != nil { + if err := w.commitTransactions(env, plainTxs, blobTxs, interrupt, new(uint256.Int)); err != nil { return err } } @@ -1352,9 +1359,7 @@ func (w *worker) generateWork(params *generateParams) *newPayloadResult { } defer work.discard() - // nolint : contextcheck - var interruptCtx = context.Background() - + w.interruptCtx = resetAndCopyInterruptCtx(w.interruptCtx) if !params.noTxs { interrupt := new(atomic.Int32) @@ -1363,7 +1368,7 @@ func (w *worker) generateWork(params *generateParams) *newPayloadResult { }) defer timer.Stop() - err := w.fillTransactions(interrupt, work, interruptCtx) + err := w.fillTransactions(interrupt, work) if errors.Is(err, errBlockInterruptedByTimeout) { log.Warn("Block building is interrupted", "allowance", common.PrettyDuration(w.newpayloadTimeout)) } @@ -1416,9 +1421,7 @@ func (w *worker) commitWork(interrupt *atomic.Int32, noempty bool, timestamp int return } - // nolint:contextcheck - var interruptCtx = context.Background() - + w.interruptCtx = resetAndCopyInterruptCtx(w.interruptCtx) stopFn := func() {} defer func() { stopFn() @@ -1426,9 +1429,8 @@ func (w *worker) commitWork(interrupt *atomic.Int32, noempty bool, timestamp int if !noempty && w.interruptCommitFlag { block := w.chain.GetBlockByHash(w.chain.CurrentBlock().Hash()) - interruptCtx, stopFn = getInterruptTimer(work, block) - // nolint : staticcheck - interruptCtx = vm.PutCache(interruptCtx, w.interruptedTxCache) + w.interruptCtx, stopFn = getInterruptTimer(w.interruptCtx, work, block) + w.interruptCtx = vm.PutCache(w.interruptCtx, w.interruptedTxCache) } // Create an empty block based on temporary copied state for @@ -1437,7 +1439,7 @@ func (w *worker) commitWork(interrupt *atomic.Int32, noempty bool, timestamp int _ = w.commit(work.copy(), nil, false, start) } // Fill pending transactions from the txpool into the block. - err = w.fillTransactions(interrupt, work, interruptCtx) + err = w.fillTransactions(interrupt, work) switch { case err == nil: @@ -1479,11 +1481,26 @@ func (w *worker) commitWork(interrupt *atomic.Int32, noempty bool, timestamp int w.current = work } -func getInterruptTimer(work *environment, current *types.Block) (context.Context, func()) { +// resetAndCopyInterruptCtx resets the interrupt context and copies the values set +// from the old one to newly created one. It is necessary to reset context in this way +// to get rid of the older parent timeout context. +func resetAndCopyInterruptCtx(interruptCtx context.Context) context.Context { + // Create a fresh new context and copy values from old one + newCtx := context.Background() + if delay := interruptCtx.Value(vm.InterruptCtxDelayKey); delay != nil { + newCtx = context.WithValue(newCtx, vm.InterruptCtxDelayKey, delay) + } + if opcodeDelay := interruptCtx.Value(vm.InterruptCtxOpcodeDelayKey); opcodeDelay != nil { + newCtx = context.WithValue(newCtx, vm.InterruptCtxOpcodeDelayKey, opcodeDelay) + } + + return newCtx +} + +func getInterruptTimer(interruptCtx context.Context, work *environment, current *types.Block) (context.Context, func()) { delay := time.Until(time.Unix(int64(work.header.Time), 0)) - interruptCtx, cancel := context.WithTimeout(context.Background(), delay) - + interruptCtx, cancel := context.WithTimeout(interruptCtx, delay) blockNumber := current.NumberU64() + 1 go func() { @@ -1566,6 +1583,12 @@ func (w *worker) adjustResubmitInterval(message *intervalAdjust) { } } +// setInterruptCtx sets `value` for given `key` for interrupt commit logic. To be only +// used for e2e unit tests. +func (w *worker) setInterruptCtx(key any, value any) { + w.interruptCtx = context.WithValue(w.interruptCtx, key, value) +} + // copyReceipts makes a deep copy of the given receipts. func copyReceipts(receipts []*types.Receipt) []*types.Receipt { result := make([]*types.Receipt, len(receipts)) diff --git a/miner/worker_test.go b/miner/worker_test.go index 1d1fcc32f5..d3c1188191 100644 --- a/miner/worker_test.go +++ b/miner/worker_test.go @@ -320,13 +320,10 @@ func (b *testWorkerBackend) newStorageContractCallTx(to common.Address, nonce ui func newTestWorker(t TensingObject, chainConfig *params.ChainConfig, engine consensus.Engine, db ethdb.Database, noempty bool, delay uint, opcodeDelay uint) (*worker, *testWorkerBackend, func()) { backend := newTestWorkerBackend(t, chainConfig, engine, db) backend.txPool.Add(pendingTxs, true, false) - var w *worker + w := newWorker(testConfig, chainConfig, engine, backend, new(event.TypeMux), nil, false) if delay != 0 || opcodeDelay != 0 { - //nolint:staticcheck - w = newWorkerWithDelay(testConfig, chainConfig, engine, backend, new(event.TypeMux), nil, false, delay, opcodeDelay) - } else { - //nolint:staticcheck - w = newWorker(testConfig, chainConfig, engine, backend, new(event.TypeMux), nil, false) + w.setInterruptCtx(vm.InterruptCtxDelayKey, delay) + w.setInterruptCtx(vm.InterruptCtxOpcodeDelayKey, opcodeDelay) } w.setEtherbase(testBankAddress) // enable empty blocks @@ -771,9 +768,7 @@ func testCommitInterruptExperimentBorContract(t *testing.T, delay uint, txCount } wrapped := make([]*types.Transaction, len(txs)) - for i, tx := range txs { - wrapped[i] = tx - } + copy(wrapped, txs) b.TxPool().Add(wrapped, false, false) @@ -783,8 +778,9 @@ func testCommitInterruptExperimentBorContract(t *testing.T, delay uint, txCount w.stop() currentBlockNumber := w.current.header.Number.Uint64() - assert.Check(t, txCount >= w.chain.GetBlockByNumber(currentBlockNumber-1).Transactions().Len()) - assert.Check(t, 0 < w.chain.GetBlockByNumber(currentBlockNumber-1).Transactions().Len()+1) + prevBlockTxCount := w.chain.GetBlockByNumber(currentBlockNumber - 1).Transactions().Len() + assert.Check(t, prevBlockTxCount > 0) + assert.Check(t, prevBlockTxCount <= txCount) } // // nolint : thelper From 2be86c91f9c197a7bcd736596126bb55f97fe17b Mon Sep 17 00:00:00 2001 From: Marcello Ardizzone Date: Thu, 30 Jan 2025 19:31:34 +0100 Subject: [PATCH 13/15] rm: sender account overwrite (#1418) --- cmd/evm/runner.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/cmd/evm/runner.go b/cmd/evm/runner.go index 9b05f93ae0..fffdb82cca 100644 --- a/cmd/evm/runner.go +++ b/cmd/evm/runner.go @@ -171,8 +171,6 @@ func runCmd(ctx *cli.Context) error { sender = common.HexToAddress(ctx.String(SenderFlag.Name)) } - statedb.CreateAccount(sender) - if ctx.String(ReceiverFlag.Name) != "" { receiver = common.HexToAddress(ctx.String(ReceiverFlag.Name)) } From 73e7a848516c1aa7164ae530c577d6c1f1568e3d Mon Sep 17 00:00:00 2001 From: Manav Darji Date: Fri, 31 Jan 2025 00:48:56 +0530 Subject: [PATCH 14/15] builder, docs, packaging: update amoy dns, uncomment mainnet p2p configs (#1428) - Add DNS entries to Amoy configs - Uncomment p2p.discovery in Mainnet and Amoy configs - Update Amoy bootnodes --- builder/files/config.toml | 12 +++++++----- docs/cli/example_config.toml | 6 +++--- .../mainnet-v1/sentry/sentry/bor/config.toml | 2 +- .../mainnet-v1/sentry/sentry/bor/pbss_config.toml | 2 +- .../mainnet-v1/sentry/validator/bor/config.toml | 2 +- .../mainnet-v1/sentry/validator/bor/pbss_config.toml | 2 +- .../mainnet-v1/without-sentry/bor/config.toml | 2 +- .../mainnet-v1/without-sentry/bor/pbss_config.toml | 2 +- packaging/templates/testnet-amoy/archive/config.toml | 4 ++-- .../testnet-amoy/sentry/sentry/bor/config.toml | 4 ++-- .../testnet-amoy/sentry/sentry/bor/pbss_config.toml | 4 ++-- .../testnet-amoy/sentry/validator/bor/config.toml | 4 ++-- .../sentry/validator/bor/pbss_config.toml | 4 ++-- .../testnet-amoy/without-sentry/bor/config.toml | 4 ++-- .../testnet-amoy/without-sentry/bor/pbss_config.toml | 4 ++-- 15 files changed, 30 insertions(+), 28 deletions(-) diff --git a/builder/files/config.toml b/builder/files/config.toml index a875a237e3..ce448103a7 100644 --- a/builder/files/config.toml +++ b/builder/files/config.toml @@ -1,8 +1,7 @@ # NOTE: Uncomment and configure the following 8 fields in case you run a validator: # `mine`, `etherbase`, `nodiscover`, `maxpeers`, `keystore`, `allow-insecure-unlock`, `password`, `unlock` -chain = "mainnet" -# chain = "mumbai", "amoy" +chain = "mainnet" # Set it to `amoy` for testnet # identity = "Annon-Identity" # verbosity = 3 # vmdebug = false @@ -42,13 +41,16 @@ syncmode = "full" # v4disc = true # v5disc = false bootnodes = ["enode://b8f1cc9c5d4403703fbf377116469667d2b1823c0daf16b7250aa576bacf399e42c3930ccfcb02c5df6879565a2b8931335565f0e8d3f8e72385ecf4a4bf160a@3.36.224.80:30303", "enode://8729e0c825f3d9cad382555f3e46dcff21af323e89025a0e6312df541f4a9e73abfa562d64906f5e59c51fe6f0501b3e61b07979606c56329c020ed739910759@54.194.245.5:30303"] - # Uncomment below `bootnodes` field for Mumbai bootnode - # bootnodes = ["enode://bdcd4786a616a853b8a041f53496d853c68d99d54ff305615cd91c03cd56895e0a7f6e9f35dbf89131044e2114a9a782b792b5661e3aff07faf125a98606a071@43.200.206.40:30303", "enode://209aaf7ed549cf4a5700fd833da25413f80a1248bd3aa7fe2a87203e3f7b236dd729579e5c8df61c97bf508281bae4969d6de76a7393bcbd04a0af70270333b3@54.216.248.9:30303"] + # Uncomment below `bootnodes` field for Amoy + # bootnodes = ["enode://bce861be777e91b0a5a49d58a51e14f32f201b4c6c2d1fbea6c7a1f14756cbb3f931f3188d6b65de8b07b53ff28d03b6e366d09e56360d2124a9fc5a15a0913d@54.217.171.196:30303", "enode://4a3dc0081a346d26a73d79dd88216a9402d2292318e2db9947dbc97ea9c4afb2498dc519c0af04420dc13a238c279062da0320181e7c1461216ce4513bfd40bf@13.251.184.185:30303"] # bootnodesv4 = [] # bootnodesv5 = [] # static-nodes = [] # trusted-nodes = [] - # dns = [] + dns = [ "enrtree://AKUEZKN7PSKVNR65FZDHECMKOJQSGPARGTPPBI7WS2VUL4EGR6XPC@pos.polygon-peers.io" ] # For pos mainnet + # Uncomment below `dns` field for Amoy + # dns = [ "enrtree://AKUEZKN7PSKVNR65FZDHECMKOJQSGPARGTPPBI7WS2VUL4EGR6XPC@amoy.polygon-peers.io" ] + # [heimdall] # url = "http://localhost:1317" diff --git a/docs/cli/example_config.toml b/docs/cli/example_config.toml index ffc822cc64..bea6ec2492 100644 --- a/docs/cli/example_config.toml +++ b/docs/cli/example_config.toml @@ -1,8 +1,8 @@ # This configuration file is for reference and learning purpose only. # The default value of the flags is provided below (except a few flags which has custom defaults which are explicitly mentioned). -# Recommended values for mainnet and/or mumbai,amoy are also provided. +# Recommended values for mainnet and/or amoy are also provided. -chain = "mainnet" # Name of the chain to sync ("amoy", "mumbai", "mainnet") or path to a genesis file +chain = "mainnet" # Name of the chain to sync ("mainnet" or "amoy") or path to a genesis file identity = "Annon-Identity" # Name/Identity of the node (default = OS hostname) verbosity = 3 # Logging verbosity for the server (5=trace|4=debug|3=info|2=warn|1=error|0=crit) (`log-level` was replaced by `verbosity`, and thus will be deprecated soon) vmdebug = false # Record information useful for VM and contract debugging @@ -153,7 +153,7 @@ devfakeauthor = false # Run miner without validator set authorization region = "us-north-1" [cache] - cache = 1024 # Megabytes of memory allocated to internal caching (recommended for mainnet = 4096, default suitable for amoy/mumbai/devnet) + cache = 1024 # Megabytes of memory allocated to internal caching (recommended for mainnet = 4096, default suitable for amoy/devnet) gc = 25 # Percentage of cache memory allowance to use for trie pruning (default = 25% full mode, 0% archive mode) snapshot = 10 # Percentage of cache memory allowance to use for snapshot caching (default = 10% full mode, 20% archive mode) database = 50 # Percentage of cache memory allowance to use for database io diff --git a/packaging/templates/mainnet-v1/sentry/sentry/bor/config.toml b/packaging/templates/mainnet-v1/sentry/sentry/bor/config.toml index d4fd25e863..17ec5ead8c 100644 --- a/packaging/templates/mainnet-v1/sentry/sentry/bor/config.toml +++ b/packaging/templates/mainnet-v1/sentry/sentry/bor/config.toml @@ -34,7 +34,7 @@ syncmode = "full" # nodekey = "" # nodekeyhex = "" # txarrivalwait = "500ms" - # [p2p.discovery] + [p2p.discovery] # v4disc = true # v5disc = false bootnodes = [ "enode://b8f1cc9c5d4403703fbf377116469667d2b1823c0daf16b7250aa576bacf399e42c3930ccfcb02c5df6879565a2b8931335565f0e8d3f8e72385ecf4a4bf160a@3.36.224.80:30303", "enode://8729e0c825f3d9cad382555f3e46dcff21af323e89025a0e6312df541f4a9e73abfa562d64906f5e59c51fe6f0501b3e61b07979606c56329c020ed739910759@54.194.245.5:30303" ] diff --git a/packaging/templates/mainnet-v1/sentry/sentry/bor/pbss_config.toml b/packaging/templates/mainnet-v1/sentry/sentry/bor/pbss_config.toml index 20edf749dc..6a99788333 100644 --- a/packaging/templates/mainnet-v1/sentry/sentry/bor/pbss_config.toml +++ b/packaging/templates/mainnet-v1/sentry/sentry/bor/pbss_config.toml @@ -36,7 +36,7 @@ syncmode = "full" # nodekey = "" # nodekeyhex = "" # txarrivalwait = "500ms" - # [p2p.discovery] + [p2p.discovery] # v4disc = true # v5disc = false bootnodes = [ "enode://b8f1cc9c5d4403703fbf377116469667d2b1823c0daf16b7250aa576bacf399e42c3930ccfcb02c5df6879565a2b8931335565f0e8d3f8e72385ecf4a4bf160a@3.36.224.80:30303", "enode://8729e0c825f3d9cad382555f3e46dcff21af323e89025a0e6312df541f4a9e73abfa562d64906f5e59c51fe6f0501b3e61b07979606c56329c020ed739910759@54.194.245.5:30303" ] diff --git a/packaging/templates/mainnet-v1/sentry/validator/bor/config.toml b/packaging/templates/mainnet-v1/sentry/validator/bor/config.toml index a839551c02..74b8731d09 100644 --- a/packaging/templates/mainnet-v1/sentry/validator/bor/config.toml +++ b/packaging/templates/mainnet-v1/sentry/validator/bor/config.toml @@ -36,7 +36,7 @@ syncmode = "full" # nodekey = "" # nodekeyhex = "" # txarrivalwait = "500ms" - # [p2p.discovery] + [p2p.discovery] # v4disc = true # v5disc = false bootnodes = ["enode://b8f1cc9c5d4403703fbf377116469667d2b1823c0daf16b7250aa576bacf399e42c3930ccfcb02c5df6879565a2b8931335565f0e8d3f8e72385ecf4a4bf160a@3.36.224.80:30303", "enode://8729e0c825f3d9cad382555f3e46dcff21af323e89025a0e6312df541f4a9e73abfa562d64906f5e59c51fe6f0501b3e61b07979606c56329c020ed739910759@54.194.245.5:30303"] diff --git a/packaging/templates/mainnet-v1/sentry/validator/bor/pbss_config.toml b/packaging/templates/mainnet-v1/sentry/validator/bor/pbss_config.toml index 3f4da5d4f8..f7eab0a97e 100644 --- a/packaging/templates/mainnet-v1/sentry/validator/bor/pbss_config.toml +++ b/packaging/templates/mainnet-v1/sentry/validator/bor/pbss_config.toml @@ -38,7 +38,7 @@ syncmode = "full" # nodekey = "" # nodekeyhex = "" # txarrivalwait = "500ms" - # [p2p.discovery] + [p2p.discovery] # v4disc = true # v5disc = false bootnodes = ["enode://b8f1cc9c5d4403703fbf377116469667d2b1823c0daf16b7250aa576bacf399e42c3930ccfcb02c5df6879565a2b8931335565f0e8d3f8e72385ecf4a4bf160a@3.36.224.80:30303", "enode://8729e0c825f3d9cad382555f3e46dcff21af323e89025a0e6312df541f4a9e73abfa562d64906f5e59c51fe6f0501b3e61b07979606c56329c020ed739910759@54.194.245.5:30303"] diff --git a/packaging/templates/mainnet-v1/without-sentry/bor/config.toml b/packaging/templates/mainnet-v1/without-sentry/bor/config.toml index 564dc6bbaa..58c5d631dc 100644 --- a/packaging/templates/mainnet-v1/without-sentry/bor/config.toml +++ b/packaging/templates/mainnet-v1/without-sentry/bor/config.toml @@ -36,7 +36,7 @@ syncmode = "full" # nodekey = "" # nodekeyhex = "" # txarrivalwait = "500ms" - # [p2p.discovery] + [p2p.discovery] # v4disc = true # v5disc = false bootnodes = [ "enode://b8f1cc9c5d4403703fbf377116469667d2b1823c0daf16b7250aa576bacf399e42c3930ccfcb02c5df6879565a2b8931335565f0e8d3f8e72385ecf4a4bf160a@3.36.224.80:30303", "enode://8729e0c825f3d9cad382555f3e46dcff21af323e89025a0e6312df541f4a9e73abfa562d64906f5e59c51fe6f0501b3e61b07979606c56329c020ed739910759@54.194.245.5:30303" ] diff --git a/packaging/templates/mainnet-v1/without-sentry/bor/pbss_config.toml b/packaging/templates/mainnet-v1/without-sentry/bor/pbss_config.toml index 06c4b6b018..ec16773656 100644 --- a/packaging/templates/mainnet-v1/without-sentry/bor/pbss_config.toml +++ b/packaging/templates/mainnet-v1/without-sentry/bor/pbss_config.toml @@ -37,7 +37,7 @@ syncmode = "full" # nodekey = "" # nodekeyhex = "" # txarrivalwait = "500ms" - # [p2p.discovery] + [p2p.discovery] # v4disc = true # v5disc = false bootnodes = [ "enode://b8f1cc9c5d4403703fbf377116469667d2b1823c0daf16b7250aa576bacf399e42c3930ccfcb02c5df6879565a2b8931335565f0e8d3f8e72385ecf4a4bf160a@3.36.224.80:30303", "enode://8729e0c825f3d9cad382555f3e46dcff21af323e89025a0e6312df541f4a9e73abfa562d64906f5e59c51fe6f0501b3e61b07979606c56329c020ed739910759@54.194.245.5:30303" ] diff --git a/packaging/templates/testnet-amoy/archive/config.toml b/packaging/templates/testnet-amoy/archive/config.toml index b571074496..a110bca29b 100644 --- a/packaging/templates/testnet-amoy/archive/config.toml +++ b/packaging/templates/testnet-amoy/archive/config.toml @@ -34,14 +34,14 @@ gcmode = "archive" # nodekey = "" # nodekeyhex = "" # txarrivalwait = "500ms" - # [p2p.discovery] + [p2p.discovery] # v5disc = false # bootnodesv4 = [] # bootnodesv5 = [] bootnodes = [ "enode://bce861be777e91b0a5a49d58a51e14f32f201b4c6c2d1fbea6c7a1f14756cbb3f931f3188d6b65de8b07b53ff28d03b6e366d09e56360d2124a9fc5a15a0913d@54.217.171.196:30303", "enode://4a3dc0081a346d26a73d79dd88216a9402d2292318e2db9947dbc97ea9c4afb2498dc519c0af04420dc13a238c279062da0320181e7c1461216ce4513bfd40bf@13.251.184.185:30303" ] static-nodes = [ "enode://383ec39eb7f7e23538ea846f502602632110a6bcfc7521bfc2b8833f5a190779507d006b28650d83674b75d188cb36bcb3c3e168a0f2b3d98f9a651cc6603146@52.214.229.208:30303", "enode://bce861be777e91b0a5a49d58a51e14f32f201b4c6c2d1fbea6c7a1f14756cbb3f931f3188d6b65de8b07b53ff28d03b6e366d09e56360d2124a9fc5a15a0913d@54.217.171.196:30303", "enode://a4a387ad423a2fd0d652808b270082250d3c616b7e8537209584ebad4806dd50ef8dc66a371c85c7f55e6c1f53747edbb11055c8073cfacf312047eaeb328f58@54.171.220.164:30303", "enode://4a3dc0081a346d26a73d79dd88216a9402d2292318e2db9947dbc97ea9c4afb2498dc519c0af04420dc13a238c279062da0320181e7c1461216ce4513bfd40bf@13.251.184.185:30303", "enode://e8fe33b52f90d4bc7a4e75800945df449d1a091bd347c9f11cd1dbcd98ea28cb4c231cb3b1c6feacdabca2aa91f1a6744724b44edc9382c107968792abdef261@52.74.18.182:30303", "enode://b240f1f18e8f3cc61df96a164ba215ea6fc3f00717e4300da6283362a0438bda53f81ecc24c575ff130066d42096319fa027c952681bbb4f003e0bdd5d5b4e61@52.76.37.145:30303", "enode://de55d16b6e1fca28cdd3d11eb0dd89e3b77b96d4722172bd5e04ac255922324076a87748e97bc021af2307dccbb5ef8062389cfcba1845f77219eee7935dea9f@52.74.125.36:30303", "enode://7f2272685fc3e31c8e43c7687dda43ea3192fd310ba01efcb7811d5dc7ad5a64402ea8cd827650e573a174cf29bb69331dffcca6f0b9894ef17eeafabd97a41d@47.128.184.10:30303", "enode://c66e12243b425b63528dd8b1ce87f2f7fbc85f35485e2d8bf6bbf0ec0dcd05b3a582ef62daadbde061b58058735788335d09ed972a451242b9943b85d323c239@63.32.214.97:30303", "enode://bd56c0f00dd37e14ae2b84f5eb50e357d3a2d326bdbb0cbb987411268b3f132288f6c86157fc132c6902d18b9be0de8bbdcd12d926e16232ebadd8e274aae780@52.208.81.179:30303", "enode://2f015d5b1571165975382281a2117a9b514e1b38e87a8116596fc9b3b121a93cfb238eb6f7b3ae30cf9c0154384372745ce9edc09cbc30526ab7e2059f57ddee@54.74.160.230:30303" ] # trusted-nodes = [] - # dns = [] + dns = [ "enrtree://AKUEZKN7PSKVNR65FZDHECMKOJQSGPARGTPPBI7WS2VUL4EGR6XPC@amoy.polygon-peers.io" ] # [heimdall] # url = "http://localhost:1317" diff --git a/packaging/templates/testnet-amoy/sentry/sentry/bor/config.toml b/packaging/templates/testnet-amoy/sentry/sentry/bor/config.toml index 2b98c30cb3..a62e7daf77 100644 --- a/packaging/templates/testnet-amoy/sentry/sentry/bor/config.toml +++ b/packaging/templates/testnet-amoy/sentry/sentry/bor/config.toml @@ -33,14 +33,14 @@ syncmode = "full" # nodekey = "" # nodekeyhex = "" # txarrivalwait = "500ms" - # [p2p.discovery] + [p2p.discovery] # v5disc = false # bootnodesv4 = [] # bootnodesv5 = [] bootnodes = [ "enode://bce861be777e91b0a5a49d58a51e14f32f201b4c6c2d1fbea6c7a1f14756cbb3f931f3188d6b65de8b07b53ff28d03b6e366d09e56360d2124a9fc5a15a0913d@54.217.171.196:30303", "enode://4a3dc0081a346d26a73d79dd88216a9402d2292318e2db9947dbc97ea9c4afb2498dc519c0af04420dc13a238c279062da0320181e7c1461216ce4513bfd40bf@13.251.184.185:30303" ] static-nodes = [ "enode://383ec39eb7f7e23538ea846f502602632110a6bcfc7521bfc2b8833f5a190779507d006b28650d83674b75d188cb36bcb3c3e168a0f2b3d98f9a651cc6603146@52.214.229.208:30303", "enode://bce861be777e91b0a5a49d58a51e14f32f201b4c6c2d1fbea6c7a1f14756cbb3f931f3188d6b65de8b07b53ff28d03b6e366d09e56360d2124a9fc5a15a0913d@54.217.171.196:30303", "enode://a4a387ad423a2fd0d652808b270082250d3c616b7e8537209584ebad4806dd50ef8dc66a371c85c7f55e6c1f53747edbb11055c8073cfacf312047eaeb328f58@54.171.220.164:30303", "enode://4a3dc0081a346d26a73d79dd88216a9402d2292318e2db9947dbc97ea9c4afb2498dc519c0af04420dc13a238c279062da0320181e7c1461216ce4513bfd40bf@13.251.184.185:30303", "enode://e8fe33b52f90d4bc7a4e75800945df449d1a091bd347c9f11cd1dbcd98ea28cb4c231cb3b1c6feacdabca2aa91f1a6744724b44edc9382c107968792abdef261@52.74.18.182:30303", "enode://b240f1f18e8f3cc61df96a164ba215ea6fc3f00717e4300da6283362a0438bda53f81ecc24c575ff130066d42096319fa027c952681bbb4f003e0bdd5d5b4e61@52.76.37.145:30303", "enode://de55d16b6e1fca28cdd3d11eb0dd89e3b77b96d4722172bd5e04ac255922324076a87748e97bc021af2307dccbb5ef8062389cfcba1845f77219eee7935dea9f@52.74.125.36:30303", "enode://7f2272685fc3e31c8e43c7687dda43ea3192fd310ba01efcb7811d5dc7ad5a64402ea8cd827650e573a174cf29bb69331dffcca6f0b9894ef17eeafabd97a41d@47.128.184.10:30303", "enode://c66e12243b425b63528dd8b1ce87f2f7fbc85f35485e2d8bf6bbf0ec0dcd05b3a582ef62daadbde061b58058735788335d09ed972a451242b9943b85d323c239@63.32.214.97:30303", "enode://bd56c0f00dd37e14ae2b84f5eb50e357d3a2d326bdbb0cbb987411268b3f132288f6c86157fc132c6902d18b9be0de8bbdcd12d926e16232ebadd8e274aae780@52.208.81.179:30303", "enode://2f015d5b1571165975382281a2117a9b514e1b38e87a8116596fc9b3b121a93cfb238eb6f7b3ae30cf9c0154384372745ce9edc09cbc30526ab7e2059f57ddee@54.74.160.230:30303" ] # trusted-nodes = [] - # dns = [] + dns = [ "enrtree://AKUEZKN7PSKVNR65FZDHECMKOJQSGPARGTPPBI7WS2VUL4EGR6XPC@amoy.polygon-peers.io" ] # [heimdall] # url = "http://localhost:1317" diff --git a/packaging/templates/testnet-amoy/sentry/sentry/bor/pbss_config.toml b/packaging/templates/testnet-amoy/sentry/sentry/bor/pbss_config.toml index f1b8cabbfe..2b8dbd5a03 100644 --- a/packaging/templates/testnet-amoy/sentry/sentry/bor/pbss_config.toml +++ b/packaging/templates/testnet-amoy/sentry/sentry/bor/pbss_config.toml @@ -34,14 +34,14 @@ syncmode = "full" # nodekey = "" # nodekeyhex = "" # txarrivalwait = "500ms" - # [p2p.discovery] + [p2p.discovery] # v5disc = false # bootnodesv4 = [] # bootnodesv5 = [] bootnodes = [ "enode://bce861be777e91b0a5a49d58a51e14f32f201b4c6c2d1fbea6c7a1f14756cbb3f931f3188d6b65de8b07b53ff28d03b6e366d09e56360d2124a9fc5a15a0913d@54.217.171.196:30303", "enode://4a3dc0081a346d26a73d79dd88216a9402d2292318e2db9947dbc97ea9c4afb2498dc519c0af04420dc13a238c279062da0320181e7c1461216ce4513bfd40bf@13.251.184.185:30303" ] static-nodes = [ "enode://383ec39eb7f7e23538ea846f502602632110a6bcfc7521bfc2b8833f5a190779507d006b28650d83674b75d188cb36bcb3c3e168a0f2b3d98f9a651cc6603146@52.214.229.208:30303", "enode://bce861be777e91b0a5a49d58a51e14f32f201b4c6c2d1fbea6c7a1f14756cbb3f931f3188d6b65de8b07b53ff28d03b6e366d09e56360d2124a9fc5a15a0913d@54.217.171.196:30303", "enode://a4a387ad423a2fd0d652808b270082250d3c616b7e8537209584ebad4806dd50ef8dc66a371c85c7f55e6c1f53747edbb11055c8073cfacf312047eaeb328f58@54.171.220.164:30303", "enode://4a3dc0081a346d26a73d79dd88216a9402d2292318e2db9947dbc97ea9c4afb2498dc519c0af04420dc13a238c279062da0320181e7c1461216ce4513bfd40bf@13.251.184.185:30303", "enode://e8fe33b52f90d4bc7a4e75800945df449d1a091bd347c9f11cd1dbcd98ea28cb4c231cb3b1c6feacdabca2aa91f1a6744724b44edc9382c107968792abdef261@52.74.18.182:30303", "enode://b240f1f18e8f3cc61df96a164ba215ea6fc3f00717e4300da6283362a0438bda53f81ecc24c575ff130066d42096319fa027c952681bbb4f003e0bdd5d5b4e61@52.76.37.145:30303", "enode://de55d16b6e1fca28cdd3d11eb0dd89e3b77b96d4722172bd5e04ac255922324076a87748e97bc021af2307dccbb5ef8062389cfcba1845f77219eee7935dea9f@52.74.125.36:30303", "enode://7f2272685fc3e31c8e43c7687dda43ea3192fd310ba01efcb7811d5dc7ad5a64402ea8cd827650e573a174cf29bb69331dffcca6f0b9894ef17eeafabd97a41d@47.128.184.10:30303", "enode://c66e12243b425b63528dd8b1ce87f2f7fbc85f35485e2d8bf6bbf0ec0dcd05b3a582ef62daadbde061b58058735788335d09ed972a451242b9943b85d323c239@63.32.214.97:30303", "enode://bd56c0f00dd37e14ae2b84f5eb50e357d3a2d326bdbb0cbb987411268b3f132288f6c86157fc132c6902d18b9be0de8bbdcd12d926e16232ebadd8e274aae780@52.208.81.179:30303", "enode://2f015d5b1571165975382281a2117a9b514e1b38e87a8116596fc9b3b121a93cfb238eb6f7b3ae30cf9c0154384372745ce9edc09cbc30526ab7e2059f57ddee@54.74.160.230:30303" ] # trusted-nodes = [] - # dns = [] + dns = [ "enrtree://AKUEZKN7PSKVNR65FZDHECMKOJQSGPARGTPPBI7WS2VUL4EGR6XPC@amoy.polygon-peers.io" ] # [heimdall] # url = "http://localhost:1317" diff --git a/packaging/templates/testnet-amoy/sentry/validator/bor/config.toml b/packaging/templates/testnet-amoy/sentry/validator/bor/config.toml index c4db9aed12..441792fe23 100644 --- a/packaging/templates/testnet-amoy/sentry/validator/bor/config.toml +++ b/packaging/templates/testnet-amoy/sentry/validator/bor/config.toml @@ -35,14 +35,14 @@ syncmode = "full" # nodekey = "" # nodekeyhex = "" # txarrivalwait = "500ms" - # [p2p.discovery] + [p2p.discovery] # v5disc = false # bootnodesv4 = [] # bootnodesv5 = [] bootnodes = [ "enode://bce861be777e91b0a5a49d58a51e14f32f201b4c6c2d1fbea6c7a1f14756cbb3f931f3188d6b65de8b07b53ff28d03b6e366d09e56360d2124a9fc5a15a0913d@54.217.171.196:30303", "enode://4a3dc0081a346d26a73d79dd88216a9402d2292318e2db9947dbc97ea9c4afb2498dc519c0af04420dc13a238c279062da0320181e7c1461216ce4513bfd40bf@13.251.184.185:30303" ] static-nodes = [ "enode://383ec39eb7f7e23538ea846f502602632110a6bcfc7521bfc2b8833f5a190779507d006b28650d83674b75d188cb36bcb3c3e168a0f2b3d98f9a651cc6603146@52.214.229.208:30303", "enode://bce861be777e91b0a5a49d58a51e14f32f201b4c6c2d1fbea6c7a1f14756cbb3f931f3188d6b65de8b07b53ff28d03b6e366d09e56360d2124a9fc5a15a0913d@54.217.171.196:30303", "enode://a4a387ad423a2fd0d652808b270082250d3c616b7e8537209584ebad4806dd50ef8dc66a371c85c7f55e6c1f53747edbb11055c8073cfacf312047eaeb328f58@54.171.220.164:30303", "enode://4a3dc0081a346d26a73d79dd88216a9402d2292318e2db9947dbc97ea9c4afb2498dc519c0af04420dc13a238c279062da0320181e7c1461216ce4513bfd40bf@13.251.184.185:30303", "enode://e8fe33b52f90d4bc7a4e75800945df449d1a091bd347c9f11cd1dbcd98ea28cb4c231cb3b1c6feacdabca2aa91f1a6744724b44edc9382c107968792abdef261@52.74.18.182:30303", "enode://b240f1f18e8f3cc61df96a164ba215ea6fc3f00717e4300da6283362a0438bda53f81ecc24c575ff130066d42096319fa027c952681bbb4f003e0bdd5d5b4e61@52.76.37.145:30303", "enode://de55d16b6e1fca28cdd3d11eb0dd89e3b77b96d4722172bd5e04ac255922324076a87748e97bc021af2307dccbb5ef8062389cfcba1845f77219eee7935dea9f@52.74.125.36:30303", "enode://7f2272685fc3e31c8e43c7687dda43ea3192fd310ba01efcb7811d5dc7ad5a64402ea8cd827650e573a174cf29bb69331dffcca6f0b9894ef17eeafabd97a41d@47.128.184.10:30303", "enode://c66e12243b425b63528dd8b1ce87f2f7fbc85f35485e2d8bf6bbf0ec0dcd05b3a582ef62daadbde061b58058735788335d09ed972a451242b9943b85d323c239@63.32.214.97:30303", "enode://bd56c0f00dd37e14ae2b84f5eb50e357d3a2d326bdbb0cbb987411268b3f132288f6c86157fc132c6902d18b9be0de8bbdcd12d926e16232ebadd8e274aae780@52.208.81.179:30303", "enode://2f015d5b1571165975382281a2117a9b514e1b38e87a8116596fc9b3b121a93cfb238eb6f7b3ae30cf9c0154384372745ce9edc09cbc30526ab7e2059f57ddee@54.74.160.230:30303" ] # trusted-nodes = [] - # dns = [] + dns = [ "enrtree://AKUEZKN7PSKVNR65FZDHECMKOJQSGPARGTPPBI7WS2VUL4EGR6XPC@amoy.polygon-peers.io" ] # [heimdall] # url = "http://localhost:1317" diff --git a/packaging/templates/testnet-amoy/sentry/validator/bor/pbss_config.toml b/packaging/templates/testnet-amoy/sentry/validator/bor/pbss_config.toml index bbe422907a..196a1863cc 100644 --- a/packaging/templates/testnet-amoy/sentry/validator/bor/pbss_config.toml +++ b/packaging/templates/testnet-amoy/sentry/validator/bor/pbss_config.toml @@ -36,14 +36,14 @@ syncmode = "full" # nodekey = "" # nodekeyhex = "" # txarrivalwait = "500ms" - # [p2p.discovery] + [p2p.discovery] # v5disc = false # bootnodesv4 = [] # bootnodesv5 = [] bootnodes = [ "enode://bce861be777e91b0a5a49d58a51e14f32f201b4c6c2d1fbea6c7a1f14756cbb3f931f3188d6b65de8b07b53ff28d03b6e366d09e56360d2124a9fc5a15a0913d@54.217.171.196:30303", "enode://4a3dc0081a346d26a73d79dd88216a9402d2292318e2db9947dbc97ea9c4afb2498dc519c0af04420dc13a238c279062da0320181e7c1461216ce4513bfd40bf@13.251.184.185:30303" ] static-nodes = [ "enode://383ec39eb7f7e23538ea846f502602632110a6bcfc7521bfc2b8833f5a190779507d006b28650d83674b75d188cb36bcb3c3e168a0f2b3d98f9a651cc6603146@52.214.229.208:30303", "enode://bce861be777e91b0a5a49d58a51e14f32f201b4c6c2d1fbea6c7a1f14756cbb3f931f3188d6b65de8b07b53ff28d03b6e366d09e56360d2124a9fc5a15a0913d@54.217.171.196:30303", "enode://a4a387ad423a2fd0d652808b270082250d3c616b7e8537209584ebad4806dd50ef8dc66a371c85c7f55e6c1f53747edbb11055c8073cfacf312047eaeb328f58@54.171.220.164:30303", "enode://4a3dc0081a346d26a73d79dd88216a9402d2292318e2db9947dbc97ea9c4afb2498dc519c0af04420dc13a238c279062da0320181e7c1461216ce4513bfd40bf@13.251.184.185:30303", "enode://e8fe33b52f90d4bc7a4e75800945df449d1a091bd347c9f11cd1dbcd98ea28cb4c231cb3b1c6feacdabca2aa91f1a6744724b44edc9382c107968792abdef261@52.74.18.182:30303", "enode://b240f1f18e8f3cc61df96a164ba215ea6fc3f00717e4300da6283362a0438bda53f81ecc24c575ff130066d42096319fa027c952681bbb4f003e0bdd5d5b4e61@52.76.37.145:30303", "enode://de55d16b6e1fca28cdd3d11eb0dd89e3b77b96d4722172bd5e04ac255922324076a87748e97bc021af2307dccbb5ef8062389cfcba1845f77219eee7935dea9f@52.74.125.36:30303", "enode://7f2272685fc3e31c8e43c7687dda43ea3192fd310ba01efcb7811d5dc7ad5a64402ea8cd827650e573a174cf29bb69331dffcca6f0b9894ef17eeafabd97a41d@47.128.184.10:30303", "enode://c66e12243b425b63528dd8b1ce87f2f7fbc85f35485e2d8bf6bbf0ec0dcd05b3a582ef62daadbde061b58058735788335d09ed972a451242b9943b85d323c239@63.32.214.97:30303", "enode://bd56c0f00dd37e14ae2b84f5eb50e357d3a2d326bdbb0cbb987411268b3f132288f6c86157fc132c6902d18b9be0de8bbdcd12d926e16232ebadd8e274aae780@52.208.81.179:30303", "enode://2f015d5b1571165975382281a2117a9b514e1b38e87a8116596fc9b3b121a93cfb238eb6f7b3ae30cf9c0154384372745ce9edc09cbc30526ab7e2059f57ddee@54.74.160.230:30303" ] # trusted-nodes = [] - # dns = [] + dns = [ "enrtree://AKUEZKN7PSKVNR65FZDHECMKOJQSGPARGTPPBI7WS2VUL4EGR6XPC@amoy.polygon-peers.io" ] # [heimdall] # url = "http://localhost:1317" diff --git a/packaging/templates/testnet-amoy/without-sentry/bor/config.toml b/packaging/templates/testnet-amoy/without-sentry/bor/config.toml index cd8f6ef2a8..6cef7d8612 100644 --- a/packaging/templates/testnet-amoy/without-sentry/bor/config.toml +++ b/packaging/templates/testnet-amoy/without-sentry/bor/config.toml @@ -35,14 +35,14 @@ syncmode = "full" # nodekey = "" # nodekeyhex = "" # txarrivalwait = "500ms" - # [p2p.discovery] + [p2p.discovery] # v5disc = false # bootnodesv4 = [] # bootnodesv5 = [] bootnodes = [ "enode://bce861be777e91b0a5a49d58a51e14f32f201b4c6c2d1fbea6c7a1f14756cbb3f931f3188d6b65de8b07b53ff28d03b6e366d09e56360d2124a9fc5a15a0913d@54.217.171.196:30303", "enode://4a3dc0081a346d26a73d79dd88216a9402d2292318e2db9947dbc97ea9c4afb2498dc519c0af04420dc13a238c279062da0320181e7c1461216ce4513bfd40bf@13.251.184.185:30303" ] static-nodes = [ "enode://383ec39eb7f7e23538ea846f502602632110a6bcfc7521bfc2b8833f5a190779507d006b28650d83674b75d188cb36bcb3c3e168a0f2b3d98f9a651cc6603146@52.214.229.208:30303", "enode://bce861be777e91b0a5a49d58a51e14f32f201b4c6c2d1fbea6c7a1f14756cbb3f931f3188d6b65de8b07b53ff28d03b6e366d09e56360d2124a9fc5a15a0913d@54.217.171.196:30303", "enode://a4a387ad423a2fd0d652808b270082250d3c616b7e8537209584ebad4806dd50ef8dc66a371c85c7f55e6c1f53747edbb11055c8073cfacf312047eaeb328f58@54.171.220.164:30303", "enode://4a3dc0081a346d26a73d79dd88216a9402d2292318e2db9947dbc97ea9c4afb2498dc519c0af04420dc13a238c279062da0320181e7c1461216ce4513bfd40bf@13.251.184.185:30303", "enode://e8fe33b52f90d4bc7a4e75800945df449d1a091bd347c9f11cd1dbcd98ea28cb4c231cb3b1c6feacdabca2aa91f1a6744724b44edc9382c107968792abdef261@52.74.18.182:30303", "enode://b240f1f18e8f3cc61df96a164ba215ea6fc3f00717e4300da6283362a0438bda53f81ecc24c575ff130066d42096319fa027c952681bbb4f003e0bdd5d5b4e61@52.76.37.145:30303", "enode://de55d16b6e1fca28cdd3d11eb0dd89e3b77b96d4722172bd5e04ac255922324076a87748e97bc021af2307dccbb5ef8062389cfcba1845f77219eee7935dea9f@52.74.125.36:30303", "enode://7f2272685fc3e31c8e43c7687dda43ea3192fd310ba01efcb7811d5dc7ad5a64402ea8cd827650e573a174cf29bb69331dffcca6f0b9894ef17eeafabd97a41d@47.128.184.10:30303", "enode://c66e12243b425b63528dd8b1ce87f2f7fbc85f35485e2d8bf6bbf0ec0dcd05b3a582ef62daadbde061b58058735788335d09ed972a451242b9943b85d323c239@63.32.214.97:30303", "enode://bd56c0f00dd37e14ae2b84f5eb50e357d3a2d326bdbb0cbb987411268b3f132288f6c86157fc132c6902d18b9be0de8bbdcd12d926e16232ebadd8e274aae780@52.208.81.179:30303", "enode://2f015d5b1571165975382281a2117a9b514e1b38e87a8116596fc9b3b121a93cfb238eb6f7b3ae30cf9c0154384372745ce9edc09cbc30526ab7e2059f57ddee@54.74.160.230:30303" ] # trusted-nodes = [] - # dns = [] + dns = [ "enrtree://AKUEZKN7PSKVNR65FZDHECMKOJQSGPARGTPPBI7WS2VUL4EGR6XPC@amoy.polygon-peers.io" ] # [heimdall] # url = "http://localhost:1317" diff --git a/packaging/templates/testnet-amoy/without-sentry/bor/pbss_config.toml b/packaging/templates/testnet-amoy/without-sentry/bor/pbss_config.toml index 8ea23b8870..dd4a2b37f7 100644 --- a/packaging/templates/testnet-amoy/without-sentry/bor/pbss_config.toml +++ b/packaging/templates/testnet-amoy/without-sentry/bor/pbss_config.toml @@ -36,14 +36,14 @@ syncmode = "full" # nodekey = "" # nodekeyhex = "" # txarrivalwait = "500ms" - # [p2p.discovery] + [p2p.discovery] # v5disc = false # bootnodesv5 = [] # bootnodesv4 = [] bootnodes = [ "enode://bce861be777e91b0a5a49d58a51e14f32f201b4c6c2d1fbea6c7a1f14756cbb3f931f3188d6b65de8b07b53ff28d03b6e366d09e56360d2124a9fc5a15a0913d@54.217.171.196:30303", "enode://4a3dc0081a346d26a73d79dd88216a9402d2292318e2db9947dbc97ea9c4afb2498dc519c0af04420dc13a238c279062da0320181e7c1461216ce4513bfd40bf@13.251.184.185:30303" ] static-nodes = [ "enode://383ec39eb7f7e23538ea846f502602632110a6bcfc7521bfc2b8833f5a190779507d006b28650d83674b75d188cb36bcb3c3e168a0f2b3d98f9a651cc6603146@52.214.229.208:30303", "enode://bce861be777e91b0a5a49d58a51e14f32f201b4c6c2d1fbea6c7a1f14756cbb3f931f3188d6b65de8b07b53ff28d03b6e366d09e56360d2124a9fc5a15a0913d@54.217.171.196:30303", "enode://a4a387ad423a2fd0d652808b270082250d3c616b7e8537209584ebad4806dd50ef8dc66a371c85c7f55e6c1f53747edbb11055c8073cfacf312047eaeb328f58@54.171.220.164:30303", "enode://4a3dc0081a346d26a73d79dd88216a9402d2292318e2db9947dbc97ea9c4afb2498dc519c0af04420dc13a238c279062da0320181e7c1461216ce4513bfd40bf@13.251.184.185:30303", "enode://e8fe33b52f90d4bc7a4e75800945df449d1a091bd347c9f11cd1dbcd98ea28cb4c231cb3b1c6feacdabca2aa91f1a6744724b44edc9382c107968792abdef261@52.74.18.182:30303", "enode://b240f1f18e8f3cc61df96a164ba215ea6fc3f00717e4300da6283362a0438bda53f81ecc24c575ff130066d42096319fa027c952681bbb4f003e0bdd5d5b4e61@52.76.37.145:30303", "enode://de55d16b6e1fca28cdd3d11eb0dd89e3b77b96d4722172bd5e04ac255922324076a87748e97bc021af2307dccbb5ef8062389cfcba1845f77219eee7935dea9f@52.74.125.36:30303", "enode://7f2272685fc3e31c8e43c7687dda43ea3192fd310ba01efcb7811d5dc7ad5a64402ea8cd827650e573a174cf29bb69331dffcca6f0b9894ef17eeafabd97a41d@47.128.184.10:30303", "enode://c66e12243b425b63528dd8b1ce87f2f7fbc85f35485e2d8bf6bbf0ec0dcd05b3a582ef62daadbde061b58058735788335d09ed972a451242b9943b85d323c239@63.32.214.97:30303", "enode://bd56c0f00dd37e14ae2b84f5eb50e357d3a2d326bdbb0cbb987411268b3f132288f6c86157fc132c6902d18b9be0de8bbdcd12d926e16232ebadd8e274aae780@52.208.81.179:30303", "enode://2f015d5b1571165975382281a2117a9b514e1b38e87a8116596fc9b3b121a93cfb238eb6f7b3ae30cf9c0154384372745ce9edc09cbc30526ab7e2059f57ddee@54.74.160.230:30303" ] # trusted-nodes = [] - # dns = [] + dns = [ "enrtree://AKUEZKN7PSKVNR65FZDHECMKOJQSGPARGTPPBI7WS2VUL4EGR6XPC@amoy.polygon-peers.io" ] # [heimdall] # url = "http://localhost:1317" From b42c28dd93eec06e80d8c6b20b54adbf5f731918 Mon Sep 17 00:00:00 2001 From: chloefeal <188809157+chloefeal@users.noreply.github.com> Date: Fri, 31 Jan 2025 03:32:27 +0800 Subject: [PATCH 15/15] fix: some typos (#1396) * build(deps): bump golang.org/x/crypto from 0.24.0 to 0.31.0 Bumps [golang.org/x/crypto](https://github.com/golang/crypto) from 0.24.0 to 0.31.0. - [Commits](https://github.com/golang/crypto/compare/v0.24.0...v0.31.0) --- updated-dependencies: - dependency-name: golang.org/x/crypto dependency-type: direct:production ... Signed-off-by: dependabot[bot] * fix: typo Signed-off-by: chloefeal <188809157+chloefeal@users.noreply.github.com> * fix: typo Signed-off-by: chloefeal <188809157+chloefeal@users.noreply.github.com> * fix: typo Signed-off-by: chloefeal <188809157+chloefeal@users.noreply.github.com> * fix: typo Signed-off-by: chloefeal <188809157+chloefeal@users.noreply.github.com> --------- Signed-off-by: dependabot[bot] Signed-off-by: chloefeal <188809157+chloefeal@users.noreply.github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Raneet Debnath <35629432+Raneet10@users.noreply.github.com> --- core/blockchain.go | 2 +- core/rawdb/database.go | 2 +- core/rawdb/freezer.go | 2 +- eth/downloader/whitelist/service_test.go | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/core/blockchain.go b/core/blockchain.go index b293f8d4ef..1fe9617870 100644 --- a/core/blockchain.go +++ b/core/blockchain.go @@ -2393,7 +2393,7 @@ func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool) (int, error) // Before the actual db insertion happens, verify the block against the whitelisted // milestone and checkpoint. This is to prevent a race condition where a milestone // or checkpoint was whitelisted while the block execution happened (and wasn't - // available sometime before) and the block turns out to be inavlid (i.e. not + // available sometime before) and the block turns out to be invalid (i.e. not // honouring the milestone or checkpoint). Use the block itself as current block // so that it's considered as a `past` chain and the validation doesn't get bypassed. isValid, err = bc.forker.ValidateReorg(block.Header(), []*types.Header{block.Header()}) diff --git a/core/rawdb/database.go b/core/rawdb/database.go index e4b2167fc7..b3563af59e 100644 --- a/core/rawdb/database.go +++ b/core/rawdb/database.go @@ -217,7 +217,7 @@ func WriteOffsetOfLastAncientFreezer(db ethdb.KeyValueWriter, offset uint64) { // NewDatabaseWithOnlyFreezer create a freezer db without state func NewDatabaseWithOnlyFreezer(db ethdb.KeyValueStore, frz, namespace string, readonly bool, newOffSet uint64) (*Freezer, error) { - // Create the idle freezer instance, this operation should be atomic to avoid mismatch between offset and acientDB. + // Create the idle freezer instance, this operation should be atomic to avoid mismatch between offset and ancientDB. frdb, err := NewChainFreezer(frz, namespace, readonly, newOffSet) if err != nil { return nil, err diff --git a/core/rawdb/freezer.go b/core/rawdb/freezer.go index 493bc3c618..af52af579d 100644 --- a/core/rawdb/freezer.go +++ b/core/rawdb/freezer.go @@ -152,7 +152,7 @@ func NewFreezer(datadir string, namespace string, readonly bool, offset uint64, } // Some blocks in ancientDB may have already been frozen and been pruned, so adding the offset to - // reprensent the absolute number of blocks already frozen. + // represent the absolute number of blocks already frozen. freezer.frozen.Add(offset) // Create the write batch. diff --git a/eth/downloader/whitelist/service_test.go b/eth/downloader/whitelist/service_test.go index 169996bf6a..3ca7f22950 100644 --- a/eth/downloader/whitelist/service_test.go +++ b/eth/downloader/whitelist/service_test.go @@ -559,7 +559,7 @@ func TestIsValidChain(t *testing.T) { s.ProcessMilestone(tempChain[1].Number.Uint64(), tempChain[1].Hash()) // case10: Try importing a past chain having valid checkpoint, should - // consider the chain as invalid as still lastest milestone is ahead of the chain. + // consider the chain as invalid as still latest milestone is ahead of the chain. res, err = s.IsValidChain(tempChain[1], chainA) require.Nil(t, err) require.Equal(t, res, false, "expected chain to be invalid")