waku-org/go-waku

package web3

import (
    "context"
    "errors"
    "math/big"

    "github.com/ethereum/go-ethereum"
    "github.com/ethereum/go-ethereum/accounts/abi/bind"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/ethclient"
    "github.com/waku-org/go-waku/waku/v2/protocol/rln/contracts"
)

// RegistryContract contains an instance of the RLN Registry contract and its address
type RegistryContract struct {
    *contracts.RLNRegistry
    Address common.Address
}

// RLNContract contains an instance of the RLN contract, its address and the storage index within the registry
// that represents this contract
type RLNContract struct {
    *contracts.RLN
    Address             common.Address
    StorageIndex        uint16
    DeployedBlockNumber uint64
}

// EthClient is an interface for the ethclient.Client, so that we can pass mock client for testing
type EthClient interface {
    bind.ContractBackend
    SyncProgress(ctx context.Context) (*ethereum.SyncProgress, error)
    TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error)
    BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error)
    SubscribeNewHead(ctx context.Context, ch chan<- *types.Header) (ethereum.Subscription, error)
    Close()
}

// Config is a helper struct that contains attributes for interaction with RLN smart contracts
type Config struct {
    configured bool

    ETHClientAddress string
    ETHClient        EthClient
    ChainID          *big.Int
    RegistryContract RegistryContract
    RLNContract      RLNContract
}

// NewConfig creates an instance of web3 Config
func NewConfig(ethClientAddress string, registryAddress common.Address) *Config {
    return &Config{
        ETHClientAddress: ethClientAddress,
        RegistryContract: RegistryContract{
            Address: registryAddress,
        },
    }
}

// BuildConfig returns an instance of Web3Config with all the required elements for interaction with the RLN smart contracts
func BuildConfig(ctx context.Context, ethClientAddress string, registryAddress common.Address) (*Config, error) {
    ethClient, err := ethclient.DialContext(ctx, ethClientAddress)
    if err != nil {
        return nil, err
    }

    chainID, err := ethClient.ChainID(ctx)
    if err != nil {
        return nil, err
    }

    rlnRegistry, err := contracts.NewRLNRegistry(registryAddress, ethClient)
    if err != nil {
        return nil, err
    }

    storageIndex, err := rlnRegistry.UsingStorageIndex(&bind.CallOpts{Context: ctx})
    if err != nil {
        return nil, err
    }

    rlnContractAddress, err := rlnRegistry.Storages(&bind.CallOpts{Context: ctx}, storageIndex)
    if err != nil {
        return nil, err
    }

    rlnContract, err := contracts.NewRLN(rlnContractAddress, ethClient)
    if err != nil {
        return nil, err
    }

    deploymentBlockNumber, err := rlnContract.DeployedBlockNumber(&bind.CallOpts{Context: ctx})
    if err != nil {
        return nil, err
    }

    return &Config{
        configured:       true,
        ETHClientAddress: ethClientAddress,
        ETHClient:        ethClient,
        ChainID:          chainID,
        RegistryContract: RegistryContract{
            RLNRegistry: rlnRegistry,
            Address:     registryAddress,
        },
        RLNContract: RLNContract{
            RLN:                 rlnContract,
            Address:             rlnContractAddress,
            StorageIndex:        storageIndex,
            DeployedBlockNumber: uint64(deploymentBlockNumber),
        },
    }, nil
}

// Build sets up the Config object by instantiating the eth client and contracts
func (w *Config) Build(ctx context.Context) error {
    if w.configured {
        return errors.New("already configured")
    }

    if w.ETHClientAddress == "" {
        return errors.New("no eth client address")
    }

    var zeroAddr common.Address
    if w.RegistryContract.Address == zeroAddr {
        return errors.New("no registry contract address")
    }

    newW, err := BuildConfig(ctx, w.ETHClientAddress, w.RegistryContract.Address)
    if err != nil {
        return err
    }

    *w = *newW
    w.configured = true

    return nil
}