exporter

package
v0.0.0-...-b8dc01b Latest Latest
Warning

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

Go to latest
Published: Apr 26, 2023 License: GPL-3.0 Imports: 61 Imported by: 0

Documentation

Index

Constants

View Source
const GethEventLogInterval = 25000

Variables

View Source
var Client *rpc.Client

Functions

func CalculateLifetimeNodeRewardsAllLegacy

func CalculateLifetimeNodeRewardsAllLegacy(rp *rocketpool.RocketPool, intervalSize *big.Int, legacyRocketRewardsPoolAddress *common.Address, legacyRocketClaimNodeAddress *common.Address) (map[string]*big.Int, error)

func DownloadRewardsFile

func DownloadRewardsFile(fileName string, interval uint64, cid string, isDaemon bool) ([]byte, error)

func ExportEpoch

func ExportEpoch(epoch uint64, client rpc.Client) error

ExportEpoch will export an epoch from rpc into the database

func GetLastBlocks

func GetLastBlocks(startEpoch, endEpoch uint64, client rpc.Client) ([]*types.MinimalBlock, error)

GetLastBlocks will get all blocks for a range of epochs

func IsAtlasDeployed

func IsAtlasDeployed(rp *rocketpool.RocketPool) (bool, error)

func MarkMissedBlocks

func MarkMissedBlocks(startEpoch, endEpoch uint64) error

MarkMissedBlocks will mark the missed blocks in the database

func MarkOrphanedBlocks

func MarkOrphanedBlocks(startEpoch, endEpoch uint64, blocks []*types.MinimalBlock) error

MarkOrphanedBlocks will mark the orphaned blocks in the database

func Start

func Start(client rpc.Client) error

Start will start the export of data from rpc into the database

func StartEthStoreExporter

func StartEthStoreExporter(bnAddress string, enAddress string, updateInterval, errorInterval, sleepInterval time.Duration)

start exporting of eth.store into db

func UpdatePubkeyTag

func UpdatePubkeyTag()

Types

type BidTrace

type BidTrace struct {
	Slot                 uint64          `json:"slot,string"`
	ParentHash           string          `json:"parent_hash"`
	BlockHash            string          `json:"block_hash"`
	BuilderPubkey        string          `json:"builder_pubkey"`
	ProposerPubkey       string          `json:"proposer_pubkey"`
	ProposerFeeRecipient string          `json:"proposer_fee_recipient"`
	GasLimit             uint64          `json:"gas_limit,string"`
	GasUsed              uint64          `json:"gas_used,string"`
	Value                types.WeiString `json:"value"`
}

type EthStoreExporter

type EthStoreExporter struct {
	DB             *sqlx.DB
	BNAddress      string
	ENAddress      string
	UpdateInverval time.Duration
	ErrorInterval  time.Duration
	Sleep          time.Duration
}

func (*EthStoreExporter) ExportDay

func (ese *EthStoreExporter) ExportDay(day string) error

func (*EthStoreExporter) Run

func (ese *EthStoreExporter) Run()

type MinipoolPerformanceFile

type MinipoolPerformanceFile struct {
	Index               uint64                                               `json:"index"`
	Network             string                                               `json:"network"`
	MinipoolPerformance map[common.Address]*SmoothingPoolMinipoolPerformance `json:"minipoolPerformance"`
}

type NetworkRewardsInfo

type NetworkRewardsInfo struct {
	CollateralRpl    *QuotedBigInt `json:"collateralRpl"`
	OracleDaoRpl     *QuotedBigInt `json:"oracleDaoRpl"`
	SmoothingPoolEth *QuotedBigInt `json:"smoothingPoolEth"`
}

Rewards per network

type NodeRewardsInfo

type NodeRewardsInfo struct {
	RewardNetwork                uint64        `json:"rewardNetwork"`
	CollateralRpl                *QuotedBigInt `json:"collateralRpl"`
	OracleDaoRpl                 *QuotedBigInt `json:"oracleDaoRpl"`
	SmoothingPoolEth             *QuotedBigInt `json:"smoothingPoolEth"`
	SmoothingPoolEligibilityRate float64       `json:"smoothingPoolEligibilityRate"`
	MerkleData                   []byte        `json:"-"`
	MerkleProof                  []string      `json:"merkleProof"`
}

Node operator rewards

type QuotedBigInt

type QuotedBigInt struct {
	big.Int
}

func NewQuotedBigInt

func NewQuotedBigInt(x int64) *QuotedBigInt

func NewQuotedBigIntFromBigInt

func NewQuotedBigIntFromBigInt(x *big.Int) *QuotedBigInt

func (*QuotedBigInt) MarshalJSON

func (b *QuotedBigInt) MarshalJSON() ([]byte, error)

func (*QuotedBigInt) UnmarshalJSON

func (b *QuotedBigInt) UnmarshalJSON(p []byte) error

type RewardsFile

type RewardsFile struct {
	// Serialized fields
	RewardsFileVersion         uint64                              `json:"rewardsFileVersion"`
	Index                      uint64                              `json:"index"`
	Network                    string                              `json:"network"`
	StartTime                  time.Time                           `json:"startTime,omitempty"`
	EndTime                    time.Time                           `json:"endTime"`
	ConsensusStartBlock        uint64                              `json:"consensusStartBlock,omitempty"`
	ConsensusEndBlock          uint64                              `json:"consensusEndBlock"`
	ExecutionStartBlock        uint64                              `json:"executionStartBlock,omitempty"`
	ExecutionEndBlock          uint64                              `json:"executionEndBlock"`
	IntervalsPassed            uint64                              `json:"intervalsPassed"`
	MerkleRoot                 string                              `json:"merkleRoot,omitempty"`
	MinipoolPerformanceFileCID string                              `json:"minipoolPerformanceFileCid,omitempty"`
	TotalRewards               *TotalRewards                       `json:"totalRewards"`
	NetworkRewards             map[uint64]*NetworkRewardsInfo      `json:"networkRewards"`
	NodeRewards                map[common.Address]*NodeRewardsInfo `json:"nodeRewards"`
	MinipoolPerformanceFile    MinipoolPerformanceFile             `json:"-"`
}

JSON struct for a complete rewards file

type RocketpoolDAOMember

type RocketpoolDAOMember struct {
	Address                []byte    `db:"address"`
	ID                     string    `db:"id"`
	URL                    string    `url:"url"`
	JoinedTime             time.Time `db:"joined_time"`
	LastProposalTime       time.Time `db:"last_proposal_time"`
	RPLBondAmount          *big.Int  `db:"rpl_bond_amount"`
	UnbondedValidatorCount uint64    `db:"unbonded_validator_count"`
}

func NewRocketpoolDAOMember

func NewRocketpoolDAOMember(rp *rocketpool.RocketPool, addr []byte) (*RocketpoolDAOMember, error)

func (*RocketpoolDAOMember) Update

type RocketpoolDAOProposal

type RocketpoolDAOProposal struct {
	ID              uint64    `db:"id"`
	DAO             string    `db:"dao"`
	ProposerAddress []byte    `db:"proposer_address"`
	Message         string    `db:"message"`
	CreatedTime     time.Time `db:"created_time"`
	StartTime       time.Time `db:"start_time"`
	EndTime         time.Time `db:"end_time"`
	ExpiryTime      time.Time `db:"expiry_time"`
	VotesRequired   float64   `db:"votes_required"`
	VotesFor        float64   `db:"votes_for"`
	VotesAgainst    float64   `db:"votes_against"`
	MemberVoted     bool      `db:"member_voted"`
	MemberSupported bool      `db:"member_supported"`
	IsCancelled     bool      `db:"is_cancelled"`
	IsExecuted      bool      `db:"is_executed"`
	Payload         []byte    `db:"payload"`
	State           string    `db:"state"`
	MemberVotes     []RocketpoolDAOProposalMemberVotes
}

func NewRocketpoolDAOProposal

func NewRocketpoolDAOProposal(rp *rocketpool.RocketPool, pid uint64) (*RocketpoolDAOProposal, error)

func (*RocketpoolDAOProposal) Update

type RocketpoolDAOProposalMemberVotes

type RocketpoolDAOProposalMemberVotes struct {
	ProposalID uint64 `db:"id"`
	Address    []byte `db:"member_address"`
	Voted      bool   `db:"voted"`
	Supported  bool   `db:"supported"`
}

type RocketpoolExporter

type RocketpoolExporter struct {
	Eth1Client                         *ethclient.Client
	API                                *rocketpool.RocketPool
	DB                                 *sqlx.DB
	UpdateInterval                     time.Duration
	MinipoolsByAddress                 map[string]*RocketpoolMinipool
	NodesByAddress                     map[string]*RocketpoolNode
	DAOProposalsByID                   map[uint64]*RocketpoolDAOProposal
	DAOMembersByAddress                map[string]*RocketpoolDAOMember
	NodeRPLCumulative                  map[string]*big.Int
	NetworkStats                       RocketpoolNetworkStats
	LastRewardTree                     uint64
	RocketpoolRewardTreesDownloadQueue []RocketpoolRewardTreeDownloadable
	RocketpoolRewardTreeData           map[uint64]RewardsFile
}

func NewRocketpoolExporter

func NewRocketpoolExporter(eth1Client *ethclient.Client, storageContractAddressHex string, db *sqlx.DB) (*RocketpoolExporter, error)

func (*RocketpoolExporter) DownloadMissingRewardTrees

func (rp *RocketpoolExporter) DownloadMissingRewardTrees() error

func (*RocketpoolExporter) Init

func (rp *RocketpoolExporter) Init() error

func (*RocketpoolExporter) InitDAOMembers

func (rp *RocketpoolExporter) InitDAOMembers() error

func (*RocketpoolExporter) InitDAOProposals

func (rp *RocketpoolExporter) InitDAOProposals() error

func (*RocketpoolExporter) InitMinipools

func (rp *RocketpoolExporter) InitMinipools() error

func (*RocketpoolExporter) InitNodes

func (rp *RocketpoolExporter) InitNodes() error

func (*RocketpoolExporter) Run

func (rp *RocketpoolExporter) Run() error

func (*RocketpoolExporter) Save

func (rp *RocketpoolExporter) Save(count int64) error

func (*RocketpoolExporter) SaveDAOMembers

func (rp *RocketpoolExporter) SaveDAOMembers() error

func (*RocketpoolExporter) SaveDAOProposals

func (rp *RocketpoolExporter) SaveDAOProposals() error

func (*RocketpoolExporter) SaveDAOProposalsMemberVotes

func (rp *RocketpoolExporter) SaveDAOProposalsMemberVotes() error

func (*RocketpoolExporter) SaveMinipools

func (rp *RocketpoolExporter) SaveMinipools() error

func (*RocketpoolExporter) SaveNetworkStats

func (rp *RocketpoolExporter) SaveNetworkStats() error

func (*RocketpoolExporter) SaveNodes

func (rp *RocketpoolExporter) SaveNodes() error

func (*RocketpoolExporter) SaveRewardTrees

func (rp *RocketpoolExporter) SaveRewardTrees() error

func (*RocketpoolExporter) TagValidators

func (rp *RocketpoolExporter) TagValidators() error

func (*RocketpoolExporter) Update

func (rp *RocketpoolExporter) Update(count int64) error

func (*RocketpoolExporter) UpdateDAOMembers

func (rp *RocketpoolExporter) UpdateDAOMembers() error

func (*RocketpoolExporter) UpdateDAOProposals

func (rp *RocketpoolExporter) UpdateDAOProposals() error

func (*RocketpoolExporter) UpdateMinipools

func (rp *RocketpoolExporter) UpdateMinipools() error

func (*RocketpoolExporter) UpdateNetworkStats

func (rp *RocketpoolExporter) UpdateNetworkStats() error

func (*RocketpoolExporter) UpdateNodes

func (rp *RocketpoolExporter) UpdateNodes(includeCumulativeRpl bool) error

type RocketpoolMinipool

type RocketpoolMinipool struct {
	Address            []byte    `db:"address"`
	Pubkey             []byte    `db:"pubkey"`
	NodeAddress        []byte    `db:"node_address"`
	NodeFee            float64   `db:"node_fee"`
	DepositType        string    `db:"deposit_type"`
	Status             string    `db:"status"`
	StatusTime         time.Time `db:"status_time"`
	PenaltyCount       uint64    `db:"penalty_count"`
	NodeDepositBalance *big.Int  `db:"node_deposit_balance"`
	NodeRefundBalance  *big.Int  `db:"node_refund_balance"`
	UserDepositBalance *big.Int  `db:"user_deposit_balance"`
	IsVacant           bool      `db:"is_vacant"`
	Version            uint8     `db:"version"`
}

func NewRocketpoolMinipool

func NewRocketpoolMinipool(rp *rocketpool.RocketPool, addr []byte, atlasDeployed bool) (*RocketpoolMinipool, error)

func (*RocketpoolMinipool) Update

func (r *RocketpoolMinipool) Update(rp *rocketpool.RocketPool, atlasDeployed bool) error

type RocketpoolNetworkStats

type RocketpoolNetworkStats struct {
	RPLPrice               *big.Int
	ClaimIntervalTime      time.Duration
	ClaimIntervalTimeStart time.Time
	CurrentNodeFee         float64
	CurrentNodeDemand      *big.Int
	RETHSupply             *big.Int
	NodeOperatorRewards    *big.Int
	RETHPrice              float64
	TotalEthStaking        *big.Int
	TotalEthBalance        *big.Int
}

type RocketpoolNode

type RocketpoolNode struct {
	Address                []byte   `db:"address"`
	TimezoneLocation       string   `db:"timezone_location"`
	RPLStake               *big.Int `db:"rpl_stake"`
	EffectiveRPLStake      *big.Int `db:"effective_rpl_stake"`
	MinRPLStake            *big.Int `db:"min_rpl_stake"`
	MaxRPLStake            *big.Int `db:"max_rpl_stake"`
	RPLCumulativeRewards   *big.Int `db:"rpl_cumulative_rewards"`
	SmoothingPoolOptedIn   bool     `db:"smoothing_pool_opted_in"`
	ClaimedSmoothingPool   *big.Int `db:"claimed_smoothing_pool"`
	UnclaimedSmoothingPool *big.Int `db:"unclaimed_smoothing_pool"`
	UnclaimedRPLRewards    *big.Int `db:"unclaimed_rpl_rewards"`
	DepositCredit          *big.Int `db:"deposit_credit"`
}

func NewRocketpoolNode

func NewRocketpoolNode(rp *rocketpool.RocketPool, addr []byte, rewardTrees map[uint64]RewardsFile, legacyClaims map[string]*big.Int, atlasDeployed bool) (*RocketpoolNode, error)

func (*RocketpoolNode) Update

func (r *RocketpoolNode) Update(rp *rocketpool.RocketPool, rewardTrees map[uint64]RewardsFile, includeCumulativeRpl bool, legacyClaims map[string]*big.Int, atlasDeployed bool) error

type RocketpoolRewardTreeDownloadable

type RocketpoolRewardTreeDownloadable struct {
	ID   uint64
	Data []byte
}

type RocketpoolRewards

type RocketpoolRewards struct {
	RplColl          *big.Int
	SmoothingPoolEth *big.Int
	OdaoRpl          *big.Int
}

type SSVExporterResponse

type SSVExporterResponse struct {
	Type   string `json:"type"`
	Filter struct {
		From int `json:"from"`
		To   int `json:"to"`
	} `json:"filter"`
	Data []struct {
		Index     int    `json:"index"`
		Publickey string `json:"publicKey"`
		Operators []struct {
			Nodeid    int    `json:"nodeId"`
			Publickey string `json:"publicKey"`
		} `json:"operators"`
	} `json:"data"`
}

type SmoothingPoolMinipoolPerformance

type SmoothingPoolMinipoolPerformance struct {
	Pubkey                  string   `json:"pubkey"`
	SuccessfulAttestations  uint64   `json:"successfulAttestations"`
	MissedAttestations      uint64   `json:"missedAttestations"`
	ParticipationRate       float64  `json:"participationRate"`
	MissingAttestationSlots []uint64 `json:"missingAttestationSlots"`
	EthEarned               float64  `json:"ethEarned"`
}

Minipool stats

type TotalRewards

type TotalRewards struct {
	ProtocolDaoRpl               *QuotedBigInt `json:"protocolDaoRpl"`
	TotalCollateralRpl           *QuotedBigInt `json:"totalCollateralRpl"`
	TotalOracleDaoRpl            *QuotedBigInt `json:"totalOracleDaoRpl"`
	TotalSmoothingPoolEth        *QuotedBigInt `json:"totalSmoothingPoolEth"`
	PoolStakerSmoothingPoolEth   *QuotedBigInt `json:"poolStakerSmoothingPoolEth"`
	NodeOperatorSmoothingPoolEth *QuotedBigInt `json:"nodeOperatorSmoothingPoolEth"`
}

Total cumulative rewards for an interval

type VerifyResponse

type VerifyResponse struct {
	Valid          bool
	ExpirationDate int64
	RejectReason   string
}

func VerifyReceipt

func VerifyReceipt(googleClient *playstore.Client, receipt *types.PremiumData) (*VerifyResponse, error)

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL