Version abstraction part 2

core/services/metatx/integration_test.go

@@ -26,7 +26,6 @@ import (
 	"github.com/smartcontractkit/chainlink/v2/core/internal/testutils"
 	"github.com/smartcontractkit/chainlink/v2/core/services/keystore/keys/ethkey"
 	"github.com/smartcontractkit/chainlink/v2/core/services/metatx"
-	"github.com/smartcontractkit/chainlink/v2/core/services/ocr2/plugins/ccip/abihelpers"
 	"github.com/smartcontractkit/chainlink/v2/core/services/ocr2/plugins/ccip/testhelpers"
 	integrationtesthelpers "github.com/smartcontractkit/chainlink/v2/core/services/ocr2/plugins/ccip/testhelpers/integration"
 )
@@ -235,7 +234,7 @@ merge [type=merge left="{}" right="{\\\"%s\\\":$(link_parse), \\\"%s\\\":$(eth_p
 
 		executionLogs := ccipContracts.AllNodesHaveExecutedSeqNums(t, geCurrentSeqNum, geCurrentSeqNum)
 		assert.Len(t, executionLogs, 1)
-		ccipContracts.AssertExecState(t, executionLogs[0], abihelpers.ExecutionStateSuccess)
+		ccipContracts.AssertExecState(t, executionLogs[0], testhelpers.ExecutionStateSuccess)
 
 		// source token is locked in the token pool
 		lockedTokenBal, err := sourceToken.BalanceOf(nil, sourcePoolAddress)

core/services/ocr2/plugins/ccip/abihelpers/abi_helpers.go

@@ -10,101 +10,40 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
 	"github.com/smartcontractkit/libocr/gethwrappers2/ocr2aggregator"
-	"github.com/smartcontractkit/libocr/offchainreporting2plus/types"
 
-	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/commit_store"
-	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/evm_2_evm_offramp"
-	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/price_registry"
 	"github.com/smartcontractkit/chainlink/v2/core/utils"
 )
 
-// MessageExecutionState defines the execution states of CCIP messages.
-type MessageExecutionState uint8
-
-const (
-	ExecutionStateUntouched MessageExecutionState = iota
-	ExecutionStateInProgress
-	ExecutionStateSuccess
-	ExecutionStateFailure
-)
-
-// TODO: Deprecate in favour of version specific types
-var EventSignatures struct {
-	// CommitStore
-	ReportAccepted common.Hash
-	// OffRamp
-	ExecutionStateChanged common.Hash
-	PoolAdded             common.Hash
-	PoolRemoved           common.Hash
-
-	// PriceRegistry
-	UsdPerUnitGasUpdated common.Hash
-	UsdPerTokenUpdated   common.Hash
-	FeeTokenAdded        common.Hash
-	FeeTokenRemoved      common.Hash
-
-	// offset || priceUpdatesOffset || minSeqNum || maxSeqNum || merkleRoot
-	ReportAcceptedMaxSequenceNumberWord int
-	// sig || seqNum || messageId || ...
-	ExecutionStateChangedSequenceNumberIndex int
-}
-
-var (
-	MessageArgs         abi.Arguments
-	TokenAmountsArgs    abi.Arguments
-	CommitReportArgs    abi.Arguments
-	ExecutionReportArgs abi.Arguments
-)
-
-func GetIDOrPanic(name string, abi2 abi.ABI) common.Hash {
+func MustGetEventID(name string, abi2 abi.ABI) common.Hash {
 	event, ok := abi2.Events[name]
 	if !ok {
 		panic(fmt.Sprintf("missing event %s", name))
 	}
 	return event.ID
 }
 
-func init() {
-	commitStoreABI, err := abi.JSON(strings.NewReader(commit_store.CommitStoreABI))
-	if err != nil {
-		panic(err)
-	}
-	EventSignatures.ReportAccepted = GetIDOrPanic("ReportAccepted", commitStoreABI)
-	EventSignatures.ReportAcceptedMaxSequenceNumberWord = 3
-
-	offRampABI, err := abi.JSON(strings.NewReader(evm_2_evm_offramp.EVM2EVMOffRampABI))
-	if err != nil {
-		panic(err)
-	}
-	EventSignatures.ExecutionStateChanged = GetIDOrPanic("ExecutionStateChanged", offRampABI)
-	EventSignatures.ExecutionStateChangedSequenceNumberIndex = 1
-	EventSignatures.PoolAdded = GetIDOrPanic("PoolAdded", offRampABI)
-	EventSignatures.PoolRemoved = GetIDOrPanic("PoolRemoved", offRampABI)
-
-	priceRegistryABI, err := abi.JSON(strings.NewReader(price_registry.PriceRegistryABI))
-	if err != nil {
-		panic(err)
+func MustGetEventInputs(name string, abi2 abi.ABI) abi.Arguments {
+	m, ok := abi2.Events[name]
+	if !ok {
+		panic(fmt.Sprintf("missing event %s", name))
 	}
-	EventSignatures.UsdPerUnitGasUpdated = GetIDOrPanic("UsdPerUnitGasUpdated", priceRegistryABI)
-	EventSignatures.UsdPerTokenUpdated = GetIDOrPanic("UsdPerTokenUpdated", priceRegistryABI)
-	EventSignatures.FeeTokenAdded = GetIDOrPanic("FeeTokenAdded", priceRegistryABI)
-	EventSignatures.FeeTokenRemoved = GetIDOrPanic("FeeTokenRemoved", priceRegistryABI)
-
-	CommitReportArgs = commitStoreABI.Events["ReportAccepted"].Inputs
+	return m.Inputs
+}
 
-	manuallyExecuteMethod, ok := offRampABI.Methods["manuallyExecute"]
+func MustGetMethodInputs(name string, abi2 abi.ABI) abi.Arguments {
+	m, ok := abi2.Methods[name]
 	if !ok {
-		panic("missing event 'manuallyExecute'")
+		panic(fmt.Sprintf("missing method %s", name))
 	}
-	ExecutionReportArgs = manuallyExecuteMethod.Inputs[:1]
+	return m.Inputs
 }
 
-func MessagesFromExecutionReport(report types.Report) ([]evm_2_evm_offramp.InternalEVM2EVMMessage, error) {
-	decodedExecutionReport, err := DecodeExecutionReport(report)
+func MustParseABI(abiStr string) abi.ABI {
+	abiParsed, err := abi.JSON(strings.NewReader(abiStr))
 	if err != nil {
-		return nil, err
+		panic(err)
 	}
-	return decodedExecutionReport.Messages, nil
+	return abiParsed
 }
 
 // ProofFlagsToBits transforms a list of boolean proof flags to a *big.Int
@@ -119,138 +58,6 @@ func ProofFlagsToBits(proofFlags []bool) *big.Int {
 	return encodedFlags
 }
 
-func EncodeExecutionReport(execReport evm_2_evm_offramp.InternalExecutionReport) ([]byte, error) {
-	return ExecutionReportArgs.PackValues([]interface{}{&execReport})
-}
-
-func DecodeExecutionReport(report []byte) (evm_2_evm_offramp.InternalExecutionReport, error) {
-	unpacked, err := ExecutionReportArgs.Unpack(report)
-	if err != nil {
-		return evm_2_evm_offramp.InternalExecutionReport{}, err
-	}
-	if len(unpacked) == 0 {
-		return evm_2_evm_offramp.InternalExecutionReport{}, errors.New("assumptionViolation: expected at least one element")
-	}
-
-	// Must be anonymous struct here
-	erStruct, ok := unpacked[0].(struct {
-		Messages []struct {
-			SourceChainSelector uint64         `json:"sourceChainSelector"`
-			Sender              common.Address `json:"sender"`
-			Receiver            common.Address `json:"receiver"`
-			SequenceNumber      uint64         `json:"sequenceNumber"`
-			GasLimit            *big.Int       `json:"gasLimit"`
-			Strict              bool           `json:"strict"`
-			Nonce               uint64         `json:"nonce"`
-			FeeToken            common.Address `json:"feeToken"`
-			FeeTokenAmount      *big.Int       `json:"feeTokenAmount"`
-			Data                []uint8        `json:"data"`
-			TokenAmounts        []struct {
-				Token  common.Address `json:"token"`
-				Amount *big.Int       `json:"amount"`
-			} `json:"tokenAmounts"`
-			SourceTokenData [][]byte `json:"sourceTokenData"`
-			MessageId       [32]byte `json:"messageId"`
-		} `json:"messages"`
-		OffchainTokenData [][][]byte  `json:"offchainTokenData"`
-		Proofs            [][32]uint8 `json:"proofs"`
-		ProofFlagBits     *big.Int    `json:"proofFlagBits"`
-	})
-	if !ok {
-		return evm_2_evm_offramp.InternalExecutionReport{}, fmt.Errorf("got %T", unpacked[0])
-	}
-	var er evm_2_evm_offramp.InternalExecutionReport
-	er.Messages = []evm_2_evm_offramp.InternalEVM2EVMMessage{}
-
-	for _, msg := range erStruct.Messages {
-		var tokensAndAmounts []evm_2_evm_offramp.ClientEVMTokenAmount
-		for _, tokenAndAmount := range msg.TokenAmounts {
-			tokensAndAmounts = append(tokensAndAmounts, evm_2_evm_offramp.ClientEVMTokenAmount{
-				Token:  tokenAndAmount.Token,
-				Amount: tokenAndAmount.Amount,
-			})
-		}
-		er.Messages = append(er.Messages, evm_2_evm_offramp.InternalEVM2EVMMessage{
-			SourceChainSelector: msg.SourceChainSelector,
-			SequenceNumber:      msg.SequenceNumber,
-			FeeTokenAmount:      msg.FeeTokenAmount,
-			Sender:              msg.Sender,
-			Nonce:               msg.Nonce,
-			GasLimit:            msg.GasLimit,
-			Strict:              msg.Strict,
-			Receiver:            msg.Receiver,
-			Data:                msg.Data,
-			TokenAmounts:        tokensAndAmounts,
-			SourceTokenData:     msg.SourceTokenData,
-			FeeToken:            msg.FeeToken,
-			MessageId:           msg.MessageId,
-		})
-	}
-
-	er.OffchainTokenData = erStruct.OffchainTokenData
-	er.Proofs = append(er.Proofs, erStruct.Proofs...)
-	// Unpack will populate with big.Int{false, <allocated empty nat>} for 0 values,
-	// which is different from the expected big.NewInt(0). Rebuild to the expected value for this case.
-	er.ProofFlagBits = new(big.Int).SetBytes(erStruct.ProofFlagBits.Bytes())
-	return er, nil
-}
-
-// EncodeCommitReport abi encodes an offramp.InternalCommitReport.
-func EncodeCommitReport(commitReport commit_store.CommitStoreCommitReport) ([]byte, error) {
-	return CommitReportArgs.PackValues([]interface{}{commitReport})
-}
-
-// DecodeCommitReport abi decodes a types.Report to an CommitStoreCommitReport
-func DecodeCommitReport(report []byte) (commit_store.CommitStoreCommitReport, error) {
-	unpacked, err := CommitReportArgs.Unpack(report)
-	if err != nil {
-		return commit_store.CommitStoreCommitReport{}, err
-	}
-	if len(unpacked) != 1 {
-		return commit_store.CommitStoreCommitReport{}, errors.New("expected single struct value")
-	}
-
-	commitReport, ok := unpacked[0].(struct {
-		PriceUpdates struct {
-			TokenPriceUpdates []struct {
-				SourceToken common.Address `json:"sourceToken"`
-				UsdPerToken *big.Int       `json:"usdPerToken"`
-			} `json:"tokenPriceUpdates"`
-			DestChainSelector uint64   `json:"destChainSelector"`
-			UsdPerUnitGas     *big.Int `json:"usdPerUnitGas"`
-		} `json:"priceUpdates"`
-		Interval struct {
-			Min uint64 `json:"min"`
-			Max uint64 `json:"max"`
-		} `json:"interval"`
-		MerkleRoot [32]byte `json:"merkleRoot"`
-	})
-	if !ok {
-		return commit_store.CommitStoreCommitReport{}, errors.Errorf("invalid commit report got %T", unpacked[0])
-	}
-
-	var tokenPriceUpdates []commit_store.InternalTokenPriceUpdate
-	for _, u := range commitReport.PriceUpdates.TokenPriceUpdates {
-		tokenPriceUpdates = append(tokenPriceUpdates, commit_store.InternalTokenPriceUpdate{
-			SourceToken: u.SourceToken,
-			UsdPerToken: u.UsdPerToken,
-		})
-	}
-
-	return commit_store.CommitStoreCommitReport{
-		PriceUpdates: commit_store.InternalPriceUpdates{
-			DestChainSelector: commitReport.PriceUpdates.DestChainSelector,
-			UsdPerUnitGas:     commitReport.PriceUpdates.UsdPerUnitGas,
-			TokenPriceUpdates: tokenPriceUpdates,
-		},
-		Interval: commit_store.CommitStoreInterval{
-			Min: commitReport.Interval.Min,
-			Max: commitReport.Interval.Max,
-		},
-		MerkleRoot: commitReport.MerkleRoot,
-	}, nil
-}
-
 type AbiDefined interface {
 	AbiString() string
 }

core/services/ocr2/plugins/ccip/abihelpers/abi_helpers_test.go

@@ -4,18 +4,10 @@ import (
 	"fmt"
 	"math"
 	"math/big"
-	"math/rand"
 	"testing"
 
-	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/commit_store"
-	"github.com/smartcontractkit/chainlink/v2/core/utils"
-
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/stretchr/testify/assert"
-	"github.com/test-go/testify/require"
-
-	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/evm_2_evm_offramp"
-	"github.com/smartcontractkit/chainlink/v2/core/internal/testutils"
 )
 
 func TestProofFlagToBits(t *testing.T) {
@@ -62,52 +54,6 @@ func TestProofFlagToBits(t *testing.T) {
 	}
 }
 
-func TestCommitReportEncoding(t *testing.T) {
-	report := commit_store.CommitStoreCommitReport{
-		PriceUpdates: commit_store.InternalPriceUpdates{
-			TokenPriceUpdates: []commit_store.InternalTokenPriceUpdate{
-				{
-					SourceToken: utils.RandomAddress(),
-					UsdPerToken: big.NewInt(9e18),
-				},
-			},
-			DestChainSelector: rand.Uint64(),
-			UsdPerUnitGas:     big.NewInt(2000e9),
-		},
-		MerkleRoot: [32]byte{123},
-		Interval:   commit_store.CommitStoreInterval{Min: 1, Max: 10},
-	}
-
-	encodedReport, err := EncodeCommitReport(report)
-	require.NoError(t, err)
-
-	decodedReport, err := DecodeCommitReport(encodedReport)
-	require.NoError(t, err)
-	require.Equal(t, report, decodedReport)
-}
-
-func TestExecutionReportEncoding(t *testing.T) {
-	// Note could consider some fancier testing here (fuzz/property)
-	// but I think that would essentially be testing geth's abi library
-	// as our encode/decode is a thin wrapper around that.
-	report := evm_2_evm_offramp.InternalExecutionReport{
-		Messages:          []evm_2_evm_offramp.InternalEVM2EVMMessage{},
-		OffchainTokenData: [][][]byte{{}},
-		Proofs:            [][32]byte{testutils.Random32Byte()},
-		ProofFlagBits:     big.NewInt(133),
-	}
-	encodeExecutionReport, err := EncodeExecutionReport(evm_2_evm_offramp.InternalExecutionReport{
-		Messages:          report.Messages,
-		OffchainTokenData: report.OffchainTokenData,
-		Proofs:            report.Proofs,
-		ProofFlagBits:     report.ProofFlagBits,
-	})
-	require.NoError(t, err)
-	decodeCommitReport, err := DecodeExecutionReport(encodeExecutionReport)
-	require.NoError(t, err)
-	require.Equal(t, report, decodeCommitReport)
-}
-
 func TestEvmWord(t *testing.T) {
 	testCases := []struct {
 		inp uint64