model

type Account struct {
	RowId            AccountID         `pack:"I,pk"      json:"row_id"`
	Address          tezos.Address     `pack:"H,bloom=3" json:"address"`
	Type             tezos.AddressType `pack:"t,u8"      json:"address_type"`
	Pubkey           tezos.Key         `pack:"k"         json:"pubkey"`
	Counter          int64             `pack:"j,i32"     json:"counter"`
	BakerId          AccountID         `pack:"D"         json:"baker_id"`
	CreatorId        AccountID         `pack:"C"         json:"creator_id"`
	FirstIn          int64             `pack:"i,i32"     json:"first_in"`
	FirstOut         int64             `pack:"o,i32"     json:"first_out"`
	LastIn           int64             `pack:"J,i32"     json:"last_in"`
	LastOut          int64             `pack:"O,i32"     json:"last_out"`
	FirstSeen        int64             `pack:"0,i32"     json:"first_seen"`
	LastSeen         int64             `pack:"l,i32"     json:"last_seen"`
	DelegatedSince   int64             `pack:"+,i32"     json:"delegated_since"`
	TotalReceived    int64             `pack:"R"         json:"total_received"`
	TotalSent        int64             `pack:"S"         json:"total_sent"`
	TotalBurned      int64             `pack:"B"         json:"total_burned"`
	TotalFeesPaid    int64             `pack:"F"         json:"total_fees_paid"`
	TotalFeesUsed    int64             `pack:"u"         json:"total_fees_used"`
	UnclaimedBalance int64             `pack:"U"         json:"unclaimed_balance"`
	SpendableBalance int64             `pack:"s"         json:"spendable_balance"`
	FrozenRollupBond int64             `pack:"L"         json:"frozen_rollup_bond"` // rollup
	LostRollupBond   int64             `pack:"X"         json:"lost_rollup_bond"`   // rollup
	StakedBalance    int64             `pack:"Y"         json:"staked_balance"`     // stake
	UnstakedBalance  int64             `pack:"Z"         json:"unstaked_balance"`   // stake
	LostStake        int64             `pack:"V"         json:"lost_stake"`         // stake
	StakeShares      int64             `pack:"W"         json:"stake_shares"`       // stake
	IsFunded         bool              `pack:"f,snappy"  json:"is_funded"`
	IsActivated      bool              `pack:"A,snappy"  json:"is_activated"`
	IsDelegated      bool              `pack:"=,snappy"  json:"is_delegated"`
	IsStaked         bool              `pack:"?,snappy"  json:"is_staked"`
	IsRevealed       bool              `pack:"r,snappy"  json:"is_revealed"`
	IsBaker          bool              `pack:"d,snappy"  json:"is_baker"`
	IsContract       bool              `pack:"c,snappy"  json:"is_contract"`
	NTxSuccess       int               `pack:"1,i32"     json:"n_tx_success"`
	NTxFailed        int               `pack:"2,i32"     json:"n_tx_failed"`
	NTxIn            int               `pack:"3,i32"     json:"n_tx_in"`
	NTxOut           int               `pack:"4,i32"     json:"n_tx_out"`

	// used during block processing, not stored in DB
	IsNew       bool   `pack:"-" json:"-"` // first seen this block
	WasFunded   bool   `pack:"-" json:"-"` // true if account was funded before processing this block
	WasDust     bool   `pack:"-" json:"-"` // true if account had 0 < balance < 1tez at start of block
	IsDirty     bool   `pack:"-" json:"-"` // indicates an update happened
	MustDelete  bool   `pack:"-" json:"-"` // indicates the account should be deleted (during rollback)
	PrevBalance int64  `pack:"-" json:"-"` // previous balance before update
	Baker       *Baker `pack:"-" json:"-"` // used for stake updates
	AuxBaker    *Baker `pack:"-" json:"-"` // used for unstake during delegation
}

type AccountID uint64

type AccountRank struct {
	AccountId    AccountID
	Balance      int64 // total balance
	TxVolume24h  int64 // tx volume in+out
	TxTraffic24h int64 // number of tx in+out
	RichRank     int   // assigned rank based on balance
	VolumeRank   int   // assigned rank based on volume
	TrafficRank  int   // assigned rank based on traffic
}

type Baker struct {
	RowId               BakerID       `pack:"I,pk"      json:"row_id"`
	AccountId           AccountID     `pack:"A,u32"     json:"account_id"`
	Address             tezos.Address `pack:"H,bloom=3" json:"address"`
	ConsensusKey        tezos.Key     `pack:"K"         json:"consensus_key"`
	IsActive            bool          `pack:"v,snappy"  json:"is_active"`
	BakerSince          int64         `pack:"*,i32"     json:"baker_since"`
	BakerUntil          int64         `pack:"/,i32"     json:"baker_until"`
	TotalRewardsEarned  int64         `pack:"W"         json:"total_rewards_earned"`
	TotalFeesEarned     int64         `pack:"E"         json:"total_fees_earned"`
	TotalLost           int64         `pack:"L"         json:"total_lost"`
	FrozenDeposits      int64         `pack:"z"         json:"frozen_deposits"`
	FrozenRewards       int64         `pack:"Z"         json:"frozen_rewards"`
	FrozenFees          int64         `pack:"Y"         json:"frozen_fees"`
	DelegatedBalance    int64         `pack:"~"         json:"delegated_balance"`
	TotalStake          int64         `pack:"g"         json:"total_stake"`
	TotalShares         int64         `pack:"h"         json:"total_shares"`
	ActiveStakers       int64         `pack:"j"         json:"active_stakers"`
	StakingEdge         int64         `pack:"k"         json:"staking_edge"`
	StakingLimit        int64         `pack:"l"         json:"staking_limit"`
	DepositsLimit       int64         `pack:"T"         json:"deposit_limit"`
	ActiveDelegations   int64         `pack:"a,i32"     json:"active_delegations"`
	BlocksBaked         int64         `pack:"b,i32"     json:"blocks_baked"`
	BlocksProposed      int64         `pack:"P,i32"     json:"blocks_proposed"`
	BlocksNotBaked      int64         `pack:"N,i32"     json:"blocks_not_baked"`
	BlocksEndorsed      int64         `pack:"x,i32"     json:"blocks_endorsed"`
	BlocksNotEndorsed   int64         `pack:"y,i32"     json:"blocks_not_endorsed"`
	SlotsEndorsed       int64         `pack:"e"         json:"slots_endorsed"`
	NBakerOps           int64         `pack:"1,i32"     json:"n_baker_ops"`
	NProposal           int64         `pack:"2,i32"     json:"n_proposals"`
	NBallot             int64         `pack:"3,i32"     json:"n_ballots"`
	NEndorsement        int64         `pack:"4,i32"     json:"n_endorsements"`
	NPreendorsement     int64         `pack:"5,i32"     json:"n_preendorsements"`
	NSeedNonce          int64         `pack:"6,i32"     json:"n_nonce_revelations"`
	N2Baking            int64         `pack:"7,i32"     json:"n_double_bakings"`
	N2Endorsement       int64         `pack:"8,i32"     json:"n_double_endorsements"`
	NSetDepositsLimit   int64         `pack:"9,i32"     json:"n_set_limits"`
	NAccusations        int64         `pack:"0,i32"     json:"n_accusations"`
	NUpdateConsensusKey int64         `pack:"!,i32"     json:"n_update_consensus_key"`
	NDrainDelegate      int64         `pack:"=,i32"     json:"n_drain_delegate"`
	GracePeriod         int64         `pack:"G,i32"     json:"grace_period"`
	Version             uint32        `pack:"V,snappy"  json:"baker_version"`

	Account     *Account `pack:"-" json:"-"` // related account
	Reliability int64    `pack:"-" json:"-"` // current cycle reliability from rights
	IsNew       bool     `pack:"-" json:"-"` // first seen this block
	IsDirty     bool     `pack:"-" json:"-"` // indicates an update happened
}

type BakerID uint64

type Balance struct {
	RowId     uint64    `pack:"I,pk"     json:"row_id"`
	AccountId AccountID `pack:"A,bloom"  json:"account_id"`
	Balance   int64     `pack:"B"        json:"balance"`
	ValidFrom int64     `pack:">,i32"    json:"valid_from"`
}

type Ballot struct {
	RowId            uint64                 `pack:"I,pk"  json:"row_id"`             // unique id
	ElectionId       ElectionID             `pack:"E"     json:"election_id"`        // related election id
	ProposalId       ProposalID             `pack:"P"     json:"proposal_id"`        // related proposal id
	VotingPeriod     int64                  `pack:"p,i16" json:"voting_period"`      // on-chain sequence number
	VotingPeriodKind tezos.VotingPeriodKind `pack:"k,u8"  json:"voting_period_kind"` // on-chain period
	Height           int64                  `pack:"h,i32" json:"height"`             // proposal/ballot operation block height
	Time             time.Time              `pack:"T"     json:"time"`               // proposal/ballot operation block time
	SourceId         AccountID              `pack:"S"     json:"source_id"`          // voting account
	OpId             OpID                   `pack:"O"     json:"op_id"`              // proposal/ballot operation id
	Stake            int64                  `pack:"s"     json:"stake"`              // voting power (at beginning of voting period)
	Ballot           tezos.BallotVote       `pack:"b,u8"  json:"ballot"`             // yay, nay, pass; proposal period uses yay only
}

type BaseRight struct {
	AccountId      AccountID
	Type           tezos.RightType
	IsUsed         bool
	IsLost         bool
	IsStolen       bool
	IsMissed       bool
	IsSeedRequired bool
	IsSeedRevealed bool
}

type BigmapAlloc struct {
	RowId     uint64    `pack:"I,pk"     json:"row_id"`        // internal: id
	BigmapId  int64     `pack:"B,i32"    json:"bigmap_id"`     // unique bigmap id
	AccountId AccountID `pack:"A,u32"    json:"account_id"`    // account table id for contract
	Height    int64     `pack:"h,i32"    json:"alloc_height"`  // allocation height
	NUpdates  int64     `pack:"n,i32"    json:"n_updates"`     // running update counter
	NKeys     int64     `pack:"k,i32"    json:"n_keys"`        // current number of active keys
	Updated   int64     `pack:"u,i32"    json:"update_height"` // last update height
	Deleted   int64     `pack:"D,i32"    json:"delete_height"` // block when bigmap was removed
	Data      []byte    `pack:"d,snappy" json:"-"`             // micheline encoded type tree (key/val pair)

	// internal, not stored
	KeyType   micheline.Type `pack:"-" json:"-"`
	ValueType micheline.Type `pack:"-" json:"-"`
}

type BigmapUpdate struct {
	RowId     uint64               `pack:"I,pk"             json:"row_id"`    // internal: id
	BigmapId  int64                `pack:"B,i32,bloom"      json:"bigmap_id"` // unique bigmap id
	KeyId     uint64               `pack:"K,bloom=3,snappy" json:"key_id"`    // xxhash(BigmapId, KeyHash)
	Action    micheline.DiffAction `pack:"a,u8"             json:"action"`    // action (alloc, copy, update, remove)
	OpId      OpID                 `pack:"o"                json:"op_id"`     // operation id
	Height    int64                `pack:"h,i32"            json:"height"`    // creation time
	Timestamp time.Time            `pack:"t"                json:"time"`      // creation height
	Key       []byte               `pack:"k,snappy"         json:"key"`       // key/value bytes: binary encoded micheline.Prim
	Value     []byte               `pack:"v,snappy"         json:"value"`     // key/value bytes: binary encoded micheline.Prim, (Pair(int,int) on copy)
}

type BigmapValue struct {
	RowId    uint64 `pack:"I,pk"             json:"row_id"`    // internal: id
	BigmapId int64  `pack:"B,i32,bloom"      json:"bigmap_id"` // unique bigmap id
	Height   int64  `pack:"h,i32"            json:"height"`    // update height
	KeyId    uint64 `pack:"K,bloom=3,snappy" json:"key_id"`    // xxhash(BigmapId, KeyHash)
	Key      []byte `pack:"k,snappy"         json:"key"`       // key/value bytes: binary encoded micheline.Prim Pair
	Value    []byte `pack:"v,snappy"         json:"value"`     // key/value bytes: binary encoded micheline.Prim Pair
}

type Block struct {
	RowId                  uint64                 `pack:"I,pk"             json:"row_id"`
	ParentId               uint64                 `pack:"P"                json:"parent_id"`
	Hash                   tezos.BlockHash        `pack:"H,snappy,bloom=3" json:"hash"`
	Height                 int64                  `pack:"h,i32"            json:"height"`
	Cycle                  int64                  `pack:"c,i16"            json:"cycle"`
	IsCycleSnapshot        bool                   `pack:"o,snappy"         json:"is_cycle_snapshot"`
	Timestamp              time.Time              `pack:"T"                json:"time"`
	Solvetime              int                    `pack:"d,i16"            json:"solvetime"`
	Version                int                    `pack:"v,i8"             json:"version"`
	Round                  int                    `pack:"p,i8"             json:"round"`
	Nonce                  uint64                 `pack:"n,snappy"         json:"nonce"`
	VotingPeriodKind       tezos.VotingPeriodKind `pack:"k,u8"             json:"voting_period_kind"`
	BakerId                AccountID              `pack:"B,u32"            json:"baker_id"`
	ProposerId             AccountID              `pack:"X,u32"            json:"proposer_id"`
	NSlotsEndorsed         int                    `pack:"e,i16"            json:"n_endorsed_slots"`
	NOpsApplied            int                    `pack:"1,i16"            json:"n_ops_applied"`
	NOpsFailed             int                    `pack:"2,i16"            json:"n_ops_failed"`
	NContractCalls         int                    `pack:"3,i16"            json:"n_calls"`
	NRollupCalls           int                    `pack:"6,i16"            json:"n_rollup_calls"`
	NEvents                int                    `pack:"4,i16"            json:"n_events"`
	NTx                    int                    `pack:"5,i16"            json:"n_tx"`
	NTickets               int                    `pack:"7,i16"            json:"n_tickets"`
	Volume                 int64                  `pack:"V"                json:"volume"`
	Fee                    int64                  `pack:"F"                json:"fee"`
	Reward                 int64                  `pack:"R"                json:"reward"`
	Deposit                int64                  `pack:"D"                json:"deposit"`
	ActivatedSupply        int64                  `pack:"S"                json:"activated_supply"`
	BurnedSupply           int64                  `pack:"b"                json:"burned_supply"`
	MintedSupply           int64                  `pack:"m"                json:"minted_supply"`
	SeenAccounts           int                    `pack:"a,i16"            json:"n_accounts"`
	NewAccounts            int                    `pack:"A,i16"            json:"n_new_accounts"`
	NewContracts           int                    `pack:"C,i16"            json:"n_new_contracts"`
	ClearedAccounts        int                    `pack:"E,i16"            json:"n_cleared_accounts"`
	FundedAccounts         int                    `pack:"J,i16"            json:"n_funded_accounts"`
	GasLimit               int64                  `pack:"L,i32"            json:"gas_limit"`
	GasUsed                int64                  `pack:"G,i32"            json:"gas_used"`
	StoragePaid            int64                  `pack:"Y,i32"            json:"storage_paid"`
	LbVote                 tezos.FeatureVote      `pack:"O,snappy"         json:"lb_vote"`
	LbEma                  int64                  `pack:"M,i32"            json:"lb_ema"`
	AiVote                 tezos.FeatureVote      `pack:"z,snappy"         json:"ai_vote"`
	AiEma                  int64                  `pack:"i,i32"            json:"ai_ema"`
	ProposerConsensusKeyId AccountID              `pack:"x"                json:"proposer_consensus_key_id"`
	BakerConsensusKeyId    AccountID              `pack:"y"                json:"baker_consensus_key_id"`

	// other tz or extracted/translated data for processing
	TZ               *rpc.Bundle `pack:"-" json:"-"`
	Params           *rpc.Params `pack:"-" json:"-"`
	Chain            *Chain      `pack:"-" json:"-"`
	Supply           *Supply     `pack:"-" json:"-"`
	Ops              []*Op       `pack:"-" json:"-"`
	Flows            []*Flow     `pack:"-" json:"-"`
	Baker            *Baker      `pack:"-" json:"-"`
	Proposer         *Baker      `pack:"-" json:"-"`
	Parent           *Block      `pack:"-" json:"-"`
	HasProposals     bool        `pack:"-" json:"-"`
	HasBallots       bool        `pack:"-" json:"-"`
	HasSeeds         bool        `pack:"-" json:"-"`
	OfflineBaker     AccountID   `pack:"-" json:"-"`
	OfflineEndorsers []AccountID `pack:"-" json:"-"`
}

type BlockBuilder interface {
	// resolves account from builder cache, returns nil and false when not found
	AccountByAddress(tezos.Address) (*Account, bool)

	// resolves account from database, returns nil and error when not found
	LoadAccountByAddress(context.Context, tezos.Address) (*Account, error)

	// resolves account from id, returns nil and false when not found
	AccountById(AccountID) (*Account, bool)

	// resolves baker from address, returns nil and false when not found
	BakerByAddress(tezos.Address) (*Baker, bool)

	// resolves baker from id, returns nil and false when not found
	BakerById(AccountID) (*Baker, bool)

	// resolves contract from account id, returns nil and false when not found
	ContractById(AccountID) (*Contract, bool)

	// returns a map of all accounts referenced in the current block
	Accounts() map[AccountID]*Account

	// returns a map of all delegates referenced in the current block
	Bakers() map[AccountID]*Baker

	// returns a map of all contracts referenced in the current block
	Contracts() map[AccountID]*Contract

	// returns a map of all constants referenced in the current block
	Constants() micheline.ConstantDict

	// return params at specific height
	Params(int64) *rpc.Params

	// returns the requested database table if exists or error otherwise
	Table(string) (*pack.Table, error)

	// returns global task scheduler
	Sched() *task.Scheduler

	// returns true if indexer is run in light mode
	IsLightMode() bool
}

type BlockCrawler interface {
	// returns the requested database table if exists or error otherwise
	Table(string) (*pack.Table, error)

	// returns the blockchain params at specified block height
	ParamsByHeight(height int64) *rpc.Params

	// returns the blockchain params for the specified protocol
	ParamsByProtocol(proto tezos.ProtocolHash) *rpc.Params

	// returns the current crawler chain tip
	Tip() *ChainTip

	// returns the crawler's most recently seen block height
	Height() int64

	// returns stored (main chain) block at specified height
	BlockByHeight(ctx context.Context, height int64) (*Block, error)

	// returns stored chain data at specified height
	ChainByHeight(ctx context.Context, height int64) (*Chain, error)

	// returns stored supply table data at specified height
	SupplyByHeight(ctx context.Context, height int64) (*Supply, error)

	// returns height for timestamp
	BlockHeightFromTime(ctx context.Context, tm time.Time) int64
}

type BlockIndexer interface {
	// Name returns the human-readable name of the index.
	Name() string

	// Key returns the key of the index as a string.
	Key() string

	// Create is invoked when the indexer manager determines the index needs
	// to be created for the first time.
	Create(path, label string, opts interface{}) error

	// Init is invoked when the table manager is first initializing the
	// datastore.  This differs from the Create method in that it is called on
	// every load, including the case the datatable was just created.
	Init(path, label string, opts interface{}) error

	// ConnectBlock is invoked when the table manager is notified that a new
	// block has been connected to the main chain.
	ConnectBlock(ctx context.Context, block *Block, builder BlockBuilder) error

	// DisconnectBlock is invoked when the table manager is notified that a
	// block has been disconnected from the main chain.
	DisconnectBlock(ctx context.Context, block *Block, builder BlockBuilder) error

	// DeleteBlock is invoked when the table manager is notified that a
	// block must be rolled back after an error occured.
	DeleteBlock(ctx context.Context, height int64) error

	// DeleteCycle is invoked when an index must delete all content from
	// a particular cycle.
	DeleteCycle(ctx context.Context, cycle int64) error

	// FinalizeSync is invoked when an the initial sync has finished. It may
	// be used to clean and defrag tables or (re)build indexes.
	FinalizeSync(ctx context.Context) error

	// OnTaskComplete is called when a scheduled task completes.
	OnTaskComplete(context.Context, *task.TaskResult) error

	// Flush flushes all indexer databases.
	Flush(ctx context.Context) error

	// Close closes the indexer and frees all associated resources, if any.
	Close() error

	// returns the database storing all indexer tables
	DB() *pack.DB

	// returns the list of database tables used by the indexer
	Tables() []*pack.Table
}

type Chain struct {
	RowId                uint64    `pack:"I,pk,snappy"       json:"row_id"`                    // unique id
	Height               int64     `pack:"a,i32,snappy"      json:"height"`                    // bc: block height (also for orphans)
	Cycle                int64     `pack:"b,i16,snappy"      json:"cycle"`                     // bc: block cycle (tezos specific)
	Timestamp            time.Time `pack:"c,snappy"          json:"time"`                      // bc: block creation time
	TotalAccounts        int64     `pack:"d,i32,snappy"      json:"total_accounts"`            // default accounts
	TotalContracts       int64     `pack:"e,i32,snappy"      json:"total_contracts"`           // smart contracts (KT1 with code)
	TotalRollups         int64     `pack:"f,i32,snappy"      json:"total_rollups"`             // rollups (any kind)
	TotalOps             int64     `pack:"g,i32,snappy"      json:"total_ops"`                 //
	TotalOpsFailed       int64     `pack:"h,i32,snappy"      json:"total_ops_failed"`          //
	TotalContractOps     int64     `pack:"i,i32,snappy"      json:"total_contract_ops"`        // ops on KT1 contracts
	TotalContractCalls   int64     `pack:"j,i32,snappy"      json:"total_contract_calls"`      // calls from EOA to KT1 contracts with params
	TotalRollupCalls     int64     `pack:"k,i32,snappy"      json:"total_rollup_calls"`        // calls from EOA or KT1 to rollups
	TotalActivations     int64     `pack:"l,i32,snappy"      json:"total_activations"`         // fundraiser accounts activated
	TotalSeedNonces      int64     `pack:"m,i32,snappy"      json:"total_nonce_revelations"`   //
	TotalEndorsements    int64     `pack:"n,i32,snappy"      json:"total_endorsements"`        //
	TotalPreendorsements int64     `pack:"o,i32,snappy"      json:"total_preendorsements"`     //
	TotalDoubleBake      int64     `pack:"p,i32,snappy"      json:"total_double_bakings"`      //
	TotalDoubleEndorse   int64     `pack:"q,i32,snappy"      json:"total_double_endorsements"` //
	TotalDelegations     int64     `pack:"r,i32,snappy"      json:"total_delegations"`         //
	TotalReveals         int64     `pack:"s,i32,snappy"      json:"total_reveals"`             //
	TotalOriginations    int64     `pack:"t,i32,snappy"      json:"total_originations"`        //
	TotalTransactions    int64     `pack:"u,i32,snappy"      json:"total_transactions"`        //
	TotalProposals       int64     `pack:"v,i32,snappy"      json:"total_proposals"`           //
	TotalBallots         int64     `pack:"w,i32,snappy"      json:"total_ballots"`             //
	TotalConstants       int64     `pack:"x,i32,snappy"      json:"total_constants"`           // registered global constants
	TotalSetLimits       int64     `pack:"y,i32,snappy"      json:"total_set_limits"`          // registered global constants
	TotalStorageBytes    int64     `pack:"z,snappy"          json:"total_storage_bytes"`       //
	TotalTicketTransfers int64     `pack:"1,i32,snappy"      json:"total_ticket_transfers"`    // transfer ticket
	FundedAccounts       int64     `pack:"2,i32,snappy"      json:"funded_accounts"`           // total number of accounts qith non-zero balance
	DustAccounts         int64     `pack:"3,i32,snappy"      json:"dust_accounts"`             // accounts with a balance < 1 tez
	GhostAccounts        int64     `pack:"4,i32,snappy"      json:"ghost_accounts"`            // unfunded L2 accounts (who own tokens, but cannot move them)
	UnclaimedAccounts    int64     `pack:"5,i16,snappy"      json:"unclaimed_accounts"`        // fundraiser accounts unclaimed
	TotalDelegators      int64     `pack:"6,i32,snappy"      json:"total_delegators"`          // count of all non-zero balance delegators
	ActiveDelegators     int64     `pack:"7,i32,snappy"      json:"active_delegators"`         // KT1 delegating to active bakers
	InactiveDelegators   int64     `pack:"8,i32,snappy"      json:"inactive_delegators"`       // KT1 delegating to inactive bakers
	DustDelegators       int64     `pack:"9,i32,snappy"      json:"dust_delegators"`           // KT1 delegating to inactive bakers
	TotalBakers          int64     `pack:"0,i16,snappy"      json:"total_bakers"`              // count of all bakers (active and inactive)
	EligibleBakers       int64     `pack:"A,i16,snappy"      json:"eligible_bakers"`           // bakers above minimum
	ActiveBakers         int64     `pack:"B,i16,snappy"      json:"active_bakers"`             // tz* active bakers
	InactiveBakers       int64     `pack:"C,i16,snappy"      json:"inactive_bakers"`           // tz* inactive bakers
	ZeroBakers           int64     `pack:"D,i16,snappy"      json:"zero_bakers"`               // tz* delegate with zero staking balance
	SelfBakers           int64     `pack:"E,i16,snappy"      json:"self_bakers"`               // tz* delegate with no incoming delegation
	SingleBakers         int64     `pack:"F,i16,snappy"      json:"single_bakers"`             // tz* delegate with 1 incoming delegation
	MultiBakers          int64     `pack:"G,i16,snappy"      json:"multi_bakers"`              // tz* delegate with >1 incoming delegations (delegation services)
	TotalStakers         int64     `pack:"H,i32,snappy"      json:"total_stakers"`             // wallets staking
	ActiveStakers        int64     `pack:"J,i32,snappy"      json:"active_stakers"`            // wallets staking with active bakers
	InactiveStakers      int64     `pack:"K,i32,snappy"      json:"inactive_stakers"`          // wallets staking with inactive bakers
}

type ChainTip struct {
	Name        string            `json:"name"`         // chain name, e.g. Bitcoin
	Symbol      string            `json:"symbol"`       // chain symbol, e.g. BTC
	ChainId     tezos.ChainIdHash `json:"chain_id"`     // chain identifier (same for all blocks)
	BestHash    tezos.BlockHash   `json:"last_block"`   // The hash of the chain tip block.
	BestId      uint64            `json:"last_id"`      // The internal blockindex id of the tip block;
	BestHeight  int64             `json:"height"`       // The height of the tip block.
	BestTime    time.Time         `json:"timestamp"`    // The timestamp of the tip block.
	GenesisTime time.Time         `json:"genesis_time"` // cache of first block generation time
	NYEveBlocks []int64           `json:"nye_blocks"`   // first block heights per year for annual statistics
	Deployments []Deployment      `json:"deployments"`  // protocol deployments
}

type Constant struct {
	RowId       ConstantID         `pack:"I,pk"      json:"row_id"`
	Address     tezos.ExprHash     `pack:"H,bloom=3" json:"address"`
	CreatorId   AccountID          `pack:"C,u32"     json:"creator_id"`
	Value       []byte             `pack:"v,snappy"  json:"value"`
	Height      int64              `pack:"h,i32"     json:"height"`
	StorageSize int64              `pack:"z,i32"     json:"storage_size"`
	Features    micheline.Features `pack:"F,snappy"  json:"features"`
}

type ConstantID uint64

type Contract struct {
	RowId          ContractID           `pack:"I,pk"      json:"row_id"`
	Address        tezos.Address        `pack:"H,bloom=3" json:"address"`
	AccountId      AccountID            `pack:"A,u32"     json:"account_id"`
	CreatorId      AccountID            `pack:"C,u32"     json:"creator_id"`
	FirstSeen      int64                `pack:"f,i32"     json:"first_seen"`
	LastSeen       int64                `pack:"l,i32"     json:"last_seen"`
	StorageSize    int64                `pack:"z,i32"     json:"storage_size"`
	StoragePaid    int64                `pack:"y,i32"     json:"storage_paid"`
	StorageBurn    int64                `pack:"Y"         json:"storage_burn"`
	Script         []byte               `pack:"s,snappy"  json:"script"`
	Storage        []byte               `pack:"g,snappy"  json:"storage"`
	InterfaceHash  uint64               `pack:"i,snappy"  json:"iface_hash"`
	CodeHash       uint64               `pack:"c,snappy"  json:"code_hash"`
	StorageHash    uint64               `pack:"x,snappy"  json:"storage_hash"`
	CallStats      []byte               `pack:"S,snappy"  json:"call_stats"`
	Features       micheline.Features   `pack:"F,snappy"  json:"features"`
	Interfaces     micheline.Interfaces `pack:"n,snappy"  json:"interfaces"`
	LedgerType     TokenType            `pack:"t"         json:"ledger_type"`
	LedgerSchema   LedgerSchema         `pack:"h"         json:"ledger_schema"`
	LedgerBigmap   int64                `pack:"b,i32"     json:"ledger_bigmap"`
	LedgerMeta     MetaID               `pack:"M"         json:"metadata_id"`
	MetadataBigmap int64                `pack:"m,i32"     json:"metadata_bigmap"`

	IsDirty bool `pack:"-" json:"-"` // indicates an update happened
	IsNew   bool `pack:"-" json:"-"` // new contract, used during migration
	// contains filtered or unexported fields
}

type ContractID uint64

type Cycle struct {
	RowId                    uint64 `pack:"I,pk" json:"row_id"`
	Cycle                    int64  `pack:"a"    json:"cycle"`
	StartHeight              int64  `pack:"b"    json:"start_height"`
	EndHeight                int64  `pack:"c"    json:"end_height"`
	SnapshotHeight           int64  `pack:"d"    json:"snapshot_height"`
	SnapshotIndex            int    `pack:"e"    json:"snapshot_index"`
	MissedRounds             int    `pack:"f"    json:"missed_rounds"`
	MissedEndorsements       int    `pack:"g"    json:"missed_endorsements"`
	Num2Baking               int    `pack:"h"    json:"n_double_baking"`
	Num2Endorsement          int    `pack:"i"    json:"n_double_endorsement"`
	NumSeeds                 int    `pack:"j"    json:"n_seed_nonces"`
	SolveTimeMin             int    `pack:"k"    json:"solvetime_min"`
	SolveTimeMax             int    `pack:"l"    json:"solvetime_max"`
	SolveTimeSum             int    `pack:"m"    json:"solvetime_sum"`
	RoundMin                 int    `pack:"n"    json:"round_min"`
	RoundMax                 int    `pack:"o"    json:"round_max"`
	EndorsementsMin          int    `pack:"q"    json:"endorsements_min"`
	EndorsementsMax          int    `pack:"r"    json:"endorsements_max"`
	WorstBakedBlock          int64  `pack:"t"    json:"worst_baked_block"`
	WorstEndorsedBlock       int64  `pack:"u"    json:"worst_endorsed_block"`
	UniqueBakers             int    `pack:"v"    json:"unique_bakers"`
	BlockReward              int64  `pack:"w"    json:"block_reward"`
	BlockBonusPerSlot        int64  `pack:"x"    json:"block_bonus_per_slot"`
	MaxBlockReward           int64  `pack:"y"    json:"max_block_reward"`
	EndorsementRewardPerSlot int64  `pack:"z"    json:"endorsement_reward_per_slot"`
	NonceRevelationReward    int64  `pack:"1"    json:"nonce_revelation_reward"`
	VdfRevelationReward      int64  `pack:"2"    json:"vdf_revelation_reward"`
	LBSubsidy                int64  `pack:"3"    json:"lb_subsidy"`
}

type Deployment struct {
	Protocol    tezos.ProtocolHash `json:"protocol"`
	Version     int                `json:"version"`      // protocol version
	Deployment  int                `json:"deployment"`   // protocol sequence id on indexed chain
	StartHeight int64              `json:"start_height"` // first block on indexed chain
	EndHeight   int64              `json:"end_height"`   // last block on indexed chain or -1
}

type Election struct {
	RowId        ElectionID `pack:"I,pk"      json:"row_id"`        // unique id
	ProposalId   ProposalID `pack:"P"         json:"proposal_id"`   // winning proposal id (after first vote)
	NumPeriods   int        `pack:"n,i8"      json:"num_periods"`   // number of periods processed (so far)
	NumProposals int        `pack:"N,i8"      json:"num_proposals"` // number of sumbitted proposals
	VotingPeriod int64      `pack:"p,i16"     json:"voting_period"` // protocol (proposal) voting period starting the election
	StartTime    time.Time  `pack:"T"         json:"start_time"`    // proposal voting period start
	EndTime      time.Time  `pack:"t"         json:"end_time"`      // last voting perid end, estimate when open
	StartHeight  int64      `pack:"H,i32"     json:"start_height"`  // proposal voting period start block
	EndHeight    int64      `pack:"h,i32"     json:"end_height"`    // last voting perid end block, estimate when open
	IsEmpty      bool       `pack:"e,snappy"  json:"is_empty"`      // no proposal published during this period
	IsOpen       bool       `pack:"o,snappy"  json:"is_open"`       // flag, election in progress
	IsFailed     bool       `pack:"f,snappy"  json:"is_failed"`     // flag, election aborted du to missing proposal or missed quorum/supermajority
	NoQuorum     bool       `pack:"!,snappy"  json:"no_quorum"`     // flag, quorum not reached
	NoMajority   bool       `pack:"m,snappy"  json:"no_majority"`   // flag, supermajority not reached
}

type ElectionID uint64

type Endorsement struct {
	RowId    OpID         `pack:"I,pk,snappy"        json:"row_id"`            // internal: unique row id
	Hash     tezos.OpHash `pack:"H,snappy,bloom=3"   json:"hash"`              // op hash
	Height   int64        `pack:"h,i32,snappy"       json:"height"`            // block height
	OpN      int          `pack:"n,i16,snappy"       json:"op_n"`              // unique in-block pos
	OpP      int          `pack:"P,i16,snappy"       json:"op_p"`              // op list pos (list can be derived from type)
	Reward   int64        `pack:"r,snappy"           json:"reward"`            // baking/endorsement reward
	Deposit  int64        `pack:"d,snappy"           json:"deposit"`           // baker deposit
	SenderId AccountID    `pack:"S,u32,snappy,bloom" json:"sender_id"`         // sender id, also on internal ops
	Power    int64        `pack:"p,i16,snappy"       json:"power"`             // power
	IsPre    bool         `pack:"i,snappy"           json:"is_preendorsement"` // Ithaca pre-endorsement
}

type Event struct {
	RowId     EventID   `pack:"I,pk"      json:"row_id"`
	Height    int64     `pack:"h,i32"     json:"height"`
	OpId      uint64    `pack:"o"         json:"op_id"` // unique external operation id
	AccountId AccountID `pack:"C,bloom=3" json:"account_id"`
	Type      []byte    `pack:"t,snappy"  json:"type"`
	Payload   []byte    `pack:"p,snappy"  json:"payload"`
	Tag       string    `pack:"a,snappy"  json:"tag"`
	TypeHash  uint64    `pack:"H,bloom"   json:"type_hash"`
}

type EventID uint64

type FA1Transfer TransferList

type FA2Transfer TransferList

type Flow struct {
	RowId          uint64    `pack:"I,pk"               json:"row_id"`
	Height         int64     `pack:"h,i32,snappy"       json:"height"`
	Cycle          int64     `pack:"c,i16,snappy"       json:"cycle"`
	Timestamp      time.Time `pack:"T,snappy"           json:"time"`
	OpN            int       `pack:"1,i16,snappy"       json:"op_n"`
	OpC            int       `pack:"2,i16,snappy"       json:"op_c"`
	OpI            int       `pack:"3,i16,snappy"       json:"op_i"`
	AccountId      AccountID `pack:"A,u32,snappy,bloom" json:"account_id"`
	CounterPartyId AccountID `pack:"R,u32,snappy"       json:"counterparty_id"` // account that initiated the flow
	Kind           FlowKind  `pack:"C,u8,snappy,bloom"  json:"kind"`            // sub-account that received the update
	Type           FlowType  `pack:"O,u8,snappy,bloom"  json:"type"`            // op type that caused this update
	AmountIn       int64     `pack:"i,snappy"           json:"amount_in"`       // sum flowing in to the account
	AmountOut      int64     `pack:"o,snappy"           json:"amount_out"`      // sum flowing out of the account
	IsFee          bool      `pack:"e,snappy"           json:"is_fee"`          // flag: out-flow paid a fee
	IsBurned       bool      `pack:"b,snappy"           json:"is_burned"`       // flag: out-flow was burned
	IsFrozen       bool      `pack:"f,snappy"           json:"is_frozen"`       // flag: in-flow is frozen
	IsUnfrozen     bool      `pack:"u,snappy"           json:"is_unfrozen"`     // flag: out-flow was unfrozen (rewards -> balance)
	IsShielded     bool      `pack:"y,snappy"           json:"is_shielded"`     // flag: in-flow was shielded (Sapling)
	IsUnshielded   bool      `pack:"Y,snappy"           json:"is_unshielded"`   // flag: out-flow was unshielded (Sapling)
	TokenAge       int64     `pack:"a,i32,snappy"       json:"token_age"`       // time since last transfer in seconds
}

type FlowKind byte

type FlowType byte

type Income struct {
	RowId                  uint64    `pack:"I,pk,snappy"     json:"row_id"`
	Cycle                  int64     `pack:"c,i16,snappy"    json:"cycle"`
	StartHeight            int64     `pack:"h,i32"           json:"start_height"`
	EndHeight              int64     `pack:"e,i32"           json:"end_height"`
	AccountId              AccountID `pack:"A,u32,snappy"    json:"account_id"`
	Balance                int64     `pack:"B,snappy"        json:"balance"`         // @snapshot
	Delegated              int64     `pack:"d,snappy"        json:"delegated"`       // @snapshot
	OwnStake               int64     `pack:"b,snappy"        json:"own_stake"`       // @snapshot
	StakingBalance         int64     `pack:"S,snappy"        json:"staking_balance"` // @snapshot
	NDelegations           int64     `pack:"n,i32,snappy"    json:"n_delegations"`   // @snapshot
	NStakers               int64     `pack:"#,i32,snappy"    json:"n_stakers"`       // @snapshot
	NBakingRights          int64     `pack:"R,i16,snappy"    json:"n_baking_rights"`
	NEndorsingRights       int64     `pack:"r,i32,snappy"    json:"n_endorsing_rights"`
	Luck                   int64     `pack:"L,snappy"        json:"luck"`                       // coins by fair share of stake
	LuckPct                int64     `pack:"l,d32,scale=2,snappy"  json:"luck_percent"`         // 0.0 .. +N.00 by fair share of stake
	ContributionPct        int64     `pack:"t,d32,scale=2,snappy"  json:"contribution_percent"` // 0.0 .. +N.00 by rights utilized
	PerformancePct         int64     `pack:"p,d32,scale=2,snappy"  json:"performance_percent"`  // -N.00 .. +N.00 by expected income
	NBlocksBaked           int64     `pack:"k,i16,snappy"    json:"n_blocks_baked"`
	NBlocksProposed        int64     `pack:"K,i16,snappy"    json:"n_blocks_proposed"`
	NBlocksNotBaked        int64     `pack:"N,i16,snappy"    json:"n_blocks_not_baked"`
	NBlocksEndorsed        int64     `pack:"E,i16,snappy"    json:"n_blocks_endorsed"`
	NBlocksNotEndorsed     int64     `pack:"X,i16,snappy"    json:"n_blocks_not_endorsed"`
	NSlotsEndorsed         int64     `pack:"Z,i32,snappy"    json:"n_slots_endorsed"`
	NSeedsRevealed         int64     `pack:"s,i16,snappy"    json:"n_seeds_revealed"`
	ExpectedIncome         int64     `pack:"f,snappy"        json:"expected_income"`
	TotalIncome            int64     `pack:"i,snappy"        json:"total_income"`
	BakingIncome           int64     `pack:"1,snappy"        json:"baking_income"`
	EndorsingIncome        int64     `pack:"2,snappy"        json:"endorsing_income"`
	AccusationIncome       int64     `pack:"3,snappy"        json:"accusation_income"`
	SeedIncome             int64     `pack:"4,snappy"        json:"seed_income"`
	FeesIncome             int64     `pack:"5,snappy"        json:"fees_income"`
	TotalLoss              int64     `pack:"6,snappy"        json:"total_loss"`
	AccusationLoss         int64     `pack:"7,snappy"        json:"accusation_loss"`
	SeedLoss               int64     `pack:"8,snappy"        json:"seed_loss"`
	EndorsingLoss          int64     `pack:"9,snappy"        json:"endorsing_loss"`
	LostAccusationFees     int64     `pack:"F,snappy"        json:"lost_accusation_fees"`     // from denunciations
	LostAccusationRewards  int64     `pack:"W,snappy"        json:"lost_accusation_rewards"`  // from denunciations
	LostAccusationDeposits int64     `pack:"D,snappy"        json:"lost_accusation_deposits"` // from denunciations
	LostSeedFees           int64     `pack:"V,snappy"        json:"lost_seed_fees"`           // from missed seed nonce revelations
	LostSeedRewards        int64     `pack:"Y,snappy"        json:"lost_seed_rewards"`        // from missed seed nonce revelations

}

type LedgerBalance struct {
	Owner   tezos.Address
	TokenId tezos.Z
	Balance tezos.Z
	Name    string // use for domain names

	// internal
	OwnerRef *TokenOwner // hook
	TokenRef *Token      // hook
	// contains filtered or unexported fields
}

type LedgerDomain LedgerBalance

type LedgerFAa LedgerBalance

type LedgerFAb LedgerBalance

type LedgerFAc LedgerBalance

type LedgerFAd LedgerBalance

type LedgerFAe LedgerBalance

type LedgerFAf LedgerBalance

type LedgerFAg LedgerBalance

type LedgerFAh LedgerBalance

type LedgerFAi LedgerBalance

type LedgerFAj LedgerBalance

type LedgerNFT1 LedgerBalance

type LedgerNFT2 LedgerBalance

type LedgerNFT3 LedgerBalance

type LedgerSchema byte

type LedgerTezFin LedgerBalance

type LedgerTzBTC LedgerBalance

type MetaID uint64

type Metadata struct {
	RowId     MetaID        `pack:"I,pk"      json:"row_id"`
	AccountId AccountID     `pack:"A,u32"     json:"account_id"`
	Address   tezos.Address `pack:"H,bloom=3" json:"address"`
	Content   []byte        `pack:"C,snappy"  json:"content"` // JSON or binary encoded content
}

type Model interface {
	TableKey() string
	TableOpts() pack.Options
	IndexOpts(string) pack.Options
}

type Op struct {
	RowId        OpID           `pack:"I,pk"             json:"row_id"`        // internal: unique row id
	Type         OpType         `pack:"t,u8,bloom"       json:"type"`          // indexer op type
	Hash         tezos.OpHash   `pack:"H,snappy,bloom=3" json:"hash"`          // op hash
	Height       int64          `pack:"h,i32"            json:"height"`        // block height
	Cycle        int64          `pack:"c,i16"            json:"cycle"`         // block cycle
	Timestamp    time.Time      `pack:"T"                json:"time"`          // block time
	OpN          int            `pack:"n,i32"            json:"op_n"`          // unique in-block pos
	OpP          int            `pack:"P,i16"            json:"op_p"`          // op list pos (list can be derived from type)
	Status       tezos.OpStatus `pack:"?,u8"             json:"status"`        // op status
	IsSuccess    bool           `pack:"!,snappy"         json:"is_success"`    // success flag
	IsContract   bool           `pack:"C,snappy"         json:"is_contract"`   // contract call flag (target is contract)
	IsInternal   bool           `pack:"N,snappy"         json:"is_internal"`   // internal contract call or op
	IsEvent      bool           `pack:"m,snappy"         json:"is_event"`      // this is an implicit event
	IsRollup     bool           `pack:"u,snappy"         json:"is_rollup"`     // this is an rollup operation
	Counter      int64          `pack:"j,i32"            json:"counter"`       // signer counter
	GasLimit     int64          `pack:"l,i32"            json:"gas_limit"`     // gas limit
	GasUsed      int64          `pack:"G,i32"            json:"gas_used"`      // gas used
	StorageLimit int64          `pack:"Z,i32"            json:"storage_limit"` // storage size limit
	StoragePaid  int64          `pack:"$,i32"            json:"storage_paid"`  // storage allocated/paid
	Volume       int64          `pack:"v"                json:"volume"`        // transacted tez volume
	Fee          int64          `pack:"f"                json:"fee"`           // tx fees
	Reward       int64          `pack:"r"                json:"reward"`        // baking/endorsement reward
	Deposit      int64          `pack:"d"                json:"deposit"`       // baker deposit
	Burned       int64          `pack:"b"                json:"burned"`        // burned tez (for storage allocation)
	SenderId     AccountID      `pack:"S,u32,bloom"      json:"sender_id"`     // sender id, also on internal ops
	ReceiverId   AccountID      `pack:"R,u32,bloom"      json:"receiver_id"`   // receiver id
	CreatorId    AccountID      `pack:"M,u32"            json:"creator_id"`    // creator id, direct source for internal ops
	BakerId      AccountID      `pack:"D,u32,bloom"      json:"baker_id"`      // delegate id
	Data         string         `pack:"a,snappy"         json:"data"`          // custom op data
	Parameters   []byte         `pack:"p,snappy"         json:"parameters"`    // call params
	CodeHash     uint64         `pack:"x"                json:"code_hash"`     // code hash of target contract
	StorageHash  uint64         `pack:"s"                json:"storage_hash"`  // storage hash
	Errors       []byte         `pack:"e,snappy"         json:"errors"`        // call errors
	Entrypoint   int            `pack:"E,i8"             json:"entrypoint_id"` // update contract counters, search by entrypoint

	// internal
	OpC              int                    `pack:"-"  json:"-"` // contents list pos
	OpI              int                    `pack:"-"  json:"-"` // internal op result list pos
	Raw              rpc.TypedOperation     `pack:"-"  json:"-"` // cache
	RawTicketUpdates []rpc.TicketUpdate     `pack:"-"  json:"-"` // rpc ticket updates
	BigmapEvents     micheline.BigmapEvents `pack:"-"  json:"-"` // cache here for bigmap index
	Storage          []byte                 `pack:"-"  json:"-"` // storage update
	IsStorageUpdate  bool                   `pack:"-"  json:"-"` // true when contract storage changed
	Contract         *Contract              `pack:"-"  json:"-"` // cached contract
	BigmapUpdates    []BigmapUpdate         `pack:"-"  json:"-"` // cached query result
	Events           []*Event               `pack:"-"  json:"-"` // cached query result
	TicketUpdates    []*TicketUpdate        `pack:"-"  json:"-"` // cached query result
	IsBurnAddress    bool                   `pack:"-"  json:"-"` // target is known burn address
}

type OpID uint64

type OpRef struct {
	Hash tezos.OpHash
	Kind OpType
	N    int
	L    int
	P    int
	C    int
	I    int
	Raw  rpc.TypedOperation
}

type OpType byte

type OpTypeList []OpType

type Proposal struct {
	RowId        ProposalID         `pack:"I,pk"      json:"row_id"`        // unique id
	Hash         tezos.ProtocolHash `pack:"H,snappy"  json:"hash"`          // unique proposal hash
	Height       int64              `pack:"h,i32"     json:"height"`        // proposal publishing block
	Time         time.Time          `pack:"T"         json:"time"`          // proposal publishing time
	SourceId     AccountID          `pack:"S"         json:"source_id"`     // proposal publisher
	OpId         OpID               `pack:"O"         json:"op_id"`         // operation publishing this proposal
	ElectionId   ElectionID         `pack:"E"         json:"election_id"`   // custom: election sequence number (same for all voting periods)
	VotingPeriod int64              `pack:"p,i16"     json:"voting_period"` // protocol: proposal period sequence number
	Stake        int64              `pack:"s"         json:"stake"`         // stake accumulated by this proposal
	Voters       int64              `pack:"v,i16"     json:"voters"`        // number of voters who voted for this proposal
}

type ProposalID uint64

type Right struct {
	RowId     uint64     `pack:"I,pk"      json:"row_id"`           // unique id
	Cycle     int64      `pack:"c,i16"     json:"cycle"`            // cycle
	Height    int64      `pack:"h,i32"     json:"height"`           // height
	AccountId AccountID  `pack:"A,u32"     json:"account_id"`       // rights holder
	Bake      vec.BitSet `pack:"B,snappy"  json:"baking_rights"`    // bits for every block
	Endorse   vec.BitSet `pack:"E,snappy"  json:"endorsing_rights"` // bits for every block
	Baked     vec.BitSet `pack:"b,snappy"  json:"blocks_baked"`     // bits for every block
	Endorsed  vec.BitSet `pack:"e,snappy"  json:"blocks_endorsed"`  // bits for every block
	Seed      vec.BitSet `pack:"S,snappy"  json:"seeds_required"`   // only bits for every seed block
	Seeded    vec.BitSet `pack:"s,snappy"  json:"seeds_revealed"`   // only bits for every seed block
}

type Snapshot struct {
	RowId          uint64    `pack:"I,pk"         json:"row_id"`
	Height         int64     `pack:"h,i32"        json:"height"`
	Cycle          int64     `pack:"c,i16"        json:"cycle"`
	Timestamp      time.Time `pack:"T"            json:"time"`
	Index          int       `pack:"i,i8"         json:"index"`
	OwnStake       int64     `pack:"O"            json:"own_stake"`
	StakingBalance int64     `pack:"K"            json:"staking_balance"`
	AccountId      AccountID `pack:"a,u32,bloom"  json:"account_id"`
	BakerId        AccountID `pack:"d,u32"        json:"baker_id"`
	IsBaker        bool      `pack:"?,snappy"     json:"is_baker"`
	IsActive       bool      `pack:"v,snappy"     json:"is_active"`
	Balance        int64     `pack:"B"            json:"balance"`
	Delegated      int64     `pack:"D"            json:"delegated"`
	NDelegations   int64     `pack:"n,i32"        json:"n_delegations"`
	NStakers       int64     `pack:"#,i32"        json:"n_stakers"`
	Since          int64     `pack:"S,i32"        json:"since"`
}

type Stake struct {
	RowId     uint64    `pack:"I,pk"  json:"row_id"`
	Height    int64     `pack:"h,i32" json:"height"`
	AccountId AccountID `pack:"A"     json:"account_id"`
	Stake     int64     `pack:"s"     json:"stake"`
}

type Status struct {
	Status    string  `json:"status"`
	Blocks    int64   `json:"blocks"`
	Finalized int64   `json:"finalized"`
	Indexed   int64   `json:"indexed"`
	Progress  float64 `json:"progress"`
}

type Storage struct {
	RowId     StorageID `pack:"I,pk"             json:"row_id"`
	AccountId AccountID `pack:"A,bloom=3,snappy" json:"account_id"`
	Hash      uint64    `pack:"H,bloom=3,snappy" json:"hash"`
	Height    int64     `pack:"h,i32"            json:"height"`
	Storage   []byte    `pack:"S,snappy"         json:"storage"`
}