types

type AbciInfoResponse struct {
	Result struct {
		Response struct {
			LastBlockHeight string `json:"last_block_height"`
		} `json:"response"`
	} `json:"result"`
}

type BlockCollector interface {
	// GetEarliestAvailableHeight gets the earliest available block in a block pool
	GetEarliestAvailableHeight() int64

	// GetLatestAvailableHeight gets the latest available block in a block pool
	GetLatestAvailableHeight() int64

	// GetBlock gets the block for the given height
	GetBlock(height int64) ([]byte, error)

	// StreamBlocks takes a continuationHeight and a targetHeight and streams
	// all blocks in order into a given block channel. This method exits once
	// the target height is reached or runs indefinitely depending on the
	// exitOnTargetHeight value
	StreamBlocks(blockCh chan<- *BlockItem, errorCh chan<- error, continuationHeight, targetHeight int64)
}

type BlockItem struct {
	Height int64
	Block  json.RawMessage
}

type Bundle = []DataItem

type ChainSchema struct {
	Status     string `json:"status"`
	ChainId    string `json:"chain_id"`
	DaemonName string `json:"daemon_name"`
	NodeHome   string `json:"node_home"`
	Fees       struct {
		FeeTokens []FeeToken `json:"fee_tokens"`
	} `json:"fees"`
	Codebase struct {
		GitRepoUrl string `json:"git_repo"`
		Genesis    struct {
			GenesisUrl string `json:"genesis_url"`
		} `json:"genesis"`
	} `json:"codebase"`
	Peers struct {
		Seeds           []Peer `json:"seeds"`
		PersistentPeers []Peer `json:"persistent_peers"`
	} `json:"peers"`
	Apis struct {
		Rpc  []Endpoint `json:"rpc"`
		Rest []Endpoint `json:"rest"`
	} `json:"apis"`
}

type Codebase struct {
	GitUrl   string         `yaml:"git-url"`
	Settings CosmosSettings `yaml:"settings"`
}

type CosmosSettings struct {
	Upgrades []CosmosUpgrade `yaml:"upgrades"`
}

type CosmosUpgrade struct {
	Name               string `yaml:"name"`
	Height             string `yaml:"height"`
	RecommendedVersion string `yaml:"recommended-version"`
	Engine             string `yaml:"ksync-engine"`
}

type DataItem struct {
	Key   string          `json:"key"`
	Value json.RawMessage `json:"value"`
}

type Endpoint struct {
	Address  string `json:"address"`
	Provider string `json:"provider"`
}

type Engine interface {
	// GetName gets the name of the engine
	GetName() string

	// LoadConfig loads and sets the config
	LoadConfig() error

	// OpenDBs opens the relevant blockstore and state DBs
	OpenDBs() error

	// CloseDBs closes the relevant blockstore and state DBs
	CloseDBs() error

	// GetRpcListenAddress gets the address the rpc endpoint is hosted
	GetRpcListenAddress() string

	// GetProxyAppAddress gets the proxy app address of the TSP connection
	GetProxyAppAddress() string

	// StartProxyApp starts the proxy app connections to the app
	StartProxyApp() error

	// StopProxyApp stops the proxy app connections to the app
	StopProxyApp() error

	// DoHandshake does a handshake with the app and needs to be called
	// before ApplyBlock
	DoHandshake() error

	// ApplyBlock takes a block at height n and n+1 and applies it against
	// the cosmos app
	ApplyBlock(rawBlock, nextRawBlock []byte) error

	// ApplyFirstBlockOverP2P applies the first block over the P2P reactor
	// which is necessary, if the genesis file is bigger than 100MB
	ApplyFirstBlockOverP2P(rawBlock, nextRawBlock []byte) error

	// GetHeight gets the latest height stored in the blockstore.db
	GetHeight() int64

	// GetBaseHeight gets the earliest height stored in the blockstore.db
	GetBaseHeight() int64

	// GetAppHeight gets over ABCI the latest block height tracked by the app
	GetAppHeight() (int64, error)

	// GetSnapshots gets the available snapshots over ABCI from the app
	GetSnapshots() ([]byte, error)

	// IsSnapshotAvailable gets available snapshots over ABCI from the app
	// and checks if the requested snapshot is available
	IsSnapshotAvailable(height int64) (bool, error)

	// GetSnapshotChunk gets the requested snapshot chunk over ABCI from the
	// app
	GetSnapshotChunk(height, format, chunk int64) ([]byte, error)

	// GetBlock loads the requested block from the blockstore.db
	GetBlock(height int64) ([]byte, error)

	// StartRPCServer spins up a basic rpc server of the engine which serves
	// /status, /block and /block_results
	StartRPCServer(port int64)

	// GetState rebuilds the requested state from the blockstore and state.db
	GetState(height int64) ([]byte, error)

	// GetSeenCommit loads the seen commit from the blockstore.db
	GetSeenCommit(height int64) ([]byte, error)

	// OfferSnapshot offers a snapshot over ABCI to the app
	OfferSnapshot(rawSnapshot, rawState []byte) error

	// ApplySnapshotChunk applies a snapshot chunk over ABCI to the app
	ApplySnapshotChunk(chunkIndex int64, chunk []byte) error

	// BootstrapState initializes the tendermint state
	BootstrapState(rawState, rawSeenCommit, rawBlock []byte) error

	// PruneBlocks prunes blocks from the block store and state store
	// from the earliest found base height to the specified height
	PruneBlocks(toHeight int64) error

	// ResetAll removes all the data and WAL, reset this node's validator
	// to genesis state
	ResetAll(keepAddrBook bool) error
}

type Entry struct {
	ConfigVersion *int     `yaml:"config-version"`
	Networks      Networks `yaml:"networks"`
	SourceID      string   `yaml:"source-id"`
	Codebase      Codebase `yaml:"codebase"`
}

type FeeToken struct {
	Denom       string  `json:"denom"`
	LowGasPrice float64 `json:"low_gas_price"`
}

type FinalizedBundle struct {
	Id                string `json:"id,omitempty"`
	StorageId         string `json:"storage_id,omitempty"`
	StorageProviderId string `json:"storage_provider_id,omitempty"`
	CompressionId     string `json:"compression_id,omitempty"`
	FromKey           string `json:"from_key,omitempty"`
	ToKey             string `json:"to_key,omitempty"`
	DataHash          string `json:"data_hash,omitempty"`
}

type FinalizedBundlesResponse = struct {
	FinalizedBundles []FinalizedBundle `json:"finalized_bundles"`
	Pagination       Pagination        `json:"pagination"`
}

type Integrations struct {
	KSYNC *KSYNCIntegration `yaml:"ksync,omitempty"`
}

type KSYNCIntegration struct {
	BlockSyncPool *int `yaml:"block-sync-pool"`
	StateSyncPool *int `yaml:"state-sync-pool"`
}

type NetworkProperties struct {
	LatestBlockKey *string
	LatestStateKey *string
	BlockStartKey  *string
	StateStartKey  *string
	Integrations   *Integrations   `yaml:"integrations,omitempty"`
	Pools          *[]Pool         `yaml:"pools,omitempty"`
	SourceMetadata *SourceMetadata `yaml:"properties,omitempty"`
}

type Networks struct {
	Kaon *NetworkProperties `yaml:"kaon-1,omitempty"`
	Kyve *NetworkProperties `yaml:"kyve-1,omitempty"`
}

type Pagination struct {
	NextKey []byte `json:"next_key"`
}

type Peer struct {
	Id       string `json:"id"`
	Address  string `json:"address"`
	Provider string `json:"provider"`
}

type Pool struct {
	Id      *int   `yaml:"id"`
	Runtime string `yaml:"runtime"`
}

type PoolResponse = struct {
	Pool struct {
		Id   int64 `json:"id"`
		Data struct {
			Runtime        string `json:"runtime"`
			StartKey       string `json:"start_key"`
			CurrentKey     string `json:"current_key"`
			CurrentSummary string `json:"current_summary"`
			TotalBundles   int64  `json:"total_bundles"`
			Config         string `json:"config"`
		} `json:"data"`
	} `json:"pool"`
}

type Snapshot struct {
	Height   uint64 `json:"height,omitempty"`
	Format   uint32 `json:"format,omitempty"`
	Chunks   uint32 `json:"chunks,omitempty"`
	Hash     []byte `json:"hash,omitempty"`
	Metadata []byte `json:"metadata,omitempty"`
}

type SnapshotBundle = []SnapshotDataItem

type SnapshotCollector interface {
	// GetEarliestAvailableHeight gets the earliest available snapshot height in
	// a snapshot pool
	GetEarliestAvailableHeight() int64

	// GetLatestAvailableHeight gets the latest available snapshot height in
	// a snapshot pool
	GetLatestAvailableHeight() int64

	// GetInterval gets the snapshot interval
	GetInterval() int64

	// GetCurrentHeight gets the current height of the latest snapshot. This snapshot
	// is not guaranteed to be fully available and chunks can still be missing
	GetCurrentHeight() (int64, error)

	// GetSnapshotHeight gets the exact height of the nearest snapshot before the target
	// height
	GetSnapshotHeight(targetHeight int64, isServeSnapshot bool) int64

	// GetSnapshotFromBundleId gets the snapshot from the given bundle
	GetSnapshotFromBundleId(bundleId int64) (*SnapshotDataItem, error)

	// DownloadChunkFromBundleId downloads the snapshot chunk from the given bundle
	DownloadChunkFromBundleId(bundleId int64) ([]byte, error)

	// FindSnapshotBundleIdForHeight searches and returns the bundle id which contains the first
	// snapshot chunk for the given height.
	// Since we do not know how many chunks a bundle has but expect that the snapshots are ordered by height
	// we can apply a binary search to minimize the amount of requests we have to make. This method fails
	// if there is no bundle which contains the snapshot at the target height
	FindSnapshotBundleIdForHeight(height int64) (int64, error)
}

type SnapshotDataItem struct {
	Key   string `json:"key"`
	Value struct {
		Snapshot   json.RawMessage `json:"snapshot"`
		Block      json.RawMessage `json:"block"`
		SeenCommit json.RawMessage `json:"seenCommit"`
		State      json.RawMessage `json:"state"`
		ChunkIndex uint32          `json:"chunkIndex"`
		Chunk      []byte          `json:"chunk"`
	} `json:"value"`
}

type SourceMetadata struct {
	Title string `yaml:"title"`
}

type SourceRegistry struct {
	Entries map[string]Entry `yaml:",inline"`
}

type StatusResponse struct {
	Result struct {
		SyncInfo struct {
			LatestBlockHeight   int64 `json:"latest_block_height"`
			EarliestBlockHeight int64 `json:"earliest_block_height"`
		} `json:"sync_info"`
	} `json:"result"`
}

type SupportedChain = struct {
	BlockPoolId    string `json:"block_pool_id"`
	ChainId        string `json:"chain-id"`
	LatestBlockKey string `json:"latest_block_key"`
	LatestStateKey string `json:"latest_state_key"`
	Name           string `json:"name"`
	StatePoolId    string `json:"state_pool_id"`
}

type TendermintSSyncConfig = struct {
	Api      string `json:"api"`
	Interval int64  `json:"interval"`
}

type Upgrade struct {
	Name            string
	Version         string
	GoVersion       string
	LibwasmVersion  string
	InstallDuration time.Duration
}

type Version struct {
	Name               string `json:"name"`
	RecommendedVersion string `json:"recommended_version"`
	Tag                string `json:"tag"`
}

type VersionsSchema struct {
	Versions []Version `json:"versions"`
}