arnaucube/hermez-node
1
0
Fork 0
mirror of https://github.com/arnaucube/hermez-node.git synced 2026-02-07 11:26:44 +01:00
Code Issues Packages Projects Releases Wiki Activity

mv of babyjub.PublicKey to babyjub.PublicKeyComp

Browse Source 
Update usage of `*babyjub.PublicKey` to `babyjub.PublicKeyComp`
- when the key is not defined, internally is used `babyjub.EmptyBJJComp`, which is a `[32]byte` of zeroes of type `babyjub.PublicKeyComp`
- the API continues returning `nil` when the key is not defined
This commit is contained in:
arnaucube
2020-12-18 17:19:07 +01:00
parent b9943182b8
commit 4b10549822
47 changed files with 761 additions and 733 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
common/account_test.go
View File

@@ -22,11 +22,11 @@ import (
func TestIdxParser(t *testing.T) {
i := Idx(1)
iBytes, err := i.Bytes()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, 6, len(iBytes))
assert.Equal(t, "000000000001", hex.EncodeToString(iBytes[:]))
i2, err := IdxFromBytes(iBytes[:])
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, i, i2)
i = Idx(100)
@@ -35,11 +35,11 @@ func TestIdxParser(t *testing.T) {
// value before overflow
i = Idx(281474976710655)
iBytes, err = i.Bytes()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, 6, len(iBytes))
assert.Equal(t, "ffffffffffff", hex.EncodeToString(iBytes[:]))
i2, err = IdxFromBytes(iBytes[:])
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, i, i2)
// expect value overflow
@@ -52,7 +52,7 @@ func TestIdxParser(t *testing.T) {
func TestNonceParser(t *testing.T) {
n := Nonce(1)
nBytes, err := n.Bytes()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, 5, len(nBytes))
assert.Equal(t, "0000000001", hex.EncodeToString(nBytes[:]))
n2 := NonceFromBytes(nBytes)
@@ -61,7 +61,7 @@ func TestNonceParser(t *testing.T) {
// value before overflow
n = Nonce(1099511627775)
nBytes, err = n.Bytes()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, 5, len(nBytes))
assert.Equal(t, "ffffffffff", hex.EncodeToString(nBytes[:]))
n2 = NonceFromBytes(nBytes)
@@ -77,25 +77,25 @@ func TestNonceParser(t *testing.T) {
func TestAccount(t *testing.T) {
var sk babyjub.PrivateKey
_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
assert.Nil(t, err)
assert.NoError(t, err)
pk := sk.Public()
account := &Account{
TokenID: TokenID(1),
Nonce: Nonce(1234),
Balance: big.NewInt(1000),
PublicKey: pk,
PublicKey: pk.Compress(),
EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
}
b, err := account.Bytes()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, byte(1), b[22])
a1, err := AccountFromBytes(b)
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, account, a1)
e, err := account.BigInts()
assert.Nil(t, err)
assert.NoError(t, err)
assert.True(t, cryptoUtils.CheckBigIntInField(e[0]))
assert.True(t, cryptoUtils.CheckBigIntInField(e[1]))
assert.True(t, cryptoUtils.CheckBigIntInField(e[2]))
@@ -106,7 +106,7 @@ func TestAccount(t *testing.T) {
assert.Equal(t, new(big.Int).SetBytes(account.EthAddr.Bytes()).String(), e[3].String())
a2, err := AccountFromBigInts(e)
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, account, a2)
assert.Equal(t, a1, a2)
}
@@ -116,35 +116,35 @@ func TestAccountLoop(t *testing.T) {
for i := 0; i < 256; i++ {
var sk babyjub.PrivateKey
_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
assert.Nil(t, err)
assert.NoError(t, err)
pk := sk.Public()
key, err := ethCrypto.GenerateKey()
assert.Nil(t, err)
assert.NoError(t, err)
address := ethCrypto.PubkeyToAddress(key.PublicKey)
account := &Account{
TokenID: TokenID(i),
Nonce: Nonce(i),
Balance: big.NewInt(1000),
PublicKey: pk,
PublicKey: pk.Compress(),
EthAddr: address,
}
b, err := account.Bytes()
assert.Nil(t, err)
assert.NoError(t, err)
a1, err := AccountFromBytes(b)
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, account, a1)
e, err := account.BigInts()
assert.Nil(t, err)
assert.NoError(t, err)
assert.True(t, cryptoUtils.CheckBigIntInField(e[0]))
assert.True(t, cryptoUtils.CheckBigIntInField(e[1]))
assert.True(t, cryptoUtils.CheckBigIntInField(e[2]))
assert.True(t, cryptoUtils.CheckBigIntInField(e[3]))
a2, err := AccountFromBigInts(e)
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, account, a2)
}
}
@@ -157,31 +157,31 @@ func TestAccountLoopRandom(t *testing.T) {
pk := sk.Public()
key, err := ethCrypto.GenerateKey()
assert.Nil(t, err)
assert.NoError(t, err)
address := ethCrypto.PubkeyToAddress(key.PublicKey)
account := &Account{
TokenID: TokenID(i),
Nonce: Nonce(i),
Balance: big.NewInt(1000),
PublicKey: pk,
PublicKey: pk.Compress(),
EthAddr: address,
}
b, err := account.Bytes()
assert.Nil(t, err)
assert.NoError(t, err)
a1, err := AccountFromBytes(b)
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, account, a1)
e, err := account.BigInts()
assert.Nil(t, err)
assert.NoError(t, err)
assert.True(t, cryptoUtils.CheckBigIntInField(e[0]))
assert.True(t, cryptoUtils.CheckBigIntInField(e[1]))
assert.True(t, cryptoUtils.CheckBigIntInField(e[2]))
assert.True(t, cryptoUtils.CheckBigIntInField(e[3]))
a2, err := AccountFromBigInts(e)
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, account, a2)
}
}
@@ -200,18 +200,18 @@ func bigFromStr(h string, u int) *big.Int {
func TestAccountHashValue(t *testing.T) {
var sk babyjub.PrivateKey
_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
assert.Nil(t, err)
assert.NoError(t, err)
pk := sk.Public()
account := &Account{
TokenID: TokenID(1),
Nonce: Nonce(1234),
Balance: big.NewInt(1000),
PublicKey: pk,
PublicKey: pk.Compress(),
EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
}
v, err := account.HashValue()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, "16297758255249203915951182296472515138555043617458222397753168518282206850764", v.String())
}
@@ -219,67 +219,70 @@ func TestAccountHashValueTestVectors(t *testing.T) {
// values from js test vectors
ay := new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(253), nil), big.NewInt(1))
assert.Equal(t, "1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", (hex.EncodeToString(ay.Bytes())))
bjj, err := babyjub.PointFromSignAndY(true, ay)
require.Nil(t, err)
bjjPoint, err := babyjub.PointFromSignAndY(true, ay)
require.NoError(t, err)
bjj := babyjub.PublicKey(*bjjPoint)
account := &Account{
Idx: 1,
TokenID: 0xFFFFFFFF,
PublicKey: (*babyjub.PublicKey)(bjj),
PublicKey: bjj.Compress(),
EthAddr: ethCommon.HexToAddress("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"),
Nonce: Nonce(0xFFFFFFFFFF),
Balance: bigFromStr("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 16),
}
e, err := account.BigInts()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, "9444732965739290427391", e[0].String())
assert.Equal(t, "6277101735386680763835789423207666416102355444464034512895", e[1].String())
assert.Equal(t, "14474011154664524427946373126085988481658748083205070504932198000989141204991", e[2].String())
assert.Equal(t, "1461501637330902918203684832716283019655932542975", e[3].String())
h, err := poseidon.Hash(e[:])
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, "4550823210217540218403400309533329186487982452461145263910122718498735057257", h.String())
v, err := account.HashValue()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, "4550823210217540218403400309533329186487982452461145263910122718498735057257", v.String())
// second account
ay = big.NewInt(0)
bjj, err = babyjub.PointFromSignAndY(false, ay)
require.Nil(t, err)
bjjPoint, err = babyjub.PointFromSignAndY(false, ay)
require.NoError(t, err)
bjj = babyjub.PublicKey(*bjjPoint)
account = &Account{
TokenID: 0,
PublicKey: (*babyjub.PublicKey)(bjj),
PublicKey: bjj.Compress(),
EthAddr: ethCommon.HexToAddress("0x00"),
Nonce: Nonce(0),
Balance: big.NewInt(0),
}
v, err = account.HashValue()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, "7750253361301235345986002241352365187241910378619330147114280396816709365657", v.String())
// third account
ay = bigFromStr("21b0a1688b37f77b1d1d5539ec3b826db5ac78b2513f574a04c50a7d4f8246d7", 16)
bjj, err = babyjub.PointFromSignAndY(false, ay)
require.Nil(t, err)
bjjPoint, err = babyjub.PointFromSignAndY(false, ay)
require.NoError(t, err)
bjj = babyjub.PublicKey(*bjjPoint)
account = &Account{
TokenID: 3,
PublicKey: (*babyjub.PublicKey)(bjj),
PublicKey: bjj.Compress(),
EthAddr: ethCommon.HexToAddress("0xA3C88ac39A76789437AED31B9608da72e1bbfBF9"),
Nonce: Nonce(129),
Balance: bigFromStr("42000000000000000000", 10),
}
e, err = account.BigInts()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, "554050781187", e[0].String())
assert.Equal(t, "42000000000000000000", e[1].String())
assert.Equal(t, "15238403086306505038849621710779816852318505119327426213168494964113886299863", e[2].String())
assert.Equal(t, "935037732739828347587684875151694054123613453305", e[3].String())
v, err = account.HashValue()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, "10565754214047872850889045989683221123564392137456000481397520902594455245517", v.String())
}
@@ -290,7 +293,7 @@ func TestAccountErrNotInFF(t *testing.T) {
r := new(big.Int).Sub(cryptoConstants.Q, big.NewInt(1))
e := [NLeafElems]*big.Int{z, z, r, r}
_, err := AccountFromBigInts(e)
assert.Nil(t, err)
assert.NoError(t, err)
// Q should give error
r = cryptoConstants.Q
@@ -310,7 +313,7 @@ func TestAccountErrNotInFF(t *testing.T) {
func TestAccountErrNumOverflowNonce(t *testing.T) {
var sk babyjub.PrivateKey
_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
assert.Nil(t, err)
assert.NoError(t, err)
pk := sk.Public()
// check limit
@@ -318,11 +321,11 @@ func TestAccountErrNumOverflowNonce(t *testing.T) {
TokenID: TokenID(1),
Nonce: Nonce(math.Pow(2, 40) - 1),
Balance: big.NewInt(1000),
PublicKey: pk,
PublicKey: pk.Compress(),
EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
}
_, err = account.Bytes()
assert.Nil(t, err)
assert.NoError(t, err)
// force value overflow
account.Nonce = Nonce(math.Pow(2, 40))
@@ -331,13 +334,13 @@ func TestAccountErrNumOverflowNonce(t *testing.T) {
assert.Equal(t, fmt.Errorf("%s Nonce", ErrNumOverflow), tracerr.Unwrap(err))
_, err = AccountFromBytes(b)
assert.Nil(t, err)
assert.NoError(t, err)
}
func TestAccountErrNumOverflowBalance(t *testing.T) {
var sk babyjub.PrivateKey
_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
assert.Nil(t, err)
assert.NoError(t, err)
pk := sk.Public()
// check limit
@@ -345,13 +348,13 @@ func TestAccountErrNumOverflowBalance(t *testing.T) {
TokenID: TokenID(1),
Nonce: Nonce(math.Pow(2, 40) - 1),
Balance: new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil), big.NewInt(1)),
PublicKey: pk,
PublicKey: pk.Compress(),
EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
}
assert.Equal(t, "6277101735386680763835789423207666416102355444464034512895", account.Balance.String())
_, err = account.Bytes()
assert.Nil(t, err)
assert.NoError(t, err)
// force value overflow
account.Balance = new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil)
@@ -361,7 +364,7 @@ func TestAccountErrNumOverflowBalance(t *testing.T) {
assert.Equal(t, fmt.Errorf("%s Balance", ErrNumOverflow), tracerr.Unwrap(err))
_, err = AccountFromBytes(b)
assert.Nil(t, err)
assert.NoError(t, err)
b[39] = 1
_, err = AccountFromBytes(b)