synapsecns/sanguine

package testutil

import (
    "context"
    "fmt"
    "testing"

    "github.com/synapsecns/sanguine/services/cctp-relayer/contracts/mockmintburntoken"
    "github.com/synapsecns/sanguine/services/cctp-relayer/contracts/mocktokenmessenger"
    "github.com/synapsecns/sanguine/services/cctp-relayer/contracts/mocktokenminter"

    "github.com/ethereum/go-ethereum/accounts/abi/bind"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/synapsecns/sanguine/ethergo/backends"
    "github.com/synapsecns/sanguine/ethergo/contracts"
    "github.com/synapsecns/sanguine/ethergo/deployer"
    "github.com/synapsecns/sanguine/ethergo/manager"
    "github.com/synapsecns/sanguine/services/cctp-relayer/contracts/cctp"
    "github.com/synapsecns/sanguine/services/cctp-relayer/contracts/mockmessagetransmitter"
)

// ChainIDDomainMap maps chain IDs to domains.
// see: https://developers.circle.com/stablecoin/docs/cctp-technical-reference#domain
// TODO: make this eaiser to debug in the case of missing domains, etc.
var ChainIDDomainMap = map[uint32]uint32{
    1:     0,
    43114: 1,
}

// NewDeployManager creates a deploy manager.
func NewDeployManager(t *testing.T) *DeployManager {
    t.Helper()

    parentManager := manager.NewDeployerManager(t,
        NewMockMessageTransmitterDeployer, NewSynapseCCTPDeployer, NewMockTokenMessengerDeployer, NewMockMintBurnTokenDeployer, NewMockTokenMinterDeployer,
    )
    return &DeployManager{parentManager}
}

// DeployManager wraps DeployManager and allows typed contract handles to be returned.
type DeployManager struct {
    *manager.DeployerManager
}

// MockMessageTransmitterDeployer deploys the mockmessagetransmitter.
type MockMessageTransmitterDeployer struct {
    *deployer.BaseDeployer
}

// NewMockMessageTransmitterDeployer deploys the light inbox contract.
func NewMockMessageTransmitterDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
    return MockMessageTransmitterDeployer{deployer.NewSimpleDeployer(registry, backend, MockMessageTransmitterType)}
}

// Deploy deploys the light manager contract.
//
//nolint:dupword,dupl,cyclop
func (d MockMessageTransmitterDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
    return d.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (address common.Address, tx *types.Transaction, data interface{}, err error) {
        // define the domain as the chain id!
        return mockmessagetransmitter.DeployMockMessageTransmitter(transactOps, backend, ChainIDDomainMap[uint32(d.Backend().GetChainID())])
    }, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
        // remember what I said about vm.ContractRef!
        return mockmessagetransmitter.NewMockMessageTransmitterRef(address, backend)
    })
}

// NewMockTokenMessengerDeployer deploys the mocktokenmessenger.
func NewMockTokenMessengerDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
    return MockTokenMessengerDeployer{deployer.NewSimpleDeployer(registry, backend, MockTokenMessengerType)}
}

// MockTokenMessengerDeployer deploys the mocktokenmessenger.
type MockTokenMessengerDeployer struct {
    *deployer.BaseDeployer
}

// Deploy deploys the mock token messenger contract.
//
//nolint:dupword,dupl,cyclop
func (m MockTokenMessengerDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
    messageTransmitter := m.Registry().Get(ctx, MockMessageTransmitterType)

    return m.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (address common.Address, tx *types.Transaction, data interface{}, err error) {
        // define the domain as the chain id!
        return mocktokenmessenger.DeployMockTokenMessenger(transactOps, backend, messageTransmitter.Address())
    }, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
        // remember what I said about vm.ContractRef!
        return mocktokenmessenger.NewMockTokenMessengerRef(address, backend)
    })
}

// Dependencies returns the dependencies of the mocktokenmessenger.
func (m MockTokenMessengerDeployer) Dependencies() []contracts.ContractType {
    return []contracts.ContractType{MockMessageTransmitterType}
}

// NewMockMintBurnTokenDeployer deploys the mocktokenmessenger.
func NewMockMintBurnTokenDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
    return MockMintBurnTokenDeployer{deployer.NewSimpleDeployer(registry, backend, MockMintBurnTokenType)}
}

// MockTokenMinterDeployer deploys the mocktokenminter.
type MockTokenMinterDeployer struct {
    *deployer.BaseDeployer
}

// NewMockTokenMinterDeployer deploys the mocktokenminter.
func NewMockTokenMinterDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
    return MockTokenMinterDeployer{deployer.NewSimpleDeployer(registry, backend, MockTokenMinterType)}
}

// Deploy deploys the mock token minter contract.
//
//nolint:dupword,dupl,cyclop
func (m MockTokenMinterDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
    tokenMessenger := m.Registry().Get(ctx, MockTokenMessengerType)

    return m.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (address common.Address, tx *types.Transaction, data interface{}, err error) {
        // define the domain as the chain id!
        address, tx, handle, err := mocktokenminter.DeployMockTokenMinter(transactOps, backend, tokenMessenger.Address())
        if err != nil {
            return address, tx, handle, fmt.Errorf("could not deploy mock token minter: %w", err)
        }

        messengerOpts := m.Backend().GetTxContext(ctx, tokenMessenger.OwnerPtr())
        messengerHandle, ok := tokenMessenger.ContractHandle().(*mocktokenmessenger.MockTokenMessengerRef)
        if !ok {
            return address, tx, handle, fmt.Errorf("could not case %T to %T", tokenMessenger.ContractHandle(), messengerHandle)
        }

        setTx, err := messengerHandle.SetLocalMinter(messengerOpts.TransactOpts, address)
        if err != nil {
            return address, tx, handle, fmt.Errorf("could not set local minter: %w", err)
        }
        m.Backend().WaitForConfirmation(ctx, setTx)

        return address, tx, handle, nil
    }, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
        // remember what I said about vm.ContractRef!
        return mocktokenminter.NewMockTokenMinterRef(address, backend)
    })
}

// Dependencies returns the dependencies of the mock token minter.
func (m MockTokenMinterDeployer) Dependencies() []contracts.ContractType {
    return m.RecursiveDependencies([]contracts.ContractType{MockTokenMessengerType})
}

// MockMintBurnTokenDeployer deploys the mocktokenminter.
type MockMintBurnTokenDeployer struct {
    *deployer.BaseDeployer
}

// Deploy deploys the mock mint burn token contract.
//
//nolint:dupword,dupl,cyclop
func (m MockMintBurnTokenDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
    messageTransmitter := m.Registry().Get(ctx, MockMessageTransmitterType)

    return m.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (address common.Address, tx *types.Transaction, data interface{}, err error) {
        // define the domain as the chain id!
        return mockmintburntoken.DeployMockMintBurnToken(transactOps, backend, messageTransmitter.Address())
    }, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
        // remember what I said about vm.ContractRef!
        return mockmintburntoken.NewMockMintBurnTokenRef(address, backend)
    })
}

// Dependencies returns the dependencies of the mock mint burn token.
func (m MockMintBurnTokenDeployer) Dependencies() []contracts.ContractType {
    return []contracts.ContractType{MockMessageTransmitterType}
}

// SynapseCCTPDeployer deploys the synapse cctp contract.
type SynapseCCTPDeployer struct {
    *deployer.BaseDeployer
}

// NewSynapseCCTPDeployer deploys the synapse cctp contract.
func NewSynapseCCTPDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
    return SynapseCCTPDeployer{deployer.NewSimpleDeployer(registry, backend, SynapseCCTPType)}
}

// Deploy deploys the light manager contract.
//
//nolint:dupword,dupl,cyclop
func (d SynapseCCTPDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
    return d.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (address common.Address, tx *types.Transaction, data interface{}, err error) {
        tokenMessenger := d.Registry().Get(ctx, MockTokenMessengerType)

        // make this a dependency so it self registers the remote domains
        _ = d.Registry().Get(ctx, MockTokenMinterType)

        // define the domain as the chain id!
        return cctp.DeploySynapseCCTP(transactOps, backend, tokenMessenger.Address(), transactOps.From)
    }, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
        // remember what I said about vm.ContractRef!
        return cctp.NewSynapseCCTPRef(address, backend)
    })
}

// Dependencies returns the dependencies of the SynapseCCTP contract.
func (d SynapseCCTPDeployer) Dependencies() []contracts.ContractType {
    return d.RecursiveDependencies([]contracts.ContractType{MockTokenMessengerType, MockTokenMinterType})
}