access

type AccountTransaction struct {
	Address          flow.Address      // Account address
	BlockHeight      uint64            // Block height where transaction was included
	BlockTimestamp   uint64            // Block timestamp where transaction was included, in Unix milliseconds
	TransactionID    flow.Identifier   // Transaction identifier
	TransactionIndex uint32            // Index of transaction within the block
	Roles            []TransactionRole // Roles of the account in the transaction

	// Expansion fields populated when expandResults is true.
	Transaction *flow.TransactionBody `msgpack:"-"` // Transaction body (nil unless expanded)
	Result      *TransactionResult    `msgpack:"-"` // Transaction result (nil unless expanded)
}

type AccountTransactionCursor struct {
	Address          flow.Address // Account address
	BlockHeight      uint64       // Block height of the last returned entry
	TransactionIndex uint32       // Transaction index within the block of the last returned entry
}

type AccountTransactionsPage struct {
	Transactions []AccountTransaction      // Transactions in this page (descending order by height)
	NextCursor   *AccountTransactionCursor // Cursor to fetch the next page, nil when no more results
}

type CompatibleRange struct {
	// StartHeight is the first block that the version supports.
	StartHeight uint64

	// EndHeight is the last block that the version supports.
	EndHeight uint64
}

type ContractDeployment struct {
	// Address is the account that owns the contract.
	Address flow.Address
	// ContractName is the unqualified contract name, derived from ContractID.
	ContractName string
	// BlockHeight is the block height at which this deployment was applied.
	BlockHeight uint64
	// TransactionID is the ID of the transaction that applied this deployment.
	TransactionID flow.Identifier
	// TransactionIndex is the position of the deploying transaction within its block.
	TransactionIndex uint32
	// EventIndex is the position of the contract event within its transaction.
	// Needed to uniquely identify a deployment when a single transaction deploys multiple contracts.
	EventIndex uint32
	// Code is the Cadence source code of the contract at the time of deployment.
	// May be nil if code could not be extracted from the transaction body.
	Code []byte
	// CodeHash is the SHA3-256 hash of the contract code, as reported in the protocol event.
	CodeHash []byte

	// IsDeleted is true if the contract was deleted.
	// Deleting contracts is not currently supported by the protocol, however there are contracts on
	// mainnet that are deleted.
	IsDeleted bool

	// IsPlaceholder is true if the deployment was created during bootstrapping based on the current
	// chain state, and not based on a protocol event.
	// When true, the BlockHeight, TransactionID, TxIndex, and EventIndex fields are undefined.
	IsPlaceholder bool

	// Expansion fields populated when expandResults is true. Never persisted.
	Transaction *flow.TransactionBody `msgpack:"-"` // Transaction body (nil unless expanded)
	Result      *TransactionResult    `msgpack:"-"` // Transaction result (nil unless expanded)
}

type ContractDeploymentPage struct {
	// Deployments is the ordered list of deployments for this page.
	Deployments []ContractDeployment
	// NextCursor is nil when no more results exist.
	NextCursor *ContractDeploymentsCursor
}

type ContractDeploymentsCursor struct {
	// Address is the account that owns the contract.
	Address flow.Address
	// ContractName is the unqualified contract name.
	ContractName string
	// BlockHeight is the block height of the last returned deployment.
	BlockHeight uint64
	// TransactionIndex is the position of the deploying transaction within its block.
	TransactionIndex uint32
	// EventIndex is the position of the contract event within its transaction.
	EventIndex uint32
}

type EventProvider func() (flow.EventsList, error)

type FungibleTokenTransfer struct {
	TransactionID    flow.Identifier // Transaction that produced the transfer event
	BlockHeight      uint64          // Block height where the transaction was included
	BlockTimestamp   uint64          // Block timestamp where the transaction was included
	TransactionIndex uint32          // Index of the transaction within the block
	EventIndices     []uint32        // Index of the event within the transaction
	TokenType        string          // Fully qualified token type identifier (e.g., "A.0x1654653399040a61.FlowToken")
	Amount           *big.Int        // Amount of tokens transferred
	SourceAddress    flow.Address    // Account that sent the tokens
	RecipientAddress flow.Address    // Account that received the tokens

	// Expansion fields populated when expandResults is true.
	Transaction *flow.TransactionBody `msgpack:"-"` // Transaction body (nil unless expanded)
	Result      *TransactionResult    `msgpack:"-"` // Transaction result (nil unless expanded)
}

type FungibleTokenTransfersPage struct {
	Transfers  []FungibleTokenTransfer // Transfers in this page (descending order by height)
	NextCursor *TransferCursor         // Cursor to fetch the next page, nil when no more results
}

type HeightVersionMapper interface {
	// GetVersion returns the version corresponding to the given height.
	GetVersion(height uint64) Version

	// All versions defined in the mapper.
	AllVersions() []Version
}

type NetworkParameters struct {
	ChainID flow.ChainID
}

type NodeVersionInfo struct {
	Semver  string
	Commit  string
	SporkId flow.Identifier
	// ProtocolVersion is the deprecated protocol version number.
	// Deprecated: Previously this referred to the major software version as of the most recent spork.
	// Replaced by protocol_state_version.
	ProtocolVersion uint64
	// ProtocolStateVersion is the Protocol State version as of the latest finalized block.
	// This tracks the schema version of the Protocol State and is used to coordinate breaking changes in the Protocol.
	// Version numbers are monotonically increasing.
	ProtocolStateVersion uint64
	SporkRootBlockHeight uint64
	NodeRootBlockHeight  uint64
	CompatibleRange      *CompatibleRange
}

type NonFungibleTokenTransfer struct {
	TransactionID    flow.Identifier // Transaction that produced the transfer event
	BlockHeight      uint64          // Block height where the transaction was included
	BlockTimestamp   uint64          // Block timestamp where the transaction was included
	TransactionIndex uint32          // Index of the transaction within the block
	EventIndices     []uint32        // Index of the event within the transaction
	TokenType        string          // Fully qualified type of NFT collection (e.g., "A.0x1654653399040a61.MyNFT")
	ID               uint64          // Unique identifier of the NFT within its collection
	SourceAddress    flow.Address    // Account that sent the token
	RecipientAddress flow.Address    // Account that received the token

	// Expansion fields populated when expandResults is true.
	Transaction *flow.TransactionBody `msgpack:"-"` // Transaction body (nil unless expanded)
	Result      *TransactionResult    `msgpack:"-"` // Transaction result (nil unless expanded)
}

type NonFungibleTokenTransfersPage struct {
	Transfers  []NonFungibleTokenTransfer // Transfers in this page (descending order by height)
	NextCursor *TransferCursor            // Cursor to fetch the next page, nil when no more results
}

type ScheduledTransaction struct {
	ID              uint64
	Priority        ScheduledTransactionPriority
	Timestamp       uint64 // stored by the contract as a UFix64 with the fractional zeroed out
	ExecutionEffort uint64
	Fees            uint64

	TransactionHandlerOwner          flow.Address
	TransactionHandlerTypeIdentifier string
	TransactionHandlerUUID           uint64
	TransactionHandlerPublicPath     string

	Status ScheduledTransactionStatus

	// CreatedTransactionID is the transaction ID of the transaction in which the scheduled transaction was created
	// It is always set unless the scheduled transaction is a placeholder, in which case IsPlaceholder is true.
	CreatedTransactionID flow.Identifier

	// ExecutedTransactionID is the transaction ID of the transaction in which the scheduled transaction was executed
	// If set, status is set to [ScheduledTxStatusExecuted].
	ExecutedTransactionID flow.Identifier

	// CancelledTransactionID is the transaction ID of the transaction in which the scheduled transaction was cancelled
	// If set, status is set to [ScheduledTxStatusCancelled].
	CancelledTransactionID flow.Identifier

	// FeesReturned is the amount of fees returned to the scheduled transaction's owner when the scheduled transaction was cancelled
	FeesReturned uint64

	// FeesDeducted is the amount of fees deducted from the scheduled transaction's owner when the scheduled transaction was cancelled
	FeesDeducted uint64

	// IsPlaceholder is true if the scheduled transaction was created based on the current chain state,
	// and not based on a protocol event. This happens when the index is bootstrapped after the original
	// transaction where the scheduled transaction was first created.
	// When true, the `CreatedTransactionID`, `TransactionHandlerUUID`, and `TransactionHandlerPublicPath`
	// fields are undefined.
	IsPlaceholder bool

	// Expansion fields populated when expandResults is true. Never persisted.
	Transaction     *flow.TransactionBody `msgpack:"-"` // Transaction body (nil unless expanded)
	Result          *TransactionResult    `msgpack:"-"` // Transaction result (nil unless expanded)
	HandlerContract *ContractDeployment   `msgpack:"-"` // Handler contract (nil unless expanded)

	// Timestamp fields are populated by the backend. Never persisted. Zero when not applicable.
	CreatedAt   uint64 `msgpack:"-"` // Unix ms timestamp of block in which the scheduled transaction was created
	CompletedAt uint64 `msgpack:"-"` // Unix ms timestamp of block in which the scheduled transaction was executed or cancelled
}

type ScheduledTransactionCursor struct {
	ID uint64 // Scheduled transaction ID of the last returned entry
}

type ScheduledTransactionPriority uint8

type ScheduledTransactionStatus int8

type ScheduledTransactionsPage struct {
	Transactions []ScheduledTransaction      // Results in this page (descending order by ID)
	NextCursor   *ScheduledTransactionCursor // Cursor to fetch the next page, nil when no more results
}

type StaticHeightVersionMapper struct {
	// contains filtered or unexported fields
}

type SystemCollectionBuilder interface {
	// ProcessCallbacksTransaction constructs a transaction for processing callbacks, for the given callback.
	//
	// No error returns are expected during normal operation.
	ProcessCallbacksTransaction(chain flow.Chain) (*flow.TransactionBody, error)

	// ExecuteCallbacksTransactions constructs a list of transaction to execute callbacks, for the given chain.
	//
	// No error returns are expected during normal operation.
	ExecuteCallbacksTransactions(chain flow.Chain, processEvents flow.EventsList) ([]*flow.TransactionBody, error)

	// ExecuteCallbacksTransaction constructs a transaction to execute a callback, for the given chain.
	//
	// No error returns are expected during normal operation.
	ExecuteCallbacksTransaction(chain flow.Chain, id uint64, effort uint64) (*flow.TransactionBody, error)

	// SystemChunkTransaction creates and returns the transaction corresponding to the
	// system chunk for the given chain.
	//
	// No error returns are expected during normal operation.
	SystemChunkTransaction(chain flow.Chain) (*flow.TransactionBody, error)

	// SystemCollection constructs a system collection for the given chain.
	// Uses the provided event provider to get events required to construct the system collection.
	// A nil event provider behaves the same as an event provider that returns an empty EventsList.
	//
	// No error returns are expected during normal operation.
	SystemCollection(chain flow.Chain, providerFn EventProvider) (*flow.Collection, error)
}

type TransactionResult struct {
	Status          flow.TransactionStatus
	StatusCode      uint
	Events          []flow.Event
	ErrorMessage    string
	BlockID         flow.Identifier
	TransactionID   flow.Identifier
	CollectionID    flow.Identifier
	BlockHeight     uint64
	ComputationUsed uint64
}

type TransactionRole int

type TransferCursor struct {
	Address          flow.Address // Account address
	BlockHeight      uint64       // Block height of the last returned entry
	TransactionIndex uint32       // Transaction index within the block of the last returned entry
	EventIndex       uint32       // Event index within the transaction of the last returned entry
}

type Version uint8

type Versioned[T any] struct {
	// contains filtered or unexported fields
}