package blockstore

import (
        "context"

        blocks "github.com/ipfs/go-block-format"
        "github.com/ipfs/go-cid"
        "golang.org/x/xerrors"
)

type ChainIO interface {
        ChainReadObj(context.Context, cid.Cid) ([]byte, error)
        ChainHasObj(context.Context, cid.Cid) (bool, error)
        ChainPutObj(context.Context, blocks.Block) error
}

type apiBlockstore struct {
        api ChainIO
}

// This blockstore is adapted in the constructor.
var _ BasicBlockstore = (*apiBlockstore)(nil)

func NewAPIBlockstore(cio ChainIO) Blockstore {
        bs := &apiBlockstore{api: cio}
        return Adapt(bs) // return an adapted blockstore.
}

func (a *apiBlockstore) DeleteBlock(context.Context, cid.Cid) error {
        return xerrors.New("not supported")
}

func (a *apiBlockstore) Has(ctx context.Context, c cid.Cid) (bool, error) {
        return a.api.ChainHasObj(ctx, c)
}

func (a *apiBlockstore) Get(ctx context.Context, c cid.Cid) (blocks.Block, error) {
        bb, err := a.api.ChainReadObj(ctx, c)
        if err != nil {
                return nil, err
        }
        return blocks.NewBlockWithCid(bb, c)
}

func (a *apiBlockstore) GetSize(ctx context.Context, c cid.Cid) (int, error) {
        bb, err := a.api.ChainReadObj(ctx, c)
        if err != nil {
                return 0, err
        }
        return len(bb), nil
}

func (a *apiBlockstore) Put(ctx context.Context, block blocks.Block) error {
        return a.api.ChainPutObj(ctx, block)
}

func (a *apiBlockstore) PutMany(ctx context.Context, blocks []blocks.Block) error {
        for _, block := range blocks {
                err := a.api.ChainPutObj(ctx, block)
                if err != nil {
                        return err
                }
        }
        return nil
}

func (a *apiBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
        return nil, xerrors.New("not supported")
}

func (a *apiBlockstore) HashOnRead(enabled bool) {
        return
}

package blockstore

import (
        "context"
        "sync"
        "time"

        block "github.com/ipfs/go-block-format"
        "github.com/ipfs/go-cid"
        ipld "github.com/ipfs/go-ipld-format"
        "golang.org/x/xerrors"
)

// autolog is a logger for the autobatching blockstore. It is subscoped from the
// blockstore logger.
var autolog = log.Named("auto")

// contains the same set of blocks twice, once as an ordered list for flushing, and as a map for fast access
type blockBatch struct {
        blockList []block.Block
        blockMap  map[cid.Cid]block.Block
}

type AutobatchBlockstore struct {
        // TODO: drop if memory consumption is too high
        addedCids map[cid.Cid]struct{}

        stateLock     sync.Mutex
        bufferedBatch blockBatch

        flushingBatch blockBatch
        flushErr      error

        flushCh chan struct{}

        doFlushLock     sync.Mutex
        flushRetryDelay time.Duration
        doneCh          chan struct{}
        shutdown        context.CancelFunc

        backingBs Blockstore

        bufferCapacity int
        bufferSize     int
}

func NewAutobatch(ctx context.Context, backingBs Blockstore, bufferCapacity int) *AutobatchBlockstore {
        ctx, cancel := context.WithCancel(ctx)
        bs := &AutobatchBlockstore{
                addedCids:      make(map[cid.Cid]struct{}),
                backingBs:      backingBs,
                bufferCapacity: bufferCapacity,
                flushCh:        make(chan struct{}, 1),
                doneCh:         make(chan struct{}),
                // could be made configable
                flushRetryDelay: time.Millisecond * 100,
                shutdown:        cancel,
        }

        bs.bufferedBatch.blockMap = make(map[cid.Cid]block.Block)

        go bs.flushWorker(ctx)

        return bs
}

func (bs *AutobatchBlockstore) Put(ctx context.Context, blk block.Block) error {
        bs.stateLock.Lock()
        defer bs.stateLock.Unlock()

        _, ok := bs.addedCids[blk.Cid()]
        if !ok {
                bs.addedCids[blk.Cid()] = struct{}{}
                bs.bufferedBatch.blockList = append(bs.bufferedBatch.blockList, blk)
                bs.bufferedBatch.blockMap[blk.Cid()] = blk
                bs.bufferSize += len(blk.RawData())
                if bs.bufferSize >= bs.bufferCapacity {
                        // signal that a flush is appropriate, may be ignored
                        select {
                        case bs.flushCh <- struct{}{}:
                        default:
                                // do nothing
                        }
                }
        }

        return nil
}

func (bs *AutobatchBlockstore) flushWorker(ctx context.Context) {
        defer close(bs.doneCh)
        for {
                select {
                case <-bs.flushCh:
                        // TODO: check if we _should_ actually flush. We could get a spurious wakeup
                        // here.
                        putErr := bs.doFlush(ctx, false)
                        for putErr != nil {
                                select {
                                case <-ctx.Done():
                                        return
                                case <-time.After(bs.flushRetryDelay):
                                        autolog.Errorf("FLUSH ERRORED: %w, retrying after %v", putErr, bs.flushRetryDelay)
                                        putErr = bs.doFlush(ctx, true)
                                }
                        }
                case <-ctx.Done():
                        // Do one last flush.
                        _ = bs.doFlush(ctx, false)
                        return
                }
        }
}

// caller must NOT hold stateLock
// set retryOnly to true to only retry a failed flush and not flush anything new.
func (bs *AutobatchBlockstore) doFlush(ctx context.Context, retryOnly bool) error {
        bs.doFlushLock.Lock()
        defer bs.doFlushLock.Unlock()

        // If we failed to flush last time, try flushing again.
        if bs.flushErr != nil {
                bs.flushErr = bs.backingBs.PutMany(ctx, bs.flushingBatch.blockList)
        }

        // If we failed, or we're _only_ retrying, bail.
        if retryOnly || bs.flushErr != nil {
                return bs.flushErr
        }

        // Then take the current batch...
        bs.stateLock.Lock()
        // We do NOT clear addedCids here, because its purpose is to expedite Puts
        bs.flushingBatch = bs.bufferedBatch
        bs.bufferedBatch.blockList = make([]block.Block, 0, len(bs.flushingBatch.blockList))
        bs.bufferedBatch.blockMap = make(map[cid.Cid]block.Block, len(bs.flushingBatch.blockMap))
        bs.stateLock.Unlock()

        // And try to flush it.
        bs.flushErr = bs.backingBs.PutMany(ctx, bs.flushingBatch.blockList)

        // If we succeeded, reset the batch. Otherwise, we'll try again next time.
        if bs.flushErr == nil {
                bs.stateLock.Lock()
                bs.flushingBatch = blockBatch{}
                bs.stateLock.Unlock()
        }

        return bs.flushErr
}

// caller must NOT hold stateLock
func (bs *AutobatchBlockstore) Flush(ctx context.Context) error {
        return bs.doFlush(ctx, false)
}

func (bs *AutobatchBlockstore) Shutdown(ctx context.Context) error {
        // TODO: Prevent puts after we call this to avoid losing data.
        bs.shutdown()
        select {
        case <-bs.doneCh:
        case <-ctx.Done():
                return ctx.Err()
        }

        bs.doFlushLock.Lock()
        defer bs.doFlushLock.Unlock()

        return bs.flushErr
}

func (bs *AutobatchBlockstore) Get(ctx context.Context, c cid.Cid) (block.Block, error) {
        // may seem backward to check the backingBs first, but that is the likeliest case
        blk, err := bs.backingBs.Get(ctx, c)
        if err == nil {
                return blk, nil
        }

        if !ipld.IsNotFound(err) {
                return blk, err
        }

        bs.stateLock.Lock()
        v, ok := bs.flushingBatch.blockMap[c]
        if ok {
                bs.stateLock.Unlock()
                return v, nil
        }

        v, ok = bs.bufferedBatch.blockMap[c]
        if ok {
                bs.stateLock.Unlock()
                return v, nil
        }
        bs.stateLock.Unlock()

        // We have to check the backing store one more time because it may have been flushed by the
        // time we were able to take the lock above.
        return bs.backingBs.Get(ctx, c)
}

func (bs *AutobatchBlockstore) DeleteBlock(context.Context, cid.Cid) error {
        // if we wanted to support this, we would have to:
        // - flush
        // - delete from the backingBs (if present)
        // - remove from addedCids (if present)
        // - if present in addedCids, also walk the ordered lists and remove if present
        return xerrors.New("deletion is unsupported")
}

func (bs *AutobatchBlockstore) DeleteMany(ctx context.Context, cids []cid.Cid) error {
        // see note in DeleteBlock()
        return xerrors.New("deletion is unsupported")
}

func (bs *AutobatchBlockstore) Has(ctx context.Context, c cid.Cid) (bool, error) {
        _, err := bs.Get(ctx, c)
        if err == nil {
                return true, nil
        }
        if ipld.IsNotFound(err) {
                return false, nil
        }

        return false, err
}

func (bs *AutobatchBlockstore) GetSize(ctx context.Context, c cid.Cid) (int, error) {
        blk, err := bs.Get(ctx, c)
        if err != nil {
                return 0, err
        }

        return len(blk.RawData()), nil
}

func (bs *AutobatchBlockstore) PutMany(ctx context.Context, blks []block.Block) error {
        for _, blk := range blks {
                if err := bs.Put(ctx, blk); err != nil {
                        return err
                }
        }

        return nil
}

func (bs *AutobatchBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
        if err := bs.Flush(ctx); err != nil {
                return nil, err
        }

        return bs.backingBs.AllKeysChan(ctx)
}

func (bs *AutobatchBlockstore) HashOnRead(enabled bool) {
        bs.backingBs.HashOnRead(enabled)
}

func (bs *AutobatchBlockstore) View(ctx context.Context, cid cid.Cid, callback func([]byte) error) error {
        blk, err := bs.Get(ctx, cid)
        if err != nil {
                return err
        }

        return callback(blk.RawData())
}

package blockstore

import (
        "context"
        "time"

        blockstore "github.com/ipfs/boxo/blockstore"
        "github.com/ipfs/go-cid"
        ds "github.com/ipfs/go-datastore"
        logging "github.com/ipfs/go-log/v2"
)

var log = logging.Logger("blockstore")

// Blockstore is the blockstore interface used by Lotus. It is the union
// of the basic go-ipfs blockstore, with other capabilities required by Lotus,
// e.g. View or Sync.
type Blockstore interface {
        blockstore.Blockstore
        blockstore.Viewer
        BatchDeleter
        Flusher
}

// BasicBlockstore is an alias to the original IPFS Blockstore.
type BasicBlockstore = blockstore.Blockstore

type Viewer = blockstore.Viewer

type Flusher interface {
        Flush(context.Context) error
}

type BatchDeleter interface {
        DeleteMany(ctx context.Context, cids []cid.Cid) error
}

// BlockstoreIterator is a trait for efficient iteration
type BlockstoreIterator interface {
        ForEachKey(func(cid.Cid) error) error
}

// BlockstoreGC is a trait for blockstores that support online garbage collection
type BlockstoreGC interface {
        CollectGarbage(ctx context.Context, options ...BlockstoreGCOption) error
}

// BlockstoreGCOnce is a trait for a blockstore that supports incremental online garbage collection
type BlockstoreGCOnce interface {
        GCOnce(ctx context.Context, options ...BlockstoreGCOption) error
}

// BlockstoreGCOption is a functional interface for controlling blockstore GC options
type BlockstoreGCOption = func(*BlockstoreGCOptions) error

// BlockstoreGCOptions is a struct with GC options
type BlockstoreGCOptions struct {
        FullGC bool
        // fraction of garbage in badger vlog before its worth processing in online GC
        Threshold float64
        // how often to call the check function
        CheckFreq time.Duration
        // function to call periodically to pause or early terminate GC
        Check func() error
}

func WithFullGC(fullgc bool) BlockstoreGCOption {
        return func(opts *BlockstoreGCOptions) error {
                opts.FullGC = fullgc
                return nil
        }
}

func WithThreshold(threshold float64) BlockstoreGCOption {
        return func(opts *BlockstoreGCOptions) error {
                opts.Threshold = threshold
                return nil
        }
}

func WithCheckFreq(f time.Duration) BlockstoreGCOption {
        return func(opts *BlockstoreGCOptions) error {
                opts.CheckFreq = f
                return nil
        }
}

func WithCheck(check func() error) BlockstoreGCOption {
        return func(opts *BlockstoreGCOptions) error {
                opts.Check = check
                return nil
        }
}

// BlockstoreSize is a trait for on-disk blockstores that can report their size
type BlockstoreSize interface {
        Size() (int64, error)
}

// WrapIDStore wraps the underlying blockstore in an "identity" blockstore.
// The ID store filters out all puts for blocks with CIDs using the "identity"
// hash function. It also extracts inlined blocks from CIDs using the identity
// hash function and returns them on get/has, ignoring the contents of the
// blockstore.
func WrapIDStore(bstore blockstore.Blockstore) Blockstore {
        if is, ok := bstore.(*idstore); ok {
                // already wrapped
                return is
        }

        if bs, ok := bstore.(Blockstore); ok {
                // we need to wrap our own because we don't want to neuter the DeleteMany method
                // the underlying blockstore has implemented an (efficient) DeleteMany
                return NewIDStore(bs)
        }

        // The underlying blockstore does not implement DeleteMany, so we need to shim it.
        // This is less efficient as it'll iterate and perform single deletes.
        return NewIDStore(Adapt(bstore))
}

// FromDatastore creates a new blockstore backed by the given datastore.
func FromDatastore(dstore ds.Batching) Blockstore {
        return WrapIDStore(blockstore.NewBlockstore(dstore))
}

type adaptedBlockstore struct {
        blockstore.Blockstore
}

var _ Blockstore = (*adaptedBlockstore)(nil)

func (a *adaptedBlockstore) Flush(ctx context.Context) error {
        if flusher, canFlush := a.Blockstore.(Flusher); canFlush {
                return flusher.Flush(ctx)
        }
        return nil
}

func (a *adaptedBlockstore) View(ctx context.Context, cid cid.Cid, callback func([]byte) error) error {
        blk, err := a.Get(ctx, cid)
        if err != nil {
                return err
        }
        return callback(blk.RawData())
}

func (a *adaptedBlockstore) DeleteMany(ctx context.Context, cids []cid.Cid) error {
        for _, cid := range cids {
                err := a.DeleteBlock(ctx, cid)
                if err != nil {
                        return err
                }
        }

        return nil
}

// Adapt adapts a standard blockstore to a Lotus blockstore by
// enriching it with the extra methods that Lotus requires (e.g. View, Sync).
//
// View proxies over to Get and calls the callback with the value supplied by Get.
// Sync noops.
func Adapt(bs blockstore.Blockstore) Blockstore {
        if ret, ok := bs.(Blockstore); ok {
                return ret
        }
        return &adaptedBlockstore{bs}
}

package blockstore

import (
        "context"
        "os"

        block "github.com/ipfs/go-block-format"
        "github.com/ipfs/go-cid"
        ipld "github.com/ipfs/go-ipld-format"
)

// buflog is a logger for the buffered blockstore. It is subscoped from the
// blockstore logger.
var buflog = log.Named("buf")

type BufferedBlockstore struct {
        read  Blockstore
        write Blockstore
}

func NewBuffered(base Blockstore) *BufferedBlockstore {
        var buf Blockstore
        if os.Getenv("LOTUS_DISABLE_VM_BUF") == "iknowitsabadidea" {
                buflog.Warn("VM BLOCKSTORE BUFFERING IS DISABLED")
                buf = base
        } else {
                buf = NewMemory()
        }

        bs := &BufferedBlockstore{
                read:  base,
                write: buf,
        }
        return bs
}

func NewTieredBstore(r Blockstore, w Blockstore) *BufferedBlockstore {
        return &BufferedBlockstore{
                read:  r,
                write: w,
        }
}

var (
        _ Blockstore = (*BufferedBlockstore)(nil)
        _ Viewer     = (*BufferedBlockstore)(nil)
)

func (bs *BufferedBlockstore) Flush(ctx context.Context) error { return bs.write.Flush(ctx) }

func (bs *BufferedBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
        a, err := bs.read.AllKeysChan(ctx)
        if err != nil {
                return nil, err
        }

        b, err := bs.write.AllKeysChan(ctx)
        if err != nil {
                return nil, err
        }

        out := make(chan cid.Cid)
        go func() {
                defer close(out)
                for a != nil || b != nil {
                        select {
                        case val, ok := <-a:
                                if !ok {
                                        a = nil
                                } else {
                                        select {
                                        case out <- val:
                                        case <-ctx.Done():
                                                return
                                        }
                                }
                        case val, ok := <-b:
                                if !ok {
                                        b = nil
                                } else {
                                        select {
                                        case out <- val:
                                        case <-ctx.Done():
                                                return
                                        }
                                }
                        }
                }
        }()

        return out, nil
}

func (bs *BufferedBlockstore) DeleteBlock(ctx context.Context, c cid.Cid) error {
        if err := bs.read.DeleteBlock(ctx, c); err != nil {
                return err
        }

        return bs.write.DeleteBlock(ctx, c)
}

func (bs *BufferedBlockstore) DeleteMany(ctx context.Context, cids []cid.Cid) error {
        if err := bs.read.DeleteMany(ctx, cids); err != nil {
                return err
        }

        return bs.write.DeleteMany(ctx, cids)
}

func (bs *BufferedBlockstore) View(ctx context.Context, c cid.Cid, callback func([]byte) error) error {
        // both stores are viewable.
        if err := bs.write.View(ctx, c, callback); !ipld.IsNotFound(err) {
                return err // propagate errors, or nil, i.e. found.
        } // else not found in write blockstore; fall through.
        return bs.read.View(ctx, c, callback)
}

func (bs *BufferedBlockstore) Get(ctx context.Context, c cid.Cid) (block.Block, error) {
        if out, err := bs.write.Get(ctx, c); err != nil {
                if !ipld.IsNotFound(err) {
                        return nil, err
                }
        } else {
                return out, nil
        }

        return bs.read.Get(ctx, c)
}

func (bs *BufferedBlockstore) GetSize(ctx context.Context, c cid.Cid) (int, error) {
        s, err := bs.read.GetSize(ctx, c)
        if ipld.IsNotFound(err) || s == 0 {
                return bs.write.GetSize(ctx, c)
        }

        return s, err
}

func (bs *BufferedBlockstore) Put(ctx context.Context, blk block.Block) error {
        has, err := bs.read.Has(ctx, blk.Cid()) // TODO: consider dropping this check
        if err != nil {
                return err
        }

        if has {
                return nil
        }

        return bs.write.Put(ctx, blk)
}

func (bs *BufferedBlockstore) Has(ctx context.Context, c cid.Cid) (bool, error) {
        has, err := bs.write.Has(ctx, c)
        if err != nil {
                return false, err
        }
        if has {
                return true, nil
        }

        return bs.read.Has(ctx, c)
}

func (bs *BufferedBlockstore) HashOnRead(hor bool) {
        bs.read.HashOnRead(hor)
        bs.write.HashOnRead(hor)
}

func (bs *BufferedBlockstore) PutMany(ctx context.Context, blks []block.Block) error {
        return bs.write.PutMany(ctx, blks)
}

func (bs *BufferedBlockstore) Read() Blockstore {
        return bs.read
}

package blockstore

import (
        "context"

        blocks "github.com/ipfs/go-block-format"
        "github.com/ipfs/go-cid"
)

// BlockstoreCache is a cache for blocks, compatible with lru.Cache; Must be safe for concurrent access
type BlockstoreCache interface {
        Remove(mhString MhString) bool
        Contains(mhString MhString) bool
        Get(mhString MhString) (blocks.Block, bool)
        Add(mhString MhString, block blocks.Block) (evicted bool)
}

type ReadCachedBlockstore struct {
        top   Blockstore
        cache BlockstoreCache
}

type MhString string

func NewReadCachedBlockstore(top Blockstore, cache BlockstoreCache) *ReadCachedBlockstore {
        return &ReadCachedBlockstore{
                top:   top,
                cache: cache,
        }
}

func (c *ReadCachedBlockstore) DeleteBlock(ctx context.Context, cid cid.Cid) error {
        c.cache.Remove(MhString(cid.Hash()))
        return c.top.DeleteBlock(ctx, cid)
}

func (c *ReadCachedBlockstore) Has(ctx context.Context, cid cid.Cid) (bool, error) {
        if c.cache.Contains(MhString(cid.Hash())) {
                return true, nil
        }

        return c.top.Has(ctx, cid)
}

func (c *ReadCachedBlockstore) Get(ctx context.Context, cid cid.Cid) (blocks.Block, error) {
        if out, ok := c.cache.Get(MhString(cid.Hash())); ok {
                return out, nil
        }

        out, err := c.top.Get(ctx, cid)
        if err != nil {
                return nil, err
        }

        c.cache.Add(MhString(cid.Hash()), out)
        return out, nil
}

func (c *ReadCachedBlockstore) GetSize(ctx context.Context, cid cid.Cid) (int, error) {
        if b, ok := c.cache.Get(MhString(cid.Hash())); ok {
                return len(b.RawData()), nil
        }

        return c.top.GetSize(ctx, cid)
}

func (c *ReadCachedBlockstore) Put(ctx context.Context, block blocks.Block) error {
        c.cache.Add(MhString(block.Cid().Hash()), block)
        return c.top.Put(ctx, block)
}

func (c *ReadCachedBlockstore) PutMany(ctx context.Context, blocks []blocks.Block) error {
        for _, b := range blocks {
                c.cache.Add(MhString(b.Cid().Hash()), b)
        }

        return c.top.PutMany(ctx, blocks)
}

func (c *ReadCachedBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
        return c.top.AllKeysChan(ctx)
}

func (c *ReadCachedBlockstore) HashOnRead(enabled bool) {
        c.top.HashOnRead(enabled)
}

func (c *ReadCachedBlockstore) View(ctx context.Context, cid cid.Cid, callback func([]byte) error) error {
        return c.top.View(ctx, cid, func(bb []byte) error {
                blk, err := blocks.NewBlockWithCid(bb, cid)
                if err != nil {
                        return err
                }

                c.cache.Add(MhString(cid.Hash()), blk)

                return callback(bb)
        })
}

func (c *ReadCachedBlockstore) DeleteMany(ctx context.Context, cids []cid.Cid) error {
        for _, ci := range cids {
                c.cache.Remove(MhString(ci.Hash()))
        }

        return c.top.DeleteMany(ctx, cids)
}

func (c *ReadCachedBlockstore) Flush(ctx context.Context) error {
        return c.top.Flush(ctx)
}

var _ Blockstore = (*ReadCachedBlockstore)(nil)

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

package blockstore

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

        cid "github.com/ipfs/go-cid"
        cbg "github.com/whyrusleeping/cbor-gen"
        xerrors "golang.org/x/xerrors"
)

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

var lengthBufNetRpcReq = []byte{132}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufNetRpcReq); err != nil {
                return err
        }

        // t.Type (blockstore.NetRPCReqType) (uint8)
        if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Type)); err != nil {
                return err
        }

        // t.ID (uint64) (uint64)

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

        // t.Cid ([]cid.Cid) (slice)
        if len(t.Cid) > 8192 {
                return xerrors.Errorf("Slice value in field t.Cid was too long")
        }

        if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Cid))); err != nil {
                return err
        }
        for _, v := range t.Cid {

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

        }

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

        if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Data))); err != nil {
                return err
        }
        for _, v := range t.Data {
                if len(v) > 2097152 {
                        return xerrors.Errorf("Byte array in field v was too long")
                }

                if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(v))); err != nil {
                        return err
                }

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

        }
        return nil
}

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

        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.MajArray {
                return fmt.Errorf("cbor input should be of type array")
        }

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

        // t.Type (blockstore.NetRPCReqType) (uint8)

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }
        if maj != cbg.MajUnsignedInt {
                return fmt.Errorf("wrong type for uint8 field")
        }
        if extra > math.MaxUint8 {
                return fmt.Errorf("integer in input was too large for uint8 field")
        }
        t.Type = NetRPCReqType(extra)
        // t.ID (uint64) (uint64)

        {

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

        }
        // t.Cid ([]cid.Cid) (slice)

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

        if extra > 0 {
                t.Cid = make([]cid.Cid, extra)
        }

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

                        {

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

                                t.Cid[i] = c

                        }

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

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

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

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

                        maj, extra, err = cr.ReadHeader()
                        if err != nil {
                                return err
                        }

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

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

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

                }
        }
        return nil
}

var lengthBufNetRpcResp = []byte{131}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufNetRpcResp); err != nil {
                return err
        }

        // t.Type (blockstore.NetRPCRespType) (uint8)
        if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Type)); err != nil {
                return err
        }

        // t.ID (uint64) (uint64)

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

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

        if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Data))); err != nil {
                return err
        }

        if _, err := cw.Write(t.Data); err != nil {
                return err
        }

        return nil
}

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

        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.MajArray {
                return fmt.Errorf("cbor input should be of type array")
        }

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

        // t.Type (blockstore.NetRPCRespType) (uint8)

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }
        if maj != cbg.MajUnsignedInt {
                return fmt.Errorf("wrong type for uint8 field")
        }
        if extra > math.MaxUint8 {
                return fmt.Errorf("integer in input was too large for uint8 field")
        }
        t.Type = NetRPCRespType(extra)
        // t.ID (uint64) (uint64)

        {

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

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

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

        if _, err := io.ReadFull(cr, t.Data); err != nil {
                return err
        }

        return nil
}

var lengthBufNetRpcErr = []byte{131}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufNetRpcErr); err != nil {
                return err
        }

        // t.Type (blockstore.NetRPCErrType) (uint8)
        if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Type)); err != nil {
                return err
        }

        // t.Msg (string) (string)
        if len(t.Msg) > 8192 {
                return xerrors.Errorf("Value in field t.Msg was too long")
        }

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

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

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

        return nil
}

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

        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.MajArray {
                return fmt.Errorf("cbor input should be of type array")
        }

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

        // t.Type (blockstore.NetRPCErrType) (uint8)

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }
        if maj != cbg.MajUnsignedInt {
                return fmt.Errorf("wrong type for uint8 field")
        }
        if extra > math.MaxUint8 {
                return fmt.Errorf("integer in input was too large for uint8 field")
        }
        t.Type = NetRPCErrType(extra)
        // t.Msg (string) (string)

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

                t.Msg = string(sval)
        }
        // t.Cid (cid.Cid) (struct)

        {

                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.Cid: %w", err)
                        }

                        t.Cid = &c
                }

        }
        return nil
}

package blockstore

import (
        "context"
)

type hotViewKey struct{}

var hotView = hotViewKey{}

// WithHotView constructs a new context with an option that provides a hint to the blockstore
// (e.g. the splitstore) that the object (and its ipld references) should be kept hot.
func WithHotView(ctx context.Context) context.Context {
        return context.WithValue(ctx, hotView, struct{}{})
}

// IsHotView returns true if the hot view option is set in the context
func IsHotView(ctx context.Context) bool {
        v := ctx.Value(hotView)
        return v != nil
}

package blockstore

import (
        "context"
        "io"

        blocks "github.com/ipfs/go-block-format"
        "github.com/ipfs/go-cid"
)

var _ Blockstore = (*discardstore)(nil)

type discardstore struct {
        bs Blockstore
}

func NewDiscardStore(bs Blockstore) Blockstore {
        return &discardstore{bs: bs}
}

func (b *discardstore) Has(ctx context.Context, cid cid.Cid) (bool, error) {
        return b.bs.Has(ctx, cid)
}

func (b *discardstore) HashOnRead(hor bool) {
        b.bs.HashOnRead(hor)
}

func (b *discardstore) Get(ctx context.Context, cid cid.Cid) (blocks.Block, error) {
        return b.bs.Get(ctx, cid)
}

func (b *discardstore) GetSize(ctx context.Context, cid cid.Cid) (int, error) {
        return b.bs.GetSize(ctx, cid)
}

func (b *discardstore) View(ctx context.Context, cid cid.Cid, f func([]byte) error) error {
        return b.bs.View(ctx, cid, f)
}

func (b *discardstore) Flush(ctx context.Context) error {
        return nil
}

func (b *discardstore) Put(ctx context.Context, blk blocks.Block) error {
        return nil
}

func (b *discardstore) PutMany(ctx context.Context, blks []blocks.Block) error {
        return nil
}

func (b *discardstore) DeleteBlock(ctx context.Context, cid cid.Cid) error {
        return nil
}

func (b *discardstore) DeleteMany(ctx context.Context, cids []cid.Cid) error {
        return nil
}

func (b *discardstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
        return b.bs.AllKeysChan(ctx)
}

func (b *discardstore) Close() error {
        if c, ok := b.bs.(io.Closer); ok {
                return c.Close()
        }
        return nil
}

package blockstore

import (
        "context"
        "sync"
        "time"

        blocks "github.com/ipfs/go-block-format"
        "github.com/ipfs/go-cid"
        ipld "github.com/ipfs/go-ipld-format"
        "golang.org/x/xerrors"
)

// UnwrapFallbackStore takes a blockstore, and returns the underlying blockstore
// if it was a FallbackStore. Otherwise, it just returns the supplied store
// unmodified.
func UnwrapFallbackStore(bs Blockstore) (Blockstore, bool) {
        if fbs, ok := bs.(*FallbackStore); ok {
                return fbs.Blockstore, true
        }
        return bs, false
}

// FallbackStore is a read-through store that queries another (potentially
// remote) source if the block is not found locally. If the block is found
// during the fallback, it stores it in the local store.
type FallbackStore struct {
        Blockstore

        lk sync.RWMutex
        // missFn is the function that will be invoked on a local miss to pull the
        // block from elsewhere.
        missFn func(context.Context, cid.Cid) (blocks.Block, error)
}

var _ Blockstore = (*FallbackStore)(nil)

func (fbs *FallbackStore) SetFallback(missFn func(context.Context, cid.Cid) (blocks.Block, error)) {
        fbs.lk.Lock()
        defer fbs.lk.Unlock()

        fbs.missFn = missFn
}

func (fbs *FallbackStore) getFallback(c cid.Cid) (blocks.Block, error) {
        log.Warnf("fallbackstore: block not found locally, fetching from the network; cid: %s", c)
        fbs.lk.RLock()
        defer fbs.lk.RUnlock()

        if fbs.missFn == nil {
                // FallbackStore wasn't configured yet (chainstore/bitswap aren't up yet)
                // Wait for a bit and retry
                fbs.lk.RUnlock()
                time.Sleep(5 * time.Second)
                fbs.lk.RLock()

                if fbs.missFn == nil {
                        log.Errorw("fallbackstore: missFn not configured yet")
                        return nil, ipld.ErrNotFound{Cid: c}
                }
        }

        ctx, cancel := context.WithTimeout(context.TODO(), 120*time.Second)
        defer cancel()

        b, err := fbs.missFn(ctx, c)
        if err != nil {
                return nil, err
        }

        // chain bitswap puts blocks in temp blockstore which is cleaned up
        // every few min (to drop any messages we fetched but don't want)
        // in this case we want to keep this block around
        if err := fbs.Put(ctx, b); err != nil {
                return nil, xerrors.Errorf("persisting fallback-fetched block: %w", err)
        }
        return b, nil
}

func (fbs *FallbackStore) Get(ctx context.Context, c cid.Cid) (blocks.Block, error) {
        b, err := fbs.Blockstore.Get(ctx, c)
        switch {
        case err == nil:
                return b, nil
        case ipld.IsNotFound(err):
                return fbs.getFallback(c)
        default:
                return b, err
        }
}

func (fbs *FallbackStore) GetSize(ctx context.Context, c cid.Cid) (int, error) {
        sz, err := fbs.Blockstore.GetSize(ctx, c)
        switch {
        case err == nil:
                return sz, nil
        case ipld.IsNotFound(err):
                b, err := fbs.getFallback(c)
                if err != nil {
                        return 0, err
                }
                return len(b.RawData()), nil
        default:
                return sz, err
        }
}

package blockstore

import (
        "context"
        "io"

        blocks "github.com/ipfs/go-block-format"
        "github.com/ipfs/go-cid"
        mh "github.com/multiformats/go-multihash"
        "golang.org/x/xerrors"
)

var _ Blockstore = (*idstore)(nil)

type idstore struct {
        bs Blockstore
}

func NewIDStore(bs Blockstore) Blockstore {
        return &idstore{bs: bs}
}

func decodeCid(cid cid.Cid) (inline bool, data []byte, err error) {
        if cid.Prefix().MhType != mh.IDENTITY {
                return false, nil, nil
        }

        dmh, err := mh.Decode(cid.Hash())
        if err != nil {
                return false, nil, err
        }

        if dmh.Code == mh.IDENTITY {
                return true, dmh.Digest, nil
        }

        return false, nil, err
}

func (b *idstore) Has(ctx context.Context, cid cid.Cid) (bool, error) {
        inline, _, err := decodeCid(cid)
        if err != nil {
                return false, xerrors.Errorf("error decoding Cid: %w", err)
        }

        if inline {
                return true, nil
        }

        return b.bs.Has(ctx, cid)
}

func (b *idstore) Get(ctx context.Context, cid cid.Cid) (blocks.Block, error) {
        inline, data, err := decodeCid(cid)
        if err != nil {
                return nil, xerrors.Errorf("error decoding Cid: %w", err)
        }

        if inline {
                return blocks.NewBlockWithCid(data, cid)
        }

        return b.bs.Get(ctx, cid)
}

func (b *idstore) GetSize(ctx context.Context, cid cid.Cid) (int, error) {
        inline, data, err := decodeCid(cid)
        if err != nil {
                return 0, xerrors.Errorf("error decoding Cid: %w", err)
        }

        if inline {
                return len(data), err
        }

        return b.bs.GetSize(ctx, cid)
}

func (b *idstore) View(ctx context.Context, cid cid.Cid, cb func([]byte) error) error {
        inline, data, err := decodeCid(cid)
        if err != nil {
                return xerrors.Errorf("error decoding Cid: %w", err)
        }

        if inline {
                return cb(data)
        }

        return b.bs.View(ctx, cid, cb)
}

func (b *idstore) Put(ctx context.Context, blk blocks.Block) error {
        inline, _, err := decodeCid(blk.Cid())
        if err != nil {
                return xerrors.Errorf("error decoding Cid: %w", err)
        }

        if inline {
                return nil
        }

        return b.bs.Put(ctx, blk)
}

func (b *idstore) ForEachKey(f func(cid.Cid) error) error {
        iterBstore, ok := b.bs.(BlockstoreIterator)
        if !ok {
                return xerrors.Errorf("underlying blockstore (type %T) doesn't support fast iteration", b.bs)
        }
        return iterBstore.ForEachKey(f)
}

func (b *idstore) PutMany(ctx context.Context, blks []blocks.Block) error {
        toPut := make([]blocks.Block, 0, len(blks))
        for _, blk := range blks {
                inline, _, err := decodeCid(blk.Cid())
                if err != nil {
                        return xerrors.Errorf("error decoding Cid: %w", err)
                }

                if inline {
                        continue
                }
                toPut = append(toPut, blk)
        }

        if len(toPut) > 0 {
                return b.bs.PutMany(ctx, toPut)
        }

        return nil
}

func (b *idstore) DeleteBlock(ctx context.Context, cid cid.Cid) error {
        inline, _, err := decodeCid(cid)
        if err != nil {
                return xerrors.Errorf("error decoding Cid: %w", err)
        }

        if inline {
                return nil
        }

        return b.bs.DeleteBlock(ctx, cid)
}

func (b *idstore) DeleteMany(ctx context.Context, cids []cid.Cid) error {
        toDelete := make([]cid.Cid, 0, len(cids))
        for _, cid := range cids {
                inline, _, err := decodeCid(cid)
                if err != nil {
                        return xerrors.Errorf("error decoding Cid: %w", err)
                }

                if inline {
                        continue
                }
                toDelete = append(toDelete, cid)
        }

        if len(toDelete) > 0 {
                return b.bs.DeleteMany(ctx, toDelete)
        }

        return nil
}

func (b *idstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
        return b.bs.AllKeysChan(ctx)
}

func (b *idstore) HashOnRead(enabled bool) {
        b.bs.HashOnRead(enabled)
}

func (b *idstore) Close() error {
        if c, ok := b.bs.(io.Closer); ok {
                return c.Close()
        }
        return nil
}

func (b *idstore) Flush(ctx context.Context) error {
        return b.bs.Flush(ctx)
}

func (b *idstore) CollectGarbage(ctx context.Context, options ...BlockstoreGCOption) error {
        if bs, ok := b.bs.(BlockstoreGC); ok {
                return bs.CollectGarbage(ctx, options...)
        }
        return xerrors.Errorf("not supported")
}

func (b *idstore) GCOnce(ctx context.Context, options ...BlockstoreGCOption) error {
        if bs, ok := b.bs.(BlockstoreGCOnce); ok {
                return bs.GCOnce(ctx, options...)
        }
        return xerrors.Errorf("not supported")
}

package blockstore

import (
        "context"

        blocks "github.com/ipfs/go-block-format"
        "github.com/ipfs/go-cid"
        ipld "github.com/ipfs/go-ipld-format"
)

// NewMemory returns a temporary memory-backed blockstore.
func NewMemory() MemBlockstore {
        return make(MemBlockstore)
}

// MemBlockstore is a terminal blockstore that keeps blocks in memory.
// To match behavior of badger blockstore we index by multihash only.
type MemBlockstore map[string]blocks.Block

func (MemBlockstore) Flush(context.Context) error { return nil }

func (m MemBlockstore) DeleteBlock(ctx context.Context, k cid.Cid) error {
        delete(m, string(k.Hash()))
        return nil
}

func (m MemBlockstore) DeleteMany(ctx context.Context, ks []cid.Cid) error {
        for _, k := range ks {
                delete(m, string(k.Hash()))
        }
        return nil
}

func (m MemBlockstore) Has(ctx context.Context, k cid.Cid) (bool, error) {
        _, ok := m[string(k.Hash())]
        return ok, nil
}

func (m MemBlockstore) View(ctx context.Context, k cid.Cid, callback func([]byte) error) error {
        b, ok := m[string(k.Hash())]
        if !ok {
                return ipld.ErrNotFound{Cid: k}
        }
        return callback(b.RawData())
}

func (m MemBlockstore) Get(ctx context.Context, k cid.Cid) (blocks.Block, error) {
        b, ok := m[string(k.Hash())]
        if !ok {
                return nil, ipld.ErrNotFound{Cid: k}
        }
        if b.Cid().Prefix().Codec != k.Prefix().Codec {
                return blocks.NewBlockWithCid(b.RawData(), k)
        }
        return b, nil
}

// GetSize returns the CIDs mapped BlockSize
func (m MemBlockstore) GetSize(ctx context.Context, k cid.Cid) (int, error) {
        b, ok := m[string(k.Hash())]
        if !ok {
                return 0, ipld.ErrNotFound{Cid: k}
        }
        return len(b.RawData()), nil
}

// Put puts a given block to the underlying datastore
func (m MemBlockstore) Put(ctx context.Context, b blocks.Block) error {
        // Convert to a basic block for safety, but try to reuse the existing
        // block if it's already a basic block.
        k := string(b.Cid().Hash())
        if _, ok := b.(*blocks.BasicBlock); !ok {
                // If we already have the block, abort.
                if _, ok := m[k]; ok {
                        return nil
                }
                // the error is only for debugging.
                b, _ = blocks.NewBlockWithCid(b.RawData(), b.Cid())
        }
        m[k] = b
        return nil
}

// PutMany puts a slice of blocks at the same time using batching
// capabilities of the underlying datastore whenever possible.
func (m MemBlockstore) PutMany(ctx context.Context, bs []blocks.Block) error {
        for _, b := range bs {
                _ = m.Put(ctx, b) // can't fail
        }
        return nil
}

// AllKeysChan returns a channel from which
// the CIDs in the Blockstore can be read. It should respect
// the given context, closing the channel if it becomes Done.
func (m MemBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
        ch := make(chan cid.Cid, len(m))
        for _, b := range m {
                ch <- b.Cid()
        }
        close(ch)
        return ch, nil
}

// HashOnRead specifies if every read block should be
// rehashed to make sure it matches its CID.
func (m MemBlockstore) HashOnRead(enabled bool) {
        // no-op
}

package blockstore

import (
        "bytes"
        "context"
        "encoding/binary"
        "fmt"
        "sync"
        "sync/atomic"

        blocks "github.com/ipfs/go-block-format"
        "github.com/ipfs/go-cid"
        ipld "github.com/ipfs/go-ipld-format"
        "github.com/libp2p/go-msgio"
        cbg "github.com/whyrusleeping/cbor-gen"
        "golang.org/x/xerrors"
)

type NetRPCReqType byte

const (
        NRpcHas NetRPCReqType = iota
        NRpcGet
        NRpcGetSize
        NRpcPut
        NRpcDelete

        // todo cancel req
)

type NetRPCRespType byte

const (
        NRpcOK NetRPCRespType = iota
        NRpcErr
        NRpcMore
)

type NetRPCErrType byte

const (
        NRpcErrGeneric NetRPCErrType = iota
        NRpcErrNotFound
)

type NetRpcReq struct {
        Type NetRPCReqType
        ID   uint64

        Cid  []cid.Cid // todo maxsize?
        Data [][]byte  // todo maxsize?
}

type NetRpcResp struct {
        Type NetRPCRespType
        ID   uint64

        // error or cids in allkeys
        Data []byte // todo maxsize?

        next <-chan NetRpcResp
}

type NetRpcErr struct {
        Type NetRPCErrType

        Msg string

        // in case of NRpcErrNotFound
        Cid *cid.Cid
}

type NetworkStore struct {
        // note: writer is thread-safe
        msgStream msgio.ReadWriteCloser

        // atomic
        reqCount uint64

        respLk sync.Mutex

        // respMap is nil after store closes
        respMap map[uint64]chan<- NetRpcResp

        closing chan struct{}
        closed  chan struct{}

        closeLk sync.Mutex
        onClose []func()
}

func NewNetworkStore(mss msgio.ReadWriteCloser) *NetworkStore {
        ns := &NetworkStore{
                msgStream: mss,

                respMap: map[uint64]chan<- NetRpcResp{},

                closing: make(chan struct{}),
                closed:  make(chan struct{}),
        }

        go ns.receive()

        return ns
}

func (n *NetworkStore) shutdown(msg string) {
        if err := n.msgStream.Close(); err != nil {
                log.Errorw("closing netstore msg stream", "error", err)
        }

        nerr := NetRpcErr{
                Type: NRpcErrGeneric,
                Msg:  msg,
                Cid:  nil,
        }

        var errb bytes.Buffer
        if err := nerr.MarshalCBOR(&errb); err != nil {
                log.Errorw("netstore shutdown: error marshaling error", "err", err)
        }

        n.respLk.Lock()
        for id, resps := range n.respMap {
                resps <- NetRpcResp{
                        Type: NRpcErr,
                        ID:   id,
                        Data: errb.Bytes(),
                }
        }

        n.respMap = nil

        n.respLk.Unlock()
}

func (n *NetworkStore) OnClose(cb func()) {
        n.closeLk.Lock()
        defer n.closeLk.Unlock()

        select {
        case <-n.closed:
                cb()
        default:
                n.onClose = append(n.onClose, cb)
        }
}

func (n *NetworkStore) receive() {
        defer func() {
                n.closeLk.Lock()
                defer n.closeLk.Unlock()

                close(n.closed)
                if n.onClose != nil {
                        for _, f := range n.onClose {
                                f()
                        }
                }
        }()

        for {
                select {
                case <-n.closing:
                        n.shutdown("netstore stopping")
                        return
                default:
                }

                msg, err := n.msgStream.ReadMsg()
                if err != nil {
                        n.shutdown(fmt.Sprintf("netstore ReadMsg: %s", err))
                        return
                }

                var resp NetRpcResp
                if err := resp.UnmarshalCBOR(bytes.NewReader(msg)); err != nil {
                        n.shutdown(fmt.Sprintf("unmarshaling netstore response: %s", err))
                        return
                }

                n.msgStream.ReleaseMsg(msg)

                n.respLk.Lock()
                if ch, ok := n.respMap[resp.ID]; ok {
                        if resp.Type == NRpcMore {
                                nch := make(chan NetRpcResp, 1)
                                resp.next = nch
                                n.respMap[resp.ID] = nch
                        } else {
                                delete(n.respMap, resp.ID)
                        }

                        ch <- resp
                }
                n.respLk.Unlock()
        }
}

func (n *NetworkStore) sendRpc(rt NetRPCReqType, cids []cid.Cid, data [][]byte) (uint64, <-chan NetRpcResp, error) {
        rid := atomic.AddUint64(&n.reqCount, 1)

        respCh := make(chan NetRpcResp, 1) // todo pool?

        n.respLk.Lock()
        if n.respMap == nil {
                n.respLk.Unlock()
                return 0, nil, xerrors.Errorf("netstore closed")
        }
        n.respMap[rid] = respCh
        n.respLk.Unlock()

        req := NetRpcReq{
                Type: rt,
                ID:   rid,
                Cid:  cids,
                Data: data,
        }

        var rbuf bytes.Buffer // todo buffer pool
        if err := req.MarshalCBOR(&rbuf); err != nil {
                n.respLk.Lock()
                defer n.respLk.Unlock()

                if n.respMap == nil {
                        return 0, nil, xerrors.Errorf("netstore closed")
                }
                delete(n.respMap, rid)

                return 0, nil, err
        }

        if err := n.msgStream.WriteMsg(rbuf.Bytes()); err != nil {
                n.respLk.Lock()
                defer n.respLk.Unlock()

                if n.respMap == nil {
                        return 0, nil, xerrors.Errorf("netstore closed")
                }
                delete(n.respMap, rid)

                return 0, nil, err
        }

        return rid, respCh, nil
}

func (n *NetworkStore) waitResp(ctx context.Context, rch <-chan NetRpcResp, rid uint64) (NetRpcResp, error) {
        select {
        case resp := <-rch:
                if resp.Type == NRpcErr {
                        var e NetRpcErr
                        if err := e.UnmarshalCBOR(bytes.NewReader(resp.Data)); err != nil {
                                return NetRpcResp{}, xerrors.Errorf("unmarshaling error data: %w", err)
                        }

                        var err error
                        switch e.Type {
                        case NRpcErrNotFound:
                                if e.Cid != nil {
                                        err = ipld.ErrNotFound{
                                                Cid: *e.Cid,
                                        }
                                } else {
                                        err = xerrors.Errorf("block not found, but cid was null")
                                }
                        case NRpcErrGeneric:
                                err = xerrors.Errorf("generic error")
                        default:
                                err = xerrors.Errorf("unknown error type")
                        }

                        return NetRpcResp{}, xerrors.Errorf("netstore error response: %s (%w)", e.Msg, err)
                }

                return resp, nil
        case <-ctx.Done():
                // todo send cancel req

                n.respLk.Lock()
                if n.respMap != nil {
                        delete(n.respMap, rid)
                }
                n.respLk.Unlock()

                return NetRpcResp{}, ctx.Err()
        }
}

func (n *NetworkStore) Has(ctx context.Context, c cid.Cid) (bool, error) {
        req, rch, err := n.sendRpc(NRpcHas, []cid.Cid{c}, nil)
        if err != nil {
                return false, err
        }

        resp, err := n.waitResp(ctx, rch, req)
        if err != nil {
                return false, err
        }

        if len(resp.Data) != 1 {
                return false, xerrors.Errorf("expected reposnse length to be 1 byte")
        }
        switch resp.Data[0] {
        case cbg.CborBoolTrue[0]:
                return true, nil
        case cbg.CborBoolFalse[0]:
                return false, nil
        default:
                return false, xerrors.Errorf("has: bad response: %x", resp.Data[0])
        }
}

func (n *NetworkStore) Get(ctx context.Context, c cid.Cid) (blocks.Block, error) {
        req, rch, err := n.sendRpc(NRpcGet, []cid.Cid{c}, nil)
        if err != nil {
                return nil, err
        }

        resp, err := n.waitResp(ctx, rch, req)
        if err != nil {
                return nil, err
        }

        return blocks.NewBlockWithCid(resp.Data, c)
}

func (n *NetworkStore) View(ctx context.Context, c cid.Cid, callback func([]byte) error) error {
        req, rch, err := n.sendRpc(NRpcGet, []cid.Cid{c}, nil)
        if err != nil {
                return err
        }

        resp, err := n.waitResp(ctx, rch, req)
        if err != nil {
                return err
        }

        return callback(resp.Data) // todo return buf to pool
}

func (n *NetworkStore) GetSize(ctx context.Context, c cid.Cid) (int, error) {
        req, rch, err := n.sendRpc(NRpcGetSize, []cid.Cid{c}, nil)
        if err != nil {
                return 0, err
        }

        resp, err := n.waitResp(ctx, rch, req)
        if err != nil {
                return 0, err
        }

        if len(resp.Data) != 4 {
                return 0, xerrors.Errorf("expected getsize response to be 4 bytes, was %d", resp.Data)
        }

        return int(binary.LittleEndian.Uint32(resp.Data)), nil
}

func (n *NetworkStore) Put(ctx context.Context, block blocks.Block) error {
        return n.PutMany(ctx, []blocks.Block{block})
}

func (n *NetworkStore) PutMany(ctx context.Context, blocks []blocks.Block) error {
        // todo pool
        cids := make([]cid.Cid, len(blocks))
        blkDatas := make([][]byte, len(blocks))
        for i, block := range blocks {
                cids[i] = block.Cid()
                blkDatas[i] = block.RawData()
        }

        req, rch, err := n.sendRpc(NRpcPut, cids, blkDatas)
        if err != nil {
                return err
        }

        _, err = n.waitResp(ctx, rch, req)
        if err != nil {
                return err
        }

        return nil
}

func (n *NetworkStore) DeleteBlock(ctx context.Context, c cid.Cid) error {
        return n.DeleteMany(ctx, []cid.Cid{c})
}

func (n *NetworkStore) DeleteMany(ctx context.Context, cids []cid.Cid) error {
        req, rch, err := n.sendRpc(NRpcDelete, cids, nil)
        if err != nil {
                return err
        }

        _, err = n.waitResp(ctx, rch, req)
        if err != nil {
                return err
        }

        return nil
}

func (n *NetworkStore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
        return nil, xerrors.Errorf("not supported")
}

func (n *NetworkStore) HashOnRead(enabled bool) {
        // todo
        return
}

func (*NetworkStore) Flush(context.Context) error { return nil }

func (n *NetworkStore) Stop(ctx context.Context) error {
        close(n.closing)

        select {
        case <-n.closed:
                return nil
        case <-ctx.Done():
                return ctx.Err()
        }
}

var _ Blockstore = &NetworkStore{}

package blockstore

import (
        "bytes"
        "context"
        "encoding/binary"

        block "github.com/ipfs/go-block-format"
        "github.com/ipfs/go-cid"
        ipld "github.com/ipfs/go-ipld-format"
        "github.com/libp2p/go-msgio"
        cbg "github.com/whyrusleeping/cbor-gen"
        "golang.org/x/xerrors"
)

type NetworkStoreHandler struct {
        msgStream msgio.ReadWriteCloser

        bs Blockstore
}

// NOTE: This code isn't yet hardened to accept untrusted input. See TODOs here and in net.go
func HandleNetBstoreStream(ctx context.Context, bs Blockstore, mss msgio.ReadWriteCloser) *NetworkStoreHandler {
        ns := &NetworkStoreHandler{
                msgStream: mss,
                bs:        bs,
        }

        go ns.handle(ctx)

        return ns
}

func (h *NetworkStoreHandler) handle(ctx context.Context) {
        defer func() {
                if err := h.msgStream.Close(); err != nil {
                        log.Errorw("error closing blockstore stream", "error", err)
                }
        }()

        for {
                var req NetRpcReq

                ms, err := h.msgStream.ReadMsg()
                if err != nil {
                        log.Warnw("bstore stream err", "error", err)
                        return
                }

                if err := req.UnmarshalCBOR(bytes.NewReader(ms)); err != nil {
                        return
                }

                h.msgStream.ReleaseMsg(ms)

                switch req.Type {
                case NRpcHas:
                        if len(req.Cid) != 1 {
                                if err := h.respondError(req.ID, xerrors.New("expected request for 1 cid"), cid.Undef); err != nil {
                                        log.Warnw("writing error response", "error", err)
                                        return
                                }
                                continue
                        }

                        res, err := h.bs.Has(ctx, req.Cid[0])
                        if err != nil {
                                if err := h.respondError(req.ID, err, req.Cid[0]); err != nil {
                                        log.Warnw("writing error response", "error", err)
                                        return
                                }
                                continue
                        }

                        var resData [1]byte
                        if res {
                                resData[0] = cbg.CborBoolTrue[0]
                        } else {
                                resData[0] = cbg.CborBoolFalse[0]
                        }

                        if err := h.respond(req.ID, NRpcOK, resData[:]); err != nil {
                                log.Warnw("writing response", "error", err)
                                return
                        }

                case NRpcGet:
                        if len(req.Cid) != 1 {
                                if err := h.respondError(req.ID, xerrors.New("expected request for 1 cid"), cid.Undef); err != nil {
                                        log.Warnw("writing error response", "error", err)
                                        return
                                }
                                continue
                        }

                        err := h.bs.View(ctx, req.Cid[0], func(bdata []byte) error {
                                return h.respond(req.ID, NRpcOK, bdata)
                        })
                        if err != nil {
                                if err := h.respondError(req.ID, err, req.Cid[0]); err != nil {
                                        log.Warnw("writing error response", "error", err)
                                        return
                                }
                                continue
                        }

                case NRpcGetSize:
                        if len(req.Cid) != 1 {
                                if err := h.respondError(req.ID, xerrors.New("expected request for 1 cid"), cid.Undef); err != nil {
                                        log.Warnw("writing error response", "error", err)
                                        return
                                }
                                continue
                        }

                        sz, err := h.bs.GetSize(ctx, req.Cid[0])
                        if err != nil {
                                if err := h.respondError(req.ID, err, req.Cid[0]); err != nil {
                                        log.Warnw("writing error response", "error", err)
                                        return
                                }
                                continue
                        }

                        var resData [4]byte
                        binary.LittleEndian.PutUint32(resData[:], uint32(sz))

                        if err := h.respond(req.ID, NRpcOK, resData[:]); err != nil {
                                log.Warnw("writing response", "error", err)
                                return
                        }

                case NRpcPut:
                        blocks := make([]block.Block, len(req.Cid))

                        if len(req.Cid) != len(req.Data) {
                                if err := h.respondError(req.ID, xerrors.New("cid count didn't match data count"), cid.Undef); err != nil {
                                        log.Warnw("writing error response", "error", err)
                                }
                                return
                        }

                        for i := range req.Cid {
                                blocks[i], err = block.NewBlockWithCid(req.Data[i], req.Cid[i])
                                if err != nil {
                                        log.Warnw("make block", "error", err)
                                        return
                                }
                        }

                        err := h.bs.PutMany(ctx, blocks)
                        if err != nil {
                                if err := h.respondError(req.ID, err, cid.Undef); err != nil {
                                        log.Warnw("writing error response", "error", err)
                                        return
                                }
                                continue
                        }

                        if err := h.respond(req.ID, NRpcOK, []byte{}); err != nil {
                                log.Warnw("writing response", "error", err)
                                return
                        }
                case NRpcDelete:
                        err := h.bs.DeleteMany(ctx, req.Cid)
                        if err != nil {
                                if err := h.respondError(req.ID, err, cid.Undef); err != nil {
                                        log.Warnw("writing error response", "error", err)
                                        return
                                }
                                continue
                        }

                        if err := h.respond(req.ID, NRpcOK, []byte{}); err != nil {
                                log.Warnw("writing response", "error", err)
                                return
                        }
                default:
                        if err := h.respondError(req.ID, xerrors.New("unsupported request type"), cid.Undef); err != nil {
                                log.Warnw("writing error response", "error", err)
                                return
                        }
                        continue
                }
        }
}

func (h *NetworkStoreHandler) respondError(req uint64, uerr error, c cid.Cid) error {
        var resp NetRpcResp
        resp.ID = req
        resp.Type = NRpcErr

        nerr := NetRpcErr{
                Type: NRpcErrGeneric,
                Msg:  uerr.Error(),
        }
        if ipld.IsNotFound(uerr) {
                nerr.Type = NRpcErrNotFound
                nerr.Cid = &c
        }

        var edata bytes.Buffer
        if err := nerr.MarshalCBOR(&edata); err != nil {
                return xerrors.Errorf("marshaling error data: %w", err)
        }

        resp.Data = edata.Bytes()

        var msg bytes.Buffer
        if err := resp.MarshalCBOR(&msg); err != nil {
                return xerrors.Errorf("marshaling error response: %w", err)
        }

        if err := h.msgStream.WriteMsg(msg.Bytes()); err != nil {
                return xerrors.Errorf("write error response: %w", err)
        }

        return nil
}

func (h *NetworkStoreHandler) respond(req uint64, rt NetRPCRespType, data []byte) error {
        var resp NetRpcResp
        resp.ID = req
        resp.Type = rt
        resp.Data = data

        var msg bytes.Buffer
        if err := resp.MarshalCBOR(&msg); err != nil {
                return xerrors.Errorf("marshaling response: %w", err)
        }

        if err := h.msgStream.WriteMsg(msg.Bytes()); err != nil {
                return xerrors.Errorf("write response: %w", err)
        }

        return nil
}

package blockstore

import (
        "bytes"
        "context"

        "github.com/gorilla/websocket"
        "github.com/libp2p/go-msgio"
        "golang.org/x/xerrors"
)

type wsWrapper struct {
        wc *websocket.Conn

        nextMsg []byte
}

func (w *wsWrapper) Read(b []byte) (int, error) {
        return 0, xerrors.New("read unsupported")
}

func (w *wsWrapper) ReadMsg() ([]byte, error) {
        if w.nextMsg != nil {
                nm := w.nextMsg
                w.nextMsg = nil
                return nm, nil
        }

        mt, r, err := w.wc.NextReader()
        if err != nil {
                return nil, err
        }

        switch mt {
        case websocket.BinaryMessage, websocket.TextMessage:
        default:
                return nil, xerrors.Errorf("unexpected message type")
        }

        // todo pool
        // todo limit sizes
        var mbuf bytes.Buffer
        if _, err := mbuf.ReadFrom(r); err != nil {
                return nil, err
        }

        return mbuf.Bytes(), nil
}

func (w *wsWrapper) ReleaseMsg(bytes []byte) {
        // todo use a pool
}

func (w *wsWrapper) NextMsgLen() (int, error) {
        if w.nextMsg != nil {
                return len(w.nextMsg), nil
        }

        mt, msg, err := w.wc.ReadMessage()
        if err != nil {
                return 0, err
        }

        switch mt {
        case websocket.BinaryMessage, websocket.TextMessage:
        default:
                return 0, xerrors.Errorf("unexpected message type")
        }

        w.nextMsg = msg
        return len(w.nextMsg), nil
}

func (w *wsWrapper) Write(bytes []byte) (int, error) {
        return 0, xerrors.New("write unsupported")
}

func (w *wsWrapper) WriteMsg(bytes []byte) error {
        return w.wc.WriteMessage(websocket.BinaryMessage, bytes)
}

func (w *wsWrapper) Close() error {
        return w.wc.Close()
}

var _ msgio.ReadWriteCloser = &wsWrapper{}

func wsConnToMio(wc *websocket.Conn) msgio.ReadWriteCloser {
        return &wsWrapper{
                wc: wc,
        }
}

func HandleNetBstoreWS(ctx context.Context, bs Blockstore, wc *websocket.Conn) *NetworkStoreHandler {
        return HandleNetBstoreStream(ctx, bs, wsConnToMio(wc))
}

func NewNetworkStoreWS(wc *websocket.Conn) *NetworkStore {
        return NewNetworkStore(wsConnToMio(wc))
}

package blockstore

import (
        "context"
        "sync"

        blocks "github.com/ipfs/go-block-format"
        "github.com/ipfs/go-cid"
)

// NewMemorySync returns a thread-safe in-memory blockstore.
func NewMemorySync() *SyncBlockstore {
        return &SyncBlockstore{bs: make(MemBlockstore)}
}

// SyncBlockstore is a terminal blockstore that is a synchronized version
// of MemBlockstore.
type SyncBlockstore struct {
        mu sync.RWMutex
        bs MemBlockstore // specifically use a memStore to save indirection overhead.
}

func (*SyncBlockstore) Flush(context.Context) error { return nil }

func (m *SyncBlockstore) DeleteBlock(ctx context.Context, k cid.Cid) error {
        m.mu.Lock()
        defer m.mu.Unlock()
        return m.bs.DeleteBlock(ctx, k)
}

func (m *SyncBlockstore) DeleteMany(ctx context.Context, ks []cid.Cid) error {
        m.mu.Lock()
        defer m.mu.Unlock()
        return m.bs.DeleteMany(ctx, ks)
}

func (m *SyncBlockstore) Has(ctx context.Context, k cid.Cid) (bool, error) {
        m.mu.RLock()
        defer m.mu.RUnlock()
        return m.bs.Has(ctx, k)
}

func (m *SyncBlockstore) View(ctx context.Context, k cid.Cid, callback func([]byte) error) error {
        m.mu.RLock()
        defer m.mu.RUnlock()

        return m.bs.View(ctx, k, callback)
}

func (m *SyncBlockstore) Get(ctx context.Context, k cid.Cid) (blocks.Block, error) {
        m.mu.RLock()
        defer m.mu.RUnlock()
        return m.bs.Get(ctx, k)
}

func (m *SyncBlockstore) GetSize(ctx context.Context, k cid.Cid) (int, error) {
        m.mu.RLock()
        defer m.mu.RUnlock()
        return m.bs.GetSize(ctx, k)
}

func (m *SyncBlockstore) Put(ctx context.Context, b blocks.Block) error {
        m.mu.Lock()
        defer m.mu.Unlock()
        return m.bs.Put(ctx, b)
}

func (m *SyncBlockstore) PutMany(ctx context.Context, bs []blocks.Block) error {
        m.mu.Lock()
        defer m.mu.Unlock()
        return m.bs.PutMany(ctx, bs)
}

func (m *SyncBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
        m.mu.RLock()
        defer m.mu.RUnlock()
        // this blockstore implementation doesn't do any async work.
        return m.bs.AllKeysChan(ctx)
}

func (m *SyncBlockstore) HashOnRead(enabled bool) {
        // noop
}

package blockstore

import (
        "context"
        "fmt"
        "sync"
        "time"

        blocks "github.com/ipfs/go-block-format"
        "github.com/ipfs/go-cid"
        ipld "github.com/ipfs/go-ipld-format"
        "github.com/raulk/clock"
        "go.uber.org/multierr"
)

// TimedCacheBlockstore is a blockstore that keeps blocks for at least the
// specified caching interval before discarding them. Garbage collection must
// be started and stopped by calling Start/Stop.
//
// Under the covers, it's implemented with an active and an inactive blockstore
// that are rotated every cache time interval. This means all blocks will be
// stored at most 2x the cache interval.
//
// Create a new instance by calling the NewTimedCacheBlockstore constructor.
type TimedCacheBlockstore struct {
        mu               sync.RWMutex
        active, inactive MemBlockstore
        clock            clock.Clock
        interval         time.Duration
        closeCh          chan struct{}
        doneRotatingCh   chan struct{}
}

func NewTimedCacheBlockstore(interval time.Duration) *TimedCacheBlockstore {
        b := &TimedCacheBlockstore{
                active:   NewMemory(),
                inactive: NewMemory(),
                interval: interval,
                clock:    clock.New(),
        }
        return b
}

func (t *TimedCacheBlockstore) Start(_ context.Context) error {
        t.mu.Lock()
        defer t.mu.Unlock()
        if t.closeCh != nil {
                return fmt.Errorf("already started")
        }
        t.closeCh = make(chan struct{})

        // Create this timer before starting the goroutine. Otherwise, creating the timer will race
        // with adding time to the mock clock, and we could add time _first_, then stall waiting for
        // a timer that'll never fire.
        ticker := t.clock.Ticker(t.interval)
        go func() {
                defer ticker.Stop()
                for {
                        select {
                        case <-ticker.C:
                                t.rotate()
                                if t.doneRotatingCh != nil {
                                        t.doneRotatingCh <- struct{}{}
                                }
                        case <-t.closeCh:
                                return
                        }
                }
        }()
        return nil
}

func (t *TimedCacheBlockstore) Stop(_ context.Context) error {
        t.mu.Lock()
        defer t.mu.Unlock()
        if t.closeCh == nil {
                return fmt.Errorf("not started")
        }
        select {
        case <-t.closeCh:
                // already closed
        default:
                close(t.closeCh)
        }
        return nil
}

func (t *TimedCacheBlockstore) rotate() {
        newBs := NewMemory()

        t.mu.Lock()
        t.inactive, t.active = t.active, newBs
        t.mu.Unlock()
}

func (t *TimedCacheBlockstore) Flush(ctx context.Context) error {
        t.mu.Lock()
        defer t.mu.Unlock()

        if err := t.active.Flush(ctx); err != nil {
                return err
        }
        return t.inactive.Flush(ctx)
}

func (t *TimedCacheBlockstore) Put(ctx context.Context, b blocks.Block) error {
        // Don't check the inactive set here. We want to keep this block for at
        // least one interval.
        t.mu.Lock()
        defer t.mu.Unlock()
        return t.active.Put(ctx, b)
}

func (t *TimedCacheBlockstore) PutMany(ctx context.Context, bs []blocks.Block) error {
        t.mu.Lock()
        defer t.mu.Unlock()
        return t.active.PutMany(ctx, bs)
}

func (t *TimedCacheBlockstore) View(ctx context.Context, k cid.Cid, callback func([]byte) error) error {
        // The underlying blockstore is always a "mem" blockstore so there's no difference,
        // from a performance perspective, between view & get. So we call Get to avoid
        // calling an arbitrary callback while holding a lock.
        t.mu.RLock()
        block, err := t.active.Get(ctx, k)
        if ipld.IsNotFound(err) {
                block, err = t.inactive.Get(ctx, k)
        }
        t.mu.RUnlock()

        if err != nil {
                return err
        }
        return callback(block.RawData())
}

func (t *TimedCacheBlockstore) Get(ctx context.Context, k cid.Cid) (blocks.Block, error) {
        t.mu.RLock()
        defer t.mu.RUnlock()
        b, err := t.active.Get(ctx, k)
        if ipld.IsNotFound(err) {
                b, err = t.inactive.Get(ctx, k)
        }
        return b, err
}

func (t *TimedCacheBlockstore) GetSize(ctx context.Context, k cid.Cid) (int, error) {
        t.mu.RLock()
        defer t.mu.RUnlock()
        size, err := t.active.GetSize(ctx, k)
        if ipld.IsNotFound(err) {
                size, err = t.inactive.GetSize(ctx, k)
        }
        return size, err
}

func (t *TimedCacheBlockstore) Has(ctx context.Context, k cid.Cid) (bool, error) {
        t.mu.RLock()
        defer t.mu.RUnlock()
        if has, err := t.active.Has(ctx, k); err != nil {
                return false, err
        } else if has {
                return true, nil
        }
        return t.inactive.Has(ctx, k)
}

func (t *TimedCacheBlockstore) HashOnRead(_ bool) {
        // no-op
}

func (t *TimedCacheBlockstore) DeleteBlock(ctx context.Context, k cid.Cid) error {
        t.mu.Lock()
        defer t.mu.Unlock()
        return multierr.Combine(t.active.DeleteBlock(ctx, k), t.inactive.DeleteBlock(ctx, k))
}

func (t *TimedCacheBlockstore) DeleteMany(ctx context.Context, ks []cid.Cid) error {
        t.mu.Lock()
        defer t.mu.Unlock()
        return multierr.Combine(t.active.DeleteMany(ctx, ks), t.inactive.DeleteMany(ctx, ks))
}

func (t *TimedCacheBlockstore) AllKeysChan(_ context.Context) (<-chan cid.Cid, error) {
        t.mu.RLock()
        defer t.mu.RUnlock()

        ch := make(chan cid.Cid, len(t.active)+len(t.inactive))
        for _, b := range t.active {
                ch <- b.Cid()
        }
        for _, b := range t.inactive {
                c := b.Cid()
                if _, ok := t.active[string(c.Hash())]; ok {
                        continue
                }
                ch <- c
        }
        close(ch)
        return ch, nil
}

package blockstore

import (
        "context"

        blocks "github.com/ipfs/go-block-format"
        "github.com/ipfs/go-cid"
        ipld "github.com/ipfs/go-ipld-format"
)

type unionBlockstore []Blockstore

// Union returns an unioned blockstore.
//
//   - Reads return from the first blockstore that has the value, querying in the
//     supplied order.
//   - Writes (puts and deletes) are broadcast to all stores.
func Union(stores ...Blockstore) Blockstore {
        return unionBlockstore(stores)
}

func (m unionBlockstore) Has(ctx context.Context, cid cid.Cid) (has bool, err error) {
        for _, bs := range m {
                if has, err = bs.Has(ctx, cid); has || err != nil {
                        break
                }
        }
        return has, err
}

func (m unionBlockstore) Get(ctx context.Context, cid cid.Cid) (blk blocks.Block, err error) {
        for _, bs := range m {
                if blk, err = bs.Get(ctx, cid); err == nil || !ipld.IsNotFound(err) {
                        break
                }
        }
        return blk, err
}

func (m unionBlockstore) View(ctx context.Context, cid cid.Cid, callback func([]byte) error) (err error) {
        for _, bs := range m {
                if err = bs.View(ctx, cid, callback); err == nil || !ipld.IsNotFound(err) {
                        break
                }
        }
        return err
}

func (m unionBlockstore) GetSize(ctx context.Context, cid cid.Cid) (size int, err error) {
        for _, bs := range m {
                if size, err = bs.GetSize(ctx, cid); err == nil || !ipld.IsNotFound(err) {
                        break
                }
        }
        return size, err
}

func (m unionBlockstore) Flush(ctx context.Context) (err error) {
        for _, bs := range m {
                if err = bs.Flush(ctx); err != nil {
                        break
                }
        }
        return err
}

func (m unionBlockstore) Put(ctx context.Context, block blocks.Block) (err error) {
        for _, bs := range m {
                if err = bs.Put(ctx, block); err != nil {
                        break
                }
        }
        return err
}

func (m unionBlockstore) PutMany(ctx context.Context, blks []blocks.Block) (err error) {
        for _, bs := range m {
                if err = bs.PutMany(ctx, blks); err != nil {
                        break
                }
        }
        return err
}

func (m unionBlockstore) DeleteBlock(ctx context.Context, cid cid.Cid) (err error) {
        for _, bs := range m {
                if err = bs.DeleteBlock(ctx, cid); err != nil {
                        break
                }
        }
        return err
}

func (m unionBlockstore) DeleteMany(ctx context.Context, cids []cid.Cid) (err error) {
        for _, bs := range m {
                if err = bs.DeleteMany(ctx, cids); err != nil {
                        break
                }
        }
        return err
}

func (m unionBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
        // this does not deduplicate; this interface needs to be revisited.
        outCh := make(chan cid.Cid)

        go func() {
                defer close(outCh)

                for _, bs := range m {
                        ch, err := bs.AllKeysChan(ctx)
                        if err != nil {
                                return
                        }
                        for cid := range ch {
                                outCh <- cid
                        }
                }
        }()

        return outCh, nil
}

func (m unionBlockstore) HashOnRead(enabled bool) {
        for _, bs := range m {
                bs.HashOnRead(enabled)
        }
}

package build

import (
        "context"
        "embed"
        "path"
        "strings"

        "github.com/libp2p/go-libp2p/core/peer"

        "github.com/filecoin-project/lotus/lib/addrutil"
)

//go:embed bootstrap
var bootstrapfs embed.FS

func BuiltinBootstrap() ([]peer.AddrInfo, error) {
        if DisableBuiltinAssets {
                return nil, nil
        }
        if BootstrappersFile != "" {
                spi, err := bootstrapfs.ReadFile(path.Join("bootstrap", BootstrappersFile))
                if err != nil {
                        return nil, err
                }
                if len(spi) == 0 {
                        return nil, nil
                }

                return addrutil.ParseAddresses(context.TODO(), strings.Split(strings.TrimSpace(string(spi)), "\n"))
        }

        return nil, nil
}

package build

import (
        "archive/tar"
        "context"
        "embed"
        "fmt"
        "io"
        "os"
        "path"
        "sort"
        "strconv"
        "strings"

        "github.com/ipfs/go-cid"
        cbor "github.com/ipfs/go-ipld-cbor"
        "github.com/ipld/go-car"
        "github.com/klauspost/compress/zstd"
        "golang.org/x/xerrors"

        actorstypes "github.com/filecoin-project/go-state-types/actors"

        "github.com/filecoin-project/lotus/blockstore"
        "github.com/filecoin-project/lotus/chain/actors"
        "github.com/filecoin-project/lotus/chain/actors/adt"
)

//go:embed actors/*.tar.zst
var embeddedBuiltinActorReleases embed.FS

func init() {
        if BundleOverrides == nil {
                BundleOverrides = make(map[actorstypes.Version]string)
        }
        for _, av := range actors.Versions {
                path := os.Getenv(fmt.Sprintf("LOTUS_BUILTIN_ACTORS_V%d_BUNDLE", av))
                if path == "" {
                        continue
                }
                BundleOverrides[actorstypes.Version(av)] = path
        }
        if err := loadManifests(NetworkBundle); err != nil {
                panic(err)
        }

        // The following code cid existed temporarily on the calibnet testnet, as a "buggy" storage miner actor implementation.
        // We include them in our builtin bundle, but intentionally omit from metadata.
        if NetworkBundle == "calibrationnet" {
                actors.AddActorMeta("storageminer", cid.MustParse("bafk2bzacecnh2ouohmonvebq7uughh4h3ppmg4cjsk74dzxlbbtlcij4xbzxq"), actorstypes.Version12)
                actors.AddActorMeta("storageminer", cid.MustParse("bafk2bzaced7emkbbnrewv5uvrokxpf5tlm4jslu2jsv77ofw2yqdglg657uie"), actorstypes.Version12)
                actors.AddActorMeta("verifiedregistry", cid.MustParse("bafk2bzacednskl3bykz5qpo54z2j2p4q44t5of4ktd6vs6ymmg2zebsbxazkm"), actorstypes.Version13)
        }
}

// UseNetworkBundle switches to a different network bundle, by name.
func UseNetworkBundle(netw string) error {
        if NetworkBundle == netw {
                return nil
        }
        if err := loadManifests(netw); err != nil {
                return err
        }
        NetworkBundle = netw
        return nil
}

func loadManifests(netw string) error {
        overridden := make(map[actorstypes.Version]struct{})
        var newMetadata []*BuiltinActorsMetadata
        // First, prefer overrides.
        for av, path := range BundleOverrides {
                root, actorCids, err := readBundleManifestFromFile(path)
                if err != nil {
                        return err
                }
                newMetadata = append(newMetadata, &BuiltinActorsMetadata{
                        Network:     netw,
                        Version:     av,
                        ManifestCid: root,
                        Actors:      actorCids,
                })
                overridden[av] = struct{}{}
        }

        // Then load embedded bundle metadata.
        for _, meta := range EmbeddedBuiltinActorsMetadata {
                if meta.Network != netw {
                        continue
                }
                if _, ok := overridden[meta.Version]; ok {
                        continue
                }
                newMetadata = append(newMetadata, meta)
        }

        actors.ClearManifests()

        for _, meta := range newMetadata {
                actors.RegisterManifest(meta.Version, meta.ManifestCid, meta.Actors)
        }

        return nil
}

type BuiltinActorsMetadata struct {
        Network      string
        Version      actorstypes.Version
        ManifestCid  cid.Cid
        Actors       map[string]cid.Cid
        BundleGitTag string
}

// ReadEmbeddedBuiltinActorsMetadata reads the metadata from the embedded built-in actor bundles.
// There should be no need to call this method as the result is cached in the
// `EmbeddedBuiltinActorsMetadata` variable on `make gen`.
func ReadEmbeddedBuiltinActorsMetadata() ([]*BuiltinActorsMetadata, error) {
        files, err := embeddedBuiltinActorReleases.ReadDir("actors")
        if err != nil {
                return nil, xerrors.Errorf("failed to read embedded bundle directory: %s", err)
        }
        var bundles []*BuiltinActorsMetadata
        for _, dirent := range files {
                name := dirent.Name()
                b, err := readEmbeddedBuiltinActorsMetadata(name)
                if err != nil {
                        return nil, err
                }
                bundles = append(bundles, b...)
        }
        // Sort by network, then by bundle.
        sort.Slice(bundles, func(i, j int) bool {
                if bundles[i].Network == bundles[j].Network {
                        return bundles[i].Version < bundles[j].Version
                }
                return bundles[i].Network < bundles[j].Network
        })
        return bundles, nil
}

func readEmbeddedBuiltinActorsMetadata(bundle string) ([]*BuiltinActorsMetadata, error) {
        const (
                archiveExt   = ".tar.zst"
                bundleExt    = ".car"
                bundlePrefix = "builtin-actors-"
        )

        if !strings.HasPrefix(bundle, "v") {
                return nil, xerrors.Errorf("bundle '%q' doesn't start with a 'v'", bundle)
        }
        if !strings.HasSuffix(bundle, archiveExt) {
                return nil, xerrors.Errorf("bundle '%q' doesn't end with '%s'", bundle, archiveExt)
        }
        version, err := strconv.ParseInt(bundle[1:len(bundle)-len(archiveExt)], 10, 0)
        if err != nil {
                return nil, xerrors.Errorf("failed to parse actors version from bundle '%q': %s", bundle, err)
        }
        fi, err := embeddedBuiltinActorReleases.Open(fmt.Sprintf("actors/%s", bundle))
        if err != nil {
                return nil, err
        }
        defer fi.Close() //nolint

        uncompressed, err := zstd.NewReader(fi)
        if err != nil {
                return nil, err
        }
        defer uncompressed.Close() //nolint

        var bundles []*BuiltinActorsMetadata

        tarReader := tar.NewReader(uncompressed)
        for {
                header, err := tarReader.Next()
                switch err {
                case io.EOF:
                        return bundles, nil
                case nil:
                default:
                        return nil, err
                }

                // Read the network name from the bundle name.
                name := path.Base(header.Name)
                if !strings.HasSuffix(name, bundleExt) {
                        return nil, xerrors.Errorf("expected bundle to end with .car: %s", name)
                }
                if !strings.HasPrefix(name, bundlePrefix) {
                        return nil, xerrors.Errorf("expected bundle to end with .car: %s", name)
                }
                name = name[len(bundlePrefix) : len(name)-len(bundleExt)]

                // Load the bundle.
                root, actorCids, err := readBundleManifest(tarReader)
                if err != nil {
                        return nil, xerrors.Errorf("error loading builtin actors bundle: %w", err)
                }

                // The following manifest cids existed temporarily on the calibnet testnet
                // We include them in our builtin bundle, but intentionally omit from metadata
                if root == cid.MustParse("bafy2bzacedrunxfqta5skb7q7x32lnp4efz2oq7fn226ffm7fu5iqs62jkmvs") ||
                        root == cid.MustParse("bafy2bzacebl4w5ptfvuw6746w7ev562idkbf5ppq72e6zub22435ws2rukzru") ||
                        root == cid.MustParse("bafy2bzacea4firkyvt2zzdwqjrws5pyeluaesh6uaid246tommayr4337xpmi") {
                        continue
                }
                bundles = append(bundles, &BuiltinActorsMetadata{
                        Network:     name,
                        Version:     actorstypes.Version(version),
                        ManifestCid: root,
                        Actors:      actorCids,
                })
        }
}

func readBundleManifestFromFile(path string) (cid.Cid, map[string]cid.Cid, error) {
        fi, err := os.Open(path)
        if err != nil {
                return cid.Undef, nil, err
        }
        defer fi.Close() //nolint

        return readBundleManifest(fi)
}

func readBundleManifest(r io.Reader) (cid.Cid, map[string]cid.Cid, error) {
        // Load the bundle.
        bs := blockstore.NewMemory()
        hdr, err := car.LoadCar(context.Background(), bs, r)
        if err != nil {
                return cid.Undef, nil, xerrors.Errorf("error loading builtin actors bundle: %w", err)
        }

        if len(hdr.Roots) != 1 {
                return cid.Undef, nil, xerrors.Errorf("expected one root when loading actors bundle, got %d", len(hdr.Roots))
        }
        root := hdr.Roots[0]
        actorCids, err := actors.ReadManifest(context.Background(), adt.WrapStore(context.Background(), cbor.NewCborStore(bs)), root)
        if err != nil {
                return cid.Undef, nil, err
        }

        // Make sure we have all the actors.
        for name, c := range actorCids {
                if has, err := bs.Has(context.Background(), c); err != nil {
                        return cid.Undef, nil, xerrors.Errorf("got an error when checking that the bundle has the actor %q: %w", name, err)
                } else if !has {
                        return cid.Undef, nil, xerrors.Errorf("actor %q missing from bundle", name)
                }
        }

        return root, actorCids, nil
}

// GetEmbeddedBuiltinActorsBundle returns the builtin-actors bundle for the given actors version.
func GetEmbeddedBuiltinActorsBundle(version actorstypes.Version, networkBundleName string) ([]byte, bool) {
        fi, err := embeddedBuiltinActorReleases.Open(fmt.Sprintf("actors/v%d.tar.zst", version))
        if err != nil {
                return nil, false
        }
        defer fi.Close() //nolint

        uncompressed, err := zstd.NewReader(fi)
        if err != nil {
                return nil, false
        }
        defer uncompressed.Close() //nolint

        tarReader := tar.NewReader(uncompressed)
        targetFileName := fmt.Sprintf("builtin-actors-%s.car", networkBundleName)
        for {
                header, err := tarReader.Next()
                switch err {
                case io.EOF:
                        return nil, false
                case nil:
                default:
                        panic(err)
                }
                if header.Name != targetFileName {
                        continue
                }

                car, err := io.ReadAll(tarReader)
                if err != nil {
                        panic(err)
                }
                return car, true
        }
}

package build

import (
        "sort"

        "github.com/filecoin-project/lotus/node/modules/dtypes"
)

type DrandEnum int

func DrandConfigSchedule() dtypes.DrandSchedule {
        out := dtypes.DrandSchedule{}
        for start, network := range DrandSchedule {
                out = append(out, dtypes.DrandPoint{Start: start, Config: DrandConfigs[network]})
        }

        sort.Slice(out, func(i, j int) bool {
                return out[i].Start < out[j].Start
        })

        return out
}

const (
        DrandMainnet DrandEnum = iota + 1
        DrandTestnet
        DrandDevnet
        DrandLocalnet
        DrandIncentinet
        DrandQuicknet
)

var DrandConfigs = map[DrandEnum]dtypes.DrandConfig{
        DrandMainnet: {
                Servers: []string{
                        "https://api.drand.sh",
                        "https://api2.drand.sh",
                        "https://api3.drand.sh",
                        "https://drand.cloudflare.com",
                        "https://api.drand.secureweb3.com:6875", // Storswift
                },
                Relays: []string{
                        "/dnsaddr/api.drand.sh/",
                        "/dnsaddr/api2.drand.sh/",
                        "/dnsaddr/api3.drand.sh/",
                },
                IsChained:     true,
                ChainInfoJSON: `{"public_key":"868f005eb8e6e4ca0a47c8a77ceaa5309a47978a7c71bc5cce96366b5d7a569937c529eeda66c7293784a9402801af31","period":30,"genesis_time":1595431050,"hash":"8990e7a9aaed2ffed73dbd7092123d6f289930540d7651336225dc172e51b2ce","groupHash":"176f93498eac9ca337150b46d21dd58673ea4e3581185f869672e59fa4cb390a"}`,
        },
        DrandQuicknet: {
                Servers: []string{
                        "https://api.drand.sh",
                        "https://api2.drand.sh",
                        "https://api3.drand.sh",
                        "https://drand.cloudflare.com",
                        "https://api.drand.secureweb3.com:6875", // Storswift
                },
                Relays: []string{
                        "/dnsaddr/api.drand.sh/",
                        "/dnsaddr/api2.drand.sh/",
                        "/dnsaddr/api3.drand.sh/",
                },
                IsChained:     false,
                ChainInfoJSON: `{"public_key":"83cf0f2896adee7eb8b5f01fcad3912212c437e0073e911fb90022d3e760183c8c4b450b6a0a6c3ac6a5776a2d1064510d1fec758c921cc22b0e17e63aaf4bcb5ed66304de9cf809bd274ca73bab4af5a6e9c76a4bc09e76eae8991ef5ece45a","period":3,"genesis_time":1692803367,"hash":"52db9ba70e0cc0f6eaf7803dd07447a1f5477735fd3f661792ba94600c84e971","groupHash":"f477d5c89f21a17c863a7f937c6a6d15859414d2be09cd448d4279af331c5d3e","schemeID":"bls-unchained-g1-rfc9380","metadata":{"beaconID":"quicknet"}}`,
        },
        DrandTestnet: {
                Servers: []string{
                        "https://pl-eu.testnet.drand.sh",
                        "https://pl-us.testnet.drand.sh",
                },
                Relays: []string{
                        "/dnsaddr/pl-eu.testnet.drand.sh/",
                        "/dnsaddr/pl-us.testnet.drand.sh/",
                },
                IsChained:     true,
                ChainInfoJSON: `{"public_key":"922a2e93828ff83345bae533f5172669a26c02dc76d6bf59c80892e12ab1455c229211886f35bb56af6d5bea981024df","period":25,"genesis_time":1590445175,"hash":"84b2234fb34e835dccd048255d7ad3194b81af7d978c3bf157e3469592ae4e02","groupHash":"4dd408e5fdff9323c76a9b6f087ba8fdc5a6da907bd9217d9d10f2287d081957"}`,
        },
        DrandDevnet: {
                Servers: []string{
                        "https://dev1.drand.sh",
                        "https://dev2.drand.sh",
                },
                Relays: []string{
                        "/dnsaddr/dev1.drand.sh/",
                        "/dnsaddr/dev2.drand.sh/",
                },
                IsChained:     true,
                ChainInfoJSON: `{"public_key":"8cda589f88914aa728fd183f383980b35789ce81b274e5daee1f338b77d02566ef4d3fb0098af1f844f10f9c803c1827","period":25,"genesis_time":1595348225,"hash":"e73b7dc3c4f6a236378220c0dd6aa110eb16eed26c11259606e07ee122838d4f","groupHash":"567d4785122a5a3e75a9bc9911d7ea807dd85ff76b78dc4ff06b075712898607"}`,
        },
        DrandIncentinet: {
                IsChained:     true,
                ChainInfoJSON: `{"public_key":"8cad0c72c606ab27d36ee06de1d5b2db1faf92e447025ca37575ab3a8aac2eaae83192f846fc9e158bc738423753d000","period":30,"genesis_time":1595873820,"hash":"80c8b872c714f4c00fdd3daa465d5514049f457f01f85a4caf68cdcd394ba039","groupHash":"d9406aaed487f7af71851b4399448e311f2328923d454e971536c05398ce2d9b"}`,
        },
}

package build

import (
        "embed"
        "path"

        logging "github.com/ipfs/go-log/v2"
)

// moved from now-defunct build/paramfetch.go
var log = logging.Logger("build")

//go:embed genesis
var genesisfs embed.FS

func MaybeGenesis() []byte {
        genBytes, err := genesisfs.ReadFile(path.Join("genesis", GenesisFile))
        if err != nil {
                log.Warnf("loading built-in genesis: %s", err)
                return nil
        }
        return genBytes
}

package build

import (
        "github.com/filecoin-project/go-state-types/abi"
)

func IsNearUpgrade(epoch, upgradeEpoch abi.ChainEpoch) bool {
        if upgradeEpoch < 0 {
                return false
        }
        return epoch > upgradeEpoch-Finality && epoch < upgradeEpoch+Finality
}

package build

import (
        "bytes"
        "embed"
        "encoding/json"

        apitypes "github.com/filecoin-project/lotus/api/types"
)

//go:embed openrpc
var openrpcfs embed.FS

func mustReadOpenRPCDocument(data []byte) apitypes.OpenRPCDocument {
        m := apitypes.OpenRPCDocument{}
        err := json.NewDecoder(bytes.NewBuffer(data)).Decode(&m)
        if err != nil {
                log.Fatal(err)
        }
        return m
}

func OpenRPCDiscoverJSON_Full() apitypes.OpenRPCDocument {
        data, err := openrpcfs.ReadFile("openrpc/full.json")
        if err != nil {
                panic(err)
        }
        return mustReadOpenRPCDocument(data)
}

func OpenRPCDiscoverJSON_Miner() apitypes.OpenRPCDocument {
        data, err := openrpcfs.ReadFile("openrpc/miner.json")
        if err != nil {
                panic(err)
        }
        return mustReadOpenRPCDocument(data)
}

func OpenRPCDiscoverJSON_Worker() apitypes.OpenRPCDocument {
        data, err := openrpcfs.ReadFile("openrpc/worker.json")
        if err != nil {
                panic(err)
        }
        return mustReadOpenRPCDocument(data)
}

func OpenRPCDiscoverJSON_Gateway() apitypes.OpenRPCDocument {
        data, err := openrpcfs.ReadFile("openrpc/gateway.json")
        if err != nil {
                panic(err)
        }
        return mustReadOpenRPCDocument(data)
}

package build

import (
        "fmt"
        "io"
        "os"
        "path/filepath"
        "runtime/debug"
        "runtime/pprof"
        "strconv"
        "strings"
        "time"

        "github.com/icza/backscanner"
        logging "github.com/ipfs/go-log/v2"
)

var (
        panicLog           = logging.Logger("panic-reporter")
        defaultJournalTail = 500
)

// PanicReportingPath is the name of the subdir created within the repoPath
// path provided to GeneratePanicReport
var PanicReportingPath = "panic-reports"

// PanicReportJournalTail is the number of lines captured from the end of
// the lotus journal to be included in the panic report.
var PanicReportJournalTail = defaultJournalTail

// GenerateNodePanicReport produces a timestamped dump of the application state
// for inspection and debugging purposes. Call this function from any place
// where a panic or severe error needs to be examined. `persistPath` is the
// path where the reports should be saved. `repoPath` is the path where the
// journal should be read from. `label` is an optional string to include
// next to the report timestamp.
//
// This function should be called for panics originating from the Lotus daemon.
func GenerateNodePanicReport(persistPath, repoPath, label string) {
        generatePanicReport(NodeUserVersion(), persistPath, repoPath, label)
}

// GenerateMinerPanicReport produces a timestamped dump of the application state
// for inspection and debugging purposes. Call this function from any place
// where a panic or severe error needs to be examined. `persistPath` is the
// path where the reports should be saved. `repoPath` is the path where the
// journal should be read from. `label` is an optional string to include
// next to the report timestamp.
//
// This function should be called for panics originating from the Lotus miner.
func GenerateMinerPanicReport(persistPath, repoPath, label string) {
        generatePanicReport(MinerUserVersion(), persistPath, repoPath, label)
}

func generatePanicReport(buildVersion BuildVersion, persistPath, repoPath, label string) {
        // make sure we always dump the latest logs on the way out
        // especially since we're probably panicking
        defer panicLog.Sync() //nolint:errcheck

        if persistPath == "" && repoPath == "" {
                panicLog.Warn("missing persist and repo paths, aborting panic report creation")
                return
        }

        reportPath := filepath.Join(repoPath, PanicReportingPath, generateReportName(label))
        if persistPath != "" {
                reportPath = filepath.Join(persistPath, generateReportName(label))
        }
        panicLog.Warnf("generating panic report at %s", reportPath)

        tl := os.Getenv("LOTUS_PANIC_JOURNAL_LOOKBACK")
        if tl != "" && PanicReportJournalTail == defaultJournalTail {
                i, err := strconv.Atoi(tl)
                if err == nil {
                        PanicReportJournalTail = i
                }
        }

        err := os.MkdirAll(reportPath, 0755)
        if err != nil {
                panicLog.Error(err.Error())
                return
        }

        writeAppVersion(buildVersion, filepath.Join(reportPath, "version"))
        writeStackTrace(filepath.Join(reportPath, "stacktrace.dump"))
        writeProfile("goroutines", filepath.Join(reportPath, "goroutines.pprof.gz"))
        writeProfile("heap", filepath.Join(reportPath, "heap.pprof.gz"))
        writeJournalTail(PanicReportJournalTail, repoPath, filepath.Join(reportPath, "journal.ndjson"))
}

func writeAppVersion(buildVersion BuildVersion, file string) {
        f, err := os.Create(file)
        if err != nil {
                panicLog.Error(err.Error())
        }
        defer f.Close() //nolint:errcheck

        versionString := []byte(string(buildVersion) + BuildTypeString() + CurrentCommit + "\n")
        if _, err := f.Write(versionString); err != nil {
                panicLog.Error(err.Error())
        }
}

func writeStackTrace(file string) {
        f, err := os.Create(file)
        if err != nil {
                panicLog.Error(err.Error())
        }
        defer f.Close() //nolint:errcheck

        if _, err := f.Write(debug.Stack()); err != nil {
                panicLog.Error(err.Error())
        }

}

func writeProfile(profileType string, file string) {
        p := pprof.Lookup(profileType)
        if p == nil {
                panicLog.Warnf("%s profile not available", profileType)
                return
        }
        f, err := os.Create(file)
        if err != nil {
                panicLog.Error(err.Error())
                return
        }
        defer f.Close() //nolint:errcheck

        if err := p.WriteTo(f, 0); err != nil {
                panicLog.Error(err.Error())
        }
}

func writeJournalTail(tailLen int, repoPath, file string) {
        if repoPath == "" {
                panicLog.Warn("repo path is empty, aborting copy of journal log")
                return
        }

        f, err := os.Create(file)
        if err != nil {
                panicLog.Error(err.Error())
                return
        }
        defer f.Close() //nolint:errcheck

        jPath, err := getLatestJournalFilePath(repoPath)
        if err != nil {
                panicLog.Warnf("failed getting latest journal: %s", err.Error())
                return
        }
        j, err := os.OpenFile(jPath, os.O_RDONLY, 0400)
        if err != nil {
                panicLog.Error(err.Error())
                return
        }
        js, err := j.Stat()
        if err != nil {
                panicLog.Error(err.Error())
                return
        }
        jScan := backscanner.New(j, int(js.Size()))
        linesWritten := 0
        for {
                if linesWritten > tailLen {
                        break
                }
                line, _, err := jScan.LineBytes()
                if err != nil {
                        if err != io.EOF {
                                panicLog.Error(err.Error())
                        }
                        break
                }
                if _, err := f.Write(line); err != nil {
                        panicLog.Error(err.Error())
                        break
                }
                if _, err := f.Write([]byte("\n")); err != nil {
                        panicLog.Error(err.Error())
                        break
                }
                linesWritten++
        }
}

func getLatestJournalFilePath(repoPath string) (string, error) {
        journalPath := filepath.Join(repoPath, "journal")
        entries, err := os.ReadDir(journalPath)
        if err != nil {
                return "", err
        }
        return filepath.Join(journalPath, entries[len(entries)-1].Name()), nil
}

func generateReportName(label string) string {
        label = strings.ReplaceAll(label, " ", "")
        return fmt.Sprintf("report_%s_%s", label, time.Now().Format("2006-01-02T150405"))
}

package build

import (
        _ "embed"
)

//go:embed proof-params/parameters.json
var params []byte

//go:embed proof-params/srs-inner-product.json
var srs []byte

func ParametersJSON() []byte {
        return params
}

func SrsJSON() []byte {
        return srs
}

//go:build !debug && !2k && !testground && !calibnet && !butterflynet && !interopnet
// +build !debug,!2k,!testground,!calibnet,!butterflynet,!interopnet

package build

import (
        "math"
        "os"
        "strconv"

        "github.com/filecoin-project/go-address"
        "github.com/filecoin-project/go-state-types/abi"
        actorstypes "github.com/filecoin-project/go-state-types/actors"
        "github.com/filecoin-project/go-state-types/network"
        builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
)

var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
        0:                    DrandIncentinet,
        UpgradeSmokeHeight:   DrandMainnet,
        UpgradePhoenixHeight: DrandQuicknet,
}

var NetworkBundle = "mainnet"

// NOTE: DO NOT change this unless you REALLY know what you're doing. This is consensus critical.
var BundleOverrides map[actorstypes.Version]string

// NOTE: DO NOT change this unless you REALLY know what you're doing. This is consensus critical.
const ActorDebugging = false

const GenesisNetworkVersion = network.Version0

const BootstrappersFile = "mainnet.pi"
const GenesisFile = "mainnet.car"

const UpgradeBreezeHeight = 41280

const BreezeGasTampingDuration = 120

const UpgradeSmokeHeight = 51000

const UpgradeIgnitionHeight = 94000
const UpgradeRefuelHeight = 130800

const UpgradeAssemblyHeight = 138720

const UpgradeTapeHeight = 140760

// This signals our tentative epoch for mainnet launch. Can make it later, but not earlier.
// Miners, clients, developers, custodians all need time to prepare.
// We still have upgrades and state changes to do, but can happen after signaling timing here.
const UpgradeLiftoffHeight = 148888

const UpgradeKumquatHeight = 170000

const UpgradeCalicoHeight = 265200
const UpgradePersianHeight = UpgradeCalicoHeight + (builtin2.EpochsInHour * 60)

const UpgradeOrangeHeight = 336458

// 2020-12-22T02:00:00Z
// var because of wdpost_test.go
var UpgradeClausHeight = abi.ChainEpoch(343200)

// 2021-03-04T00:00:30Z
const UpgradeTrustHeight = 550321

// 2021-04-12T22:00:00Z
const UpgradeNorwegianHeight = 665280

// 2021-04-29T06:00:00Z
const UpgradeTurboHeight = 712320

// 2021-06-30T22:00:00Z
const UpgradeHyperdriveHeight = 892800

// 2021-10-26T13:30:00Z
const UpgradeChocolateHeight = 1231620

// 2022-03-01T15:00:00Z
const UpgradeOhSnapHeight = 1594680

// 2022-07-06T14:00:00Z
const UpgradeSkyrHeight = 1960320

// 2022-11-30T14:00:00Z
const UpgradeSharkHeight = 2383680

// 2023-03-14T15:14:00Z
const UpgradeHyggeHeight = 2683348

// 2023-04-27T13:00:00Z
const UpgradeLightningHeight = 2809800

// 2023-05-18T13:00:00Z
const UpgradeThunderHeight = UpgradeLightningHeight + 2880*21

// 2023-12-12T13:30:00Z
const UpgradeWatermelonHeight = 3469380

// 2024-04-24T14:00:00Z
const UpgradeDragonHeight = 3855360

// This epoch, 120 epochs after the "rest" of the nv22 upgrade, is when we switch to Drand quicknet
// 2024-04-11T15:00:00Z
const UpgradePhoenixHeight = UpgradeDragonHeight + 120

// ??????
var UpgradeWaffleHeight = abi.ChainEpoch(9999999999)

// This fix upgrade only ran on calibrationnet
const UpgradeWatermelonFixHeight = -1

// This fix upgrade only ran on calibrationnet
const UpgradeWatermelonFix2Height = -2

// This fix upgrade only ran on calibrationnet
const UpgradeCalibrationDragonFixHeight = -3

var SupportedProofTypes = []abi.RegisteredSealProof{
        abi.RegisteredSealProof_StackedDrg32GiBV1,
        abi.RegisteredSealProof_StackedDrg64GiBV1,
}
var ConsensusMinerMinPower = abi.NewStoragePower(10 << 40)
var PreCommitChallengeDelay = abi.ChainEpoch(150)
var PropagationDelaySecs = uint64(10)

var EquivocationDelaySecs = uint64(2)

func init() {
        if os.Getenv("LOTUS_USE_TEST_ADDRESSES") != "1" {
                SetAddressNetwork(address.Mainnet)
        }

        if os.Getenv("LOTUS_DISABLE_WAFFLE") == "1" {
                UpgradeWaffleHeight = math.MaxInt64 - 1
        }

        // NOTE: DO NOT change this unless you REALLY know what you're doing. This is not consensus critical, however,
        //set this value too high may impacts your block submission; set this value too low may cause you miss
        //parent tipsets for blocking forming and mining.
        if len(os.Getenv("PROPAGATION_DELAY_SECS")) != 0 {
                pds, err := strconv.ParseUint(os.Getenv("PROPAGATION_DELAY_SECS"), 10, 64)
                if err != nil {
                        log.Warnw("Error setting PROPAGATION_DELAY_SECS, %v, proceed with default value %s", err,
                                PropagationDelaySecs)
                } else {
                        PropagationDelaySecs = pds
                        log.Warnw(" !!WARNING!! propagation delay is set to be %s second, "+
                                "this value impacts your message republish interval and block forming - monitor with caution!!", PropagationDelaySecs)
                }
        }

        Devnet = false

        BuildType = BuildMainnet
}

const BlockDelaySecs = uint64(builtin2.EpochDurationSeconds)

// BootstrapPeerThreshold is the minimum number peers we need to track for a sync worker to start
const BootstrapPeerThreshold = 4

// ChainId defines the chain ID used in the Ethereum JSON-RPC endpoint.
// As per https://github.com/ethereum-lists/chains
const Eip155ChainId = 314

// WhitelistedBlock skips checks on message validity in this block to sidestep the zero-bls signature
var WhitelistedBlock = MustParseCid("bafy2bzaceapyg2uyzk7vueh3xccxkuwbz3nxewjyguoxvhx77malc2lzn2ybi")

const F3Enabled = false
const F3BootstrapEpoch abi.ChainEpoch = -1

package build

import (
        "github.com/ipfs/go-cid"
        "github.com/libp2p/go-libp2p/core/protocol"

        "github.com/filecoin-project/go-address"

        "github.com/filecoin-project/lotus/node/modules/dtypes"
)

// Core network constants

func BlocksTopic(netName dtypes.NetworkName) string   { return "/fil/blocks/" + string(netName) }
func MessagesTopic(netName dtypes.NetworkName) string { return "/fil/msgs/" + string(netName) }
func IndexerIngestTopic(netName dtypes.NetworkName) string {

        nn := string(netName)
        // The network name testnetnet is here for historical reasons.
        // Going forward we aim to use the name `mainnet` where possible.
        if nn == "testnetnet" {
                nn = "mainnet"
        }

        return "/indexer/ingest/" + nn
}
func DhtProtocolName(netName dtypes.NetworkName) protocol.ID {
        return protocol.ID("/fil/kad/" + string(netName))
}

func SetAddressNetwork(n address.Network) {
        address.CurrentNetwork = n
}

func MustParseAddress(addr string) address.Address {
        ret, err := address.NewFromString(addr)
        if err != nil {
                panic(err)
        }

        return ret
}

func MustParseCid(c string) cid.Cid {
        ret, err := cid.Decode(c)
        if err != nil {
                panic(err)
        }

        return ret
}

//go:build !testground
// +build !testground

package build

import (
        "math/big"
        "os"

        "github.com/filecoin-project/go-address"
        "github.com/filecoin-project/go-state-types/abi"
        "github.com/filecoin-project/go-state-types/network"
        builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"

        "github.com/filecoin-project/lotus/chain/actors/policy"
)

// /////
// Storage

const UnixfsChunkSize uint64 = 1 << 20
const UnixfsLinksPerLevel = 1024

// /////
// Consensus / Network

const AllowableClockDriftSecs = uint64(1)

// Used by tests and some obscure tooling
/* inline-gen template
const TestNetworkVersion = network.Version{{.latestNetworkVersion}}
/* inline-gen start */
const TestNetworkVersion = network.Version23

/* inline-gen end */

// Epochs
const ForkLengthThreshold = Finality

// Blocks (e)
var BlocksPerEpoch = uint64(builtin2.ExpectedLeadersPerEpoch)

// Epochs
const Finality = policy.ChainFinality
const MessageConfidence = uint64(5)

// constants for Weight calculation
// The ratio of weight contributed by short-term vs long-term factors in a given round
const WRatioNum = int64(1)
const WRatioDen = uint64(2)

// /////
// Proofs

// Epochs
// TODO: unused
const SealRandomnessLookback = policy.SealRandomnessLookback

// /////
// Mining

// Epochs
const TicketRandomnessLookback = abi.ChainEpoch(1)

// /////
// Address

const AddressMainnetEnvVar = "_mainnet_"

// the 'f' prefix doesn't matter
var ZeroAddress = MustParseAddress("f3yaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaby2smx7a")

// /////
// Devnet settings

var Devnet = true

const FilBase = uint64(2_000_000_000)
const FilAllocStorageMining = uint64(1_100_000_000)

const FilecoinPrecision = uint64(1_000_000_000_000_000_000)
const FilReserved = uint64(300_000_000)

var InitialRewardBalance *big.Int
var InitialFilReserved *big.Int

// TODO: Move other important consts here

func init() {
        InitialRewardBalance = big.NewInt(int64(FilAllocStorageMining))
        InitialRewardBalance = InitialRewardBalance.Mul(InitialRewardBalance, big.NewInt(int64(FilecoinPrecision)))

        InitialFilReserved = big.NewInt(int64(FilReserved))
        InitialFilReserved = InitialFilReserved.Mul(InitialFilReserved, big.NewInt(int64(FilecoinPrecision)))

        if os.Getenv("LOTUS_ADDRESS_TYPE") == AddressMainnetEnvVar {
                SetAddressNetwork(address.Mainnet)
        }
}

// Sync
const BadBlockCacheSize = 1 << 15

// assuming 4000 messages per round, this lets us not lose any messages across a
// 10 block reorg.
const BlsSignatureCacheSize = 40000

// Size of signature verification cache
// 32k keeps the cache around 10MB in size, max
const VerifSigCacheSize = 32000

// ///////
// Limits

// TODO: If this is gonna stay, it should move to specs-actors
const BlockMessageLimit = 10000

var BlockGasLimit = int64(10_000_000_000)
var BlockGasTarget = BlockGasLimit / 2

const BaseFeeMaxChangeDenom = 8 // 12.5%
const InitialBaseFee = 100e6
const MinimumBaseFee = 100
const PackingEfficiencyNum = 4
const PackingEfficiencyDenom = 5

// revive:disable-next-line:exported
// Actor consts
// TODO: pieceSize unused from actors
var MinDealDuration, MaxDealDuration = policy.DealDurationBounds(0)

package build

import "os"

type BuildVersion string

var CurrentCommit string
var BuildType int

const (
        BuildDefault      = 0
        BuildMainnet      = 0x1
        Build2k           = 0x2
        BuildDebug        = 0x3
        BuildCalibnet     = 0x4
        BuildInteropnet   = 0x5
        BuildButterflynet = 0x7
)

func BuildTypeString() string {
        switch BuildType {
        case BuildDefault:
                return ""
        case BuildMainnet:
                return "+mainnet"
        case Build2k:
                return "+2k"
        case BuildDebug:
                return "+debug"
        case BuildCalibnet:
                return "+calibnet"
        case BuildInteropnet:
                return "+interopnet"
        case BuildButterflynet:
                return "+butterflynet"
        default:
                return "+huh?"
        }
}

// NodeBuildVersion is the local build version of the Lotus daemon
const NodeBuildVersion string = "1.27.2-dev"

func NodeUserVersion() BuildVersion {
        if os.Getenv("LOTUS_VERSION_IGNORE_COMMIT") == "1" {
                return BuildVersion(NodeBuildVersion)
        }

        return BuildVersion(NodeBuildVersion + BuildTypeString() + CurrentCommit)
}

// MinerBuildVersion is the local build version of the Lotus miner
const MinerBuildVersion = "1.27.2-dev"

func MinerUserVersion() BuildVersion {
        if os.Getenv("LOTUS_VERSION_IGNORE_COMMIT") == "1" {
                return BuildVersion(MinerBuildVersion)
        }

        return BuildVersion(MinerBuildVersion + BuildTypeString() + CurrentCommit)
}

package actors

import (
        "github.com/ipfs/go-cid"
        "golang.org/x/xerrors"

        actorstypes "github.com/filecoin-project/go-state-types/actors"
        "github.com/filecoin-project/go-state-types/manifest"
        builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
        builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
        builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
        builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
        builtin5 "github.com/filecoin-project/specs-actors/v5/actors/builtin"
        builtin6 "github.com/filecoin-project/specs-actors/v6/actors/builtin"
        builtin7 "github.com/filecoin-project/specs-actors/v7/actors/builtin"
)

// GetActorCodeID looks up a builtin actor's code CID by actor version and canonical actor name.
func GetActorCodeID(av actorstypes.Version, name string) (cid.Cid, bool) {

        // Actors V8 and above
        if av >= actorstypes.Version8 {
                if cids, ok := GetActorCodeIDsFromManifest(av); ok {
                        c, ok := cids[name]
                        return c, ok
                }
        }

        // Actors V7 and lower
        switch name {

        case manifest.AccountKey:
                switch av {

                case actorstypes.Version0:
                        return builtin0.AccountActorCodeID, true

                case actorstypes.Version2:
                        return builtin2.AccountActorCodeID, true

                case actorstypes.Version3:
                        return builtin3.AccountActorCodeID, true

                case actorstypes.Version4:
                        return builtin4.AccountActorCodeID, true

                case actorstypes.Version5:
                        return builtin5.AccountActorCodeID, true

                case actorstypes.Version6:
                        return builtin6.AccountActorCodeID, true

                case actorstypes.Version7:
                        return builtin7.AccountActorCodeID, true
                }

        case manifest.CronKey:
                switch av {

                case actorstypes.Version0:
                        return builtin0.CronActorCodeID, true

                case actorstypes.Version2:
                        return builtin2.CronActorCodeID, true

                case actorstypes.Version3:
                        return builtin3.CronActorCodeID, true

                case actorstypes.Version4:
                        return builtin4.CronActorCodeID, true

                case actorstypes.Version5:
                        return builtin5.CronActorCodeID, true

                case actorstypes.Version6:
                        return builtin6.CronActorCodeID, true

                case actorstypes.Version7:
                        return builtin7.CronActorCodeID, true
                }

        case manifest.InitKey:
                switch av {

                case actorstypes.Version0:
                        return builtin0.InitActorCodeID, true

                case actorstypes.Version2:
                        return builtin2.InitActorCodeID, true

                case actorstypes.Version3:
                        return builtin3.InitActorCodeID, true

                case actorstypes.Version4:
                        return builtin4.InitActorCodeID, true

                case actorstypes.Version5:
                        return builtin5.InitActorCodeID, true

                case actorstypes.Version6:
                        return builtin6.InitActorCodeID, true

                case actorstypes.Version7:
                        return builtin7.InitActorCodeID, true
                }

        case manifest.MarketKey:
                switch av {

                case actorstypes.Version0:
                        return builtin0.StorageMarketActorCodeID, true

                case actorstypes.Version2:
                        return builtin2.StorageMarketActorCodeID, true

                case actorstypes.Version3:
                        return builtin3.StorageMarketActorCodeID, true

                case actorstypes.Version4:
                        return builtin4.StorageMarketActorCodeID, true

                case actorstypes.Version5:
                        return builtin5.StorageMarketActorCodeID, true

                case actorstypes.Version6:
                        return builtin6.StorageMarketActorCodeID, true

                case actorstypes.Version7:
                        return builtin7.StorageMarketActorCodeID, true
                }

        case manifest.MinerKey:
                switch av {

                case actorstypes.Version0:
                        return builtin0.StorageMinerActorCodeID, true

                case actorstypes.Version2:
                        return builtin2.StorageMinerActorCodeID, true

                case actorstypes.Version3:
                        return builtin3.StorageMinerActorCodeID, true

                case actorstypes.Version4:
                        return builtin4.StorageMinerActorCodeID, true

                case actorstypes.Version5:
                        return builtin5.StorageMinerActorCodeID, true

                case actorstypes.Version6:
                        return builtin6.StorageMinerActorCodeID, true

                case actorstypes.Version7:
                        return builtin7.StorageMinerActorCodeID, true
                }

        case manifest.MultisigKey:
                switch av {

                case actorstypes.Version0:
                        return builtin0.MultisigActorCodeID, true

                case actorstypes.Version2:
                        return builtin2.MultisigActorCodeID, true

                case actorstypes.Version3:
                        return builtin3.MultisigActorCodeID, true

                case actorstypes.Version4:
                        return builtin4.MultisigActorCodeID, true

                case actorstypes.Version5:
                        return builtin5.MultisigActorCodeID, true

                case actorstypes.Version6:
                        return builtin6.MultisigActorCodeID, true

                case actorstypes.Version7:
                        return builtin7.MultisigActorCodeID, true
                }

        case manifest.PaychKey:
                switch av {

                case actorstypes.Version0:
                        return builtin0.PaymentChannelActorCodeID, true

                case actorstypes.Version2:
                        return builtin2.PaymentChannelActorCodeID, true

                case actorstypes.Version3:
                        return builtin3.PaymentChannelActorCodeID, true

                case actorstypes.Version4:
                        return builtin4.PaymentChannelActorCodeID, true

                case actorstypes.Version5:
                        return builtin5.PaymentChannelActorCodeID, true

                case actorstypes.Version6:
                        return builtin6.PaymentChannelActorCodeID, true

                case actorstypes.Version7:
                        return builtin7.PaymentChannelActorCodeID, true
                }

        case manifest.PowerKey:
                switch av {

                case actorstypes.Version0:
                        return builtin0.StoragePowerActorCodeID, true

                case actorstypes.Version2:
                        return builtin2.StoragePowerActorCodeID, true

                case actorstypes.Version3:
                        return builtin3.StoragePowerActorCodeID, true

                case actorstypes.Version4:
                        return builtin4.StoragePowerActorCodeID, true

                case actorstypes.Version5:
                        return builtin5.StoragePowerActorCodeID, true

                case actorstypes.Version6:
                        return builtin6.StoragePowerActorCodeID, true

                case actorstypes.Version7:
                        return builtin7.StoragePowerActorCodeID, true
                }

        case manifest.RewardKey:
                switch av {

                case actorstypes.Version0:
                        return builtin0.RewardActorCodeID, true

                case actorstypes.Version2:
                        return builtin2.RewardActorCodeID, true

                case actorstypes.Version3:
                        return builtin3.RewardActorCodeID, true

                case actorstypes.Version4:
                        return builtin4.RewardActorCodeID, true

                case actorstypes.Version5:
                        return builtin5.RewardActorCodeID, true

                case actorstypes.Version6:
                        return builtin6.RewardActorCodeID, true

                case actorstypes.Version7:
                        return builtin7.RewardActorCodeID, true
                }

        case manifest.SystemKey:
                switch av {

                case actorstypes.Version0:
                        return builtin0.SystemActorCodeID, true

                case actorstypes.Version2:
                        return builtin2.SystemActorCodeID, true

                case actorstypes.Version3:
                        return builtin3.SystemActorCodeID, true

                case actorstypes.Version4:
                        return builtin4.SystemActorCodeID, true

                case actorstypes.Version5:
                        return builtin5.SystemActorCodeID, true

                case actorstypes.Version6:
                        return builtin6.SystemActorCodeID, true

                case actorstypes.Version7:
                        return builtin7.SystemActorCodeID, true
                }

        case manifest.VerifregKey:
                switch av {

                case actorstypes.Version0:
                        return builtin0.VerifiedRegistryActorCodeID, true

                case actorstypes.Version2:
                        return builtin2.VerifiedRegistryActorCodeID, true

                case actorstypes.Version3:
                        return builtin3.VerifiedRegistryActorCodeID, true

                case actorstypes.Version4:
                        return builtin4.VerifiedRegistryActorCodeID, true

                case actorstypes.Version5:
                        return builtin5.VerifiedRegistryActorCodeID, true

                case actorstypes.Version6:
                        return builtin6.VerifiedRegistryActorCodeID, true

                case actorstypes.Version7:
                        return builtin7.VerifiedRegistryActorCodeID, true
                }
        }

        return cid.Undef, false
}

// GetActorCodeIDs looks up all builtin actor's code CIDs by actor version.
func GetActorCodeIDs(av actorstypes.Version) (map[string]cid.Cid, error) {
        cids, ok := GetActorCodeIDsFromManifest(av)
        if ok {
                return cids, nil
        }

        actorsKeys := manifest.GetBuiltinActorsKeys(av)
        synthCids := make(map[string]cid.Cid)

        for _, key := range actorsKeys {
                c, ok := GetActorCodeID(av, key)
                if !ok {
                        return nil, xerrors.Errorf("could not find builtin actor cids for Actors version %d", av)
                }
                synthCids[key] = c
        }

        return synthCids, nil
}

package adt

import (
        "bytes"

        typegen "github.com/whyrusleeping/cbor-gen"

        "github.com/filecoin-project/go-state-types/abi"
)

// AdtArrayDiff generalizes adt.Array diffing by accepting a Deferred type that can unmarshalled to its corresponding struct
// in an interface implantation.
// Add should be called when a new k,v is added to the array
// Modify should be called when a value is modified in the array
// Remove should be called when a value is removed from the array
type AdtArrayDiff interface {
        Add(key uint64, val *typegen.Deferred) error
        Modify(key uint64, from, to *typegen.Deferred) error
        Remove(key uint64, val *typegen.Deferred) error
}

// TODO Performance can be improved by diffing the underlying IPLD graph, e.g. https://github.com/ipfs/go-merkledag/blob/749fd8717d46b4f34c9ce08253070079c89bc56d/dagutils/diff.go#L104
// CBOR Marshaling will likely be the largest performance bottleneck here.

// DiffAdtArray accepts two *adt.Array's and an AdtArrayDiff implementation. It does the following:
// - All values that exist in preArr and not in curArr are passed to AdtArrayDiff.Remove()
// - All values that exist in curArr nnd not in prevArr are passed to adtArrayDiff.Add()
// - All values that exist in preArr and in curArr are passed to AdtArrayDiff.Modify()
//   - It is the responsibility of AdtArrayDiff.Modify() to determine if the values it was passed have been modified.
func DiffAdtArray(preArr, curArr Array, out AdtArrayDiff) error {
        notNew := make(map[int64]struct{}, curArr.Length())
        prevVal := new(typegen.Deferred)
        if err := preArr.ForEach(prevVal, func(i int64) error {
                curVal := new(typegen.Deferred)
                found, err := curArr.Get(uint64(i), curVal)
                if err != nil {
                        return err
                }
                if !found {
                        if err := out.Remove(uint64(i), prevVal); err != nil {
                                return err
                        }
                        return nil
                }

                // no modification
                if !bytes.Equal(prevVal.Raw, curVal.Raw) {
                        if err := out.Modify(uint64(i), prevVal, curVal); err != nil {
                                return err
                        }
                }
                notNew[i] = struct{}{}
                return nil
        }); err != nil {
                return err
        }

        curVal := new(typegen.Deferred)
        return curArr.ForEach(curVal, func(i int64) error {
                if _, ok := notNew[i]; ok {
                        return nil
                }
                return out.Add(uint64(i), curVal)
        })
}

// TODO Performance can be improved by diffing the underlying IPLD graph, e.g. https://github.com/ipfs/go-merkledag/blob/749fd8717d46b4f34c9ce08253070079c89bc56d/dagutils/diff.go#L104
// CBOR Marshaling will likely be the largest performance bottleneck here.

// AdtMapDiff generalizes adt.Map diffing by accepting a Deferred type that can unmarshalled to its corresponding struct
// in an interface implantation.
// AsKey should return the Keyer implementation specific to the map
// Add should be called when a new k,v is added to the map
// Modify should be called when a value is modified in the map
// Remove should be called when a value is removed from the map
type AdtMapDiff interface {
        AsKey(key string) (abi.Keyer, error)
        Add(key string, val *typegen.Deferred) error
        Modify(key string, from, to *typegen.Deferred) error
        Remove(key string, val *typegen.Deferred) error
}

func DiffAdtMap(preMap, curMap Map, out AdtMapDiff) error {
        notNew := make(map[string]struct{})
        prevVal := new(typegen.Deferred)
        if err := preMap.ForEach(prevVal, func(key string) error {
                curVal := new(typegen.Deferred)
                k, err := out.AsKey(key)
                if err != nil {
                        return err
                }

                found, err := curMap.Get(k, curVal)
                if err != nil {
                        return err
                }
                if !found {
                        if err := out.Remove(key, prevVal); err != nil {
                                return err
                        }
                        return nil
                }

                // no modification
                if !bytes.Equal(prevVal.Raw, curVal.Raw) {
                        if err := out.Modify(key, prevVal, curVal); err != nil {
                                return err
                        }
                }
                notNew[key] = struct{}{}
                return nil
        }); err != nil {
                return err
        }

        curVal := new(typegen.Deferred)
        return curMap.ForEach(curVal, func(key string) error {
                if _, ok := notNew[key]; ok {
                        return nil
                }
                return out.Add(key, curVal)
        })
}

package adt

import (
        "context"

        cbor "github.com/ipfs/go-ipld-cbor"

        "github.com/filecoin-project/specs-actors/actors/util/adt"
)

type Store interface {
        Context() context.Context
        cbor.IpldStore
}

func WrapStore(ctx context.Context, store cbor.IpldStore) Store {
        return adt.WrapStore(ctx, store)
}

package aerrors

import (
        "fmt"

        "golang.org/x/xerrors"

        "github.com/filecoin-project/go-state-types/exitcode"
)

func IsFatal(err ActorError) bool {
        return err != nil && err.IsFatal()
}
func RetCode(err ActorError) exitcode.ExitCode {
        if err == nil {
                return 0
        }
        return err.RetCode()
}

type internalActorError interface {
        ActorError
        FormatError(p xerrors.Printer) (next error)
        Unwrap() error
}

type ActorError interface {
        error
        IsFatal() bool
        RetCode() exitcode.ExitCode
}

type actorError struct {
        fatal   bool
        retCode exitcode.ExitCode

        msg   string
        frame xerrors.Frame
        err   error
}

func (e *actorError) IsFatal() bool {
        return e.fatal
}

func (e *actorError) RetCode() exitcode.ExitCode {
        return e.retCode
}

func (e *actorError) Error() string {
        return fmt.Sprint(e)
}
func (e *actorError) Format(s fmt.State, v rune) { xerrors.FormatError(e, s, v) }
func (e *actorError) FormatError(p xerrors.Printer) (next error) {
        p.Print(e.msg)
        if e.fatal {
                p.Print(" (FATAL)")
        } else {
                p.Printf(" (RetCode=%d)", e.retCode)
        }

        e.frame.Format(p)
        return e.err
}

func (e *actorError) Unwrap() error {
        return e.err
}

var _ internalActorError = (*actorError)(nil)

package aerrors

import (
        "errors"
        "fmt"

        cbor "github.com/ipfs/go-ipld-cbor"
        "golang.org/x/xerrors"

        "github.com/filecoin-project/go-state-types/exitcode"
)

// New creates a new non-fatal error
func New(retCode exitcode.ExitCode, message string) ActorError {
        if retCode == 0 {
                return &actorError{
                        fatal:   true,
                        retCode: 0,

                        msg:   "tried creating an error and setting RetCode to 0",
                        frame: xerrors.Caller(1),
                        err:   errors.New(message),
                }
        }
        return &actorError{
                retCode: retCode,

                msg:   message,
                frame: xerrors.Caller(1),
        }
}

// Newf creates a new non-fatal error
func Newf(retCode exitcode.ExitCode, format string, args ...interface{}) ActorError {
        if retCode == 0 {
                return &actorError{
                        fatal:   true,
                        retCode: 0,

                        msg:   "tried creating an error and setting RetCode to 0",
                        frame: xerrors.Caller(1),
                        err:   fmt.Errorf(format, args...),
                }
        }
        return &actorError{
                retCode: retCode,

                msg:   fmt.Sprintf(format, args...),
                frame: xerrors.Caller(1),
        }
}

// todo: bit hacky

func NewfSkip(skip int, retCode exitcode.ExitCode, format string, args ...interface{}) ActorError {
        if retCode == 0 {
                return &actorError{
                        fatal:   true,
                        retCode: 0,

                        msg:   "tried creating an error and setting RetCode to 0",
                        frame: xerrors.Caller(skip),
                        err:   fmt.Errorf(format, args...),
                }
        }
        return &actorError{
                retCode: retCode,

                msg:   fmt.Sprintf(format, args...),
                frame: xerrors.Caller(skip),
        }
}

func Fatal(message string, args ...interface{}) ActorError {
        return &actorError{
                fatal: true,
                msg:   message,
                frame: xerrors.Caller(1),
        }
}

func Fatalf(format string, args ...interface{}) ActorError {
        return &actorError{
                fatal: true,
                msg:   fmt.Sprintf(format, args...),
                frame: xerrors.Caller(1),
        }
}

// Wrap extens chain of errors with a message
func Wrap(err ActorError, message string) ActorError {
        if err == nil {
                return nil
        }
        return &actorError{
                fatal:   IsFatal(err),
                retCode: RetCode(err),

                msg:   message,
                frame: xerrors.Caller(1),
                err:   err,
        }
}

// Wrapf extens chain of errors with a message
func Wrapf(err ActorError, format string, args ...interface{}) ActorError {
        if err == nil {
                return nil
        }
        return &actorError{
                fatal:   IsFatal(err),
                retCode: RetCode(err),

                msg:   fmt.Sprintf(format, args...),
                frame: xerrors.Caller(1),
                err:   err,
        }
}

// Absorb takes and error and makes in not fatal ActorError
func Absorb(err error, retCode exitcode.ExitCode, msg string) ActorError {
        if err == nil {
                return nil
        }
        if aerr, ok := err.(ActorError); ok && IsFatal(aerr) {
                return &actorError{
                        fatal:   true,
                        retCode: 0,

                        msg:   "tried absorbing an error that is already a fatal error",
                        frame: xerrors.Caller(1),
                        err:   err,
                }
        }
        if retCode == 0 {
                return &actorError{
                        fatal:   true,
                        retCode: 0,

                        msg:   "tried absorbing an error and setting RetCode to 0",
                        frame: xerrors.Caller(1),
                        err:   err,
                }
        }

        return &actorError{
                fatal:   false,
                retCode: retCode,

                msg:   msg,
                frame: xerrors.Caller(1),
                err:   err,
        }
}

// Escalate takes and error and escalates it into a fatal error
func Escalate(err error, msg string) ActorError {
        if err == nil {
                return nil
        }
        return &actorError{
                fatal: true,

                msg:   msg,
                frame: xerrors.Caller(1),
                err:   err,
        }
}

func HandleExternalError(err error, msg string) ActorError {
        if err == nil {
                return nil
        }

        if aerr, ok := err.(ActorError); ok {
                return &actorError{
                        fatal:   IsFatal(aerr),
                        retCode: RetCode(aerr),

                        msg:   msg,
                        frame: xerrors.Caller(1),
                        err:   aerr,
                }
        }

        if xerrors.Is(err, &cbor.SerializationError{}) {
                return &actorError{
                        fatal:   false,
                        retCode: 253,
                        msg:     msg,
                        frame:   xerrors.Caller(1),
                        err:     err,
                }
        }

        return &actorError{
                fatal:   false,
                retCode: 219,

                msg:   msg,
                frame: xerrors.Caller(1),
                err:   err,
        }
}

package actors

import (
        "context"
        "strings"
        "sync"

        "github.com/ipfs/go-cid"
        cbor "github.com/ipfs/go-ipld-cbor"
        "golang.org/x/xerrors"

        actorstypes "github.com/filecoin-project/go-state-types/actors"
        "github.com/filecoin-project/go-state-types/manifest"

        "github.com/filecoin-project/lotus/chain/actors/adt"
)

var manifestCids = make(map[actorstypes.Version]cid.Cid)
var manifests = make(map[actorstypes.Version]map[string]cid.Cid)
var actorMeta = make(map[cid.Cid]actorEntry)

var (
        manifestMx sync.RWMutex
)

type actorEntry struct {
        name    string
        version actorstypes.Version
}

// ClearManifests clears all known manifests. This is usually used in tests that need to switch networks.
func ClearManifests() {
        manifestMx.Lock()
        defer manifestMx.Unlock()

        manifestCids = make(map[actorstypes.Version]cid.Cid)
        manifests = make(map[actorstypes.Version]map[string]cid.Cid)
        actorMeta = make(map[cid.Cid]actorEntry)
}

// RegisterManifest registers an actors manifest with lotus.
func RegisterManifest(av actorstypes.Version, manifestCid cid.Cid, entries map[string]cid.Cid) {
        manifestMx.Lock()
        defer manifestMx.Unlock()

        manifestCids[av] = manifestCid
        manifests[av] = entries

        for name, c := range entries {
                actorMeta[c] = actorEntry{name: name, version: av}
        }
}

func AddActorMeta(name string, codeId cid.Cid, av actorstypes.Version) {
        manifestMx.Lock()
        defer manifestMx.Unlock()
        actorMeta[codeId] = actorEntry{name: name, version: av}
}

// GetManifest gets a loaded manifest.
func GetManifest(av actorstypes.Version) (cid.Cid, bool) {
        manifestMx.RLock()
        defer manifestMx.RUnlock()

        c, ok := manifestCids[av]
        return c, ok
}

// ReadManifest reads a manifest from a blockstore. It does not "add" it.
func ReadManifest(ctx context.Context, store cbor.IpldStore, mfCid cid.Cid) (map[string]cid.Cid, error) {
        adtStore := adt.WrapStore(ctx, store)

        var mf manifest.Manifest
        if err := adtStore.Get(ctx, mfCid, &mf); err != nil {
                return nil, xerrors.Errorf("error reading manifest (cid: %s): %w", mfCid, err)
        }

        if err := mf.Load(ctx, adtStore); err != nil {
                return nil, xerrors.Errorf("error loading manifest (cid: %s): %w", mfCid, err)
        }

        var manifestData manifest.ManifestData
        if err := store.Get(ctx, mf.Data, &manifestData); err != nil {
                return nil, xerrors.Errorf("error loading manifest data: %w", err)
        }

        metadata := make(map[string]cid.Cid)
        for _, entry := range manifestData.Entries {
                metadata[entry.Name] = entry.Code
        }

        return metadata, nil
}

// GetActorCodeIDsFromManifest looks up all builtin actor's code CIDs by actor version for versions that have a manifest.
func GetActorCodeIDsFromManifest(av actorstypes.Version) (map[string]cid.Cid, bool) {
        manifestMx.RLock()
        defer manifestMx.RUnlock()

        cids, ok := manifests[av]
        return cids, ok
}

// Given a Manifest CID, get the manifest from the store and Load data into its entries
func LoadManifest(ctx context.Context, mfCid cid.Cid, adtStore adt.Store) (*manifest.Manifest, error) {
        var mf manifest.Manifest

        if err := adtStore.Get(ctx, mfCid, &mf); err != nil {
                return nil, xerrors.Errorf("error reading manifest: %w", err)
        }

        if err := mf.Load(ctx, adtStore); err != nil {
                return nil, xerrors.Errorf("error loading manifest entries data: %w", err)
        }

        return &mf, nil
}

func GetActorMetaByCode(c cid.Cid) (string, actorstypes.Version, bool) {
        manifestMx.RLock()
        defer manifestMx.RUnlock()

        entry, ok := actorMeta[c]
        if !ok {
                return "", -1, false
        }

        return entry.name, entry.version, true
}

func CanonicalName(name string) string {
        idx := strings.LastIndex(name, "/")
        if idx >= 0 {
                return name[idx+1:]
        }

        return name
}

package actors

import (
        "bytes"

        cbg "github.com/whyrusleeping/cbor-gen"

        "github.com/filecoin-project/go-state-types/exitcode"

        "github.com/filecoin-project/lotus/chain/actors/aerrors"
)

func SerializeParams(i cbg.CBORMarshaler) ([]byte, aerrors.ActorError) {
        buf := new(bytes.Buffer)
        if err := i.MarshalCBOR(buf); err != nil {
                // TODO: shouldn't this be a fatal error?
                return nil, aerrors.Absorb(err, exitcode.ErrSerialization, "failed to encode parameter")
        }
        return buf.Bytes(), nil
}

package policy

import (
        "golang.org/x/xerrors"

        "github.com/filecoin-project/go-state-types/abi"
        actorstypes "github.com/filecoin-project/go-state-types/actors"
        "github.com/filecoin-project/go-state-types/big"
        builtin10 "github.com/filecoin-project/go-state-types/builtin"
        builtin11 "github.com/filecoin-project/go-state-types/builtin"
        builtin12 "github.com/filecoin-project/go-state-types/builtin"
        builtin13 "github.com/filecoin-project/go-state-types/builtin"
        builtin14 "github.com/filecoin-project/go-state-types/builtin"
        builtin8 "github.com/filecoin-project/go-state-types/builtin"
        builtin9 "github.com/filecoin-project/go-state-types/builtin"
        market10 "github.com/filecoin-project/go-state-types/builtin/v10/market"
        miner10 "github.com/filecoin-project/go-state-types/builtin/v10/miner"
        verifreg10 "github.com/filecoin-project/go-state-types/builtin/v10/verifreg"
        market11 "github.com/filecoin-project/go-state-types/builtin/v11/market"
        miner11 "github.com/filecoin-project/go-state-types/builtin/v11/miner"
        verifreg11 "github.com/filecoin-project/go-state-types/builtin/v11/verifreg"
        market12 "github.com/filecoin-project/go-state-types/builtin/v12/market"
        miner12 "github.com/filecoin-project/go-state-types/builtin/v12/miner"
        verifreg12 "github.com/filecoin-project/go-state-types/builtin/v12/verifreg"
        market13 "github.com/filecoin-project/go-state-types/builtin/v13/market"
        miner13 "github.com/filecoin-project/go-state-types/builtin/v13/miner"
        verifreg13 "github.com/filecoin-project/go-state-types/builtin/v13/verifreg"
        market14 "github.com/filecoin-project/go-state-types/builtin/v14/market"
        miner14 "github.com/filecoin-project/go-state-types/builtin/v14/miner"
        paych14 "github.com/filecoin-project/go-state-types/builtin/v14/paych"
        verifreg14 "github.com/filecoin-project/go-state-types/builtin/v14/verifreg"
        market8 "github.com/filecoin-project/go-state-types/builtin/v8/market"
        miner8 "github.com/filecoin-project/go-state-types/builtin/v8/miner"
        verifreg8 "github.com/filecoin-project/go-state-types/builtin/v8/verifreg"
        market9 "github.com/filecoin-project/go-state-types/builtin/v9/market"
        miner9 "github.com/filecoin-project/go-state-types/builtin/v9/miner"
        verifreg9 "github.com/filecoin-project/go-state-types/builtin/v9/verifreg"
        "github.com/filecoin-project/go-state-types/network"
        market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
        miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
        power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
        verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
        builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
        market2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/market"
        miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
        verifreg2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/verifreg"
        builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
        market3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/market"
        miner3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/miner"
        verifreg3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/verifreg"
        builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
        market4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/market"
        miner4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/miner"
        verifreg4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/verifreg"
        builtin5 "github.com/filecoin-project/specs-actors/v5/actors/builtin"
        market5 "github.com/filecoin-project/specs-actors/v5/actors/builtin/market"
        miner5 "github.com/filecoin-project/specs-actors/v5/actors/builtin/miner"
        verifreg5 "github.com/filecoin-project/specs-actors/v5/actors/builtin/verifreg"
        builtin6 "github.com/filecoin-project/specs-actors/v6/actors/builtin"
        market6 "github.com/filecoin-project/specs-actors/v6/actors/builtin/market"
        miner6 "github.com/filecoin-project/specs-actors/v6/actors/builtin/miner"
        verifreg6 "github.com/filecoin-project/specs-actors/v6/actors/builtin/verifreg"
        builtin7 "github.com/filecoin-project/specs-actors/v7/actors/builtin"
        market7 "github.com/filecoin-project/specs-actors/v7/actors/builtin/market"
        miner7 "github.com/filecoin-project/specs-actors/v7/actors/builtin/miner"
        verifreg7 "github.com/filecoin-project/specs-actors/v7/actors/builtin/verifreg"
)

const (
        ChainFinality                  = miner14.ChainFinality
        SealRandomnessLookback         = ChainFinality
        PaychSettleDelay               = paych14.SettleDelay
        MaxPreCommitRandomnessLookback = builtin14.EpochsInDay + SealRandomnessLookback
)

var (
        MarketDefaultAllocationTermBuffer = market14.MarketDefaultAllocationTermBuffer
)

// SetSupportedProofTypes sets supported proof types, across all actor versions.
// This should only be used for testing.
func SetSupportedProofTypes(types ...abi.RegisteredSealProof) {

        miner0.SupportedProofTypes = make(map[abi.RegisteredSealProof]struct{}, len(types))

        miner2.PreCommitSealProofTypesV0 = make(map[abi.RegisteredSealProof]struct{}, len(types))
        miner2.PreCommitSealProofTypesV7 = make(map[abi.RegisteredSealProof]struct{}, len(types)*2)
        miner2.PreCommitSealProofTypesV8 = make(map[abi.RegisteredSealProof]struct{}, len(types))

        miner3.PreCommitSealProofTypesV0 = make(map[abi.RegisteredSealProof]struct{}, len(types))
        miner3.PreCommitSealProofTypesV7 = make(map[abi.RegisteredSealProof]struct{}, len(types)*2)
        miner3.PreCommitSealProofTypesV8 = make(map[abi.RegisteredSealProof]struct{}, len(types))

        miner4.PreCommitSealProofTypesV0 = make(map[abi.RegisteredSealProof]struct{}, len(types))
        miner4.PreCommitSealProofTypesV7 = make(map[abi.RegisteredSealProof]struct{}, len(types)*2)
        miner4.PreCommitSealProofTypesV8 = make(map[abi.RegisteredSealProof]struct{}, len(types))

        miner5.PreCommitSealProofTypesV8 = make(map[abi.RegisteredSealProof]struct{}, len(types))

        miner6.PreCommitSealProofTypesV8 = make(map[abi.RegisteredSealProof]struct{}, len(types))

        miner7.PreCommitSealProofTypesV8 = make(map[abi.RegisteredSealProof]struct{}, len(types))

        AddSupportedProofTypes(types...)
}

// AddSupportedProofTypes sets supported proof types, across all actor versions.
// This should only be used for testing.
func AddSupportedProofTypes(types ...abi.RegisteredSealProof) {
        for _, t := range types {
                if t >= abi.RegisteredSealProof_StackedDrg2KiBV1_1 {
                        panic("must specify v1 proof types only")
                }
                // Set for all miner versions.

                miner0.SupportedProofTypes[t] = struct{}{}

                miner2.PreCommitSealProofTypesV0[t] = struct{}{}
                miner2.PreCommitSealProofTypesV7[t] = struct{}{}
                miner2.PreCommitSealProofTypesV7[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}
                miner2.PreCommitSealProofTypesV8[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}

                miner3.PreCommitSealProofTypesV0[t] = struct{}{}
                miner3.PreCommitSealProofTypesV7[t] = struct{}{}
                miner3.PreCommitSealProofTypesV7[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}
                miner3.PreCommitSealProofTypesV8[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}

                miner4.PreCommitSealProofTypesV0[t] = struct{}{}
                miner4.PreCommitSealProofTypesV7[t] = struct{}{}
                miner4.PreCommitSealProofTypesV7[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}
                miner4.PreCommitSealProofTypesV8[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}

                miner5.PreCommitSealProofTypesV8[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}
                wpp, err := t.RegisteredWindowPoStProof()
                if err != nil {
                        // Fine to panic, this is a test-only method
                        panic(err)
                }

                miner5.WindowPoStProofTypes[wpp] = struct{}{}

                miner6.PreCommitSealProofTypesV8[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}
                wpp, err = t.RegisteredWindowPoStProof()
                if err != nil {
                        // Fine to panic, this is a test-only method
                        panic(err)
                }

                miner6.WindowPoStProofTypes[wpp] = struct{}{}

                miner7.PreCommitSealProofTypesV8[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}
                wpp, err = t.RegisteredWindowPoStProof()
                if err != nil {
                        // Fine to panic, this is a test-only method
                        panic(err)
                }

                miner7.WindowPoStProofTypes[wpp] = struct{}{}

        }
}

// SetPreCommitChallengeDelay sets the pre-commit challenge delay across all
// actors versions. Use for testing.
func SetPreCommitChallengeDelay(delay abi.ChainEpoch) {
        // Set for all miner versions.

        miner0.PreCommitChallengeDelay = delay

        miner2.PreCommitChallengeDelay = delay

        miner3.PreCommitChallengeDelay = delay

        miner4.PreCommitChallengeDelay = delay

        miner5.PreCommitChallengeDelay = delay

        miner6.PreCommitChallengeDelay = delay

        miner7.PreCommitChallengeDelay = delay

        miner8.PreCommitChallengeDelay = delay

        miner9.PreCommitChallengeDelay = delay

        miner10.PreCommitChallengeDelay = delay

        miner11.PreCommitChallengeDelay = delay

        miner12.PreCommitChallengeDelay = delay

        miner13.PreCommitChallengeDelay = delay

        miner14.PreCommitChallengeDelay = delay

}

// TODO: this function shouldn't really exist. Instead, the API should expose the precommit delay.
func GetPreCommitChallengeDelay() abi.ChainEpoch {
        return miner14.PreCommitChallengeDelay
}

// SetConsensusMinerMinPower sets the minimum power of an individual miner must
// meet for leader election, across all actor versions. This should only be used
// for testing.
func SetConsensusMinerMinPower(p abi.StoragePower) {

        power0.ConsensusMinerMinPower = p

        for _, policy := range builtin2.SealProofPolicies {
                policy.ConsensusMinerMinPower = p
        }

        for _, policy := range builtin3.PoStProofPolicies {
                policy.ConsensusMinerMinPower = p
        }

        for _, policy := range builtin4.PoStProofPolicies {
                policy.ConsensusMinerMinPower = p
        }

        for _, policy := range builtin5.PoStProofPolicies {
                policy.ConsensusMinerMinPower = p
        }

        for _, policy := range builtin6.PoStProofPolicies {
                policy.ConsensusMinerMinPower = p
        }

        for _, policy := range builtin7.PoStProofPolicies {
                policy.ConsensusMinerMinPower = p
        }

        for _, policy := range builtin8.PoStProofPolicies {
                policy.ConsensusMinerMinPower = p
        }

        for _, policy := range builtin9.PoStProofPolicies {
                policy.ConsensusMinerMinPower = p
        }

        for _, policy := range builtin10.PoStProofPolicies {
                policy.ConsensusMinerMinPower = p
        }

        for _, policy := range builtin11.PoStProofPolicies {
                policy.ConsensusMinerMinPower = p
        }

        for _, policy := range builtin12.PoStProofPolicies {
                policy.ConsensusMinerMinPower = p
        }

        for _, policy := range builtin13.PoStProofPolicies {
                policy.ConsensusMinerMinPower = p
        }

        for _, policy := range builtin14.PoStProofPolicies {
                policy.ConsensusMinerMinPower = p
        }

}

// SetMinVerifiedDealSize sets the minimum size of a verified deal. This should
// only be used for testing.
func SetMinVerifiedDealSize(size abi.StoragePower) {

        verifreg0.MinVerifiedDealSize = size

        verifreg2.MinVerifiedDealSize = size

        verifreg3.MinVerifiedDealSize = size

        verifreg4.MinVerifiedDealSize = size

        verifreg5.MinVerifiedDealSize = size

        verifreg6.MinVerifiedDealSize = size

        verifreg7.MinVerifiedDealSize = size

        verifreg8.MinVerifiedDealSize = size

        verifreg9.MinVerifiedDealSize = size

        verifreg10.MinVerifiedDealSize = size

        verifreg11.MinVerifiedDealSize = size

        verifreg12.MinVerifiedDealSize = size

        verifreg13.MinVerifiedDealSize = size

        verifreg14.MinVerifiedDealSize = size

}

func GetMaxProveCommitDuration(ver actorstypes.Version, t abi.RegisteredSealProof) (abi.ChainEpoch, error) {
        switch ver {

        case actorstypes.Version0:

                return miner0.MaxSealDuration[t], nil

        case actorstypes.Version2:

                return miner2.MaxProveCommitDuration[t], nil

        case actorstypes.Version3:

                return miner3.MaxProveCommitDuration[t], nil

        case actorstypes.Version4:

                return miner4.MaxProveCommitDuration[t], nil

        case actorstypes.Version5:

                return miner5.MaxProveCommitDuration[t], nil

        case actorstypes.Version6:

                return miner6.MaxProveCommitDuration[t], nil

        case actorstypes.Version7:

                return miner7.MaxProveCommitDuration[t], nil

        case actorstypes.Version8:

                return miner8.MaxProveCommitDuration[t], nil

        case actorstypes.Version9:

                return miner9.MaxProveCommitDuration[t], nil

        case actorstypes.Version10:

                return miner10.MaxProveCommitDuration[t], nil

        case actorstypes.Version11:

                return miner11.MaxProveCommitDuration[t], nil

        case actorstypes.Version12:

                return miner12.MaxProveCommitDuration[t], nil

        case actorstypes.Version13:

                return miner13.MaxProveCommitDuration[t], nil

        case actorstypes.Version14:

                return miner14.MaxProveCommitDuration[t], nil

        default:
                return 0, xerrors.Errorf("unsupported actors version")
        }
}

// SetProviderCollateralSupplyTarget sets the percentage of normalized circulating
// supply that must be covered by provider collateral in a deal. This should
// only be used for testing.
func SetProviderCollateralSupplyTarget(num, denom big.Int) {

        market2.ProviderCollateralSupplyTarget = builtin2.BigFrac{
                Numerator:   num,
                Denominator: denom,
        }

        market3.ProviderCollateralSupplyTarget = builtin3.BigFrac{
                Numerator:   num,
                Denominator: denom,
        }

        market4.ProviderCollateralSupplyTarget = builtin4.BigFrac{
                Numerator:   num,
                Denominator: denom,
        }

        market5.ProviderCollateralSupplyTarget = builtin5.BigFrac{
                Numerator:   num,
                Denominator: denom,
        }

        market6.ProviderCollateralSupplyTarget = builtin6.BigFrac{
                Numerator:   num,
                Denominator: denom,
        }

        market7.ProviderCollateralSupplyTarget = builtin7.BigFrac{
                Numerator:   num,
                Denominator: denom,
        }

        market8.ProviderCollateralSupplyTarget = builtin8.BigFrac{
                Numerator:   num,
                Denominator: denom,
        }

        market9.ProviderCollateralSupplyTarget = builtin9.BigFrac{
                Numerator:   num,
                Denominator: denom,
        }

        market10.ProviderCollateralSupplyTarget = builtin10.BigFrac{
                Numerator:   num,
                Denominator: denom,
        }

        market11.ProviderCollateralSupplyTarget = builtin11.BigFrac{
                Numerator:   num,
                Denominator: denom,
        }

        market12.ProviderCollateralSupplyTarget = builtin12.BigFrac{
                Numerator:   num,
                Denominator: denom,
        }

        market13.ProviderCollateralSupplyTarget = builtin13.BigFrac{
                Numerator:   num,
                Denominator: denom,
        }

        market14.ProviderCollateralSupplyTarget = builtin14.BigFrac{
                Numerator:   num,
                Denominator: denom,
        }

}

func DealProviderCollateralBounds(
        size abi.PaddedPieceSize, verified bool,
        rawBytePower, qaPower, baselinePower abi.StoragePower,
        circulatingFil abi.TokenAmount, nwVer network.Version,
) (min, max abi.TokenAmount, err error) {
        v, err := actorstypes.VersionForNetwork(nwVer)
        if err != nil {
                return big.Zero(), big.Zero(), err
        }
        switch v {

        case actorstypes.Version0:

                min, max := market0.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil, nwVer)
                return min, max, nil

        case actorstypes.Version2:

                min, max := market2.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
                return min, max, nil

        case actorstypes.Version3:

                min, max := market3.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
                return min, max, nil

        case actorstypes.Version4:

                min, max := market4.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
                return min, max, nil

        case actorstypes.Version5:

                min, max := market5.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
                return min, max, nil

        case actorstypes.Version6:

                min, max := market6.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
                return min, max, nil

        case actorstypes.Version7:

                min, max := market7.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
                return min, max, nil

        case actorstypes.Version8:

                min, max := market8.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
                return min, max, nil

        case actorstypes.Version9:

                min, max := market9.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
                return min, max, nil

        case actorstypes.Version10:

                min, max := market10.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
                return min, max, nil

        case actorstypes.Version11:

                min, max := market11.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
                return min, max, nil

        case actorstypes.Version12:

                min, max := market12.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
                return min, max, nil

        case actorstypes.Version13:

                min, max := market13.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
                return min, max, nil

        case actorstypes.Version14:

                min, max := market14.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
                return min, max, nil

        default:
                return big.Zero(), big.Zero(), xerrors.Errorf("unsupported actors version")
        }
}

func DealDurationBounds(pieceSize abi.PaddedPieceSize) (min, max abi.ChainEpoch) {
        return market14.DealDurationBounds(pieceSize)
}

// Sets the challenge window and scales the proving period to match (such that
// there are always 48 challenge windows in a proving period).
func SetWPoStChallengeWindow(period abi.ChainEpoch) {

        miner0.WPoStChallengeWindow = period
        miner0.WPoStProvingPeriod = period * abi.ChainEpoch(miner0.WPoStPeriodDeadlines)

        miner2.WPoStChallengeWindow = period
        miner2.WPoStProvingPeriod = period * abi.ChainEpoch(miner2.WPoStPeriodDeadlines)

        miner3.WPoStChallengeWindow = period
        miner3.WPoStProvingPeriod = period * abi.ChainEpoch(miner3.WPoStPeriodDeadlines)

        // by default, this is 2x finality which is 30 periods.
        // scale it if we're scaling the challenge period.
        miner3.WPoStDisputeWindow = period * 30

        miner4.WPoStChallengeWindow = period
        miner4.WPoStProvingPeriod = period * abi.ChainEpoch(miner4.WPoStPeriodDeadlines)

        // by default, this is 2x finality which is 30 periods.
        // scale it if we're scaling the challenge period.
        miner4.WPoStDisputeWindow = period * 30

        miner5.WPoStChallengeWindow = period
        miner5.WPoStProvingPeriod = period * abi.ChainEpoch(miner5.WPoStPeriodDeadlines)

        // by default, this is 2x finality which is 30 periods.
        // scale it if we're scaling the challenge period.
        miner5.WPoStDisputeWindow = period * 30

        miner6.WPoStChallengeWindow = period
        miner6.WPoStProvingPeriod = period * abi.ChainEpoch(miner6.WPoStPeriodDeadlines)

        // by default, this is 2x finality which is 30 periods.
        // scale it if we're scaling the challenge period.
        miner6.WPoStDisputeWindow = period * 30

        miner7.WPoStChallengeWindow = period
        miner7.WPoStProvingPeriod = period * abi.ChainEpoch(miner7.WPoStPeriodDeadlines)

        // by default, this is 2x finality which is 30 periods.
        // scale it if we're scaling the challenge period.
        miner7.WPoStDisputeWindow = period * 30

        miner8.WPoStChallengeWindow = period
        miner8.WPoStProvingPeriod = period * abi.ChainEpoch(miner8.WPoStPeriodDeadlines)

        // by default, this is 2x finality which is 30 periods.
        // scale it if we're scaling the challenge period.
        miner8.WPoStDisputeWindow = period * 30

        miner9.WPoStChallengeWindow = period
        miner9.WPoStProvingPeriod = period * abi.ChainEpoch(miner9.WPoStPeriodDeadlines)

        // by default, this is 2x finality which is 30 periods.
        // scale it if we're scaling the challenge period.
        miner9.WPoStDisputeWindow = period * 30

        miner10.WPoStChallengeWindow = period
        miner10.WPoStProvingPeriod = period * abi.ChainEpoch(miner10.WPoStPeriodDeadlines)

        // by default, this is 2x finality which is 30 periods.
        // scale it if we're scaling the challenge period.
        miner10.WPoStDisputeWindow = period * 30

        miner11.WPoStChallengeWindow = period
        miner11.WPoStProvingPeriod = period * abi.ChainEpoch(miner11.WPoStPeriodDeadlines)

        // by default, this is 2x finality which is 30 periods.
        // scale it if we're scaling the challenge period.
        miner11.WPoStDisputeWindow = period * 30

        miner12.WPoStChallengeWindow = period
        miner12.WPoStProvingPeriod = period * abi.ChainEpoch(miner12.WPoStPeriodDeadlines)

        // by default, this is 2x finality which is 30 periods.
        // scale it if we're scaling the challenge period.
        miner12.WPoStDisputeWindow = period * 30

        miner13.WPoStChallengeWindow = period
        miner13.WPoStProvingPeriod = period * abi.ChainEpoch(miner13.WPoStPeriodDeadlines)

        // by default, this is 2x finality which is 30 periods.
        // scale it if we're scaling the challenge period.
        miner13.WPoStDisputeWindow = period * 30

        miner14.WPoStChallengeWindow = period
        miner14.WPoStProvingPeriod = period * abi.ChainEpoch(miner14.WPoStPeriodDeadlines)

        // by default, this is 2x finality which is 30 periods.
        // scale it if we're scaling the challenge period.
        miner14.WPoStDisputeWindow = period * 30

}

func GetWinningPoStSectorSetLookback(nwVer network.Version) abi.ChainEpoch {
        if nwVer <= network.Version3 {
                return 10
        }

        // NOTE: if this ever changes, adjust it in a (*Miner).mineOne() logline as well
        return ChainFinality
}

func GetMaxSectorExpirationExtension(nv network.Version) (abi.ChainEpoch, error) {
        v, err := actorstypes.VersionForNetwork(nv)
        if err != nil {
                return 0, xerrors.Errorf("failed to get actors version: %w", err)
        }
        switch v {

        case actorstypes.Version0:
                return miner0.MaxSectorExpirationExtension, nil

        case actorstypes.Version2:
                return miner2.MaxSectorExpirationExtension, nil

        case actorstypes.Version3:
                return miner3.MaxSectorExpirationExtension, nil

        case actorstypes.Version4:
                return miner4.MaxSectorExpirationExtension, nil

        case actorstypes.Version5:
                return miner5.MaxSectorExpirationExtension, nil

        case actorstypes.Version6:
                return miner6.MaxSectorExpirationExtension, nil

        case actorstypes.Version7:
                return miner7.MaxSectorExpirationExtension, nil

        case actorstypes.Version8:
                return miner8.MaxSectorExpirationExtension, nil

        case actorstypes.Version9:
                return miner9.MaxSectorExpirationExtension, nil

        case actorstypes.Version10:
                return miner10.MaxSectorExpirationExtension, nil

        case actorstypes.Version11:
                return miner11.MaxSectorExpirationExtension, nil

        case actorstypes.Version12:
                return miner12.MaxSectorExpirationExtension, nil

        case actorstypes.Version13:
                return miner13.MaxSectorExpirationExtension, nil

        case actorstypes.Version14:
                return miner14.MaxSectorExpirationExtension, nil

        default:
                return 0, xerrors.Errorf("unsupported network version")
        }

}

func GetMinSectorExpiration() abi.ChainEpoch {
        return miner14.MinSectorExpiration
}

func GetMaxPoStPartitions(nv network.Version, p abi.RegisteredPoStProof) (int, error) {
        sectorsPerPart, err := builtin14.PoStProofWindowPoStPartitionSectors(p)
        if err != nil {
                return 0, err
        }
        maxSectors, err := GetAddressedSectorsMax(nv)
        if err != nil {
                return 0, err
        }

        return min(miner14.PoStedPartitionsMax, int(uint64(maxSectors)/sectorsPerPart)), nil
}

func GetDefaultAggregationProof() abi.RegisteredAggregationProof {
        return abi.RegisteredAggregationProof_SnarkPackV1
}

func GetSectorMaxLifetime(proof abi.RegisteredSealProof, nwVer network.Version) abi.ChainEpoch {
        if nwVer <= network.Version10 {
                return builtin4.SealProofPoliciesV0[proof].SectorMaxLifetime
        }

        return builtin14.SealProofPoliciesV11[proof].SectorMaxLifetime
}

func GetAddressedSectorsMax(nwVer network.Version) (int, error) {
        v, err := actorstypes.VersionForNetwork(nwVer)
        if err != nil {
                return 0, err
        }
        switch v {

        case actorstypes.Version0:
                return miner0.AddressedSectorsMax, nil

        case actorstypes.Version2:
                return miner2.AddressedSectorsMax, nil

        case actorstypes.Version3:
                return miner3.AddressedSectorsMax, nil

        case actorstypes.Version4:
                return miner4.AddressedSectorsMax, nil

        case actorstypes.Version5:
                return miner5.AddressedSectorsMax, nil

        case actorstypes.Version6:
                return miner6.AddressedSectorsMax, nil

        case actorstypes.Version7:
                return miner7.AddressedSectorsMax, nil

        case actorstypes.Version8:
                return miner8.AddressedSectorsMax, nil

        case actorstypes.Version9:
                return miner9.AddressedSectorsMax, nil

        case actorstypes.Version10:
                return miner10.AddressedSectorsMax, nil

        case actorstypes.Version11:
                return miner11.AddressedSectorsMax, nil

        case actorstypes.Version12:
                return miner12.AddressedSectorsMax, nil

        case actorstypes.Version13:
                return miner13.AddressedSectorsMax, nil

        case actorstypes.Version14:
                return miner14.AddressedSectorsMax, nil

        default:
                return 0, xerrors.Errorf("unsupported network version")
        }
}

func GetDeclarationsMax(nwVer network.Version) (int, error) {
        v, err := actorstypes.VersionForNetwork(nwVer)
        if err != nil {
                return 0, err
        }
        switch v {

        case actorstypes.Version0:

                // TODO: Should we instead error here since the concept doesn't exist yet?
                return miner0.AddressedPartitionsMax, nil

        case actorstypes.Version2:

                return miner2.DeclarationsMax, nil

        case actorstypes.Version3:

                return miner3.DeclarationsMax, nil

        case actorstypes.Version4:

                return miner4.DeclarationsMax, nil

        case actorstypes.Version5:

                return miner5.DeclarationsMax, nil

        case actorstypes.Version6:

                return miner6.DeclarationsMax, nil

        case actorstypes.Version7:

                return miner7.DeclarationsMax, nil

        case actorstypes.Version8:

                return miner8.DeclarationsMax, nil

        case actorstypes.Version9:

                return miner9.DeclarationsMax, nil

        case actorstypes.Version10:

                return miner10.DeclarationsMax, nil

        case actorstypes.Version11:

                return miner11.DeclarationsMax, nil

        case actorstypes.Version12:

                return miner12.DeclarationsMax, nil

        case actorstypes.Version13:

                return miner13.DeclarationsMax, nil

        case actorstypes.Version14:

                return miner14.DeclarationsMax, nil

        default:
                return 0, xerrors.Errorf("unsupported network version")
        }
}

func AggregateProveCommitNetworkFee(nwVer network.Version, aggregateSize int, baseFee abi.TokenAmount) (abi.TokenAmount, error) {
        v, err := actorstypes.VersionForNetwork(nwVer)
        if err != nil {
                return big.Zero(), err
        }
        switch v {

        case actorstypes.Version0:

                return big.Zero(), nil

        case actorstypes.Version2:

                return big.Zero(), nil

        case actorstypes.Version3:

                return big.Zero(), nil

        case actorstypes.Version4:

                return big.Zero(), nil

        case actorstypes.Version5:

                return miner5.AggregateNetworkFee(aggregateSize, baseFee), nil

        case actorstypes.Version6:

                return miner6.AggregateProveCommitNetworkFee(aggregateSize, baseFee), nil

        case actorstypes.Version7:

                return miner7.AggregateProveCommitNetworkFee(aggregateSize, baseFee), nil

        case actorstypes.Version8:

                return miner8.AggregateProveCommitNetworkFee(aggregateSize, baseFee), nil

        case actorstypes.Version9:

                return miner9.AggregateProveCommitNetworkFee(aggregateSize, baseFee), nil

        case actorstypes.Version10:

                return miner10.AggregateProveCommitNetworkFee(aggregateSize, baseFee), nil

        case actorstypes.Version11:

                return miner11.AggregateProveCommitNetworkFee(aggregateSize, baseFee), nil

        case actorstypes.Version12:

                return miner12.AggregateProveCommitNetworkFee(aggregateSize, baseFee), nil

        case actorstypes.Version13:

                return miner13.AggregateProveCommitNetworkFee(aggregateSize, baseFee), nil

        case actorstypes.Version14:

                return miner14.AggregateProveCommitNetworkFee(aggregateSize, baseFee), nil

        default:
                return big.Zero(), xerrors.Errorf("unsupported network version")
        }
}

func AggregatePreCommitNetworkFee(nwVer network.Version, aggregateSize int, baseFee abi.TokenAmount) (abi.TokenAmount, error) {
        v, err := actorstypes.VersionForNetwork(nwVer)
        if err != nil {
                return big.Zero(), err
        }
        switch v {

        case actorstypes.Version0:

                return big.Zero(), nil

        case actorstypes.Version2:

                return big.Zero(), nil

        case actorstypes.Version3:

                return big.Zero(), nil

        case actorstypes.Version4:

                return big.Zero(), nil

        case actorstypes.Version5:

                return big.Zero(), nil

        case actorstypes.Version6:

                return miner6.AggregatePreCommitNetworkFee(aggregateSize, baseFee), nil

        case actorstypes.Version7:

                return miner7.AggregatePreCommitNetworkFee(aggregateSize, baseFee), nil

        case actorstypes.Version8:

                return miner8.AggregatePreCommitNetworkFee(aggregateSize, baseFee), nil

        case actorstypes.Version9:

                return miner9.AggregatePreCommitNetworkFee(aggregateSize, baseFee), nil

        case actorstypes.Version10:

                return miner10.AggregatePreCommitNetworkFee(aggregateSize, baseFee), nil

        case actorstypes.Version11:

                return miner11.AggregatePreCommitNetworkFee(aggregateSize, baseFee), nil

        case actorstypes.Version12:

                return miner12.AggregatePreCommitNetworkFee(aggregateSize, baseFee), nil

        case actorstypes.Version13:

                return miner13.AggregatePreCommitNetworkFee(aggregateSize, baseFee), nil

        case actorstypes.Version14:

                return miner14.AggregatePreCommitNetworkFee(aggregateSize, baseFee), nil

        default:
                return big.Zero(), xerrors.Errorf("unsupported network version")
        }
}

var PoStToSealMap map[abi.RegisteredPoStProof]abi.RegisteredSealProof

func init() {
        PoStToSealMap = make(map[abi.RegisteredPoStProof]abi.RegisteredSealProof)
        for sealProof, info := range abi.SealProofInfos {
                PoStToSealMap[info.WinningPoStProof] = sealProof
                PoStToSealMap[info.WindowPoStProof] = sealProof
        }
}

func GetSealProofFromPoStProof(postProof abi.RegisteredPoStProof) (abi.RegisteredSealProof, error) {
        sealProof, exists := PoStToSealMap[postProof]
        if !exists {
                return 0, xerrors.New("no corresponding RegisteredSealProof for the given RegisteredPoStProof")
        }
        return sealProof, nil
}

func min(a, b int) int {
        if a < b {
                return a
        }
        return b
}

package types

import (
        "errors"

        "github.com/ipfs/go-cid"

        "github.com/filecoin-project/go-address"
)

var ErrActorNotFound = errors.New("actor not found")

// Actor State for state tree version up to 4
type ActorV4 struct {
        // Identifies the type of actor (string coded as a CID), see `chain/actors/actors.go`.
        Code    cid.Cid
        Head    cid.Cid
        Nonce   uint64
        Balance BigInt
}

// Actor State for state tree version 5
type ActorV5 struct {
        // Identifies the type of actor (string coded as a CID), see `chain/actors/actors.go`.
        Code    cid.Cid
        Head    cid.Cid
        Nonce   uint64
        Balance BigInt
        // The f4 address of the actor, if any.
        DelegatedAddress *address.Address
}

type Actor = ActorV5

func AsActorV4(a *ActorV5) *ActorV4 {
        return &ActorV4{
                Code:    a.Code,
                Head:    a.Head,
                Nonce:   a.Nonce,
                Balance: a.Balance,
        }
}

func AsActorV5(a *ActorV4) *ActorV5 {
        return &ActorV5{
                Code:    a.Code,
                Head:    a.Head,
                Nonce:   a.Nonce,
                Balance: a.Balance,
        }
}

package types

import (
        "fmt"
        "math/big"

        big2 "github.com/filecoin-project/go-state-types/big"

        "github.com/filecoin-project/lotus/build"
)

const BigIntMaxSerializedLen = 128 // is this big enough? or too big?

var TotalFilecoinInt = FromFil(build.FilBase)

var EmptyInt = BigInt{}

type BigInt = big2.Int

func NewInt(i uint64) BigInt {
        return BigInt{Int: big.NewInt(0).SetUint64(i)}
}

func FromFil(i uint64) BigInt {
        return BigMul(NewInt(i), NewInt(build.FilecoinPrecision))
}

func BigFromBytes(b []byte) BigInt {
        i := big.NewInt(0).SetBytes(b)
        return BigInt{Int: i}
}

func BigFromString(s string) (BigInt, error) {
        v, ok := big.NewInt(0).SetString(s, 10)
        if !ok {
                return BigInt{}, fmt.Errorf("failed to parse string as a big int")
        }

        return BigInt{Int: v}, nil
}

func BigMul(a, b BigInt) BigInt {
        return BigInt{Int: big.NewInt(0).Mul(a.Int, b.Int)}
}

func BigDiv(a, b BigInt) BigInt {
        return BigInt{Int: big.NewInt(0).Div(a.Int, b.Int)}
}

func BigDivFloat(num, den BigInt) float64 {
        res, _ := new(big.Rat).SetFrac(num.Int, den.Int).Float64()
        return res
}

func BigMod(a, b BigInt) BigInt {
        return BigInt{Int: big.NewInt(0).Mod(a.Int, b.Int)}
}

func BigAdd(a, b BigInt) BigInt {
        return BigInt{Int: big.NewInt(0).Add(a.Int, b.Int)}
}

func BigSub(a, b BigInt) BigInt {
        return BigInt{Int: big.NewInt(0).Sub(a.Int, b.Int)}
}

func BigCmp(a, b BigInt) int {
        return a.Int.Cmp(b.Int)
}

var byteSizeUnits = []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB"}

func SizeStr(bi BigInt) string {
        r := new(big.Rat).SetInt(bi.Int)
        den := big.NewRat(1, 1024)

        var i int
        for f, _ := r.Float64(); f >= 1024 && i+1 < len(byteSizeUnits); f, _ = r.Float64() {
                i++
                r = r.Mul(r, den)
        }

        f, _ := r.Float64()
        return fmt.Sprintf("%.4g %s", f, byteSizeUnits[i])
}

var deciUnits = []string{"", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"}

func DeciStr(bi BigInt) string {
        r := new(big.Rat).SetInt(bi.Int)
        den := big.NewRat(1, 1024)

        var i int
        for f, _ := r.Float64(); f >= 1024 && i+1 < len(deciUnits); f, _ = r.Float64() {
                i++
                r = r.Mul(r, den)
        }

        f, _ := r.Float64()
        return fmt.Sprintf("%.3g %s", f, deciUnits[i])
}

package types

import (
        "bytes"
        "math/big"

        block "github.com/ipfs/go-block-format"
        "github.com/ipfs/go-cid"
        "github.com/minio/blake2b-simd"
        "golang.org/x/xerrors"

        "github.com/filecoin-project/go-address"
        "github.com/filecoin-project/go-state-types/abi"
        "github.com/filecoin-project/go-state-types/crypto"
        "github.com/filecoin-project/go-state-types/proof"
)

type Ticket struct {
        VRFProof []byte
}

func (t *Ticket) Quality() float64 {
        ticketHash := blake2b.Sum256(t.VRFProof)
        ticketNum := BigFromBytes(ticketHash[:]).Int
        ticketDenu := big.NewInt(1)
        ticketDenu.Lsh(ticketDenu, 256)
        tv, _ := new(big.Rat).SetFrac(ticketNum, ticketDenu).Float64()
        tq := 1 - tv
        return tq
}

type BeaconEntry struct {
        Round uint64
        Data  []byte
}

func NewBeaconEntry(round uint64, data []byte) BeaconEntry {
        return BeaconEntry{
                Round: round,
                Data:  data,
        }
}

type BlockHeader struct {
        Miner address.Address // 0 unique per block/miner

        Ticket                *Ticket           // 1 unique per block/miner: should be a valid VRF
        ElectionProof         *ElectionProof    // 2 unique per block/miner: should be a valid VRF
        BeaconEntries         []BeaconEntry     // 3 identical for all blocks in same tipset
        WinPoStProof          []proof.PoStProof // 4 unique per block/miner
        Parents               []cid.Cid         // 5 identical for all blocks in same tipset
        ParentWeight          BigInt            // 6 identical for all blocks in same tipset
        Height                abi.ChainEpoch    // 7 identical for all blocks in same tipset
        ParentStateRoot       cid.Cid           // 8 identical for all blocks in same tipset
        ParentMessageReceipts cid.Cid           // 9 identical for all blocks in same tipset
        Messages              cid.Cid           // 10 unique per block
        BLSAggregate          *crypto.Signature // 11 unique per block: aggrregate of BLS messages from above
        Timestamp             uint64            // 12 identical for all blocks in same tipset / hard-tied to the value of Height above
        BlockSig              *crypto.Signature // 13 unique per block/miner: miner signature
        ForkSignaling         uint64            // 14 currently unused/undefined
        ParentBaseFee         abi.TokenAmount   // 15 identical for all blocks in same tipset: the base fee after executing parent tipset

        validated bool // internal, true if the signature has been validated
}

func (blk *BlockHeader) ToStorageBlock() (block.Block, error) {
        data, err := blk.Serialize()
        if err != nil {
                return nil, err
        }

        c, err := abi.CidBuilder.Sum(data)
        if err != nil {
                return nil, err
        }

        return block.NewBlockWithCid(data, c)
}

func (blk *BlockHeader) Cid() cid.Cid {
        sb, err := blk.ToStorageBlock()
        if err != nil {
                panic(err) // Not sure i'm entirely comfortable with this one, needs to be checked
        }

        return sb.Cid()
}

func DecodeBlock(b []byte) (*BlockHeader, error) {
        var blk BlockHeader
        if err := blk.UnmarshalCBOR(bytes.NewReader(b)); err != nil {
                return nil, err
        }

        return &blk, nil
}

func (blk *BlockHeader) Serialize() ([]byte, error) {
        buf := new(bytes.Buffer)
        if err := blk.MarshalCBOR(buf); err != nil {
                return nil, err
        }

        return buf.Bytes(), nil
}

func (blk *BlockHeader) LastTicket() *Ticket {
        return blk.Ticket
}

func (blk *BlockHeader) SigningBytes() ([]byte, error) {
        blkcopy := *blk
        blkcopy.BlockSig = nil

        return blkcopy.Serialize()
}

func (blk *BlockHeader) SetValidated() {
        blk.validated = true
}

func (blk *BlockHeader) IsValidated() bool {
        return blk.validated
}

type MsgMeta struct {
        BlsMessages   cid.Cid
        SecpkMessages cid.Cid
}

func (mm *MsgMeta) Cid() cid.Cid {
        b, err := mm.ToStorageBlock()
        if err != nil {
                panic(err) // also maybe sketchy
        }
        return b.Cid()
}

func (mm *MsgMeta) ToStorageBlock() (block.Block, error) {
        var buf bytes.Buffer
        if err := mm.MarshalCBOR(&buf); err != nil {
                return nil, xerrors.Errorf("failed to marshal MsgMeta: %w", err)
        }

        c, err := abi.CidBuilder.Sum(buf.Bytes())
        if err != nil {
                return nil, err
        }

        return block.NewBlockWithCid(buf.Bytes(), c)
}

func CidArrsEqual(a, b []cid.Cid) bool {
        if len(a) != len(b) {
                return false
        }

        // order ignoring compare...
        s := make(map[cid.Cid]bool)
        for _, c := range a {
                s[c] = true
        }

        for _, c := range b {
                if !s[c] {
                        return false
                }
        }
        return true
}

func CidArrsSubset(a, b []cid.Cid) bool {
        // order ignoring compare...
        s := make(map[cid.Cid]bool)
        for _, c := range b {
                s[c] = true
        }

        for _, c := range a {
                if !s[c] {
                        return false
                }
        }
        return true
}

func CidArrsContains(a []cid.Cid, b cid.Cid) bool {
        for _, elem := range a {
                if elem.Equals(b) {
                        return true
                }
        }
        return false
}

func (t *Ticket) Equals(ot *Ticket) bool {
        return bytes.Equal(t.VRFProof, ot.VRFProof)
}

package types

import (
        "bytes"
        "fmt"

        "github.com/ipfs/go-cid"
)

type BlockMsg struct {
        Header        *BlockHeader
        BlsMessages   []cid.Cid
        SecpkMessages []cid.Cid
}

func DecodeBlockMsg(b []byte) (*BlockMsg, error) {
        var bm BlockMsg
        data := bytes.NewReader(b)
        if err := bm.UnmarshalCBOR(data); err != nil {
                return nil, err
        }
        if l := data.Len(); l != 0 {
                return nil, fmt.Errorf("extraneous data in BlockMsg CBOR encoding: got %d unexpected bytes", l)
        }
        return &bm, nil
}

func (bm *BlockMsg) Cid() cid.Cid {
        return bm.Header.Cid()
}

func (bm *BlockMsg) Serialize() ([]byte, error) {
        buf := new(bytes.Buffer)
        if err := bm.MarshalCBOR(buf); err != nil {
                return nil, err
        }
        return buf.Bytes(), nil
}

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

package types

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

        cid "github.com/ipfs/go-cid"
        cbg "github.com/whyrusleeping/cbor-gen"
        xerrors "golang.org/x/xerrors"

        address "github.com/filecoin-project/go-address"
        abi "github.com/filecoin-project/go-state-types/abi"
        crypto "github.com/filecoin-project/go-state-types/crypto"
        exitcode "github.com/filecoin-project/go-state-types/exitcode"
        proof "github.com/filecoin-project/go-state-types/proof"
)

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

var lengthBufBlockHeader = []byte{144}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufBlockHeader); err != nil {
                return err
        }

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

        // t.Ticket (types.Ticket) (struct)
        if err := t.Ticket.MarshalCBOR(cw); err != nil {
                return err
        }

        // t.ElectionProof (types.ElectionProof) (struct)
        if err := t.ElectionProof.MarshalCBOR(cw); err != nil {
                return err
        }

        // t.BeaconEntries ([]types.BeaconEntry) (slice)
        if len(t.BeaconEntries) > 8192 {
                return xerrors.Errorf("Slice value in field t.BeaconEntries was too long")
        }

        if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.BeaconEntries))); err != nil {
                return err
        }
        for _, v := range t.BeaconEntries {
                if err := v.MarshalCBOR(cw); err != nil {
                        return err
                }

        }

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

        if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.WinPoStProof))); err != nil {
                return err
        }
        for _, v := range t.WinPoStProof {
                if err := v.MarshalCBOR(cw); err != nil {
                        return err
                }

        }

        // t.Parents ([]cid.Cid) (slice)
        if len(t.Parents) > 8192 {
                return xerrors.Errorf("Slice value in field t.Parents was too long")
        }

        if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Parents))); err != nil {
                return err
        }
        for _, v := range t.Parents {

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

        }

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

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

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

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

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

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

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

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

        // t.BLSAggregate (crypto.Signature) (struct)
        if err := t.BLSAggregate.MarshalCBOR(cw); err != nil {
                return err
        }

        // t.Timestamp (uint64) (uint64)

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

        // t.BlockSig (crypto.Signature) (struct)
        if err := t.BlockSig.MarshalCBOR(cw); err != nil {
                return err
        }

        // t.ForkSignaling (uint64) (uint64)

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

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

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

        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.MajArray {
                return fmt.Errorf("cbor input should be of type array")
        }

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

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

        {

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

        }
        // t.Ticket (types.Ticket) (struct)

        {

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

        }
        // t.ElectionProof (types.ElectionProof) (struct)

        {

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

        }
        // t.BeaconEntries ([]types.BeaconEntry) (slice)

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

        if extra > 0 {
                t.BeaconEntries = make([]BeaconEntry, extra)
        }

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

                        {

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

                        }

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

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

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

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

                        {

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

                        }

                }
        }
        // t.Parents ([]cid.Cid) (slice)

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

        if extra > 0 {
                t.Parents = make([]cid.Cid, extra)
        }

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

                        {

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

                                t.Parents[i] = c

                        }

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

        {

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

        }
        // t.Height (abi.ChainEpoch) (int64)
        {
                maj, extra, err := cr.ReadHeader()
                if err != nil {
                        return err
                }
                var extraI int64
                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 overflow")
                        }
                        extraI = -1 - extraI
                default:
                        return fmt.Errorf("wrong type for int64 field: %d", maj)
                }

                t.Height = abi.ChainEpoch(extraI)
        }
        // t.ParentStateRoot (cid.Cid) (struct)

        {

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

                t.ParentStateRoot = c

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

        {

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

                t.ParentMessageReceipts = c

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

        {

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

                t.Messages = c

        }
        // t.BLSAggregate (crypto.Signature) (struct)

        {

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

        }
        // t.Timestamp (uint64) (uint64)

        {

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

        }
        // t.BlockSig (crypto.Signature) (struct)

        {

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

        }
        // t.ForkSignaling (uint64) (uint64)

        {

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

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

        {

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

        }
        return nil
}

var lengthBufTicket = []byte{129}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufTicket); err != nil {
                return err
        }

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

        if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.VRFProof))); err != nil {
                return err
        }

        if _, err := cw.Write(t.VRFProof); err != nil {
                return err
        }

        return nil
}

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

        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.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.VRFProof ([]uint8) (slice)

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

        if _, err := io.ReadFull(cr, t.VRFProof); err != nil {
                return err
        }

        return nil
}

var lengthBufElectionProof = []byte{130}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufElectionProof); err != nil {
                return err
        }

        // t.WinCount (int64) (int64)
        if t.WinCount >= 0 {
                if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.WinCount)); err != nil {
                        return err
                }
        } else {
                if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.WinCount-1)); err != nil {
                        return err
                }
        }

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

        if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.VRFProof))); err != nil {
                return err
        }

        if _, err := cw.Write(t.VRFProof); err != nil {
                return err
        }

        return nil
}

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

        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.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.WinCount (int64) (int64)
        {
                maj, extra, err := cr.ReadHeader()
                if err != nil {
                        return err
                }
                var extraI int64
                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 overflow")
                        }
                        extraI = -1 - extraI
                default:
                        return fmt.Errorf("wrong type for int64 field: %d", maj)
                }

                t.WinCount = int64(extraI)
        }
        // t.VRFProof ([]uint8) (slice)

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

        if _, err := io.ReadFull(cr, t.VRFProof); err != nil {
                return err
        }

        return nil
}

var lengthBufMessage = []byte{138}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufMessage); err != nil {
                return err
        }

        // t.Version (uint64) (uint64)

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

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

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

        // t.Nonce (uint64) (uint64)

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

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

        // t.GasLimit (int64) (int64)
        if t.GasLimit >= 0 {
                if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.GasLimit)); err != nil {
                        return err
                }
        } else {
                if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.GasLimit-1)); err != nil {
                        return err
                }
        }

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

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

        // t.Method (abi.MethodNum) (uint64)

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

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

        if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Params))); err != nil {
                return err
        }

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

        return nil
}

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

        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.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.Version (uint64) (uint64)

        {

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

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

        {

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

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

        {

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

        }
        // t.Nonce (uint64) (uint64)

        {

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

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

        {

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

        }
        // t.GasLimit (int64) (int64)
        {
                maj, extra, err := cr.ReadHeader()
                if err != nil {
                        return err
                }
                var extraI int64
                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 overflow")
                        }
                        extraI = -1 - extraI
                default:
                        return fmt.Errorf("wrong type for int64 field: %d", maj)
                }

                t.GasLimit = int64(extraI)
        }
        // t.GasFeeCap (big.Int) (struct)

        {

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

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

        {

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

        }
        // t.Method (abi.MethodNum) (uint64)

        {

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

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

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

        if _, err := io.ReadFull(cr, t.Params); err != nil {
                return err
        }

        return nil
}

var lengthBufSignedMessage = []byte{130}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufSignedMessage); err != nil {
                return err
        }

        // t.Message (types.Message) (struct)
        if err := t.Message.MarshalCBOR(cw); err != nil {
                return err
        }

        // t.Signature (crypto.Signature) (struct)
        if err := t.Signature.MarshalCBOR(cw); err != nil {
                return err
        }
        return nil
}

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

        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.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.Message (types.Message) (struct)

        {

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

        }
        // t.Signature (crypto.Signature) (struct)

        {

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

        }
        return nil
}

var lengthBufMsgMeta = []byte{130}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufMsgMeta); err != nil {
                return err
        }

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

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

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

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

        return nil
}

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

        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.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.BlsMessages (cid.Cid) (struct)

        {

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

                t.BlsMessages = c

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

        {

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

                t.SecpkMessages = c

        }
        return nil
}

var lengthBufActorV4 = []byte{132}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufActorV4); err != nil {
                return err
        }

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

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

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

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

        // t.Nonce (uint64) (uint64)

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

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

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

        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.MajArray {
                return fmt.Errorf("cbor input should be of type array")
        }

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

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

        {

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

                t.Code = c

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

        {

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

                t.Head = c

        }
        // t.Nonce (uint64) (uint64)

        {

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

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

        {

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

        }
        return nil
}

var lengthBufActorV5 = []byte{133}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufActorV5); err != nil {
                return err
        }

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

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

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

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

        // t.Nonce (uint64) (uint64)

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

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

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

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

        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.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.Code (cid.Cid) (struct)

        {

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

                t.Code = c

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

        {

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

                t.Head = c

        }
        // t.Nonce (uint64) (uint64)

        {

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

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

        {

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

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

        {

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

        }
        return nil
}

var lengthBufBlockMsg = []byte{131}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufBlockMsg); err != nil {
                return err
        }

        // t.Header (types.BlockHeader) (struct)
        if err := t.Header.MarshalCBOR(cw); err != nil {
                return err
        }

        // t.BlsMessages ([]cid.Cid) (slice)
        if len(t.BlsMessages) > 8192 {
                return xerrors.Errorf("Slice value in field t.BlsMessages was too long")
        }

        if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.BlsMessages))); err != nil {
                return err
        }
        for _, v := range t.BlsMessages {

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

        }

        // t.SecpkMessages ([]cid.Cid) (slice)
        if len(t.SecpkMessages) > 8192 {
                return xerrors.Errorf("Slice value in field t.SecpkMessages was too long")
        }

        if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.SecpkMessages))); err != nil {
                return err
        }
        for _, v := range t.SecpkMessages {

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

        }
        return nil
}

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

        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.MajArray {
                return fmt.Errorf("cbor input should be of type array")
        }

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

        // t.Header (types.BlockHeader) (struct)

        {

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

        }
        // t.BlsMessages ([]cid.Cid) (slice)

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

        if extra > 0 {
                t.BlsMessages = make([]cid.Cid, extra)
        }

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

                        {

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

                                t.BlsMessages[i] = c

                        }

                }
        }
        // t.SecpkMessages ([]cid.Cid) (slice)

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

        if extra > 0 {
                t.SecpkMessages = make([]cid.Cid, extra)
        }

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

                        {

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

                                t.SecpkMessages[i] = c

                        }

                }
        }
        return nil
}

var lengthBufExpTipSet = []byte{131}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufExpTipSet); err != nil {
                return err
        }

        // t.Cids ([]cid.Cid) (slice)
        if len(t.Cids) > 8192 {
                return xerrors.Errorf("Slice value in field t.Cids was too long")
        }

        if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Cids))); err != nil {
                return err
        }
        for _, v := range t.Cids {

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

        }

        // t.Blocks ([]*types.BlockHeader) (slice)
        if len(t.Blocks) > 8192 {
                return xerrors.Errorf("Slice value in field t.Blocks was too long")
        }

        if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Blocks))); err != nil {
                return err
        }
        for _, v := range t.Blocks {
                if err := v.MarshalCBOR(cw); err != nil {
                        return err
                }

        }

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

        return nil
}

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

        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.MajArray {
                return fmt.Errorf("cbor input should be of type array")
        }

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

        // t.Cids ([]cid.Cid) (slice)

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

        if extra > 0 {
                t.Cids = make([]cid.Cid, extra)
        }

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

                        {

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

                                t.Cids[i] = c

                        }

                }
        }
        // t.Blocks ([]*types.BlockHeader) (slice)

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

        if extra > 0 {
                t.Blocks = make([]*BlockHeader, extra)
        }

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

                        {

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

                        }

                }
        }
        // t.Height (abi.ChainEpoch) (int64)
        {
                maj, extra, err := cr.ReadHeader()
                if err != nil {
                        return err
                }
                var extraI int64
                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 overflow")
                        }
                        extraI = -1 - extraI
                default:
                        return fmt.Errorf("wrong type for int64 field: %d", maj)
                }

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

var lengthBufBeaconEntry = []byte{130}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufBeaconEntry); err != nil {
                return err
        }

        // t.Round (uint64) (uint64)

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

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

        if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Data))); err != nil {
                return err
        }

        if _, err := cw.Write(t.Data); err != nil {
                return err
        }

        return nil
}

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

        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.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.Round (uint64) (uint64)

        {

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

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

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

        if _, err := io.ReadFull(cr, t.Data); err != nil {
                return err
        }

        return nil
}

var lengthBufStateRoot = []byte{131}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufStateRoot); err != nil {
                return err
        }

        // t.Version (types.StateTreeVersion) (uint64)

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

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

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

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

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

        return nil
}

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

        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.MajArray {
                return fmt.Errorf("cbor input should be of type array")
        }

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

        // t.Version (types.StateTreeVersion) (uint64)

        {

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

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

        {

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

                t.Actors = c

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

        {

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

                t.Info = c

        }
        return nil
}

var lengthBufStateInfo0 = []byte{128}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufStateInfo0); err != nil {
                return err
        }

        return nil
}

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

        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.MajArray {
                return fmt.Errorf("cbor input should be of type array")
        }

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

        return nil
}

var lengthBufEvent = []byte{130}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufEvent); err != nil {
                return err
        }

        // t.Emitter (abi.ActorID) (uint64)

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

        // t.Entries ([]types.EventEntry) (slice)
        if len(t.Entries) > 8192 {
                return xerrors.Errorf("Slice value in field t.Entries was too long")
        }

        if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Entries))); err != nil {
                return err
        }
        for _, v := range t.Entries {
                if err := v.MarshalCBOR(cw); err != nil {
                        return err
                }

        }
        return nil
}

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

        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.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.Emitter (abi.ActorID) (uint64)

        {

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

        }
        // t.Entries ([]types.EventEntry) (slice)

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

        if extra > 0 {
                t.Entries = make([]EventEntry, extra)
        }

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

                        {

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

                        }

                }
        }
        return nil
}

var lengthBufEventEntry = []byte{132}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufEventEntry); err != nil {
                return err
        }

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

        // t.Key (string) (string)
        if len(t.Key) > 8192 {
                return xerrors.Errorf("Value in field t.Key was too long")
        }

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

        // t.Codec (uint64) (uint64)

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

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

        if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Value))); err != nil {
                return err
        }

        if _, err := cw.Write(t.Value); err != nil {
                return err
        }

        return nil
}

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

        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.MajArray {
                return fmt.Errorf("cbor input should be of type array")
        }

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

        // t.Flags (uint8) (uint8)

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }
        if maj != cbg.MajUnsignedInt {
                return fmt.Errorf("wrong type for uint8 field")
        }
        if extra > math.MaxUint8 {
                return fmt.Errorf("integer in input was too large for uint8 field")
        }
        t.Flags = uint8(extra)
        // t.Key (string) (string)

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

                t.Key = string(sval)
        }
        // t.Codec (uint64) (uint64)

        {

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

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

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

        if _, err := io.ReadFull(cr, t.Value); err != nil {
                return err
        }

        return nil
}

var lengthBufGasTrace = []byte{133}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufGasTrace); err != nil {
                return err
        }

        // t.Name (string) (string)
        if len(t.Name) > 8192 {
                return xerrors.Errorf("Value in field t.Name was too long")
        }

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

        // t.TotalGas (int64) (int64)
        if t.TotalGas >= 0 {
                if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.TotalGas)); err != nil {
                        return err
                }
        } else {
                if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.TotalGas-1)); err != nil {
                        return err
                }
        }

        // t.ComputeGas (int64) (int64)
        if t.ComputeGas >= 0 {
                if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.ComputeGas)); err != nil {
                        return err
                }
        } else {
                if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.ComputeGas-1)); err != nil {
                        return err
                }
        }

        // t.StorageGas (int64) (int64)
        if t.StorageGas >= 0 {
                if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.StorageGas)); err != nil {
                        return err
                }
        } else {
                if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.StorageGas-1)); err != nil {
                        return err
                }
        }

        // t.TimeTaken (time.Duration) (int64)
        if t.TimeTaken >= 0 {
                if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.TimeTaken)); err != nil {
                        return err
                }
        } else {
                if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.TimeTaken-1)); err != nil {
                        return err
                }
        }

        return nil
}

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

        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.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.Name (string) (string)

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

                t.Name = string(sval)
        }
        // t.TotalGas (int64) (int64)
        {
                maj, extra, err := cr.ReadHeader()
                if err != nil {
                        return err
                }
                var extraI int64
                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 overflow")
                        }
                        extraI = -1 - extraI
                default:
                        return fmt.Errorf("wrong type for int64 field: %d", maj)
                }

                t.TotalGas = int64(extraI)
        }
        // t.ComputeGas (int64) (int64)
        {
                maj, extra, err := cr.ReadHeader()
                if err != nil {
                        return err
                }
                var extraI int64
                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 overflow")
                        }
                        extraI = -1 - extraI
                default:
                        return fmt.Errorf("wrong type for int64 field: %d", maj)
                }

                t.ComputeGas = int64(extraI)
        }
        // t.StorageGas (int64) (int64)
        {
                maj, extra, err := cr.ReadHeader()
                if err != nil {
                        return err
                }
                var extraI int64
                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 overflow")
                        }
                        extraI = -1 - extraI
                default:
                        return fmt.Errorf("wrong type for int64 field: %d", maj)
                }

                t.StorageGas = int64(extraI)
        }
        // t.TimeTaken (time.Duration) (int64)
        {
                maj, extra, err := cr.ReadHeader()
                if err != nil {
                        return err
                }
                var extraI int64
                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 overflow")
                        }
                        extraI = -1 - extraI
                default:
                        return fmt.Errorf("wrong type for int64 field: %d", maj)
                }

                t.TimeTaken = time.Duration(extraI)
        }
        return nil
}

var lengthBufActorTrace = []byte{130}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufActorTrace); err != nil {
                return err
        }

        // t.Id (abi.ActorID) (uint64)

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

        // t.State (types.ActorV5) (struct)
        if err := t.State.MarshalCBOR(cw); err != nil {
                return err
        }
        return nil
}

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

        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.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.Id (abi.ActorID) (uint64)

        {

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

        }
        // t.State (types.ActorV5) (struct)

        {

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

        }
        return nil
}

var lengthBufMessageTrace = []byte{136}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufMessageTrace); err != nil {
                return err
        }

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

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

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

        // t.Method (abi.MethodNum) (uint64)

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

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

        if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Params))); err != nil {
                return err
        }

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

        // t.ParamsCodec (uint64) (uint64)

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

        // t.GasLimit (uint64) (uint64)

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

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

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

        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.MajArray {
                return fmt.Errorf("cbor input should be of type array")
        }

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

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

        {

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

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

        {

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

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

        {

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

        }
        // t.Method (abi.MethodNum) (uint64)

        {

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

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

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

        if _, err := io.ReadFull(cr, t.Params); err != nil {
                return err
        }

        // t.ParamsCodec (uint64) (uint64)

        {

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

        }
        // t.GasLimit (uint64) (uint64)

        {

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

        }
        // t.ReadOnly (bool) (bool)

        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.ReadOnly = false
        case 21:
                t.ReadOnly = true
        default:
                return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
        }
        return nil
}

var lengthBufReturnTrace = []byte{131}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufReturnTrace); err != nil {
                return err
        }

        // t.ExitCode (exitcode.ExitCode) (int64)
        if t.ExitCode >= 0 {
                if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.ExitCode)); err != nil {
                        return err
                }
        } else {
                if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.ExitCode-1)); err != nil {
                        return err
                }
        }

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

        if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Return))); err != nil {
                return err
        }

        if _, err := cw.Write(t.Return); err != nil {
                return err
        }

        // t.ReturnCodec (uint64) (uint64)

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

        return nil
}

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

        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.MajArray {
                return fmt.Errorf("cbor input should be of type array")
        }

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

        // t.ExitCode (exitcode.ExitCode) (int64)
        {
                maj, extra, err := cr.ReadHeader()
                if err != nil {
                        return err
                }
                var extraI int64
                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 overflow")
                        }
                        extraI = -1 - extraI
                default:
                        return fmt.Errorf("wrong type for int64 field: %d", maj)
                }

                t.ExitCode = exitcode.ExitCode(extraI)
        }
        // t.Return ([]uint8) (slice)

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

        if _, err := io.ReadFull(cr, t.Return); err != nil {
                return err
        }

        // t.ReturnCodec (uint64) (uint64)

        {

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

        }
        return nil
}

var lengthBufExecutionTrace = []byte{133}

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

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufExecutionTrace); err != nil {
                return err
        }

        // t.Msg (types.MessageTrace) (struct)
        if err := t.Msg.MarshalCBOR(cw); err != nil {
                return err
        }

        // t.MsgRct (types.ReturnTrace) (struct)
        if err := t.MsgRct.MarshalCBOR(cw); err != nil {
                return err
        }

        // t.InvokedActor (types.ActorTrace) (struct)
        if err := t.InvokedActor.MarshalCBOR(cw); err != nil {
                return err
        }

        // t.GasCharges ([]*types.GasTrace) (slice)
        if len(t.GasCharges) > 1000000000 {
                return xerrors.Errorf("Slice value in field t.GasCharges was too long")
        }

        if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.GasCharges))); err != nil {
                return err
        }
        for _, v := range t.GasCharges {
                if err := v.MarshalCBOR(cw); err != nil {
                        return err
                }

        }

        // t.Subcalls ([]types.ExecutionTrace) (slice)
        if len(t.Subcalls) > 1000000000 {
                return xerrors.Errorf("Slice value in field t.Subcalls was too long")
        }

        if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Subcalls))); err != nil {
                return err
        }
        for _, v := range t.Subcalls {
                if err := v.MarshalCBOR(cw); err != nil {
                        return err
                }

        }
        return nil
}

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

        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.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.Msg (types.MessageTrace) (struct)

        {

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

        }
        // t.MsgRct (types.ReturnTrace) (struct)

        {

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

        }
        // t.InvokedActor (types.ActorTrace) (struct)

        {

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

        }
        // t.GasCharges ([]*types.GasTrace) (slice)

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

        if extra > 0 {
                t.GasCharges = make([]*GasTrace, extra)
        }

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

                        {

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

                        }

                }
        }
        // t.Subcalls ([]types.ExecutionTrace) (slice)

        maj, extra, err = cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

        if extra > 0 {
                t.Subcalls = make([]ExecutionTrace, extra)
        }

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

                        {

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

                        }

                }
        }
        return nil
}

package types

import (
        "math/big"

        "github.com/minio/blake2b-simd"

        "github.com/filecoin-project/lotus/build"
)

type ElectionProof struct {
        WinCount int64
        VRFProof []byte
}

const precision = 256

var (
        expNumCoef  []*big.Int
        expDenoCoef []*big.Int
)

func init() {
        parse := func(coefs []string) []*big.Int {
                out := make([]*big.Int, len(coefs))
                for i, coef := range coefs {
                        c, ok := new(big.Int).SetString(coef, 10)
                        if !ok {
                                panic("could not parse exp paramemter")
                        }
                        // << 256 (Q.0 to Q.256), >> 128 to transform integer params to coefficients
                        c = c.Lsh(c, precision-128)
                        out[i] = c
                }
                return out
        }

        // parameters are in integer format,
        // coefficients are *2^-128 of that
        num := []string{
                "-648770010757830093818553637600",
                "67469480939593786226847644286976",
                "-3197587544499098424029388939001856",
                "89244641121992890118377641805348864",
                "-1579656163641440567800982336819953664",
                "17685496037279256458459817590917169152",
                "-115682590513835356866803355398940131328",
                "340282366920938463463374607431768211456",
        }
        expNumCoef = parse(num)

        deno := []string{
                "1225524182432722209606361",
                "114095592300906098243859450",
                "5665570424063336070530214243",
                "194450132448609991765137938448",
                "5068267641632683791026134915072",
                "104716890604972796896895427629056",
                "1748338658439454459487681798864896",
                "23704654329841312470660182937960448",
                "259380097567996910282699886670381056",
                "2250336698853390384720606936038375424",
                "14978272436876548034486263159246028800",
                "72144088983913131323343765784380833792",
                "224599776407103106596571252037123047424",
                "340282366920938463463374607431768211456",
        }
        expDenoCoef = parse(deno)
}

// expneg accepts x in Q.256 format and computes e^-x.
// It is most precise within [0, 1.725) range, where error is less than 3.4e-30.
// Over the [0, 5) range its error is less than 4.6e-15.
// Output is in Q.256 format.
func expneg(x *big.Int) *big.Int {
        // exp is approximated by rational function
        // polynomials of the rational function are evaluated using Horner's method
        num := polyval(expNumCoef, x)   // Q.256
        deno := polyval(expDenoCoef, x) // Q.256

        num = num.Lsh(num, precision) // Q.512
        return num.Div(num, deno)     // Q.512 / Q.256 => Q.256
}

// polyval evaluates a polynomial given by coefficients `p` in Q.256 format
// at point `x` in Q.256 format. Output is in Q.256.
// Coefficients should be ordered from the highest order coefficient to the lowest.
func polyval(p []*big.Int, x *big.Int) *big.Int {
        // evaluation using Horner's method
        res := new(big.Int).Set(p[0]) // Q.256
        tmp := new(big.Int)           // big.Int.Mul doesn't like when input is reused as output
        for _, c := range p[1:] {
                tmp = tmp.Mul(res, x)         // Q.256 * Q.256 => Q.512
                res = res.Rsh(tmp, precision) // Q.512 >> 256 => Q.256
                res = res.Add(res, c)
        }

        return res
}

// computes lambda in Q.256
func lambda(power, totalPower *big.Int) *big.Int {
        blocksPerEpoch := NewInt(build.BlocksPerEpoch)
        lam := new(big.Int).Mul(power, blocksPerEpoch.Int)   // Q.0
        lam = lam.Lsh(lam, precision)                        // Q.256
        lam = lam.Div(lam /* Q.256 */, totalPower /* Q.0 */) // Q.256
        return lam
}

var MaxWinCount = 3 * int64(build.BlocksPerEpoch)

type poiss struct {
        lam  *big.Int
        pmf  *big.Int
        icdf *big.Int

        tmp *big.Int // temporary variable for optimization

        k uint64
}

// newPoiss starts poisson inverted CDF
// lambda is in Q.256 format
// returns (instance, `1-poisscdf(0, lambda)`)
// CDF value returend is reused when calling `next`
func newPoiss(lambda *big.Int) (*poiss, *big.Int) {

        // pmf(k) = (lambda^k)*(e^lambda) / k!
        // k = 0 here, so it simplifies to just e^-lambda
        elam := expneg(lambda) // Q.256
        pmf := new(big.Int).Set(elam)

        // icdf(k) = 1 - ∑ᵏᵢ₌₀ pmf(i)
        // icdf(0) = 1 - pmf(0)
        icdf := big.NewInt(1)
        icdf = icdf.Lsh(icdf, precision) // Q.256
        icdf = icdf.Sub(icdf, pmf)       // Q.256

        k := uint64(0)

        p := &poiss{
                lam: lambda,
                pmf: pmf,

                tmp:  elam,
                icdf: icdf,

                k: k,
        }

        return p, icdf
}

// next computes `k++, 1-poisscdf(k, lam)`
// return is in Q.256 format
func (p *poiss) next() *big.Int {
        // incrementally compute next pmf and icdf

        // pmf(k) = (lambda^k)*(e^lambda) / k!
        // so pmf(k) = pmf(k-1) * lambda / k
        p.k++
        p.tmp.SetUint64(p.k) // Q.0

        // calculate pmf for k
        p.pmf = p.pmf.Div(p.pmf, p.tmp) // Q.256 / Q.0 => Q.256
        // we are using `tmp` as target for multiplication as using an input as output
        // for Int.Mul causes allocations
        p.tmp = p.tmp.Mul(p.pmf, p.lam)     // Q.256 * Q.256 => Q.512
        p.pmf = p.pmf.Rsh(p.tmp, precision) // Q.512 >> 256 => Q.256

        // calculate output
        // icdf(k) = icdf(k-1) - pmf(k)
        p.icdf = p.icdf.Sub(p.icdf, p.pmf) // Q.256
        return p.icdf
}

// ComputeWinCount uses VRFProof to compute number of wins
// The algorithm is based on Algorand's Sortition with Binomial distribution
// replaced by Poisson distribution.
func (ep *ElectionProof) ComputeWinCount(power BigInt, totalPower BigInt) int64 {
        h := blake2b.Sum256(ep.VRFProof)

        lhs := BigFromBytes(h[:]).Int // 256bits, assume Q.256 so [0, 1)

        // We are calculating upside-down CDF of Poisson distribution with
        // rate λ=power*E/totalPower
        // Steps:
        //  1. calculate λ=power*E/totalPower
        //  2. calculate elam = exp(-λ)
        //  3. Check how many times we win:
        //    j = 0
        //    pmf = elam
        //    rhs = 1 - pmf
        //    for h(vrf) < rhs: j++; pmf = pmf * lam / j; rhs = rhs - pmf

        lam := lambda(power.Int, totalPower.Int) // Q.256

        p, rhs := newPoiss(lam)

        var j int64
        for lhs.Cmp(rhs) < 0 && j < MaxWinCount {
                rhs = p.next()
                j++
        }

        return j
}

package types

import (
        "encoding/json"
        "time"

        "github.com/filecoin-project/go-address"
        "github.com/filecoin-project/go-state-types/abi"
        "github.com/filecoin-project/go-state-types/exitcode"
)

type GasTrace struct {
        Name       string
        TotalGas   int64         `json:"tg"`
        ComputeGas int64         `json:"cg"`
        StorageGas int64         `json:"sg"`
        TimeTaken  time.Duration `json:"tt"`
}

type MessageTrace struct {
        From        address.Address
        To          address.Address
        Value       abi.TokenAmount
        Method      abi.MethodNum
        Params      []byte
        ParamsCodec uint64
        GasLimit    uint64
        ReadOnly    bool
}

type ActorTrace struct {
        Id    abi.ActorID
        State Actor
}

type ReturnTrace struct {
        ExitCode    exitcode.ExitCode
        Return      []byte
        ReturnCodec uint64
}

type ExecutionTrace struct {
        Msg          MessageTrace
        MsgRct       ReturnTrace
        InvokedActor *ActorTrace      `json:",omitempty"`
        GasCharges   []*GasTrace      `cborgen:"maxlen=1000000000"`
        Subcalls     []ExecutionTrace `cborgen:"maxlen=1000000000"`
}

func (et ExecutionTrace) SumGas() GasTrace {
        return SumGas(et.GasCharges)
}

func SumGas(charges []*GasTrace) GasTrace {
        var out GasTrace
        for _, gc := range charges {
                out.TotalGas += gc.TotalGas
                out.ComputeGas += gc.ComputeGas
                out.StorageGas += gc.StorageGas
        }

        return out
}

func (gt *GasTrace) MarshalJSON() ([]byte, error) {
        type GasTraceCopy GasTrace
        cpy := (*GasTraceCopy)(gt)
        return json.Marshal(cpy)
}

package types

import (
        "encoding"
        "fmt"
        "math/big"
        "strings"

        "github.com/invopop/jsonschema"

        "github.com/filecoin-project/lotus/build"
)

type FIL BigInt

func (f FIL) String() string {
        if f.Int == nil {
                return "0 FIL"
        }
        return f.Unitless() + " FIL"
}

func (f FIL) Unitless() string {
        r := new(big.Rat).SetFrac(f.Int, big.NewInt(int64(build.FilecoinPrecision)))
        if r.Sign() == 0 {
                return "0"
        }
        return strings.TrimRight(strings.TrimRight(r.FloatString(18), "0"), ".")
}

var AttoFil = NewInt(1)
var FemtoFil = BigMul(AttoFil, NewInt(1000))
var PicoFil = BigMul(FemtoFil, NewInt(1000))
var NanoFil = BigMul(PicoFil, NewInt(1000))

var unitPrefixes = []string{"a", "f", "p", "n", "μ", "m"}

func (f FIL) Short() string {
        n := BigInt(f).Abs()

        dn := uint64(1)
        var prefix string
        for _, p := range unitPrefixes {
                if n.LessThan(NewInt(dn * 1000)) {
                        prefix = p
                        break
                }
                dn *= 1000
        }

        r := new(big.Rat).SetFrac(f.Int, big.NewInt(int64(dn)))
        if r.Sign() == 0 {
                return "0"
        }

        return strings.TrimRight(strings.TrimRight(r.FloatString(3), "0"), ".") + " " + prefix + "FIL"
}

func (f FIL) Nano() string {
        r := new(big.Rat).SetFrac(f.Int, big.NewInt(int64(1e9)))
        if r.Sign() == 0 {
                return "0"
        }

        return strings.TrimRight(strings.TrimRight(r.FloatString(9), "0"), ".") + " nFIL"
}

func (f FIL) Format(s fmt.State, ch rune) {
        switch ch {
        case 's', 'v':
                _, _ = fmt.Fprint(s, f.String())
        default:
                f.Int.Format(s, ch)
        }
}

func (f FIL) MarshalText() (text []byte, err error) {
        return []byte(f.String()), nil
}

func (f FIL) UnmarshalText(text []byte) error {
        if f.Int == nil {
                return fmt.Errorf("cannot unmarshal into nil BigInt (text:%s)", string(text))
        }

        p, err := ParseFIL(string(text))
        if err != nil {
                return err
        }

        f.Int.Set(p.Int)
        return nil
}

func ParseFIL(s string) (FIL, error) {
        suffix := strings.TrimLeft(s, "-.1234567890")
        s = s[:len(s)-len(suffix)]
        var attofil bool
        if suffix != "" {
                norm := strings.ToLower(strings.TrimSpace(suffix))
                switch norm {
                case "", "fil":
                case "attofil", "afil":
                        attofil = true
                default:
                        return FIL{}, fmt.Errorf("unrecognized suffix: %q", suffix)
                }
        }

        if len(s) > 50 {
                return FIL{}, fmt.Errorf("string length too large: %d", len(s))
        }

        r, ok := new(big.Rat).SetString(s) //nolint:gosec
        if !ok {
                return FIL{}, fmt.Errorf("failed to parse %q as a decimal number", s)
        }

        if !attofil {
                r = r.Mul(r, big.NewRat(int64(build.FilecoinPrecision), 1))
        }

        if !r.IsInt() {
                var pref string
                if attofil {
                        pref = "atto"
                }
                return FIL{}, fmt.Errorf("invalid %sFIL value: %q", pref, s)
        }

        return FIL{r.Num()}, nil
}

func MustParseFIL(s string) FIL {
        n, err := ParseFIL(s)
        if err != nil {
                panic(err)
        }

        return n
}

func (f FIL) JSONSchema() *jsonschema.Schema {
        return &jsonschema.Schema{
                Type:    "string",
                Pattern: `^((\d+(\.\d+)?|0x[0-9a-fA-F]+))( ([aA]([tT][tT][oO])?)?[fF][iI][lL])?$`,
        }
}

var _ encoding.TextMarshaler = (*FIL)(nil)
var _ encoding.TextUnmarshaler = (*FIL)(nil)

package types

import "github.com/ipfs/go-cid"

type FullBlock struct {
        Header        *BlockHeader
        BlsMessages   []*Message
        SecpkMessages []*SignedMessage
}

func (fb *FullBlock) Cid() cid.Cid {
        return fb.Header.Cid()
}

package types

import (
        "encoding/json"
        "fmt"

        "github.com/filecoin-project/go-state-types/crypto"
)

var (
        ErrKeyInfoNotFound = fmt.Errorf("key info not found")
        ErrKeyExists       = fmt.Errorf("key already exists")
)

// KeyType defines a type of a key
type KeyType string

func (kt *KeyType) UnmarshalJSON(bb []byte) error {
        {
                // first option, try unmarshaling as string
                var s string
                err := json.Unmarshal(bb, &s)
                if err == nil {
                        *kt = KeyType(s)
                        return nil
                }
        }

        {
                var b byte
                err := json.Unmarshal(bb, &b)
                if err != nil {
                        return fmt.Errorf("could not unmarshal KeyType either as string nor integer: %w", err)
                }
                bst := crypto.SigType(b)

                switch bst {
                case crypto.SigTypeBLS:
                        *kt = KTBLS
                case crypto.SigTypeSecp256k1:
                        *kt = KTSecp256k1
                case crypto.SigTypeDelegated:
                        *kt = KTDelegated
                default:
                        return fmt.Errorf("unknown sigtype: %d", bst)
                }
                log.Warnf("deprecation: integer style 'KeyType' is deprecated, switch to string style")
                return nil
        }
}

const (
        KTBLS             KeyType = "bls"
        KTSecp256k1       KeyType = "secp256k1"
        KTSecp256k1Ledger KeyType = "secp256k1-ledger"
        KTDelegated       KeyType = "delegated"
)

// KeyInfo is used for storing keys in KeyStore
type KeyInfo struct {
        Type       KeyType
        PrivateKey []byte
}

// KeyStore is used for storing secret keys
type KeyStore interface {
        // List lists all the keys stored in the KeyStore
        List() ([]string, error)
        // Get gets a key out of keystore and returns KeyInfo corresponding to named key
        Get(string) (KeyInfo, error)
        // Put saves a key info under given name
        Put(string, KeyInfo) error
        // Delete removes a key from keystore
        Delete(string) error
}

package types

import (
        "github.com/ipfs/go-cid"
        "go.uber.org/zap/zapcore"
)

type LogCids []cid.Cid

var _ zapcore.ArrayMarshaler = (*LogCids)(nil)

func (cids LogCids) MarshalLogArray(ae zapcore.ArrayEncoder) error {
        for _, c := range cids {
                ae.AppendString(c.String())
        }
        return nil
}

package types

import (
        "bytes"
        "encoding/json"
        "fmt"

        block "github.com/ipfs/go-block-format"
        "github.com/ipfs/go-cid"
        "golang.org/x/xerrors"

        "github.com/filecoin-project/go-address"
        "github.com/filecoin-project/go-state-types/abi"
        "github.com/filecoin-project/go-state-types/big"
        "github.com/filecoin-project/go-state-types/network"

        "github.com/filecoin-project/lotus/build"
)

const MessageVersion = 0

type ChainMsg interface {
        Cid() cid.Cid
        VMMessage() *Message
        ToStorageBlock() (block.Block, error)
        // FIXME: This is the *message* length, this name is misleading.
        ChainLength() int
}

type Message struct {
        Version uint64

        To   address.Address
        From address.Address

        Nonce uint64

        Value abi.TokenAmount

        GasLimit   int64
        GasFeeCap  abi.TokenAmount
        GasPremium abi.TokenAmount

        Method abi.MethodNum
        Params []byte
}

func (m *Message) Caller() address.Address {
        return m.From
}

func (m *Message) Receiver() address.Address {
        return m.To
}

func (m *Message) ValueReceived() abi.TokenAmount {
        return m.Value
}

func DecodeMessage(b []byte) (*Message, error) {
        var msg Message
        if err := msg.UnmarshalCBOR(bytes.NewReader(b)); err != nil {
                return nil, err
        }

        if msg.Version != MessageVersion {
                return nil, fmt.Errorf("decoded message had incorrect version (%d)", msg.Version)
        }

        return &msg, nil
}

func (m *Message) Serialize() ([]byte, error) {
        buf := new(bytes.Buffer)
        if err := m.MarshalCBOR(buf); err != nil {
                return nil, err
        }
        return buf.Bytes(), nil
}

func (m *Message) ChainLength() int {
        ser, err := m.Serialize()
        if err != nil {
                panic(err)
        }
        return len(ser)
}

func (m *Message) ToStorageBlock() (block.Block, error) {
        data, err := m.Serialize()
        if err != nil {
                return nil, err
        }

        c, err := abi.CidBuilder.Sum(data)
        if err != nil {
                return nil, err
        }

        return block.NewBlockWithCid(data, c)
}

func (m *Message) Cid() cid.Cid {
        b, err := m.ToStorageBlock()
        if err != nil {
                panic(fmt.Sprintf("failed to marshal message: %s", err)) // I think this is maybe sketchy, what happens if we try to serialize a message with an undefined address in it?
        }

        return b.Cid()
}

type mCid struct {
        *RawMessage
        CID cid.Cid
}

type RawMessage Message

func (m *Message) MarshalJSON() ([]byte, error) {
        return json.Marshal(&mCid{
                RawMessage: (*RawMessage)(m),
                CID:        m.Cid(),
        })
}

func (m *Message) RequiredFunds() BigInt {
        return BigMul(m.GasFeeCap, NewInt(uint64(m.GasLimit)))
}

func (m *Message) VMMessage() *Message {
        return m
}

func (m *Message) Equals(o *Message) bool {
        return m.Cid() == o.Cid()
}

func (m *Message) EqualCall(o *Message) bool {
        m1 := *m
        m2 := *o

        m1.GasLimit, m2.GasLimit = 0, 0
        m1.GasFeeCap, m2.GasFeeCap = big.Zero(), big.Zero()
        m1.GasPremium, m2.GasPremium = big.Zero(), big.Zero()

        return (&m1).Equals(&m2)
}

func (m *Message) ValidForBlockInclusion(minGas int64, version network.Version) error {
        if m.Version != 0 {
                return xerrors.New("'Version' unsupported")
        }

        if m.To == address.Undef {
                return xerrors.New("'To' address cannot be empty")
        }

        if m.To == build.ZeroAddress && version >= network.Version7 {
                return xerrors.New("invalid 'To' address")
        }

        if !abi.AddressValidForNetworkVersion(m.To, version) {
                return xerrors.New("'To' address protocol unsupported for network version")
        }

        if m.From == address.Undef {
                return xerrors.New("'From' address cannot be empty")
        }

        if !abi.AddressValidForNetworkVersion(m.From, version) {
                return xerrors.New("'From' address protocol unsupported for network version")
        }

        if m.Value.Int == nil {
                return xerrors.New("'Value' cannot be nil")
        }

        if m.Value.LessThan(big.Zero()) {
                return xerrors.New("'Value' field cannot be negative")
        }

        if m.Value.GreaterThan(TotalFilecoinInt) {
                return xerrors.New("'Value' field cannot be greater than total filecoin supply")
        }

        if m.GasFeeCap.Int == nil {
                return xerrors.New("'GasFeeCap' cannot be nil")
        }

        if m.GasFeeCap.LessThan(big.Zero()) {
                return xerrors.New("'GasFeeCap' field cannot be negative")
        }

        if m.GasPremium.Int == nil {
                return xerrors.New("'GasPremium' cannot be nil")
        }

        if m.GasPremium.LessThan(big.Zero()) {
                return xerrors.New("'GasPremium' field cannot be negative")
        }

        if m.GasPremium.GreaterThan(m.GasFeeCap) {
                return xerrors.New("'GasFeeCap' less than 'GasPremium'")
        }

        if m.GasLimit > build.BlockGasLimit {
                return xerrors.Errorf("'GasLimit' field cannot be greater than a block's gas limit (%d > %d)", m.GasLimit, build.BlockGasLimit)
        }

        if m.GasLimit <= 0 {
                return xerrors.Errorf("'GasLimit' field %d must be positive", m.GasLimit)
        }

        // since prices might vary with time, this is technically semantic validation
        if m.GasLimit < minGas {
                return xerrors.Errorf("'GasLimit' field cannot be less than the cost of storing a message on chain %d < %d", m.GasLimit, minGas)
        }

        return nil
}

// EffectiveGasPremium returns the effective gas premium claimable by the miner
// given the supplied base fee. This method is not used anywhere except the Eth API.
//
// Filecoin clamps the gas premium at GasFeeCap - BaseFee, if lower than the
// specified premium. Returns 0 if GasFeeCap is less than BaseFee.
func (m *Message) EffectiveGasPremium(baseFee abi.TokenAmount) abi.TokenAmount {
        available := big.Sub(m.GasFeeCap, baseFee)
        // It's possible that storage providers may include messages with gasFeeCap less than the baseFee
        // In such cases, their reward should be viewed as zero
        if available.LessThan(big.NewInt(0)) {
                available = big.NewInt(0)
        }
        if big.Cmp(m.GasPremium, available) <= 0 {
                return m.GasPremium
        }
        return available
}

const TestGasLimit = 100e6

//go:build gofuzz
// +build gofuzz

package types

import "bytes"

func FuzzMessage(data []byte) int {
        var msg Message
        err := msg.UnmarshalCBOR(bytes.NewReader(data))
        if err != nil {
                return 0
        }
        reData, err := msg.Serialize()
        if err != nil {
                panic(err) // ok
        }
        var msg2 Message
        err = msg2.UnmarshalCBOR(bytes.NewReader(data))
        if err != nil {
                panic(err) // ok
        }
        reData2, err := msg.Serialize()
        if err != nil {
                panic(err) // ok
        }
        if !bytes.Equal(reData, reData2) {
                panic("reencoding not equal") // ok
        }
        return 1
}

package types

import (
        "bytes"

        "github.com/ipfs/go-cid"

        "github.com/filecoin-project/go-state-types/exitcode"
)

type MessageReceiptVersion byte

const (
        // MessageReceiptV0 refers to pre FIP-0049 receipts.
        MessageReceiptV0 MessageReceiptVersion = 0
        // MessageReceiptV1 refers to post FIP-0049 receipts.
        MessageReceiptV1 MessageReceiptVersion = 1
)

const EventAMTBitwidth = 5

type MessageReceipt struct {
        version MessageReceiptVersion

        ExitCode   exitcode.ExitCode
        Return     []byte
        GasUsed    int64
        EventsRoot *cid.Cid // Root of Event AMT with bitwidth = EventAMTBitwidth
}

// NewMessageReceiptV0 creates a new pre FIP-0049 receipt with no capability to
// convey events.
func NewMessageReceiptV0(exitcode exitcode.ExitCode, ret []byte, gasUsed int64) MessageReceipt {
        return MessageReceipt{
                version:  MessageReceiptV0,
                ExitCode: exitcode,
                Return:   ret,
                GasUsed:  gasUsed,
        }
}

// NewMessageReceiptV1 creates a new pre FIP-0049 receipt with the ability to
// convey events.
func NewMessageReceiptV1(exitcode exitcode.ExitCode, ret []byte, gasUsed int64, eventsRoot *cid.Cid) MessageReceipt {
        return MessageReceipt{
                version:    MessageReceiptV1,
                ExitCode:   exitcode,
                Return:     ret,
                GasUsed:    gasUsed,
                EventsRoot: eventsRoot,
        }
}

func (mr *MessageReceipt) Version() MessageReceiptVersion {
        return mr.version
}

func (mr *MessageReceipt) Equals(o *MessageReceipt) bool {
        return mr.version == o.version && mr.ExitCode == o.ExitCode && bytes.Equal(mr.Return, o.Return) && mr.GasUsed == o.GasUsed &&
                (mr.EventsRoot == o.EventsRoot || (mr.EventsRoot != nil && o.EventsRoot != nil && *mr.EventsRoot == *o.EventsRoot))
}

package types

import (
        "fmt"
        "io"

        cbg "github.com/whyrusleeping/cbor-gen"
        "golang.org/x/xerrors"

        "github.com/filecoin-project/go-state-types/cbor"
        "github.com/filecoin-project/go-state-types/exitcode"
)

// This file contains custom CBOR serde logic to deal with the new versioned
// MessageReceipt resulting from the introduction of actor events (FIP-0049).

type messageReceiptV0 struct{ *MessageReceipt }

type messageReceiptV1 struct{ *MessageReceipt }

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

        var m cbor.Marshaler
        switch mr.version {
        case MessageReceiptV0:
                m = &messageReceiptV0{mr}
        case MessageReceiptV1:
                m = &messageReceiptV1{mr}
        default:
                return xerrors.Errorf("invalid message receipt version: %d", mr.version)
        }

        return m.MarshalCBOR(w)
}

func (mr *MessageReceipt) UnmarshalCBOR(r io.Reader) (err error) {
        *mr = MessageReceipt{}

        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.MajArray {
                return fmt.Errorf("cbor input should be of type array")
        }

        var u cbor.Unmarshaler
        switch extra {
        case 3:
                mr.version = MessageReceiptV0
                u = &messageReceiptV0{mr}
        case 4:
                mr.version = MessageReceiptV1
                u = &messageReceiptV1{mr}
        default:
                return fmt.Errorf("cbor input had wrong number of fields")
        }

        // Ok to pass a CBOR reader since cbg.NewCborReader will return itself when
        // already a CBOR reader.
        return u.UnmarshalCBOR(cr)
}

var lengthBufAMessageReceiptV0 = []byte{131}

func (t *messageReceiptV0) MarshalCBOR(w io.Writer) error {
        // eliding null check since nulls were already handled in the dispatcher

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufAMessageReceiptV0); err != nil {
                return err
        }

        // t.ExitCode (exitcode.ExitCode) (int64)
        if t.ExitCode >= 0 {
                if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.ExitCode)); err != nil {
                        return err
                }
        } else {
                if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.ExitCode-1)); err != nil {
                        return err
                }
        }

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

        if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Return))); err != nil {
                return err
        }

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

        // t.GasUsed (int64) (int64)
        if t.GasUsed >= 0 {
                if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.GasUsed)); err != nil {
                        return err
                }
        } else {
                if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.GasUsed-1)); err != nil {
                        return err
                }
        }
        return nil
}

func (t *messageReceiptV0) UnmarshalCBOR(r io.Reader) (err error) {
        cr := cbg.NewCborReader(r)

        // t.ExitCode (exitcode.ExitCode) (int64)
        {
                maj, extra, err := cr.ReadHeader()
                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 overflow")
                        }
                        extraI = -1 - extraI
                default:
                        return fmt.Errorf("wrong type for int64 field: %d", maj)
                }

                t.ExitCode = exitcode.ExitCode(extraI)
        }
        // t.Return ([]uint8) (slice)

        maj, extra, err := cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

        if _, err := io.ReadFull(cr, t.Return[:]); err != nil {
                return err
        }
        // t.GasUsed (int64) (int64)
        {
                maj, extra, err := cr.ReadHeader()
                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 overflow")
                        }
                        extraI = -1 - extraI
                default:
                        return fmt.Errorf("wrong type for int64 field: %d", maj)
                }

                t.GasUsed = extraI
        }
        return nil
}

var lengthBufBMessageReceiptV1 = []byte{132}

func (t *messageReceiptV1) MarshalCBOR(w io.Writer) error {
        // eliding null check since nulls were already handled in the dispatcher

        cw := cbg.NewCborWriter(w)

        if _, err := cw.Write(lengthBufBMessageReceiptV1); err != nil {
                return err
        }

        // t.ExitCode (exitcode.ExitCode) (int64)
        if t.ExitCode >= 0 {
                if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.ExitCode)); err != nil {
                        return err
                }
        } else {
                if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.ExitCode-1)); err != nil {
                        return err
                }
        }

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

        if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Return))); err != nil {
                return err
        }

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

        // t.GasUsed (int64) (int64)
        if t.GasUsed >= 0 {
                if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.GasUsed)); err != nil {
                        return err
                }
        } else {
                if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.GasUsed-1)); err != nil {
                        return err
                }
        }

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

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

        return nil
}

func (t *messageReceiptV1) UnmarshalCBOR(r io.Reader) (err error) {
        cr := cbg.NewCborReader(r)

        // t.ExitCode (exitcode.ExitCode) (int64)
        {
                maj, extra, err := cr.ReadHeader()
                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 overflow")
                        }
                        extraI = -1 - extraI
                default:
                        return fmt.Errorf("wrong type for int64 field: %d", maj)
                }

                t.ExitCode = exitcode.ExitCode(extraI)
        }
        // t.Return ([]uint8) (slice)

        maj, extra, err := cr.ReadHeader()
        if err != nil {
                return err
        }

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

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

        if _, err := io.ReadFull(cr, t.Return[:]); err != nil {
                return err
        }
        // t.GasUsed (int64) (int64)
        {
                maj, extra, err := cr.ReadHeader()
                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 overflow")
                        }
                        extraI = -1 - extraI
                default:
                        return fmt.Errorf("wrong type for int64 field: %d", maj)
                }

                t.GasUsed = extraI
        }
        // t.EventsRoot (cid.Cid) (struct)

        {

                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.EventsRoot: %w", err)
                        }

                        t.EventsRoot = &c
                }

        }
        return nil
}

package types

import (
        "time"

        "github.com/filecoin-project/go-address"
)

type MpoolConfig struct {
        PriorityAddrs          []address.Address
        SizeLimitHigh          int
        SizeLimitLow           int
        ReplaceByFeeRatio      Percent
        PruneCooldown          time.Duration
        GasLimitOverestimation float64
}

func (mc *MpoolConfig) Clone() *MpoolConfig {
        r := new(MpoolConfig)
        *r = *mc
        return r
}

package types

import (
        "fmt"
        "math"
        "strconv"

        "golang.org/x/xerrors"
)

// Percent stores a signed percentage as an int64. When converted to a string (or json), it's stored
// as a decimal with two places (e.g., 100% -> 1.00).
type Percent int64

func (p Percent) String() string {
        abs := p
        sign := ""
        if abs < 0 {
                abs = -abs
                sign = "-"
        }
        return fmt.Sprintf(`%s%d.%d`, sign, abs/100, abs%100)
}

func (p Percent) MarshalJSON() ([]byte, error) {
        return []byte(p.String()), nil
}

func (p *Percent) UnmarshalJSON(b []byte) error {
        flt, err := strconv.ParseFloat(string(b)+"e2", 64)
        if err != nil {
                return xerrors.Errorf("unable to parse ratio %s: %w", string(b), err)
        }
        if math.Trunc(flt) != flt {
                return xerrors.Errorf("ratio may only have two decimals: %s", string(b))
        }
        *p = Percent(flt)
        return nil
}

package types

import (
        "bytes"
        "encoding/json"

        block "github.com/ipfs/go-block-format"
        "github.com/ipfs/go-cid"

        "github.com/filecoin-project/go-state-types/abi"
        "github.com/filecoin-project/go-state-types/crypto"
)

func (sm *SignedMessage) ToStorageBlock() (block.Block, error) {
        if sm.Signature.Type == crypto.SigTypeBLS {
                return sm.Message.ToStorageBlock()
        }

        data, err := sm.Serialize()
        if err != nil {
                return nil, err
        }

        c, err := abi.CidBuilder.Sum(data)
        if err != nil {
                return nil, err
        }

        return block.NewBlockWithCid(data, c)
}

func (sm *SignedMessage) Cid() cid.Cid {
        if sm.Signature.Type == crypto.SigTypeBLS {
                return sm.Message.Cid()
        }

        sb, err := sm.ToStorageBlock()
        if err != nil {
                panic(err)
        }

        return sb.Cid()
}

type SignedMessage struct {
        Message   Message
        Signature crypto.Signature
}

func DecodeSignedMessage(data []byte) (*SignedMessage, error) {
        var msg SignedMessage
        if err := msg.UnmarshalCBOR(bytes.NewReader(data)); err != nil {
                return nil, err
        }

        return &msg, nil
}

func (sm *SignedMessage) Serialize() ([]byte, error) {
        buf := new(bytes.Buffer)
        if err := sm.MarshalCBOR(buf); err != nil {
                return nil, err
        }
        return buf.Bytes(), nil
}

type smCid struct {
        *RawSignedMessage
        CID cid.Cid
}

type RawSignedMessage SignedMessage

func (sm *SignedMessage) MarshalJSON() ([]byte, error) {
        return json.Marshal(&smCid{
                RawSignedMessage: (*RawSignedMessage)(sm),
                CID:              sm.Cid(),
        })
}

func (sm *SignedMessage) ChainLength() int {
        var ser []byte
        var err error
        if sm.Signature.Type == crypto.SigTypeBLS {
                // BLS chain message length doesn't include signature
                ser, err = sm.Message.Serialize()
        } else {
                ser, err = sm.Serialize()
        }
        if err != nil {
                panic(err)
        }
        return len(ser)
}

func (sm *SignedMessage) Size() int {
        serdata, err := sm.Serialize()
        if err != nil {
                log.Errorf("serializing message failed: %s", err)
                return 0
        }

        return len(serdata)
}

func (sm *SignedMessage) VMMessage() *Message {
        return &sm.Message
}

package types

import (
        "bytes"
        "encoding/json"
        "fmt"
        "io"
        "sort"

        "github.com/ipfs/go-cid"
        logging "github.com/ipfs/go-log/v2"
        "github.com/minio/blake2b-simd"
        cbg "github.com/whyrusleeping/cbor-gen"
        "golang.org/x/xerrors"

        "github.com/filecoin-project/go-state-types/abi"
)

var log = logging.Logger("types")

type TipSet struct {
        cids   []cid.Cid
        blks   []*BlockHeader
        height abi.ChainEpoch
}

type ExpTipSet struct {
        Cids   []cid.Cid
        Blocks []*BlockHeader
        Height abi.ChainEpoch
}

func (ts *TipSet) MarshalJSON() ([]byte, error) {
        // why didnt i just export the fields? Because the struct has methods with the
        // same names already
        return json.Marshal(ExpTipSet{
                Cids:   ts.cids,
                Blocks: ts.blks,
                Height: ts.height,
        })
}

func (ts *TipSet) UnmarshalJSON(b []byte) error {
        var ets ExpTipSet
        if err := json.Unmarshal(b, &ets); err != nil {
                return err
        }

        ots, err := NewTipSet(ets.Blocks)
        if err != nil {
                return err
        }

        *ts = *ots

        return nil
}

func (ts *TipSet) MarshalCBOR(w io.Writer) error {
        if ts == nil {
                _, err := w.Write(cbg.CborNull)
                return err
        }
        return (&ExpTipSet{
                Cids:   ts.cids,
                Blocks: ts.blks,
                Height: ts.height,
        }).MarshalCBOR(w)
}

func (ts *TipSet) UnmarshalCBOR(r io.Reader) error {
        var ets ExpTipSet
        if err := ets.UnmarshalCBOR(r); err != nil {
                return err
        }

        ots, err := NewTipSet(ets.Blocks)
        if err != nil {
                return err
        }

        *ts = *ots

        return nil
}

func tipsetSortFunc(blks []*BlockHeader) func(i, j int) bool {
        return func(i, j int) bool {
                ti := blks[i].LastTicket()
                tj := blks[j].LastTicket()

                if ti.Equals(tj) {
                        log.Warnf("blocks have same ticket (%s %s)", blks[i].Miner, blks[j].Miner)
                        return bytes.Compare(blks[i].Cid().Bytes(), blks[j].Cid().Bytes()) < 0
                }

                return ti.Less(tj)
        }
}

// Checks:
//   - A tipset is composed of at least one block. (Because of our variable
//     number of blocks per tipset, determined by randomness, we do not impose
//     an upper limit.)
//   - All blocks have the same height.
//   - All blocks have the same parents (same number of them and matching CIDs).
func NewTipSet(blks []*BlockHeader) (*TipSet, error) {
        if len(blks) == 0 {
                return nil, xerrors.Errorf("NewTipSet called with zero length array of blocks")
        }

        sort.Slice(blks, tipsetSortFunc(blks))

        var ts TipSet
        ts.cids = []cid.Cid{blks[0].Cid()}
        ts.blks = blks
        for _, b := range blks[1:] {
                if b.Height != blks[0].Height {
                        return nil, fmt.Errorf("cannot create tipset with mismatching heights")
                }

                if len(blks[0].Parents) != len(b.Parents) {
                        return nil, fmt.Errorf("cannot create tipset with mismatching number of parents")
                }

                for i, cid := range b.Parents {
                        if cid != blks[0].Parents[i] {
                                return nil, fmt.Errorf("cannot create tipset with mismatching parents")
                        }
                }

                ts.cids = append(ts.cids, b.Cid())

        }
        ts.height = blks[0].Height

        return &ts, nil
}

func (ts *TipSet) Cids() []cid.Cid {
        return ts.cids
}

func (ts *TipSet) Key() TipSetKey {
        if ts == nil {
                return EmptyTSK
        }
        return NewTipSetKey(ts.cids...)
}

func (ts *TipSet) Height() abi.ChainEpoch {
        return ts.height
}

func (ts *TipSet) Parents() TipSetKey {
        return NewTipSetKey(ts.blks[0].Parents...)
}

func (ts *TipSet) Blocks() []*BlockHeader {
        return ts.blks
}

func (ts *TipSet) Equals(ots *TipSet) bool {
        if ts == nil && ots == nil {
                return true
        }
        if ts == nil || ots == nil {
                return false
        }

        if ts.height != ots.height {
                return false
        }

        if len(ts.cids) != len(ots.cids) {
                return false
        }

        for i, cid := range ts.cids {
                if cid != ots.cids[i] {
                        return false
                }
        }

        return true
}

func (t *Ticket) Less(o *Ticket) bool {
        tDigest := blake2b.Sum256(t.VRFProof)
        oDigest := blake2b.Sum256(o.VRFProof)
        return bytes.Compare(tDigest[:], oDigest[:]) < 0
}

func (ts *TipSet) MinTicket() *Ticket {
        return ts.MinTicketBlock().Ticket
}

func (ts *TipSet) MinTimestamp() uint64 {
        if ts == nil {
                return 0
        }

        blks := ts.Blocks()

        // TODO::FVM @vyzo @magik Null rounds shouldn't ever be represented as
        //  tipsets with no blocks; Null-round generally means that the tipset at
        //  that epoch doesn't exist - and the next tipset that does exist links
        //  straight to first epoch with blocks (@raulk agrees -- this is odd)
        if len(blks) == 0 {
                // null rounds make things crash -- it is threaded in every fvm instantiation
                return 0
        }

        minTs := blks[0].Timestamp
        for _, bh := range blks[1:] {
                if bh.Timestamp < minTs {
                        minTs = bh.Timestamp
                }
        }
        return minTs
}

func (ts *TipSet) MinTicketBlock() *BlockHeader {
        blks := ts.Blocks()

        min := blks[0]

        for _, b := range blks[1:] {
                if b.LastTicket().Less(min.LastTicket()) {
                        min = b
                }
        }

        return min
}

func (ts *TipSet) ParentMessageReceipts() cid.Cid {
        return ts.blks[0].ParentMessageReceipts
}

func (ts *TipSet) ParentState() cid.Cid {
        return ts.blks[0].ParentStateRoot
}

func (ts *TipSet) ParentWeight() BigInt {
        return ts.blks[0].ParentWeight
}

func (ts *TipSet) Contains(oc cid.Cid) bool {
        for _, c := range ts.cids {
                if c == oc {
                        return true
                }
        }
        return false
}

func (ts *TipSet) IsChildOf(parent *TipSet) bool {
        return CidArrsEqual(ts.Parents().Cids(), parent.Cids()) &&
                // FIXME: The height check might go beyond what is meant by
                //  "parent", but many parts of the code rely on the tipset's
                //  height for their processing logic at the moment to obviate it.
                ts.height > parent.height
}

func (ts *TipSet) String() string {
        return fmt.Sprintf("%v", ts.cids)
}

package types

import (
        "bytes"
        "encoding/json"
        "fmt"
        "io"
        "strings"

        block "github.com/ipfs/go-block-format"
        "github.com/ipfs/go-cid"
        typegen "github.com/whyrusleeping/cbor-gen"

        "github.com/filecoin-project/go-state-types/abi"
)

var EmptyTSK = TipSetKey{}

// The length of a block header CID in bytes.
var blockHeaderCIDLen int

func init() {
        // hash a large string of zeros so we don't estimate based on inlined CIDs.
        var buf [256]byte
        c, err := abi.CidBuilder.Sum(buf[:])
        if err != nil {
                panic(err)
        }
        blockHeaderCIDLen = len(c.Bytes())
}

// A TipSetKey is an immutable collection of CIDs forming a unique key for a tipset.
// The CIDs are assumed to be distinct and in canonical order. Two keys with the same
// CIDs in a different order are not considered equal.
// TipSetKey is a lightweight value type, and may be compared for equality with ==.
type TipSetKey struct {
        // The internal representation is a concatenation of the bytes of the CIDs, which are
        // self-describing, wrapped as a string.
        // These gymnastics make the a TipSetKey usable as a map key.
        // The empty key has value "".
        value string
}

// NewTipSetKey builds a new key from a slice of CIDs.
// The CIDs are assumed to be ordered correctly.
func NewTipSetKey(cids ...cid.Cid) TipSetKey {
        encoded := encodeKey(cids)
        return TipSetKey{string(encoded)}
}

// TipSetKeyFromBytes wraps an encoded key, validating correct decoding.
func TipSetKeyFromBytes(encoded []byte) (TipSetKey, error) {
        _, err := decodeKey(encoded)
        if err != nil {
                return EmptyTSK, err
        }
        return TipSetKey{string(encoded)}, nil
}

// Cids returns a slice of the CIDs comprising this key.
func (k TipSetKey) Cids() []cid.Cid {
        cids, err := decodeKey([]byte(k.value))
        if err != nil {
                panic("invalid tipset key: " + err.Error())
        }
        return cids
}

// String() returns a human-readable representation of the key.
func (k TipSetKey) String() string {
        b := strings.Builder{}
        b.WriteString("{")
        cids := k.Cids()
        for i, c := range cids {
                b.WriteString(c.String())
                if i < len(cids)-1 {
                        b.WriteString(",")
                }
        }
        b.WriteString("}")
        return b.String()
}

// Bytes() returns a binary representation of the key.
func (k TipSetKey) Bytes() []byte {
        return []byte(k.value)
}

func (k TipSetKey) MarshalJSON() ([]byte, error) {
        return json.Marshal(k.Cids())
}

func (k *TipSetKey) UnmarshalJSON(b []byte) error {
        var cids []cid.Cid
        if err := json.Unmarshal(b, &cids); err != nil {
                return err
        }
        k.value = string(encodeKey(cids))
        return nil
}

func (k TipSetKey) Cid() (cid.Cid, error) {
        blk, err := k.ToStorageBlock()
        if err != nil {
                return cid.Cid{}, err
        }
        return blk.Cid(), nil
}

func (k TipSetKey) ToStorageBlock() (block.Block, error) {
        buf := new(bytes.Buffer)
        if err := k.MarshalCBOR(buf); err != nil {
                log.Errorf("failed to marshal ts key as CBOR: %s", k)
        }

        cid, err := abi.CidBuilder.Sum(buf.Bytes())
        if err != nil {
                return nil, err
        }

        return block.NewBlockWithCid(buf.Bytes(), cid)
}

func (k TipSetKey) MarshalCBOR(writer io.Writer) error {
        if err := typegen.WriteMajorTypeHeader(writer, typegen.MajByteString, uint64(len(k.Bytes()))); err != nil {
                return err
        }

        _, err := writer.Write(k.Bytes())
        return err
}

func (k *TipSetKey) UnmarshalCBOR(reader io.Reader) error {
        cr := typegen.NewCborReader(reader)

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

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

        b := make([]uint8, extra)

        if _, err := io.ReadFull(cr, b); err != nil {
                return err
        }

        *k, err = TipSetKeyFromBytes(b)
        return err
}

func (k TipSetKey) IsEmpty() bool {
        return len(k.value) == 0
}

func encodeKey(cids []cid.Cid) []byte {
        buffer := new(bytes.Buffer)
        for _, c := range cids {
                // bytes.Buffer.Write() err is documented to be always nil.
                _, _ = buffer.Write(c.Bytes())
        }
        return buffer.Bytes()
}

func decodeKey(encoded []byte) ([]cid.Cid, error) {
        // To avoid reallocation of the underlying array, estimate the number of CIDs to be extracted
        // by dividing the encoded length by the expected CID length.
        estimatedCount := len(encoded) / blockHeaderCIDLen
        cids := make([]cid.Cid, 0, estimatedCount)
        nextIdx := 0
        for nextIdx < len(encoded) {
                nr, c, err := cid.CidFromBytes(encoded[nextIdx:])
                if err != nil {
                        return nil, err
                }
                cids = append(cids, c)
                nextIdx += nr
        }
        return cids, nil
}

var _ typegen.CBORMarshaler = &TipSetKey{}
var _ typegen.CBORUnmarshaler = &TipSetKey{}

package addrutil

import (
        "context"
        "fmt"
        "sync"
        "time"

        "github.com/libp2p/go-libp2p/core/peer"
        ma "github.com/multiformats/go-multiaddr"
        madns "github.com/multiformats/go-multiaddr-dns"
)

// ParseAddresses is a function that takes in a slice of string peer addresses
// (multiaddr + peerid) and returns a slice of properly constructed peers
func ParseAddresses(ctx context.Context, addrs []string) ([]peer.AddrInfo, error) {
        // resolve addresses
        maddrs, err := resolveAddresses(ctx, addrs)
        if err != nil {
                return nil, err
        }

        return peer.AddrInfosFromP2pAddrs(maddrs...)
}

const (
        dnsResolveTimeout = 10 * time.Second
)

// resolveAddresses resolves addresses parallelly
func resolveAddresses(ctx context.Context, addrs []string) ([]ma.Multiaddr, error) {
        ctx, cancel := context.WithTimeout(ctx, dnsResolveTimeout)
        defer cancel()

        var maddrs []ma.Multiaddr
        var wg sync.WaitGroup
        resolveErrC := make(chan error, len(addrs))

        maddrC := make(chan ma.Multiaddr)

        for _, addr := range addrs {
                maddr, err := ma.NewMultiaddr(addr)
                if err != nil {
                        return nil, err
                }

                // check whether address ends in `ipfs/Qm...`
                if _, last := ma.SplitLast(maddr); last.Protocol().Code == ma.P_IPFS {
                        maddrs = append(maddrs, maddr)
                        continue
                }
                wg.Add(1)
                go func(maddr ma.Multiaddr) {
                        defer wg.Done()
                        raddrs, err := madns.Resolve(ctx, maddr)
                        if err != nil {
                                resolveErrC <- err
                                return
                        }
                        // filter out addresses that still doesn't end in `ipfs/Qm...`
                        found := 0
                        for _, raddr := range raddrs {
                                if _, last := ma.SplitLast(raddr); last != nil && last.Protocol().Code == ma.P_IPFS {
                                        maddrC <- raddr
                                        found++
                                }
                        }
                        if found == 0 {
                                resolveErrC <- fmt.Errorf("found no ipfs peers at %s", maddr)
                        }
                }(maddr)
        }
        go func() {
                wg.Wait()
                close(maddrC)
        }()

        for maddr := range maddrC {
                maddrs = append(maddrs, maddr)
        }

        select {
        case err := <-resolveErrC:
                return nil, err
        default:
        }

        return maddrs, nil
}

package dtypes

import (
        "context"
        "sync"

        "github.com/filecoin-project/go-address"
        "github.com/filecoin-project/go-state-types/abi"
)

type MpoolLocker struct {
        m  map[address.Address]chan struct{}
        lk sync.Mutex
}

func (ml *MpoolLocker) TakeLock(ctx context.Context, a address.Address) (func(), error) {
        ml.lk.Lock()
        if ml.m == nil {
                ml.m = make(map[address.Address]chan struct{})
        }
        lk, ok := ml.m[a]
        if !ok {
                lk = make(chan struct{}, 1)
                ml.m[a] = lk
        }
        ml.lk.Unlock()

        select {
        case lk <- struct{}{}:
        case <-ctx.Done():
                return nil, ctx.Err()
        }
        return func() {
                <-lk
        }, nil
}

type DefaultMaxFeeFunc func() (abi.TokenAmount, error)

package dtypes

import (
        "github.com/ipfs/go-cid"
)

type GCReferenceProtector interface {
        AddProtector(func(func(cid.Cid) error) error)
}

type NoopGCReferenceProtector struct{}

func (p NoopGCReferenceProtector) AddProtector(func(func(cid.Cid) error) error) {}

package dtypes

import (
        "sync"

        pubsub "github.com/libp2p/go-libp2p-pubsub"
        "github.com/libp2p/go-libp2p/core/peer"
)

type ScoreKeeper struct {
        lk     sync.Mutex
        scores map[peer.ID]*pubsub.PeerScoreSnapshot
}

func (sk *ScoreKeeper) Update(scores map[peer.ID]*pubsub.PeerScoreSnapshot) {
        sk.lk.Lock()
        sk.scores = scores
        sk.lk.Unlock()
}

func (sk *ScoreKeeper) Get() map[peer.ID]*pubsub.PeerScoreSnapshot {
        sk.lk.Lock()
        defer sk.lk.Unlock()
        return sk.scores
}