cbor_gen.go

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

package miner

import (
	"fmt"
	"io"

	address "github.com/filecoin-project/go-address"
	abi "github.com/filecoin-project/go-state-types/abi"
	miner "github.com/filecoin-project/specs-actors/actors/builtin/miner"
	proof "github.com/filecoin-project/specs-actors/actors/runtime/proof"
	cid "github.com/ipfs/go-cid"
	cbg "github.com/whyrusleeping/cbor-gen"
	xerrors "golang.org/x/xerrors"
)

var _ = xerrors.Errorf

var lengthBufState = []byte{143}

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

	scratch := make([]byte, 9)

	// t.Info (cid.Cid) (struct)

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

	// t.PreCommitDeposits (big.Int) (struct)
	if err := t.PreCommitDeposits.MarshalCBOR(w); err != nil {
		return err
	}

	// t.LockedFunds (big.Int) (struct)
	if err := t.LockedFunds.MarshalCBOR(w); err != nil {
		return err
	}

	// t.VestingFunds (cid.Cid) (struct)

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

	// t.FeeDebt (big.Int) (struct)
	if err := t.FeeDebt.MarshalCBOR(w); err != nil {
		return err
	}

	// t.InitialPledge (big.Int) (struct)
	if err := t.InitialPledge.MarshalCBOR(w); err != nil {
		return err
	}

	// t.PreCommittedSectors (cid.Cid) (struct)

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

	// t.PreCommittedSectorsCleanUp (cid.Cid) (struct)

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

	// t.AllocatedSectors (cid.Cid) (struct)

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

	// t.Sectors (cid.Cid) (struct)

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

	// t.ProvingPeriodStart (abi.ChainEpoch) (int64)
	if t.ProvingPeriodStart >= 0 {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.ProvingPeriodStart)); err != nil {
			return err
		}
	} else {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.ProvingPeriodStart-1)); err != nil {
			return err
		}
	}

	// t.CurrentDeadline (uint64) (uint64)

	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.CurrentDeadline)); err != nil {
		return err
	}

	// t.Deadlines (cid.Cid) (struct)

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

	// t.EarlyTerminations (bitfield.BitField) (struct)
	if err := t.EarlyTerminations.MarshalCBOR(w); err != nil {
		return err
	}

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

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

	br := cbg.GetPeeker(r)
	scratch := make([]byte, 8)

	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}
	if maj != cbg.MajArray {
		return fmt.Errorf("cbor input should be of type array")
	}

	if extra != 15 {
		return fmt.Errorf("cbor input had wrong number of fields")
	}

	// t.Info (cid.Cid) (struct)

	{

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

		t.Info = c

	}
	// t.PreCommitDeposits (big.Int) (struct)

	{

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

	}
	// t.LockedFunds (big.Int) (struct)

	{

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

	}
	// t.VestingFunds (cid.Cid) (struct)

	{

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

		t.VestingFunds = c

	}
	// t.FeeDebt (big.Int) (struct)

	{

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

	}
	// t.InitialPledge (big.Int) (struct)

	{

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

	}
	// t.PreCommittedSectors (cid.Cid) (struct)

	{

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

		t.PreCommittedSectors = c

	}
	// t.PreCommittedSectorsCleanUp (cid.Cid) (struct)

	{

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

		t.PreCommittedSectorsCleanUp = c

	}
	// t.AllocatedSectors (cid.Cid) (struct)

	{

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

		t.AllocatedSectors = c

	}
	// t.Sectors (cid.Cid) (struct)

	{

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

		t.Sectors = c

	}
	// t.ProvingPeriodStart (abi.ChainEpoch) (int64)
	{
		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
		var extraI int64
		if err != nil {
			return err
		}
		switch maj {
		case cbg.MajUnsignedInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 positive overflow")
			}
		case cbg.MajNegativeInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 negative oveflow")
			}
			extraI = -1 - extraI
		default:
			return fmt.Errorf("wrong type for int64 field: %d", maj)
		}

		t.ProvingPeriodStart = abi.ChainEpoch(extraI)
	}
	// t.CurrentDeadline (uint64) (uint64)

	{

		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
		if err != nil {
			return err
		}
		if maj != cbg.MajUnsignedInt {
			return fmt.Errorf("wrong type for uint64 field")
		}
		t.CurrentDeadline = uint64(extra)

	}
	// t.Deadlines (cid.Cid) (struct)

	{

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

		t.Deadlines = c

	}
	// t.EarlyTerminations (bitfield.BitField) (struct)

	{

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

	}
	// t.DeadlineCronActive (bool) (bool)

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

var lengthBufMinerInfo = []byte{139}

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

	scratch := make([]byte, 9)

	// t.Owner (address.Address) (struct)
	if err := t.Owner.MarshalCBOR(w); err != nil {
		return err
	}

	// t.Worker (address.Address) (struct)
	if err := t.Worker.MarshalCBOR(w); err != nil {
		return err
	}

	// t.ControlAddresses ([]address.Address) (slice)
	if len(t.ControlAddresses) > cbg.MaxLength {
		return xerrors.Errorf("Slice value in field t.ControlAddresses was too long")
	}

	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.ControlAddresses))); err != nil {
		return err
	}
	for _, v := range t.ControlAddresses {
		if err := v.MarshalCBOR(w); err != nil {
			return err
		}
	}

	// t.PendingWorkerKey (miner.WorkerKeyChange) (struct)
	if err := t.PendingWorkerKey.MarshalCBOR(w); err != nil {
		return err
	}

	// t.PeerId ([]uint8) (slice)
	if len(t.PeerId) > cbg.ByteArrayMaxLen {
		return xerrors.Errorf("Byte array in field t.PeerId was too long")
	}

	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.PeerId))); err != nil {
		return err
	}

	if _, err := w.Write(t.PeerId[:]); err != nil {
		return err
	}

	// t.Multiaddrs ([][]uint8) (slice)
	if len(t.Multiaddrs) > cbg.MaxLength {
		return xerrors.Errorf("Slice value in field t.Multiaddrs was too long")
	}

	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Multiaddrs))); err != nil {
		return err
	}
	for _, v := range t.Multiaddrs {
		if len(v) > cbg.ByteArrayMaxLen {
			return xerrors.Errorf("Byte array in field v was too long")
		}

		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(v))); err != nil {
			return err
		}

		if _, err := w.Write(v[:]); err != nil {
			return err
		}
	}

	// t.WindowPoStProofType (abi.RegisteredPoStProof) (int64)
	if t.WindowPoStProofType >= 0 {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.WindowPoStProofType)); err != nil {
			return err
		}
	} else {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.WindowPoStProofType-1)); err != nil {
			return err
		}
	}

	// t.SectorSize (abi.SectorSize) (uint64)

	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.SectorSize)); err != nil {
		return err
	}

	// t.WindowPoStPartitionSectors (uint64) (uint64)

	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.WindowPoStPartitionSectors)); err != nil {
		return err
	}

	// t.ConsensusFaultElapsed (abi.ChainEpoch) (int64)
	if t.ConsensusFaultElapsed >= 0 {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.ConsensusFaultElapsed)); err != nil {
			return err
		}
	} else {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.ConsensusFaultElapsed-1)); err != nil {
			return err
		}
	}

	// t.PendingOwnerAddress (address.Address) (struct)
	if err := t.PendingOwnerAddress.MarshalCBOR(w); err != nil {
		return err
	}
	return nil
}

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

	br := cbg.GetPeeker(r)
	scratch := make([]byte, 8)

	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}
	if maj != cbg.MajArray {
		return fmt.Errorf("cbor input should be of type array")
	}

	if extra != 11 {
		return fmt.Errorf("cbor input had wrong number of fields")
	}

	// t.Owner (address.Address) (struct)

	{

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

	}
	// t.Worker (address.Address) (struct)

	{

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

	}
	// t.ControlAddresses ([]address.Address) (slice)

	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("t.ControlAddresses: array too large (%d)", extra)
	}

	if maj != cbg.MajArray {
		return fmt.Errorf("expected cbor array")
	}

	if extra > 0 {
		t.ControlAddresses = make([]address.Address, extra)
	}

	for i := 0; i < int(extra); i++ {

		var v address.Address
		if err := v.UnmarshalCBOR(br); err != nil {
			return err
		}

		t.ControlAddresses[i] = v
	}

	// t.PendingWorkerKey (miner.WorkerKeyChange) (struct)

	{

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

	}
	// t.PeerId ([]uint8) (slice)

	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}

	if extra > cbg.ByteArrayMaxLen {
		return fmt.Errorf("t.PeerId: byte array too large (%d)", extra)
	}
	if maj != cbg.MajByteString {
		return fmt.Errorf("expected byte array")
	}

	if extra > 0 {
		t.PeerId = make([]uint8, extra)
	}

	if _, err := io.ReadFull(br, t.PeerId[:]); err != nil {
		return err
	}
	// t.Multiaddrs ([][]uint8) (slice)

	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("t.Multiaddrs: array too large (%d)", extra)
	}

	if maj != cbg.MajArray {
		return fmt.Errorf("expected cbor array")
	}

	if extra > 0 {
		t.Multiaddrs = make([][]uint8, extra)
	}

	for i := 0; i < int(extra); i++ {
		{
			var maj byte
			var extra uint64
			var err error

			maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
			if err != nil {
				return err
			}

			if extra > cbg.ByteArrayMaxLen {
				return fmt.Errorf("t.Multiaddrs[i]: byte array too large (%d)", extra)
			}
			if maj != cbg.MajByteString {
				return fmt.Errorf("expected byte array")
			}

			if extra > 0 {
				t.Multiaddrs[i] = make([]uint8, extra)
			}

			if _, err := io.ReadFull(br, t.Multiaddrs[i][:]); err != nil {
				return err
			}
		}
	}

	// t.WindowPoStProofType (abi.RegisteredPoStProof) (int64)
	{
		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
		var extraI int64
		if err != nil {
			return err
		}
		switch maj {
		case cbg.MajUnsignedInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 positive overflow")
			}
		case cbg.MajNegativeInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 negative oveflow")
			}
			extraI = -1 - extraI
		default:
			return fmt.Errorf("wrong type for int64 field: %d", maj)
		}

		t.WindowPoStProofType = abi.RegisteredPoStProof(extraI)
	}
	// t.SectorSize (abi.SectorSize) (uint64)

	{

		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
		if err != nil {
			return err
		}
		if maj != cbg.MajUnsignedInt {
			return fmt.Errorf("wrong type for uint64 field")
		}
		t.SectorSize = abi.SectorSize(extra)

	}
	// t.WindowPoStPartitionSectors (uint64) (uint64)

	{

		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
		if err != nil {
			return err
		}
		if maj != cbg.MajUnsignedInt {
			return fmt.Errorf("wrong type for uint64 field")
		}
		t.WindowPoStPartitionSectors = uint64(extra)

	}
	// t.ConsensusFaultElapsed (abi.ChainEpoch) (int64)
	{
		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
		var extraI int64
		if err != nil {
			return err
		}
		switch maj {
		case cbg.MajUnsignedInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 positive overflow")
			}
		case cbg.MajNegativeInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 negative oveflow")
			}
			extraI = -1 - extraI
		default:
			return fmt.Errorf("wrong type for int64 field: %d", maj)
		}

		t.ConsensusFaultElapsed = abi.ChainEpoch(extraI)
	}
	// t.PendingOwnerAddress (address.Address) (struct)

	{

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

	}
	return nil
}

var lengthBufDeadlines = []byte{129}

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

	scratch := make([]byte, 9)

	// t.Due ([48]cid.Cid) (array)
	if len(t.Due) > cbg.MaxLength {
		return xerrors.Errorf("Slice value in field t.Due was too long")
	}

	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Due))); err != nil {
		return err
	}
	for _, v := range t.Due {
		if err := cbg.WriteCidBuf(scratch, w, v); err != nil {
			return xerrors.Errorf("failed writing cid field t.Due: %w", err)
		}
	}
	return nil
}

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

	br := cbg.GetPeeker(r)
	scratch := make([]byte, 8)

	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}
	if maj != cbg.MajArray {
		return fmt.Errorf("cbor input should be of type array")
	}

	if extra != 1 {
		return fmt.Errorf("cbor input had wrong number of fields")
	}

	// t.Due ([48]cid.Cid) (array)

	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("t.Due: array too large (%d)", extra)
	}

	if maj != cbg.MajArray {
		return fmt.Errorf("expected cbor array")
	}

	if extra != 48 {
		return fmt.Errorf("expected array to have 48 elements")
	}

	t.Due = [48]cid.Cid{}

	for i := 0; i < int(extra); i++ {

		c, err := cbg.ReadCid(br)
		if err != nil {
			return xerrors.Errorf("reading cid field t.Due failed: %w", err)
		}
		t.Due[i] = c
	}

	return nil
}

var lengthBufDeadline = []byte{138}

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

	scratch := make([]byte, 9)

	// t.Partitions (cid.Cid) (struct)

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

	// t.ExpirationsEpochs (cid.Cid) (struct)

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

	// t.PartitionsPoSted (bitfield.BitField) (struct)
	if err := t.PartitionsPoSted.MarshalCBOR(w); err != nil {
		return err
	}

	// t.EarlyTerminations (bitfield.BitField) (struct)
	if err := t.EarlyTerminations.MarshalCBOR(w); err != nil {
		return err
	}

	// t.LiveSectors (uint64) (uint64)

	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.LiveSectors)); err != nil {
		return err
	}

	// t.TotalSectors (uint64) (uint64)

	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.TotalSectors)); err != nil {
		return err
	}

	// t.FaultyPower (miner.PowerPair) (struct)
	if err := t.FaultyPower.MarshalCBOR(w); err != nil {
		return err
	}

	// t.OptimisticPoStSubmissions (cid.Cid) (struct)

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

	// t.PartitionsSnapshot (cid.Cid) (struct)

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

	// t.OptimisticPoStSubmissionsSnapshot (cid.Cid) (struct)

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

	return nil
}

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

	br := cbg.GetPeeker(r)
	scratch := make([]byte, 8)

	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}
	if maj != cbg.MajArray {
		return fmt.Errorf("cbor input should be of type array")
	}

	if extra != 10 {
		return fmt.Errorf("cbor input had wrong number of fields")
	}

	// t.Partitions (cid.Cid) (struct)

	{

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

		t.Partitions = c

	}
	// t.ExpirationsEpochs (cid.Cid) (struct)

	{

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

		t.ExpirationsEpochs = c

	}
	// t.PartitionsPoSted (bitfield.BitField) (struct)

	{

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

	}
	// t.EarlyTerminations (bitfield.BitField) (struct)

	{

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

	}
	// t.LiveSectors (uint64) (uint64)

	{

		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
		if err != nil {
			return err
		}
		if maj != cbg.MajUnsignedInt {
			return fmt.Errorf("wrong type for uint64 field")
		}
		t.LiveSectors = uint64(extra)

	}
	// t.TotalSectors (uint64) (uint64)

	{

		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
		if err != nil {
			return err
		}
		if maj != cbg.MajUnsignedInt {
			return fmt.Errorf("wrong type for uint64 field")
		}
		t.TotalSectors = uint64(extra)

	}
	// t.FaultyPower (miner.PowerPair) (struct)

	{

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

	}
	// t.OptimisticPoStSubmissions (cid.Cid) (struct)

	{

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

		t.OptimisticPoStSubmissions = c

	}
	// t.PartitionsSnapshot (cid.Cid) (struct)

	{

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

		t.PartitionsSnapshot = c

	}
	// t.OptimisticPoStSubmissionsSnapshot (cid.Cid) (struct)

	{

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

		t.OptimisticPoStSubmissionsSnapshot = c

	}
	return nil
}

var lengthBufPartition = []byte{139}

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

	scratch := make([]byte, 9)

	// t.Sectors (bitfield.BitField) (struct)
	if err := t.Sectors.MarshalCBOR(w); err != nil {
		return err
	}

	// t.Unproven (bitfield.BitField) (struct)
	if err := t.Unproven.MarshalCBOR(w); err != nil {
		return err
	}

	// t.Faults (bitfield.BitField) (struct)
	if err := t.Faults.MarshalCBOR(w); err != nil {
		return err
	}

	// t.Recoveries (bitfield.BitField) (struct)
	if err := t.Recoveries.MarshalCBOR(w); err != nil {
		return err
	}

	// t.Terminated (bitfield.BitField) (struct)
	if err := t.Terminated.MarshalCBOR(w); err != nil {
		return err
	}

	// t.ExpirationsEpochs (cid.Cid) (struct)

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

	// t.EarlyTerminated (cid.Cid) (struct)

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

	// t.LivePower (miner.PowerPair) (struct)
	if err := t.LivePower.MarshalCBOR(w); err != nil {
		return err
	}

	// t.UnprovenPower (miner.PowerPair) (struct)
	if err := t.UnprovenPower.MarshalCBOR(w); err != nil {
		return err
	}

	// t.FaultyPower (miner.PowerPair) (struct)
	if err := t.FaultyPower.MarshalCBOR(w); err != nil {
		return err
	}

	// t.RecoveringPower (miner.PowerPair) (struct)
	if err := t.RecoveringPower.MarshalCBOR(w); err != nil {
		return err
	}
	return nil
}

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

	br := cbg.GetPeeker(r)
	scratch := make([]byte, 8)

	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}
	if maj != cbg.MajArray {
		return fmt.Errorf("cbor input should be of type array")
	}

	if extra != 11 {
		return fmt.Errorf("cbor input had wrong number of fields")
	}

	// t.Sectors (bitfield.BitField) (struct)

	{

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

	}
	// t.Unproven (bitfield.BitField) (struct)

	{

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

	}
	// t.Faults (bitfield.BitField) (struct)

	{

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

	}
	// t.Recoveries (bitfield.BitField) (struct)

	{

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

	}
	// t.Terminated (bitfield.BitField) (struct)

	{

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

	}
	// t.ExpirationsEpochs (cid.Cid) (struct)

	{

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

		t.ExpirationsEpochs = c

	}
	// t.EarlyTerminated (cid.Cid) (struct)

	{

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

		t.EarlyTerminated = c

	}
	// t.LivePower (miner.PowerPair) (struct)

	{

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

	}
	// t.UnprovenPower (miner.PowerPair) (struct)

	{

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

	}
	// t.FaultyPower (miner.PowerPair) (struct)

	{

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

	}
	// t.RecoveringPower (miner.PowerPair) (struct)

	{

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

	}
	return nil
}

var lengthBufExpirationSet = []byte{133}

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

	// t.OnTimeSectors (bitfield.BitField) (struct)
	if err := t.OnTimeSectors.MarshalCBOR(w); err != nil {
		return err
	}

	// t.EarlySectors (bitfield.BitField) (struct)
	if err := t.EarlySectors.MarshalCBOR(w); err != nil {
		return err
	}

	// t.OnTimePledge (big.Int) (struct)
	if err := t.OnTimePledge.MarshalCBOR(w); err != nil {
		return err
	}

	// t.ActivePower (miner.PowerPair) (struct)
	if err := t.ActivePower.MarshalCBOR(w); err != nil {
		return err
	}

	// t.FaultyPower (miner.PowerPair) (struct)
	if err := t.FaultyPower.MarshalCBOR(w); err != nil {
		return err
	}
	return nil
}

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

	br := cbg.GetPeeker(r)
	scratch := make([]byte, 8)

	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}
	if maj != cbg.MajArray {
		return fmt.Errorf("cbor input should be of type array")
	}

	if extra != 5 {
		return fmt.Errorf("cbor input had wrong number of fields")
	}

	// t.OnTimeSectors (bitfield.BitField) (struct)

	{

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

	}
	// t.EarlySectors (bitfield.BitField) (struct)

	{

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

	}
	// t.OnTimePledge (big.Int) (struct)

	{

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

	}
	// t.ActivePower (miner.PowerPair) (struct)

	{

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

	}
	// t.FaultyPower (miner.PowerPair) (struct)

	{

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

	}
	return nil
}

var lengthBufPowerPair = []byte{130}

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

	// t.Raw (big.Int) (struct)
	if err := t.Raw.MarshalCBOR(w); err != nil {
		return err
	}

	// t.QA (big.Int) (struct)
	if err := t.QA.MarshalCBOR(w); err != nil {
		return err
	}
	return nil
}

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

	br := cbg.GetPeeker(r)
	scratch := make([]byte, 8)

	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}
	if maj != cbg.MajArray {
		return fmt.Errorf("cbor input should be of type array")
	}

	if extra != 2 {
		return fmt.Errorf("cbor input had wrong number of fields")
	}

	// t.Raw (big.Int) (struct)

	{

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

	}
	// t.QA (big.Int) (struct)

	{

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

	}
	return nil
}

var lengthBufSectorPreCommitOnChainInfo = []byte{133}

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

	scratch := make([]byte, 9)

	// t.Info (miner.SectorPreCommitInfo) (struct)
	if err := t.Info.MarshalCBOR(w); err != nil {
		return err
	}

	// t.PreCommitDeposit (big.Int) (struct)
	if err := t.PreCommitDeposit.MarshalCBOR(w); err != nil {
		return err
	}

	// t.PreCommitEpoch (abi.ChainEpoch) (int64)
	if t.PreCommitEpoch >= 0 {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.PreCommitEpoch)); err != nil {
			return err
		}
	} else {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.PreCommitEpoch-1)); err != nil {
			return err
		}
	}

	// t.DealWeight (big.Int) (struct)
	if err := t.DealWeight.MarshalCBOR(w); err != nil {
		return err
	}

	// t.VerifiedDealWeight (big.Int) (struct)
	if err := t.VerifiedDealWeight.MarshalCBOR(w); err != nil {
		return err
	}
	return nil
}

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

	br := cbg.GetPeeker(r)
	scratch := make([]byte, 8)

	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}
	if maj != cbg.MajArray {
		return fmt.Errorf("cbor input should be of type array")
	}

	if extra != 5 {
		return fmt.Errorf("cbor input had wrong number of fields")
	}

	// t.Info (miner.SectorPreCommitInfo) (struct)

	{

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

	}
	// t.PreCommitDeposit (big.Int) (struct)

	{

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

	}
	// t.PreCommitEpoch (abi.ChainEpoch) (int64)
	{
		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
		var extraI int64
		if err != nil {
			return err
		}
		switch maj {
		case cbg.MajUnsignedInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 positive overflow")
			}
		case cbg.MajNegativeInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 negative oveflow")
			}
			extraI = -1 - extraI
		default:
			return fmt.Errorf("wrong type for int64 field: %d", maj)
		}

		t.PreCommitEpoch = abi.ChainEpoch(extraI)
	}
	// t.DealWeight (big.Int) (struct)

	{

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

	}
	// t.VerifiedDealWeight (big.Int) (struct)

	{

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

	}
	return nil
}

var lengthBufSectorPreCommitInfo = []byte{138}

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

	scratch := make([]byte, 9)

	// t.SealProof (abi.RegisteredSealProof) (int64)
	if t.SealProof >= 0 {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.SealProof)); err != nil {
			return err
		}
	} else {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.SealProof-1)); err != nil {
			return err
		}
	}

	// t.SectorNumber (abi.SectorNumber) (uint64)

	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.SectorNumber)); err != nil {
		return err
	}

	// t.SealedCID (cid.Cid) (struct)

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

	// t.SealRandEpoch (abi.ChainEpoch) (int64)
	if t.SealRandEpoch >= 0 {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.SealRandEpoch)); err != nil {
			return err
		}
	} else {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.SealRandEpoch-1)); err != nil {
			return err
		}
	}

	// t.DealIDs ([]abi.DealID) (slice)
	if len(t.DealIDs) > cbg.MaxLength {
		return xerrors.Errorf("Slice value in field t.DealIDs was too long")
	}

	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.DealIDs))); err != nil {
		return err
	}
	for _, v := range t.DealIDs {
		if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, uint64(v)); err != nil {
			return err
		}
	}

	// t.Expiration (abi.ChainEpoch) (int64)
	if t.Expiration >= 0 {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Expiration)); err != nil {
			return err
		}
	} else {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Expiration-1)); err != nil {
			return err
		}
	}

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

	// t.ReplaceSectorDeadline (uint64) (uint64)

	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.ReplaceSectorDeadline)); err != nil {
		return err
	}

	// t.ReplaceSectorPartition (uint64) (uint64)

	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.ReplaceSectorPartition)); err != nil {
		return err
	}

	// t.ReplaceSectorNumber (abi.SectorNumber) (uint64)

	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.ReplaceSectorNumber)); err != nil {
		return err
	}

	return nil
}

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

	br := cbg.GetPeeker(r)
	scratch := make([]byte, 8)

	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}
	if maj != cbg.MajArray {
		return fmt.Errorf("cbor input should be of type array")
	}

	if extra != 10 {
		return fmt.Errorf("cbor input had wrong number of fields")
	}

	// t.SealProof (abi.RegisteredSealProof) (int64)
	{
		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
		var extraI int64
		if err != nil {
			return err
		}
		switch maj {
		case cbg.MajUnsignedInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 positive overflow")
			}
		case cbg.MajNegativeInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 negative oveflow")
			}
			extraI = -1 - extraI
		default:
			return fmt.Errorf("wrong type for int64 field: %d", maj)
		}

		t.SealProof = abi.RegisteredSealProof(extraI)
	}
	// t.SectorNumber (abi.SectorNumber) (uint64)

	{

		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
		if err != nil {
			return err
		}
		if maj != cbg.MajUnsignedInt {
			return fmt.Errorf("wrong type for uint64 field")
		}
		t.SectorNumber = abi.SectorNumber(extra)

	}
	// t.SealedCID (cid.Cid) (struct)

	{

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

		t.SealedCID = c

	}
	// t.SealRandEpoch (abi.ChainEpoch) (int64)
	{
		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
		var extraI int64
		if err != nil {
			return err
		}
		switch maj {
		case cbg.MajUnsignedInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 positive overflow")
			}
		case cbg.MajNegativeInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 negative oveflow")
			}
			extraI = -1 - extraI
		default:
			return fmt.Errorf("wrong type for int64 field: %d", maj)
		}

		t.SealRandEpoch = abi.ChainEpoch(extraI)
	}
	// t.DealIDs ([]abi.DealID) (slice)

	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("t.DealIDs: array too large (%d)", extra)
	}

	if maj != cbg.MajArray {
		return fmt.Errorf("expected cbor array")
	}

	if extra > 0 {
		t.DealIDs = make([]abi.DealID, extra)
	}

	for i := 0; i < int(extra); i++ {

		maj, val, err := cbg.CborReadHeaderBuf(br, scratch)
		if err != nil {
			return xerrors.Errorf("failed to read uint64 for t.DealIDs slice: %w", err)
		}

		if maj != cbg.MajUnsignedInt {
			return xerrors.Errorf("value read for array t.DealIDs was not a uint, instead got %d", maj)
		}

		t.DealIDs[i] = abi.DealID(val)
	}

	// t.Expiration (abi.ChainEpoch) (int64)
	{
		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
		var extraI int64
		if err != nil {
			return err
		}
		switch maj {
		case cbg.MajUnsignedInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 positive overflow")
			}
		case cbg.MajNegativeInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 negative oveflow")
			}
			extraI = -1 - extraI
		default:
			return fmt.Errorf("wrong type for int64 field: %d", maj)
		}

		t.Expiration = abi.ChainEpoch(extraI)
	}
	// t.ReplaceCapacity (bool) (bool)

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

	{

		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
		if err != nil {
			return err
		}
		if maj != cbg.MajUnsignedInt {
			return fmt.Errorf("wrong type for uint64 field")
		}
		t.ReplaceSectorDeadline = uint64(extra)

	}
	// t.ReplaceSectorPartition (uint64) (uint64)

	{

		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
		if err != nil {
			return err
		}
		if maj != cbg.MajUnsignedInt {
			return fmt.Errorf("wrong type for uint64 field")
		}
		t.ReplaceSectorPartition = uint64(extra)

	}
	// t.ReplaceSectorNumber (abi.SectorNumber) (uint64)

	{

		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
		if err != nil {
			return err
		}
		if maj != cbg.MajUnsignedInt {
			return fmt.Errorf("wrong type for uint64 field")
		}
		t.ReplaceSectorNumber = abi.SectorNumber(extra)

	}
	return nil
}

var lengthBufSectorOnChainInfo = []byte{141}

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

	scratch := make([]byte, 9)

	// t.SectorNumber (abi.SectorNumber) (uint64)

	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.SectorNumber)); err != nil {
		return err
	}

	// t.SealProof (abi.RegisteredSealProof) (int64)
	if t.SealProof >= 0 {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.SealProof)); err != nil {
			return err
		}
	} else {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.SealProof-1)); err != nil {
			return err
		}
	}

	// t.SealedCID (cid.Cid) (struct)

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

	// t.DealIDs ([]abi.DealID) (slice)
	if len(t.DealIDs) > cbg.MaxLength {
		return xerrors.Errorf("Slice value in field t.DealIDs was too long")
	}

	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.DealIDs))); err != nil {
		return err
	}
	for _, v := range t.DealIDs {
		if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, uint64(v)); err != nil {
			return err
		}
	}

	// t.Activation (abi.ChainEpoch) (int64)
	if t.Activation >= 0 {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Activation)); err != nil {
			return err
		}
	} else {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Activation-1)); err != nil {
			return err
		}
	}

	// t.Expiration (abi.ChainEpoch) (int64)
	if t.Expiration >= 0 {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Expiration)); err != nil {
			return err
		}
	} else {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Expiration-1)); err != nil {
			return err
		}
	}

	// t.DealWeight (big.Int) (struct)
	if err := t.DealWeight.MarshalCBOR(w); err != nil {
		return err
	}

	// t.VerifiedDealWeight (big.Int) (struct)
	if err := t.VerifiedDealWeight.MarshalCBOR(w); err != nil {
		return err
	}

	// t.InitialPledge (big.Int) (struct)
	if err := t.InitialPledge.MarshalCBOR(w); err != nil {
		return err
	}

	// t.ExpectedDayReward (big.Int) (struct)
	if err := t.ExpectedDayReward.MarshalCBOR(w); err != nil {
		return err
	}

	// t.ExpectedStoragePledge (big.Int) (struct)
	if err := t.ExpectedStoragePledge.MarshalCBOR(w); err != nil {
		return err
	}

	// t.ReplacedSectorAge (abi.ChainEpoch) (int64)
	if t.ReplacedSectorAge >= 0 {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.ReplacedSectorAge)); err != nil {
			return err
		}
	} else {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.ReplacedSectorAge-1)); err != nil {
			return err
		}
	}

	// t.ReplacedDayReward (big.Int) (struct)
	if err := t.ReplacedDayReward.MarshalCBOR(w); err != nil {
		return err
	}
	return nil
}

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

	br := cbg.GetPeeker(r)
	scratch := make([]byte, 8)

	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}
	if maj != cbg.MajArray {
		return fmt.Errorf("cbor input should be of type array")
	}

	if extra != 13 {
		return fmt.Errorf("cbor input had wrong number of fields")
	}

	// t.SectorNumber (abi.SectorNumber) (uint64)

	{

		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
		if err != nil {
			return err
		}
		if maj != cbg.MajUnsignedInt {
			return fmt.Errorf("wrong type for uint64 field")
		}
		t.SectorNumber = abi.SectorNumber(extra)

	}
	// t.SealProof (abi.RegisteredSealProof) (int64)
	{
		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
		var extraI int64
		if err != nil {
			return err
		}
		switch maj {
		case cbg.MajUnsignedInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 positive overflow")
			}
		case cbg.MajNegativeInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 negative oveflow")
			}
			extraI = -1 - extraI
		default:
			return fmt.Errorf("wrong type for int64 field: %d", maj)
		}

		t.SealProof = abi.RegisteredSealProof(extraI)
	}
	// t.SealedCID (cid.Cid) (struct)

	{

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

		t.SealedCID = c

	}
	// t.DealIDs ([]abi.DealID) (slice)

	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("t.DealIDs: array too large (%d)", extra)
	}

	if maj != cbg.MajArray {
		return fmt.Errorf("expected cbor array")
	}

	if extra > 0 {
		t.DealIDs = make([]abi.DealID, extra)
	}

	for i := 0; i < int(extra); i++ {

		maj, val, err := cbg.CborReadHeaderBuf(br, scratch)
		if err != nil {
			return xerrors.Errorf("failed to read uint64 for t.DealIDs slice: %w", err)
		}

		if maj != cbg.MajUnsignedInt {
			return xerrors.Errorf("value read for array t.DealIDs was not a uint, instead got %d", maj)
		}

		t.DealIDs[i] = abi.DealID(val)
	}

	// t.Activation (abi.ChainEpoch) (int64)
	{
		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
		var extraI int64
		if err != nil {
			return err
		}
		switch maj {
		case cbg.MajUnsignedInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 positive overflow")
			}
		case cbg.MajNegativeInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 negative oveflow")
			}
			extraI = -1 - extraI
		default:
			return fmt.Errorf("wrong type for int64 field: %d", maj)
		}

		t.Activation = abi.ChainEpoch(extraI)
	}
	// t.Expiration (abi.ChainEpoch) (int64)
	{
		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
		var extraI int64
		if err != nil {
			return err
		}
		switch maj {
		case cbg.MajUnsignedInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 positive overflow")
			}
		case cbg.MajNegativeInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 negative oveflow")
			}
			extraI = -1 - extraI
		default:
			return fmt.Errorf("wrong type for int64 field: %d", maj)
		}

		t.Expiration = abi.ChainEpoch(extraI)
	}
	// t.DealWeight (big.Int) (struct)

	{

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

	}
	// t.VerifiedDealWeight (big.Int) (struct)

	{

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

	}
	// t.InitialPledge (big.Int) (struct)

	{

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

	}
	// t.ExpectedDayReward (big.Int) (struct)

	{

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

	}
	// t.ExpectedStoragePledge (big.Int) (struct)

	{

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

	}
	// t.ReplacedSectorAge (abi.ChainEpoch) (int64)
	{
		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
		var extraI int64
		if err != nil {
			return err
		}
		switch maj {
		case cbg.MajUnsignedInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 positive overflow")
			}
		case cbg.MajNegativeInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 negative oveflow")
			}
			extraI = -1 - extraI
		default:
			return fmt.Errorf("wrong type for int64 field: %d", maj)
		}

		t.ReplacedSectorAge = abi.ChainEpoch(extraI)
	}
	// t.ReplacedDayReward (big.Int) (struct)

	{

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

	}
	return nil
}

var lengthBufWorkerKeyChange = []byte{130}

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

	scratch := make([]byte, 9)

	// t.NewWorker (address.Address) (struct)
	if err := t.NewWorker.MarshalCBOR(w); err != nil {
		return err
	}

	// t.EffectiveAt (abi.ChainEpoch) (int64)
	if t.EffectiveAt >= 0 {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.EffectiveAt)); err != nil {
			return err
		}
	} else {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.EffectiveAt-1)); err != nil {
			return err
		}
	}
	return nil
}

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

	br := cbg.GetPeeker(r)
	scratch := make([]byte, 8)

	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}
	if maj != cbg.MajArray {
		return fmt.Errorf("cbor input should be of type array")
	}

	if extra != 2 {
		return fmt.Errorf("cbor input had wrong number of fields")
	}

	// t.NewWorker (address.Address) (struct)

	{

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

	}
	// t.EffectiveAt (abi.ChainEpoch) (int64)
	{
		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
		var extraI int64
		if err != nil {
			return err
		}
		switch maj {
		case cbg.MajUnsignedInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 positive overflow")
			}
		case cbg.MajNegativeInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 negative oveflow")
			}
			extraI = -1 - extraI
		default:
			return fmt.Errorf("wrong type for int64 field: %d", maj)
		}

		t.EffectiveAt = abi.ChainEpoch(extraI)
	}
	return nil
}

var lengthBufVestingFunds = []byte{129}

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

	scratch := make([]byte, 9)

	// t.Funds ([]miner.VestingFund) (slice)
	if len(t.Funds) > cbg.MaxLength {
		return xerrors.Errorf("Slice value in field t.Funds was too long")
	}

	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Funds))); err != nil {
		return err
	}
	for _, v := range t.Funds {
		if err := v.MarshalCBOR(w); err != nil {
			return err
		}
	}
	return nil
}

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

	br := cbg.GetPeeker(r)
	scratch := make([]byte, 8)

	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}
	if maj != cbg.MajArray {
		return fmt.Errorf("cbor input should be of type array")
	}

	if extra != 1 {
		return fmt.Errorf("cbor input had wrong number of fields")
	}

	// t.Funds ([]miner.VestingFund) (slice)

	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("t.Funds: array too large (%d)", extra)
	}

	if maj != cbg.MajArray {
		return fmt.Errorf("expected cbor array")
	}

	if extra > 0 {
		t.Funds = make([]VestingFund, extra)
	}

	for i := 0; i < int(extra); i++ {

		var v VestingFund
		if err := v.UnmarshalCBOR(br); err != nil {
			return err
		}

		t.Funds[i] = v
	}

	return nil
}

var lengthBufVestingFund = []byte{130}

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

	scratch := make([]byte, 9)

	// t.Epoch (abi.ChainEpoch) (int64)
	if t.Epoch >= 0 {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Epoch)); err != nil {
			return err
		}
	} else {
		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Epoch-1)); err != nil {
			return err
		}
	}

	// t.Amount (big.Int) (struct)
	if err := t.Amount.MarshalCBOR(w); err != nil {
		return err
	}
	return nil
}

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

	br := cbg.GetPeeker(r)
	scratch := make([]byte, 8)

	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}
	if maj != cbg.MajArray {
		return fmt.Errorf("cbor input should be of type array")
	}

	if extra != 2 {
		return fmt.Errorf("cbor input had wrong number of fields")
	}

	// t.Epoch (abi.ChainEpoch) (int64)
	{
		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
		var extraI int64
		if err != nil {
			return err
		}
		switch maj {
		case cbg.MajUnsignedInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 positive overflow")
			}
		case cbg.MajNegativeInt:
			extraI = int64(extra)
			if extraI < 0 {
				return fmt.Errorf("int64 negative oveflow")
			}
			extraI = -1 - extraI
		default:
			return fmt.Errorf("wrong type for int64 field: %d", maj)
		}

		t.Epoch = abi.ChainEpoch(extraI)
	}
	// t.Amount (big.Int) (struct)

	{

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

	}
	return nil
}

var lengthBufWindowedPoSt = []byte{130}

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

	scratch := make([]byte, 9)

	// t.Partitions (bitfield.BitField) (struct)
	if err := t.Partitions.MarshalCBOR(w); err != nil {
		return err
	}

	// t.Proofs ([]proof.PoStProof) (slice)
	if len(t.Proofs) > cbg.MaxLength {
		return xerrors.Errorf("Slice value in field t.Proofs was too long")
	}

	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Proofs))); err != nil {
		return err
	}
	for _, v := range t.Proofs {
		if err := v.MarshalCBOR(w); err != nil {
			return err
		}
	}
	return nil
}

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

	br := cbg.GetPeeker(r)
	scratch := make([]byte, 8)

	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}
	if maj != cbg.MajArray {
		return fmt.Errorf("cbor input should be of type array")
	}

	if extra != 2 {
		return fmt.Errorf("cbor input had wrong number of fields")
	}

	// t.Partitions (bitfield.BitField) (struct)

	{

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

	}
	// t.Proofs ([]proof.PoStProof) (slice)

	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("t.Proofs: array too large (%d)", extra)
	}

	if maj != cbg.MajArray {
		return fmt.Errorf("expected cbor array")
	}

	if extra > 0 {
		t.Proofs = make([]proof.PoStProof, extra)
	}

	for i := 0; i < int(extra); i++ {

		var v proof.PoStProof
		if err := v.UnmarshalCBOR(br); err != nil {
			return err
		}

		t.Proofs[i] = v
	}

	return nil
}

var lengthBufProveCommitAggregateParams = []byte{130}

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

	scratch := make([]byte, 9)

	// t.SectorNumbers (bitfield.BitField) (struct)
	if err := t.SectorNumbers.MarshalCBOR(w); err != nil {
		return err
	}

	// t.AggregateProof ([]uint8) (slice)
	if len(t.AggregateProof) > cbg.ByteArrayMaxLen {
		return xerrors.Errorf("Byte array in field t.AggregateProof was too long")
	}

	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.AggregateProof))); err != nil {
		return err
	}

	if _, err := w.Write(t.AggregateProof[:]); err != nil {
		return err
	}
	return nil
}

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

	br := cbg.GetPeeker(r)
	scratch := make([]byte, 8)

	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}
	if maj != cbg.MajArray {
		return fmt.Errorf("cbor input should be of type array")
	}

	if extra != 2 {
		return fmt.Errorf("cbor input had wrong number of fields")
	}

	// t.SectorNumbers (bitfield.BitField) (struct)

	{

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

	}
	// t.AggregateProof ([]uint8) (slice)

	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}

	if extra > cbg.ByteArrayMaxLen {
		return fmt.Errorf("t.AggregateProof: byte array too large (%d)", extra)
	}
	if maj != cbg.MajByteString {
		return fmt.Errorf("expected byte array")
	}

	if extra > 0 {
		t.AggregateProof = make([]uint8, extra)
	}

	if _, err := io.ReadFull(br, t.AggregateProof[:]); err != nil {
		return err
	}
	return nil
}

var lengthBufPreCommitSectorBatchParams = []byte{129}

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

	scratch := make([]byte, 9)

	// t.Sectors ([]miner.SectorPreCommitInfo) (slice)
	if len(t.Sectors) > cbg.MaxLength {
		return xerrors.Errorf("Slice value in field t.Sectors was too long")
	}

	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Sectors))); err != nil {
		return err
	}
	for _, v := range t.Sectors {
		if err := v.MarshalCBOR(w); err != nil {
			return err
		}
	}
	return nil
}

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

	br := cbg.GetPeeker(r)
	scratch := make([]byte, 8)

	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}
	if maj != cbg.MajArray {
		return fmt.Errorf("cbor input should be of type array")
	}

	if extra != 1 {
		return fmt.Errorf("cbor input had wrong number of fields")
	}

	// t.Sectors ([]miner.SectorPreCommitInfo) (slice)

	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
	if err != nil {
		return err
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("t.Sectors: array too large (%d)", extra)
	}

	if maj != cbg.MajArray {
		return fmt.Errorf("expected cbor array")
	}

	if extra > 0 {
		t.Sectors = make([]miner.SectorPreCommitInfo, extra)
	}

	for i := 0; i < int(extra); i++ {

		var v miner.SectorPreCommitInfo
		if err := v.UnmarshalCBOR(br); err != nil {
			return err
		}

		t.Sectors[i] = v
	}

	return nil
}