diff --git a/pkg/validator/validator.go b/pkg/validator/validator.go index b31d88f..e844cc5 100644 --- a/pkg/validator/validator.go +++ b/pkg/validator/validator.go @@ -98,6 +98,9 @@ func (s *service) Start(ctx context.Context, wg *sync.WaitGroup) { select { case <-s.quitChan: s.logger.Infof("last validated block %v", idxBlockNum-1) + if s.progressChan != nil { + close(s.progressChan) + } return default: idxBlockNum, err = s.Validate(ctx, api, idxBlockNum) @@ -113,9 +116,6 @@ func (s *service) Start(ctx context.Context, wg *sync.WaitGroup) { // Stop is used to gracefully stop the service func (s *service) Stop() { s.logger.Info("stopping ipld-eth-db-validator process") - if s.progressChan != nil { - close(s.progressChan) - } close(s.quitChan) } diff --git a/test/contract/contracts/Test.sol b/test/contract/contracts/Test.sol new file mode 100644 index 0000000..8fe1b4b --- /dev/null +++ b/test/contract/contracts/Test.sol @@ -0,0 +1,29 @@ +// SPDX-License-Identifier: AGPL-3.0 +pragma solidity ^0.8.0; + +contract Test { + address payable owner; + + modifier onlyOwner { + require( + msg.sender == owner, + "Only owner can call this function." + ); + _; + } + + uint256[100] data; + + constructor() { + owner = payable(msg.sender); + data = [1]; + } + + function Put(uint256 addr, uint256 value) public { + data[addr] = value; + } + + function close() public onlyOwner { + selfdestruct(owner); + } +} diff --git a/test/contract/src/index.js b/test/contract/src/index.js index b20d54a..f42b6af 100644 --- a/test/contract/src/index.js +++ b/test/contract/src/index.js @@ -63,6 +63,49 @@ fastify.get('/v1/sendEth', async (req, reply) => { } }); +fastify.get('/v1/deployTestContract', async (req, reply) => { + const testContract = await hre.ethers.getContractFactory("Test"); + const test = await testContract.deploy(); + await test.deployed(); + + return { + address: test.address, + txHash: test.deployTransaction.hash, + blockNumber: test.deployTransaction.blockNumber, + blockHash: test.deployTransaction.blockHash, + } +}); + +fastify.get('/v1/putTestValue', async (req, reply) => { + const addr = req.query.addr; + const index = req.query.index; + const value = req.query.value; + + const testContract = await hre.ethers.getContractFactory("Test"); + const test = await testContract.attach(addr); + + const tx = await test.Put(index, value); + const receipt = await tx.wait(); + + return { + blockNumber: receipt.blockNumber, + } +}); + +fastify.get('/v1/destroyTestContract', async (req, reply) => { + const addr = req.query.addr; + + const testContract = await hre.ethers.getContractFactory("Test"); + const test = await testContract.attach(addr); + + await test.destroy(); + const blockNum = await hre.ethers.provider.getBlockNumber() + + return { + blockNumber: blockNum, + } +}) + async function main() { try { await fastify.listen(3000, '0.0.0.0'); @@ -72,4 +115,4 @@ async function main() { } } -main(); \ No newline at end of file +main(); diff --git a/test/helper.go b/test/helper.go new file mode 100644 index 0000000..bca384f --- /dev/null +++ b/test/helper.go @@ -0,0 +1,54 @@ +package integration + +import ( + "encoding/json" + "fmt" + "net/http" + + ethServerIntegration "github.com/vulcanize/ipld-eth-server/v3/test" +) + +type PutResult struct { + BlockNumber int64 `json:"blockNumber"` +} + +const srvUrl = "http://localhost:3000" + +func DeployTestContract() (*ethServerIntegration.ContractDeployed, error) { + ethServerIntegration.DeployContract() + res, err := http.Get(fmt.Sprintf("%s/v1/deployTestContract", srvUrl)) + if err != nil { + return nil, err + } + defer res.Body.Close() + + var contract ethServerIntegration.ContractDeployed + decoder := json.NewDecoder(res.Body) + + return &contract, decoder.Decode(&contract) +} + +func PutTestValue(addr string, index, value int) (*PutResult, error) { + res, err := http.Get(fmt.Sprintf("%s/v1/putTestValue?addr=%s&index=%d&value=%d", srvUrl, addr, index, value)) + if err != nil { + return nil, err + } + + var blockNumber PutResult + decoder := json.NewDecoder(res.Body) + + return &blockNumber, decoder.Decode(&blockNumber) +} + +func DestroyTestContract(addr string) (*ethServerIntegration.ContractDestroyed, error) { + res, err := http.Get(fmt.Sprintf("%s/v1/destroyTestContract?addr=%s", srvUrl, addr)) + if err != nil { + return nil, err + } + defer res.Body.Close() + + var data ethServerIntegration.ContractDestroyed + decoder := json.NewDecoder(res.Body) + + return &data, decoder.Decode(&data) +} diff --git a/test/integration_test.go b/test/integration_test.go index ec0c1ba..9101a6a 100644 --- a/test/integration_test.go +++ b/test/integration_test.go @@ -9,9 +9,10 @@ import ( . "github.com/onsi/gomega" "github.com/vulcanize/ipld-eth-db-validator/pkg/validator" + integration "github.com/vulcanize/ipld-eth-db-validator/test" "github.com/vulcanize/ipld-eth-server/v3/pkg/shared" - integration "github.com/vulcanize/ipld-eth-server/v3/test" + ethServerIntegration "github.com/vulcanize/ipld-eth-server/v3/test" ) const ( @@ -19,12 +20,28 @@ const ( validatorSleepInterval = uint(5) ) +var ( + testAddresses = []string{ + "0x1111111111111111111111111111111111111112", + "0x1ca7c995f8eF0A2989BbcE08D5B7Efe50A584aa1", + "0x9a4b666af23a2cdb4e5538e1d222a445aeb82134", + "0xF7C7AEaECD2349b129d5d15790241c32eeE4607B", + "0x992b6E9BFCA1F7b0797Cee10b0170E536EAd3532", + "0x29ed93a7454Bc17a8D4A24D0627009eE0849B990", + "0x66E3dCA826b04B5d4988F7a37c91c9b1041e579D", + "0x96288939Ac7048c27E0E087b02bDaad3cd61b37b", + "0xD354280BCd771541c935b15bc04342c26086FE9B", + "0x7f887e25688c274E77b8DeB3286A55129B55AF14", + } +) + var _ = Describe("Integration test", func() { ctx := context.Background() - var contract *integration.ContractDeployed - var contractErr error - sleepInterval := 5 * time.Second + var contract *ethServerIntegration.ContractDeployed + var err error + sleepInterval := 2 * time.Second + timeout := 4 * time.Second db := shared.SetupDB() validationProgressChan := make(chan uint64) @@ -35,6 +52,10 @@ var _ = Describe("Integration test", func() { It("test init", func() { wg.Add(1) go service.Start(ctx, wg) + + // Deploy a dummy contract as the first contract might get deployed at block number 0 + _, _ = ethServerIntegration.DeployContract() + time.Sleep(sleepInterval) }) defer It("test teardown", func() { @@ -45,20 +66,35 @@ var _ = Describe("Integration test", func() { }) Describe("Validate state", func() { - BeforeEach(func() { - // Deploy a dummy contract as the first contract might get deployed at block number 0 - _, _ = integration.DeployContract() + It("performs validation on contract deployment", func() { + contract, err = integration.DeployTestContract() + Expect(err).ToNot(HaveOccurred()) time.Sleep(sleepInterval) - contract, contractErr = integration.DeployContract() - time.Sleep(sleepInterval) - }) - - It("performs state root validation", func() { - Expect(contractErr).ToNot(HaveOccurred()) - Expect(validationProgressChan).ToNot(BeClosed()) - Eventually(validationProgressChan).Should(Receive(Equal(uint64(contract.BlockNumber)))) + Eventually(validationProgressChan, timeout).Should(Receive(Equal(uint64(contract.BlockNumber)))) + }) + + It("performs validation on contract transactions", func() { + for i := 0; i < 10; i++ { + res, txErr := integration.PutTestValue(contract.Address, i, i) + Expect(txErr).ToNot(HaveOccurred()) + time.Sleep(sleepInterval) + + Expect(validationProgressChan).ToNot(BeClosed()) + Eventually(validationProgressChan, timeout).Should(Receive(Equal(uint64(res.BlockNumber)))) + } + }) + + It("performs validation on eth transfer transactions", func() { + for _, address := range testAddresses { + tx, txErr := ethServerIntegration.SendEth(address, "0.01") + Expect(txErr).ToNot(HaveOccurred()) + time.Sleep(sleepInterval) + + Expect(validationProgressChan).ToNot(BeClosed()) + Eventually(validationProgressChan, timeout).Should(Receive(Equal(uint64(tx.BlockNumber)))) + } }) }) })