From b7be6db63639b4f82045b77d430590c648fbfdec Mon Sep 17 00:00:00 2001
From: Richard Patel <me@terorie.dev>
Date: Wed, 7 Sep 2022 08:13:45 +0200
Subject: [PATCH] gossip: add all data types

---
 cmd/gossip/ping/ping.go   |    2 +-
 generate.sh               |    4 +
 pkg/gossip/schema.go      | 3313 ++++++++++++++++++++++++++++++++++++-
 pkg/gossip/schema.yaml    |  324 +++-
 pkg/gossip/transaction.go |   16 +
 5 files changed, 3639 insertions(+), 20 deletions(-)
 create mode 100644 pkg/gossip/transaction.go

diff --git a/cmd/gossip/ping/ping.go b/cmd/gossip/ping/ping.go
index c3030c0..9574148 100644
--- a/cmd/gossip/ping/ping.go
+++ b/cmd/gossip/ping/ping.go
@@ -157,7 +157,7 @@ func (s *Session) sendPing(ctx context.Context, c int) {
 
 func (s *Session) receive(ctx context.Context) error {
 	for ctx.Err() == nil {
-		var packet [132]byte
+		var packet [4 + gossip.PingSize]byte
 		n, remote, err := s.udpConn.ReadFromUDPAddrPort(packet[:])
 		klog.V(7).Infof("Packet from %s", remote)
 		if n >= len(packet) {
diff --git a/generate.sh b/generate.sh
index 1e920ef..9dfdd9c 100755
--- a/generate.sh
+++ b/generate.sh
@@ -14,6 +14,10 @@ then
   serdegen ./pkg/gossip/schema.yaml \
     --language=Go \
     --with-runtimes=Bincode \
+    --module-name=gossip \
     --serde-package-name=gossip \
     > ./pkg/gossip/schema.go
+  sed -i'.bak' '1s/^/\/\/ Code generated by "serde-generate"; DO NOT EDIT.\n\n/' ./pkg/gossip/schema.go
+  rm -f ./pkg/gossip/schema.go.bak
+  go fmt ./pkg/gossip/schema.go
 fi
diff --git a/pkg/gossip/schema.go b/pkg/gossip/schema.go
index 2a7317f..5440ccf 100644
--- a/pkg/gossip/schema.go
+++ b/pkg/gossip/schema.go
@@ -1,4 +1,4 @@
-// Code generated by serde-generate; DO NOT EDIT.
+// Code generated by "serde-generate"; DO NOT EDIT.
 
 package gossip
 
@@ -8,6 +8,1863 @@ import (
 	"github.com/novifinancial/serde-reflection/serde-generate/runtime/golang/serde"
 )
 
+type BitVecU64 struct {
+	Bits BitVecU64Inner
+	Len  uint64
+}
+
+func (obj *BitVecU64) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := obj.Bits.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Len); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *BitVecU64) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeBitVecU64(deserializer serde.Deserializer) (BitVecU64, error) {
+	var obj BitVecU64
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializeBitVecU64Inner(deserializer); err == nil {
+		obj.Bits = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Len = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializeBitVecU64(input []byte) (BitVecU64, error) {
+	if input == nil {
+		var obj BitVecU64
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeBitVecU64(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type BitVecU64Inner struct {
+	Value *[]uint8
+}
+
+func (obj *BitVecU64Inner) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := serialize_option_vector_u8(obj.Value, serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *BitVecU64Inner) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeBitVecU64Inner(deserializer serde.Deserializer) (BitVecU64Inner, error) {
+	var obj BitVecU64Inner
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := deserialize_option_vector_u8(deserializer); err == nil {
+		obj.Value = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializeBitVecU64Inner(input []byte) (BitVecU64Inner, error) {
+	if input == nil {
+		var obj BitVecU64Inner
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeBitVecU64Inner(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type BitVecU8 struct {
+	Bits BitVecU8Inner
+	Len  uint64
+}
+
+func (obj *BitVecU8) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := obj.Bits.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Len); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *BitVecU8) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeBitVecU8(deserializer serde.Deserializer) (BitVecU8, error) {
+	var obj BitVecU8
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializeBitVecU8Inner(deserializer); err == nil {
+		obj.Bits = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Len = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializeBitVecU8(input []byte) (BitVecU8, error) {
+	if input == nil {
+		var obj BitVecU8
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeBitVecU8(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type BitVecU8Inner struct {
+	Value *[]uint8
+}
+
+func (obj *BitVecU8Inner) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := serialize_option_vector_u8(obj.Value, serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *BitVecU8Inner) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeBitVecU8Inner(deserializer serde.Deserializer) (BitVecU8Inner, error) {
+	var obj BitVecU8Inner
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := deserialize_option_vector_u8(deserializer); err == nil {
+		obj.Value = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializeBitVecU8Inner(input []byte) (BitVecU8Inner, error) {
+	if input == nil {
+		var obj BitVecU8Inner
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeBitVecU8Inner(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type Bloom struct {
+	Keys       []uint64
+	Bits       BitVecU64
+	NumBitsSet uint64
+}
+
+func (obj *Bloom) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := serialize_vector_u64(obj.Keys, serializer); err != nil {
+		return err
+	}
+	if err := obj.Bits.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.NumBitsSet); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *Bloom) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeBloom(deserializer serde.Deserializer) (Bloom, error) {
+	var obj Bloom
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := deserialize_vector_u64(deserializer); err == nil {
+		obj.Keys = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeBitVecU64(deserializer); err == nil {
+		obj.Bits = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.NumBitsSet = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializeBloom(input []byte) (Bloom, error) {
+	if input == nil {
+		var obj Bloom
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeBloom(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type CompressedSlots interface {
+	isCompressedSlots()
+	Serialize(serializer serde.Serializer) error
+	BincodeSerialize() ([]byte, error)
+}
+
+func DeserializeCompressedSlots(deserializer serde.Deserializer) (CompressedSlots, error) {
+	index, err := deserializer.DeserializeVariantIndex()
+	if err != nil {
+		return nil, err
+	}
+
+	switch index {
+	case 0:
+		if val, err := load_CompressedSlots__Flate2(deserializer); err == nil {
+			return &val, nil
+		} else {
+			return nil, err
+		}
+
+	case 1:
+		if val, err := load_CompressedSlots__Uncompressed(deserializer); err == nil {
+			return &val, nil
+		} else {
+			return nil, err
+		}
+
+	default:
+		return nil, fmt.Errorf("Unknown variant index for CompressedSlots: %d", index)
+	}
+}
+
+func BincodeDeserializeCompressedSlots(input []byte) (CompressedSlots, error) {
+	if input == nil {
+		var obj CompressedSlots
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeCompressedSlots(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type CompressedSlots__Flate2 struct {
+	Value SlotsFlate2
+}
+
+func (*CompressedSlots__Flate2) isCompressedSlots() {}
+
+func (obj *CompressedSlots__Flate2) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	serializer.SerializeVariantIndex(0)
+	if err := obj.Value.Serialize(serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *CompressedSlots__Flate2) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func load_CompressedSlots__Flate2(deserializer serde.Deserializer) (CompressedSlots__Flate2, error) {
+	var obj CompressedSlots__Flate2
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializeSlotsFlate2(deserializer); err == nil {
+		obj.Value = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+type CompressedSlots__Uncompressed struct {
+	Value SlotsUncompressed
+}
+
+func (*CompressedSlots__Uncompressed) isCompressedSlots() {}
+
+func (obj *CompressedSlots__Uncompressed) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	serializer.SerializeVariantIndex(1)
+	if err := obj.Value.Serialize(serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *CompressedSlots__Uncompressed) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func load_CompressedSlots__Uncompressed(deserializer serde.Deserializer) (CompressedSlots__Uncompressed, error) {
+	var obj CompressedSlots__Uncompressed
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializeSlotsUncompressed(deserializer); err == nil {
+		obj.Value = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+type ContactInfo struct {
+	Id           Pubkey
+	Gossip       SocketAddr
+	Tvu          SocketAddr
+	TvuForwards  SocketAddr
+	Repair       SocketAddr
+	Tpu          SocketAddr
+	TpuForwards  SocketAddr
+	TpuVote      SocketAddr
+	Rpc          SocketAddr
+	RpcPubsub    SocketAddr
+	ServeRepair  SocketAddr
+	Wallclock    uint64
+	ShredVersion uint16
+}
+
+func (obj *ContactInfo) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := obj.Id.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := obj.Gossip.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := obj.Tvu.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := obj.TvuForwards.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := obj.Repair.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := obj.Tpu.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := obj.TpuForwards.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := obj.TpuVote.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := obj.Rpc.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := obj.RpcPubsub.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := obj.ServeRepair.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Wallclock); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU16(obj.ShredVersion); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *ContactInfo) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeContactInfo(deserializer serde.Deserializer) (ContactInfo, error) {
+	var obj ContactInfo
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializePubkey(deserializer); err == nil {
+		obj.Id = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeSocketAddr(deserializer); err == nil {
+		obj.Gossip = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeSocketAddr(deserializer); err == nil {
+		obj.Tvu = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeSocketAddr(deserializer); err == nil {
+		obj.TvuForwards = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeSocketAddr(deserializer); err == nil {
+		obj.Repair = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeSocketAddr(deserializer); err == nil {
+		obj.Tpu = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeSocketAddr(deserializer); err == nil {
+		obj.TpuForwards = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeSocketAddr(deserializer); err == nil {
+		obj.TpuVote = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeSocketAddr(deserializer); err == nil {
+		obj.Rpc = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeSocketAddr(deserializer); err == nil {
+		obj.RpcPubsub = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeSocketAddr(deserializer); err == nil {
+		obj.ServeRepair = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Wallclock = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU16(); err == nil {
+		obj.ShredVersion = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializeContactInfo(input []byte) (ContactInfo, error) {
+	if input == nil {
+		var obj ContactInfo
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeContactInfo(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type CrdsData interface {
+	isCrdsData()
+	Serialize(serializer serde.Serializer) error
+	BincodeSerialize() ([]byte, error)
+}
+
+func DeserializeCrdsData(deserializer serde.Deserializer) (CrdsData, error) {
+	index, err := deserializer.DeserializeVariantIndex()
+	if err != nil {
+		return nil, err
+	}
+
+	switch index {
+	case 0:
+		if val, err := load_CrdsData__ContactInfo(deserializer); err == nil {
+			return &val, nil
+		} else {
+			return nil, err
+		}
+
+	case 1:
+		if val, err := load_CrdsData__Vote(deserializer); err == nil {
+			return &val, nil
+		} else {
+			return nil, err
+		}
+
+	case 2:
+		if val, err := load_CrdsData__LowestSlot(deserializer); err == nil {
+			return &val, nil
+		} else {
+			return nil, err
+		}
+
+	case 3:
+		if val, err := load_CrdsData__SnapshotHashes(deserializer); err == nil {
+			return &val, nil
+		} else {
+			return nil, err
+		}
+
+	case 4:
+		if val, err := load_CrdsData__AccountsHashes(deserializer); err == nil {
+			return &val, nil
+		} else {
+			return nil, err
+		}
+
+	case 5:
+		if val, err := load_CrdsData__EpochSlots(deserializer); err == nil {
+			return &val, nil
+		} else {
+			return nil, err
+		}
+
+	case 6:
+		if val, err := load_CrdsData__LegacyVersion(deserializer); err == nil {
+			return &val, nil
+		} else {
+			return nil, err
+		}
+
+	case 7:
+		if val, err := load_CrdsData__Version(deserializer); err == nil {
+			return &val, nil
+		} else {
+			return nil, err
+		}
+
+	case 8:
+		if val, err := load_CrdsData__NodeInstance(deserializer); err == nil {
+			return &val, nil
+		} else {
+			return nil, err
+		}
+
+	case 9:
+		if val, err := load_CrdsData__DuplicateShred(deserializer); err == nil {
+			return &val, nil
+		} else {
+			return nil, err
+		}
+
+	case 10:
+		if val, err := load_CrdsData__IncrementalSnapshotHashes(deserializer); err == nil {
+			return &val, nil
+		} else {
+			return nil, err
+		}
+
+	default:
+		return nil, fmt.Errorf("Unknown variant index for CrdsData: %d", index)
+	}
+}
+
+func BincodeDeserializeCrdsData(input []byte) (CrdsData, error) {
+	if input == nil {
+		var obj CrdsData
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeCrdsData(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type CrdsData__ContactInfo struct {
+	Value ContactInfo
+}
+
+func (*CrdsData__ContactInfo) isCrdsData() {}
+
+func (obj *CrdsData__ContactInfo) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	serializer.SerializeVariantIndex(0)
+	if err := obj.Value.Serialize(serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *CrdsData__ContactInfo) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func load_CrdsData__ContactInfo(deserializer serde.Deserializer) (CrdsData__ContactInfo, error) {
+	var obj CrdsData__ContactInfo
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializeContactInfo(deserializer); err == nil {
+		obj.Value = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+type CrdsData__Vote struct {
+	Field0 uint8
+	Field1 Vote
+}
+
+func (*CrdsData__Vote) isCrdsData() {}
+
+func (obj *CrdsData__Vote) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	serializer.SerializeVariantIndex(1)
+	if err := serializer.SerializeU8(obj.Field0); err != nil {
+		return err
+	}
+	if err := obj.Field1.Serialize(serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *CrdsData__Vote) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func load_CrdsData__Vote(deserializer serde.Deserializer) (CrdsData__Vote, error) {
+	var obj CrdsData__Vote
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU8(); err == nil {
+		obj.Field0 = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeVote(deserializer); err == nil {
+		obj.Field1 = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+type CrdsData__LowestSlot struct {
+	Field0 uint8
+	Field1 LowestSlot
+}
+
+func (*CrdsData__LowestSlot) isCrdsData() {}
+
+func (obj *CrdsData__LowestSlot) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	serializer.SerializeVariantIndex(2)
+	if err := serializer.SerializeU8(obj.Field0); err != nil {
+		return err
+	}
+	if err := obj.Field1.Serialize(serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *CrdsData__LowestSlot) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func load_CrdsData__LowestSlot(deserializer serde.Deserializer) (CrdsData__LowestSlot, error) {
+	var obj CrdsData__LowestSlot
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU8(); err == nil {
+		obj.Field0 = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeLowestSlot(deserializer); err == nil {
+		obj.Field1 = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+type CrdsData__SnapshotHashes struct {
+	Value SnapshotHashes
+}
+
+func (*CrdsData__SnapshotHashes) isCrdsData() {}
+
+func (obj *CrdsData__SnapshotHashes) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	serializer.SerializeVariantIndex(3)
+	if err := obj.Value.Serialize(serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *CrdsData__SnapshotHashes) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func load_CrdsData__SnapshotHashes(deserializer serde.Deserializer) (CrdsData__SnapshotHashes, error) {
+	var obj CrdsData__SnapshotHashes
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializeSnapshotHashes(deserializer); err == nil {
+		obj.Value = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+type CrdsData__AccountsHashes struct {
+	Value SnapshotHashes
+}
+
+func (*CrdsData__AccountsHashes) isCrdsData() {}
+
+func (obj *CrdsData__AccountsHashes) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	serializer.SerializeVariantIndex(4)
+	if err := obj.Value.Serialize(serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *CrdsData__AccountsHashes) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func load_CrdsData__AccountsHashes(deserializer serde.Deserializer) (CrdsData__AccountsHashes, error) {
+	var obj CrdsData__AccountsHashes
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializeSnapshotHashes(deserializer); err == nil {
+		obj.Value = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+type CrdsData__EpochSlots struct {
+	Field0 uint8
+	Field1 EpochSlots
+}
+
+func (*CrdsData__EpochSlots) isCrdsData() {}
+
+func (obj *CrdsData__EpochSlots) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	serializer.SerializeVariantIndex(5)
+	if err := serializer.SerializeU8(obj.Field0); err != nil {
+		return err
+	}
+	if err := obj.Field1.Serialize(serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *CrdsData__EpochSlots) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func load_CrdsData__EpochSlots(deserializer serde.Deserializer) (CrdsData__EpochSlots, error) {
+	var obj CrdsData__EpochSlots
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU8(); err == nil {
+		obj.Field0 = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeEpochSlots(deserializer); err == nil {
+		obj.Field1 = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+type CrdsData__LegacyVersion struct {
+	Value LegacyVersion
+}
+
+func (*CrdsData__LegacyVersion) isCrdsData() {}
+
+func (obj *CrdsData__LegacyVersion) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	serializer.SerializeVariantIndex(6)
+	if err := obj.Value.Serialize(serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *CrdsData__LegacyVersion) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func load_CrdsData__LegacyVersion(deserializer serde.Deserializer) (CrdsData__LegacyVersion, error) {
+	var obj CrdsData__LegacyVersion
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializeLegacyVersion(deserializer); err == nil {
+		obj.Value = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+type CrdsData__Version struct {
+	Value Version
+}
+
+func (*CrdsData__Version) isCrdsData() {}
+
+func (obj *CrdsData__Version) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	serializer.SerializeVariantIndex(7)
+	if err := obj.Value.Serialize(serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *CrdsData__Version) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func load_CrdsData__Version(deserializer serde.Deserializer) (CrdsData__Version, error) {
+	var obj CrdsData__Version
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializeVersion(deserializer); err == nil {
+		obj.Value = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+type CrdsData__NodeInstance struct {
+	Value NodeInstance
+}
+
+func (*CrdsData__NodeInstance) isCrdsData() {}
+
+func (obj *CrdsData__NodeInstance) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	serializer.SerializeVariantIndex(8)
+	if err := obj.Value.Serialize(serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *CrdsData__NodeInstance) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func load_CrdsData__NodeInstance(deserializer serde.Deserializer) (CrdsData__NodeInstance, error) {
+	var obj CrdsData__NodeInstance
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializeNodeInstance(deserializer); err == nil {
+		obj.Value = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+type CrdsData__DuplicateShred struct {
+	Field0 uint16
+	Field1 DuplicateShred
+}
+
+func (*CrdsData__DuplicateShred) isCrdsData() {}
+
+func (obj *CrdsData__DuplicateShred) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	serializer.SerializeVariantIndex(9)
+	if err := serializer.SerializeU16(obj.Field0); err != nil {
+		return err
+	}
+	if err := obj.Field1.Serialize(serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *CrdsData__DuplicateShred) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func load_CrdsData__DuplicateShred(deserializer serde.Deserializer) (CrdsData__DuplicateShred, error) {
+	var obj CrdsData__DuplicateShred
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU16(); err == nil {
+		obj.Field0 = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeDuplicateShred(deserializer); err == nil {
+		obj.Field1 = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+type CrdsData__IncrementalSnapshotHashes struct {
+	Value IncrementalSnapshotHashes
+}
+
+func (*CrdsData__IncrementalSnapshotHashes) isCrdsData() {}
+
+func (obj *CrdsData__IncrementalSnapshotHashes) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	serializer.SerializeVariantIndex(10)
+	if err := obj.Value.Serialize(serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *CrdsData__IncrementalSnapshotHashes) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func load_CrdsData__IncrementalSnapshotHashes(deserializer serde.Deserializer) (CrdsData__IncrementalSnapshotHashes, error) {
+	var obj CrdsData__IncrementalSnapshotHashes
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializeIncrementalSnapshotHashes(deserializer); err == nil {
+		obj.Value = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+type CrdsFilter struct {
+	Filter   Bloom
+	Mask     uint64
+	MaskBits uint32
+}
+
+func (obj *CrdsFilter) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := obj.Filter.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Mask); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU32(obj.MaskBits); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *CrdsFilter) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeCrdsFilter(deserializer serde.Deserializer) (CrdsFilter, error) {
+	var obj CrdsFilter
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializeBloom(deserializer); err == nil {
+		obj.Filter = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Mask = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU32(); err == nil {
+		obj.MaskBits = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializeCrdsFilter(input []byte) (CrdsFilter, error) {
+	if input == nil {
+		var obj CrdsFilter
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeCrdsFilter(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type CrdsValue struct {
+	Signature Signature
+	Data      CrdsData
+}
+
+func (obj *CrdsValue) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := obj.Signature.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := obj.Data.Serialize(serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *CrdsValue) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeCrdsValue(deserializer serde.Deserializer) (CrdsValue, error) {
+	var obj CrdsValue
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializeSignature(deserializer); err == nil {
+		obj.Signature = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeCrdsData(deserializer); err == nil {
+		obj.Data = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializeCrdsValue(input []byte) (CrdsValue, error) {
+	if input == nil {
+		var obj CrdsValue
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeCrdsValue(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type DuplicateShred struct {
+	From       Pubkey
+	Wallclock  uint64
+	Slot       uint64
+	ShredIndex uint32
+	ShredType  uint8
+	NumChunks  uint8
+	ChunkIndex uint8
+	Chunk      []uint8
+}
+
+func (obj *DuplicateShred) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := obj.From.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Wallclock); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Slot); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU32(obj.ShredIndex); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU8(obj.ShredType); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU8(obj.NumChunks); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU8(obj.ChunkIndex); err != nil {
+		return err
+	}
+	if err := serialize_vector_u8(obj.Chunk, serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *DuplicateShred) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeDuplicateShred(deserializer serde.Deserializer) (DuplicateShred, error) {
+	var obj DuplicateShred
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializePubkey(deserializer); err == nil {
+		obj.From = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Wallclock = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Slot = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU32(); err == nil {
+		obj.ShredIndex = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU8(); err == nil {
+		obj.ShredType = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU8(); err == nil {
+		obj.NumChunks = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU8(); err == nil {
+		obj.ChunkIndex = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserialize_vector_u8(deserializer); err == nil {
+		obj.Chunk = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializeDuplicateShred(input []byte) (DuplicateShred, error) {
+	if input == nil {
+		var obj DuplicateShred
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeDuplicateShred(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type EpochSlots struct {
+	From      Pubkey
+	Slots     []CompressedSlots
+	Wallclock uint64
+}
+
+func (obj *EpochSlots) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := obj.From.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := serialize_vector_CompressedSlots(obj.Slots, serializer); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Wallclock); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *EpochSlots) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeEpochSlots(deserializer serde.Deserializer) (EpochSlots, error) {
+	var obj EpochSlots
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializePubkey(deserializer); err == nil {
+		obj.From = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserialize_vector_CompressedSlots(deserializer); err == nil {
+		obj.Slots = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Wallclock = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializeEpochSlots(input []byte) (EpochSlots, error) {
+	if input == nil {
+		var obj EpochSlots
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeEpochSlots(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type Hash [32]uint8
+
+func (obj *Hash) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := serialize_array32_u8_array((([32]uint8)(*obj)), serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *Hash) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeHash(deserializer serde.Deserializer) (Hash, error) {
+	var obj [32]uint8
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return (Hash)(obj), err
+	}
+	if val, err := deserialize_array32_u8_array(deserializer); err == nil {
+		obj = val
+	} else {
+		return ((Hash)(obj)), err
+	}
+	deserializer.DecreaseContainerDepth()
+	return (Hash)(obj), nil
+}
+
+func BincodeDeserializeHash(input []byte) (Hash, error) {
+	if input == nil {
+		var obj Hash
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeHash(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type IncrementalSnapshotHashes struct {
+	From      Pubkey
+	Base      SlotHash
+	Hashes    []SlotHash
+	Wallclock uint64
+}
+
+func (obj *IncrementalSnapshotHashes) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := obj.From.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := obj.Base.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := serialize_vector_SlotHash(obj.Hashes, serializer); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Wallclock); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *IncrementalSnapshotHashes) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeIncrementalSnapshotHashes(deserializer serde.Deserializer) (IncrementalSnapshotHashes, error) {
+	var obj IncrementalSnapshotHashes
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializePubkey(deserializer); err == nil {
+		obj.From = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeSlotHash(deserializer); err == nil {
+		obj.Base = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserialize_vector_SlotHash(deserializer); err == nil {
+		obj.Hashes = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Wallclock = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializeIncrementalSnapshotHashes(input []byte) (IncrementalSnapshotHashes, error) {
+	if input == nil {
+		var obj IncrementalSnapshotHashes
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeIncrementalSnapshotHashes(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type LegacyVersion struct {
+	From      Pubkey
+	Wallclock uint64
+	Major     uint16
+	Minor     uint16
+	Patch     uint16
+	Commit    *uint32
+}
+
+func (obj *LegacyVersion) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := obj.From.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Wallclock); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU16(obj.Major); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU16(obj.Minor); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU16(obj.Patch); err != nil {
+		return err
+	}
+	if err := serialize_option_u32(obj.Commit, serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *LegacyVersion) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeLegacyVersion(deserializer serde.Deserializer) (LegacyVersion, error) {
+	var obj LegacyVersion
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializePubkey(deserializer); err == nil {
+		obj.From = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Wallclock = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU16(); err == nil {
+		obj.Major = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU16(); err == nil {
+		obj.Minor = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU16(); err == nil {
+		obj.Patch = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserialize_option_u32(deserializer); err == nil {
+		obj.Commit = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializeLegacyVersion(input []byte) (LegacyVersion, error) {
+	if input == nil {
+		var obj LegacyVersion
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeLegacyVersion(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type LowestSlot struct {
+	From      Pubkey
+	Root      uint64
+	Lowest    uint64
+	Slots     []uint64
+	Stash     []struct{}
+	Wallclock uint64
+}
+
+func (obj *LowestSlot) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := obj.From.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Root); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Lowest); err != nil {
+		return err
+	}
+	if err := serialize_vector_u64(obj.Slots, serializer); err != nil {
+		return err
+	}
+	if err := serialize_vector_unit(obj.Stash, serializer); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Wallclock); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *LowestSlot) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeLowestSlot(deserializer serde.Deserializer) (LowestSlot, error) {
+	var obj LowestSlot
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializePubkey(deserializer); err == nil {
+		obj.From = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Root = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Lowest = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserialize_vector_u64(deserializer); err == nil {
+		obj.Slots = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserialize_vector_unit(deserializer); err == nil {
+		obj.Stash = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Wallclock = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializeLowestSlot(input []byte) (LowestSlot, error) {
+	if input == nil {
+		var obj LowestSlot
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeLowestSlot(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
 type Message interface {
 	isMessage()
 	Serialize(serializer serde.Serializer) error
@@ -21,6 +1878,34 @@ func DeserializeMessage(deserializer serde.Deserializer) (Message, error) {
 	}
 
 	switch index {
+	case 0:
+		if val, err := load_Message__PullRequest(deserializer); err == nil {
+			return &val, nil
+		} else {
+			return nil, err
+		}
+
+	case 1:
+		if val, err := load_Message__PullResponse(deserializer); err == nil {
+			return &val, nil
+		} else {
+			return nil, err
+		}
+
+	case 2:
+		if val, err := load_Message__PushMessage(deserializer); err == nil {
+			return &val, nil
+		} else {
+			return nil, err
+		}
+
+	case 3:
+		if val, err := load_Message__PruneMessage(deserializer); err == nil {
+			return &val, nil
+		} else {
+			return nil, err
+		}
+
 	case 4:
 		if val, err := load_Message__Ping(deserializer); err == nil {
 			return &val, nil
@@ -53,6 +1938,214 @@ func BincodeDeserializeMessage(input []byte) (Message, error) {
 	return obj, err
 }
 
+type Message__PullRequest struct {
+	Field0 CrdsFilter
+	Field1 CrdsValue
+}
+
+func (*Message__PullRequest) isMessage() {}
+
+func (obj *Message__PullRequest) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	serializer.SerializeVariantIndex(0)
+	if err := obj.Field0.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := obj.Field1.Serialize(serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *Message__PullRequest) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func load_Message__PullRequest(deserializer serde.Deserializer) (Message__PullRequest, error) {
+	var obj Message__PullRequest
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializeCrdsFilter(deserializer); err == nil {
+		obj.Field0 = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeCrdsValue(deserializer); err == nil {
+		obj.Field1 = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+type Message__PullResponse struct {
+	Field0 Pubkey
+	Field1 []CrdsValue
+}
+
+func (*Message__PullResponse) isMessage() {}
+
+func (obj *Message__PullResponse) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	serializer.SerializeVariantIndex(1)
+	if err := obj.Field0.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := serialize_vector_CrdsValue(obj.Field1, serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *Message__PullResponse) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func load_Message__PullResponse(deserializer serde.Deserializer) (Message__PullResponse, error) {
+	var obj Message__PullResponse
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializePubkey(deserializer); err == nil {
+		obj.Field0 = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserialize_vector_CrdsValue(deserializer); err == nil {
+		obj.Field1 = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+type Message__PushMessage struct {
+	Field0 Pubkey
+	Field1 []CrdsValue
+}
+
+func (*Message__PushMessage) isMessage() {}
+
+func (obj *Message__PushMessage) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	serializer.SerializeVariantIndex(2)
+	if err := obj.Field0.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := serialize_vector_CrdsValue(obj.Field1, serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *Message__PushMessage) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func load_Message__PushMessage(deserializer serde.Deserializer) (Message__PushMessage, error) {
+	var obj Message__PushMessage
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializePubkey(deserializer); err == nil {
+		obj.Field0 = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserialize_vector_CrdsValue(deserializer); err == nil {
+		obj.Field1 = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+type Message__PruneMessage struct {
+	Field0 Pubkey
+	Field1 PruneData
+}
+
+func (*Message__PruneMessage) isMessage() {}
+
+func (obj *Message__PruneMessage) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	serializer.SerializeVariantIndex(3)
+	if err := obj.Field0.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := obj.Field1.Serialize(serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *Message__PruneMessage) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func load_Message__PruneMessage(deserializer serde.Deserializer) (Message__PruneMessage, error) {
+	var obj Message__PruneMessage
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializePubkey(deserializer); err == nil {
+		obj.Field0 = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializePruneData(deserializer); err == nil {
+		obj.Field1 = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
 type Message__Ping struct {
 	Value Ping
 }
@@ -139,23 +2232,103 @@ func load_Message__Pong(deserializer serde.Deserializer) (Message__Pong, error)
 	return obj, nil
 }
 
+type NodeInstance struct {
+	From      Pubkey
+	Wallclock uint64
+	Timestamp uint64
+	Token     uint64
+}
+
+func (obj *NodeInstance) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := obj.From.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Wallclock); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Timestamp); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Token); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *NodeInstance) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeNodeInstance(deserializer serde.Deserializer) (NodeInstance, error) {
+	var obj NodeInstance
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializePubkey(deserializer); err == nil {
+		obj.From = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Wallclock = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Timestamp = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Token = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializeNodeInstance(input []byte) (NodeInstance, error) {
+	if input == nil {
+		var obj NodeInstance
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeNodeInstance(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
 type Ping struct {
-	From      [32]uint8
-	Token     [32]uint8
-	Signature [64]uint8
+	From      Pubkey
+	Token     Hash
+	Signature Signature
 }
 
 func (obj *Ping) Serialize(serializer serde.Serializer) error {
 	if err := serializer.IncreaseContainerDepth(); err != nil {
 		return err
 	}
-	if err := serialize_array32_u8_array(obj.From, serializer); err != nil {
+	if err := obj.From.Serialize(serializer); err != nil {
 		return err
 	}
-	if err := serialize_array32_u8_array(obj.Token, serializer); err != nil {
+	if err := obj.Token.Serialize(serializer); err != nil {
 		return err
 	}
-	if err := serialize_array64_u8_array(obj.Signature, serializer); err != nil {
+	if err := obj.Signature.Serialize(serializer); err != nil {
 		return err
 	}
 	serializer.DecreaseContainerDepth()
@@ -178,17 +2351,17 @@ func DeserializePing(deserializer serde.Deserializer) (Ping, error) {
 	if err := deserializer.IncreaseContainerDepth(); err != nil {
 		return obj, err
 	}
-	if val, err := deserialize_array32_u8_array(deserializer); err == nil {
+	if val, err := DeserializePubkey(deserializer); err == nil {
 		obj.From = val
 	} else {
 		return obj, err
 	}
-	if val, err := deserialize_array32_u8_array(deserializer); err == nil {
+	if val, err := DeserializeHash(deserializer); err == nil {
 		obj.Token = val
 	} else {
 		return obj, err
 	}
-	if val, err := deserialize_array64_u8_array(deserializer); err == nil {
+	if val, err := DeserializeSignature(deserializer); err == nil {
 		obj.Signature = val
 	} else {
 		return obj, err
@@ -209,6 +2382,807 @@ func BincodeDeserializePing(input []byte) (Ping, error) {
 	}
 	return obj, err
 }
+
+type PruneData struct {
+	Pubkey      Pubkey
+	Prunes      []Pubkey
+	Signature   Signature
+	Destination Pubkey
+	Wallclock   uint64
+}
+
+func (obj *PruneData) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := obj.Pubkey.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := serialize_vector_Pubkey(obj.Prunes, serializer); err != nil {
+		return err
+	}
+	if err := obj.Signature.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := obj.Destination.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Wallclock); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *PruneData) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializePruneData(deserializer serde.Deserializer) (PruneData, error) {
+	var obj PruneData
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializePubkey(deserializer); err == nil {
+		obj.Pubkey = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserialize_vector_Pubkey(deserializer); err == nil {
+		obj.Prunes = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeSignature(deserializer); err == nil {
+		obj.Signature = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializePubkey(deserializer); err == nil {
+		obj.Destination = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Wallclock = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializePruneData(input []byte) (PruneData, error) {
+	if input == nil {
+		var obj PruneData
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializePruneData(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type Pubkey [32]uint8
+
+func (obj *Pubkey) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := serialize_array32_u8_array((([32]uint8)(*obj)), serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *Pubkey) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializePubkey(deserializer serde.Deserializer) (Pubkey, error) {
+	var obj [32]uint8
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return (Pubkey)(obj), err
+	}
+	if val, err := deserialize_array32_u8_array(deserializer); err == nil {
+		obj = val
+	} else {
+		return ((Pubkey)(obj)), err
+	}
+	deserializer.DecreaseContainerDepth()
+	return (Pubkey)(obj), nil
+}
+
+func BincodeDeserializePubkey(input []byte) (Pubkey, error) {
+	if input == nil {
+		var obj Pubkey
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializePubkey(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type Signature [64]uint8
+
+func (obj *Signature) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := serialize_array64_u8_array((([64]uint8)(*obj)), serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *Signature) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeSignature(deserializer serde.Deserializer) (Signature, error) {
+	var obj [64]uint8
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return (Signature)(obj), err
+	}
+	if val, err := deserialize_array64_u8_array(deserializer); err == nil {
+		obj = val
+	} else {
+		return ((Signature)(obj)), err
+	}
+	deserializer.DecreaseContainerDepth()
+	return (Signature)(obj), nil
+}
+
+func BincodeDeserializeSignature(input []byte) (Signature, error) {
+	if input == nil {
+		var obj Signature
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeSignature(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type SlotHash struct {
+	Slot uint64
+	Hash Hash
+}
+
+func (obj *SlotHash) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Slot); err != nil {
+		return err
+	}
+	if err := obj.Hash.Serialize(serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *SlotHash) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeSlotHash(deserializer serde.Deserializer) (SlotHash, error) {
+	var obj SlotHash
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Slot = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeHash(deserializer); err == nil {
+		obj.Hash = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializeSlotHash(input []byte) (SlotHash, error) {
+	if input == nil {
+		var obj SlotHash
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeSlotHash(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type SlotsFlate2 struct {
+	FirstSlot  uint64
+	Num        uint64
+	Compressed []uint8
+}
+
+func (obj *SlotsFlate2) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.FirstSlot); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Num); err != nil {
+		return err
+	}
+	if err := serialize_vector_u8(obj.Compressed, serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *SlotsFlate2) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeSlotsFlate2(deserializer serde.Deserializer) (SlotsFlate2, error) {
+	var obj SlotsFlate2
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.FirstSlot = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Num = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserialize_vector_u8(deserializer); err == nil {
+		obj.Compressed = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializeSlotsFlate2(input []byte) (SlotsFlate2, error) {
+	if input == nil {
+		var obj SlotsFlate2
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeSlotsFlate2(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type SlotsUncompressed struct {
+	FirstSlot uint64
+	Num       uint64
+	Slots     BitVecU8
+}
+
+func (obj *SlotsUncompressed) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.FirstSlot); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Num); err != nil {
+		return err
+	}
+	if err := obj.Slots.Serialize(serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *SlotsUncompressed) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeSlotsUncompressed(deserializer serde.Deserializer) (SlotsUncompressed, error) {
+	var obj SlotsUncompressed
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.FirstSlot = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Num = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeBitVecU8(deserializer); err == nil {
+		obj.Slots = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializeSlotsUncompressed(input []byte) (SlotsUncompressed, error) {
+	if input == nil {
+		var obj SlotsUncompressed
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeSlotsUncompressed(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type SnapshotHashes struct {
+	From      Pubkey
+	Hashes    []SlotHash
+	Wallclock uint64
+}
+
+func (obj *SnapshotHashes) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := obj.From.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := serialize_vector_SlotHash(obj.Hashes, serializer); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Wallclock); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *SnapshotHashes) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeSnapshotHashes(deserializer serde.Deserializer) (SnapshotHashes, error) {
+	var obj SnapshotHashes
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializePubkey(deserializer); err == nil {
+		obj.From = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserialize_vector_SlotHash(deserializer); err == nil {
+		obj.Hashes = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Wallclock = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializeSnapshotHashes(input []byte) (SnapshotHashes, error) {
+	if input == nil {
+		var obj SnapshotHashes
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeSnapshotHashes(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type SocketAddr interface {
+	isSocketAddr()
+	Serialize(serializer serde.Serializer) error
+	BincodeSerialize() ([]byte, error)
+}
+
+func DeserializeSocketAddr(deserializer serde.Deserializer) (SocketAddr, error) {
+	index, err := deserializer.DeserializeVariantIndex()
+	if err != nil {
+		return nil, err
+	}
+
+	switch index {
+	case 0:
+		if val, err := load_SocketAddr__V4(deserializer); err == nil {
+			return &val, nil
+		} else {
+			return nil, err
+		}
+
+	case 1:
+		if val, err := load_SocketAddr__V6(deserializer); err == nil {
+			return &val, nil
+		} else {
+			return nil, err
+		}
+
+	default:
+		return nil, fmt.Errorf("Unknown variant index for SocketAddr: %d", index)
+	}
+}
+
+func BincodeDeserializeSocketAddr(input []byte) (SocketAddr, error) {
+	if input == nil {
+		var obj SocketAddr
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeSocketAddr(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type SocketAddr__V4 [4]uint8
+
+func (*SocketAddr__V4) isSocketAddr() {}
+
+func (obj *SocketAddr__V4) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	serializer.SerializeVariantIndex(0)
+	if err := serialize_array4_u8_array((([4]uint8)(*obj)), serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *SocketAddr__V4) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func load_SocketAddr__V4(deserializer serde.Deserializer) (SocketAddr__V4, error) {
+	var obj [4]uint8
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return (SocketAddr__V4)(obj), err
+	}
+	if val, err := deserialize_array4_u8_array(deserializer); err == nil {
+		obj = val
+	} else {
+		return ((SocketAddr__V4)(obj)), err
+	}
+	deserializer.DecreaseContainerDepth()
+	return (SocketAddr__V4)(obj), nil
+}
+
+type SocketAddr__V6 [16]uint8
+
+func (*SocketAddr__V6) isSocketAddr() {}
+
+func (obj *SocketAddr__V6) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	serializer.SerializeVariantIndex(1)
+	if err := serialize_array16_u8_array((([16]uint8)(*obj)), serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *SocketAddr__V6) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func load_SocketAddr__V6(deserializer serde.Deserializer) (SocketAddr__V6, error) {
+	var obj [16]uint8
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return (SocketAddr__V6)(obj), err
+	}
+	if val, err := deserialize_array16_u8_array(deserializer); err == nil {
+		obj = val
+	} else {
+		return ((SocketAddr__V6)(obj)), err
+	}
+	deserializer.DecreaseContainerDepth()
+	return (SocketAddr__V6)(obj), nil
+}
+
+type Version struct {
+	From       Pubkey
+	Wallclock  uint64
+	Major      uint16
+	Minor      uint16
+	Patch      uint16
+	Commit     *uint32
+	FeatureSet uint32
+}
+
+func (obj *Version) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := obj.From.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Wallclock); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU16(obj.Major); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU16(obj.Minor); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU16(obj.Patch); err != nil {
+		return err
+	}
+	if err := serialize_option_u32(obj.Commit, serializer); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU32(obj.FeatureSet); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *Version) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeVersion(deserializer serde.Deserializer) (Version, error) {
+	var obj Version
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializePubkey(deserializer); err == nil {
+		obj.From = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Wallclock = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU16(); err == nil {
+		obj.Major = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU16(); err == nil {
+		obj.Minor = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU16(); err == nil {
+		obj.Patch = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserialize_option_u32(deserializer); err == nil {
+		obj.Commit = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU32(); err == nil {
+		obj.FeatureSet = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializeVersion(input []byte) (Version, error) {
+	if input == nil {
+		var obj Version
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeVersion(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+
+type Vote struct {
+	From        Pubkey
+	Transaction Transaction
+	Wallclock   uint64
+	Slot        *uint64
+}
+
+func (obj *Vote) Serialize(serializer serde.Serializer) error {
+	if err := serializer.IncreaseContainerDepth(); err != nil {
+		return err
+	}
+	if err := obj.From.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := obj.Transaction.Serialize(serializer); err != nil {
+		return err
+	}
+	if err := serializer.SerializeU64(obj.Wallclock); err != nil {
+		return err
+	}
+	if err := serialize_option_u64(obj.Slot, serializer); err != nil {
+		return err
+	}
+	serializer.DecreaseContainerDepth()
+	return nil
+}
+
+func (obj *Vote) BincodeSerialize() ([]byte, error) {
+	if obj == nil {
+		return nil, fmt.Errorf("Cannot serialize null object")
+	}
+	serializer := bincode.NewSerializer()
+	if err := obj.Serialize(serializer); err != nil {
+		return nil, err
+	}
+	return serializer.GetBytes(), nil
+}
+
+func DeserializeVote(deserializer serde.Deserializer) (Vote, error) {
+	var obj Vote
+	if err := deserializer.IncreaseContainerDepth(); err != nil {
+		return obj, err
+	}
+	if val, err := DeserializePubkey(deserializer); err == nil {
+		obj.From = val
+	} else {
+		return obj, err
+	}
+	if val, err := DeserializeTransaction(deserializer); err == nil {
+		obj.Transaction = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserializer.DeserializeU64(); err == nil {
+		obj.Wallclock = val
+	} else {
+		return obj, err
+	}
+	if val, err := deserialize_option_u64(deserializer); err == nil {
+		obj.Slot = val
+	} else {
+		return obj, err
+	}
+	deserializer.DecreaseContainerDepth()
+	return obj, nil
+}
+
+func BincodeDeserializeVote(input []byte) (Vote, error) {
+	if input == nil {
+		var obj Vote
+		return obj, fmt.Errorf("Cannot deserialize null array")
+	}
+	deserializer := bincode.NewDeserializer(input)
+	obj, err := DeserializeVote(deserializer)
+	if err == nil && deserializer.GetBufferOffset() < uint64(len(input)) {
+		return obj, fmt.Errorf("Some input bytes were not read")
+	}
+	return obj, err
+}
+func serialize_array16_u8_array(value [16]uint8, serializer serde.Serializer) error {
+	for _, item := range value {
+		if err := serializer.SerializeU8(item); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func deserialize_array16_u8_array(deserializer serde.Deserializer) ([16]uint8, error) {
+	var obj [16]uint8
+	for i := range obj {
+		if val, err := deserializer.DeserializeU8(); err == nil {
+			obj[i] = val
+		} else {
+			return obj, err
+		}
+	}
+	return obj, nil
+}
+
 func serialize_array32_u8_array(value [32]uint8, serializer serde.Serializer) error {
 	for _, item := range value {
 		if err := serializer.SerializeU8(item); err != nil {
@@ -230,6 +3204,27 @@ func deserialize_array32_u8_array(deserializer serde.Deserializer) ([32]uint8, e
 	return obj, nil
 }
 
+func serialize_array4_u8_array(value [4]uint8, serializer serde.Serializer) error {
+	for _, item := range value {
+		if err := serializer.SerializeU8(item); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func deserialize_array4_u8_array(deserializer serde.Deserializer) ([4]uint8, error) {
+	var obj [4]uint8
+	for i := range obj {
+		if val, err := deserializer.DeserializeU8(); err == nil {
+			obj[i] = val
+		} else {
+			return obj, err
+		}
+	}
+	return obj, nil
+}
+
 func serialize_array64_u8_array(value [64]uint8, serializer serde.Serializer) error {
 	for _, item := range value {
 		if err := serializer.SerializeU8(item); err != nil {
@@ -250,3 +3245,301 @@ func deserialize_array64_u8_array(deserializer serde.Deserializer) ([64]uint8, e
 	}
 	return obj, nil
 }
+
+func serialize_option_u32(value *uint32, serializer serde.Serializer) error {
+	if value != nil {
+		if err := serializer.SerializeOptionTag(true); err != nil {
+			return err
+		}
+		if err := serializer.SerializeU32((*value)); err != nil {
+			return err
+		}
+	} else {
+		if err := serializer.SerializeOptionTag(false); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func deserialize_option_u32(deserializer serde.Deserializer) (*uint32, error) {
+	tag, err := deserializer.DeserializeOptionTag()
+	if err != nil {
+		return nil, err
+	}
+	if tag {
+		value := new(uint32)
+		if val, err := deserializer.DeserializeU32(); err == nil {
+			*value = val
+		} else {
+			return nil, err
+		}
+		return value, nil
+	} else {
+		return nil, nil
+	}
+}
+
+func serialize_option_u64(value *uint64, serializer serde.Serializer) error {
+	if value != nil {
+		if err := serializer.SerializeOptionTag(true); err != nil {
+			return err
+		}
+		if err := serializer.SerializeU64((*value)); err != nil {
+			return err
+		}
+	} else {
+		if err := serializer.SerializeOptionTag(false); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func deserialize_option_u64(deserializer serde.Deserializer) (*uint64, error) {
+	tag, err := deserializer.DeserializeOptionTag()
+	if err != nil {
+		return nil, err
+	}
+	if tag {
+		value := new(uint64)
+		if val, err := deserializer.DeserializeU64(); err == nil {
+			*value = val
+		} else {
+			return nil, err
+		}
+		return value, nil
+	} else {
+		return nil, nil
+	}
+}
+
+func serialize_option_vector_u8(value *[]uint8, serializer serde.Serializer) error {
+	if value != nil {
+		if err := serializer.SerializeOptionTag(true); err != nil {
+			return err
+		}
+		if err := serialize_vector_u8((*value), serializer); err != nil {
+			return err
+		}
+	} else {
+		if err := serializer.SerializeOptionTag(false); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func deserialize_option_vector_u8(deserializer serde.Deserializer) (*[]uint8, error) {
+	tag, err := deserializer.DeserializeOptionTag()
+	if err != nil {
+		return nil, err
+	}
+	if tag {
+		value := new([]uint8)
+		if val, err := deserialize_vector_u8(deserializer); err == nil {
+			*value = val
+		} else {
+			return nil, err
+		}
+		return value, nil
+	} else {
+		return nil, nil
+	}
+}
+
+func serialize_vector_CompressedSlots(value []CompressedSlots, serializer serde.Serializer) error {
+	if err := serializer.SerializeLen(uint64(len(value))); err != nil {
+		return err
+	}
+	for _, item := range value {
+		if err := item.Serialize(serializer); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func deserialize_vector_CompressedSlots(deserializer serde.Deserializer) ([]CompressedSlots, error) {
+	length, err := deserializer.DeserializeLen()
+	if err != nil {
+		return nil, err
+	}
+	obj := make([]CompressedSlots, length)
+	for i := range obj {
+		if val, err := DeserializeCompressedSlots(deserializer); err == nil {
+			obj[i] = val
+		} else {
+			return nil, err
+		}
+	}
+	return obj, nil
+}
+
+func serialize_vector_CrdsValue(value []CrdsValue, serializer serde.Serializer) error {
+	if err := serializer.SerializeLen(uint64(len(value))); err != nil {
+		return err
+	}
+	for _, item := range value {
+		if err := item.Serialize(serializer); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func deserialize_vector_CrdsValue(deserializer serde.Deserializer) ([]CrdsValue, error) {
+	length, err := deserializer.DeserializeLen()
+	if err != nil {
+		return nil, err
+	}
+	obj := make([]CrdsValue, length)
+	for i := range obj {
+		if val, err := DeserializeCrdsValue(deserializer); err == nil {
+			obj[i] = val
+		} else {
+			return nil, err
+		}
+	}
+	return obj, nil
+}
+
+func serialize_vector_Pubkey(value []Pubkey, serializer serde.Serializer) error {
+	if err := serializer.SerializeLen(uint64(len(value))); err != nil {
+		return err
+	}
+	for _, item := range value {
+		if err := item.Serialize(serializer); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func deserialize_vector_Pubkey(deserializer serde.Deserializer) ([]Pubkey, error) {
+	length, err := deserializer.DeserializeLen()
+	if err != nil {
+		return nil, err
+	}
+	obj := make([]Pubkey, length)
+	for i := range obj {
+		if val, err := DeserializePubkey(deserializer); err == nil {
+			obj[i] = val
+		} else {
+			return nil, err
+		}
+	}
+	return obj, nil
+}
+
+func serialize_vector_SlotHash(value []SlotHash, serializer serde.Serializer) error {
+	if err := serializer.SerializeLen(uint64(len(value))); err != nil {
+		return err
+	}
+	for _, item := range value {
+		if err := item.Serialize(serializer); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func deserialize_vector_SlotHash(deserializer serde.Deserializer) ([]SlotHash, error) {
+	length, err := deserializer.DeserializeLen()
+	if err != nil {
+		return nil, err
+	}
+	obj := make([]SlotHash, length)
+	for i := range obj {
+		if val, err := DeserializeSlotHash(deserializer); err == nil {
+			obj[i] = val
+		} else {
+			return nil, err
+		}
+	}
+	return obj, nil
+}
+
+func serialize_vector_u64(value []uint64, serializer serde.Serializer) error {
+	if err := serializer.SerializeLen(uint64(len(value))); err != nil {
+		return err
+	}
+	for _, item := range value {
+		if err := serializer.SerializeU64(item); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func deserialize_vector_u64(deserializer serde.Deserializer) ([]uint64, error) {
+	length, err := deserializer.DeserializeLen()
+	if err != nil {
+		return nil, err
+	}
+	obj := make([]uint64, length)
+	for i := range obj {
+		if val, err := deserializer.DeserializeU64(); err == nil {
+			obj[i] = val
+		} else {
+			return nil, err
+		}
+	}
+	return obj, nil
+}
+
+func serialize_vector_u8(value []uint8, serializer serde.Serializer) error {
+	if err := serializer.SerializeLen(uint64(len(value))); err != nil {
+		return err
+	}
+	for _, item := range value {
+		if err := serializer.SerializeU8(item); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func deserialize_vector_u8(deserializer serde.Deserializer) ([]uint8, error) {
+	length, err := deserializer.DeserializeLen()
+	if err != nil {
+		return nil, err
+	}
+	obj := make([]uint8, length)
+	for i := range obj {
+		if val, err := deserializer.DeserializeU8(); err == nil {
+			obj[i] = val
+		} else {
+			return nil, err
+		}
+	}
+	return obj, nil
+}
+
+func serialize_vector_unit(value []struct{}, serializer serde.Serializer) error {
+	if err := serializer.SerializeLen(uint64(len(value))); err != nil {
+		return err
+	}
+	for _, item := range value {
+		if err := serializer.SerializeUnit(item); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func deserialize_vector_unit(deserializer serde.Deserializer) ([]struct{}, error) {
+	length, err := deserializer.DeserializeLen()
+	if err != nil {
+		return nil, err
+	}
+	obj := make([]struct{}, length)
+	for i := range obj {
+		if val, err := deserializer.DeserializeUnit(); err == nil {
+			obj[i] = val
+		} else {
+			return nil, err
+		}
+	}
+	return obj, nil
+}
diff --git a/pkg/gossip/schema.yaml b/pkg/gossip/schema.yaml
index 2aad913..5949f92 100644
--- a/pkg/gossip/schema.yaml
+++ b/pkg/gossip/schema.yaml
@@ -1,6 +1,64 @@
 ---
+# ------------------------
+# Basic types
+# ------------------------
+Pubkey:
+  NEWTYPESTRUCT:
+    TUPLEARRAY:
+      CONTENT: U8
+      SIZE: 32
+Hash:
+  NEWTYPESTRUCT:
+    TUPLEARRAY:
+      CONTENT: U8
+      SIZE: 32
+Signature:
+  NEWTYPESTRUCT:
+    TUPLEARRAY:
+      CONTENT: U8
+      SIZE: 64
+SocketAddr:
+  ENUM:
+    0:
+      V4:
+        NEWTYPE:
+          TUPLEARRAY:
+            CONTENT: U8
+            SIZE: 4
+    1:
+      V6:
+        NEWTYPE:
+          TUPLEARRAY:
+            CONTENT: U8
+            SIZE: 16
+
+# ------------------------
+# Message Enum
+# ------------------------
 Message:
   ENUM:
+    0:
+      PullRequest:
+        TUPLE:
+          - TYPENAME: CrdsFilter
+          - TYPENAME: CrdsValue
+    1:
+      PullResponse:
+        TUPLE:
+          - TYPENAME: Pubkey
+          - SEQ:
+              TYPENAME: CrdsValue
+    2:
+      PushMessage:
+        TUPLE:
+          - TYPENAME: Pubkey
+          - SEQ:
+              TYPENAME: CrdsValue
+    3:
+      PruneMessage:
+        TUPLE:
+          - TYPENAME: Pubkey
+          - TYPENAME: PruneData
     4:
       Ping:
         NEWTYPE:
@@ -9,17 +67,265 @@ Message:
       Pong:
         NEWTYPE:
           TYPENAME: Ping
+
+# ------------------------
+# CRDS
+# ------------------------
+CrdsData:
+  ENUM:
+    0:
+      ContactInfo:
+        NEWTYPE:
+          TYPENAME: ContactInfo
+    1:
+      Vote:
+        TUPLE:
+          - U8
+          - TYPENAME: Vote
+    2:
+      LowestSlot:
+        TUPLE:
+          - U8
+          - TYPENAME: LowestSlot
+    3:
+      SnapshotHashes:
+        NEWTYPE:
+          TYPENAME: SnapshotHashes
+    4:
+      AccountsHashes:
+        NEWTYPE:
+          TYPENAME: SnapshotHashes
+    5:
+      EpochSlots:
+        TUPLE:
+          - U8
+          - TYPENAME: EpochSlots
+    6:
+      LegacyVersion:
+        NEWTYPE:
+          TYPENAME: LegacyVersion
+    7:
+      Version:
+        NEWTYPE:
+          TYPENAME: Version
+    8:
+      NodeInstance:
+        NEWTYPE:
+          TYPENAME: NodeInstance
+    9:
+      DuplicateShred:
+        TUPLE:
+          - U16
+          - TYPENAME: DuplicateShred
+    10:
+      IncrementalSnapshotHashes:
+        NEWTYPE:
+          TYPENAME: IncrementalSnapshotHashes
+
+# ------------------------
+# Auxiliary stuff
+# ------------------------
+BitVecU8:
+  STRUCT:
+    - bits:
+        TYPENAME: BitVecU8Inner
+    - len: U64
+BitVecU8Inner:
+  NEWTYPESTRUCT:
+    OPTION:
+      SEQ: U8
+BitVecU64:
+  STRUCT:
+    - bits:
+        TYPENAME: BitVecU64Inner
+    - len: U64
+BitVecU64Inner:
+  NEWTYPESTRUCT:
+    OPTION:
+      SEQ: U8
+
+# ------------------------
+# CRDTs
+# ------------------------
+ContactInfo:
+  STRUCT:
+    - id:
+        TYPENAME: Pubkey
+    - gossip:
+        TYPENAME: SocketAddr
+    - tvu:
+        TYPENAME: SocketAddr
+    - tvu_forwards:
+        TYPENAME: SocketAddr
+    - repair:
+        TYPENAME: SocketAddr
+    - tpu:
+        TYPENAME: SocketAddr
+    - tpu_forwards:
+        TYPENAME: SocketAddr
+    - tpu_vote:
+        TYPENAME: SocketAddr
+    - rpc:
+        TYPENAME: SocketAddr
+    - rpc_pubsub:
+        TYPENAME: SocketAddr
+    - serve_repair:
+        TYPENAME: SocketAddr
+    - wallclock: U64
+    - shred_version: U16
+CompressedSlots:
+  ENUM:
+    0:
+      Flate2:
+        NEWTYPE:
+          TYPENAME: SlotsFlate2
+    1:
+      Uncompressed:
+        NEWTYPE:
+          TYPENAME: SlotsUncompressed
+DuplicateShred:
+  STRUCT:
+    - from:
+        TYPENAME: Pubkey
+    - wallclock: U64
+    - slot: U64
+    - shred_index: U32
+    - shred_type: U8
+    - num_chunks: U8
+    - chunk_index: U8
+    - chunk:
+        SEQ: U8
+EpochSlots:
+  STRUCT:
+    - from:
+        TYPENAME: Pubkey
+    - slots:
+        SEQ:
+          TYPENAME: CompressedSlots
+    - wallclock: U64
+IncrementalSnapshotHashes:
+  STRUCT:
+    - from:
+        TYPENAME: Pubkey
+    - base:
+        TYPENAME: SlotHash
+    - hashes:
+        SEQ:
+          TYPENAME: SlotHash
+    - wallclock: U64
+NodeInstance:
+  STRUCT:
+    - from:
+        TYPENAME: Pubkey
+    - wallclock: U64
+    - timestamp: U64
+    - token: U64
+SlotHash:
+  STRUCT:
+    - slot: U64
+    - hash:
+        TYPENAME: Hash
+SlotsFlate2:
+  STRUCT:
+    - first_slot: U64
+    - num: U64
+    - compressed:
+        SEQ: U8
+SlotsUncompressed:
+  STRUCT:
+    - first_slot: U64
+    - num: U64
+    - slots:
+        TYPENAME: BitVecU8
+LegacyVersion:
+  STRUCT:
+    - from:
+        TYPENAME: Pubkey
+    - wallclock: U64
+    - major: U16
+    - minor: U16
+    - patch: U16
+    - commit:
+        OPTION: U32
+LowestSlot:
+  STRUCT:
+    - from:
+        TYPENAME: Pubkey
+    - root: U64
+    - lowest: U64
+    - slots:
+        SEQ: U64
+    - stash:
+        SEQ: UNIT
+    - wallclock: U64
+SnapshotHashes:
+  STRUCT:
+    - from:
+        TYPENAME: Pubkey
+    - hashes:
+        SEQ:
+          TYPENAME: SlotHash
+    - wallclock: U64
+Version:
+  STRUCT:
+    - from:
+        TYPENAME: Pubkey
+    - wallclock: U64
+    - major: U16
+    - minor: U16
+    - patch: U16
+    - commit:
+        OPTION: U32
+    - feature_set: U32
+Vote:
+  STRUCT:
+    - from:
+        TYPENAME: Pubkey
+    - transaction:
+        TYPENAME: Transaction
+    - wallclock: U64
+    - slot:
+        OPTION: U64
+
+# ------------------------
+# Message Types
+# ------------------------
+Bloom:
+  STRUCT:
+    - keys:
+        SEQ: U64
+    - bits:
+        TYPENAME: BitVecU64
+    - num_bits_set: U64
+CrdsFilter:
+  STRUCT:
+    - filter:
+        TYPENAME: Bloom
+    - mask: U64
+    - mask_bits: U32
+CrdsValue:
+  STRUCT:
+    - signature:
+        TYPENAME: Signature
+    - data:
+        TYPENAME: CrdsData
+PruneData:
+  STRUCT:
+    - pubkey:
+        TYPENAME: Pubkey
+    - prunes:
+        SEQ:
+          TYPENAME: Pubkey
+    - signature:
+        TYPENAME: Signature
+    - destination:
+        TYPENAME: Pubkey
+    - wallclock: U64
 Ping:
   STRUCT:
     - from:
-        TUPLEARRAY:
-          CONTENT: U8
-          SIZE: 32
+        TYPENAME: Pubkey
     - token:
-        TUPLEARRAY:
-          CONTENT: U8
-          SIZE: 32
+        TYPENAME: Hash
     - signature:
-        TUPLEARRAY:
-          CONTENT: U8
-          SIZE: 64
+        TYPENAME: Signature
diff --git a/pkg/gossip/transaction.go b/pkg/gossip/transaction.go
new file mode 100644
index 0000000..5a1a378
--- /dev/null
+++ b/pkg/gossip/transaction.go
@@ -0,0 +1,16 @@
+package gossip
+
+import (
+	"github.com/gagliardetto/solana-go"
+	"github.com/novifinancial/serde-reflection/serde-generate/runtime/golang/serde"
+)
+
+type Transaction solana.Transaction
+
+func DeserializeTransaction(deserializer serde.Deserializer) (Transaction, error) {
+	panic("not implemented")
+}
+
+func (obj *Transaction) Serialize(serializer serde.Serializer) error {
+	panic("not implemented")
+}