import endians, typetraits, options, stew/[objects, bitseqs], serialization/testing/tracing, ../spec/[digest, datatypes], ./types template setLen[R, T](a: var array[R, T], length: int) = if length != a.len: raise newException(MalformedSszError, "SSZ input of insufficient size") template assignNullValue(loc: untyped, T: type): auto = when T is ref|ptr: loc = nil elif T is Option: loc = T() else: raise newException(MalformedSszError, "SSZ list element of zero size") # fromSszBytes copies the wire representation to a Nim variable, # assuming there's enough data in the buffer func fromSszBytes*(T: type SomeInteger, data: openarray[byte]): T = ## Convert directly to bytes the size of the int. (e.g. ``uint16 = 2 bytes``) ## All integers are serialized as **little endian**. ## TODO: Assumes data points to a sufficiently large buffer doAssert data.len == sizeof(result) # TODO: any better way to get a suitably aligned buffer in nim??? # see also: https://github.com/nim-lang/Nim/issues/9206 var tmp: uint64 var alignedBuf = cast[ptr byte](tmp.addr) copyMem(alignedBuf, unsafeAddr data[0], result.sizeof) when result.sizeof == 8: littleEndian64(result.addr, alignedBuf) elif result.sizeof == 4: littleEndian32(result.addr, alignedBuf) elif result.sizeof == 2: littleEndian16(result.addr, alignedBuf) elif result.sizeof == 1: copyMem(result.addr, alignedBuf, sizeof(result)) else: {.fatal: "Unsupported type deserialization: " & $(type(result)).name.} func fromSszBytes*(T: type bool, data: openarray[byte]): T = # TODO: spec doesn't say what to do if the value is >1 - we'll use the C # definition for now, but maybe this should be a parse error instead? fromSszBytes(uint8, data) != 0 func fromSszBytes*(T: type Eth2Digest, data: openarray[byte]): T = doAssert data.len == sizeof(result.data) copyMem(result.data.addr, unsafeAddr data[0], sizeof(result.data)) template fromSszBytes*(T: type Slot, bytes: openarray[byte]): Slot = Slot fromSszBytes(uint64, bytes) template fromSszBytes*(T: type Epoch, bytes: openarray[byte]): Epoch = Epoch fromSszBytes(uint64, bytes) template fromSszBytes*(T: type enum, bytes: openarray[byte]): auto = T fromSszBytes(uint64, bytes) template fromSszBytes*(T: type BitSeq, bytes: openarray[byte]): auto = BitSeq @bytes proc fromSszBytes*[N](T: type BitList[N], bytes: openarray[byte]): auto = BitList[N] @bytes proc readSszValue*(input: openarray[byte], T: type): T = mixin fromSszBytes, toSszType type T {.used.}= type(result) template readOffset(n: int): int {.used.}= int fromSszBytes(uint32, input[n ..< n + offsetSize]) when useListType and result is List: type ElemType = type result[0] result = T readSszValue(input, seq[ElemType]) elif result is ptr|ref: if input.len > 0: new result result[] = readSszValue(input, type(result[])) elif result is Option: if input.len > 0: result = some readSszValue(input, result.T) elif result is string|seq|openarray|array: type ElemType = type result[0] when ElemType is byte|char: result.setLen input.len if input.len > 0: copyMem(addr result[0], unsafeAddr input[0], input.len) elif isFixedSize(ElemType): const elemSize = fixedPortionSize(ElemType) if input.len mod elemSize != 0: var ex = new SszSizeMismatchError ex.deserializedType = cstring typetraits.name(T) ex.actualSszSize = input.len ex.elementSize = elemSize raise ex result.setLen input.len div elemSize trs "READING LIST WITH LEN ", result.len for i in 0 ..< result.len: trs "TRYING TO READ LIST ELEM ", i let offset = i * elemSize result[i] = readSszValue(input[offset ..< offset+elemSize], ElemType) trs "LIST READING COMPLETE" else: if input.len == 0: # This is an empty list. # The default initialization of the return value is fine. return var offset = readOffset 0 trs "GOT OFFSET ", offset let resultLen = offset div offsetSize trs "LEN ", resultLen result.setLen resultLen for i in 1 ..< resultLen: let nextOffset = readOffset(i * offsetSize) if nextOffset == offset: assignNullValue result[i - 1], ElemType else: result[i - 1] = readSszValue(input[offset ..< nextOffset], ElemType) offset = nextOffset result[resultLen - 1] = readSszValue(input[offset ..< input.len], ElemType) elif result is object|tuple: enumInstanceSerializedFields(result, fieldName, field): const boundingOffsets = T.getFieldBoundingOffsets(fieldName) trs "BOUNDING OFFSET FOR FIELD ", fieldName, " = ", boundingOffsets type FieldType = type field type SszType = type toSszType(default(FieldType)) when isFixedSize(SszType): const startOffset = boundingOffsets[0] endOffset = boundingOffsets[1] trs "FIXED FIELD ", startOffset, "-", endOffset else: let startOffset = readOffset(boundingOffsets[0]) endOffset = if boundingOffsets[1] == -1: input.len else: readOffset(boundingOffsets[1]) trs "VAR FIELD ", startOffset, "-", endOffset # TODO The extra type escaping here is a work-around for a Nim issue: when type(FieldType) is type(SszType): trs "READING NATIVE ", fieldName, ": ", name(SszType) field = readSszValue(input[startOffset ..< endOffset], SszType) trs "READING COMPLETE ", fieldName elif useListType and FieldType is List: field = readSszValue(input[startOffset ..< endOffset], FieldType) else: trs "READING FOREIGN ", fieldName, ": ", name(SszType) field = fromSszBytes(FieldType, input[startOffset ..< endOffset]) elif result is SomeInteger|bool|enum: trs "READING BASIC TYPE ", type(result).name, " input=", input.len result = fromSszBytes(type(result), input) trs "RESULT WAS ", repr(result) else: unsupported T