align error with geth

yperbasis · yperbasis · commit 9fb8b5b00e20 · 2025-08-07T15:37:43.000+02:00
diff --git a/core/vm/contracts.go b/core/vm/contracts.go
@@ -559,11 +559,7 @@ func (c *bigModExp) RequiredGas(input []byte) uint64 {
 	return gas.Uint64()
 }
 
-var (
-	errModExpBaseLengthTooLarge     = errors.New("base length is too large")
-	errModExpExponentLengthTooLarge = errors.New("exponent length is too large")
-	errModExpModulusLengthTooLarge  = errors.New("modulus length is too large")
-)
+var errModExpLengthTooLarge = errors.New("one or more of base/exponent/modulus length exceeded 1024 bytes")
 
 func (c *bigModExp) Run(input []byte) ([]byte, error) {
 	header := getData(input, 0, 3*32)
@@ -577,13 +573,13 @@ func (c *bigModExp) Run(input []byte) ([]byte, error) {
 		// We also need to check that the high bytes truncated by the Uint64 conversion above are zero
 		// (32 - 8 bytes were truncated)
 		if !allZero(header[0:32-8]) || baseLen > 1024 {
-			return nil, errModExpBaseLengthTooLarge
+			return nil, errModExpLengthTooLarge
 		}
 		if !allZero(header[32:64-8]) || expLen > 1024 {
-			return nil, errModExpExponentLengthTooLarge
+			return nil, errModExpLengthTooLarge
 		}
 		if !allZero(header[64:96-8]) || modLen > 1024 {
-			return nil, errModExpModulusLengthTooLarge
+			return nil, errModExpLengthTooLarge
 		}
 	}
 
diff --git a/core/vm/contracts_test.go b/core/vm/contracts_test.go
@@ -294,7 +294,7 @@ func TestPrecompiledModExpInputEip7823(t *testing.T) {
 	osakaModExp := allPrecompiles[common.BytesToAddress([]byte{0xb5})]
 	gas = osakaModExp.RequiredGas(in)
 	_, _, err = RunPrecompiledContract(osakaModExp, in, gas, nil)
-	assert.ErrorIs(t, err, errModExpExponentLengthTooLarge)
+	assert.ErrorIs(t, err, errModExpLengthTooLarge)
 }
 
 // Tests the sample inputs from the elliptic curve scalar multiplication EIP 213.
diff --git a/core/vm/testdata/precompiles/fail-modexp-eip7823.json b/core/vm/testdata/precompiles/fail-modexp-eip7823.json
@@ -2,21 +2,21 @@
   {
     "Input": "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004010000000000000000000000000000000000000000000000000000000000000000",
     "Name": "length_of_EXPONENT = 1025; everything else is zero",
-    "ExpectedError": "exponent length is too large"
+    "ExpectedError": "one or more of base/exponent/modulus length exceeded 1024 bytes"
   },
   {
     "Input": "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000",
     "Name": "length_of_EXPONENT = 2048; everything else is zero",
-    "ExpectedError": "exponent length is too large"
+    "ExpectedError": "one or more of base/exponent/modulus length exceeded 1024 bytes"
   },
   {
     "Input": "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000",
     "Name": "length_of_EXPONENT = 2^32; everything else is zero",
-    "ExpectedError": "exponent length is too large"
+    "ExpectedError": "one or more of base/exponent/modulus length exceeded 1024 bytes"
   },
   {
     "Input": "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000",
     "Name": "length_of_EXPONENT = 2^64; everything else is zero",
-    "ExpectedError": "exponent length is too large"
+    "ExpectedError": "one or more of base/exponent/modulus length exceeded 1024 bytes"
   }
 ]

Original file line number	Diff line number	Diff line change
`@@ -559,11 +559,7 @@ func (c *bigModExp) RequiredGas(input []byte) uint64 {`
`559`	`559`	`return gas.Uint64()`
`560`	`560`	`}`
`561`	`561`
`562`		`-var (`
`563`		`- errModExpBaseLengthTooLarge = errors.New("base length is too large")`
`564`		`- errModExpExponentLengthTooLarge = errors.New("exponent length is too large")`
`565`		`- errModExpModulusLengthTooLarge = errors.New("modulus length is too large")`
`566`		`-)`
	`562`	`+var errModExpLengthTooLarge = errors.New("one or more of base/exponent/modulus length exceeded 1024 bytes")`
`567`	`563`
`568`	`564`	`func (c *bigModExp) Run(input []byte) ([]byte, error) {`
`569`	`565`	`header := getData(input, 0, 3*32)`
`@@ -577,13 +573,13 @@ func (c *bigModExp) Run(input []byte) ([]byte, error) {`
`577`	`573`	`// We also need to check that the high bytes truncated by the Uint64 conversion above are zero`
`578`	`574`	`// (32 - 8 bytes were truncated)`
`579`	`575`	`if !allZero(header[0:32-8]) \|\| baseLen > 1024 {`
`580`		`- return nil, errModExpBaseLengthTooLarge`
	`576`	`+ return nil, errModExpLengthTooLarge`
`581`	`577`	`}`
`582`	`578`	`if !allZero(header[32:64-8]) \|\| expLen > 1024 {`
`583`		`- return nil, errModExpExponentLengthTooLarge`
	`579`	`+ return nil, errModExpLengthTooLarge`
`584`	`580`	`}`
`585`	`581`	`if !allZero(header[64:96-8]) \|\| modLen > 1024 {`
`586`		`- return nil, errModExpModulusLengthTooLarge`
	`582`	`+ return nil, errModExpLengthTooLarge`
`587`	`583`	`}`
`588`	`584`	`}`
`589`	`585`
Original file line number	Diff line number	Diff line change
`@@ -294,7 +294,7 @@ func TestPrecompiledModExpInputEip7823(t *testing.T) {`
`294`	`294`	`osakaModExp := allPrecompiles[common.BytesToAddress([]byte{0xb5})]`
`295`	`295`	`gas = osakaModExp.RequiredGas(in)`
`296`	`296`	`_, _, err = RunPrecompiledContract(osakaModExp, in, gas, nil)`
`297`		`- assert.ErrorIs(t, err, errModExpExponentLengthTooLarge)`
	`297`	`+ assert.ErrorIs(t, err, errModExpLengthTooLarge)`
`298`	`298`	`}`
`299`	`299`
`300`	`300`	`// Tests the sample inputs from the elliptic curve scalar multiplication EIP 213.`
Original file line number	Diff line number	Diff line change
`@@ -2,21 +2,21 @@`
`2`	`2`	`{`
`3`	`3`	`"Input": "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004010000000000000000000000000000000000000000000000000000000000000000",`
`4`	`4`	`"Name": "length_of_EXPONENT = 1025; everything else is zero",`
`5`		`- "ExpectedError": "exponent length is too large"`
	`5`	`+ "ExpectedError": "one or more of base/exponent/modulus length exceeded 1024 bytes"`
`6`	`6`	`},`
`7`	`7`	`{`
`8`	`8`	`"Input": "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000",`
`9`	`9`	`"Name": "length_of_EXPONENT = 2048; everything else is zero",`
`10`		`- "ExpectedError": "exponent length is too large"`
	`10`	`+ "ExpectedError": "one or more of base/exponent/modulus length exceeded 1024 bytes"`
`11`	`11`	`},`
`12`	`12`	`{`
`13`	`13`	`"Input": "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000",`
`14`	`14`	`"Name": "length_of_EXPONENT = 2^32; everything else is zero",`
`15`		`- "ExpectedError": "exponent length is too large"`
	`15`	`+ "ExpectedError": "one or more of base/exponent/modulus length exceeded 1024 bytes"`
`16`	`16`	`},`
`17`	`17`	`{`
`18`	`18`	`"Input": "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000",`
`19`	`19`	`"Name": "length_of_EXPONENT = 2^64; everything else is zero",`
`20`		`- "ExpectedError": "exponent length is too large"`
	`20`	`+ "ExpectedError": "one or more of base/exponent/modulus length exceeded 1024 bytes"`
`21`	`21`	`}`
`22`	`22`	`]`