From e2d459969099cd82a0e2b5a12c5469f0c51b9c11 Mon Sep 17 00:00:00 2001 From: arnaucube Date: Wed, 19 Aug 2020 15:21:35 +0200 Subject: [PATCH 1/3] Add tx generation lang interpreter --- common/account.go | 2 +- common/account_test.go | 2 +- go.mod | 4 +- go.sum | 6 + test/lang.go | 304 +++++++++++++++++++++++++++++++++++++++++ test/lang_test.go | 62 +++++++++ 6 files changed, 376 insertions(+), 4 deletions(-) create mode 100644 test/lang.go create mode 100644 test/lang_test.go diff --git a/common/account.go b/common/account.go index 6e64a44..b6cc425 100644 --- a/common/account.go +++ b/common/account.go @@ -71,7 +71,7 @@ func (l *Account) BigInts() ([NLEAFELEMS]*big.Int, error) { // HashValue returns the value of the Account, which is the Poseidon hash of its *big.Int representation func (l *Account) HashValue() (*big.Int, error) { b0 := big.NewInt(0) - toHash := [poseidon.T]*big.Int{b0, b0, b0, b0, b0, b0} + toHash := []*big.Int{b0, b0, b0, b0, b0, b0} lBI, err := l.BigInts() if err != nil { return nil, err diff --git a/common/account_test.go b/common/account_test.go index cf6b36b..c19d0b7 100644 --- a/common/account_test.go +++ b/common/account_test.go @@ -106,7 +106,7 @@ func TestAccountHashValue(t *testing.T) { v, err := account.HashValue() assert.Nil(t, err) - assert.Equal(t, "6335844662301214382338419199835935731871537354006112711277201708185593574314", v.String()) + assert.Equal(t, "16085711911723375585301279875451049849443101031421093098714359651259271023730", v.String()) } func TestAccountErrNotInFF(t *testing.T) { diff --git a/go.mod b/go.mod index 3c8a666..33a2888 100644 --- a/go.mod +++ b/go.mod @@ -8,8 +8,8 @@ require ( github.com/go-sql-driver/mysql v1.5.0 // indirect github.com/gobuffalo/packr/v2 v2.8.0 github.com/iden3/go-iden3-core v0.0.8 - github.com/iden3/go-iden3-crypto v0.0.6-0.20200814110325-70841d78e7d8 - github.com/iden3/go-merkletree v0.0.0-20200815144208-1f1bd54b93ae + github.com/iden3/go-iden3-crypto v0.0.6-0.20200819064831-09d161e9f670 + github.com/iden3/go-merkletree v0.0.0-20200819092443-dc656fdd32fc github.com/jinzhu/gorm v1.9.15 github.com/jmoiron/sqlx v1.2.0 github.com/lib/pq v1.8.0 diff --git a/go.sum b/go.sum index ff62838..2e6a56f 100644 --- a/go.sum +++ b/go.sum @@ -274,6 +274,8 @@ github.com/iden3/go-iden3-crypto v0.0.6-0.20200813145745-66519124ca17 h1:aqy++85 github.com/iden3/go-iden3-crypto v0.0.6-0.20200813145745-66519124ca17/go.mod h1:oBgthFLboAWi9feaBUFy7OxEcyn9vA1khHSL/WwWFyg= github.com/iden3/go-iden3-crypto v0.0.6-0.20200814110325-70841d78e7d8 h1:1QeVvr/DjiBpk8tw3vBfYD+zs0JeYl3fPIUA/foDq3w= github.com/iden3/go-iden3-crypto v0.0.6-0.20200814110325-70841d78e7d8/go.mod h1:oBgthFLboAWi9feaBUFy7OxEcyn9vA1khHSL/WwWFyg= +github.com/iden3/go-iden3-crypto v0.0.6-0.20200819064831-09d161e9f670 h1:gNBFu/WnRfNn+xywE04fgCWSHlb6wr0nIIll9i4R2fc= +github.com/iden3/go-iden3-crypto v0.0.6-0.20200819064831-09d161e9f670/go.mod h1:oBgthFLboAWi9feaBUFy7OxEcyn9vA1khHSL/WwWFyg= github.com/iden3/go-merkletree v0.0.0-20200723202738-75e24244a1e3 h1:QR6LqG1HqqPE4myiLR73QFIieAfwODG3bqo1juuaqVI= github.com/iden3/go-merkletree v0.0.0-20200723202738-75e24244a1e3/go.mod h1:Fc49UeywIsj8nUfb5lxBzmWrMeMmqzTJ5F0OcjdiEME= github.com/iden3/go-merkletree v0.0.0-20200806171216-dd600560e44c h1:EzVMSVkwKdfcOR1a+rZe9dfbtAj6KdJnBxOEZ5B+gCQ= @@ -284,6 +286,10 @@ github.com/iden3/go-merkletree v0.0.0-20200815105542-2277604e65dd h1:AkPlODLWkgQ github.com/iden3/go-merkletree v0.0.0-20200815105542-2277604e65dd/go.mod h1:/MsQOzDnxK8X/u7XP9ZBoZwZ4gIm9FlwfqckH5dRuTM= github.com/iden3/go-merkletree v0.0.0-20200815144208-1f1bd54b93ae h1:CC8oKPM+38/Dkq20QymuIjyRo0UFzJZeH5DPbGWURrI= github.com/iden3/go-merkletree v0.0.0-20200815144208-1f1bd54b93ae/go.mod h1:/MsQOzDnxK8X/u7XP9ZBoZwZ4gIm9FlwfqckH5dRuTM= +github.com/iden3/go-merkletree v0.0.0-20200819075941-77df3096f7ea h1:0MtMnN42ULNxOnJYa0FH1qjeSEBPkYVH6ZCs22rz2FU= +github.com/iden3/go-merkletree v0.0.0-20200819075941-77df3096f7ea/go.mod h1:MRe6i0mi2oDVUzgBIHsNRE6XAg8EBuqIQZMsd+do+dU= +github.com/iden3/go-merkletree v0.0.0-20200819092443-dc656fdd32fc h1:VnRP7JCp5TJHnTC+r8NrXGkRBvp62tRGqeA3FcdEq+Q= +github.com/iden3/go-merkletree v0.0.0-20200819092443-dc656fdd32fc/go.mod h1:MRe6i0mi2oDVUzgBIHsNRE6XAg8EBuqIQZMsd+do+dU= github.com/iden3/go-wasm3 v0.0.1/go.mod h1:j+TcAB94Dfrjlu5kJt83h2OqAU+oyNUTwNZnQyII1sI= github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= github.com/influxdata/influxdb v1.2.3-0.20180221223340-01288bdb0883/go.mod h1:qZna6X/4elxqT3yI9iZYdZrWWdeFOOprn86kgg4+IzY= diff --git a/test/lang.go b/test/lang.go new file mode 100644 index 0000000..444c793 --- /dev/null +++ b/test/lang.go @@ -0,0 +1,304 @@ +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") + +const ( + ILLEGAL Token = iota + WS + EOF + + IDENT // val +) + +type Instruction struct { + Literal string + From string + To string + Amount uint64 + TokenID common.TokenID + Type int // 0: Deposit, 1: Transfer +} + +type Instructions struct { + Instructions []*Instruction + Accounts []string + TokenIDs []common.TokenID +} + +func (i Instruction) String() string { + buf := bytes.NewBufferString("") + switch i.Type { + case 0: + fmt.Fprintf(buf, "Type: Deposit, ") + case 1: + fmt.Fprintf(buf, "Type: Transfer, ") + default: + } + fmt.Fprintf(buf, "From: %s, ", i.From) + if i.Type == 1 { + fmt.Fprintf(buf, "To: %s, ", i.To) + } + fmt.Fprintf(buf, "Amount: %d, ", i.Amount) + 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 == 1 { + fmt.Fprintf(buf, "-%s", i.To) + } + fmt.Fprintf(buf, " (%d):", i.TokenID) + fmt.Fprintf(buf, " %d", i.Amount) + 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 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() + } + + 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 + */ + c := &Instruction{} + tok, lit := p.scanIgnoreWhitespace() + if tok == EOF { + return nil, errof + } + c.Literal += lit + c.From = lit + + _, lit = p.scanIgnoreWhitespace() + c.Literal += lit + if lit == "-" { + // transfer + _, lit = p.scanIgnoreWhitespace() + c.Literal += lit + c.To = lit + c.Type = 1 + _, 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 = 0 + } + + _, 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 : + 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 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 != 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 == 1 { // 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 +} diff --git a/test/lang_test.go b/test/lang_test.go new file mode 100644 index 0000000..56528ca --- /dev/null +++ b/test/lang_test.go @@ -0,0 +1,62 @@ +package test + +import ( + "fmt" + "strings" + "testing" + + "github.com/stretchr/testify/assert" +) + +var debug = false + +func TestParse(t *testing.T) { + s := ` + A (1): 10 + A (2): 20 + B (1): 5 + A-B (1): 6 + B-C (1): 3 + C-A (1): 3 + A-B (2): 15 + User0 (1): 20 + User1 (3) : 20 + User0-User1 (1): 15 + User1-User0 (3): 15 + ` + parser := NewParser(strings.NewReader(s)) + instructions, err := parser.Parse() + assert.Nil(t, err) + assert.Equal(t, 11, 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: Deposit, From: User0, Amount: 20, TokenID: 1,\n", instructions.Instructions[7].String()) + assert.Equal(t, "User0-User1 (1): 15", instructions.Instructions[9].Raw()) + assert.Equal(t, "Type: Transfer, From: User0, To: User1, Amount: 15, TokenID: 1,\n", instructions.Instructions[9].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()) +} From 8eb42c011c625ac45ac7c1bdc80d6bb959505b3d Mon Sep 17 00:00:00 2001 From: arnaucube Date: Wed, 19 Aug 2020 16:59:08 +0200 Subject: [PATCH 2/3] Add tx L1&L2 test generation & keys for TestingFramework Add test-lang Fee & ForceExit option --- common/tx.go | 10 +-- coordinator/coordinator.go | 2 +- test/lang.go | 86 ++++++++++++++++++++------ test/lang_test.go | 38 +++++++++--- test/txs.go | 111 ++++++++++++++++++++++++++++++++++ test/txs_test.go | 50 +++++++++++++++ txselector/txselector_test.go | 89 --------------------------- 7 files changed, 264 insertions(+), 122 deletions(-) create mode 100644 test/txs.go create mode 100644 test/txs_test.go diff --git a/common/tx.go b/common/tx.go index 744849b..368e0e6 100644 --- a/common/tx.go +++ b/common/tx.go @@ -45,10 +45,10 @@ const ( TxTypeDeposit TxType = "Deposit" // TxTypeCreateAccountDeposit represents creation of a new leaf in the state tree (newAcconut) + L1->L2 transfer TxTypeCreateAccountDeposit TxType = "CreateAccountDeposit" - // TxTypeCreateAccountDepositAndTransfer represents L1->L2 transfer + L2->L2 transfer - TxTypeCreateAccountDepositAndTransfer TxType = "CreateAccountDepositAndTransfer" - // TxTypeDepositAndTransfer TBD - TxTypeDepositAndTransfer TxType = "TxTypeDepositAndTransfer" + // TxTypeCreateAccountDepositTransfer represents L1->L2 transfer + L2->L2 transfer + TxTypeCreateAccountDepositTransfer TxType = "CreateAccountDepositTransfer" + // TxTypeDepositTransfer TBD + TxTypeDepositTransfer TxType = "TxTypeDepositTransfer" // TxTypeForceTransfer TBD TxTypeForceTransfer TxType = "TxTypeForceTransfer" // TxTypeForceExit TBD @@ -63,7 +63,7 @@ const ( type Tx struct { TxID TxID FromIdx Idx // FromIdx is used by L1Tx/Deposit to indicate the Idx receiver of the L1Tx.LoadAmount (deposit) - ToIdx Idx // ToIdx is ignored in L1Tx/Deposit, but used in the L1Tx/DepositAndTransfer + ToIdx Idx // ToIdx is ignored in L1Tx/Deposit, but used in the L1Tx/DepositTransfer TokenID TokenID Amount *big.Int Nonce uint64 // effective 48 bits used diff --git a/coordinator/coordinator.go b/coordinator/coordinator.go index 2f361d0..5da9d02 100644 --- a/coordinator/coordinator.go +++ b/coordinator/coordinator.go @@ -133,7 +133,7 @@ func (c *Coordinator) forgeSequence() error { batchInfo.SetTxsInfo(l1UserTxsExtra, l1OperatorTxs, l2Txs) // TODO feesInfo // 4. Call BatchBuilder with TxSelector output - configBatch := batchbuilder.ConfigBatch{ + configBatch := &batchbuilder.ConfigBatch{ ForgerAddress: c.config.ForgerAddress, } zkInputs, err := c.batchBuilder.BuildBatch(configBatch, l1UserTxsExtra, l1OperatorTxs, l2Txs, nil) // TODO []common.TokenID --> feesInfo diff --git a/test/lang.go b/test/lang.go index 444c793..51f4348 100644 --- a/test/lang.go +++ b/test/lang.go @@ -13,6 +13,7 @@ import ( var eof = rune(0) var errof = fmt.Errorf("eof in parseline") +var ecomment = fmt.Errorf("comment in parseline") const ( ILLEGAL Token = iota @@ -27,8 +28,9 @@ type Instruction struct { From string To string Amount uint64 + Fee uint8 TokenID common.TokenID - Type int // 0: Deposit, 1: Transfer + Type common.TxType // D: Deposit, T: Transfer, E: ForceExit } type Instructions struct { @@ -40,17 +42,22 @@ type Instructions struct { func (i Instruction) String() string { buf := bytes.NewBufferString("") switch i.Type { - case 0: - fmt.Fprintf(buf, "Type: Deposit, ") - case 1: + 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 == 1 { + 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() } @@ -58,11 +65,18 @@ func (i Instruction) String() string { func (i Instruction) Raw() string { buf := bytes.NewBufferString("") fmt.Fprintf(buf, "%s", i.From) - if i.Type == 1 { + if i.Type == common.TxTypeTransfer { fmt.Fprintf(buf, "-%s", i.To) } - fmt.Fprintf(buf, " (%d):", i.TokenID) + 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() } @@ -80,6 +94,10 @@ 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') } @@ -113,6 +131,10 @@ func (s *Scanner) scan() (tok Token, lit string) { // letter/digit s.unread() return s.scanIndent() + } else if isComment(ch) { + // comment + s.unread() + return s.scanIndent() } if ch == eof { @@ -198,18 +220,22 @@ func (p *Parser) scanIgnoreWhitespace() (tok Token, lit string) { // parseLine parses the current line func (p *Parser) parseLine() (*Instruction, error) { - /* - line can be Deposit: - A (1): 10 - or Transfer: - A-B (1): 6 - */ + // 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() @@ -219,7 +245,7 @@ func (p *Parser) parseLine() (*Instruction, error) { _, lit = p.scanIgnoreWhitespace() c.Literal += lit c.To = lit - c.Type = 1 + c.Type = common.TxTypeTransfer _, lit = p.scanIgnoreWhitespace() // expect ( c.Literal += lit if lit != "(" { @@ -228,7 +254,7 @@ func (p *Parser) parseLine() (*Instruction, error) { return c, fmt.Errorf("Expected '(', found '%s'", lit) } } else { - c.Type = 0 + c.Type = common.TxTypeCreateAccountDeposit } _, lit = p.scanIgnoreWhitespace() @@ -248,8 +274,13 @@ func (p *Parser) parseLine() (*Instruction, error) { return c, fmt.Errorf("Expected ')', found '%s'", lit) } - _, lit = p.scanIgnoreWhitespace() // expect : + _, 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 @@ -265,6 +296,23 @@ func (p *Parser) parseLine() (*Instruction, error) { } 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 } @@ -282,12 +330,16 @@ func (p *Parser) Parse() (Instructions, error) { 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 == 1 { // type: Transfer + if instruction.Type == common.TxTypeTransfer { // type: Transfer accounts[instruction.To] = true } tokenids[instruction.TokenID] = true diff --git a/test/lang_test.go b/test/lang_test.go index 56528ca..deb4522 100644 --- a/test/lang_test.go +++ b/test/lang_test.go @@ -12,22 +12,29 @@ var debug = false func TestParse(t *testing.T) { s := ` + // deposits A (1): 10 A (2): 20 B (1): 5 - A-B (1): 6 - B-C (1): 3 - C-A (1): 3 - A-B (2): 15 + + // 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 - User1-User0 (3): 15 + 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, 11, len(instructions.Instructions)) + assert.Equal(t, 12, len(instructions.Instructions)) assert.Equal(t, 5, len(instructions.Accounts)) assert.Equal(t, 3, len(instructions.TokenIDs)) @@ -39,9 +46,11 @@ func TestParse(t *testing.T) { } assert.Equal(t, "User0 (1): 20", instructions.Instructions[7].Raw()) - assert.Equal(t, "Type: Deposit, From: User0, Amount: 20, TokenID: 1,\n", instructions.Instructions[7].String()) - assert.Equal(t, "User0-User1 (1): 15", instructions.Instructions[9].Raw()) - assert.Equal(t, "Type: Transfer, From: User0, To: User1, Amount: 15, TokenID: 1,\n", instructions.Instructions[9].String()) + 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) { @@ -59,4 +68,13 @@ func TestParseErrors(t *testing.T) { 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()) } diff --git a/test/txs.go b/test/txs.go new file mode 100644 index 0000000..17d151c --- /dev/null +++ b/test/txs.go @@ -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 +} diff --git a/test/txs_test.go b/test/txs_test.go new file mode 100644 index 0000000..9a3d2b0 --- /dev/null +++ b/test/txs_test.go @@ -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) +} diff --git a/txselector/txselector_test.go b/txselector/txselector_test.go index 03ac53f..dffdaf3 100644 --- a/txselector/txselector_test.go +++ b/txselector/txselector_test.go @@ -12,95 +12,6 @@ import ( "github.com/stretchr/testify/require" ) -/* -func initTestDB(l2 *l2db.L2DB, sdb *statedb.StateDB) *mock.MockDB { - txs := []common.Tx{ - { - FromIdx: common.Idx(0), - ToIdx: common.Idx(1), - TokenID: 1, - Nonce: 1, - AbsoluteFee: 1, - }, - { - FromIdx: common.Idx(0), - ToIdx: common.Idx(1), - TokenID: 1, - Nonce: 2, - AbsoluteFee: 3, - }, - { - FromIdx: common.Idx(0), - ToIdx: common.Idx(1), - TokenID: 1, - Nonce: 4, - AbsoluteFee: 6, - }, - { - FromIdx: common.Idx(0), - ToIdx: common.Idx(1), - TokenID: 1, - Nonce: 4, - AbsoluteFee: 4, - }, - { - ToIdx: common.Idx(1), - FromIdx: common.Idx(0), - TokenID: 1, - Nonce: 1, - AbsoluteFee: 4, - }, - { - ToIdx: common.Idx(1), - FromIdx: common.Idx(0), - TokenID: 1, - Nonce: 2, - AbsoluteFee: 3, - }, - { - ToIdx: common.Idx(1), - FromIdx: common.Idx(0), - TokenID: 1, - Nonce: 3, - AbsoluteFee: 5, - }, - { - // this tx will not be selected, as the ToEthAddr does not have an account - FromIdx: common.Idx(1), - ToIdx: common.Idx(2), - TokenID: 1, - Nonce: 4, - AbsoluteFee: 5, - }, - } - - // n := 0 - nBatch := 0 - for i := 0; i < len(txs); i++ { - // for i := 0; i < nBatch; i++ { - // for j := 0; j < len(txs)/nBatch; j++ { - // store tx - l2db.AddTx(uint64(nBatch), txs[i]) - - // store account if not yet - accountID := getAccountID(txs[i].FromEthAddr, txs[i].TokenID) - if _, ok := m.AccountDB[accountID]; !ok { - account := common.Account{ - // EthAddr: txs[i].FromEthAddr, - TokenID: txs[i].TokenID, - Nonce: 0, - Balance: big.NewInt(0), - } - m.AccountDB[accountID] = account - } - // n++ - // } - } - - return m -} -*/ - func TestGetL2TxSelection(t *testing.T) { dir, err := ioutil.TempDir("", "tmpdb") require.Nil(t, err) From cfa441e1ac4c80074afae1b293537f5f6b9228de Mon Sep 17 00:00:00 2001 From: arnaucube Date: Thu, 20 Aug 2020 11:52:30 +0200 Subject: [PATCH 3/3] Migrate TxProcessors from BatchBuilder to StateDB Migrate TxProcessors from BatchBuilder to StateDB in order to be used by BatchBuilder & Synchronizer --- batchbuilder/batchbuilder.go | 203 ++--------------------------------- db/statedb/statedb.go | 15 ++- db/statedb/txprocessors.go | 195 +++++++++++++++++++++++++++++++++ 3 files changed, 216 insertions(+), 197 deletions(-) create mode 100644 db/statedb/txprocessors.go diff --git a/batchbuilder/batchbuilder.go b/batchbuilder/batchbuilder.go index 6d8a130..c2f0539 100644 --- a/batchbuilder/batchbuilder.go +++ b/batchbuilder/batchbuilder.go @@ -1,18 +1,11 @@ package batchbuilder import ( - "encoding/binary" - "math/big" - ethCommon "github.com/ethereum/go-ethereum/common" "github.com/hermeznetwork/hermez-node/common" "github.com/hermeznetwork/hermez-node/db/statedb" - "github.com/iden3/go-merkletree/db" ) -// KEYIDX is used as key in the db to store the current Idx -var KEYIDX = []byte("idx") - // ConfigCircuit contains the circuit configuration type ConfigCircuit struct { TxsMax uint64 @@ -23,8 +16,6 @@ type ConfigCircuit struct { // BatchBuilder implements the batch builder type, which contains the // functionalities type BatchBuilder struct { - // idx holds the current Idx that the BatchBuilder is using - idx uint64 localStateDB *statedb.LocalStateDB configCircuits []ConfigCircuit } @@ -56,209 +47,29 @@ func NewBatchBuilder(dbpath string, synchronizerStateDB *statedb.StateDB, config // copy of the rollup state from the Synchronizer at that `batchNum`, otherwise // it can just roll back the internal copy. func (bb *BatchBuilder) Reset(batchNum uint64, fromSynchronizer bool) error { - if batchNum == 0 { - bb.idx = 0 - return nil - } - err := bb.localStateDB.Reset(batchNum, fromSynchronizer) - if err != nil { - return err - } - // idx is obtained from the statedb reset - bb.idx, err = bb.getIdx() - return err + return bb.localStateDB.Reset(batchNum, fromSynchronizer) } // BuildBatch takes the transactions and returns the common.ZKInputs of the next batch -func (bb *BatchBuilder) BuildBatch(configBatch ConfigBatch, l1usertxs, l1coordinatortxs []*common.L1Tx, l2txs []*common.PoolL2Tx, tokenIDs []common.TokenID) (*common.ZKInputs, error) { +func (bb *BatchBuilder) BuildBatch(configBatch *ConfigBatch, l1usertxs, l1coordinatortxs []*common.L1Tx, l2txs []*common.PoolL2Tx, tokenIDs []common.TokenID) (*common.ZKInputs, error) { for _, tx := range l1usertxs { - err := bb.processL1Tx(tx) + err := bb.localStateDB.ProcessL1Tx(tx) if err != nil { return nil, err } } for _, tx := range l1coordinatortxs { - err := bb.processL1Tx(tx) + err := bb.localStateDB.ProcessL1Tx(tx) if err != nil { return nil, err } } for _, tx := range l2txs { - switch tx.Type { - case common.TxTypeTransfer: - // go to the MT account of sender and receiver, and update - // balance & nonce - err := bb.applyTransfer(tx.Tx()) - if err != nil { - return nil, err - } - case common.TxTypeExit: - // execute exit flow - default: - } - } - - return nil, nil -} - -func (bb *BatchBuilder) 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 := bb.applyTransfer(tx.Tx()) - if err != nil { - return err - } - case common.TxTypeCreateAccountDeposit: - // add new account to the MT, update balance of the MT account - err := bb.applyCreateAccount(tx) - if err != nil { - return err - } - case common.TxTypeDeposit: // TODO check if this type will ever exist, or will be TxTypeDepositAndTransfer with transfer 0 value - // update balance of the MT account - err := bb.applyDeposit(tx, false) - if err != nil { - return err - } - case common.TxTypeDepositAndTransfer: - // update balance in MT account, update balance & nonce of sender - // & receiver - err := bb.applyDeposit(tx, true) + err := bb.localStateDB.ProcessPoolL2Tx(tx) if err != nil { - return err - } - case common.TxTypeCreateAccountDepositAndTransfer: - // add new account to the merkletree, update balance in MT account, - // update balance & nonce of sender & receiver - err := bb.applyCreateAccount(tx) - if err != nil { - return err - } - err = bb.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 (bb *BatchBuilder) applyCreateAccount(tx *common.L1Tx) error { - account := &common.Account{ - TokenID: tx.TokenID, - Nonce: 0, - Balance: tx.LoadAmount, - PublicKey: tx.FromBJJ, - EthAddr: tx.FromEthAddr, - } - - err := bb.localStateDB.CreateAccount(common.Idx(bb.idx+1), account) - if err != nil { - return err - } - - bb.idx = bb.idx + 1 - return bb.setIdx(bb.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/DepositAndTransfer -func (bb *BatchBuilder) applyDeposit(tx *common.L1Tx, transfer bool) error { - // deposit the tx.LoadAmount into the sender account - accSender, err := bb.localStateDB.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>DepositAndTransfer - if transfer { - accReceiver, err := bb.localStateDB.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 = bb.localStateDB.UpdateAccount(tx.ToIdx, accReceiver) - if err != nil { - return err + return nil, err } } - // update sender account in localStateDB - err = bb.localStateDB.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 (bb *BatchBuilder) applyTransfer(tx *common.Tx) error { - // get sender and receiver accounts from localStateDB - accSender, err := bb.localStateDB.GetAccount(tx.FromIdx) - if err != nil { - return err - } - accReceiver, err := bb.localStateDB.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 = bb.localStateDB.UpdateAccount(tx.ToIdx, accReceiver) - if err != nil { - return err - } - // update sender account in localStateDB - err = bb.localStateDB.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 (bb *BatchBuilder) getIdx() (uint64, error) { - idxBytes, err := bb.localStateDB.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 (bb *BatchBuilder) setIdx(idx uint64) error { - tx, err := bb.localStateDB.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 + return nil, nil } diff --git a/db/statedb/statedb.go b/db/statedb/statedb.go index 1df7154..3113982 100644 --- a/db/statedb/statedb.go +++ b/db/statedb/statedb.go @@ -34,6 +34,8 @@ type StateDB struct { currentBatch uint64 db *pebble.PebbleStorage mt *merkletree.MerkleTree + // idx holds the current Idx that the BatchBuilder is using + idx uint64 } // NewStateDB creates a new StateDB, allowing to use an in-memory or in-disk @@ -147,6 +149,11 @@ func (s *StateDB) DeleteCheckpoint(batchNum uint64) error { // those checkpoints will remain in the storage, and eventually will be // deleted when MakeCheckpoint overwrites them. func (s *StateDB) Reset(batchNum uint64) error { + if batchNum == 0 { + s.idx = 0 + return nil + } + checkpointPath := s.path + PATHBATCHNUM + strconv.Itoa(int(batchNum)) currentPath := s.path + PATHCURRENT @@ -174,7 +181,9 @@ func (s *StateDB) Reset(batchNum uint64) error { if err != nil { return err } - return nil + // idx is obtained from the statedb reset + s.idx, err = s.getIdx() + return err } // GetAccount returns the account for the given Idx @@ -315,6 +324,10 @@ func NewLocalStateDB(path string, synchronizerDB *StateDB, withMT bool, nLevels // Reset performs a reset in the LocaStateDB. If fromSynchronizer is true, it // gets the state from LocalStateDB.synchronizerStateDB for the given batchNum. If fromSynchronizer is false, get the state from LocalStateDB checkpoints. func (l *LocalStateDB) Reset(batchNum uint64, fromSynchronizer bool) error { + if batchNum == 0 { + l.idx = 0 + return nil + } synchronizerCheckpointPath := l.synchronizerStateDB.path + PATHBATCHNUM + strconv.Itoa(int(batchNum)) checkpointPath := l.path + PATHBATCHNUM + strconv.Itoa(int(batchNum)) diff --git a/db/statedb/txprocessors.go b/db/statedb/txprocessors.go new file mode 100644 index 0000000..a0148ad --- /dev/null +++ b/db/statedb/txprocessors.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 +}