chain

type CLIFlagDef struct {
	Name         string
	Description  string
	DefaultValue string // empty string for string flags, or special handling
	FlagType     CLIFlagType
}

type CLIFlagType int

type CapabilityConfig struct {
	Registry   *capreg.Registry
	Clients    map[uint64]ChainClient
	Forwarders map[uint64]string
	PrivateKey interface{} // chain-type-specific key type; EVM uses *ecdsa.PrivateKey
	Broadcast  bool
	Limits     *cresettings.Workflows // nil disables enforcement
	Logger     logger.Logger
}

type ChainClient interface{}

type ChainConfig struct {
	Selector  uint64
	Forwarder string // chain-type-specific forwarding address
}

type ChainType interface {
	// Name returns the chain type identifier (e.g., "evm", "aptos").
	Name() string

	// ResolveClients creates RPC clients for all chains this chain type can
	// simulate, including both supported and experimental chains. Returns a
	// ResolvedChains bundle containing clients keyed by chain selector,
	// forwarder addresses, and any chain-type-agnostic metadata (e.g.
	// experimental-selector set) that later interface methods need.
	ResolveClients(v *viper.Viper) (ResolvedChains, error)

	// ResolveKey parses and validates this chain type's signing key from
	// settings. If broadcast is true, missing or default-sentinel keys
	// are a hard error; otherwise a sentinel may be used with a warning.
	// Returns the parsed key (chain-type-specific) or nil if the chain
	// type does not use a signing key.
	ResolveKey(creSettings *settings.Settings, broadcast bool) (interface{}, error)

	// ResolveTriggerData produces the chain-type-specific trigger payload for
	// a given chain selector, using runtime parameters from the caller.
	ResolveTriggerData(ctx context.Context, selector uint64, params TriggerParams) (interface{}, error)

	// RegisterCapabilities creates capability servers for this chain type's
	// chains and adds them to the registry. Returns the underlying services
	// (e.g., per-selector chain fakes) so the caller can manage their lifecycle.
	RegisterCapabilities(ctx context.Context, cfg CapabilityConfig) ([]services.Service, error)

	// ExecuteTrigger fires a chain-specific trigger for a given selector.
	// Each chain type defines what triggerData looks like.
	ExecuteTrigger(ctx context.Context, selector uint64, registrationID string, triggerData interface{}) error

	// Supports reports whether this chain type has an initialised capability
	// for the given selector in the current run (supported + RPC configured).
	Supports(selector uint64) bool

	// ParseTriggerChainSelector extracts this family's selector from a trigger
	// subscription ID (e.g. "evm:ChainSelector:123@1.0.0"). Returns 0, false if
	// the ID does not belong to this chain type.
	ParseTriggerChainSelector(triggerID string) (uint64, bool)

	// RunHealthCheck validates RPC connectivity for all resolved clients.
	// The resolved argument is the same bundle ResolveClients returned,
	// threaded back by the caller so RunHealthCheck is self-contained and
	// does not depend on hidden state on the ChainType instance.
	RunHealthCheck(resolved ResolvedChains) error

	// SupportedChains returns the list of chains this chain type supports
	// out of the box (for display/documentation purposes).
	SupportedChains() []ChainConfig

	// CollectCLIInputs reads this chain type's CLI flags from viper and
	// returns them as key-value pairs for TriggerParams.ChainTypeInputs.
	CollectCLIInputs(v *viper.Viper) map[string]string
}

type Factory func(lggr *zerolog.Logger) ChainType

type Limits struct {
	ReportSize int
	GasLimit   uint64
}

type ListeningChainType interface {
	NewTriggerListener(ctx context.Context, selector uint64, params TriggerParams) (TriggerListener, error)
}

type ResolvedChains struct {
	Clients    map[uint64]ChainClient
	Forwarders map[uint64]string
	// ExperimentalSelectors marks selectors that came from experimental-chain
	// config rather than the chain type's built-in supported list. Used for
	// error labelling (e.g. "experimental chain N" vs a chain name).
	ExperimentalSelectors map[uint64]bool
}

type TriggerListener interface {
	Next(ctx context.Context) (interface{}, error)
}

type TriggerParams struct {
	Clients         map[uint64]ChainClient
	Interactive     bool
	Listen          bool
	Limits          *cresettings.Workflows
	ChainTypeInputs map[string]string
	// TriggerPayload is the protobuf Any payload from the selected
	// pb.TriggerSubscription. Chain types unmarshal it into their own
	// trigger-config message (e.g. evm.FilterLogTriggerRequest) to learn what
	// the workflow is actually subscribed to.
	TriggerPayload *anypb.Any
	// WorkflowName is used to render replay-command hints in interactive copy.
	WorkflowName string
}