arnaucube/hermez-node
1
0
Fork 0
mirror of https://github.com/arnaucube/hermez-node.git synced 2026-02-08 11:56:46 +01:00
Code Issues Packages Projects Releases Wiki Activity

Update ethclient contracts & add wdelayer events

Browse Source
This commit is contained in:
laisolizq
2020-09-28 17:53:10 +02:00
parent 8efbb7ab18
commit 8451b92295
6 changed files with 377 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

139
eth/wdelayer_test.go
View File

@@ -3,6 +3,7 @@ package eth
import (
"math/big"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
@@ -14,6 +15,7 @@ var wdelayerClient *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 @@ func TestWDelayerGetHermezGovernanceDAOAddress(t *testing.T) {
}
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 @@ func TestWDelayerGetHermezKeeperAddress(t *testing.T) {
}
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 @@ func TestWDelayerGetWhiteHackGroupAddress(t *testing.T) {
}
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 @@ func TestWDelayerGetWithdrawalDelay(t *testing.T) {
assert.Equal(t, initWithdrawalDelay, withdrawalDelay)
}
func TestWDelayerEnableEmergencyMode(t *testing.T) {
wdelayerClientKep := NewWDelayerClient(ethereumClientKep, wdelayerAddressConst)
_, err := wdelayerClientKep.WDelayerEnableEmergencyMode()
require.Nil(t, err)
emergencyMode, err := wdelayerClient.WDelayerIsEmergencyMode()
require.Nil(t, err)
assert.Equal(t, true, emergencyMode)
}
func TestWDelayerChangeWithdrawalDelay(t *testing.T) {
wdelayerClientKep := NewWDelayerClient(ethereumClientKep, wdelayerAddressConst)
_, err := wdelayerClientKep.WDelayerChangeWithdrawalDelay(newWithdrawalDelay.Uint64())
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)
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)
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 TestWDelayerEnableEmergencyMode(t *testing.T) {
wdelayerClientKep, err := NewWDelayerClient(ethereumClientKep, wdelayerAddressConst)
require.Nil(t, err)
_, err = wdelayerClientKep.WDelayerEnableEmergencyMode()
require.Nil(t, err)
emergencyMode, err := wdelayerClient.WDelayerIsEmergencyMode()
require.Nil(t, err)
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 @@ func TestWDelayerGetEmergencyModeStartingTime(t *testing.T) {
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)
}