orchestration

type Config struct {
	// PollInterval between blockchain polls
	PollInterval time.Duration `json:"poll_interval" yaml:"poll_interval"`
	// ProviderAddress is this provider's blockchain address
	ProviderAddress string `json:"provider_address" yaml:"provider_address"`
	// NodeRPCURL is the blockchain node RPC URL
	NodeRPCURL string `json:"node_rpc_url" yaml:"node_rpc_url"`
	// Enabled controls whether polling is active
	Enabled bool `json:"enabled" yaml:"enabled"`
	// ResponseMode chooses how responses are submitted back to the chain.
	// Defaults to contract-execute for backward compatibility.
	ResponseMode ResponseMode `json:"response_mode" yaml:"response_mode"`
	// KubeSettings is required with ClusterRead for NodePort discovery on
	// health/status responses (ClusterPublicHostname, etc.). Both may be nil.
	KubeSettings *builder.Settings `json:"-" yaml:"-"`
	// ClusterRead supplies ForwardedPortStatus when set (typically the real
	// cluster client from provider run).
	ClusterRead cluster.ReadClient `json:"-" yaml:"-"`
	// Deployments enumerates the leases the poller should proactively report
	// forwarded_ports for. When nil the poller falls back to the legacy
	// behaviour of only emitting ForwardedPorts in response to a chain
	// `health_request` event.
	Deployments DeploymentLister `json:"-" yaml:"-"`
	// ForwardedPortsInterval throttles how often the poller publishes a
	// fresh forwarded_ports snapshot for each active lease. Zero defaults
	// to one minute. The chain only keeps the latest payload per lease so
	// the interval can be conservative without losing fidelity.
	ForwardedPortsInterval time.Duration `json:"forwarded_ports_interval" yaml:"forwarded_ports_interval"`
	// ForwardedPortsOnChange switches the publisher to CHANGE-DRIVEN: a lease's
	// deployment_ready/forwarded_ports tx is submitted as soon as the cluster's
	// NodePort allocation DIFFERS from the value this process last published for
	// that lease (or has no cached value yet — the first deploy, and once after a
	// provider restart: the "after reset" case), instead of on every fixed tick.
	// Default false preserves the legacy timer behaviour.
	//
	// IMPORTANT: this is NOT "publish only on change and never again". An
	// unchanged lease is still republished every LivenessRefreshInterval (the
	// heartbeat backstop) so the per-lease liveness signal stays fresh and a dead
	// deployment on an otherwise-healthy provider is still detected + failed over.
	// Pure on-change publishing (no backstop) drops the heartbeat entirely, and a
	// dead pod on a provider whose gateway is up becomes invisible to the HA
	// contract (per-provider x/valiporacle can't see it). See
	// docs/legacy/LIVENESS-AND-ENDPOINT-REDESIGN.md §8.
	ForwardedPortsOnChange bool `json:"forwarded_ports_on_change" yaml:"forwarded_ports_on_change"`
	// LivenessRefreshInterval is the heartbeat backstop for change-driven mode:
	// an unchanged lease is republished at least this often. Zero inherits
	// ForwardedPortsInterval (resolved in Normalized — same liveness cadence as
	// the legacy timer, so enabling change-driven is safe by default). RAISE it —
	// with x/valiporacle handling fast provider-down failover — to cut
	// steady-state tx cost, at the price of slower per-deployment
	// (dead-pod-on-healthy-provider) failover. Must stay below the HA contract's
	// health_timeout (in wall-clock) or healthy members will spuriously time out.
	// Ignored when ForwardedPortsOnChange=false.
	LivenessRefreshInterval time.Duration `json:"liveness_refresh_interval" yaml:"liveness_refresh_interval"`
}

type DeploymentLister interface {
	Deployments(ctx context.Context) ([]ctypes.IDeployment, error)
}

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

type HealthResponsePayload struct {
	LeaseID   apiorch.LeaseIdentifier `json:"lease_id"`
	Status    string                  `json:"status"`
	Message   string                  `json:"message,omitempty"`
	Timestamp int64                   `json:"timestamp"`
	// NodePort / workload-facing ports (from cluster ForwardedPortStatus), when configured.
	ForwardedPorts []orchestrationForwardedPort `json:"forwarded_ports,omitempty"`
}

type KubeClient interface {
	ScaleDeployment(ctx context.Context, namespace, service string, replicas int32) error
	RestartDeployment(ctx context.Context, namespace, service string) error
	StopDeployment(ctx context.Context, namespace, service string) error
	// SetLeaseEnv persists per-lease env vars in a ConfigMap inside
	// the lease's namespace (typically named
	// `akash-lease-env-<dseq>-<gseq>-<oseq>`). The builder reads this
	// ConfigMap when (re)creating pods so the env merges in
	// transparently. `version` is monotonically increasing; the
	// implementation must reject stale writes (version <= currently
	// stored version) and return the actually-applied version. When
	// `restart` is true the implementation also triggers a rolling
	// restart of every Deployment in the namespace so the env takes
	// effect immediately. Returns the ConfigMap name, the applied
	// version, whether a restart was triggered, and any error.
	SetLeaseEnv(
		ctx context.Context,
		namespace string,
		env map[string]string,
		version uint64,
		restart bool,
	) (configMapName string, applied uint64, restartTriggered bool, err error)
}

type LeaseHealthChecker interface {
	CheckLeaseHealth(ctx context.Context, leaseID mv1.LeaseID) (*health.LeaseHealth, error)
}

type MessageSource interface {
	PendingMessages(ctx context.Context) ([]apiorch.OrchestrationMessage, error)
}

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

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

type ResponderConfig struct {
	// ProviderAddress is this provider's bech32 signer address. Must
	// match the LeaseID.Provider of every message being submitted.
	ProviderAddress string

	// FromName is the keyring entry used to sign transactions. Usually
	// the same key used by the rest of the provider daemon.
	FromName string

	// Gas settings applied to every submission. Override for load
	// testing or when running on chains with unusual gas markets.
	Gas           uint64
	GasAdjustment float64
	GasPrices     string

	// BroadcastMode: "sync" (default), "async", or "block".
	BroadcastMode string

	// DefaultTTLBlocks is copied onto outbound messages when the caller
	// does not specify one. Zero means "let the chain apply its module
	// default" (see orchestration.Params.DefaultTTLBlocks).
	DefaultTTLBlocks uint64
}

type ResponseMode string

type ResponseSink interface {
	SendResponse(ctx context.Context, origin apiorch.OrchestrationMessage, msgType apiorch.OrchestrationMessageType, payload interface{}) error
}

type SubmitOptions struct {
	LeaseID       apiorch.LeaseIdentifier
	MessageType   string
	CorrelationID string
	// Payload is an arbitrary JSON-encodable value. Pass []byte / json.RawMessage
	// to skip re-encoding, or a Go struct to let Submit marshal it.
	Payload   interface{}
	TTLBlocks uint64
}

type SubmitResult struct {
	TxHash  string `json:"tx_hash"`
	Code    uint32 `json:"code"`
	RawLog  string `json:"raw_log"`
	GasUsed int64  `json:"gas_used"`
	// MessageID is the queue id returned by the chain in the tx response
	// events. Empty when the broadcast mode does not include a result
	// (e.g. async) or when the chain did not emit the expected event.
	MessageID string `json:"message_id"`
}