common

type AttestationReport struct {
	Report      []byte         // the signed bytes of the report which includes some encrypted identifying data
	PubKey      []byte         // a public key that can be used to send encrypted data back to the TEE securely (should only be used once Report has been verified)
	Owner       common.Address // address identifying the owner of the TEE which signed this report, can also be verified from the encrypted Report data
	HostAddress string         // the IP address on which the host can be contacted by other Obscuro hosts for peer-to-peer communication
}

type BatchHeader struct {
	ParentHash       L2BatchHash    `json:"parentHash"`
	Root             StateRoot      `json:"stateRoot"`
	TxHash           common.Hash    `json:"transactionsRoot"`
	ReceiptHash      common.Hash    `json:"receiptsRoot"`
	Number           *big.Int       `json:"number"`           // height of the batch
	SequencerOrderNo *big.Int       `json:"sequencerOrderNo"` // multiple batches can be created with the same height in case of L1 reorgs. The sequencer is responsible for including all of them in the rollups.
	GasLimit         uint64         `json:"gasLimit"`
	GasUsed          uint64         `json:"gasUsed"`
	Time             uint64         `json:"timestamp"`
	Extra            []byte         `json:"extraData"`
	BaseFee          *big.Int       `json:"baseFee"`
	Coinbase         common.Address `json:"coinbase"`

	// The custom Obscuro fields.
	L1Proof                       L1BlockHash                           `json:"l1Proof"` // the L1 block used by the enclave to generate the current batch
	R, S                          *big.Int                              // signature values
	CrossChainMessages            []MessageBus.StructsCrossChainMessage `json:"crossChainMessages"`
	LatestInboundCrossChainHash   common.Hash                           `json:"inboundCrossChainHash"`   // The block hash of the latest block that has been scanned for cross chain messages.
	LatestInboundCrossChainHeight *big.Int                              `json:"inboundCrossChainHeight"` // The block height of the latest block that has been scanned for cross chain messages.
	TransfersTree                 common.Hash                           `json:"transfersTree"`           // This is a merkle tree of all of the outbound value transfers for the MainNet
}

type BatchListingResponse struct {
	BatchesData []PublicBatch
	Total       uint64
}

type BatchRequest struct {
	Requester string   // The address of the requester, used to direct the response
	FromSeqNo *big.Int // The requester's view of the current head seq no, or nil if they haven't stored any batches.
}

type BlockAndReceipts struct {
	Block       *types.Block
	ReceiptsMap map[int]*types.Receipt // sparse map with obscuro-relevant receipts in it
	Receipts    *types.Receipts
	// contains filtered or unexported fields
}

type BlockListingResponse struct {
	BlocksData []PublicBlock
	Total      uint64
}

type BlockSubmissionResponse struct {
	ProducedSecretResponses []*ProducedSecretResponse // The responses to any secret requests in the ingested L1 block.
	RejectError             *errutil.BlockRejectError // If block was rejected, contains information about what block to submit next.
}

type CalldataRollupHeader struct {
	FirstBatchSequence    *big.Int
	FirstCanonBatchHeight *big.Int
	FirstCanonParentHash  L2BatchHash

	Coinbase common.Address
	BaseFee  *big.Int
	GasLimit uint64

	StartTime       uint64
	BatchTimeDeltas [][]byte // todo - minimize assuming a default of 1 sec and then store only exceptions

	L1HeightDeltas [][]byte // delta of the block height. Stored as a byte array because rlp can't encode negative numbers

	ReOrgs [][]byte `rlp:"optional"` // sparse list of reorged headers - non null only for reorgs.
}

type ChainFork struct {
	NewCanonical *types.Block
	OldCanonical *types.Block

	CommonAncestor   *types.Block
	CanonicalPath    []L1BlockHash
	NonCanonicalPath []L1BlockHash
}

type CrossChainMessage = MessageBus.StructsCrossChainMessage

type CrossChainMessages = []CrossChainMessage

type Enclave interface {
	EnclaveScan

	// Status checks whether the enclave is ready to process requests - only implemented by the RPC layer
	Status() (Status, SystemError)

	// Attestation - Produces an attestation report which will be used to request the shared secret from another enclave.
	Attestation() (*AttestationReport, SystemError)

	// GenerateSecret - the genesis enclave is responsible with generating the secret entropy
	GenerateSecret() (EncryptedSharedEnclaveSecret, SystemError)

	// InitEnclave - initialise an enclave with a seed received by another enclave
	InitEnclave(secret EncryptedSharedEnclaveSecret) SystemError

	// SubmitL1Block - Used for the host to submit L1 blocks to the enclave, these may be:
	//  a. historic block - if the enclave is behind and in the process of catching up with the L1 state
	//  b. the latest block published by the L1, to which the enclave should respond with a rollup
	// It is the responsibility of the host to gossip the returned rollup
	// For good functioning the caller should always submit blocks ordered by height
	// submitting a block before receiving ancestors of it, will result in it being ignored
	SubmitL1Block(block L1Block, receipts L1Receipts, isLatest bool) (*BlockSubmissionResponse, SystemError)

	// SubmitTx - user transactions
	SubmitTx(tx EncryptedTx) (*responses.RawTx, SystemError)

	// SubmitBatch submits a batch received from the sequencer for processing.
	SubmitBatch(batch *ExtBatch) SystemError

	// ObsCall - Execute a smart contract to retrieve data. The equivalent of "Eth_call"
	// Todo - return the result with a block delay. To prevent frontrunning.
	ObsCall(encryptedParams EncryptedParamsCall) (*responses.Call, SystemError)

	// GetTransactionCount returns the nonce of the wallet with the given address (encrypted with the acc viewing key)
	GetTransactionCount(encryptedParams EncryptedParamsGetTxCount) (*responses.TxCount, SystemError)

	// Stop gracefully stops the enclave
	Stop() SystemError

	// GetTransaction returns a transaction in JSON format, encrypted with the viewing key for the transaction's `from` field.
	GetTransaction(encryptedParams EncryptedParamsGetTxByHash) (*responses.TxByHash, SystemError)

	// GetTransactionReceipt returns a transaction receipt given its signed hash, or nil if the transaction is unknown
	GetTransactionReceipt(encryptedParams EncryptedParamsGetTxReceipt) (*responses.TxReceipt, SystemError)

	// GetBalance returns the balance of the address on the Obscuro network, encrypted with the viewing key for the
	// address.
	GetBalance(encryptedParams EncryptedParamsGetBalance) (*responses.Balance, SystemError)

	// GetCode returns the code stored at the given address in the state for the given rollup hash.
	GetCode(address gethcommon.Address, rollupHash *gethcommon.Hash) ([]byte, SystemError)

	// Subscribe adds a log subscription to the enclave under the given ID, provided the request is authenticated
	// correctly. The events will be populated in the BlockSubmissionResponse. If there is an existing subscription
	// with the given ID, it is overwritten.
	Subscribe(id rpc.ID, encryptedParams EncryptedParamsLogSubscription) SystemError

	// Unsubscribe removes the log subscription with the given ID from the enclave. If there is no subscription with
	// the given ID, nothing is deleted.
	Unsubscribe(id rpc.ID) SystemError

	// StopClient stops the enclave client if one exists - only implemented by the RPC layer
	StopClient() SystemError

	// EstimateGas tries to estimate the gas needed to execute a specific transaction based on the pending state.
	EstimateGas(encryptedParams EncryptedParamsEstimateGas) (*responses.Gas, SystemError)

	// GetLogs returns all the logs matching the filter.
	GetLogs(encryptedParams EncryptedParamsGetLogs) (*responses.Logs, SystemError)

	// HealthCheck returns whether the enclave is in a healthy state
	HealthCheck() (bool, SystemError)

	// GetBatch - retrieve a batch if existing within the enclave db.
	GetBatch(hash L2BatchHash) (*ExtBatch, SystemError)

	// GetBatchBySeqNo - retrieve batch by sequencer number if it's in the db
	GetBatchBySeqNo(seqNo uint64) (*ExtBatch, SystemError)

	// CreateBatch - creates a new head batch extending the previous one for the latest known L1 head if the node is
	// a sequencer. Will panic otherwise.
	CreateBatch(skipIfEmpty bool) SystemError

	// CreateRollup - will create a new rollup by going through the sequencer if the node is a sequencer
	// or panic otherwise.
	CreateRollup(fromSeqNo uint64) (*ExtRollup, SystemError)

	// DebugTraceTransaction returns the trace of a transaction
	DebugTraceTransaction(hash gethcommon.Hash, config *tracers.TraceConfig) (json.RawMessage, SystemError)

	// StreamL2Updates - will stream any new batches as they are created/detected
	// All will be queued in the channel that has been returned.
	StreamL2Updates() (chan StreamL2UpdatesResponse, func())
	// DebugEventLogRelevancy returns the logs of a transaction
	DebugEventLogRelevancy(hash gethcommon.Hash) (json.RawMessage, SystemError)
}

type EnclaveScan interface {
	// GetTotalContractCount returns the total number of contracts that have been deployed
	GetTotalContractCount() (*big.Int, SystemError)

	// GetCustomQuery returns the data of a custom query
	GetCustomQuery(encryptedParams EncryptedParamsGetStorageAt) (*responses.PrivateQueryResponse, SystemError)

	// GetPublicTransactionData returns a list of public transaction data
	GetPublicTransactionData(pagination *QueryPagination) (*TransactionListingResponse, SystemError)
}

type EncodedAttestationReport []byte

type EncodedBatchMsg []byte

type EncodedBatchRequest []byte

type EncodedL1Block []byte

type EncodedRollup []byte

type EncryptedParamsCall []byte // As above, but for an RPC call request.

type EncryptedParamsEstimateGas []byte // As above, but for an RPC estimateGas request.

type EncryptedParamsGetBalance []byte // The params for an RPC getBalance request, as a JSON object encrypted with the public key of the enclave.

type EncryptedParamsGetLogs []byte // As above, but for an RPC getLogs request.

type EncryptedParamsGetStorageAt []byte

type EncryptedParamsGetTxByHash []byte // As above, but for an RPC getTransactionByHash request.

type EncryptedParamsGetTxCount []byte // As above, but for an RPC getTransactionCount request.

type EncryptedParamsGetTxReceipt []byte // As above, but for an RPC getTransactionReceipt request.

type EncryptedParamsLogSubscription []byte // As above, but for an RPC logs subscription request.

type EncryptedParamsSendRawTx []byte // As above, but for an RPC sendRawTransaction request.

type EncryptedSharedEnclaveSecret []byte

type EncryptedSubscriptionLogs = map[rpc.ID][]byte

type EncryptedTransactions []byte // A blob of encrypted transactions, as they're stored in the rollup, with the nonce prepended.

type EncryptedTx []byte // A single transaction, encoded as a JSON list of transaction binary hexes and encrypted using the enclave's public key

type ExtBatch struct {
	Header *BatchHeader
	// todo - remove
	TxHashes        []TxHash // The hashes of the transactions included in the batch.
	EncryptedTxBlob EncryptedTransactions
	// contains filtered or unexported fields
}

type ExtRollup struct {
	Header               *RollupHeader // the fields required by the management contract
	CalldataRollupHeader []byte        // encrypted header useful for recreating the batches
	BatchPayloads        []byte        // The transactions included in the rollup, in external/encrypted form.
	// contains filtered or unexported fields
}

type FilterCriteriaJSON struct {
	BlockHash *common.Hash     `json:"blockHash"`
	FromBlock *rpc.BlockNumber `json:"fromBlock"`
	ToBlock   *rpc.BlockNumber `json:"toBlock"`
	Addresses interface{}      `json:"address"`
	Topics    []interface{}    `json:"topics"`
}

type FinalityType string

type IDAndEncLog struct {
	SubID  rpc.ID
	EncLog []byte
}

type IDAndLog struct {
	SubID rpc.ID
	Log   *types.Log
}

type L1Address = common.Address

type L1Block = types.Block

type L1BlockHash = common.Hash

type L1Receipt = types.Receipt

type L1Receipts = types.Receipts

type L1Transaction = types.Transaction

type L2Address = common.Address

type L2BatchHash = common.Hash

type L2Receipt = types.Receipt

type L2Receipts = types.Receipts

type L2RollupHash = common.Hash

type L2Transactions = types.Transactions

type L2Tx = types.Transaction

type L2TxHash = common.Hash

type Latency func() time.Duration

type LogSubscription struct {
	// The account the events relate to.
	Account *common.Address

	// A signature over the account address using a private viewing key. Prevents attackers from subscribing to
	// (encrypted) logs for other accounts to see the pattern of logs.
	// todo - this does not protect against replay attacks, where someone resends an intercepted subscription request.
	Signature []byte

	// PublicViewingKey stores the viewing key used for this subscription
	PublicViewingKey []byte

	// A subscriber-defined filter to apply to the stream of logs.
	Filter *filters.FilterCriteria

	// Handles the viewing key encryption
	VkHandler *vkhandler.VKHandler
}

type NodeType int

type Nonce = uint64

type ObscuroNetworkInfo struct {
	ManagementContractAddress common.Address
	L1StartHash               common.Hash
	SequencerID               common.Address
	MessageBusAddress         common.Address
}

type PrivateCustomQueryListTransactions struct {
	Address    common.Address  `json:"address"`
	Pagination QueryPagination `json:"pagination"`
}

type PrivateQueryResponse struct {
	Receipts types.Receipts
	Total    uint64
}

type ProducedSecretResponse struct {
	Secret      []byte
	RequesterID gethcommon.Address
	HostAddress string
}

type PublicBatch struct {
	BatchHeader
}

type PublicBlock struct {
	BlockHeader types.Header `json:"blockHeader"`
	RollupHash  common.Hash  `json:"rollupHash"`
}

type PublicTransaction struct {
	TransactionHash TxHash
	BatchHeight     *big.Int
	Finality        FinalityType
}

type QueryPagination struct {
	Offset uint64
	Size   uint
}

type RollupHeader struct {
	Coinbase          common.Address
	CompressionL1Head L1BlockHash // the l1 block that the sequencer considers canonical at the time when this rollup is created

	CrossChainMessages []MessageBus.StructsCrossChainMessage `json:"crossChainMessages"`

	PayloadHash common.Hash // The hash of the compressed batches. TODO
	R, S        *big.Int    // signature values

	LastBatchSeqNo uint64
}

type StateRoot = common.Hash

type Status struct {
	StatusCode StatusCode
	L1Head     gethcommon.Hash
	L2Head     *big.Int
}

type StatusCode int

type StreamL2UpdatesResponse struct {
	Batch *ExtBatch
	Logs  EncryptedSubscriptionLogs
}

type SystemError interface {
	Error() string
}

type TransactionListingResponse struct {
	TransactionsData []PublicTransaction
	Total            uint64
}

type TxHash = common.Hash

type ValueTransferEvent struct {
	Sender   common.Address
	Receiver common.Address
	Amount   *big.Int
}

type ValueTransferEvents = []ValueTransferEvent