synapsecns/sanguine

package deployer

import (
    "context"
    "fmt"
    "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"
)

// BaseDeployer is a basic deployment contract. It contains several utility functions including:
// - RecursiveDependencies: can be used to return dependents of dependents (since Dependencies should return all dependents: direct and indirect)
// - DeploySimpleContract: can be used to deploy contracts that don't have to be initialized.
type BaseDeployer struct {
    // registry is the contract registry
    registry GetOnlyContractRegistry
    // backend is the registry
    backend      backends.SimulatedTestBackend
    contractType contracts.ContractType
}

// NewSimpleDeployer creates a new base deployer.
func NewSimpleDeployer(registry GetOnlyContractRegistry, backend backends.SimulatedTestBackend, contractType contracts.ContractType) *BaseDeployer {
    return &BaseDeployer{
        registry:     registry,
        backend:      backend,
        contractType: contractType,
    }
}

// Deploy is a placeholder to ensure function inheritance. Calling this directly will panic.
func (n BaseDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
    panic("deploy not implemented in base deployer")
}

// Backend gets the backend of the current deployer instance.
func (n BaseDeployer) Backend() backends.SimulatedTestBackend {
    return n.backend
}

// Registry gets the registry.
func (n BaseDeployer) Registry() GetOnlyContractRegistry {
    return n.registry
}

// ContractType returns the contract type.
func (n BaseDeployer) ContractType() contracts.ContractType {
    return n.contractType
}

// Dependencies returns dependencies for the contract - this should be overridden by base classes if there are dependencies.
func (n BaseDeployer) Dependencies() []contracts.ContractType {
    return []contracts.ContractType{}
}

// RecursiveDependencies recursively get dependencies.
func (n BaseDeployer) RecursiveDependencies(dependencies []contracts.ContractType) (res []contracts.ContractType) {
    // check if dependency is already in result
    resultHasDependency := func(dep contracts.ContractType) bool {
        for _, dependency := range res {
            if dep.ID() == dependency.ID() {
                return true
            }
        }
        return false
    }
    // TODO handle cyclicality
    for _, dependency := range dependencies {
        codependencies := append(n.registry.GetRegisteredDeployer(dependency).Dependencies(), dependency)
        for _, dependency := range codependencies {
            if !resultHasDependency(dependency) {
                res = append(res, dependency)
            }
        }
    }
    return res
}

// DeployFunc is the deploy function.
type DeployFunc func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error)

// HandleFunc gets the ref function.
type HandleFunc func(address common.Address, backend bind.ContractBackend) (interface{}, error)

// DeploySimpleContract handles no dependency contract deployments.
// All others must be handled in inheriting structs.
func (n BaseDeployer) DeploySimpleContract(ctx context.Context, deployFunction DeployFunc, handleFunction HandleFunc) (contracts.DeployedContract, error) {
    auth := n.backend.GetTxContext(ctx, nil)
    tmpAddress, tx, _, err := deployFunction(auth.TransactOpts, n.backend)
    if err != nil {
        return nil, fmt.Errorf("could not deploy contract of type %s: %w", n.contractType.ContractName(), err)
    }

    handle, err := handleFunction(tmpAddress, n.backend)
    if err != nil {
        return nil, fmt.Errorf("could not get handke: %w", err)
    }

    return &DeployedContract{
        address:        tmpAddress,
        contractHandle: handle,
        owner:          auth.From,
        chainID:        n.backend.GetBigChainID(),
        deployTx:       tx,
    }, nil
}