package common
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"errors"
|
|
"fmt"
|
|
"math/big"
|
|
"time"
|
|
|
|
ethCommon "github.com/ethereum/go-ethereum/common"
|
|
"github.com/hermeznetwork/tracerr"
|
|
"github.com/iden3/go-iden3-crypto/babyjub"
|
|
"github.com/iden3/go-iden3-crypto/poseidon"
|
|
)
|
|
|
|
// EmptyBJJComp contains the 32 byte array of a empty BabyJubJub PublicKey
|
|
// Compressed. It is a valid point in the BabyJubJub curve, so does not give
|
|
// errors when being decompressed.
|
|
var EmptyBJJComp = babyjub.PublicKeyComp([32]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})
|
|
|
|
// PoolL2Tx is a struct that represents a L2Tx sent by an account to the
|
|
// coordinator that is waiting to be forged
|
|
type PoolL2Tx struct {
|
|
// Stored in DB: mandatory fileds
|
|
|
|
// TxID (12 bytes) for L2Tx is:
|
|
// bytes: | 1 | 6 | 5 |
|
|
// values: | type | FromIdx | Nonce |
|
|
TxID TxID `meddler:"tx_id"`
|
|
FromIdx Idx `meddler:"from_idx"`
|
|
ToIdx Idx `meddler:"to_idx,zeroisnull"`
|
|
// AuxToIdx is only used internally at the StateDB to avoid repeated
|
|
// computation when processing transactions (from Synchronizer,
|
|
// TxSelector, BatchBuilder)
|
|
AuxToIdx Idx `meddler:"-"`
|
|
ToEthAddr ethCommon.Address `meddler:"to_eth_addr,zeroisnull"`
|
|
ToBJJ babyjub.PublicKeyComp `meddler:"to_bjj,zeroisnull"`
|
|
TokenID TokenID `meddler:"token_id"`
|
|
Amount *big.Int `meddler:"amount,bigint"` // TODO: change to float16
|
|
Fee FeeSelector `meddler:"fee"`
|
|
Nonce Nonce `meddler:"nonce"` // effective 40 bits used
|
|
State PoolL2TxState `meddler:"state"`
|
|
// Info contains information about the status & State of the
|
|
// transaction. As for example, if the Tx has not been selected in the
|
|
// last batch due not enough Balance at the Sender account, this reason
|
|
// would appear at this parameter.
|
|
Info string `meddler:"info,zeroisnull"`
|
|
Signature babyjub.SignatureComp `meddler:"signature"` // tx signature
|
|
Timestamp time.Time `meddler:"timestamp,utctime"` // time when added to the tx pool
|
|
// Stored in DB: optional fileds, may be uninitialized
|
|
RqFromIdx Idx `meddler:"rq_from_idx,zeroisnull"`
|
|
RqToIdx Idx `meddler:"rq_to_idx,zeroisnull"`
|
|
RqToEthAddr ethCommon.Address `meddler:"rq_to_eth_addr,zeroisnull"`
|
|
RqToBJJ babyjub.PublicKeyComp `meddler:"rq_to_bjj,zeroisnull"`
|
|
RqTokenID TokenID `meddler:"rq_token_id,zeroisnull"`
|
|
RqAmount *big.Int `meddler:"rq_amount,bigintnull"` // TODO: change to float16
|
|
RqFee FeeSelector `meddler:"rq_fee,zeroisnull"`
|
|
RqNonce Nonce `meddler:"rq_nonce,zeroisnull"` // effective 48 bits used
|
|
AbsoluteFee float64 `meddler:"fee_usd,zeroisnull"`
|
|
AbsoluteFeeUpdate time.Time `meddler:"usd_update,utctimez"`
|
|
Type TxType `meddler:"tx_type"`
|
|
// Extra metadata, may be uninitialized
|
|
RqTxCompressedData []byte `meddler:"-"` // 253 bits, optional for atomic txs
|
|
}
|
|
|
|
// NewPoolL2Tx returns the given L2Tx with the TxId & Type parameters calculated
|
|
// from the L2Tx values
|
|
func NewPoolL2Tx(tx *PoolL2Tx) (*PoolL2Tx, error) {
|
|
txTypeOld := tx.Type
|
|
if err := tx.SetType(); err != nil {
|
|
return nil, tracerr.Wrap(err)
|
|
}
|
|
// If original Type doesn't match the correct one, return error
|
|
if txTypeOld != "" && txTypeOld != tx.Type {
|
|
return nil, tracerr.Wrap(fmt.Errorf("L2Tx.Type: %s, should be: %s",
|
|
tx.Type, txTypeOld))
|
|
}
|
|
|
|
txIDOld := tx.TxID
|
|
if err := tx.SetID(); err != nil {
|
|
return nil, tracerr.Wrap(err)
|
|
}
|
|
// If original TxID doesn't match the correct one, return error
|
|
if txIDOld != (TxID{}) && txIDOld != tx.TxID {
|
|
return tx, tracerr.Wrap(fmt.Errorf("PoolL2Tx.TxID: %s, should be: %s",
|
|
tx.TxID.String(), txIDOld.String()))
|
|
}
|
|
|
|
return tx, nil
|
|
}
|
|
|
|
// SetType sets the type of the transaction
|
|
func (tx *PoolL2Tx) SetType() error {
|
|
if tx.ToIdx >= IdxUserThreshold {
|
|
tx.Type = TxTypeTransfer
|
|
} else if tx.ToIdx == 1 {
|
|
tx.Type = TxTypeExit
|
|
} else if tx.ToIdx == 0 {
|
|
if tx.ToBJJ != EmptyBJJComp && tx.ToEthAddr == FFAddr {
|
|
tx.Type = TxTypeTransferToBJJ
|
|
} else if tx.ToEthAddr != FFAddr && tx.ToEthAddr != EmptyAddr {
|
|
tx.Type = TxTypeTransferToEthAddr
|
|
}
|
|
} else {
|
|
return tracerr.Wrap(errors.New("malformed transaction"))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// SetID sets the ID of the transaction
|
|
func (tx *PoolL2Tx) SetID() error {
|
|
txID, err := tx.L2Tx().CalculateTxID()
|
|
if err != nil {
|
|
return tracerr.Wrap(err)
|
|
}
|
|
tx.TxID = txID
|
|
return nil
|
|
}
|
|
|
|
// TxCompressedData spec:
|
|
// [ 1 bits ] toBJJSign // 1 byte
|
|
// [ 8 bits ] userFee // 1 byte
|
|
// [ 40 bits ] nonce // 5 bytes
|
|
// [ 32 bits ] tokenID // 4 bytes
|
|
// [ 16 bits ] amountFloat16 // 2 bytes
|
|
// [ 48 bits ] toIdx // 6 bytes
|
|
// [ 48 bits ] fromIdx // 6 bytes
|
|
// [ 16 bits ] chainId // 2 bytes
|
|
// [ 32 bits ] signatureConstant // 4 bytes
|
|
// Total bits compressed data: 241 bits // 31 bytes in *big.Int representation
|
|
func (tx *PoolL2Tx) TxCompressedData(chainID uint16) (*big.Int, error) {
|
|
amountFloat16, err := NewFloat16(tx.Amount)
|
|
if err != nil {
|
|
return nil, tracerr.Wrap(err)
|
|
}
|
|
var b [31]byte
|
|
|
|
toBJJSign := byte(0)
|
|
pkSign, _ := babyjub.UnpackSignY(tx.ToBJJ)
|
|
if pkSign {
|
|
toBJJSign = byte(1)
|
|
}
|
|
|
|
b[0] = toBJJSign
|
|
b[1] = byte(tx.Fee)
|
|
nonceBytes, err := tx.Nonce.Bytes()
|
|
if err != nil {
|
|
return nil, tracerr.Wrap(err)
|
|
}
|
|
copy(b[2:7], nonceBytes[:])
|
|
copy(b[7:11], tx.TokenID.Bytes())
|
|
copy(b[11:13], amountFloat16.Bytes())
|
|
toIdxBytes, err := tx.ToIdx.Bytes()
|
|
if err != nil {
|
|
return nil, tracerr.Wrap(err)
|
|
}
|
|
copy(b[13:19], toIdxBytes[:])
|
|
fromIdxBytes, err := tx.FromIdx.Bytes()
|
|
if err != nil {
|
|
return nil, tracerr.Wrap(err)
|
|
}
|
|
copy(b[19:25], fromIdxBytes[:])
|
|
binary.BigEndian.PutUint16(b[25:27], chainID)
|
|
copy(b[27:31], SignatureConstantBytes[:])
|
|
|
|
bi := new(big.Int).SetBytes(b[:])
|
|
return bi, nil
|
|
}
|
|
|
|
// TxCompressedDataEmpty calculates the TxCompressedData of an empty
|
|
// transaction
|
|
func TxCompressedDataEmpty(chainID uint16) *big.Int {
|
|
var b [31]byte
|
|
binary.BigEndian.PutUint16(b[25:27], chainID)
|
|
copy(b[27:31], SignatureConstantBytes[:])
|
|
bi := new(big.Int).SetBytes(b[:])
|
|
return bi
|
|
}
|
|
|
|
// TxCompressedDataV2 spec:
|
|
// [ 1 bits ] toBJJSign // 1 byte
|
|
// [ 8 bits ] userFee // 1 byte
|
|
// [ 40 bits ] nonce // 5 bytes
|
|
// [ 32 bits ] tokenID // 4 bytes
|
|
// [ 16 bits ] amountFloat16 // 2 bytes
|
|
// [ 48 bits ] toIdx // 6 bytes
|
|
// [ 48 bits ] fromIdx // 6 bytes
|
|
// Total bits compressed data: 193 bits // 25 bytes in *big.Int representation
|
|
func (tx *PoolL2Tx) TxCompressedDataV2() (*big.Int, error) {
|
|
if tx.Amount == nil {
|
|
tx.Amount = big.NewInt(0)
|
|
}
|
|
amountFloat16, err := NewFloat16(tx.Amount)
|
|
if err != nil {
|
|
return nil, tracerr.Wrap(err)
|
|
}
|
|
var b [25]byte
|
|
toBJJSign := byte(0)
|
|
if tx.ToBJJ != EmptyBJJComp {
|
|
sign, _ := babyjub.UnpackSignY(tx.ToBJJ)
|
|
if sign {
|
|
toBJJSign = byte(1)
|
|
}
|
|
}
|
|
b[0] = toBJJSign
|
|
b[1] = byte(tx.Fee)
|
|
nonceBytes, err := tx.Nonce.Bytes()
|
|
if err != nil {
|
|
return nil, tracerr.Wrap(err)
|
|
}
|
|
copy(b[2:7], nonceBytes[:])
|
|
copy(b[7:11], tx.TokenID.Bytes())
|
|
copy(b[11:13], amountFloat16.Bytes())
|
|
toIdxBytes, err := tx.ToIdx.Bytes()
|
|
if err != nil {
|
|
return nil, tracerr.Wrap(err)
|
|
}
|
|
copy(b[13:19], toIdxBytes[:])
|
|
fromIdxBytes, err := tx.FromIdx.Bytes()
|
|
if err != nil {
|
|
return nil, tracerr.Wrap(err)
|
|
}
|
|
copy(b[19:25], fromIdxBytes[:])
|
|
|
|
bi := new(big.Int).SetBytes(b[:])
|
|
return bi, nil
|
|
}
|
|
|
|
// RqTxCompressedDataV2 is like the TxCompressedDataV2 but using the 'Rq'
|
|
// parameters. In a future iteration of the hermez-node, the 'Rq' parameters
|
|
// can be inside a struct, which contains the 'Rq' transaction grouped inside,
|
|
// so then computing the 'RqTxCompressedDataV2' would be just calling
|
|
// 'tx.Rq.TxCompressedDataV2()'.
|
|
// RqTxCompressedDataV2 spec:
|
|
// [ 1 bits ] rqToBJJSign // 1 byte
|
|
// [ 8 bits ] rqUserFee // 1 byte
|
|
// [ 40 bits ] rqNonce // 5 bytes
|
|
// [ 32 bits ] rqTokenID // 4 bytes
|
|
// [ 16 bits ] rqAmountFloat16 // 2 bytes
|
|
// [ 48 bits ] rqToIdx // 6 bytes
|
|
// [ 48 bits ] rqFromIdx // 6 bytes
|
|
// Total bits compressed data: 193 bits // 25 bytes in *big.Int representation
|
|
func (tx *PoolL2Tx) RqTxCompressedDataV2() (*big.Int, error) {
|
|
if tx.RqAmount == nil {
|
|
tx.RqAmount = big.NewInt(0)
|
|
}
|
|
amountFloat16, err := NewFloat16(tx.RqAmount)
|
|
if err != nil {
|
|
return nil, tracerr.Wrap(err)
|
|
}
|
|
var b [25]byte
|
|
rqToBJJSign := byte(0)
|
|
if tx.RqToBJJ != EmptyBJJComp {
|
|
sign, _ := babyjub.UnpackSignY(tx.RqToBJJ)
|
|
if sign {
|
|
rqToBJJSign = byte(1)
|
|
}
|
|
}
|
|
b[0] = rqToBJJSign
|
|
b[1] = byte(tx.RqFee)
|
|
nonceBytes, err := tx.RqNonce.Bytes()
|
|
if err != nil {
|
|
return nil, tracerr.Wrap(err)
|
|
}
|
|
copy(b[2:7], nonceBytes[:])
|
|
copy(b[7:11], tx.RqTokenID.Bytes())
|
|
copy(b[11:13], amountFloat16.Bytes())
|
|
toIdxBytes, err := tx.RqToIdx.Bytes()
|
|
if err != nil {
|
|
return nil, tracerr.Wrap(err)
|
|
}
|
|
copy(b[13:19], toIdxBytes[:])
|
|
fromIdxBytes, err := tx.RqFromIdx.Bytes()
|
|
if err != nil {
|
|
return nil, tracerr.Wrap(err)
|
|
}
|
|
copy(b[19:25], fromIdxBytes[:])
|
|
|
|
bi := new(big.Int).SetBytes(b[:])
|
|
return bi, nil
|
|
}
|
|
|
|
// HashToSign returns the computed Poseidon hash from the *PoolL2Tx that will
|
|
// be signed by the sender.
|
|
func (tx *PoolL2Tx) HashToSign(chainID uint16) (*big.Int, error) {
|
|
toCompressedData, err := tx.TxCompressedData(chainID)
|
|
if err != nil {
|
|
return nil, tracerr.Wrap(err)
|
|
}
|
|
toEthAddr := EthAddrToBigInt(tx.ToEthAddr)
|
|
rqToEthAddr := EthAddrToBigInt(tx.RqToEthAddr)
|
|
|
|
_, toBJJY := babyjub.UnpackSignY(tx.ToBJJ)
|
|
|
|
rqTxCompressedDataV2, err := tx.RqTxCompressedDataV2()
|
|
if err != nil {
|
|
return nil, tracerr.Wrap(err)
|
|
}
|
|
|
|
_, rqToBJJY := babyjub.UnpackSignY(tx.RqToBJJ)
|
|
|
|
return poseidon.Hash([]*big.Int{toCompressedData, toEthAddr, toBJJY, rqTxCompressedDataV2, rqToEthAddr, rqToBJJY})
|
|
}
|
|
|
|
// VerifySignature returns true if the signature verification is correct for the given PublicKeyComp
|
|
func (tx *PoolL2Tx) VerifySignature(chainID uint16, pkComp babyjub.PublicKeyComp) bool {
|
|
h, err := tx.HashToSign(chainID)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
s, err := tx.Signature.Decompress()
|
|
if err != nil {
|
|
return false
|
|
}
|
|
pk, err := pkComp.Decompress()
|
|
if err != nil {
|
|
return false
|
|
}
|
|
return pk.VerifyPoseidon(h, s)
|
|
}
|
|
|
|
// L2Tx returns a *L2Tx from the PoolL2Tx
|
|
func (tx PoolL2Tx) L2Tx() L2Tx {
|
|
var toIdx Idx
|
|
if tx.ToIdx == Idx(0) {
|
|
toIdx = tx.AuxToIdx
|
|
} else {
|
|
toIdx = tx.ToIdx
|
|
}
|
|
return L2Tx{
|
|
TxID: tx.TxID,
|
|
FromIdx: tx.FromIdx,
|
|
ToIdx: toIdx,
|
|
TokenID: tx.TokenID,
|
|
Amount: tx.Amount,
|
|
Fee: tx.Fee,
|
|
Nonce: tx.Nonce,
|
|
Type: tx.Type,
|
|
}
|
|
}
|
|
|
|
// Tx returns a *Tx from the PoolL2Tx
|
|
func (tx PoolL2Tx) Tx() Tx {
|
|
return Tx{
|
|
TxID: tx.TxID,
|
|
FromIdx: tx.FromIdx,
|
|
ToIdx: tx.ToIdx,
|
|
Amount: tx.Amount,
|
|
TokenID: tx.TokenID,
|
|
Nonce: &tx.Nonce,
|
|
Fee: &tx.Fee,
|
|
Type: tx.Type,
|
|
}
|
|
}
|
|
|
|
// PoolL2TxsToL2Txs returns an array of []L2Tx from an array of []PoolL2Tx
|
|
func PoolL2TxsToL2Txs(txs []PoolL2Tx) ([]L2Tx, error) {
|
|
l2Txs := make([]L2Tx, len(txs))
|
|
for i, poolTx := range txs {
|
|
l2Txs[i] = poolTx.L2Tx()
|
|
}
|
|
return l2Txs, nil
|
|
}
|
|
|
|
// TxIDsFromPoolL2Txs returns an array of TxID from the []PoolL2Tx
|
|
func TxIDsFromPoolL2Txs(txs []PoolL2Tx) []TxID {
|
|
txIDs := make([]TxID, len(txs))
|
|
for i, tx := range txs {
|
|
txIDs[i] = tx.TxID
|
|
}
|
|
return txIDs
|
|
}
|
|
|
|
// PoolL2TxState is a string that represents the status of a L2 transaction
|
|
type PoolL2TxState string
|
|
|
|
const (
|
|
// PoolL2TxStatePending represents a valid L2Tx that hasn't started the
|
|
// forging process
|
|
PoolL2TxStatePending PoolL2TxState = "pend"
|
|
// PoolL2TxStateForging represents a valid L2Tx that has started the
|
|
// forging process
|
|
PoolL2TxStateForging PoolL2TxState = "fing"
|
|
// PoolL2TxStateForged represents a L2Tx that has already been forged
|
|
PoolL2TxStateForged PoolL2TxState = "fged"
|
|
// PoolL2TxStateInvalid represents a L2Tx that has been invalidated
|
|
PoolL2TxStateInvalid PoolL2TxState = "invl"
|
|
)
|