# Nimbus
# Copyright (c) 2018-2024 Status Research & Development GmbH
# Licensed under either of
#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
#  * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
# at your option. This file may not be copied, modified, or distributed except according to those terms.

import
  std/[importutils, sequtils],
  unittest2,
  stew/byteutils,
  eth/keys,
  ../nimbus/common,
  ../nimbus/transaction,
  ../nimbus/evm/types,
  ../nimbus/evm/state,
  ../nimbus/evm/evm_errors,
  ../nimbus/evm/stack,
  ../nimbus/evm/memory,
  ../nimbus/evm/code_stream,
  ../nimbus/evm/internals,
  ../nimbus/constants,
  ../nimbus/core/pow/header,
  ../nimbus/db/ledger,
  ../nimbus/transaction/call_evm

template testPush(value: untyped, expected: untyped): untyped =
  privateAccess(EvmStackRef)
  var stack = EvmStackRef.new()
  check stack.push(value).isOk
  check(stack.values == @[expected])

func toBytes(s: string): seq[byte] =
  cast[seq[byte]](s)

func bigEndianToInt(value: openArray[byte]): UInt256 =
  result.initFromBytesBE(value)

proc runStackTests() =
  suite "Stack tests":
    test "push only valid":
      testPush(0'u, 0.u256)
      testPush(UINT_256_MAX, UINT_256_MAX)
      testPush("ves".toBytes, "ves".toBytes.bigEndianToInt)

    test "push does not allow stack to exceed 1024":
      var stack = EvmStackRef.new()
      for z in 0 ..< 1024:
        check stack.push(z.uint).isOk
      check(stack.len == 1024)
      check stack.push(1025).error.code == EvmErrorCode.StackFull

    test "dup does not allow stack to exceed 1024":
      var stack = EvmStackRef.new()
      check stack.push(1.u256).isOk
      for z in 0 ..< 1023:
        check stack.dup(1).isOk
      check(stack.len == 1024)
      check stack.dup(1).error.code == EvmErrorCode.StackFull

    test "pop returns latest stack item":
      var stack = EvmStackRef.new()
      for element in @[1'u, 2'u, 3'u]:
        check stack.push(element).isOk
      check(stack.popInt.get == 3.u256)

    test "swap correct":
      privateAccess(EvmStackRef)
      var stack = EvmStackRef.new()
      for z in 0 ..< 5:
        check stack.push(z.uint).isOk
      check(stack.values == @[0.u256, 1.u256, 2.u256, 3.u256, 4.u256])
      check stack.swap(3).isOk
      check(stack.values == @[0.u256, 4.u256, 2.u256, 3.u256, 1.u256])
      check stack.swap(1).isOk
      check(stack.values == @[0.u256, 4.u256, 2.u256, 1.u256, 3.u256])

    test "dup correct":
      privateAccess(EvmStackRef)
      var stack = EvmStackRef.new()
      for z in 0 ..< 5:
        check stack.push(z.uint).isOk
      check(stack.values == @[0.u256, 1.u256, 2.u256, 3.u256, 4.u256])
      check stack.dup(1).isOk
      check(stack.values == @[0.u256, 1.u256, 2.u256, 3.u256, 4.u256, 4.u256])
      check stack.dup(5).isOk
      check(stack.values == @[0.u256, 1.u256, 2.u256, 3.u256, 4.u256, 4.u256, 1.u256])

    test "pop raises InsufficientStack appropriately":
      var stack = EvmStackRef.new()
      check stack.popInt().error.code == EvmErrorCode.StackInsufficient

    test "swap raises InsufficientStack appropriately":
      var stack = EvmStackRef.new()
      check stack.swap(0).error.code == EvmErrorCode.StackInsufficient

    test "dup raises InsufficientStack appropriately":
      var stack = EvmStackRef.new()
      check stack.dup(0).error.code == EvmErrorCode.StackInsufficient

    test "binary operations raises InsufficientStack appropriately":
      # https://github.com/status-im/nimbus/issues/31
      # ./tests/fixtures/VMTests/vmArithmeticTest/mulUnderFlow.json

      var stack = EvmStackRef.new()
      check stack.push(123).isOk
      check stack.popInt(2).error.code == EvmErrorCode.StackInsufficient

proc memory32: EvmMemoryRef =
  result = EvmMemoryRef.new(32)

proc memory128: EvmMemoryRef =
  result = EvmMemoryRef.new(123)

proc runMemoryTests() =
  suite "Memory tests":
    test "write":
      var mem = memory32()
      # Test that write creates 32byte string == value padded with zeros
      check mem.write(startPos = 0, value = @[1.byte, 0.byte, 1.byte, 0.byte]).isOk
      check(mem.bytes == @[1.byte, 0.byte, 1.byte, 0.byte].concat(repeat(0.byte, 28)))

    test "write rejects values beyond memory size":
      var mem = memory128()
      check mem.write(startPos = 128, value = @[1.byte, 0.byte, 1.byte, 0.byte]).error.code == EvmErrorCode.MemoryFull
      check mem.write(startPos = 128, value = 1.byte).error.code == EvmErrorCode.MemoryFull

    test "extends appropriately extends memory":
      var mem = EvmMemoryRef.new()
      # Test extends to 32 byte array: 0 < (start_position + size) <= 32
      mem.extend(startPos = 0, size = 10)
      check(mem.bytes == repeat(0.byte, 32))
      # Test will extend past length if params require: 32 < (start_position + size) <= 64
      mem.extend(startPos = 28, size = 32)
      check(mem.bytes == repeat(0.byte, 64))
      # Test won't extend past length unless params require: 32 < (start_position + size) <= 64
      mem.extend(startPos = 48, size = 10)
      check(mem.bytes == repeat(0.byte, 64))

    test "read returns correct bytes":
      var mem = memory32()
      check mem.write(startPos = 5, value = @[1.byte, 0.byte, 1.byte, 0.byte]).isOk
      check(@(mem.read(startPos = 5, size = 4)) == @[1.byte, 0.byte, 1.byte, 0.byte])
      check(@(mem.read(startPos = 6, size = 4)) == @[0.byte, 1.byte, 0.byte, 0.byte])
      check(@(mem.read(startPos = 1, size = 3)) == @[0.byte, 0.byte, 0.byte])

proc runCodeStreamTests() =
  suite "Codestream tests":
    test "accepts bytes":
      let codeStream = CodeStream.init("\x01")
      check(codeStream.len == 1)

    test "next returns the correct opcode":
      var codeStream = CodeStream.init("\x01\x02\x30")
      check(codeStream.next == Op.ADD)
      check(codeStream.next == Op.MUL)
      check(codeStream.next == Op.ADDRESS)

    test "peek returns next opcode without changing location":
      var codeStream = CodeStream.init("\x01\x02\x30")
      check(codeStream.pc == 0)
      check(codeStream.peek == Op.ADD)
      check(codeStream.pc == 0)
      check(codeStream.next == Op.ADD)
      check(codeStream.pc == 1)
      check(codeStream.peek == Op.MUL)
      check(codeStream.pc == 1)

    test "stop opcode is returned when end reached":
      var codeStream = CodeStream.init("\x01\x02")
      discard codeStream.next
      discard codeStream.next
      check(codeStream.next == Op.STOP)

    test "[] returns opcode":
      let codeStream = CodeStream.init("\x01\x02\x30")
      check(codeStream[0] == Op.ADD)
      check(codeStream[1] == Op.MUL)
      check(codeStream[2] == Op.ADDRESS)

    test "isValidOpcode invalidates after PUSHXX":
      var codeStream = CodeStream.init("\x02\x60\x02\x04")
      check(codeStream.isValidOpcode(0))
      check(codeStream.isValidOpcode(1))
      check(not codeStream.isValidOpcode(2))
      check(codeStream.isValidOpcode(3))
      check(not codeStream.isValidOpcode(4))

    test "isValidOpcode 0":
      var codeStream = CodeStream.init(@[2.byte, 3.byte, 0x72.byte].concat(repeat(4.byte, 32)).concat(@[5.byte]))
      # valid: 0 - 2 :: 22 - 35
      # invalid: 3-21 (PUSH19) :: 36+ (too long)
      check(codeStream.isValidOpcode(0))
      check(codeStream.isValidOpcode(1))
      check(codeStream.isValidOpcode(2))
      check(not codeStream.isValidOpcode(3))
      check(not codeStream.isValidOpcode(21))
      check(codeStream.isValidOpcode(22))
      check(codeStream.isValidOpcode(35))
      check(not codeStream.isValidOpcode(36))

    test "isValidOpcode 1":
      let test = @[2.byte, 3.byte, 0x7d.byte].concat(repeat(4.byte, 32)).concat(@[5.byte, 0x7e.byte]).concat(repeat(4.byte, 35)).concat(@[1.byte, 0x61.byte, 1.byte, 1.byte, 1.byte])
      var codeStream = CodeStream.init(test)
      # valid: 0 - 2 :: 33 - 36 :: 68 - 73 :: 76
      # invalid: 3 - 32 (PUSH30) :: 37 - 67 (PUSH31) :: 74, 75 (PUSH2) :: 77+ (too long)
      check(codeStream.isValidOpcode(0))
      check(codeStream.isValidOpcode(1))
      check(codeStream.isValidOpcode(2))
      check(not codeStream.isValidOpcode(3))
      check(not codeStream.isValidOpcode(32))
      check(codeStream.isValidOpcode(33))
      check(codeStream.isValidOpcode(36))
      check(not codeStream.isValidOpcode(37))
      check(not codeStream.isValidOpcode(67))
      check(codeStream.isValidOpcode(68))
      check(codeStream.isValidOpcode(71))
      check(codeStream.isValidOpcode(72))
      check(codeStream.isValidOpcode(73))
      check(not codeStream.isValidOpcode(74))
      check(not codeStream.isValidOpcode(75))
      check(codeStream.isValidOpcode(76))
      check(not codeStream.isValidOpcode(77))

    test "right number of bytes invalidates":
      var codeStream = CodeStream.init("\x02\x03\x60\x02\x02")
      check(codeStream.isValidOpcode(0))
      check(codeStream.isValidOpcode(1))
      check(codeStream.isValidOpcode(2))
      check(not codeStream.isValidOpcode(3))
      check(codeStream.isValidOpcode(4))
      check(not codeStream.isValidOpcode(5))


proc initGasMeter(startGas: GasInt): GasMeter = result.init(startGas)

proc gasMeters: seq[GasMeter] =
  @[initGasMeter(10), initGasMeter(100), initGasMeter(999)]

template runTest(body: untyped) =
  var res = gasMeters()
  for gasMeter {.inject.} in res.mitems:
    let StartGas {.inject.} = gasMeter.gasRemaining
    body

proc runGasMeterTests() =
  suite "GasMeter tests":
    test "consume spends":
      runTest:
        check(gasMeter.gasRemaining == StartGas)
        let consume = StartGas
        check gasMeter.consumeGas(consume, "0").isOk
        check(gasMeter.gasRemaining - (StartGas - consume) == 0)

    test "consume errors":
      runTest:
        check(gasMeter.gasRemaining == StartGas)
        check gasMeter.consumeGas(StartGas + 1, "").error.code == EvmErrorCode.OutOfGas

    test "return refund works correctly":
      runTest:
        check(gasMeter.gasRemaining == StartGas)
        check(gasMeter.gasRefunded == 0)
        check gasMeter.consumeGas(5, "").isOk
        check(gasMeter.gasRemaining == StartGas - 5)
        gasMeter.returnGas(5)
        check(gasMeter.gasRemaining == StartGas)
        gasMeter.refundGas(5)
        check(gasMeter.gasRefunded == 5)

func toAddress(n: int): EthAddress =
  result[19] = n.byte

func toAddress(a, b: int): EthAddress =
  result[18] = a.byte
  result[19] = b.byte

func toAddress(a, b, c: int): EthAddress =
  result[17] = a.byte
  result[18] = b.byte
  result[19] = c.byte

proc runMiscTests() =
  suite "Misc test suite":
    test "EthAddress to int":
      check toAddress(0xff).toInt == 0xFF
      check toAddress(0x10, 0x0).toInt == 0x1000
      check toAddress(0x10, 0x0, 0x0).toInt == 0x100000

    test "calcGasLimitEIP1559":
      type
        GLT = object
          limit: GasInt
          max  : GasInt
          min  : GasInt

      const testData = [
        GLT(limit: 20000000, max: 20019530, min: 19980470),
        GLT(limit: 40000000, max: 40039061, min: 39960939)
      ]

      for x in testData:
        # Increase
        var have = calcGasLimit1559(x.limit, 2*x.limit)
        var want = x.max
        check have == want

        # Decrease
        have = calcGasLimit1559(x.limit, 0)
        want = x.min
        check have == want

        # Small decrease
        have = calcGasLimit1559(x.limit, x.limit-1)
        want = x.limit-1
        check have == want

        # Small increase
        have = calcGasLimit1559(x.limit, x.limit+1)
        want = x.limit+1
        check have == want

        # No change
        have = calcGasLimit1559(x.limit, x.limit)
        want = x.limit
        check have == want

const
  data = [0x5b.uint8, 0x5a, 0x5a, 0x30, 0x30, 0x30, 0x30, 0x72, 0x00, 0x00, 0x00, 0x58,
    0x58, 0x24, 0x58, 0x58, 0x3a, 0x19, 0x75, 0x75, 0x2e, 0x2e, 0x2e, 0x2e,
    0xec, 0x9f, 0x69, 0x67, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x6c, 0x5a, 0x32,
    0x07, 0xf4, 0x75, 0x75, 0xf5, 0x75, 0x75, 0x75, 0x7f, 0x5b, 0xd9, 0x32,
    0x5a, 0x07, 0x19, 0x34, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
    0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
    0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0xec,
    0x9f, 0x69, 0x67, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x6c, 0xfc, 0xf7, 0xfc,
    0xfc, 0xfc, 0xfc, 0xf4, 0x03, 0x03, 0x81, 0x81, 0x81, 0xfb, 0x7a, 0x30,
    0x80, 0x3d, 0x59, 0x59, 0x59, 0x59, 0x81, 0x00, 0x59, 0x2f, 0x45, 0x30,
    0x32, 0xf4, 0x5d, 0x5b, 0x37, 0x19]

  codeAddress = hexToByteArray[20]("000000000000000000000000636f6e7472616374")
  coinbase = hexToByteArray[20]("4444588443C3a91288c5002483449Aba1054192b")

proc runTestOverflow() =
  test "GasCall unhandled overflow":
    let header = BlockHeader(
      stateRoot: EMPTY_ROOT_HASH,
      number: 1150000'u64,
      coinBase: coinbase,
      gasLimit: 30000000,
      timeStamp: EthTime(123456),
    )

    let com = CommonRef.new(
      newCoreDbRef(DefaultDbMemory),
      config = chainConfigForNetwork(MainNet)
    )

    let s = BaseVMState.new(
      header,
      header,
      com,
    )

    s.stateDB.setCode(codeAddress, @data)
    let unsignedTx = Transaction(
      txType: TxLegacy,
      nonce: 0,
      chainId: MainNet.ChainId,
      gasPrice: 0.GasInt,
      gasLimit: 30000000,
      to: Opt.some codeAddress,
      value: 0.u256,
      payload: @data
    )

    let privateKey = PrivateKey.fromHex("0000000000000000000000000000000000000000000000000000001000000000")[]
    let tx = signTransaction(unsignedTx, privateKey, ChainId(1), false)
    let res = testCallEvm(tx, tx.getSender, s)

    when defined(evmc_enabled):
      check res.error == "EVMC_FAILURE"
    else:
      # After gasCall values always on positive, this test become OOG
      check res.error == "Opcode Dispatch Error: OutOfGas, depth=1"

proc evmSupportMain*() =
  runStackTests()
  runMemoryTests()
  runCodeStreamTests()
  runGasMeterTests()
  runMiscTests()
  runTestOverflow()

when isMainModule:
  evmSupportMain()