Merge branch 'main' into deploy-docs

.golangci.yaml

@@ -64,6 +64,9 @@ linters-settings:
     require-explanation: false # don't require an explanation for nolint directives
     require-specific: false # don't require nolint directives to be specific about which linter is being skipped
 
+  exhaustruct:
+    include: []
+
 linters:
   disable-all: true
   enable:
@@ -99,6 +102,7 @@ linters:
     - whitespace
     - tparallel
     - gci
+    - exhaustruct
 
   # don't enable:
   # - asciicheck
@@ -125,6 +129,11 @@ issues:
         - funlen
         - lll
         - gosec
+        - exhaustruct
+
+    - path-except: 'adapters/.+\.go' # run specified linters only on files that reside inside adapters
+      linters:
+        - exhaustruct
 
     - linters:
         - lll

adapters/core2p2p/receipt.go

@@ -68,6 +68,7 @@ func receiptCommon(r *core.TransactionReceipt) *spec.Receipt_Common {
 		MessagesSent:       utils.Map(r.L2ToL1Message, AdaptMessageToL1),
 		ExecutionResources: AdaptExecutionResources(r.ExecutionResources),
 		RevertReason:       r.RevertReason,
+		ConsumedMessage:    nil, // todo(kirill) recheck
 	}
 }
 
@@ -93,6 +94,7 @@ func AdaptExecutionResources(er *core.ExecutionResources) *spec.Receipt_Executio
 			RangeCheck: uint32(er.BuiltinInstanceCounter.RangeCheck),
 			Poseidon:   uint32(er.BuiltinInstanceCounter.Poseidon),
 			Keccak:     uint32(er.BuiltinInstanceCounter.Keccak),
+			Output:     uint32(er.BuiltinInstanceCounter.Output),
 		},
 		Steps:       uint32(er.Steps),
 		MemoryHoles: uint32(er.MemoryHoles),

adapters/core2sn/class.go

@@ -49,6 +49,7 @@ func AdaptSierraClass(class *core.Cairo1Class) *starknet.SierraDefinition {
 	handlers := utils.Map(utils.NonNilSlice(class.EntryPoints.L1Handler), adapt)
 
 	return &starknet.SierraDefinition{
+		Abi:     class.Abi,
 		Version: class.SemanticVersion,
 		Program: class.Program,
 		EntryPoints: starknet.SierraEntryPoints{

adapters/p2p2core/block.go

@@ -23,7 +23,7 @@ func AdaptSignature(cs *spec.ConsensusSignature) []*felt.Felt {
 	return []*felt.Felt{AdaptFelt(cs.R), AdaptFelt(cs.S)}
 }
 
-func AdaptBlockHeader(h *spec.BlockHeader) core.Header {
+func AdaptBlockHeader(h *spec.BlockHeader, signatures []*spec.ConsensusSignature) core.Header {
 	return core.Header{
 		Hash:             nil, // todo: add this when building the block
 		ParentHash:       AdaptHash(h.ParentHash),
@@ -36,5 +36,10 @@ func AdaptBlockHeader(h *spec.BlockHeader) core.Header {
 		ProtocolVersion:  h.ProtocolVersion,
 		EventsBloom:      nil, // Todo: add this in when building the block
 		GasPrice:         AdaptFelt(h.GasPrice),
+		Signatures:       utils.Map(signatures, AdaptSignature),
+		// todo(kirill) recheck fields
+		GasPriceSTRK:   nil,
+		L1DAMode:       0,
+		L1DataGasPrice: nil,
 	}
 }

adapters/p2p2core/receipt.go

@@ -24,6 +24,7 @@ func AdaptReceipt(r *spec.Receipt) *core.TransactionReceipt {
 
 	return &core.TransactionReceipt{
 		Fee:                AdaptFelt(common.ActualFee),
+		FeeUnit:            0,   // todo(kirill) recheck
 		Events:             nil, // todo SPEC , current specification does not maintain the mapping of events to transactions receipts
 		ExecutionResources: adaptExecutionResources(common.ExecutionResources),
 		L1ToL2Message:      nil,
@@ -40,17 +41,19 @@ func adaptExecutionResources(er *spec.Receipt_ExecutionResources) *core.Executio
 	}
 	return &core.ExecutionResources{
 		BuiltinInstanceCounter: core.BuiltinInstanceCounter{
-			Pedersen:   uint64(er.GetBuiltins().GetPedersen()),
-			RangeCheck: uint64(er.GetBuiltins().GetRangeCheck()),
-			Bitwise:    uint64(er.GetBuiltins().GetBitwise()),
-			Output:     0, // todo SPEC
-			Ecsda:      uint64(er.GetBuiltins().GetEcdsa()),
-			EcOp:       uint64(er.GetBuiltins().GetEcOp()),
-			Keccak:     uint64(er.GetBuiltins().GetKeccak()),
-			Poseidon:   uint64(er.GetBuiltins().GetPoseidon()),
+			Pedersen:     uint64(er.GetBuiltins().GetPedersen()),
+			RangeCheck:   uint64(er.GetBuiltins().GetRangeCheck()),
+			Bitwise:      uint64(er.GetBuiltins().GetBitwise()),
+			Output:       uint64(er.GetBuiltins().GetOutput()),
+			Ecsda:        uint64(er.GetBuiltins().GetEcdsa()),
+			EcOp:         uint64(er.GetBuiltins().GetEcOp()),
+			Keccak:       uint64(er.GetBuiltins().GetKeccak()),
+			Poseidon:     uint64(er.GetBuiltins().GetPoseidon()),
+			SegmentArena: 0, // todo(kirill) recheck
 		},
-		MemoryHoles: uint64(er.MemoryHoles),
-		Steps:       uint64(er.Steps), // todo SPEC 32 -> 64 bytes
+		DataAvailability: nil, // todo(kirill) recheck
+		MemoryHoles:      uint64(er.MemoryHoles),
+		Steps:            uint64(er.Steps), // todo SPEC 32 -> 64 bytes
 	}
 }
 

adapters/p2p2core/transaction.go

@@ -30,41 +30,67 @@ func AdaptTransaction(t *spec.Transaction, network *utils.Network) core.Transact
 	case *spec.Transaction_DeclareV0_:
 		tx := t.GetDeclareV0()
 		declareTx := &core.DeclareTransaction{
+			TransactionHash:      nil, // overridden below
 			Nonce:                nil, // for v0 nonce is not used for hash calculation
 			ClassHash:            AdaptHash(tx.ClassHash),
 			SenderAddress:        AdaptAddress(tx.Sender),
 			MaxFee:               AdaptFelt(tx.MaxFee),
 			TransactionSignature: adaptAccountSignature(tx.Signature),
 			Version:              txVersion(0),
-			CompiledClassHash:    nil,
+			// version 2 field
+			CompiledClassHash: nil,
+			// version 3 fields (zero values)
+			ResourceBounds:        nil,
+			PaymasterData:         nil,
+			AccountDeploymentData: nil,
+			Tip:                   0,
+			NonceDAMode:           0,
+			FeeDAMode:             0,
 		}
 		declareTx.TransactionHash = hash(declareTx)
 
 		return declareTx
 	case *spec.Transaction_DeclareV1_:
 		tx := t.GetDeclareV1()
 		declareTx := &core.DeclareTransaction{
+			TransactionHash:      nil, // overridden below
 			ClassHash:            AdaptHash(tx.ClassHash),
 			SenderAddress:        AdaptAddress(tx.Sender),
 			MaxFee:               AdaptFelt(tx.MaxFee),
 			TransactionSignature: adaptAccountSignature(tx.Signature),
 			Nonce:                AdaptFelt(tx.Nonce),
 			Version:              txVersion(1),
-			CompiledClassHash:    nil,
+			// version 2 field
+			CompiledClassHash: nil,
+			// version 3 fields (zero values)
+			ResourceBounds:        nil,
+			PaymasterData:         nil,
+			AccountDeploymentData: nil,
+			Tip:                   0,
+			NonceDAMode:           0,
+			FeeDAMode:             0,
 		}
 		declareTx.TransactionHash = hash(declareTx)
 
 		return declareTx
 	case *spec.Transaction_DeclareV2_:
 		tx := t.GetDeclareV2()
 		declareTx := &core.DeclareTransaction{
+			TransactionHash:      nil, // overridden below
 			ClassHash:            AdaptHash(tx.ClassHash),
 			SenderAddress:        AdaptAddress(tx.Sender),
 			MaxFee:               AdaptFelt(tx.MaxFee),
 			TransactionSignature: adaptAccountSignature(tx.Signature),
 			Nonce:                AdaptFelt(tx.Nonce),
 			Version:              txVersion(2),
 			CompiledClassHash:    AdaptFelt(tx.CompiledClassHash),
+			// version 3 fields (zero values)
+			ResourceBounds:        nil,
+			PaymasterData:         nil,
+			AccountDeploymentData: nil,
+			Tip:                   0,
+			NonceDAMode:           0,
+			FeeDAMode:             0,
 		}
 		declareTx.TransactionHash = hash(declareTx)
 
@@ -83,6 +109,7 @@ func AdaptTransaction(t *spec.Transaction, network *utils.Network) core.Transact
 		}
 
 		declareTx := &core.DeclareTransaction{
+			TransactionHash:      nil, // overridden below
 			ClassHash:            AdaptHash(tx.ClassHash),
 			SenderAddress:        AdaptAddress(tx.Sender),
 			MaxFee:               AdaptFelt(tx.MaxFee),
@@ -110,6 +137,7 @@ func AdaptTransaction(t *spec.Transaction, network *utils.Network) core.Transact
 		classHash := AdaptHash(tx.ClassHash)
 		callData := utils.Map(tx.Calldata, AdaptFelt)
 		deployTx := &core.DeployTransaction{
+			TransactionHash:     nil, // overridden below
 			ContractAddress:     core.ContractAddress(&felt.Zero, classHash, addressSalt, callData),
 			ContractAddressSalt: addressSalt,
 			ClassHash:           classHash,
@@ -127,6 +155,7 @@ func AdaptTransaction(t *spec.Transaction, network *utils.Network) core.Transact
 		callData := utils.Map(tx.Calldata, AdaptFelt)
 		deployAccTx := &core.DeployAccountTransaction{
 			DeployTransaction: core.DeployTransaction{
+				TransactionHash:     nil, // overridden below
 				ContractAddressSalt: addressSalt,
 				ContractAddress:     core.ContractAddress(&felt.Zero, classHash, addressSalt, callData),
 				ClassHash:           classHash,
@@ -136,6 +165,12 @@ func AdaptTransaction(t *spec.Transaction, network *utils.Network) core.Transact
 			MaxFee:               AdaptFelt(tx.MaxFee),
 			TransactionSignature: adaptAccountSignature(tx.Signature),
 			Nonce:                AdaptFelt(tx.Nonce),
+			// version 3 fields (zero values)
+			ResourceBounds: nil,
+			PaymasterData:  nil,
+			Tip:            0,
+			NonceDAMode:    0,
+			FeeDAMode:      0,
 		}
 		deployAccTx.DeployTransaction.TransactionHash = hash(deployAccTx)
 
@@ -158,6 +193,7 @@ func AdaptTransaction(t *spec.Transaction, network *utils.Network) core.Transact
 		callData := utils.Map(tx.Calldata, AdaptFelt)
 		deployAccTx := &core.DeployAccountTransaction{
 			DeployTransaction: core.DeployTransaction{
+				TransactionHash:     nil, // overridden below
 				ContractAddressSalt: addressSalt,
 				ContractAddress:     core.ContractAddress(&felt.Zero, classHash, addressSalt, callData),
 				ClassHash:           classHash,
@@ -182,21 +218,31 @@ func AdaptTransaction(t *spec.Transaction, network *utils.Network) core.Transact
 	case *spec.Transaction_InvokeV0_:
 		tx := t.GetInvokeV0()
 		invTx := &core.InvokeTransaction{
-			Nonce:                nil, // not used in v0
-			SenderAddress:        nil, // not used in v0
+			TransactionHash:      nil, // overridden below
 			CallData:             utils.Map(tx.Calldata, AdaptFelt),
 			TransactionSignature: adaptAccountSignature(tx.Signature),
 			MaxFee:               AdaptFelt(tx.MaxFee),
 			ContractAddress:      AdaptAddress(tx.Address),
 			Version:              txVersion(0),
 			EntryPointSelector:   AdaptFelt(tx.EntryPointSelector),
+			// version 1 fields (zero values)
+			Nonce:         nil,
+			SenderAddress: nil,
+			// version 3 fields (zero values)
+			ResourceBounds:        nil,
+			Tip:                   0,
+			PaymasterData:         nil,
+			AccountDeploymentData: nil,
+			NonceDAMode:           0,
+			FeeDAMode:             0,
 		}
 		invTx.TransactionHash = hash(invTx)
 
 		return invTx
 	case *spec.Transaction_InvokeV1_:
 		tx := t.GetInvokeV1()
 		invTx := &core.InvokeTransaction{
+			TransactionHash:      nil, // overridden below
 			ContractAddress:      nil, // not used in v1
 			Nonce:                AdaptFelt(tx.Nonce),
 			SenderAddress:        AdaptAddress(tx.Sender),
@@ -205,6 +251,13 @@ func AdaptTransaction(t *spec.Transaction, network *utils.Network) core.Transact
 			MaxFee:               AdaptFelt(tx.MaxFee),
 			Version:              txVersion(1),
 			EntryPointSelector:   nil,
+			// version 3 fields (zero values)
+			ResourceBounds:        nil,
+			Tip:                   0,
+			PaymasterData:         nil,
+			AccountDeploymentData: nil,
+			NonceDAMode:           0,
+			FeeDAMode:             0,
 		}
 		invTx.TransactionHash = hash(invTx)
 
@@ -223,6 +276,7 @@ func AdaptTransaction(t *spec.Transaction, network *utils.Network) core.Transact
 		}
 
 		invTx := &core.InvokeTransaction{
+			TransactionHash:      nil, // overridden below
 			ContractAddress:      nil, // is it ok?
 			CallData:             utils.Map(tx.Calldata, AdaptFelt),
 			TransactionSignature: adaptAccountSignature(tx.Signature),
@@ -236,16 +290,18 @@ func AdaptTransaction(t *spec.Transaction, network *utils.Network) core.Transact
 				core.ResourceL1Gas: adaptResourceLimits(tx.L1Gas),
 				core.ResourceL2Gas: adaptResourceLimits(tx.L2Gas),
 			},
-			PaymasterData: nil, // Todo: P2P needs to change the pay master data to a list
-			NonceDAMode:   core.DataAvailabilityMode(nDAMode),
-			FeeDAMode:     core.DataAvailabilityMode(fDAMode),
+			PaymasterData:         nil, // Todo: P2P needs to change the pay master data to a list
+			NonceDAMode:           core.DataAvailabilityMode(nDAMode),
+			FeeDAMode:             core.DataAvailabilityMode(fDAMode),
+			AccountDeploymentData: nil, // todo(kirill) recheck
 		}
 		invTx.TransactionHash = hash(invTx)
 
 		return invTx
 	case *spec.Transaction_L1Handler:
 		tx := t.GetL1Handler()
 		l1Tx := &core.L1HandlerTransaction{
+			TransactionHash:    nil, // overridden below
 			ContractAddress:    AdaptAddress(tx.Address),
 			EntryPointSelector: AdaptFelt(tx.EntryPointSelector),
 			Nonce:              AdaptFelt(tx.Nonce),

adapters/sn2core/sn2core.go

@@ -67,6 +67,7 @@ func AdaptTransactionReceipt(response *starknet.TransactionReceipt) *core.Transa
 	}
 
 	return &core.TransactionReceipt{
+		FeeUnit:            0, // todo(kirill) recheck
 		Fee:                response.ActualFee,
 		TransactionHash:    response.TransactionHash,
 		Events:             utils.Map(utils.NonNilSlice(response.Events), AdaptEvent),

adapters/vm2core/vm2core.go

@@ -21,9 +21,11 @@ func AdaptExecutionResources(resources *vm.ExecutionResources) *core.ExecutionRe
 			Keccak:       resources.Keccak,
 			Poseidon:     resources.Poseidon,
 			SegmentArena: resources.SegmentArena,
+			Output:       0, // todo(kirill) recheck, add Output field to core?
 		},
-		MemoryHoles: resources.MemoryHoles,
-		Steps:       resources.Steps,
+		MemoryHoles:      resources.MemoryHoles,
+		Steps:            resources.Steps,
+		DataAvailability: adaptDA(resources.DataAvailability),
 	}
 }
 
@@ -56,3 +58,14 @@ func AdaptOrderedEvents(events []vm.OrderedEvent) []*core.Event {
 	})
 	return utils.Map(events, AdaptOrderedEvent)
 }
+
+func adaptDA(da *vm.DataAvailability) *core.DataAvailability {
+	if da == nil {
+		return nil
+	}
+
+	return &core.DataAvailability{
+		L1Gas:     da.L1Gas,
+		L1DataGas: da.L1DataGas,
+	}
+}

p2p/sync.go

@@ -339,8 +339,7 @@ func (s *syncService) adaptAndSanityCheckBlock(ctx context.Context, header *spec
 			})
 			coreBlock.Receipts = coreReceipts
 
-			coreHeader := p2p2core.AdaptBlockHeader(header)
-			coreHeader.Signatures = utils.Map(sig.GetSignatures(), p2p2core.AdaptSignature)
+			coreHeader := p2p2core.AdaptBlockHeader(header, sig.GetSignatures())
 
 			coreBlock.Header = &coreHeader
 			coreBlock.EventsBloom = core.EventsBloom(coreBlock.Receipts)