chain

package
v1.2.1 Latest Latest
Warning

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

 Go to latest Published: Aug 4, 2023 License: MIT Imports: 20 Imported by: 0

README

Chain Validator Design

Chain validators are organized by transaction type. The executor handles mundane tasks that are common to all chain validators, such as authentication and authorization.

In general, every transaction requires an origin record. Thus, the executor validates and loads the origin before delegating to the chain validator. However, certain transaction types, specifically synthetic transactions that create records, may not need an extant origin. The executor has a specific clause for these special cases.

Chain Validator Implementation

Chain validators must satisfy the TxExecutor interface:

type TxExecutor interface {
	Type() protocol.TransactionType
	Validate(*StateManager, *messaging.Envelope) error
}

All state manipulation (mutating and loading) must go through the state manager. There are three methods that can be used to modify records and/or create synthetic transactions:

  • Implementing a user transaction executor
    • Update(record) - Update one or more existing records. Cannot be used to create records.
    • Create(record) - Create one or more new records. Produces a synthetic chain create transaction.
    • Submit(url, body) - Submit a synthetic transaction.
  • Implementing a synthetic transaction executor
    • Update(record) - Create or update one or more existing records.
    • Create(record) - Cannot be used by synthetic transactions.
    • Submit(url, body) - Cannot be used by synthetic transactions.

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AcmeFaucet 

type AcmeFaucet struct{}

func (AcmeFaucet) Execute 

func (AcmeFaucet) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (AcmeFaucet) Type 

func (AcmeFaucet) Type() protocol.TransactionType

func (AcmeFaucet) Validate 

func (AcmeFaucet) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type ActivateProtocolVersion 

type ActivateProtocolVersion struct{}

func (ActivateProtocolVersion) Execute 

func (ActivateProtocolVersion) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (ActivateProtocolVersion) Type 

func (ActivateProtocolVersion) Type() protocol.TransactionType

func (ActivateProtocolVersion) Validate 

func (ActivateProtocolVersion) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type AddCredits 

type AddCredits struct{}

func (AddCredits) Execute 

func (AddCredits) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (AddCredits) Type 

func (AddCredits) Type() protocol.TransactionType

func (AddCredits) Validate 

func (AddCredits) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type AuthDelegate 

type AuthDelegate interface {
	GetAccountAuthoritySet(*database.Batch, protocol.Account) (*protocol.AccountAuth, error)
	SignerIsAuthorized(batch *database.Batch, transaction *protocol.Transaction, signer protocol.Signer, checkAuthz bool) error
	AuthorityIsSatisfied(batch *database.Batch, transaction *protocol.Transaction, status *protocol.TransactionStatus, authUrl *url.URL) (bool, error)
	SignerIsSatisfied(batch *database.Batch, transaction *protocol.Transaction, status *protocol.TransactionStatus, signer protocol.Signer) (bool, error)
}

type BurnTokens 

type BurnTokens struct{}

func (BurnTokens) Execute 

func (BurnTokens) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (BurnTokens) Type 

func (BurnTokens) Type() protocol.TransactionType

func (BurnTokens) Validate 

func (BurnTokens) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type ChainUpdates 

type ChainUpdates struct {
	Entries      []*protocol.BlockEntry
	SynthEntries []*database.BlockStateSynthTxnEntry
}

func (*ChainUpdates) AddChainEntry 

func (u *ChainUpdates) AddChainEntry(batch *database.Batch, chain *database.Chain2, entry []byte, sourceIndex, sourceBlock uint64) error

AddChainEntry adds an entry to a chain and records the chain update in the block state.

func (*ChainUpdates) AddChainEntry2 

func (u *ChainUpdates) AddChainEntry2(batch *database.Batch, chain *database.Chain2, entry []byte, sourceIndex, sourceBlock uint64, unique bool) (int64, error)

func (*ChainUpdates) DidAddChainEntry 

func (c *ChainUpdates) DidAddChainEntry(batch *database.Batch, u *url.URL, name string, typ protocol.ChainType, entry []byte, index, sourceIndex, sourceBlock uint64) error

DidAddChainEntry records a chain update in the block state.

func (*ChainUpdates) DidUpdateChain 

func (c *ChainUpdates) DidUpdateChain(update *protocol.BlockEntry)

DidUpdateChain records a chain update.

func (*ChainUpdates) Merge 

func (c *ChainUpdates) Merge(d *ChainUpdates)

type CreateDataAccount 

type CreateDataAccount struct{}

func (CreateDataAccount) Execute 

func (CreateDataAccount) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (CreateDataAccount) SignerIsAuthorized 

func (CreateDataAccount) SignerIsAuthorized(delegate AuthDelegate, batch *database.Batch, transaction *protocol.Transaction, signer protocol.Signer, md SignatureValidationMetadata) (fallback bool, err error)

func (CreateDataAccount) TransactionIsReady 

func (CreateDataAccount) TransactionIsReady(delegate AuthDelegate, batch *database.Batch, transaction *protocol.Transaction, status *protocol.TransactionStatus) (ready, fallback bool, err error)

func (CreateDataAccount) Type 

func (CreateDataAccount) Type() protocol.TransactionType

func (CreateDataAccount) Validate 

func (CreateDataAccount) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type CreateIdentity 

type CreateIdentity struct{}

func (CreateIdentity) AllowMissingPrincipal 

func (CreateIdentity) AllowMissingPrincipal(transaction *protocol.Transaction) bool

func (CreateIdentity) Execute 

func (CreateIdentity) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (CreateIdentity) SignerIsAuthorized 

func (CreateIdentity) SignerIsAuthorized(delegate AuthDelegate, batch *database.Batch, transaction *protocol.Transaction, signer protocol.Signer, md SignatureValidationMetadata) (fallback bool, err error)

func (CreateIdentity) TransactionIsReady 

func (CreateIdentity) TransactionIsReady(delegate AuthDelegate, batch *database.Batch, transaction *protocol.Transaction, status *protocol.TransactionStatus) (ready, fallback bool, err error)

func (CreateIdentity) Type 

func (CreateIdentity) Type() protocol.TransactionType

func (CreateIdentity) Validate 

func (CreateIdentity) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type CreateKeyBook 

type CreateKeyBook struct{}

func (CreateKeyBook) Execute 

func (CreateKeyBook) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (CreateKeyBook) SignerIsAuthorized 

func (CreateKeyBook) SignerIsAuthorized(delegate AuthDelegate, batch *database.Batch, transaction *protocol.Transaction, signer protocol.Signer, md SignatureValidationMetadata) (fallback bool, err error)

func (CreateKeyBook) TransactionIsReady 

func (CreateKeyBook) TransactionIsReady(delegate AuthDelegate, batch *database.Batch, transaction *protocol.Transaction, status *protocol.TransactionStatus) (ready, fallback bool, err error)

func (CreateKeyBook) Type 

func (CreateKeyBook) Type() protocol.TransactionType

func (CreateKeyBook) Validate 

func (CreateKeyBook) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type CreateKeyPage 

type CreateKeyPage struct{}

func (CreateKeyPage) Execute 

func (CreateKeyPage) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (CreateKeyPage) Type 

func (CreateKeyPage) Type() protocol.TransactionType

func (CreateKeyPage) Validate 

func (CreateKeyPage) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type CreateLiteTokenAccount 

type CreateLiteTokenAccount struct{}

func (CreateLiteTokenAccount) AllowMissingPrincipal 

func (CreateLiteTokenAccount) AllowMissingPrincipal(transaction *protocol.Transaction) bool

func (CreateLiteTokenAccount) Execute 

func (CreateLiteTokenAccount) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (CreateLiteTokenAccount) SignerIsAuthorized 

func (CreateLiteTokenAccount) SignerIsAuthorized(delegate AuthDelegate, batch *database.Batch, transaction *protocol.Transaction, signer protocol.Signer, md SignatureValidationMetadata) (fallback bool, err error)

func (CreateLiteTokenAccount) TransactionIsReady 

func (CreateLiteTokenAccount) TransactionIsReady(delegate AuthDelegate, batch *database.Batch, transaction *protocol.Transaction, status *protocol.TransactionStatus) (ready, fallback bool, err error)

func (CreateLiteTokenAccount) Type 

func (CreateLiteTokenAccount) Type() protocol.TransactionType

func (CreateLiteTokenAccount) Validate 

func (CreateLiteTokenAccount) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type CreateToken 

type CreateToken struct{}

func (CreateToken) Execute 

func (CreateToken) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (CreateToken) SignerIsAuthorized 

func (CreateToken) SignerIsAuthorized(delegate AuthDelegate, batch *database.Batch, transaction *protocol.Transaction, signer protocol.Signer, md SignatureValidationMetadata) (fallback bool, err error)

func (CreateToken) TransactionIsReady 

func (CreateToken) TransactionIsReady(delegate AuthDelegate, batch *database.Batch, transaction *protocol.Transaction, status *protocol.TransactionStatus) (ready, fallback bool, err error)

func (CreateToken) Type 

func (CreateToken) Type() protocol.TransactionType

func (CreateToken) Validate 

func (CreateToken) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type CreateTokenAccount 

type CreateTokenAccount struct{}

func (CreateTokenAccount) Execute 

func (CreateTokenAccount) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (CreateTokenAccount) SignerIsAuthorized 

func (CreateTokenAccount) SignerIsAuthorized(delegate AuthDelegate, batch *database.Batch, transaction *protocol.Transaction, signer protocol.Signer, md SignatureValidationMetadata) (fallback bool, err error)

func (CreateTokenAccount) TransactionIsReady 

func (CreateTokenAccount) TransactionIsReady(delegate AuthDelegate, batch *database.Batch, transaction *protocol.Transaction, status *protocol.TransactionStatus) (ready, fallback bool, err error)

func (CreateTokenAccount) Type 

func (CreateTokenAccount) Type() protocol.TransactionType

func (CreateTokenAccount) Validate 

func (CreateTokenAccount) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type Delivery 

type Delivery struct {
	Signatures  []protocol.Signature
	Transaction *protocol.Transaction
	State       ProcessTransactionState

	// For synthetic transactions
	SequenceNumber     uint64
	SourceNetwork      *url.URL
	DestinationNetwork *url.URL
	// contains filtered or unexported fields
}

func DeliveriesFromMessages 

func DeliveriesFromMessages(messages []messaging.Message) ([]*Delivery, error)

DeliveriesFromMessages converts a set of messages into a set of deliveries.

func NormalizeEnvelope 

func NormalizeEnvelope(envelope *messaging.Envelope) ([]*Delivery, error)

NormalizeEnvelope normalizes the envelope into one or more deliveries.

func (*Delivery) IsForwarded 

func (d *Delivery) IsForwarded() bool

IsForwarded returns true if the transaction was delivered within a SyntheticForwardedTransaction.

func (*Delivery) LoadSyntheticMetadata 

func (d *Delivery) LoadSyntheticMetadata(batch *database.Batch, typ protocol.TransactionType, status *protocol.TransactionStatus) error

func (*Delivery) LoadTransaction 

func (d *Delivery) LoadTransaction(batch *database.Batch) (*protocol.TransactionStatus, error)

LoadTransaction attempts to load the transaction from the database.

func (*Delivery) NewChild 

func (d *Delivery) NewChild(transaction *protocol.Transaction, signatures []protocol.Signature) *Delivery

func (*Delivery) NewForwarded 

func (d *Delivery) NewForwarded(fwd *protocol.SyntheticForwardTransaction) *Delivery

func (*Delivery) NewInternal 

func (d *Delivery) NewInternal(transaction *protocol.Transaction) *Delivery

func (*Delivery) NewSyntheticFromSequence 

func (d *Delivery) NewSyntheticFromSequence(hash [32]byte) *Delivery

func (*Delivery) NewSyntheticReceipt 

func (d *Delivery) NewSyntheticReceipt(hash [32]byte, source *url.URL, receipt *merkle.Receipt) *Delivery

func (*Delivery) Parent 

func (d *Delivery) Parent() *Delivery

func (*Delivery) WasProducedByPushedUpdate 

func (d *Delivery) WasProducedByPushedUpdate() bool

WasProducedByPushedUpdate returns true if the transaction was produced by an update pushed via an anchor from the directory network.

func (*Delivery) WasProducedInternally 

func (d *Delivery) WasProducedInternally() bool

type DirectoryAnchor 

type DirectoryAnchor struct{}

func (DirectoryAnchor) Execute 

func (DirectoryAnchor) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (DirectoryAnchor) Type 

func (DirectoryAnchor) Type() protocol.TransactionType

func (DirectoryAnchor) Validate 

func (DirectoryAnchor) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type IssueTokens 

type IssueTokens struct{}

func (IssueTokens) Execute 

func (IssueTokens) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (IssueTokens) Type 

func (IssueTokens) Type() protocol.TransactionType

func (IssueTokens) Validate 

func (IssueTokens) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type LockAccount 

type LockAccount struct{}

func (LockAccount) Execute 

func (LockAccount) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (LockAccount) Type 

func (LockAccount) Type() protocol.TransactionType

func (LockAccount) Validate 

func (LockAccount) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type PartitionAnchor 

type PartitionAnchor struct{}

func (PartitionAnchor) Execute 

func (PartitionAnchor) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (PartitionAnchor) Type 

func (PartitionAnchor) Type() protocol.TransactionType

func (PartitionAnchor) Validate 

func (PartitionAnchor) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type PrincipalValidator 

type PrincipalValidator interface {
	TransactionExecutor

	AllowMissingPrincipal(*protocol.Transaction) bool
}

PrincipalValidator validates the principal for a specific type of transaction.

type ProcessTransactionState 

type ProcessTransactionState struct {
	ProducedTxns           []*protocol.Transaction
	AdditionalTransactions []*Delivery
	ChainUpdates           ChainUpdates
	MakeMajorBlock         uint64
	MakeMajorBlockTime     time.Time
	ReceivedAnchors        []*ReceivedAnchor
}

func (*ProcessTransactionState) DidProduceTxn 

func (s *ProcessTransactionState) DidProduceTxn(url *url.URL, body protocol.TransactionBody)

DidProduceTxn records a produced transaction.

func (*ProcessTransactionState) DidReceiveAnchor 

func (s *ProcessTransactionState) DidReceiveAnchor(partition string, body protocol.AnchorBody, index int64)

func (*ProcessTransactionState) Merge 

func (s *ProcessTransactionState) Merge(r *ProcessTransactionState)

func (*ProcessTransactionState) ProcessAdditionalTransaction 

func (s *ProcessTransactionState) ProcessAdditionalTransaction(txn *Delivery)

type ReceivedAnchor 

type ReceivedAnchor struct {
	Partition string
	Body      protocol.AnchorBody
	Index     int64
}

type SendTokens 

type SendTokens struct{}

func (SendTokens) Execute 

func (SendTokens) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (SendTokens) Type 

func (SendTokens) Type() protocol.TransactionType

func (SendTokens) Validate 

func (SendTokens) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type SignatureValidationMetadata 

type SignatureValidationMetadata struct {
	Location    *url.URL
	IsInitiator bool
	Delegated   bool
	Forwarded   bool
}

func (SignatureValidationMetadata) Nested 

func (d SignatureValidationMetadata) Nested() bool

func (SignatureValidationMetadata) SetDelegated 

func (d SignatureValidationMetadata) SetDelegated() SignatureValidationMetadata

func (SignatureValidationMetadata) SetForwarded 

func (d SignatureValidationMetadata) SetForwarded() SignatureValidationMetadata

type SignerValidator 

type SignerValidator interface {
	TransactionExecutor

	// SignerIsAuthorized checks if the signature is authorized for the
	// transaction.
	SignerIsAuthorized(delegate AuthDelegate, batch *database.Batch, transaction *protocol.Transaction, signer protocol.Signer, md SignatureValidationMetadata) (fallback bool, err error)

	// TransactionIsReady checks if the transaction is ready to be executed.
	TransactionIsReady(delegate AuthDelegate, batch *database.Batch, transaction *protocol.Transaction, status *protocol.TransactionStatus) (ready, fallback bool, err error)
}

SignerValidator validates signatures for a specific type of transaction.

type StateManager 

type StateManager struct {
	Origin    protocol.Account
	OriginUrl *url.URL
	// contains filtered or unexported fields
}

func LoadStateManager 

func LoadStateManager(net *config.Describe, globals *core.GlobalValues, batch *database.Batch, principal protocol.Account, transaction *protocol.Transaction, status *protocol.TransactionStatus, logger log.Logger) (*StateManager, error)

func NewStateManager 

func NewStateManager(net *config.Describe, globals *core.GlobalValues, batch *database.Batch, principal protocol.Account, transaction *protocol.Transaction, logger log.Logger) *StateManager

NewStateManager creates a new state manager and loads the transaction's origin. If the origin is not found, NewStateManager returns a valid state manager along with a not-found error.

func (*StateManager) AddAuthority 

func (m *StateManager) AddAuthority(account protocol.FullAccount, authority *url.URL) error

func (*StateManager) AddDirectoryEntry 

func (c *StateManager) AddDirectoryEntry(directory *url.URL, u ...*url.URL) error

func (*StateManager) Commit 

func (m *StateManager) Commit() (*ProcessTransactionState, error)

commit writes pending records to the database.

func (*StateManager) Create 

func (st *StateManager) Create(accounts ...protocol.Account) error

func (*StateManager) Discard 

func (m *StateManager) Discard()

func (*StateManager) GetBatch 

func (m *StateManager) GetBatch() *database.Batch

func (*StateManager) GetHash 

func (m *StateManager) GetHash() []byte

func (*StateManager) GetHeight 

func (c *StateManager) GetHeight(u *url.URL) (uint64, error)

GetHeight loads the height of the chain

func (*StateManager) InheritAuth 

func (m *StateManager) InheritAuth(account protocol.FullAccount) error

func (*StateManager) LoadTxn 

func (c *StateManager) LoadTxn(txid [32]byte) (*protocol.Transaction, error)

LoadTxn loads and unmarshals a saved transaction

func (*StateManager) LoadUrl 

func (c *StateManager) LoadUrl(account *url.URL) (protocol.Account, error)

LoadUrl loads a chain by URL and unmarshals it.

func (*StateManager) LoadUrlAs 

func (c *StateManager) LoadUrlAs(account *url.URL, target interface{}) error

LoadUrlAs loads a chain by URL and unmarshals it as a specific type.

func (*StateManager) SetAuth 

func (m *StateManager) SetAuth(account protocol.FullAccount, authorities []*url.URL) error

func (*StateManager) Submit 

func (m *StateManager) Submit(url *url.URL, body protocol.TransactionBody)

Submit queues a synthetic transaction for submission.

func (*StateManager) Update 

func (st *StateManager) Update(accounts ...protocol.Account) error

Update queues a record for storage in the database. The queued update will fail if the record does not already exist, unless it is created by a synthetic transaction, or the record is a transaction.

func (*StateManager) UpdateData 

func (m *StateManager) UpdateData(record protocol.Account, entryHash []byte, dataEntry protocol.DataEntry)

UpdateData will cache a data associated with a DataAccount chain. the cache data will not be stored directly in the state but can be used upstream for storing a chain in the state database.

type SyntheticBurnTokens 

type SyntheticBurnTokens struct{}

func (SyntheticBurnTokens) Execute 

func (SyntheticBurnTokens) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (SyntheticBurnTokens) Type 

func (SyntheticBurnTokens) Type() protocol.TransactionType

func (SyntheticBurnTokens) Validate 

func (SyntheticBurnTokens) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type SyntheticCreateIdentity 

type SyntheticCreateIdentity struct{}

func (SyntheticCreateIdentity) AllowMissingPrincipal 

func (SyntheticCreateIdentity) AllowMissingPrincipal(transaction *protocol.Transaction) bool

func (SyntheticCreateIdentity) Execute 

func (SyntheticCreateIdentity) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (SyntheticCreateIdentity) Type 

func (SyntheticCreateIdentity) Type() protocol.TransactionType

func (SyntheticCreateIdentity) Validate 

func (SyntheticCreateIdentity) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type SyntheticDepositCredits 

type SyntheticDepositCredits struct{}

func (SyntheticDepositCredits) AllowMissingPrincipal 

func (SyntheticDepositCredits) AllowMissingPrincipal(transaction *protocol.Transaction) bool

func (SyntheticDepositCredits) DidFail 

func (SyntheticDepositCredits) DidFail(state *ProcessTransactionState, transaction *protocol.Transaction) error

func (SyntheticDepositCredits) Execute 

func (SyntheticDepositCredits) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (SyntheticDepositCredits) Type 

func (SyntheticDepositCredits) Type() protocol.TransactionType

func (SyntheticDepositCredits) Validate 

func (SyntheticDepositCredits) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type SyntheticDepositTokens 

type SyntheticDepositTokens struct{}

func (SyntheticDepositTokens) AllowMissingPrincipal 

func (SyntheticDepositTokens) AllowMissingPrincipal(transaction *protocol.Transaction) bool

func (SyntheticDepositTokens) DidFail 

func (SyntheticDepositTokens) DidFail(state *ProcessTransactionState, transaction *protocol.Transaction) error

func (SyntheticDepositTokens) Execute 

func (SyntheticDepositTokens) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (SyntheticDepositTokens) Type 

func (SyntheticDepositTokens) Type() protocol.TransactionType

func (SyntheticDepositTokens) Validate 

func (SyntheticDepositTokens) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type SyntheticForwardTransaction 

type SyntheticForwardTransaction struct{}

func (SyntheticForwardTransaction) AllowMissingPrincipal 

func (SyntheticForwardTransaction) AllowMissingPrincipal(transaction *protocol.Transaction) bool

func (SyntheticForwardTransaction) Execute 

func (SyntheticForwardTransaction) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (SyntheticForwardTransaction) Type 

func (SyntheticForwardTransaction) Type() protocol.TransactionType

func (SyntheticForwardTransaction) Validate 

func (SyntheticForwardTransaction) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type SyntheticWriteData 

type SyntheticWriteData struct{}

func (SyntheticWriteData) AllowMissingPrincipal 

func (SyntheticWriteData) AllowMissingPrincipal(transaction *protocol.Transaction) bool

func (SyntheticWriteData) Execute 

func (SyntheticWriteData) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (SyntheticWriteData) Type 

func (SyntheticWriteData) Type() protocol.TransactionType

func (SyntheticWriteData) Validate 

func (SyntheticWriteData) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type SystemWriteData 

type SystemWriteData struct{}

func (SystemWriteData) Execute 

func (SystemWriteData) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (SystemWriteData) Type 

func (SystemWriteData) Type() protocol.TransactionType

func (SystemWriteData) Validate 

func (SystemWriteData) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type TransactionExecutor 

type TransactionExecutor interface {
	// Type is the transaction type the executor can execute.
	Type() protocol.TransactionType

	// Validate validates the transaction for acceptance.
	Validate(*StateManager, *Delivery) (protocol.TransactionResult, error)

	// Execute fully validates and executes the transaction.
	Execute(*StateManager, *Delivery) (protocol.TransactionResult, error)
}

TransactionExecutor executes a specific type of transaction.

type TransactionExecutorCleanup 

type TransactionExecutorCleanup interface {
	// DidFail is called if the transaction failed.
	DidFail(*ProcessTransactionState, *protocol.Transaction) error
}

TransactionExecutorCleanup cleans up after a failed transaction.

type UpdateAccountAuth 

type UpdateAccountAuth struct{}

func (UpdateAccountAuth) Execute 

func (UpdateAccountAuth) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (UpdateAccountAuth) SignerIsAuthorized 

func (UpdateAccountAuth) SignerIsAuthorized(delegate AuthDelegate, batch *database.Batch, transaction *protocol.Transaction, signer protocol.Signer, md SignatureValidationMetadata) (fallback bool, err error)

func (UpdateAccountAuth) TransactionIsReady 

func (UpdateAccountAuth) TransactionIsReady(delegate AuthDelegate, batch *database.Batch, transaction *protocol.Transaction, status *protocol.TransactionStatus) (ready, fallback bool, err error)

func (UpdateAccountAuth) Type 

func (UpdateAccountAuth) Type() protocol.TransactionType

func (UpdateAccountAuth) Validate 

func (UpdateAccountAuth) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type UpdateKey 

type UpdateKey struct{}

func (UpdateKey) Execute 

func (UpdateKey) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (UpdateKey) Type 

func (UpdateKey) Type() protocol.TransactionType

func (UpdateKey) Validate 

func (UpdateKey) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type UpdateKeyPage 

type UpdateKeyPage struct{}

func (UpdateKeyPage) Execute 

func (UpdateKeyPage) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (UpdateKeyPage) SignerIsAuthorized 

func (UpdateKeyPage) SignerIsAuthorized(delegate AuthDelegate, batch *database.Batch, transaction *protocol.Transaction, signer protocol.Signer, md SignatureValidationMetadata) (fallback bool, err error)

func (UpdateKeyPage) TransactionIsReady 

func (UpdateKeyPage) TransactionIsReady(delegate AuthDelegate, batch *database.Batch, transaction *protocol.Transaction, status *protocol.TransactionStatus) (ready, fallback bool, err error)

func (UpdateKeyPage) Type 

func (UpdateKeyPage) Type() protocol.TransactionType

func (UpdateKeyPage) Validate 

func (UpdateKeyPage) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type WriteData 

type WriteData struct{}

func (WriteData) AllowMissingPrincipal 

func (WriteData) AllowMissingPrincipal(transaction *protocol.Transaction) bool

func (WriteData) Execute 

func (WriteData) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (WriteData) SignerIsAuthorized 

func (WriteData) SignerIsAuthorized(_ AuthDelegate, batch *database.Batch, transaction *protocol.Transaction, _ protocol.Signer, _ SignatureValidationMetadata) (fallback bool, err error)

SignerIsAuthorized returns nil if the transaction is writing to a lite data account.

func (WriteData) TransactionIsReady 

func (WriteData) TransactionIsReady(_ AuthDelegate, batch *database.Batch, transaction *protocol.Transaction, status *protocol.TransactionStatus) (ready, fallback bool, err error)

TransactionIsReady returns true if the transaction is writing to a lite data account.

func (WriteData) Type 

func (WriteData) Type() protocol.TransactionType

func (WriteData) Validate 

func (WriteData) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

type WriteDataTo 

type WriteDataTo struct{}

func (WriteDataTo) Execute 

func (WriteDataTo) Execute(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

func (WriteDataTo) Type 

func (WriteDataTo) Type() protocol.TransactionType

func (WriteDataTo) Validate 

func (WriteDataTo) Validate(st *StateManager, tx *Delivery) (protocol.TransactionResult, error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.