hermez-node/txselector/txselector.go
txselector/txselector.goRaw
1package txselector
2
3// current: very simple version of TxSelector
4
5import (
6 "bytes"
7 "fmt"
8 "math/big"
9 "sort"
10
11 ethCommon "github.com/ethereum/go-ethereum/common"
12 "github.com/hermeznetwork/hermez-node/common"
13 "github.com/hermeznetwork/hermez-node/db/l2db"
14 "github.com/hermeznetwork/hermez-node/db/statedb"
15 "github.com/hermeznetwork/hermez-node/log"
16 "github.com/hermeznetwork/hermez-node/txprocessor"
17 "github.com/hermeznetwork/tracerr"
18 "github.com/iden3/go-iden3-crypto/babyjub"
19)
20
21// txs implements the interface Sort for an array of Tx
22type txs []common.PoolL2Tx
23
24func (t txs) Len() int {
25 return len(t)
26}
27func (t txs) Swap(i, j int) {
28 t[i], t[j] = t[j], t[i]
29}
30func (t txs) Less(i, j int) bool {
31 return t[i].AbsoluteFee > t[j].AbsoluteFee
32}
33
34// CoordAccount contains the data of the Coordinator account, that will be used
35// to create new transactions of CreateAccountDeposit type to add new TokenID
36// accounts for the Coordinator to receive the fees.
37type CoordAccount struct {
38 Addr ethCommon.Address
39 BJJ babyjub.PublicKeyComp
40 AccountCreationAuth []byte // signature in byte array format
41}
42
43// SelectionConfig contains the parameters of configuration of the selection of
44// transactions for the next batch
45type SelectionConfig struct {
46 // MaxL1UserTxs is the maximum L1-user-tx for a batch
47 MaxL1UserTxs uint64
48
49 // TxProcessorConfig contains the config for ProcessTxs
50 TxProcessorConfig txprocessor.Config
51}
52
53// TxSelector implements all the functionalities to select the txs for the next
54// batch
55type TxSelector struct {
56 l2db *l2db.L2DB
57 localAccountsDB *statedb.LocalStateDB
58
59 coordAccount *CoordAccount
60}
61
62// NewTxSelector returns a *TxSelector
63func NewTxSelector(coordAccount *CoordAccount, dbpath string,
64 synchronizerStateDB *statedb.StateDB, l2 *l2db.L2DB) (*TxSelector, error) {
65 localAccountsDB, err := statedb.NewLocalStateDB(dbpath, 128,
66 synchronizerStateDB, statedb.TypeTxSelector, 0) // without merkletree
67 if err != nil {
68 return nil, tracerr.Wrap(err)
69 }
70
71 return &TxSelector{
72 l2db: l2,
73 localAccountsDB: localAccountsDB,
74 coordAccount: coordAccount,
75 }, nil
76}
77
78// LocalAccountsDB returns the LocalStateDB of the TxSelector
79func (txsel *TxSelector) LocalAccountsDB() *statedb.LocalStateDB {
80 return txsel.localAccountsDB
81}
82
83// Reset tells the TxSelector to get it's internal AccountsDB
84// from the required `batchNum`
85func (txsel *TxSelector) Reset(batchNum common.BatchNum) error {
86 err := txsel.localAccountsDB.Reset(batchNum, true)
87 if err != nil {
88 return tracerr.Wrap(err)
89 }
90 return nil
91}
92
93func (txsel *TxSelector) getCoordIdx(tokenID common.TokenID) (common.Idx, error) {
94 return txsel.localAccountsDB.GetIdxByEthAddrBJJ(txsel.coordAccount.Addr,
95 txsel.coordAccount.BJJ, tokenID)
96}
97
98// coordAccountForTokenID creates a new L1CoordinatorTx to create a new
99// Coordinator account for the given TokenID in the case that the account does
100// not exist yet in the db, and does not exist a L1CoordinatorTx to creat that
101// account in the given array of L1CoordinatorTxs. If a new Coordinator account
102// needs to be created, a new L1CoordinatorTx will be returned from this
103// function. After calling this method, if the l1CoordinatorTx is added to the
104// selection, positionL1 must be increased 1.
105func (txsel *TxSelector) coordAccountForTokenID(l1CoordinatorTxs []common.L1Tx,
106 tokenID common.TokenID, positionL1 int) (*common.L1Tx, int, error) {
107 // check if CoordinatorAccount for TokenID is already pending to create
108 if checkAlreadyPendingToCreate(l1CoordinatorTxs, tokenID,
109 txsel.coordAccount.Addr, txsel.coordAccount.BJJ) {
110 return nil, positionL1, nil
111 }
112 _, err := txsel.getCoordIdx(tokenID)
113 if tracerr.Unwrap(err) == statedb.ErrIdxNotFound {
114 // create L1CoordinatorTx to create new CoordAccount for
115 // TokenID
116 l1CoordinatorTx := common.L1Tx{
117 Position: positionL1,
118 UserOrigin: false,
119 FromEthAddr: txsel.coordAccount.Addr,
120 FromBJJ: txsel.coordAccount.BJJ,
121 TokenID: tokenID,
122 Amount: big.NewInt(0),
123 DepositAmount: big.NewInt(0),
124 Type: common.TxTypeCreateAccountDeposit,
125 }
126
127 return &l1CoordinatorTx, positionL1, nil
128 }
129 if err != nil {
130 return nil, positionL1, tracerr.Wrap(err)
131 }
132 // CoordAccount for TokenID already exists
133 return nil, positionL1, nil
134}
135
136// GetL2TxSelection returns the L1CoordinatorTxs and a selection of the L2Txs
137// for the next batch, from the L2DB pool.
138// It returns: the CoordinatorIdxs used to receive the fees of the selected
139// L2Txs. An array of bytearrays with the signatures of the
140// AccountCreationAuthorization of the accounts of the users created by the
141// Coordinator with L1CoordinatorTxs of those accounts that does not exist yet
142// but there is a transactions to them and the authorization of account
143// creation exists. The L1UserTxs, L1CoordinatorTxs, PoolL2Txs that will be
144// included in the next batch.
145func (txsel *TxSelector) GetL2TxSelection(selectionConfig *SelectionConfig) ([]common.Idx,
146 [][]byte, []common.L1Tx, []common.PoolL2Tx, []common.PoolL2Tx, error) {
147 coordIdxs, accCreationAuths, _, l1CoordinatorTxs, l2Txs, discardedL2Txs, err :=
148 txsel.GetL1L2TxSelection(selectionConfig, []common.L1Tx{})
149 return coordIdxs, accCreationAuths, l1CoordinatorTxs, l2Txs, discardedL2Txs, tracerr.Wrap(err)
150}
151
152// GetL1L2TxSelection returns the selection of L1 + L2 txs.
153// It returns: the CoordinatorIdxs used to receive the fees of the selected
154// L2Txs. An array of bytearrays with the signatures of the
155// AccountCreationAuthorization of the accounts of the users created by the
156// Coordinator with L1CoordinatorTxs of those accounts that does not exist yet
157// but there is a transactions to them and the authorization of account
158// creation exists. The L1UserTxs, L1CoordinatorTxs, PoolL2Txs that will be
159// included in the next batch.
160func (txsel *TxSelector) GetL1L2TxSelection(selectionConfig *SelectionConfig,
161 l1UserTxs []common.L1Tx) ([]common.Idx, [][]byte, []common.L1Tx,
162 []common.L1Tx, []common.PoolL2Tx, []common.PoolL2Tx, error) {
163 // WIP.0: the TxSelector is not optimized and will need a redesign. The
164 // current version is implemented in order to have a functional
165 // implementation that can be used asap.
166 //
167 // WIP.1: this method uses a 'cherry-pick' of internal calls of the
168 // StateDB, a refactor of the StateDB to reorganize it internally is
169 // planned once the main functionallities are covered, with that
170 // refactor the TxSelector will be updated also.
171
172 // get pending l2-tx from tx-pool
173 l2TxsRaw, err := txsel.l2db.GetPendingTxs()
174 if err != nil {
175 return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
176 }
177
178 txselStateDB := txsel.localAccountsDB.StateDB
179 tp := txprocessor.NewTxProcessor(txselStateDB, selectionConfig.TxProcessorConfig)
180
181 // Process L1UserTxs
182 for i := 0; i < len(l1UserTxs); i++ {
183 // assumption: l1usertx are sorted by L1Tx.Position
184 _, _, _, _, err := tp.ProcessL1Tx(nil, &l1UserTxs[i])
185 if err != nil {
186 return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
187 }
188 }
189
190 // discardedL2Txs contains an array of the L2Txs that have not been selected in this Batch
191 var discardedL2Txs []common.PoolL2Tx
192
193 var l1CoordinatorTxs []common.L1Tx
194 positionL1 := len(l1UserTxs)
195 var accAuths [][]byte
196
197 // sort l2TxsRaw (cropping at MaxTx at this point)
198 l2Txs0 := txsel.getL2Profitable(l2TxsRaw, selectionConfig.TxProcessorConfig.MaxTx)
199
200 noncesMap := make(map[common.Idx]common.Nonce)
201 var l2Txs []common.PoolL2Tx
202 // iterate over l2Txs
203 // - if tx.TokenID does not exist at CoordsIdxDB
204 // - create new L1CoordinatorTx creating a CoordAccount, for
205 // Coordinator to receive the fee of the new TokenID
206 for i := 0; i < len(l2Txs0); i++ {
207 accSender, err := tp.StateDB().GetAccount(l2Txs0[i].FromIdx)
208 if err != nil {
209 return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
210 }
211 l2Txs0[i].TokenID = accSender.TokenID
212 // populate the noncesMap used at the next iteration
213 noncesMap[l2Txs0[i].FromIdx] = accSender.Nonce
214
215 // if TokenID does not exist yet, create new L1CoordinatorTx to
216 // create the CoordinatorAccount for that TokenID, to receive
217 // the fees. Only in the case that there does not exist yet a
218 // pending L1CoordinatorTx to create the account for the
219 // Coordinator for that TokenID
220 var newL1CoordTx *common.L1Tx
221 newL1CoordTx, positionL1, err =
222 txsel.coordAccountForTokenID(l1CoordinatorTxs,
223 accSender.TokenID, positionL1)
224 if err != nil {
225 return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
226 }
227 if newL1CoordTx != nil {
228 // if there is no space for the L1CoordinatorTx, discard the L2Tx
229 if len(l1CoordinatorTxs) >= int(selectionConfig.MaxL1UserTxs)-len(l1UserTxs) {
230 // discard L2Tx, and update Info parameter of
231 // the tx, and add it to the discardedTxs array
232 l2Txs0[i].Info = "Tx not selected due the L2Tx depends on a L1CoordinatorTx and there is not enough space for L1Coordinator"
233 discardedL2Txs = append(discardedL2Txs, l2Txs0[i])
234 continue
235 }
236 // increase positionL1
237 positionL1++
238 l1CoordinatorTxs = append(l1CoordinatorTxs, *newL1CoordTx)
239 accAuths = append(accAuths, txsel.coordAccount.AccountCreationAuth)
240 }
241 l2Txs = append(l2Txs, l2Txs0[i])
242 }
243
244 var validTxs []common.PoolL2Tx
245 // iterate over l2TxsRaw
246 // - check Nonces
247 // - check enough Balance for the Amount+Fee
248 // - if needed, create new L1CoordinatorTxs for unexisting ToIdx
249 // - keep used accAuths
250 // - put the valid txs into validTxs array
251 for i := 0; i < len(l2Txs); i++ {
252 enoughBalance, balance, feeAndAmount := tp.CheckEnoughBalance(l2Txs[i])
253 if !enoughBalance {
254 // not valid Amount with current Balance. Discard L2Tx,
255 // and update Info parameter of the tx, and add it to
256 // the discardedTxs array
257 l2Txs[i].Info = fmt.Sprintf("Tx not selected due not enough Balance at the sender. Current sender account Balance: %s, Amount+Fee: %s", balance.String(), feeAndAmount.String())
258 discardedL2Txs = append(discardedL2Txs, l2Txs[i])
259 continue
260 }
261 // check if Nonce is correct
262 nonce := noncesMap[l2Txs[i].FromIdx]
263 if l2Txs[i].Nonce == nonce {
264 noncesMap[l2Txs[i].FromIdx]++
265 } else {
266 // not valid Nonce at tx. Discard L2Tx, and update Info
267 // parameter of the tx, and add it to the discardedTxs
268 // array
269 l2Txs[i].Info = fmt.Sprintf("Tx not selected due not current Nonce. Tx.Nonce: %d, Account.Nonce: %d", l2Txs[i].Nonce, nonce)
270 discardedL2Txs = append(discardedL2Txs, l2Txs[i])
271 continue
272 }
273
274 // If tx.ToIdx>=256, tx.ToIdx should exist to localAccountsDB,
275 // if so, tx is used. If tx.ToIdx==0, for an L2Tx will be the
276 // case of TxToEthAddr or TxToBJJ, check if
277 // tx.ToEthAddr/tx.ToBJJ exist in localAccountsDB, if yes tx is
278 // used; if not, check if tx.ToEthAddr is in
279 // AccountCreationAuthDB, if so, tx is used and L1CoordinatorTx
280 // of CreateAccountAndDeposit is created. If tx.ToIdx==1, is a
281 // Exit type and is used.
282 if l2Txs[i].ToIdx == 0 { // ToEthAddr/ToBJJ case
283 validL2Tx, l1CoordinatorTx, accAuth, err :=
284 txsel.processTxToEthAddrBJJ(validTxs, selectionConfig,
285 len(l1UserTxs), l1CoordinatorTxs, positionL1, l2Txs[i])
286 if err != nil {
287 log.Debug(err)
288 // Discard L2Tx, and update Info parameter of
289 // the tx, and add it to the discardedTxs array
290 l2Txs[i].Info = fmt.Sprintf("Tx not selected (in processTxToEthAddrBJJ) due %s", err.Error())
291 discardedL2Txs = append(discardedL2Txs, l2Txs[i])
292 continue
293 }
294 if accAuth != nil && l1CoordinatorTx != nil {
295 accAuths = append(accAuths, accAuth.Signature)
296 l1CoordinatorTxs = append(l1CoordinatorTxs, *l1CoordinatorTx)
297 positionL1++
298 }
299 if validL2Tx != nil {
300 validTxs = append(validTxs, *validL2Tx)
301 }
302 } else if l2Txs[i].ToIdx >= common.IdxUserThreshold {
303 receiverAcc, err := txsel.localAccountsDB.GetAccount(l2Txs[i].ToIdx)
304 if err != nil {
305 // tx not valid
306 log.Debugw("invalid L2Tx: ToIdx not found in StateDB",
307 "ToIdx", l2Txs[i].ToIdx)
308 // Discard L2Tx, and update Info parameter of
309 // the tx, and add it to the discardedTxs array
310 l2Txs[i].Info = fmt.Sprintf("Tx not selected due tx.ToIdx not found in StateDB. ToIdx: %d",
311 l2Txs[i].ToIdx)
312 discardedL2Txs = append(discardedL2Txs, l2Txs[i])
313 continue
314 }
315 if l2Txs[i].ToEthAddr != common.EmptyAddr {
316 if l2Txs[i].ToEthAddr != receiverAcc.EthAddr {
317 log.Debugw("invalid L2Tx: ToEthAddr does not correspond to the Account.EthAddr",
318 "ToIdx", l2Txs[i].ToIdx, "tx.ToEthAddr",
319 l2Txs[i].ToEthAddr, "account.EthAddr", receiverAcc.EthAddr)
320 // Discard L2Tx, and update Info
321 // parameter of the tx, and add it to
322 // the discardedTxs array
323 l2Txs[i].Info = fmt.Sprintf("Tx not selected due ToEthAddr does not correspond to the Account.EthAddr. tx.ToIdx: %d, tx.ToEthAddr: %s, account.EthAddr: %s",
324 l2Txs[i].ToIdx, l2Txs[i].ToEthAddr, receiverAcc.EthAddr)
325 discardedL2Txs = append(discardedL2Txs, l2Txs[i])
326 continue
327 }
328 }
329 if l2Txs[i].ToBJJ != common.EmptyBJJComp {
330 if l2Txs[i].ToBJJ != receiverAcc.BJJ {
331 log.Debugw("invalid L2Tx: ToBJJ does not correspond to the Account.BJJ",
332 "ToIdx", l2Txs[i].ToIdx, "tx.ToEthAddr", l2Txs[i].ToBJJ,
333 "account.BJJ", receiverAcc.BJJ)
334 // Discard L2Tx, and update Info
335 // parameter of the tx, and add it to
336 // the discardedTxs array
337 l2Txs[i].Info = fmt.Sprintf("Tx not selected due tx.ToBJJ does not correspond to the Account.BJJ. tx.ToIdx: %d, tx.ToEthAddr: %s, tx.ToBJJ: %s, account.BJJ: %s",
338 l2Txs[i].ToIdx, l2Txs[i].ToEthAddr, l2Txs[i].ToBJJ, receiverAcc.BJJ)
339 discardedL2Txs = append(discardedL2Txs, l2Txs[i])
340 continue
341 }
342 }
343
344 // Account found in the DB, include the l2Tx in the selection
345 validTxs = append(validTxs, l2Txs[i])
346 } else if l2Txs[i].ToIdx == common.Idx(1) {
347 // valid txs (of Exit type)
348 validTxs = append(validTxs, l2Txs[i])
349 }
350 }
351
352 // Process L1CoordinatorTxs
353 for i := 0; i < len(l1CoordinatorTxs); i++ {
354 _, _, _, _, err := tp.ProcessL1Tx(nil, &l1CoordinatorTxs[i])
355 if err != nil {
356 return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
357 }
358 }
359
360 // get CoordIdxsMap for the TokenIDs
361 coordIdxsMap := make(map[common.TokenID]common.Idx)
362 for i := 0; i < len(validTxs); i++ {
363 // get TokenID from tx.Sender
364 accSender, err := tp.StateDB().GetAccount(validTxs[i].FromIdx)
365 if err != nil {
366 return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
367 }
368 tokenID := accSender.TokenID
369
370 coordIdx, err := txsel.getCoordIdx(tokenID)
371 if err != nil {
372 // if err is db.ErrNotFound, should not happen, as all
373 // the validTxs.TokenID should have a CoordinatorIdx
374 // created in the DB at this point
375 return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
376 }
377 coordIdxsMap[tokenID] = coordIdx
378 }
379
380 var coordIdxs []common.Idx
381 tp.AccumulatedFees = make(map[common.Idx]*big.Int)
382 for _, idx := range coordIdxsMap {
383 tp.AccumulatedFees[idx] = big.NewInt(0)
384 coordIdxs = append(coordIdxs, idx)
385 }
386 // sort CoordIdxs
387 sort.SliceStable(coordIdxs, func(i, j int) bool {
388 return coordIdxs[i] < coordIdxs[j]
389 })
390
391 // get most profitable L2-tx
392 maxL2Txs := int(selectionConfig.TxProcessorConfig.MaxTx) -
393 len(l1UserTxs) - len(l1CoordinatorTxs)
394
395 selectedL2Txs := validTxs
396 if len(validTxs) > maxL2Txs {
397 selectedL2Txs = selectedL2Txs[:maxL2Txs]
398 }
399 var finalL2Txs []common.PoolL2Tx
400 for i := 0; i < len(selectedL2Txs); i++ {
401 _, _, _, err = tp.ProcessL2Tx(coordIdxsMap, nil, nil, &selectedL2Txs[i])
402 if err != nil {
403 // the error can be due not valid tx data, or due other
404 // cases (such as StateDB error). At this initial
405 // version of the TxSelector, we discard the L2Tx and
406 // log the error, assuming that this will be iterated
407 // in a near future.
408 log.Error(err)
409 // Discard L2Tx, and update Info parameter of the tx,
410 // and add it to the discardedTxs array
411 selectedL2Txs[i].Info = fmt.Sprintf("Tx not selected (in ProcessL2Tx) due %s", err.Error())
412 discardedL2Txs = append(discardedL2Txs, selectedL2Txs[i])
413 continue
414 }
415 finalL2Txs = append(finalL2Txs, selectedL2Txs[i])
416 }
417
418 // distribute the AccumulatedFees from the processed L2Txs into the
419 // Coordinator Idxs
420 for idx, accumulatedFee := range tp.AccumulatedFees {
421 cmp := accumulatedFee.Cmp(big.NewInt(0))
422 if cmp == 1 { // accumulatedFee>0
423 // send the fee to the Idx of the Coordinator for the TokenID
424 accCoord, err := txsel.localAccountsDB.GetAccount(idx)
425 if err != nil {
426 log.Errorw("Can not distribute accumulated fees to coordinator account: No coord Idx to receive fee", "idx", idx)
427 return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
428 }
429 accCoord.Balance = new(big.Int).Add(accCoord.Balance, accumulatedFee)
430 _, err = txsel.localAccountsDB.UpdateAccount(idx, accCoord)
431 if err != nil {
432 log.Error(err)
433 return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
434 }
435 }
436 }
437
438 err = tp.StateDB().MakeCheckpoint()
439 if err != nil {
440 return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
441 }
442
443 return coordIdxs, accAuths, l1UserTxs, l1CoordinatorTxs, finalL2Txs, discardedL2Txs, nil
444}
445
446// processTxsToEthAddrBJJ process the common.PoolL2Tx in the case where
447// ToIdx==0, which can be the tx type of ToEthAddr or ToBJJ. If the receiver
448// does not have an account yet, a new L1CoordinatorTx of type
449// CreateAccountDeposit (with 0 as DepositAmount) is created and added to the
450// l1CoordinatorTxs array, and then the PoolL2Tx is added into the validTxs
451// array.
452func (txsel *TxSelector) processTxToEthAddrBJJ(validTxs []common.PoolL2Tx,
453 selectionConfig *SelectionConfig, nL1UserTxs int, l1CoordinatorTxs []common.L1Tx,
454 positionL1 int, l2Tx common.PoolL2Tx) (*common.PoolL2Tx, *common.L1Tx,
455 *common.AccountCreationAuth, error) {
456 // if L2Tx needs a new L1CoordinatorTx of CreateAccount type, and a
457 // previous L2Tx in the current process already created a
458 // L1CoordinatorTx of this type, in the DB there still seem that needs
459 // to create a new L1CoordinatorTx, but as is already created, the tx
460 // is valid
461 if checkAlreadyPendingToCreate(l1CoordinatorTxs, l2Tx.TokenID, l2Tx.ToEthAddr, l2Tx.ToBJJ) {
462 return &l2Tx, nil, nil, nil
463 }
464
465 var l1CoordinatorTx *common.L1Tx
466 var accAuth *common.AccountCreationAuth
467 if !bytes.Equal(l2Tx.ToEthAddr.Bytes(), common.EmptyAddr.Bytes()) &&
468 !bytes.Equal(l2Tx.ToEthAddr.Bytes(), common.FFAddr.Bytes()) {
469 // case: ToEthAddr != 0x00 neither 0xff
470 if l2Tx.ToBJJ != common.EmptyBJJComp {
471 // case: ToBJJ!=0:
472 // if idx exist for EthAddr&BJJ use it
473 _, err := txsel.localAccountsDB.GetIdxByEthAddrBJJ(l2Tx.ToEthAddr,
474 l2Tx.ToBJJ, l2Tx.TokenID)
475 if err == nil {
476 // account for ToEthAddr&ToBJJ already exist,
477 // there is no need to create a new one.
478 // tx valid, StateDB will use the ToIdx==0 to define the AuxToIdx
479 return &l2Tx, nil, nil, nil
480 }
481 // if not, check if AccountCreationAuth exist for that
482 // ToEthAddr
483 accAuth, err = txsel.l2db.GetAccountCreationAuth(l2Tx.ToEthAddr)
484 if err != nil {
485 // not found, l2Tx will not be added in the selection
486 return nil, nil, nil, tracerr.Wrap(fmt.Errorf("invalid L2Tx: ToIdx not found in StateDB, neither ToEthAddr found in AccountCreationAuths L2DB. ToIdx: %d, ToEthAddr: %s",
487 l2Tx.ToIdx, l2Tx.ToEthAddr.Hex()))
488 }
489 if accAuth.BJJ != l2Tx.ToBJJ {
490 // if AccountCreationAuth.BJJ is not the same
491 // than in the tx, tx is not accepted
492 return nil, nil, nil, tracerr.Wrap(fmt.Errorf("invalid L2Tx: ToIdx not found in StateDB, neither ToEthAddr & ToBJJ found in AccountCreationAuths L2DB. ToIdx: %d, ToEthAddr: %s, ToBJJ: %s",
493 l2Tx.ToIdx, l2Tx.ToEthAddr.Hex(), l2Tx.ToBJJ.String()))
494 }
495 } else {
496 // case: ToBJJ==0:
497 // if idx exist for EthAddr use it
498 _, err := txsel.localAccountsDB.GetIdxByEthAddr(l2Tx.ToEthAddr, l2Tx.TokenID)
499 if err == nil {
500 // account for ToEthAddr already exist,
501 // there is no need to create a new one.
502 // tx valid, StateDB will use the ToIdx==0 to define the AuxToIdx
503 return &l2Tx, nil, nil, nil
504 }
505 // if not, check if AccountCreationAuth exist for that ToEthAddr
506 accAuth, err = txsel.l2db.GetAccountCreationAuth(l2Tx.ToEthAddr)
507 if err != nil {
508 // not found, l2Tx will not be added in the selection
509 return nil, nil, nil, tracerr.Wrap(fmt.Errorf("invalid L2Tx: ToIdx not found in StateDB, neither ToEthAddr found in AccountCreationAuths L2DB. ToIdx: %d, ToEthAddr: %s",
510 l2Tx.ToIdx, l2Tx.ToEthAddr))
511 }
512 }
513 // create L1CoordinatorTx for the accountCreation
514 l1CoordinatorTx = &common.L1Tx{
515 Position: positionL1,
516 UserOrigin: false,
517 FromEthAddr: accAuth.EthAddr,
518 FromBJJ: accAuth.BJJ,
519 TokenID: l2Tx.TokenID,
520 Amount: big.NewInt(0),
521 DepositAmount: big.NewInt(0),
522 Type: common.TxTypeCreateAccountDeposit,
523 }
524 } else if bytes.Equal(l2Tx.ToEthAddr.Bytes(), common.FFAddr.Bytes()) &&
525 l2Tx.ToBJJ != common.EmptyBJJComp {
526 // if idx exist for EthAddr&BJJ use it
527 _, err := txsel.localAccountsDB.GetIdxByEthAddrBJJ(l2Tx.ToEthAddr, l2Tx.ToBJJ,
528 l2Tx.TokenID)
529 if err == nil {
530 // account for ToEthAddr&ToBJJ already exist, (where ToEthAddr==0xff)
531 // there is no need to create a new one.
532 // tx valid, StateDB will use the ToIdx==0 to define the AuxToIdx
533 return &l2Tx, nil, nil, nil
534 }
535 // if idx don't exist for EthAddr&BJJ, coordinator can create a
536 // new account without L1Authorization, as ToEthAddr==0xff
537 // create L1CoordinatorTx for the accountCreation
538 l1CoordinatorTx = &common.L1Tx{
539 Position: positionL1,
540 UserOrigin: false,
541 FromEthAddr: l2Tx.ToEthAddr,
542 FromBJJ: l2Tx.ToBJJ,
543 TokenID: l2Tx.TokenID,
544 Amount: big.NewInt(0),
545 DepositAmount: big.NewInt(0),
546 Type: common.TxTypeCreateAccountDeposit,
547 }
548 }
549 if len(l1CoordinatorTxs) >= int(selectionConfig.MaxL1UserTxs)-nL1UserTxs {
550 // L2Tx discarded
551 return nil, nil, nil, tracerr.Wrap(fmt.Errorf("L2Tx discarded due not slots for L1CoordinatorTx to create a new account for receiver of L2Tx"))
552 }
553
554 return &l2Tx, l1CoordinatorTx, accAuth, nil
555}
556
557func checkAlreadyPendingToCreate(l1CoordinatorTxs []common.L1Tx, tokenID common.TokenID,
558 addr ethCommon.Address, bjj babyjub.PublicKeyComp) bool {
559 for i := 0; i < len(l1CoordinatorTxs); i++ {
560 if bytes.Equal(l1CoordinatorTxs[i].FromEthAddr.Bytes(), addr.Bytes()) &&
561 l1CoordinatorTxs[i].TokenID == tokenID &&
562 l1CoordinatorTxs[i].FromBJJ == bjj {
563 return true
564 }
565 }
566 return false
567}
568
569// getL2Profitable returns the profitable selection of L2Txssorted by Nonce
570func (txsel *TxSelector) getL2Profitable(l2Txs []common.PoolL2Tx, max uint32) []common.PoolL2Tx {
571 sort.Sort(txs(l2Txs))
572 if len(l2Txs) < int(max) {
573 return l2Txs
574 }
575 l2Txs = l2Txs[:max]
576
577 // sort l2Txs by Nonce. This can be done in many different ways, what
578 // is needed is to output the l2Txs where the Nonce of l2Txs for each
579 // Account is sorted, but the l2Txs can not be grouped by sender Account
580 // neither by Fee. This is because later on the Nonces will need to be
581 // sequential for the zkproof generation.
582 sort.SliceStable(l2Txs, func(i, j int) bool {
583 return l2Txs[i].Nonce < l2Txs[j].Nonce
584 })
585
586 return l2Txs
587}