Skip to content

Commit

Permalink
leftover cleanup
Browse files Browse the repository at this point in the history
  • Loading branch information
@anirudhwarrier
anirudhwarrier committed Sep 18, 2024
1 parent b1fdcd9 commit 8ec8cc2
Showing 1 changed file with 0 additions and 277 deletions.
277 changes: 0 additions & 277 deletions integration-tests/actions/automation_ocr_helpers.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,297 +2,20 @@ package actions

//revive:disable:dot-imports
import (
"encoding/json"
"fmt"
"math"
"math/big"
"testing"
"time"

"github.com/pkg/errors"

"github.com/smartcontractkit/chainlink-testing-framework/seth"

"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/generated/i_automation_registry_master_wrapper_2_3"

"github.com/ethereum/go-ethereum/common"
"github.com/lib/pq"
"github.com/stretchr/testify/require"
"gopkg.in/guregu/null.v4"

ocr2 "github.com/smartcontractkit/libocr/offchainreporting2plus/confighelper"
ocr3 "github.com/smartcontractkit/libocr/offchainreporting2plus/ocr3confighelper"
"github.com/smartcontractkit/libocr/offchainreporting2plus/types"

ocr2keepers20config "github.com/smartcontractkit/chainlink-automation/pkg/v2/config"
ocr2keepers30config "github.com/smartcontractkit/chainlink-automation/pkg/v3/config"
"github.com/smartcontractkit/chainlink-testing-framework/lib/logging"

"github.com/smartcontractkit/chainlink/integration-tests/client"
"github.com/smartcontractkit/chainlink/integration-tests/contracts"
"github.com/smartcontractkit/chainlink/integration-tests/contracts/ethereum"
"github.com/smartcontractkit/chainlink/v2/core/services/job"
"github.com/smartcontractkit/chainlink/v2/core/services/keystore/chaintype"
"github.com/smartcontractkit/chainlink/v2/core/store/models"
)

func BuildAutoOCR2ConfigVars(
t *testing.T,
chainlinkNodes []*client.ChainlinkK8sClient,
registryConfig contracts.KeeperRegistrySettings,
registrar string,
deltaStage time.Duration,
chainModuleAddress common.Address,
reorgProtectionEnabled bool,
linkToken contracts.LinkToken,
wethToken contracts.WETHToken,
ethUSDFeed contracts.MockETHUSDFeed,

) (contracts.OCRv2Config, error) {
return BuildAutoOCR2ConfigVarsWithKeyIndex(t, chainlinkNodes, registryConfig, registrar, deltaStage, 0, common.Address{}, chainModuleAddress, reorgProtectionEnabled, linkToken, wethToken, ethUSDFeed)
}

func BuildAutoOCR2ConfigVarsWithKeyIndex(
t *testing.T,
chainlinkNodes []*client.ChainlinkK8sClient,
registryConfig contracts.KeeperRegistrySettings,
registrar string,
deltaStage time.Duration,
keyIndex int,
registryOwnerAddress common.Address,
chainModuleAddress common.Address,
reorgProtectionEnabled bool,
linkToken contracts.LinkToken,
wethToken contracts.WETHToken,
ethUSDFeed contracts.MockETHUSDFeed,
) (contracts.OCRv2Config, error) {
l := logging.GetTestLogger(t)
S, oracleIdentities, err := GetOracleIdentitiesWithKeyIndex(chainlinkNodes, keyIndex)
if err != nil {
return contracts.OCRv2Config{}, err
}

var offC []byte
var signerOnchainPublicKeys []types.OnchainPublicKey
var transmitterAccounts []types.Account
var f uint8
var offchainConfigVersion uint64
var offchainConfig []byte

if registryConfig.RegistryVersion == ethereum.RegistryVersion_2_1 || registryConfig.RegistryVersion == ethereum.RegistryVersion_2_2 || registryConfig.RegistryVersion == ethereum.RegistryVersion_2_3 {
offC, err = json.Marshal(ocr2keepers30config.OffchainConfig{
TargetProbability: "0.999",
TargetInRounds: 1,
PerformLockoutWindow: 3600000, // Intentionally set to be higher than in prod for testing purpose
GasLimitPerReport: 5_300_000,
GasOverheadPerUpkeep: 300_000,
MinConfirmations: 0,
MaxUpkeepBatchSize: 10,
})
if err != nil {
return contracts.OCRv2Config{}, err
}

signerOnchainPublicKeys, transmitterAccounts, f, _, offchainConfigVersion, offchainConfig, err = ocr3.ContractSetConfigArgsForTests(
10*time.Second, // deltaProgress time.Duration,
15*time.Second, // deltaResend time.Duration,
500*time.Millisecond, // deltaInitial time.Duration,
1000*time.Millisecond, // deltaRound time.Duration,
200*time.Millisecond, // deltaGrace time.Duration,
300*time.Millisecond, // deltaCertifiedCommitRequest time.Duration
deltaStage, // deltaStage time.Duration,
24, // rMax uint64,
S, // s []int,
oracleIdentities, // oracles []OracleIdentityExtra,
offC, // reportingPluginConfig []byte,
20*time.Millisecond, // maxDurationQuery time.Duration,
20*time.Millisecond, // maxDurationObservation time.Duration, // good to here
1200*time.Millisecond, // maxDurationShouldAcceptAttestedReport time.Duration,
20*time.Millisecond, // maxDurationShouldTransmitAcceptedReport time.Duration,
1, // f int,
nil, // onchainConfig []byte,
)
if err != nil {
return contracts.OCRv2Config{}, err
}
} else {
offC, err = json.Marshal(ocr2keepers20config.OffchainConfig{
TargetProbability: "0.999",
TargetInRounds: 1,
PerformLockoutWindow: 3600000, // Intentionally set to be higher than in prod for testing purpose
GasLimitPerReport: 5_300_000,
GasOverheadPerUpkeep: 300_000,
SamplingJobDuration: 3000,
MinConfirmations: 0,
MaxUpkeepBatchSize: 1,
})
if err != nil {
return contracts.OCRv2Config{}, err
}

signerOnchainPublicKeys, transmitterAccounts, f, _, offchainConfigVersion, offchainConfig, err = ocr2.ContractSetConfigArgsForTests(
10*time.Second, // deltaProgress time.Duration,
15*time.Second, // deltaResend time.Duration,
3000*time.Millisecond, // deltaRound time.Duration,
200*time.Millisecond, // deltaGrace time.Duration,
deltaStage, // deltaStage time.Duration,
24, // rMax uint8,
S, // s []int,
oracleIdentities, // oracles []OracleIdentityExtra,
offC, // reportingPluginConfig []byte,
20*time.Millisecond, // maxDurationQuery time.Duration,
20*time.Millisecond, // maxDurationObservation time.Duration,
1200*time.Millisecond, // maxDurationReport time.Duration,
20*time.Millisecond, // maxDurationShouldAcceptFinalizedReport time.Duration,
20*time.Millisecond, // maxDurationShouldTransmitAcceptedReport time.Duration,
1, // f int,
nil, // onchainConfig []byte,
)
if err != nil {
return contracts.OCRv2Config{}, err
}
}

var signers []common.Address
for _, signer := range signerOnchainPublicKeys {
require.Equal(t, 20, len(signer), "OnChainPublicKey '%v' has wrong length for address", signer)
signers = append(signers, common.BytesToAddress(signer))
}

var transmitters []common.Address
for _, transmitter := range transmitterAccounts {
require.True(t, common.IsHexAddress(string(transmitter)), "TransmitAccount '%s' is not a valid Ethereum address", string(transmitter))
transmitters = append(transmitters, common.HexToAddress(string(transmitter)))
}

ocrConfig := contracts.OCRv2Config{
Signers: signers,
Transmitters: transmitters,
F: f,
OffchainConfigVersion: offchainConfigVersion,
OffchainConfig: offchainConfig,
}

if registryConfig.RegistryVersion == ethereum.RegistryVersion_2_0 {
ocrConfig.OnchainConfig = registryConfig.Encode20OnchainConfig(registrar)
} else if registryConfig.RegistryVersion == ethereum.RegistryVersion_2_1 {
ocrConfig.TypedOnchainConfig21 = registryConfig.Create21OnchainConfig(registrar, registryOwnerAddress)
} else if registryConfig.RegistryVersion == ethereum.RegistryVersion_2_2 {
ocrConfig.TypedOnchainConfig22 = registryConfig.Create22OnchainConfig(registrar, registryOwnerAddress, chainModuleAddress, reorgProtectionEnabled)
} else if registryConfig.RegistryVersion == ethereum.RegistryVersion_2_3 {
ocrConfig.TypedOnchainConfig23 = registryConfig.Create23OnchainConfig(registrar, registryOwnerAddress, chainModuleAddress, reorgProtectionEnabled)
ocrConfig.BillingTokens = []common.Address{
common.HexToAddress(linkToken.Address()),
common.HexToAddress(wethToken.Address()),
}

ocrConfig.BillingConfigs = []i_automation_registry_master_wrapper_2_3.AutomationRegistryBase23BillingConfig{
{
GasFeePPB: 100,
FlatFeeMilliCents: big.NewInt(500),
PriceFeed: common.HexToAddress(ethUSDFeed.Address()), // ETH/USD feed and LINK/USD feed are the same
Decimals: 18,
FallbackPrice: big.NewInt(1000),
MinSpend: big.NewInt(200),
},
{
GasFeePPB: 100,
FlatFeeMilliCents: big.NewInt(500),
PriceFeed: common.HexToAddress(ethUSDFeed.Address()), // ETH/USD feed and LINK/USD feed are the same
Decimals: 18,
FallbackPrice: big.NewInt(1000),
MinSpend: big.NewInt(200),
},
}
}

l.Info().Msg("Done building OCR config")
return ocrConfig, nil
}

// CreateOCRKeeperJobs bootstraps the first node and to the other nodes sends ocr jobs
func CreateOCRKeeperJobs(
t *testing.T,
chainlinkNodes []*client.ChainlinkK8sClient,
registryAddr string,
chainID int64,
keyIndex int,
registryVersion ethereum.KeeperRegistryVersion,
) {
l := logging.GetTestLogger(t)
bootstrapNode := chainlinkNodes[0]
bootstrapP2PIds, err := bootstrapNode.MustReadP2PKeys()
require.NoError(t, err, "Shouldn't fail reading P2P keys from bootstrap node")
bootstrapP2PId := bootstrapP2PIds.Data[0].Attributes.PeerID

var contractVersion string
if registryVersion == ethereum.RegistryVersion_2_2 || registryVersion == ethereum.RegistryVersion_2_3 {
contractVersion = "v2.1+"
} else if registryVersion == ethereum.RegistryVersion_2_1 {
contractVersion = "v2.1"
} else if registryVersion == ethereum.RegistryVersion_2_0 {
contractVersion = "v2.0"
} else {
require.FailNow(t, fmt.Sprintf("v2.0, v2.1, v2.2 and v2.3 are the only supported versions, but got something else: %v (iota)", registryVersion))
}

bootstrapSpec := &client.OCR2TaskJobSpec{
Name: "ocr2 bootstrap node " + registryAddr,
JobType: "bootstrap",
OCR2OracleSpec: job.OCR2OracleSpec{
ContractID: registryAddr,
Relay: "evm",
RelayConfig: map[string]interface{}{
"chainID": int(chainID),
},
ContractConfigTrackerPollInterval: *models.NewInterval(time.Second * 15),
},
}
_, err = bootstrapNode.MustCreateJob(bootstrapSpec)
require.NoError(t, err, "Shouldn't fail creating bootstrap job on bootstrap node")
// TODO: Use service name returned by chainlink-env once that is available
P2Pv2Bootstrapper := fmt.Sprintf("%s@%s-node-1:%d", bootstrapP2PId, bootstrapNode.Name(), 6690)

for nodeIndex := 1; nodeIndex < len(chainlinkNodes); nodeIndex++ {
nodeTransmitterAddress, err := chainlinkNodes[nodeIndex].EthAddresses()
require.NoError(t, err, "Shouldn't fail getting primary ETH address from OCR node %d", nodeIndex+1)
nodeOCRKeys, err := chainlinkNodes[nodeIndex].MustReadOCR2Keys()
require.NoError(t, err, "Shouldn't fail getting OCR keys from OCR node %d", nodeIndex+1)
var nodeOCRKeyId []string
for _, key := range nodeOCRKeys.Data {
if key.Attributes.ChainType == string(chaintype.EVM) {
nodeOCRKeyId = append(nodeOCRKeyId, key.ID)
break
}
}

autoOCR2JobSpec := client.OCR2TaskJobSpec{
Name: "ocr2 " + registryAddr,
JobType: "offchainreporting2",
OCR2OracleSpec: job.OCR2OracleSpec{
PluginType: "ocr2automation",
Relay: "evm",
RelayConfig: map[string]interface{}{
"chainID": int(chainID),
},
PluginConfig: map[string]interface{}{
"mercuryCredentialName": "\"cred1\"",
"contractVersion": "\"" + contractVersion + "\"",
},
ContractConfigTrackerPollInterval: *models.NewInterval(time.Second * 15),
ContractID: registryAddr, // registryAddr
OCRKeyBundleID: null.StringFrom(nodeOCRKeyId[0]), // get node ocr2config.ID
TransmitterID: null.StringFrom(nodeTransmitterAddress[keyIndex]), // node addr
P2PV2Bootstrappers: pq.StringArray{P2Pv2Bootstrapper}, // bootstrap node key and address <p2p-key>@bootstrap:8000
},
}

_, err = chainlinkNodes[nodeIndex].MustCreateJob(&autoOCR2JobSpec)
require.NoError(t, err, "Shouldn't fail creating OCR Task job on OCR node %d err: %+v", nodeIndex+1, err)
}
l.Info().Msg("Done creating OCR automation jobs")
}

// DeployAutoOCRRegistryAndRegistrar registry and registrar
func DeployAutoOCRRegistryAndRegistrar(
t *testing.T,
Expand Down

0 comments on commit 8ec8cc2

Please sign in to comment.