@feelyourprotocol/evm 8141.0.0

package/src/precompiles/05-modexp.ts

@@ -0,0 +1,215 @@
+import {
+  BIGINT_0,
+  BIGINT_1,
+  BIGINT_2,
+  BIGINT_7,
+  BIGINT_8,
+  BIGINT_32,
+  BIGINT_64,
+  BIGINT_96,
+  bigIntToBytes,
+  bytesToBigInt,
+  bytesToHex,
+  setLengthLeft,
+  setLengthRight,
+} from '@feelyourprotocol/util'
+
+import { OOGResult } from '../evm.ts'
+
+import { getPrecompileName } from './index.ts'
+import { gasLimitCheck } from './util.ts'
+
+import type { ExecResult } from '../types.ts'
+import type { PrecompileInput } from './types.ts'
+
+const BIGINT_4 = BigInt(4)
+const BIGINT_16 = BigInt(16)
+const BIGINT_480 = BigInt(480)
+const BIGINT_200 = BigInt(200)
+const BIGINT_500 = BigInt(500)
+const BIGINT_1024 = BigInt(1024)
+const BIGINT_3072 = BigInt(3072)
+const BIGINT_199680 = BigInt(199680)
+const BIGINT_2147483647 = BigInt(2147483647)
+
+const maxInt = BigInt(Number.MAX_SAFE_INTEGER)
+
+function multiplicationComplexity(x: bigint): bigint {
+  let fac1
+  let fac2
+  if (x <= BIGINT_64) {
+    return x ** BIGINT_2
+  } else if (x <= BIGINT_1024) {
+    // return Math.floor(Math.pow(x, 2) / 4) + 96 * x - 3072
+    fac1 = x ** BIGINT_2 / BIGINT_4
+    fac2 = x * BIGINT_96
+    return fac1 + fac2 - BIGINT_3072
+  } else {
+    // return Math.floor(Math.pow(x, 2) / 16) + 480 * x - 199680
+    fac1 = x ** BIGINT_2 / BIGINT_16
+    fac2 = x * BIGINT_480
+    return fac1 + fac2 - BIGINT_199680
+  }
+}
+
+function getAdjustedExponentLength(data: Uint8Array, opts: PrecompileInput): bigint {
+  let expBytesStart
+  try {
+    const baseLen = bytesToBigInt(data.subarray(0, 32))
+    expBytesStart = 96 + Number(baseLen) // 96 for base length, then exponent length, and modulus length, then baseLen for the base data, then exponent bytes start
+  } catch {
+    expBytesStart = Number.MAX_SAFE_INTEGER - 32
+  }
+  const expLen = bytesToBigInt(data.subarray(32, 64))
+  let firstExpBytes = data.subarray(expBytesStart, expBytesStart + 32) // first word of the exponent data
+  firstExpBytes = setLengthRight(firstExpBytes, 32) // reading past the data reads virtual zeros
+  let firstExpBigInt = bytesToBigInt(firstExpBytes)
+  let max32expLen = 0
+  if (expLen < BIGINT_32) {
+    max32expLen = 32 - Number(expLen)
+  }
+  firstExpBigInt = firstExpBigInt >> (BIGINT_8 * BigInt(Math.max(max32expLen, 0)))
+
+  let bitLen = -1
+  while (firstExpBigInt > BIGINT_0) {
+    bitLen = bitLen + 1
+    firstExpBigInt = firstExpBigInt >> BIGINT_1
+  }
+  let expLenMinus32OrZero = expLen - BIGINT_32
+  if (expLenMinus32OrZero < BIGINT_0) {
+    expLenMinus32OrZero = BIGINT_0
+  }
+  let adjustedExpLen =
+    expLenMinus32OrZero * (opts.common.isActivatedEIP(7883) === true ? BIGINT_16 : BIGINT_8)
+  if (bitLen > 0) {
+    adjustedExpLen += BigInt(bitLen)
+  }
+  return adjustedExpLen
+}
+
+export function expMod(a: bigint, power: bigint, modulo: bigint) {
+  if (power === BIGINT_0) {
+    return BIGINT_1 % modulo
+  }
+  let res = BIGINT_1
+  while (power > BIGINT_0) {
+    if (power & BIGINT_1) res = (res * a) % modulo
+    a = (a * a) % modulo
+    power >>= BIGINT_1
+  }
+  return res
+}
+
+export function precompile05(opts: PrecompileInput): ExecResult {
+  const pName = getPrecompileName('05')
+  const data = opts.data.length < 96 ? setLengthRight(opts.data, 96) : opts.data
+
+  let adjustedELen = getAdjustedExponentLength(data, opts)
+  if (adjustedELen < BIGINT_1) {
+    adjustedELen = BIGINT_1
+  }
+
+  const bLen = bytesToBigInt(data.subarray(0, 32))
+  const eLen = bytesToBigInt(data.subarray(32, 64))
+  const mLen = bytesToBigInt(data.subarray(64, 96))
+
+  let maxLen = bLen
+  if (maxLen < mLen) {
+    maxLen = mLen
+  }
+  const Gquaddivisor = opts.common.param('modexpGquaddivisorGas')
+  let gasUsed
+
+  const bStart = BIGINT_96
+  const bEnd = bStart + bLen
+  const eStart = bEnd
+  const eEnd = eStart + eLen
+  const mStart = eEnd
+  const mEnd = mStart + mLen
+
+  if (opts.common.isActivatedEIP(2565)) {
+    const words = (maxLen + BIGINT_7) / BIGINT_8
+    if (opts.common.isActivatedEIP(7883)) {
+      gasUsed = adjustedELen * (maxLen > BIGINT_32 ? BIGINT_2 * words * words : BIGINT_16)
+      if (gasUsed < BIGINT_500) {
+        gasUsed = BIGINT_500
+      }
+    } else {
+      gasUsed = (adjustedELen * words * words) / Gquaddivisor
+      if (gasUsed < BIGINT_200) {
+        gasUsed = BIGINT_200
+      }
+    }
+  } else {
+    gasUsed = (adjustedELen * multiplicationComplexity(maxLen)) / Gquaddivisor
+  }
+
+  if (!gasLimitCheck(opts, gasUsed, pName)) {
+    return OOGResult(opts.gasLimit)
+  }
+
+  // Upper bounds by EIP-7823 (Osaka and upwards) or otherwise
+  // @feelyourprotocol/util setLengthRight limitation
+  const maxSize = opts.common.isActivatedEIP(7823) ? BIGINT_1024 : BIGINT_2147483647
+
+  if (opts._debug !== undefined) {
+    // Lengths value debugging
+    const total = BigInt(96) + bLen + eLen + mLen
+    const data = BigInt(opts.data.length)
+    let msg = `${pName} length values: maxSize(b/e/m)=${maxSize} bLen=${bLen} eLen=${eLen} mLen=${mLen} 96+b+e+m=${total} `
+    msg += `data=${data} lengthMatch=${total === data}`
+    opts._debug(msg)
+  }
+
+  // Optimization: do not compute for b and m being 0 but return early
+  if (!opts.common.isActivatedEIP(7823) && bLen === BIGINT_0 && mLen === BIGINT_0) {
+    return {
+      executionGasUsed: gasUsed,
+      returnValue: new Uint8Array(),
+    }
+  }
+
+  if (bLen > maxSize || eLen > maxSize || mLen > maxSize) {
+    if (opts._debug !== undefined) {
+      opts._debug(`${pName} failed: one or more input values too large`)
+    }
+    return OOGResult(opts.gasLimit)
+  }
+
+  if (mEnd > maxInt) {
+    if (opts._debug !== undefined) {
+      opts._debug(`${pName} failed: total input too large`)
+    }
+    return OOGResult(opts.gasLimit)
+  }
+
+  const B = bytesToBigInt(setLengthRight(data.subarray(Number(bStart), Number(bEnd)), Number(bLen)))
+  const E = bytesToBigInt(setLengthRight(data.subarray(Number(eStart), Number(eEnd)), Number(eLen)))
+  const M = bytesToBigInt(setLengthRight(data.subarray(Number(mStart), Number(mEnd)), Number(mLen)))
+
+  if (opts._debug !== undefined) {
+    opts._debug(`${pName} input: B=${B} E=${E} M=${M}`)
+  }
+
+  let R
+  if (M === BIGINT_0) {
+    R = new Uint8Array()
+  } else {
+    R = expMod(B, E, M)
+    if (R === BIGINT_0) {
+      R = new Uint8Array()
+    } else {
+      R = bigIntToBytes(R)
+    }
+  }
+
+  const res = setLengthLeft(R, Number(mLen))
+  if (opts._debug !== undefined) {
+    opts._debug(`${pName} return value=${bytesToHex(res)}`)
+  }
+
+  return {
+    executionGasUsed: gasUsed,
+    returnValue: res,
+  }
+}

package/src/precompiles/06-bn254-add.ts

@@ -0,0 +1,49 @@
+import { bytesToHex, setLengthRight } from '@feelyourprotocol/util'
+
+import { EVMErrorResult, OOGResult } from '../evm.ts'
+
+import { getPrecompileName } from './index.ts'
+import { gasLimitCheck } from './util.ts'
+
+import type { EVM } from '../evm.ts'
+import type { ExecResult } from '../types.ts'
+import type { PrecompileInput } from './types.ts'
+
+export function precompile06(opts: PrecompileInput): ExecResult {
+  const pName = getPrecompileName('06')
+  const gasUsed = opts.common.param('bn254AddGas')
+  if (!gasLimitCheck(opts, gasUsed, pName)) {
+    return OOGResult(opts.gasLimit)
+  }
+
+  // > 128 bytes: chop off extra bytes
+  // < 128 bytes: right-pad with 0-s
+  const input = setLengthRight(opts.data.subarray(0, 128), 128)
+
+  let returnData
+  try {
+    returnData = (opts._EVM as EVM)['_bn254'].add(input)
+  } catch (e: any) {
+    if (opts._debug !== undefined) {
+      opts._debug(`${pName} failed: ${e.message}`)
+    }
+    return EVMErrorResult(e, opts.gasLimit)
+  }
+
+  // check ecadd success or failure by comparing the output length
+  if (returnData.length !== 64) {
+    if (opts._debug !== undefined) {
+      opts._debug(`${pName} failed: OOG`)
+    }
+    return OOGResult(opts.gasLimit)
+  }
+
+  if (opts._debug !== undefined) {
+    opts._debug(`${pName} return value=${bytesToHex(returnData)}`)
+  }
+
+  return {
+    executionGasUsed: gasUsed,
+    returnValue: returnData,
+  }
+}

package/src/precompiles/07-bn254-mul.ts

@@ -0,0 +1,50 @@
+import { bytesToHex, setLengthRight } from '@feelyourprotocol/util'
+
+import { EVMErrorResult, OOGResult } from '../evm.ts'
+
+import { getPrecompileName } from './index.ts'
+import { gasLimitCheck } from './util.ts'
+
+import type { EVM } from '../evm.ts'
+import type { ExecResult } from '../types.ts'
+import type { PrecompileInput } from './types.ts'
+
+export function precompile07(opts: PrecompileInput): ExecResult {
+  const pName = getPrecompileName('07')
+  const gasUsed = opts.common.param('bn254MulGas')
+  if (!gasLimitCheck(opts, gasUsed, pName)) {
+    return OOGResult(opts.gasLimit)
+  }
+
+  // > 128 bytes: chop off extra bytes
+  // < 128 bytes: right-pad with 0-s
+  const input = setLengthRight(opts.data.subarray(0, 128), 128)
+
+  let returnData
+  try {
+    returnData = (opts._EVM as EVM)['_bn254'].mul(input)
+  } catch (e: any) {
+    if (opts._debug !== undefined) {
+      opts._debug(`${pName} failed: ${e.message}`)
+    }
+    return EVMErrorResult(e, opts.gasLimit)
+  }
+
+  // check ecmul success or failure by comparing the output length
+  if (returnData.length !== 64) {
+    if (opts._debug !== undefined) {
+      opts._debug(`${pName} failed: OOG`)
+    }
+    // TODO: should this really return OOG?
+    return OOGResult(opts.gasLimit)
+  }
+
+  if (opts._debug !== undefined) {
+    opts._debug(`${pName} return value=${bytesToHex(returnData)}`)
+  }
+
+  return {
+    executionGasUsed: gasUsed,
+    returnValue: returnData,
+  }
+}

package/src/precompiles/08-bn254-pairing.ts

@@ -0,0 +1,54 @@
+import { bytesToHex } from '@feelyourprotocol/util'
+
+import { EVMError } from '../errors.ts'
+import { EVMErrorResult, OOGResult } from '../evm.ts'
+
+import { getPrecompileName } from './index.ts'
+import { gasLimitCheck, moduloLengthCheck } from './util.ts'
+
+import type { EVM } from '../evm.ts'
+import type { ExecResult } from '../types.ts'
+import type { PrecompileInput } from './types.ts'
+
+export function precompile08(opts: PrecompileInput): ExecResult {
+  const pName = getPrecompileName('08')
+  if (!moduloLengthCheck(opts, 192, pName)) {
+    return EVMErrorResult(new EVMError(EVMError.errorMessages.INVALID_INPUT_LENGTH), opts.gasLimit)
+  }
+
+  const inputDataSize = BigInt(Math.floor(opts.data.length / 192))
+  const gasUsed =
+    opts.common.param('bn254PairingGas') + inputDataSize * opts.common.param('bn254PairingWordGas')
+
+  if (!gasLimitCheck(opts, gasUsed, pName)) {
+    return OOGResult(opts.gasLimit)
+  }
+
+  let returnData
+  try {
+    returnData = (opts._EVM as EVM)['_bn254'].pairing(opts.data)
+  } catch (e: any) {
+    if (opts._debug !== undefined) {
+      opts._debug(`${pName} failed: ${e.message}`)
+    }
+    return EVMErrorResult(e, opts.gasLimit)
+  }
+
+  // check ecpairing success or failure by comparing the output length
+  if (returnData.length !== 32) {
+    if (opts._debug !== undefined) {
+      opts._debug(`${pName} failed: OOG`)
+    }
+    // TODO: should this really return OOG?
+    return OOGResult(opts.gasLimit)
+  }
+
+  if (opts._debug !== undefined) {
+    opts._debug(`${pName} return value=${bytesToHex(returnData)}`)
+  }
+
+  return {
+    executionGasUsed: gasUsed,
+    returnValue: returnData,
+  }
+}

package/src/precompiles/09-blake2f.ts

@@ -0,0 +1,243 @@
+import { bytesToHex } from '@feelyourprotocol/util'
+
+import { EVMError } from '../errors.ts'
+import { OOGResult } from '../evm.ts'
+
+import { getPrecompileName } from './index.ts'
+import { gasLimitCheck } from './util.ts'
+
+import type { ExecResult } from '../types.ts'
+import type { PrecompileInput } from './types.ts'
+
+// The following blake2 code has been taken from (license: Creative Commons CC0):
+// https://github.com/dcposch/blakejs/blob/410c640d0f08d3b26904c6d1ab3d81df3619d282/blake2b.js
+// The modifications include:
+//  - Avoiding the use of context in F
+//  - F accepts number of rounds as parameter
+//  - Expect 2 64-byte t values, xor them both
+//  - Take modulo 10 for indices of SIGMA
+//  - Added type annotations
+//  - Moved previously global `v` and `m` variables inside the F function
+
+// 64-bit unsigned addition
+// Sets v[a,a+1] += v[b,b+1]
+// v should be a Uint32Array
+function ADD64AA(v: Uint32Array, a: number, b: number) {
+  const o0 = v[a] + v[b]
+  let o1 = v[a + 1] + v[b + 1]
+  if (o0 >= 0x100000000) {
+    o1++
+  }
+  v[a] = o0
+  v[a + 1] = o1
+}
+
+// 64-bit unsigned addition
+// Sets v[a,a+1] += b
+// b0 is the low 32 bits of b, b1 represents the high 32 bits
+function ADD64AC(v: Uint32Array, a: number, b0: number, b1: number) {
+  let o0 = v[a] + b0
+  if (b0 < 0) {
+    o0 += 0x100000000
+  }
+  let o1 = v[a + 1] + b1
+  if (o0 >= 0x100000000) {
+    o1++
+  }
+  v[a] = o0
+  v[a + 1] = o1
+}
+
+// G Mixing function
+// The ROTRs are inlined for speed
+function B2B_G(
+  v: Uint32Array,
+  mw: Uint32Array,
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+  ix: number,
+  iy: number,
+) {
+  const x0 = mw[ix]
+  const x1 = mw[ix + 1]
+  const y0 = mw[iy]
+  const y1 = mw[iy + 1]
+
+  ADD64AA(v, a, b) // v[a,a+1] += v[b,b+1] ... in JS we must store a uint64 as two uint32s
+  ADD64AC(v, a, x0, x1) // v[a, a+1] += x ... x0 is the low 32 bits of x, x1 is the high 32 bits
+
+  // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated to the right by 32 bits
+  let xor0 = v[d] ^ v[a]
+  let xor1 = v[d + 1] ^ v[a + 1]
+  v[d] = xor1
+  v[d + 1] = xor0
+
+  ADD64AA(v, c, d)
+
+  // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 24 bits
+  xor0 = v[b] ^ v[c]
+  xor1 = v[b + 1] ^ v[c + 1]
+  v[b] = (xor0 >>> 24) ^ (xor1 << 8)
+  v[b + 1] = (xor1 >>> 24) ^ (xor0 << 8)
+
+  ADD64AA(v, a, b)
+  ADD64AC(v, a, y0, y1)
+
+  // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated right by 16 bits
+  xor0 = v[d] ^ v[a]
+  xor1 = v[d + 1] ^ v[a + 1]
+  v[d] = (xor0 >>> 16) ^ (xor1 << 16)
+  v[d + 1] = (xor1 >>> 16) ^ (xor0 << 16)
+
+  ADD64AA(v, c, d)
+
+  // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 63 bits
+  xor0 = v[b] ^ v[c]
+  xor1 = v[b + 1] ^ v[c + 1]
+  v[b] = (xor1 >>> 31) ^ (xor0 << 1)
+  v[b + 1] = (xor0 >>> 31) ^ (xor1 << 1)
+}
+
+// Initialization Vector
+// prettier-ignore
+const BLAKE2B_IV32 = new Uint32Array([
+  0xf3bcc908, 0x6a09e667, 0x84caa73b, 0xbb67ae85, 0xfe94f82b, 0x3c6ef372, 0x5f1d36f1, 0xa54ff53a,
+  0xade682d1, 0x510e527f, 0x2b3e6c1f, 0x9b05688c, 0xfb41bd6b, 0x1f83d9ab, 0x137e2179, 0x5be0cd19,
+])
+
+// prettier-ignore
+const SIGMA8 = [
+  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11,
+  7, 5, 3, 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4, 7, 9, 3, 1, 13, 12, 11, 14, 2, 6,
+  5, 10, 4, 0, 15, 8, 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13, 2, 12, 6, 10, 0, 11, 8,
+  3, 4, 13, 7, 5, 15, 14, 1, 9, 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11, 13, 11, 7, 14,
+  12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10, 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5, 10,
+  2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+  14, 15, 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+]
+
+// These are offsets into a uint64 buffer.
+// Multiply them all by 2 to make them offsets into a uint32 buffer,
+// because this is Javascript and we don't have uint64s
+const SIGMA82 = new Uint8Array(
+  SIGMA8.map(function (x) {
+    return x * 2
+  }),
+)
+
+export function F(h: Uint32Array, m: Uint32Array, t: Uint32Array, f: boolean, rounds: number) {
+  const v = new Uint32Array(32)
+  let i = 0
+
+  // init work variables
+  for (i = 0; i < 16; i++) {
+    v[i] = h[i]
+    v[i + 16] = BLAKE2B_IV32[i]
+  }
+
+  // 128 bits of offset
+  v[24] = v[24] ^ t[0]
+  v[25] = v[25] ^ t[1]
+  v[26] = v[26] ^ t[2]
+  v[27] = v[27] ^ t[3]
+
+  // last block flag set ?
+  if (f) {
+    v[28] = ~v[28]
+    v[29] = ~v[29]
+  }
+
+  // twelve rounds of mixing
+  // uncomment the DebugPrint calls to log the computation
+  // and match the RFC sample documentation
+  // util.debugPrint('          m[16]', m, 64)
+  for (i = 0; i < rounds; i++) {
+    // util.debugPrint('   (i=' + (i < 10 ? ' ' : '') + i + ') v[16]', v, 64)
+    const ri = (i % 10) * 16
+    B2B_G(v, m, 0, 8, 16, 24, SIGMA82[ri + 0], SIGMA82[ri + 1])
+    B2B_G(v, m, 2, 10, 18, 26, SIGMA82[ri + 2], SIGMA82[ri + 3])
+    B2B_G(v, m, 4, 12, 20, 28, SIGMA82[ri + 4], SIGMA82[ri + 5])
+    B2B_G(v, m, 6, 14, 22, 30, SIGMA82[ri + 6], SIGMA82[ri + 7])
+    B2B_G(v, m, 0, 10, 20, 30, SIGMA82[ri + 8], SIGMA82[ri + 9])
+    B2B_G(v, m, 2, 12, 22, 24, SIGMA82[ri + 10], SIGMA82[ri + 11])
+    B2B_G(v, m, 4, 14, 16, 26, SIGMA82[ri + 12], SIGMA82[ri + 13])
+    B2B_G(v, m, 6, 8, 18, 28, SIGMA82[ri + 14], SIGMA82[ri + 15])
+  }
+
+  for (i = 0; i < 16; i++) {
+    h[i] = h[i] ^ v[i] ^ v[i + 16]
+  }
+}
+
+export function precompile09(opts: PrecompileInput): ExecResult {
+  const pName = getPrecompileName('09')
+  const data = opts.data
+  if (data.length !== 213) {
+    if (opts._debug !== undefined) {
+      opts._debug(`${pName} failed: OUT_OF_RANGE dataLength=${data.length}`)
+    }
+    return {
+      returnValue: new Uint8Array(0),
+      executionGasUsed: opts.gasLimit,
+      exceptionError: new EVMError(EVMError.errorMessages.OUT_OF_RANGE),
+    }
+  }
+  const lastByte = data.subarray(212, 213)[0]
+  if (lastByte !== 1 && lastByte !== 0) {
+    if (opts._debug !== undefined) {
+      opts._debug(`${pName} failed: OUT_OF_RANGE lastByte=${lastByte}`)
+    }
+    return {
+      returnValue: new Uint8Array(0),
+      executionGasUsed: opts.gasLimit,
+      exceptionError: new EVMError(EVMError.errorMessages.OUT_OF_RANGE),
+    }
+  }
+
+  const rounds = new DataView(data.buffer, data.byteOffset).getUint32(0)
+  const hRaw = new DataView(data.buffer, data.byteOffset + 4, 64)
+  const mRaw = new DataView(data.buffer, data.byteOffset + 68, 128)
+  const tRaw = new DataView(data.buffer, data.byteOffset + 196, 16)
+  // final
+  const f = lastByte === 1
+
+  let gasUsed = opts.common.param('blake2RoundGas')
+  gasUsed *= BigInt(rounds)
+  if (!gasLimitCheck(opts, gasUsed, pName)) {
+    return OOGResult(opts.gasLimit)
+  }
+
+  const h = new Uint32Array(16)
+  for (let i = 0; i < 16; i++) {
+    h[i] = hRaw.getUint32(i * 4, true)
+  }
+
+  const m = new Uint32Array(32)
+  for (let i = 0; i < 32; i++) {
+    m[i] = mRaw.getUint32(i * 4, true)
+  }
+
+  const t = new Uint32Array(4)
+  for (let i = 0; i < 4; i++) {
+    t[i] = tRaw.getUint32(i * 4, true)
+  }
+
+  F(h, m, t, f, rounds)
+
+  const output = new Uint8Array(64)
+  const outputView = new DataView(output.buffer)
+  for (let i = 0; i < 16; i++) {
+    outputView.setUint32(i * 4, h[i], true)
+  }
+
+  if (opts._debug !== undefined) {
+    opts._debug(`${pName} return hash=${bytesToHex(output)}`)
+  }
+
+  return {
+    executionGasUsed: gasUsed,
+    returnValue: output,
+  }
+}

package/src/precompiles/0a-kzg-point-evaluation.ts

@@ -0,0 +1,94 @@
+import {
+  EthereumJSErrorWithoutCode,
+  bigIntToBytes,
+  bytesToHex,
+  computeVersionedHash,
+  concatBytes,
+  setLengthLeft,
+} from '@feelyourprotocol/util'
+
+import { EVMError } from '../errors.ts'
+import { EVMErrorResult, OOGResult } from '../evm.ts'
+
+import { getPrecompileName } from './index.ts'
+import { gasLimitCheck } from './util.ts'
+
+import type { ExecResult } from '../types.ts'
+import type { PrecompileInput } from './types.ts'
+
+export const BLS_MODULUS = BigInt(
+  '52435875175126190479447740508185965837690552500527637822603658699938581184513',
+)
+
+const modulusBuffer = setLengthLeft(bigIntToBytes(BLS_MODULUS), 32)
+
+export async function precompile0a(opts: PrecompileInput): Promise<ExecResult> {
+  const pName = getPrecompileName('0a')
+  if (opts.common.customCrypto?.kzg === undefined) {
+    throw EthereumJSErrorWithoutCode('kzg not initialized')
+  }
+  const gasUsed = opts.common.param('kzgPointEvaluationPrecompileGas')
+  if (!gasLimitCheck(opts, gasUsed, pName)) {
+    return OOGResult(opts.gasLimit)
+  }
+
+  if (opts.data.length !== 192) {
+    return EVMErrorResult(new EVMError(EVMError.errorMessages.INVALID_INPUT_LENGTH), opts.gasLimit)
+  }
+
+  const version = Number(opts.common.param('blobCommitmentVersionKzg'))
+  const fieldElementsPerBlob = opts.common.param('fieldElementsPerBlob')
+  const versionedHash = bytesToHex(opts.data.subarray(0, 32))
+  const z = bytesToHex(opts.data.subarray(32, 64))
+  const y = bytesToHex(opts.data.subarray(64, 96))
+  const commitment = bytesToHex(opts.data.subarray(96, 144))
+  const kzgProof = bytesToHex(opts.data.subarray(144, 192))
+
+  if (computeVersionedHash(commitment, version) !== versionedHash) {
+    if (opts._debug !== undefined) {
+      opts._debug(`${pName} failed: INVALID_COMMITMENT`)
+    }
+    return EVMErrorResult(new EVMError(EVMError.errorMessages.INVALID_COMMITMENT), opts.gasLimit)
+  }
+
+  if (opts._debug !== undefined) {
+    opts._debug(
+      `${pName}: proof verification with commitment=${
+        commitment
+      } z=${z} y=${y} kzgProof=${kzgProof}`,
+    )
+  }
+  try {
+    const res = opts.common.customCrypto?.kzg?.verifyProof(commitment, z, y, kzgProof)
+    if (res === false) {
+      return EVMErrorResult(new EVMError(EVMError.errorMessages.INVALID_PROOF), opts.gasLimit)
+    }
+  } catch (err: any) {
+    if (((err.message.includes('C_KZG_BADARGS') === true) === true) === true) {
+      if (opts._debug !== undefined) {
+        opts._debug(`${pName} failed: INVALID_INPUTS`)
+      }
+      return EVMErrorResult(new EVMError(EVMError.errorMessages.INVALID_INPUTS), opts.gasLimit)
+    }
+    if (opts._debug !== undefined) {
+      opts._debug(`${pName} failed: Unknown error - ${err.message}`)
+    }
+    return EVMErrorResult(new EVMError(EVMError.errorMessages.REVERT), opts.gasLimit)
+  }
+
+  // Return value - FIELD_ELEMENTS_PER_BLOB and BLS_MODULUS as padded 32 byte big endian values
+  const fieldElementsBuffer = setLengthLeft(bigIntToBytes(fieldElementsPerBlob), 32)
+
+  if (opts._debug !== undefined) {
+    opts._debug(
+      `${pName} return fieldElements=${bytesToHex(
+        fieldElementsBuffer,
+      )} modulus=${bytesToHex(modulusBuffer)}`,
+    )
+  }
+
+  return {
+    executionGasUsed: gasUsed,
+    returnValue: concatBytes(fieldElementsBuffer, modulusBuffer),
+  }
+}