mirror of
https://github.com/arnaucube/hermez-node.git
synced 2026-02-07 03:16:45 +01:00
Rename load amount to deposit amount
This commit is contained in:
Arnau B
@@ -218,8 +218,8 @@ type RollupInterface interface {
|
||||
RollupWithdrawMerkleProof(babyPubKey *babyjub.PublicKey, tokenID uint32, numExitRoot, idx int64, amount *big.Int, siblings []*big.Int, instantWithdraw bool) (*types.Transaction, error)
|
||||
RollupWithdrawCircuit(proofA, proofC [2]*big.Int, proofB [2][2]*big.Int, tokenID uint32, numExitRoot, idx int64, amount *big.Int, instantWithdraw bool) (*types.Transaction, error)
|
||||
|
||||
RollupL1UserTxERC20ETH(fromBJJ *babyjub.PublicKey, fromIdx int64, loadAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64) (*types.Transaction, error)
|
||||
RollupL1UserTxERC20Permit(fromBJJ *babyjub.PublicKey, fromIdx int64, loadAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64, deadline *big.Int) (tx *types.Transaction, err error)
|
||||
RollupL1UserTxERC20ETH(fromBJJ *babyjub.PublicKey, fromIdx int64, depositAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64) (*types.Transaction, error)
|
||||
RollupL1UserTxERC20Permit(fromBJJ *babyjub.PublicKey, fromIdx int64, depositAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64, deadline *big.Int) (tx *types.Transaction, err error)
|
||||
|
||||
// Governance Public Functions
|
||||
RollupUpdateForgeL1L2BatchTimeout(newForgeL1L2BatchTimeout int64) (*types.Transaction, error)
|
||||
@@ -409,7 +409,7 @@ func (c *RollupClient) RollupWithdrawCircuit(proofA, proofC [2]*big.Int, proofB
|
||||
}
|
||||
|
||||
// RollupL1UserTxERC20ETH is the interface to call the smart contract function
|
||||
func (c *RollupClient) RollupL1UserTxERC20ETH(fromBJJ *babyjub.PublicKey, fromIdx int64, loadAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64) (tx *types.Transaction, err error) {
|
||||
func (c *RollupClient) RollupL1UserTxERC20ETH(fromBJJ *babyjub.PublicKey, fromIdx int64, depositAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64) (tx *types.Transaction, err error) {
|
||||
if tx, err = c.client.CallAuth(
|
||||
0,
|
||||
func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
|
||||
@@ -423,7 +423,7 @@ func (c *RollupClient) RollupL1UserTxERC20ETH(fromBJJ *babyjub.PublicKey, fromId
|
||||
}
|
||||
fromIdxBig := big.NewInt(fromIdx)
|
||||
toIdxBig := big.NewInt(toIdx)
|
||||
loadAmountF, err := common.NewFloat16(loadAmount)
|
||||
depositAmountF, err := common.NewFloat16(depositAmount)
|
||||
if err != nil {
|
||||
return nil, tracerr.Wrap(err)
|
||||
}
|
||||
@@ -432,10 +432,10 @@ func (c *RollupClient) RollupL1UserTxERC20ETH(fromBJJ *babyjub.PublicKey, fromId
|
||||
return nil, tracerr.Wrap(err)
|
||||
}
|
||||
if tokenID == 0 {
|
||||
auth.Value = loadAmount
|
||||
auth.Value = depositAmount
|
||||
}
|
||||
var permit []byte
|
||||
return c.hermez.AddL1Transaction(auth, babyPubKey, fromIdxBig, uint16(loadAmountF),
|
||||
return c.hermez.AddL1Transaction(auth, babyPubKey, fromIdxBig, uint16(depositAmountF),
|
||||
uint16(amountF), tokenID, toIdxBig, permit)
|
||||
},
|
||||
); err != nil {
|
||||
@@ -445,7 +445,7 @@ func (c *RollupClient) RollupL1UserTxERC20ETH(fromBJJ *babyjub.PublicKey, fromId
|
||||
}
|
||||
|
||||
// RollupL1UserTxERC20Permit is the interface to call the smart contract function
|
||||
func (c *RollupClient) RollupL1UserTxERC20Permit(fromBJJ *babyjub.PublicKey, fromIdx int64, loadAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64, deadline *big.Int) (tx *types.Transaction, err error) {
|
||||
func (c *RollupClient) RollupL1UserTxERC20Permit(fromBJJ *babyjub.PublicKey, fromIdx int64, depositAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64, deadline *big.Int) (tx *types.Transaction, err error) {
|
||||
if tx, err = c.client.CallAuth(
|
||||
0,
|
||||
func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
|
||||
@@ -459,7 +459,7 @@ func (c *RollupClient) RollupL1UserTxERC20Permit(fromBJJ *babyjub.PublicKey, fro
|
||||
}
|
||||
fromIdxBig := big.NewInt(fromIdx)
|
||||
toIdxBig := big.NewInt(toIdx)
|
||||
loadAmountF, err := common.NewFloat16(loadAmount)
|
||||
depositAmountF, err := common.NewFloat16(depositAmount)
|
||||
if err != nil {
|
||||
return nil, tracerr.Wrap(err)
|
||||
}
|
||||
@@ -468,7 +468,7 @@ func (c *RollupClient) RollupL1UserTxERC20Permit(fromBJJ *babyjub.PublicKey, fro
|
||||
return nil, tracerr.Wrap(err)
|
||||
}
|
||||
if tokenID == 0 {
|
||||
auth.Value = loadAmount
|
||||
auth.Value = depositAmount
|
||||
}
|
||||
owner := c.client.account.Address
|
||||
spender := c.address
|
||||
@@ -481,7 +481,7 @@ func (c *RollupClient) RollupL1UserTxERC20Permit(fromBJJ *babyjub.PublicKey, fro
|
||||
digest, _ := createPermitDigest(tokenAddr, owner, spender, c.chainID, amount, nonce, deadline, tokenName)
|
||||
signature, _ := c.client.ks.SignHash(*c.client.account, digest)
|
||||
permit := createPermit(owner, spender, amount, deadline, digest, signature)
|
||||
return c.hermez.AddL1Transaction(auth, babyPubKey, fromIdxBig, uint16(loadAmountF),
|
||||
return c.hermez.AddL1Transaction(auth, babyPubKey, fromIdxBig, uint16(depositAmountF),
|
||||
uint16(amountF), tokenID, toIdxBig, permit)
|
||||
},
|
||||
); err != nil {
|
||||
|
||||
@@ -267,18 +267,18 @@ func TestRollupL1UserTxETHCreateAccountDeposit(t *testing.T) {
|
||||
fromIdxInt64 := int64(0)
|
||||
toIdxInt64 := int64(0)
|
||||
tokenIDUint32 := uint32(0)
|
||||
loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
l1Tx := common.L1Tx{
|
||||
FromBJJ: key.BJJPublicKey,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
LoadAmount: loadAmount,
|
||||
TokenID: common.TokenID(tokenIDUint32),
|
||||
Amount: big.NewInt(0),
|
||||
FromBJJ: key.BJJPublicKey,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
DepositAmount: depositAmount,
|
||||
TokenID: common.TokenID(tokenIDUint32),
|
||||
Amount: big.NewInt(0),
|
||||
}
|
||||
L1UserTxs = append(L1UserTxs, l1Tx)
|
||||
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
|
||||
require.NoError(t, err)
|
||||
|
||||
currentBlockNum, err := rollupClient.client.EthLastBlock()
|
||||
@@ -287,7 +287,7 @@ func TestRollupL1UserTxETHCreateAccountDeposit(t *testing.T) {
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, l1Tx.FromBJJ, rollupEvents.L1UserTx[0].L1UserTx.FromBJJ)
|
||||
assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
|
||||
assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
|
||||
assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
|
||||
assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
|
||||
assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
|
||||
assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
|
||||
@@ -299,18 +299,18 @@ func TestRollupL1UserTxERC20CreateAccountDeposit(t *testing.T) {
|
||||
key := genKeysBjj(1)
|
||||
fromIdxInt64 := int64(0)
|
||||
toIdxInt64 := int64(0)
|
||||
loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
l1Tx := common.L1Tx{
|
||||
FromBJJ: key.BJJPublicKey,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
LoadAmount: loadAmount,
|
||||
TokenID: common.TokenID(tokenHEZID),
|
||||
Amount: big.NewInt(0),
|
||||
FromBJJ: key.BJJPublicKey,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
DepositAmount: depositAmount,
|
||||
TokenID: common.TokenID(tokenHEZID),
|
||||
Amount: big.NewInt(0),
|
||||
}
|
||||
L1UserTxs = append(L1UserTxs, l1Tx)
|
||||
|
||||
_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
|
||||
_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
|
||||
require.NoError(t, err)
|
||||
|
||||
currentBlockNum, err := rollupClient.client.EthLastBlock()
|
||||
@@ -319,7 +319,7 @@ func TestRollupL1UserTxERC20CreateAccountDeposit(t *testing.T) {
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, l1Tx.FromBJJ, rollupEvents.L1UserTx[0].L1UserTx.FromBJJ)
|
||||
assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
|
||||
assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
|
||||
assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
|
||||
assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
|
||||
assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
|
||||
assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
|
||||
@@ -331,18 +331,18 @@ func TestRollupL1UserTxERC20PermitCreateAccountDeposit(t *testing.T) {
|
||||
key := genKeysBjj(3)
|
||||
fromIdxInt64 := int64(0)
|
||||
toIdxInt64 := int64(0)
|
||||
loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
l1Tx := common.L1Tx{
|
||||
FromBJJ: key.BJJPublicKey,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
LoadAmount: loadAmount,
|
||||
TokenID: common.TokenID(tokenIDERC777),
|
||||
Amount: big.NewInt(0),
|
||||
FromBJJ: key.BJJPublicKey,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
DepositAmount: depositAmount,
|
||||
TokenID: common.TokenID(tokenIDERC777),
|
||||
Amount: big.NewInt(0),
|
||||
}
|
||||
L1UserTxs = append(L1UserTxs, l1Tx)
|
||||
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
|
||||
require.NoError(t, err)
|
||||
|
||||
currentBlockNum, err := rollupClient.client.EthLastBlock()
|
||||
@@ -351,7 +351,7 @@ func TestRollupL1UserTxERC20PermitCreateAccountDeposit(t *testing.T) {
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, l1Tx.FromBJJ, rollupEvents.L1UserTx[0].L1UserTx.FromBJJ)
|
||||
assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
|
||||
assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
|
||||
assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
|
||||
assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
|
||||
assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
|
||||
assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
|
||||
@@ -363,18 +363,18 @@ func TestRollupL1UserTxETHDeposit(t *testing.T) {
|
||||
fromIdxInt64 := int64(256)
|
||||
toIdxInt64 := int64(0)
|
||||
tokenIDUint32 := uint32(0)
|
||||
loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
l1Tx := common.L1Tx{
|
||||
FromBJJ: nil,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
LoadAmount: loadAmount,
|
||||
TokenID: common.TokenID(tokenIDUint32),
|
||||
Amount: big.NewInt(0),
|
||||
FromBJJ: nil,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
DepositAmount: depositAmount,
|
||||
TokenID: common.TokenID(tokenIDUint32),
|
||||
Amount: big.NewInt(0),
|
||||
}
|
||||
L1UserTxs = append(L1UserTxs, l1Tx)
|
||||
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
|
||||
require.NoError(t, err)
|
||||
|
||||
currentBlockNum, err := rollupClient.client.EthLastBlock()
|
||||
@@ -382,7 +382,7 @@ func TestRollupL1UserTxETHDeposit(t *testing.T) {
|
||||
rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
|
||||
assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
|
||||
assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
|
||||
assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
|
||||
assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
|
||||
assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
|
||||
@@ -393,18 +393,18 @@ func TestRollupL1UserTxERC20Deposit(t *testing.T) {
|
||||
require.NoError(t, err)
|
||||
fromIdxInt64 := int64(257)
|
||||
toIdxInt64 := int64(0)
|
||||
loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
l1Tx := common.L1Tx{
|
||||
FromBJJ: nil,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
LoadAmount: loadAmount,
|
||||
TokenID: common.TokenID(tokenHEZID),
|
||||
Amount: big.NewInt(0),
|
||||
FromBJJ: nil,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
DepositAmount: depositAmount,
|
||||
TokenID: common.TokenID(tokenHEZID),
|
||||
Amount: big.NewInt(0),
|
||||
}
|
||||
L1UserTxs = append(L1UserTxs, l1Tx)
|
||||
|
||||
_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
|
||||
_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
|
||||
require.NoError(t, err)
|
||||
|
||||
currentBlockNum, err := rollupClient.client.EthLastBlock()
|
||||
@@ -412,7 +412,7 @@ func TestRollupL1UserTxERC20Deposit(t *testing.T) {
|
||||
rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
|
||||
assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
|
||||
assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
|
||||
assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
|
||||
assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
|
||||
assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
|
||||
@@ -423,17 +423,17 @@ func TestRollupL1UserTxERC20PermitDeposit(t *testing.T) {
|
||||
require.NoError(t, err)
|
||||
fromIdxInt64 := int64(258)
|
||||
toIdxInt64 := int64(0)
|
||||
loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
l1Tx := common.L1Tx{
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
LoadAmount: loadAmount,
|
||||
TokenID: common.TokenID(tokenIDERC777),
|
||||
Amount: big.NewInt(0),
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
DepositAmount: depositAmount,
|
||||
TokenID: common.TokenID(tokenIDERC777),
|
||||
Amount: big.NewInt(0),
|
||||
}
|
||||
L1UserTxs = append(L1UserTxs, l1Tx)
|
||||
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
|
||||
require.NoError(t, err)
|
||||
|
||||
currentBlockNum, err := rollupClient.client.EthLastBlock()
|
||||
@@ -441,7 +441,7 @@ func TestRollupL1UserTxERC20PermitDeposit(t *testing.T) {
|
||||
rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
|
||||
assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
|
||||
assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
|
||||
assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
|
||||
assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
|
||||
assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
|
||||
@@ -453,18 +453,18 @@ func TestRollupL1UserTxETHDepositTransfer(t *testing.T) {
|
||||
fromIdxInt64 := int64(256)
|
||||
toIdxInt64 := int64(257)
|
||||
tokenIDUint32 := uint32(0)
|
||||
loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
amount, _ := new(big.Int).SetString("100000000000000000000", 10)
|
||||
l1Tx := common.L1Tx{
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
LoadAmount: loadAmount,
|
||||
TokenID: common.TokenID(tokenIDUint32),
|
||||
Amount: amount,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
DepositAmount: depositAmount,
|
||||
TokenID: common.TokenID(tokenIDUint32),
|
||||
Amount: amount,
|
||||
}
|
||||
L1UserTxs = append(L1UserTxs, l1Tx)
|
||||
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
|
||||
require.NoError(t, err)
|
||||
|
||||
currentBlockNum, err := rollupClient.client.EthLastBlock()
|
||||
@@ -472,7 +472,7 @@ func TestRollupL1UserTxETHDepositTransfer(t *testing.T) {
|
||||
rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
|
||||
assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
|
||||
assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
|
||||
assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
|
||||
assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
|
||||
assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
|
||||
@@ -483,18 +483,18 @@ func TestRollupL1UserTxERC20DepositTransfer(t *testing.T) {
|
||||
require.NoError(t, err)
|
||||
fromIdxInt64 := int64(257)
|
||||
toIdxInt64 := int64(258)
|
||||
loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
amount, _ := new(big.Int).SetString("100000000000000000000", 10)
|
||||
l1Tx := common.L1Tx{
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
LoadAmount: loadAmount,
|
||||
TokenID: common.TokenID(tokenHEZID),
|
||||
Amount: amount,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
DepositAmount: depositAmount,
|
||||
TokenID: common.TokenID(tokenHEZID),
|
||||
Amount: amount,
|
||||
}
|
||||
L1UserTxs = append(L1UserTxs, l1Tx)
|
||||
|
||||
_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
|
||||
_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
|
||||
require.NoError(t, err)
|
||||
|
||||
currentBlockNum, err := rollupClient.client.EthLastBlock()
|
||||
@@ -502,7 +502,7 @@ func TestRollupL1UserTxERC20DepositTransfer(t *testing.T) {
|
||||
rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
|
||||
assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
|
||||
assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
|
||||
assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
|
||||
assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
|
||||
assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
|
||||
@@ -513,18 +513,18 @@ func TestRollupL1UserTxERC20PermitDepositTransfer(t *testing.T) {
|
||||
require.NoError(t, err)
|
||||
fromIdxInt64 := int64(258)
|
||||
toIdxInt64 := int64(259)
|
||||
loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
amount, _ := new(big.Int).SetString("100000000000000000000", 10)
|
||||
l1Tx := common.L1Tx{
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
LoadAmount: loadAmount,
|
||||
TokenID: common.TokenID(tokenIDERC777),
|
||||
Amount: amount,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
DepositAmount: depositAmount,
|
||||
TokenID: common.TokenID(tokenIDERC777),
|
||||
Amount: amount,
|
||||
}
|
||||
L1UserTxs = append(L1UserTxs, l1Tx)
|
||||
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
|
||||
require.NoError(t, err)
|
||||
|
||||
currentBlockNum, err := rollupClient.client.EthLastBlock()
|
||||
@@ -532,7 +532,7 @@ func TestRollupL1UserTxERC20PermitDepositTransfer(t *testing.T) {
|
||||
rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
|
||||
assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
|
||||
assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
|
||||
assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
|
||||
assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
|
||||
assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
|
||||
@@ -544,18 +544,18 @@ func TestRollupL1UserTxETHCreateAccountDepositTransfer(t *testing.T) {
|
||||
fromIdxInt64 := int64(256)
|
||||
toIdxInt64 := int64(257)
|
||||
tokenIDUint32 := uint32(0)
|
||||
loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
amount, _ := new(big.Int).SetString("20000000000000000000", 10)
|
||||
l1Tx := common.L1Tx{
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
LoadAmount: loadAmount,
|
||||
TokenID: common.TokenID(tokenIDUint32),
|
||||
Amount: amount,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
DepositAmount: depositAmount,
|
||||
TokenID: common.TokenID(tokenIDUint32),
|
||||
Amount: amount,
|
||||
}
|
||||
L1UserTxs = append(L1UserTxs, l1Tx)
|
||||
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
|
||||
require.NoError(t, err)
|
||||
|
||||
currentBlockNum, err := rollupClient.client.EthLastBlock()
|
||||
@@ -563,7 +563,7 @@ func TestRollupL1UserTxETHCreateAccountDepositTransfer(t *testing.T) {
|
||||
rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
|
||||
assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
|
||||
assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
|
||||
assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
|
||||
assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
|
||||
assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
|
||||
@@ -574,18 +574,18 @@ func TestRollupL1UserTxERC20CreateAccountDepositTransfer(t *testing.T) {
|
||||
require.NoError(t, err)
|
||||
fromIdxInt64 := int64(257)
|
||||
toIdxInt64 := int64(258)
|
||||
loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
amount, _ := new(big.Int).SetString("30000000000000000000", 10)
|
||||
l1Tx := common.L1Tx{
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
LoadAmount: loadAmount,
|
||||
TokenID: common.TokenID(tokenHEZID),
|
||||
Amount: amount,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
DepositAmount: depositAmount,
|
||||
TokenID: common.TokenID(tokenHEZID),
|
||||
Amount: amount,
|
||||
}
|
||||
L1UserTxs = append(L1UserTxs, l1Tx)
|
||||
|
||||
_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
|
||||
_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
|
||||
require.NoError(t, err)
|
||||
|
||||
currentBlockNum, err := rollupClient.client.EthLastBlock()
|
||||
@@ -593,7 +593,7 @@ func TestRollupL1UserTxERC20CreateAccountDepositTransfer(t *testing.T) {
|
||||
rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
|
||||
assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
|
||||
assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
|
||||
assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
|
||||
assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
|
||||
assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
|
||||
@@ -604,18 +604,18 @@ func TestRollupL1UserTxERC20PermitCreateAccountDepositTransfer(t *testing.T) {
|
||||
require.NoError(t, err)
|
||||
fromIdxInt64 := int64(258)
|
||||
toIdxInt64 := int64(259)
|
||||
loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
|
||||
amount, _ := new(big.Int).SetString("40000000000000000000", 10)
|
||||
l1Tx := common.L1Tx{
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
LoadAmount: loadAmount,
|
||||
TokenID: common.TokenID(tokenIDERC777),
|
||||
Amount: amount,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
DepositAmount: depositAmount,
|
||||
TokenID: common.TokenID(tokenIDERC777),
|
||||
Amount: amount,
|
||||
}
|
||||
L1UserTxs = append(L1UserTxs, l1Tx)
|
||||
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
|
||||
require.NoError(t, err)
|
||||
|
||||
currentBlockNum, err := rollupClient.client.EthLastBlock()
|
||||
@@ -623,7 +623,7 @@ func TestRollupL1UserTxERC20PermitCreateAccountDepositTransfer(t *testing.T) {
|
||||
rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
|
||||
assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
|
||||
assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
|
||||
assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
|
||||
assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
|
||||
assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
|
||||
@@ -637,15 +637,15 @@ func TestRollupL1UserTxETHForceTransfer(t *testing.T) {
|
||||
tokenIDUint32 := uint32(0)
|
||||
amount, _ := new(big.Int).SetString("20000000000000000000", 10)
|
||||
l1Tx := common.L1Tx{
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
LoadAmount: big.NewInt(0),
|
||||
TokenID: common.TokenID(tokenIDUint32),
|
||||
Amount: amount,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
DepositAmount: big.NewInt(0),
|
||||
TokenID: common.TokenID(tokenIDUint32),
|
||||
Amount: amount,
|
||||
}
|
||||
L1UserTxs = append(L1UserTxs, l1Tx)
|
||||
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
|
||||
require.NoError(t, err)
|
||||
|
||||
currentBlockNum, err := rollupClient.client.EthLastBlock()
|
||||
@@ -653,7 +653,7 @@ func TestRollupL1UserTxETHForceTransfer(t *testing.T) {
|
||||
rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
|
||||
assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
|
||||
assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
|
||||
assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
|
||||
assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
|
||||
assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
|
||||
@@ -666,15 +666,15 @@ func TestRollupL1UserTxERC20ForceTransfer(t *testing.T) {
|
||||
toIdxInt64 := int64(258)
|
||||
amount, _ := new(big.Int).SetString("10000000000000000000", 10)
|
||||
l1Tx := common.L1Tx{
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
LoadAmount: big.NewInt(0),
|
||||
TokenID: common.TokenID(tokenHEZID),
|
||||
Amount: amount,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
DepositAmount: big.NewInt(0),
|
||||
TokenID: common.TokenID(tokenHEZID),
|
||||
Amount: amount,
|
||||
}
|
||||
L1UserTxs = append(L1UserTxs, l1Tx)
|
||||
|
||||
_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
|
||||
_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
|
||||
require.NoError(t, err)
|
||||
|
||||
currentBlockNum, err := rollupClient.client.EthLastBlock()
|
||||
@@ -682,7 +682,7 @@ func TestRollupL1UserTxERC20ForceTransfer(t *testing.T) {
|
||||
rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
|
||||
assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
|
||||
assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
|
||||
assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
|
||||
assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
|
||||
assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
|
||||
@@ -695,15 +695,15 @@ func TestRollupL1UserTxERC20PermitForceTransfer(t *testing.T) {
|
||||
toIdxInt64 := int64(260)
|
||||
amount, _ := new(big.Int).SetString("30000000000000000000", 10)
|
||||
l1Tx := common.L1Tx{
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
LoadAmount: big.NewInt(0),
|
||||
TokenID: common.TokenID(tokenIDERC777),
|
||||
Amount: amount,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
DepositAmount: big.NewInt(0),
|
||||
TokenID: common.TokenID(tokenIDERC777),
|
||||
Amount: amount,
|
||||
}
|
||||
L1UserTxs = append(L1UserTxs, l1Tx)
|
||||
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
|
||||
require.NoError(t, err)
|
||||
|
||||
currentBlockNum, err := rollupClient.client.EthLastBlock()
|
||||
@@ -711,7 +711,7 @@ func TestRollupL1UserTxERC20PermitForceTransfer(t *testing.T) {
|
||||
rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
|
||||
assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
|
||||
assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
|
||||
assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
|
||||
assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
|
||||
assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
|
||||
@@ -725,15 +725,15 @@ func TestRollupL1UserTxETHForceExit(t *testing.T) {
|
||||
tokenIDUint32 := uint32(0)
|
||||
amount, _ := new(big.Int).SetString("10000000000000000000", 10)
|
||||
l1Tx := common.L1Tx{
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
LoadAmount: big.NewInt(0),
|
||||
TokenID: common.TokenID(tokenIDUint32),
|
||||
Amount: amount,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
DepositAmount: big.NewInt(0),
|
||||
TokenID: common.TokenID(tokenIDUint32),
|
||||
Amount: amount,
|
||||
}
|
||||
L1UserTxs = append(L1UserTxs, l1Tx)
|
||||
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
|
||||
require.NoError(t, err)
|
||||
|
||||
currentBlockNum, err := rollupClient.client.EthLastBlock()
|
||||
@@ -741,7 +741,7 @@ func TestRollupL1UserTxETHForceExit(t *testing.T) {
|
||||
rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
|
||||
assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
|
||||
assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
|
||||
assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
|
||||
assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
|
||||
assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
|
||||
@@ -754,15 +754,15 @@ func TestRollupL1UserTxERC20ForceExit(t *testing.T) {
|
||||
toIdxInt64 := int64(1)
|
||||
amount, _ := new(big.Int).SetString("20000000000000000000", 10)
|
||||
l1Tx := common.L1Tx{
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
LoadAmount: big.NewInt(0),
|
||||
TokenID: common.TokenID(tokenHEZID),
|
||||
Amount: amount,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
DepositAmount: big.NewInt(0),
|
||||
TokenID: common.TokenID(tokenHEZID),
|
||||
Amount: amount,
|
||||
}
|
||||
L1UserTxs = append(L1UserTxs, l1Tx)
|
||||
|
||||
_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
|
||||
_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
|
||||
require.NoError(t, err)
|
||||
|
||||
currentBlockNum, err := rollupClient.client.EthLastBlock()
|
||||
@@ -770,7 +770,7 @@ func TestRollupL1UserTxERC20ForceExit(t *testing.T) {
|
||||
rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
|
||||
assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
|
||||
assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
|
||||
assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
|
||||
assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
|
||||
assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
|
||||
@@ -785,15 +785,15 @@ func TestRollupL1UserTxERC20PermitForceExit(t *testing.T) {
|
||||
*fromIdx = 0
|
||||
amount, _ := new(big.Int).SetString("30000000000000000000", 10)
|
||||
l1Tx := common.L1Tx{
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
LoadAmount: big.NewInt(0),
|
||||
TokenID: common.TokenID(tokenIDERC777),
|
||||
Amount: amount,
|
||||
FromIdx: common.Idx(fromIdxInt64),
|
||||
ToIdx: common.Idx(toIdxInt64),
|
||||
DepositAmount: big.NewInt(0),
|
||||
TokenID: common.TokenID(tokenIDERC777),
|
||||
Amount: amount,
|
||||
}
|
||||
L1UserTxs = append(L1UserTxs, l1Tx)
|
||||
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
|
||||
_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
|
||||
require.NoError(t, err)
|
||||
|
||||
currentBlockNum, err := rollupClient.client.EthLastBlock()
|
||||
@@ -801,7 +801,7 @@ func TestRollupL1UserTxERC20PermitForceExit(t *testing.T) {
|
||||
rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
|
||||
assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
|
||||
assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
|
||||
assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
|
||||
assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
|
||||
assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
|
||||
|
||||
Reference in New Issue
Block a user