package common import ( "encoding/binary" "fmt" "math/big" ethCommon "github.com/ethereum/go-ethereum/common" ethCrypto "github.com/ethereum/go-ethereum/crypto" "github.com/hermeznetwork/tracerr" "github.com/iden3/go-iden3-crypto/babyjub" ) // L1Tx is a struct that represents a L1 tx type L1Tx struct { // Stored in DB: mandatory fileds // TxID (32 bytes) for L1Tx is the Keccak256 (ethereum) hash of: // bytes: | 1 | 8 | 2 | 1 | // values: | type | ToForgeL1TxsNum | Position | 0 (padding) | // where type: // - L1UserTx: 0 // - L1CoordinatorTx: 1 TxID TxID `meddler:"id"` ToForgeL1TxsNum *int64 `meddler:"to_forge_l1_txs_num"` // toForgeL1TxsNum in which the tx was forged / will be forged Position int `meddler:"position"` UserOrigin bool `meddler:"user_origin"` // true if the tx was originated by a user, false if it was aoriginated by a coordinator. Note that this differ from the spec for implementation simplification purpposes FromIdx Idx `meddler:"from_idx,zeroisnull"` // FromIdx is used by L1Tx/Deposit to indicate the Idx receiver of the L1Tx.DepositAmount (deposit) EffectiveFromIdx Idx `meddler:"effective_from_idx,zeroisnull"` FromEthAddr ethCommon.Address `meddler:"from_eth_addr,zeroisnull"` FromBJJ babyjub.PublicKeyComp `meddler:"from_bjj,zeroisnull"` ToIdx Idx `meddler:"to_idx"` // ToIdx is ignored in L1Tx/Deposit, but used in the L1Tx/DepositAndTransfer TokenID TokenID `meddler:"token_id"` Amount *big.Int `meddler:"amount,bigint"` // EffectiveAmount only applies to L1UserTx. EffectiveAmount *big.Int `meddler:"effective_amount,bigintnull"` DepositAmount *big.Int `meddler:"deposit_amount,bigint"` // EffectiveDepositAmount only applies to L1UserTx. EffectiveDepositAmount *big.Int `meddler:"effective_deposit_amount,bigintnull"` EthBlockNum int64 `meddler:"eth_block_num"` // Ethereum Block Number in which this L1Tx was added to the queue Type TxType `meddler:"type"` BatchNum *BatchNum `meddler:"batch_num"` } // NewL1Tx returns the given L1Tx with the TxId & Type parameters calculated // from the L1Tx values func NewL1Tx(tx *L1Tx) (*L1Tx, 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("L1Tx.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("L1Tx.TxID: %s, should be: %s", tx.TxID.String(), txIDOld.String())) } return tx, nil } // SetType sets the type of the transaction func (tx *L1Tx) SetType() error { if tx.FromIdx == 0 { if tx.ToIdx == Idx(0) { tx.Type = TxTypeCreateAccountDeposit } else if tx.ToIdx >= IdxUserThreshold { tx.Type = TxTypeCreateAccountDepositTransfer } else { return tracerr.Wrap(fmt.Errorf( "Can not determine type of L1Tx, invalid ToIdx value: %d", tx.ToIdx)) } } else if tx.FromIdx >= IdxUserThreshold { if tx.ToIdx == Idx(0) { tx.Type = TxTypeDeposit } else if tx.ToIdx == Idx(1) { tx.Type = TxTypeForceExit } else if tx.ToIdx >= IdxUserThreshold { if tx.DepositAmount.Int64() == int64(0) { tx.Type = TxTypeForceTransfer } else { tx.Type = TxTypeDepositTransfer } } else { return tracerr.Wrap(fmt.Errorf( "Can not determine type of L1Tx, invalid ToIdx value: %d", tx.ToIdx)) } } else { return tracerr.Wrap(fmt.Errorf( "Can not determine type of L1Tx, invalid FromIdx value: %d", tx.FromIdx)) } return nil } // SetID sets the ID of the transaction. For L1UserTx uses (ToForgeL1TxsNum, // Position), for L1CoordinatorTx uses (BatchNum, Position). func (tx *L1Tx) SetID() error { var b []byte if tx.UserOrigin { if tx.ToForgeL1TxsNum == nil { return tracerr.Wrap(fmt.Errorf("L1Tx.UserOrigin == true && L1Tx.ToForgeL1TxsNum == nil")) } tx.TxID[0] = TxIDPrefixL1UserTx var toForgeL1TxsNumBytes [8]byte binary.BigEndian.PutUint64(toForgeL1TxsNumBytes[:], uint64(*tx.ToForgeL1TxsNum)) b = append(b, toForgeL1TxsNumBytes[:]...) } else { if tx.BatchNum == nil { return tracerr.Wrap(fmt.Errorf("L1Tx.UserOrigin == false && L1Tx.BatchNum == nil")) } tx.TxID[0] = TxIDPrefixL1CoordTx var batchNumBytes [8]byte binary.BigEndian.PutUint64(batchNumBytes[:], uint64(*tx.BatchNum)) b = append(b, batchNumBytes[:]...) } var positionBytes [2]byte binary.BigEndian.PutUint16(positionBytes[:], uint16(tx.Position)) b = append(b, positionBytes[:]...) // calculate hash h := ethCrypto.Keccak256Hash(b).Bytes() copy(tx.TxID[1:], h) return nil } // Tx returns a *Tx from the L1Tx func (tx L1Tx) Tx() Tx { f := new(big.Float).SetInt(tx.EffectiveAmount) amountFloat, _ := f.Float64() userOrigin := new(bool) *userOrigin = tx.UserOrigin genericTx := Tx{ IsL1: true, TxID: tx.TxID, Type: tx.Type, Position: tx.Position, FromIdx: tx.FromIdx, ToIdx: tx.ToIdx, Amount: tx.EffectiveAmount, AmountFloat: amountFloat, TokenID: tx.TokenID, ToForgeL1TxsNum: tx.ToForgeL1TxsNum, UserOrigin: userOrigin, FromEthAddr: tx.FromEthAddr, FromBJJ: tx.FromBJJ, DepositAmount: tx.EffectiveDepositAmount, EthBlockNum: tx.EthBlockNum, } if tx.DepositAmount != nil { lf := new(big.Float).SetInt(tx.DepositAmount) depositAmountFloat, _ := lf.Float64() genericTx.DepositAmountFloat = &depositAmountFloat } return genericTx } // TxCompressedData spec: // [ 1 bits ] empty (toBJJSign) // 1 byte // [ 8 bits ] empty (userFee) // 1 byte // [ 40 bits ] empty (nonce) // 5 bytes // [ 32 bits ] tokenID // 4 bytes // [ 48 bits ] toIdx // 6 bytes // [ 48 bits ] fromIdx // 6 bytes // [ 16 bits ] chainId // 2 bytes // [ 32 bits ] empty (signatureConstant) // 4 bytes // Total bits compressed data: 225 bits // 29 bytes in *big.Int representation func (tx L1Tx) TxCompressedData(chainID uint16) (*big.Int, error) { var b [29]byte // b[0:7] empty: no ToBJJSign, no fee, no nonce copy(b[7:11], tx.TokenID.Bytes()) toIdxBytes, err := tx.ToIdx.Bytes() if err != nil { return nil, tracerr.Wrap(err) } copy(b[11:17], toIdxBytes[:]) fromIdxBytes, err := tx.FromIdx.Bytes() if err != nil { return nil, tracerr.Wrap(err) } copy(b[17:23], fromIdxBytes[:]) binary.BigEndian.PutUint16(b[23:25], chainID) copy(b[25:29], SignatureConstantBytes[:]) bi := new(big.Int).SetBytes(b[:]) return bi, nil } // BytesDataAvailability encodes a L1Tx into []byte for the Data Availability // [ fromIdx | toIdx | amountFloat40 | Fee ] func (tx *L1Tx) BytesDataAvailability(nLevels uint32) ([]byte, error) { idxLen := nLevels / 8 //nolint:gomnd b := make([]byte, ((nLevels*2)+40+8)/8) //nolint:gomnd fromIdxBytes, err := tx.FromIdx.Bytes() if err != nil { return nil, tracerr.Wrap(err) } copy(b[0:idxLen], fromIdxBytes[6-idxLen:]) toIdxBytes, err := tx.ToIdx.Bytes() if err != nil { return nil, tracerr.Wrap(err) } copy(b[idxLen:idxLen*2], toIdxBytes[6-idxLen:]) if tx.EffectiveAmount != nil { amountFloat40, err := NewFloat40(tx.EffectiveAmount) if err != nil { return nil, tracerr.Wrap(err) } amountFloat40Bytes, err := amountFloat40.Bytes() if err != nil { return nil, tracerr.Wrap(err) } copy(b[idxLen*2:idxLen*2+Float40BytesLength], amountFloat40Bytes) } // fee = 0 (as is L1Tx) return b[:], nil } // L1TxFromDataAvailability decodes a L1Tx from []byte (Data Availability) func L1TxFromDataAvailability(b []byte, nLevels uint32) (*L1Tx, error) { idxLen := nLevels / 8 //nolint:gomnd fromIdxBytes := b[0:idxLen] toIdxBytes := b[idxLen : idxLen*2] amountBytes := b[idxLen*2 : idxLen*2+Float40BytesLength] l1tx := L1Tx{} fromIdx, err := IdxFromBytes(ethCommon.LeftPadBytes(fromIdxBytes, 6)) if err != nil { return nil, tracerr.Wrap(err) } l1tx.FromIdx = fromIdx toIdx, err := IdxFromBytes(ethCommon.LeftPadBytes(toIdxBytes, 6)) if err != nil { return nil, tracerr.Wrap(err) } l1tx.ToIdx = toIdx l1tx.EffectiveAmount, err = Float40FromBytes(amountBytes).BigInt() return &l1tx, err } // BytesGeneric returns the generic representation of a L1Tx. This method is // used to compute the []byte representation of a L1UserTx, and also to compute // the L1TxData for the ZKInputs (at the HashGlobalInputs), using this method // for L1CoordinatorTxs & L1UserTxs (for the ZKInputs case). func (tx *L1Tx) BytesGeneric() ([]byte, error) { var b [RollupConstL1UserTotalBytes]byte copy(b[0:20], tx.FromEthAddr.Bytes()) if tx.FromBJJ != EmptyBJJComp { pkCompL := tx.FromBJJ pkCompB := SwapEndianness(pkCompL[:]) copy(b[20:52], pkCompB[:]) } fromIdxBytes, err := tx.FromIdx.Bytes() if err != nil { return nil, tracerr.Wrap(err) } copy(b[52:58], fromIdxBytes[:]) depositAmountFloat40, err := NewFloat40(tx.DepositAmount) if err != nil { return nil, tracerr.Wrap(err) } depositAmountFloat40Bytes, err := depositAmountFloat40.Bytes() if err != nil { return nil, tracerr.Wrap(err) } copy(b[58:63], depositAmountFloat40Bytes) amountFloat40, err := NewFloat40(tx.Amount) if err != nil { return nil, tracerr.Wrap(err) } amountFloat40Bytes, err := amountFloat40.Bytes() if err != nil { return nil, tracerr.Wrap(err) } copy(b[63:68], amountFloat40Bytes) copy(b[68:72], tx.TokenID.Bytes()) toIdxBytes, err := tx.ToIdx.Bytes() if err != nil { return nil, tracerr.Wrap(err) } copy(b[72:78], toIdxBytes[:]) return b[:], nil } // BytesUser encodes a L1UserTx into []byte func (tx *L1Tx) BytesUser() ([]byte, error) { if !tx.UserOrigin { return nil, tracerr.Wrap(fmt.Errorf("Can not calculate BytesUser() for a L1CoordinatorTx")) } return tx.BytesGeneric() } // BytesCoordinatorTx encodes a L1CoordinatorTx into []byte func (tx *L1Tx) BytesCoordinatorTx(compressedSignatureBytes []byte) ([]byte, error) { if tx.UserOrigin { return nil, tracerr.Wrap(fmt.Errorf("Can not calculate BytesCoordinatorTx() for a L1UserTx")) } var b [RollupConstL1CoordinatorTotalBytes]byte v := compressedSignatureBytes[64] s := compressedSignatureBytes[32:64] r := compressedSignatureBytes[0:32] b[0] = v copy(b[1:33], s) copy(b[33:65], r) pkCompL := tx.FromBJJ pkCompB := SwapEndianness(pkCompL[:]) copy(b[65:97], pkCompB[:]) copy(b[97:101], tx.TokenID.Bytes()) return b[:], nil } // L1UserTxFromBytes decodes a L1Tx from []byte func L1UserTxFromBytes(b []byte) (*L1Tx, error) { if len(b) != RollupConstL1UserTotalBytes { return nil, tracerr.Wrap(fmt.Errorf("Can not parse L1Tx bytes, expected length %d, current: %d", 68, len(b))) } tx := &L1Tx{ UserOrigin: true, } var err error tx.FromEthAddr = ethCommon.BytesToAddress(b[0:20]) pkCompB := b[20:52] pkCompL := SwapEndianness(pkCompB) copy(tx.FromBJJ[:], pkCompL) fromIdx, err := IdxFromBytes(b[52:58]) if err != nil { return nil, tracerr.Wrap(err) } tx.FromIdx = fromIdx tx.DepositAmount, err = Float40FromBytes(b[58:63]).BigInt() if err != nil { return nil, tracerr.Wrap(err) } tx.Amount, err = Float40FromBytes(b[63:68]).BigInt() if err != nil { return nil, tracerr.Wrap(err) } tx.TokenID, err = TokenIDFromBytes(b[68:72]) if err != nil { return nil, tracerr.Wrap(err) } tx.ToIdx, err = IdxFromBytes(b[72:78]) if err != nil { return nil, tracerr.Wrap(err) } return tx, nil } // L1CoordinatorTxFromBytes decodes a L1Tx from []byte func L1CoordinatorTxFromBytes(b []byte, chainID *big.Int, hermezAddress ethCommon.Address) (*L1Tx, error) { if len(b) != RollupConstL1CoordinatorTotalBytes { return nil, tracerr.Wrap(fmt.Errorf("Can not parse L1CoordinatorTx bytes, expected length %d, current: %d", 101, len(b))) } tx := &L1Tx{ UserOrigin: false, } var err error v := b[0] s := b[1:33] r := b[33:65] pkCompB := b[65:97] pkCompL := SwapEndianness(pkCompB) copy(tx.FromBJJ[:], pkCompL) tx.TokenID, err = TokenIDFromBytes(b[97:101]) if err != nil { return nil, tracerr.Wrap(err) } tx.Amount = big.NewInt(0) tx.DepositAmount = big.NewInt(0) if int(v) > 0 { // L1CoordinatorTX ETH // Ethereum adds 27 to v v = b[0] - byte(27) //nolint:gomnd var signature []byte signature = append(signature, r[:]...) signature = append(signature, s[:]...) signature = append(signature, v) accCreationAuth := AccountCreationAuth{ BJJ: tx.FromBJJ, } h, err := accCreationAuth.HashToSign(uint16(chainID.Uint64()), hermezAddress) if err != nil { return nil, tracerr.Wrap(err) } pubKeyBytes, err := ethCrypto.Ecrecover(h, signature) if err != nil { return nil, tracerr.Wrap(err) } pubKey, err := ethCrypto.UnmarshalPubkey(pubKeyBytes) if err != nil { return nil, tracerr.Wrap(err) } tx.FromEthAddr = ethCrypto.PubkeyToAddress(*pubKey) } else { // L1Coordinator Babyjub tx.FromEthAddr = RollupConstEthAddressInternalOnly } return tx, nil }