feature: implemet p2p2consensus adapters for proposal types

Author: rianhughes

adapters/p2p2consensus/class.go

@@ -0,0 +1,89 @@
+package p2p2consensus
+
+import (
+	"github.com/NethermindEth/juno/adapters/sn2core"
+	"github.com/NethermindEth/juno/core"
+	"github.com/NethermindEth/juno/core/crypto"
+	"github.com/NethermindEth/juno/starknet"
+	"github.com/NethermindEth/juno/starknet/compiler"
+	"github.com/NethermindEth/juno/utils"
+	"github.com/starknet-io/starknet-p2pspecs/p2p/proto/class"
+)
+
+func AdaptClass(cls *class.Cairo1Class) core.Class {
+	if cls == nil {
+		return nil
+	}
+
+	abiHash := crypto.StarknetKeccak([]byte(cls.Abi))
+
+	program := utils.Map(cls.Program, AdaptFelt)
+	compiled, err := createCompiledClass(cls)
+	if err != nil {
+		panic(err)
+	}
+
+	adaptEP := func(points []*class.SierraEntryPoint) []core.SierraEntryPoint {
+		// usage of NonNilSlice is essential because relevant core class fields are non nil
+		return utils.Map(utils.NonNilSlice(points), adaptSierra)
+	}
+
+	entryPoints := cls.EntryPoints
+	return &core.Cairo1Class{
+		Abi:     cls.Abi,
+		AbiHash: abiHash,
+		EntryPoints: struct {
+			Constructor []core.SierraEntryPoint
+			External    []core.SierraEntryPoint
+			L1Handler   []core.SierraEntryPoint
+		}{
+			Constructor: adaptEP(entryPoints.Constructors),
+			External:    adaptEP(entryPoints.Externals),
+			L1Handler:   adaptEP(entryPoints.L1Handlers),
+		},
+		Program:         program,
+		ProgramHash:     crypto.PoseidonArray(program...),
+		SemanticVersion: cls.ContractClassVersion,
+		Compiled:        compiled,
+	}
+}
+
+func adaptSierra(e *class.SierraEntryPoint) core.SierraEntryPoint {
+	return core.SierraEntryPoint{
+		Index:    e.Index,
+		Selector: AdaptFelt(e.Selector),
+	}
+}
+
+func createCompiledClass(cairo1 *class.Cairo1Class) (*core.CompiledClass, error) {
+	if cairo1 == nil {
+		return nil, nil
+	}
+
+	adapt := func(ep *class.SierraEntryPoint) starknet.SierraEntryPoint {
+		return starknet.SierraEntryPoint{
+			Index:    ep.Index,
+			Selector: AdaptFelt(ep.Selector),
+		}
+	}
+	ep := cairo1.EntryPoints
+	def := &starknet.SierraDefinition{
+		Abi: cairo1.Abi,
+		EntryPoints: starknet.SierraEntryPoints{
+			// WARNING: usage of utils.NonNilSlice is essential, otherwise compilation will finish with errors
+			// todo move NonNilSlice to Compile ?
+			Constructor: utils.Map(utils.NonNilSlice(ep.Constructors), adapt),
+			External:    utils.Map(utils.NonNilSlice(ep.Externals), adapt),
+			L1Handler:   utils.Map(utils.NonNilSlice(ep.L1Handlers), adapt),
+		},
+		Program: utils.Map(cairo1.Program, AdaptFelt),
+		Version: cairo1.ContractClassVersion,
+	}
+
+	compiledClass, err := compiler.Compile(def)
+	if err != nil {
+		return nil, err
+	}
+
+	return sn2core.AdaptCompiledClass(compiledClass)
+}

adapters/p2p2consensus/felt.go

@@ -0,0 +1,48 @@
+package p2p2consensus
+
+import (
+	"encoding/binary"
+
+	"github.com/NethermindEth/juno/core/felt"
+	"github.com/NethermindEth/juno/utils"
+	ethcommon "github.com/ethereum/go-ethereum/common"
+	"github.com/starknet-io/starknet-p2pspecs/p2p/proto/common"
+	"github.com/starknet-io/starknet-p2pspecs/p2p/proto/sync/receipt"
+)
+
+func AdaptHash(h *common.Hash) *felt.Felt {
+	return adapt(h)
+}
+
+func AdaptAddress(h *common.Address) *felt.Felt {
+	return adapt(h)
+}
+
+func AdaptEthAddress(h *receipt.EthereumAddress) ethcommon.Address {
+	return ethcommon.BytesToAddress(h.Elements)
+}
+
+func AdaptFelt(f *common.Felt252) *felt.Felt {
+	return adapt(f)
+}
+
+func adapt(v interface{ GetElements() []byte }) *felt.Felt {
+	if utils.IsNil(v) {
+		return nil
+	}
+
+	return new(felt.Felt).SetBytes(v.GetElements())
+}
+
+func AdaptUint128(u *common.Uint128) *felt.Felt {
+	if u == nil {
+		return nil
+	}
+
+	bytes := make([]byte, 16) //nolint:mnd
+
+	binary.BigEndian.PutUint64(bytes[:8], u.High)
+	binary.BigEndian.PutUint64(bytes[8:], u.Low)
+
+	return new(felt.Felt).SetBytes(bytes)
+}

adapters/p2p2consensus/proposal.go

@@ -0,0 +1,83 @@
+package p2p2consensus
+
+import (
+	"math/big"
+
+	"github.com/Masterminds/semver/v3"
+	consensus "github.com/NethermindEth/juno/consensus/types"
+	"github.com/NethermindEth/juno/core"
+	"github.com/NethermindEth/juno/core/felt"
+	p2pconsensus "github.com/NethermindEth/juno/p2p/proto/consensus/consensus"
+	"github.com/NethermindEth/juno/utils"
+	common "github.com/starknet-io/starknet-p2pspecs/p2p/proto/common"
+)
+
+func U128ToFelt(u *common.Uint128) *felt.Felt {
+	lowBig := new(big.Int).SetUint64(u.Low)
+	highBig := new(big.Int).SetUint64(u.High)
+	highBig.Lsh(highBig, 64) //nolint:mnd
+	return new(felt.Felt).SetBigInt(highBig.Or(highBig, lowBig))
+}
+
+func AdaptProposalInit(msg *p2pconsensus.ProposalInit) consensus.ProposalInit {
+	return consensus.ProposalInit{
+		BlockNum: msg.BlockNumber,
+		Proposer: *new(felt.Felt).SetBytes(msg.Proposer.Elements),
+	}
+}
+
+func AdaptBlockInfo(msg *p2pconsensus.BlockInfo) *consensus.BlockInfo {
+	return &consensus.BlockInfo{
+		BlockNumber:       msg.BlockNumber,
+		Builder:           *new(felt.Felt).SetBytes(msg.Builder.Elements),
+		Timestamp:         msg.Timestamp,
+		L2GasPriceFRI:     *U128ToFelt(msg.L2GasPriceFri),
+		L1GasPriceWEI:     *U128ToFelt(msg.L1DataGasPriceWei),
+		L1DataGasPriceWEI: *U128ToFelt(msg.L1DataGasPriceWei),
+		EthToStrkRate:     *U128ToFelt(msg.EthToStrkRate),
+		L1DAMode:          core.L1DAMode(msg.L1DaMode),
+	}
+}
+
+func AdaptProposalCommitment(msg *p2pconsensus.ProposalCommitment) consensus.ProposalCommitment {
+	return consensus.ProposalCommitment{
+		BlockNumber: msg.BlockNumber,
+		Builder:     *new(felt.Felt).SetBytes(msg.Builder.Elements),
+
+		ParentCommitment: *new(felt.Felt).SetBytes(msg.ParentCommitment.Elements),
+		Timestamp:        msg.Timestamp,
+		ProtocolVersion:  *semver.MustParse(msg.ProtocolVersion),
+
+		OldStateRoot:              *new(felt.Felt).SetBytes(msg.OldStateRoot.Elements),
+		VersionConstantCommitment: *new(felt.Felt).SetBytes(msg.VersionConstantCommitment.Elements),
+		NextL2GasPriceFRI:         *U128ToFelt(msg.NextL2GasPriceFri),
+
+		StateDiffCommitment:   *new(felt.Felt).SetBytes(msg.StateDiffCommitment.Elements),
+		TransactionCommitment: *new(felt.Felt).SetBytes(msg.TransactionCommitment.Elements),
+		EventCommitment:       *new(felt.Felt).SetBytes(msg.EventCommitment.Elements),
+		ReceiptCommitment:     *new(felt.Felt).SetBytes(msg.ReceiptCommitment.Elements),
+		ConcatenatedCounts:    *new(felt.Felt).SetBytes(msg.ConcatenatedCounts.Elements),
+		L1GasPriceFRI:         *U128ToFelt(msg.L1GasPriceFri),
+		L1DataGasPriceFRI:     *U128ToFelt(msg.L1DataGasPriceFri),
+		L2GasPriceFRI:         *U128ToFelt(msg.L2GasPriceFri),
+		L2GasUsed:             *U128ToFelt(msg.L2GasUsed),
+		L1DAMode:              core.L1DAMode(msg.L1DaMode),
+	}
+}
+
+func AdaptProposalTransaction(msg *p2pconsensus.TransactionBatch, network *utils.Network) []consensus.Transaction {
+	txns := make([]consensus.Transaction, len(msg.Transactions))
+	for i := range msg.Transactions {
+		txn, class := AdaptTransaction(msg.Transactions[i], network)
+		txns[i] = consensus.Transaction{
+			Transaction: txn,
+			Class:       class,
+			PaidFeeOnL1: nil, // Todo: this value is not passed in the spec.
+		}
+	}
+	return txns
+}
+
+func AdaptProposalFin(msg *p2pconsensus.ProposalFin) consensus.ProposalFin {
+	return consensus.ProposalFin(*new(felt.Felt).SetBytes(msg.ProposalCommitment.Elements))
+}