Update ethclient contracts & add wdelayer events
laisolizq laisolizq@gmail.com
Mon, 28 Sep 2020 17:53:10 +0200
6 files changed,
376 insertions(+),
91 deletions(-)
M
eth/auction.go
→
eth/auction.go
@@ -281,10 +281,10 @@ contractAbi abi.ABI
} // NewAuctionClient creates a new AuctionClient. `tokenAddress` is the address of the HEZ tokens. -func NewAuctionClient(client *EthereumClient, address, tokenAddress ethCommon.Address) *AuctionClient { +func NewAuctionClient(client *EthereumClient, address, tokenAddress ethCommon.Address) (*AuctionClient, error) { contractAbi, err := abi.JSON(strings.NewReader(string(HermezAuctionProtocol.HermezAuctionProtocolABI))) if err != nil { - fmt.Println(err) + return nil, err } return &AuctionClient{ client: client,@@ -292,7 +292,7 @@ address: address,
tokenAddress: tokenAddress, gasLimit: 1000000, //nolint:gomnd contractAbi: contractAbi, - } + }, nil } // AuctionSetSlotDeadline is the interface to call the smart contract function@@ -841,6 +841,25 @@ }
return tx, nil } +// AuctionForge is the interface to call the smart contract function +func (c *AuctionClient) AuctionForge(forger ethCommon.Address) (*types.Transaction, error) { + var tx *types.Transaction + var err error + if tx, err = c.client.CallAuth( + c.gasLimit, + func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) { + auction, err := HermezAuctionProtocol.NewHermezAuctionProtocol(c.address, ec) + if err != nil { + return nil, err + } + return auction.Forge(auth, forger) + }, + ); err != nil { + return nil, fmt.Errorf("Failed forge: %w", err) + } + return tx, nil +} + // AuctionConstants returns the Constants of the Auction Smart Contract func (c *AuctionClient) AuctionConstants() (*AuctionConstants, error) { auctionConstants := new(AuctionConstants)@@ -942,6 +961,7 @@
// AuctionEventsByBlock returns the events in a block that happened in the Auction Smart Contract func (c *AuctionClient) AuctionEventsByBlock(blockNum int64) (*AuctionEvents, *ethCommon.Hash, error) { var auctionEvents AuctionEvents + var blockHash ethCommon.Hash query := ethereum.FilterQuery{ FromBlock: big.NewInt(blockNum),@@ -949,15 +969,20 @@ ToBlock: big.NewInt(blockNum),
Addresses: []ethCommon.Address{ c.address, }, - BlockHash: nil, // TODO: Maybe we can put the blockHash here to make sure we get the results from the known block. - Topics: [][]ethCommon.Hash{}, + Topics: [][]ethCommon.Hash{}, } logs, err := c.client.client.FilterLogs(context.TODO(), query) if err != nil { fmt.Println(err) } + if len(logs) > 0 { + blockHash = logs[0].BlockHash + } for _, vLog := range logs { + if vLog.BlockHash != blockHash { + return nil, nil, err + } switch vLog.Topics[0] { case logNewBid: var auxNewBid struct {@@ -1061,5 +1086,5 @@ HEZClaimed.Owner = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
auctionEvents.HEZClaimed = append(auctionEvents.HEZClaimed, HEZClaimed) } } - return &auctionEvents, nil, nil + return &auctionEvents, &blockHash, nil }
M
eth/auction_test.go
→
eth/auction_test.go
@@ -1,7 +1,6 @@
package eth import ( - "context" "math/big" "testing"@@ -19,7 +18,8 @@ var allocationRatioConst [3]uint16 = [3]uint16{4000, 4000, 2000}
var auctionClient *AuctionClient -var genesisBlock = 91 +//var genesisBlock = 91 +var genesisBlock = 98 var minBidStr = "10000000000000000000" var URL = "http://localhost:3000"@@ -41,7 +41,7 @@ auctionConstants, err := auctionClient.AuctionConstants()
require.Nil(t, err) assert.Equal(t, auctionConstants.BlocksPerSlot, BLOCKSPERSLOT) // assert.Equal(t, auctionConstants.GenesisBlockNum, GENESISBLOCKNUM) - assert.Equal(t, auctionConstants.HermezRollup, hermezRollupAddressConst) + assert.Equal(t, auctionConstants.HermezRollup, hermezRollupAddressTestConst) assert.Equal(t, auctionConstants.InitialMinimalBidding, INITMINBID) assert.Equal(t, auctionConstants.TokenHEZ, tokenHezAddressConst) }@@ -77,8 +77,8 @@ require.Nil(t, err)
slotDeadline, err := auctionClient.AuctionGetSlotDeadline() require.Nil(t, err) assert.Equal(t, newSlotDeadline, slotDeadline) - header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil) - auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64()) + currentBlockNum, _ := auctionClient.client.EthCurrentBlock() + auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum) assert.Equal(t, newSlotDeadline, auctionEvents.NewSlotDeadline[0].NewSlotDeadline) }@@ -96,8 +96,8 @@ require.Nil(t, err)
openAuctionSlots, err := auctionClient.AuctionGetOpenAuctionSlots() require.Nil(t, err) assert.Equal(t, newOpenAuctionSlots, openAuctionSlots) - header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil) - auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64()) + currentBlockNum, _ := auctionClient.client.EthCurrentBlock() + auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum) assert.Equal(t, newOpenAuctionSlots, auctionEvents.NewOpenAuctionSlots[0].NewOpenAuctionSlots) }@@ -115,8 +115,8 @@ require.Nil(t, err)
closedAuctionSlots, err := auctionClient.AuctionGetClosedAuctionSlots() require.Nil(t, err) assert.Equal(t, newClosedAuctionSlots, closedAuctionSlots) - header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil) - auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64()) + currentBlockNum, _ := auctionClient.client.EthCurrentBlock() + auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum) assert.Equal(t, newClosedAuctionSlots, auctionEvents.NewClosedAuctionSlots[0].NewClosedAuctionSlots) _, err = auctionClient.AuctionSetClosedAuctionSlots(closedAuctionSlots) require.Nil(t, err)@@ -136,8 +136,8 @@ require.Nil(t, err)
outbidding, err := auctionClient.AuctionGetOutbidding() require.Nil(t, err) assert.Equal(t, newOutbidding, outbidding) - header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil) - auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64()) + currentBlockNum, _ := auctionClient.client.EthCurrentBlock() + auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum) assert.Equal(t, newOutbidding, auctionEvents.NewOutbidding[0].NewOutbidding) _, err = auctionClient.AuctionSetOutbidding(outbiddingConst) require.Nil(t, err)@@ -157,8 +157,8 @@ require.Nil(t, err)
allocationRatio, err := auctionClient.AuctionGetAllocationRatio() require.Nil(t, err) assert.Equal(t, newAllocationRatio, allocationRatio) - header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil) - auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64()) + currentBlockNum, _ := auctionClient.client.EthCurrentBlock() + auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum) assert.Equal(t, newAllocationRatio, auctionEvents.NewAllocationRatio[0].NewAllocationRatio) _, err = auctionClient.AuctionSetAllocationRatio(allocationRatioConst) require.Nil(t, err)@@ -184,8 +184,8 @@ require.Nil(t, err)
donationAddress, err := auctionClient.AuctionGetDonationAddress() require.Nil(t, err) assert.Equal(t, &newDonationAddress, donationAddress) - header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil) - auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64()) + currentBlockNum, _ := auctionClient.client.EthCurrentBlock() + auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum) assert.Equal(t, newDonationAddress, auctionEvents.NewDonationAddress[0].NewDonationAddress) _, err = auctionClient.AuctionSetDonationAddress(donationAddressConst) require.Nil(t, err)@@ -199,8 +199,8 @@ require.Nil(t, err)
bootCoordinator, err := auctionClient.AuctionGetBootCoordinator() require.Nil(t, err) assert.Equal(t, &newBootCoordinator, bootCoordinator) - header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil) - auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64()) + currentBlockNum, _ := auctionClient.client.EthCurrentBlock() + auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum) assert.Equal(t, newBootCoordinator, auctionEvents.NewBootCoordinator[0].NewBootCoordinator) _, err = auctionClient.AuctionSetBootCoordinator(bootCoordinatorAddressConst) require.Nil(t, err)@@ -233,8 +233,8 @@ require.Nil(t, err)
minBid, err := auctionClient.AuctionGetDefaultSlotSetBid(set) require.Nil(t, err) assert.Equal(t, minBid, newInitialMinBid) - header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil) - auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64()) + currentBlockNum, _ := auctionClient.client.EthCurrentBlock() + auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum) assert.Equal(t, slotSet, auctionEvents.NewDefaultSlotSetBid[0].SlotSet) assert.Equal(t, newInitialMinBid, auctionEvents.NewDefaultSlotSetBid[0].NewInitialMinBid) newMinBid := new(big.Int)@@ -264,8 +264,8 @@ forgerAddress := governanceAddressConst
_, err := auctionClient.AuctionRegisterCoordinator(forgerAddress, URL) require.Nil(t, err) - header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil) - auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64()) + currentBlockNum, _ := auctionClient.client.EthCurrentBlock() + auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum) assert.Equal(t, forgerAddress, auctionEvents.NewCoordinator[0].ForgerAddress) assert.Equal(t, forgerAddress, auctionEvents.NewCoordinator[0].WithdrawalAddress) assert.Equal(t, URL, auctionEvents.NewCoordinator[0].CoordinatorURL)@@ -284,8 +284,8 @@ forgerAddress := governanceAddressConst
_, err := auctionClient.AuctionUpdateCoordinatorInfo(forgerAddress, forgerAddress, newURL) require.Nil(t, err) - header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil) - auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64()) + currentBlockNum, _ := auctionClient.client.EthCurrentBlock() + auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum) assert.Equal(t, forgerAddress, auctionEvents.CoordinatorUpdated[0].ForgerAddress) assert.Equal(t, forgerAddress, auctionEvents.CoordinatorUpdated[0].WithdrawalAddress) assert.Equal(t, newURL, auctionEvents.CoordinatorUpdated[0].CoordinatorURL)@@ -299,8 +299,8 @@ bidAmount.SetString("12000000000000000000", 10)
forgerAddress := governanceAddressConst _, err = auctionClient.AuctionBid(currentSlot+4, bidAmount, forgerAddress) require.Nil(t, err) - header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil) - auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64()) + currentBlockNum, _ := auctionClient.client.EthCurrentBlock() + auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum) assert.Equal(t, bidAmount, auctionEvents.NewBid[0].BidAmount) assert.Equal(t, forgerAddress, auctionEvents.NewBid[0].CoordinatorForger) assert.Equal(t, currentSlot+4, auctionEvents.NewBid[0].Slot)@@ -337,8 +337,8 @@ budget.SetString("45200000000000000000", 10)
forgerAddress := governanceAddressConst _, err = auctionClient.AuctionMultiBid(currentSlot+4, currentSlot+10, slotSet, maxBid, minBid, budget, forgerAddress) require.Nil(t, err) - header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil) - auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64()) + currentBlockNum, _ := auctionClient.client.EthCurrentBlock() + auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum) assert.Equal(t, forgerAddress, auctionEvents.NewBid[0].CoordinatorForger) assert.Equal(t, currentSlot+4, auctionEvents.NewBid[0].Slot) assert.Equal(t, forgerAddress, auctionEvents.NewBid[1].CoordinatorForger)@@ -365,8 +365,24 @@ amount.SetString("11000000000000000000", 10)
_, err := auctionClient.AuctionClaimHEZ(governanceAddressConst) require.Nil(t, err) - header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil) - auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64()) + currentBlockNum, _ := auctionClient.client.EthCurrentBlock() + auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum) assert.Equal(t, amount, auctionEvents.HEZClaimed[0].Amount) assert.Equal(t, governanceAddressConst, auctionEvents.HEZClaimed[0].Owner) } + +func TestAuctionForge(t *testing.T) { + auctionClientHermez, err := NewAuctionClient(ethereumClientHermez, auctionAddressConst, tokenHezAddressConst) + require.Nil(t, err) + slotConst := 4 + blockNum := int64(int(BLOCKSPERSLOT)*slotConst + genesisBlock) + currentBlockNum, _ := auctionClient.client.EthCurrentBlock() + blocksToAdd := blockNum - currentBlockNum + addBlocks(blocksToAdd, ethClientDialURL) + currentBlockNum, _ = auctionClient.client.EthCurrentBlock() + assert.Equal(t, currentBlockNum, blockNum) + _, err = auctionClientHermez.AuctionForge(bootCoordinatorAddressConst) + require.Contains(t, err.Error(), "Can't forge") + _, err = auctionClientHermez.AuctionForge(governanceAddressConst) + require.Nil(t, err) +}
A
eth/helpers.go
@@ -0,0 +1,63 @@
+package eth + +import ( + "fmt" + "net/http" + "strconv" + "strings" +) + +func addBlock(url string) { + method := "POST" + + payload := strings.NewReader("{\n \"jsonrpc\":\"2.0\",\n \"method\":\"evm_mine\",\n \"params\":[],\n \"id\":1\n}") + + client := &http.Client{} + req, err := http.NewRequest(method, url, payload) + + if err != nil { + fmt.Println(err) + } + req.Header.Add("Content-Type", "application/json") + + res, err := client.Do(req) + if err != nil { + fmt.Println(err) + } + defer func() { + if err := res.Body.Close(); err != nil { + fmt.Println("Error when closing:", err) + } + }() +} + +func addBlocks(numBlocks int64, url string) { + for i := int64(0); i < numBlocks; i++ { + addBlock(url) + } +} + +func addTime(seconds float64, url string) { + secondsStr := strconv.FormatFloat(seconds, 'E', -1, 32) + + method := "POST" + payload := strings.NewReader("{\n \"jsonrpc\":\"2.0\",\n \"method\":\"evm_increaseTime\",\n \"params\":[" + secondsStr + "],\n \"id\":1\n}") + + client := &http.Client{} + req, err := http.NewRequest(method, url, payload) + + if err != nil { + fmt.Println(err) + } + req.Header.Add("Content-Type", "application/json") + + res, err := client.Do(req) + if err != nil { + fmt.Println(err) + } + defer func() { + if err := res.Body.Close(); err != nil { + fmt.Println("Error when closing:", err) + } + }() +}
M
eth/main_test.go
→
eth/main_test.go
@@ -19,13 +19,15 @@ var tokenHezStr = os.Getenv("TOKEN_ADDRESS")
var hermezStr = os.Getenv("HERMEZ_ADDRESS") var governanceAddressStr = os.Getenv("GOV_ADDRESS") var governancePrivateKey = os.Getenv("GOV_PK") -var ehtClientDialURL = os.Getenv("ETHCLIENT_DIAL_URL")*/ -var ehtClientDialURL = "http://localhost:8545" +var ethClientDialURL = os.Getenv("ETHCLIENT_DIAL_URL")*/ +var ethClientDialURL = "http://localhost:8545" var password = "pass" // Smart Contract Addresses var ( - auctionAddressStr = "0x3619DbE27d7c1e7E91aA738697Ae7Bc5FC3eACA5" + // auctionAddressStr = "0x3619DbE27d7c1e7E91aA738697Ae7Bc5FC3eACA5" + // wdelayerAddressStr = "0x1A1FEe7EeD918BD762173e4dc5EfDB8a78C924A8" + auctionAddressStr = "0x8B5B7a6055E54a36fF574bbE40cf2eA68d5554b3" auctionAddressConst = ethCommon.HexToAddress(auctionAddressStr) donationAddressStr = "0x6c365935CA8710200C7595F0a72EB6023A7706Cd" donationAddressConst = ethCommon.HexToAddress(donationAddressStr)@@ -35,7 +37,7 @@ tokenHezAddressStr = "0xf4e77E5Da47AC3125140c470c71cBca77B5c638c" //nolint:gosec
tokenHezAddressConst = ethCommon.HexToAddress(tokenHezAddressStr) hermezRollupAddressStr = "0xc4905364b78a742ccce7B890A89514061E47068D" hermezRollupAddressConst = ethCommon.HexToAddress(hermezRollupAddressStr) - wdelayerAddressStr = "0x1A1FEe7EeD918BD762173e4dc5EfDB8a78C924A8" + wdelayerAddressStr = "0x20Ce94F404343aD2752A2D01b43fa407db9E0D00" wdelayerAddressConst = ethCommon.HexToAddress(wdelayerAddressStr) )@@ -60,6 +62,10 @@
auxAddressSK = "28d1bfbbafe9d1d4f5a11c3c16ab6bf9084de48d99fbac4058bdfa3c80b29089" auxAddressStr = "0x3d91185a02774C70287F6c74Dd26d13DFB58ff16" auxAddressConst = ethCommon.HexToAddress(auxAddressStr) + + hermezRollupTestSK = "28d1bfbbafe9d1d4f5a11c3c16ab6bf9084de48d99fbac4058bdfa3c80b29088" + hermezRollupTestAddressStr = "0xEa960515F8b4C237730F028cBAcF0a28E7F45dE0" + hermezRollupAddressTestConst = ethCommon.HexToAddress(hermezRollupTestAddressStr) ) var (@@ -68,12 +74,14 @@ accountKep *accounts.Account
accountWhite *accounts.Account accountGovDAO *accounts.Account accountAux *accounts.Account + accountHermez *accounts.Account ks *keystore.KeyStore ethClient *ethclient.Client ethereumClientWhite *EthereumClient ethereumClientKep *EthereumClient ethereumClientGovDAO *EthereumClient ethereumClientAux *EthereumClient + ethereumClientHermez *EthereumClient ) func addKey(ks *keystore.KeyStore, skHex string) *accounts.Account {@@ -108,8 +116,9 @@ accountKep = addKey(ks, hermezKeeperAddressSK)
accountWhite = addKey(ks, whiteHackGroupAddressSK) accountGovDAO = addKey(ks, hermezGovernanceDAOAddressSK) accountAux = addKey(ks, auxAddressSK) + accountHermez = addKey(ks, hermezRollupTestSK) - ethClient, err = ethclient.Dial(ehtClientDialURL) + ethClient, err = ethclient.Dial(ethClientDialURL) if err != nil { panic(err) }@@ -117,14 +126,15 @@
// Controllable Governance Address ethereumClientGov := NewEthereumClient(ethClient, accountGov, ks, nil) - auctionClient = NewAuctionClient(ethereumClientGov, auctionAddressConst, tokenHezAddressConst) + auctionClient, _ = NewAuctionClient(ethereumClientGov, auctionAddressConst, tokenHezAddressConst) rollupClient = NewRollupClient(ethereumClientGov, hermezRollupAddressConst) - wdelayerClient = NewWDelayerClient(ethereumClientGov, wdelayerAddressConst) + wdelayerClient, _ = NewWDelayerClient(ethereumClientGov, wdelayerAddressConst) ethereumClientKep = NewEthereumClient(ethClient, accountKep, ks, nil) ethereumClientWhite = NewEthereumClient(ethClient, accountWhite, ks, nil) ethereumClientGovDAO = NewEthereumClient(ethClient, accountGovDAO, ks, nil) ethereumClientAux = NewEthereumClient(ethClient, accountAux, ks, nil) + ethereumClientHermez = NewEthereumClient(ethClient, accountHermez, ks, nil) exitVal = m.Run() }
M
eth/wdelayer.go
→
eth/wdelayer.go
@@ -1,12 +1,17 @@
package eth import ( + "context" "fmt" "math/big" + "strings" + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" ethCommon "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethclient" WithdrawalDelayer "github.com/hermeznetwork/hermez-node/eth/contracts/withdrawdelayer" )@@ -128,18 +133,24 @@ //
// WDelayerClient is the implementation of the interface to the WithdrawDelayer Smart Contract in ethereum. type WDelayerClient struct { - client *EthereumClient - address ethCommon.Address - gasLimit uint64 + client *EthereumClient + address ethCommon.Address + gasLimit uint64 + contractAbi abi.ABI } // NewWDelayerClient creates a new WDelayerClient -func NewWDelayerClient(client *EthereumClient, address ethCommon.Address) *WDelayerClient { - return &WDelayerClient{ - client: client, - address: address, - gasLimit: 1000000, //nolint:gomnd +func NewWDelayerClient(client *EthereumClient, address ethCommon.Address) (*WDelayerClient, error) { + contractAbi, err := abi.JSON(strings.NewReader(string(WithdrawalDelayer.WithdrawalDelayerABI))) + if err != nil { + return nil, err } + return &WDelayerClient{ + client: client, + address: address, + gasLimit: 1000000, //nolint:gomnd + contractAbi: contractAbi, + }, nil } // WDelayerGetHermezGovernanceDAOAddress is the interface to call the smart contract function@@ -407,3 +418,108 @@ return nil, fmt.Errorf("Failed escapeHatchWithdrawal: %w", err)
} return tx, nil } + +var ( + logDeposit = crypto.Keccak256Hash([]byte("Deposit(address,address,uint192,uint64)")) + logWithdraw = crypto.Keccak256Hash([]byte("Withdraw(address,address,uint192)")) + logEmergencyModeEnabled = crypto.Keccak256Hash([]byte("EmergencyModeEnabled()")) + logNewWithdrawalDelay = crypto.Keccak256Hash([]byte("NewWithdrawalDelay(uint64)")) + logEscapeHatchWithdrawal = crypto.Keccak256Hash([]byte("EscapeHatchWithdrawal(address,address,address)")) + logNewHermezKeeperAddress = crypto.Keccak256Hash([]byte("NewHermezKeeperAddress(address)")) + logNewWhiteHackGroupAddress = crypto.Keccak256Hash([]byte("NewWhiteHackGroupAddress(address)")) + logNewHermezGovernanceDAOAddress = crypto.Keccak256Hash([]byte("NewHermezGovernanceDAOAddress(address)")) +) + +// WDelayerEventsByBlock returns the events in a block that happened in the WDelayer Smart Contract +func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64) (*WDelayerEvents, *ethCommon.Hash, error) { + var wdelayerEvents WDelayerEvents + var blockHash ethCommon.Hash + + query := ethereum.FilterQuery{ + FromBlock: big.NewInt(blockNum), + ToBlock: big.NewInt(blockNum), + Addresses: []ethCommon.Address{ + c.address, + }, + BlockHash: nil, + Topics: [][]ethCommon.Hash{}, + } + + logs, err := c.client.client.FilterLogs(context.Background(), query) + if err != nil { + fmt.Println(err) + } + if len(logs) > 0 { + blockHash = logs[0].BlockHash + } + for _, vLog := range logs { + if vLog.BlockHash != blockHash { + return nil, nil, err + } + switch vLog.Topics[0] { + case logDeposit: + var deposit WDelayerEventDeposit + err := c.contractAbi.Unpack(&deposit, "Deposit", vLog.Data) + if err != nil { + return nil, nil, err + } + deposit.Owner = ethCommon.BytesToAddress(vLog.Topics[1].Bytes()) + deposit.Token = ethCommon.BytesToAddress(vLog.Topics[2].Bytes()) + wdelayerEvents.Deposit = append(wdelayerEvents.Deposit, deposit) + + case logWithdraw: + var withdraw WDelayerEventWithdraw + err := c.contractAbi.Unpack(&withdraw, "Withdraw", vLog.Data) + if err != nil { + return nil, nil, err + } + withdraw.Token = ethCommon.BytesToAddress(vLog.Topics[1].Bytes()) + withdraw.Owner = ethCommon.BytesToAddress(vLog.Topics[2].Bytes()) + wdelayerEvents.Withdraw = append(wdelayerEvents.Withdraw, withdraw) + + case logEmergencyModeEnabled: + var emergencyModeEnabled WDelayerEventEmergencyModeEnabled + wdelayerEvents.EmergencyModeEnabled = append(wdelayerEvents.EmergencyModeEnabled, emergencyModeEnabled) + + case logNewWithdrawalDelay: + var withdrawalDelay WDelayerEventNewWithdrawalDelay + err := c.contractAbi.Unpack(&withdrawalDelay, "NewWithdrawalDelay", vLog.Data) + if err != nil { + return nil, nil, err + } + wdelayerEvents.NewWithdrawalDelay = append(wdelayerEvents.NewWithdrawalDelay, withdrawalDelay) + + case logEscapeHatchWithdrawal: + var escapeHatchWithdrawal WDelayerEventEscapeHatchWithdrawal + escapeHatchWithdrawal.Who = ethCommon.BytesToAddress(vLog.Topics[1].Bytes()) + escapeHatchWithdrawal.To = ethCommon.BytesToAddress(vLog.Topics[2].Bytes()) + escapeHatchWithdrawal.Token = ethCommon.BytesToAddress(vLog.Topics[3].Bytes()) + wdelayerEvents.EscapeHatchWithdrawal = append(wdelayerEvents.EscapeHatchWithdrawal, escapeHatchWithdrawal) + + case logNewHermezKeeperAddress: + var keeperAddress WDelayerEventNewHermezKeeperAddress + err := c.contractAbi.Unpack(&keeperAddress, "NewHermezKeeperAddress", vLog.Data) + if err != nil { + return nil, nil, err + } + wdelayerEvents.NewHermezKeeperAddress = append(wdelayerEvents.NewHermezKeeperAddress, keeperAddress) + + case logNewWhiteHackGroupAddress: + var whiteHackGroupAddress WDelayerEventNewWhiteHackGroupAddress + err := c.contractAbi.Unpack(&whiteHackGroupAddress, "NewWhiteHackGroupAddress", vLog.Data) + if err != nil { + return nil, nil, err + } + wdelayerEvents.NewWhiteHackGroupAddress = append(wdelayerEvents.NewWhiteHackGroupAddress, whiteHackGroupAddress) + + case logNewHermezGovernanceDAOAddress: + var governanceDAOAddress WDelayerEventNewHermezGovernanceDAOAddress + err := c.contractAbi.Unpack(&governanceDAOAddress, "NewHermezGovernanceDAOAddress", vLog.Data) + if err != nil { + return nil, nil, err + } + wdelayerEvents.NewHermezGovernanceDAOAddress = append(wdelayerEvents.NewHermezGovernanceDAOAddress, governanceDAOAddress) + } + } + return &wdelayerEvents, &blockHash, nil +}
M
eth/wdelayer_test.go
→
eth/wdelayer_test.go
@@ -3,6 +3,7 @@
import ( "math/big" "testing" + "time" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require"@@ -14,6 +15,7 @@ // var wdelayerClientKep *WDelayerClient
var initWithdrawalDelay = big.NewInt(60) var newWithdrawalDelay = big.NewInt(79) +var maxEmergencyModeTime = time.Hour * 24 * 7 * 26 func TestWDelayerGetHermezGovernanceDAOAddress(t *testing.T) { governanceAddress, err := wdelayerClient.WDelayerGetHermezGovernanceDAOAddress()@@ -22,13 +24,18 @@ assert.Equal(t, &hermezGovernanceDAOAddressConst, governanceAddress)
} func TestWDelayerSetHermezGovernanceDAOAddress(t *testing.T) { - wdelayerClientGov := NewWDelayerClient(ethereumClientGovDAO, wdelayerAddressConst) - _, err := wdelayerClientGov.WDelayerSetHermezGovernanceDAOAddress(auxAddressConst) + wdelayerClientGov, err := NewWDelayerClient(ethereumClientGovDAO, wdelayerAddressConst) + require.Nil(t, err) + _, err = wdelayerClientGov.WDelayerSetHermezGovernanceDAOAddress(auxAddressConst) require.Nil(t, err) auxAddress, err := wdelayerClient.WDelayerGetHermezGovernanceDAOAddress() require.Nil(t, err) assert.Equal(t, &auxAddressConst, auxAddress) - wdelayerClientAux := NewWDelayerClient(ethereumClientAux, wdelayerAddressConst) + currentBlockNum, _ := wdelayerClient.client.EthCurrentBlock() + wdelayerEvents, _, _ := wdelayerClient.WDelayerEventsByBlock(currentBlockNum) + assert.Equal(t, auxAddressConst, wdelayerEvents.NewHermezGovernanceDAOAddress[0].NewHermezGovernanceDAOAddress) + wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerAddressConst) + require.Nil(t, err) _, err = wdelayerClientAux.WDelayerSetHermezGovernanceDAOAddress(hermezGovernanceDAOAddressConst) require.Nil(t, err) }@@ -40,13 +47,18 @@ assert.Equal(t, &hermezKeeperAddressConst, keeperAddress)
} func TestWDelayerSetHermezKeeperAddress(t *testing.T) { - wdelayerClientKep := NewWDelayerClient(ethereumClientKep, wdelayerAddressConst) - _, err := wdelayerClientKep.WDelayerSetHermezKeeperAddress(auxAddressConst) + wdelayerClientKep, err := NewWDelayerClient(ethereumClientKep, wdelayerAddressConst) + require.Nil(t, err) + _, err = wdelayerClientKep.WDelayerSetHermezKeeperAddress(auxAddressConst) require.Nil(t, err) auxAddress, err := wdelayerClient.WDelayerGetHermezKeeperAddress() require.Nil(t, err) assert.Equal(t, &auxAddressConst, auxAddress) - wdelayerClientAux := NewWDelayerClient(ethereumClientAux, wdelayerAddressConst) + currentBlockNum, _ := wdelayerClient.client.EthCurrentBlock() + wdelayerEvents, _, _ := wdelayerClient.WDelayerEventsByBlock(currentBlockNum) + assert.Equal(t, auxAddressConst, wdelayerEvents.NewHermezKeeperAddress[0].NewHermezKeeperAddress) + wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerAddressConst) + require.Nil(t, err) _, err = wdelayerClientAux.WDelayerSetHermezKeeperAddress(hermezKeeperAddressConst) require.Nil(t, err) }@@ -58,13 +70,18 @@ assert.Equal(t, &whiteHackGroupAddressConst, whiteHackGroupAddress)
} func TestWDelayerSetWhiteHackGroupAddress(t *testing.T) { - wdelayerClientWhite := NewWDelayerClient(ethereumClientWhite, wdelayerAddressConst) - _, err := wdelayerClientWhite.WDelayerSetWhiteHackGroupAddress(auxAddressConst) + wdelayerClientWhite, err := NewWDelayerClient(ethereumClientWhite, wdelayerAddressConst) + require.Nil(t, err) + _, err = wdelayerClientWhite.WDelayerSetWhiteHackGroupAddress(auxAddressConst) require.Nil(t, err) auxAddress, err := wdelayerClient.WDelayerGetWhiteHackGroupAddress() require.Nil(t, err) assert.Equal(t, &auxAddressConst, auxAddress) - wdelayerClientAux := NewWDelayerClient(ethereumClientAux, wdelayerAddressConst) + currentBlockNum, _ := wdelayerClient.client.EthCurrentBlock() + wdelayerEvents, _, _ := wdelayerClient.WDelayerEventsByBlock(currentBlockNum) + assert.Equal(t, auxAddressConst, wdelayerEvents.NewWhiteHackGroupAddress[0].NewWhiteHackGroupAddress) + wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerAddressConst) + require.Nil(t, err) _, err = wdelayerClientAux.WDelayerSetWhiteHackGroupAddress(whiteHackGroupAddressConst) require.Nil(t, err) }@@ -81,22 +98,68 @@ require.Nil(t, err)
assert.Equal(t, initWithdrawalDelay, withdrawalDelay) } -func TestWDelayerEnableEmergencyMode(t *testing.T) { - wdelayerClientKep := NewWDelayerClient(ethereumClientKep, wdelayerAddressConst) - _, err := wdelayerClientKep.WDelayerEnableEmergencyMode() +func TestWDelayerChangeWithdrawalDelay(t *testing.T) { + wdelayerClientKep, err := NewWDelayerClient(ethereumClientKep, wdelayerAddressConst) + require.Nil(t, err) + _, err = wdelayerClientKep.WDelayerChangeWithdrawalDelay(newWithdrawalDelay.Uint64()) + require.Nil(t, err) + withdrawalDelay, err := wdelayerClient.WDelayerGetWithdrawalDelay() + require.Nil(t, err) + assert.Equal(t, newWithdrawalDelay, withdrawalDelay) + currentBlockNum, _ := wdelayerClient.client.EthCurrentBlock() + wdelayerEvents, _, _ := wdelayerClient.WDelayerEventsByBlock(currentBlockNum) + assert.Equal(t, newWithdrawalDelay.Uint64(), wdelayerEvents.NewWithdrawalDelay[0].WithdrawalDelay) +} + +func TestWDelayerDeposit(t *testing.T) { + amount := new(big.Int) + amount.SetString("1100000000000000000", 10) + wdelayerClientHermez, err := NewWDelayerClient(ethereumClientHermez, wdelayerAddressConst) + require.Nil(t, err) + _, err = wdelayerClientHermez.WDelayerDeposit(auxAddressConst, tokenHezAddressConst, amount) + require.Nil(t, err) + currentBlockNum, _ := wdelayerClient.client.EthCurrentBlock() + wdelayerEvents, _, _ := wdelayerClient.WDelayerEventsByBlock(currentBlockNum) + assert.Equal(t, amount, wdelayerEvents.Deposit[0].Amount) + assert.Equal(t, auxAddressConst, wdelayerEvents.Deposit[0].Owner) + assert.Equal(t, tokenHezAddressConst, wdelayerEvents.Deposit[0].Token) +} + +func TestWDelayerDepositInfo(t *testing.T) { + amount := new(big.Int) + amount.SetString("1100000000000000000", 10) + state, err := wdelayerClient.WDelayerDepositInfo(auxAddressConst, tokenHezAddressConst) require.Nil(t, err) - emergencyMode, err := wdelayerClient.WDelayerIsEmergencyMode() + assert.Equal(t, state.Amount, amount) +} + +func TestWDelayerWithdrawal(t *testing.T) { + amount := new(big.Int) + amount.SetString("1100000000000000000", 10) + _, err := wdelayerClient.WDelayerWithdrawal(auxAddressConst, tokenHezAddressConst) + require.Contains(t, err.Error(), "Withdrawal not allowed yet") + addBlocks(newWithdrawalDelay.Int64(), ethClientDialURL) + _, err = wdelayerClient.WDelayerWithdrawal(auxAddressConst, tokenHezAddressConst) require.Nil(t, err) - assert.Equal(t, true, emergencyMode) + currentBlockNum, _ := wdelayerClient.client.EthCurrentBlock() + wdelayerEvents, _, _ := wdelayerClient.WDelayerEventsByBlock(currentBlockNum) + assert.Equal(t, amount, wdelayerEvents.Withdraw[0].Amount) + assert.Equal(t, auxAddressConst, wdelayerEvents.Withdraw[0].Owner) + assert.Equal(t, tokenHezAddressConst, wdelayerEvents.Withdraw[0].Token) } -func TestWDelayerChangeWithdrawalDelay(t *testing.T) { - wdelayerClientKep := NewWDelayerClient(ethereumClientKep, wdelayerAddressConst) - _, err := wdelayerClientKep.WDelayerChangeWithdrawalDelay(newWithdrawalDelay.Uint64()) +func TestWDelayerEnableEmergencyMode(t *testing.T) { + wdelayerClientKep, err := NewWDelayerClient(ethereumClientKep, wdelayerAddressConst) require.Nil(t, err) - withdrawalDelay, err := wdelayerClient.WDelayerGetWithdrawalDelay() + _, err = wdelayerClientKep.WDelayerEnableEmergencyMode() + require.Nil(t, err) + emergencyMode, err := wdelayerClient.WDelayerIsEmergencyMode() require.Nil(t, err) - assert.Equal(t, newWithdrawalDelay, withdrawalDelay) + assert.Equal(t, true, emergencyMode) + currentBlockNum, _ := wdelayerClient.client.EthCurrentBlock() + wdelayerEvents, _, _ := wdelayerClient.WDelayerEventsByBlock(currentBlockNum) + auxEvent := new(WDelayerEventEmergencyModeEnabled) + assert.Equal(t, auxEvent, &wdelayerEvents.EmergencyModeEnabled[0]) } func TestWDelayerGetEmergencyModeStartingTime(t *testing.T) {@@ -109,26 +172,18 @@ // call was made, so it's > 0.
assert.True(t, emergencyModeStartingTime.Cmp(big.NewInt(0)) == 1) } -/* func TestWDelayerDeposit(t *testing.T) { - if wdelayerClient != nil { - - } -} - -func TestWDelayerDepositInfo(t *testing.T) { - if wdelayerClient != nil { - - } -} - -func TestWDelayerWithdrawal(t *testing.T) { - if wdelayerClient != nil { - - } -} - func TestWDelayerEscapeHatchWithdrawal(t *testing.T) { - if wdelayerClient != nil { - - } -} */ + wdelayerClientWhite, err := NewWDelayerClient(ethereumClientWhite, wdelayerAddressConst) + require.Nil(t, err) + _, err = wdelayerClientWhite.WDelayerEscapeHatchWithdrawal(governanceAddressConst, tokenHezAddressConst) + require.Contains(t, err.Error(), "NO MAX_EMERGENCY_MODE_TIME") + seconds := maxEmergencyModeTime.Seconds() + addTime(seconds, ethClientDialURL) + _, err = wdelayerClientWhite.WDelayerEscapeHatchWithdrawal(governanceAddressConst, tokenHezAddressConst) + require.Nil(t, err) + currentBlockNum, _ := wdelayerClient.client.EthCurrentBlock() + wdelayerEvents, _, _ := wdelayerClient.WDelayerEventsByBlock(currentBlockNum) + assert.Equal(t, tokenHezAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].Token) + assert.Equal(t, governanceAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].To) + assert.Equal(t, whiteHackGroupAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].Who) +}