You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

44 lines
1.2 KiB

Redo coordinator structure, connect API to node - API: - Modify the constructor so that hardcoded rollup constants don't need to be passed (introduce a `Config` and use `configAPI` internally) - Common: - Update rollup constants with proper *big.Int when required - Add BidCoordinator and Slot structs used by the HistoryDB and Synchronizer. - Add helper methods to AuctionConstants - AuctionVariables: Add column `DefaultSlotSetBidSlotNum` (in the SQL table: `default_slot_set_bid_slot_num`), which indicates at which slotNum does the `DefaultSlotSetBid` specified starts applying. - Config: - Move coordinator exclusive configuration from the node config to the coordinator config - Coordinator: - Reorganize the code towards having the goroutines started and stopped from the coordinator itself instead of the node. - Remove all stop and stopped channels, and use context.Context and sync.WaitGroup instead. - Remove BatchInfo setters and assing variables directly - In ServerProof and ServerProofPool use context instead stop channel. - Use message passing to notify the coordinator about sync updates and reorgs - Introduce the Pipeline, which can be started and stopped by the Coordinator - Introduce the TxManager, which manages ethereum transactions (the TxManager is also in charge of making the forge call to the rollup smart contract). The TxManager keeps ethereum transactions and: 1. Waits for the transaction to be accepted 2. Waits for the transaction to be confirmed for N blocks - In forge logic, first prepare a batch and then wait for an available server proof to have all work ready once the proof server is ready. - Remove the `isForgeSequence` method which was querying the smart contract, and instead use notifications sent by the Synchronizer to figure out if it's forging time. - Update test (which is a minimal test to manually see if the coordinator starts) - HistoryDB: - Add method to get the number of batches in a slot (used to detect when a slot has passed the bid winner forging deadline) - Add method to get the best bid and associated coordinator of a slot (used to detect the forgerAddress that can forge the slot) - General: - Rename some instances of `currentBlock` to `lastBlock` to be more clear. - Node: - Connect the API to the node and call the methods to update cached state when the sync advances blocks. - Call methods to update Coordinator state when the sync advances blocks and finds reorgs. - Synchronizer: - Add Auction field in the Stats, which contain the current slot with info about highest bidder and other related info required to know who can forge in the current block. - Better organization of cached state: - On Sync, update the internal cached state - On Init or Reorg, load the state from HistoryDB into the internal cached state.
4 years ago
  1. package common
  2. import (
  3. "encoding/hex"
  4. "math/big"
  5. ethCommon "github.com/ethereum/go-ethereum/common"
  6. "github.com/hermeznetwork/tracerr"
  7. "github.com/iden3/go-iden3-crypto/babyjub"
  8. )
  9. // SwapEndianness swaps the order of the bytes in the slice.
  10. func SwapEndianness(b []byte) []byte {
  11. o := make([]byte, len(b))
  12. for i := range b {
  13. o[len(b)-1-i] = b[i]
  14. }
  15. return o
  16. }
  17. // EthAddrToBigInt returns a *big.Int from a given ethereum common.Address.
  18. func EthAddrToBigInt(a ethCommon.Address) *big.Int {
  19. return new(big.Int).SetBytes(a.Bytes())
  20. }
  21. // BJJFromStringWithChecksum parses a hex string in Hermez format (which has
  22. // the Hermez checksum at the last byte, and is encoded in BigEndian) and
  23. // returns the corresponding *babyjub.PublicKey. This method is not part of the
  24. // spec, is used for importing javascript test vectors data.
  25. func BJJFromStringWithChecksum(s string) (*babyjub.PublicKey, error) {
  26. b, err := hex.DecodeString(s)
  27. if err != nil {
  28. return nil, tracerr.Wrap(err)
  29. }
  30. pkBytes := SwapEndianness(b)
  31. var pkComp babyjub.PublicKeyComp
  32. copy(pkComp[:], pkBytes[:])
  33. return pkComp.Decompress()
  34. }
  35. // CopyBigInt returns a copy of the big int
  36. func CopyBigInt(a *big.Int) *big.Int {
  37. return new(big.Int).SetBytes(a.Bytes())
  38. }