110 lines
3.5 KiB
Nim
110 lines
3.5 KiB
Nim
# Nimbus
|
|
# Copyright (c) 2018 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
|
|
strformat, strutils, sequtils, endians, macros,
|
|
eth/common/eth_types, eth/rlp,
|
|
../../../constants
|
|
|
|
# some methods based on py-evm utils/numeric
|
|
|
|
func log2*[bits: static int](value: StUint[bits]): Natural {.inline.}=
|
|
(bits - 1) - value.leadingZeros
|
|
|
|
func log256*(value: UInt256): Natural {.inline.}=
|
|
value.log2 shr 3 # div 8 (= log2(256), Logb x = Loga x/Loga b)
|
|
|
|
func ceil32*(value: Natural): Natural {.inline.}=
|
|
# Round input to the nearest bigger multiple of 32
|
|
|
|
result = value
|
|
|
|
let remainder = result and 31 # equivalent to modulo 32
|
|
if remainder != 0:
|
|
return value + 32 - remainder
|
|
|
|
func wordCount*(length: Natural): Natural {.inline.}=
|
|
# Returns the number of EVM words corresponding to a specific size.
|
|
# EVM words is rounded up
|
|
length.ceil32 shr 5 # equivalent to `div 32` (32 = 2^5)
|
|
|
|
proc flipSign(value: var UInt256) =
|
|
# ⚠ Warning: low(Int256) (binary repr 0b1000...0000) cannot be negated, please handle this special case
|
|
value = not value
|
|
value += 1.u256
|
|
|
|
proc extractSign*(v: var UInt256, sign: var bool) =
|
|
sign = v > INT_256_MAX_AS_UINT256
|
|
if sign:
|
|
flipSign(v)
|
|
|
|
proc setSign*(v: var UInt256, sign: bool) {.inline.} =
|
|
if sign: flipSign(v)
|
|
|
|
func cleanMemRef*(x: UInt256): int {.inline.} =
|
|
## Sanitize memory addresses, catch negative or impossibly big offsets
|
|
# See https://github.com/status-im/nimbus/pull/97 for more info
|
|
# For rationale on shr, see https://github.com/status-im/nimbus/pull/101
|
|
const upperBound = (high(int32) shr 2).u256
|
|
if x > upperBound:
|
|
return high(int32) shr 2
|
|
return x.toInt
|
|
|
|
proc rangeToPadded*[T: StUint](x: openarray[byte], first, last: int, toLen = 0): T =
|
|
## Convert take a slice of a sequence of bytes interpret it as the big endian
|
|
## representation of an Uint256. Use padding for sequence shorter than 32 bytes
|
|
## including 0-length sequences.
|
|
const N = T.bits div 8
|
|
|
|
let lo = max(0, first)
|
|
let hi = min(min(x.high, last), (lo+N)-1)
|
|
|
|
if not(lo <= hi):
|
|
return # 0
|
|
|
|
if toLen > hi-lo+1:
|
|
var temp: array[N, byte]
|
|
temp[0..hi-lo] = x.toOpenArray(lo, hi)
|
|
result = T.fromBytesBE(
|
|
temp,
|
|
allowPadding = false
|
|
)
|
|
else:
|
|
result = T.fromBytesBE(
|
|
x.toOpenArray(lo, hi),
|
|
allowPadding = true
|
|
)
|
|
|
|
proc rangeToPadded2*[T: StUint](x: openarray[byte], first, last: int, toLen = 0): T =
|
|
## Convert take a slice of a sequence of bytes interpret it as the big endian
|
|
## representation of an Uint256. Use padding for sequence shorter than 32 bytes
|
|
## including 0-length sequences.
|
|
const N = T.bits div 8
|
|
|
|
let lo = max(0, first)
|
|
let hi = min(min(x.high, last), (lo+N)-1)
|
|
|
|
if not(lo <= hi):
|
|
return # 0
|
|
|
|
var temp: array[N, byte]
|
|
temp[0..hi-lo] = x.toOpenArray(lo, hi)
|
|
result = T.fromBytesBE(
|
|
temp.toOpenArray(0, toLen-1),
|
|
allowPadding = true
|
|
)
|
|
|
|
# calculates the memory size required for a step
|
|
func calcMemSize*(offset, length: int): int {.inline.} =
|
|
if length.isZero: return 0
|
|
result = offset + length
|
|
|
|
func safeInt*(x: Uint256): int {.inline.} =
|
|
result = x.truncate(int)
|
|
if x > high(int32).u256 or result < 0:
|
|
result = high(int32)
|