store

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

type ActiveContractStoreInterface interface {
	// Get returns the active contract for the given instance address.
	Get(address contracts.InstanceAddress) (*apiv2.ActiveContract, bool)
	// GetByTemplateId returns the active contracts for the given party and template ID.
	GetByTemplateId(party types.PARTY, templateId contracts.TemplateID) ([]*apiv2.ActiveContract, bool)
	// GetByContractId returns the active contract for the given contract ID.
	GetByContractId(contractId types.CONTRACT_ID) (*apiv2.ActiveContract, bool)
	// RegisterTemplates registers templates to be tracked by the store.
	RegisterTemplates(templates ...RegisteredTemplate)
}

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

type FiltersByParty map[string]*apiv2.Filters

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

type InstrumentHoldingStoreInterface interface {
	// GetHolding returns the active holdings for the given party and instrument ID.
	GetHolding(party types.PARTY, instrumentId splice_api_token_holding_v1.InstrumentId) ([]*apiv2.ActiveContract, bool)
	// ListHoldings returns all active holdings for the given instrument ID.
	ListHoldings(instrumentId splice_api_token_holding_v1.InstrumentId) ([]*apiv2.ActiveContract, error)
	// RegisterParty registers parties whose holdings should be tracked by the store.
	RegisterParty(parties ...string)
}

type Metrics interface {
	IncrementStoreSubscriptionUptime(ctx context.Context)
	IncrementStoreUpdatesCounter(ctx context.Context)
	IncrementStoreReconnectCounter(ctx context.Context)
	RecordStoreLedgerEndGauge(ctx context.Context, ledgerEnd int64)
}

type RegisteredTemplate struct {
	TemplateID contracts.TemplateID
	PartyID    string
}

type RunOption func(o *runOptions)

type StreamConfig struct {
	MaxRetries    int           // 0 means unlimited retries
	BackoffMin    time.Duration // default 100ms
	BackoffMax    time.Duration // default 3s
	BackoffFactor float64       // default 2
	// MaxEmptyReconnects fails closed after this many consecutive stream
	// reconnects that never became live (no update received and broken
	// before LivenessGrace elapsed) (0 means never fail on this).
	MaxEmptyReconnects int
	// MaxDisconnected fails closed after a single failure-to-connect gap
	// longer than this (0 means never fail on this).
	MaxDisconnected time.Duration
	// LivenessGrace is how long a freshly established stream must survive
	// without an error before it counts as live for the uptime metric
	// (0 counts uptime immediately on establishment).
	//
	// This grace exists because gRPC does not confirm a server-streaming
	// subscription up front: the GetUpdates call returns as soon as the
	// request is on the wire, and the server's acceptance or rejection is
	// only observed by the first Recv. Waiting on stream.Header() does not
	// help either, because gRPC servers may defer response headers until
	// the first message - a healthy stream with no traffic would block
	// forever. The only reliable signal is therefore the absence of an
	// immediate error: genuine rejections (bad URL, expired auth, bad
	// offset) surface on the first Recv within milliseconds and never
	// survive this grace, while an accepted stream does.
	//
	// A pre-subscribe gRPC health check (grpc.health.v1.Health, exposed by
	// the Canton Ledger API) was considered as an alternative and deferred
	// for now: it is a point-in-time signal that cannot detect per-RPC
	// rejections (auth, invalid offset) and does not close the race between
	// check and subscribe, so this grace window would still be needed
	// alongside it.
	LivenessGrace time.Duration
}