github.com/leovct/zkevm-bridge-service@v0.4.4/etherman/etherman_test.go (about) 1 package etherman 2 3 import ( 4 "context" 5 "math/big" 6 "testing" 7 8 "github.com/0xPolygonHermez/zkevm-bridge-service/log" 9 "github.com/0xPolygonHermez/zkevm-node/etherman/smartcontracts/polygonzkevm" 10 "github.com/0xPolygonHermez/zkevm-node/etherman/smartcontracts/polygonzkevmbridge" 11 "github.com/ethereum/go-ethereum/accounts/abi/bind" 12 "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" 13 "github.com/ethereum/go-ethereum/common" 14 "github.com/ethereum/go-ethereum/crypto" 15 "github.com/stretchr/testify/assert" 16 "github.com/stretchr/testify/require" 17 ) 18 19 func init() { 20 log.Init(log.Config{ 21 Level: "debug", 22 Outputs: []string{"stdout"}, 23 }) 24 } 25 26 // This function prepare the blockchain, the wallet with funds and deploy the smc 27 func newTestingEnv() (*Client, *backends.SimulatedBackend, *bind.TransactOpts, common.Address, *polygonzkevmbridge.Polygonzkevmbridge, *polygonzkevm.Polygonzkevm) { 28 privateKey, err := crypto.GenerateKey() 29 if err != nil { 30 log.Fatal(err) 31 } 32 auth, err := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(1337)) 33 if err != nil { 34 log.Fatal(err) 35 } 36 ethman, ethBackend, polAddr, bridge, zkevm, err := NewSimulatedEtherman(Config{}, auth) 37 if err != nil { 38 log.Fatal(err) 39 } 40 return ethman, ethBackend, auth, polAddr, bridge, zkevm 41 } 42 43 func TestGEREvent(t *testing.T) { 44 // Set up testing environment 45 etherman, ethBackend, auth, _, _, _ := newTestingEnv() 46 47 // Read currentBlock 48 ctx := context.Background() 49 initBlock, err := etherman.EtherClient.BlockByNumber(ctx, nil) 50 require.NoError(t, err) 51 52 amount := big.NewInt(1000000000000000) 53 auth.Value = amount 54 _, err = etherman.PolygonBridge.BridgeAsset(auth, 1, auth.From, amount, common.Address{}, true, []byte{}) 55 require.NoError(t, err) 56 57 // Mine the tx in a block 58 ethBackend.Commit() 59 60 // Now read the event 61 finalBlock, err := etherman.EtherClient.BlockByNumber(ctx, nil) 62 require.NoError(t, err) 63 finalBlockNumber := finalBlock.NumberU64() 64 blocks, _, err := etherman.GetRollupInfoByBlockRange(ctx, initBlock.NumberU64(), &finalBlockNumber) 65 require.NoError(t, err) 66 67 assert.NotEqual(t, common.Hash{}, blocks[0].GlobalExitRoots[0].ExitRoots[0]) 68 assert.Equal(t, common.Hash{}, blocks[0].GlobalExitRoots[0].ExitRoots[1]) 69 } 70 71 func TestBridgeEvents(t *testing.T) { 72 // Set up testing environment 73 etherman, ethBackend, auth, polAddr, bridge, _ := newTestingEnv() 74 75 // Read currentBlock 76 ctx := context.Background() 77 initBlock, err := etherman.EtherClient.BlockByNumber(ctx, nil) 78 require.NoError(t, err) 79 80 // Deposit funds 81 amount := big.NewInt(9000000000000000000) 82 var destNetwork uint32 = 1 // 0 is reserved to mainnet. This variable is set in the smc 83 destinationAddr := common.HexToAddress("0x61A1d716a74fb45d29f148C6C20A2eccabaFD753") 84 _, err = bridge.BridgeAsset(auth, destNetwork, destinationAddr, amount, polAddr, true, []byte{}) 85 require.NoError(t, err) 86 87 // Mine the tx in a block 88 ethBackend.Commit() 89 90 block, order, err := etherman.GetRollupInfoByBlockRange(ctx, initBlock.NumberU64(), nil) 91 require.NoError(t, err) 92 assert.Equal(t, DepositsOrder, order[block[0].BlockHash][0].Name) 93 assert.Equal(t, GlobalExitRootsOrder, order[block[0].BlockHash][1].Name) 94 assert.Equal(t, uint64(4), block[0].BlockNumber) 95 assert.Equal(t, big.NewInt(9000000000000000000), block[0].Deposits[0].Amount) 96 assert.Equal(t, uint(destNetwork), block[0].Deposits[0].DestinationNetwork) 97 assert.Equal(t, destinationAddr, block[0].Deposits[0].DestinationAddress) 98 assert.Equal(t, 1, len(block[0].GlobalExitRoots)) 99 100 //Claim funds 101 var ( 102 network uint32 103 smtProofLocalExitRoot, smtProofRollupExitRoot [32][32]byte 104 globalIndex, _ = big.NewInt(0).SetString("18446744073709551650", 0) 105 ) 106 mainnetExitRoot := block[0].GlobalExitRoots[0].ExitRoots[0] 107 rollupExitRoot := block[0].GlobalExitRoots[0].ExitRoots[1] 108 109 destNetwork = 1 110 _, err = bridge.ClaimAsset(auth, smtProofLocalExitRoot, smtProofRollupExitRoot, globalIndex, mainnetExitRoot, rollupExitRoot, 111 network, polAddr, destNetwork, auth.From, big.NewInt(1000000000000000000), []byte{}) 112 require.NoError(t, err) 113 114 // Mine the tx in a block 115 ethBackend.Commit() 116 117 //Read claim event 118 initBlock, err = etherman.EtherClient.BlockByNumber(ctx, nil) 119 require.NoError(t, err) 120 block, order, err = etherman.GetRollupInfoByBlockRange(ctx, initBlock.NumberU64(), nil) 121 require.NoError(t, err) 122 assert.Equal(t, TokensOrder, order[block[0].BlockHash][0].Name) 123 assert.Equal(t, ClaimsOrder, order[block[0].BlockHash][1].Name) 124 assert.Equal(t, big.NewInt(1000000000000000000), block[0].Claims[0].Amount) 125 assert.Equal(t, uint64(5), block[0].BlockNumber) 126 assert.NotEqual(t, common.Address{}, block[0].Claims[0].OriginalAddress) 127 assert.Equal(t, auth.From, block[0].Claims[0].DestinationAddress) 128 assert.Equal(t, uint(34), block[0].Claims[0].Index) 129 assert.Equal(t, uint64(0), block[0].Claims[0].RollupIndex) 130 assert.Equal(t, true, block[0].Claims[0].MainnetFlag) 131 assert.Equal(t, uint(0), block[0].Claims[0].OriginalNetwork) 132 assert.Equal(t, uint64(5), block[0].Claims[0].BlockNumber) 133 } 134 135 func TestDecodeGlobalIndex(t *testing.T) { 136 globalIndex, _ := big.NewInt(0).SetString("4294967307", 0) 137 138 var buf [32]byte 139 gi := globalIndex.FillBytes(buf[:]) 140 for _, n := range gi { 141 t.Logf("%08b ", n) 142 } 143 mainnetFlag, rollupIndex, localExitRootIndex, err := decodeGlobalIndex(globalIndex) 144 require.NoError(t, err) 145 assert.Equal(t, false, mainnetFlag) 146 assert.Equal(t, uint64(1), rollupIndex) 147 assert.Equal(t, uint64(11), localExitRootIndex) 148 149 globalIndex, _ = big.NewInt(0).SetString("8589934604", 0) 150 151 gi = globalIndex.FillBytes(buf[:]) 152 for _, n := range gi { 153 t.Logf("%08b ", n) 154 } 155 mainnetFlag, rollupIndex, localExitRootIndex, err = decodeGlobalIndex(globalIndex) 156 require.NoError(t, err) 157 assert.Equal(t, false, mainnetFlag) 158 assert.Equal(t, uint64(2), rollupIndex) 159 assert.Equal(t, uint64(12), localExitRootIndex) 160 161 globalIndex, _ = big.NewInt(0).SetString("18446744073709551627", 0) 162 163 gi = globalIndex.FillBytes(buf[:]) 164 for _, n := range gi { 165 t.Logf("%08b ", n) 166 } 167 mainnetFlag, rollupIndex, localExitRootIndex, err = decodeGlobalIndex(globalIndex) 168 require.NoError(t, err) 169 assert.Equal(t, true, mainnetFlag) 170 assert.Equal(t, uint64(0), rollupIndex) 171 assert.Equal(t, uint64(11), localExitRootIndex) 172 173 globalIndex, _ = big.NewInt(0).SetString("18446744073709551616", 0) 174 175 gi = globalIndex.FillBytes(buf[:]) 176 for _, n := range gi { 177 t.Logf("%08b ", n) 178 } 179 mainnetFlag, rollupIndex, localExitRootIndex, err = decodeGlobalIndex(globalIndex) 180 require.NoError(t, err) 181 assert.Equal(t, true, mainnetFlag) 182 assert.Equal(t, uint64(0), rollupIndex) 183 assert.Equal(t, uint64(0), localExitRootIndex) 184 } 185 186 func TestVerifyBatchEvent(t *testing.T) { 187 // Set up testing environment 188 etherman, ethBackend, auth, _, _, zkevm := newTestingEnv() 189 190 // Read currentBlock 191 ctx := context.Background() 192 193 initBlock, err := etherman.EtherClient.BlockByNumber(ctx, nil) 194 require.NoError(t, err) 195 196 rawTxs := "f84901843b9aca00827b0c945fbdb2315678afecb367f032d93f642f64180aa380a46057361d00000000000000000000000000000000000000000000000000000000000000048203e9808073efe1fa2d3e27f26f32208550ea9b0274d49050b816cadab05a771f4275d0242fd5d92b3fb89575c070e6c930587c520ee65a3aa8cfe382fcad20421bf51d621c" 197 tx := polygonzkevm.PolygonRollupBaseEtrogBatchData{ 198 ForcedGlobalExitRoot: common.Hash{}, 199 ForcedBlockHashL1: common.Hash{}, 200 ForcedTimestamp: 0, 201 Transactions: common.Hex2Bytes(rawTxs), 202 } 203 _, err = zkevm.SequenceBatches(auth, []polygonzkevm.PolygonRollupBaseEtrogBatchData{tx}, auth.From) 204 require.NoError(t, err) 205 206 // Mine the tx in a block 207 ethBackend.Commit() 208 209 _, err = etherman.PolygonRollupManager.VerifyBatchesTrustedAggregator(auth, 1, uint64(0), uint64(0), uint64(1), [32]byte{}, [32]byte{}, auth.From, [24][32]byte{}) 210 require.NoError(t, err) 211 212 // Mine the tx in a block 213 ethBackend.Commit() 214 215 // Now read the event 216 finalBlock, err := etherman.EtherClient.BlockByNumber(ctx, nil) 217 require.NoError(t, err) 218 finalBlockNumber := finalBlock.NumberU64() 219 blocks, order, err := etherman.GetRollupInfoByBlockRange(ctx, initBlock.NumberU64(), &finalBlockNumber) 220 require.NoError(t, err) 221 t.Logf("Blocks: %+v, \nOrder: %+v", blocks, order) 222 assert.Equal(t, uint64(5), blocks[0].BlockNumber) 223 assert.Equal(t, uint64(1), blocks[0].VerifiedBatches[0].BatchNumber) 224 assert.NotEqual(t, common.Address{}, blocks[0].VerifiedBatches[0].Aggregator) 225 assert.NotEqual(t, common.Hash{}, blocks[0].VerifiedBatches[0].TxHash) 226 assert.Equal(t, GlobalExitRootsOrder, order[blocks[0].BlockHash][0].Name) 227 assert.Equal(t, VerifyBatchOrder, order[blocks[0].BlockHash][1].Name) 228 assert.Equal(t, 0, order[blocks[0].BlockHash][0].Pos) 229 assert.Equal(t, 0, order[blocks[0].BlockHash][1].Pos) 230 } 231 232 func TestGenerateGlobalIndex(t *testing.T) { 233 globalIndex, _ := big.NewInt(0).SetString("4294967307", 0) 234 mainnetFlag, rollupIndex, localExitRootIndex := false, uint(1), uint(11) 235 globalIndexGenerated := GenerateGlobalIndex(mainnetFlag, rollupIndex, localExitRootIndex) 236 t.Log("First test number:") 237 for _, n := range globalIndexGenerated.Bytes() { 238 t.Logf("%08b ", n) 239 } 240 assert.Equal(t, globalIndex, globalIndexGenerated) 241 242 globalIndex, _ = big.NewInt(0).SetString("8589934604", 0) 243 mainnetFlag, rollupIndex, localExitRootIndex = false, uint(2), uint(12) 244 globalIndexGenerated = GenerateGlobalIndex(mainnetFlag, rollupIndex, localExitRootIndex) 245 t.Log("Second test number:") 246 for _, n := range globalIndexGenerated.Bytes() { 247 t.Logf("%08b ", n) 248 } 249 assert.Equal(t, globalIndex, globalIndexGenerated) 250 251 globalIndex, _ = big.NewInt(0).SetString("18446744073709551627", 0) 252 mainnetFlag, rollupIndex, localExitRootIndex = true, uint(0), uint(11) 253 globalIndexGenerated = GenerateGlobalIndex(mainnetFlag, rollupIndex, localExitRootIndex) 254 t.Log("Third test number:") 255 for _, n := range globalIndexGenerated.Bytes() { 256 t.Logf("%08b ", n) 257 } 258 assert.Equal(t, globalIndex, globalIndexGenerated) 259 }