ethadapter

type APIBlobData struct {
	VersionedHash string `json:"versionedHash"`
	Commitment    string `json:"commitment"`
	Proof         string `json:"proof"`
	Data          string `json:"data"`
}

type APIConfigResponse struct {
	Data ReducedConfigData `json:"data"`
}

type APIGenesisResponse struct {
	Data ReducedGenesisData `json:"data"`
}

type APIGetBlobSidecarsResponse struct {
	Data []*BlobSidecar `json:"data"`
}

type APIVersionResponse struct {
	Data VersionInformation `json:"data"`
}

type ArchivalBlobResponse struct {
	Blob APIBlobData `json:"blob"`
}

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

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

type BeaconClient interface {
	NodeVersion(ctx context.Context) (string, error)
	ConfigSpec(ctx context.Context) (APIConfigResponse, error)
	BeaconGenesis(ctx context.Context) (APIGenesisResponse, error)
	BeaconBlobSidecars(ctx context.Context, slot uint64, hashes []gethcommon.Hash) (APIGetBlobSidecarsResponse, error)
}

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

type BlobHasher interface {
	BlobHash(blob *kzg4844.Blob) (gethcommon.Hash, kzg4844.Commitment, kzg4844.Proof, error)
}

type BlobRetrievalService interface {
	BeaconBlobSidecars(ctx context.Context, slot uint64, hashes []gethcommon.Hash) (APIGetBlobSidecarsResponse, error)
}

type BlobSidecar struct {
	// Blob is the actual blob data, a large byte array (up to 128 KB) that contains the off-chain data
	Blob kzg4844.Blob `json:"blob"`

	// Index is the position of this blob within the transaction's blob array
	// It's represented as a string to accommodate uint64 values in JSON
	Index Uint64String `json:"index"`

	// KZGCommitment is a cryptographic commitment to the blob content
	// This is what the EVM sees and uses to verify blob availability without accessing the full blob data
	// It's significantly smaller than the blob itself, reducing on-chain storage requirements
	KZGCommitment Bytes48 `json:"kzg_commitment"`

	// KZGProof is a zero-knowledge proof that allows verification of small portions of the blob
	// without needing the entire blob data
	// It's used to prove that the commitment corresponds to the actual blob data
	KZGProof Bytes48 `json:"kzg_proof"`
}

type Bytes32 [32]byte

type Bytes48 [48]byte

type ClientPool[T any] struct {
	// contains filtered or unexported fields
}

type EthClient interface {
	BlockNumber() (uint64, error)                                                 // retrieves the number of the head block
	FetchHeadBlock() (*types.Header, error)                                       // retrieves the block at head height
	HeaderByHash(id gethcommon.Hash) (*types.Header, error)                       // retrieves a block header given a hash
	BlockByHash(id gethcommon.Hash) (*types.Block, error)                         // retrieves a block given a hash
	HeaderByNumber(n *big.Int) (*types.Header, error)                             // retrieves a block given a number - returns head block if n is nil
	SendTransaction(signedTx *types.Transaction) error                            // issues an ethereum transaction (expects signed tx)
	TransactionReceipt(hash gethcommon.Hash) (*types.Receipt, error)              // fetches the ethereum transaction receipt
	TransactionByHash(hash gethcommon.Hash) (*types.Transaction, bool, error)     // fetches the ethereum tx
	Nonce(address gethcommon.Address) (uint64, error)                             // fetches the account nonce to use in the next transaction
	BalanceAt(account gethcommon.Address, blockNumber *big.Int) (*big.Int, error) // fetches the balance of the account
	GetLogs(q ethereum.FilterQuery) ([]types.Log, error)                          // fetches the logs for a given query
	CallContract(msg ethereum.CallMsg) ([]byte, error)                            // Runs the provided call message on the latest block.
	SuggestGasTipCap(ctx context.Context) (*big.Int, error)                       // Suggests the gas tip cap
	EthClient() *ethclient.Client                                                 // returns the underlying eth client
	EstimateGas(ctx context.Context, call ethereum.CallMsg) (uint64, error)       // estimates the gas for a given call
	BlockListener() (chan *types.Header, ethereum.Subscription)                   // subscribes to new blocks and returns a listener with the blocks heads and the subscription handler
	ReconnectIfClosed() error                                                     // closes and creates a new connection
	Alive() bool                                                                  // returns whether the connection is live or not
	Info() Info                                                                   // retrieves the node Info
	Stop()                                                                        // tries to cleanly stop the client and release any resources
	SupportsEventLogs() bool                                                      // returns false for the in-mem simulation

	// todo - all the below should be removed from the interface
	FetchLastBatchSeqNo(address gethcommon.Address) (*big.Int, error)
}

type Info struct {
	L2ID gethcommon.Address // the address of the Obscuro node this client is dedicated to
}

type KZGToVersionedHasher struct{}

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

type ReducedConfigData struct {
	SecondsPerSlot Uint64String `json:"SECONDS_PER_SLOT"`
}

type ReducedGenesisData struct {
	GenesisTime Uint64String `json:"genesis_time"`
}

type TimeToSlot func(timestamp uint64) (uint64, error)

type Uint64String uint64

type VersionInformation struct {
	Version string `json:"version"`
}