150 lines
4.1 KiB
Nim
150 lines
4.1 KiB
Nim
import std/unittest
|
|
import pkg/questionable/results
|
|
import contractabi
|
|
import ./examples
|
|
|
|
type SomeDistinctType = distinct uint16
|
|
func `==`*(a, b: SomeDistinctType): bool =
|
|
uint16(a) == uint16(b)
|
|
|
|
suite "ABI decoding":
|
|
|
|
proc checkDecode[T](value: T) =
|
|
let encoded = AbiEncoder.encode(value)
|
|
check !AbiDecoder.decode(encoded, T) == value
|
|
|
|
proc checkDecode(T: type) =
|
|
checkDecode(T.example)
|
|
checkDecode(T.low)
|
|
checkDecode(T.high)
|
|
|
|
test "decodes uint8, uint16, 32, 64":
|
|
checkDecode(uint8)
|
|
checkDecode(uint16)
|
|
checkDecode(uint32)
|
|
checkDecode(uint64)
|
|
|
|
test "decodes int8, int16, int32, int64":
|
|
checkDecode(int8)
|
|
checkDecode(int16)
|
|
checkDecode(int32)
|
|
checkDecode(int64)
|
|
|
|
test "fails to decode when reading past end":
|
|
var encoded = AbiEncoder.encode(uint8.example)
|
|
encoded.delete(encoded.len-1)
|
|
let decoded = AbiDecoder.decode(encoded, uint8)
|
|
check decoded.error.msg == "reading past end"
|
|
|
|
test "fails to decode when trailing bytes remain":
|
|
var encoded = AbiEncoder.encode(uint8.example)
|
|
encoded.add(byte.example)
|
|
let decoded = AbiDecoder.decode(encoded, uint8)
|
|
check decoded.error.msg == "unread trailing bytes found"
|
|
|
|
test "fails to decode when padding does not consist of zeroes":
|
|
var encoded = AbiEncoder.encode(uint8.example)
|
|
encoded[3] = 42'u8
|
|
let decoded = AbiDecoder.decode(encoded, uint8)
|
|
check decoded.error.msg == "invalid padding found"
|
|
|
|
test "decodes booleans":
|
|
checkDecode(false)
|
|
checkDecode(true)
|
|
|
|
test "fails to decode boolean when value is not 0 or 1":
|
|
let encoded = AbiEncoder.encode(2'u8)
|
|
check AbiDecoder.decode(encoded, bool).error.msg == "invalid boolean value"
|
|
|
|
test "decodes ranges":
|
|
type SomeRange = range[0x0000'u16..0xAAAA'u16]
|
|
checkDecode(SomeRange(42))
|
|
checkDecode(SomeRange.low)
|
|
checkDecode(SomeRange.high)
|
|
|
|
test "fails to decode when value not in range":
|
|
type SomeRange = range[0x0000'u16..0xAAAA'u16]
|
|
let encoded = AbiEncoder.encode(0xFFFF'u16)
|
|
let decoded = AbiDecoder.decode(encoded, SomeRange)
|
|
check decoded.error.msg == "value not in range"
|
|
|
|
test "decodes enums":
|
|
type SomeEnum = enum
|
|
one = 1
|
|
two = 2
|
|
checkDecode(one)
|
|
checkDecode(two)
|
|
|
|
test "fails to decode enum when encountering invalid value":
|
|
type SomeEnum = enum
|
|
one = 1
|
|
two = 2
|
|
let encoded = AbiEncoder.encode(3'u8)
|
|
check AbiDecoder.decode(encoded, SomeEnum).error.msg == "invalid enum value"
|
|
|
|
test "decodes stints":
|
|
checkDecode(UInt128)
|
|
checkDecode(UInt256)
|
|
checkDecode(Int128)
|
|
checkDecode(Int256)
|
|
|
|
test "decodes addresses":
|
|
checkDecode(Address.example)
|
|
|
|
test "decodes byte arrays":
|
|
checkDecode([1'u8, 2'u8, 3'u8])
|
|
checkDecode(array[32, byte].example)
|
|
checkDecode(array[33, byte].example)
|
|
|
|
test "decodes byte sequences":
|
|
checkDecode(@[1'u8, 2'u8, 3'u8])
|
|
checkDecode(@(array[32, byte].example))
|
|
checkDecode(@(array[33, byte].example))
|
|
|
|
test "decodes tuples":
|
|
let a = true
|
|
let b = @[1'u8, 2'u8, 3'u8]
|
|
let c = 0xAABBCCDD'u32
|
|
let d = @[4'u8, 5'u8, 6'u8]
|
|
checkDecode( (a, b, c, d) )
|
|
|
|
test "decodes nested tuples":
|
|
let a = true
|
|
let b = @[1'u8, 2'u8, 3'u8]
|
|
let c = 0xAABBCCDD'u32
|
|
let d = @[4'u8, 5'u8, 6'u8]
|
|
checkDecode( (a, b, (c, d)) )
|
|
|
|
test "reads elements after dynamic tuple":
|
|
let a = @[1'u8, 2'u8, 3'u8]
|
|
let b = 0xAABBCCDD'u32
|
|
checkDecode( ((a,), b) )
|
|
|
|
test "reads elements after static tuple":
|
|
let a = 0x123'u16
|
|
let b = 0xAABBCCDD'u32
|
|
checkDecode( ((a,), b) )
|
|
|
|
test "reads static tuple inside dynamic tuple":
|
|
let a = @[1'u8, 2'u8, 3'u8]
|
|
let b = 0xAABBCCDD'u32
|
|
checkDecode( (a, (b,)) )
|
|
|
|
test "reads empty tuples":
|
|
checkDecode( ((),) )
|
|
|
|
test "decodes sequences":
|
|
checkDecode(@[seq[byte].example, seq[byte].example])
|
|
|
|
test "decodes arrays with static elements":
|
|
checkDecode([array[32, byte].example, array[32, byte].example])
|
|
|
|
test "decodes arrays with dynamic elements":
|
|
checkDecode([seq[byte].example, seq[byte].example])
|
|
|
|
test "decodes strings":
|
|
checkDecode("hello!☺")
|
|
|
|
test "decodes distinct types as their base type":
|
|
checkDecode(SomeDistinctType(0xAABB'u16))
|