snapshot

type AccountFreeActionsObject struct {
	Name                 roxe.AccountName
	PermissionObject     FreeObjectUsage
	SharedKey            FreeObjectUsage
	PermissionLevel      FreeObjectUsage
	Wait                 FreeObjectUsage
	PermissionLinkObject FreeObjectUsage
}

type AccountMetadataObject struct {
	Name           roxe.AccountName //< name should not be changed within a chainbase modifier lambda
	RecvSequence   roxe.Uint64
	AuthSequence   roxe.Uint64
	CodeSequence   roxe.Uint64
	ABISequence    roxe.Uint64
	CodeHash       roxe.Checksum256
	LastCodeUpdate roxe.TimePoint
	Flags          uint32 // First flag means "privileged".
	VMType         byte
	VMVersion      byte
}

type AccountObject struct {
	Name         roxe.AccountName
	CreationDate roxe.BlockTimestamp
	RawABI       []byte
}

type AccountRAMCorrectionObject struct {
	Name          roxe.AccountName
	RAMCorrection roxe.Uint64
}

type ActivatedProtocolFeature struct {
	FeatureDigest      roxe.Checksum256
	ActivationBlockNum uint32
}

type BlockState struct {
	/// from block_header_state_common
	BlockNum                         uint32                          `json:"block_num"`
	DposProposedIrreversibleBlocknum uint32                          `json:"dpos_proposed_irreversible_blocknum"`
	DposIrreversibleBlocknum         uint32                          `json:"dpos_irreversible_blocknum"`
	ActiveSchedule                   *roxe.ProducerAuthoritySchedule `json:"active_schedule"`
	BlockrootMerkle                  *roxe.MerkleRoot                `json:"blockroot_merkle"`
	ProducerToLastProduced           []roxe.PairAccountNameBlockNum  `json:"producer_to_last_produced"`
	ProducerToLastImpliedIrb         []roxe.PairAccountNameBlockNum  `json:"producer_to_last_implied_irb"`
	BlockSigningKey                  *roxe.BlockSigningAuthority     `json:"block_signing_key"`
	ConfirmCount                     []uint8                         `json:"confirm_count"`

	// from block_header_state
	BlockID                   roxe.Checksum256                   `json:"id"`
	Header                    *roxe.SignedBlockHeader            `json:"header"`
	PendingSchedule           *ScheduleInfo                      `json:"pending_schedule"`
	ActivatedProtocolFeatures *roxe.ProtocolFeatureActivationSet `json:"activated_protocol_features"`
}

type BlockSummary struct {
	BlockID roxe.Checksum256
}

type ChainConfig struct {
	MaxBlockNetUsage               roxe.Uint64 ///< the maxiumum net usage in instructions for a block
	TargetBlockNetUsagePct         uint32      ///< the target percent (1% == 100, 100%= 10,000) of maximum net usage; exceeding this triggers congestion handling
	MaxTransactionNetUsage         uint32      ///< the maximum objectively measured net usage that the chain will allow regardless of account limits
	BasePerTransactionNetUsage     uint32      ///< the base amount of net usage billed for a transaction to cover incidentals
	NetUsageLeeway                 uint32
	ContextFreeDiscountNetUsageNum uint32 ///< the numerator for the discount on net usage of context-free data
	ContextFreeDiscountNetUsageDen uint32 ///< the denominator for the discount on net usage of context-free data

	MaxBlockCpuUsage       uint32 ///< the maxiumum billable cpu usage (in microseconds) for a block
	TargetBlockCpuUsagePct uint32 ///< the target percent (1% == 100, 100%= 10,000) of maximum cpu usage; exceeding this triggers congestion handling
	MaxTransactionCpuUsage uint32 ///< the maximum billable cpu usage (in microseconds) that the chain will allow regardless of account limits
	MinTransactionCpuUsage uint32 ///< the minimum billable cpu usage (in microseconds) that the chain requires

	MaxTransactionLifetime      uint32 ///< the maximum number of seconds that an input transaction's expiration can be ahead of the time of the block in which it is first included
	DeferredTrxExpirationWindow uint32 ///< the number of seconds after the time a deferred transaction can first execute until it expires
	MaxTransactionDelay         uint32 ///< the maximum number of seconds that can be imposed as a delay requirement by authorization checks
	MaxInlineActionSize         uint32 ///< maximum allowed size (in bytes) of an inline action
	MaxInlineActionDepth        uint16 ///< recursion depth limit on sending inline actions
	MaxAuthorityDepth           uint16 ///< recursion depth limit for checking if an authority is satisfied
}

type ChainSnapshotHeader struct {
	Version uint32
}

type CodeObject struct {
	CodeHash       roxe.Checksum256 //< code_hash should not be changed within a chainbase modifier lambda
	Code           roxe.HexBytes
	CodeRefCount   roxe.Uint64
	FirstBlockUsed uint32
	VMType         uint8 //< vm_type should not be changed within a chainbase modifier lambda
	VMVersion      uint8 //< vm_version should not be changed within a chainbase modifier lambda
}

type ContractRow struct {
	PrimKey string
	Payer   string
}

type DynamicGlobalPropertyObject struct {
	GlobalActionSequence roxe.Uint64
}

type ElasticLimitParameters struct {
	Target  roxe.Uint64 // the desired usage
	Max     roxe.Uint64 // the maximum usage
	Periods uint32      // the number of aggregation periods that contribute to the average usage

	MaxMultiplier uint32      // the multiplier by which virtual space can oversell usage when uncongested
	ContractRate  roxe.Uint64 // the rate at which a congested resource contracts its limit
	ExpandRate    roxe.Uint64 // the rate at which an uncongested resource expands its limits
}

type FreeObjectUsage struct {
	UserSize   roxe.Uint64
	UserCount  roxe.Uint64
	UltraSize  roxe.Uint64
	UltraCount roxe.Uint64
}

type GeneratedTransactionObject struct {
	TrxID      roxe.Checksum256 //< trx_id should not be changed within a chainbase modifier lambda
	Sender     roxe.AccountName //< sender should not be changed within a chainbase modifier lambda
	SenderID   roxe.Uint128     /// ID given this transaction by the sender (should not be changed within a chainbase modifier lambda)
	Payer      roxe.AccountName
	DelayUntil roxe.TimePoint /// this generated transaction will not be applied until the specified time
	Expiration roxe.TimePoint /// this generated transaction will not be applied after  time
	Published  roxe.TimePoint
	PackedTrx  roxe.HexBytes
}

type GenesisState struct {
	//InitialConfiguration ChainConfig //roxe.ChainConfig
	InitialTimestamp roxe.TimePoint
	InitialKey       ecc.PublicKey
}

type GlobalPropertyObject struct {
	ProposedScheduleBlockNum uint32 `roxe:"optional"`
	ProposedSchedule         *roxe.ProducerAuthoritySchedule
	Configuration            ChainConfig
	ChainID                  roxe.Checksum256
}

type Header struct {
	Version uint32
}

type Index64Object struct {
	ContractRow
	SecondaryKey roxe.Name
}

type Index128Object struct {
	ContractRow
	SecondaryKey roxe.Uint128
}

type Index256Object struct {
	ContractRow
	SecondaryKey roxe.Checksum256
}

type IndexDoubleObject struct {
	ContractRow
	SecondaryKey roxe.Float64
}

type IndexLongDoubleObject struct {
	ContractRow
	SecondaryKey roxe.Float128
}

type KeyValueObject struct {
	ContractRow
	Value roxe.HexBytes
}

type PermissionLinkObject struct {
	/// The account which is defining its permission requirements
	Account roxe.AccountName
	/// The contract which account requires @ref required_permission to invoke
	Code roxe.AccountName
	/// The message type which account requires @ref required_permission to invoke
	/// May be empty; if so, it sets a default @ref required_permission for all messages to @ref code
	MessageType roxe.ActionName
	/// The permission level which @ref account requires for the specified message types
	/// all of the above fields should not be changed within a chainbase modifier lambda
	RequiredPermission roxe.PermissionName
}

type PermissionObject struct {
	Parent      roxe.PermissionName ///< parent permission
	Owner       roxe.AccountName    ///< the account this permission belongs to
	Name        roxe.PermissionName ///< human-readable name for the permission
	LastUpdated roxe.TimePoint      ///< the last time this authority was updated
	LastUsed    roxe.TimePoint      ///< when this permission was last used
	Auth        roxe.Authority      ///< authority required to execute this permission
}

type ProtocolStateObject struct {
	ActivatedProtocolFeatures    []*ActivatedProtocolFeature
	PreactivatedProtocolFeatures []roxe.Checksum256
	WhitelistedIntrinsics        []string
	NumSupportedKeyTypes         uint32
}

type Reader struct {
	Header         *Header
	CurrentSection *Section
	// contains filtered or unexported fields
}

type ResourceLimitsConfigObject struct {
	CPULimitParameters ElasticLimitParameters
	NetLimitParameters ElasticLimitParameters

	AccountCPUUsageAverageWindow uint32
	AccountNetUsageAverageWindow uint32
}

type ResourceLimitsObject struct {
	Owner roxe.AccountName //<  should not be changed within a chainbase modifier lambda

	NetWeight roxe.Int64
	CPUWeight roxe.Int64
	RAMBytes  roxe.Int64
}

type ResourceLimitsStateObject struct {
	/**
	 * Track the average netusage for blocks
	 */
	AverageBlockNetUsage UsageAccumulator

	/**
	 * Track the average cpu usage for blocks
	 */
	AverageBlockCPUUsage UsageAccumulator

	PendingNetUsage roxe.Uint64
	PendingCPUUsage roxe.Uint64

	TotalNetWeight roxe.Uint64
	TotalCPUWeight roxe.Uint64
	TotalRAMBytes  roxe.Uint64

	/**
	 * The virtual number of bytes that would be consumed over blocksize_average_window_ms
	 * if all blocks were at their maximum virtual size. This is virtual because the
	 * real maximum block is less, this virtual number is only used for rate limiting users.
	 *
	 * It's lowest possible value is max_block_size * blocksize_average_window_ms / block_interval
	 * It's highest possible value is config::maximum_elastic_resource_multiplier (1000) times its lowest possible value
	 *
	 * This means that the most an account can consume during idle periods is 1000x the bandwidth
	 * it is gauranteed under congestion.
	 *
	 * Increases when average_block_size < target_block_size, decreases when
	 * average_block_size > target_block_size, with a cap at 1000x max_block_size
	 * and a floor at max_block_size;
	 **/
	VirtualNetLimit roxe.Uint64

	/**
	 *  Increases when average_bloc
	 */
	VirtualCPULimit roxe.Uint64
}

type ResourceUsageObject struct {
	Owner roxe.AccountName //< owner should not be changed within a chainbase modifier lambda

	NetUsage UsageAccumulator
	CPUUsage UsageAccumulator

	RAMUsage roxe.Uint64
}

type ScheduleInfo struct {
	ScheduleLIBNum uint32                          `json:"schedule_lib_num"`
	ScheduleHash   roxe.Checksum256                `json:"schedule_hash"`
	Schedule       *roxe.ProducerAuthoritySchedule `json:"schedule"`
}

type Section struct {
	Name       SectionName
	Offset     uint64
	Size       uint64 // This includes the section name and row count
	BufferSize uint64 // This represents the bytes that are following the section header
	RowCount   uint64 // This is a count of rows packed in `Buffer`
	Buffer     io.Reader
}

type SectionName string

type TableIDObject struct {
	Code      string
	Scope     string
	TableName string
	Payer     string
	Count     uint32 // represents the number of rows & indices for a given table
}

type TransactionObject struct {
	Expiration roxe.TimePointSec
	TrxID      roxe.Checksum256 //< trx_id shou
}

type UsageAccumulator struct {
	LastOrdinal uint32      ///< The ordinal of the last period which has contributed to the average
	ValueEx     roxe.Uint64 ///< The current average pre-multiplied by Precision
	Consumed    roxe.Uint64 ///< The last periods average + the current periods contribution so far
}