package til import ( "bufio" "bytes" "fmt" "io" "math/big" "sort" "strconv" "github.com/hermeznetwork/hermez-node/common" "github.com/hermeznetwork/hermez-node/log" "github.com/hermeznetwork/tracerr" ) var eof = rune(0) var errof = fmt.Errorf("eof in parseline") var commentLine = fmt.Errorf("comment in parseline") //nolint:golint var newEventLine = fmt.Errorf("newEventLine") //nolint:golint var setTypeLine = fmt.Errorf("setTypeLine") //nolint:golint // setType defines the type of the set type setType string // SetTypeBlockchain defines the type 'Blockchain' of the set var SetTypeBlockchain = setType("Blockchain") // SetTypePoolL2 defines the type 'PoolL2' of the set var SetTypePoolL2 = setType("PoolL2") // TypeNewBatch is used for testing purposes only, and represents the // common.TxType of a new batch var TypeNewBatch common.TxType = "InstrTypeNewBatch" // TypeNewBatchL1 is used for testing purposes only, and represents the // common.TxType of a new batch var TypeNewBatchL1 common.TxType = "InstrTypeNewBatchL1" // TypeNewBlock is used for testing purposes only, and represents the // common.TxType of a new ethereum block var TypeNewBlock common.TxType = "InstrTypeNewBlock" // TypeAddToken is used for testing purposes only, and represents the // common.TxType of a new Token regsitration // It has 'nolint:gosec' as the string 'Token' triggers gosec as a potential leaked Token (which is not the case) var TypeAddToken common.TxType = "InstrTypeAddToken" //nolint:gosec // TxTypeCreateAccountDepositCoordinator is used for testing purposes only, and represents the // common.TxType of a create acount deposit made by the coordinator var TxTypeCreateAccountDepositCoordinator common.TxType = "TypeCreateAccountDepositCoordinator" //nolint const ( ILLEGAL token = iota WS EOF IDENT // val ) // Instruction is the data structure that represents one line of code type Instruction struct { LineNum int Literal string From string To string Amount *big.Int LoadAmount *big.Int Fee uint8 TokenID common.TokenID Typ common.TxType // D: Deposit, T: Transfer, E: ForceExit } // parsedSet contains the full Set of Instructions representing a full code type parsedSet struct { typ setType instructions []Instruction users []string } func (i Instruction) String() string { buf := bytes.NewBufferString("") fmt.Fprintf(buf, "Type: %s, ", i.Typ) fmt.Fprintf(buf, "From: %s, ", i.From) if i.Typ == common.TxTypeTransfer || i.Typ == common.TxTypeDepositTransfer || i.Typ == common.TxTypeCreateAccountDepositTransfer { fmt.Fprintf(buf, "To: %s, ", i.To) } if i.Typ == common.TxTypeDeposit || i.Typ == common.TxTypeDepositTransfer || i.Typ == common.TxTypeCreateAccountDepositTransfer { fmt.Fprintf(buf, "LoadAmount: %d, ", i.LoadAmount) } if i.Typ != common.TxTypeDeposit { fmt.Fprintf(buf, "Amount: %d, ", i.Amount) } if i.Typ == common.TxTypeTransfer || i.Typ == common.TxTypeDepositTransfer || i.Typ == common.TxTypeCreateAccountDepositTransfer { fmt.Fprintf(buf, "Fee: %d, ", i.Fee) } fmt.Fprintf(buf, "TokenID: %d\n", i.TokenID) return buf.String() } // Raw returns a string with the raw representation of the Instruction func (i Instruction) raw() string { buf := bytes.NewBufferString("") fmt.Fprintf(buf, "%s", i.Typ) fmt.Fprintf(buf, "(%d)", i.TokenID) fmt.Fprintf(buf, "%s", i.From) if i.Typ == common.TxTypeTransfer || i.Typ == common.TxTypeDepositTransfer || i.Typ == common.TxTypeCreateAccountDepositTransfer { fmt.Fprintf(buf, "-%s", i.To) } fmt.Fprintf(buf, ":") if i.Typ == common.TxTypeDeposit || i.Typ == common.TxTypeDepositTransfer || i.Typ == common.TxTypeCreateAccountDepositTransfer { fmt.Fprintf(buf, "%d", i.LoadAmount) } if i.Typ != common.TxTypeDeposit { fmt.Fprintf(buf, "%d", i.Amount) } if i.Typ == common.TxTypeTransfer { fmt.Fprintf(buf, "(%d)", i.Fee) } return buf.String() } type token int type scanner struct { r *bufio.Reader } func isWhitespace(ch rune) bool { return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' || ch == '\v' || ch == '\f' } func isLetter(ch rune) bool { return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') } func isComment(ch rune) bool { return ch == '/' } func isDigit(ch rune) bool { return (ch >= '0' && ch <= '9') } // newScanner creates a new scanner with the given io.Reader func newScanner(r io.Reader) *scanner { return &scanner{r: bufio.NewReader(r)} } func (s *scanner) read() rune { ch, _, err := s.r.ReadRune() if err != nil { return eof } return ch } func (s *scanner) unread() { _ = s.r.UnreadRune() } // scan returns the token and literal string of the current value func (s *scanner) scan() (tok token, lit string) { ch := s.read() if isWhitespace(ch) { // space s.unread() return s.scanWhitespace() } else if isLetter(ch) || isDigit(ch) { // letter/digit s.unread() return s.scanIndent() } else if isComment(ch) { // comment s.unread() return s.scanIndent() } if ch == eof { return EOF, "" } return ILLEGAL, string(ch) } func (s *scanner) scanWhitespace() (token token, lit string) { var buf bytes.Buffer buf.WriteRune(s.read()) for { if ch := s.read(); ch == eof { break } else if !isWhitespace(ch) { s.unread() break } else { _, _ = buf.WriteRune(ch) } } return WS, buf.String() } func (s *scanner) scanIndent() (tok token, lit string) { var buf bytes.Buffer buf.WriteRune(s.read()) for { if ch := s.read(); ch == eof { break } else if !isLetter(ch) && !isDigit(ch) { s.unread() break } else { _, _ = buf.WriteRune(ch) } } if len(buf.String()) == 1 { return token(rune(buf.String()[0])), buf.String() } return IDENT, buf.String() } // parser defines the parser type parser struct { s *scanner buf struct { tok token lit string n int } } // newParser creates a new parser from a io.Reader func newParser(r io.Reader) *parser { return &parser{s: newScanner(r)} } func (p *parser) scan() (tok token, lit string) { // if there is a token in the buffer return it if p.buf.n != 0 { p.buf.n = 0 return p.buf.tok, p.buf.lit } tok, lit = p.s.scan() p.buf.tok, p.buf.lit = tok, lit return } func (p *parser) scanIgnoreWhitespace() (tok token, lit string) { tok, lit = p.scan() if tok == WS { tok, lit = p.scan() } return } // parseLine parses the current line func (p *parser) parseLine(setType setType) (*Instruction, error) { c := &Instruction{} tok, lit := p.scanIgnoreWhitespace() if tok == EOF { return nil, tracerr.Wrap(errof) } c.Literal += lit if lit == "/" { _, _ = p.s.r.ReadString('\n') return nil, commentLine } else if lit == ">" { if setType == SetTypePoolL2 { return c, tracerr.Wrap(fmt.Errorf("Unexpected '>' at PoolL2Txs set")) } _, lit = p.scanIgnoreWhitespace() if lit == "batch" { _, _ = p.s.r.ReadString('\n') return &Instruction{Typ: TypeNewBatch}, newEventLine } else if lit == "batchL1" { _, _ = p.s.r.ReadString('\n') return &Instruction{Typ: TypeNewBatchL1}, newEventLine } else if lit == "block" { _, _ = p.s.r.ReadString('\n') return &Instruction{Typ: TypeNewBlock}, newEventLine } else { return c, tracerr.Wrap(fmt.Errorf("Unexpected '> %s', expected '> batch' or '> block'", lit)) } } else if lit == "Type" { if err := p.expectChar(c, ":"); err != nil { return c, tracerr.Wrap(err) } _, lit = p.scanIgnoreWhitespace() if lit == "Blockchain" { return &Instruction{Typ: "Blockchain"}, setTypeLine } else if lit == "PoolL2" { return &Instruction{Typ: "PoolL2"}, setTypeLine } else { return c, tracerr.Wrap(fmt.Errorf("Invalid set type: '%s'. Valid set types: 'Blockchain', 'PoolL2'", lit)) } } else if lit == "AddToken" { if err := p.expectChar(c, "("); err != nil { return c, tracerr.Wrap(err) } _, lit = p.scanIgnoreWhitespace() c.Literal += lit tidI, err := strconv.Atoi(lit) if err != nil { line, _ := p.s.r.ReadString('\n') c.Literal += line return c, tracerr.Wrap(err) } c.TokenID = common.TokenID(tidI) if err := p.expectChar(c, ")"); err != nil { return c, tracerr.Wrap(err) } c.Typ = TypeAddToken line, _ := p.s.r.ReadString('\n') c.Literal += line return c, newEventLine } if setType == "" { return c, tracerr.Wrap(fmt.Errorf("Set type not defined")) } transferring := false fee := false if setType == SetTypeBlockchain { switch lit { case "Deposit": c.Typ = common.TxTypeDeposit case "Exit": c.Typ = common.TxTypeExit fee = true case "Transfer": c.Typ = common.TxTypeTransfer transferring = true fee = true case "CreateAccountDeposit": c.Typ = common.TxTypeCreateAccountDeposit case "CreateAccountDepositTransfer": c.Typ = common.TxTypeCreateAccountDepositTransfer transferring = true case "CreateAccountCoordinator": c.Typ = TxTypeCreateAccountDepositCoordinator // transferring is false, as the Coordinator tx transfer will be 0 case "DepositTransfer": c.Typ = common.TxTypeDepositTransfer transferring = true case "ForceTransfer": c.Typ = common.TxTypeForceTransfer transferring = true case "ForceExit": c.Typ = common.TxTypeForceExit default: return c, tracerr.Wrap(fmt.Errorf("Unexpected Blockchain tx type: %s", lit)) } } else if setType == SetTypePoolL2 { switch lit { case "PoolTransfer": c.Typ = common.TxTypeTransfer transferring = true fee = true case "PoolTransferToEthAddr": c.Typ = common.TxTypeTransferToEthAddr transferring = true fee = true case "PoolTransferToBJJ": c.Typ = common.TxTypeTransferToBJJ transferring = true fee = true case "PoolExit": c.Typ = common.TxTypeExit fee = true default: return c, tracerr.Wrap(fmt.Errorf("Unexpected PoolL2 tx type: %s", lit)) } } else { return c, tracerr.Wrap(fmt.Errorf("Invalid set type: '%s'. Valid set types: 'Blockchain', 'PoolL2'", setType)) } if err := p.expectChar(c, "("); err != nil { return c, tracerr.Wrap(err) } _, lit = p.scanIgnoreWhitespace() c.Literal += lit tidI, err := strconv.Atoi(lit) if err != nil { line, _ := p.s.r.ReadString('\n') c.Literal += line return c, tracerr.Wrap(err) } c.TokenID = common.TokenID(tidI) if err := p.expectChar(c, ")"); err != nil { return c, tracerr.Wrap(err) } _, lit = p.scanIgnoreWhitespace() c.Literal += lit c.From = lit if c.Typ == TxTypeCreateAccountDepositCoordinator { line, _ := p.s.r.ReadString('\n') c.Literal += line return c, nil } _, lit = p.scanIgnoreWhitespace() c.Literal += lit if transferring { if lit != "-" { return c, tracerr.Wrap(fmt.Errorf("Expected '-', found '%s'", lit)) } _, lit = p.scanIgnoreWhitespace() c.Literal += lit c.To = lit _, lit = p.scanIgnoreWhitespace() c.Literal += lit } if lit != ":" { line, _ := p.s.r.ReadString('\n') c.Literal += line return c, tracerr.Wrap(fmt.Errorf("Expected ':', found '%s'", lit)) } if c.Typ == common.TxTypeDepositTransfer || c.Typ == common.TxTypeCreateAccountDepositTransfer { // deposit case _, lit = p.scanIgnoreWhitespace() c.Literal += lit loadAmount, ok := new(big.Int).SetString(lit, 10) if !ok { line, _ := p.s.r.ReadString('\n') c.Literal += line return c, tracerr.Wrap(fmt.Errorf("Can not parse number for LoadAmount")) } c.LoadAmount = loadAmount if err := p.expectChar(c, ","); err != nil { return c, tracerr.Wrap(err) } } _, lit = p.scanIgnoreWhitespace() c.Literal += lit amount, ok := new(big.Int).SetString(lit, 10) if !ok { line, _ := p.s.r.ReadString('\n') c.Literal += line return c, tracerr.Wrap(fmt.Errorf("Can not parse number for Amount: %s", lit)) } if c.Typ == common.TxTypeDeposit || c.Typ == common.TxTypeCreateAccountDeposit { c.LoadAmount = amount } else { c.Amount = amount } if fee { if err := p.expectChar(c, "("); err != nil { return c, tracerr.Wrap(err) } _, lit = p.scanIgnoreWhitespace() c.Literal += lit fee, err := strconv.Atoi(lit) if err != nil { line, _ := p.s.r.ReadString('\n') c.Literal += line return c, tracerr.Wrap(err) } if fee > common.MaxFeePlan-1 { line, _ := p.s.r.ReadString('\n') c.Literal += line return c, tracerr.Wrap(fmt.Errorf("Fee %d can not be bigger than 255", fee)) } c.Fee = uint8(fee) if err := p.expectChar(c, ")"); err != nil { return c, tracerr.Wrap(err) } } if tok == EOF { return nil, tracerr.Wrap(errof) } return c, nil } func (p *parser) expectChar(c *Instruction, ch string) error { _, lit := p.scanIgnoreWhitespace() c.Literal += lit if lit != ch { line, _ := p.s.r.ReadString('\n') c.Literal += line return tracerr.Wrap(fmt.Errorf("Expected '%s', found '%s'", ch, lit)) } return nil } func idxTokenIDToString(idx string, tid common.TokenID) string { return idx + strconv.Itoa(int(tid)) } // parse parses through reader func (p *parser) parse() (*parsedSet, error) { ps := &parsedSet{} i := 0 // lines will start counting at line 1 users := make(map[string]bool) for { i++ instruction, err := p.parseLine(ps.typ) if tracerr.Unwrap(err) == errof { break } if tracerr.Unwrap(err) == setTypeLine { if ps.typ != "" { return ps, tracerr.Wrap(fmt.Errorf("Line %d: Instruction of 'Type: %s' when there is already a previous instruction 'Type: %s' defined", i, instruction.Typ, ps.typ)) } if instruction.Typ == "PoolL2" { ps.typ = SetTypePoolL2 } else if instruction.Typ == "Blockchain" { ps.typ = SetTypeBlockchain } else { log.Fatalf("Line %d: Invalid set type: '%s'. Valid set types: 'Blockchain', 'PoolL2'", i, instruction.Typ) } continue } if tracerr.Unwrap(err) == commentLine { continue } instruction.LineNum = i if tracerr.Unwrap(err) == newEventLine { if instruction.Typ == TypeAddToken && instruction.TokenID == common.TokenID(0) { return ps, tracerr.Wrap(fmt.Errorf("Line %d: AddToken can not register TokenID 0", i)) } ps.instructions = append(ps.instructions, *instruction) continue } if err != nil { return ps, tracerr.Wrap(fmt.Errorf("Line %d: %s, err: %s", i, instruction.Literal, err.Error())) } if ps.typ == "" { return ps, tracerr.Wrap(fmt.Errorf("Line %d: Set type not defined", i)) } ps.instructions = append(ps.instructions, *instruction) users[instruction.From] = true if instruction.Typ == common.TxTypeTransfer || instruction.Typ == common.TxTypeTransferToEthAddr || instruction.Typ == common.TxTypeTransferToBJJ { // type: Transfer users[instruction.To] = true } } for u := range users { ps.users = append(ps.users, u) } sort.Strings(ps.users) return ps, nil }