synapsecns/sanguine

package mocks

import (
    "context"
    "github.com/ethereum/go-ethereum/accounts/keystore"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/params"
    "github.com/stretchr/testify/assert"
    "github.com/synapsecns/sanguine/ethergo/backends"
    "github.com/synapsecns/sanguine/ethergo/backends/simulated"
    "math/big"
    "testing"
)

// MockBlocksOnBackend mocks count blocks on a backend.
func MockBlocksOnBackend(ctx context.Context, t *testing.T, simulatedBackend backends.SimulatedTestBackend, count int) (blocks []*types.Block) {
    t.Helper()

    acct := simulatedBackend.GetFundedAccount(ctx, big.NewInt(params.Ether))
    lastBlock, err := simulatedBackend.BlockByNumber(ctx, nil)
    assert.Nil(t, err)

    // there should be done tx per block on simulated backend but we want to make sure
    defer func() {
        assert.Equal(t, count, len(blocks))
    }()

    for len(blocks) < count {
        MockTx(ctx, t, simulatedBackend, acct, types.LegacyTxType)
        newBlock, err := simulatedBackend.BlockByNumber(ctx, nil)
        assert.Nil(t, err)

        if newBlock.Number().Uint64() > lastBlock.Number().Uint64() {
            blocks = append(blocks, newBlock)
            lastBlock = newBlock
        }
    }
    return blocks
}

// GetMockTxes gets count txes from a new mock account. These are real txes ona  simulated chain
// useful for testing db interactions/adding noise to listeners.
func GetMockTxes(ctx context.Context, t *testing.T, count int, txType uint8) (txes []*types.Transaction) {
    t.Helper()
    simulatedBackend := simulated.NewSimulatedBackend(ctx, t)

    acct := simulatedBackend.GetFundedAccount(ctx, big.NewInt(params.Ether))
    for i := 0; i < count; i++ {
        txes = append(txes, MockTx(ctx, t, simulatedBackend, acct, txType))
    }
    return txes
}

// MockTx mocks a transaction on a simulated backend.
func MockTx(ctx context.Context, t *testing.T, simulatedBackend backends.SimulatedTestBackend, acct *keystore.Key, txType uint8) *types.Transaction {
    t.Helper()
    nonce, err := simulatedBackend.PendingNonceAt(ctx, acct.Address)
    assert.Nil(t, err)

    to := common.BigToAddress(big.NewInt(0))
    value := big.NewInt(params.GWei)

    var rawTx *types.Transaction
    switch txType {
    case types.LegacyTxType:
        gasPrice, err := simulatedBackend.SuggestGasPrice(ctx)
        assert.Nil(t, err)

        rawTx = types.NewTx(&types.LegacyTx{
            Nonce:    nonce,
            GasPrice: gasPrice,
            Gas:      21000,
            To:       &to,
            Value:    value,
        })
    case types.DynamicFeeTxType:
        gasTipCap, err := simulatedBackend.SuggestGasTipCap(ctx)
        assert.Nil(t, err)

        latestBlock, err := simulatedBackend.BlockByNumber(ctx, nil)
        assert.Nil(t, err)

        rawTx = types.NewTx(&types.DynamicFeeTx{
            ChainID:   simulatedBackend.GetBigChainID(),
            Nonce:     nonce,
            GasTipCap: gasTipCap,
            GasFeeCap: big.NewInt(0).Add(latestBlock.BaseFee(), gasTipCap),
            Gas:       21000,
            To:        &to,
            Value:     value,
        })
    default:
        t.Errorf("tx type %d unspoorted", txType)
    }

    signedTx, err := simulatedBackend.SignTx(rawTx, simulatedBackend.Signer(), acct.PrivateKey)
    assert.Nil(t, err)

    err = simulatedBackend.SendTransaction(ctx, signedTx)
    assert.Nil(t, err)

    return signedTx
}