synapsecns/sanguine

package deployer

import (
    "fmt"
    "github.com/ethereum/go-ethereum/common"
    ethCore "github.com/ethereum/go-ethereum/core"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/core/vm"
    "github.com/synapsecns/sanguine/core"
    "github.com/synapsecns/sanguine/ethergo/contracts"
    "math/big"
)

// DeployedContract represents a deployed contract. It is returned by a deployer after a successful deployment.
type DeployedContract struct {
    // address is the address where the contract has been deployed
    address common.Address
    // contractHandle is the actual handle returned by deploying the contract
    // this must be castt o be useful
    contractHandle interface{}
    // owner of the contract
    owner common.Address
    // deployTx is the transaction where the contract was created
    deployTx *types.Transaction
    // chainID is the chain id where the contract is deployed
    chainID *big.Int
}

// NewDeployedContract creates a new deployed contract. We take some shortcuts by making some assumptions:
// namely, that tx sender is owner.
func NewDeployedContract(handle vm.ContractRef, deployTx *types.Transaction) (DeployedContract, error) {
    // TODO: eip-2930 signer?
    msg, err := ethCore.TransactionToMessage(deployTx, types.LatestSignerForChainID(deployTx.ChainId()), nil)
    if err != nil {
        return DeployedContract{}, fmt.Errorf("failed to get message from deployTx: %w", err)
    }

    return DeployedContract{
        address:        handle.Address(),
        contractHandle: handle,
        owner:          msg.From,
        deployTx:       deployTx,
        chainID:        deployTx.ChainId(),
    }, nil
}

// Address gets the address of the deployed contract.
func (d DeployedContract) Address() common.Address {
    return d.address
}

// ContractHandle is the contract handle of the deployed ocontract.
func (d DeployedContract) ContractHandle() interface{} {
    return d.contractHandle
}

// Owner gets the contract owner.
func (d DeployedContract) Owner() common.Address {
    return d.owner
}

// OwnerPtr returns a pointer to the owner (useful for GetTxContext() operations).
func (d DeployedContract) OwnerPtr() *common.Address {
    return &d.owner
}

// DeployTx gets the deploy transaction.
func (d DeployedContract) DeployTx() *types.Transaction {
    return d.deployTx
}

// ChainID is the chain id of the deployed contract.
func (d DeployedContract) ChainID() *big.Int {
    return core.CopyBigInt(d.chainID)
}

// String returns a string representation of the contract metadata.
func (d DeployedContract) String() string {
    return fmt.Sprintf("address: %s, owner: %s, chainID: %s, deployTX: %s", d.address.String(), d.owner.String(), d.chainID.String(), d.deployTx.Hash())
}

var _ contracts.DeployedContract = DeployedContract{}