types

type Account struct {
	Status          byte     `codec:"onl"`
	MicroAlgos      uint64   `codec:"algo"`
	VoteID          [32]byte `codec:"vote"`
	StateProofID    [64]byte `codec:"stprf"`
	SelectionID     [32]byte `codec:"sel"`
	VoteFirstValid  uint64   `codec:"voteFst"`
	VoteLastValid   uint64   `codec:"voteLst"`
	VoteKeyDilution uint64   `codec:"voteKD"`
	// contains filtered or unexported fields
}

type AccountApp struct {
	Address Address
	App     AppIndex
}

type AccountAsset struct {
	Address Address
	Asset   AssetIndex
}

type AccountBaseData struct {
	Status             Status
	MicroAlgos         MicroAlgos
	RewardsBase        uint64
	RewardedMicroAlgos MicroAlgos
	AuthAddr           Address

	TotalAppSchema      StateSchema // Totals across created globals, and opted in locals.
	TotalExtraAppPages  uint32      // Total number of extra pages across all created apps
	TotalAppParams      uint64      // Total number of apps this account has created
	TotalAppLocalStates uint64      // Total number of apps this account is opted into.
	TotalAssetParams    uint64      // Total number of assets created by this account
	TotalAssets         uint64      // Total of asset creations and optins (i.e. number of holdings)
	TotalBoxes          uint64      // Total number of boxes associated to this account
	TotalBoxBytes       uint64      // Total bytes for this account's boxes. keys _and_ values count
}

type AccountData struct {
	AccountBaseData
	VotingData
}

type AccountDeltas struct {
	// Actual data. If an account is deleted, `Accts` contains the BalanceRecord
	// with an empty `AccountData` and a populated `Addr`.
	Accts []BalanceRecord

	// AppResources deltas. If app params or local state is deleted, there is a nil value in AppResources.Params or AppResources.State and Deleted flag set
	AppResources []AppResourceRecord

	AssetResources []AssetResourceRecord
	// contains filtered or unexported fields
}

type AccountTotals struct {
	Online           AlgoCount `codec:"online"`
	Offline          AlgoCount `codec:"offline"`
	NotParticipating AlgoCount `codec:"notpart"`

	// Total number of algos received per reward unit since genesis
	RewardsLevel uint64 `codec:"rwdlvl"`
	// contains filtered or unexported fields
}

type Address [hashLenBytes]byte

type AlgoCount struct {

	// Sum of algos of all accounts in this class.
	Money MicroAlgos `codec:"mon"`

	// Total number of whole reward units in accounts.
	RewardUnits uint64 `codec:"rwd"`
	// contains filtered or unexported fields
}

type AppBoxReference struct {
	// The ID of the app that owns the box. Must be converted to BoxReference during transaction submission.
	AppID uint64

	// The Name of the box unique to the app it belongs to
	Name []byte
}

type AppIndex uint64

type AppLocalState struct {
	Schema   StateSchema  `codec:"hsch"`
	KeyValue TealKeyValue `codec:"tkv"`
	// contains filtered or unexported fields
}

type AppLocalStateDelta struct {
	LocalState *AppLocalState
	Deleted    bool
}

type AppParams struct {
	ApprovalProgram   []byte       `codec:"approv,allocbound=config.MaxAvailableAppProgramLen"`
	ClearStateProgram []byte       `codec:"clearp,allocbound=config.MaxAvailableAppProgramLen"`
	GlobalState       TealKeyValue `codec:"gs"`
	StateSchemas
	ExtraProgramPages uint32 `codec:"epp"`
	// contains filtered or unexported fields
}

type AppParamsDelta struct {
	Params  *AppParams
	Deleted bool
}

type AppResourceRecord struct {
	Aidx   AppIndex
	Addr   Address
	Params AppParamsDelta
	State  AppLocalStateDelta
}

type ApplicationCallTxnFields struct {
	ApplicationID   AppIndex       `codec:"apid"`
	OnCompletion    OnCompletion   `codec:"apan"`
	ApplicationArgs [][]byte       `codec:"apaa,allocbound=encodedMaxApplicationArgs,maxtotalbytes=config.MaxAppTotalArgLen"`
	Accounts        []Address      `codec:"apat,allocbound=encodedMaxAccounts"`
	ForeignApps     []AppIndex     `codec:"apfa,allocbound=encodedMaxForeignApps"`
	ForeignAssets   []AssetIndex   `codec:"apas,allocbound=encodedMaxForeignAssets"`
	BoxReferences   []BoxReference `codec:"apbx,allocbound=encodedMaxBoxReferences"`

	LocalStateSchema  StateSchema `codec:"apls"`
	GlobalStateSchema StateSchema `codec:"apgs"`
	ApprovalProgram   []byte      `codec:"apap"`
	ClearStateProgram []byte      `codec:"apsu"`
	ExtraProgramPages uint32      `codec:"apep"`
	// contains filtered or unexported fields
}

type ApplicationFields struct {
	ApplicationCallTxnFields
}

type ApplyData struct {

	// Closing amount for transaction.
	ClosingAmount MicroAlgos `codec:"ca"`

	// Closing amount for asset transaction.
	AssetClosingAmount uint64 `codec:"aca"`

	// Rewards applied to the Sender, Receiver, and CloseRemainderTo accounts.
	SenderRewards   MicroAlgos `codec:"rs"`
	ReceiverRewards MicroAlgos `codec:"rr"`
	CloseRewards    MicroAlgos `codec:"rc"`
	EvalDelta       EvalDelta  `codec:"dt"`

	ConfigAsset   uint64 `codec:"caid"`
	ApplicationID uint64 `codec:"apid"`
	// contains filtered or unexported fields
}

type AssetConfigTxnFields struct {

	// ConfigAsset is the asset being configured or destroyed.
	// A zero value means allocation.
	ConfigAsset AssetIndex `codec:"caid"`

	// AssetParams are the parameters for the asset being
	// created or re-configured.  A zero value means destruction.
	AssetParams AssetParams `codec:"apar"`
	// contains filtered or unexported fields
}

type AssetFreezeTxnFields struct {

	// FreezeAccount is the address of the account whose asset
	// slot is being frozen or un-frozen.
	FreezeAccount Address `codec:"fadd"`

	// FreezeAsset is the asset ID being frozen or un-frozen.
	FreezeAsset AssetIndex `codec:"faid"`

	// AssetFrozen is the new frozen value.
	AssetFrozen bool `codec:"afrz"`
	// contains filtered or unexported fields
}

type AssetHolding struct {
	Amount uint64 `codec:"a"`
	Frozen bool   `codec:"f"`
	// contains filtered or unexported fields
}

type AssetHoldingDelta struct {
	Holding *AssetHolding
	Deleted bool
}

type AssetIndex uint64

type AssetParams struct {

	// Total specifies the total number of units of this asset
	// created.
	Total uint64 `codec:"t"`

	// Decimals specifies the number of digits to display after the decimal
	// place when displaying this asset. A value of 0 represents an asset
	// that is not divisible, a value of 1 represents an asset divisible
	// into tenths, and so on. This value must be between 0 and 19
	// (inclusive).
	Decimals uint32 `codec:"dc"`

	// DefaultFrozen specifies whether slots for this asset
	// in user accounts are frozen by default or not.
	DefaultFrozen bool `codec:"df"`

	// UnitName specifies a hint for the name of a unit of
	// this asset.
	UnitName string `codec:"un,allocbound=config.MaxAssetUnitNameBytes"`

	// AssetName specifies a hint for the name of the asset.
	AssetName string `codec:"an,allocbound=config.MaxAssetNameBytes"`

	// URL specifies a URL where more information about the asset can be
	// retrieved
	URL string `codec:"au,allocbound=config.MaxAssetURLBytes"`

	// MetadataHash specifies a commitment to some unspecified asset
	// metadata. The format of this metadata is up to the application.
	MetadataHash [AssetMetadataHashLen]byte `codec:"am"`

	// Manager specifies an account that is allowed to change the
	// non-zero addresses in this AssetParams.
	Manager Address `codec:"m"`

	// Reserve specifies an account whose holdings of this asset
	// should be reported as "not minted".
	Reserve Address `codec:"r"`

	// Freeze specifies an account that is allowed to change the
	// frozen state of holdings of this asset.
	Freeze Address `codec:"f"`

	// Clawback specifies an account that is allowed to take units
	// of this asset from any account.
	Clawback Address `codec:"c"`
	// contains filtered or unexported fields
}

type AssetParamsDelta struct {
	Params  *AssetParams
	Deleted bool
}

type AssetResourceRecord struct {
	Aidx    AssetIndex
	Addr    Address
	Params  AssetParamsDelta
	Holding AssetHoldingDelta
}

type AssetTransferTxnFields struct {
	XferAsset AssetIndex `codec:"xaid"`

	// AssetAmount is the amount of asset to transfer.
	// A zero amount transferred to self allocates that asset
	// in the account's Assets map.
	AssetAmount uint64 `codec:"aamt"`

	// AssetSender is the sender of the transfer.  If this is not
	// a zero value, the real transaction sender must be the Clawback
	// address from the AssetParams.  If this is the zero value,
	// the asset is sent from the transaction's Sender.
	AssetSender Address `codec:"asnd"`

	// AssetReceiver is the recipient of the transfer.
	AssetReceiver Address `codec:"arcv"`

	// AssetCloseTo indicates that the asset should be removed
	// from the account's Assets map, and specifies where the remaining
	// asset holdings should be transferred.  It's always valid to transfer
	// remaining asset holdings to the creator account.
	AssetCloseTo Address `codec:"aclose"`
	// contains filtered or unexported fields
}

type BalanceRecord struct {
	Addr Address
	AccountData
}

type Bid struct {

	// BidderKey identifies the bidder placing this bid.
	BidderKey Address `codec:"bidder"`

	// BidCurrency specifies how much external currency the bidder
	// is putting in with this bid.
	BidCurrency uint64 `codec:"cur"`

	// MaxPrice specifies the maximum price, in units of external
	// currency per Algo, that the bidder is willing to pay.
	// This must be at least as high as the current price of the
	// auction in the block in which this bid appears.
	MaxPrice uint64 `codec:"price"`

	// BidID identifies this bid.  The first bid by a bidder (identified
	// by BidderKey) with a particular BidID on the blockchain will be
	// considered, preventing replay of bids.  Specifying a different
	// BidID allows the bidder to place multiple bids in an auction.
	BidID uint64 `codec:"id"`

	// AuctionKey specifies the auction for this bid.
	AuctionKey Address `codec:"auc"`

	// AuctionID identifies the auction for which this bid is intended.
	AuctionID uint64 `codec:"aid"`
	// contains filtered or unexported fields
}

type Block struct {
	BlockHeader
	Payset Payset `codec:"txns,maxtotalbytes=config.MaxTxnBytesPerBlock"`
}

type BlockHash Digest

type BlockHeader struct {
	Round Round `codec:"rnd"`

	// The hash of the previous block
	Branch BlockHash `codec:"prev"`

	// Sortition seed
	Seed [32]byte `codec:"seed"`

	TxnCommitments

	// TimeStamp in seconds since epoch
	TimeStamp int64 `codec:"ts"`

	// Genesis ID to which this block belongs.
	GenesisID string `codec:"gen,allocbound=config.MaxGenesisIDLen"`

	// Genesis hash to which this block belongs.
	GenesisHash Digest `codec:"gh"`

	// Rewards.
	//
	// When a block is applied, some amount of rewards are accrued to
	// every account with AccountData.Status=/=NotParticipating.  The
	// amount is (thisBlock.RewardsLevel-prevBlock.RewardsLevel) of
	// MicroAlgos for every whole config.Protocol.RewardUnit of MicroAlgos in
	// that account's AccountData.MicroAlgos.
	//
	// Rewards are not compounded (i.e., not added to AccountData.MicroAlgos)
	// until some other transaction is executed on that account.
	//
	// Not compounding rewards allows us to precisely know how many algos
	// of rewards will be distributed without having to examine every
	// account to determine if it should get one more algo of rewards
	// because compounding formed another whole config.Protocol.RewardUnit
	// of algos.
	RewardsState

	// Consensus protocol versioning.
	//
	// Each block is associated with a version of the consensus protocol,
	// stored under UpgradeState.CurrentProtocol.  The protocol version
	// for a block can be determined without having to first decode the
	// block and its CurrentProtocol field, and this field is present for
	// convenience and explicitness.  Block.Valid() checks that this field
	// correctly matches the expected protocol version.
	//
	// Each block is associated with at most one active upgrade proposal
	// (a new version of the protocol).  An upgrade proposal can be made
	// by a block proposer, as long as no other upgrade proposal is active.
	// The upgrade proposal lasts for many rounds (UpgradeVoteRounds), and
	// in each round, that round's block proposer votes to support (or not)
	// the proposed upgrade.
	//
	// If enough votes are collected, the proposal is approved, and will
	// definitely take effect.  The proposal lingers for some number of
	// rounds to give clients a chance to notify users about an approved
	// upgrade, if the client doesn't support it, so the user has a chance
	// to download updated client software.
	//
	// Block proposers influence this upgrade machinery through two fields
	// in UpgradeVote: UpgradePropose, which proposes an upgrade to a new
	// protocol, and UpgradeApprove, which signals approval of the current
	// proposal.
	//
	// Once a block proposer determines its UpgradeVote, then UpdateState
	// is updated deterministically based on the previous UpdateState and
	// the new block's UpgradeVote.
	UpgradeState
	UpgradeVote

	// TxnCounter is the number of the next transaction that will be
	// committed after this block.  Genesis blocks can start at either
	// 0 or 1000, depending on a consensus parameter (AppForbidLowResources).
	TxnCounter uint64 `codec:"tc"`

	// StateProofTracking tracks the status of the state proofs, potentially
	// for multiple types of ASPs (Algorand's State Proofs).
	//msgp:sort protocol.StateProofType protocol.SortStateProofType
	StateProofTracking map[StateProofType]StateProofTrackingData `codec:"spt,allocbound=NumStateProofTypes"`

	// ParticipationUpdates contains the information needed to mark
	// certain accounts offline because their participation keys expired
	ParticipationUpdates
	// contains filtered or unexported fields
}

type BoxReference struct {

	// The index of the app in the foreign app array.
	ForeignAppIdx uint64 `codec:"i"`

	// The name of the box unique to the app it belongs to
	Name []byte `codec:"n"`
	// contains filtered or unexported fields
}

type Commitment [MerkleSignatureSchemeRootSize]byte

type CreatableIndex uint64

type CreatableType uint64

type DeltaAction uint64

type Digest [hashLenBytes]byte

type EvalDelta struct {
	GlobalDelta StateDelta `codec:"gd"`

	// When decoding EvalDeltas, the integer key represents an offset into
	// [txn.Sender, txn.Accounts[0], txn.Accounts[1], ...]
	//msgp:allocbound LocalDeltas config.MaxEvalDeltaAccounts
	LocalDeltas map[uint64]StateDelta `codec:"ld"`

	// If a program modifies the local of an account that is not the Sender, or
	// in txn.Accounts, it must be recorded here, so that the key in LocalDeltas
	// can refer to it.
	//msgp:allocbound SharedAccts config.MaxEvalDeltaAccounts
	SharedAccts []Address `codec:"sa"`

	Logs []string `codec:"lg"`

	InnerTxns []SignedTxnWithAD `codec:"itx"`
	// contains filtered or unexported fields
}

type FalconPublicKey [FalconPublicKeySize]byte

type FalconSignatureStruct struct {
	Signature             MerkleSignature `codec:"sig"`
	VectorCommitmentIndex uint64          `codec:"idx"`
	Proof                 SingleLeafProof `codec:"prf"`
	VerifyingKey          FalconVerifier  `codec:"vkey"`
	// contains filtered or unexported fields
}

type FalconVerifier struct {
	PublicKey FalconPublicKey `codec:"k"`
	// contains filtered or unexported fields
}

type GenericDigest []byte

type Genesis struct {

	// The SchemaID allows nodes to store data specific to a particular
	// universe
	SchemaID string `codec:"id"`

	// Network identifies the unique algorand network for which the ledger
	// is valid.
	Network string `codec:"network"`

	// Proto is the consensus protocol in use at the genesis block.
	Proto string `codec:"proto"`

	// Allocation determines the initial accounts and their state.
	Allocation []GenesisAllocation `codec:"alloc"`

	// RewardsPool is the address of the rewards pool.
	RewardsPool string `codec:"rwd"`

	// FeeSink is the address of the fee sink.
	FeeSink string `codec:"fees"`

	// Timestamp for the genesis block
	Timestamp int64 `codec:"timestamp"`

	// Arbitrary genesis comment string - will be excluded from file if empty
	Comment string `codec:"comment"`

	// DevMode defines whether this network operates in a developer mode or not. Developer mode networks
	// are a single node network, that operates without the agreement service being active. In liue of the
	// agreement service, a new block is generated each time a node receives a transaction group. The
	// default value for this field is "false", which makes this field empty from it's encoding, and
	// therefore backward compatible.
	DevMode bool `codec:"devmode"`
	// contains filtered or unexported fields
}

type GenesisAllocation struct {
	Address string  `codec:"addr"`
	Comment string  `codec:"comment"`
	State   Account `codec:"state"`
	// contains filtered or unexported fields
}

type GenesisBalances struct {
	Balances    map[Address]Account
	FeeSink     Address
	RewardsPool Address
	Timestamp   int64
}

type HashFactory struct {
	HashType HashType `codec:"t"`
	// contains filtered or unexported fields
}

type HashType uint16

type Header struct {
	Sender      Address    `codec:"snd"`
	Fee         MicroAlgos `codec:"fee"`
	FirstValid  Round      `codec:"fv"`
	LastValid   Round      `codec:"lv"`
	Note        []byte     `codec:"note"`
	GenesisID   string     `codec:"gen"`
	GenesisHash Digest     `codec:"gh"`

	// Group specifies that this transaction is part of a
	// transaction group (and, if so, specifies the hash
	// of a TxGroup).
	Group Digest `codec:"grp"`

	// Lease enforces mutual exclusion of transactions.  If this field is
	// nonzero, then once the transaction is confirmed, it acquires the
	// lease identified by the (Sender, Lease) pair of the transaction until
	// the LastValid round passes.  While this transaction possesses the
	// lease, no other transaction specifying this lease can be confirmed.
	Lease [32]byte `codec:"lx"`

	// RekeyTo, if nonzero, sets the sender's SpendingKey to the given address
	// If the RekeyTo address is the sender's actual address, the SpendingKey is set to zero
	// This allows "re-keying" a long-lived account -- rotating the signing key, changing
	// membership of a multisig account, etc.
	RekeyTo Address `codec:"rekey"`
	// contains filtered or unexported fields
}

type IncludedTransactions struct {
	LastValid Round
	Intra     uint64 // the index of the transaction in the block
}

type KeyregTxnFields struct {
	VotePK           VotePK         `codec:"votekey"`
	SelectionPK      VRFPK          `codec:"selkey"`
	VoteFirst        Round          `codec:"votefst"`
	VoteLast         Round          `codec:"votelst"`
	VoteKeyDilution  uint64         `codec:"votekd"`
	Nonparticipation bool           `codec:"nonpart"`
	StateProofPK     MerkleVerifier `codec:"sprfkey"`
	// contains filtered or unexported fields
}

type KvValueDelta struct {
	// Data stores the most recent value (nil == deleted)
	Data []byte

	// OldData stores the previous vlaue (nil == didn't exist)
	OldData []byte
}

type LedgerStateDelta struct {
	// modified new accounts
	Accts AccountDeltas

	// modified kv pairs (nil == delete)
	// not preallocated use .AddKvMod to insert instead of direct assignment
	KvMods map[string]KvValueDelta

	// new Txids for the txtail and TxnCounter, mapped to txn.LastValid
	Txids map[Txid]IncludedTransactions

	// new txleases for the txtail mapped to expiration
	// not pre-allocated so use .AddTxLease to insert instead of direct assignment
	Txleases map[Txlease]Round

	// new creatables creator lookup table
	// not pre-allocated so use .AddCreatable to insert instead of direct assignment
	Creatables map[CreatableIndex]ModifiedCreatable

	// new block header; read-only
	Hdr *BlockHeader

	// StateProofNext represents modification on StateProofNextRound field in the block header. If the block contains
	// a valid state proof transaction, this field will contain the next round for state proof.
	// otherwise it will be set to 0.
	StateProofNext Round

	// previous block timestamp
	PrevTimestamp int64

	// The account totals reflecting the changes in this StateDelta object.
	Totals AccountTotals
	// contains filtered or unexported fields
}

type LightBlockHeader struct {
	Seed                Seed   `codec:"0"`
	BlockHash           Digest `codec:"1"`
	RoundNumber         Round  `codec:"r"`
	GenesisHash         Digest `codec:"gh"`
	Sha256TxnCommitment Digest `codec:"tc,allocbound=Sha256Size"`
	// contains filtered or unexported fields
}

type LogicSig struct {

	// Logic signed by Sig or Msig
	// OR hashed to be the Address of an account.
	Logic []byte `codec:"l"`

	// The signature of the account that has delegated to this LogicSig, if any
	Sig Signature `codec:"sig"`

	// The signature of the multisig account that has delegated to this LogicSig, if any
	Msig MultisigSig `codec:"msig"`

	// Args are not signed, but checked by Logic
	Args [][]byte `codec:"arg"`
	// contains filtered or unexported fields
}

type MasterDerivationKey [masterDerivationKeyLenBytes]byte

type MerkleSignature []byte

type MerkleVerifier [KeyStoreRootSize]byte

type Message struct {

	// BlockHeadersCommitment contains a commitment on all light block headers within a state proof interval.
	BlockHeadersCommitment []byte `codec:"b,allocbound=Sha256Size"`
	VotersCommitment       []byte `codec:"v,allocbound=SumhashDigestSize"`
	LnProvenWeight         uint64 `codec:"P"`
	FirstAttestedRound     uint64 `codec:"f"`
	LastAttestedRound      uint64 `codec:"l"`
	// contains filtered or unexported fields
}

type MessageHash [32]byte

type MicroAlgos uint64

type ModifiedCreatable struct {
	// Type of the creatable: app or asset
	Ctype CreatableType

	// Created if true, deleted if false
	Created bool

	// creator of the app/asset
	Creator Address

	// Keeps track of how many times this app/asset appears in
	// accountUpdates.creatableDeltas
	Ndeltas int
}

type MultisigSig struct {
	Version   uint8            `codec:"v"`
	Threshold uint8            `codec:"thr"`
	Subsigs   []MultisigSubsig `codec:"subsig"`
	// contains filtered or unexported fields
}

type MultisigSubsig struct {
	Key ed25519.PublicKey `codec:"pk"`
	Sig Signature         `codec:"s"`
	// contains filtered or unexported fields
}

type NoteField struct {

	// Type indicates which type of a message this is
	Type NoteFieldType `codec:"t"`

	// SignedBid, for NoteBid type
	SignedBid SignedBid `codec:"b"`
	// contains filtered or unexported fields
}

type NoteFieldType string

type OnCompletion uint64

type OneTimeSignatureVerifier [32]byte

type Participant struct {

	// PK is the identifier used to verify the signature for a specific participant
	PK Verifier `codec:"p"`

	// Weight is AccountData.MicroAlgos.
	Weight uint64 `codec:"w"`
	// contains filtered or unexported fields
}

type ParticipationUpdates struct {

	// ExpiredParticipationAccounts contains a list of online accounts
	// that needs to be converted to offline since their
	// participation key expired.
	ExpiredParticipationAccounts []Address `codec:"partupdrmv"`
	// contains filtered or unexported fields
}

type PaymentTxnFields struct {
	Receiver Address    `codec:"rcv"`
	Amount   MicroAlgos `codec:"amt"`

	// When CloseRemainderTo is set, it indicates that the
	// transaction is requesting that the account should be
	// closed, and all remaining funds be transferred to this
	// address.
	CloseRemainderTo Address `codec:"close"`
	// contains filtered or unexported fields
}

type Payset []SignedTxnInBlock

type Proof struct {

	// Path is bounded by MaxNumLeavesOnEncodedTree since there could be multiple reveals, and
	// given the distribution of the elt positions and the depth of the tree,
	// the path length can increase up to 2^MaxEncodedTreeDepth / 2
	Path        []GenericDigest `codec:"pth,allocbound=MaxNumLeavesOnEncodedTree/2"`
	HashFactory HashFactory     `codec:"hsh"`
	// TreeDepth represents the depth of the tree that is being proven.
	// It is the number of edges from the root to a leaf.
	TreeDepth uint8 `codec:"td"`
	// contains filtered or unexported fields
}

type Reveal struct {
	SigSlot sigslotCommit `codec:"s"`
	Part    Participant   `codec:"p"`
	// contains filtered or unexported fields
}

type RewardsState struct {

	// The FeeSink accepts transaction fees. It can only spend to
	// the incentive pool.
	FeeSink Address `codec:"fees"`

	// The RewardsPool accepts periodic injections from the
	// FeeSink and continually redistributes them to adresses as
	// rewards.
	RewardsPool Address `codec:"rwd"`

	// RewardsLevel specifies how many rewards, in MicroAlgos,
	// have been distributed to each config.Protocol.RewardUnit
	// of MicroAlgos since genesis.
	RewardsLevel uint64 `codec:"earn"`

	// The number of new MicroAlgos added to the participation stake from rewards at the next round.
	RewardsRate uint64 `codec:"rate"`

	// The number of leftover MicroAlgos after the distribution of RewardsRate/rewardUnits
	// MicroAlgos for every reward unit in the next round.
	RewardsResidue uint64 `codec:"frac"`

	// The round at which the RewardsRate will be recalculated.
	RewardsRecalculationRound Round `codec:"rwcalr"`
	// contains filtered or unexported fields
}

type Round uint64

type Seed [32]byte

type Signature [ed25519.SignatureSize]byte

type SignedBid struct {

	// Bid contains information about the bid.
	Bid Bid `codec:"bid"`

	// Sig is a signature by the bidder, as identified in the bid
	// (Bid.BidderKey) over the hash of the Bid.
	Sig Signature `codec:"sig"`
	// contains filtered or unexported fields
}

type SignedTxn struct {
	Sig      Signature   `codec:"sig"`
	Msig     MultisigSig `codec:"msig"`
	Lsig     LogicSig    `codec:"lsig"`
	Txn      Transaction `codec:"txn"`
	AuthAddr Address     `codec:"sgnr"`
	// contains filtered or unexported fields
}

type SignedTxnInBlock struct {
	SignedTxnWithAD

	HasGenesisID   bool `codec:"hgi"`
	HasGenesisHash bool `codec:"hgh"`
	// contains filtered or unexported fields
}

type SignedTxnWithAD struct {
	SignedTxn
	ApplyData
	// contains filtered or unexported fields
}

type SingleLeafProof struct {
	Proof
	// contains filtered or unexported fields
}

type StateDelta map[string]ValueDelta

type StateProof struct {
	SigCommit                  GenericDigest `codec:"c"`
	SignedWeight               uint64        `codec:"w"`
	SigProofs                  Proof         `codec:"S"`
	PartProofs                 Proof         `codec:"P"`
	MerkleSignatureSaltVersion byte          `codec:"v"`
	// Reveals is a sparse map from the position being revealed
	// to the corresponding elements from the sigs and participants
	// arrays.
	Reveals           map[uint64]Reveal `codec:"r,allocbound=MaxReveals"`
	PositionsToReveal []uint64          `codec:"pr,allocbound=MaxReveals"`
	// contains filtered or unexported fields
}

type StateProofTrackingData struct {

	// StateProofVotersCommitment is the root of a vector commitment containing the
	// online accounts that will help sign a state proof.  The
	// VC root, and the state proof, happen on blocks that
	// are a multiple of ConsensusParams.StateProofRounds.  For blocks
	// that are not a multiple of ConsensusParams.StateProofRounds,
	// this value is zero.
	StateProofVotersCommitment GenericDigest `codec:"v"`

	// StateProofOnlineTotalWeight is the total number of microalgos held by the online accounts
	// during the StateProof round (or zero, if the merkle root is zero - no commitment for StateProof voters).
	// This is intended for computing the threshold of votes to expect from StateProofVotersCommitment.
	StateProofOnlineTotalWeight MicroAlgos `codec:"t"`

	// StateProofNextRound is the next round for which we will accept
	// a StateProof transaction.
	StateProofNextRound Round `codec:"n"`
	// contains filtered or unexported fields
}

type StateProofTxnFields struct {
	StateProofType StateProofType `codec:"sptype"`
	StateProof     StateProof     `codec:"sp"`
	Message        Message        `codec:"spmsg"`
	// contains filtered or unexported fields
}

type StateProofType uint64

type StateSchema struct {
	NumUint      uint64 `codec:"nui"`
	NumByteSlice uint64 `codec:"nbs"`
	// contains filtered or unexported fields
}

type StateSchemas struct {
	LocalStateSchema  StateSchema `codec:"lsch"`
	GlobalStateSchema StateSchema `codec:"gsch"`
	// contains filtered or unexported fields
}

type Status byte

type SuggestedParams struct {
	// Fee is the suggested transaction fee
	// Fee is in units of micro-Algos per byte.
	// Fee may fall to zero but a group of N atomic transactions must
	// still have a fee of at least N*MinTxnFee for the current network protocol.
	Fee MicroAlgos `codec:"fee"`

	// Genesis ID
	GenesisID string `codec:"genesis-id"`

	// Genesis hash
	GenesisHash []byte `codec:"genesis-hash"`

	// FirstRoundValid is the first protocol round on which the txn is valid
	FirstRoundValid Round `codec:"first-round"`

	// LastRoundValid is the final protocol round on which the txn may be committed
	LastRoundValid Round `codec:"last-round"`

	// ConsensusVersion indicates the consensus protocol version
	// as of LastRound.
	ConsensusVersion string `codec:"consensus-version"`

	// FlatFee indicates whether the passed fee is per-byte or per-transaction
	// If true, txn fee may fall below the MinTxnFee for the current network protocol.
	FlatFee bool `codec:"flat-fee"`

	// The minimum transaction fee (not per byte) required for the
	// txn to validate for the current network protocol.
	MinFee uint64 `codec:"min-fee"`
}

type TealKeyValue map[string]TealValue

type TealType uint64

type TealValue struct {
	Type  TealType `codec:"tt"`
	Bytes string   `codec:"tb"`
	Uint  uint64   `codec:"ui"`
	// contains filtered or unexported fields
}

type Transaction struct {

	// Type of transaction
	Type TxType `codec:"type"`

	// Common fields for all types of transactions
	Header

	// Fields for different types of transactions
	KeyregTxnFields
	PaymentTxnFields
	AssetConfigTxnFields
	AssetTransferTxnFields
	AssetFreezeTxnFields
	ApplicationFields
	StateProofTxnFields
	// contains filtered or unexported fields
}

type TxGroup struct {

	// TxGroupHashes specifies a list of hashes of transactions that must appear
	// together, sequentially, in a block in order for the group to be
	// valid.  Each hash in the list is a hash of a transaction with
	// the `Group` field omitted.
	TxGroupHashes []Digest `codec:"txlist"`
	// contains filtered or unexported fields
}

type TxType string

type Txid Digest

type Txlease struct {
	Sender Address
	Lease  [32]byte
}

type TxnCommitments struct {

	// Root of transaction merkle tree using SHA512_256 hash function.
	// This commitment is computed based on the PaysetCommit type specified in the block's consensus protocol.
	NativeSha512_256Commitment Digest `codec:"txn"`

	// Root of transaction vector commitment merkle tree using SHA256 hash function
	Sha256Commitment Digest `codec:"txn256"`
	// contains filtered or unexported fields
}

type UpgradeState struct {
	CurrentProtocol        string `codec:"proto"`
	NextProtocol           string `codec:"nextproto"`
	NextProtocolApprovals  uint64 `codec:"nextyes"`
	NextProtocolVoteBefore Round  `codec:"nextbefore"`
	NextProtocolSwitchOn   Round  `codec:"nextswitch"`
}

type UpgradeVote struct {

	// UpgradePropose indicates a proposed upgrade
	UpgradePropose string `codec:"upgradeprop"`

	// UpgradeDelay indicates the time between acceptance and execution
	UpgradeDelay Round `codec:"upgradedelay"`

	// UpgradeApprove indicates a yes vote for the current proposal
	UpgradeApprove bool `codec:"upgradeyes"`
	// contains filtered or unexported fields
}

type VRFPK [ed25519.PublicKeySize]byte

type VRFVerifier [32]byte

type ValueDelta struct {
	Action DeltaAction `codec:"at"`
	Bytes  string      `codec:"bs"`
	Uint   uint64      `codec:"ui"`
	// contains filtered or unexported fields
}

type Verifier struct {
	Commitment  Commitment `codec:"cmt"`
	KeyLifetime uint64     `codec:"lf"`
	// contains filtered or unexported fields
}

type VotePK [ed25519.PublicKeySize]byte

type VotingData struct {
	VoteID       OneTimeSignatureVerifier
	SelectionID  VRFVerifier
	StateProofID Commitment

	VoteFirstValid  Round
	VoteLastValid   Round
	VoteKeyDilution uint64
}