tee

type Amount big.Int

type Balance struct {
	Epoch   Epoch          `json:"epoch"`   // sol: uint64
	Account common.Address `json:"account"` // sol: address
	Value   *Amount        `json:"value"`   // sol: uint256
}

type BalanceProof struct {
	Balance Balance `json:"balance"`
	Sig     Sig     `json:"sig"`
}

type Block struct {
	types.Block
	Receipts types.Receipts
}

type DepositProof struct {
	Balance Balance `json:"balance"`
	Sig     Sig     `json:"sig"`
}

type Enclave interface {
	// Init initializes the enclave, generating a new secp256k1 ECDSA key and
	// storing it as the enclave's signing key.
	//
	// It returns the public key derived Ethereum address and attestation of
	// correct initialization of the enclave with the generated address. The
	// attestation can be used to verify the enclave with the TEE vendor.
	//
	// The Operator must deploy the contract with the Enclave's address after
	// calling Init.
	Init() (common.Address, []byte, error)

	// Run should be called by the operator after they deployed the contract to
	// start the Enclave with the given parameters. The call blocks until the
	// Enclave has shut down. It can be told to gracefully shutdown by calling
	// Shutdown.
	//
	// The Enclave verifies the parameters upon receival of the first block.
	Run(Parameters) error

	// ProcessBlocks should be called by the Operator to cause the enclave to
	// process the given block(s), logging deposits and exits.
	//
	// Note that BalanceProofs requires an additional k blocks to be known to
	// the Enclave before it reveals an epoch's balance proofs to the operator.
	// k is a security parameter to guarantee enough PoW depth.
	ProcessBlocks(...*Block) error

	// ProcessTXs should be called by the Operator whenever they receive new
	// transactions from users. After a transaction epoch has finished and an
	// additional k blocks made known to the Enclave, the epoch's balance proofs
	// can be received by calling BalanceProofs.
	ProcessTXs(...*Transaction) error

	// DepositProofs returns the deposit proofs of all deposits made in an epoch
	// at the end of the deposit phase.
	//
	// Note that all blocks of the epoch's deposit phase (+k) need to be known
	// to the Enclave. This call blocks until all necessary blocks are received
	// and processed.
	//
	// It should be called in a loop by the operator.
	DepositProofs() ([]*DepositProof, error)

	// BalanceProofs returns all balance proofs at the end of each transaction
	// phase.
	//
	// Note that all blocks of the epoch's transaction phase (+k) need to be
	// known to the Enclave. This call blocks until all necessary blocks are
	// received and processed.
	//
	// It should be called in a loop by the operator.
	BalanceProofs() ([]*BalanceProof, error)

	// Shutdown signals the Enclave to gracefully shutdown after the next phase
	// is sealed. It will continue receiving transactions and blocks until the
	// last block of the current phase is received via ProcessBlocks.
	//
	// The functions ProcessBlocks, ProcessTXs, DepositProofs and BalanceProofs
	// will return an ErrEnclaveStopped error after the Enclave shut down.
	// The operator should test for this error in their loops around those
	// functions.
	Shutdown()
}

type Epoch = uint64

type Parameters struct {
	PowDepth         uint64         // required confirmed block depth
	PhaseDuration    uint64         // number of blocks of one phase (not epoch)
	ResponseDuration uint64         // challenge response grace period for operator at end of exit phase
	InitBlock        uint64         // block at which Erdstall contract was deployed
	TEE              common.Address // Enclave's public key address
	Contract         common.Address // Erdstall contract address
}

type Sig []byte

type TextSigner interface {
	// SignText returns a signature with 'v' value of 0 or 1.
	SignText(account accounts.Account, text []byte) ([]byte, error)
}

type Transaction struct {
	Nonce     uint64         `json:"nonce"` // starts at 0, each tx must increase by one, across epochs
	Epoch     Epoch          `json:"epoch"`
	Sender    common.Address `json:"sender"`
	Recipient common.Address `json:"recipient"`
	Amount    *Amount        `json:"amount"`
	Sig       Sig            `json:"sig"`
	// contains filtered or unexported fields
}

type Transactor interface {
	Send(*Transaction) error
}