ethereum_event_vote.go

package keeper

import (
	"encoding/binary"
	"fmt"
	"strconv"

	"github.com/cosmos/cosmos-sdk/store/prefix"
	sdk "github.com/cosmos/cosmos-sdk/types"
	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"

	"github.com/peggyjv/gravity-bridge/module/v2/x/gravity/types"
)

func (k Keeper) recordEventVote(
	ctx sdk.Context,
	event types.EthereumEvent,
	val sdk.ValAddress,
) (*types.EthereumEventVoteRecord, error) {
	// Check that the nonce of this event is exactly one higher than the last nonce stored by this validator.
	// We check the event nonce in processEthereumEvent as well,
	// but checking it here gives individual eth signers a chance to retry,
	// and prevents validators from submitting two claims with the same nonce
	lastEventNonce := k.getLastEventNonceByValidator(ctx, val)
	expectedNonce := lastEventNonce + 1
	if event.GetEventNonce() != expectedNonce {
		return nil, sdkerrors.Wrapf(types.ErrInvalid,
			"non contiguous event nonce expected %v observed %v for validator %v",
			expectedNonce,
			event.GetEventNonce(),
			val,
		)
	}

	// Tries to get an EthereumEventVoteRecord with the same eventNonce and event as the event that was submitted.
	eventVoteRecord := k.GetEthereumEventVoteRecord(ctx, event.GetEventNonce(), event.Hash())

	// If it does not exist, create a new one.
	if eventVoteRecord == nil {
		any, err := types.PackEvent(event)
		if err != nil {
			return nil, err
		}
		eventVoteRecord = &types.EthereumEventVoteRecord{
			Accepted: false,
			Event:    any,
		}
	}

	// Add the validator's vote to this EthereumEventVoteRecord
	eventVoteRecord.Votes = append(eventVoteRecord.Votes, val.String())

	k.setEthereumEventVoteRecord(ctx, event.GetEventNonce(), event.Hash(), eventVoteRecord)
	k.setLastEventNonceByValidator(ctx, val, event.GetEventNonce())

	return eventVoteRecord, nil
}

// TryEventVoteRecord checks if an event vote record has enough votes to be applied to the consensus state
// and has not already been marked Observed, then calls processEthereumEvent to actually apply it to the state,
// and then marks it Observed and emits an event.
func (k Keeper) TryEventVoteRecord(ctx sdk.Context, eventVoteRecord *types.EthereumEventVoteRecord) {
	// If the event vote record has not yet been Observed, sum up the votes and see if it is ready to apply to the state.
	// This conditional stops the event vote record from accidentally being applied twice.
	if !eventVoteRecord.Accepted {
		var event types.EthereumEvent
		if err := k.cdc.UnpackAny(eventVoteRecord.Event, &event); err != nil {
			k.DisableBridge(ctx)
			k.Logger(ctx).Error("TryEventVoteRecord: unpacking packed any")
			return
		}

		// Sum the current powers of all validators who have voted and see if it passes the current threshold
		// TODO: The different integer types and math here needs a careful review
		requiredPower := types.EventVoteRecordPowerThreshold(k.StakingKeeper.GetLastTotalPower(ctx))
		eventVotePower := sdk.NewInt(0)
		for _, validator := range eventVoteRecord.Votes {
			val, _ := sdk.ValAddressFromBech32(validator)

			validatorPower := k.StakingKeeper.GetLastValidatorPower(ctx, val)
			// Add it to the attestation power's sum
			eventVotePower = eventVotePower.Add(sdk.NewInt(validatorPower))
			// If the power of all the validators that have voted on the attestation is higher or equal to the threshold,
			// process the attestation, set Observed to true, and break
			if eventVotePower.GTE(requiredPower) {
				lastEventNonce := k.GetLastObservedEventNonce(ctx)
				// this check is performed at the next level up so this should never happen
				// outside of programmer error.
				if event.GetEventNonce() != lastEventNonce+1 {
					k.DisableBridge(ctx)
					k.Logger(ctx).Error(
						"TryEventVoteRecord: attempting to apply events to state out of order")
					return
				}

				k.setLastObservedEventNonce(ctx, event.GetEventNonce())

				// check that the ethereum block height recorded is lower than the attestation height
				ethWithCosmosHeight := k.GetLastObservedEthereumBlockHeight(ctx)
				if ethWithCosmosHeight.EthereumHeight > event.GetEthereumHeight() {
					// Log the error.
					// While technically this should not happen with the new oracle msg ordering,
					// it could happen that the UpdateHeight msg is ordered before the AttestationVote (if using
					// a load balancer for example) and thus having a higher height recorded in the chain.
					// This should not have critical impact unless the difference between the height recorded
					// exceed TargetEthTxTimeout
					k.Logger(ctx).Error(
						"TryEventVoteRecord: attempting to process events that may have been expired")
				} else {
					k.SetLastObservedEthereumBlockHeight(ctx, event.GetEthereumHeight())
				}

				eventVoteRecord.Accepted = true
				k.setEthereumEventVoteRecord(ctx, event.GetEventNonce(), event.Hash(), eventVoteRecord)

				k.processEthereumEvent(ctx, event)
				ctx.EventManager().EmitEvent(sdk.NewEvent(
					types.EventTypeObservation,
					sdk.NewAttribute(sdk.AttributeKeyModule, types.ModuleName),
					sdk.NewAttribute(types.AttributeKeyEthereumEventType, fmt.Sprintf("%T", event)),
					sdk.NewAttribute(types.AttributeKeyContract, k.getBridgeContractAddress(ctx)),
					sdk.NewAttribute(types.AttributeKeyBridgeChainID, strconv.Itoa(int(k.getBridgeChainID(ctx)))),
					sdk.NewAttribute(types.AttributeKeyEthereumEventVoteRecordID,
						string(types.MakeEthereumEventVoteRecordKey(event.GetEventNonce(), event.Hash()))),
					sdk.NewAttribute(types.AttributeKeyNonce, fmt.Sprint(event.GetEventNonce())),
				))

				break
			}
		}
	} else {
		// We disable the bridge here because this should never happen
		k.DisableBridge(ctx)
		k.Logger(ctx).Error(
			"TryEventVoteRecord: attempting to process observed ethereum event")
		return
	}
}

// processEthereumEvent actually applies the attestation to the consensus state
func (k Keeper) processEthereumEvent(ctx sdk.Context, event types.EthereumEvent) {
	// then execute in a new Tx so that we can store state on failure
	xCtx, commit := ctx.CacheContext()
	if err := k.Handle(xCtx, event); err != nil { // execute with a transient storage
		// If the attestation fails, something has gone wrong and we can't recover it. Disable the bridge,
		// log the error and move on
		// The attestation will still be marked "Observed", and validators can still be slashed for not
		// having voted for it.
		k.DisableBridge(ctx)
		k.Logger(ctx).Error(
			"ethereum event vote record failed",
			"cause", err.Error(),
			"event type", fmt.Sprintf("%T", event),
			"id", types.MakeEthereumEventVoteRecordKey(event.GetEventNonce(), event.Hash()),
			"nonce", fmt.Sprint(event.GetEventNonce()),
		)
	} else {
		ctx.EventManager().EmitEvents(xCtx.EventManager().Events()) // copy events to original context
		commit()                                                    // persist transient storage
	}
}

// setEthereumEventVoteRecord sets the attestation in the store
func (k Keeper) setEthereumEventVoteRecord(ctx sdk.Context, eventNonce uint64, claimHash []byte, eventVoteRecord *types.EthereumEventVoteRecord) {
	ctx.KVStore(k.storeKey).Set(types.MakeEthereumEventVoteRecordKey(eventNonce, claimHash), k.cdc.MustMarshal(eventVoteRecord))
}

// GetEthereumEventVoteRecord return a vote record given a nonce
func (k Keeper) GetEthereumEventVoteRecord(ctx sdk.Context, eventNonce uint64, claimHash []byte) *types.EthereumEventVoteRecord {
	if bz := ctx.KVStore(k.storeKey).Get(types.MakeEthereumEventVoteRecordKey(eventNonce, claimHash)); bz == nil {
		return nil
	} else {
		var out types.EthereumEventVoteRecord
		k.cdc.MustUnmarshal(bz, &out)
		return &out
	}
}

// DeleteEthereumEventVoteRecord deletes a vote record
func (k Keeper) DeleteEthereumEventVoteRecord(ctx sdk.Context, eventVoteRecord *types.EthereumEventVoteRecord) {
	event, err := types.UnpackEvent(eventVoteRecord.Event)
	if err != nil {
		k.DisableBridge(ctx)
		k.Logger(ctx).Error(
			fmt.Sprintf("DeleteEthereumEventVoteRecord: couldn't cast to event: %s", err))
		return
	}
	ctx.KVStore(k.storeKey).Delete(types.MakeEthereumEventVoteRecordKey(event.GetEventNonce(), event.Hash()))
}

// GetEthereumEventVoteRecordMapping returns a mapping of eventnonce -> attestations at that nonce
func (k Keeper) GetEthereumEventVoteRecordMapping(ctx sdk.Context) (out map[uint64][]*types.EthereumEventVoteRecord) {
	out = make(map[uint64][]*types.EthereumEventVoteRecord)
	k.iterateEthereumEventVoteRecords(ctx, func(key []byte, eventVoteRecord *types.EthereumEventVoteRecord) bool {
		event, err := types.UnpackEvent(eventVoteRecord.Event)
		if err != nil {
			panic(err)
		}
		if val, ok := out[event.GetEventNonce()]; !ok {
			out[event.GetEventNonce()] = []*types.EthereumEventVoteRecord{eventVoteRecord}
		} else {
			out[event.GetEventNonce()] = append(val, eventVoteRecord)
		}
		return false
	})
	return
}

// iterateEthereumEventVoteRecords iterates through all attestations
func (k Keeper) iterateEthereumEventVoteRecords(ctx sdk.Context, cb func([]byte, *types.EthereumEventVoteRecord) bool) {
	store := prefix.NewStore(ctx.KVStore(k.storeKey), []byte{types.EthereumEventVoteRecordKey})
	iter := store.Iterator(nil, nil)
	defer iter.Close()
	for ; iter.Valid(); iter.Next() {
		att := &types.EthereumEventVoteRecord{}
		k.cdc.MustUnmarshal(iter.Value(), att)
		// cb returns true to stop early
		if cb(iter.Key(), att) {
			return
		}
	}
}

// GetLastObservedEventNonce returns the latest observed event nonce
func (k Keeper) GetLastObservedEventNonce(ctx sdk.Context) uint64 {
	store := ctx.KVStore(k.storeKey)
	bytes := store.Get([]byte{types.LastObservedEventNonceKey})

	if len(bytes) == 0 {
		return 0
	}
	return binary.BigEndian.Uint64(bytes)
}

// GetLastObservedEthereumBlockHeight height gets the block height to of the last observed attestation from
// the store
func (k Keeper) GetLastObservedEthereumBlockHeight(ctx sdk.Context) types.LatestEthereumBlockHeight {
	store := ctx.KVStore(k.storeKey)
	bytes := store.Get([]byte{types.LastEthereumBlockHeightKey})

	if len(bytes) == 0 {
		return types.LatestEthereumBlockHeight{
			CosmosHeight:   0,
			EthereumHeight: 0,
		}
	}
	height := types.LatestEthereumBlockHeight{}
	k.cdc.MustUnmarshal(bytes, &height)
	return height
}

// SetLastObservedEthereumBlockHeight sets the block height in the store.
func (k Keeper) SetLastObservedEthereumBlockHeight(ctx sdk.Context, ethereumHeight uint64) {
	k.SetLastObservedEthereumBlockHeightWithCosmos(ctx, ethereumHeight, uint64(ctx.BlockHeight()))
}

// SetLastObservedEthereumBlockHeight sets the block height in the store, specifying the cosmos height
func (k Keeper) SetLastObservedEthereumBlockHeightWithCosmos(ctx sdk.Context, ethereumHeight uint64, cosmosHeight uint64) {
	store := ctx.KVStore(k.storeKey)
	height := types.LatestEthereumBlockHeight{
		EthereumHeight: ethereumHeight,
		CosmosHeight:   cosmosHeight,
	}
	store.Set([]byte{types.LastEthereumBlockHeightKey}, k.cdc.MustMarshal(&height))
}

// setLastObservedEventNonce sets the latest observed event nonce
func (k Keeper) setLastObservedEventNonce(ctx sdk.Context, nonce uint64) {
	store := ctx.KVStore(k.storeKey)
	store.Set([]byte{types.LastObservedEventNonceKey}, sdk.Uint64ToBigEndian(nonce))
}

// getLastEventNonceByValidator returns the latest event nonce for a given validator
func (k Keeper) getLastEventNonceByValidator(ctx sdk.Context, validator sdk.ValAddress) uint64 {
	store := ctx.KVStore(k.storeKey)
	bytes := store.Get(types.MakeLastEventNonceByValidatorKey(validator))

	if len(bytes) == 0 {
		// in the case that we have no existing value this is the first
		// time a validator is submitting a claim. Since we don't want to force
		// them to replay the entire history of all events ever we can't start
		// at zero
		//
		// We return the LastObservedEventNonce
		lowestObserved := k.GetLastObservedEventNonce(ctx)

		// return the latest event minus one so that the validator
		// can submit that event and avoid slashing. special case
		// for zero
		if lowestObserved > 0 {
			return lowestObserved - 1
		}
		return 0
	}
	return binary.BigEndian.Uint64(bytes)
}

// setLastEventNonceByValidator sets the latest event nonce for a give validator
func (k Keeper) setLastEventNonceByValidator(ctx sdk.Context, validator sdk.ValAddress, nonce uint64) {
	store := ctx.KVStore(k.storeKey)
	store.Set(types.MakeLastEventNonceByValidatorKey(validator), sdk.Uint64ToBigEndian(nonce))
}