hermez-node/test/transakcio/lang.go

package transakcio

import (
	"bufio"
	"bytes"
	"fmt"
	"io"
	"log"
	"sort"
	"strconv"

	"github.com/hermeznetwork/hermez-node/common"
)

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 = "TxTypeNewBatch"

// typeNewBlock is used for testing purposes only, and represents the
// common.TxType of a new ethereum block
var typeNewBlock common.TxType = "TxTypeNewBlock"

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 {
	literal    string
	from       string
	to         string
	amount     uint64
	loadAmount uint64
	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 {
	// type         string
	instructions []instruction
	accounts     []string
	tokenIDs     []common.TokenID
}

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, errof
	}
	c.literal += lit
	if lit == "/" {
		_, _ = p.s.r.ReadString('\n')
		return nil, commentLine
	} else if lit == ">" {
		if setType == setTypePoolL2 {
			return c, 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 == "block" {
			_, _ = p.s.r.ReadString('\n')
			return &instruction{typ: typeNewBlock}, newEventLine
		} else {
			return c, fmt.Errorf("Unexpected '> %s', expected '> batch' or '> block'", lit)
		}
	} else if lit == "Type" {
		if err := p.expectChar(c, ":"); err != nil {
			return c, err
		}
		_, lit = p.scanIgnoreWhitespace()
		if lit == "Blockchain" {
			return &instruction{typ: "Blockchain"}, setTypeLine
		} else if lit == "PoolL2" {
			return &instruction{typ: "PoolL2"}, setTypeLine
		} else {
			return c, fmt.Errorf("Invalid set type: '%s'. Valid set types: 'Blockchain', 'PoolL2'", lit)
		}
	}
	if setType == "" {
		return c, fmt.Errorf("Set type not defined")
	}
	transferring := false

	if setType == setTypeBlockchain {
		switch lit {
		case "Deposit":
			c.typ = common.TxTypeDeposit
		case "Exit":
			c.typ = common.TxTypeExit
		case "Transfer":
			c.typ = common.TxTypeTransfer
			transferring = true
		case "CreateAccountDeposit":
			c.typ = common.TxTypeCreateAccountDeposit
		case "CreateAccountDepositTransfer":
			c.typ = common.TxTypeCreateAccountDepositTransfer
			transferring = true
		case "CreateAccountDepositCoordinator":
			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
		case "ForceExit":
			c.typ = common.TxTypeForceExit
		default:
			return c, fmt.Errorf("Unexpected Blockchain tx type: %s", lit)
		}
	} else if setType == setTypePoolL2 {
		switch lit {
		case "PoolTransfer":
			c.typ = common.TxTypeTransfer
			transferring = true
		case "PoolExit":
			c.typ = common.TxTypeExit
		default:
			return c, fmt.Errorf("Unexpected PoolL2 tx type: %s", lit)
		}
	} else {
		return c, fmt.Errorf("Invalid set type: '%s'. Valid set types: 'Blockchain', 'PoolL2'", setType)
	}

	if err := p.expectChar(c, "("); err != nil {
		return c, 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, err
	}
	c.tokenID = common.TokenID(tidI)
	if err := p.expectChar(c, ")"); err != nil {
		return c, 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, 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, fmt.Errorf("Expected ':', found '%s'", lit)
	}
	if c.typ == common.TxTypeDepositTransfer ||
		c.typ == common.TxTypeCreateAccountDepositTransfer {
		// deposit case
		_, lit = p.scanIgnoreWhitespace()
		c.literal += lit
		loadAmount, err := strconv.Atoi(lit)
		if err != nil {
			line, _ := p.s.r.ReadString('\n')
			c.literal += line
			return c, err
		}
		c.loadAmount = uint64(loadAmount)
		if err := p.expectChar(c, ","); err != nil {
			return c, err
		}
	}
	_, lit = p.scanIgnoreWhitespace()
	c.literal += lit
	amount, err := strconv.Atoi(lit)
	if err != nil {
		line, _ := p.s.r.ReadString('\n')
		c.literal += line
		return c, err
	}
	if c.typ == common.TxTypeDeposit ||
		c.typ == common.TxTypeCreateAccountDeposit {
		c.loadAmount = uint64(amount)
	} else {
		c.amount = uint64(amount)
	}
	if transferring {
		if err := p.expectChar(c, "("); err != nil {
			return c, 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, err
		}
		if fee > common.MaxFeePlan-1 {
			line, _ := p.s.r.ReadString('\n')
			c.literal += line
			return c, fmt.Errorf("Fee %d can not be bigger than 255", fee)
		}
		c.fee = uint8(fee)

		if err := p.expectChar(c, ")"); err != nil {
			return c, err
		}
	}

	if tok == EOF {
		return nil, 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 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) {
	instructions := &parsedSet{}
	i := 0
	accounts := make(map[string]bool)
	tokenids := make(map[common.TokenID]bool)
	var setTypeOfSet setType
	for {
		instruction, err := p.parseLine(setTypeOfSet)
		if err == errof {
			break
		}
		if err == setTypeLine {
			if instruction.typ == "PoolL2" {
				setTypeOfSet = setTypePoolL2
			} else if instruction.typ == "Blockchain" {
				setTypeOfSet = setTypeBlockchain
			} else {
				log.Fatalf("Invalid set type: '%s'. Valid set types: 'Blockchain', 'PoolL2'", instruction.typ)
			}
			i++
			continue
		}
		if err == commentLine {
			i++
			continue
		}
		if err == newEventLine {
			i++
			instructions.instructions = append(instructions.instructions, *instruction)
			continue
		}
		if err != nil {
			return instructions, fmt.Errorf("error parsing line %d: %s, err: %s", i, instruction.literal, err.Error())
		}
		if setTypeOfSet == "" {
			return instructions, fmt.Errorf("Set type not defined")
		}
		instructions.instructions = append(instructions.instructions, *instruction)
		accounts[instruction.from] = true
		if instruction.typ == common.TxTypeTransfer { // type: Transfer
			accounts[instruction.to] = true
		}
		tokenids[instruction.tokenID] = true
		i++
	}
	for a := range accounts {
		instructions.accounts = append(instructions.accounts, a)
	}
	sort.Strings(instructions.accounts)
	for tid := range tokenids {
		instructions.tokenIDs = append(instructions.tokenIDs, tid)
	}
	return instructions, nil
}