ethergo/backends/anvil/client_test.go
package anvil_test
import (
"github.com/brianvoe/gofakeit/v6"
"github.com/ethereum/go-ethereum/accounts/abi/bind"
"github.com/ethereum/go-ethereum/common"
. "github.com/stretchr/testify/assert"
"github.com/synapsecns/sanguine/ethergo/backends/anvil"
"github.com/synapsecns/sanguine/ethergo/mocks"
"math/big"
"time"
)
func (a *AnvilSuite) TestClientImpersonateAccount() {
ogCount, err := a.counter.GetVitalikCount(&bind.CallOpts{Context: a.GetTestContext()})
Nil(a.T(), err)
err = a.client.ImpersonateAccount(a.GetTestContext(), vitalik)
Nil(a.T(), err)
increment, err := a.counter.VitalikIncrement(&bind.TransactOpts{
From: vitalik,
Value: big.NewInt(0),
NoSend: true,
Signer: anvil.ImpersonatedSigner,
})
Nil(a.T(), err)
err = a.client.SendUnsignedTransaction(a.GetTestContext(), vitalik, increment)
Nil(a.T(), err)
vitalikCount, err := a.counter.GetVitalikCount(&bind.CallOpts{Context: a.GetTestContext()})
Nil(a.T(), err)
Equal(a.T(), ogCount.Uint64()+10, vitalikCount.Uint64())
defer func() {
err = a.client.StopImpersonatingAccount(a.GetTestContext(), vitalik)
Nil(a.T(), err)
}()
}
func (a *AnvilSuite) TestGetAutomine() {
isAutomining, err := a.client.GetAutomine(a.GetTestContext())
Nil(a.T(), err)
True(a.T(), isAutomining)
}
func (a *AnvilSuite) TestMine() {
for i := 0; i < 3; i++ {
height, err := a.backend.BlockNumber(a.GetTestContext())
Nil(a.T(), err)
mineCount := uint64(gofakeit.Number(1, 10))
err = a.client.Mine(a.GetTestContext(), uint(mineCount))
Nil(a.T(), err)
newHeight, err := a.backend.BlockNumber(a.GetTestContext())
Nil(a.T(), err)
Equal(a.T(), height+mineCount, newHeight)
}
}
func (a *AnvilSuite) TestReset() {
a.T().Skip("investigate why this is failing: method not implemented")
err := a.client.Mine(a.GetTestContext(), 1)
Nil(a.T(), err)
height, err := a.backend.BlockNumber(a.GetTestContext())
Nil(a.T(), err)
err = a.client.Reset(a.GetTestContext())
Nil(a.T(), err)
newHeight, err := a.backend.BlockNumber(a.GetTestContext())
Nil(a.T(), err)
Less(a.T(), newHeight, height)
}
// just make sure there's no error here.
func (a *AnvilSuite) TestSetRPCURL() {
err := a.client.SetRPCURL(a.GetTestContext(), a.forkAddress)
Nil(a.T(), err)
}
func (a *AnvilSuite) TestSetBalance() {
address := mocks.MockAddress()
balance := gofakeit.Uint64()
err := a.client.SetBalance(a.GetTestContext(), address, balance)
Nil(a.T(), err)
realBal, err := a.backend.BalanceAt(a.GetTestContext(), address, nil)
Nil(a.T(), err)
Equal(a.T(), balance, realBal.Uint64())
}
func (a *AnvilSuite) TestSetCode() {
address := mocks.MockAddress()
code := []byte("0x606060")
err := a.client.SetCode(a.GetTestContext(), address, code)
Nil(a.T(), err)
realCode, err := a.backend.Client().CodeAt(a.GetTestContext(), address, nil)
Nil(a.T(), err)
Equal(a.T(), code, realCode)
}
func (a *AnvilSuite) TestSetNonce() {
address := mocks.MockAddress()
nonce := uint64(gofakeit.Number(1, 100))
err := a.client.SetNonce(a.GetTestContext(), address, nonce)
Nil(a.T(), err)
realNonce, err := a.backend.NonceAt(a.GetTestContext(), address, nil)
Nil(a.T(), err)
Equal(a.T(), nonce, realNonce)
}
func (a *AnvilSuite) TestSetStorageAt() {
address := mocks.MockAddress()
key := common.HexToHash("0x0123456789abcdef")
value := common.HexToHash("0xabcdef1234567890")
err := a.client.SetStorageAt(a.GetTestContext(), address, key, value)
Nil(a.T(), err)
realValue, err := a.backend.StorageAt(a.GetTestContext(), address, key, nil)
Nil(a.T(), err)
Equal(a.T(), value, common.BytesToHash(realValue))
}
func (a *AnvilSuite) TestSetCoinbase() {
coinbase := mocks.MockAddress()
err := a.client.SetCoinbase(a.GetTestContext(), coinbase)
Nil(a.T(), err)
}
func (a *AnvilSuite) TestSetLoggingEnabled() {
err := a.client.SetLoggingEnabled(a.GetTestContext(), true)
Nil(a.T(), err)
}
func (a *AnvilSuite) TestDropTransactions() {
// TODO: test w/ a mempool
err := a.client.DropTransaction(a.GetTestContext(), common.Hash{})
Nil(a.T(), err)
}
func (a *AnvilSuite) TestSetMinGasPrice() {
a.T().Skip("This is disabled when eip-1559 is active, we might want to spin up a separate docker container for this later")
minGasPrice := big.NewInt(int64(gofakeit.Number(1, 100)))
err := a.client.SetMinGasPrice(a.GetTestContext(), minGasPrice)
Nil(a.T(), err)
}
func (a *AnvilSuite) TestSetNextBlockBaseFeePerGas() {
baseFee := big.NewInt(int64(gofakeit.Number(1, 100)))
err := a.client.SetNextBlockBaseFeePerGas(a.GetTestContext(), baseFee)
Nil(a.T(), err)
err = a.client.Mine(a.GetTestContext(), 1)
Nil(a.T(), err)
header, err := a.backend.Client().HeaderByNumber(a.GetTestContext(), nil)
Nil(a.T(), err)
Equal(a.T(), header.BaseFee, baseFee)
}
func (a *AnvilSuite) TestDumpState() {
stateHex, err := a.client.DumpState(a.GetTestContext())
Nil(a.T(), err)
NotEqual(a.T(), "", stateHex)
}
func (a *AnvilSuite) TestLoadState() {
stateHex, err := a.client.DumpState(a.GetTestContext())
Nil(a.T(), err)
err = a.client.LoadState(a.GetTestContext(), stateHex)
Nil(a.T(), err)
}
func (a *AnvilSuite) TestNodeInfo() {
nodeInfo, err := a.client.NodeInfo(a.GetTestContext())
Nil(a.T(), err)
NotNil(a.T(), nodeInfo)
}
func (a *AnvilSuite) TestSetAutomine() {
err := a.client.SetAutomine(a.GetTestContext(), false)
Nil(a.T(), err)
isAutomining, err := a.client.GetAutomine(a.GetTestContext())
Nil(a.T(), err)
False(a.T(), isAutomining)
err = a.client.SetAutomine(a.GetTestContext(), true)
Nil(a.T(), err)
isAutomining, err = a.client.GetAutomine(a.GetTestContext())
Nil(a.T(), err)
True(a.T(), isAutomining)
}
func (a *AnvilSuite) TestSetIntervalMining() {
a.T().Skip("This is disabled because it interferes with other tests, we might want to spin up a separate docker container for this later")
err := a.client.SetIntervalMining(a.GetTestContext(), 5)
Nil(a.T(), err)
}
func (a *AnvilSuite) TestSnapshotAndRevert() {
curBlock, err := a.backend.BlockNumber(a.GetTestContext())
Nil(a.T(), err)
snapshotID, err := a.client.Snapshot(a.GetTestContext())
Nil(a.T(), err)
err = a.client.Mine(a.GetTestContext(), 1)
Nil(a.T(), err)
err = a.client.Revert(a.GetTestContext(), snapshotID)
Nil(a.T(), err)
newBlock, err := a.backend.BlockNumber(a.GetTestContext())
Nil(a.T(), err)
Equal(a.T(), curBlock, newBlock)
}
func (a *AnvilSuite) TestIncreaseTime() {
// TODO: test w/ contract call
err := a.client.IncreaseTime(a.GetTestContext(), 60)
Nil(a.T(), err)
}
func (a *AnvilSuite) TestSetNextBlockTimestamp() {
timestamp := time.Now().Add(time.Hour * 10000).Unix()
err := a.client.SetNextBlockTimestamp(a.GetTestContext(), timestamp)
Nil(a.T(), err)
err = a.client.Mine(a.GetTestContext(), 1)
Nil(a.T(), err)
header, err := a.backend.Client().HeaderByNumber(a.GetTestContext(), nil)
Nil(a.T(), err)
Equal(a.T(), header.Time, uint64(timestamp))
}
func (a *AnvilSuite) TestSetRemoveBlockTimestampInterval() {
err := a.client.SetBlockTimestampInterval(a.GetTestContext(), 10)
Nil(a.T(), err)
// todo: can test this by mining some blocks and checking the timestamp
err = a.client.RemoveBlockTimestampInterval(a.GetTestContext())
Nil(a.T(), err)
}
func (a *AnvilSuite) TestSetBlockGasLimit() {
gasLimit := uint64(10000000)
err := a.client.SetBlockGasLimit(a.GetTestContext(), gasLimit)
Nil(a.T(), err)
err = a.client.Mine(a.GetTestContext(), 1)
Nil(a.T(), err)
header, err := a.backend.Client().HeaderByNumber(a.GetTestContext(), nil)
Nil(a.T(), err)
Equal(a.T(), header.GasLimit, gasLimit)
}
func (a *AnvilSuite) TestEvmMine() {
height, err := a.backend.BlockNumber(a.GetTestContext())
Nil(a.T(), err)
err = a.client.EvmMine(a.GetTestContext())
Nil(a.T(), err)
newHeight, err := a.backend.BlockNumber(a.GetTestContext())
Nil(a.T(), err)
Equal(a.T(), height+1, newHeight)
}
func (a *AnvilSuite) TestEnableTraces() {
a.T().Skip("not yet implemented")
err := a.client.EnableTraces(a.GetTestContext())
Nil(a.T(), err)
}