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.

43 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/iden3/go-iden3-crypto/babyjub"
  7. )
  8. // SwapEndianness swaps the order of the bytes in the slice.
  9. func SwapEndianness(b []byte) []byte {
  10. o := make([]byte, len(b))
  11. for i := range b {
  12. o[len(b)-1-i] = b[i]
  13. }
  14. return o
  15. }
  16. // EthAddrToBigInt returns a *big.Int from a given ethereum common.Address.
  17. func EthAddrToBigInt(a ethCommon.Address) *big.Int {
  18. return new(big.Int).SetBytes(a.Bytes())
  19. }
  20. // BJJFromStringWithChecksum parses a hex string in Hermez format (which has
  21. // the Hermez checksum at the last byte, and is encoded in BigEndian) and
  22. // returns the corresponding *babyjub.PublicKey. This method is not part of the
  23. // spec, is used for importing javascript test vectors data.
  24. func BJJFromStringWithChecksum(s string) (*babyjub.PublicKey, error) {
  25. b, err := hex.DecodeString(s)
  26. if err != nil {
  27. return nil, err
  28. }
  29. pkBytes := SwapEndianness(b)
  30. var pkComp babyjub.PublicKeyComp
  31. copy(pkComp[:], pkBytes[:])
  32. return pkComp.Decompress()
  33. }
  34. // CopyBigInt returns a copy of the big int
  35. func CopyBigInt(a *big.Int) *big.Int {
  36. return new(big.Int).SetBytes(a.Bytes())
  37. }