# nim-eth - Limited SSZ implementation # Copyright (c) 2018-2021 Status Research & Development GmbH # Licensed and distributed under either of # * MIT license (license terms in the root directory or at https://opensource.org/licenses/MIT). # * Apache v2 license (license terms in the root directory or at https://www.apache.org/licenses/LICENSE-2.0). # at your option. This file may not be copied, modified, or distributed except according to those terms. {.push raises: [Defect].} import std/[tables, options, typetraits, strformat], stew/shims/macros, stew/[byteutils, bitops2, objects], serialization/[object_serialization, errors], ./bitseqs export bitseqs const offsetSize* = 4 bytesPerChunk* = 32 type UintN* = SomeUnsignedInt BasicType* = bool|UintN Limit* = int64 List*[T; maxLen: static Limit] = distinct seq[T] BitList*[maxLen: static Limit] = distinct BitSeq # Note for readers: # We use `array` for `Vector` and # `BitArray` for `BitVector` SszError* = object of SerializationError MalformedSszError* = object of SszError SszSizeMismatchError* = object of SszError deserializedType*: cstring actualSszSize*: int elementSize*: int template asSeq*(x: List): auto = distinctBase(x) template init*[T](L: type List, x: seq[T], N: static Limit): auto = List[T, N](x) template init*[T, N](L: type List[T, N], x: seq[T]): auto = List[T, N](x) template `$`*(x: List): auto = $(distinctBase x) template len*(x: List): auto = len(distinctBase x) template low*(x: List): auto = low(distinctBase x) template high*(x: List): auto = high(distinctBase x) template `[]`*(x: List, idx: auto): untyped = distinctBase(x)[idx] template `[]=`*(x: var List, idx: auto, val: auto) = distinctBase(x)[idx] = val template `==`*(a, b: List): bool = distinctBase(a) == distinctBase(b) template `&`*(a, b: List): auto = (type(a)(distinctBase(a) & distinctBase(b))) template items* (x: List): untyped = items(distinctBase x) template pairs* (x: List): untyped = pairs(distinctBase x) template mitems*(x: var List): untyped = mitems(distinctBase x) template mpairs*(x: var List): untyped = mpairs(distinctBase x) template contains* (x: List, val: auto): untyped = contains(distinctBase x, val) proc add*(x: var List, val: auto): bool = if x.len < x.maxLen: add(distinctBase x, val) true else: false proc setLen*(x: var List, newLen: int): bool = if newLen <= x.maxLen: setLen(distinctBase x, newLen) true else: false template init*(L: type BitList, x: seq[byte], N: static Limit): auto = BitList[N](data: x) template init*[N](L: type BitList[N], x: seq[byte]): auto = L(data: x) template init*(T: type BitList, len: int): auto = T init(BitSeq, len) template len*(x: BitList): auto = len(BitSeq(x)) template bytes*(x: BitList): auto = seq[byte](x) template `[]`*(x: BitList, idx: auto): auto = BitSeq(x)[idx] template `[]=`*(x: var BitList, idx: auto, val: bool) = BitSeq(x)[idx] = val template `==`*(a, b: BitList): bool = BitSeq(a) == BitSeq(b) template setBit*(x: var BitList, idx: Natural) = setBit(BitSeq(x), idx) template clearBit*(x: var BitList, idx: Natural) = clearBit(BitSeq(x), idx) template overlaps*(a, b: BitList): bool = overlaps(BitSeq(a), BitSeq(b)) template incl*(a: var BitList, b: BitList) = incl(BitSeq(a), BitSeq(b)) template isSubsetOf*(a, b: BitList): bool = isSubsetOf(BitSeq(a), BitSeq(b)) template isZeros*(x: BitList): bool = isZeros(BitSeq(x)) template countOnes*(x: BitList): int = countOnes(BitSeq(x)) template countZeros*(x: BitList): int = countZeros(BitSeq(x)) template countOverlap*(x, y: BitList): int = countOverlap(BitSeq(x), BitSeq(y)) template `$`*(a: BitList): string = $(BitSeq(a)) iterator items*(x: BitList): bool = for i in 0 ..< x.len: yield x[i] macro unsupported*(T: typed): untyped = # TODO: {.fatal.} breaks compilation even in `compiles()` context, # so we use this macro instead. It's also much better at figuring # out the actual type that was used in the instantiation. # File both problems as issues. error "SSZ serialization of the type " & humaneTypeName(T) & " is not supported" template ElemType*(T: type array): untyped = type(default(T)[low(T)]) template ElemType*(T: type seq): untyped = type(default(T)[0]) template ElemType*(T: type List): untyped = T.T func isFixedSize*(T0: type): bool {.compileTime.} = mixin toSszType, enumAllSerializedFields type T = type toSszType(declval T0) when T is BasicType: return true elif T is array: return isFixedSize(ElemType(T)) elif T is object|tuple: enumAllSerializedFields(T): when not isFixedSize(FieldType): return false return true func fixedPortionSize*(T0: type): int {.compileTime.} = mixin enumAllSerializedFields, toSszType type T = type toSszType(declval T0) when T is BasicType: sizeof(T) elif T is array: type E = ElemType(T) when isFixedSize(E): int(len(T)) * fixedPortionSize(E) else: int(len(T)) * offsetSize elif T is object|tuple: enumAllSerializedFields(T): when isFixedSize(FieldType): result += fixedPortionSize(FieldType) else: result += offsetSize else: unsupported T0 # TODO This should have been an iterator, but the VM can't compile the # code due to "too many registers required". proc fieldInfos*(RecordType: type): seq[tuple[name: string, offset: int, fixedSize: int, branchKey: string]] = mixin enumAllSerializedFields var offsetInBranch = {"": 0}.toTable nestedUnder = initTable[string, string]() enumAllSerializedFields(RecordType): const isFixed = isFixedSize(FieldType) fixedSize = when isFixed: fixedPortionSize(FieldType) else: 0 branchKey = when fieldCaseDiscriminator.len == 0: "" else: fieldCaseDiscriminator & ":" & $fieldCaseBranches fieldSize = when isFixed: fixedSize else: offsetSize nestedUnder[fieldName] = branchKey var fieldOffset: int offsetInBranch.withValue(branchKey, val): fieldOffset = val[] val[] += fieldSize do: try: let parentBranch = nestedUnder.getOrDefault(fieldCaseDiscriminator, "") fieldOffset = offsetInBranch[parentBranch] offsetInBranch[branchKey] = fieldOffset + fieldSize except KeyError as e: raiseAssert e.msg result.add((fieldName, fieldOffset, fixedSize, branchKey)) func getFieldBoundingOffsetsImpl(RecordType: type, fieldName: static string): tuple[fieldOffset, nextFieldOffset: int, isFirstOffset: bool] {.compileTime.} = result = (-1, -1, false) var fieldBranchKey: string var isFirstOffset = true for f in fieldInfos(RecordType): if fieldName == f.name: result[0] = f.offset if f.fixedSize > 0: result[1] = result[0] + f.fixedSize return else: fieldBranchKey = f.branchKey result.isFirstOffset = isFirstOffset elif result[0] != -1 and f.fixedSize == 0 and f.branchKey == fieldBranchKey: # We have found the next variable sized field result[1] = f.offset return if f.fixedSize == 0: isFirstOffset = false func getFieldBoundingOffsets*(RecordType: type, fieldName: static string): tuple[fieldOffset, nextFieldOffset: int, isFirstOffset: bool] {.compileTime.} = ## Returns the start and end offsets of a field. ## ## For fixed-size fields, the start offset points to the first ## byte of the field and the end offset points to 1 byte past the ## end of the field. ## ## For variable-size fields, the returned offsets point to the ## statically known positions of the 32-bit offset values written ## within the SSZ object. You must read the 32-bit values stored ## at the these locations in order to obtain the actual offsets. ## ## For variable-size fields, the end offset may be -1 when the ## designated field is the last variable sized field within the ## object. Then the SSZ object boundary known at run-time marks ## the end of the variable-size field. type T = RecordType anonConst getFieldBoundingOffsetsImpl(T, fieldName) template enumerateSubFields*(holder, fieldVar, body: untyped) = when holder is array: for fieldVar in holder: body else: enumInstanceSerializedFields(holder, _{.used.}, fieldVar): body method formatMsg*( err: ref SszSizeMismatchError, filename: string): string {.gcsafe, raises: [Defect].} = try: &"SSZ size mismatch, element {err.elementSize}, actual {err.actualSszSize}, type {err.deserializedType}, file {filename}" except CatchableError: "SSZ size mismatch"