lib

package
v0.0.11 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 13, 2020 License: Apache-2.0, MIT Imports: 18 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var AccountV0State__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "AccountV0State",
	Fields: graphql.Fields{
		"Address": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: AccountV0State__Address__resolve,
		},
	},
})
View Source 
var ActorID__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "ActorID",
	Description:  "ActorID",
	Serialize:    ActorID__type__serialize,
	ParseValue:   ActorID__type__parse,
	ParseLiteral: ActorID__type__parseLiteral,
})
View Source 
var Address__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "Address",
	Description:  "Address",
	Serialize:    Address__type__serialize,
	ParseValue:   Address__type__parse,
	ParseLiteral: Address__type__parseLiteral,
})
View Source 
var Any__type = graphql.NewUnion(graphql.UnionConfig{
	Name: "Any",
	Types: []*graphql.Object{

		union__Any__Bool,

		union__Any__Int,

		union__Any__Float,

		union__Any__String,

		union__Any__Bytes,

		union__Any__Map,

		union__Any__List,

		union__Any__Link,
	},
	ResolveType: func(p graphql.ResolveTypeParams) *graphql.Object {
		if node, ok := p.Value.(ipld.Node); ok {
			switch node.Prototype() {

			case types.Type.Bool:
				fallthrough
			case types.Type.Bool__Repr:
				return union__Any__Bool

			case types.Type.Int:
				fallthrough
			case types.Type.Int__Repr:
				return union__Any__Int

			case types.Type.Float:
				fallthrough
			case types.Type.Float__Repr:
				return union__Any__Float

			case types.Type.String:
				fallthrough
			case types.Type.String__Repr:
				return union__Any__String

			case types.Type.Bytes:
				fallthrough
			case types.Type.Bytes__Repr:
				return union__Any__Bytes

			case types.Type.Map:
				fallthrough
			case types.Type.Map__Repr:
				return union__Any__Map

			case types.Type.List:
				fallthrough
			case types.Type.List__Repr:
				return union__Any__List

			case types.Type.Link:
				fallthrough
			case types.Type.Link__Repr:
				return union__Any__Link

			}
		}
		fmt.Printf("Actual type %T: %v not in union\n", p.Value, p.Value)
		return nil
	},
})
View Source 
var ApplyRewardParams__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "ApplyRewardParams",
	Fields: graphql.Fields{
		"Reward": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: ApplyRewardParams__Reward__resolve,
		},
		"Penalty": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: ApplyRewardParams__Penalty__resolve,
		},
	},
})
View Source 
var BigInt__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "BigInt",
	Description:  "BigInt",
	Serialize:    BigInt__type__serialize,
	ParseValue:   BigInt__type__parse,
	ParseLiteral: BigInt__type__parseLiteral,
})
View Source 
var BitField__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "BitField",
	Description:  "BitField",
	Serialize:    BitField__type__serialize,
	ParseValue:   BitField__type__parse,
	ParseLiteral: BitField__type__parseLiteral,
})
View Source 
var Bytes__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "Bytes",
	Description:  "Bytes",
	Serialize:    Bytes__type__serialize,
	ParseValue:   Bytes__type__parse,
	ParseLiteral: Bytes__type__parseLiteral,
})
View Source 
var ChainEpoch__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "ChainEpoch",
	Description:  "ChainEpoch",
	Serialize:    ChainEpoch__type__serialize,
	ParseValue:   ChainEpoch__type__parse,
	ParseLiteral: ChainEpoch__type__parseLiteral,
})
View Source 
var CidString__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "CidString",
	Description:  "CidString",
	Serialize:    CidString__type__serialize,
	ParseValue:   CidString__type__parse,
	ParseLiteral: CidString__type__parseLiteral,
})
View Source 
var CronV0Entry__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "CronV0Entry",
	Fields: graphql.Fields{
		"Receiver": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: CronV0Entry__Receiver__resolve,
		},
		"MethodNum": &graphql.Field{

			Type: graphql.NewNonNull(MethodNum__type),

			Resolve: CronV0Entry__MethodNum__resolve,
		},
	},
})
View Source 
var CronV0State__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "CronV0State",
	Fields: graphql.Fields{
		"Entries": &graphql.Field{

			Type: graphql.NewNonNull(List__CronV0Entry__type),

			Resolve: CronV0State__Entries__resolve,
		},
	},
})
View Source 
var DealID__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "DealID",
	Description:  "DealID",
	Serialize:    DealID__type__serialize,
	ParseValue:   DealID__type__parse,
	ParseLiteral: DealID__type__parseLiteral,
})
View Source 
var InitV0State__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "InitV0State",
	Fields: graphql.Fields{
		"AddressMap": &graphql.Field{

			Type: graphql.NewNonNull(Map__ActorID__type),

			Resolve: InitV0State__AddressMap__resolve,
		},
		"NextID": &graphql.Field{

			Type: graphql.NewNonNull(ActorID__type),

			Resolve: InitV0State__NextID__resolve,
		},
		"NetworkName": &graphql.Field{

			Type: graphql.NewNonNull(graphql.String),

			Resolve: InitV0State__NetworkName__resolve,
		},
	},
})
View Source 
var List__Address__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__Address",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: Address__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Address)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Address__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Address)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(Address__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Address)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Address)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})
View Source 
var List__ClientDealProposal__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__ClientDealProposal",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MarketClientDealProposal__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__ClientDealProposal)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(MarketClientDealProposal__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__ClientDealProposal)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(MarketClientDealProposal__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__ClientDealProposal)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__ClientDealProposal)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})
View Source 
var List__CronV0Entry__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__CronV0Entry",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: CronV0Entry__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__CronV0Entry)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(CronV0Entry__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__CronV0Entry)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(CronV0Entry__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__CronV0Entry)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__CronV0Entry)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})
View Source 
var List__DealID__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__DealID",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: DealID__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__DealID)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(DealID__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__DealID)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(DealID__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__DealID)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__DealID)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})
View Source 
var List__LinkLotusMessage__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__LinkLotusMessage",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: LotusMessage__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__LinkLotusMessage)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				if err != nil {
					return nil, err
				}
				targetCid, err := out.AsLink()
				if err != nil {
					return nil, err
				}

				var node ipld.Node

				if cl, ok := targetCid.(cidlink.Link); ok {
					v := p.Context.Value(nodeLoaderCtxKey)
					if v == nil {
						return cl.Cid, nil
					}
					loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) error)
					if !ok {
						return nil, errInvalidLoader
					}

					builder := types.Type.LotusMessage__Repr.NewBuilder()
					if err := loader(p.Context, cl, builder); err != nil {
						return nil, err
					}
					node = builder.Build()
				} else {
					return nil, errInvalidLink
				}

				return node, nil

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(LotusMessage__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__LinkLotusMessage)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					targetCid, err := node.AsLink()
					if err != nil {
						return nil, err
					}

					if cl, ok := targetCid.(cidlink.Link); ok {
						v := p.Context.Value(nodeLoaderCtxKey)
						if v == nil {
							return cl.Cid, nil
						}
						loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) error)
						if !ok {
							return nil, errInvalidLoader
						}

						builder := types.Type.LotusMessage__Repr.NewBuilder()
						if err := loader(p.Context, cl, builder); err != nil {
							return nil, err
						}
						node = builder.Build()
					} else {
						return nil, errInvalidLink
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(LotusMessage__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__LinkLotusMessage)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					targetCid, err := node.AsLink()
					if err != nil {
						return nil, err
					}

					if cl, ok := targetCid.(cidlink.Link); ok {
						v := p.Context.Value(nodeLoaderCtxKey)
						if v == nil {
							return cl.Cid, nil
						}
						loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) error)
						if !ok {
							return nil, errInvalidLoader
						}

						builder := types.Type.LotusMessage__Repr.NewBuilder()
						if err := loader(p.Context, cl, builder); err != nil {
							return nil, err
						}
						node = builder.Build()
					} else {
						return nil, errInvalidLink
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__LinkLotusMessage)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})
View Source 
var List__Link__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__Link",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: graphql.ID,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Link)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(graphql.ID),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Link)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(graphql.ID),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Link)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Link)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})
View Source 
var List__LotusBeaconEntry__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__LotusBeaconEntry",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: LotusBeaconEntry__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__LotusBeaconEntry)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(LotusBeaconEntry__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__LotusBeaconEntry)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(LotusBeaconEntry__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__LotusBeaconEntry)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__LotusBeaconEntry)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})
View Source 
var List__Merge__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__Merge",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: Merge__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Merge)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Merge__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Merge)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(Merge__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Merge)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Merge)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})
View Source 
var List__MinerExpirationExtend__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__MinerExpirationExtend",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerExpirationExtend__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerExpirationExtend)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(MinerExpirationExtend__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerExpirationExtend)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(MinerExpirationExtend__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerExpirationExtend)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerExpirationExtend)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})
View Source 
var List__MinerPoStProof__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__MinerPoStProof",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerPostProof__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerPoStProof)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(MinerPostProof__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerPoStProof)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(MinerPostProof__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerPoStProof)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerPoStProof)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})
View Source 
var List__MinerPostPartition__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__MinerPostPartition",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerPostPartition__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerPostPartition)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(MinerPostPartition__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerPostPartition)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(MinerPostPartition__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerPostPartition)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerPostPartition)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})
View Source 
var List__MinerTerminationDecl__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__MinerTerminationDecl",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerTerminationDecl__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerTerminationDecl)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(MinerTerminationDecl__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerTerminationDecl)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(MinerTerminationDecl__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerTerminationDecl)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerTerminationDecl)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})
View Source 
var List__MinerV0DeadlineLink__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__MinerV0DeadlineLink",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerV0Deadline__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV0DeadlineLink)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				if err != nil {
					return nil, err
				}
				targetCid, err := out.AsLink()
				if err != nil {
					return nil, err
				}

				var node ipld.Node

				if cl, ok := targetCid.(cidlink.Link); ok {
					v := p.Context.Value(nodeLoaderCtxKey)
					if v == nil {
						return cl.Cid, nil
					}
					loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) error)
					if !ok {
						return nil, errInvalidLoader
					}

					builder := types.Type.MinerV0Deadline__Repr.NewBuilder()
					if err := loader(p.Context, cl, builder); err != nil {
						return nil, err
					}
					node = builder.Build()
				} else {
					return nil, errInvalidLink
				}

				return node, nil

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(MinerV0Deadline__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV0DeadlineLink)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					targetCid, err := node.AsLink()
					if err != nil {
						return nil, err
					}

					if cl, ok := targetCid.(cidlink.Link); ok {
						v := p.Context.Value(nodeLoaderCtxKey)
						if v == nil {
							return cl.Cid, nil
						}
						loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) error)
						if !ok {
							return nil, errInvalidLoader
						}

						builder := types.Type.MinerV0Deadline__Repr.NewBuilder()
						if err := loader(p.Context, cl, builder); err != nil {
							return nil, err
						}
						node = builder.Build()
					} else {
						return nil, errInvalidLink
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(MinerV0Deadline__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV0DeadlineLink)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					targetCid, err := node.AsLink()
					if err != nil {
						return nil, err
					}

					if cl, ok := targetCid.(cidlink.Link); ok {
						v := p.Context.Value(nodeLoaderCtxKey)
						if v == nil {
							return cl.Cid, nil
						}
						loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) error)
						if !ok {
							return nil, errInvalidLoader
						}

						builder := types.Type.MinerV0Deadline__Repr.NewBuilder()
						if err := loader(p.Context, cl, builder); err != nil {
							return nil, err
						}
						node = builder.Build()
					} else {
						return nil, errInvalidLink
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV0DeadlineLink)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})
View Source 
var List__MinerV0VestingFund__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__MinerV0VestingFund",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerV0VestingFund__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV0VestingFund)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(MinerV0VestingFund__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV0VestingFund)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(MinerV0VestingFund__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV0VestingFund)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV0VestingFund)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})
View Source 
var List__MinerV2DeadlineLink__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__MinerV2DeadlineLink",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerV2Deadline__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV2DeadlineLink)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				if err != nil {
					return nil, err
				}
				targetCid, err := out.AsLink()
				if err != nil {
					return nil, err
				}

				var node ipld.Node

				if cl, ok := targetCid.(cidlink.Link); ok {
					v := p.Context.Value(nodeLoaderCtxKey)
					if v == nil {
						return cl.Cid, nil
					}
					loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) error)
					if !ok {
						return nil, errInvalidLoader
					}

					builder := types.Type.MinerV2Deadline__Repr.NewBuilder()
					if err := loader(p.Context, cl, builder); err != nil {
						return nil, err
					}
					node = builder.Build()
				} else {
					return nil, errInvalidLink
				}

				return node, nil

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(MinerV2Deadline__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV2DeadlineLink)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					targetCid, err := node.AsLink()
					if err != nil {
						return nil, err
					}

					if cl, ok := targetCid.(cidlink.Link); ok {
						v := p.Context.Value(nodeLoaderCtxKey)
						if v == nil {
							return cl.Cid, nil
						}
						loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) error)
						if !ok {
							return nil, errInvalidLoader
						}

						builder := types.Type.MinerV2Deadline__Repr.NewBuilder()
						if err := loader(p.Context, cl, builder); err != nil {
							return nil, err
						}
						node = builder.Build()
					} else {
						return nil, errInvalidLink
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(MinerV2Deadline__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV2DeadlineLink)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					targetCid, err := node.AsLink()
					if err != nil {
						return nil, err
					}

					if cl, ok := targetCid.(cidlink.Link); ok {
						v := p.Context.Value(nodeLoaderCtxKey)
						if v == nil {
							return cl.Cid, nil
						}
						loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) error)
						if !ok {
							return nil, errInvalidLoader
						}

						builder := types.Type.MinerV2Deadline__Repr.NewBuilder()
						if err := loader(p.Context, cl, builder); err != nil {
							return nil, err
						}
						node = builder.Build()
					} else {
						return nil, errInvalidLink
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV2DeadlineLink)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})
View Source 
var List__Multiaddrs__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__Multiaddrs",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: Multiaddr__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Multiaddrs)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Multiaddr__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Multiaddrs)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(Multiaddr__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Multiaddrs)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Multiaddrs)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})
View Source 
var List__PoStProof__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__PoStProof",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: PoStProof__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__PoStProof)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(PoStProof__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__PoStProof)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(PoStProof__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__PoStProof)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__PoStProof)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})
View Source 
var List__SectorNumber__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__SectorNumber",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: SectorNumber__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__SectorNumber)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(SectorNumber__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__SectorNumber)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(SectorNumber__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__SectorNumber)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__SectorNumber)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})
View Source 
var List__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: Any__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Any__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(Any__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})
View Source 
var LotusActorV2Head__type = graphql.NewUnion(graphql.UnionConfig{
	Name: "LotusActorV2Head",
	Types: []*graphql.Object{

		MarketV2State__type,

		MinerV2State__type,

		PowerV2State__type,

		RewardV2State__type,

		AccountV0State__type,

		CronV0State__type,

		InitV0State__type,

		MarketV0State__type,

		MinerV0State__type,

		MultisigV0State__type,

		PaychV0State__type,

		PowerV0State__type,

		RewardV0State__type,

		VerifregV0State__type,
	},
	ResolveType: func(p graphql.ResolveTypeParams) *graphql.Object {
		if node, ok := p.Value.(ipld.Node); ok {
			switch node.Prototype() {

			case types.Type.MarketV2State:
				fallthrough
			case types.Type.MarketV2State__Repr:
				return MarketV2State__type

			case types.Type.MinerV2State:
				fallthrough
			case types.Type.MinerV2State__Repr:
				return MinerV2State__type

			case types.Type.PowerV2State:
				fallthrough
			case types.Type.PowerV2State__Repr:
				return PowerV2State__type

			case types.Type.RewardV2State:
				fallthrough
			case types.Type.RewardV2State__Repr:
				return RewardV2State__type

			case types.Type.AccountV0State:
				fallthrough
			case types.Type.AccountV0State__Repr:
				return AccountV0State__type

			case types.Type.CronV0State:
				fallthrough
			case types.Type.CronV0State__Repr:
				return CronV0State__type

			case types.Type.InitV0State:
				fallthrough
			case types.Type.InitV0State__Repr:
				return InitV0State__type

			case types.Type.MarketV0State:
				fallthrough
			case types.Type.MarketV0State__Repr:
				return MarketV0State__type

			case types.Type.MinerV0State:
				fallthrough
			case types.Type.MinerV0State__Repr:
				return MinerV0State__type

			case types.Type.MultisigV0State:
				fallthrough
			case types.Type.MultisigV0State__Repr:
				return MultisigV0State__type

			case types.Type.PaychV0State:
				fallthrough
			case types.Type.PaychV0State__Repr:
				return PaychV0State__type

			case types.Type.PowerV0State:
				fallthrough
			case types.Type.PowerV0State__Repr:
				return PowerV0State__type

			case types.Type.RewardV0State:
				fallthrough
			case types.Type.RewardV0State__Repr:
				return RewardV0State__type

			case types.Type.VerifregV0State:
				fallthrough
			case types.Type.VerifregV0State__Repr:
				return VerifregV0State__type

			}
		}
		fmt.Printf("Actual type %T: %v not in union\n", p.Value, p.Value)
		return nil
	},
})
View Source 
var LotusActors__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "LotusActors",
	Fields: graphql.Fields{
		"Code": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: LotusActors__Code__resolve,
		},
		"Head": &graphql.Field{

			Type: graphql.NewNonNull(LotusActorV2Head__type),

			Resolve: LotusActors__Head__resolve,
		},
		"Nonce": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: LotusActors__Nonce__resolve,
		},
		"Balance": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: LotusActors__Balance__resolve,
		},
	},
})
View Source 
var LotusBeaconEntry__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "LotusBeaconEntry",
	Fields: graphql.Fields{
		"Round": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: LotusBeaconEntry__Round__resolve,
		},
		"Data": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: LotusBeaconEntry__Data__resolve,
		},
	},
})
View Source 
var LotusBlockHeader__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "LotusBlockHeader",
	Fields: graphql.Fields{
		"Miner": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: LotusBlockHeader__Miner__resolve,
		},
		"Ticket": &graphql.Field{

			Type: LotusTicket__type,

			Resolve: LotusBlockHeader__Ticket__resolve,
		},
		"ElectionProof": &graphql.Field{

			Type: LotusElectionProof__type,

			Resolve: LotusBlockHeader__ElectionProof__resolve,
		},
		"BeaconEntries": &graphql.Field{

			Type: graphql.NewNonNull(List__LotusBeaconEntry__type),

			Resolve: LotusBlockHeader__BeaconEntries__resolve,
		},
		"WinPoStProof": &graphql.Field{

			Type: graphql.NewNonNull(List__PoStProof__type),

			Resolve: LotusBlockHeader__WinPoStProof__resolve,
		},
		"Parents": &graphql.Field{

			Type: graphql.NewNonNull(List__Link__type),

			Resolve: LotusBlockHeader__Parents__resolve,
		},
		"ParentWeight": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: LotusBlockHeader__ParentWeight__resolve,
		},
		"Height": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: LotusBlockHeader__Height__resolve,
		},
		"ParentStateRoot": &graphql.Field{

			Type: graphql.NewNonNull(LotusStateRoot__type),

			Resolve: LotusBlockHeader__ParentStateRoot__resolve,
		},
		"ParentMessageReceipts": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: LotusBlockHeader__ParentMessageReceipts__resolve,
		},
		"Messages": &graphql.Field{

			Type: graphql.NewNonNull(LotusMsgMeta__type),

			Resolve: LotusBlockHeader__Messages__resolve,
		},
		"BLSAggregate": &graphql.Field{

			Type: Signature__type,

			Resolve: LotusBlockHeader__BLSAggregate__resolve,
		},
		"Timestamp": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: LotusBlockHeader__Timestamp__resolve,
		},
		"BlockSig": &graphql.Field{

			Type: Signature__type,

			Resolve: LotusBlockHeader__BlockSig__resolve,
		},
		"ForkSignaling": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: LotusBlockHeader__ForkSignaling__resolve,
		},
		"ParentBaseFee": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: LotusBlockHeader__ParentBaseFee__resolve,
		},
	},
})
View Source 
var LotusElectionProof__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "LotusElectionProof",
	Fields: graphql.Fields{
		"WinCount": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: LotusElectionProof__WinCount__resolve,
		},
		"VRFProof": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: LotusElectionProof__VRFProof__resolve,
		},
	},
})
View Source 
var LotusMessageV2Params__type = graphql.NewUnion(graphql.UnionConfig{
	Name: "LotusMessageV2Params",
	Types: []*graphql.Object{

		MessageParamsInitExecParams__type,

		MinerV0SectorPreCommitInfo__type,

		MessageParamsMarketWithdrawBalance__type,

		MessageParamsMarketPublishDeals__type,

		MessageParamsMarketVerifyDeals__type,

		MessageParamsMarketActivateDeals__type,

		MessageParamsMarketTerminateDeals__type,

		MessageParamsMarketComputeCommitment__type,

		MessageParamsMinerConstructor__type,

		MessageParamsMinerChangeAddress__type,

		MessageParamsMinerChangeMultiaddrs__type,

		MessageParamsMinerChangePeerID__type,

		MessageParamsMinerSubmitWindowedPoSt__type,

		MessageParamsMinerProveCommitSector__type,

		MessageParamsMinerCheckSectorProven__type,

		MessageParamsMinerConfirmSectorProofs__type,

		MessageParamsMinerExtendSectorExpiration__type,

		MessageParamsMinerTerminateSectors__type,

		MessageParamsMinerDeclareFaults__type,

		MessageParamsMinerDeclareFaultsRecovered__type,

		MessageParamsMinerCompactPartitions__type,

		MessageParamsMinerCompactSectorNumbers__type,

		ApplyRewardParams__type,

		MessageParamsMinerReportFault__type,

		MessageParamsMinerWithdrawBalance__type,

		MessageParamsMinerDeferredCron__type,

		MessageParamsMultisigConstructor__type,

		MessageParamsMultisigPropose__type,

		MessageParamsMultisigTxnID__type,

		MessageParamsMultisigAddSigner__type,

		MessageParamsMultisigRemoveSigner__type,

		MessageParamsMultisigSwapSigner__type,

		MessageParamsMultisigChangeThreshold__type,

		MessageParamsMultisigLockBalance__type,

		MessageParamsPaychConstructor__type,

		MessageParamsPaychUpdateChannelState__type,

		MessageParamsPowerCreateMiner__type,

		MessageParamsPowerUpdateClaimed__type,

		MessageParamsPowerEnrollCron__type,

		MessageParamsPowerCurrentTotal__type,

		MessageParamsRewardAwardBlock__type,

		MessageParamsVerifregAddVerifier__type,

		MessageParamsVerifregUseBytes__type,
	},
	ResolveType: func(p graphql.ResolveTypeParams) *graphql.Object {
		if node, ok := p.Value.(ipld.Node); ok {
			switch node.Prototype() {

			case types.Type.MessageParamsInitExecParams:
				fallthrough
			case types.Type.MessageParamsInitExecParams__Repr:
				return MessageParamsInitExecParams__type

			case types.Type.MinerV0SectorPreCommitInfo:
				fallthrough
			case types.Type.MinerV0SectorPreCommitInfo__Repr:
				return MinerV0SectorPreCommitInfo__type

			case types.Type.MessageParamsMarketWithdrawBalance:
				fallthrough
			case types.Type.MessageParamsMarketWithdrawBalance__Repr:
				return MessageParamsMarketWithdrawBalance__type

			case types.Type.MessageParamsMarketPublishDeals:
				fallthrough
			case types.Type.MessageParamsMarketPublishDeals__Repr:
				return MessageParamsMarketPublishDeals__type

			case types.Type.MessageParamsMarketVerifyDeals:
				fallthrough
			case types.Type.MessageParamsMarketVerifyDeals__Repr:
				return MessageParamsMarketVerifyDeals__type

			case types.Type.MessageParamsMarketActivateDeals:
				fallthrough
			case types.Type.MessageParamsMarketActivateDeals__Repr:
				return MessageParamsMarketActivateDeals__type

			case types.Type.MessageParamsMarketTerminateDeals:
				fallthrough
			case types.Type.MessageParamsMarketTerminateDeals__Repr:
				return MessageParamsMarketTerminateDeals__type

			case types.Type.MessageParamsMarketComputeCommitment:
				fallthrough
			case types.Type.MessageParamsMarketComputeCommitment__Repr:
				return MessageParamsMarketComputeCommitment__type

			case types.Type.MessageParamsMinerConstructor:
				fallthrough
			case types.Type.MessageParamsMinerConstructor__Repr:
				return MessageParamsMinerConstructor__type

			case types.Type.MessageParamsMinerChangeAddress:
				fallthrough
			case types.Type.MessageParamsMinerChangeAddress__Repr:
				return MessageParamsMinerChangeAddress__type

			case types.Type.MessageParamsMinerChangeMultiaddrs:
				fallthrough
			case types.Type.MessageParamsMinerChangeMultiaddrs__Repr:
				return MessageParamsMinerChangeMultiaddrs__type

			case types.Type.MessageParamsMinerChangePeerID:
				fallthrough
			case types.Type.MessageParamsMinerChangePeerID__Repr:
				return MessageParamsMinerChangePeerID__type

			case types.Type.MessageParamsMinerSubmitWindowedPoSt:
				fallthrough
			case types.Type.MessageParamsMinerSubmitWindowedPoSt__Repr:
				return MessageParamsMinerSubmitWindowedPoSt__type

			case types.Type.MessageParamsMinerProveCommitSector:
				fallthrough
			case types.Type.MessageParamsMinerProveCommitSector__Repr:
				return MessageParamsMinerProveCommitSector__type

			case types.Type.MessageParamsMinerCheckSectorProven:
				fallthrough
			case types.Type.MessageParamsMinerCheckSectorProven__Repr:
				return MessageParamsMinerCheckSectorProven__type

			case types.Type.MessageParamsMinerConfirmSectorProofs:
				fallthrough
			case types.Type.MessageParamsMinerConfirmSectorProofs__Repr:
				return MessageParamsMinerConfirmSectorProofs__type

			case types.Type.MessageParamsMinerExtendSectorExpiration:
				fallthrough
			case types.Type.MessageParamsMinerExtendSectorExpiration__Repr:
				return MessageParamsMinerExtendSectorExpiration__type

			case types.Type.MessageParamsMinerTerminateSectors:
				fallthrough
			case types.Type.MessageParamsMinerTerminateSectors__Repr:
				return MessageParamsMinerTerminateSectors__type

			case types.Type.MessageParamsMinerDeclareFaults:
				fallthrough
			case types.Type.MessageParamsMinerDeclareFaults__Repr:
				return MessageParamsMinerDeclareFaults__type

			case types.Type.MessageParamsMinerDeclareFaultsRecovered:
				fallthrough
			case types.Type.MessageParamsMinerDeclareFaultsRecovered__Repr:
				return MessageParamsMinerDeclareFaultsRecovered__type

			case types.Type.MessageParamsMinerCompactPartitions:
				fallthrough
			case types.Type.MessageParamsMinerCompactPartitions__Repr:
				return MessageParamsMinerCompactPartitions__type

			case types.Type.MessageParamsMinerCompactSectorNumbers:
				fallthrough
			case types.Type.MessageParamsMinerCompactSectorNumbers__Repr:
				return MessageParamsMinerCompactSectorNumbers__type

			case types.Type.ApplyRewardParams:
				fallthrough
			case types.Type.ApplyRewardParams__Repr:
				return ApplyRewardParams__type

			case types.Type.MessageParamsMinerReportFault:
				fallthrough
			case types.Type.MessageParamsMinerReportFault__Repr:
				return MessageParamsMinerReportFault__type

			case types.Type.MessageParamsMinerWithdrawBalance:
				fallthrough
			case types.Type.MessageParamsMinerWithdrawBalance__Repr:
				return MessageParamsMinerWithdrawBalance__type

			case types.Type.MessageParamsMinerDeferredCron:
				fallthrough
			case types.Type.MessageParamsMinerDeferredCron__Repr:
				return MessageParamsMinerDeferredCron__type

			case types.Type.MessageParamsMultisigConstructor:
				fallthrough
			case types.Type.MessageParamsMultisigConstructor__Repr:
				return MessageParamsMultisigConstructor__type

			case types.Type.MessageParamsMultisigPropose:
				fallthrough
			case types.Type.MessageParamsMultisigPropose__Repr:
				return MessageParamsMultisigPropose__type

			case types.Type.MessageParamsMultisigTxnID:
				fallthrough
			case types.Type.MessageParamsMultisigTxnID__Repr:
				return MessageParamsMultisigTxnID__type

			case types.Type.MessageParamsMultisigAddSigner:
				fallthrough
			case types.Type.MessageParamsMultisigAddSigner__Repr:
				return MessageParamsMultisigAddSigner__type

			case types.Type.MessageParamsMultisigRemoveSigner:
				fallthrough
			case types.Type.MessageParamsMultisigRemoveSigner__Repr:
				return MessageParamsMultisigRemoveSigner__type

			case types.Type.MessageParamsMultisigSwapSigner:
				fallthrough
			case types.Type.MessageParamsMultisigSwapSigner__Repr:
				return MessageParamsMultisigSwapSigner__type

			case types.Type.MessageParamsMultisigChangeThreshold:
				fallthrough
			case types.Type.MessageParamsMultisigChangeThreshold__Repr:
				return MessageParamsMultisigChangeThreshold__type

			case types.Type.MessageParamsMultisigLockBalance:
				fallthrough
			case types.Type.MessageParamsMultisigLockBalance__Repr:
				return MessageParamsMultisigLockBalance__type

			case types.Type.MessageParamsPaychConstructor:
				fallthrough
			case types.Type.MessageParamsPaychConstructor__Repr:
				return MessageParamsPaychConstructor__type

			case types.Type.MessageParamsPaychUpdateChannelState:
				fallthrough
			case types.Type.MessageParamsPaychUpdateChannelState__Repr:
				return MessageParamsPaychUpdateChannelState__type

			case types.Type.MessageParamsPowerCreateMiner:
				fallthrough
			case types.Type.MessageParamsPowerCreateMiner__Repr:
				return MessageParamsPowerCreateMiner__type

			case types.Type.MessageParamsPowerUpdateClaimed:
				fallthrough
			case types.Type.MessageParamsPowerUpdateClaimed__Repr:
				return MessageParamsPowerUpdateClaimed__type

			case types.Type.MessageParamsPowerEnrollCron:
				fallthrough
			case types.Type.MessageParamsPowerEnrollCron__Repr:
				return MessageParamsPowerEnrollCron__type

			case types.Type.MessageParamsPowerCurrentTotal:
				fallthrough
			case types.Type.MessageParamsPowerCurrentTotal__Repr:
				return MessageParamsPowerCurrentTotal__type

			case types.Type.MessageParamsRewardAwardBlock:
				fallthrough
			case types.Type.MessageParamsRewardAwardBlock__Repr:
				return MessageParamsRewardAwardBlock__type

			case types.Type.MessageParamsVerifregAddVerifier:
				fallthrough
			case types.Type.MessageParamsVerifregAddVerifier__Repr:
				return MessageParamsVerifregAddVerifier__type

			case types.Type.MessageParamsVerifregUseBytes:
				fallthrough
			case types.Type.MessageParamsVerifregUseBytes__Repr:
				return MessageParamsVerifregUseBytes__type

			}
		}
		fmt.Printf("Actual type %T: %v not in union\n", p.Value, p.Value)
		return nil
	},
})
View Source 
var LotusMessage__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "LotusMessage",
	Fields: graphql.Fields{
		"Version": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: LotusMessage__Version__resolve,
		},
		"To": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: LotusMessage__To__resolve,
		},
		"From": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: LotusMessage__From__resolve,
		},
		"Nonce": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: LotusMessage__Nonce__resolve,
		},
		"Value": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: LotusMessage__Value__resolve,
		},
		"GasLimit": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: LotusMessage__GasLimit__resolve,
		},
		"GasFeeCap": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: LotusMessage__GasFeeCap__resolve,
		},
		"GasPremium": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: LotusMessage__GasPremium__resolve,
		},
		"Method": &graphql.Field{

			Type: graphql.NewNonNull(MethodNum__type),

			Resolve: LotusMessage__Method__resolve,
		},
		"Params": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: LotusMessage__Params__resolve,
		},
	},
})
View Source 
var LotusMsgMeta__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "LotusMsgMeta",
	Fields: graphql.Fields{
		"BlsMessages": &graphql.Field{

			Type: graphql.NewNonNull(List__LinkLotusMessage__type),

			Resolve: LotusMsgMeta__BlsMessages__resolve,
		},
		"SecpkMessages": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: LotusMsgMeta__SecpkMessages__resolve,
		},
	},
})
View Source 
var LotusSignedMessage__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "LotusSignedMessage",
	Fields: graphql.Fields{
		"Message": &graphql.Field{

			Type: graphql.NewNonNull(LotusMessage__type),

			Resolve: LotusSignedMessage__Message__resolve,
		},
		"Signature": &graphql.Field{

			Type: graphql.NewNonNull(Signature__type),

			Resolve: LotusSignedMessage__Signature__resolve,
		},
	},
})
View Source 
var LotusStateRoot__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "LotusStateRoot",
	Fields: graphql.Fields{
		"Version": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: LotusStateRoot__Version__resolve,
		},
		"Actors": &graphql.Field{

			Type: graphql.NewNonNull(Map__LotusActors__type),

			Resolve: LotusStateRoot__Actors__resolve,
		},
		"Info": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: LotusStateRoot__Info__resolve,
		},
	},
})
View Source 
var LotusTicket__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "LotusTicket",
	Fields: graphql.Fields{
		"VRFProof": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: LotusTicket__VRFProof__resolve,
		},
	},
})
View Source 
var Map__ActorID__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__ActorID",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: ActorID__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(RawAddress__type),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__ActorID)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(RawAddress__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__ActorID)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(ActorID__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__ActorID)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__BalanceTable__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__BalanceTable",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: BigInt__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(RawAddress__type),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__BalanceTable)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(RawAddress__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__BalanceTable)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(BigInt__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__BalanceTable)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__BitField__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__BitField",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: BitField__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__BitField)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__BitField)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(BitField__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__BitField)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__DataCap__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__DataCap",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: BigInt__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(RawAddress__type),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__DataCap)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(RawAddress__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__DataCap)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(BigInt__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__DataCap)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__List__DealID__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__List__DealID",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: List__DealID__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__List__DealID)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__List__DealID)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(List__DealID__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__List__DealID)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__LotusActors__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__LotusActors",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: LotusActors__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(RawAddress__type),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__LotusActors)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(RawAddress__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__LotusActors)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(LotusActors__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__LotusActors)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__MarketV0DealProposal__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV0DealProposal",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MarketV0DealProposal__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(CidString__type),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MarketV0DealProposal)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(CidString__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MarketV0DealProposal)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MarketV0DealProposal__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MarketV0DealProposal)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__MarketV0DealState__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV0DealState",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MarketV0DealState__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MarketV0DealState)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MarketV0DealState)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MarketV0DealState__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MarketV0DealState)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__MarketV0RawDealProposal__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV0RawDealProposal",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MarketV0DealProposal__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MarketV0RawDealProposal)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MarketV0RawDealProposal)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MarketV0DealProposal__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MarketV0RawDealProposal)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__MarketV2DealProposal__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV2DealProposal",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MarketV2DealProposal__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(CidString__type),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MarketV2DealProposal)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(CidString__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MarketV2DealProposal)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MarketV2DealProposal__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MarketV2DealProposal)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__MarketV2RawDealProposal__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV2RawDealProposal",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MarketV2DealProposal__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MarketV2RawDealProposal)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MarketV2RawDealProposal)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MarketV2DealProposal__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MarketV2RawDealProposal)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__MinerV0ExpirationSet__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MinerV0ExpirationSet",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerV0ExpirationSet__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MinerV0ExpirationSet)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MinerV0ExpirationSet)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MinerV0ExpirationSet__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MinerV0ExpirationSet)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__MinerV0Partition__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MinerV0Partition",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerV0Partition__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MinerV0Partition)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MinerV0Partition)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MinerV0Partition__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MinerV0Partition)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__MinerV2Partition__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MinerV2Partition",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerV2Partition__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MinerV2Partition)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MinerV2Partition)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MinerV2Partition__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MinerV2Partition)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__MultisigV0Transaction__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MultisigV0Transaction",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MultisigV0Transaction__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MultisigV0Transaction)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MultisigV0Transaction)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MultisigV0Transaction__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__MultisigV0Transaction)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__PaychV0LaneState__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__PaychV0LaneState",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: PaychV0LaneState__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__PaychV0LaneState)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__PaychV0LaneState)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(PaychV0LaneState__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__PaychV0LaneState)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__PowerV0Claim__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__PowerV0Claim",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: PowerV0Claim__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(RawAddress__type),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__PowerV0Claim)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(RawAddress__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__PowerV0Claim)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(PowerV0Claim__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__PowerV0Claim)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__PowerV0CronEvent__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__PowerV0CronEvent",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: PowerV0CronEvent__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__PowerV0CronEvent)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__PowerV0CronEvent)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(PowerV0CronEvent__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__PowerV0CronEvent)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__PowerV2Claim__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__PowerV2Claim",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: PowerV2Claim__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(RawAddress__type),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__PowerV2Claim)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(RawAddress__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__PowerV2Claim)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(PowerV2Claim__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__PowerV2Claim)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__SectorOnChainInfo__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__SectorOnChainInfo",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerV0SectorOnChainInfo__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__SectorOnChainInfo)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__SectorOnChainInfo)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MinerV0SectorOnChainInfo__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__SectorOnChainInfo)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__SectorPreCommitOnChainInfo__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__SectorPreCommitOnChainInfo",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerV0SectorPreCommitOnChainInfo__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__SectorPreCommitOnChainInfo)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__SectorPreCommitOnChainInfo)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MinerV0SectorPreCommitOnChainInfo__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__SectorPreCommitOnChainInfo)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__SectorV2OnChainInfo__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__SectorV2OnChainInfo",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerV2SectorOnChainInfo__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__SectorV2OnChainInfo)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__SectorV2OnChainInfo)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MinerV2SectorOnChainInfo__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map__SectorV2OnChainInfo)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var Map__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: Any__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(Any__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Map)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var MarketClientDealProposal__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MarketClientDealProposal",
	Fields: graphql.Fields{
		"Proposal": &graphql.Field{

			Type: graphql.NewNonNull(MarketV2DealProposal__type),

			Resolve: MarketClientDealProposal__Proposal__resolve,
		},
		"ClientSignature": &graphql.Field{

			Type: graphql.NewNonNull(Signature__type),

			Resolve: MarketClientDealProposal__ClientSignature__resolve,
		},
	},
})
View Source 
var MarketV0DealProposal__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MarketV0DealProposal",
	Fields: graphql.Fields{
		"PieceCID": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: MarketV0DealProposal__PieceCID__resolve,
		},
		"PieceSize": &graphql.Field{

			Type: graphql.NewNonNull(PaddedPieceSize__type),

			Resolve: MarketV0DealProposal__PieceSize__resolve,
		},
		"VerifiedDeal": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Boolean),

			Resolve: MarketV0DealProposal__VerifiedDeal__resolve,
		},
		"Client": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MarketV0DealProposal__Client__resolve,
		},
		"Provider": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MarketV0DealProposal__Provider__resolve,
		},
		"Label": &graphql.Field{

			Type: graphql.NewNonNull(graphql.String),

			Resolve: MarketV0DealProposal__Label__resolve,
		},
		"StartEpoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MarketV0DealProposal__StartEpoch__resolve,
		},
		"EndEpoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MarketV0DealProposal__EndEpoch__resolve,
		},
		"StoragePricePerEpoch": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MarketV0DealProposal__StoragePricePerEpoch__resolve,
		},
		"ProviderCollateral": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MarketV0DealProposal__ProviderCollateral__resolve,
		},
		"ClientCollateral": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MarketV0DealProposal__ClientCollateral__resolve,
		},
	},
})
View Source 
var MarketV0DealState__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MarketV0DealState",
	Fields: graphql.Fields{
		"SectorStartEpoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MarketV0DealState__SectorStartEpoch__resolve,
		},
		"LastUpdatedEpoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MarketV0DealState__LastUpdatedEpoch__resolve,
		},
		"SlashEpoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MarketV0DealState__SlashEpoch__resolve,
		},
	},
})
View Source 
var MarketV0State__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MarketV0State",
	Fields: graphql.Fields{
		"Proposals": &graphql.Field{

			Type: graphql.NewNonNull(Map__MarketV0RawDealProposal__type),

			Resolve: MarketV0State__Proposals__resolve,
		},
		"States": &graphql.Field{

			Type: graphql.NewNonNull(Map__MarketV0DealState__type),

			Resolve: MarketV0State__States__resolve,
		},
		"PendingProposals": &graphql.Field{

			Type: graphql.NewNonNull(Map__MarketV0DealProposal__type),

			Resolve: MarketV0State__PendingProposals__resolve,
		},
		"EscrowTable": &graphql.Field{

			Type: graphql.NewNonNull(Map__BalanceTable__type),

			Resolve: MarketV0State__EscrowTable__resolve,
		},
		"LockedTable": &graphql.Field{

			Type: graphql.NewNonNull(Map__BalanceTable__type),

			Resolve: MarketV0State__LockedTable__resolve,
		},
		"NextID": &graphql.Field{

			Type: graphql.NewNonNull(DealID__type),

			Resolve: MarketV0State__NextID__resolve,
		},
		"DealOpsByEpoch": &graphql.Field{

			Type: graphql.NewNonNull(Map__List__DealID__type),

			Resolve: MarketV0State__DealOpsByEpoch__resolve,
		},
		"LastCron": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MarketV0State__LastCron__resolve,
		},
		"TotalClientLockedCollateral": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MarketV0State__TotalClientLockedCollateral__resolve,
		},
		"TotalProviderLockedCollateral": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MarketV0State__TotalProviderLockedCollateral__resolve,
		},
		"TotalClientStorageFee": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MarketV0State__TotalClientStorageFee__resolve,
		},
	},
})
View Source 
var MarketV2DealProposal__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MarketV2DealProposal",
	Fields: graphql.Fields{
		"PieceCID": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: MarketV2DealProposal__PieceCID__resolve,
		},
		"PieceSize": &graphql.Field{

			Type: graphql.NewNonNull(PaddedPieceSize__type),

			Resolve: MarketV2DealProposal__PieceSize__resolve,
		},
		"VerifiedDeal": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Boolean),

			Resolve: MarketV2DealProposal__VerifiedDeal__resolve,
		},
		"Client": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MarketV2DealProposal__Client__resolve,
		},
		"Provider": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MarketV2DealProposal__Provider__resolve,
		},
		"Label": &graphql.Field{

			Type: graphql.NewNonNull(graphql.String),

			Resolve: MarketV2DealProposal__Label__resolve,
		},
		"StartEpoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MarketV2DealProposal__StartEpoch__resolve,
		},
		"EndEpoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MarketV2DealProposal__EndEpoch__resolve,
		},
		"StoragePricePerEpoch": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MarketV2DealProposal__StoragePricePerEpoch__resolve,
		},
		"ProviderCollateral": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MarketV2DealProposal__ProviderCollateral__resolve,
		},
		"ClientCollateral": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MarketV2DealProposal__ClientCollateral__resolve,
		},
	},
})
View Source 
var MarketV2State__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MarketV2State",
	Fields: graphql.Fields{
		"Proposals": &graphql.Field{

			Type: graphql.NewNonNull(Map__MarketV2RawDealProposal__type),

			Resolve: MarketV2State__Proposals__resolve,
		},
		"States": &graphql.Field{

			Type: graphql.NewNonNull(Map__MarketV0DealState__type),

			Resolve: MarketV2State__States__resolve,
		},
		"PendingProposals": &graphql.Field{

			Type: graphql.NewNonNull(Map__MarketV2DealProposal__type),

			Resolve: MarketV2State__PendingProposals__resolve,
		},
		"EscrowTable": &graphql.Field{

			Type: graphql.NewNonNull(Map__BalanceTable__type),

			Resolve: MarketV2State__EscrowTable__resolve,
		},
		"LockedTable": &graphql.Field{

			Type: graphql.NewNonNull(Map__BalanceTable__type),

			Resolve: MarketV2State__LockedTable__resolve,
		},
		"NextID": &graphql.Field{

			Type: graphql.NewNonNull(DealID__type),

			Resolve: MarketV2State__NextID__resolve,
		},
		"DealOpsByEpoch": &graphql.Field{

			Type: graphql.NewNonNull(Map__List__DealID__type),

			Resolve: MarketV2State__DealOpsByEpoch__resolve,
		},
		"LastCron": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MarketV2State__LastCron__resolve,
		},
		"TotalClientLockedCollateral": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MarketV2State__TotalClientLockedCollateral__resolve,
		},
		"TotalProviderLockedCollateral": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MarketV2State__TotalProviderLockedCollateral__resolve,
		},
		"TotalClientStorageFee": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MarketV2State__TotalClientStorageFee__resolve,
		},
	},
})
View Source 
var Merge__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Merge",
	Fields: graphql.Fields{
		"Lane": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: Merge__Lane__resolve,
		},
		"Nonce": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: Merge__Nonce__resolve,
		},
	},
})
View Source 
var MessageParamsInitExecParams__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsInitExecParams",
	Fields: graphql.Fields{
		"CodeCID": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: MessageParamsInitExecParams__CodeCID__resolve,
		},
		"ConstructorParams": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: MessageParamsInitExecParams__ConstructorParams__resolve,
		},
	},
})
View Source 
var MessageParamsMarketActivateDeals__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMarketActivateDeals",
	Fields: graphql.Fields{
		"DealIDs": &graphql.Field{

			Type: graphql.NewNonNull(List__DealID__type),

			Resolve: MessageParamsMarketActivateDeals__DealIDs__resolve,
		},
		"SectorExpiry": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MessageParamsMarketActivateDeals__SectorExpiry__resolve,
		},
	},
})
View Source 
var MessageParamsMarketComputeCommitment__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMarketComputeCommitment",
	Fields: graphql.Fields{
		"DealIDs": &graphql.Field{

			Type: graphql.NewNonNull(List__DealID__type),

			Resolve: MessageParamsMarketComputeCommitment__DealIDs__resolve,
		},
		"SectorType": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: MessageParamsMarketComputeCommitment__SectorType__resolve,
		},
	},
})
View Source 
var MessageParamsMarketPublishDeals__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMarketPublishDeals",
	Fields: graphql.Fields{
		"Deals": &graphql.Field{

			Type: graphql.NewNonNull(List__ClientDealProposal__type),

			Resolve: MessageParamsMarketPublishDeals__Deals__resolve,
		},
	},
})
View Source 
var MessageParamsMarketTerminateDeals__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMarketTerminateDeals",
	Fields: graphql.Fields{
		"Epoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MessageParamsMarketTerminateDeals__Epoch__resolve,
		},
		"DealIDs": &graphql.Field{

			Type: graphql.NewNonNull(List__DealID__type),

			Resolve: MessageParamsMarketTerminateDeals__DealIDs__resolve,
		},
	},
})
View Source 
var MessageParamsMarketVerifyDeals__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMarketVerifyDeals",
	Fields: graphql.Fields{
		"DealIDs": &graphql.Field{

			Type: graphql.NewNonNull(List__DealID__type),

			Resolve: MessageParamsMarketVerifyDeals__DealIDs__resolve,
		},
		"SectorExpiry": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MessageParamsMarketVerifyDeals__SectorExpiry__resolve,
		},
		"SectorStart": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MessageParamsMarketVerifyDeals__SectorStart__resolve,
		},
	},
})
View Source 
var MessageParamsMarketWithdrawBalance__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMarketWithdrawBalance",
	Fields: graphql.Fields{
		"ProviderOrClientAmount": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MessageParamsMarketWithdrawBalance__ProviderOrClientAmount__resolve,
		},
		"Amount": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MessageParamsMarketWithdrawBalance__Amount__resolve,
		},
	},
})
View Source 
var MessageParamsMinerChangeAddress__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMinerChangeAddress",
	Fields: graphql.Fields{
		"NewWorker": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MessageParamsMinerChangeAddress__NewWorker__resolve,
		},
		"NewControlAddrs": &graphql.Field{

			Type: graphql.NewNonNull(List__Address__type),

			Resolve: MessageParamsMinerChangeAddress__NewControlAddrs__resolve,
		},
	},
})
View Source 
var MessageParamsMinerChangeMultiaddrs__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMinerChangeMultiaddrs",
	Fields: graphql.Fields{
		"NewMultiaddrs": &graphql.Field{

			Type: graphql.NewNonNull(List__Multiaddrs__type),

			Resolve: MessageParamsMinerChangeMultiaddrs__NewMultiaddrs__resolve,
		},
	},
})
View Source 
var MessageParamsMinerChangePeerID__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMinerChangePeerID",
	Fields: graphql.Fields{
		"NewID": &graphql.Field{

			Type: graphql.NewNonNull(PeerID__type),

			Resolve: MessageParamsMinerChangePeerID__NewID__resolve,
		},
	},
})
View Source 
var MessageParamsMinerCheckSectorProven__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMinerCheckSectorProven",
	Fields: graphql.Fields{
		"SectorNumber": &graphql.Field{

			Type: graphql.NewNonNull(SectorNumber__type),

			Resolve: MessageParamsMinerCheckSectorProven__SectorNumber__resolve,
		},
	},
})
View Source 
var MessageParamsMinerCompactPartitions__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMinerCompactPartitions",
	Fields: graphql.Fields{
		"Deadline": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MessageParamsMinerCompactPartitions__Deadline__resolve,
		},
		"Partitions": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MessageParamsMinerCompactPartitions__Partitions__resolve,
		},
	},
})
View Source 
var MessageParamsMinerCompactSectorNumbers__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMinerCompactSectorNumbers",
	Fields: graphql.Fields{
		"MaskSectorNumbers": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MessageParamsMinerCompactSectorNumbers__MaskSectorNumbers__resolve,
		},
	},
})
View Source 
var MessageParamsMinerConfirmSectorProofs__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMinerConfirmSectorProofs",
	Fields: graphql.Fields{
		"Sectors": &graphql.Field{

			Type: graphql.NewNonNull(List__SectorNumber__type),

			Resolve: MessageParamsMinerConfirmSectorProofs__Sectors__resolve,
		},
	},
})
View Source 
var MessageParamsMinerConstructor__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMinerConstructor",
	Fields: graphql.Fields{
		"__Exists": &graphql.Field{
			Type: graphql.Boolean,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				return true, nil
			},
		},
	},
})
View Source 
var MessageParamsMinerDeclareFaultsRecovered__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMinerDeclareFaultsRecovered",
	Fields: graphql.Fields{
		"Recoveries": &graphql.Field{

			Type: graphql.NewNonNull(List__MinerTerminationDecl__type),

			Resolve: MessageParamsMinerDeclareFaultsRecovered__Recoveries__resolve,
		},
	},
})
View Source 
var MessageParamsMinerDeclareFaults__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMinerDeclareFaults",
	Fields: graphql.Fields{
		"Faults": &graphql.Field{

			Type: graphql.NewNonNull(List__MinerTerminationDecl__type),

			Resolve: MessageParamsMinerDeclareFaults__Faults__resolve,
		},
	},
})
View Source 
var MessageParamsMinerDeferredCron__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMinerDeferredCron",
	Fields: graphql.Fields{
		"EventType": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MessageParamsMinerDeferredCron__EventType__resolve,
		},
	},
})
View Source 
var MessageParamsMinerExtendSectorExpiration__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMinerExtendSectorExpiration",
	Fields: graphql.Fields{
		"Extension": &graphql.Field{

			Type: graphql.NewNonNull(List__MinerExpirationExtend__type),

			Resolve: MessageParamsMinerExtendSectorExpiration__Extension__resolve,
		},
	},
})
View Source 
var MessageParamsMinerProveCommitSector__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMinerProveCommitSector",
	Fields: graphql.Fields{
		"SectorNumber": &graphql.Field{

			Type: graphql.NewNonNull(SectorNumber__type),

			Resolve: MessageParamsMinerProveCommitSector__SectorNumber__resolve,
		},
		"Proof": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: MessageParamsMinerProveCommitSector__Proof__resolve,
		},
	},
})
View Source 
var MessageParamsMinerReportFault__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMinerReportFault",
	Fields: graphql.Fields{
		"BlockHeader1": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: MessageParamsMinerReportFault__BlockHeader1__resolve,
		},
		"BlockHeader2": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: MessageParamsMinerReportFault__BlockHeader2__resolve,
		},
		"BlockHeaderExtra": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: MessageParamsMinerReportFault__BlockHeaderExtra__resolve,
		},
	},
})
View Source 
var MessageParamsMinerSubmitWindowedPoSt__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMinerSubmitWindowedPoSt",
	Fields: graphql.Fields{
		"Deadline": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MessageParamsMinerSubmitWindowedPoSt__Deadline__resolve,
		},
		"Partitions": &graphql.Field{

			Type: graphql.NewNonNull(List__MinerPostPartition__type),

			Resolve: MessageParamsMinerSubmitWindowedPoSt__Partitions__resolve,
		},
		"Proofs": &graphql.Field{

			Type: graphql.NewNonNull(List__MinerPoStProof__type),

			Resolve: MessageParamsMinerSubmitWindowedPoSt__Proofs__resolve,
		},
		"ChainCommitEpoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MessageParamsMinerSubmitWindowedPoSt__ChainCommitEpoch__resolve,
		},
		"ChainCommitRand": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: MessageParamsMinerSubmitWindowedPoSt__ChainCommitRand__resolve,
		},
	},
})
View Source 
var MessageParamsMinerTerminateSectors__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMinerTerminateSectors",
	Fields: graphql.Fields{
		"Terminations": &graphql.Field{

			Type: graphql.NewNonNull(List__MinerTerminationDecl__type),

			Resolve: MessageParamsMinerTerminateSectors__Terminations__resolve,
		},
	},
})
View Source 
var MessageParamsMinerWithdrawBalance__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMinerWithdrawBalance",
	Fields: graphql.Fields{
		"AmountRequested": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MessageParamsMinerWithdrawBalance__AmountRequested__resolve,
		},
	},
})
View Source 
var MessageParamsMultisigAddSigner__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMultisigAddSigner",
	Fields: graphql.Fields{
		"Signer": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MessageParamsMultisigAddSigner__Signer__resolve,
		},
		"Increase": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Boolean),

			Resolve: MessageParamsMultisigAddSigner__Increase__resolve,
		},
	},
})
View Source 
var MessageParamsMultisigChangeThreshold__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMultisigChangeThreshold",
	Fields: graphql.Fields{
		"NewThreshold": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MessageParamsMultisigChangeThreshold__NewThreshold__resolve,
		},
	},
})
View Source 
var MessageParamsMultisigConstructor__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMultisigConstructor",
	Fields: graphql.Fields{
		"Signers": &graphql.Field{

			Type: graphql.NewNonNull(List__Address__type),

			Resolve: MessageParamsMultisigConstructor__Signers__resolve,
		},
		"NumApprovalsThreshold": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MessageParamsMultisigConstructor__NumApprovalsThreshold__resolve,
		},
		"UnlockDuration": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MessageParamsMultisigConstructor__UnlockDuration__resolve,
		},
		"StartEpoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MessageParamsMultisigConstructor__StartEpoch__resolve,
		},
	},
})
View Source 
var MessageParamsMultisigLockBalance__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMultisigLockBalance",
	Fields: graphql.Fields{
		"StartEpoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MessageParamsMultisigLockBalance__StartEpoch__resolve,
		},
		"UnlockDuration": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MessageParamsMultisigLockBalance__UnlockDuration__resolve,
		},
		"Amount": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MessageParamsMultisigLockBalance__Amount__resolve,
		},
	},
})
View Source 
var MessageParamsMultisigPropose__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMultisigPropose",
	Fields: graphql.Fields{
		"To": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MessageParamsMultisigPropose__To__resolve,
		},
		"Value": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MessageParamsMultisigPropose__Value__resolve,
		},
		"Method": &graphql.Field{

			Type: graphql.NewNonNull(MethodNum__type),

			Resolve: MessageParamsMultisigPropose__Method__resolve,
		},
		"Params": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: MessageParamsMultisigPropose__Params__resolve,
		},
	},
})
View Source 
var MessageParamsMultisigRemoveSigner__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMultisigRemoveSigner",
	Fields: graphql.Fields{
		"Signer": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MessageParamsMultisigRemoveSigner__Signer__resolve,
		},
		"Decrease": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Boolean),

			Resolve: MessageParamsMultisigRemoveSigner__Decrease__resolve,
		},
	},
})
View Source 
var MessageParamsMultisigSwapSigner__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMultisigSwapSigner",
	Fields: graphql.Fields{
		"From": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MessageParamsMultisigSwapSigner__From__resolve,
		},
		"To": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MessageParamsMultisigSwapSigner__To__resolve,
		},
	},
})
View Source 
var MessageParamsMultisigTxnID__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsMultisigTxnID",
	Fields: graphql.Fields{
		"ID": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MessageParamsMultisigTxnID__ID__resolve,
		},
		"ProposeHash": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: MessageParamsMultisigTxnID__ProposeHash__resolve,
		},
	},
})
View Source 
var MessageParamsPaychConstructor__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsPaychConstructor",
	Fields: graphql.Fields{
		"From": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MessageParamsPaychConstructor__From__resolve,
		},
		"To": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MessageParamsPaychConstructor__To__resolve,
		},
	},
})
View Source 
var MessageParamsPaychUpdateChannelState__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsPaychUpdateChannelState",
	Fields: graphql.Fields{
		"Sv": &graphql.Field{

			Type: graphql.NewNonNull(SignedVoucher__type),

			Resolve: MessageParamsPaychUpdateChannelState__Sv__resolve,
		},
		"Secret": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: MessageParamsPaychUpdateChannelState__Secret__resolve,
		},
	},
})
View Source 
var MessageParamsPowerCreateMiner__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsPowerCreateMiner",
	Fields: graphql.Fields{
		"Owner": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MessageParamsPowerCreateMiner__Owner__resolve,
		},
		"Worker": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MessageParamsPowerCreateMiner__Worker__resolve,
		},
		"SealProofType": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MessageParamsPowerCreateMiner__SealProofType__resolve,
		},
		"Peer": &graphql.Field{

			Type: graphql.NewNonNull(PeerID__type),

			Resolve: MessageParamsPowerCreateMiner__Peer__resolve,
		},
		"Multiaddrs": &graphql.Field{

			Type: graphql.NewNonNull(List__Multiaddrs__type),

			Resolve: MessageParamsPowerCreateMiner__Multiaddrs__resolve,
		},
	},
})
View Source 
var MessageParamsPowerCurrentTotal__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsPowerCurrentTotal",
	Fields: graphql.Fields{
		"RawBytePower": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MessageParamsPowerCurrentTotal__RawBytePower__resolve,
		},
		"QualityAdjPower": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MessageParamsPowerCurrentTotal__QualityAdjPower__resolve,
		},
		"PledgeCollateral": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MessageParamsPowerCurrentTotal__PledgeCollateral__resolve,
		},
		"QualityAdjPowerSmoothed": &graphql.Field{

			Type: graphql.NewNonNull(V0FilterEstimate__type),

			Resolve: MessageParamsPowerCurrentTotal__QualityAdjPowerSmoothed__resolve,
		},
	},
})
View Source 
var MessageParamsPowerEnrollCron__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsPowerEnrollCron",
	Fields: graphql.Fields{
		"EventEpoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MessageParamsPowerEnrollCron__EventEpoch__resolve,
		},
		"Payload": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: MessageParamsPowerEnrollCron__Payload__resolve,
		},
	},
})
View Source 
var MessageParamsPowerUpdateClaimed__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsPowerUpdateClaimed",
	Fields: graphql.Fields{
		"RawByteDelta": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MessageParamsPowerUpdateClaimed__RawByteDelta__resolve,
		},
		"QualityAdjustedDelta": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MessageParamsPowerUpdateClaimed__QualityAdjustedDelta__resolve,
		},
	},
})
View Source 
var MessageParamsRewardAwardBlock__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsRewardAwardBlock",
	Fields: graphql.Fields{
		"Miner": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MessageParamsRewardAwardBlock__Miner__resolve,
		},
		"Penalty": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MessageParamsRewardAwardBlock__Penalty__resolve,
		},
		"GasReward": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MessageParamsRewardAwardBlock__GasReward__resolve,
		},
		"WinCount": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MessageParamsRewardAwardBlock__WinCount__resolve,
		},
	},
})
View Source 
var MessageParamsVerifregAddVerifier__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsVerifregAddVerifier",
	Fields: graphql.Fields{
		"Address": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MessageParamsVerifregAddVerifier__Address__resolve,
		},
		"Allowance": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MessageParamsVerifregAddVerifier__Allowance__resolve,
		},
	},
})
View Source 
var MessageParamsVerifregUseBytes__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MessageParamsVerifregUseBytes",
	Fields: graphql.Fields{
		"Address": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MessageParamsVerifregUseBytes__Address__resolve,
		},
		"DealSize": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MessageParamsVerifregUseBytes__DealSize__resolve,
		},
	},
})
View Source 
var MethodNum__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "MethodNum",
	Description:  "MethodNum",
	Serialize:    MethodNum__type__serialize,
	ParseValue:   MethodNum__type__parse,
	ParseLiteral: MethodNum__type__parseLiteral,
})
View Source 
var MinerExpirationExtend__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerExpirationExtend",
	Fields: graphql.Fields{
		"Deadline": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerExpirationExtend__Deadline__resolve,
		},
		"Partition": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerExpirationExtend__Partition__resolve,
		},
		"Sectors": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerExpirationExtend__Sectors__resolve,
		},
		"NewExpiration": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MinerExpirationExtend__NewExpiration__resolve,
		},
	},
})
View Source 
var MinerPostPartition__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerPostPartition",
	Fields: graphql.Fields{
		"Index": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerPostPartition__Index__resolve,
		},
		"Skipped": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerPostPartition__Skipped__resolve,
		},
	},
})
View Source 
var MinerPostProof__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerPostProof",
	Fields: graphql.Fields{
		"PoStProof": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerPostProof__PoStProof__resolve,
		},
		"ProofBytes": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: MinerPostProof__ProofBytes__resolve,
		},
	},
})
View Source 
var MinerTerminationDecl__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerTerminationDecl",
	Fields: graphql.Fields{
		"Deadline": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerTerminationDecl__Deadline__resolve,
		},
		"Partition": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerTerminationDecl__Partition__resolve,
		},
		"Sectors": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerTerminationDecl__Sectors__resolve,
		},
	},
})
View Source 
var MinerV0Deadline__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerV0Deadline",
	Fields: graphql.Fields{
		"Partitions": &graphql.Field{

			Type: graphql.NewNonNull(Map__MinerV0Partition__type),

			Resolve: MinerV0Deadline__Partitions__resolve,
		},
		"ExpirationEpochs": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: MinerV0Deadline__ExpirationEpochs__resolve,
		},
		"PostSubmissions": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerV0Deadline__PostSubmissions__resolve,
		},
		"EarlyTerminations": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerV0Deadline__EarlyTerminations__resolve,
		},
		"LiveSectors": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerV0Deadline__LiveSectors__resolve,
		},
		"TotalSectors": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerV0Deadline__TotalSectors__resolve,
		},
		"FaultyPower": &graphql.Field{

			Type: graphql.NewNonNull(MinerV0PowerPair__type),

			Resolve: MinerV0Deadline__FaultyPower__resolve,
		},
	},
})
View Source 
var MinerV0Deadlines__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerV0Deadlines",
	Fields: graphql.Fields{
		"Due": &graphql.Field{

			Type: graphql.NewNonNull(List__MinerV0DeadlineLink__type),

			Resolve: MinerV0Deadlines__Due__resolve,
		},
	},
})
View Source 
var MinerV0ExpirationSet__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerV0ExpirationSet",
	Fields: graphql.Fields{
		"OnTimeSectors": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerV0ExpirationSet__OnTimeSectors__resolve,
		},
		"EarlySectors": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerV0ExpirationSet__EarlySectors__resolve,
		},
		"OnTimePledge": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV0ExpirationSet__OnTimePledge__resolve,
		},
		"ActivePower": &graphql.Field{

			Type: graphql.NewNonNull(MinerV0PowerPair__type),

			Resolve: MinerV0ExpirationSet__ActivePower__resolve,
		},
		"FaultyPower": &graphql.Field{

			Type: graphql.NewNonNull(MinerV0PowerPair__type),

			Resolve: MinerV0ExpirationSet__FaultyPower__resolve,
		},
	},
})
View Source 
var MinerV0Info__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerV0Info",
	Fields: graphql.Fields{
		"Owner": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MinerV0Info__Owner__resolve,
		},
		"Worker": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MinerV0Info__Worker__resolve,
		},
		"ControlAddresses": &graphql.Field{

			Type: List__Address__type,

			Resolve: MinerV0Info__ControlAddresses__resolve,
		},
		"PendingWorkerKey": &graphql.Field{

			Type: MinerV0WorkerChangeKey__type,

			Resolve: MinerV0Info__PendingWorkerKey__resolve,
		},
		"PeerId": &graphql.Field{

			Type: graphql.NewNonNull(PeerID__type),

			Resolve: MinerV0Info__PeerId__resolve,
		},
		"Multiaddrs": &graphql.Field{

			Type: List__Multiaddrs__type,

			Resolve: MinerV0Info__Multiaddrs__resolve,
		},
		"SealProofType": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerV0Info__SealProofType__resolve,
		},
		"SectorSize": &graphql.Field{

			Type: graphql.NewNonNull(SectorSize__type),

			Resolve: MinerV0Info__SectorSize__resolve,
		},
		"WindowPoStPartitionSectors": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerV0Info__WindowPoStPartitionSectors__resolve,
		},
	},
})
View Source 
var MinerV0Partition__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerV0Partition",
	Fields: graphql.Fields{
		"Sectors": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerV0Partition__Sectors__resolve,
		},
		"Faults": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerV0Partition__Faults__resolve,
		},
		"Recoveries": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerV0Partition__Recoveries__resolve,
		},
		"Terminated": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerV0Partition__Terminated__resolve,
		},
		"ExpirationsEpochs": &graphql.Field{

			Type: graphql.NewNonNull(Map__MinerV0ExpirationSet__type),

			Resolve: MinerV0Partition__ExpirationsEpochs__resolve,
		},
		"EarlyTerminated": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: MinerV0Partition__EarlyTerminated__resolve,
		},
		"LivePower": &graphql.Field{

			Type: graphql.NewNonNull(MinerV0PowerPair__type),

			Resolve: MinerV0Partition__LivePower__resolve,
		},
		"FaultyPower": &graphql.Field{

			Type: graphql.NewNonNull(MinerV0PowerPair__type),

			Resolve: MinerV0Partition__FaultyPower__resolve,
		},
		"RecoveringPower": &graphql.Field{

			Type: graphql.NewNonNull(MinerV0PowerPair__type),

			Resolve: MinerV0Partition__RecoveringPower__resolve,
		},
	},
})
View Source 
var MinerV0PowerPair__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerV0PowerPair",
	Fields: graphql.Fields{
		"Raw": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV0PowerPair__Raw__resolve,
		},
		"QA": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV0PowerPair__QA__resolve,
		},
	},
})
View Source 
var MinerV0SectorOnChainInfo__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerV0SectorOnChainInfo",
	Fields: graphql.Fields{
		"SectorNumber": &graphql.Field{

			Type: graphql.NewNonNull(SectorNumber__type),

			Resolve: MinerV0SectorOnChainInfo__SectorNumber__resolve,
		},
		"SealProof": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerV0SectorOnChainInfo__SealProof__resolve,
		},
		"SealedCID": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: MinerV0SectorOnChainInfo__SealedCID__resolve,
		},
		"DealIDs": &graphql.Field{

			Type: graphql.NewNonNull(List__DealID__type),

			Resolve: MinerV0SectorOnChainInfo__DealIDs__resolve,
		},
		"Activation": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MinerV0SectorOnChainInfo__Activation__resolve,
		},
		"Expiration": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MinerV0SectorOnChainInfo__Expiration__resolve,
		},
		"DealWeight": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV0SectorOnChainInfo__DealWeight__resolve,
		},
		"VerifiedDealWeight": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV0SectorOnChainInfo__VerifiedDealWeight__resolve,
		},
		"InitialPledge": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV0SectorOnChainInfo__InitialPledge__resolve,
		},
		"ExpectedDayReward": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV0SectorOnChainInfo__ExpectedDayReward__resolve,
		},
		"ExpectedStorageReward": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV0SectorOnChainInfo__ExpectedStorageReward__resolve,
		},
	},
})
View Source 
var MinerV0SectorPreCommitInfo__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerV0SectorPreCommitInfo",
	Fields: graphql.Fields{
		"SealProof": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerV0SectorPreCommitInfo__SealProof__resolve,
		},
		"SectorNumber": &graphql.Field{

			Type: graphql.NewNonNull(SectorNumber__type),

			Resolve: MinerV0SectorPreCommitInfo__SectorNumber__resolve,
		},
		"SealedCID": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: MinerV0SectorPreCommitInfo__SealedCID__resolve,
		},
		"SealRandEpoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MinerV0SectorPreCommitInfo__SealRandEpoch__resolve,
		},
		"DealIDs": &graphql.Field{

			Type: List__DealID__type,

			Resolve: MinerV0SectorPreCommitInfo__DealIDs__resolve,
		},
		"Expiration": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MinerV0SectorPreCommitInfo__Expiration__resolve,
		},
		"ReplaceCapacity": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Boolean),

			Resolve: MinerV0SectorPreCommitInfo__ReplaceCapacity__resolve,
		},
		"ReplaceSectorDeadline": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerV0SectorPreCommitInfo__ReplaceSectorDeadline__resolve,
		},
		"ReplaceSectorPartition": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerV0SectorPreCommitInfo__ReplaceSectorPartition__resolve,
		},
		"ReplaceSectorNumber": &graphql.Field{

			Type: graphql.NewNonNull(SectorNumber__type),

			Resolve: MinerV0SectorPreCommitInfo__ReplaceSectorNumber__resolve,
		},
	},
})
View Source 
var MinerV0SectorPreCommitOnChainInfo__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerV0SectorPreCommitOnChainInfo",
	Fields: graphql.Fields{
		"Info": &graphql.Field{

			Type: graphql.NewNonNull(MinerV0SectorPreCommitInfo__type),

			Resolve: MinerV0SectorPreCommitOnChainInfo__Info__resolve,
		},
		"PreCommitDeposit": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV0SectorPreCommitOnChainInfo__PreCommitDeposit__resolve,
		},
		"PreCommitEpoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MinerV0SectorPreCommitOnChainInfo__PreCommitEpoch__resolve,
		},
		"DealWeight": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV0SectorPreCommitOnChainInfo__DealWeight__resolve,
		},
		"VerifiedDealWeight": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV0SectorPreCommitOnChainInfo__VerifiedDealWeight__resolve,
		},
	},
})
View Source 
var MinerV0State__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerV0State",
	Fields: graphql.Fields{
		"Info": &graphql.Field{

			Type: graphql.NewNonNull(MinerV0Info__type),

			Resolve: MinerV0State__Info__resolve,
		},
		"PreCommitDeposits": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV0State__PreCommitDeposits__resolve,
		},
		"LockedFunds": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV0State__LockedFunds__resolve,
		},
		"VestingFunds": &graphql.Field{

			Type: graphql.NewNonNull(MinerV0VestingFunds__type),

			Resolve: MinerV0State__VestingFunds__resolve,
		},
		"InitialPledgeRequirement": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV0State__InitialPledgeRequirement__resolve,
		},
		"PreCommittedSectors": &graphql.Field{

			Type: graphql.NewNonNull(Map__SectorPreCommitOnChainInfo__type),

			Resolve: MinerV0State__PreCommittedSectors__resolve,
		},
		"PreCommittedSectorsExpiry": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: MinerV0State__PreCommittedSectorsExpiry__resolve,
		},
		"AllocatedSectors": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerV0State__AllocatedSectors__resolve,
		},
		"Sectors": &graphql.Field{

			Type: graphql.NewNonNull(Map__SectorOnChainInfo__type),

			Resolve: MinerV0State__Sectors__resolve,
		},
		"ProvingPeriodStart": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MinerV0State__ProvingPeriodStart__resolve,
		},
		"CurrentDeadline": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerV0State__CurrentDeadline__resolve,
		},
		"Deadlines": &graphql.Field{

			Type: graphql.NewNonNull(MinerV0Deadlines__type),

			Resolve: MinerV0State__Deadlines__resolve,
		},
		"EarlyTerminations": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerV0State__EarlyTerminations__resolve,
		},
	},
})
View Source 
var MinerV0VestingFund__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerV0VestingFund",
	Fields: graphql.Fields{
		"Epoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MinerV0VestingFund__Epoch__resolve,
		},
		"Amount": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV0VestingFund__Amount__resolve,
		},
	},
})
View Source 
var MinerV0VestingFunds__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerV0VestingFunds",
	Fields: graphql.Fields{
		"Funds": &graphql.Field{

			Type: graphql.NewNonNull(List__MinerV0VestingFund__type),

			Resolve: MinerV0VestingFunds__Funds__resolve,
		},
	},
})
View Source 
var MinerV0WorkerChangeKey__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerV0WorkerChangeKey",
	Fields: graphql.Fields{
		"NewWorker": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MinerV0WorkerChangeKey__NewWorker__resolve,
		},
		"EffectiveAt": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MinerV0WorkerChangeKey__EffectiveAt__resolve,
		},
	},
})
View Source 
var MinerV2Deadline__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerV2Deadline",
	Fields: graphql.Fields{
		"Partitions": &graphql.Field{

			Type: graphql.NewNonNull(Map__MinerV2Partition__type),

			Resolve: MinerV2Deadline__Partitions__resolve,
		},
		"ExpirationEpochs": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: MinerV2Deadline__ExpirationEpochs__resolve,
		},
		"PostSubmissions": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerV2Deadline__PostSubmissions__resolve,
		},
		"EarlyTerminations": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerV2Deadline__EarlyTerminations__resolve,
		},
		"LiveSectors": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerV2Deadline__LiveSectors__resolve,
		},
		"TotalSectors": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerV2Deadline__TotalSectors__resolve,
		},
		"FaultyPower": &graphql.Field{

			Type: graphql.NewNonNull(MinerV0PowerPair__type),

			Resolve: MinerV2Deadline__FaultyPower__resolve,
		},
	},
})
View Source 
var MinerV2Deadlines__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerV2Deadlines",
	Fields: graphql.Fields{
		"Due": &graphql.Field{

			Type: graphql.NewNonNull(List__MinerV2DeadlineLink__type),

			Resolve: MinerV2Deadlines__Due__resolve,
		},
	},
})
View Source 
var MinerV2Info__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerV2Info",
	Fields: graphql.Fields{
		"Owner": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MinerV2Info__Owner__resolve,
		},
		"Worker": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MinerV2Info__Worker__resolve,
		},
		"ControlAddresses": &graphql.Field{

			Type: List__Address__type,

			Resolve: MinerV2Info__ControlAddresses__resolve,
		},
		"PendingWorkerKey": &graphql.Field{

			Type: MinerV0WorkerChangeKey__type,

			Resolve: MinerV2Info__PendingWorkerKey__resolve,
		},
		"PeerId": &graphql.Field{

			Type: graphql.NewNonNull(PeerID__type),

			Resolve: MinerV2Info__PeerId__resolve,
		},
		"Multiaddrs": &graphql.Field{

			Type: List__Multiaddrs__type,

			Resolve: MinerV2Info__Multiaddrs__resolve,
		},
		"SealProofType": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerV2Info__SealProofType__resolve,
		},
		"SectorSize": &graphql.Field{

			Type: graphql.NewNonNull(SectorSize__type),

			Resolve: MinerV2Info__SectorSize__resolve,
		},
		"WindowPoStPartitionSectors": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerV2Info__WindowPoStPartitionSectors__resolve,
		},
		"ConsensusFaultElapsed": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MinerV2Info__ConsensusFaultElapsed__resolve,
		},
		"PendingOwnerAddress": &graphql.Field{

			Type: Address__type,

			Resolve: MinerV2Info__PendingOwnerAddress__resolve,
		},
	},
})
View Source 
var MinerV2Partition__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerV2Partition",
	Fields: graphql.Fields{
		"Sectors": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerV2Partition__Sectors__resolve,
		},
		"Unproven": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerV2Partition__Unproven__resolve,
		},
		"Faults": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerV2Partition__Faults__resolve,
		},
		"Recoveries": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerV2Partition__Recoveries__resolve,
		},
		"Terminated": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerV2Partition__Terminated__resolve,
		},
		"ExpirationsEpochs": &graphql.Field{

			Type: graphql.NewNonNull(Map__MinerV0ExpirationSet__type),

			Resolve: MinerV2Partition__ExpirationsEpochs__resolve,
		},
		"EarlyTerminated": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: MinerV2Partition__EarlyTerminated__resolve,
		},
		"LivePower": &graphql.Field{

			Type: graphql.NewNonNull(MinerV0PowerPair__type),

			Resolve: MinerV2Partition__LivePower__resolve,
		},
		"UnprovenPower": &graphql.Field{

			Type: graphql.NewNonNull(MinerV0PowerPair__type),

			Resolve: MinerV2Partition__UnprovenPower__resolve,
		},
		"FaultyPower": &graphql.Field{

			Type: graphql.NewNonNull(MinerV0PowerPair__type),

			Resolve: MinerV2Partition__FaultyPower__resolve,
		},
		"RecoveringPower": &graphql.Field{

			Type: graphql.NewNonNull(MinerV0PowerPair__type),

			Resolve: MinerV2Partition__RecoveringPower__resolve,
		},
	},
})
View Source 
var MinerV2SectorOnChainInfo__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerV2SectorOnChainInfo",
	Fields: graphql.Fields{
		"SectorNumber": &graphql.Field{

			Type: graphql.NewNonNull(SectorNumber__type),

			Resolve: MinerV2SectorOnChainInfo__SectorNumber__resolve,
		},
		"SealProof": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerV2SectorOnChainInfo__SealProof__resolve,
		},
		"SealedCID": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: MinerV2SectorOnChainInfo__SealedCID__resolve,
		},
		"DealIDs": &graphql.Field{

			Type: graphql.NewNonNull(List__DealID__type),

			Resolve: MinerV2SectorOnChainInfo__DealIDs__resolve,
		},
		"Activation": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MinerV2SectorOnChainInfo__Activation__resolve,
		},
		"Expiration": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MinerV2SectorOnChainInfo__Expiration__resolve,
		},
		"DealWeight": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV2SectorOnChainInfo__DealWeight__resolve,
		},
		"VerifiedDealWeight": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV2SectorOnChainInfo__VerifiedDealWeight__resolve,
		},
		"InitialPledge": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV2SectorOnChainInfo__InitialPledge__resolve,
		},
		"ExpectedDayReward": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV2SectorOnChainInfo__ExpectedDayReward__resolve,
		},
		"ExpectedStorageReward": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV2SectorOnChainInfo__ExpectedStorageReward__resolve,
		},
		"ReplacedSectorAge": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MinerV2SectorOnChainInfo__ReplacedSectorAge__resolve,
		},
		"ReplacedDayReward": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV2SectorOnChainInfo__ReplacedDayReward__resolve,
		},
	},
})
View Source 
var MinerV2State__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MinerV2State",
	Fields: graphql.Fields{
		"Info": &graphql.Field{

			Type: graphql.NewNonNull(MinerV2Info__type),

			Resolve: MinerV2State__Info__resolve,
		},
		"PreCommitDeposits": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV2State__PreCommitDeposits__resolve,
		},
		"LockedFunds": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV2State__LockedFunds__resolve,
		},
		"VestingFunds": &graphql.Field{

			Type: graphql.NewNonNull(MinerV0VestingFunds__type),

			Resolve: MinerV2State__VestingFunds__resolve,
		},
		"FeeDebt": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV2State__FeeDebt__resolve,
		},
		"InitialPledge": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MinerV2State__InitialPledge__resolve,
		},
		"PreCommittedSectors": &graphql.Field{

			Type: graphql.NewNonNull(Map__SectorPreCommitOnChainInfo__type),

			Resolve: MinerV2State__PreCommittedSectors__resolve,
		},
		"PreCommittedSectorsExpiry": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: MinerV2State__PreCommittedSectorsExpiry__resolve,
		},
		"AllocatedSectors": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerV2State__AllocatedSectors__resolve,
		},
		"Sectors": &graphql.Field{

			Type: graphql.NewNonNull(Map__SectorV2OnChainInfo__type),

			Resolve: MinerV2State__Sectors__resolve,
		},
		"ProvingPeriodStart": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MinerV2State__ProvingPeriodStart__resolve,
		},
		"CurrentDeadline": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MinerV2State__CurrentDeadline__resolve,
		},
		"Deadlines": &graphql.Field{

			Type: graphql.NewNonNull(MinerV2Deadlines__type),

			Resolve: MinerV2State__Deadlines__resolve,
		},
		"EarlyTerminations": &graphql.Field{

			Type: graphql.NewNonNull(BitField__type),

			Resolve: MinerV2State__EarlyTerminations__resolve,
		},
	},
})
View Source 
var ModVerifyParams__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "ModVerifyParams",
	Fields: graphql.Fields{
		"Method": &graphql.Field{

			Type: graphql.NewNonNull(MethodNum__type),

			Resolve: ModVerifyParams__Method__resolve,
		},
		"Params": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: ModVerifyParams__Params__resolve,
		},
	},
})
View Source 
var Multiaddr__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "Multiaddr",
	Description:  "Multiaddr",
	Serialize:    Multiaddr__type__serialize,
	ParseValue:   Multiaddr__type__parse,
	ParseLiteral: Multiaddr__type__parseLiteral,
})
View Source 
var Multimap__PowerV0CronEvent__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Multimap__PowerV0CronEvent",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: Map__PowerV0CronEvent__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Multimap__PowerV0CronEvent)
				if !ok {
					return nil, errNotNode
				}
				arg := p.Args["key"]

				switch ta := arg.(type) {
				case ipld.Node:
					return ts.LookupByNode(ta)
				case string:
					return ts.LookupByString(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}
			},
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Multimap__PowerV0CronEvent)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(Map__PowerV0CronEvent__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.Multimap__PowerV0CronEvent)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
	},
})
View Source 
var MultisigV0State__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MultisigV0State",
	Fields: graphql.Fields{
		"Signers": &graphql.Field{

			Type: graphql.NewNonNull(List__Address__type),

			Resolve: MultisigV0State__Signers__resolve,
		},
		"NumApprovalsThreshold": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MultisigV0State__NumApprovalsThreshold__resolve,
		},
		"NextTxnID": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: MultisigV0State__NextTxnID__resolve,
		},
		"InitialBalance": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MultisigV0State__InitialBalance__resolve,
		},
		"StartEpoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MultisigV0State__StartEpoch__resolve,
		},
		"UnlockDuration": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: MultisigV0State__UnlockDuration__resolve,
		},
		"PendingTxns": &graphql.Field{

			Type: graphql.NewNonNull(Map__MultisigV0Transaction__type),

			Resolve: MultisigV0State__PendingTxns__resolve,
		},
	},
})
View Source 
var MultisigV0Transaction__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MultisigV0Transaction",
	Fields: graphql.Fields{
		"To": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: MultisigV0Transaction__To__resolve,
		},
		"Value": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: MultisigV0Transaction__Value__resolve,
		},
		"Method": &graphql.Field{

			Type: graphql.NewNonNull(MethodNum__type),

			Resolve: MultisigV0Transaction__Method__resolve,
		},
		"Params": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: MultisigV0Transaction__Params__resolve,
		},
		"Approved": &graphql.Field{

			Type: graphql.NewNonNull(List__Address__type),

			Resolve: MultisigV0Transaction__Approved__resolve,
		},
	},
})
View Source 
var PaddedPieceSize__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "PaddedPieceSize",
	Description:  "PaddedPieceSize",
	Serialize:    PaddedPieceSize__type__serialize,
	ParseValue:   PaddedPieceSize__type__parse,
	ParseLiteral: PaddedPieceSize__type__parseLiteral,
})
View Source 
var PaychV0LaneState__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "PaychV0LaneState",
	Fields: graphql.Fields{
		"Redeemed": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PaychV0LaneState__Redeemed__resolve,
		},
		"Nonce": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: PaychV0LaneState__Nonce__resolve,
		},
	},
})
View Source 
var PaychV0State__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "PaychV0State",
	Fields: graphql.Fields{
		"From": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: PaychV0State__From__resolve,
		},
		"To": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: PaychV0State__To__resolve,
		},
		"ToSend": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PaychV0State__ToSend__resolve,
		},
		"SettlingAt": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: PaychV0State__SettlingAt__resolve,
		},
		"MinSettleHeight": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: PaychV0State__MinSettleHeight__resolve,
		},
		"LaneStates": &graphql.Field{

			Type: graphql.NewNonNull(Map__PaychV0LaneState__type),

			Resolve: PaychV0State__LaneStates__resolve,
		},
	},
})
View Source 
var PeerID__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "PeerID",
	Description:  "PeerID",
	Serialize:    PeerID__type__serialize,
	ParseValue:   PeerID__type__parse,
	ParseLiteral: PeerID__type__parseLiteral,
})
View Source 
var PoStProof__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "PoStProof",
	Fields: graphql.Fields{
		"PoStProof": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: PoStProof__PoStProof__resolve,
		},
		"ProofBytes": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: PoStProof__ProofBytes__resolve,
		},
	},
})
View Source 
var PowerV0Claim__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "PowerV0Claim",
	Fields: graphql.Fields{
		"RawBytePower": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PowerV0Claim__RawBytePower__resolve,
		},
		"QualityAdjPower": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PowerV0Claim__QualityAdjPower__resolve,
		},
	},
})
View Source 
var PowerV0CronEvent__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "PowerV0CronEvent",
	Fields: graphql.Fields{
		"MinerAddr": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: PowerV0CronEvent__MinerAddr__resolve,
		},
		"CallbackPayload": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: PowerV0CronEvent__CallbackPayload__resolve,
		},
	},
})
View Source 
var PowerV0State__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "PowerV0State",
	Fields: graphql.Fields{
		"TotalRawBytePower": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PowerV0State__TotalRawBytePower__resolve,
		},
		"TotalBytesCommitted": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PowerV0State__TotalBytesCommitted__resolve,
		},
		"TotalQualityAdjPower": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PowerV0State__TotalQualityAdjPower__resolve,
		},
		"TotalQABytesCommitted": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PowerV0State__TotalQABytesCommitted__resolve,
		},
		"TotalPledgeCollateral": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PowerV0State__TotalPledgeCollateral__resolve,
		},
		"ThisEpochRawBytePower": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PowerV0State__ThisEpochRawBytePower__resolve,
		},
		"ThisEpochQualityAdjPower": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PowerV0State__ThisEpochQualityAdjPower__resolve,
		},
		"ThisEpochPledgeCollateral": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PowerV0State__ThisEpochPledgeCollateral__resolve,
		},
		"ThisEpochQAPowerSmoothed": &graphql.Field{

			Type: V0FilterEstimate__type,

			Resolve: PowerV0State__ThisEpochQAPowerSmoothed__resolve,
		},
		"MinerCount": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: PowerV0State__MinerCount__resolve,
		},
		"MinerAboveMinPowerCount": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: PowerV0State__MinerAboveMinPowerCount__resolve,
		},
		"CronEventQueue": &graphql.Field{

			Type: graphql.NewNonNull(Multimap__PowerV0CronEvent__type),

			Resolve: PowerV0State__CronEventQueue__resolve,
		},
		"FirstCronEpoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: PowerV0State__FirstCronEpoch__resolve,
		},
		"LastProcessedCronEpoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: PowerV0State__LastProcessedCronEpoch__resolve,
		},
		"Claims": &graphql.Field{

			Type: graphql.NewNonNull(Map__PowerV0Claim__type),

			Resolve: PowerV0State__Claims__resolve,
		},
		"ProofValidationBatch": &graphql.Field{

			Type: graphql.ID,

			Resolve: PowerV0State__ProofValidationBatch__resolve,
		},
	},
})
View Source 
var PowerV2Claim__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "PowerV2Claim",
	Fields: graphql.Fields{
		"SealProofType": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: PowerV2Claim__SealProofType__resolve,
		},
		"RawBytePower": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PowerV2Claim__RawBytePower__resolve,
		},
		"QualityAdjPower": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PowerV2Claim__QualityAdjPower__resolve,
		},
	},
})
View Source 
var PowerV2State__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "PowerV2State",
	Fields: graphql.Fields{
		"TotalRawBytePower": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PowerV2State__TotalRawBytePower__resolve,
		},
		"TotalBytesCommitted": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PowerV2State__TotalBytesCommitted__resolve,
		},
		"TotalQualityAdjPower": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PowerV2State__TotalQualityAdjPower__resolve,
		},
		"TotalQABytesCommitted": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PowerV2State__TotalQABytesCommitted__resolve,
		},
		"TotalPledgeCollateral": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PowerV2State__TotalPledgeCollateral__resolve,
		},
		"ThisEpochRawBytePower": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PowerV2State__ThisEpochRawBytePower__resolve,
		},
		"ThisEpochQualityAdjPower": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PowerV2State__ThisEpochQualityAdjPower__resolve,
		},
		"ThisEpochPledgeCollateral": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: PowerV2State__ThisEpochPledgeCollateral__resolve,
		},
		"ThisEpochQAPowerSmoothed": &graphql.Field{

			Type: V0FilterEstimate__type,

			Resolve: PowerV2State__ThisEpochQAPowerSmoothed__resolve,
		},
		"MinerCount": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: PowerV2State__MinerCount__resolve,
		},
		"MinerAboveMinPowerCount": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: PowerV2State__MinerAboveMinPowerCount__resolve,
		},
		"CronEventQueue": &graphql.Field{

			Type: graphql.NewNonNull(Multimap__PowerV0CronEvent__type),

			Resolve: PowerV2State__CronEventQueue__resolve,
		},
		"FirstCronEpoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: PowerV2State__FirstCronEpoch__resolve,
		},
		"Claims": &graphql.Field{

			Type: graphql.NewNonNull(Map__PowerV2Claim__type),

			Resolve: PowerV2State__Claims__resolve,
		},
		"ProofValidationBatch": &graphql.Field{

			Type: graphql.ID,

			Resolve: PowerV2State__ProofValidationBatch__resolve,
		},
	},
})
View Source 
var RawAddress__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "RawAddress",
	Description:  "RawAddress",
	Serialize:    RawAddress__type__serialize,
	ParseValue:   RawAddress__type__parse,
	ParseLiteral: RawAddress__type__parseLiteral,
})
View Source 
var RewardV0State__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "RewardV0State",
	Fields: graphql.Fields{
		"CumsumBaseline": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: RewardV0State__CumsumBaseline__resolve,
		},
		"CumsumRealized": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: RewardV0State__CumsumRealized__resolve,
		},
		"EffectiveNetworkTime": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: RewardV0State__EffectiveNetworkTime__resolve,
		},
		"EffectiveBaselinePower": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: RewardV0State__EffectiveBaselinePower__resolve,
		},
		"ThisEpochReward": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: RewardV0State__ThisEpochReward__resolve,
		},
		"ThisEpochRewardSmoothed": &graphql.Field{

			Type: V0FilterEstimate__type,

			Resolve: RewardV0State__ThisEpochRewardSmoothed__resolve,
		},
		"ThisEpochBaselinePower": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: RewardV0State__ThisEpochBaselinePower__resolve,
		},
		"Epoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: RewardV0State__Epoch__resolve,
		},
		"TotalMined": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: RewardV0State__TotalMined__resolve,
		},
	},
})
View Source 
var RewardV2State__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "RewardV2State",
	Fields: graphql.Fields{
		"CumsumBaseline": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: RewardV2State__CumsumBaseline__resolve,
		},
		"CumsumRealized": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: RewardV2State__CumsumRealized__resolve,
		},
		"EffectiveNetworkTime": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: RewardV2State__EffectiveNetworkTime__resolve,
		},
		"EffectiveBaselinePower": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: RewardV2State__EffectiveBaselinePower__resolve,
		},
		"ThisEpochReward": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: RewardV2State__ThisEpochReward__resolve,
		},
		"ThisEpochRewardSmoothed": &graphql.Field{

			Type: graphql.NewNonNull(V0FilterEstimate__type),

			Resolve: RewardV2State__ThisEpochRewardSmoothed__resolve,
		},
		"ThisEpochBaselinePower": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: RewardV2State__ThisEpochBaselinePower__resolve,
		},
		"Epoch": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: RewardV2State__Epoch__resolve,
		},
		"TotalStoragePowerReward": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: RewardV2State__TotalStoragePowerReward__resolve,
		},
		"SimpleTotal": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: RewardV2State__SimpleTotal__resolve,
		},
		"BaselineTotal": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: RewardV2State__BaselineTotal__resolve,
		},
	},
})
View Source 
var SealVerifyInfo__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "SealVerifyInfo",
	Fields: graphql.Fields{
		"SealProof": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: SealVerifyInfo__SealProof__resolve,
		},
		"SectorID": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: SealVerifyInfo__SectorID__resolve,
		},
		"DealIDs": &graphql.Field{

			Type: graphql.NewNonNull(List__DealID__type),

			Resolve: SealVerifyInfo__DealIDs__resolve,
		},
		"Randomness": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: SealVerifyInfo__Randomness__resolve,
		},
		"InteractiveRandomness": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: SealVerifyInfo__InteractiveRandomness__resolve,
		},
		"Proof": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: SealVerifyInfo__Proof__resolve,
		},
		"SealedCID": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: SealVerifyInfo__SealedCID__resolve,
		},
		"UnsealedCID": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: SealVerifyInfo__UnsealedCID__resolve,
		},
	},
})
View Source 
var SectorNumber__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "SectorNumber",
	Description:  "SectorNumber",
	Serialize:    SectorNumber__type__serialize,
	ParseValue:   SectorNumber__type__parse,
	ParseLiteral: SectorNumber__type__parseLiteral,
})
View Source 
var SectorSize__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "SectorSize",
	Description:  "SectorSize",
	Serialize:    SectorSize__type__serialize,
	ParseValue:   SectorSize__type__parse,
	ParseLiteral: SectorSize__type__parseLiteral,
})
View Source 
var Signature__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "Signature",
	Description:  "Signature",
	Serialize:    Signature__type__serialize,
	ParseValue:   Signature__type__parse,
	ParseLiteral: Signature__type__parseLiteral,
})
View Source 
var SignedVoucher__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "SignedVoucher",
	Fields: graphql.Fields{
		"ChannelAddr": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: SignedVoucher__ChannelAddr__resolve,
		},
		"TimeLockMin": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: SignedVoucher__TimeLockMin__resolve,
		},
		"TimeLockMax": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: SignedVoucher__TimeLockMax__resolve,
		},
		"SecretPreimage": &graphql.Field{

			Type: Bytes__type,

			Resolve: SignedVoucher__SecretPreimage__resolve,
		},
		"Extra": &graphql.Field{

			Type: ModVerifyParams__type,

			Resolve: SignedVoucher__Extra__resolve,
		},
		"Lane": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: SignedVoucher__Lane__resolve,
		},
		"Nonce": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: SignedVoucher__Nonce__resolve,
		},
		"Amount": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: SignedVoucher__Amount__resolve,
		},
		"MinSettleHeight": &graphql.Field{

			Type: ChainEpoch__type,

			Resolve: SignedVoucher__MinSettleHeight__resolve,
		},
		"Merges": &graphql.Field{

			Type: List__Merge__type,

			Resolve: SignedVoucher__Merges__resolve,
		},
		"Signature": &graphql.Field{

			Type: Signature__type,

			Resolve: SignedVoucher__Signature__resolve,
		},
	},
})
View Source 
var UnpaddedPieceSize__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "UnpaddedPieceSize",
	Description:  "UnpaddedPieceSize",
	Serialize:    UnpaddedPieceSize__type__serialize,
	ParseValue:   UnpaddedPieceSize__type__parse,
	ParseLiteral: UnpaddedPieceSize__type__parseLiteral,
})
View Source 
var V0FilterEstimate__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "V0FilterEstimate",
	Fields: graphql.Fields{
		"PositionEstimate": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: V0FilterEstimate__PositionEstimate__resolve,
		},
		"VelocityEstimate": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: V0FilterEstimate__VelocityEstimate__resolve,
		},
	},
})
View Source 
var VerifregV0State__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "VerifregV0State",
	Fields: graphql.Fields{
		"RootKey": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: VerifregV0State__RootKey__resolve,
		},
		"Verifiers": &graphql.Field{

			Type: graphql.NewNonNull(Map__DataCap__type),

			Resolve: VerifregV0State__Verifiers__resolve,
		},
		"VerifiedClients": &graphql.Field{

			Type: graphql.NewNonNull(Map__DataCap__type),

			Resolve: VerifregV0State__VerifiedClients__resolve,
		},
	},
})

Functions

func AccountV0State__Address__resolve 

func AccountV0State__Address__resolve(p graphql.ResolveParams) (interface{}, error)

func ActorID__type__parse 

func ActorID__type__parse(value interface{}) interface{}

func ActorID__type__parseLiteral 

func ActorID__type__parseLiteral(valueAST ast.Value) interface{}

func ActorID__type__serialize 

func ActorID__type__serialize(value interface{}) interface{}

func AddFields 

func AddFields()

func Address__type__parse 

func Address__type__parse(value interface{}) interface{}

func Address__type__parseLiteral 

func Address__type__parseLiteral(valueAST ast.Value) interface{}

func Address__type__serialize 

func Address__type__serialize(value interface{}) interface{}

Address__type__serialize - and undo the presentation of the "bytes" of addres for presentation.

func ApplyRewardParams__Penalty__resolve 

func ApplyRewardParams__Penalty__resolve(p graphql.ResolveParams) (interface{}, error)

func ApplyRewardParams__Reward__resolve 

func ApplyRewardParams__Reward__resolve(p graphql.ResolveParams) (interface{}, error)

func BigInt__type__parse 

func BigInt__type__parse(value interface{}) interface{}

func BigInt__type__parseLiteral 

func BigInt__type__parseLiteral(valueAST ast.Value) interface{}

func BigInt__type__serialize 

func BigInt__type__serialize(value interface{}) interface{}

Print big-ints in a decimal / human readable string form.

func BitField__type__parse 

func BitField__type__parse(value interface{}) interface{}

func BitField__type__parseLiteral 

func BitField__type__parseLiteral(valueAST ast.Value) interface{}

func BitField__type__serialize 

func BitField__type__serialize(value interface{}) interface{}

func Bytes__type__parse 

func Bytes__type__parse(value interface{}) interface{}

func Bytes__type__parseLiteral 

func Bytes__type__parseLiteral(valueAST ast.Value) interface{}

func Bytes__type__serialize 

func Bytes__type__serialize(value interface{}) interface{}

func ChainEpoch__type__parse 

func ChainEpoch__type__parse(value interface{}) interface{}

func ChainEpoch__type__parseLiteral 

func ChainEpoch__type__parseLiteral(valueAST ast.Value) interface{}

func ChainEpoch__type__serialize 

func ChainEpoch__type__serialize(value interface{}) interface{}

func CidString__type__parse 

func CidString__type__parse(value interface{}) interface{}

func CidString__type__parseLiteral 

func CidString__type__parseLiteral(valueAST ast.Value) interface{}

func CidString__type__serialize 

func CidString__type__serialize(value interface{}) interface{}

func CorsMiddleware 

func CorsMiddleware(next http.HandlerFunc) http.Handler

func CronV0Entry__MethodNum__resolve 

func CronV0Entry__MethodNum__resolve(p graphql.ResolveParams) (interface{}, error)

func CronV0Entry__Receiver__resolve 

func CronV0Entry__Receiver__resolve(p graphql.ResolveParams) (interface{}, error)

func CronV0State__Entries__resolve 

func CronV0State__Entries__resolve(p graphql.ResolveParams) (interface{}, error)

func DealID__type__parse 

func DealID__type__parse(value interface{}) interface{}

func DealID__type__parseLiteral 

func DealID__type__parseLiteral(valueAST ast.Value) interface{}

func DealID__type__serialize 

func DealID__type__serialize(value interface{}) interface{}

func GetGraphQL 

func GetGraphQL(c *cli.Context, source sdlib.Datasource) *http.ServeMux

func InitV0State__AddressMap__resolve 

func InitV0State__AddressMap__resolve(p graphql.ResolveParams) (interface{}, error)

func InitV0State__NetworkName__resolve 

func InitV0State__NetworkName__resolve(p graphql.ResolveParams) (interface{}, error)

func InitV0State__NextID__resolve 

func InitV0State__NextID__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusActors__Balance__resolve 

func LotusActors__Balance__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusActors__Code__resolve 

func LotusActors__Code__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusActors__Head__resolve 

func LotusActors__Head__resolve(p graphql.ResolveParams) (interface{}, error)

LotusActors__Head__resolve resolves head cid based on code.

func LotusActors__Nonce__resolve 

func LotusActors__Nonce__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusBeaconEntry__Data__resolve 

func LotusBeaconEntry__Data__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusBeaconEntry__Round__resolve 

func LotusBeaconEntry__Round__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusBlockHeader__BLSAggregate__resolve 

func LotusBlockHeader__BLSAggregate__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusBlockHeader__BeaconEntries__resolve 

func LotusBlockHeader__BeaconEntries__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusBlockHeader__BlockSig__resolve 

func LotusBlockHeader__BlockSig__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusBlockHeader__ElectionProof__resolve 

func LotusBlockHeader__ElectionProof__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusBlockHeader__ForkSignaling__resolve 

func LotusBlockHeader__ForkSignaling__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusBlockHeader__Height__resolve 

func LotusBlockHeader__Height__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusBlockHeader__Messages__resolve 

func LotusBlockHeader__Messages__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusBlockHeader__Miner__resolve 

func LotusBlockHeader__Miner__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusBlockHeader__ParentBaseFee__resolve 

func LotusBlockHeader__ParentBaseFee__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusBlockHeader__ParentMessageReceipts__resolve 

func LotusBlockHeader__ParentMessageReceipts__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusBlockHeader__ParentStateRoot__resolve 

func LotusBlockHeader__ParentStateRoot__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusBlockHeader__ParentWeight__resolve 

func LotusBlockHeader__ParentWeight__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusBlockHeader__Parents__resolve 

func LotusBlockHeader__Parents__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusBlockHeader__Ticket__resolve 

func LotusBlockHeader__Ticket__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusBlockHeader__Timestamp__resolve 

func LotusBlockHeader__Timestamp__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusBlockHeader__WinPoStProof__resolve 

func LotusBlockHeader__WinPoStProof__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusElectionProof__VRFProof__resolve 

func LotusElectionProof__VRFProof__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusElectionProof__WinCount__resolve 

func LotusElectionProof__WinCount__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusMessage__From__resolve 

func LotusMessage__From__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusMessage__GasFeeCap__resolve 

func LotusMessage__GasFeeCap__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusMessage__GasLimit__resolve 

func LotusMessage__GasLimit__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusMessage__GasPremium__resolve 

func LotusMessage__GasPremium__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusMessage__Method__resolve 

func LotusMessage__Method__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusMessage__Nonce__resolve 

func LotusMessage__Nonce__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusMessage__Params__resolve 

func LotusMessage__Params__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusMessage__To__resolve 

func LotusMessage__To__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusMessage__Value__resolve 

func LotusMessage__Value__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusMessage__Version__resolve 

func LotusMessage__Version__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusMsgMeta__BlsMessages__resolve 

func LotusMsgMeta__BlsMessages__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusMsgMeta__SecpkMessages__resolve 

func LotusMsgMeta__SecpkMessages__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusSignedMessage__Message__resolve 

func LotusSignedMessage__Message__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusSignedMessage__Signature__resolve 

func LotusSignedMessage__Signature__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusStateRoot__Actors__resolve 

func LotusStateRoot__Actors__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusStateRoot__Info__resolve 

func LotusStateRoot__Info__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusStateRoot__Version__resolve 

func LotusStateRoot__Version__resolve(p graphql.ResolveParams) (interface{}, error)

func LotusTicket__VRFProof__resolve 

func LotusTicket__VRFProof__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketClientDealProposal__ClientSignature__resolve 

func MarketClientDealProposal__ClientSignature__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketClientDealProposal__Proposal__resolve 

func MarketClientDealProposal__Proposal__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0DealProposal__ClientCollateral__resolve 

func MarketV0DealProposal__ClientCollateral__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0DealProposal__Client__resolve 

func MarketV0DealProposal__Client__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0DealProposal__EndEpoch__resolve 

func MarketV0DealProposal__EndEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0DealProposal__Label__resolve 

func MarketV0DealProposal__Label__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0DealProposal__PieceCID__resolve 

func MarketV0DealProposal__PieceCID__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0DealProposal__PieceSize__resolve 

func MarketV0DealProposal__PieceSize__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0DealProposal__ProviderCollateral__resolve 

func MarketV0DealProposal__ProviderCollateral__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0DealProposal__Provider__resolve 

func MarketV0DealProposal__Provider__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0DealProposal__StartEpoch__resolve 

func MarketV0DealProposal__StartEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0DealProposal__StoragePricePerEpoch__resolve 

func MarketV0DealProposal__StoragePricePerEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0DealProposal__VerifiedDeal__resolve 

func MarketV0DealProposal__VerifiedDeal__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0DealState__LastUpdatedEpoch__resolve 

func MarketV0DealState__LastUpdatedEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0DealState__SectorStartEpoch__resolve 

func MarketV0DealState__SectorStartEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0DealState__SlashEpoch__resolve 

func MarketV0DealState__SlashEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0State__DealOpsByEpoch__resolve 

func MarketV0State__DealOpsByEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0State__EscrowTable__resolve 

func MarketV0State__EscrowTable__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0State__LastCron__resolve 

func MarketV0State__LastCron__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0State__LockedTable__resolve 

func MarketV0State__LockedTable__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0State__NextID__resolve 

func MarketV0State__NextID__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0State__PendingProposals__resolve 

func MarketV0State__PendingProposals__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0State__Proposals__resolve 

func MarketV0State__Proposals__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0State__States__resolve 

func MarketV0State__States__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0State__TotalClientLockedCollateral__resolve 

func MarketV0State__TotalClientLockedCollateral__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0State__TotalClientStorageFee__resolve 

func MarketV0State__TotalClientStorageFee__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV0State__TotalProviderLockedCollateral__resolve 

func MarketV0State__TotalProviderLockedCollateral__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2DealProposal__ClientCollateral__resolve 

func MarketV2DealProposal__ClientCollateral__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2DealProposal__Client__resolve 

func MarketV2DealProposal__Client__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2DealProposal__EndEpoch__resolve 

func MarketV2DealProposal__EndEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2DealProposal__Label__resolve 

func MarketV2DealProposal__Label__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2DealProposal__PieceCID__resolve 

func MarketV2DealProposal__PieceCID__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2DealProposal__PieceSize__resolve 

func MarketV2DealProposal__PieceSize__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2DealProposal__ProviderCollateral__resolve 

func MarketV2DealProposal__ProviderCollateral__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2DealProposal__Provider__resolve 

func MarketV2DealProposal__Provider__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2DealProposal__StartEpoch__resolve 

func MarketV2DealProposal__StartEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2DealProposal__StoragePricePerEpoch__resolve 

func MarketV2DealProposal__StoragePricePerEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2DealProposal__VerifiedDeal__resolve 

func MarketV2DealProposal__VerifiedDeal__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2State__DealOpsByEpoch__resolve 

func MarketV2State__DealOpsByEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2State__EscrowTable__resolve 

func MarketV2State__EscrowTable__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2State__LastCron__resolve 

func MarketV2State__LastCron__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2State__LockedTable__resolve 

func MarketV2State__LockedTable__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2State__NextID__resolve 

func MarketV2State__NextID__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2State__PendingProposals__resolve 

func MarketV2State__PendingProposals__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2State__Proposals__resolve 

func MarketV2State__Proposals__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2State__States__resolve 

func MarketV2State__States__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2State__TotalClientLockedCollateral__resolve 

func MarketV2State__TotalClientLockedCollateral__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2State__TotalClientStorageFee__resolve 

func MarketV2State__TotalClientStorageFee__resolve(p graphql.ResolveParams) (interface{}, error)

func MarketV2State__TotalProviderLockedCollateral__resolve 

func MarketV2State__TotalProviderLockedCollateral__resolve(p graphql.ResolveParams) (interface{}, error)

func Merge__Lane__resolve 

func Merge__Lane__resolve(p graphql.ResolveParams) (interface{}, error)

func Merge__Nonce__resolve 

func Merge__Nonce__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsInitExecParams__CodeCID__resolve 

func MessageParamsInitExecParams__CodeCID__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsInitExecParams__ConstructorParams__resolve 

func MessageParamsInitExecParams__ConstructorParams__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMarketActivateDeals__DealIDs__resolve 

func MessageParamsMarketActivateDeals__DealIDs__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMarketActivateDeals__SectorExpiry__resolve 

func MessageParamsMarketActivateDeals__SectorExpiry__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMarketComputeCommitment__DealIDs__resolve 

func MessageParamsMarketComputeCommitment__DealIDs__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMarketComputeCommitment__SectorType__resolve 

func MessageParamsMarketComputeCommitment__SectorType__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMarketPublishDeals__Deals__resolve 

func MessageParamsMarketPublishDeals__Deals__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMarketTerminateDeals__DealIDs__resolve 

func MessageParamsMarketTerminateDeals__DealIDs__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMarketTerminateDeals__Epoch__resolve 

func MessageParamsMarketTerminateDeals__Epoch__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMarketVerifyDeals__DealIDs__resolve 

func MessageParamsMarketVerifyDeals__DealIDs__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMarketVerifyDeals__SectorExpiry__resolve 

func MessageParamsMarketVerifyDeals__SectorExpiry__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMarketVerifyDeals__SectorStart__resolve 

func MessageParamsMarketVerifyDeals__SectorStart__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMarketWithdrawBalance__Amount__resolve 

func MessageParamsMarketWithdrawBalance__Amount__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMarketWithdrawBalance__ProviderOrClientAmount__resolve 

func MessageParamsMarketWithdrawBalance__ProviderOrClientAmount__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerChangeAddress__NewControlAddrs__resolve 

func MessageParamsMinerChangeAddress__NewControlAddrs__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerChangeAddress__NewWorker__resolve 

func MessageParamsMinerChangeAddress__NewWorker__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerChangeMultiaddrs__NewMultiaddrs__resolve 

func MessageParamsMinerChangeMultiaddrs__NewMultiaddrs__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerChangePeerID__NewID__resolve 

func MessageParamsMinerChangePeerID__NewID__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerCheckSectorProven__SectorNumber__resolve 

func MessageParamsMinerCheckSectorProven__SectorNumber__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerCompactPartitions__Deadline__resolve 

func MessageParamsMinerCompactPartitions__Deadline__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerCompactPartitions__Partitions__resolve 

func MessageParamsMinerCompactPartitions__Partitions__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerCompactSectorNumbers__MaskSectorNumbers__resolve 

func MessageParamsMinerCompactSectorNumbers__MaskSectorNumbers__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerConfirmSectorProofs__Sectors__resolve 

func MessageParamsMinerConfirmSectorProofs__Sectors__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerDeclareFaultsRecovered__Recoveries__resolve 

func MessageParamsMinerDeclareFaultsRecovered__Recoveries__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerDeclareFaults__Faults__resolve 

func MessageParamsMinerDeclareFaults__Faults__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerDeferredCron__EventType__resolve 

func MessageParamsMinerDeferredCron__EventType__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerExtendSectorExpiration__Extension__resolve 

func MessageParamsMinerExtendSectorExpiration__Extension__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerProveCommitSector__Proof__resolve 

func MessageParamsMinerProveCommitSector__Proof__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerProveCommitSector__SectorNumber__resolve 

func MessageParamsMinerProveCommitSector__SectorNumber__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerReportFault__BlockHeader1__resolve 

func MessageParamsMinerReportFault__BlockHeader1__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerReportFault__BlockHeader2__resolve 

func MessageParamsMinerReportFault__BlockHeader2__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerReportFault__BlockHeaderExtra__resolve 

func MessageParamsMinerReportFault__BlockHeaderExtra__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerSubmitWindowedPoSt__ChainCommitEpoch__resolve 

func MessageParamsMinerSubmitWindowedPoSt__ChainCommitEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerSubmitWindowedPoSt__ChainCommitRand__resolve 

func MessageParamsMinerSubmitWindowedPoSt__ChainCommitRand__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerSubmitWindowedPoSt__Deadline__resolve 

func MessageParamsMinerSubmitWindowedPoSt__Deadline__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerSubmitWindowedPoSt__Partitions__resolve 

func MessageParamsMinerSubmitWindowedPoSt__Partitions__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerSubmitWindowedPoSt__Proofs__resolve 

func MessageParamsMinerSubmitWindowedPoSt__Proofs__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerTerminateSectors__Terminations__resolve 

func MessageParamsMinerTerminateSectors__Terminations__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMinerWithdrawBalance__AmountRequested__resolve 

func MessageParamsMinerWithdrawBalance__AmountRequested__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMultisigAddSigner__Increase__resolve 

func MessageParamsMultisigAddSigner__Increase__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMultisigAddSigner__Signer__resolve 

func MessageParamsMultisigAddSigner__Signer__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMultisigChangeThreshold__NewThreshold__resolve 

func MessageParamsMultisigChangeThreshold__NewThreshold__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMultisigConstructor__NumApprovalsThreshold__resolve 

func MessageParamsMultisigConstructor__NumApprovalsThreshold__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMultisigConstructor__Signers__resolve 

func MessageParamsMultisigConstructor__Signers__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMultisigConstructor__StartEpoch__resolve 

func MessageParamsMultisigConstructor__StartEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMultisigConstructor__UnlockDuration__resolve 

func MessageParamsMultisigConstructor__UnlockDuration__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMultisigLockBalance__Amount__resolve 

func MessageParamsMultisigLockBalance__Amount__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMultisigLockBalance__StartEpoch__resolve 

func MessageParamsMultisigLockBalance__StartEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMultisigLockBalance__UnlockDuration__resolve 

func MessageParamsMultisigLockBalance__UnlockDuration__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMultisigPropose__Method__resolve 

func MessageParamsMultisigPropose__Method__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMultisigPropose__Params__resolve 

func MessageParamsMultisigPropose__Params__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMultisigPropose__To__resolve 

func MessageParamsMultisigPropose__To__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMultisigPropose__Value__resolve 

func MessageParamsMultisigPropose__Value__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMultisigRemoveSigner__Decrease__resolve 

func MessageParamsMultisigRemoveSigner__Decrease__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMultisigRemoveSigner__Signer__resolve 

func MessageParamsMultisigRemoveSigner__Signer__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMultisigSwapSigner__From__resolve 

func MessageParamsMultisigSwapSigner__From__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMultisigSwapSigner__To__resolve 

func MessageParamsMultisigSwapSigner__To__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMultisigTxnID__ID__resolve 

func MessageParamsMultisigTxnID__ID__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsMultisigTxnID__ProposeHash__resolve 

func MessageParamsMultisigTxnID__ProposeHash__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsPaychConstructor__From__resolve 

func MessageParamsPaychConstructor__From__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsPaychConstructor__To__resolve 

func MessageParamsPaychConstructor__To__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsPaychUpdateChannelState__Secret__resolve 

func MessageParamsPaychUpdateChannelState__Secret__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsPaychUpdateChannelState__Sv__resolve 

func MessageParamsPaychUpdateChannelState__Sv__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsPowerCreateMiner__Multiaddrs__resolve 

func MessageParamsPowerCreateMiner__Multiaddrs__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsPowerCreateMiner__Owner__resolve 

func MessageParamsPowerCreateMiner__Owner__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsPowerCreateMiner__Peer__resolve 

func MessageParamsPowerCreateMiner__Peer__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsPowerCreateMiner__SealProofType__resolve 

func MessageParamsPowerCreateMiner__SealProofType__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsPowerCreateMiner__Worker__resolve 

func MessageParamsPowerCreateMiner__Worker__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsPowerCurrentTotal__PledgeCollateral__resolve 

func MessageParamsPowerCurrentTotal__PledgeCollateral__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsPowerCurrentTotal__QualityAdjPowerSmoothed__resolve 

func MessageParamsPowerCurrentTotal__QualityAdjPowerSmoothed__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsPowerCurrentTotal__QualityAdjPower__resolve 

func MessageParamsPowerCurrentTotal__QualityAdjPower__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsPowerCurrentTotal__RawBytePower__resolve 

func MessageParamsPowerCurrentTotal__RawBytePower__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsPowerEnrollCron__EventEpoch__resolve 

func MessageParamsPowerEnrollCron__EventEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsPowerEnrollCron__Payload__resolve 

func MessageParamsPowerEnrollCron__Payload__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsPowerUpdateClaimed__QualityAdjustedDelta__resolve 

func MessageParamsPowerUpdateClaimed__QualityAdjustedDelta__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsPowerUpdateClaimed__RawByteDelta__resolve 

func MessageParamsPowerUpdateClaimed__RawByteDelta__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsRewardAwardBlock__GasReward__resolve 

func MessageParamsRewardAwardBlock__GasReward__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsRewardAwardBlock__Miner__resolve 

func MessageParamsRewardAwardBlock__Miner__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsRewardAwardBlock__Penalty__resolve 

func MessageParamsRewardAwardBlock__Penalty__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsRewardAwardBlock__WinCount__resolve 

func MessageParamsRewardAwardBlock__WinCount__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsVerifregAddVerifier__Address__resolve 

func MessageParamsVerifregAddVerifier__Address__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsVerifregAddVerifier__Allowance__resolve 

func MessageParamsVerifregAddVerifier__Allowance__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsVerifregUseBytes__Address__resolve 

func MessageParamsVerifregUseBytes__Address__resolve(p graphql.ResolveParams) (interface{}, error)

func MessageParamsVerifregUseBytes__DealSize__resolve 

func MessageParamsVerifregUseBytes__DealSize__resolve(p graphql.ResolveParams) (interface{}, error)

func MethodNum__type__parse 

func MethodNum__type__parse(value interface{}) interface{}

func MethodNum__type__parseLiteral 

func MethodNum__type__parseLiteral(valueAST ast.Value) interface{}

func MethodNum__type__serialize 

func MethodNum__type__serialize(value interface{}) interface{}

func MinerExpirationExtend__Deadline__resolve 

func MinerExpirationExtend__Deadline__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerExpirationExtend__NewExpiration__resolve 

func MinerExpirationExtend__NewExpiration__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerExpirationExtend__Partition__resolve 

func MinerExpirationExtend__Partition__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerExpirationExtend__Sectors__resolve 

func MinerExpirationExtend__Sectors__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerPostPartition__Index__resolve 

func MinerPostPartition__Index__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerPostPartition__Skipped__resolve 

func MinerPostPartition__Skipped__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerPostProof__PoStProof__resolve 

func MinerPostProof__PoStProof__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerPostProof__ProofBytes__resolve 

func MinerPostProof__ProofBytes__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerTerminationDecl__Deadline__resolve 

func MinerTerminationDecl__Deadline__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerTerminationDecl__Partition__resolve 

func MinerTerminationDecl__Partition__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerTerminationDecl__Sectors__resolve 

func MinerTerminationDecl__Sectors__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Deadline__EarlyTerminations__resolve 

func MinerV0Deadline__EarlyTerminations__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Deadline__ExpirationEpochs__resolve 

func MinerV0Deadline__ExpirationEpochs__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Deadline__FaultyPower__resolve 

func MinerV0Deadline__FaultyPower__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Deadline__LiveSectors__resolve 

func MinerV0Deadline__LiveSectors__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Deadline__Partitions__resolve 

func MinerV0Deadline__Partitions__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Deadline__PostSubmissions__resolve 

func MinerV0Deadline__PostSubmissions__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Deadline__TotalSectors__resolve 

func MinerV0Deadline__TotalSectors__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Deadlines__Due__resolve 

func MinerV0Deadlines__Due__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0ExpirationSet__ActivePower__resolve 

func MinerV0ExpirationSet__ActivePower__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0ExpirationSet__EarlySectors__resolve 

func MinerV0ExpirationSet__EarlySectors__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0ExpirationSet__FaultyPower__resolve 

func MinerV0ExpirationSet__FaultyPower__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0ExpirationSet__OnTimePledge__resolve 

func MinerV0ExpirationSet__OnTimePledge__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0ExpirationSet__OnTimeSectors__resolve 

func MinerV0ExpirationSet__OnTimeSectors__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Info__ControlAddresses__resolve 

func MinerV0Info__ControlAddresses__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Info__Multiaddrs__resolve 

func MinerV0Info__Multiaddrs__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Info__Owner__resolve 

func MinerV0Info__Owner__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Info__PeerId__resolve 

func MinerV0Info__PeerId__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Info__PendingWorkerKey__resolve 

func MinerV0Info__PendingWorkerKey__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Info__SealProofType__resolve 

func MinerV0Info__SealProofType__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Info__SectorSize__resolve 

func MinerV0Info__SectorSize__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Info__WindowPoStPartitionSectors__resolve 

func MinerV0Info__WindowPoStPartitionSectors__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Info__Worker__resolve 

func MinerV0Info__Worker__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Partition__EarlyTerminated__resolve 

func MinerV0Partition__EarlyTerminated__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Partition__ExpirationsEpochs__resolve 

func MinerV0Partition__ExpirationsEpochs__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Partition__Faults__resolve 

func MinerV0Partition__Faults__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Partition__FaultyPower__resolve 

func MinerV0Partition__FaultyPower__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Partition__LivePower__resolve 

func MinerV0Partition__LivePower__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Partition__Recoveries__resolve 

func MinerV0Partition__Recoveries__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Partition__RecoveringPower__resolve 

func MinerV0Partition__RecoveringPower__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Partition__Sectors__resolve 

func MinerV0Partition__Sectors__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0Partition__Terminated__resolve 

func MinerV0Partition__Terminated__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0PowerPair__QA__resolve 

func MinerV0PowerPair__QA__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0PowerPair__Raw__resolve 

func MinerV0PowerPair__Raw__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorOnChainInfo__Activation__resolve 

func MinerV0SectorOnChainInfo__Activation__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorOnChainInfo__DealIDs__resolve 

func MinerV0SectorOnChainInfo__DealIDs__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorOnChainInfo__DealWeight__resolve 

func MinerV0SectorOnChainInfo__DealWeight__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorOnChainInfo__ExpectedDayReward__resolve 

func MinerV0SectorOnChainInfo__ExpectedDayReward__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorOnChainInfo__ExpectedStorageReward__resolve 

func MinerV0SectorOnChainInfo__ExpectedStorageReward__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorOnChainInfo__Expiration__resolve 

func MinerV0SectorOnChainInfo__Expiration__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorOnChainInfo__InitialPledge__resolve 

func MinerV0SectorOnChainInfo__InitialPledge__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorOnChainInfo__SealProof__resolve 

func MinerV0SectorOnChainInfo__SealProof__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorOnChainInfo__SealedCID__resolve 

func MinerV0SectorOnChainInfo__SealedCID__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorOnChainInfo__SectorNumber__resolve 

func MinerV0SectorOnChainInfo__SectorNumber__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorOnChainInfo__VerifiedDealWeight__resolve 

func MinerV0SectorOnChainInfo__VerifiedDealWeight__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorPreCommitInfo__DealIDs__resolve 

func MinerV0SectorPreCommitInfo__DealIDs__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorPreCommitInfo__Expiration__resolve 

func MinerV0SectorPreCommitInfo__Expiration__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorPreCommitInfo__ReplaceCapacity__resolve 

func MinerV0SectorPreCommitInfo__ReplaceCapacity__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorPreCommitInfo__ReplaceSectorDeadline__resolve 

func MinerV0SectorPreCommitInfo__ReplaceSectorDeadline__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorPreCommitInfo__ReplaceSectorNumber__resolve 

func MinerV0SectorPreCommitInfo__ReplaceSectorNumber__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorPreCommitInfo__ReplaceSectorPartition__resolve 

func MinerV0SectorPreCommitInfo__ReplaceSectorPartition__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorPreCommitInfo__SealProof__resolve 

func MinerV0SectorPreCommitInfo__SealProof__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorPreCommitInfo__SealRandEpoch__resolve 

func MinerV0SectorPreCommitInfo__SealRandEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorPreCommitInfo__SealedCID__resolve 

func MinerV0SectorPreCommitInfo__SealedCID__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorPreCommitInfo__SectorNumber__resolve 

func MinerV0SectorPreCommitInfo__SectorNumber__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorPreCommitOnChainInfo__DealWeight__resolve 

func MinerV0SectorPreCommitOnChainInfo__DealWeight__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorPreCommitOnChainInfo__Info__resolve 

func MinerV0SectorPreCommitOnChainInfo__Info__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorPreCommitOnChainInfo__PreCommitDeposit__resolve 

func MinerV0SectorPreCommitOnChainInfo__PreCommitDeposit__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorPreCommitOnChainInfo__PreCommitEpoch__resolve 

func MinerV0SectorPreCommitOnChainInfo__PreCommitEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0SectorPreCommitOnChainInfo__VerifiedDealWeight__resolve 

func MinerV0SectorPreCommitOnChainInfo__VerifiedDealWeight__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0State__AllocatedSectors__resolve 

func MinerV0State__AllocatedSectors__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0State__CurrentDeadline__resolve 

func MinerV0State__CurrentDeadline__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0State__Deadlines__resolve 

func MinerV0State__Deadlines__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0State__EarlyTerminations__resolve 

func MinerV0State__EarlyTerminations__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0State__Info__resolve 

func MinerV0State__Info__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0State__InitialPledgeRequirement__resolve 

func MinerV0State__InitialPledgeRequirement__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0State__LockedFunds__resolve 

func MinerV0State__LockedFunds__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0State__PreCommitDeposits__resolve 

func MinerV0State__PreCommitDeposits__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0State__PreCommittedSectorsExpiry__resolve 

func MinerV0State__PreCommittedSectorsExpiry__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0State__PreCommittedSectors__resolve 

func MinerV0State__PreCommittedSectors__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0State__ProvingPeriodStart__resolve 

func MinerV0State__ProvingPeriodStart__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0State__Sectors__resolve 

func MinerV0State__Sectors__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0State__VestingFunds__resolve 

func MinerV0State__VestingFunds__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0VestingFund__Amount__resolve 

func MinerV0VestingFund__Amount__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0VestingFund__Epoch__resolve 

func MinerV0VestingFund__Epoch__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0VestingFunds__Funds__resolve 

func MinerV0VestingFunds__Funds__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0WorkerChangeKey__EffectiveAt__resolve 

func MinerV0WorkerChangeKey__EffectiveAt__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV0WorkerChangeKey__NewWorker__resolve 

func MinerV0WorkerChangeKey__NewWorker__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Deadline__EarlyTerminations__resolve 

func MinerV2Deadline__EarlyTerminations__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Deadline__ExpirationEpochs__resolve 

func MinerV2Deadline__ExpirationEpochs__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Deadline__FaultyPower__resolve 

func MinerV2Deadline__FaultyPower__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Deadline__LiveSectors__resolve 

func MinerV2Deadline__LiveSectors__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Deadline__Partitions__resolve 

func MinerV2Deadline__Partitions__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Deadline__PostSubmissions__resolve 

func MinerV2Deadline__PostSubmissions__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Deadline__TotalSectors__resolve 

func MinerV2Deadline__TotalSectors__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Deadlines__Due__resolve 

func MinerV2Deadlines__Due__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Info__ConsensusFaultElapsed__resolve 

func MinerV2Info__ConsensusFaultElapsed__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Info__ControlAddresses__resolve 

func MinerV2Info__ControlAddresses__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Info__Multiaddrs__resolve 

func MinerV2Info__Multiaddrs__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Info__Owner__resolve 

func MinerV2Info__Owner__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Info__PeerId__resolve 

func MinerV2Info__PeerId__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Info__PendingOwnerAddress__resolve 

func MinerV2Info__PendingOwnerAddress__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Info__PendingWorkerKey__resolve 

func MinerV2Info__PendingWorkerKey__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Info__SealProofType__resolve 

func MinerV2Info__SealProofType__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Info__SectorSize__resolve 

func MinerV2Info__SectorSize__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Info__WindowPoStPartitionSectors__resolve 

func MinerV2Info__WindowPoStPartitionSectors__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Info__Worker__resolve 

func MinerV2Info__Worker__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Partition__EarlyTerminated__resolve 

func MinerV2Partition__EarlyTerminated__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Partition__ExpirationsEpochs__resolve 

func MinerV2Partition__ExpirationsEpochs__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Partition__Faults__resolve 

func MinerV2Partition__Faults__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Partition__FaultyPower__resolve 

func MinerV2Partition__FaultyPower__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Partition__LivePower__resolve 

func MinerV2Partition__LivePower__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Partition__Recoveries__resolve 

func MinerV2Partition__Recoveries__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Partition__RecoveringPower__resolve 

func MinerV2Partition__RecoveringPower__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Partition__Sectors__resolve 

func MinerV2Partition__Sectors__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Partition__Terminated__resolve 

func MinerV2Partition__Terminated__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Partition__UnprovenPower__resolve 

func MinerV2Partition__UnprovenPower__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2Partition__Unproven__resolve 

func MinerV2Partition__Unproven__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2SectorOnChainInfo__Activation__resolve 

func MinerV2SectorOnChainInfo__Activation__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2SectorOnChainInfo__DealIDs__resolve 

func MinerV2SectorOnChainInfo__DealIDs__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2SectorOnChainInfo__DealWeight__resolve 

func MinerV2SectorOnChainInfo__DealWeight__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2SectorOnChainInfo__ExpectedDayReward__resolve 

func MinerV2SectorOnChainInfo__ExpectedDayReward__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2SectorOnChainInfo__ExpectedStorageReward__resolve 

func MinerV2SectorOnChainInfo__ExpectedStorageReward__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2SectorOnChainInfo__Expiration__resolve 

func MinerV2SectorOnChainInfo__Expiration__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2SectorOnChainInfo__InitialPledge__resolve 

func MinerV2SectorOnChainInfo__InitialPledge__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2SectorOnChainInfo__ReplacedDayReward__resolve 

func MinerV2SectorOnChainInfo__ReplacedDayReward__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2SectorOnChainInfo__ReplacedSectorAge__resolve 

func MinerV2SectorOnChainInfo__ReplacedSectorAge__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2SectorOnChainInfo__SealProof__resolve 

func MinerV2SectorOnChainInfo__SealProof__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2SectorOnChainInfo__SealedCID__resolve 

func MinerV2SectorOnChainInfo__SealedCID__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2SectorOnChainInfo__SectorNumber__resolve 

func MinerV2SectorOnChainInfo__SectorNumber__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2SectorOnChainInfo__VerifiedDealWeight__resolve 

func MinerV2SectorOnChainInfo__VerifiedDealWeight__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2State__AllocatedSectors__resolve 

func MinerV2State__AllocatedSectors__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2State__CurrentDeadline__resolve 

func MinerV2State__CurrentDeadline__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2State__Deadlines__resolve 

func MinerV2State__Deadlines__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2State__EarlyTerminations__resolve 

func MinerV2State__EarlyTerminations__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2State__FeeDebt__resolve 

func MinerV2State__FeeDebt__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2State__Info__resolve 

func MinerV2State__Info__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2State__InitialPledge__resolve 

func MinerV2State__InitialPledge__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2State__LockedFunds__resolve 

func MinerV2State__LockedFunds__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2State__PreCommitDeposits__resolve 

func MinerV2State__PreCommitDeposits__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2State__PreCommittedSectorsExpiry__resolve 

func MinerV2State__PreCommittedSectorsExpiry__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2State__PreCommittedSectors__resolve 

func MinerV2State__PreCommittedSectors__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2State__ProvingPeriodStart__resolve 

func MinerV2State__ProvingPeriodStart__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2State__Sectors__resolve 

func MinerV2State__Sectors__resolve(p graphql.ResolveParams) (interface{}, error)

func MinerV2State__VestingFunds__resolve 

func MinerV2State__VestingFunds__resolve(p graphql.ResolveParams) (interface{}, error)

func ModVerifyParams__Method__resolve 

func ModVerifyParams__Method__resolve(p graphql.ResolveParams) (interface{}, error)

func ModVerifyParams__Params__resolve 

func ModVerifyParams__Params__resolve(p graphql.ResolveParams) (interface{}, error)

func Multiaddr__type__parse 

func Multiaddr__type__parse(value interface{}) interface{}

func Multiaddr__type__parseLiteral 

func Multiaddr__type__parseLiteral(valueAST ast.Value) interface{}

func Multiaddr__type__serialize 

func Multiaddr__type__serialize(value interface{}) interface{}

func MultisigV0State__InitialBalance__resolve 

func MultisigV0State__InitialBalance__resolve(p graphql.ResolveParams) (interface{}, error)

func MultisigV0State__NextTxnID__resolve 

func MultisigV0State__NextTxnID__resolve(p graphql.ResolveParams) (interface{}, error)

func MultisigV0State__NumApprovalsThreshold__resolve 

func MultisigV0State__NumApprovalsThreshold__resolve(p graphql.ResolveParams) (interface{}, error)

func MultisigV0State__PendingTxns__resolve 

func MultisigV0State__PendingTxns__resolve(p graphql.ResolveParams) (interface{}, error)

func MultisigV0State__Signers__resolve 

func MultisigV0State__Signers__resolve(p graphql.ResolveParams) (interface{}, error)

func MultisigV0State__StartEpoch__resolve 

func MultisigV0State__StartEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func MultisigV0State__UnlockDuration__resolve 

func MultisigV0State__UnlockDuration__resolve(p graphql.ResolveParams) (interface{}, error)

func MultisigV0Transaction__Approved__resolve 

func MultisigV0Transaction__Approved__resolve(p graphql.ResolveParams) (interface{}, error)

func MultisigV0Transaction__Method__resolve 

func MultisigV0Transaction__Method__resolve(p graphql.ResolveParams) (interface{}, error)

func MultisigV0Transaction__Params__resolve 

func MultisigV0Transaction__Params__resolve(p graphql.ResolveParams) (interface{}, error)

func MultisigV0Transaction__To__resolve 

func MultisigV0Transaction__To__resolve(p graphql.ResolveParams) (interface{}, error)

func MultisigV0Transaction__Value__resolve 

func MultisigV0Transaction__Value__resolve(p graphql.ResolveParams) (interface{}, error)

func PaddedPieceSize__type__parse 

func PaddedPieceSize__type__parse(value interface{}) interface{}

func PaddedPieceSize__type__parseLiteral 

func PaddedPieceSize__type__parseLiteral(valueAST ast.Value) interface{}

func PaddedPieceSize__type__serialize 

func PaddedPieceSize__type__serialize(value interface{}) interface{}

func PaychV0LaneState__Nonce__resolve 

func PaychV0LaneState__Nonce__resolve(p graphql.ResolveParams) (interface{}, error)

func PaychV0LaneState__Redeemed__resolve 

func PaychV0LaneState__Redeemed__resolve(p graphql.ResolveParams) (interface{}, error)

func PaychV0State__From__resolve 

func PaychV0State__From__resolve(p graphql.ResolveParams) (interface{}, error)

func PaychV0State__LaneStates__resolve 

func PaychV0State__LaneStates__resolve(p graphql.ResolveParams) (interface{}, error)

func PaychV0State__MinSettleHeight__resolve 

func PaychV0State__MinSettleHeight__resolve(p graphql.ResolveParams) (interface{}, error)

func PaychV0State__SettlingAt__resolve 

func PaychV0State__SettlingAt__resolve(p graphql.ResolveParams) (interface{}, error)

func PaychV0State__ToSend__resolve 

func PaychV0State__ToSend__resolve(p graphql.ResolveParams) (interface{}, error)

func PaychV0State__To__resolve 

func PaychV0State__To__resolve(p graphql.ResolveParams) (interface{}, error)

func PeerID__type__parse 

func PeerID__type__parse(value interface{}) interface{}

func PeerID__type__parseLiteral 

func PeerID__type__parseLiteral(valueAST ast.Value) interface{}

func PeerID__type__serialize 

func PeerID__type__serialize(value interface{}) interface{}

func PoStProof__PoStProof__resolve 

func PoStProof__PoStProof__resolve(p graphql.ResolveParams) (interface{}, error)

func PoStProof__ProofBytes__resolve 

func PoStProof__ProofBytes__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV0Claim__QualityAdjPower__resolve 

func PowerV0Claim__QualityAdjPower__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV0Claim__RawBytePower__resolve 

func PowerV0Claim__RawBytePower__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV0CronEvent__CallbackPayload__resolve 

func PowerV0CronEvent__CallbackPayload__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV0CronEvent__MinerAddr__resolve 

func PowerV0CronEvent__MinerAddr__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV0State__Claims__resolve 

func PowerV0State__Claims__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV0State__CronEventQueue__resolve 

func PowerV0State__CronEventQueue__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV0State__FirstCronEpoch__resolve 

func PowerV0State__FirstCronEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV0State__LastProcessedCronEpoch__resolve 

func PowerV0State__LastProcessedCronEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV0State__MinerAboveMinPowerCount__resolve 

func PowerV0State__MinerAboveMinPowerCount__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV0State__MinerCount__resolve 

func PowerV0State__MinerCount__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV0State__ProofValidationBatch__resolve 

func PowerV0State__ProofValidationBatch__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV0State__ThisEpochPledgeCollateral__resolve 

func PowerV0State__ThisEpochPledgeCollateral__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV0State__ThisEpochQAPowerSmoothed__resolve 

func PowerV0State__ThisEpochQAPowerSmoothed__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV0State__ThisEpochQualityAdjPower__resolve 

func PowerV0State__ThisEpochQualityAdjPower__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV0State__ThisEpochRawBytePower__resolve 

func PowerV0State__ThisEpochRawBytePower__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV0State__TotalBytesCommitted__resolve 

func PowerV0State__TotalBytesCommitted__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV0State__TotalPledgeCollateral__resolve 

func PowerV0State__TotalPledgeCollateral__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV0State__TotalQABytesCommitted__resolve 

func PowerV0State__TotalQABytesCommitted__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV0State__TotalQualityAdjPower__resolve 

func PowerV0State__TotalQualityAdjPower__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV0State__TotalRawBytePower__resolve 

func PowerV0State__TotalRawBytePower__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV2Claim__QualityAdjPower__resolve 

func PowerV2Claim__QualityAdjPower__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV2Claim__RawBytePower__resolve 

func PowerV2Claim__RawBytePower__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV2Claim__SealProofType__resolve 

func PowerV2Claim__SealProofType__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV2State__Claims__resolve 

func PowerV2State__Claims__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV2State__CronEventQueue__resolve 

func PowerV2State__CronEventQueue__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV2State__FirstCronEpoch__resolve 

func PowerV2State__FirstCronEpoch__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV2State__MinerAboveMinPowerCount__resolve 

func PowerV2State__MinerAboveMinPowerCount__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV2State__MinerCount__resolve 

func PowerV2State__MinerCount__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV2State__ProofValidationBatch__resolve 

func PowerV2State__ProofValidationBatch__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV2State__ThisEpochPledgeCollateral__resolve 

func PowerV2State__ThisEpochPledgeCollateral__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV2State__ThisEpochQAPowerSmoothed__resolve 

func PowerV2State__ThisEpochQAPowerSmoothed__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV2State__ThisEpochQualityAdjPower__resolve 

func PowerV2State__ThisEpochQualityAdjPower__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV2State__ThisEpochRawBytePower__resolve 

func PowerV2State__ThisEpochRawBytePower__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV2State__TotalBytesCommitted__resolve 

func PowerV2State__TotalBytesCommitted__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV2State__TotalPledgeCollateral__resolve 

func PowerV2State__TotalPledgeCollateral__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV2State__TotalQABytesCommitted__resolve 

func PowerV2State__TotalQABytesCommitted__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV2State__TotalQualityAdjPower__resolve 

func PowerV2State__TotalQualityAdjPower__resolve(p graphql.ResolveParams) (interface{}, error)

func PowerV2State__TotalRawBytePower__resolve 

func PowerV2State__TotalRawBytePower__resolve(p graphql.ResolveParams) (interface{}, error)

func RawAddress__type__parse 

func RawAddress__type__parse(value interface{}) interface{}

RawAddress__type__parse - massage incoming strings into their "bytes-in-string" on disk form

func RawAddress__type__parseLiteral 

func RawAddress__type__parseLiteral(valueAST ast.Value) interface{}

RawAddress__type__parseLiteral - massage incoming strings into their "bytes-in-string" on disk form

func RawAddress__type__serialize 

func RawAddress__type__serialize(value interface{}) interface{}

func RewardV0State__CumsumBaseline__resolve 

func RewardV0State__CumsumBaseline__resolve(p graphql.ResolveParams) (interface{}, error)

func RewardV0State__CumsumRealized__resolve 

func RewardV0State__CumsumRealized__resolve(p graphql.ResolveParams) (interface{}, error)

func RewardV0State__EffectiveBaselinePower__resolve 

func RewardV0State__EffectiveBaselinePower__resolve(p graphql.ResolveParams) (interface{}, error)

func RewardV0State__EffectiveNetworkTime__resolve 

func RewardV0State__EffectiveNetworkTime__resolve(p graphql.ResolveParams) (interface{}, error)

func RewardV0State__Epoch__resolve 

func RewardV0State__Epoch__resolve(p graphql.ResolveParams) (interface{}, error)

func RewardV0State__ThisEpochBaselinePower__resolve 

func RewardV0State__ThisEpochBaselinePower__resolve(p graphql.ResolveParams) (interface{}, error)

func RewardV0State__ThisEpochRewardSmoothed__resolve 

func RewardV0State__ThisEpochRewardSmoothed__resolve(p graphql.ResolveParams) (interface{}, error)

func RewardV0State__ThisEpochReward__resolve 

func RewardV0State__ThisEpochReward__resolve(p graphql.ResolveParams) (interface{}, error)

func RewardV0State__TotalMined__resolve 

func RewardV0State__TotalMined__resolve(p graphql.ResolveParams) (interface{}, error)

func RewardV2State__BaselineTotal__resolve 

func RewardV2State__BaselineTotal__resolve(p graphql.ResolveParams) (interface{}, error)

func RewardV2State__CumsumBaseline__resolve 

func RewardV2State__CumsumBaseline__resolve(p graphql.ResolveParams) (interface{}, error)

func RewardV2State__CumsumRealized__resolve 

func RewardV2State__CumsumRealized__resolve(p graphql.ResolveParams) (interface{}, error)

func RewardV2State__EffectiveBaselinePower__resolve 

func RewardV2State__EffectiveBaselinePower__resolve(p graphql.ResolveParams) (interface{}, error)

func RewardV2State__EffectiveNetworkTime__resolve 

func RewardV2State__EffectiveNetworkTime__resolve(p graphql.ResolveParams) (interface{}, error)

func RewardV2State__Epoch__resolve 

func RewardV2State__Epoch__resolve(p graphql.ResolveParams) (interface{}, error)

func RewardV2State__SimpleTotal__resolve 

func RewardV2State__SimpleTotal__resolve(p graphql.ResolveParams) (interface{}, error)

func RewardV2State__ThisEpochBaselinePower__resolve 

func RewardV2State__ThisEpochBaselinePower__resolve(p graphql.ResolveParams) (interface{}, error)

func RewardV2State__ThisEpochRewardSmoothed__resolve 

func RewardV2State__ThisEpochRewardSmoothed__resolve(p graphql.ResolveParams) (interface{}, error)

func RewardV2State__ThisEpochReward__resolve 

func RewardV2State__ThisEpochReward__resolve(p graphql.ResolveParams) (interface{}, error)

func RewardV2State__TotalStoragePowerReward__resolve 

func RewardV2State__TotalStoragePowerReward__resolve(p graphql.ResolveParams) (interface{}, error)

func SealVerifyInfo__DealIDs__resolve 

func SealVerifyInfo__DealIDs__resolve(p graphql.ResolveParams) (interface{}, error)

func SealVerifyInfo__InteractiveRandomness__resolve 

func SealVerifyInfo__InteractiveRandomness__resolve(p graphql.ResolveParams) (interface{}, error)

func SealVerifyInfo__Proof__resolve 

func SealVerifyInfo__Proof__resolve(p graphql.ResolveParams) (interface{}, error)

func SealVerifyInfo__Randomness__resolve 

func SealVerifyInfo__Randomness__resolve(p graphql.ResolveParams) (interface{}, error)

func SealVerifyInfo__SealProof__resolve 

func SealVerifyInfo__SealProof__resolve(p graphql.ResolveParams) (interface{}, error)

func SealVerifyInfo__SealedCID__resolve 

func SealVerifyInfo__SealedCID__resolve(p graphql.ResolveParams) (interface{}, error)

func SealVerifyInfo__SectorID__resolve 

func SealVerifyInfo__SectorID__resolve(p graphql.ResolveParams) (interface{}, error)

func SealVerifyInfo__UnsealedCID__resolve 

func SealVerifyInfo__UnsealedCID__resolve(p graphql.ResolveParams) (interface{}, error)

func SectorNumber__type__parse 

func SectorNumber__type__parse(value interface{}) interface{}

func SectorNumber__type__parseLiteral 

func SectorNumber__type__parseLiteral(valueAST ast.Value) interface{}

func SectorNumber__type__serialize 

func SectorNumber__type__serialize(value interface{}) interface{}

func SectorSize__type__parse 

func SectorSize__type__parse(value interface{}) interface{}

func SectorSize__type__parseLiteral 

func SectorSize__type__parseLiteral(valueAST ast.Value) interface{}

func SectorSize__type__serialize 

func SectorSize__type__serialize(value interface{}) interface{}

func Signature__type__parse 

func Signature__type__parse(value interface{}) interface{}

func Signature__type__parseLiteral 

func Signature__type__parseLiteral(valueAST ast.Value) interface{}

func Signature__type__serialize 

func Signature__type__serialize(value interface{}) interface{}

func SignedVoucher__Amount__resolve 

func SignedVoucher__Amount__resolve(p graphql.ResolveParams) (interface{}, error)

func SignedVoucher__ChannelAddr__resolve 

func SignedVoucher__ChannelAddr__resolve(p graphql.ResolveParams) (interface{}, error)

func SignedVoucher__Extra__resolve 

func SignedVoucher__Extra__resolve(p graphql.ResolveParams) (interface{}, error)

func SignedVoucher__Lane__resolve 

func SignedVoucher__Lane__resolve(p graphql.ResolveParams) (interface{}, error)

func SignedVoucher__Merges__resolve 

func SignedVoucher__Merges__resolve(p graphql.ResolveParams) (interface{}, error)

func SignedVoucher__MinSettleHeight__resolve 

func SignedVoucher__MinSettleHeight__resolve(p graphql.ResolveParams) (interface{}, error)

func SignedVoucher__Nonce__resolve 

func SignedVoucher__Nonce__resolve(p graphql.ResolveParams) (interface{}, error)

func SignedVoucher__SecretPreimage__resolve 

func SignedVoucher__SecretPreimage__resolve(p graphql.ResolveParams) (interface{}, error)

func SignedVoucher__Signature__resolve 

func SignedVoucher__Signature__resolve(p graphql.ResolveParams) (interface{}, error)

func SignedVoucher__TimeLockMax__resolve 

func SignedVoucher__TimeLockMax__resolve(p graphql.ResolveParams) (interface{}, error)

func SignedVoucher__TimeLockMin__resolve 

func SignedVoucher__TimeLockMin__resolve(p graphql.ResolveParams) (interface{}, error)

func UnpaddedPieceSize__type__parse 

func UnpaddedPieceSize__type__parse(value interface{}) interface{}

func UnpaddedPieceSize__type__parseLiteral 

func UnpaddedPieceSize__type__parseLiteral(valueAST ast.Value) interface{}

func UnpaddedPieceSize__type__serialize 

func UnpaddedPieceSize__type__serialize(value interface{}) interface{}

func V0FilterEstimate__PositionEstimate__resolve 

func V0FilterEstimate__PositionEstimate__resolve(p graphql.ResolveParams) (interface{}, error)

func V0FilterEstimate__VelocityEstimate__resolve 

func V0FilterEstimate__VelocityEstimate__resolve(p graphql.ResolveParams) (interface{}, error)

func VerifregV0State__RootKey__resolve 

func VerifregV0State__RootKey__resolve(p graphql.ResolveParams) (interface{}, error)

func VerifregV0State__VerifiedClients__resolve 

func VerifregV0State__VerifiedClients__resolve(p graphql.ResolveParams) (interface{}, error)

func VerifregV0State__Verifiers__resolve 

func VerifregV0State__Verifiers__resolve(p graphql.ResolveParams) (interface{}, error)

Types

This section is empty.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.