mirror of https://github.com/status-im/nim-eth.git
76 lines
2.1 KiB
Nim
76 lines
2.1 KiB
Nim
import
|
|
strutils, parseutils,
|
|
stew/ranges/[typedranges, ptr_arith], nimcrypto/[hash, keccak],
|
|
trie_defs, binaries
|
|
|
|
#proc baseAddr*(x: Bytes): ptr byte = x[0].unsafeAddr
|
|
|
|
proc toTrieNodeKey*(hash: KeccakHash): TrieNodeKey =
|
|
result = newRange[byte](32)
|
|
copyMem(result.baseAddr, hash.data.baseAddr, 32)
|
|
|
|
template checkValidHashZ*(x: untyped) =
|
|
when x.type isnot KeccakHash:
|
|
doAssert(x.len == 32 or x.len == 0)
|
|
|
|
template isZeroHash*(x: ByteRange): bool =
|
|
x.len == 0
|
|
|
|
template toRange*(hash: KeccakHash): ByteRange =
|
|
toTrieNodeKey(hash)
|
|
|
|
proc toRange*(str: string): ByteRange =
|
|
var s = newSeq[byte](str.len)
|
|
if str.len > 0:
|
|
copyMem(s[0].addr, str[0].unsafeAddr, str.len)
|
|
result = toRange(s)
|
|
|
|
proc hashFromHex*(bits: static[int], input: string): MDigest[bits] =
|
|
if input.len != bits div 4:
|
|
raise newException(ValueError,
|
|
"The input string has incorrect size")
|
|
|
|
for i in 0 ..< bits div 8:
|
|
var nextByte: int
|
|
if parseHex(input, nextByte, i*2, 2) == 2:
|
|
result.data[i] = uint8(nextByte)
|
|
else:
|
|
raise newException(ValueError,
|
|
"The input string contains invalid characters")
|
|
|
|
template hashFromHex*(s: static[string]): untyped = hashFromHex(s.len * 4, s)
|
|
|
|
proc keccakHash*(input: openArray[byte]): ByteRange =
|
|
var s = newSeq[byte](32)
|
|
var ctx: keccak256
|
|
ctx.init()
|
|
if input.len > 0:
|
|
ctx.update(input[0].unsafeAddr, uint(input.len))
|
|
ctx.finish s
|
|
ctx.clear()
|
|
result = toRange(s)
|
|
|
|
proc keccakHash*(dest: var openArray[byte], a, b: openArray[byte]) =
|
|
var ctx: keccak256
|
|
ctx.init()
|
|
if a.len != 0:
|
|
ctx.update(a[0].unsafeAddr, uint(a.len))
|
|
if b.len != 0:
|
|
ctx.update(b[0].unsafeAddr, uint(b.len))
|
|
ctx.finish dest
|
|
ctx.clear()
|
|
|
|
proc keccakHash*(a, b: openArray[byte]): ByteRange =
|
|
var s = newSeq[byte](32)
|
|
keccakHash(s, a, b)
|
|
result = toRange(s)
|
|
|
|
template keccakHash*(input: ByteRange): ByteRange =
|
|
keccakHash(input.toOpenArray)
|
|
|
|
template keccakHash*(a, b: ByteRange): ByteRange =
|
|
keccakHash(a.toOpenArray, b.toOpenArray)
|
|
|
|
template keccakHash*(dest: var ByteRange, a, b: ByteRange) =
|
|
keccakHash(dest.toOpenArray, a.toOpenArray, b.toOpenArray)
|