Implement `P256VERIFY` precompile EIP-7951

[advaita-saha]

EIP- https://eips.ethereum.org/EIPS/eip-7951

Add functionality to efficiently perform ECDSA signature verification over the secp256r1 elliptic curve (also known as P-256 or prime256v1)

[mratsim]

ECDSA verify is implemented here:

constantine/constantine/signatures/ecdsa.nim

Lines 259 to 310 in d2df757

	proc verifyImpl[Name: static Algebra; Sig](
	publicKey: EC_ShortW_Aff[Fp[Name], G1],
	signature: Sig,
	msgHash: Fr[Name]
	): bool =
	## Verify a given `signature` for a `message` using the given `publicKey`.
	# 1. Compute w = s⁻¹
	var w = signature.s
	w.inv() # w = s⁻¹
	# 2. Compute u₁ = ew and u₂ = rw
	var
	u1 {.noinit.}: Fr[Name]
	u2 {.noinit.}: Fr[Name]
	u1.prod(msgHash, w)
	u2.prod(signature.r, w)
	# 3. Compute u₁G + u₂Q
	var
	point1 {.noinit.}: EC_ShortW_Jac[Fp[Name], G1]
	point2 {.noinit.}: EC_ShortW_Jac[Fp[Name], G1]
	# Generator of the curve
	const G = publicKey.F.Name.getGenerator($publicKey.G)
	point1.scalarMul(u1, G)
	point2.scalarMul(u2, publicKey)
	var R {.noinit.}: EC_ShortW_Jac[Fp[Name], G1]
	R.sum(point1, point2)
	# 4. Get x coordinate (in `Fp`) and convert to `Fr` (like in signing)
	let x = R.getAffine().x
	let r_computed = Fr[Name].fromBig(x.toBig())
	# 5. Verify r_computed equals provided r
	result = bool(r_computed == signature.r)
	func coreVerify*[Pubkey, Sig](
	pubkey: Pubkey,
	message: openarray[byte],
	signature: Sig,
	H: type CryptoHash): bool {.genCharAPI.} =
	## Check that a signature is valid
	## for a message under the provided public key
	## This assumes that the PublicKey and Signatures
	## have been pre-checked for non-infinity and being in the correct subgroup
	## (likely on deserialization)
	# 1. Hash the message (same as in signing)
	var dgst {.noinit.}: array[H.digestSize, byte]
	H.hash(dgst, message)
	var msgHash {.noinit.}: Fr[pubkey.F.Name]
	msgHash.fromDigest(dgst, truncateInput = true)
	# 2. verify
	result = pubKey.verifyImpl(signature, msgHash)

P256 is configured:

constantine/constantine/named/config_fields_and_curves.nim

Lines 231 to 235 in d2df757

	curve P256: # secp256r1 / NIST P-256
	bitwidth: 256
	modulus: "0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff"
	order: "0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551"
	orderBitwidth: 256

So an initial implementation should be trivial and only make sure to handle EVM specific serialization + passing the test vectors.

Then making the code fast likely involve:

• adding Crandall prime parameter like secp256k1:

  constantine/constantine/named/config_fields_and_curves.nim

  Lines 236 to 245 in d2df757

  	curve Secp256k1: # Bitcoin curve
  	bitwidth: 256
  	modulus: "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"
  	modulusKind: Crandall(0x1000003D1'u64)
  	order: "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"
  	orderBitwidth: 256
  	eq_form: ShortWeierstrass
  	coef_a: 0
  	coef_b: 7

• investigating performance issues on 256-bit curves:
  • Low-level: discrepancy between field arithmetic performance and elliptic curve performance #446
  • ECRECOVER performance bug #521