io

type Change ¶

type Change struct {
	Type xdr.LedgerEntryType
	Pre  *xdr.LedgerEntry
	Post *xdr.LedgerEntry
}

Change is a developer friendly representation of LedgerEntryChanges. It also provides some helper functions to quickly check if a given change has occured in an entry.

If an entry is created: Pre is nil and Post is not nil. If an entry is updated: Pre is not nil and Post is not nil. If an entry is removed: Pre is not nil and Post is nil.

func (c *Change) AccountChangedExceptSigners() (bool, error)

func (c *Change) AccountSignersChanged() bool

func (c *Change) LedgerEntryChangeType() xdr.LedgerEntryChangeType

type ChangeProcessor ¶

type ChangeProcessor interface {
	ProcessChange(change Change) error
}

type ChangeReader ¶

type ChangeReader interface {
	// Read should return the next `Change` in the leader. If there are no more
	// changes left it should return an `io.EOF` error.
	Read() (Change, error)
	// Close should be called when reading is finished. This is especially
	// helpful when there are still some changes available so reader can stop
	// streaming them.
	Close() error
}

ChangeReader provides convenient, streaming access to a sequence of Changes

type DBLedgerReader ¶

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

DBLedgerReader is a database-backed implementation of the io.LedgerReader interface. Use NewDBLedgerReader to create a new instance.

func NewDBLedgerReader(
	ctx context.Context, sequence uint32, backend ledgerbackend.LedgerBackend,
) (*DBLedgerReader, error)

func (dblrc *DBLedgerReader) Close() error

func (dblrc *DBLedgerReader) GetHeader() xdr.LedgerHeaderHistoryEntry

func (dblrc *DBLedgerReader) GetSequence() uint32

func (dblrc *DBLedgerReader) Read() (LedgerTransaction, error)

type GenesisLedgerStateReader ¶

type GenesisLedgerStateReader struct {
	NetworkPassphrase string
	// contains filtered or unexported fields
}

GenesisLedgerStateReader is a streaming ledger entries for genesis ledger (ledgerseq = 1) for of the network with the given passphrase.

func (r *GenesisLedgerStateReader) Close() error

func (r *GenesisLedgerStateReader) Read() (Change, error)

type LedgerChangeReader ¶

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

LedgerChangeReader is a ChangeReader which returns Changes from Stellar Core for a single ledger

func NewLedgerChangeReader(
	ctx context.Context, sequence uint32, backend ledgerbackend.LedgerBackend,
) (*LedgerChangeReader, error)

func (r *LedgerChangeReader) Close() error

func (r *LedgerChangeReader) GetHeader() xdr.LedgerHeaderHistoryEntry

func (r *LedgerChangeReader) Read() (Change, error)

type LedgerEntryChangeCache ¶

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

LedgerEntryChangeCache is a cache of ledger entry changes that squashes all changes within a single ledger. By doing this, it decreases number of DB queries sent to a DB to update the current state of the ledger. It has integrity checks built in so ex. removing an account that was previously removed returns an error. In such case verify.StateError is returned.

It applies changes to the cache using the following algorithm:

1. If the change is CREATED it checks if any change connected to given entry is already in the cache. If not, it adds CREATED change. Otherwise, if existing change is: a. CREATED it returns error because we can't add an entry that already exists. b. UPDATED it returns error because we can't add an entry that already exists. c. REMOVED it means that due to previous transitions we want to remove this from a DB what means that it already exists in a DB so we need to update the type of change to UPDATED.
2. If the change is UPDATE it checks if any change connected to given entry is already in the cache. If not, it adds UPDATE change. Otherwise, if existing change is: a. CREATED it means that due to previous transitions we want to create this in a DB what means that it doesn't exist in a DB so we need to update the entry but stay with CREATED type. b. UPDATED we simply update it with the new value. c. REMOVED it means that at this point in the ledger the entry is removed so updating it returns an error.
3. If the change is REMOVE it checks if any change connected to given entry is already in the cache. If not, it adds REMOVE change. Otherwise, if existing change is: a. CREATED it means that due to previous transitions we want to create this in a DB what means that it doesn't exist in a DB. If it was created and removed in the same ledger it's a noop so we remove entry from the cache. b. UPDATED we simply update it to be a REMOVE change because the UPDATE change means the entry exists in a DB. c. REMOVED it returns error because we can't remove an entry that was already removed.

func NewLedgerEntryChangeCache() *LedgerEntryChangeCache

func (c *LedgerEntryChangeCache) AddChange(change Change) error

func (c *LedgerEntryChangeCache) GetChanges() []Change

func (c *LedgerEntryChangeCache) Size() int

type LedgerReader ¶

type LedgerReader interface {
	GetSequence() uint32
	GetHeader() xdr.LedgerHeaderHistoryEntry
	// Read should return the next transaction. If there are no more
	// transactions it should return `io.EOF` error.
	Read() (LedgerTransaction, error)
	// Close should be called when reading is finished. This is especially
	// helpful when there are still some transactions available so reader can stop
	// streaming them.
	Close() error
}

LedgerReader provides convenient, streaming access to the transactions within a ledger.

type LedgerTransaction ¶

type LedgerTransaction struct {
	Index    uint32
	Envelope xdr.TransactionEnvelope
	Result   xdr.TransactionResultPair
	// FeeChanges and Meta are low level values.
	// Use LedgerTransaction.GetChanges() for higher level access to ledger
	// entry changes.
	FeeChanges xdr.LedgerEntryChanges
	Meta       xdr.TransactionMeta
}

LedgerTransaction represents the data for a single transaction within a ledger.

func (t *LedgerTransaction) GetChanges() ([]Change, error)

func (t *LedgerTransaction) GetFeeChanges() []Change

func (t *LedgerTransaction) GetOperationChanges(operationIndex uint32) ([]Change, error)

type LedgerTransactionProcessor ¶

type LedgerTransactionProcessor interface {
	ProcessTransaction(transaction LedgerTransaction) error
}

type MockChangeProcessor ¶

type MockChangeProcessor struct {
	mock.Mock
}

func (m *MockChangeProcessor) ProcessChange(change Change) error

type MockChangeReader ¶

type MockChangeReader struct {
	mock.Mock
}

func (m *MockChangeReader) Close() error

func (m *MockChangeReader) Read() (Change, error)

type MockLedgerReader ¶

type MockLedgerReader struct {
	mock.Mock
}

func (m *MockLedgerReader) Close() error

func (m *MockLedgerReader) GetHeader() xdr.LedgerHeaderHistoryEntry

func (m *MockLedgerReader) GetSequence() uint32

func (m *MockLedgerReader) GetUpgradeChanges() []Change

func (m *MockLedgerReader) IgnoreUpgradeChanges()

func (m *MockLedgerReader) Read() (LedgerTransaction, error)

func (m *MockLedgerReader) ReadUpgradeChange() (Change, error)

type MockLedgerTransactionProcessor ¶

type MockLedgerTransactionProcessor struct {
	mock.Mock
}

func (m *MockLedgerTransactionProcessor) ProcessTransaction(transaction LedgerTransaction) error

type SingleLedgerStateReader ¶

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

SingleLedgerStateReader is a streaming implementation that reads ledger entries from buckets for a given HistoryArchiveState (single ledger/checkpoint). SingleLedgerStateReader hides internal structure of buckets from the user so entries returned by `Read()` are exactly the ledger entries present at the given ledger.

func MakeSingleLedgerStateReader(
	ctx context.Context,
	archive historyarchive.ArchiveInterface,
	sequence uint32,
	maxStreamRetries int,
) (*SingleLedgerStateReader, error)

func (msr *SingleLedgerStateReader) Close() error

func (msr *SingleLedgerStateReader) Read() (Change, error)

type StatsChangeProcessor ¶

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

StatsChangeProcessor is a state processors that counts number of changes types and entry types.

func (p *StatsChangeProcessor) GetResults() StatsChangeProcessorResults

func (p *StatsChangeProcessor) ProcessChange(change Change) error

type StatsChangeProcessorResults ¶

type StatsChangeProcessorResults struct {
	AccountsCreated int64
	AccountsUpdated int64
	AccountsRemoved int64

	DataCreated int64
	DataUpdated int64
	DataRemoved int64

	OffersCreated int64
	OffersUpdated int64
	OffersRemoved int64

	TrustLinesCreated int64
	TrustLinesUpdated int64
	TrustLinesRemoved int64
}

StatsChangeProcessorResults contains results after running StatsChangeProcessor.

func (stats *StatsChangeProcessorResults) Map() map[string]interface{}

type StatsLedgerTransactionProcessor ¶

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

StatsLedgerTransactionProcessor is a state processors that counts number of changes types and entry types.

func (p *StatsLedgerTransactionProcessor) GetResults() StatsLedgerTransactionProcessorResults

func (p *StatsLedgerTransactionProcessor) ProcessTransaction(transaction LedgerTransaction) error

type StatsLedgerTransactionProcessorResults ¶

type StatsLedgerTransactionProcessorResults struct {
	Transactions           int64
	TransactionsSuccessful int64
	TransactionsFailed     int64

	Operations             int64
	OperationsInSuccessful int64
	OperationsInFailed     int64

	OperationsCreateAccount            int64
	OperationsPayment                  int64
	OperationsPathPaymentStrictReceive int64
	OperationsManageSellOffer          int64
	OperationsCreatePassiveSellOffer   int64
	OperationsSetOptions               int64
	OperationsChangeTrust              int64
	OperationsAllowTrust               int64
	OperationsAccountMerge             int64
	OperationsInflation                int64
	OperationsManageData               int64
	OperationsBumpSequence             int64
	OperationsManageBuyOffer           int64
	OperationsPathPaymentStrictSend    int64
}

StatsLedgerTransactionProcessorResults contains results after running StatsLedgerTransactionProcessor.

func (stats *StatsLedgerTransactionProcessorResults) Map() map[string]interface{}