Browse Source
Merge pull request #64 from hermeznetwork/feature/testing-framework
Feature/testing framework languagefeature/sql-semaphore1
a_bennassar
4 years ago
committed by
GitHub
GitHub
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 829 additions and 296 deletions
Unified View
Diff Options
-
+7 -196batchbuilder/batchbuilder.go
-
+1 -1common/account.go
-
+1 -1common/account_test.go
-
+5 -5common/tx.go
-
+1 -1coordinator/coordinator.go
-
+14 -1db/statedb/statedb.go
-
+195 -0db/statedb/txprocessors.go
-
+2 -2go.mod
-
+6 -0go.sum
-
+356 -0test/lang.go
-
+80 -0test/lang_test.go
-
+111 -0test/txs.go
-
+50 -0test/txs_test.go
-
+0 -89txselector/txselector_test.go
@ -0,0 +1,195 @@ |
|||||
|
package statedb |
||||
|
|
||||
|
import ( |
||||
|
"encoding/binary" |
||||
|
"math/big" |
||||
|
|
||||
|
"github.com/hermeznetwork/hermez-node/common" |
||||
|
"github.com/iden3/go-merkletree/db" |
||||
|
) |
||||
|
|
||||
|
// KEYIDX is used as key in the db to store the current Idx
|
||||
|
var KEYIDX = []byte("idx") |
||||
|
|
||||
|
// ProcessPoolL2Tx process the given PoolL2Tx applying the needed updates to
|
||||
|
// the StateDB depending on the transaction Type.
|
||||
|
func (s *StateDB) ProcessPoolL2Tx(tx *common.PoolL2Tx) error { |
||||
|
switch tx.Type { |
||||
|
case common.TxTypeTransfer: |
||||
|
// go to the MT account of sender and receiver, and update
|
||||
|
// balance & nonce
|
||||
|
err := s.applyTransfer(tx.Tx()) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
case common.TxTypeExit: |
||||
|
// execute exit flow
|
||||
|
default: |
||||
|
} |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
// ProcessL1Tx process the given L1Tx applying the needed updates to the
|
||||
|
// StateDB depending on the transaction Type.
|
||||
|
func (s *StateDB) ProcessL1Tx(tx *common.L1Tx) error { |
||||
|
switch tx.Type { |
||||
|
case common.TxTypeForceTransfer, common.TxTypeTransfer: |
||||
|
// go to the MT account of sender and receiver, and update balance
|
||||
|
// & nonce
|
||||
|
err := s.applyTransfer(tx.Tx()) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
case common.TxTypeCreateAccountDeposit: |
||||
|
// add new account to the MT, update balance of the MT account
|
||||
|
err := s.applyCreateAccount(tx) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
case common.TxTypeDeposit: |
||||
|
// update balance of the MT account
|
||||
|
err := s.applyDeposit(tx, false) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
case common.TxTypeDepositTransfer: |
||||
|
// update balance in MT account, update balance & nonce of sender
|
||||
|
// & receiver
|
||||
|
err := s.applyDeposit(tx, true) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
case common.TxTypeCreateAccountDepositTransfer: |
||||
|
// add new account to the merkletree, update balance in MT account,
|
||||
|
// update balance & nonce of sender & receiver
|
||||
|
err := s.applyCreateAccount(tx) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
err = s.applyTransfer(tx.Tx()) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
case common.TxTypeExit: |
||||
|
// execute exit flow
|
||||
|
default: |
||||
|
} |
||||
|
|
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
// applyCreateAccount creates a new account in the account of the depositer, it
|
||||
|
// stores the deposit value
|
||||
|
func (s *StateDB) applyCreateAccount(tx *common.L1Tx) error { |
||||
|
account := &common.Account{ |
||||
|
TokenID: tx.TokenID, |
||||
|
Nonce: 0, |
||||
|
Balance: tx.LoadAmount, |
||||
|
PublicKey: tx.FromBJJ, |
||||
|
EthAddr: tx.FromEthAddr, |
||||
|
} |
||||
|
|
||||
|
err := s.CreateAccount(common.Idx(s.idx+1), account) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
|
||||
|
s.idx = s.idx + 1 |
||||
|
return s.setIdx(s.idx) |
||||
|
} |
||||
|
|
||||
|
// applyDeposit updates the balance in the account of the depositer, if
|
||||
|
// andTransfer parameter is set to true, the method will also apply the
|
||||
|
// Transfer of the L1Tx/DepositTransfer
|
||||
|
func (s *StateDB) applyDeposit(tx *common.L1Tx, transfer bool) error { |
||||
|
// deposit the tx.LoadAmount into the sender account
|
||||
|
accSender, err := s.GetAccount(tx.FromIdx) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
accSender.Balance = new(big.Int).Add(accSender.Balance, tx.LoadAmount) |
||||
|
|
||||
|
// in case that the tx is a L1Tx>DepositTransfer
|
||||
|
if transfer { |
||||
|
accReceiver, err := s.GetAccount(tx.ToIdx) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
// substract amount to the sender
|
||||
|
accSender.Balance = new(big.Int).Sub(accSender.Balance, tx.Amount) |
||||
|
// add amount to the receiver
|
||||
|
accReceiver.Balance = new(big.Int).Add(accReceiver.Balance, tx.Amount) |
||||
|
// update receiver account in localStateDB
|
||||
|
err = s.UpdateAccount(tx.ToIdx, accReceiver) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
} |
||||
|
// update sender account in localStateDB
|
||||
|
err = s.UpdateAccount(tx.FromIdx, accSender) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
// applyTransfer updates the balance & nonce in the account of the sender, and
|
||||
|
// the balance in the account of the receiver
|
||||
|
func (s *StateDB) applyTransfer(tx *common.Tx) error { |
||||
|
// get sender and receiver accounts from localStateDB
|
||||
|
accSender, err := s.GetAccount(tx.FromIdx) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
accReceiver, err := s.GetAccount(tx.ToIdx) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
|
||||
|
// substract amount to the sender
|
||||
|
accSender.Balance = new(big.Int).Sub(accSender.Balance, tx.Amount) |
||||
|
// add amount to the receiver
|
||||
|
accReceiver.Balance = new(big.Int).Add(accReceiver.Balance, tx.Amount) |
||||
|
|
||||
|
// update receiver account in localStateDB
|
||||
|
err = s.UpdateAccount(tx.ToIdx, accReceiver) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
// update sender account in localStateDB
|
||||
|
err = s.UpdateAccount(tx.FromIdx, accSender) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
|
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
// getIdx returns the stored Idx from the localStateDB, which is the last Idx
|
||||
|
// used for an Account in the localStateDB.
|
||||
|
func (s *StateDB) getIdx() (uint64, error) { |
||||
|
idxBytes, err := s.DB().Get(KEYIDX) |
||||
|
if err == db.ErrNotFound { |
||||
|
return 0, nil |
||||
|
} |
||||
|
if err != nil { |
||||
|
return 0, err |
||||
|
} |
||||
|
idx := binary.LittleEndian.Uint64(idxBytes[:8]) |
||||
|
return idx, nil |
||||
|
} |
||||
|
|
||||
|
// setIdx stores Idx in the localStateDB
|
||||
|
func (s *StateDB) setIdx(idx uint64) error { |
||||
|
tx, err := s.DB().NewTx() |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
var idxBytes [8]byte |
||||
|
binary.LittleEndian.PutUint64(idxBytes[:], idx) |
||||
|
tx.Put(KEYIDX, idxBytes[:]) |
||||
|
if err := tx.Commit(); err != nil { |
||||
|
return err |
||||
|
} |
||||
|
return nil |
||||
|
} |
||||
@ -0,0 +1,356 @@ |
|||||
|
package test |
||||
|
|
||||
|
import ( |
||||
|
"bufio" |
||||
|
"bytes" |
||||
|
"fmt" |
||||
|
"io" |
||||
|
"sort" |
||||
|
"strconv" |
||||
|
|
||||
|
"github.com/hermeznetwork/hermez-node/common" |
||||
|
) |
||||
|
|
||||
|
var eof = rune(0) |
||||
|
var errof = fmt.Errorf("eof in parseline") |
||||
|
var ecomment = fmt.Errorf("comment in parseline") |
||||
|
|
||||
|
const ( |
||||
|
ILLEGAL Token = iota |
||||
|
WS |
||||
|
EOF |
||||
|
|
||||
|
IDENT // val
|
||||
|
) |
||||
|
|
||||
|
type Instruction struct { |
||||
|
Literal string |
||||
|
From string |
||||
|
To string |
||||
|
Amount uint64 |
||||
|
Fee uint8 |
||||
|
TokenID common.TokenID |
||||
|
Type common.TxType // D: Deposit, T: Transfer, E: ForceExit
|
||||
|
} |
||||
|
|
||||
|
type Instructions struct { |
||||
|
Instructions []*Instruction |
||||
|
Accounts []string |
||||
|
TokenIDs []common.TokenID |
||||
|
} |
||||
|
|
||||
|
func (i Instruction) String() string { |
||||
|
buf := bytes.NewBufferString("") |
||||
|
switch i.Type { |
||||
|
case common.TxTypeCreateAccountDeposit: |
||||
|
fmt.Fprintf(buf, "Type: Create&Deposit, ") |
||||
|
case common.TxTypeTransfer: |
||||
|
fmt.Fprintf(buf, "Type: Transfer, ") |
||||
|
case common.TxTypeForceExit: |
||||
|
fmt.Fprintf(buf, "Type: ForceExit, ") |
||||
|
default: |
||||
|
} |
||||
|
fmt.Fprintf(buf, "From: %s, ", i.From) |
||||
|
if i.Type == common.TxTypeTransfer { |
||||
|
fmt.Fprintf(buf, "To: %s, ", i.To) |
||||
|
} |
||||
|
fmt.Fprintf(buf, "Amount: %d, ", i.Amount) |
||||
|
if i.Type == common.TxTypeTransfer { |
||||
|
fmt.Fprintf(buf, "Fee: %d, ", i.Fee) |
||||
|
} |
||||
|
fmt.Fprintf(buf, "TokenID: %d,\n", i.TokenID) |
||||
|
return buf.String() |
||||
|
} |
||||
|
|
||||
|
func (i Instruction) Raw() string { |
||||
|
buf := bytes.NewBufferString("") |
||||
|
fmt.Fprintf(buf, "%s", i.From) |
||||
|
if i.Type == common.TxTypeTransfer { |
||||
|
fmt.Fprintf(buf, "-%s", i.To) |
||||
|
} |
||||
|
fmt.Fprintf(buf, " (%d)", i.TokenID) |
||||
|
if i.Type == common.TxTypeForceExit { |
||||
|
fmt.Fprintf(buf, "E") |
||||
|
} |
||||
|
fmt.Fprintf(buf, ":") |
||||
|
fmt.Fprintf(buf, " %d", i.Amount) |
||||
|
if i.Type == 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() (*Instruction, error) { |
||||
|
// line can be Deposit:
|
||||
|
// A (1): 10
|
||||
|
// or Transfer:
|
||||
|
// A-B (1): 6
|
||||
|
// or Withdraw:
|
||||
|
// A (1) E: 4
|
||||
|
c := &Instruction{} |
||||
|
tok, lit := p.scanIgnoreWhitespace() |
||||
|
if tok == EOF { |
||||
|
return nil, errof |
||||
|
} |
||||
|
c.Literal += lit |
||||
|
if lit == "/" { |
||||
|
_, _ = p.s.r.ReadString('\n') |
||||
|
return nil, ecomment |
||||
|
} |
||||
|
c.From = lit |
||||
|
|
||||
|
_, lit = p.scanIgnoreWhitespace() |
||||
|
c.Literal += lit |
||||
|
if lit == "-" { |
||||
|
// transfer
|
||||
|
_, lit = p.scanIgnoreWhitespace() |
||||
|
c.Literal += lit |
||||
|
c.To = lit |
||||
|
c.Type = common.TxTypeTransfer |
||||
|
_, lit = p.scanIgnoreWhitespace() // expect (
|
||||
|
c.Literal += lit |
||||
|
if lit != "(" { |
||||
|
line, _ := p.s.r.ReadString('\n') |
||||
|
c.Literal += line |
||||
|
return c, fmt.Errorf("Expected '(', found '%s'", lit) |
||||
|
} |
||||
|
} else { |
||||
|
c.Type = common.TxTypeCreateAccountDeposit |
||||
|
} |
||||
|
|
||||
|
_, 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) |
||||
|
_, lit = p.scanIgnoreWhitespace() // expect )
|
||||
|
c.Literal += lit |
||||
|
if lit != ")" { |
||||
|
line, _ := p.s.r.ReadString('\n') |
||||
|
c.Literal += line |
||||
|
return c, fmt.Errorf("Expected ')', found '%s'", lit) |
||||
|
} |
||||
|
|
||||
|
_, lit = p.scanIgnoreWhitespace() // expect ':' or 'E' (Exit type)
|
||||
|
c.Literal += lit |
||||
|
if lit == "E" { |
||||
|
c.Type = common.TxTypeForceExit |
||||
|
_, lit = p.scanIgnoreWhitespace() // expect ':'
|
||||
|
c.Literal += lit |
||||
|
} |
||||
|
if lit != ":" { |
||||
|
line, _ := p.s.r.ReadString('\n') |
||||
|
c.Literal += line |
||||
|
return c, fmt.Errorf("Expected ':', found '%s'", lit) |
||||
|
} |
||||
|
tok, 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 |
||||
|
} |
||||
|
c.Amount = uint64(amount) |
||||
|
|
||||
|
if c.Type == common.TxTypeTransfer { |
||||
|
tok, 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 > 255 { |
||||
|
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 tok == EOF { |
||||
|
return nil, errof |
||||
|
} |
||||
|
return c, nil |
||||
|
} |
||||
|
|
||||
|
// Parse parses through reader
|
||||
|
func (p *Parser) Parse() (Instructions, error) { |
||||
|
var instructions Instructions |
||||
|
i := 0 |
||||
|
accounts := make(map[string]bool) |
||||
|
tokenids := make(map[common.TokenID]bool) |
||||
|
for { |
||||
|
instruction, err := p.parseLine() |
||||
|
if err == errof { |
||||
|
break |
||||
|
} |
||||
|
if err == ecomment { |
||||
|
i++ |
||||
|
continue |
||||
|
} |
||||
|
if err != nil { |
||||
|
return instructions, fmt.Errorf("error parsing line %d: %s, err: %s", i, instruction.Literal, err.Error()) |
||||
|
} |
||||
|
instructions.Instructions = append(instructions.Instructions, instruction) |
||||
|
accounts[instruction.From] = true |
||||
|
if instruction.Type == 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 |
||||
|
} |
||||
@ -0,0 +1,80 @@ |
|||||
|
package test |
||||
|
|
||||
|
import ( |
||||
|
"fmt" |
||||
|
"strings" |
||||
|
"testing" |
||||
|
|
||||
|
"github.com/stretchr/testify/assert" |
||||
|
) |
||||
|
|
||||
|
var debug = false |
||||
|
|
||||
|
func TestParse(t *testing.T) { |
||||
|
s := ` |
||||
|
// deposits
|
||||
|
A (1): 10 |
||||
|
A (2): 20 |
||||
|
B (1): 5 |
||||
|
|
||||
|
// L2 transactions
|
||||
|
A-B (1): 6 1 |
||||
|
B-C (1): 3 1 |
||||
|
C-A (1): 3 1 |
||||
|
A-B (2): 15 1 |
||||
|
|
||||
|
User0 (1): 20 |
||||
|
User1 (3) : 20 |
||||
|
User0-User1 (1): 15 1 |
||||
|
User1-User0 (3): 15 1 |
||||
|
|
||||
|
// Exits
|
||||
|
A (1) E: 5 |
||||
|
` |
||||
|
parser := NewParser(strings.NewReader(s)) |
||||
|
instructions, err := parser.Parse() |
||||
|
assert.Nil(t, err) |
||||
|
assert.Equal(t, 12, len(instructions.Instructions)) |
||||
|
assert.Equal(t, 5, len(instructions.Accounts)) |
||||
|
assert.Equal(t, 3, len(instructions.TokenIDs)) |
||||
|
|
||||
|
if debug { |
||||
|
fmt.Println(instructions) |
||||
|
for _, instruction := range instructions.Instructions { |
||||
|
fmt.Println(instruction.Raw()) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
assert.Equal(t, "User0 (1): 20", instructions.Instructions[7].Raw()) |
||||
|
assert.Equal(t, "Type: Create&Deposit, From: User0, Amount: 20, TokenID: 1,\n", instructions.Instructions[7].String()) |
||||
|
assert.Equal(t, "User0-User1 (1): 15 1", instructions.Instructions[9].Raw()) |
||||
|
assert.Equal(t, "Type: Transfer, From: User0, To: User1, Amount: 15, Fee: 1, TokenID: 1,\n", instructions.Instructions[9].String()) |
||||
|
assert.Equal(t, "A (1)E: 5", instructions.Instructions[11].Raw()) |
||||
|
assert.Equal(t, "Type: ForceExit, From: A, Amount: 5, TokenID: 1,\n", instructions.Instructions[11].String()) |
||||
|
} |
||||
|
|
||||
|
func TestParseErrors(t *testing.T) { |
||||
|
s := "A (1):: 10" |
||||
|
parser := NewParser(strings.NewReader(s)) |
||||
|
_, err := parser.Parse() |
||||
|
assert.Equal(t, "error parsing line 0: A(1):: 10, err: strconv.Atoi: parsing \":\": invalid syntax", err.Error()) |
||||
|
|
||||
|
s = "A (1): 10 20" |
||||
|
parser = NewParser(strings.NewReader(s)) |
||||
|
_, err = parser.Parse() |
||||
|
assert.Equal(t, "error parsing line 1: 20, err: strconv.Atoi: parsing \"\": invalid syntax", err.Error()) |
||||
|
|
||||
|
s = "A B (1): 10" |
||||
|
parser = NewParser(strings.NewReader(s)) |
||||
|
_, err = parser.Parse() |
||||
|
assert.Equal(t, "error parsing line 0: AB(1): 10, err: strconv.Atoi: parsing \"(\": invalid syntax", err.Error()) |
||||
|
|
||||
|
s = "A-B (1): 10 255" |
||||
|
parser = NewParser(strings.NewReader(s)) |
||||
|
_, err = parser.Parse() |
||||
|
assert.Nil(t, err) |
||||
|
s = "A-B (1): 10 256" |
||||
|
parser = NewParser(strings.NewReader(s)) |
||||
|
_, err = parser.Parse() |
||||
|
assert.Equal(t, "error parsing line 0: A-B(1):10256, err: Fee 256 can not be bigger than 255", err.Error()) |
||||
|
} |
||||
@ -0,0 +1,111 @@ |
|||||
|
package test |
||||
|
|
||||
|
import ( |
||||
|
"crypto/ecdsa" |
||||
|
"math/big" |
||||
|
"strconv" |
||||
|
"testing" |
||||
|
"time" |
||||
|
|
||||
|
ethCommon "github.com/ethereum/go-ethereum/common" |
||||
|
ethCrypto "github.com/ethereum/go-ethereum/crypto" |
||||
|
"github.com/hermeznetwork/hermez-node/common" |
||||
|
"github.com/iden3/go-iden3-crypto/babyjub" |
||||
|
) |
||||
|
|
||||
|
type Account struct { |
||||
|
BJJ *babyjub.PrivateKey |
||||
|
Addr ethCommon.Address |
||||
|
Idx common.Idx |
||||
|
Nonce uint64 |
||||
|
} |
||||
|
|
||||
|
// GenerateKeys generates BabyJubJub & Address keys for the given list of
|
||||
|
// account names in a deterministic way. This means, that for the same given
|
||||
|
// 'accNames' the keys will be always the same.
|
||||
|
func GenerateKeys(t *testing.T, accNames []string) map[string]*Account { |
||||
|
acc := make(map[string]*Account) |
||||
|
for i := 1; i < len(accNames)+1; i++ { |
||||
|
// babyjubjub key
|
||||
|
var sk babyjub.PrivateKey |
||||
|
copy(sk[:], []byte(strconv.Itoa(i))) // only for testing
|
||||
|
|
||||
|
// eth address
|
||||
|
var key ecdsa.PrivateKey |
||||
|
key.D = big.NewInt(int64(i)) // only for testing
|
||||
|
key.PublicKey.X, key.PublicKey.Y = ethCrypto.S256().ScalarBaseMult(key.D.Bytes()) |
||||
|
key.Curve = ethCrypto.S256() |
||||
|
addr := ethCrypto.PubkeyToAddress(key.PublicKey) |
||||
|
|
||||
|
a := Account{ |
||||
|
BJJ: &sk, |
||||
|
Addr: addr, |
||||
|
Nonce: 0, |
||||
|
} |
||||
|
acc[accNames[i-1]] = &a |
||||
|
} |
||||
|
return acc |
||||
|
} |
||||
|
|
||||
|
// GenerateTestTxs generates L1Tx & PoolL2Tx in a deterministic way for the
|
||||
|
// given Instructions.
|
||||
|
func GenerateTestTxs(t *testing.T, instructions Instructions) ([]*common.L1Tx, []*common.PoolL2Tx) { |
||||
|
accounts := GenerateKeys(t, instructions.Accounts) |
||||
|
|
||||
|
// debug
|
||||
|
// fmt.Println("accounts:")
|
||||
|
// for n, a := range accounts {
|
||||
|
// fmt.Printf(" %s: bjj:%s - addr:%s\n", n, a.BJJ.Public().String()[:10], a.Addr.Hex()[:10])
|
||||
|
// }
|
||||
|
|
||||
|
var l1txs []*common.L1Tx |
||||
|
var l2txs []*common.PoolL2Tx |
||||
|
idx := 1 |
||||
|
for _, inst := range instructions.Instructions { |
||||
|
switch inst.Type { |
||||
|
case common.TxTypeCreateAccountDeposit: |
||||
|
tx := common.L1Tx{ |
||||
|
// TxID
|
||||
|
FromEthAddr: accounts[inst.From].Addr, |
||||
|
FromBJJ: accounts[inst.From].BJJ.Public(), |
||||
|
TokenID: inst.TokenID, |
||||
|
LoadAmount: big.NewInt(int64(inst.Amount)), |
||||
|
Type: common.TxTypeCreateAccountDeposit, |
||||
|
} |
||||
|
l1txs = append(l1txs, &tx) |
||||
|
if accounts[inst.From].Idx == common.Idx(0) { // if account.Idx is not set yet, set it and increment idx
|
||||
|
accounts[inst.From].Idx = common.Idx(idx) |
||||
|
idx++ |
||||
|
} |
||||
|
case common.TxTypeTransfer: |
||||
|
tx := common.PoolL2Tx{ |
||||
|
// TxID: nil,
|
||||
|
FromIdx: accounts[inst.From].Idx, |
||||
|
ToIdx: accounts[inst.To].Idx, |
||||
|
ToEthAddr: accounts[inst.To].Addr, |
||||
|
ToBJJ: accounts[inst.To].BJJ.Public(), |
||||
|
TokenID: inst.TokenID, |
||||
|
Amount: big.NewInt(int64(inst.Amount)), |
||||
|
Fee: common.FeeSelector(inst.Fee), |
||||
|
Nonce: accounts[inst.From].Nonce, |
||||
|
State: common.PoolL2TxStatePending, |
||||
|
Timestamp: time.Now(), |
||||
|
BatchNum: 0, |
||||
|
Type: common.TxTypeTransfer, |
||||
|
} |
||||
|
// if inst.Fee == 0 {
|
||||
|
// tx.Fee = common.FeeSelector(i % 255)
|
||||
|
// }
|
||||
|
// TODO once signature function is ready, perform
|
||||
|
// signature and set it to tx.Signature
|
||||
|
|
||||
|
accounts[inst.From].Nonce++ |
||||
|
l2txs = append(l2txs, &tx) |
||||
|
default: |
||||
|
continue |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
return l1txs, l2txs |
||||
|
} |
||||
@ -0,0 +1,50 @@ |
|||||
|
package test |
||||
|
|
||||
|
import ( |
||||
|
"strings" |
||||
|
"testing" |
||||
|
|
||||
|
"github.com/hermeznetwork/hermez-node/common" |
||||
|
"github.com/stretchr/testify/assert" |
||||
|
"github.com/stretchr/testify/require" |
||||
|
) |
||||
|
|
||||
|
func TestGenerateTestL2Txs(t *testing.T) { |
||||
|
s := ` |
||||
|
A (1): 10 |
||||
|
A (2): 20 |
||||
|
B (1): 5 |
||||
|
A-B (1): 6 1 |
||||
|
B-C (1): 3 1 |
||||
|
C-A (1): 3 1 |
||||
|
A-B (2): 15 1 |
||||
|
User0 (1): 20 |
||||
|
User1 (3) : 20 |
||||
|
User0-User1 (1): 15 1 |
||||
|
User1-User0 (3): 15 1 |
||||
|
` |
||||
|
parser := NewParser(strings.NewReader(s)) |
||||
|
instructions, err := parser.Parse() |
||||
|
assert.Nil(t, err) |
||||
|
|
||||
|
l1txs, l2txs := GenerateTestTxs(t, instructions) |
||||
|
require.Equal(t, 5, len(l1txs)) |
||||
|
require.Equal(t, 6, len(l2txs)) |
||||
|
|
||||
|
// l1txs
|
||||
|
assert.Equal(t, common.TxTypeCreateAccountDeposit, l1txs[0].Type) |
||||
|
assert.Equal(t, "5bac784d938067d980a9d39bdd79bf84a0cbb296977c47cc30de2d5ce9229d2f", l1txs[0].FromBJJ.String()) |
||||
|
assert.Equal(t, "5bac784d938067d980a9d39bdd79bf84a0cbb296977c47cc30de2d5ce9229d2f", l1txs[1].FromBJJ.String()) |
||||
|
assert.Equal(t, "323ff10c28df37ecb787fe216e111db64aa7cfa2c517509fe0057ff08a10b30c", l1txs[2].FromBJJ.String()) |
||||
|
assert.Equal(t, "a25c7150609ecfcf90fc3f419474e8bc28ea5978df1b0a68339bff884c117e19", l1txs[4].FromBJJ.String()) |
||||
|
|
||||
|
// l2txs
|
||||
|
assert.Equal(t, common.TxTypeTransfer, l2txs[0].Type) |
||||
|
assert.Equal(t, common.Idx(1), l2txs[0].FromIdx) |
||||
|
assert.Equal(t, common.Idx(2), l2txs[0].ToIdx) |
||||
|
assert.Equal(t, "323ff10c28df37ecb787fe216e111db64aa7cfa2c517509fe0057ff08a10b30c", l2txs[0].ToBJJ.String()) |
||||
|
assert.Equal(t, "0x2B5AD5c4795c026514f8317c7a215E218DcCD6cF", l2txs[0].ToEthAddr.Hex()) |
||||
|
assert.Equal(t, uint64(0), l2txs[0].Nonce) |
||||
|
assert.Equal(t, uint64(1), l2txs[3].Nonce) |
||||
|
assert.Equal(t, common.FeeSelector(1), l2txs[0].Fee) |
||||
|
} |
||||