Refactor: Return by values instead of reference from sn2core.go methods

adapters/p2p2core/class.go

@@ -119,6 +119,6 @@ func createCompiledClass(cairo1 *class.Cairo1Class) (*core.CasmClass, error) {
 	if err != nil {
 		return nil, err
 	}
-
-	return sn2core.AdaptCompiledClass(compiledClass)
+	coreCasmClass, err := sn2core.AdaptCasmClass(compiledClass)
+	return &coreCasmClass, err
 }

adapters/sn2core/sn2core.go

@@ -13,24 +13,24 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 )
 
-func AdaptBlock(response *starknet.Block, sig *starknet.Signature) (*core.Block, error) {
+func AdaptBlock(response *starknet.Block, sig *starknet.Signature) (core.Block, error) {
 	if response == nil {
-		return nil, errors.New("nil client block")
+		return core.Block{}, errors.New("nil client block")
 	}
 
 	txns := make([]core.Transaction, len(response.Transactions))
 	for i := range response.Transactions {
 		var err error
 		txns[i], err = AdaptTransaction(response.Transactions[i])
 		if err != nil {
-			return nil, err
+			return core.Block{}, err
 		}
 	}
 
 	receipts := make([]*core.TransactionReceipt, len(response.Receipts))
 	eventCount := uint64(0)
 	for i := range response.Receipts {
-		receipts[i] = AdaptTransactionReceipt(response.Receipts[i])
+		receipts[i] = utils.HeapPtr(AdaptTransactionReceipt(response.Receipts[i]))
 		eventCount += uint64(len(response.Receipts[i].Events))
 	}
 
@@ -39,7 +39,7 @@ func AdaptBlock(response *starknet.Block, sig *starknet.Signature) (*core.Block,
 		sigs = append(sigs, sig.Signature)
 	}
 
-	return &core.Block{
+	return core.Block{
 		Header: &core.Header{
 			Hash:             response.Hash,
 			ParentHash:       response.ParentHash,
@@ -63,71 +63,78 @@ func AdaptBlock(response *starknet.Block, sig *starknet.Signature) (*core.Block,
 	}, nil
 }
 
-func AdaptTransactionReceipt(response *starknet.TransactionReceipt) *core.TransactionReceipt {
+func AdaptTransactionReceipt(response *starknet.TransactionReceipt) core.TransactionReceipt {
 	if response == nil {
-		return nil
+		return core.TransactionReceipt{} //nolint:exhaustruct // returning empty object
+	}
+
+	events := make([]*core.Event, len(response.Events))
+	for i := range response.Events {
+		events[i] = utils.HeapPtr(AdaptEvent(response.Events[i]))
 	}
 
-	return &core.TransactionReceipt{
+	l2ToL1Messages := make([]*core.L2ToL1Message, len(response.L2ToL1Message))
+	for i := range response.L2ToL1Message {
+		l2ToL1Messages[i] = utils.HeapPtr(AdaptL2ToL1Message(response.L2ToL1Message[i]))
+	}
+
+	return core.TransactionReceipt{
 		FeeUnit:            0, // todo(kirill) recheck
 		Fee:                response.ActualFee,
 		TransactionHash:    response.TransactionHash,
-		Events:             utils.Map(utils.NonNilSlice(response.Events), AdaptEvent),
-		ExecutionResources: AdaptExecutionResources(response.ExecutionResources),
-		L1ToL2Message:      AdaptL1ToL2Message(response.L1ToL2Message),
-		L2ToL1Message: utils.Map(
-			utils.NonNilSlice(response.L2ToL1Message),
-			AdaptL2ToL1Message,
-		),
-		Reverted:     response.ExecutionStatus == starknet.Reverted,
-		RevertReason: response.RevertError,
+		Events:             events,
+		ExecutionResources: utils.HeapPtr(AdaptExecutionResources(response.ExecutionResources)),
+		L1ToL2Message:      utils.HeapPtr(AdaptL1ToL2Message(response.L1ToL2Message)),
+		L2ToL1Message:      l2ToL1Messages,
+		Reverted:           response.ExecutionStatus == starknet.Reverted,
+		RevertReason:       response.RevertError,
 	}
 }
 
-func adaptGasConsumed(response *starknet.GasConsumed) *core.GasConsumed {
+func adaptGasConsumed(response *starknet.GasConsumed) core.GasConsumed {
 	if response == nil {
-		return nil
+		return core.GasConsumed{} //nolint:exhaustruct // returning empty object
 	}
 
-	return &core.GasConsumed{
+	return core.GasConsumed{
 		L1Gas:     response.L1Gas,
 		L1DataGas: response.L1DataGas,
 		L2Gas:     response.L2Gas,
 	}
 }
 
-func AdaptEvent(response *starknet.Event) *core.Event {
+func AdaptEvent(response *starknet.Event) core.Event {
 	if response == nil {
-		return nil
+		return core.Event{} //nolint:exhaustruct // returning empty object
 	}
 
-	return &core.Event{
+	return core.Event{
 		Data: response.Data,
 		From: response.From,
 		Keys: response.Keys,
 	}
 }
 
-func AdaptExecutionResources(response *starknet.ExecutionResources) *core.ExecutionResources {
+func AdaptExecutionResources(response *starknet.ExecutionResources) core.ExecutionResources {
 	if response == nil {
-		return nil
+		return core.ExecutionResources{} //nolint:exhaustruct // returning empty object
 	}
 
-	return &core.ExecutionResources{
+	return core.ExecutionResources{
 		BuiltinInstanceCounter: core.BuiltinInstanceCounter(response.BuiltinInstanceCounter),
 		MemoryHoles:            response.MemoryHoles,
 		Steps:                  response.Steps,
 		DataAvailability:       (*core.DataAvailability)(response.DataAvailability),
-		TotalGasConsumed:       adaptGasConsumed(response.TotalGasConsumed),
+		TotalGasConsumed:       utils.HeapPtr(adaptGasConsumed(response.TotalGasConsumed)),
 	}
 }
 
-func AdaptL1ToL2Message(response *starknet.L1ToL2Message) *core.L1ToL2Message {
+func AdaptL1ToL2Message(response *starknet.L1ToL2Message) core.L1ToL2Message {
 	if response == nil {
-		return nil
+		return core.L1ToL2Message{} //nolint:exhaustruct // returning empty object
 	}
 
-	return &core.L1ToL2Message{
+	return core.L1ToL2Message{
 		From:     common.HexToAddress(response.From),
 		Nonce:    response.Nonce,
 		Payload:  response.Payload,
@@ -136,12 +143,12 @@ func AdaptL1ToL2Message(response *starknet.L1ToL2Message) *core.L1ToL2Message {
 	}
 }
 
-func AdaptL2ToL1Message(response *starknet.L2ToL1Message) *core.L2ToL1Message {
+func AdaptL2ToL1Message(response *starknet.L2ToL1Message) core.L2ToL1Message {
 	if response == nil {
-		return nil
+		return core.L2ToL1Message{} //nolint:exhaustruct // returning empty object
 	}
 
-	return &core.L2ToL1Message{
+	return core.L2ToL1Message{
 		From:    response.From,
 		Payload: response.Payload,
 		To:      common.HexToAddress(response.To),
@@ -316,7 +323,7 @@ func AdaptSierraClass(
 		return nil, errors.New("sierra program size is too small")
 	}
 
-	coreCompiledClass, err := AdaptCompiledClass(compiledClass)
+	coreCompiledClass, err := AdaptCasmClass(compiledClass)
 	if err != nil {
 		return nil, err
 	}
@@ -329,15 +336,15 @@ func AdaptSierraClass(
 		Abi:     response.Abi,
 		AbiHash: crypto.StarknetKeccak([]byte(response.Abi)),
 
-		Compiled: coreCompiledClass,
+		Compiled: &coreCompiledClass,
 
 		EntryPoints: adaptSierraEntrypoints(&response.EntryPoints),
 	}, nil
 }
 
-func AdaptCompiledClass(compiledClass *starknet.CasmClass) (*core.CasmClass, error) {
+func AdaptCasmClass(compiledClass *starknet.CasmClass) (core.CasmClass, error) {
 	if compiledClass == nil {
-		return nil, nil
+		return core.CasmClass{}, nil //nolint:exhaustruct // returning empty object
 	}
 
 	var casm core.CasmClass
@@ -350,15 +357,15 @@ func AdaptCompiledClass(compiledClass *starknet.CasmClass) (*core.CasmClass, err
 	var ok bool
 	casm.Prime, ok = new(big.Int).SetString(compiledClass.Prime, 0)
 	if !ok {
-		return nil, fmt.Errorf("couldn't convert prime value to big.Int: %d", casm.Prime)
+		return core.CasmClass{}, fmt.Errorf("couldn't convert prime value to big.Int: %d", casm.Prime)
 	}
 
 	entryPoints := compiledClass.EntryPoints
 	casm.External = utils.Map(entryPoints.External, adaptCompiledEntryPoint)
 	casm.L1Handler = utils.Map(entryPoints.L1Handler, adaptCompiledEntryPoint)
 	casm.Constructor = utils.Map(entryPoints.Constructor, adaptCompiledEntryPoint)
 
-	return &casm, nil
+	return casm, nil
 }
 
 func AdaptSegmentLengths(l starknet.SegmentLengths) core.SegmentLengths {
@@ -403,13 +410,13 @@ func AdaptDeprecatedCairoClass(
 	return class, nil
 }
 
-func AdaptStateUpdate(response *starknet.StateUpdate) (*core.StateUpdate, error) {
+func AdaptStateUpdate(response *starknet.StateUpdate) (core.StateUpdate, error) {
 	stateDiff, err := AdaptStateDiff(&response.StateDiff)
 	if err != nil {
-		return nil, err
+		return core.StateUpdate{}, err
 	}
 
-	return &core.StateUpdate{
+	return core.StateUpdate{
 		BlockHash: response.BlockHash,
 		NewRoot:   response.NewRoot,
 		OldRoot:   response.OldRoot,
@@ -525,7 +532,7 @@ func AdaptPreConfirmedBlock(
 				return core.PreConfirmed{}, err
 			}
 			txStateDiffs[preIdx] = &stateDiff
-			receipts[preIdx] = AdaptTransactionReceipt(response.Receipts[i])
+			receipts[preIdx] = utils.HeapPtr(AdaptTransactionReceipt(response.Receipts[i]))
 			eventCount += uint64(len(response.Receipts[i].Events))
 			preIdx++
 		} else {

adapters/sn2core/sn2core_test.go

@@ -627,9 +627,9 @@ func TestClassV1(t *testing.T) {
 }
 
 func TestAdaptCompiledClass(t *testing.T) {
-	result, err := sn2core.AdaptCompiledClass(nil)
+	result, err := sn2core.AdaptCasmClass(nil)
 	require.NoError(t, err)
-	assert.Nil(t, result)
+	assert.Empty(t, result)
 }
 
 func TestAdaptPreConfirmed(t *testing.T) {

migration/migration.go

@@ -781,15 +781,15 @@ func migrateCairo1CompiledClass2(txn db.KeyValueWriter, key, value []byte, _ *ut
 		return err
 	}
 
-	var casmClass *core.CasmClass
+	var casmClass core.CasmClass
 	if deprecated, _ := starknet.IsDeprecatedCompiledClassDefinition(class.Class.Compiled); !deprecated {
 		var starknetCompiledClass starknet.CasmClass
 		err = json.Unmarshal(class.Class.Compiled, &starknetCompiledClass)
 		if err != nil {
 			return err
 		}
 
-		casmClass, err = sn2core.AdaptCompiledClass(&starknetCompiledClass)
+		casmClass, err = sn2core.AdaptCasmClass(&starknetCompiledClass)
 		if err != nil {
 			return err
 		}
@@ -804,7 +804,7 @@ func migrateCairo1CompiledClass2(txn db.KeyValueWriter, key, value []byte, _ *ut
 			Program:         class.Class.Program,
 			ProgramHash:     class.Class.ProgramHash,
 			SemanticVersion: class.Class.SemanticVersion,
-			Compiled:        casmClass,
+			Compiled:        &casmClass,
 		},
 	}
 

migration/migration_pkg_test.go

@@ -345,7 +345,7 @@ func TestMigrateCairo1CompiledClass(t *testing.T) {
 		if test.checkCompiledExists {
 			assert.NotNil(t, actualClass.Compiled)
 		} else {
-			assert.Nil(t, actualClass.Compiled)
+			assert.Empty(t, actualClass.Compiled)
 		}
 	}
 }

starknet/compiler/compiler_test.go

@@ -31,13 +31,13 @@ func TestCompile(t *testing.T) {
 		compiledDef, err := cl.CasmClassDefinition(t.Context(), classHash)
 		require.NoError(t, err)
 
-		expectedCompiled, err := sn2core.AdaptCompiledClass(compiledDef)
+		expectedCompiled, err := sn2core.AdaptCasmClass(compiledDef)
 		require.NoError(t, err)
 
 		res, err := compiler.Compile(classDef.Sierra)
 		require.NoError(t, err)
 
-		gotCompiled, err := sn2core.AdaptCompiledClass(res)
+		gotCompiled, err := sn2core.AdaptCasmClass(res)
 		require.NoError(t, err)
 		assert.Equal(t, expectedCompiled.Hash(), gotCompiled.Hash())
 	})

starknetdata/feeder/feeder.go

@@ -66,8 +66,8 @@ func (f *Feeder) block(ctx context.Context, blockID string) (*core.Block, error)
 			return nil, fmt.Errorf("get signature for block %q: %v", blockID, err)
 		}
 	}
-
-	return sn2core.AdaptBlock(response, sig)
+	adaptedBlock, err := sn2core.AdaptBlock(response, sig)
+	return &adaptedBlock, err
 }
 
 // Transaction gets the transaction for a given transaction hash from the feeder,
@@ -113,8 +113,8 @@ func (f *Feeder) stateUpdate(ctx context.Context, blockID string) (*core.StateUp
 	if err != nil {
 		return nil, err
 	}
-
-	return sn2core.AdaptStateUpdate(response)
+	coreStateUpdate, err := sn2core.AdaptStateUpdate(response)
+	return &coreStateUpdate, err
 }
 
 // StateUpdate gets the state update for a given block number from the feeder,
@@ -147,8 +147,8 @@ func (f *Feeder) stateUpdateWithBlock(ctx context.Context, blockID string) (*cor
 		}
 	}
 
-	var adaptedState *core.StateUpdate
-	var adaptedBlock *core.Block
+	var adaptedState core.StateUpdate
+	var adaptedBlock core.Block
 
 	if adaptedState, err = sn2core.AdaptStateUpdate(response.StateUpdate); err != nil {
 		return nil, nil, err
@@ -158,7 +158,7 @@ func (f *Feeder) stateUpdateWithBlock(ctx context.Context, blockID string) (*cor
 		return nil, nil, err
 	}
 
-	return adaptedState, adaptedBlock, nil
+	return &adaptedState, &adaptedBlock, nil
 }
 
 // StateUpdatePendingWithBlock gets both pending state update and pending block from the feeder,