types.go

package common

import (
	"fmt"
	"math/big"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ten-protocol/go-ten/contracts/generated/MessageBus"
	"github.com/ten-protocol/go-ten/lib/gethfork/rpc"
)

type (
	StateRoot = common.Hash
	TxHash    = common.Hash

	// EncryptedSubscriptionLogs - Alias for the event subscription updates going
	// out of the enclave.
	EncryptedSubscriptionLogs = map[rpc.ID][]byte

	// StreamL2UpdatesResponse - the struct encoded for each response message
	// when streaming batches out of the enclave.
	// The properties inside need to be encrypted according to the privacy rules.
	StreamL2UpdatesResponse struct {
		Batch *ExtBatch
		Logs  EncryptedSubscriptionLogs
	}

	// MainNet aliases
	L1Address     = common.Address
	L1BlockHash   = common.Hash
	L1Block       = types.Block
	L1Transaction = types.Transaction
	L1Receipt     = types.Receipt
	L1Receipts    = types.Receipts

	// Local Obscuro aliases
	L2BatchHash              = common.Hash
	L2RollupHash             = common.Hash
	L2TxHash                 = common.Hash
	L2Tx                     = types.Transaction
	L2Transactions           = types.Transactions
	L2Address                = common.Address
	L2Receipt                = types.Receipt
	L2Receipts               = types.Receipts
	SerializedCrossChainTree = []byte

	L2PricedTransaction struct {
		Tx             *L2Tx
		PublishingCost *big.Int
	}
	L2PricedTransactions []L2PricedTransaction

	CrossChainMessage  = MessageBus.StructsCrossChainMessage
	CrossChainMessages = []CrossChainMessage
	ValueTransferEvent struct {
		Sender   common.Address
		Receiver common.Address
		Amount   *big.Int
		Sequence uint64
	}
	ValueTransferEvents   = []ValueTransferEvent
	EncryptedTx           []byte // A single transaction, encoded as a JSON list of transaction binary hexes and encrypted using the enclave's public key
	EncryptedTransactions []byte // A blob of encrypted transactions, as they're stored in the rollup, with the nonce prepended.

	EncryptedParamsGetBalance              []byte // The params for an RPC getBalance request, as a JSON object encrypted with the public key of the enclave.
	EncryptedParamsCall                    []byte // As above, but for an RPC call request.
	EncryptedParamsGetTxByHash             []byte // As above, but for an RPC getTransactionByHash request.
	EncryptedParamsGetTxReceipt            []byte // As above, but for an RPC getTransactionReceipt request.
	EncryptedParamsLogSubscription         []byte // As above, but for an RPC logs subscription request.
	EncryptedParamsDebugLogRelevancy       []byte // As above, but for an RPC the relevancy call.
	EncryptedParamsSendRawTx               []byte // As above, but for an RPC sendRawTransaction request.
	EncryptedParamsGetTxCount              []byte // As above, but for an RPC getTransactionCount request.
	EncryptedParamsEstimateGas             []byte // As above, but for an RPC estimateGas request.
	EncryptedParamsGetLogs                 []byte // As above, but for an RPC getLogs request.
	EncryptedParamsGetPersonalTransactions []byte
	EncryptedParamsGetStorageSlot          []byte

	Nonce               = uint64
	EncodedRollup       []byte
	EncodedBatchMsg     []byte
	EncodedBatchRequest []byte
	EncodedBlobHashes   []byte

	EnclaveID = common.Address
)

func (txs L2PricedTransactions) ToTransactions() types.Transactions {
	ret := make(types.Transactions, 0)
	for _, tx := range txs {
		ret = append(ret, tx.Tx)
	}
	return ret
}

const (
	L2GenesisHeight = uint64(0)
	L1GenesisHeight = uint64(0)
	L2GenesisSeqNo  = uint64(1)
	// HeightCommittedBlocks is the number of blocks deep a transaction must be to be considered safe from reorganisations.
	HeightCommittedBlocks = 15
)

var GethGenesisParentHash = common.Hash{}

// SystemError is the interface for the internal errors generated in the Enclave and consumed by the Host
type SystemError interface {
	Error() string
}

// AttestationReport represents a signed attestation report from a TEE and some metadata about the source of it to verify it
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)
	EnclaveID   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 (
	EncryptedSharedEnclaveSecret []byte
	EncodedAttestationReport     []byte
)

// BlockAndReceipts - a structure that contains a fuller view of a block. It allows iterating over the
// successful transactions, using the receipts. The receipts are bundled in the host node and thus verification
// is performed over their correctness.
// To work properly, all of the receipts are required, due to rlp encoding pruning some of the information.
// The receipts must also be in the correct order.
type BlockAndReceipts struct {
	BlockHeader            *types.Header
	TxsWithReceipts        []*TxAndReceiptAndBlobs
	successfulTransactions *types.Transactions
}

// ParseBlockAndReceipts - will create a container struct that has preprocessed the receipts
// and verified if they indeed match the receipt root hash in the block.
func ParseBlockAndReceipts(block *types.Header, receiptsAndBlobs []*TxAndReceiptAndBlobs) (*BlockAndReceipts, error) {
	br := BlockAndReceipts{
		BlockHeader:     block,
		TxsWithReceipts: receiptsAndBlobs,
	}

	return &br, nil
}

func (br *BlockAndReceipts) Receipts() L1Receipts {
	rec := make(L1Receipts, 0)
	for _, txsWithReceipt := range br.TxsWithReceipts {
		rec = append(rec, txsWithReceipt.Receipt)
	}
	return rec
}

// RelevantTransactions - returns slice containing only the transactions that have receipts with successful status.
func (br *BlockAndReceipts) RelevantTransactions() *types.Transactions {
	if br.successfulTransactions != nil {
		return br.successfulTransactions
	}

	st := make(types.Transactions, 0)
	for _, tx := range br.TxsWithReceipts {
		if tx.Receipt.Status == types.ReceiptStatusSuccessful {
			st = append(st, tx.Tx)
		}
	}
	br.successfulTransactions = &st
	return br.successfulTransactions
}

// ChainFork - represents the result of walking the chain when processing a fork
type ChainFork struct {
	NewCanonical *types.Header
	OldCanonical *types.Header

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

func (cf *ChainFork) IsFork() bool {
	return len(cf.NonCanonicalPath) > 0
}

func (cf *ChainFork) String() string {
	if cf == nil {
		return ""
	}
	return fmt.Sprintf("ChainFork{NewCanonical: %s, OldCanonical: %s, CommonAncestor: %s, CanonicalPath: %s, NonCanonicalPath: %s}",
		cf.NewCanonical.Hash(), cf.OldCanonical.Hash(), cf.CommonAncestor.Hash(), cf.CanonicalPath, cf.NonCanonicalPath)
}