validator

type Blocks ¶

type Blocks interface {
	HeaderByID(id flow.Identifier) (*flow.Header, error)
	FinalizedHeader() (*flow.Header, error)
	SealedHeader() (*flow.Header, error)
	IndexedHeight() (uint64, error)
}

type DuplicatedSignatureError ¶

type DuplicatedSignatureError struct {
	Address  flow.Address
	KeyIndex uint32
}

DuplicatedSignatureError indicates that two signatures havs been provided for a key (combination of account and key index)

func (e DuplicatedSignatureError) Error() string

type ExpiredTransactionError ¶

type ExpiredTransactionError struct {
	RefHeight, FinalHeight uint64
}

ExpiredTransactionError indicates that a transaction has expired.

func (e ExpiredTransactionError) Error() string

type IncompleteTransactionError ¶

type IncompleteTransactionError struct {
	MissingFields []string
}

IncompleteTransactionError indicates that a transaction is missing one or more required fields.

func (e IncompleteTransactionError) Error() string

type IndexedHeightFarBehindError ¶

type IndexedHeightFarBehindError struct {
	SealedHeight  uint64
	IndexedHeight uint64
}

IndexedHeightFarBehindError indicates that a node is far behind on indexing.

func (e IndexedHeightFarBehindError) Error() string

type InsufficientBalanceError ¶

type InsufficientBalanceError struct {
	Payer           flow.Address
	RequiredBalance cadence.UFix64
}

func (e InsufficientBalanceError) Error() string

type InvalidAddressError ¶

type InvalidAddressError struct {
	Address flow.Address
}

InvalidAddressError indicates that a transaction references an invalid flow Address in either the Authorizers or Payer field.

func (e InvalidAddressError) Error() string

type InvalidGasLimitError ¶

type InvalidGasLimitError struct {
	Maximum uint64
	Actual  uint64
}

InvalidGasLimitError indicates that a transaction specifies a gas limit that exceeds the maximum.

func (e InvalidGasLimitError) Error() string

type InvalidScriptError ¶

type InvalidScriptError struct {
	ParserErr error
}

InvalidScriptError indicates that a transaction contains an invalid Cadence script.

func (e InvalidScriptError) Error() string

func (e InvalidScriptError) Unwrap() error

type InvalidSignatureError ¶

type InvalidSignatureError struct {
	Signature flow.TransactionSignature
}

InvalidSignatureError indicates that a transaction contains a signature with a wrong format.

func (e InvalidSignatureError) Error() string

type InvalidTxByteSizeError ¶

type InvalidTxByteSizeError struct {
	Maximum uint64
	Actual  uint64
}

InvalidTxByteSizeError indicates that a transaction byte size exceeds the maximum.

func (e InvalidTxByteSizeError) Error() string

type InvalidTxRateLimitedError ¶

type InvalidTxRateLimitedError struct {
	Payer flow.Address
}

func (e InvalidTxRateLimitedError) Error() string

type PayerBalanceMode ¶

type PayerBalanceMode int

PayerBalanceMode represents the mode for checking the payer's balance when validating transactions. It controls whether and how the balance check is performed during transaction validation.

There are few modes available:

• `Disabled` - Balance checking is completely disabled. No checks are performed to verify if the payer has sufficient balance to cover the transaction fees.
• `WarnCheck` - Balance is checked, and a warning is logged if the payer does not have enough balance. The transaction is still accepted and processed regardless of the check result.
• `EnforceCheck` - Balance is checked, and the transaction is rejected if the payer does not have sufficient balance to cover the transaction fees.

const (
	// Disabled indicates that payer balance checking is turned off.
	Disabled PayerBalanceMode = iota

	// WarnCheck logs a warning if the payer's balance is insufficient, but does not prevent the transaction from being accepted.
	WarnCheck

	// EnforceCheck prevents the transaction from being accepted if the payer's balance is insufficient to cover transaction fees.
	EnforceCheck
)

func ParsePayerBalanceMode(s string) (PayerBalanceMode, error)

func (m PayerBalanceMode) String() string

type ProtocolStateBlocks ¶

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

func NewProtocolStateBlocks(state protocol.State, indexReporter state_synchronization.IndexReporter) *ProtocolStateBlocks

func (b *ProtocolStateBlocks) FinalizedHeader() (*flow.Header, error)

func (b *ProtocolStateBlocks) HeaderByID(id flow.Identifier) (*flow.Header, error)

func (b *ProtocolStateBlocks) IndexedHeight() (uint64, error)

func (b *ProtocolStateBlocks) SealedHeader() (*flow.Header, error)

type TransactionValidationOptions ¶

type TransactionValidationOptions struct {
	Expiry                       uint
	ExpiryBuffer                 uint
	AllowEmptyReferenceBlockID   bool
	AllowUnknownReferenceBlockID bool
	MaxGasLimit                  uint64
	CheckScriptsParse            bool
	MaxTransactionByteSize       uint64
	MaxCollectionByteSize        uint64
	CheckPayerBalanceMode        PayerBalanceMode
}

type TransactionValidator ¶

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

func NewTransactionValidator(
	blocks Blocks,
	chain flow.Chain,
	transactionValidationMetrics module.TransactionValidationMetrics,
	options TransactionValidationOptions,
	executor execution.ScriptExecutor,
) (*TransactionValidator, error)

func NewTransactionValidatorWithLimiter(
	blocks Blocks,
	chain flow.Chain,
	options TransactionValidationOptions,
	transactionValidationMetrics module.TransactionValidationMetrics,
	rateLimiter ratelimit.RateLimiter,
) *TransactionValidator

func (v *TransactionValidator) Validate(ctx context.Context, tx *flow.TransactionBody) (err error)

type ValidationStep ¶

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