diff --git a/core/services/relay/evm/types/abi_types.go b/core/services/relay/evm/types/abi_types.go
new file mode 100644
index 00000000000..001810a2b33
--- /dev/null
+++ b/core/services/relay/evm/types/abi_types.go
@@ -0,0 +1,60 @@
+package types
+
+import (
+	"reflect"
+)
+
+//go:generate go run ./gen/main.go
+
+var typeMap = map[string]*AbiEncodingType{
+	"bool": {
+		Native:  reflect.TypeOf(true),
+		Checked: reflect.TypeOf(true),
+	},
+	"int8": {
+		Native:  reflect.TypeOf(int8(0)),
+		Checked: reflect.TypeOf(int8(0)),
+	},
+	"int16": {
+		Native:  reflect.TypeOf(int16(0)),
+		Checked: reflect.TypeOf(int16(0)),
+	},
+	"int32": {
+		Native:  reflect.TypeOf(int32(0)),
+		Checked: reflect.TypeOf(int32(0)),
+	},
+	"int64": {
+		Native:  reflect.TypeOf(int64(0)),
+		Checked: reflect.TypeOf(int64(0)),
+	},
+	"uint8": {
+		Native:  reflect.TypeOf(uint8(0)),
+		Checked: reflect.TypeOf(uint8(0)),
+	},
+	"uint16": {
+		Native:  reflect.TypeOf(uint16(0)),
+		Checked: reflect.TypeOf(uint16(0)),
+	},
+	"uint32": {
+		Native:  reflect.TypeOf(uint32(0)),
+		Checked: reflect.TypeOf(uint32(0)),
+	},
+	"uint64": {
+		Native:  reflect.TypeOf(uint64(0)),
+		Checked: reflect.TypeOf(uint64(0)),
+	},
+	"string": {
+		Native:  reflect.TypeOf(""),
+		Checked: reflect.TypeOf(""),
+	},
+}
+
+type AbiEncodingType struct {
+	Native  reflect.Type
+	Checked reflect.Type
+}
+
+func GetType(name string) (*AbiEncodingType, bool) {
+	abiType, ok := typeMap[name]
+	return abiType, ok
+}
diff --git a/core/services/relay/evm/types/byte_types_gen.go b/core/services/relay/evm/types/byte_types_gen.go
new file mode 100644
index 00000000000..e87b11c2336
--- /dev/null
+++ b/core/services/relay/evm/types/byte_types_gen.go
@@ -0,0 +1,300 @@
+package types
+
+import "reflect"
+
+type bytes1 [1]byte
+
+func init() {
+	typeMap["bytes1"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([1]byte{}),
+		Checked: reflect.TypeOf(bytes1{}),
+	}
+}
+
+type bytes2 [2]byte
+
+func init() {
+	typeMap["bytes2"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([2]byte{}),
+		Checked: reflect.TypeOf(bytes2{}),
+	}
+}
+
+type bytes3 [3]byte
+
+func init() {
+	typeMap["bytes3"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([3]byte{}),
+		Checked: reflect.TypeOf(bytes3{}),
+	}
+}
+
+type bytes4 [4]byte
+
+func init() {
+	typeMap["bytes4"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([4]byte{}),
+		Checked: reflect.TypeOf(bytes4{}),
+	}
+}
+
+type bytes5 [5]byte
+
+func init() {
+	typeMap["bytes5"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([5]byte{}),
+		Checked: reflect.TypeOf(bytes5{}),
+	}
+}
+
+type bytes6 [6]byte
+
+func init() {
+	typeMap["bytes6"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([6]byte{}),
+		Checked: reflect.TypeOf(bytes6{}),
+	}
+}
+
+type bytes7 [7]byte
+
+func init() {
+	typeMap["bytes7"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([7]byte{}),
+		Checked: reflect.TypeOf(bytes7{}),
+	}
+}
+
+type bytes8 [8]byte
+
+func init() {
+	typeMap["bytes8"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([8]byte{}),
+		Checked: reflect.TypeOf(bytes8{}),
+	}
+}
+
+type bytes9 [9]byte
+
+func init() {
+	typeMap["bytes9"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([9]byte{}),
+		Checked: reflect.TypeOf(bytes9{}),
+	}
+}
+
+type bytes10 [10]byte
+
+func init() {
+	typeMap["bytes10"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([10]byte{}),
+		Checked: reflect.TypeOf(bytes10{}),
+	}
+}
+
+type bytes11 [11]byte
+
+func init() {
+	typeMap["bytes11"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([11]byte{}),
+		Checked: reflect.TypeOf(bytes11{}),
+	}
+}
+
+type bytes12 [12]byte
+
+func init() {
+	typeMap["bytes12"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([12]byte{}),
+		Checked: reflect.TypeOf(bytes12{}),
+	}
+}
+
+type bytes13 [13]byte
+
+func init() {
+	typeMap["bytes13"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([13]byte{}),
+		Checked: reflect.TypeOf(bytes13{}),
+	}
+}
+
+type bytes14 [14]byte
+
+func init() {
+	typeMap["bytes14"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([14]byte{}),
+		Checked: reflect.TypeOf(bytes14{}),
+	}
+}
+
+type bytes15 [15]byte
+
+func init() {
+	typeMap["bytes15"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([15]byte{}),
+		Checked: reflect.TypeOf(bytes15{}),
+	}
+}
+
+type bytes16 [16]byte
+
+func init() {
+	typeMap["bytes16"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([16]byte{}),
+		Checked: reflect.TypeOf(bytes16{}),
+	}
+}
+
+type bytes17 [17]byte
+
+func init() {
+	typeMap["bytes17"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([17]byte{}),
+		Checked: reflect.TypeOf(bytes17{}),
+	}
+}
+
+type bytes18 [18]byte
+
+func init() {
+	typeMap["bytes18"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([18]byte{}),
+		Checked: reflect.TypeOf(bytes18{}),
+	}
+}
+
+type bytes19 [19]byte
+
+func init() {
+	typeMap["bytes19"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([19]byte{}),
+		Checked: reflect.TypeOf(bytes19{}),
+	}
+}
+
+type bytes20 [20]byte
+
+func init() {
+	typeMap["bytes20"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([20]byte{}),
+		Checked: reflect.TypeOf(bytes20{}),
+	}
+}
+
+type bytes21 [21]byte
+
+func init() {
+	typeMap["bytes21"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([21]byte{}),
+		Checked: reflect.TypeOf(bytes21{}),
+	}
+}
+
+type bytes22 [22]byte
+
+func init() {
+	typeMap["bytes22"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([22]byte{}),
+		Checked: reflect.TypeOf(bytes22{}),
+	}
+}
+
+type bytes23 [23]byte
+
+func init() {
+	typeMap["bytes23"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([23]byte{}),
+		Checked: reflect.TypeOf(bytes23{}),
+	}
+}
+
+type bytes24 [24]byte
+
+func init() {
+	typeMap["bytes24"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([24]byte{}),
+		Checked: reflect.TypeOf(bytes24{}),
+	}
+}
+
+type bytes25 [25]byte
+
+func init() {
+	typeMap["bytes25"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([25]byte{}),
+		Checked: reflect.TypeOf(bytes25{}),
+	}
+}
+
+type bytes26 [26]byte
+
+func init() {
+	typeMap["bytes26"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([26]byte{}),
+		Checked: reflect.TypeOf(bytes26{}),
+	}
+}
+
+type bytes27 [27]byte
+
+func init() {
+	typeMap["bytes27"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([27]byte{}),
+		Checked: reflect.TypeOf(bytes27{}),
+	}
+}
+
+type bytes28 [28]byte
+
+func init() {
+	typeMap["bytes28"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([28]byte{}),
+		Checked: reflect.TypeOf(bytes28{}),
+	}
+}
+
+type bytes29 [29]byte
+
+func init() {
+	typeMap["bytes29"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([29]byte{}),
+		Checked: reflect.TypeOf(bytes29{}),
+	}
+}
+
+type bytes30 [30]byte
+
+func init() {
+	typeMap["bytes30"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([30]byte{}),
+		Checked: reflect.TypeOf(bytes30{}),
+	}
+}
+
+type bytes31 [31]byte
+
+func init() {
+	typeMap["bytes31"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([31]byte{}),
+		Checked: reflect.TypeOf(bytes31{}),
+	}
+}
+
+type bytes32 [32]byte
+
+func init() {
+	typeMap["bytes32"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([32]byte{}),
+		Checked: reflect.TypeOf(bytes32{}),
+	}
+}
+
+type bytes0 [0]byte
+
+func init() {
+	typeMap["bytes0"] = &AbiEncodingType{
+		Native:  reflect.TypeOf([0]byte{}),
+		Checked: reflect.TypeOf(bytes0{}),
+	}
+}
diff --git a/core/services/relay/evm/types/gen/bytes.tmpl b/core/services/relay/evm/types/gen/bytes.tmpl
new file mode 100644
index 00000000000..cecf1868691
--- /dev/null
+++ b/core/services/relay/evm/types/gen/bytes.tmpl
@@ -0,0 +1,14 @@
+package types
+
+import "reflect"
+
+{{ range . }}
+type bytes{{.Size}} [{{.Size}}]byte
+func init() {
+	typeMap["bytes{{.Size}}"] = &AbiEncodingType {
+		Native: reflect.TypeOf([{{.Size}}]byte{}),
+		Checked: reflect.TypeOf(bytes{{.Size}}{}),
+	}
+}
+
+{{ end }}
\ No newline at end of file
diff --git a/core/services/relay/evm/types/gen/ints.tmpl b/core/services/relay/evm/types/gen/ints.tmpl
new file mode 100644
index 00000000000..2b5a727ce63
--- /dev/null
+++ b/core/services/relay/evm/types/gen/ints.tmpl
@@ -0,0 +1,64 @@
+package types
+
+import (
+	"math/big"
+	"reflect"
+
+	"github.com/fxamacker/cbor/v2"
+
+	"github.com/smartcontractkit/chainlink-relay/pkg/types"
+)
+
+type SizedBigInt interface {
+	Verify() error
+	private()
+}
+
+var sizedBigIntType = reflect.TypeOf((*SizedBigInt)(nil)).Elem()
+func SizedBigIntType() reflect.Type {
+	return sizedBigIntType
+}
+
+{{ range . }}
+type {{.Prefix}}int{{.Size}} big.Int
+func (i *{{.Prefix}}int{{.Size}}) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *{{.Prefix}}int{{.Size}}) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *{{.Prefix}}int{{.Size}}) Verify() error {
+	bi := (*big.Int)(i)
+	{{ if .Signed }}
+	if !codec.FitsInNBitsSigned({{.Size}}, bi) {
+		return types.InvalidTypeError{}
+	}
+	{{ else }}
+	if bi.BitLen() > {{.Size}} {
+		return types.InvalidTypeError{}
+	}
+	{{ end }}
+	return nil
+}
+
+func (i *{{.Prefix}}int{{.Size}}) private() {}
+
+func init() {
+	typeMap["{{.Prefix}}int{{.Size}}"] = &AbiEncodingType {
+		Native: reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*{{.Prefix}}int{{.Size}})(nil)),
+	}
+}
+{{ end }}
\ No newline at end of file
diff --git a/core/services/relay/evm/types/gen/main.go b/core/services/relay/evm/types/gen/main.go
new file mode 100644
index 00000000000..7bd35bf3d18
--- /dev/null
+++ b/core/services/relay/evm/types/gen/main.go
@@ -0,0 +1,76 @@
+package main
+
+import (
+	"bytes"
+	_ "embed"
+	"go/format"
+	"os"
+	"text/template"
+)
+
+func main() {
+	genInts()
+	genBytes()
+}
+
+func genBytes() {
+	byteTypes := [33]ByteType{}
+	for i := 1; i < 33; i++ {
+		byteTypes[i-1].Size = i
+	}
+	runTemplate("bytes", bytesTemplate, "byte_types_gen.go", byteTypes)
+}
+
+func genInts() {
+	var intTypes []*IntType
+
+	// 8, 16, 32, and 64 bits have their own type in go that is used by abi.
+	// The test use *big.Int
+	for i := 24; i <= 256; i += 8 {
+		if i == 32 || i == 64 {
+			continue
+		}
+
+		signed := &IntType{Size: i, Signed: false}
+		unsigned := &IntType{Prefix: "u", Size: i}
+		intTypes = append(intTypes, signed, unsigned)
+	}
+	runTemplate("ints", intsTemplate, "int_types_gen.go", intTypes)
+}
+
+func runTemplate(name, rawTemplate, outputFile string, input any) {
+	t, err := template.New(name).Parse(rawTemplate)
+	if err != nil {
+		panic(err)
+	}
+
+	br := bytes.Buffer{}
+	if err = t.Execute(&br, input); err != nil {
+		panic(err)
+	}
+
+	res, err := format.Source([]byte(br.Bytes()))
+	if err != nil {
+		panic(err)
+	}
+
+	if err = os.WriteFile(outputFile, res, 0600); err != nil {
+		panic(err)
+	}
+}
+
+type IntType struct {
+	Prefix string
+	Size   int
+	Signed bool
+}
+
+type ByteType struct {
+	Size int
+}
+
+//go:embed bytes.tmpl
+var bytesTemplate string
+
+//go:embed ints.tmpl
+var intsTemplate string
diff --git a/core/services/relay/evm/types/int_types_gen.go b/core/services/relay/evm/types/int_types_gen.go
new file mode 100644
index 00000000000..a3a29dfc6b9
--- /dev/null
+++ b/core/services/relay/evm/types/int_types_gen.go
@@ -0,0 +1,2205 @@
+package types
+
+import (
+	"math/big"
+	"reflect"
+
+	"github.com/fxamacker/cbor/v2"
+
+	"github.com/smartcontractkit/chainlink-relay/pkg/types"
+)
+
+type SizedBigInt interface {
+	Verify() error
+	private()
+}
+
+var sizedBigIntType = reflect.TypeOf((*SizedBigInt)(nil)).Elem()
+
+func SizedBigIntType() reflect.Type {
+	return sizedBigIntType
+}
+
+type int24 big.Int
+
+func (i *int24) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int24) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int24) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 24 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int24) private() {}
+
+func init() {
+	typeMap["int24"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int24)(nil)),
+	}
+}
+
+type uint24 big.Int
+
+func (i *uint24) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint24) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint24) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 24 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint24) private() {}
+
+func init() {
+	typeMap["uint24"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint24)(nil)),
+	}
+}
+
+type int40 big.Int
+
+func (i *int40) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int40) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int40) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 40 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int40) private() {}
+
+func init() {
+	typeMap["int40"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int40)(nil)),
+	}
+}
+
+type uint40 big.Int
+
+func (i *uint40) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint40) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint40) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 40 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint40) private() {}
+
+func init() {
+	typeMap["uint40"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint40)(nil)),
+	}
+}
+
+type int48 big.Int
+
+func (i *int48) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int48) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int48) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 48 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int48) private() {}
+
+func init() {
+	typeMap["int48"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int48)(nil)),
+	}
+}
+
+type uint48 big.Int
+
+func (i *uint48) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint48) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint48) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 48 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint48) private() {}
+
+func init() {
+	typeMap["uint48"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint48)(nil)),
+	}
+}
+
+type int56 big.Int
+
+func (i *int56) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int56) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int56) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 56 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int56) private() {}
+
+func init() {
+	typeMap["int56"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int56)(nil)),
+	}
+}
+
+type uint56 big.Int
+
+func (i *uint56) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint56) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint56) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 56 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint56) private() {}
+
+func init() {
+	typeMap["uint56"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint56)(nil)),
+	}
+}
+
+type int72 big.Int
+
+func (i *int72) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int72) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int72) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 72 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int72) private() {}
+
+func init() {
+	typeMap["int72"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int72)(nil)),
+	}
+}
+
+type uint72 big.Int
+
+func (i *uint72) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint72) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint72) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 72 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint72) private() {}
+
+func init() {
+	typeMap["uint72"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint72)(nil)),
+	}
+}
+
+type int80 big.Int
+
+func (i *int80) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int80) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int80) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 80 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int80) private() {}
+
+func init() {
+	typeMap["int80"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int80)(nil)),
+	}
+}
+
+type uint80 big.Int
+
+func (i *uint80) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint80) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint80) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 80 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint80) private() {}
+
+func init() {
+	typeMap["uint80"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint80)(nil)),
+	}
+}
+
+type int88 big.Int
+
+func (i *int88) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int88) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int88) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 88 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int88) private() {}
+
+func init() {
+	typeMap["int88"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int88)(nil)),
+	}
+}
+
+type uint88 big.Int
+
+func (i *uint88) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint88) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint88) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 88 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint88) private() {}
+
+func init() {
+	typeMap["uint88"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint88)(nil)),
+	}
+}
+
+type int96 big.Int
+
+func (i *int96) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int96) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int96) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 96 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int96) private() {}
+
+func init() {
+	typeMap["int96"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int96)(nil)),
+	}
+}
+
+type uint96 big.Int
+
+func (i *uint96) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint96) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint96) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 96 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint96) private() {}
+
+func init() {
+	typeMap["uint96"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint96)(nil)),
+	}
+}
+
+type int104 big.Int
+
+func (i *int104) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int104) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int104) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 104 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int104) private() {}
+
+func init() {
+	typeMap["int104"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int104)(nil)),
+	}
+}
+
+type uint104 big.Int
+
+func (i *uint104) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint104) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint104) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 104 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint104) private() {}
+
+func init() {
+	typeMap["uint104"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint104)(nil)),
+	}
+}
+
+type int112 big.Int
+
+func (i *int112) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int112) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int112) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 112 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int112) private() {}
+
+func init() {
+	typeMap["int112"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int112)(nil)),
+	}
+}
+
+type uint112 big.Int
+
+func (i *uint112) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint112) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint112) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 112 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint112) private() {}
+
+func init() {
+	typeMap["uint112"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint112)(nil)),
+	}
+}
+
+type int120 big.Int
+
+func (i *int120) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int120) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int120) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 120 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int120) private() {}
+
+func init() {
+	typeMap["int120"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int120)(nil)),
+	}
+}
+
+type uint120 big.Int
+
+func (i *uint120) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint120) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint120) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 120 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint120) private() {}
+
+func init() {
+	typeMap["uint120"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint120)(nil)),
+	}
+}
+
+type int128 big.Int
+
+func (i *int128) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int128) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int128) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 128 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int128) private() {}
+
+func init() {
+	typeMap["int128"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int128)(nil)),
+	}
+}
+
+type uint128 big.Int
+
+func (i *uint128) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint128) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint128) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 128 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint128) private() {}
+
+func init() {
+	typeMap["uint128"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint128)(nil)),
+	}
+}
+
+type int136 big.Int
+
+func (i *int136) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int136) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int136) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 136 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int136) private() {}
+
+func init() {
+	typeMap["int136"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int136)(nil)),
+	}
+}
+
+type uint136 big.Int
+
+func (i *uint136) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint136) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint136) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 136 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint136) private() {}
+
+func init() {
+	typeMap["uint136"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint136)(nil)),
+	}
+}
+
+type int144 big.Int
+
+func (i *int144) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int144) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int144) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 144 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int144) private() {}
+
+func init() {
+	typeMap["int144"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int144)(nil)),
+	}
+}
+
+type uint144 big.Int
+
+func (i *uint144) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint144) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint144) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 144 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint144) private() {}
+
+func init() {
+	typeMap["uint144"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint144)(nil)),
+	}
+}
+
+type int152 big.Int
+
+func (i *int152) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int152) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int152) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 152 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int152) private() {}
+
+func init() {
+	typeMap["int152"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int152)(nil)),
+	}
+}
+
+type uint152 big.Int
+
+func (i *uint152) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint152) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint152) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 152 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint152) private() {}
+
+func init() {
+	typeMap["uint152"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint152)(nil)),
+	}
+}
+
+type int160 big.Int
+
+func (i *int160) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int160) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int160) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 160 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int160) private() {}
+
+func init() {
+	typeMap["int160"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int160)(nil)),
+	}
+}
+
+type uint160 big.Int
+
+func (i *uint160) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint160) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint160) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 160 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint160) private() {}
+
+func init() {
+	typeMap["uint160"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint160)(nil)),
+	}
+}
+
+type int168 big.Int
+
+func (i *int168) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int168) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int168) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 168 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int168) private() {}
+
+func init() {
+	typeMap["int168"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int168)(nil)),
+	}
+}
+
+type uint168 big.Int
+
+func (i *uint168) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint168) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint168) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 168 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint168) private() {}
+
+func init() {
+	typeMap["uint168"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint168)(nil)),
+	}
+}
+
+type int176 big.Int
+
+func (i *int176) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int176) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int176) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 176 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int176) private() {}
+
+func init() {
+	typeMap["int176"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int176)(nil)),
+	}
+}
+
+type uint176 big.Int
+
+func (i *uint176) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint176) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint176) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 176 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint176) private() {}
+
+func init() {
+	typeMap["uint176"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint176)(nil)),
+	}
+}
+
+type int184 big.Int
+
+func (i *int184) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int184) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int184) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 184 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int184) private() {}
+
+func init() {
+	typeMap["int184"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int184)(nil)),
+	}
+}
+
+type uint184 big.Int
+
+func (i *uint184) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint184) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint184) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 184 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint184) private() {}
+
+func init() {
+	typeMap["uint184"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint184)(nil)),
+	}
+}
+
+type int192 big.Int
+
+func (i *int192) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int192) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int192) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 192 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int192) private() {}
+
+func init() {
+	typeMap["int192"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int192)(nil)),
+	}
+}
+
+type uint192 big.Int
+
+func (i *uint192) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint192) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint192) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 192 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint192) private() {}
+
+func init() {
+	typeMap["uint192"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint192)(nil)),
+	}
+}
+
+type int200 big.Int
+
+func (i *int200) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int200) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int200) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 200 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int200) private() {}
+
+func init() {
+	typeMap["int200"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int200)(nil)),
+	}
+}
+
+type uint200 big.Int
+
+func (i *uint200) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint200) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint200) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 200 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint200) private() {}
+
+func init() {
+	typeMap["uint200"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint200)(nil)),
+	}
+}
+
+type int208 big.Int
+
+func (i *int208) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int208) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int208) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 208 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int208) private() {}
+
+func init() {
+	typeMap["int208"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int208)(nil)),
+	}
+}
+
+type uint208 big.Int
+
+func (i *uint208) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint208) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint208) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 208 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint208) private() {}
+
+func init() {
+	typeMap["uint208"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint208)(nil)),
+	}
+}
+
+type int216 big.Int
+
+func (i *int216) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int216) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int216) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 216 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int216) private() {}
+
+func init() {
+	typeMap["int216"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int216)(nil)),
+	}
+}
+
+type uint216 big.Int
+
+func (i *uint216) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint216) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint216) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 216 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint216) private() {}
+
+func init() {
+	typeMap["uint216"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint216)(nil)),
+	}
+}
+
+type int224 big.Int
+
+func (i *int224) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int224) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int224) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 224 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int224) private() {}
+
+func init() {
+	typeMap["int224"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int224)(nil)),
+	}
+}
+
+type uint224 big.Int
+
+func (i *uint224) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint224) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint224) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 224 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint224) private() {}
+
+func init() {
+	typeMap["uint224"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint224)(nil)),
+	}
+}
+
+type int232 big.Int
+
+func (i *int232) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int232) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int232) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 232 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int232) private() {}
+
+func init() {
+	typeMap["int232"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int232)(nil)),
+	}
+}
+
+type uint232 big.Int
+
+func (i *uint232) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint232) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint232) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 232 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint232) private() {}
+
+func init() {
+	typeMap["uint232"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint232)(nil)),
+	}
+}
+
+type int240 big.Int
+
+func (i *int240) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int240) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int240) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 240 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int240) private() {}
+
+func init() {
+	typeMap["int240"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int240)(nil)),
+	}
+}
+
+type uint240 big.Int
+
+func (i *uint240) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint240) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint240) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 240 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint240) private() {}
+
+func init() {
+	typeMap["uint240"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint240)(nil)),
+	}
+}
+
+type int248 big.Int
+
+func (i *int248) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int248) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int248) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 248 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int248) private() {}
+
+func init() {
+	typeMap["int248"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int248)(nil)),
+	}
+}
+
+type uint248 big.Int
+
+func (i *uint248) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint248) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint248) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 248 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint248) private() {}
+
+func init() {
+	typeMap["uint248"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint248)(nil)),
+	}
+}
+
+type int256 big.Int
+
+func (i *int256) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *int256) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *int256) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 256 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *int256) private() {}
+
+func init() {
+	typeMap["int256"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*int256)(nil)),
+	}
+}
+
+type uint256 big.Int
+
+func (i *uint256) UnmarshalCBOR(input []byte) error {
+	bi := (*big.Int)(i)
+	if err := cbor.Unmarshal(input, bi); err != nil {
+		return err
+	}
+
+	return i.Verify()
+}
+
+func (i *uint256) UnmarshalText(input []byte) error {
+	bi := (*big.Int)(i)
+	if _, ok := bi.SetString(string(input), 10); !ok {
+		return types.InvalidTypeError{}
+	}
+
+	return i.Verify()
+}
+
+func (i *uint256) Verify() error {
+	bi := (*big.Int)(i)
+
+	if bi.BitLen() > 256 {
+		return types.InvalidTypeError{}
+	}
+
+	return nil
+}
+
+func (i *uint256) private() {}
+
+func init() {
+	typeMap["uint256"] = &AbiEncodingType{
+		Native:  reflect.TypeOf((*big.Int)(nil)),
+		Checked: reflect.TypeOf((*uint256)(nil)),
+	}
+}
diff --git a/core/services/relay/evm/types/types.go b/core/services/relay/evm/types/types.go
index ade714b63bc..528c09d0b4e 100644
--- a/core/services/relay/evm/types/types.go
+++ b/core/services/relay/evm/types/types.go
@@ -31,9 +31,17 @@ type ChainReaderConfig struct {
 	// key being contract name
 	ChainContractReaders map[string]ChainContractReader `json:"chainContractReaders"`
 
+	// key being the type for the codec
+	ChainCodecConfigs map[string]ChainCodedConfig `json:"chainCodecConfig"`
+
 	// ..reserved for any global config options chainreader might need..
 }
 
+type ChainCodedConfig struct {
+	TypeAbi string `json:"typeAbi"`
+	// TODO transform configs that allow hard-coding values or transforming them (max, min, median etc)
+}
+
 type ChainContractReader struct {
 	ContractABI string `json:"contractABI"`
 	// key is genericName from config