txprocessor

Documentation

Overview

Package txprocessor is the module that takes the transactions from the input and processes them, updating the Balances and Nonces of the Accounts in the StateDB.

It's a package used by 3 other different packages, and its behaviour will differ depending on the Type of the StateDB of the TxProcessor:

- TypeSynchronizer:

• The StateDB contains the full State MerkleTree, where the leafs are the accounts
• Updates the StateDB and as output returns: ExitInfos, CreatedAccounts, CoordinatorIdxsMap, CollectedFees, UpdatedAccounts
• Internally computes the ExitTree

- TypeTxSelector:

• The StateDB contains only the Accounts, which are the equivalent to only the leafs of the State MerkleTree
• Updates the Accounts from the StateDB

- TypeBatchBuilder:

• The StateDB contains the full State MerkleTree, where the leafs are the accounts
• Updates the StateDB. As output returns: ZKInputs, CoordinatorIdxsMap
• Internally computes the ZKInputs

Packages dependency overview:

Outputs: + ExitInfos              +                  +                       +
	 | CreatedAccounts        |                  |                       |
	 | CoordinatorIdxsMap     |                  |    ZKInputs           |
	 | CollectedFees          |                  |    CoordinatorIdxsMap |
	 | UpdatedAccounts        |                  |                       |
	 +------------------------+----------------+ +-----------------------+

	    +------------+           +----------+             +------------+
	    |Synchronizer|           |TxSelector|             |BatchBuilder|
	    +-----+------+           +-----+----+             +-----+------+
		  |                        |                        |
		  v                        v                        v
	     TxProcessor              TxProcessor              TxProcessor
		  +                        +                        +
		  |                        |                        |
	     +----+----+                   v                   +----+----+
	     |         |                StateDB                |         |
	     v         v                   +                   v         v
	  StateDB  ExitTree                |                StateDB  ExitTree
	     +                        +----+----+              +
	     |                        |         |              |
	+----+----+                   v         v         +----+----+
	|         |                 KVDB  AccountsDB      |         |
	v         v                                       v         v
      KVDB   MerkleTree                                 KVDB   MerkleTree

The structure of the TxProcessor can be understand as:

• StateDB: where the Rollup state is stored. It contains the Accounts & MerkleTree.
• Config: parameters of the configuration of the circuit
• ZKInputs: computed inputs for the circuit, depends on the Config parameters
• ExitTree: only in the TypeSynchronizer & TypeBatchBuilder, contains the MerkleTree with the processed Exits of the Batch

The main exposed method of the TxProcessor is `ProcessTxs`, which as general lines does:

• if type==(Synchronizer || BatchBuilder), creates an ephemeral ExitTree
• processes:
• L1UserTxs --> for each tx calls ProcessL1Tx()
• L1CoordinatorTxs --> for each tx calls ProcessL1Tx()
• L2Txs --> for each tx calls ProcessL2Tx()
• internally, it computes the Fees
• each transaction processment includes:
• updating the Account Balances (for sender & receiver, and in case that there is fee, updates the fee receiver account)
• which includes updating the State MerkleTree (except for the type==TxSelector, which only updates the Accounts (leafs))
• in case of Synchronizer & BatchBuilder, updates the ExitTree for the txs of type Exit (L1 & L2)
• in case of BatchBuilder, computes the ZKInputs while processing the txs
• if type==Synchronizer, once all the txs are processed, for each Exit it generates the ExitInfo data

Index

• func BJJCompressedTo256BigInts(pkComp babyjub.PublicKeyComp) [256]*big.Int
• type Config
• type ProcessTxOutput
• type TxProcessor
  • func NewTxProcessor(sdb *statedb.StateDB, config Config) *TxProcessor
  • func (tp *TxProcessor) CheckEnoughBalance(tx common.PoolL2Tx) (bool, *big.Int, *big.Int)
  • func (tp *TxProcessor) ProcessL1Tx(exitTree *merkletree.MerkleTree, tx *common.L1Tx) (*common.Idx, *common.Account, bool, *common.Account, error)
  • func (tp *TxProcessor) ProcessL2Tx(coordIdxsMap map[common.TokenID]common.Idx, ...) (*common.Idx, *common.Account, bool, error)
  • func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinatortxs []common.L1Tx, ...) (ptOut *ProcessTxOutput, err error)
  • func (tp *TxProcessor) StateDB() *statedb.StateDB

Functions

func BJJCompressedTo256BigInts

func BJJCompressedTo256BigInts(pkComp babyjub.PublicKeyComp) [256]*big.Int

BJJCompressedTo256BigInts returns a [256]*big.Int array with the bit representation of the babyjub.PublicKeyComp

Types

type Config

type Config struct {
	NLevels uint32
	// MaxFeeTx is the maximum number of coordinator accounts that can receive fees
	MaxFeeTx uint32
	MaxTx    uint32
	MaxL1Tx  uint32
	// ChainID of the blockchain
	ChainID uint16
}

Config contains the TxProcessor configuration parameters

type ProcessTxOutput

type ProcessTxOutput struct {
	ZKInputs           *common.ZKInputs
	ExitInfos          []common.ExitInfo
	CreatedAccounts    []common.Account
	CoordinatorIdxsMap map[common.TokenID]common.Idx
	CollectedFees      map[common.TokenID]*big.Int
	// UpdatedAccounts returns the current state of each account
	// created/updated by any of the processed transactions.
	UpdatedAccounts map[common.Idx]*common.Account
}

ProcessTxOutput contains the output of the ProcessTxs method

type TxProcessor

type TxProcessor struct {

	// AccumulatedFees contains the accumulated fees for each token (Coord
	// Idx) in the processed batch
	AccumulatedFees map[common.Idx]*big.Int
	// contains filtered or unexported fields
}

TxProcessor represents the TxProcessor object

func NewTxProcessor

func NewTxProcessor(sdb *statedb.StateDB, config Config) *TxProcessor

NewTxProcessor returns a new TxProcessor with the given *StateDB & Config

func (*TxProcessor) CheckEnoughBalance

func (tp *TxProcessor) CheckEnoughBalance(tx common.PoolL2Tx) (bool, *big.Int, *big.Int)

CheckEnoughBalance returns true if the sender of the transaction has enough balance in the account to send the Amount+Fee, and also returns the account Balance and the Fee+Amount (which is used to give information about why the transaction is not selected in case that this method returns false.

func (*TxProcessor) ProcessL1Tx

func (tp *TxProcessor) ProcessL1Tx(exitTree *merkletree.MerkleTree, tx *common.L1Tx) (*common.Idx,
	*common.Account, bool, *common.Account, error)

ProcessL1Tx process the given L1Tx applying the needed updates to the StateDB depending on the transaction Type. It returns the 3 parameters related to the Exit (in case of): Idx, ExitAccount, boolean determining if the Exit created a new Leaf in the ExitTree. And another *common.Account parameter which contains the created account in case that has been a new created account and that the StateDB is of type TypeSynchronizer.

func (*TxProcessor) ProcessL2Tx

func (tp *TxProcessor) ProcessL2Tx(coordIdxsMap map[common.TokenID]common.Idx,
	collectedFees map[common.TokenID]*big.Int, exitTree *merkletree.MerkleTree,
	tx *common.PoolL2Tx) (*common.Idx, *common.Account, bool, error)

ProcessL2Tx process the given L2Tx applying the needed updates to the StateDB depending on the transaction Type. It returns the 3 parameters related to the Exit (in case of): Idx, ExitAccount, boolean determining if the Exit created a new Leaf in the ExitTree.

func (*TxProcessor) ProcessTxs

func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinatortxs []common.L1Tx,
	l2txs []common.PoolL2Tx) (ptOut *ProcessTxOutput, err error)

ProcessTxs process the given L1Txs & L2Txs applying the needed updates to the StateDB depending on the transaction Type. If StateDB type==TypeBatchBuilder, returns the common.ZKInputs to generate the SnarkProof later used by the BatchBuilder. If StateDB type==TypeSynchronizer, assumes that the call is done from the Synchronizer, returns common.ExitTreeLeaf that is later used by the Synchronizer to update the HistoryDB, and adds Nonce & TokenID to the L2Txs. And if TypeSynchronizer returns an array of common.Account with all the created accounts.

func (*TxProcessor) StateDB

func (tp *TxProcessor) StateDB() *statedb.StateDB

StateDB returns a pointer to the StateDB of the TxProcessor