1package eth
  2
  3import (
  4	"math/big"
  5	"testing"
  6	"time"
  7
  8	"github.com/stretchr/testify/assert"
  9	"github.com/stretchr/testify/require"
 10)
 11
 12var wdelayerClient *WDelayerClient
 13var wdelayerClientTest *WDelayerClient
 14
 15var initWithdrawalDelay = big.NewInt(60)
 16var newWithdrawalDelay = big.NewInt(79)
 17var maxEmergencyModeTime = time.Hour * 24 * 7 * 26
 18var maxWithdrawalDelay = time.Hour * 24 * 7 * 2
 19
 20func TestWDelayerConstants(t *testing.T) {
 21	wDelayerConstants, err := wdelayerClientTest.WDelayerConstants()
 22	require.Nil(t, err)
 23	assert.Equal(t, uint64(maxWithdrawalDelay.Seconds()), wDelayerConstants.MaxWithdrawalDelay)
 24	assert.Equal(t, uint64(maxEmergencyModeTime.Seconds()), wDelayerConstants.MaxEmergencyModeTime)
 25	assert.Equal(t, hermezRollupTestAddressConst, wDelayerConstants.HermezRollup)
 26}
 27
 28func TestWDelayerGetHermezGovernanceAddress(t *testing.T) {
 29	governanceAddress, err := wdelayerClientTest.WDelayerGetHermezGovernanceAddress()
 30	require.Nil(t, err)
 31	assert.Equal(t, &governanceAddressConst, governanceAddress)
 32}
 33
 34func TestWDelayerSetHermezGovernanceAddress(t *testing.T) {
 35	wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerTestAddressConst)
 36	require.Nil(t, err)
 37	_, err = wdelayerClientTest.WDelayerTransferGovernance(auxAddressConst)
 38	require.Nil(t, err)
 39	_, err = wdelayerClientAux.WDelayerClaimGovernance()
 40	require.Nil(t, err)
 41	auxAddress, err := wdelayerClientTest.WDelayerGetHermezGovernanceAddress()
 42	require.Nil(t, err)
 43	assert.Equal(t, &auxAddressConst, auxAddress)
 44	currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
 45	require.Nil(t, err)
 46	wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
 47	require.Nil(t, err)
 48	assert.Equal(t, auxAddressConst, wdelayerEvents.NewHermezGovernanceAddress[0].NewHermezGovernanceAddress)
 49	_, err = wdelayerClientAux.WDelayerTransferGovernance(governanceAddressConst)
 50	require.Nil(t, err)
 51	_, err = wdelayerClientTest.WDelayerClaimGovernance()
 52	require.Nil(t, err)
 53}
 54
 55func TestWDelayerGetEmergencyCouncil(t *testing.T) {
 56	emergencyCouncil, err := wdelayerClientTest.WDelayerGetEmergencyCouncil()
 57	require.Nil(t, err)
 58	assert.Equal(t, &emergencyCouncilAddressConst, emergencyCouncil)
 59}
 60
 61func TestWDelayerSetEmergencyCouncil(t *testing.T) {
 62	wdelayerClientEmergencyCouncil, err := NewWDelayerClient(ethereumClientEmergencyCouncil, wdelayerTestAddressConst)
 63	require.Nil(t, err)
 64	wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerTestAddressConst)
 65	require.Nil(t, err)
 66	_, err = wdelayerClientEmergencyCouncil.WDelayerTransferEmergencyCouncil(auxAddressConst)
 67	require.Nil(t, err)
 68	_, err = wdelayerClientAux.WDelayerClaimEmergencyCouncil()
 69	require.Nil(t, err)
 70	auxAddress, err := wdelayerClientTest.WDelayerGetEmergencyCouncil()
 71	require.Nil(t, err)
 72	assert.Equal(t, &auxAddressConst, auxAddress)
 73	currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
 74	require.Nil(t, err)
 75	wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
 76	require.Nil(t, err)
 77	assert.Equal(t, auxAddressConst, wdelayerEvents.NewEmergencyCouncil[0].NewEmergencyCouncil)
 78	_, err = wdelayerClientAux.WDelayerTransferEmergencyCouncil(emergencyCouncilAddressConst)
 79	require.Nil(t, err)
 80	_, err = wdelayerClientEmergencyCouncil.WDelayerClaimEmergencyCouncil()
 81	require.Nil(t, err)
 82}
 83
 84func TestWDelayerIsEmergencyMode(t *testing.T) {
 85	emergencyMode, err := wdelayerClientTest.WDelayerIsEmergencyMode()
 86	require.Nil(t, err)
 87	assert.Equal(t, false, emergencyMode)
 88}
 89
 90func TestWDelayerGetWithdrawalDelay(t *testing.T) {
 91	withdrawalDelay, err := wdelayerClientTest.WDelayerGetWithdrawalDelay()
 92	require.Nil(t, err)
 93	assert.Equal(t, initWithdrawalDelay, withdrawalDelay)
 94}
 95
 96func TestWDelayerChangeWithdrawalDelay(t *testing.T) {
 97	_, err := wdelayerClientTest.WDelayerChangeWithdrawalDelay(newWithdrawalDelay.Uint64())
 98	require.Nil(t, err)
 99	withdrawalDelay, err := wdelayerClientTest.WDelayerGetWithdrawalDelay()
100	require.Nil(t, err)
101	assert.Equal(t, newWithdrawalDelay, withdrawalDelay)
102	currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
103	require.Nil(t, err)
104	wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
105	require.Nil(t, err)
106	assert.Equal(t, newWithdrawalDelay.Uint64(), wdelayerEvents.NewWithdrawalDelay[0].WithdrawalDelay)
107}
108
109func TestWDelayerDeposit(t *testing.T) {
110	amount := new(big.Int)
111	amount.SetString("1100000000000000000", 10)
112	wdelayerClientHermez, err := NewWDelayerClient(ethereumClientHermez, wdelayerTestAddressConst)
113	require.Nil(t, err)
114	_, err = wdelayerClientHermez.WDelayerDeposit(auxAddressConst, tokenHEZAddressConst, amount)
115	require.Nil(t, err)
116	currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
117	require.Nil(t, err)
118	wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
119	require.Nil(t, err)
120	assert.Equal(t, amount, wdelayerEvents.Deposit[0].Amount)
121	assert.Equal(t, auxAddressConst, wdelayerEvents.Deposit[0].Owner)
122	assert.Equal(t, tokenHEZAddressConst, wdelayerEvents.Deposit[0].Token)
123}
124
125func TestWDelayerDepositInfo(t *testing.T) {
126	amount := new(big.Int)
127	amount.SetString("1100000000000000000", 10)
128	state, err := wdelayerClientTest.WDelayerDepositInfo(auxAddressConst, tokenHEZAddressConst)
129	require.Nil(t, err)
130	assert.Equal(t, state.Amount, amount)
131}
132
133func TestWDelayerWithdrawal(t *testing.T) {
134	amount := new(big.Int)
135	amount.SetString("1100000000000000000", 10)
136	_, err := wdelayerClientTest.WDelayerWithdrawal(auxAddressConst, tokenHEZAddressConst)
137	require.Contains(t, err.Error(), "WITHDRAWAL_NOT_ALLOWED")
138	addTime(float64(newWithdrawalDelay.Int64()), ethClientDialURL)
139	addBlock(ethClientDialURL)
140	_, err = wdelayerClientTest.WDelayerWithdrawal(auxAddressConst, tokenHEZAddressConst)
141	require.Nil(t, err)
142	currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
143	require.Nil(t, err)
144	wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
145	require.Nil(t, err)
146	assert.Equal(t, amount, wdelayerEvents.Withdraw[0].Amount)
147	assert.Equal(t, auxAddressConst, wdelayerEvents.Withdraw[0].Owner)
148	assert.Equal(t, tokenHEZAddressConst, wdelayerEvents.Withdraw[0].Token)
149}
150
151func TestWDelayerSecondDeposit(t *testing.T) {
152	amount := new(big.Int)
153	amount.SetString("1100000000000000000", 10)
154	wdelayerClientHermez, err := NewWDelayerClient(ethereumClientHermez, wdelayerTestAddressConst)
155	require.Nil(t, err)
156	_, err = wdelayerClientHermez.WDelayerDeposit(auxAddressConst, tokenHEZAddressConst, amount)
157	require.Nil(t, err)
158	currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
159	require.Nil(t, err)
160	wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
161	require.Nil(t, err)
162	assert.Equal(t, amount, wdelayerEvents.Deposit[0].Amount)
163	assert.Equal(t, auxAddressConst, wdelayerEvents.Deposit[0].Owner)
164	assert.Equal(t, tokenHEZAddressConst, wdelayerEvents.Deposit[0].Token)
165}
166
167func TestWDelayerEnableEmergencyMode(t *testing.T) {
168	_, err := wdelayerClientTest.WDelayerEnableEmergencyMode()
169	require.Nil(t, err)
170	emergencyMode, err := wdelayerClientTest.WDelayerIsEmergencyMode()
171	require.Nil(t, err)
172	assert.Equal(t, true, emergencyMode)
173	currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
174	require.Nil(t, err)
175	wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
176	require.Nil(t, err)
177	auxEvent := new(WDelayerEventEmergencyModeEnabled)
178	assert.Equal(t, auxEvent, &wdelayerEvents.EmergencyModeEnabled[0])
179}
180
181func TestWDelayerGetEmergencyModeStartingTime(t *testing.T) {
182	emergencyModeStartingTime, err := wdelayerClientTest.WDelayerGetEmergencyModeStartingTime()
183	require.Nil(t, err)
184	// `emergencyModeStartingTime` is initialized to 0 in the smart
185	// contract construction.  Since we called WDelayerEnableEmergencyMode
186	// previously, `emergencyModeStartingTime` is set to the time when the
187	// call was made, so it's > 0.
188	assert.True(t, emergencyModeStartingTime.Cmp(big.NewInt(0)) == 1)
189}
190
191func TestWDelayerEscapeHatchWithdrawal(t *testing.T) {
192	amount := new(big.Int)
193	amount.SetString("10000000000000000", 10)
194	wdelayerClientEmergencyCouncil, err := NewWDelayerClient(ethereumClientEmergencyCouncil, wdelayerTestAddressConst)
195	require.Nil(t, err)
196	_, err = wdelayerClientEmergencyCouncil.WDelayerEscapeHatchWithdrawal(governanceAddressConst, tokenHEZAddressConst, amount)
197	require.Contains(t, err.Error(), "NO_MAX_EMERGENCY_MODE_TIME")
198	seconds := maxEmergencyModeTime.Seconds()
199	addTime(seconds, ethClientDialURL)
200	_, err = wdelayerClientEmergencyCouncil.WDelayerEscapeHatchWithdrawal(governanceAddressConst, tokenHEZAddressConst, amount)
201	require.Nil(t, err)
202	currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
203	require.Nil(t, err)
204	wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
205	require.Nil(t, err)
206	assert.Equal(t, tokenHEZAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].Token)
207	assert.Equal(t, governanceAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].To)
208	assert.Equal(t, emergencyCouncilAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].Who)
209	assert.Equal(t, amount, wdelayerEvents.EscapeHatchWithdrawal[0].Amount)
210}