processors

package
v0.0.0-...-095633c Latest Latest
Warning

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

 Go to latest Published: Jun 10, 2024 License: Apache-2.0, Apache-2.0 Imports: 30 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func AssetFromContractData 

func AssetFromContractData(ledgerEntry xdr.LedgerEntry, passphrase string) *xdr.Asset

AssetFromContractData takes a ledger entry and verifies if the ledger entry corresponds to the asset info entry written to contract storage by the Hcnet Asset Contract upon initialization.

Note that AssetFromContractData will ignore forged asset info entries by deriving the Hcnet Asset Contract ID from the asset info entry and comparing it to the contract ID found in the ledger entry.

If the given ledger entry is a verified asset info entry, AssetFromContractData will return the corresponding Hcnet asset. Otherwise, it returns nil.

References: https://github.com/shantanu-hashcash/rs-soroban-env/blob/v0.0.16/soroban-env-host/src/native_contract/token/public_types.rs#L21 https://github.com/shantanu-hashcash/rs-soroban-env/blob/v0.0.16/soroban-env-host/src/native_contract/token/asset_info.rs#L6 https://github.com/shantanu-hashcash/rs-soroban-env/blob/v0.0.16/soroban-env-host/src/native_contract/token/contract.rs#L115

The asset info in `ContractData` entry takes the following form:

  • Instance storage - it's part of contract instance data storage

  • Key: a vector with one element, which is the symbol "AssetInfo"

    ScVal{ Vec: ScVec({ ScVal{ Sym: ScSymbol("AssetInfo") }})}

  • Value: a map with two key-value pairs: code and issuer

    ScVal{ Map: ScMap( { ScVal{ Sym: ScSymbol("asset_code") } -> ScVal{ Str: ScString(...) } }, { ScVal{ Sym: ScSymbol("issuer") } -> ScVal{ Bytes: ScBytes(...) } } )}

func AssetToContractData 

func AssetToContractData(isNative bool, code, issuer string, contractID [32]byte) (xdr.LedgerEntryData, error)

AssetToContractData is the inverse of AssetFromContractData. It creates a ledger entry containing the asset info entry written to contract storage by the Hcnet Asset Contract.

Warning: Only for use in tests. This does not create the accompanied TTLEntry which would typically be created by core.

func BalanceToContractData 

func BalanceToContractData(assetContractId, holderID [32]byte, amt uint64) xdr.LedgerEntryData

BalanceToContractData is the inverse of ContractBalanceFromContractData. It creates a ledger entry containing the asset balance of a contract holder written to contract storage by the Hcnet Asset Contract.

Warning: Only for use in tests. This does not create the accompanied TTLEntry which would typically be created by core.

func ContractBalanceFromContractData 

func ContractBalanceFromContractData(ledgerEntry xdr.LedgerEntry, passphrase string) ([32]byte, *big.Int, bool)

ContractBalanceFromContractData takes a ledger entry and verifies that the ledger entry corresponds to the balance entry written to contract storage by the Hcnet Asset Contract.

Reference: 

https://github.com/shantanu-hashcash/rs-soroban-env/blob/da325551829d31dcbfa71427d51c18e71a121c5f/soroban-env-host/src/native_contract/token/storage_types.rs#L11-L24

func ContractBalanceLedgerKey 

func ContractBalanceLedgerKey(assetContractId, holderID [32]byte) xdr.LedgerKey

ContractBalanceLedgerKey constructs the ledger key corresponding to the asset balance of a contract holder written to contract storage by the Hcnet Asset Contract.

func EncodeOfferId 

func EncodeOfferId(id uint64, typ OfferIDType) int64

EncodeOfferId creates synthetic offer ids to be used by trade resources

This is required because hcnet-core does not allocate offer ids for immediately filled offers, while clients expect them for aggregated views.

The encoded value is of type int64 for sql compatibility. The 2nd bit is used to differentiate between hcnet-core offer ids and operation ids, which are toids.

Due to the 2nd bit being used, the largest possible toid is: 0011111111111111111111111111111100000000000000000001000000000001 \ ledger /\ transaction /\ op / 

= 1073741823
  with avg. 5 sec close time will reach in ~170 years

func IncludeContractIDsInAssetStats 

func IncludeContractIDsInAssetStats(
	networkPassphrase string,
	assetStatsDeltas []history.ExpAssetStat,
	contractToAsset map[xdr.Hash]*xdr.Asset,
) ([]history.ExpAssetStat, error)

func ParticipantsForTransaction 

func ParticipantsForTransaction(
	sequence uint32,
	transaction ingest.LedgerTransaction,
) ([]xdr.AccountId, error)

func PoolIDToString 

func PoolIDToString(id xdr.PoolId) string

PoolIDToString encodes a liquidity pool id xdr value to its string form

func StreamLedgerTransactions 

func StreamLedgerTransactions(
	ctx context.Context,
	txFilterer LedgerTransactionFilterer,
	filteredTxProcessor LedgerTransactionProcessor,
	txProcessor LedgerTransactionProcessor,
	reader *ingest.LedgerTransactionReader,
	ledger xdr.LedgerCloseMeta,
) error

Types

type AccountDataProcessor 

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

func NewAccountDataProcessor 

func NewAccountDataProcessor(dataQ history.QData) *AccountDataProcessor

func (*AccountDataProcessor) Commit 

func (p *AccountDataProcessor) Commit(ctx context.Context) error

func (*AccountDataProcessor) Name 

func (p *AccountDataProcessor) Name() string

func (*AccountDataProcessor) ProcessChange 

func (p *AccountDataProcessor) ProcessChange(ctx context.Context, change ingest.Change) error

type AccountsProcessor 

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

func NewAccountsProcessor 

func NewAccountsProcessor(accountsQ history.QAccounts) *AccountsProcessor

func (*AccountsProcessor) Commit 

func (p *AccountsProcessor) Commit(ctx context.Context) error

func (*AccountsProcessor) Name 

func (p *AccountsProcessor) Name() string

func (*AccountsProcessor) ProcessChange 

func (p *AccountsProcessor) ProcessChange(ctx context.Context, change ingest.Change) error

type AssetStatSet 

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

AssetStatSet represents a collection of asset stats and a mapping of Soroban contract IDs to classic assets (which is unique to each network).

func NewAssetStatSet 

func NewAssetStatSet() AssetStatSet

NewAssetStatSet constructs a new AssetStatSet instance

func (AssetStatSet) AddClaimableBalance 

func (s AssetStatSet) AddClaimableBalance(change ingest.Change) error

AddClaimableBalance updates the set to account for how a given claimable balance has changed. change must be a xdr.LedgerEntryTypeClaimableBalance type.

func (AssetStatSet) AddLiquidityPool 

func (s AssetStatSet) AddLiquidityPool(change ingest.Change) error

AddLiquidityPool updates the set to account for how a given liquidity pool has changed. change must be a xdr.LedgerEntryTypeLiqidityPool type.

func (AssetStatSet) AddTrustline 

func (s AssetStatSet) AddTrustline(change ingest.Change) error

AddTrustline updates the set to account for how a given trustline has changed. change must be a xdr.LedgerEntryTypeTrustLine type.

func (AssetStatSet) All 

func (s AssetStatSet) All() []history.ExpAssetStat

All returns a list of all `history.ExpAssetStat` contained within the set along with all contract id attribution changes in the set.

type AssetStatsProcessor 

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

func NewAssetStatsProcessor 

func NewAssetStatsProcessor(
	assetStatsQ history.QAssetStats,
	networkPassphrase string,
	ingestFromHistoryArchive bool,
	currentLedger uint32,
) *AssetStatsProcessor

NewAssetStatsProcessor constructs a new AssetStatsProcessor instance.

func (*AssetStatsProcessor) Commit 

func (p *AssetStatsProcessor) Commit(ctx context.Context) error

func (*AssetStatsProcessor) Name 

func (p *AssetStatsProcessor) Name() string

func (*AssetStatsProcessor) ProcessChange 

func (p *AssetStatsProcessor) ProcessChange(ctx context.Context, change ingest.Change) error

type ChangeProcessor 

type ChangeProcessor interface {
	ProcessChange(ctx context.Context, change ingest.Change) error
}

type ClaimableBalancesChangeProcessor 

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

func NewClaimableBalancesChangeProcessor 

func NewClaimableBalancesChangeProcessor(Q history.QClaimableBalances) *ClaimableBalancesChangeProcessor

func (*ClaimableBalancesChangeProcessor) Commit 

func (p *ClaimableBalancesChangeProcessor) Commit(ctx context.Context) error

func (*ClaimableBalancesChangeProcessor) Name 

func (p *ClaimableBalancesChangeProcessor) Name() string

func (*ClaimableBalancesChangeProcessor) ProcessChange 

func (p *ClaimableBalancesChangeProcessor) ProcessChange(ctx context.Context, change ingest.Change) error

type ClaimableBalancesTransactionProcessor 

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

func NewClaimableBalancesTransactionProcessor 

func NewClaimableBalancesTransactionProcessor(
	cbLoader *history.ClaimableBalanceLoader,
	txBatch history.TransactionClaimableBalanceBatchInsertBuilder,
	opBatch history.OperationClaimableBalanceBatchInsertBuilder,
) *ClaimableBalancesTransactionProcessor

func (*ClaimableBalancesTransactionProcessor) Flush 

func (p *ClaimableBalancesTransactionProcessor) Flush(ctx context.Context, session db.SessionInterface) error

func (*ClaimableBalancesTransactionProcessor) Name 

func (p *ClaimableBalancesTransactionProcessor) Name() string

func (*ClaimableBalancesTransactionProcessor) ProcessTransaction 

func (p *ClaimableBalancesTransactionProcessor) ProcessTransaction(
	lcm xdr.LedgerCloseMeta, transaction ingest.LedgerTransaction,
) error

type ContractAssetStatSet 

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

ContractAssetStatSet represents a collection of asset stats for contract asset holders

func NewContractAssetStatSet 

func NewContractAssetStatSet(
	assetStatsQ contractAssetBalancesQ,
	networkPassphrase string,
	removedExpirationEntries map[xdr.Hash]uint32,
	createdExpirationEntries map[xdr.Hash]uint32,
	updatedExpirationEntries map[xdr.Hash][2]uint32,
	currentLedger uint32,
) *ContractAssetStatSet

NewContractAssetStatSet constructs a new ContractAssetStatSet instance

func (*ContractAssetStatSet) AddContractData 

func (s *ContractAssetStatSet) AddContractData(ctx context.Context, change ingest.Change) error

AddContractData updates the set to account for how a given contract data entry has changed. change must be a xdr.LedgerEntryTypeContractData type.

func (*ContractAssetStatSet) GetAssetToContractMap 

func (s *ContractAssetStatSet) GetAssetToContractMap() map[xdr.Hash]*xdr.Asset

func (*ContractAssetStatSet) GetContractStats 

func (s *ContractAssetStatSet) GetContractStats() []history.ContractAssetStatRow

func (*ContractAssetStatSet) GetCreatedBalances 

func (s *ContractAssetStatSet) GetCreatedBalances() []history.ContractAssetBalance

type EffectProcessor 

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

EffectProcessor process effects

func NewEffectProcessor 

func NewEffectProcessor(
	accountLoader *history.AccountLoader,
	batch history.EffectBatchInsertBuilder,
	network string,
) *EffectProcessor

func (*EffectProcessor) Flush 

func (p *EffectProcessor) Flush(ctx context.Context, session db.SessionInterface) (err error)

func (*EffectProcessor) Name 

func (p *EffectProcessor) Name() string

func (*EffectProcessor) ProcessTransaction 

func (p *EffectProcessor) ProcessTransaction(
	lcm xdr.LedgerCloseMeta, transaction ingest.LedgerTransaction,
) error

type LedgerTransactionFilterer 

type LedgerTransactionFilterer interface {
	Name() string
	FilterTransaction(ctx context.Context, transaction ingest.LedgerTransaction) (bool, error)
}

type LedgerTransactionProcessor 

type LedgerTransactionProcessor interface {
	ProcessTransaction(lcm xdr.LedgerCloseMeta, transaction ingest.LedgerTransaction) error
	Flush(ctx context.Context, session db.SessionInterface) error
}

type LedgersProcessor 

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

func NewLedgerProcessor 

func NewLedgerProcessor(batch history.LedgerBatchInsertBuilder, ingestVersion int) *LedgersProcessor

func (*LedgersProcessor) Flush 

func (p *LedgersProcessor) Flush(ctx context.Context, session db.SessionInterface) error

func (*LedgersProcessor) Name 

func (p *LedgersProcessor) Name() string

func (*LedgersProcessor) ProcessLedger 

func (p *LedgersProcessor) ProcessLedger(lcm xdr.LedgerCloseMeta) *ledgerInfo

func (*LedgersProcessor) ProcessTransaction 

func (p *LedgersProcessor) ProcessTransaction(lcm xdr.LedgerCloseMeta, transaction ingest.LedgerTransaction) error

type LiquidityPoolsChangeProcessor 

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

func NewLiquidityPoolsChangeProcessor 

func NewLiquidityPoolsChangeProcessor(Q history.QLiquidityPools, sequence uint32) *LiquidityPoolsChangeProcessor

func (*LiquidityPoolsChangeProcessor) Commit 

func (p *LiquidityPoolsChangeProcessor) Commit(ctx context.Context) error

func (*LiquidityPoolsChangeProcessor) Name 

func (p *LiquidityPoolsChangeProcessor) Name() string

func (*LiquidityPoolsChangeProcessor) ProcessChange 

func (p *LiquidityPoolsChangeProcessor) ProcessChange(ctx context.Context, change ingest.Change) error

type LiquidityPoolsTransactionProcessor 

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

func NewLiquidityPoolsTransactionProcessor 

func NewLiquidityPoolsTransactionProcessor(
	lpLoader *history.LiquidityPoolLoader,
	txBatch history.TransactionLiquidityPoolBatchInsertBuilder,
	opBatch history.OperationLiquidityPoolBatchInsertBuilder,
) *LiquidityPoolsTransactionProcessor

func (*LiquidityPoolsTransactionProcessor) Flush 

func (p *LiquidityPoolsTransactionProcessor) Flush(ctx context.Context, session db.SessionInterface) error

func (*LiquidityPoolsTransactionProcessor) Name 

func (p *LiquidityPoolsTransactionProcessor) Name() string

func (*LiquidityPoolsTransactionProcessor) ProcessTransaction 

func (p *LiquidityPoolsTransactionProcessor) ProcessTransaction(lcm xdr.LedgerCloseMeta, transaction ingest.LedgerTransaction) error

type MockChangeProcessor 

type MockChangeProcessor struct {
	mock.Mock
}

func (*MockChangeProcessor) ProcessChange 

func (m *MockChangeProcessor) ProcessChange(ctx context.Context, change ingest.Change) error

type OfferIDType 

type OfferIDType uint64
const (
	CoreOfferIDType OfferIDType = 0
	TOIDType        OfferIDType = 1
)

func DecodeOfferID 

func DecodeOfferID(encodedId int64) (uint64, OfferIDType)

DecodeOfferID performs the reverse operation of EncodeOfferID

type OffersProcessor 

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

func NewOffersProcessor 

func NewOffersProcessor(offersQ history.QOffers, sequence uint32) *OffersProcessor

func (*OffersProcessor) Commit 

func (p *OffersProcessor) Commit(ctx context.Context) error

func (*OffersProcessor) Name 

func (p *OffersProcessor) Name() string

func (*OffersProcessor) ProcessChange 

func (p *OffersProcessor) ProcessChange(ctx context.Context, change ingest.Change) error

type OperationProcessor 

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

OperationProcessor operations processor

func NewOperationProcessor 

func NewOperationProcessor(batch history.OperationBatchInsertBuilder, network string) *OperationProcessor

func (*OperationProcessor) Flush 

func (p *OperationProcessor) Flush(ctx context.Context, session db.SessionInterface) error

func (*OperationProcessor) Name 

func (p *OperationProcessor) Name() string

func (*OperationProcessor) ProcessTransaction 

func (p *OperationProcessor) ProcessTransaction(lcm xdr.LedgerCloseMeta, transaction ingest.LedgerTransaction) error

ProcessTransaction process the given transaction

type ParticipantsProcessor 

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

ParticipantsProcessor is a processor which ingests various participants from different sources (transactions, operations, etc)

func NewParticipantsProcessor 

func NewParticipantsProcessor(
	accountLoader *history.AccountLoader,
	txBatch history.TransactionParticipantsBatchInsertBuilder,
	opBatch history.OperationParticipantBatchInsertBuilder,
) *ParticipantsProcessor

func (*ParticipantsProcessor) Flush 

func (p *ParticipantsProcessor) Flush(ctx context.Context, session db.SessionInterface) error

func (*ParticipantsProcessor) Name 

func (p *ParticipantsProcessor) Name() string

func (*ParticipantsProcessor) ProcessTransaction 

func (p *ParticipantsProcessor) ProcessTransaction(lcm xdr.LedgerCloseMeta, transaction ingest.LedgerTransaction) error

type SignersProcessor 

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

func NewSignersProcessor 

func NewSignersProcessor(
	signersQ history.QSigners,
) *SignersProcessor

func (*SignersProcessor) Commit 

func (p *SignersProcessor) Commit(ctx context.Context) error

func (*SignersProcessor) Name 

func (p *SignersProcessor) Name() string

func (*SignersProcessor) ProcessChange 

func (p *SignersProcessor) ProcessChange(ctx context.Context, change ingest.Change) error

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 NewStatsLedgerTransactionProcessor 

func NewStatsLedgerTransactionProcessor() *StatsLedgerTransactionProcessor

func (*StatsLedgerTransactionProcessor) Flush 

func (p *StatsLedgerTransactionProcessor) Flush(ctx context.Context, session db.SessionInterface) error

func (*StatsLedgerTransactionProcessor) GetResults 

func (p *StatsLedgerTransactionProcessor) GetResults() StatsLedgerTransactionProcessorResults

func (*StatsLedgerTransactionProcessor) Name 

func (p *StatsLedgerTransactionProcessor) Name() string

func (*StatsLedgerTransactionProcessor) ProcessTransaction 

func (p *StatsLedgerTransactionProcessor) ProcessTransaction(lcm xdr.LedgerCloseMeta, transaction ingest.LedgerTransaction) error

func (*StatsLedgerTransactionProcessor) ResetStats 

func (p *StatsLedgerTransactionProcessor) ResetStats()

type StatsLedgerTransactionProcessorResults 

type StatsLedgerTransactionProcessorResults struct {
	Transactions           int64
	TransactionsSuccessful int64
	TransactionsFailed     int64
	TransactionsFiltered   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
	OperationsCreateClaimableBalance        int64
	OperationsClaimClaimableBalance         int64
	OperationsBeginSponsoringFutureReserves int64
	OperationsEndSponsoringFutureReserves   int64
	OperationsRevokeSponsorship             int64
	OperationsClawback                      int64
	OperationsClawbackClaimableBalance      int64
	OperationsSetTrustLineFlags             int64
	OperationsLiquidityPoolDeposit          int64
	OperationsLiquidityPoolWithdraw         int64
	OperationsInvokeHostFunction            int64
	OperationsExtendFootprintTtl            int64
	OperationsRestoreFootprint              int64
}

StatsLedgerTransactionProcessorResults contains results after running StatsLedgerTransactionProcessor.

func (*StatsLedgerTransactionProcessorResults) Map 

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

type TradeProcessor 

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

TradeProcessor operations processor

func NewTradeProcessor 

func NewTradeProcessor(
	accountLoader *history.AccountLoader,
	lpLoader *history.LiquidityPoolLoader,
	assetLoader *history.AssetLoader,
	batch history.TradeBatchInsertBuilder,
) *TradeProcessor

func (*TradeProcessor) Flush 

func (p *TradeProcessor) Flush(ctx context.Context, session db.SessionInterface) error

func (*TradeProcessor) GetStats 

func (p *TradeProcessor) GetStats() TradeStats

func (*TradeProcessor) Name 

func (p *TradeProcessor) Name() string

func (*TradeProcessor) ProcessTransaction 

func (p *TradeProcessor) ProcessTransaction(lcm xdr.LedgerCloseMeta, transaction ingest.LedgerTransaction) (err error)

ProcessTransaction process the given transaction

func (*TradeProcessor) ResetStats 

func (p *TradeProcessor) ResetStats()

type TradeStats 

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

func (*TradeStats) Map 

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

type TransactionProcessor 

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

func NewTransactionFilteredTmpProcessor 

func NewTransactionFilteredTmpProcessor(batch history.TransactionBatchInsertBuilder, skipTxmeta bool) *TransactionProcessor

func NewTransactionProcessor 

func NewTransactionProcessor(batch history.TransactionBatchInsertBuilder, skipTxmeta bool) *TransactionProcessor

func (*TransactionProcessor) Flush 

func (p *TransactionProcessor) Flush(ctx context.Context, session db.SessionInterface) error

func (*TransactionProcessor) Name 

func (p *TransactionProcessor) Name() string

func (*TransactionProcessor) ProcessTransaction 

func (p *TransactionProcessor) ProcessTransaction(lcm xdr.LedgerCloseMeta, transaction ingest.LedgerTransaction) error

type TrustLinesProcessor 

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

func NewTrustLinesProcessor 

func NewTrustLinesProcessor(trustLinesQ history.QTrustLines) *TrustLinesProcessor

func (*TrustLinesProcessor) Commit 

func (p *TrustLinesProcessor) Commit(ctx context.Context) error

func (*TrustLinesProcessor) Name 

func (p *TrustLinesProcessor) Name() string

func (*TrustLinesProcessor) ProcessChange 

func (p *TrustLinesProcessor) ProcessChange(ctx context.Context, change ingest.Change) 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.