agents/testutil/typecast.go
package testutil
import (
"context"
"fmt"
"github.com/synapsecns/sanguine/agents/contracts/test/receiptharness"
"sync"
"github.com/ethereum/go-ethereum/accounts/abi/bind"
"github.com/ethereum/go-ethereum/common"
"github.com/synapsecns/sanguine/agents/contracts/bondingmanager"
"github.com/synapsecns/sanguine/agents/contracts/inbox"
"github.com/synapsecns/sanguine/agents/contracts/lightinbox"
"github.com/synapsecns/sanguine/agents/contracts/lightmanager"
"github.com/synapsecns/sanguine/agents/contracts/test/basemessageharness"
"github.com/synapsecns/sanguine/agents/contracts/test/bondingmanagerharness"
gasdataharness "github.com/synapsecns/sanguine/agents/contracts/test/gasdata"
"github.com/synapsecns/sanguine/agents/contracts/test/lightmanagerharness"
"github.com/synapsecns/sanguine/agents/contracts/test/requestharness"
"github.com/synapsecns/sanguine/ethergo/manager"
"golang.org/x/sync/errgroup"
"github.com/synapsecns/sanguine/agents/contracts/test/attestationharness"
"github.com/synapsecns/sanguine/agents/contracts/test/summitharness"
"github.com/synapsecns/sanguine/agents/contracts/test/snapshotharness"
"github.com/synapsecns/sanguine/agents/contracts/test/stateharness"
"github.com/synapsecns/sanguine/agents/contracts/origin"
"github.com/synapsecns/sanguine/agents/contracts/summit"
"github.com/synapsecns/sanguine/agents/contracts/test/headerharness"
"github.com/synapsecns/sanguine/agents/contracts/test/pingpongclient"
"github.com/synapsecns/sanguine/agents/contracts/test/testclient"
"github.com/synapsecns/sanguine/ethergo/contracts"
"github.com/synapsecns/sanguine/agents/contracts/destination"
"github.com/synapsecns/sanguine/agents/contracts/test/destinationharness"
"github.com/synapsecns/sanguine/agents/contracts/test/messageharness"
"github.com/synapsecns/sanguine/agents/contracts/test/originharness"
"github.com/synapsecns/sanguine/agents/contracts/test/tipsharness"
"github.com/synapsecns/sanguine/ethergo/backends"
"github.com/synapsecns/sanguine/agents/testutil/agentstestcontract"
)
// GetOrigin gets a typecast origin contract.
// nolint:dupl
func (d *DeployManager) GetOrigin(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *origin.OriginRef) {
d.T().Helper()
return manager.GetContract[*origin.OriginRef](ctx, d.T(), d, backend, OriginType)
}
// GetMessageHarness gets the message harness.
// nolint:dupl
func (d *DeployManager) GetMessageHarness(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *messageharness.MessageHarnessRef) {
d.T().Helper()
return manager.GetContract[*messageharness.MessageHarnessRef](ctx, d.T(), d, backend, MessageHarnessType)
}
// GetBaseMessageHarness gets the base message harness.
// nolint:dupl
func (d *DeployManager) GetBaseMessageHarness(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *basemessageharness.BaseMessageHarnessRef) {
d.T().Helper()
return manager.GetContract[*basemessageharness.BaseMessageHarnessRef](ctx, d.T(), d, backend, BaseMessageHarnessType)
}
// GetRequestHarness gets the request harness.
// nolint:dupl
func (d *DeployManager) GetRequestHarness(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *requestharness.RequestHarnessRef) {
d.T().Helper()
return manager.GetContract[*requestharness.RequestHarnessRef](ctx, d.T(), d, backend, RequestHarnessType)
}
// GetLightInbox gets the light inbox.
// nolint:dupl
func (d *DeployManager) GetLightInbox(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *lightinbox.LightInboxRef) {
d.T().Helper()
return manager.GetContract[*lightinbox.LightInboxRef](ctx, d.T(), d, backend, LightInboxType)
}
// GetLightManager gets the light manager.
// nolint:dupl
func (d *DeployManager) GetLightManager(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *lightmanager.LightManagerRef) {
d.T().Helper()
return manager.GetContract[*lightmanager.LightManagerRef](ctx, d.T(), d, backend, LightManagerType)
}
// GetLightManagerHarness gets the light manager harness.
// nolint:dupl
func (d *DeployManager) GetLightManagerHarness(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *lightmanagerharness.LightManagerHarnessRef) {
d.T().Helper()
return manager.GetContract[*lightmanagerharness.LightManagerHarnessRef](ctx, d.T(), d, backend, LightManagerHarnessType)
}
// GetInbox gets the inbox.
// nolint:dupl
func (d *DeployManager) GetInbox(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *inbox.InboxRef) {
d.T().Helper()
return manager.GetContract[*inbox.InboxRef](ctx, d.T(), d, backend, InboxType)
}
// GetBondingManager gets the bonding manager.
// nolint:dupl
func (d *DeployManager) GetBondingManager(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *bondingmanager.BondingManagerRef) {
d.T().Helper()
return manager.GetContract[*bondingmanager.BondingManagerRef](ctx, d.T(), d, backend, BondingManagerType)
}
// GetBondingManagerHarness gets the bonding manager harness.
// nolint:dupl
func (d *DeployManager) GetBondingManagerHarness(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *bondingmanagerharness.BondingManagerHarnessRef) {
d.T().Helper()
return manager.GetContract[*bondingmanagerharness.BondingManagerHarnessRef](ctx, d.T(), d, backend, BondingManagerHarnessType)
}
// GetOriginHarness gets the origin harness.
// nolint:dupl
func (d *DeployManager) GetOriginHarness(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *originharness.OriginHarnessRef) {
d.T().Helper()
return manager.GetContract[*originharness.OriginHarnessRef](ctx, d.T(), d, backend, OriginHarnessType)
}
// GetGasDataHarness gets the gasData harness.
// nolint:dupl
func (d *DeployManager) GetGasDataHarness(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *gasdataharness.GasDataHarnessRef) {
d.T().Helper()
return manager.GetContract[*gasdataharness.GasDataHarnessRef](ctx, d.T(), d, backend, GasDataHarnessType)
}
// GetStateHarness gets the state harness.
// nolint:dupl
func (d *DeployManager) GetStateHarness(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *stateharness.StateHarnessRef) {
d.T().Helper()
return manager.GetContract[*stateharness.StateHarnessRef](ctx, d.T(), d, backend, StateHarnessType)
}
// GetSnapshotHarness gets the snapshot harness.
// nolint:dupl
func (d *DeployManager) GetSnapshotHarness(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *snapshotharness.SnapshotHarnessRef) {
d.T().Helper()
return manager.GetContract[*snapshotharness.SnapshotHarnessRef](ctx, d.T(), d, backend, SnapshotHarnessType)
}
// GetReceiptHarness gets the receipt harness.
// nolint:dupl
func (d *DeployManager) GetReceiptHarness(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *receiptharness.ReceiptHarnessRef) {
d.T().Helper()
return manager.GetContract[*receiptharness.ReceiptHarnessRef](ctx, d.T(), d, backend, ReceiptHarnessType)
}
// GetAttestationHarness gets the attestation harness.
// nolint:dupl
func (d *DeployManager) GetAttestationHarness(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *attestationharness.AttestationHarnessRef) {
d.T().Helper()
return manager.GetContract[*attestationharness.AttestationHarnessRef](ctx, d.T(), d, backend, AttestationHarnessType)
}
// GetDestinationHarness gets the destination harness.
// nolint:dupl
func (d *DeployManager) GetDestinationHarness(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *destinationharness.DestinationHarnessRef) {
d.T().Helper()
return manager.GetContract[*destinationharness.DestinationHarnessRef](ctx, d.T(), d, backend, DestinationHarnessType)
}
// GetSummitHarness gets the summit harness.
// nolint:dupl
func (d *DeployManager) GetSummitHarness(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *summitharness.SummitHarnessRef) {
d.T().Helper()
return manager.GetContract[*summitharness.SummitHarnessRef](ctx, d.T(), d, backend, SummitHarnessType)
}
// GetSummit gets the summit contract.
// nolint:dupl
func (d *DeployManager) GetSummit(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *summit.SummitRef) {
d.T().Helper()
return manager.GetContract[*summit.SummitRef](ctx, d.T(), d, backend, SummitType)
}
// GetDestination gets the destination contract.
func (d *DeployManager) GetDestination(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *destination.DestinationRef) {
d.T().Helper()
return manager.GetContract[*destination.DestinationRef](ctx, d.T(), d, backend, DestinationType)
}
// GetTipsHarness gets the tips harness for testing.
// nolint:dupl
func (d *DeployManager) GetTipsHarness(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *tipsharness.TipsHarnessRef) {
d.T().Helper()
return manager.GetContract[*tipsharness.TipsHarnessRef](ctx, d.T(), d, backend, TipsHarnessType)
}
// GetHeaderHarness gets the header harness.
// nolint:dupl
func (d *DeployManager) GetHeaderHarness(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *headerharness.HeaderHarnessRef) {
d.T().Helper()
return manager.GetContract[*headerharness.HeaderHarnessRef](ctx, d.T(), d, backend, HeaderHarnessType)
}
// GetAgentsTestContract gets the agents test contract.
// nolint:dupl
func (d *DeployManager) GetAgentsTestContract(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *agentstestcontract.AgentsTestContractRef) {
d.T().Helper()
return manager.GetContract[*agentstestcontract.AgentsTestContractRef](ctx, d.T(), d, backend, AgentsTestContractType)
}
// GetTestClient gets the test client.
// nolint:dupl
func (d *DeployManager) GetTestClient(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *testclient.TestClientRef) {
d.T().Helper()
return manager.GetContract[*testclient.TestClientRef](ctx, d.T(), d, backend, TestClientType)
}
// GetPingPongClient gets the ping pong test client.
// nolint:dupl
func (d *DeployManager) GetPingPongClient(ctx context.Context, backend backends.SimulatedTestBackend) (contract contracts.DeployedContract, handle *pingpongclient.PingPongClientRef) {
d.T().Helper()
return manager.GetContract[*pingpongclient.PingPongClientRef](ctx, d.T(), d, backend, PingPongClientType)
}
// InitializeBondingManagerHarnessContract handles initializing the bonding manager harness contract on the "SYN" chain.
// nolint:dupl,cyclop
func (d *DeployManager) InitializeBondingManagerHarnessContract(
ctx context.Context,
synChainBackend backends.SimulatedTestBackend) error {
d.T().Helper()
deployedOriginHarness, _ := d.GetOriginHarness(ctx, synChainBackend)
deployedDestinationHarness, _ := d.GetDestinationHarness(ctx, synChainBackend)
deployedSummitHarness, _ := d.GetSummitHarness(ctx, synChainBackend)
deployedInbox, inboxContract := d.GetInbox(ctx, synChainBackend)
deployedBondingManagerHarness, bondingManagerHarnessContract := d.GetBondingManagerHarness(ctx, synChainBackend)
_, summitHarnessContract := d.GetSummitHarness(ctx, synChainBackend)
summitHarnessOwnerPtr, err := summitHarnessContract.SummitHarnessCaller.Owner(&bind.CallOpts{Context: ctx})
if err != nil {
return fmt.Errorf("could not get bonding manager harness: %w", err)
}
summitHarnessOwnerAuth := synChainBackend.GetTxContext(ctx, &summitHarnessOwnerPtr)
initializeBondingManagerHarnessTx, err := bondingManagerHarnessContract.Initialize(
summitHarnessOwnerAuth.TransactOpts,
deployedOriginHarness.Address(),
deployedDestinationHarness.Address(),
deployedInbox.Address(),
deployedSummitHarness.Address())
if err != nil {
return fmt.Errorf("could not initialize bonding manager harness: %w", err)
}
synChainBackend.WaitForConfirmation(ctx, initializeBondingManagerHarnessTx)
initializeInboxTx, err := inboxContract.Initialize(
summitHarnessOwnerAuth.TransactOpts,
deployedBondingManagerHarness.Address(),
deployedOriginHarness.Address(),
deployedDestinationHarness.Address(),
deployedSummitHarness.Address())
if err != nil {
return fmt.Errorf("could not initialize inbox: %w", err)
}
synChainBackend.WaitForConfirmation(ctx, initializeInboxTx)
return nil
}
// AddAgentsToBondingManagerHarnessContract handles adding the agents to the bonding manager harness contract on the "SYN" chain.
// nolint:dupl,cyclop
func (d *DeployManager) AddAgentsToBondingManagerHarnessContract(
ctx context.Context,
synChainBackend backends.SimulatedTestBackend,
agents []common.Address,
domains []uint32) ([32]byte, [][][32]byte, []bondingmanagerharness.AgentStatus, error) {
d.T().Helper()
if len(agents) != len(domains) {
return [32]byte{}, [][][32]byte{}, []bondingmanagerharness.AgentStatus{}, fmt.Errorf("agents and domains not same length")
}
_, bondingManagerHarnessContract := d.GetBondingManagerHarness(ctx, synChainBackend)
bondingManagerHarnessOwnerPtr, err := bondingManagerHarnessContract.BondingManagerHarnessCaller.Owner(&bind.CallOpts{Context: ctx})
if err != nil {
return [32]byte{}, [][][32]byte{}, []bondingmanagerharness.AgentStatus{}, fmt.Errorf("could not get bonding manager harness: %w", err)
}
bondingManagerHarnessOwnerAuth := synChainBackend.GetTxContext(ctx, &bondingManagerHarnessOwnerPtr)
for i := range agents {
agent := agents[i]
domain := domains[i]
agentProof, err := bondingManagerHarnessContract.GetProof(&bind.CallOpts{Context: ctx}, agent)
if err != nil {
return [32]byte{}, [][][32]byte{}, []bondingmanagerharness.AgentStatus{}, fmt.Errorf("could not get agent proof from bonding manager harness: %w", err)
}
txAddAgent, err := bondingManagerHarnessContract.AddAgent(bondingManagerHarnessOwnerAuth.TransactOpts, domain, agent, agentProof)
if err != nil {
return [32]byte{}, [][][32]byte{}, []bondingmanagerharness.AgentStatus{}, fmt.Errorf("could not add agent to bonding manager harness: %w", err)
}
synChainBackend.WaitForConfirmation(ctx, txAddAgent)
}
bondingManagerHarnessAgentRoot, err := bondingManagerHarnessContract.AgentRoot(&bind.CallOpts{Context: ctx})
if err != nil {
return [32]byte{}, [][][32]byte{}, []bondingmanagerharness.AgentStatus{}, fmt.Errorf("could not get bonding manager agent root: %w", err)
}
agentProofs := make([][][32]byte, len(agents))
agentStatuses := make([]bondingmanagerharness.AgentStatus, len(agents))
for i := range agents {
agent := agents[i]
agentStatus, err := bondingManagerHarnessContract.AgentStatus(&bind.CallOpts{Context: ctx}, agent)
if err != nil {
return [32]byte{}, [][][32]byte{}, []bondingmanagerharness.AgentStatus{}, fmt.Errorf("could not get agent status from bonding manager harness: %w", err)
}
agentStatuses[i] = agentStatus
agentProof, err := bondingManagerHarnessContract.GetProof(&bind.CallOpts{Context: ctx}, agent)
if err != nil {
return [32]byte{}, [][][32]byte{}, []bondingmanagerharness.AgentStatus{}, fmt.Errorf("could not get agent proof from bonding manager harness: %w", err)
}
agentProofs[i] = agentProof
}
return bondingManagerHarnessAgentRoot, agentProofs, agentStatuses, nil
}
// InitializeBondingManagerContract handles initializing the bonding manager contract on the "syn" chain.
// nolint:dupl,cyclop
func (d *DeployManager) InitializeBondingManagerContract(
ctx context.Context,
synChainBackend backends.SimulatedTestBackend) error {
d.T().Helper()
deployedOrigin, _ := d.GetOrigin(ctx, synChainBackend)
deployedDestination, _ := d.GetDestination(ctx, synChainBackend)
deployedSummit, _ := d.GetSummit(ctx, synChainBackend)
deployedInbox, inboxContract := d.GetInbox(ctx, synChainBackend)
deployedBondingManager, bondingManagerContract := d.GetBondingManager(ctx, synChainBackend)
bondingManagerOwnerPtr, err := bondingManagerContract.BondingManagerCaller.Owner(&bind.CallOpts{Context: ctx})
if err != nil {
return fmt.Errorf("could not get bonding manager: %w", err)
}
bondingManagerOwnerAuth := synChainBackend.GetTxContext(ctx, &bondingManagerOwnerPtr)
initializeBondingManagerTx, err := bondingManagerContract.Initialize(
bondingManagerOwnerAuth.TransactOpts,
deployedOrigin.Address(),
deployedDestination.Address(),
deployedInbox.Address(),
deployedSummit.Address())
if err != nil {
return fmt.Errorf("could not initialize bonding manager: %w", err)
}
synChainBackend.WaitForConfirmation(ctx, initializeBondingManagerTx)
initializeInboxTx, err := inboxContract.Initialize(
bondingManagerOwnerAuth.TransactOpts,
deployedBondingManager.Address(),
deployedOrigin.Address(),
deployedDestination.Address(),
deployedSummit.Address())
if err != nil {
return fmt.Errorf("could not initialize inbox: %w", err)
}
synChainBackend.WaitForConfirmation(ctx, initializeInboxTx)
return nil
}
// AddAgentsToBondingManagerContract handles adding the agents to the bonding manager contract on the "SYN" chain.
// nolint:dupl,cyclop
func (d *DeployManager) AddAgentsToBondingManagerContract(
ctx context.Context,
synChainBackend backends.SimulatedTestBackend,
agents []common.Address,
domains []uint32) ([32]byte, [][][32]byte, []bondingmanager.AgentStatus, error) {
d.T().Helper()
if len(agents) != len(domains) {
return [32]byte{}, [][][32]byte{}, []bondingmanager.AgentStatus{}, fmt.Errorf("agents and domains not same length")
}
_, bondingManagerContract := d.GetBondingManager(ctx, synChainBackend)
bondingManagerOwnerPtr, err := bondingManagerContract.BondingManagerCaller.Owner(&bind.CallOpts{Context: ctx})
if err != nil {
return [32]byte{}, [][][32]byte{}, []bondingmanager.AgentStatus{}, fmt.Errorf("could not get bonding manager: %w", err)
}
bondingManagerOwnerAuth := synChainBackend.GetTxContext(ctx, &bondingManagerOwnerPtr)
var proof [][32]byte
for i := range agents {
agent := agents[i]
domain := domains[i]
txAddAgent, err := bondingManagerContract.AddAgent(bondingManagerOwnerAuth.TransactOpts, domain, agent, proof)
if err != nil {
return [32]byte{}, [][][32]byte{}, []bondingmanager.AgentStatus{}, fmt.Errorf("could not add agent to bonding manager: %w", err)
}
synChainBackend.WaitForConfirmation(ctx, txAddAgent)
}
bondingManagerAgentRoot, err := bondingManagerContract.AgentRoot(&bind.CallOpts{Context: ctx})
if err != nil {
return [32]byte{}, [][][32]byte{}, []bondingmanager.AgentStatus{}, fmt.Errorf("could not get bonding manager agent root: %w", err)
}
agentProofs := make([][][32]byte, len(agents))
agentStatuses := make([]bondingmanager.AgentStatus, len(agents))
for i := range agents {
agent := agents[i]
agentStatus, err := bondingManagerContract.AgentStatus(&bind.CallOpts{Context: ctx}, agent)
if err != nil {
return [32]byte{}, [][][32]byte{}, []bondingmanager.AgentStatus{}, fmt.Errorf("could not get agent status from bonding manager: %w", err)
}
agentStatuses[i] = agentStatus
agentProof, err := bondingManagerContract.GetProof(&bind.CallOpts{Context: ctx}, agent)
if err != nil {
return [32]byte{}, [][][32]byte{}, []bondingmanager.AgentStatus{}, fmt.Errorf("could not get agent proof from bonding manager: %w", err)
}
agentProofs[i] = agentProof
}
return bondingManagerAgentRoot, agentProofs, agentStatuses, nil
}
// InitializeRemoteDeployedHarnessContracts handles initializing the harness contracts for light manager harness and destination harness on remote chain.
// nolint:dupl,cyclop
func (d *DeployManager) InitializeRemoteDeployedHarnessContracts(
ctx context.Context,
backend backends.SimulatedTestBackend,
bondingManagerHarnessAgentRoot [32]byte) error {
d.T().Helper()
deployedDestinationHarness, destinationHarnessContract := d.GetDestinationHarness(ctx, backend)
deployedLightInbox, lightInboxContract := d.GetLightInbox(ctx, backend)
deployedLightManagerHarness, lightManagerHarnessContract := d.GetLightManagerHarness(ctx, backend)
deployedOriginHarness, originHarnessContract := d.GetOriginHarness(ctx, backend)
originHarnessOwnerPtr, err := originHarnessContract.OriginHarnessCaller.Owner(&bind.CallOpts{Context: ctx})
if err != nil {
return fmt.Errorf("could not get origin harness: %w", err)
}
originHarnessOwnerAuth := backend.GetTxContext(ctx, &originHarnessOwnerPtr)
initializeLightManagerHarnessTx, err := lightManagerHarnessContract.Initialize(
originHarnessOwnerAuth.TransactOpts,
deployedOriginHarness.Address(),
deployedDestinationHarness.Address(),
deployedLightInbox.Address())
if err != nil {
return fmt.Errorf("could not initialize light manager harness: %w", err)
}
backend.WaitForConfirmation(ctx, initializeLightManagerHarnessTx)
/*destinationHarnessOwnerPtr, err := destinationHarnessContract.DestinationHarnessCaller.Owner(&bind.CallOpts{Context: ctx})
if err != nil {
return fmt.Errorf("could not get destination harness: %w", err)
}
destinationHarnessOwnerAuth := backend.GetTxContext(ctx, &destinationHarnessOwnerPtr)*/
initializeDestinationHarnessTx, err := destinationHarnessContract.Initialize(originHarnessOwnerAuth.TransactOpts, bondingManagerHarnessAgentRoot)
if err != nil {
return fmt.Errorf("could not initialize destination harness: %w", err)
}
backend.WaitForConfirmation(ctx, initializeDestinationHarnessTx)
initializeLightInboxTx, err := lightInboxContract.Initialize(
originHarnessOwnerAuth.TransactOpts,
deployedLightManagerHarness.Address(),
deployedOriginHarness.Address(),
deployedDestinationHarness.Address())
if err != nil {
return fmt.Errorf("could not initialize light inbox: %w", err)
}
backend.WaitForConfirmation(ctx, initializeLightInboxTx)
return nil
}
// AddAgentsToLightManagerHarnessContract handles adding the agents to the light manager harness contract on the remote chain.
// nolint:dupl,cyclop
// codebeat:disable[CYCLO]
func (d *DeployManager) AddAgentsToLightManagerHarnessContract(
ctx context.Context,
backend backends.SimulatedTestBackend,
agents []common.Address,
agentProofs [][][32]byte,
agentStatuses []bondingmanagerharness.AgentStatus) error {
d.T().Helper()
if len(agents) != len(agentProofs) {
return fmt.Errorf("agents and agentProofs not same length")
}
_, lightManagerHarnessContract := d.GetLightManagerHarness(ctx, backend)
lightManagerHarnessOwnerPtr, err := lightManagerHarnessContract.LightManagerHarnessCaller.Owner(&bind.CallOpts{Context: ctx})
if err != nil {
return fmt.Errorf("could not get light manager harness: %w", err)
}
lightManagerHarnessOwnerAuth := backend.GetTxContext(ctx, &lightManagerHarnessOwnerPtr)
for i := range agents {
agent := agents[i]
agentProof := agentProofs[i]
bondingManagerAgentStatus := agentStatuses[i]
lightManagerAgentStatus := lightmanagerharness.AgentStatus{
Flag: bondingManagerAgentStatus.Flag,
Domain: bondingManagerAgentStatus.Domain,
Index: bondingManagerAgentStatus.Index,
}
// We want to make the notary do the work of adding the agent and not
// have it done automatically by the test harness
if lightManagerAgentStatus.Domain != 0 {
continue
}
txAddAgent, err := lightManagerHarnessContract.UpdateAgentStatus(
lightManagerHarnessOwnerAuth.TransactOpts,
agent,
lightManagerAgentStatus,
agentProof)
if err != nil {
return fmt.Errorf("could not add agent to light manager harness: %w", err)
}
backend.WaitForConfirmation(ctx, txAddAgent)
}
return nil
}
// InitializeRemoteDeployedContracts handles initializing the contracts for light manager and destination on remote chain.
// nolint:dupl,cyclop
func (d *DeployManager) InitializeRemoteDeployedContracts(
ctx context.Context,
backend backends.SimulatedTestBackend,
bondingManagerAgentRoot [32]byte) error {
d.T().Helper()
deployedOrigin, originContract := d.GetOrigin(ctx, backend)
deployedDestination, destinationContract := d.GetDestination(ctx, backend)
deployedLightInbox, lightInboxContract := d.GetLightInbox(ctx, backend)
deployedLightManager, lightManagerContract := d.GetLightManager(ctx, backend)
lightManagerOwnerPtr, err := lightManagerContract.LightManagerCaller.Owner(&bind.CallOpts{Context: ctx})
if err != nil {
return fmt.Errorf("could not get light manager: %w", err)
}
lightManagerOwnerAuth := backend.GetTxContext(ctx, &lightManagerOwnerPtr)
initializeLightManagerTx, err := lightManagerContract.Initialize(
lightManagerOwnerAuth.TransactOpts,
deployedOrigin.Address(),
deployedDestination.Address(),
deployedLightInbox.Address())
if err != nil {
return fmt.Errorf("could not initialize light manager: %w", err)
}
backend.WaitForConfirmation(ctx, initializeLightManagerTx)
originOwnerPtr, err := originContract.OriginCaller.Owner(&bind.CallOpts{Context: ctx})
if err != nil {
return fmt.Errorf("could not get origin: %w", err)
}
originOwnerAuth := backend.GetTxContext(ctx, &originOwnerPtr)
initializeDestinationTx, err := destinationContract.Initialize(originOwnerAuth.TransactOpts, bondingManagerAgentRoot)
if err != nil {
return fmt.Errorf("could not initialize destination: %w", err)
}
backend.WaitForConfirmation(ctx, initializeDestinationTx)
initializeLightInboxTx, err := lightInboxContract.Initialize(
originOwnerAuth.TransactOpts,
deployedLightManager.Address(),
deployedOrigin.Address(),
deployedDestination.Address())
if err != nil {
return fmt.Errorf("could not initialize light inbox: %w", err)
}
backend.WaitForConfirmation(ctx, initializeLightInboxTx)
return nil
}
// AddAgentsToLightManagerContract handles adding the agents to the light manager contract on the remote chain.
// nolint:dupl,cyclop
func (d *DeployManager) AddAgentsToLightManagerContract(
ctx context.Context,
backend backends.SimulatedTestBackend,
agents []common.Address,
agentProofs [][][32]byte,
agentStatuses []bondingmanager.AgentStatus) error {
d.T().Helper()
if len(agents) != len(agentProofs) {
return fmt.Errorf("agents and agentProofs not same length")
}
_, lightManagerContract := d.GetLightManager(ctx, backend)
lightManagerOwnerPtr, err := lightManagerContract.LightManagerCaller.Owner(&bind.CallOpts{Context: ctx})
if err != nil {
return fmt.Errorf("could not get light manager: %w", err)
}
lightManagerOwnerAuth := backend.GetTxContext(ctx, &lightManagerOwnerPtr)
for i := range agents {
agent := agents[i]
agentProof := agentProofs[i]
bondingManagerAgentStatus := agentStatuses[i]
lightManagerAgentStatus := lightmanager.AgentStatus{
Flag: bondingManagerAgentStatus.Flag,
Domain: bondingManagerAgentStatus.Domain,
Index: bondingManagerAgentStatus.Index,
}
txAddAgent, err := lightManagerContract.UpdateAgentStatus(
lightManagerOwnerAuth.TransactOpts,
agent,
lightManagerAgentStatus,
agentProof)
if err != nil {
return fmt.Errorf("could not add agent to light manager: %w", err)
}
backend.WaitForConfirmation(ctx, txAddAgent)
}
return nil
}
// LoadHarnessContractsOnChains loads the harness contracts to the various chains and initializes them.
// nolint:dupl,cyclop
func (d *DeployManager) LoadHarnessContractsOnChains(
ctx context.Context,
synChainBackend backends.SimulatedTestBackend,
backends []backends.SimulatedTestBackend,
agents []common.Address,
agentDomains []uint32) error {
d.T().Helper()
err := d.InitializeBondingManagerHarnessContract(ctx, synChainBackend)
if err != nil {
return fmt.Errorf("could not initialize bonding manager harness on syn chain: %w", err)
}
bondingManagerHarnessAgentRoot, agentProofs, agentStatuses, err := d.AddAgentsToBondingManagerHarnessContract(
ctx,
synChainBackend,
agents,
agentDomains)
if err != nil {
return fmt.Errorf("could not add agents to bonding manager harness on syn chain: %w", err)
}
wg := sync.WaitGroup{}
g, ctx := errgroup.WithContext(ctx)
for _, b := range backends {
backend := b
wg.Add(1)
g.Go(func() error {
defer wg.Done()
err := d.InitializeRemoteDeployedHarnessContracts(
ctx,
backend,
bondingManagerHarnessAgentRoot)
if err != nil {
return fmt.Errorf("could not initialize remote deplyed harness contracts: %w", err)
}
err = d.AddAgentsToLightManagerHarnessContract(
ctx,
backend,
agents,
agentProofs,
agentStatuses)
if err != nil {
return fmt.Errorf("could not add agents to remote light manager harness contract: %w", err)
}
return nil
})
}
err = g.Wait()
if err != nil {
return fmt.Errorf("could not initialize remote deplyed harness contracts: %w", err)
}
return nil
}
// LoadContractsOnChains loads the contracts to the various chains and initializes them.
// nolint:dupl,cyclop
func (d *DeployManager) LoadContractsOnChains(
ctx context.Context,
synChainBackend backends.SimulatedTestBackend,
backends []backends.SimulatedTestBackend,
agents []common.Address,
agentDomains []uint32) error {
d.T().Helper()
err := d.InitializeBondingManagerContract(ctx, synChainBackend)
if err != nil {
return fmt.Errorf("could not initialize bonding manager on syn chain: %w", err)
}
bondingManagerAgentRoot, agentProofs, agentStatuses, err := d.AddAgentsToBondingManagerContract(
ctx,
synChainBackend,
agents,
agentDomains)
if err != nil {
return fmt.Errorf("could not add agents to bonding manager on syn chain: %w", err)
}
for _, backend := range backends {
err := d.InitializeRemoteDeployedContracts(
ctx,
backend,
bondingManagerAgentRoot)
if err != nil {
return fmt.Errorf("could not initialize remote deplyed contracts: %w", err)
}
err = d.AddAgentsToLightManagerContract(
ctx,
backend,
agents,
agentProofs,
agentStatuses)
if err != nil {
return fmt.Errorf("could not add agents to remote light manager contract: %w", err)
}
}
return nil
}