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.
 
 
 

562 lines
14 KiB

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
}