types_cbor_gen.go

// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.

package retrievalmarket

import (
	"fmt"
	"io"
	"math"
	"sort"

	datatransfer "github.com/filecoin-project/go-data-transfer/v2"
	piecestore "github.com/filecoin-project/go-fil-markets/piecestore"
	paych "github.com/filecoin-project/go-state-types/builtin/v8/paych"
	cid "github.com/ipfs/go-cid"
	peer "github.com/libp2p/go-libp2p/core/peer"
	cbg "github.com/whyrusleeping/cbor-gen"
	xerrors "golang.org/x/xerrors"
)

var _ = xerrors.Errorf
var _ = cid.Undef
var _ = math.E
var _ = sort.Sort

func (t *Query) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{162}); err != nil {
		return err
	}

	// t.PayloadCID (cid.Cid) (struct)
	if len("PayloadCID") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"PayloadCID\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PayloadCID"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("PayloadCID")); err != nil {
		return err
	}

	if err := cbg.WriteCid(cw, t.PayloadCID); err != nil {
		return xerrors.Errorf("failed to write cid field t.PayloadCID: %w", err)
	}

	// t.QueryParams (retrievalmarket.QueryParams) (struct)
	if len("QueryParams") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"QueryParams\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("QueryParams"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("QueryParams")); err != nil {
		return err
	}

	if err := t.QueryParams.MarshalCBOR(cw); err != nil {
		return err
	}
	return nil
}

func (t *Query) UnmarshalCBOR(r io.Reader) (err error) {
	*t = Query{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("Query: map struct too large (%d)", extra)
	}

	var name string
	n := extra

	for i := uint64(0); i < n; i++ {

		{
			sval, err := cbg.ReadString(cr)
			if err != nil {
				return err
			}

			name = string(sval)
		}

		switch name {
		// t.PayloadCID (cid.Cid) (struct)
		case "PayloadCID":

			{

				c, err := cbg.ReadCid(cr)
				if err != nil {
					return xerrors.Errorf("failed to read cid field t.PayloadCID: %w", err)
				}

				t.PayloadCID = c

			}
			// t.QueryParams (retrievalmarket.QueryParams) (struct)
		case "QueryParams":

			{

				if err := t.QueryParams.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.QueryParams: %w", err)
				}

			}

		default:
			// Field doesn't exist on this type, so ignore it
			cbg.ScanForLinks(r, func(cid.Cid) {})
		}
	}

	return nil
}
func (t *QueryResponse) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{169}); err != nil {
		return err
	}

	// t.Size (uint64) (uint64)
	if len("Size") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Size\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Size"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Size")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil {
		return err
	}

	// t.Status (retrievalmarket.QueryResponseStatus) (uint64)
	if len("Status") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Status\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Status"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Status")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Status)); err != nil {
		return err
	}

	// t.Message (string) (string)
	if len("Message") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Message\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Message"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Message")); err != nil {
		return err
	}

	if len(t.Message) > cbg.MaxLength {
		return xerrors.Errorf("Value in field t.Message was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Message))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string(t.Message)); err != nil {
		return err
	}

	// t.UnsealPrice (big.Int) (struct)
	if len("UnsealPrice") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"UnsealPrice\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("UnsealPrice"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("UnsealPrice")); err != nil {
		return err
	}

	if err := t.UnsealPrice.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.PieceCIDFound (retrievalmarket.QueryItemStatus) (uint64)
	if len("PieceCIDFound") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"PieceCIDFound\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PieceCIDFound"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("PieceCIDFound")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.PieceCIDFound)); err != nil {
		return err
	}

	// t.PaymentAddress (address.Address) (struct)
	if len("PaymentAddress") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"PaymentAddress\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PaymentAddress"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("PaymentAddress")); err != nil {
		return err
	}

	if err := t.PaymentAddress.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.MinPricePerByte (big.Int) (struct)
	if len("MinPricePerByte") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"MinPricePerByte\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("MinPricePerByte"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("MinPricePerByte")); err != nil {
		return err
	}

	if err := t.MinPricePerByte.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.MaxPaymentInterval (uint64) (uint64)
	if len("MaxPaymentInterval") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"MaxPaymentInterval\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("MaxPaymentInterval"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("MaxPaymentInterval")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.MaxPaymentInterval)); err != nil {
		return err
	}

	// t.MaxPaymentIntervalIncrease (uint64) (uint64)
	if len("MaxPaymentIntervalIncrease") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"MaxPaymentIntervalIncrease\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("MaxPaymentIntervalIncrease"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("MaxPaymentIntervalIncrease")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.MaxPaymentIntervalIncrease)); err != nil {
		return err
	}

	return nil
}

func (t *QueryResponse) UnmarshalCBOR(r io.Reader) (err error) {
	*t = QueryResponse{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("QueryResponse: map struct too large (%d)", extra)
	}

	var name string
	n := extra

	for i := uint64(0); i < n; i++ {

		{
			sval, err := cbg.ReadString(cr)
			if err != nil {
				return err
			}

			name = string(sval)
		}

		switch name {
		// t.Size (uint64) (uint64)
		case "Size":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.Size = uint64(extra)

			}
			// t.Status (retrievalmarket.QueryResponseStatus) (uint64)
		case "Status":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.Status = QueryResponseStatus(extra)

			}
			// t.Message (string) (string)
		case "Message":

			{
				sval, err := cbg.ReadString(cr)
				if err != nil {
					return err
				}

				t.Message = string(sval)
			}
			// t.UnsealPrice (big.Int) (struct)
		case "UnsealPrice":

			{

				if err := t.UnsealPrice.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.UnsealPrice: %w", err)
				}

			}
			// t.PieceCIDFound (retrievalmarket.QueryItemStatus) (uint64)
		case "PieceCIDFound":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.PieceCIDFound = QueryItemStatus(extra)

			}
			// t.PaymentAddress (address.Address) (struct)
		case "PaymentAddress":

			{

				if err := t.PaymentAddress.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.PaymentAddress: %w", err)
				}

			}
			// t.MinPricePerByte (big.Int) (struct)
		case "MinPricePerByte":

			{

				if err := t.MinPricePerByte.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.MinPricePerByte: %w", err)
				}

			}
			// t.MaxPaymentInterval (uint64) (uint64)
		case "MaxPaymentInterval":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.MaxPaymentInterval = uint64(extra)

			}
			// t.MaxPaymentIntervalIncrease (uint64) (uint64)
		case "MaxPaymentIntervalIncrease":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.MaxPaymentIntervalIncrease = uint64(extra)

			}

		default:
			// Field doesn't exist on this type, so ignore it
			cbg.ScanForLinks(r, func(cid.Cid) {})
		}
	}

	return nil
}
func (t *DealProposal) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{163}); err != nil {
		return err
	}

	// t.ID (retrievalmarket.DealID) (uint64)
	if len("ID") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"ID\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ID"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("ID")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.ID)); err != nil {
		return err
	}

	// t.Params (retrievalmarket.Params) (struct)
	if len("Params") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Params\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Params"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Params")); err != nil {
		return err
	}

	if err := t.Params.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.PayloadCID (cid.Cid) (struct)
	if len("PayloadCID") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"PayloadCID\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PayloadCID"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("PayloadCID")); err != nil {
		return err
	}

	if err := cbg.WriteCid(cw, t.PayloadCID); err != nil {
		return xerrors.Errorf("failed to write cid field t.PayloadCID: %w", err)
	}

	return nil
}

func (t *DealProposal) UnmarshalCBOR(r io.Reader) (err error) {
	*t = DealProposal{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("DealProposal: map struct too large (%d)", extra)
	}

	var name string
	n := extra

	for i := uint64(0); i < n; i++ {

		{
			sval, err := cbg.ReadString(cr)
			if err != nil {
				return err
			}

			name = string(sval)
		}

		switch name {
		// t.ID (retrievalmarket.DealID) (uint64)
		case "ID":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.ID = DealID(extra)

			}
			// t.Params (retrievalmarket.Params) (struct)
		case "Params":

			{

				if err := t.Params.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.Params: %w", err)
				}

			}
			// t.PayloadCID (cid.Cid) (struct)
		case "PayloadCID":

			{

				c, err := cbg.ReadCid(cr)
				if err != nil {
					return xerrors.Errorf("failed to read cid field t.PayloadCID: %w", err)
				}

				t.PayloadCID = c

			}

		default:
			// Field doesn't exist on this type, so ignore it
			cbg.ScanForLinks(r, func(cid.Cid) {})
		}
	}

	return nil
}
func (t *DealResponse) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{164}); err != nil {
		return err
	}

	// t.ID (retrievalmarket.DealID) (uint64)
	if len("ID") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"ID\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ID"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("ID")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.ID)); err != nil {
		return err
	}

	// t.Status (retrievalmarket.DealStatus) (uint64)
	if len("Status") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Status\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Status"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Status")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Status)); err != nil {
		return err
	}

	// t.Message (string) (string)
	if len("Message") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Message\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Message"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Message")); err != nil {
		return err
	}

	if len(t.Message) > cbg.MaxLength {
		return xerrors.Errorf("Value in field t.Message was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Message))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string(t.Message)); err != nil {
		return err
	}

	// t.PaymentOwed (big.Int) (struct)
	if len("PaymentOwed") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"PaymentOwed\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PaymentOwed"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("PaymentOwed")); err != nil {
		return err
	}

	if err := t.PaymentOwed.MarshalCBOR(cw); err != nil {
		return err
	}
	return nil
}

func (t *DealResponse) UnmarshalCBOR(r io.Reader) (err error) {
	*t = DealResponse{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("DealResponse: map struct too large (%d)", extra)
	}

	var name string
	n := extra

	for i := uint64(0); i < n; i++ {

		{
			sval, err := cbg.ReadString(cr)
			if err != nil {
				return err
			}

			name = string(sval)
		}

		switch name {
		// t.ID (retrievalmarket.DealID) (uint64)
		case "ID":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.ID = DealID(extra)

			}
			// t.Status (retrievalmarket.DealStatus) (uint64)
		case "Status":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.Status = DealStatus(extra)

			}
			// t.Message (string) (string)
		case "Message":

			{
				sval, err := cbg.ReadString(cr)
				if err != nil {
					return err
				}

				t.Message = string(sval)
			}
			// t.PaymentOwed (big.Int) (struct)
		case "PaymentOwed":

			{

				if err := t.PaymentOwed.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.PaymentOwed: %w", err)
				}

			}

		default:
			// Field doesn't exist on this type, so ignore it
			cbg.ScanForLinks(r, func(cid.Cid) {})
		}
	}

	return nil
}
func (t *Params) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{166}); err != nil {
		return err
	}

	// t.PieceCID (cid.Cid) (struct)
	if len("PieceCID") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"PieceCID\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PieceCID"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("PieceCID")); err != nil {
		return err
	}

	if t.PieceCID == nil {
		if _, err := cw.Write(cbg.CborNull); err != nil {
			return err
		}
	} else {
		if err := cbg.WriteCid(cw, *t.PieceCID); err != nil {
			return xerrors.Errorf("failed to write cid field t.PieceCID: %w", err)
		}
	}

	// t.Selector (retrievalmarket.CborGenCompatibleNode) (struct)
	if len("Selector") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Selector\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Selector"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Selector")); err != nil {
		return err
	}

	if err := t.Selector.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.UnsealPrice (big.Int) (struct)
	if len("UnsealPrice") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"UnsealPrice\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("UnsealPrice"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("UnsealPrice")); err != nil {
		return err
	}

	if err := t.UnsealPrice.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.PricePerByte (big.Int) (struct)
	if len("PricePerByte") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"PricePerByte\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PricePerByte"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("PricePerByte")); err != nil {
		return err
	}

	if err := t.PricePerByte.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.PaymentInterval (uint64) (uint64)
	if len("PaymentInterval") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"PaymentInterval\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PaymentInterval"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("PaymentInterval")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.PaymentInterval)); err != nil {
		return err
	}

	// t.PaymentIntervalIncrease (uint64) (uint64)
	if len("PaymentIntervalIncrease") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"PaymentIntervalIncrease\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PaymentIntervalIncrease"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("PaymentIntervalIncrease")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.PaymentIntervalIncrease)); err != nil {
		return err
	}

	return nil
}

func (t *Params) UnmarshalCBOR(r io.Reader) (err error) {
	*t = Params{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("Params: map struct too large (%d)", extra)
	}

	var name string
	n := extra

	for i := uint64(0); i < n; i++ {

		{
			sval, err := cbg.ReadString(cr)
			if err != nil {
				return err
			}

			name = string(sval)
		}

		switch name {
		// t.PieceCID (cid.Cid) (struct)
		case "PieceCID":

			{

				b, err := cr.ReadByte()
				if err != nil {
					return err
				}
				if b != cbg.CborNull[0] {
					if err := cr.UnreadByte(); err != nil {
						return err
					}

					c, err := cbg.ReadCid(cr)
					if err != nil {
						return xerrors.Errorf("failed to read cid field t.PieceCID: %w", err)
					}

					t.PieceCID = &c
				}

			}
			// t.Selector (retrievalmarket.CborGenCompatibleNode) (struct)
		case "Selector":

			{

				if err := t.Selector.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.Selector: %w", err)
				}

			}
			// t.UnsealPrice (big.Int) (struct)
		case "UnsealPrice":

			{

				if err := t.UnsealPrice.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.UnsealPrice: %w", err)
				}

			}
			// t.PricePerByte (big.Int) (struct)
		case "PricePerByte":

			{

				if err := t.PricePerByte.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.PricePerByte: %w", err)
				}

			}
			// t.PaymentInterval (uint64) (uint64)
		case "PaymentInterval":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.PaymentInterval = uint64(extra)

			}
			// t.PaymentIntervalIncrease (uint64) (uint64)
		case "PaymentIntervalIncrease":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.PaymentIntervalIncrease = uint64(extra)

			}

		default:
			// Field doesn't exist on this type, so ignore it
			cbg.ScanForLinks(r, func(cid.Cid) {})
		}
	}

	return nil
}
func (t *QueryParams) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{161}); err != nil {
		return err
	}

	// t.PieceCID (cid.Cid) (struct)
	if len("PieceCID") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"PieceCID\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PieceCID"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("PieceCID")); err != nil {
		return err
	}

	if t.PieceCID == nil {
		if _, err := cw.Write(cbg.CborNull); err != nil {
			return err
		}
	} else {
		if err := cbg.WriteCid(cw, *t.PieceCID); err != nil {
			return xerrors.Errorf("failed to write cid field t.PieceCID: %w", err)
		}
	}

	return nil
}

func (t *QueryParams) UnmarshalCBOR(r io.Reader) (err error) {
	*t = QueryParams{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("QueryParams: map struct too large (%d)", extra)
	}

	var name string
	n := extra

	for i := uint64(0); i < n; i++ {

		{
			sval, err := cbg.ReadString(cr)
			if err != nil {
				return err
			}

			name = string(sval)
		}

		switch name {
		// t.PieceCID (cid.Cid) (struct)
		case "PieceCID":

			{

				b, err := cr.ReadByte()
				if err != nil {
					return err
				}
				if b != cbg.CborNull[0] {
					if err := cr.UnreadByte(); err != nil {
						return err
					}

					c, err := cbg.ReadCid(cr)
					if err != nil {
						return xerrors.Errorf("failed to read cid field t.PieceCID: %w", err)
					}

					t.PieceCID = &c
				}

			}

		default:
			// Field doesn't exist on this type, so ignore it
			cbg.ScanForLinks(r, func(cid.Cid) {})
		}
	}

	return nil
}
func (t *DealPayment) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{163}); err != nil {
		return err
	}

	// t.ID (retrievalmarket.DealID) (uint64)
	if len("ID") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"ID\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ID"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("ID")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.ID)); err != nil {
		return err
	}

	// t.PaymentChannel (address.Address) (struct)
	if len("PaymentChannel") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"PaymentChannel\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PaymentChannel"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("PaymentChannel")); err != nil {
		return err
	}

	if err := t.PaymentChannel.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.PaymentVoucher (paych.SignedVoucher) (struct)
	if len("PaymentVoucher") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"PaymentVoucher\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PaymentVoucher"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("PaymentVoucher")); err != nil {
		return err
	}

	if err := t.PaymentVoucher.MarshalCBOR(cw); err != nil {
		return err
	}
	return nil
}

func (t *DealPayment) UnmarshalCBOR(r io.Reader) (err error) {
	*t = DealPayment{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("DealPayment: map struct too large (%d)", extra)
	}

	var name string
	n := extra

	for i := uint64(0); i < n; i++ {

		{
			sval, err := cbg.ReadString(cr)
			if err != nil {
				return err
			}

			name = string(sval)
		}

		switch name {
		// t.ID (retrievalmarket.DealID) (uint64)
		case "ID":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.ID = DealID(extra)

			}
			// t.PaymentChannel (address.Address) (struct)
		case "PaymentChannel":

			{

				if err := t.PaymentChannel.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.PaymentChannel: %w", err)
				}

			}
			// t.PaymentVoucher (paych.SignedVoucher) (struct)
		case "PaymentVoucher":

			{

				b, err := cr.ReadByte()
				if err != nil {
					return err
				}
				if b != cbg.CborNull[0] {
					if err := cr.UnreadByte(); err != nil {
						return err
					}
					t.PaymentVoucher = new(paych.SignedVoucher)
					if err := t.PaymentVoucher.UnmarshalCBOR(cr); err != nil {
						return xerrors.Errorf("unmarshaling t.PaymentVoucher pointer: %w", err)
					}
				}

			}

		default:
			// Field doesn't exist on this type, so ignore it
			cbg.ScanForLinks(r, func(cid.Cid) {})
		}
	}

	return nil
}
func (t *ClientDealState) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{181}); err != nil {
		return err
	}

	// t.Sender (peer.ID) (string)
	if len("Sender") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Sender\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Sender"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Sender")); err != nil {
		return err
	}

	if len(t.Sender) > cbg.MaxLength {
		return xerrors.Errorf("Value in field t.Sender was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Sender))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string(t.Sender)); err != nil {
		return err
	}

	// t.Status (retrievalmarket.DealStatus) (uint64)
	if len("Status") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Status\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Status"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Status")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Status)); err != nil {
		return err
	}

	// t.Message (string) (string)
	if len("Message") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Message\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Message"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Message")); err != nil {
		return err
	}

	if len(t.Message) > cbg.MaxLength {
		return xerrors.Errorf("Value in field t.Message was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Message))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string(t.Message)); err != nil {
		return err
	}

	// t.StoreID (uint64) (uint64)
	if len("StoreID") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"StoreID\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("StoreID"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("StoreID")); err != nil {
		return err
	}

	if t.StoreID == nil {
		if _, err := cw.Write(cbg.CborNull); err != nil {
			return err
		}
	} else {
		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.StoreID)); err != nil {
			return err
		}
	}

	// t.ChannelID (datatransfer.ChannelID) (struct)
	if len("ChannelID") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"ChannelID\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ChannelID"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("ChannelID")); err != nil {
		return err
	}

	if err := t.ChannelID.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.FundsSpent (big.Int) (struct)
	if len("FundsSpent") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"FundsSpent\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("FundsSpent"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("FundsSpent")); err != nil {
		return err
	}

	if err := t.FundsSpent.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.TotalFunds (big.Int) (struct)
	if len("TotalFunds") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"TotalFunds\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("TotalFunds"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("TotalFunds")); err != nil {
		return err
	}

	if err := t.TotalFunds.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.WaitMsgCID (cid.Cid) (struct)
	if len("WaitMsgCID") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"WaitMsgCID\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("WaitMsgCID"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("WaitMsgCID")); err != nil {
		return err
	}

	if t.WaitMsgCID == nil {
		if _, err := cw.Write(cbg.CborNull); err != nil {
			return err
		}
	} else {
		if err := cbg.WriteCid(cw, *t.WaitMsgCID); err != nil {
			return xerrors.Errorf("failed to write cid field t.WaitMsgCID: %w", err)
		}
	}

	// t.MinerWallet (address.Address) (struct)
	if len("MinerWallet") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"MinerWallet\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("MinerWallet"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("MinerWallet")); err != nil {
		return err
	}

	if err := t.MinerWallet.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.PaymentInfo (retrievalmarket.PaymentInfo) (struct)
	if len("PaymentInfo") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"PaymentInfo\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PaymentInfo"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("PaymentInfo")); err != nil {
		return err
	}

	if err := t.PaymentInfo.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.BytesPaidFor (uint64) (uint64)
	if len("BytesPaidFor") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"BytesPaidFor\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("BytesPaidFor"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("BytesPaidFor")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.BytesPaidFor)); err != nil {
		return err
	}

	// t.ClientWallet (address.Address) (struct)
	if len("ClientWallet") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"ClientWallet\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ClientWallet"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("ClientWallet")); err != nil {
		return err
	}

	if err := t.ClientWallet.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.DealProposal (retrievalmarket.DealProposal) (struct)
	if len("DealProposal") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"DealProposal\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("DealProposal"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("DealProposal")); err != nil {
		return err
	}

	if err := t.DealProposal.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.TotalReceived (uint64) (uint64)
	if len("TotalReceived") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"TotalReceived\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("TotalReceived"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("TotalReceived")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.TotalReceived)); err != nil {
		return err
	}

	// t.LegacyProtocol (bool) (bool)
	if len("LegacyProtocol") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"LegacyProtocol\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("LegacyProtocol"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("LegacyProtocol")); err != nil {
		return err
	}

	if err := cbg.WriteBool(w, t.LegacyProtocol); err != nil {
		return err
	}

	// t.CurrentInterval (uint64) (uint64)
	if len("CurrentInterval") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"CurrentInterval\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("CurrentInterval"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("CurrentInterval")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.CurrentInterval)); err != nil {
		return err
	}

	// t.UnsealFundsPaid (big.Int) (struct)
	if len("UnsealFundsPaid") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"UnsealFundsPaid\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("UnsealFundsPaid"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("UnsealFundsPaid")); err != nil {
		return err
	}

	if err := t.UnsealFundsPaid.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.PaymentRequested (big.Int) (struct)
	if len("PaymentRequested") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"PaymentRequested\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PaymentRequested"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("PaymentRequested")); err != nil {
		return err
	}

	if err := t.PaymentRequested.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.VoucherShortfall (big.Int) (struct)
	if len("VoucherShortfall") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"VoucherShortfall\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("VoucherShortfall"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("VoucherShortfall")); err != nil {
		return err
	}

	if err := t.VoucherShortfall.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.AllBlocksReceived (bool) (bool)
	if len("AllBlocksReceived") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"AllBlocksReceived\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("AllBlocksReceived"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("AllBlocksReceived")); err != nil {
		return err
	}

	if err := cbg.WriteBool(w, t.AllBlocksReceived); err != nil {
		return err
	}

	// t.LastPaymentRequested (bool) (bool)
	if len("LastPaymentRequested") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"LastPaymentRequested\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("LastPaymentRequested"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("LastPaymentRequested")); err != nil {
		return err
	}

	if err := cbg.WriteBool(w, t.LastPaymentRequested); err != nil {
		return err
	}
	return nil
}

func (t *ClientDealState) UnmarshalCBOR(r io.Reader) (err error) {
	*t = ClientDealState{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("ClientDealState: map struct too large (%d)", extra)
	}

	var name string
	n := extra

	for i := uint64(0); i < n; i++ {

		{
			sval, err := cbg.ReadString(cr)
			if err != nil {
				return err
			}

			name = string(sval)
		}

		switch name {
		// t.Sender (peer.ID) (string)
		case "Sender":

			{
				sval, err := cbg.ReadString(cr)
				if err != nil {
					return err
				}

				t.Sender = peer.ID(sval)
			}
			// t.Status (retrievalmarket.DealStatus) (uint64)
		case "Status":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.Status = DealStatus(extra)

			}
			// t.Message (string) (string)
		case "Message":

			{
				sval, err := cbg.ReadString(cr)
				if err != nil {
					return err
				}

				t.Message = string(sval)
			}
			// t.StoreID (uint64) (uint64)
		case "StoreID":

			{

				b, err := cr.ReadByte()
				if err != nil {
					return err
				}
				if b != cbg.CborNull[0] {
					if err := cr.UnreadByte(); err != nil {
						return err
					}
					maj, extra, err = cr.ReadHeader()
					if err != nil {
						return err
					}
					if maj != cbg.MajUnsignedInt {
						return fmt.Errorf("wrong type for uint64 field")
					}
					typed := uint64(extra)
					t.StoreID = &typed
				}

			}
			// t.ChannelID (datatransfer.ChannelID) (struct)
		case "ChannelID":

			{

				b, err := cr.ReadByte()
				if err != nil {
					return err
				}
				if b != cbg.CborNull[0] {
					if err := cr.UnreadByte(); err != nil {
						return err
					}
					t.ChannelID = new(datatransfer.ChannelID)
					if err := t.ChannelID.UnmarshalCBOR(cr); err != nil {
						return xerrors.Errorf("unmarshaling t.ChannelID pointer: %w", err)
					}
				}

			}
			// t.FundsSpent (big.Int) (struct)
		case "FundsSpent":

			{

				if err := t.FundsSpent.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.FundsSpent: %w", err)
				}

			}
			// t.TotalFunds (big.Int) (struct)
		case "TotalFunds":

			{

				if err := t.TotalFunds.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.TotalFunds: %w", err)
				}

			}
			// t.WaitMsgCID (cid.Cid) (struct)
		case "WaitMsgCID":

			{

				b, err := cr.ReadByte()
				if err != nil {
					return err
				}
				if b != cbg.CborNull[0] {
					if err := cr.UnreadByte(); err != nil {
						return err
					}

					c, err := cbg.ReadCid(cr)
					if err != nil {
						return xerrors.Errorf("failed to read cid field t.WaitMsgCID: %w", err)
					}

					t.WaitMsgCID = &c
				}

			}
			// t.MinerWallet (address.Address) (struct)
		case "MinerWallet":

			{

				if err := t.MinerWallet.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.MinerWallet: %w", err)
				}

			}
			// t.PaymentInfo (retrievalmarket.PaymentInfo) (struct)
		case "PaymentInfo":

			{

				b, err := cr.ReadByte()
				if err != nil {
					return err
				}
				if b != cbg.CborNull[0] {
					if err := cr.UnreadByte(); err != nil {
						return err
					}
					t.PaymentInfo = new(PaymentInfo)
					if err := t.PaymentInfo.UnmarshalCBOR(cr); err != nil {
						return xerrors.Errorf("unmarshaling t.PaymentInfo pointer: %w", err)
					}
				}

			}
			// t.BytesPaidFor (uint64) (uint64)
		case "BytesPaidFor":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.BytesPaidFor = uint64(extra)

			}
			// t.ClientWallet (address.Address) (struct)
		case "ClientWallet":

			{

				if err := t.ClientWallet.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.ClientWallet: %w", err)
				}

			}
			// t.DealProposal (retrievalmarket.DealProposal) (struct)
		case "DealProposal":

			{

				if err := t.DealProposal.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.DealProposal: %w", err)
				}

			}
			// t.TotalReceived (uint64) (uint64)
		case "TotalReceived":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.TotalReceived = uint64(extra)

			}
			// t.LegacyProtocol (bool) (bool)
		case "LegacyProtocol":

			maj, extra, err = cr.ReadHeader()
			if err != nil {
				return err
			}
			if maj != cbg.MajOther {
				return fmt.Errorf("booleans must be major type 7")
			}
			switch extra {
			case 20:
				t.LegacyProtocol = false
			case 21:
				t.LegacyProtocol = true
			default:
				return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
			}
			// t.CurrentInterval (uint64) (uint64)
		case "CurrentInterval":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.CurrentInterval = uint64(extra)

			}
			// t.UnsealFundsPaid (big.Int) (struct)
		case "UnsealFundsPaid":

			{

				if err := t.UnsealFundsPaid.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.UnsealFundsPaid: %w", err)
				}

			}
			// t.PaymentRequested (big.Int) (struct)
		case "PaymentRequested":

			{

				if err := t.PaymentRequested.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.PaymentRequested: %w", err)
				}

			}
			// t.VoucherShortfall (big.Int) (struct)
		case "VoucherShortfall":

			{

				if err := t.VoucherShortfall.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.VoucherShortfall: %w", err)
				}

			}
			// t.AllBlocksReceived (bool) (bool)
		case "AllBlocksReceived":

			maj, extra, err = cr.ReadHeader()
			if err != nil {
				return err
			}
			if maj != cbg.MajOther {
				return fmt.Errorf("booleans must be major type 7")
			}
			switch extra {
			case 20:
				t.AllBlocksReceived = false
			case 21:
				t.AllBlocksReceived = true
			default:
				return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
			}
			// t.LastPaymentRequested (bool) (bool)
		case "LastPaymentRequested":

			maj, extra, err = cr.ReadHeader()
			if err != nil {
				return err
			}
			if maj != cbg.MajOther {
				return fmt.Errorf("booleans must be major type 7")
			}
			switch extra {
			case 20:
				t.LastPaymentRequested = false
			case 21:
				t.LastPaymentRequested = true
			default:
				return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
			}

		default:
			// Field doesn't exist on this type, so ignore it
			cbg.ScanForLinks(r, func(cid.Cid) {})
		}
	}

	return nil
}
func (t *ProviderDealState) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{168}); err != nil {
		return err
	}

	// t.Status (retrievalmarket.DealStatus) (uint64)
	if len("Status") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Status\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Status"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Status")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Status)); err != nil {
		return err
	}

	// t.Message (string) (string)
	if len("Message") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Message\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Message"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Message")); err != nil {
		return err
	}

	if len(t.Message) > cbg.MaxLength {
		return xerrors.Errorf("Value in field t.Message was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Message))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string(t.Message)); err != nil {
		return err
	}

	// t.StoreID (uint64) (uint64)
	if len("StoreID") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"StoreID\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("StoreID"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("StoreID")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.StoreID)); err != nil {
		return err
	}

	// t.Receiver (peer.ID) (string)
	if len("Receiver") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Receiver\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Receiver"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Receiver")); err != nil {
		return err
	}

	if len(t.Receiver) > cbg.MaxLength {
		return xerrors.Errorf("Value in field t.Receiver was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Receiver))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string(t.Receiver)); err != nil {
		return err
	}

	// t.ChannelID (datatransfer.ChannelID) (struct)
	if len("ChannelID") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"ChannelID\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ChannelID"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("ChannelID")); err != nil {
		return err
	}

	if err := t.ChannelID.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.PieceInfo (piecestore.PieceInfo) (struct)
	if len("PieceInfo") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"PieceInfo\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PieceInfo"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("PieceInfo")); err != nil {
		return err
	}

	if err := t.PieceInfo.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.DealProposal (retrievalmarket.DealProposal) (struct)
	if len("DealProposal") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"DealProposal\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("DealProposal"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("DealProposal")); err != nil {
		return err
	}

	if err := t.DealProposal.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.FundsReceived (big.Int) (struct)
	if len("FundsReceived") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"FundsReceived\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("FundsReceived"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("FundsReceived")); err != nil {
		return err
	}

	if err := t.FundsReceived.MarshalCBOR(cw); err != nil {
		return err
	}
	return nil
}

func (t *ProviderDealState) UnmarshalCBOR(r io.Reader) (err error) {
	*t = ProviderDealState{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("ProviderDealState: map struct too large (%d)", extra)
	}

	var name string
	n := extra

	for i := uint64(0); i < n; i++ {

		{
			sval, err := cbg.ReadString(cr)
			if err != nil {
				return err
			}

			name = string(sval)
		}

		switch name {
		// t.Status (retrievalmarket.DealStatus) (uint64)
		case "Status":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.Status = DealStatus(extra)

			}
			// t.Message (string) (string)
		case "Message":

			{
				sval, err := cbg.ReadString(cr)
				if err != nil {
					return err
				}

				t.Message = string(sval)
			}
			// t.StoreID (uint64) (uint64)
		case "StoreID":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.StoreID = uint64(extra)

			}
			// t.Receiver (peer.ID) (string)
		case "Receiver":

			{
				sval, err := cbg.ReadString(cr)
				if err != nil {
					return err
				}

				t.Receiver = peer.ID(sval)
			}
			// t.ChannelID (datatransfer.ChannelID) (struct)
		case "ChannelID":

			{

				b, err := cr.ReadByte()
				if err != nil {
					return err
				}
				if b != cbg.CborNull[0] {
					if err := cr.UnreadByte(); err != nil {
						return err
					}
					t.ChannelID = new(datatransfer.ChannelID)
					if err := t.ChannelID.UnmarshalCBOR(cr); err != nil {
						return xerrors.Errorf("unmarshaling t.ChannelID pointer: %w", err)
					}
				}

			}
			// t.PieceInfo (piecestore.PieceInfo) (struct)
		case "PieceInfo":

			{

				b, err := cr.ReadByte()
				if err != nil {
					return err
				}
				if b != cbg.CborNull[0] {
					if err := cr.UnreadByte(); err != nil {
						return err
					}
					t.PieceInfo = new(piecestore.PieceInfo)
					if err := t.PieceInfo.UnmarshalCBOR(cr); err != nil {
						return xerrors.Errorf("unmarshaling t.PieceInfo pointer: %w", err)
					}
				}

			}
			// t.DealProposal (retrievalmarket.DealProposal) (struct)
		case "DealProposal":

			{

				if err := t.DealProposal.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.DealProposal: %w", err)
				}

			}
			// t.FundsReceived (big.Int) (struct)
		case "FundsReceived":

			{

				if err := t.FundsReceived.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.FundsReceived: %w", err)
				}

			}

		default:
			// Field doesn't exist on this type, so ignore it
			cbg.ScanForLinks(r, func(cid.Cid) {})
		}
	}

	return nil
}
func (t *PaymentInfo) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{162}); err != nil {
		return err
	}

	// t.Lane (uint64) (uint64)
	if len("Lane") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Lane\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Lane"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Lane")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Lane)); err != nil {
		return err
	}

	// t.PayCh (address.Address) (struct)
	if len("PayCh") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"PayCh\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PayCh"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("PayCh")); err != nil {
		return err
	}

	if err := t.PayCh.MarshalCBOR(cw); err != nil {
		return err
	}
	return nil
}

func (t *PaymentInfo) UnmarshalCBOR(r io.Reader) (err error) {
	*t = PaymentInfo{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("PaymentInfo: map struct too large (%d)", extra)
	}

	var name string
	n := extra

	for i := uint64(0); i < n; i++ {

		{
			sval, err := cbg.ReadString(cr)
			if err != nil {
				return err
			}

			name = string(sval)
		}

		switch name {
		// t.Lane (uint64) (uint64)
		case "Lane":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.Lane = uint64(extra)

			}
			// t.PayCh (address.Address) (struct)
		case "PayCh":

			{

				if err := t.PayCh.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.PayCh: %w", err)
				}

			}

		default:
			// Field doesn't exist on this type, so ignore it
			cbg.ScanForLinks(r, func(cid.Cid) {})
		}
	}

	return nil
}
func (t *RetrievalPeer) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{163}); err != nil {
		return err
	}

	// t.ID (peer.ID) (string)
	if len("ID") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"ID\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ID"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("ID")); err != nil {
		return err
	}

	if len(t.ID) > cbg.MaxLength {
		return xerrors.Errorf("Value in field t.ID was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.ID))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string(t.ID)); err != nil {
		return err
	}

	// t.Address (address.Address) (struct)
	if len("Address") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Address\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Address"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Address")); err != nil {
		return err
	}

	if err := t.Address.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.PieceCID (cid.Cid) (struct)
	if len("PieceCID") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"PieceCID\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PieceCID"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("PieceCID")); err != nil {
		return err
	}

	if t.PieceCID == nil {
		if _, err := cw.Write(cbg.CborNull); err != nil {
			return err
		}
	} else {
		if err := cbg.WriteCid(cw, *t.PieceCID); err != nil {
			return xerrors.Errorf("failed to write cid field t.PieceCID: %w", err)
		}
	}

	return nil
}

func (t *RetrievalPeer) UnmarshalCBOR(r io.Reader) (err error) {
	*t = RetrievalPeer{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("RetrievalPeer: map struct too large (%d)", extra)
	}

	var name string
	n := extra

	for i := uint64(0); i < n; i++ {

		{
			sval, err := cbg.ReadString(cr)
			if err != nil {
				return err
			}

			name = string(sval)
		}

		switch name {
		// t.ID (peer.ID) (string)
		case "ID":

			{
				sval, err := cbg.ReadString(cr)
				if err != nil {
					return err
				}

				t.ID = peer.ID(sval)
			}
			// t.Address (address.Address) (struct)
		case "Address":

			{

				if err := t.Address.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.Address: %w", err)
				}

			}
			// t.PieceCID (cid.Cid) (struct)
		case "PieceCID":

			{

				b, err := cr.ReadByte()
				if err != nil {
					return err
				}
				if b != cbg.CborNull[0] {
					if err := cr.UnreadByte(); err != nil {
						return err
					}

					c, err := cbg.ReadCid(cr)
					if err != nil {
						return xerrors.Errorf("failed to read cid field t.PieceCID: %w", err)
					}

					t.PieceCID = &c
				}

			}

		default:
			// Field doesn't exist on this type, so ignore it
			cbg.ScanForLinks(r, func(cid.Cid) {})
		}
	}

	return nil
}
func (t *Ask) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{164}); err != nil {
		return err
	}

	// t.UnsealPrice (big.Int) (struct)
	if len("UnsealPrice") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"UnsealPrice\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("UnsealPrice"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("UnsealPrice")); err != nil {
		return err
	}

	if err := t.UnsealPrice.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.PricePerByte (big.Int) (struct)
	if len("PricePerByte") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"PricePerByte\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PricePerByte"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("PricePerByte")); err != nil {
		return err
	}

	if err := t.PricePerByte.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.PaymentInterval (uint64) (uint64)
	if len("PaymentInterval") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"PaymentInterval\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PaymentInterval"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("PaymentInterval")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.PaymentInterval)); err != nil {
		return err
	}

	// t.PaymentIntervalIncrease (uint64) (uint64)
	if len("PaymentIntervalIncrease") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"PaymentIntervalIncrease\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PaymentIntervalIncrease"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("PaymentIntervalIncrease")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.PaymentIntervalIncrease)); err != nil {
		return err
	}

	return nil
}

func (t *Ask) UnmarshalCBOR(r io.Reader) (err error) {
	*t = Ask{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("Ask: map struct too large (%d)", extra)
	}

	var name string
	n := extra

	for i := uint64(0); i < n; i++ {

		{
			sval, err := cbg.ReadString(cr)
			if err != nil {
				return err
			}

			name = string(sval)
		}

		switch name {
		// t.UnsealPrice (big.Int) (struct)
		case "UnsealPrice":

			{

				if err := t.UnsealPrice.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.UnsealPrice: %w", err)
				}

			}
			// t.PricePerByte (big.Int) (struct)
		case "PricePerByte":

			{

				if err := t.PricePerByte.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.PricePerByte: %w", err)
				}

			}
			// t.PaymentInterval (uint64) (uint64)
		case "PaymentInterval":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.PaymentInterval = uint64(extra)

			}
			// t.PaymentIntervalIncrease (uint64) (uint64)
		case "PaymentIntervalIncrease":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.PaymentIntervalIncrease = uint64(extra)

			}

		default:
			// Field doesn't exist on this type, so ignore it
			cbg.ScanForLinks(r, func(cid.Cid) {})
		}
	}

	return nil
}