mutation.go

// Code generated by ent, DO NOT EDIT.

package ent

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

	"entgo.io/ent"
	"entgo.io/ent/dialect/sql"
	"github.com/google/uuid"
	"github.com/omni-network/omni/explorer/db/ent/block"
	"github.com/omni-network/omni/explorer/db/ent/chain"
	"github.com/omni-network/omni/explorer/db/ent/msg"
	"github.com/omni-network/omni/explorer/db/ent/predicate"
	"github.com/omni-network/omni/explorer/db/ent/receipt"
	"github.com/omni-network/omni/explorer/db/ent/xprovidercursor"
)

const (
	// Operation types.
	OpCreate    = ent.OpCreate
	OpDelete    = ent.OpDelete
	OpDeleteOne = ent.OpDeleteOne
	OpUpdate    = ent.OpUpdate
	OpUpdateOne = ent.OpUpdateOne

	// Node types.
	TypeBlock           = "Block"
	TypeChain           = "Chain"
	TypeMsg             = "Msg"
	TypeReceipt         = "Receipt"
	TypeXProviderCursor = "XProviderCursor"
)

// BlockMutation represents an operation that mutates the Block nodes in the graph.
type BlockMutation struct {
	config
	op              Op
	typ             string
	id              *int
	hash            *[]byte
	chain_id        *uint64
	addchain_id     *int64
	height          *uint64
	addheight       *int64
	_offset         *uint64
	add_offset      *int64
	timestamp       *time.Time
	created_at      *time.Time
	clearedFields   map[string]struct{}
	msgs            map[int]struct{}
	removedmsgs     map[int]struct{}
	clearedmsgs     bool
	receipts        map[int]struct{}
	removedreceipts map[int]struct{}
	clearedreceipts bool
	done            bool
	oldValue        func(context.Context) (*Block, error)
	predicates      []predicate.Block
}

var _ ent.Mutation = (*BlockMutation)(nil)

// blockOption allows management of the mutation configuration using functional options.
type blockOption func(*BlockMutation)

// newBlockMutation creates new mutation for the Block entity.
func newBlockMutation(c config, op Op, opts ...blockOption) *BlockMutation {
	m := &BlockMutation{
		config:        c,
		op:            op,
		typ:           TypeBlock,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

// withBlockID sets the ID field of the mutation.
func withBlockID(id int) blockOption {
	return func(m *BlockMutation) {
		var (
			err   error
			once  sync.Once
			value *Block
		)
		m.oldValue = func(ctx context.Context) (*Block, error) {
			once.Do(func() {
				if m.done {
					err = errors.New("querying old values post mutation is not allowed")
				} else {
					value, err = m.Client().Block.Get(ctx, id)
				}
			})
			return value, err
		}
		m.id = &id
	}
}

// withBlock sets the old Block of the mutation.
func withBlock(node *Block) blockOption {
	return func(m *BlockMutation) {
		m.oldValue = func(context.Context) (*Block, error) {
			return node, nil
		}
		m.id = &node.ID
	}
}

// Client returns a new `ent.Client` from the mutation. If the mutation was
// executed in a transaction (ent.Tx), a transactional client is returned.
func (m BlockMutation) Client() *Client {
	client := &Client{config: m.config}
	client.init()
	return client
}

// Tx returns an `ent.Tx` for mutations that were executed in transactions;
// it returns an error otherwise.
func (m BlockMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// ID returns the ID value in the mutation. Note that the ID is only available
// if it was provided to the builder or after it was returned from the database.
func (m *BlockMutation) ID() (id int, exists bool) {
	if m.id == nil {
		return
	}
	return *m.id, true
}

// IDs queries the database and returns the entity ids that match the mutation's predicate.
// That means, if the mutation is applied within a transaction with an isolation level such
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
// or updated by the mutation.
func (m *BlockMutation) IDs(ctx context.Context) ([]int, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []int{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().Block.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

// SetHash sets the "hash" field.
func (m *BlockMutation) SetHash(b []byte) {
	m.hash = &b
}

// Hash returns the value of the "hash" field in the mutation.
func (m *BlockMutation) Hash() (r []byte, exists bool) {
	v := m.hash
	if v == nil {
		return
	}
	return *v, true
}

// OldHash returns the old "hash" field's value of the Block entity.
// If the Block object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *BlockMutation) OldHash(ctx context.Context) (v []byte, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldHash is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldHash requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldHash: %w", err)
	}
	return oldValue.Hash, nil
}

// ResetHash resets all changes to the "hash" field.
func (m *BlockMutation) ResetHash() {
	m.hash = nil
}

// SetChainID sets the "chain_id" field.
func (m *BlockMutation) SetChainID(u uint64) {
	m.chain_id = &u
	m.addchain_id = nil
}

// ChainID returns the value of the "chain_id" field in the mutation.
func (m *BlockMutation) ChainID() (r uint64, exists bool) {
	v := m.chain_id
	if v == nil {
		return
	}
	return *v, true
}

// OldChainID returns the old "chain_id" field's value of the Block entity.
// If the Block object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *BlockMutation) OldChainID(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldChainID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldChainID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldChainID: %w", err)
	}
	return oldValue.ChainID, nil
}

// AddChainID adds u to the "chain_id" field.
func (m *BlockMutation) AddChainID(u int64) {
	if m.addchain_id != nil {
		*m.addchain_id += u
	} else {
		m.addchain_id = &u
	}
}

// AddedChainID returns the value that was added to the "chain_id" field in this mutation.
func (m *BlockMutation) AddedChainID() (r int64, exists bool) {
	v := m.addchain_id
	if v == nil {
		return
	}
	return *v, true
}

// ResetChainID resets all changes to the "chain_id" field.
func (m *BlockMutation) ResetChainID() {
	m.chain_id = nil
	m.addchain_id = nil
}

// SetHeight sets the "height" field.
func (m *BlockMutation) SetHeight(u uint64) {
	m.height = &u
	m.addheight = nil
}

// Height returns the value of the "height" field in the mutation.
func (m *BlockMutation) Height() (r uint64, exists bool) {
	v := m.height
	if v == nil {
		return
	}
	return *v, true
}

// OldHeight returns the old "height" field's value of the Block entity.
// If the Block object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *BlockMutation) OldHeight(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldHeight is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldHeight requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldHeight: %w", err)
	}
	return oldValue.Height, nil
}

// AddHeight adds u to the "height" field.
func (m *BlockMutation) AddHeight(u int64) {
	if m.addheight != nil {
		*m.addheight += u
	} else {
		m.addheight = &u
	}
}

// AddedHeight returns the value that was added to the "height" field in this mutation.
func (m *BlockMutation) AddedHeight() (r int64, exists bool) {
	v := m.addheight
	if v == nil {
		return
	}
	return *v, true
}

// ResetHeight resets all changes to the "height" field.
func (m *BlockMutation) ResetHeight() {
	m.height = nil
	m.addheight = nil
}

// SetOffset sets the "offset" field.
func (m *BlockMutation) SetOffset(u uint64) {
	m._offset = &u
	m.add_offset = nil
}

// Offset returns the value of the "offset" field in the mutation.
func (m *BlockMutation) Offset() (r uint64, exists bool) {
	v := m._offset
	if v == nil {
		return
	}
	return *v, true
}

// OldOffset returns the old "offset" field's value of the Block entity.
// If the Block object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *BlockMutation) OldOffset(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldOffset is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldOffset requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldOffset: %w", err)
	}
	return oldValue.Offset, nil
}

// AddOffset adds u to the "offset" field.
func (m *BlockMutation) AddOffset(u int64) {
	if m.add_offset != nil {
		*m.add_offset += u
	} else {
		m.add_offset = &u
	}
}

// AddedOffset returns the value that was added to the "offset" field in this mutation.
func (m *BlockMutation) AddedOffset() (r int64, exists bool) {
	v := m.add_offset
	if v == nil {
		return
	}
	return *v, true
}

// ResetOffset resets all changes to the "offset" field.
func (m *BlockMutation) ResetOffset() {
	m._offset = nil
	m.add_offset = nil
}

// SetTimestamp sets the "timestamp" field.
func (m *BlockMutation) SetTimestamp(t time.Time) {
	m.timestamp = &t
}

// Timestamp returns the value of the "timestamp" field in the mutation.
func (m *BlockMutation) Timestamp() (r time.Time, exists bool) {
	v := m.timestamp
	if v == nil {
		return
	}
	return *v, true
}

// OldTimestamp returns the old "timestamp" field's value of the Block entity.
// If the Block object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *BlockMutation) OldTimestamp(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldTimestamp is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldTimestamp requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldTimestamp: %w", err)
	}
	return oldValue.Timestamp, nil
}

// ResetTimestamp resets all changes to the "timestamp" field.
func (m *BlockMutation) ResetTimestamp() {
	m.timestamp = nil
}

// SetCreatedAt sets the "created_at" field.
func (m *BlockMutation) SetCreatedAt(t time.Time) {
	m.created_at = &t
}

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *BlockMutation) CreatedAt() (r time.Time, exists bool) {
	v := m.created_at
	if v == nil {
		return
	}
	return *v, true
}

// OldCreatedAt returns the old "created_at" field's value of the Block entity.
// If the Block object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *BlockMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
	}
	return oldValue.CreatedAt, nil
}

// ResetCreatedAt resets all changes to the "created_at" field.
func (m *BlockMutation) ResetCreatedAt() {
	m.created_at = nil
}

// AddMsgIDs adds the "msgs" edge to the Msg entity by ids.
func (m *BlockMutation) AddMsgIDs(ids ...int) {
	if m.msgs == nil {
		m.msgs = make(map[int]struct{})
	}
	for i := range ids {
		m.msgs[ids[i]] = struct{}{}
	}
}

// ClearMsgs clears the "msgs" edge to the Msg entity.
func (m *BlockMutation) ClearMsgs() {
	m.clearedmsgs = true
}

// MsgsCleared reports if the "msgs" edge to the Msg entity was cleared.
func (m *BlockMutation) MsgsCleared() bool {
	return m.clearedmsgs
}

// RemoveMsgIDs removes the "msgs" edge to the Msg entity by IDs.
func (m *BlockMutation) RemoveMsgIDs(ids ...int) {
	if m.removedmsgs == nil {
		m.removedmsgs = make(map[int]struct{})
	}
	for i := range ids {
		delete(m.msgs, ids[i])
		m.removedmsgs[ids[i]] = struct{}{}
	}
}

// RemovedMsgs returns the removed IDs of the "msgs" edge to the Msg entity.
func (m *BlockMutation) RemovedMsgsIDs() (ids []int) {
	for id := range m.removedmsgs {
		ids = append(ids, id)
	}
	return
}

// MsgsIDs returns the "msgs" edge IDs in the mutation.
func (m *BlockMutation) MsgsIDs() (ids []int) {
	for id := range m.msgs {
		ids = append(ids, id)
	}
	return
}

// ResetMsgs resets all changes to the "msgs" edge.
func (m *BlockMutation) ResetMsgs() {
	m.msgs = nil
	m.clearedmsgs = false
	m.removedmsgs = nil
}

// AddReceiptIDs adds the "receipts" edge to the Receipt entity by ids.
func (m *BlockMutation) AddReceiptIDs(ids ...int) {
	if m.receipts == nil {
		m.receipts = make(map[int]struct{})
	}
	for i := range ids {
		m.receipts[ids[i]] = struct{}{}
	}
}

// ClearReceipts clears the "receipts" edge to the Receipt entity.
func (m *BlockMutation) ClearReceipts() {
	m.clearedreceipts = true
}

// ReceiptsCleared reports if the "receipts" edge to the Receipt entity was cleared.
func (m *BlockMutation) ReceiptsCleared() bool {
	return m.clearedreceipts
}

// RemoveReceiptIDs removes the "receipts" edge to the Receipt entity by IDs.
func (m *BlockMutation) RemoveReceiptIDs(ids ...int) {
	if m.removedreceipts == nil {
		m.removedreceipts = make(map[int]struct{})
	}
	for i := range ids {
		delete(m.receipts, ids[i])
		m.removedreceipts[ids[i]] = struct{}{}
	}
}

// RemovedReceipts returns the removed IDs of the "receipts" edge to the Receipt entity.
func (m *BlockMutation) RemovedReceiptsIDs() (ids []int) {
	for id := range m.removedreceipts {
		ids = append(ids, id)
	}
	return
}

// ReceiptsIDs returns the "receipts" edge IDs in the mutation.
func (m *BlockMutation) ReceiptsIDs() (ids []int) {
	for id := range m.receipts {
		ids = append(ids, id)
	}
	return
}

// ResetReceipts resets all changes to the "receipts" edge.
func (m *BlockMutation) ResetReceipts() {
	m.receipts = nil
	m.clearedreceipts = false
	m.removedreceipts = nil
}

// Where appends a list predicates to the BlockMutation builder.
func (m *BlockMutation) Where(ps ...predicate.Block) {
	m.predicates = append(m.predicates, ps...)
}

// WhereP appends storage-level predicates to the BlockMutation builder. Using this method,
// users can use type-assertion to append predicates that do not depend on any generated package.
func (m *BlockMutation) WhereP(ps ...func(*sql.Selector)) {
	p := make([]predicate.Block, len(ps))
	for i := range ps {
		p[i] = ps[i]
	}
	m.Where(p...)
}

// Op returns the operation name.
func (m *BlockMutation) Op() Op {
	return m.op
}

// SetOp allows setting the mutation operation.
func (m *BlockMutation) SetOp(op Op) {
	m.op = op
}

// Type returns the node type of this mutation (Block).
func (m *BlockMutation) Type() string {
	return m.typ
}

// Fields returns all fields that were changed during this mutation. Note that in
// order to get all numeric fields that were incremented/decremented, call
// AddedFields().
func (m *BlockMutation) Fields() []string {
	fields := make([]string, 0, 6)
	if m.hash != nil {
		fields = append(fields, block.FieldHash)
	}
	if m.chain_id != nil {
		fields = append(fields, block.FieldChainID)
	}
	if m.height != nil {
		fields = append(fields, block.FieldHeight)
	}
	if m._offset != nil {
		fields = append(fields, block.FieldOffset)
	}
	if m.timestamp != nil {
		fields = append(fields, block.FieldTimestamp)
	}
	if m.created_at != nil {
		fields = append(fields, block.FieldCreatedAt)
	}
	return fields
}

// Field returns the value of a field with the given name. The second boolean
// return value indicates that this field was not set, or was not defined in the
// schema.
func (m *BlockMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case block.FieldHash:
		return m.Hash()
	case block.FieldChainID:
		return m.ChainID()
	case block.FieldHeight:
		return m.Height()
	case block.FieldOffset:
		return m.Offset()
	case block.FieldTimestamp:
		return m.Timestamp()
	case block.FieldCreatedAt:
		return m.CreatedAt()
	}
	return nil, false
}

// OldField returns the old value of the field from the database. An error is
// returned if the mutation operation is not UpdateOne, or the query to the
// database failed.
func (m *BlockMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case block.FieldHash:
		return m.OldHash(ctx)
	case block.FieldChainID:
		return m.OldChainID(ctx)
	case block.FieldHeight:
		return m.OldHeight(ctx)
	case block.FieldOffset:
		return m.OldOffset(ctx)
	case block.FieldTimestamp:
		return m.OldTimestamp(ctx)
	case block.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	}
	return nil, fmt.Errorf("unknown Block field %s", name)
}

// SetField sets the value of a field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *BlockMutation) SetField(name string, value ent.Value) error {
	switch name {
	case block.FieldHash:
		v, ok := value.([]byte)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetHash(v)
		return nil
	case block.FieldChainID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetChainID(v)
		return nil
	case block.FieldHeight:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetHeight(v)
		return nil
	case block.FieldOffset:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOffset(v)
		return nil
	case block.FieldTimestamp:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTimestamp(v)
		return nil
	case block.FieldCreatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	}
	return fmt.Errorf("unknown Block field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *BlockMutation) AddedFields() []string {
	var fields []string
	if m.addchain_id != nil {
		fields = append(fields, block.FieldChainID)
	}
	if m.addheight != nil {
		fields = append(fields, block.FieldHeight)
	}
	if m.add_offset != nil {
		fields = append(fields, block.FieldOffset)
	}
	return fields
}

// AddedField returns the numeric value that was incremented/decremented on a field
// with the given name. The second boolean return value indicates that this field
// was not set, or was not defined in the schema.
func (m *BlockMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case block.FieldChainID:
		return m.AddedChainID()
	case block.FieldHeight:
		return m.AddedHeight()
	case block.FieldOffset:
		return m.AddedOffset()
	}
	return nil, false
}

// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *BlockMutation) AddField(name string, value ent.Value) error {
	switch name {
	case block.FieldChainID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddChainID(v)
		return nil
	case block.FieldHeight:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddHeight(v)
		return nil
	case block.FieldOffset:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOffset(v)
		return nil
	}
	return fmt.Errorf("unknown Block numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *BlockMutation) ClearedFields() []string {
	return nil
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *BlockMutation) FieldCleared(name string) bool {
	_, ok := m.clearedFields[name]
	return ok
}

// ClearField clears the value of the field with the given name. It returns an
// error if the field is not defined in the schema.
func (m *BlockMutation) ClearField(name string) error {
	return fmt.Errorf("unknown Block nullable field %s", name)
}

// ResetField resets all changes in the mutation for the field with the given name.
// It returns an error if the field is not defined in the schema.
func (m *BlockMutation) ResetField(name string) error {
	switch name {
	case block.FieldHash:
		m.ResetHash()
		return nil
	case block.FieldChainID:
		m.ResetChainID()
		return nil
	case block.FieldHeight:
		m.ResetHeight()
		return nil
	case block.FieldOffset:
		m.ResetOffset()
		return nil
	case block.FieldTimestamp:
		m.ResetTimestamp()
		return nil
	case block.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	}
	return fmt.Errorf("unknown Block field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *BlockMutation) AddedEdges() []string {
	edges := make([]string, 0, 2)
	if m.msgs != nil {
		edges = append(edges, block.EdgeMsgs)
	}
	if m.receipts != nil {
		edges = append(edges, block.EdgeReceipts)
	}
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *BlockMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case block.EdgeMsgs:
		ids := make([]ent.Value, 0, len(m.msgs))
		for id := range m.msgs {
			ids = append(ids, id)
		}
		return ids
	case block.EdgeReceipts:
		ids := make([]ent.Value, 0, len(m.receipts))
		for id := range m.receipts {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *BlockMutation) RemovedEdges() []string {
	edges := make([]string, 0, 2)
	if m.removedmsgs != nil {
		edges = append(edges, block.EdgeMsgs)
	}
	if m.removedreceipts != nil {
		edges = append(edges, block.EdgeReceipts)
	}
	return edges
}

// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
// the given name in this mutation.
func (m *BlockMutation) RemovedIDs(name string) []ent.Value {
	switch name {
	case block.EdgeMsgs:
		ids := make([]ent.Value, 0, len(m.removedmsgs))
		for id := range m.removedmsgs {
			ids = append(ids, id)
		}
		return ids
	case block.EdgeReceipts:
		ids := make([]ent.Value, 0, len(m.removedreceipts))
		for id := range m.removedreceipts {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *BlockMutation) ClearedEdges() []string {
	edges := make([]string, 0, 2)
	if m.clearedmsgs {
		edges = append(edges, block.EdgeMsgs)
	}
	if m.clearedreceipts {
		edges = append(edges, block.EdgeReceipts)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *BlockMutation) EdgeCleared(name string) bool {
	switch name {
	case block.EdgeMsgs:
		return m.clearedmsgs
	case block.EdgeReceipts:
		return m.clearedreceipts
	}
	return false
}

// ClearEdge clears the value of the edge with the given name. It returns an error
// if that edge is not defined in the schema.
func (m *BlockMutation) ClearEdge(name string) error {
	switch name {
	}
	return fmt.Errorf("unknown Block unique edge %s", name)
}

// ResetEdge resets all changes to the edge with the given name in this mutation.
// It returns an error if the edge is not defined in the schema.
func (m *BlockMutation) ResetEdge(name string) error {
	switch name {
	case block.EdgeMsgs:
		m.ResetMsgs()
		return nil
	case block.EdgeReceipts:
		m.ResetReceipts()
		return nil
	}
	return fmt.Errorf("unknown Block edge %s", name)
}

// ChainMutation represents an operation that mutates the Chain nodes in the graph.
type ChainMutation struct {
	config
	op            Op
	typ           string
	id            *int
	chain_id      *uint64
	addchain_id   *int64
	created_at    *time.Time
	name          *string
	clearedFields map[string]struct{}
	done          bool
	oldValue      func(context.Context) (*Chain, error)
	predicates    []predicate.Chain
}

var _ ent.Mutation = (*ChainMutation)(nil)

// chainOption allows management of the mutation configuration using functional options.
type chainOption func(*ChainMutation)

// newChainMutation creates new mutation for the Chain entity.
func newChainMutation(c config, op Op, opts ...chainOption) *ChainMutation {
	m := &ChainMutation{
		config:        c,
		op:            op,
		typ:           TypeChain,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

// withChainID sets the ID field of the mutation.
func withChainID(id int) chainOption {
	return func(m *ChainMutation) {
		var (
			err   error
			once  sync.Once
			value *Chain
		)
		m.oldValue = func(ctx context.Context) (*Chain, error) {
			once.Do(func() {
				if m.done {
					err = errors.New("querying old values post mutation is not allowed")
				} else {
					value, err = m.Client().Chain.Get(ctx, id)
				}
			})
			return value, err
		}
		m.id = &id
	}
}

// withChain sets the old Chain of the mutation.
func withChain(node *Chain) chainOption {
	return func(m *ChainMutation) {
		m.oldValue = func(context.Context) (*Chain, error) {
			return node, nil
		}
		m.id = &node.ID
	}
}

// Client returns a new `ent.Client` from the mutation. If the mutation was
// executed in a transaction (ent.Tx), a transactional client is returned.
func (m ChainMutation) Client() *Client {
	client := &Client{config: m.config}
	client.init()
	return client
}

// Tx returns an `ent.Tx` for mutations that were executed in transactions;
// it returns an error otherwise.
func (m ChainMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// ID returns the ID value in the mutation. Note that the ID is only available
// if it was provided to the builder or after it was returned from the database.
func (m *ChainMutation) ID() (id int, exists bool) {
	if m.id == nil {
		return
	}
	return *m.id, true
}

// IDs queries the database and returns the entity ids that match the mutation's predicate.
// That means, if the mutation is applied within a transaction with an isolation level such
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
// or updated by the mutation.
func (m *ChainMutation) IDs(ctx context.Context) ([]int, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []int{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().Chain.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

// SetChainID sets the "chain_id" field.
func (m *ChainMutation) SetChainID(u uint64) {
	m.chain_id = &u
	m.addchain_id = nil
}

// ChainID returns the value of the "chain_id" field in the mutation.
func (m *ChainMutation) ChainID() (r uint64, exists bool) {
	v := m.chain_id
	if v == nil {
		return
	}
	return *v, true
}

// OldChainID returns the old "chain_id" field's value of the Chain entity.
// If the Chain object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ChainMutation) OldChainID(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldChainID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldChainID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldChainID: %w", err)
	}
	return oldValue.ChainID, nil
}

// AddChainID adds u to the "chain_id" field.
func (m *ChainMutation) AddChainID(u int64) {
	if m.addchain_id != nil {
		*m.addchain_id += u
	} else {
		m.addchain_id = &u
	}
}

// AddedChainID returns the value that was added to the "chain_id" field in this mutation.
func (m *ChainMutation) AddedChainID() (r int64, exists bool) {
	v := m.addchain_id
	if v == nil {
		return
	}
	return *v, true
}

// ResetChainID resets all changes to the "chain_id" field.
func (m *ChainMutation) ResetChainID() {
	m.chain_id = nil
	m.addchain_id = nil
}

// SetCreatedAt sets the "created_at" field.
func (m *ChainMutation) SetCreatedAt(t time.Time) {
	m.created_at = &t
}

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *ChainMutation) CreatedAt() (r time.Time, exists bool) {
	v := m.created_at
	if v == nil {
		return
	}
	return *v, true
}

// OldCreatedAt returns the old "created_at" field's value of the Chain entity.
// If the Chain object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ChainMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
	}
	return oldValue.CreatedAt, nil
}

// ResetCreatedAt resets all changes to the "created_at" field.
func (m *ChainMutation) ResetCreatedAt() {
	m.created_at = nil
}

// SetName sets the "name" field.
func (m *ChainMutation) SetName(s string) {
	m.name = &s
}

// Name returns the value of the "name" field in the mutation.
func (m *ChainMutation) Name() (r string, exists bool) {
	v := m.name
	if v == nil {
		return
	}
	return *v, true
}

// OldName returns the old "name" field's value of the Chain entity.
// If the Chain object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ChainMutation) OldName(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldName is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldName requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldName: %w", err)
	}
	return oldValue.Name, nil
}

// ResetName resets all changes to the "name" field.
func (m *ChainMutation) ResetName() {
	m.name = nil
}

// Where appends a list predicates to the ChainMutation builder.
func (m *ChainMutation) Where(ps ...predicate.Chain) {
	m.predicates = append(m.predicates, ps...)
}

// WhereP appends storage-level predicates to the ChainMutation builder. Using this method,
// users can use type-assertion to append predicates that do not depend on any generated package.
func (m *ChainMutation) WhereP(ps ...func(*sql.Selector)) {
	p := make([]predicate.Chain, len(ps))
	for i := range ps {
		p[i] = ps[i]
	}
	m.Where(p...)
}

// Op returns the operation name.
func (m *ChainMutation) Op() Op {
	return m.op
}

// SetOp allows setting the mutation operation.
func (m *ChainMutation) SetOp(op Op) {
	m.op = op
}

// Type returns the node type of this mutation (Chain).
func (m *ChainMutation) Type() string {
	return m.typ
}

// Fields returns all fields that were changed during this mutation. Note that in
// order to get all numeric fields that were incremented/decremented, call
// AddedFields().
func (m *ChainMutation) Fields() []string {
	fields := make([]string, 0, 3)
	if m.chain_id != nil {
		fields = append(fields, chain.FieldChainID)
	}
	if m.created_at != nil {
		fields = append(fields, chain.FieldCreatedAt)
	}
	if m.name != nil {
		fields = append(fields, chain.FieldName)
	}
	return fields
}

// Field returns the value of a field with the given name. The second boolean
// return value indicates that this field was not set, or was not defined in the
// schema.
func (m *ChainMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case chain.FieldChainID:
		return m.ChainID()
	case chain.FieldCreatedAt:
		return m.CreatedAt()
	case chain.FieldName:
		return m.Name()
	}
	return nil, false
}

// OldField returns the old value of the field from the database. An error is
// returned if the mutation operation is not UpdateOne, or the query to the
// database failed.
func (m *ChainMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case chain.FieldChainID:
		return m.OldChainID(ctx)
	case chain.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case chain.FieldName:
		return m.OldName(ctx)
	}
	return nil, fmt.Errorf("unknown Chain field %s", name)
}

// SetField sets the value of a field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *ChainMutation) SetField(name string, value ent.Value) error {
	switch name {
	case chain.FieldChainID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetChainID(v)
		return nil
	case chain.FieldCreatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case chain.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	}
	return fmt.Errorf("unknown Chain field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *ChainMutation) AddedFields() []string {
	var fields []string
	if m.addchain_id != nil {
		fields = append(fields, chain.FieldChainID)
	}
	return fields
}

// AddedField returns the numeric value that was incremented/decremented on a field
// with the given name. The second boolean return value indicates that this field
// was not set, or was not defined in the schema.
func (m *ChainMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case chain.FieldChainID:
		return m.AddedChainID()
	}
	return nil, false
}

// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *ChainMutation) AddField(name string, value ent.Value) error {
	switch name {
	case chain.FieldChainID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddChainID(v)
		return nil
	}
	return fmt.Errorf("unknown Chain numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *ChainMutation) ClearedFields() []string {
	return nil
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *ChainMutation) FieldCleared(name string) bool {
	_, ok := m.clearedFields[name]
	return ok
}

// ClearField clears the value of the field with the given name. It returns an
// error if the field is not defined in the schema.
func (m *ChainMutation) ClearField(name string) error {
	return fmt.Errorf("unknown Chain nullable field %s", name)
}

// ResetField resets all changes in the mutation for the field with the given name.
// It returns an error if the field is not defined in the schema.
func (m *ChainMutation) ResetField(name string) error {
	switch name {
	case chain.FieldChainID:
		m.ResetChainID()
		return nil
	case chain.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case chain.FieldName:
		m.ResetName()
		return nil
	}
	return fmt.Errorf("unknown Chain field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *ChainMutation) AddedEdges() []string {
	edges := make([]string, 0, 0)
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *ChainMutation) AddedIDs(name string) []ent.Value {
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *ChainMutation) RemovedEdges() []string {
	edges := make([]string, 0, 0)
	return edges
}

// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
// the given name in this mutation.
func (m *ChainMutation) RemovedIDs(name string) []ent.Value {
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *ChainMutation) ClearedEdges() []string {
	edges := make([]string, 0, 0)
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *ChainMutation) EdgeCleared(name string) bool {
	return false
}

// ClearEdge clears the value of the edge with the given name. It returns an error
// if that edge is not defined in the schema.
func (m *ChainMutation) ClearEdge(name string) error {
	return fmt.Errorf("unknown Chain unique edge %s", name)
}

// ResetEdge resets all changes to the edge with the given name in this mutation.
// It returns an error if the edge is not defined in the schema.
func (m *ChainMutation) ResetEdge(name string) error {
	return fmt.Errorf("unknown Chain edge %s", name)
}

// MsgMutation represents an operation that mutates the Msg nodes in the graph.
type MsgMutation struct {
	config
	op                 Op
	typ                string
	id                 *int
	sender             *[]byte
	to                 *[]byte
	data               *[]byte
	gas_limit          *uint64
	addgas_limit       *int64
	source_chain_id    *uint64
	addsource_chain_id *int64
	dest_chain_id      *uint64
	adddest_chain_id   *int64
	_offset            *uint64
	add_offset         *int64
	tx_hash            *[]byte
	receipt_hash       *[]byte
	status             *string
	created_at         *time.Time
	clearedFields      map[string]struct{}
	block              map[int]struct{}
	removedblock       map[int]struct{}
	clearedblock       bool
	receipts           map[int]struct{}
	removedreceipts    map[int]struct{}
	clearedreceipts    bool
	done               bool
	oldValue           func(context.Context) (*Msg, error)
	predicates         []predicate.Msg
}

var _ ent.Mutation = (*MsgMutation)(nil)

// msgOption allows management of the mutation configuration using functional options.
type msgOption func(*MsgMutation)

// newMsgMutation creates new mutation for the Msg entity.
func newMsgMutation(c config, op Op, opts ...msgOption) *MsgMutation {
	m := &MsgMutation{
		config:        c,
		op:            op,
		typ:           TypeMsg,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

// withMsgID sets the ID field of the mutation.
func withMsgID(id int) msgOption {
	return func(m *MsgMutation) {
		var (
			err   error
			once  sync.Once
			value *Msg
		)
		m.oldValue = func(ctx context.Context) (*Msg, error) {
			once.Do(func() {
				if m.done {
					err = errors.New("querying old values post mutation is not allowed")
				} else {
					value, err = m.Client().Msg.Get(ctx, id)
				}
			})
			return value, err
		}
		m.id = &id
	}
}

// withMsg sets the old Msg of the mutation.
func withMsg(node *Msg) msgOption {
	return func(m *MsgMutation) {
		m.oldValue = func(context.Context) (*Msg, error) {
			return node, nil
		}
		m.id = &node.ID
	}
}

// Client returns a new `ent.Client` from the mutation. If the mutation was
// executed in a transaction (ent.Tx), a transactional client is returned.
func (m MsgMutation) Client() *Client {
	client := &Client{config: m.config}
	client.init()
	return client
}

// Tx returns an `ent.Tx` for mutations that were executed in transactions;
// it returns an error otherwise.
func (m MsgMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// ID returns the ID value in the mutation. Note that the ID is only available
// if it was provided to the builder or after it was returned from the database.
func (m *MsgMutation) ID() (id int, exists bool) {
	if m.id == nil {
		return
	}
	return *m.id, true
}

// IDs queries the database and returns the entity ids that match the mutation's predicate.
// That means, if the mutation is applied within a transaction with an isolation level such
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
// or updated by the mutation.
func (m *MsgMutation) IDs(ctx context.Context) ([]int, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []int{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().Msg.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

// SetSender sets the "sender" field.
func (m *MsgMutation) SetSender(b []byte) {
	m.sender = &b
}

// Sender returns the value of the "sender" field in the mutation.
func (m *MsgMutation) Sender() (r []byte, exists bool) {
	v := m.sender
	if v == nil {
		return
	}
	return *v, true
}

// OldSender returns the old "sender" field's value of the Msg entity.
// If the Msg object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *MsgMutation) OldSender(ctx context.Context) (v []byte, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldSender is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldSender requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldSender: %w", err)
	}
	return oldValue.Sender, nil
}

// ResetSender resets all changes to the "sender" field.
func (m *MsgMutation) ResetSender() {
	m.sender = nil
}

// SetTo sets the "to" field.
func (m *MsgMutation) SetTo(b []byte) {
	m.to = &b
}

// To returns the value of the "to" field in the mutation.
func (m *MsgMutation) To() (r []byte, exists bool) {
	v := m.to
	if v == nil {
		return
	}
	return *v, true
}

// OldTo returns the old "to" field's value of the Msg entity.
// If the Msg object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *MsgMutation) OldTo(ctx context.Context) (v []byte, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldTo is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldTo requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldTo: %w", err)
	}
	return oldValue.To, nil
}

// ResetTo resets all changes to the "to" field.
func (m *MsgMutation) ResetTo() {
	m.to = nil
}

// SetData sets the "data" field.
func (m *MsgMutation) SetData(b []byte) {
	m.data = &b
}

// Data returns the value of the "data" field in the mutation.
func (m *MsgMutation) Data() (r []byte, exists bool) {
	v := m.data
	if v == nil {
		return
	}
	return *v, true
}

// OldData returns the old "data" field's value of the Msg entity.
// If the Msg object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *MsgMutation) OldData(ctx context.Context) (v []byte, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldData is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldData requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldData: %w", err)
	}
	return oldValue.Data, nil
}

// ResetData resets all changes to the "data" field.
func (m *MsgMutation) ResetData() {
	m.data = nil
}

// SetGasLimit sets the "gas_limit" field.
func (m *MsgMutation) SetGasLimit(u uint64) {
	m.gas_limit = &u
	m.addgas_limit = nil
}

// GasLimit returns the value of the "gas_limit" field in the mutation.
func (m *MsgMutation) GasLimit() (r uint64, exists bool) {
	v := m.gas_limit
	if v == nil {
		return
	}
	return *v, true
}

// OldGasLimit returns the old "gas_limit" field's value of the Msg entity.
// If the Msg object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *MsgMutation) OldGasLimit(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldGasLimit is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldGasLimit requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldGasLimit: %w", err)
	}
	return oldValue.GasLimit, nil
}

// AddGasLimit adds u to the "gas_limit" field.
func (m *MsgMutation) AddGasLimit(u int64) {
	if m.addgas_limit != nil {
		*m.addgas_limit += u
	} else {
		m.addgas_limit = &u
	}
}

// AddedGasLimit returns the value that was added to the "gas_limit" field in this mutation.
func (m *MsgMutation) AddedGasLimit() (r int64, exists bool) {
	v := m.addgas_limit
	if v == nil {
		return
	}
	return *v, true
}

// ResetGasLimit resets all changes to the "gas_limit" field.
func (m *MsgMutation) ResetGasLimit() {
	m.gas_limit = nil
	m.addgas_limit = nil
}

// SetSourceChainID sets the "source_chain_id" field.
func (m *MsgMutation) SetSourceChainID(u uint64) {
	m.source_chain_id = &u
	m.addsource_chain_id = nil
}

// SourceChainID returns the value of the "source_chain_id" field in the mutation.
func (m *MsgMutation) SourceChainID() (r uint64, exists bool) {
	v := m.source_chain_id
	if v == nil {
		return
	}
	return *v, true
}

// OldSourceChainID returns the old "source_chain_id" field's value of the Msg entity.
// If the Msg object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *MsgMutation) OldSourceChainID(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldSourceChainID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldSourceChainID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldSourceChainID: %w", err)
	}
	return oldValue.SourceChainID, nil
}

// AddSourceChainID adds u to the "source_chain_id" field.
func (m *MsgMutation) AddSourceChainID(u int64) {
	if m.addsource_chain_id != nil {
		*m.addsource_chain_id += u
	} else {
		m.addsource_chain_id = &u
	}
}

// AddedSourceChainID returns the value that was added to the "source_chain_id" field in this mutation.
func (m *MsgMutation) AddedSourceChainID() (r int64, exists bool) {
	v := m.addsource_chain_id
	if v == nil {
		return
	}
	return *v, true
}

// ResetSourceChainID resets all changes to the "source_chain_id" field.
func (m *MsgMutation) ResetSourceChainID() {
	m.source_chain_id = nil
	m.addsource_chain_id = nil
}

// SetDestChainID sets the "dest_chain_id" field.
func (m *MsgMutation) SetDestChainID(u uint64) {
	m.dest_chain_id = &u
	m.adddest_chain_id = nil
}

// DestChainID returns the value of the "dest_chain_id" field in the mutation.
func (m *MsgMutation) DestChainID() (r uint64, exists bool) {
	v := m.dest_chain_id
	if v == nil {
		return
	}
	return *v, true
}

// OldDestChainID returns the old "dest_chain_id" field's value of the Msg entity.
// If the Msg object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *MsgMutation) OldDestChainID(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldDestChainID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldDestChainID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldDestChainID: %w", err)
	}
	return oldValue.DestChainID, nil
}

// AddDestChainID adds u to the "dest_chain_id" field.
func (m *MsgMutation) AddDestChainID(u int64) {
	if m.adddest_chain_id != nil {
		*m.adddest_chain_id += u
	} else {
		m.adddest_chain_id = &u
	}
}

// AddedDestChainID returns the value that was added to the "dest_chain_id" field in this mutation.
func (m *MsgMutation) AddedDestChainID() (r int64, exists bool) {
	v := m.adddest_chain_id
	if v == nil {
		return
	}
	return *v, true
}

// ResetDestChainID resets all changes to the "dest_chain_id" field.
func (m *MsgMutation) ResetDestChainID() {
	m.dest_chain_id = nil
	m.adddest_chain_id = nil
}

// SetOffset sets the "offset" field.
func (m *MsgMutation) SetOffset(u uint64) {
	m._offset = &u
	m.add_offset = nil
}

// Offset returns the value of the "offset" field in the mutation.
func (m *MsgMutation) Offset() (r uint64, exists bool) {
	v := m._offset
	if v == nil {
		return
	}
	return *v, true
}

// OldOffset returns the old "offset" field's value of the Msg entity.
// If the Msg object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *MsgMutation) OldOffset(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldOffset is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldOffset requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldOffset: %w", err)
	}
	return oldValue.Offset, nil
}

// AddOffset adds u to the "offset" field.
func (m *MsgMutation) AddOffset(u int64) {
	if m.add_offset != nil {
		*m.add_offset += u
	} else {
		m.add_offset = &u
	}
}

// AddedOffset returns the value that was added to the "offset" field in this mutation.
func (m *MsgMutation) AddedOffset() (r int64, exists bool) {
	v := m.add_offset
	if v == nil {
		return
	}
	return *v, true
}

// ResetOffset resets all changes to the "offset" field.
func (m *MsgMutation) ResetOffset() {
	m._offset = nil
	m.add_offset = nil
}

// SetTxHash sets the "tx_hash" field.
func (m *MsgMutation) SetTxHash(b []byte) {
	m.tx_hash = &b
}

// TxHash returns the value of the "tx_hash" field in the mutation.
func (m *MsgMutation) TxHash() (r []byte, exists bool) {
	v := m.tx_hash
	if v == nil {
		return
	}
	return *v, true
}

// OldTxHash returns the old "tx_hash" field's value of the Msg entity.
// If the Msg object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *MsgMutation) OldTxHash(ctx context.Context) (v []byte, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldTxHash is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldTxHash requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldTxHash: %w", err)
	}
	return oldValue.TxHash, nil
}

// ResetTxHash resets all changes to the "tx_hash" field.
func (m *MsgMutation) ResetTxHash() {
	m.tx_hash = nil
}

// SetReceiptHash sets the "receipt_hash" field.
func (m *MsgMutation) SetReceiptHash(b []byte) {
	m.receipt_hash = &b
}

// ReceiptHash returns the value of the "receipt_hash" field in the mutation.
func (m *MsgMutation) ReceiptHash() (r []byte, exists bool) {
	v := m.receipt_hash
	if v == nil {
		return
	}
	return *v, true
}

// OldReceiptHash returns the old "receipt_hash" field's value of the Msg entity.
// If the Msg object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *MsgMutation) OldReceiptHash(ctx context.Context) (v []byte, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldReceiptHash is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldReceiptHash requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldReceiptHash: %w", err)
	}
	return oldValue.ReceiptHash, nil
}

// ClearReceiptHash clears the value of the "receipt_hash" field.
func (m *MsgMutation) ClearReceiptHash() {
	m.receipt_hash = nil
	m.clearedFields[msg.FieldReceiptHash] = struct{}{}
}

// ReceiptHashCleared returns if the "receipt_hash" field was cleared in this mutation.
func (m *MsgMutation) ReceiptHashCleared() bool {
	_, ok := m.clearedFields[msg.FieldReceiptHash]
	return ok
}

// ResetReceiptHash resets all changes to the "receipt_hash" field.
func (m *MsgMutation) ResetReceiptHash() {
	m.receipt_hash = nil
	delete(m.clearedFields, msg.FieldReceiptHash)
}

// SetStatus sets the "status" field.
func (m *MsgMutation) SetStatus(s string) {
	m.status = &s
}

// Status returns the value of the "status" field in the mutation.
func (m *MsgMutation) Status() (r string, exists bool) {
	v := m.status
	if v == nil {
		return
	}
	return *v, true
}

// OldStatus returns the old "status" field's value of the Msg entity.
// If the Msg object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *MsgMutation) OldStatus(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldStatus is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldStatus requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldStatus: %w", err)
	}
	return oldValue.Status, nil
}

// ClearStatus clears the value of the "status" field.
func (m *MsgMutation) ClearStatus() {
	m.status = nil
	m.clearedFields[msg.FieldStatus] = struct{}{}
}

// StatusCleared returns if the "status" field was cleared in this mutation.
func (m *MsgMutation) StatusCleared() bool {
	_, ok := m.clearedFields[msg.FieldStatus]
	return ok
}

// ResetStatus resets all changes to the "status" field.
func (m *MsgMutation) ResetStatus() {
	m.status = nil
	delete(m.clearedFields, msg.FieldStatus)
}

// SetCreatedAt sets the "created_at" field.
func (m *MsgMutation) SetCreatedAt(t time.Time) {
	m.created_at = &t
}

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *MsgMutation) CreatedAt() (r time.Time, exists bool) {
	v := m.created_at
	if v == nil {
		return
	}
	return *v, true
}

// OldCreatedAt returns the old "created_at" field's value of the Msg entity.
// If the Msg object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *MsgMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
	}
	return oldValue.CreatedAt, nil
}

// ResetCreatedAt resets all changes to the "created_at" field.
func (m *MsgMutation) ResetCreatedAt() {
	m.created_at = nil
}

// AddBlockIDs adds the "block" edge to the Block entity by ids.
func (m *MsgMutation) AddBlockIDs(ids ...int) {
	if m.block == nil {
		m.block = make(map[int]struct{})
	}
	for i := range ids {
		m.block[ids[i]] = struct{}{}
	}
}

// ClearBlock clears the "block" edge to the Block entity.
func (m *MsgMutation) ClearBlock() {
	m.clearedblock = true
}

// BlockCleared reports if the "block" edge to the Block entity was cleared.
func (m *MsgMutation) BlockCleared() bool {
	return m.clearedblock
}

// RemoveBlockIDs removes the "block" edge to the Block entity by IDs.
func (m *MsgMutation) RemoveBlockIDs(ids ...int) {
	if m.removedblock == nil {
		m.removedblock = make(map[int]struct{})
	}
	for i := range ids {
		delete(m.block, ids[i])
		m.removedblock[ids[i]] = struct{}{}
	}
}

// RemovedBlock returns the removed IDs of the "block" edge to the Block entity.
func (m *MsgMutation) RemovedBlockIDs() (ids []int) {
	for id := range m.removedblock {
		ids = append(ids, id)
	}
	return
}

// BlockIDs returns the "block" edge IDs in the mutation.
func (m *MsgMutation) BlockIDs() (ids []int) {
	for id := range m.block {
		ids = append(ids, id)
	}
	return
}

// ResetBlock resets all changes to the "block" edge.
func (m *MsgMutation) ResetBlock() {
	m.block = nil
	m.clearedblock = false
	m.removedblock = nil
}

// AddReceiptIDs adds the "receipts" edge to the Receipt entity by ids.
func (m *MsgMutation) AddReceiptIDs(ids ...int) {
	if m.receipts == nil {
		m.receipts = make(map[int]struct{})
	}
	for i := range ids {
		m.receipts[ids[i]] = struct{}{}
	}
}

// ClearReceipts clears the "receipts" edge to the Receipt entity.
func (m *MsgMutation) ClearReceipts() {
	m.clearedreceipts = true
}

// ReceiptsCleared reports if the "receipts" edge to the Receipt entity was cleared.
func (m *MsgMutation) ReceiptsCleared() bool {
	return m.clearedreceipts
}

// RemoveReceiptIDs removes the "receipts" edge to the Receipt entity by IDs.
func (m *MsgMutation) RemoveReceiptIDs(ids ...int) {
	if m.removedreceipts == nil {
		m.removedreceipts = make(map[int]struct{})
	}
	for i := range ids {
		delete(m.receipts, ids[i])
		m.removedreceipts[ids[i]] = struct{}{}
	}
}

// RemovedReceipts returns the removed IDs of the "receipts" edge to the Receipt entity.
func (m *MsgMutation) RemovedReceiptsIDs() (ids []int) {
	for id := range m.removedreceipts {
		ids = append(ids, id)
	}
	return
}

// ReceiptsIDs returns the "receipts" edge IDs in the mutation.
func (m *MsgMutation) ReceiptsIDs() (ids []int) {
	for id := range m.receipts {
		ids = append(ids, id)
	}
	return
}

// ResetReceipts resets all changes to the "receipts" edge.
func (m *MsgMutation) ResetReceipts() {
	m.receipts = nil
	m.clearedreceipts = false
	m.removedreceipts = nil
}

// Where appends a list predicates to the MsgMutation builder.
func (m *MsgMutation) Where(ps ...predicate.Msg) {
	m.predicates = append(m.predicates, ps...)
}

// WhereP appends storage-level predicates to the MsgMutation builder. Using this method,
// users can use type-assertion to append predicates that do not depend on any generated package.
func (m *MsgMutation) WhereP(ps ...func(*sql.Selector)) {
	p := make([]predicate.Msg, len(ps))
	for i := range ps {
		p[i] = ps[i]
	}
	m.Where(p...)
}

// Op returns the operation name.
func (m *MsgMutation) Op() Op {
	return m.op
}

// SetOp allows setting the mutation operation.
func (m *MsgMutation) SetOp(op Op) {
	m.op = op
}

// Type returns the node type of this mutation (Msg).
func (m *MsgMutation) Type() string {
	return m.typ
}

// Fields returns all fields that were changed during this mutation. Note that in
// order to get all numeric fields that were incremented/decremented, call
// AddedFields().
func (m *MsgMutation) Fields() []string {
	fields := make([]string, 0, 11)
	if m.sender != nil {
		fields = append(fields, msg.FieldSender)
	}
	if m.to != nil {
		fields = append(fields, msg.FieldTo)
	}
	if m.data != nil {
		fields = append(fields, msg.FieldData)
	}
	if m.gas_limit != nil {
		fields = append(fields, msg.FieldGasLimit)
	}
	if m.source_chain_id != nil {
		fields = append(fields, msg.FieldSourceChainID)
	}
	if m.dest_chain_id != nil {
		fields = append(fields, msg.FieldDestChainID)
	}
	if m._offset != nil {
		fields = append(fields, msg.FieldOffset)
	}
	if m.tx_hash != nil {
		fields = append(fields, msg.FieldTxHash)
	}
	if m.receipt_hash != nil {
		fields = append(fields, msg.FieldReceiptHash)
	}
	if m.status != nil {
		fields = append(fields, msg.FieldStatus)
	}
	if m.created_at != nil {
		fields = append(fields, msg.FieldCreatedAt)
	}
	return fields
}

// Field returns the value of a field with the given name. The second boolean
// return value indicates that this field was not set, or was not defined in the
// schema.
func (m *MsgMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case msg.FieldSender:
		return m.Sender()
	case msg.FieldTo:
		return m.To()
	case msg.FieldData:
		return m.Data()
	case msg.FieldGasLimit:
		return m.GasLimit()
	case msg.FieldSourceChainID:
		return m.SourceChainID()
	case msg.FieldDestChainID:
		return m.DestChainID()
	case msg.FieldOffset:
		return m.Offset()
	case msg.FieldTxHash:
		return m.TxHash()
	case msg.FieldReceiptHash:
		return m.ReceiptHash()
	case msg.FieldStatus:
		return m.Status()
	case msg.FieldCreatedAt:
		return m.CreatedAt()
	}
	return nil, false
}

// OldField returns the old value of the field from the database. An error is
// returned if the mutation operation is not UpdateOne, or the query to the
// database failed.
func (m *MsgMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case msg.FieldSender:
		return m.OldSender(ctx)
	case msg.FieldTo:
		return m.OldTo(ctx)
	case msg.FieldData:
		return m.OldData(ctx)
	case msg.FieldGasLimit:
		return m.OldGasLimit(ctx)
	case msg.FieldSourceChainID:
		return m.OldSourceChainID(ctx)
	case msg.FieldDestChainID:
		return m.OldDestChainID(ctx)
	case msg.FieldOffset:
		return m.OldOffset(ctx)
	case msg.FieldTxHash:
		return m.OldTxHash(ctx)
	case msg.FieldReceiptHash:
		return m.OldReceiptHash(ctx)
	case msg.FieldStatus:
		return m.OldStatus(ctx)
	case msg.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	}
	return nil, fmt.Errorf("unknown Msg field %s", name)
}

// SetField sets the value of a field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *MsgMutation) SetField(name string, value ent.Value) error {
	switch name {
	case msg.FieldSender:
		v, ok := value.([]byte)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSender(v)
		return nil
	case msg.FieldTo:
		v, ok := value.([]byte)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTo(v)
		return nil
	case msg.FieldData:
		v, ok := value.([]byte)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetData(v)
		return nil
	case msg.FieldGasLimit:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetGasLimit(v)
		return nil
	case msg.FieldSourceChainID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSourceChainID(v)
		return nil
	case msg.FieldDestChainID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDestChainID(v)
		return nil
	case msg.FieldOffset:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOffset(v)
		return nil
	case msg.FieldTxHash:
		v, ok := value.([]byte)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTxHash(v)
		return nil
	case msg.FieldReceiptHash:
		v, ok := value.([]byte)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetReceiptHash(v)
		return nil
	case msg.FieldStatus:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case msg.FieldCreatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	}
	return fmt.Errorf("unknown Msg field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *MsgMutation) AddedFields() []string {
	var fields []string
	if m.addgas_limit != nil {
		fields = append(fields, msg.FieldGasLimit)
	}
	if m.addsource_chain_id != nil {
		fields = append(fields, msg.FieldSourceChainID)
	}
	if m.adddest_chain_id != nil {
		fields = append(fields, msg.FieldDestChainID)
	}
	if m.add_offset != nil {
		fields = append(fields, msg.FieldOffset)
	}
	return fields
}

// AddedField returns the numeric value that was incremented/decremented on a field
// with the given name. The second boolean return value indicates that this field
// was not set, or was not defined in the schema.
func (m *MsgMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case msg.FieldGasLimit:
		return m.AddedGasLimit()
	case msg.FieldSourceChainID:
		return m.AddedSourceChainID()
	case msg.FieldDestChainID:
		return m.AddedDestChainID()
	case msg.FieldOffset:
		return m.AddedOffset()
	}
	return nil, false
}

// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *MsgMutation) AddField(name string, value ent.Value) error {
	switch name {
	case msg.FieldGasLimit:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddGasLimit(v)
		return nil
	case msg.FieldSourceChainID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddSourceChainID(v)
		return nil
	case msg.FieldDestChainID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDestChainID(v)
		return nil
	case msg.FieldOffset:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOffset(v)
		return nil
	}
	return fmt.Errorf("unknown Msg numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *MsgMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(msg.FieldReceiptHash) {
		fields = append(fields, msg.FieldReceiptHash)
	}
	if m.FieldCleared(msg.FieldStatus) {
		fields = append(fields, msg.FieldStatus)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *MsgMutation) FieldCleared(name string) bool {
	_, ok := m.clearedFields[name]
	return ok
}

// ClearField clears the value of the field with the given name. It returns an
// error if the field is not defined in the schema.
func (m *MsgMutation) ClearField(name string) error {
	switch name {
	case msg.FieldReceiptHash:
		m.ClearReceiptHash()
		return nil
	case msg.FieldStatus:
		m.ClearStatus()
		return nil
	}
	return fmt.Errorf("unknown Msg nullable field %s", name)
}

// ResetField resets all changes in the mutation for the field with the given name.
// It returns an error if the field is not defined in the schema.
func (m *MsgMutation) ResetField(name string) error {
	switch name {
	case msg.FieldSender:
		m.ResetSender()
		return nil
	case msg.FieldTo:
		m.ResetTo()
		return nil
	case msg.FieldData:
		m.ResetData()
		return nil
	case msg.FieldGasLimit:
		m.ResetGasLimit()
		return nil
	case msg.FieldSourceChainID:
		m.ResetSourceChainID()
		return nil
	case msg.FieldDestChainID:
		m.ResetDestChainID()
		return nil
	case msg.FieldOffset:
		m.ResetOffset()
		return nil
	case msg.FieldTxHash:
		m.ResetTxHash()
		return nil
	case msg.FieldReceiptHash:
		m.ResetReceiptHash()
		return nil
	case msg.FieldStatus:
		m.ResetStatus()
		return nil
	case msg.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	}
	return fmt.Errorf("unknown Msg field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *MsgMutation) AddedEdges() []string {
	edges := make([]string, 0, 2)
	if m.block != nil {
		edges = append(edges, msg.EdgeBlock)
	}
	if m.receipts != nil {
		edges = append(edges, msg.EdgeReceipts)
	}
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *MsgMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case msg.EdgeBlock:
		ids := make([]ent.Value, 0, len(m.block))
		for id := range m.block {
			ids = append(ids, id)
		}
		return ids
	case msg.EdgeReceipts:
		ids := make([]ent.Value, 0, len(m.receipts))
		for id := range m.receipts {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *MsgMutation) RemovedEdges() []string {
	edges := make([]string, 0, 2)
	if m.removedblock != nil {
		edges = append(edges, msg.EdgeBlock)
	}
	if m.removedreceipts != nil {
		edges = append(edges, msg.EdgeReceipts)
	}
	return edges
}

// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
// the given name in this mutation.
func (m *MsgMutation) RemovedIDs(name string) []ent.Value {
	switch name {
	case msg.EdgeBlock:
		ids := make([]ent.Value, 0, len(m.removedblock))
		for id := range m.removedblock {
			ids = append(ids, id)
		}
		return ids
	case msg.EdgeReceipts:
		ids := make([]ent.Value, 0, len(m.removedreceipts))
		for id := range m.removedreceipts {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *MsgMutation) ClearedEdges() []string {
	edges := make([]string, 0, 2)
	if m.clearedblock {
		edges = append(edges, msg.EdgeBlock)
	}
	if m.clearedreceipts {
		edges = append(edges, msg.EdgeReceipts)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *MsgMutation) EdgeCleared(name string) bool {
	switch name {
	case msg.EdgeBlock:
		return m.clearedblock
	case msg.EdgeReceipts:
		return m.clearedreceipts
	}
	return false
}

// ClearEdge clears the value of the edge with the given name. It returns an error
// if that edge is not defined in the schema.
func (m *MsgMutation) ClearEdge(name string) error {
	switch name {
	}
	return fmt.Errorf("unknown Msg unique edge %s", name)
}

// ResetEdge resets all changes to the edge with the given name in this mutation.
// It returns an error if the edge is not defined in the schema.
func (m *MsgMutation) ResetEdge(name string) error {
	switch name {
	case msg.EdgeBlock:
		m.ResetBlock()
		return nil
	case msg.EdgeReceipts:
		m.ResetReceipts()
		return nil
	}
	return fmt.Errorf("unknown Msg edge %s", name)
}

// ReceiptMutation represents an operation that mutates the Receipt nodes in the graph.
type ReceiptMutation struct {
	config
	op                 Op
	typ                string
	id                 *int
	block_hash         *[]byte
	gas_used           *uint64
	addgas_used        *int64
	success            *bool
	relayer_address    *[]byte
	source_chain_id    *uint64
	addsource_chain_id *int64
	dest_chain_id      *uint64
	adddest_chain_id   *int64
	_offset            *uint64
	add_offset         *int64
	tx_hash            *[]byte
	created_at         *time.Time
	revert_reason      *string
	clearedFields      map[string]struct{}
	block              map[int]struct{}
	removedblock       map[int]struct{}
	clearedblock       bool
	msgs               map[int]struct{}
	removedmsgs        map[int]struct{}
	clearedmsgs        bool
	done               bool
	oldValue           func(context.Context) (*Receipt, error)
	predicates         []predicate.Receipt
}

var _ ent.Mutation = (*ReceiptMutation)(nil)

// receiptOption allows management of the mutation configuration using functional options.
type receiptOption func(*ReceiptMutation)

// newReceiptMutation creates new mutation for the Receipt entity.
func newReceiptMutation(c config, op Op, opts ...receiptOption) *ReceiptMutation {
	m := &ReceiptMutation{
		config:        c,
		op:            op,
		typ:           TypeReceipt,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

// withReceiptID sets the ID field of the mutation.
func withReceiptID(id int) receiptOption {
	return func(m *ReceiptMutation) {
		var (
			err   error
			once  sync.Once
			value *Receipt
		)
		m.oldValue = func(ctx context.Context) (*Receipt, error) {
			once.Do(func() {
				if m.done {
					err = errors.New("querying old values post mutation is not allowed")
				} else {
					value, err = m.Client().Receipt.Get(ctx, id)
				}
			})
			return value, err
		}
		m.id = &id
	}
}

// withReceipt sets the old Receipt of the mutation.
func withReceipt(node *Receipt) receiptOption {
	return func(m *ReceiptMutation) {
		m.oldValue = func(context.Context) (*Receipt, error) {
			return node, nil
		}
		m.id = &node.ID
	}
}

// Client returns a new `ent.Client` from the mutation. If the mutation was
// executed in a transaction (ent.Tx), a transactional client is returned.
func (m ReceiptMutation) Client() *Client {
	client := &Client{config: m.config}
	client.init()
	return client
}

// Tx returns an `ent.Tx` for mutations that were executed in transactions;
// it returns an error otherwise.
func (m ReceiptMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// ID returns the ID value in the mutation. Note that the ID is only available
// if it was provided to the builder or after it was returned from the database.
func (m *ReceiptMutation) ID() (id int, exists bool) {
	if m.id == nil {
		return
	}
	return *m.id, true
}

// IDs queries the database and returns the entity ids that match the mutation's predicate.
// That means, if the mutation is applied within a transaction with an isolation level such
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
// or updated by the mutation.
func (m *ReceiptMutation) IDs(ctx context.Context) ([]int, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []int{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().Receipt.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

// SetBlockHash sets the "block_hash" field.
func (m *ReceiptMutation) SetBlockHash(b []byte) {
	m.block_hash = &b
}

// BlockHash returns the value of the "block_hash" field in the mutation.
func (m *ReceiptMutation) BlockHash() (r []byte, exists bool) {
	v := m.block_hash
	if v == nil {
		return
	}
	return *v, true
}

// OldBlockHash returns the old "block_hash" field's value of the Receipt entity.
// If the Receipt object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ReceiptMutation) OldBlockHash(ctx context.Context) (v []byte, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldBlockHash is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldBlockHash requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldBlockHash: %w", err)
	}
	return oldValue.BlockHash, nil
}

// ResetBlockHash resets all changes to the "block_hash" field.
func (m *ReceiptMutation) ResetBlockHash() {
	m.block_hash = nil
}

// SetGasUsed sets the "gas_used" field.
func (m *ReceiptMutation) SetGasUsed(u uint64) {
	m.gas_used = &u
	m.addgas_used = nil
}

// GasUsed returns the value of the "gas_used" field in the mutation.
func (m *ReceiptMutation) GasUsed() (r uint64, exists bool) {
	v := m.gas_used
	if v == nil {
		return
	}
	return *v, true
}

// OldGasUsed returns the old "gas_used" field's value of the Receipt entity.
// If the Receipt object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ReceiptMutation) OldGasUsed(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldGasUsed is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldGasUsed requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldGasUsed: %w", err)
	}
	return oldValue.GasUsed, nil
}

// AddGasUsed adds u to the "gas_used" field.
func (m *ReceiptMutation) AddGasUsed(u int64) {
	if m.addgas_used != nil {
		*m.addgas_used += u
	} else {
		m.addgas_used = &u
	}
}

// AddedGasUsed returns the value that was added to the "gas_used" field in this mutation.
func (m *ReceiptMutation) AddedGasUsed() (r int64, exists bool) {
	v := m.addgas_used
	if v == nil {
		return
	}
	return *v, true
}

// ResetGasUsed resets all changes to the "gas_used" field.
func (m *ReceiptMutation) ResetGasUsed() {
	m.gas_used = nil
	m.addgas_used = nil
}

// SetSuccess sets the "success" field.
func (m *ReceiptMutation) SetSuccess(b bool) {
	m.success = &b
}

// Success returns the value of the "success" field in the mutation.
func (m *ReceiptMutation) Success() (r bool, exists bool) {
	v := m.success
	if v == nil {
		return
	}
	return *v, true
}

// OldSuccess returns the old "success" field's value of the Receipt entity.
// If the Receipt object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ReceiptMutation) OldSuccess(ctx context.Context) (v bool, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldSuccess is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldSuccess requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldSuccess: %w", err)
	}
	return oldValue.Success, nil
}

// ResetSuccess resets all changes to the "success" field.
func (m *ReceiptMutation) ResetSuccess() {
	m.success = nil
}

// SetRelayerAddress sets the "relayer_address" field.
func (m *ReceiptMutation) SetRelayerAddress(b []byte) {
	m.relayer_address = &b
}

// RelayerAddress returns the value of the "relayer_address" field in the mutation.
func (m *ReceiptMutation) RelayerAddress() (r []byte, exists bool) {
	v := m.relayer_address
	if v == nil {
		return
	}
	return *v, true
}

// OldRelayerAddress returns the old "relayer_address" field's value of the Receipt entity.
// If the Receipt object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ReceiptMutation) OldRelayerAddress(ctx context.Context) (v []byte, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldRelayerAddress is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldRelayerAddress requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldRelayerAddress: %w", err)
	}
	return oldValue.RelayerAddress, nil
}

// ResetRelayerAddress resets all changes to the "relayer_address" field.
func (m *ReceiptMutation) ResetRelayerAddress() {
	m.relayer_address = nil
}

// SetSourceChainID sets the "source_chain_id" field.
func (m *ReceiptMutation) SetSourceChainID(u uint64) {
	m.source_chain_id = &u
	m.addsource_chain_id = nil
}

// SourceChainID returns the value of the "source_chain_id" field in the mutation.
func (m *ReceiptMutation) SourceChainID() (r uint64, exists bool) {
	v := m.source_chain_id
	if v == nil {
		return
	}
	return *v, true
}

// OldSourceChainID returns the old "source_chain_id" field's value of the Receipt entity.
// If the Receipt object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ReceiptMutation) OldSourceChainID(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldSourceChainID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldSourceChainID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldSourceChainID: %w", err)
	}
	return oldValue.SourceChainID, nil
}

// AddSourceChainID adds u to the "source_chain_id" field.
func (m *ReceiptMutation) AddSourceChainID(u int64) {
	if m.addsource_chain_id != nil {
		*m.addsource_chain_id += u
	} else {
		m.addsource_chain_id = &u
	}
}

// AddedSourceChainID returns the value that was added to the "source_chain_id" field in this mutation.
func (m *ReceiptMutation) AddedSourceChainID() (r int64, exists bool) {
	v := m.addsource_chain_id
	if v == nil {
		return
	}
	return *v, true
}

// ResetSourceChainID resets all changes to the "source_chain_id" field.
func (m *ReceiptMutation) ResetSourceChainID() {
	m.source_chain_id = nil
	m.addsource_chain_id = nil
}

// SetDestChainID sets the "dest_chain_id" field.
func (m *ReceiptMutation) SetDestChainID(u uint64) {
	m.dest_chain_id = &u
	m.adddest_chain_id = nil
}

// DestChainID returns the value of the "dest_chain_id" field in the mutation.
func (m *ReceiptMutation) DestChainID() (r uint64, exists bool) {
	v := m.dest_chain_id
	if v == nil {
		return
	}
	return *v, true
}

// OldDestChainID returns the old "dest_chain_id" field's value of the Receipt entity.
// If the Receipt object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ReceiptMutation) OldDestChainID(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldDestChainID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldDestChainID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldDestChainID: %w", err)
	}
	return oldValue.DestChainID, nil
}

// AddDestChainID adds u to the "dest_chain_id" field.
func (m *ReceiptMutation) AddDestChainID(u int64) {
	if m.adddest_chain_id != nil {
		*m.adddest_chain_id += u
	} else {
		m.adddest_chain_id = &u
	}
}

// AddedDestChainID returns the value that was added to the "dest_chain_id" field in this mutation.
func (m *ReceiptMutation) AddedDestChainID() (r int64, exists bool) {
	v := m.adddest_chain_id
	if v == nil {
		return
	}
	return *v, true
}

// ResetDestChainID resets all changes to the "dest_chain_id" field.
func (m *ReceiptMutation) ResetDestChainID() {
	m.dest_chain_id = nil
	m.adddest_chain_id = nil
}

// SetOffset sets the "offset" field.
func (m *ReceiptMutation) SetOffset(u uint64) {
	m._offset = &u
	m.add_offset = nil
}

// Offset returns the value of the "offset" field in the mutation.
func (m *ReceiptMutation) Offset() (r uint64, exists bool) {
	v := m._offset
	if v == nil {
		return
	}
	return *v, true
}

// OldOffset returns the old "offset" field's value of the Receipt entity.
// If the Receipt object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ReceiptMutation) OldOffset(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldOffset is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldOffset requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldOffset: %w", err)
	}
	return oldValue.Offset, nil
}

// AddOffset adds u to the "offset" field.
func (m *ReceiptMutation) AddOffset(u int64) {
	if m.add_offset != nil {
		*m.add_offset += u
	} else {
		m.add_offset = &u
	}
}

// AddedOffset returns the value that was added to the "offset" field in this mutation.
func (m *ReceiptMutation) AddedOffset() (r int64, exists bool) {
	v := m.add_offset
	if v == nil {
		return
	}
	return *v, true
}

// ResetOffset resets all changes to the "offset" field.
func (m *ReceiptMutation) ResetOffset() {
	m._offset = nil
	m.add_offset = nil
}

// SetTxHash sets the "tx_hash" field.
func (m *ReceiptMutation) SetTxHash(b []byte) {
	m.tx_hash = &b
}

// TxHash returns the value of the "tx_hash" field in the mutation.
func (m *ReceiptMutation) TxHash() (r []byte, exists bool) {
	v := m.tx_hash
	if v == nil {
		return
	}
	return *v, true
}

// OldTxHash returns the old "tx_hash" field's value of the Receipt entity.
// If the Receipt object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ReceiptMutation) OldTxHash(ctx context.Context) (v []byte, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldTxHash is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldTxHash requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldTxHash: %w", err)
	}
	return oldValue.TxHash, nil
}

// ResetTxHash resets all changes to the "tx_hash" field.
func (m *ReceiptMutation) ResetTxHash() {
	m.tx_hash = nil
}

// SetCreatedAt sets the "created_at" field.
func (m *ReceiptMutation) SetCreatedAt(t time.Time) {
	m.created_at = &t
}

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *ReceiptMutation) CreatedAt() (r time.Time, exists bool) {
	v := m.created_at
	if v == nil {
		return
	}
	return *v, true
}

// OldCreatedAt returns the old "created_at" field's value of the Receipt entity.
// If the Receipt object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ReceiptMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
	}
	return oldValue.CreatedAt, nil
}

// ResetCreatedAt resets all changes to the "created_at" field.
func (m *ReceiptMutation) ResetCreatedAt() {
	m.created_at = nil
}

// SetRevertReason sets the "revert_reason" field.
func (m *ReceiptMutation) SetRevertReason(s string) {
	m.revert_reason = &s
}

// RevertReason returns the value of the "revert_reason" field in the mutation.
func (m *ReceiptMutation) RevertReason() (r string, exists bool) {
	v := m.revert_reason
	if v == nil {
		return
	}
	return *v, true
}

// OldRevertReason returns the old "revert_reason" field's value of the Receipt entity.
// If the Receipt object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ReceiptMutation) OldRevertReason(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldRevertReason is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldRevertReason requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldRevertReason: %w", err)
	}
	return oldValue.RevertReason, nil
}

// ClearRevertReason clears the value of the "revert_reason" field.
func (m *ReceiptMutation) ClearRevertReason() {
	m.revert_reason = nil
	m.clearedFields[receipt.FieldRevertReason] = struct{}{}
}

// RevertReasonCleared returns if the "revert_reason" field was cleared in this mutation.
func (m *ReceiptMutation) RevertReasonCleared() bool {
	_, ok := m.clearedFields[receipt.FieldRevertReason]
	return ok
}

// ResetRevertReason resets all changes to the "revert_reason" field.
func (m *ReceiptMutation) ResetRevertReason() {
	m.revert_reason = nil
	delete(m.clearedFields, receipt.FieldRevertReason)
}

// AddBlockIDs adds the "block" edge to the Block entity by ids.
func (m *ReceiptMutation) AddBlockIDs(ids ...int) {
	if m.block == nil {
		m.block = make(map[int]struct{})
	}
	for i := range ids {
		m.block[ids[i]] = struct{}{}
	}
}

// ClearBlock clears the "block" edge to the Block entity.
func (m *ReceiptMutation) ClearBlock() {
	m.clearedblock = true
}

// BlockCleared reports if the "block" edge to the Block entity was cleared.
func (m *ReceiptMutation) BlockCleared() bool {
	return m.clearedblock
}

// RemoveBlockIDs removes the "block" edge to the Block entity by IDs.
func (m *ReceiptMutation) RemoveBlockIDs(ids ...int) {
	if m.removedblock == nil {
		m.removedblock = make(map[int]struct{})
	}
	for i := range ids {
		delete(m.block, ids[i])
		m.removedblock[ids[i]] = struct{}{}
	}
}

// RemovedBlock returns the removed IDs of the "block" edge to the Block entity.
func (m *ReceiptMutation) RemovedBlockIDs() (ids []int) {
	for id := range m.removedblock {
		ids = append(ids, id)
	}
	return
}

// BlockIDs returns the "block" edge IDs in the mutation.
func (m *ReceiptMutation) BlockIDs() (ids []int) {
	for id := range m.block {
		ids = append(ids, id)
	}
	return
}

// ResetBlock resets all changes to the "block" edge.
func (m *ReceiptMutation) ResetBlock() {
	m.block = nil
	m.clearedblock = false
	m.removedblock = nil
}

// AddMsgIDs adds the "msgs" edge to the Msg entity by ids.
func (m *ReceiptMutation) AddMsgIDs(ids ...int) {
	if m.msgs == nil {
		m.msgs = make(map[int]struct{})
	}
	for i := range ids {
		m.msgs[ids[i]] = struct{}{}
	}
}

// ClearMsgs clears the "msgs" edge to the Msg entity.
func (m *ReceiptMutation) ClearMsgs() {
	m.clearedmsgs = true
}

// MsgsCleared reports if the "msgs" edge to the Msg entity was cleared.
func (m *ReceiptMutation) MsgsCleared() bool {
	return m.clearedmsgs
}

// RemoveMsgIDs removes the "msgs" edge to the Msg entity by IDs.
func (m *ReceiptMutation) RemoveMsgIDs(ids ...int) {
	if m.removedmsgs == nil {
		m.removedmsgs = make(map[int]struct{})
	}
	for i := range ids {
		delete(m.msgs, ids[i])
		m.removedmsgs[ids[i]] = struct{}{}
	}
}

// RemovedMsgs returns the removed IDs of the "msgs" edge to the Msg entity.
func (m *ReceiptMutation) RemovedMsgsIDs() (ids []int) {
	for id := range m.removedmsgs {
		ids = append(ids, id)
	}
	return
}

// MsgsIDs returns the "msgs" edge IDs in the mutation.
func (m *ReceiptMutation) MsgsIDs() (ids []int) {
	for id := range m.msgs {
		ids = append(ids, id)
	}
	return
}

// ResetMsgs resets all changes to the "msgs" edge.
func (m *ReceiptMutation) ResetMsgs() {
	m.msgs = nil
	m.clearedmsgs = false
	m.removedmsgs = nil
}

// Where appends a list predicates to the ReceiptMutation builder.
func (m *ReceiptMutation) Where(ps ...predicate.Receipt) {
	m.predicates = append(m.predicates, ps...)
}

// WhereP appends storage-level predicates to the ReceiptMutation builder. Using this method,
// users can use type-assertion to append predicates that do not depend on any generated package.
func (m *ReceiptMutation) WhereP(ps ...func(*sql.Selector)) {
	p := make([]predicate.Receipt, len(ps))
	for i := range ps {
		p[i] = ps[i]
	}
	m.Where(p...)
}

// Op returns the operation name.
func (m *ReceiptMutation) Op() Op {
	return m.op
}

// SetOp allows setting the mutation operation.
func (m *ReceiptMutation) SetOp(op Op) {
	m.op = op
}

// Type returns the node type of this mutation (Receipt).
func (m *ReceiptMutation) Type() string {
	return m.typ
}

// Fields returns all fields that were changed during this mutation. Note that in
// order to get all numeric fields that were incremented/decremented, call
// AddedFields().
func (m *ReceiptMutation) Fields() []string {
	fields := make([]string, 0, 10)
	if m.block_hash != nil {
		fields = append(fields, receipt.FieldBlockHash)
	}
	if m.gas_used != nil {
		fields = append(fields, receipt.FieldGasUsed)
	}
	if m.success != nil {
		fields = append(fields, receipt.FieldSuccess)
	}
	if m.relayer_address != nil {
		fields = append(fields, receipt.FieldRelayerAddress)
	}
	if m.source_chain_id != nil {
		fields = append(fields, receipt.FieldSourceChainID)
	}
	if m.dest_chain_id != nil {
		fields = append(fields, receipt.FieldDestChainID)
	}
	if m._offset != nil {
		fields = append(fields, receipt.FieldOffset)
	}
	if m.tx_hash != nil {
		fields = append(fields, receipt.FieldTxHash)
	}
	if m.created_at != nil {
		fields = append(fields, receipt.FieldCreatedAt)
	}
	if m.revert_reason != nil {
		fields = append(fields, receipt.FieldRevertReason)
	}
	return fields
}

// Field returns the value of a field with the given name. The second boolean
// return value indicates that this field was not set, or was not defined in the
// schema.
func (m *ReceiptMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case receipt.FieldBlockHash:
		return m.BlockHash()
	case receipt.FieldGasUsed:
		return m.GasUsed()
	case receipt.FieldSuccess:
		return m.Success()
	case receipt.FieldRelayerAddress:
		return m.RelayerAddress()
	case receipt.FieldSourceChainID:
		return m.SourceChainID()
	case receipt.FieldDestChainID:
		return m.DestChainID()
	case receipt.FieldOffset:
		return m.Offset()
	case receipt.FieldTxHash:
		return m.TxHash()
	case receipt.FieldCreatedAt:
		return m.CreatedAt()
	case receipt.FieldRevertReason:
		return m.RevertReason()
	}
	return nil, false
}

// OldField returns the old value of the field from the database. An error is
// returned if the mutation operation is not UpdateOne, or the query to the
// database failed.
func (m *ReceiptMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case receipt.FieldBlockHash:
		return m.OldBlockHash(ctx)
	case receipt.FieldGasUsed:
		return m.OldGasUsed(ctx)
	case receipt.FieldSuccess:
		return m.OldSuccess(ctx)
	case receipt.FieldRelayerAddress:
		return m.OldRelayerAddress(ctx)
	case receipt.FieldSourceChainID:
		return m.OldSourceChainID(ctx)
	case receipt.FieldDestChainID:
		return m.OldDestChainID(ctx)
	case receipt.FieldOffset:
		return m.OldOffset(ctx)
	case receipt.FieldTxHash:
		return m.OldTxHash(ctx)
	case receipt.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case receipt.FieldRevertReason:
		return m.OldRevertReason(ctx)
	}
	return nil, fmt.Errorf("unknown Receipt field %s", name)
}

// SetField sets the value of a field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *ReceiptMutation) SetField(name string, value ent.Value) error {
	switch name {
	case receipt.FieldBlockHash:
		v, ok := value.([]byte)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBlockHash(v)
		return nil
	case receipt.FieldGasUsed:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetGasUsed(v)
		return nil
	case receipt.FieldSuccess:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSuccess(v)
		return nil
	case receipt.FieldRelayerAddress:
		v, ok := value.([]byte)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetRelayerAddress(v)
		return nil
	case receipt.FieldSourceChainID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSourceChainID(v)
		return nil
	case receipt.FieldDestChainID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDestChainID(v)
		return nil
	case receipt.FieldOffset:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOffset(v)
		return nil
	case receipt.FieldTxHash:
		v, ok := value.([]byte)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTxHash(v)
		return nil
	case receipt.FieldCreatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case receipt.FieldRevertReason:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetRevertReason(v)
		return nil
	}
	return fmt.Errorf("unknown Receipt field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *ReceiptMutation) AddedFields() []string {
	var fields []string
	if m.addgas_used != nil {
		fields = append(fields, receipt.FieldGasUsed)
	}
	if m.addsource_chain_id != nil {
		fields = append(fields, receipt.FieldSourceChainID)
	}
	if m.adddest_chain_id != nil {
		fields = append(fields, receipt.FieldDestChainID)
	}
	if m.add_offset != nil {
		fields = append(fields, receipt.FieldOffset)
	}
	return fields
}

// AddedField returns the numeric value that was incremented/decremented on a field
// with the given name. The second boolean return value indicates that this field
// was not set, or was not defined in the schema.
func (m *ReceiptMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case receipt.FieldGasUsed:
		return m.AddedGasUsed()
	case receipt.FieldSourceChainID:
		return m.AddedSourceChainID()
	case receipt.FieldDestChainID:
		return m.AddedDestChainID()
	case receipt.FieldOffset:
		return m.AddedOffset()
	}
	return nil, false
}

// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *ReceiptMutation) AddField(name string, value ent.Value) error {
	switch name {
	case receipt.FieldGasUsed:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddGasUsed(v)
		return nil
	case receipt.FieldSourceChainID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddSourceChainID(v)
		return nil
	case receipt.FieldDestChainID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDestChainID(v)
		return nil
	case receipt.FieldOffset:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOffset(v)
		return nil
	}
	return fmt.Errorf("unknown Receipt numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *ReceiptMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(receipt.FieldRevertReason) {
		fields = append(fields, receipt.FieldRevertReason)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *ReceiptMutation) FieldCleared(name string) bool {
	_, ok := m.clearedFields[name]
	return ok
}

// ClearField clears the value of the field with the given name. It returns an
// error if the field is not defined in the schema.
func (m *ReceiptMutation) ClearField(name string) error {
	switch name {
	case receipt.FieldRevertReason:
		m.ClearRevertReason()
		return nil
	}
	return fmt.Errorf("unknown Receipt nullable field %s", name)
}

// ResetField resets all changes in the mutation for the field with the given name.
// It returns an error if the field is not defined in the schema.
func (m *ReceiptMutation) ResetField(name string) error {
	switch name {
	case receipt.FieldBlockHash:
		m.ResetBlockHash()
		return nil
	case receipt.FieldGasUsed:
		m.ResetGasUsed()
		return nil
	case receipt.FieldSuccess:
		m.ResetSuccess()
		return nil
	case receipt.FieldRelayerAddress:
		m.ResetRelayerAddress()
		return nil
	case receipt.FieldSourceChainID:
		m.ResetSourceChainID()
		return nil
	case receipt.FieldDestChainID:
		m.ResetDestChainID()
		return nil
	case receipt.FieldOffset:
		m.ResetOffset()
		return nil
	case receipt.FieldTxHash:
		m.ResetTxHash()
		return nil
	case receipt.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case receipt.FieldRevertReason:
		m.ResetRevertReason()
		return nil
	}
	return fmt.Errorf("unknown Receipt field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *ReceiptMutation) AddedEdges() []string {
	edges := make([]string, 0, 2)
	if m.block != nil {
		edges = append(edges, receipt.EdgeBlock)
	}
	if m.msgs != nil {
		edges = append(edges, receipt.EdgeMsgs)
	}
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *ReceiptMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case receipt.EdgeBlock:
		ids := make([]ent.Value, 0, len(m.block))
		for id := range m.block {
			ids = append(ids, id)
		}
		return ids
	case receipt.EdgeMsgs:
		ids := make([]ent.Value, 0, len(m.msgs))
		for id := range m.msgs {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *ReceiptMutation) RemovedEdges() []string {
	edges := make([]string, 0, 2)
	if m.removedblock != nil {
		edges = append(edges, receipt.EdgeBlock)
	}
	if m.removedmsgs != nil {
		edges = append(edges, receipt.EdgeMsgs)
	}
	return edges
}

// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
// the given name in this mutation.
func (m *ReceiptMutation) RemovedIDs(name string) []ent.Value {
	switch name {
	case receipt.EdgeBlock:
		ids := make([]ent.Value, 0, len(m.removedblock))
		for id := range m.removedblock {
			ids = append(ids, id)
		}
		return ids
	case receipt.EdgeMsgs:
		ids := make([]ent.Value, 0, len(m.removedmsgs))
		for id := range m.removedmsgs {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *ReceiptMutation) ClearedEdges() []string {
	edges := make([]string, 0, 2)
	if m.clearedblock {
		edges = append(edges, receipt.EdgeBlock)
	}
	if m.clearedmsgs {
		edges = append(edges, receipt.EdgeMsgs)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *ReceiptMutation) EdgeCleared(name string) bool {
	switch name {
	case receipt.EdgeBlock:
		return m.clearedblock
	case receipt.EdgeMsgs:
		return m.clearedmsgs
	}
	return false
}

// ClearEdge clears the value of the edge with the given name. It returns an error
// if that edge is not defined in the schema.
func (m *ReceiptMutation) ClearEdge(name string) error {
	switch name {
	}
	return fmt.Errorf("unknown Receipt unique edge %s", name)
}

// ResetEdge resets all changes to the edge with the given name in this mutation.
// It returns an error if the edge is not defined in the schema.
func (m *ReceiptMutation) ResetEdge(name string) error {
	switch name {
	case receipt.EdgeBlock:
		m.ResetBlock()
		return nil
	case receipt.EdgeMsgs:
		m.ResetMsgs()
		return nil
	}
	return fmt.Errorf("unknown Receipt edge %s", name)
}

// XProviderCursorMutation represents an operation that mutates the XProviderCursor nodes in the graph.
type XProviderCursorMutation struct {
	config
	op            Op
	typ           string
	id            *uuid.UUID
	chain_id      *uint64
	addchain_id   *int64
	height        *uint64
	addheight     *int64
	_offset       *uint64
	add_offset    *int64
	created_at    *time.Time
	updated_at    *time.Time
	clearedFields map[string]struct{}
	done          bool
	oldValue      func(context.Context) (*XProviderCursor, error)
	predicates    []predicate.XProviderCursor
}

var _ ent.Mutation = (*XProviderCursorMutation)(nil)

// xprovidercursorOption allows management of the mutation configuration using functional options.
type xprovidercursorOption func(*XProviderCursorMutation)

// newXProviderCursorMutation creates new mutation for the XProviderCursor entity.
func newXProviderCursorMutation(c config, op Op, opts ...xprovidercursorOption) *XProviderCursorMutation {
	m := &XProviderCursorMutation{
		config:        c,
		op:            op,
		typ:           TypeXProviderCursor,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

// withXProviderCursorID sets the ID field of the mutation.
func withXProviderCursorID(id uuid.UUID) xprovidercursorOption {
	return func(m *XProviderCursorMutation) {
		var (
			err   error
			once  sync.Once
			value *XProviderCursor
		)
		m.oldValue = func(ctx context.Context) (*XProviderCursor, error) {
			once.Do(func() {
				if m.done {
					err = errors.New("querying old values post mutation is not allowed")
				} else {
					value, err = m.Client().XProviderCursor.Get(ctx, id)
				}
			})
			return value, err
		}
		m.id = &id
	}
}

// withXProviderCursor sets the old XProviderCursor of the mutation.
func withXProviderCursor(node *XProviderCursor) xprovidercursorOption {
	return func(m *XProviderCursorMutation) {
		m.oldValue = func(context.Context) (*XProviderCursor, error) {
			return node, nil
		}
		m.id = &node.ID
	}
}

// Client returns a new `ent.Client` from the mutation. If the mutation was
// executed in a transaction (ent.Tx), a transactional client is returned.
func (m XProviderCursorMutation) Client() *Client {
	client := &Client{config: m.config}
	client.init()
	return client
}

// Tx returns an `ent.Tx` for mutations that were executed in transactions;
// it returns an error otherwise.
func (m XProviderCursorMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// SetID sets the value of the id field. Note that this
// operation is only accepted on creation of XProviderCursor entities.
func (m *XProviderCursorMutation) SetID(id uuid.UUID) {
	m.id = &id
}

// ID returns the ID value in the mutation. Note that the ID is only available
// if it was provided to the builder or after it was returned from the database.
func (m *XProviderCursorMutation) ID() (id uuid.UUID, exists bool) {
	if m.id == nil {
		return
	}
	return *m.id, true
}

// IDs queries the database and returns the entity ids that match the mutation's predicate.
// That means, if the mutation is applied within a transaction with an isolation level such
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
// or updated by the mutation.
func (m *XProviderCursorMutation) IDs(ctx context.Context) ([]uuid.UUID, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uuid.UUID{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().XProviderCursor.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

// SetChainID sets the "chain_id" field.
func (m *XProviderCursorMutation) SetChainID(u uint64) {
	m.chain_id = &u
	m.addchain_id = nil
}

// ChainID returns the value of the "chain_id" field in the mutation.
func (m *XProviderCursorMutation) ChainID() (r uint64, exists bool) {
	v := m.chain_id
	if v == nil {
		return
	}
	return *v, true
}

// OldChainID returns the old "chain_id" field's value of the XProviderCursor entity.
// If the XProviderCursor object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *XProviderCursorMutation) OldChainID(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldChainID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldChainID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldChainID: %w", err)
	}
	return oldValue.ChainID, nil
}

// AddChainID adds u to the "chain_id" field.
func (m *XProviderCursorMutation) AddChainID(u int64) {
	if m.addchain_id != nil {
		*m.addchain_id += u
	} else {
		m.addchain_id = &u
	}
}

// AddedChainID returns the value that was added to the "chain_id" field in this mutation.
func (m *XProviderCursorMutation) AddedChainID() (r int64, exists bool) {
	v := m.addchain_id
	if v == nil {
		return
	}
	return *v, true
}

// ResetChainID resets all changes to the "chain_id" field.
func (m *XProviderCursorMutation) ResetChainID() {
	m.chain_id = nil
	m.addchain_id = nil
}

// SetHeight sets the "height" field.
func (m *XProviderCursorMutation) SetHeight(u uint64) {
	m.height = &u
	m.addheight = nil
}

// Height returns the value of the "height" field in the mutation.
func (m *XProviderCursorMutation) Height() (r uint64, exists bool) {
	v := m.height
	if v == nil {
		return
	}
	return *v, true
}

// OldHeight returns the old "height" field's value of the XProviderCursor entity.
// If the XProviderCursor object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *XProviderCursorMutation) OldHeight(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldHeight is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldHeight requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldHeight: %w", err)
	}
	return oldValue.Height, nil
}

// AddHeight adds u to the "height" field.
func (m *XProviderCursorMutation) AddHeight(u int64) {
	if m.addheight != nil {
		*m.addheight += u
	} else {
		m.addheight = &u
	}
}

// AddedHeight returns the value that was added to the "height" field in this mutation.
func (m *XProviderCursorMutation) AddedHeight() (r int64, exists bool) {
	v := m.addheight
	if v == nil {
		return
	}
	return *v, true
}

// ResetHeight resets all changes to the "height" field.
func (m *XProviderCursorMutation) ResetHeight() {
	m.height = nil
	m.addheight = nil
}

// SetOffset sets the "offset" field.
func (m *XProviderCursorMutation) SetOffset(u uint64) {
	m._offset = &u
	m.add_offset = nil
}

// Offset returns the value of the "offset" field in the mutation.
func (m *XProviderCursorMutation) Offset() (r uint64, exists bool) {
	v := m._offset
	if v == nil {
		return
	}
	return *v, true
}

// OldOffset returns the old "offset" field's value of the XProviderCursor entity.
// If the XProviderCursor object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *XProviderCursorMutation) OldOffset(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldOffset is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldOffset requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldOffset: %w", err)
	}
	return oldValue.Offset, nil
}

// AddOffset adds u to the "offset" field.
func (m *XProviderCursorMutation) AddOffset(u int64) {
	if m.add_offset != nil {
		*m.add_offset += u
	} else {
		m.add_offset = &u
	}
}

// AddedOffset returns the value that was added to the "offset" field in this mutation.
func (m *XProviderCursorMutation) AddedOffset() (r int64, exists bool) {
	v := m.add_offset
	if v == nil {
		return
	}
	return *v, true
}

// ResetOffset resets all changes to the "offset" field.
func (m *XProviderCursorMutation) ResetOffset() {
	m._offset = nil
	m.add_offset = nil
}

// SetCreatedAt sets the "created_at" field.
func (m *XProviderCursorMutation) SetCreatedAt(t time.Time) {
	m.created_at = &t
}

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *XProviderCursorMutation) CreatedAt() (r time.Time, exists bool) {
	v := m.created_at
	if v == nil {
		return
	}
	return *v, true
}

// OldCreatedAt returns the old "created_at" field's value of the XProviderCursor entity.
// If the XProviderCursor object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *XProviderCursorMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
	}
	return oldValue.CreatedAt, nil
}

// ResetCreatedAt resets all changes to the "created_at" field.
func (m *XProviderCursorMutation) ResetCreatedAt() {
	m.created_at = nil
}

// SetUpdatedAt sets the "updated_at" field.
func (m *XProviderCursorMutation) SetUpdatedAt(t time.Time) {
	m.updated_at = &t
}

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *XProviderCursorMutation) UpdatedAt() (r time.Time, exists bool) {
	v := m.updated_at
	if v == nil {
		return
	}
	return *v, true
}

// OldUpdatedAt returns the old "updated_at" field's value of the XProviderCursor entity.
// If the XProviderCursor object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *XProviderCursorMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
	}
	return oldValue.UpdatedAt, nil
}

// ResetUpdatedAt resets all changes to the "updated_at" field.
func (m *XProviderCursorMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

// Where appends a list predicates to the XProviderCursorMutation builder.
func (m *XProviderCursorMutation) Where(ps ...predicate.XProviderCursor) {
	m.predicates = append(m.predicates, ps...)
}

// WhereP appends storage-level predicates to the XProviderCursorMutation builder. Using this method,
// users can use type-assertion to append predicates that do not depend on any generated package.
func (m *XProviderCursorMutation) WhereP(ps ...func(*sql.Selector)) {
	p := make([]predicate.XProviderCursor, len(ps))
	for i := range ps {
		p[i] = ps[i]
	}
	m.Where(p...)
}

// Op returns the operation name.
func (m *XProviderCursorMutation) Op() Op {
	return m.op
}

// SetOp allows setting the mutation operation.
func (m *XProviderCursorMutation) SetOp(op Op) {
	m.op = op
}

// Type returns the node type of this mutation (XProviderCursor).
func (m *XProviderCursorMutation) Type() string {
	return m.typ
}

// Fields returns all fields that were changed during this mutation. Note that in
// order to get all numeric fields that were incremented/decremented, call
// AddedFields().
func (m *XProviderCursorMutation) Fields() []string {
	fields := make([]string, 0, 5)
	if m.chain_id != nil {
		fields = append(fields, xprovidercursor.FieldChainID)
	}
	if m.height != nil {
		fields = append(fields, xprovidercursor.FieldHeight)
	}
	if m._offset != nil {
		fields = append(fields, xprovidercursor.FieldOffset)
	}
	if m.created_at != nil {
		fields = append(fields, xprovidercursor.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, xprovidercursor.FieldUpdatedAt)
	}
	return fields
}

// Field returns the value of a field with the given name. The second boolean
// return value indicates that this field was not set, or was not defined in the
// schema.
func (m *XProviderCursorMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case xprovidercursor.FieldChainID:
		return m.ChainID()
	case xprovidercursor.FieldHeight:
		return m.Height()
	case xprovidercursor.FieldOffset:
		return m.Offset()
	case xprovidercursor.FieldCreatedAt:
		return m.CreatedAt()
	case xprovidercursor.FieldUpdatedAt:
		return m.UpdatedAt()
	}
	return nil, false
}

// OldField returns the old value of the field from the database. An error is
// returned if the mutation operation is not UpdateOne, or the query to the
// database failed.
func (m *XProviderCursorMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case xprovidercursor.FieldChainID:
		return m.OldChainID(ctx)
	case xprovidercursor.FieldHeight:
		return m.OldHeight(ctx)
	case xprovidercursor.FieldOffset:
		return m.OldOffset(ctx)
	case xprovidercursor.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case xprovidercursor.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	}
	return nil, fmt.Errorf("unknown XProviderCursor field %s", name)
}

// SetField sets the value of a field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *XProviderCursorMutation) SetField(name string, value ent.Value) error {
	switch name {
	case xprovidercursor.FieldChainID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetChainID(v)
		return nil
	case xprovidercursor.FieldHeight:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetHeight(v)
		return nil
	case xprovidercursor.FieldOffset:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOffset(v)
		return nil
	case xprovidercursor.FieldCreatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case xprovidercursor.FieldUpdatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	}
	return fmt.Errorf("unknown XProviderCursor field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *XProviderCursorMutation) AddedFields() []string {
	var fields []string
	if m.addchain_id != nil {
		fields = append(fields, xprovidercursor.FieldChainID)
	}
	if m.addheight != nil {
		fields = append(fields, xprovidercursor.FieldHeight)
	}
	if m.add_offset != nil {
		fields = append(fields, xprovidercursor.FieldOffset)
	}
	return fields
}

// AddedField returns the numeric value that was incremented/decremented on a field
// with the given name. The second boolean return value indicates that this field
// was not set, or was not defined in the schema.
func (m *XProviderCursorMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case xprovidercursor.FieldChainID:
		return m.AddedChainID()
	case xprovidercursor.FieldHeight:
		return m.AddedHeight()
	case xprovidercursor.FieldOffset:
		return m.AddedOffset()
	}
	return nil, false
}

// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *XProviderCursorMutation) AddField(name string, value ent.Value) error {
	switch name {
	case xprovidercursor.FieldChainID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddChainID(v)
		return nil
	case xprovidercursor.FieldHeight:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddHeight(v)
		return nil
	case xprovidercursor.FieldOffset:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOffset(v)
		return nil
	}
	return fmt.Errorf("unknown XProviderCursor numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *XProviderCursorMutation) ClearedFields() []string {
	return nil
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *XProviderCursorMutation) FieldCleared(name string) bool {
	_, ok := m.clearedFields[name]
	return ok
}

// ClearField clears the value of the field with the given name. It returns an
// error if the field is not defined in the schema.
func (m *XProviderCursorMutation) ClearField(name string) error {
	return fmt.Errorf("unknown XProviderCursor nullable field %s", name)
}

// ResetField resets all changes in the mutation for the field with the given name.
// It returns an error if the field is not defined in the schema.
func (m *XProviderCursorMutation) ResetField(name string) error {
	switch name {
	case xprovidercursor.FieldChainID:
		m.ResetChainID()
		return nil
	case xprovidercursor.FieldHeight:
		m.ResetHeight()
		return nil
	case xprovidercursor.FieldOffset:
		m.ResetOffset()
		return nil
	case xprovidercursor.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case xprovidercursor.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	}
	return fmt.Errorf("unknown XProviderCursor field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *XProviderCursorMutation) AddedEdges() []string {
	edges := make([]string, 0, 0)
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *XProviderCursorMutation) AddedIDs(name string) []ent.Value {
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *XProviderCursorMutation) RemovedEdges() []string {
	edges := make([]string, 0, 0)
	return edges
}

// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
// the given name in this mutation.
func (m *XProviderCursorMutation) RemovedIDs(name string) []ent.Value {
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *XProviderCursorMutation) ClearedEdges() []string {
	edges := make([]string, 0, 0)
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *XProviderCursorMutation) EdgeCleared(name string) bool {
	return false
}

// ClearEdge clears the value of the edge with the given name. It returns an error
// if that edge is not defined in the schema.
func (m *XProviderCursorMutation) ClearEdge(name string) error {
	return fmt.Errorf("unknown XProviderCursor unique edge %s", name)
}

// ResetEdge resets all changes to the edge with the given name in this mutation.
// It returns an error if the edge is not defined in the schema.
func (m *XProviderCursorMutation) ResetEdge(name string) error {
	return fmt.Errorf("unknown XProviderCursor edge %s", name)
}