mirror of
https://github.com/arnaucube/hermez-node.git
synced 2026-02-06 19:06:42 +01:00
Add apitypes to avoid parsing from/to DB
This commit is contained in:
Arnau B
207
apitypes/apitypes.go
Normal file
207
apitypes/apitypes.go
Normal file
@@ -0,0 +1,207 @@
|
||||
package apitypes
|
||||
|
||||
import (
|
||||
"database/sql/driver"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"math/big"
|
||||
"strings"
|
||||
|
||||
ethCommon "github.com/ethereum/go-ethereum/common"
|
||||
"github.com/hermeznetwork/hermez-node/common"
|
||||
"github.com/iden3/go-iden3-crypto/babyjub"
|
||||
)
|
||||
|
||||
// BigIntStr is used to scan/value *big.Int directly into strings from/to sql DBs.
|
||||
// It assumes that *big.Int are inserted/fetched to/from the DB using the BigIntMeddler meddler
|
||||
// defined at github.com/hermeznetwork/hermez-node/db
|
||||
type BigIntStr string
|
||||
|
||||
// NewBigIntStr creates a *BigIntStr from a *big.Int.
|
||||
// If the provided bigInt is nil the returned *BigIntStr will also be nil
|
||||
func NewBigIntStr(bigInt *big.Int) *BigIntStr {
|
||||
if bigInt == nil {
|
||||
return nil
|
||||
}
|
||||
bigIntStr := BigIntStr(bigInt.String())
|
||||
return &bigIntStr
|
||||
}
|
||||
|
||||
// Scan implements Scanner for database/sql
|
||||
func (b *BigIntStr) Scan(src interface{}) error {
|
||||
// decode base64 src
|
||||
var decoded []byte
|
||||
var err error
|
||||
if srcStr, ok := src.(string); ok {
|
||||
// src is a string
|
||||
decoded, err = base64.StdEncoding.DecodeString(srcStr)
|
||||
} else if srcBytes, ok := src.([]byte); ok {
|
||||
// src is []byte
|
||||
decoded, err = base64.StdEncoding.DecodeString(string(srcBytes))
|
||||
} else {
|
||||
// unexpected src
|
||||
return fmt.Errorf("can't scan %T into apitypes.BigIntStr", src)
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// decoded bytes to *big.Int
|
||||
bigInt := &big.Int{}
|
||||
bigInt = bigInt.SetBytes(decoded)
|
||||
// *big.Int to BigIntStr
|
||||
bigIntStr := NewBigIntStr(bigInt)
|
||||
if bigIntStr == nil {
|
||||
return nil
|
||||
}
|
||||
*b = *bigIntStr
|
||||
return nil
|
||||
}
|
||||
|
||||
// Value implements valuer for database/sql
|
||||
func (b BigIntStr) Value() (driver.Value, error) {
|
||||
// string to *big.Int
|
||||
bigInt := &big.Int{}
|
||||
bigInt, ok := bigInt.SetString(string(b), 10)
|
||||
if !ok || bigInt == nil {
|
||||
return nil, errors.New("invalid representation of a *big.Int")
|
||||
}
|
||||
// *big.Int to base64
|
||||
return base64.StdEncoding.EncodeToString(bigInt.Bytes()), nil
|
||||
}
|
||||
|
||||
type CollectedFees map[common.TokenID]BigIntStr
|
||||
|
||||
func (c *CollectedFees) UnmarshalJSON(text []byte) error {
|
||||
fmt.Println(string(text))
|
||||
bigIntMap := make(map[common.TokenID]*big.Int)
|
||||
if err := json.Unmarshal(text, &bigIntMap); err != nil {
|
||||
return err
|
||||
}
|
||||
bStrMap := make(map[common.TokenID]BigIntStr)
|
||||
for k, v := range bigIntMap {
|
||||
bStr := NewBigIntStr(v)
|
||||
bStrMap[k] = *bStr
|
||||
}
|
||||
*c = CollectedFees(bStrMap)
|
||||
return nil
|
||||
// fmt.Println(string(text))
|
||||
// *b = BigIntStr(string(text))
|
||||
// return nil
|
||||
// bigInt := &big.Int{}
|
||||
// if err := bigInt.UnmarshalText(text); err != nil {
|
||||
// return err
|
||||
// }
|
||||
// bigIntStr := NewBigIntStr(bigInt)
|
||||
// if bigIntStr == nil {
|
||||
// return nil
|
||||
// }
|
||||
// *b = *bigIntStr
|
||||
// return nil
|
||||
}
|
||||
|
||||
// HezEthAddr is used to scan/value Ethereum Address directly into strings that follow the Ethereum address hez fotmat (^hez:0x[a-fA-F0-9]{40}$) from/to sql DBs.
|
||||
// It assumes that Ethereum Address are inserted/fetched to/from the DB using the default Scan/Value interface
|
||||
type HezEthAddr string
|
||||
|
||||
// NewHezEthAddr creates a HezEthAddr from an Ethereum addr
|
||||
func NewHezEthAddr(addr ethCommon.Address) HezEthAddr {
|
||||
return HezEthAddr("hez:" + addr.String())
|
||||
}
|
||||
|
||||
// ToEthAddr returns an Ethereum Address created from HezEthAddr
|
||||
func (a HezEthAddr) ToEthAddr() (ethCommon.Address, error) {
|
||||
addrStr := strings.TrimPrefix(string(a), "hez:")
|
||||
var addr ethCommon.Address
|
||||
return addr, addr.UnmarshalText([]byte(addrStr))
|
||||
}
|
||||
|
||||
// Scan implements Scanner for database/sql
|
||||
func (a *HezEthAddr) Scan(src interface{}) error {
|
||||
ethAddr := ðCommon.Address{}
|
||||
if err := ethAddr.Scan(src); err != nil {
|
||||
return err
|
||||
}
|
||||
if ethAddr == nil {
|
||||
return nil
|
||||
}
|
||||
*a = NewHezEthAddr(*ethAddr)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Value implements valuer for database/sql
|
||||
func (a HezEthAddr) Value() (driver.Value, error) {
|
||||
ethAddr, err := a.ToEthAddr()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return ethAddr.Value()
|
||||
}
|
||||
|
||||
// HezBJJ is used to scan/value *babyjub.PublicKey directly into strings that follow the BJJ public key hez fotmat (^hez:[A-Za-z0-9_-]{44}$) from/to sql DBs.
|
||||
// It assumes that *babyjub.PublicKey are inserted/fetched to/from the DB using the default Scan/Value interface
|
||||
type HezBJJ string
|
||||
|
||||
// NewHezBJJ creates a HezBJJ from a *babyjub.PublicKey.
|
||||
// Calling this method with a nil bjj causes panic
|
||||
func NewHezBJJ(bjj *babyjub.PublicKey) HezBJJ {
|
||||
pkComp := [32]byte(bjj.Compress())
|
||||
sum := pkComp[0]
|
||||
for i := 1; i < len(pkComp); i++ {
|
||||
sum += pkComp[i]
|
||||
}
|
||||
bjjSum := append(pkComp[:], sum)
|
||||
return HezBJJ("hez:" + base64.RawURLEncoding.EncodeToString(bjjSum))
|
||||
}
|
||||
|
||||
// ToBJJ returns a *babyjub.PublicKey created from HezBJJ
|
||||
func (b HezBJJ) ToBJJ() (*babyjub.PublicKey, error) {
|
||||
const decodedLen = 33
|
||||
const encodedLen = 44
|
||||
formatErr := errors.New("invalid BJJ format. Must follow this regex: ^hez:[A-Za-z0-9_-]{44}$")
|
||||
encoded := strings.TrimPrefix(string(b), "hez:")
|
||||
if len(encoded) != encodedLen {
|
||||
return nil, formatErr
|
||||
}
|
||||
decoded, err := base64.RawURLEncoding.DecodeString(encoded)
|
||||
if err != nil {
|
||||
return nil, formatErr
|
||||
}
|
||||
if len(decoded) != decodedLen {
|
||||
return nil, formatErr
|
||||
}
|
||||
bjjBytes := [decodedLen - 1]byte{}
|
||||
copy(bjjBytes[:decodedLen-1], decoded[:decodedLen-1])
|
||||
sum := bjjBytes[0]
|
||||
for i := 1; i < len(bjjBytes); i++ {
|
||||
sum += bjjBytes[i]
|
||||
}
|
||||
if decoded[decodedLen-1] != sum {
|
||||
return nil, errors.New("checksum verification failed")
|
||||
}
|
||||
bjjComp := babyjub.PublicKeyComp(bjjBytes)
|
||||
return bjjComp.Decompress()
|
||||
}
|
||||
|
||||
// Scan implements Scanner for database/sql
|
||||
func (b *HezBJJ) Scan(src interface{}) error {
|
||||
bjj := &babyjub.PublicKey{}
|
||||
if err := bjj.Scan(src); err != nil {
|
||||
return err
|
||||
}
|
||||
if bjj == nil {
|
||||
return nil
|
||||
}
|
||||
*b = NewHezBJJ(bjj)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Value implements valuer for database/sql
|
||||
func (b HezBJJ) Value() (driver.Value, error) {
|
||||
bjj, err := b.ToBJJ()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return bjj.Value()
|
||||
}
|
||||
286
apitypes/apitypes_test.go
Normal file
286
apitypes/apitypes_test.go
Normal file
@@ -0,0 +1,286 @@
|
||||
package apitypes
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"io/ioutil"
|
||||
"math/big"
|
||||
"os"
|
||||
"testing"
|
||||
|
||||
"github.com/iden3/go-iden3-crypto/babyjub"
|
||||
|
||||
ethCommon "github.com/ethereum/go-ethereum/common"
|
||||
dbUtils "github.com/hermeznetwork/hermez-node/db"
|
||||
_ "github.com/mattn/go-sqlite3" // sqlite driver
|
||||
"github.com/russross/meddler"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
var db *sql.DB
|
||||
|
||||
func TestMain(m *testing.M) {
|
||||
// Register meddler
|
||||
meddler.Default = meddler.SQLite
|
||||
meddler.Register("bigint", dbUtils.BigIntMeddler{})
|
||||
meddler.Register("bigintnull", dbUtils.BigIntNullMeddler{})
|
||||
// Create temporary sqlite DB
|
||||
dir, err := ioutil.TempDir("", "db")
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
db, err = sql.Open("sqlite3", dir+"sqlite.db")
|
||||
defer os.RemoveAll(dir)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
schema := `CREATE TABLE test (i BLOB);`
|
||||
if _, err := db.Exec(schema); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
// Run tests
|
||||
result := m.Run()
|
||||
os.Exit(result)
|
||||
}
|
||||
|
||||
func TestBigIntStrScannerValuer(t *testing.T) {
|
||||
// Clean DB
|
||||
_, err := db.Exec("delete from test")
|
||||
assert.NoError(t, err)
|
||||
// Example structs
|
||||
type bigInMeddlerStruct struct {
|
||||
I *big.Int `meddler:"i,bigint"` // note the bigint that instructs meddler to use BigIntMeddler
|
||||
}
|
||||
type bigIntStrStruct struct {
|
||||
I BigIntStr `meddler:"i"` // note that no meddler is specified, and Scan/Value will be used
|
||||
}
|
||||
type bigInMeddlerStructNil struct {
|
||||
I *big.Int `meddler:"i,bigintnull"` // note the bigint that instructs meddler to use BigIntNullMeddler
|
||||
}
|
||||
type bigIntStrStructNil struct {
|
||||
I *BigIntStr `meddler:"i"` // note that no meddler is specified, and Scan/Value will be used
|
||||
}
|
||||
|
||||
// Not nil case
|
||||
// Insert into DB using meddler
|
||||
const x = int64(12345)
|
||||
fromMeddler := bigInMeddlerStruct{
|
||||
I: big.NewInt(x),
|
||||
}
|
||||
err = meddler.Insert(db, "test", &fromMeddler)
|
||||
assert.NoError(t, err)
|
||||
// Read from DB using BigIntStr
|
||||
toBigIntStr := bigIntStrStruct{}
|
||||
err = meddler.QueryRow(db, &toBigIntStr, "select * from test")
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, fromMeddler.I.String(), string(toBigIntStr.I))
|
||||
// Clean DB
|
||||
_, err = db.Exec("delete from test")
|
||||
assert.NoError(t, err)
|
||||
// Insert into DB using BigIntStr
|
||||
fromBigIntStr := bigIntStrStruct{
|
||||
I: "54321",
|
||||
}
|
||||
err = meddler.Insert(db, "test", &fromBigIntStr)
|
||||
assert.NoError(t, err)
|
||||
// Read from DB using meddler
|
||||
toMeddler := bigInMeddlerStruct{}
|
||||
err = meddler.QueryRow(db, &toMeddler, "select * from test")
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, string(fromBigIntStr.I), toMeddler.I.String())
|
||||
|
||||
// Nil case
|
||||
// Clean DB
|
||||
_, err = db.Exec("delete from test")
|
||||
assert.NoError(t, err)
|
||||
// Insert into DB using meddler
|
||||
fromMeddlerNil := bigInMeddlerStructNil{
|
||||
I: nil,
|
||||
}
|
||||
err = meddler.Insert(db, "test", &fromMeddlerNil)
|
||||
assert.NoError(t, err)
|
||||
// Read from DB using BigIntStr
|
||||
foo := BigIntStr("foo")
|
||||
toBigIntStrNil := bigIntStrStructNil{
|
||||
I: &foo, // check that this will be set to nil, not because of not being initialized
|
||||
}
|
||||
err = meddler.QueryRow(db, &toBigIntStrNil, "select * from test")
|
||||
assert.NoError(t, err)
|
||||
assert.Nil(t, toBigIntStrNil.I)
|
||||
// Clean DB
|
||||
_, err = db.Exec("delete from test")
|
||||
assert.NoError(t, err)
|
||||
// Insert into DB using BigIntStr
|
||||
fromBigIntStrNil := bigIntStrStructNil{
|
||||
I: nil,
|
||||
}
|
||||
err = meddler.Insert(db, "test", &fromBigIntStrNil)
|
||||
assert.NoError(t, err)
|
||||
// Read from DB using meddler
|
||||
toMeddlerNil := bigInMeddlerStructNil{
|
||||
I: big.NewInt(x), // check that this will be set to nil, not because of not being initialized
|
||||
}
|
||||
err = meddler.QueryRow(db, &toMeddlerNil, "select * from test")
|
||||
assert.NoError(t, err)
|
||||
assert.Nil(t, toMeddlerNil.I)
|
||||
}
|
||||
|
||||
func TestHezEthAddr(t *testing.T) {
|
||||
// Clean DB
|
||||
_, err := db.Exec("delete from test")
|
||||
assert.NoError(t, err)
|
||||
// Example structs
|
||||
type ethAddrStruct struct {
|
||||
I ethCommon.Address `meddler:"i"`
|
||||
}
|
||||
type hezEthAddrStruct struct {
|
||||
I HezEthAddr `meddler:"i"`
|
||||
}
|
||||
type ethAddrStructNil struct {
|
||||
I *ethCommon.Address `meddler:"i"`
|
||||
}
|
||||
type hezEthAddrStructNil struct {
|
||||
I *HezEthAddr `meddler:"i"`
|
||||
}
|
||||
|
||||
// Not nil case
|
||||
// Insert into DB using ethCommon.Address Scan/Value
|
||||
fromEth := ethAddrStruct{
|
||||
I: ethCommon.BigToAddress(big.NewInt(73737373)),
|
||||
}
|
||||
err = meddler.Insert(db, "test", &fromEth)
|
||||
assert.NoError(t, err)
|
||||
// Read from DB using HezEthAddr Scan/Value
|
||||
toHezEth := hezEthAddrStruct{}
|
||||
err = meddler.QueryRow(db, &toHezEth, "select * from test")
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, NewHezEthAddr(fromEth.I), toHezEth.I)
|
||||
// Clean DB
|
||||
_, err = db.Exec("delete from test")
|
||||
assert.NoError(t, err)
|
||||
// Insert into DB using HezEthAddr Scan/Value
|
||||
fromHezEth := hezEthAddrStruct{
|
||||
I: NewHezEthAddr(ethCommon.BigToAddress(big.NewInt(3786872586))),
|
||||
}
|
||||
err = meddler.Insert(db, "test", &fromHezEth)
|
||||
assert.NoError(t, err)
|
||||
// Read from DB using ethCommon.Address Scan/Value
|
||||
toEth := ethAddrStruct{}
|
||||
err = meddler.QueryRow(db, &toEth, "select * from test")
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, fromHezEth.I, NewHezEthAddr(toEth.I))
|
||||
|
||||
// Nil case
|
||||
// Clean DB
|
||||
_, err = db.Exec("delete from test")
|
||||
assert.NoError(t, err)
|
||||
// Insert into DB using ethCommon.Address Scan/Value
|
||||
fromEthNil := ethAddrStructNil{
|
||||
I: nil,
|
||||
}
|
||||
err = meddler.Insert(db, "test", &fromEthNil)
|
||||
assert.NoError(t, err)
|
||||
// Read from DB using HezEthAddr Scan/Value
|
||||
foo := HezEthAddr("foo")
|
||||
toHezEthNil := hezEthAddrStructNil{
|
||||
I: &foo, // check that this will be set to nil, not because of not being initialized
|
||||
}
|
||||
err = meddler.QueryRow(db, &toHezEthNil, "select * from test")
|
||||
assert.NoError(t, err)
|
||||
assert.Nil(t, toHezEthNil.I)
|
||||
// Clean DB
|
||||
_, err = db.Exec("delete from test")
|
||||
assert.NoError(t, err)
|
||||
// Insert into DB using HezEthAddr Scan/Value
|
||||
fromHezEthNil := hezEthAddrStructNil{
|
||||
I: nil,
|
||||
}
|
||||
err = meddler.Insert(db, "test", &fromHezEthNil)
|
||||
assert.NoError(t, err)
|
||||
// Read from DB using ethCommon.Address Scan/Value
|
||||
fooAddr := ethCommon.BigToAddress(big.NewInt(1))
|
||||
toEthNil := ethAddrStructNil{
|
||||
I: &fooAddr, // check that this will be set to nil, not because of not being initialized
|
||||
}
|
||||
err = meddler.QueryRow(db, &toEthNil, "select * from test")
|
||||
assert.NoError(t, err)
|
||||
assert.Nil(t, toEthNil.I)
|
||||
}
|
||||
|
||||
func TestHezBJJ(t *testing.T) {
|
||||
// Clean DB
|
||||
_, err := db.Exec("delete from test")
|
||||
assert.NoError(t, err)
|
||||
// Example structs
|
||||
type bjjStruct struct {
|
||||
I *babyjub.PublicKey `meddler:"i"`
|
||||
}
|
||||
type hezBJJStruct struct {
|
||||
I HezBJJ `meddler:"i"`
|
||||
}
|
||||
type hezBJJStructNil struct {
|
||||
I *HezBJJ `meddler:"i"`
|
||||
}
|
||||
|
||||
// Not nil case
|
||||
// Insert into DB using *babyjub.PublicKey Scan/Value
|
||||
priv := babyjub.NewRandPrivKey()
|
||||
fromBJJ := bjjStruct{
|
||||
I: priv.Public(),
|
||||
}
|
||||
err = meddler.Insert(db, "test", &fromBJJ)
|
||||
assert.NoError(t, err)
|
||||
// Read from DB using HezBJJ Scan/Value
|
||||
toHezBJJ := hezBJJStruct{}
|
||||
err = meddler.QueryRow(db, &toHezBJJ, "select * from test")
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, NewHezBJJ(fromBJJ.I), toHezBJJ.I)
|
||||
// Clean DB
|
||||
_, err = db.Exec("delete from test")
|
||||
assert.NoError(t, err)
|
||||
// Insert into DB using HezBJJ Scan/Value
|
||||
fromHezBJJ := hezBJJStruct{
|
||||
I: NewHezBJJ(priv.Public()),
|
||||
}
|
||||
err = meddler.Insert(db, "test", &fromHezBJJ)
|
||||
assert.NoError(t, err)
|
||||
// Read from DB using *babyjub.PublicKey Scan/Value
|
||||
toBJJ := bjjStruct{}
|
||||
err = meddler.QueryRow(db, &toBJJ, "select * from test")
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, fromHezBJJ.I, NewHezBJJ(toBJJ.I))
|
||||
|
||||
// Nil case
|
||||
// Clean DB
|
||||
_, err = db.Exec("delete from test")
|
||||
assert.NoError(t, err)
|
||||
// Insert into DB using *babyjub.PublicKey Scan/Value
|
||||
fromBJJNil := bjjStruct{
|
||||
I: nil,
|
||||
}
|
||||
err = meddler.Insert(db, "test", &fromBJJNil)
|
||||
assert.NoError(t, err)
|
||||
// Read from DB using HezBJJ Scan/Value
|
||||
foo := HezBJJ("foo")
|
||||
toHezBJJNil := hezBJJStructNil{
|
||||
I: &foo, // check that this will be set to nil, not because of not being initialized
|
||||
}
|
||||
err = meddler.QueryRow(db, &toHezBJJNil, "select * from test")
|
||||
assert.NoError(t, err)
|
||||
assert.Nil(t, toHezBJJNil.I)
|
||||
// Clean DB
|
||||
_, err = db.Exec("delete from test")
|
||||
assert.NoError(t, err)
|
||||
// Insert into DB using HezBJJ Scan/Value
|
||||
fromHezBJJNil := hezBJJStructNil{
|
||||
I: nil,
|
||||
}
|
||||
err = meddler.Insert(db, "test", &fromHezBJJNil)
|
||||
assert.NoError(t, err)
|
||||
// Read from DB using *babyjub.PublicKey Scan/Value
|
||||
toBJJNil := bjjStruct{
|
||||
I: priv.Public(), // check that this will be set to nil, not because of not being initialized
|
||||
}
|
||||
err = meddler.QueryRow(db, &toBJJNil, "select * from test")
|
||||
assert.NoError(t, err)
|
||||
assert.Nil(t, toBJJNil.I)
|
||||
}
|
||||
Reference in New Issue
Block a user