feat: Blake2s implementation (#821)

* chore: upgrade juno module to use the blake2s implementation

* fix: compiler error due to juno module upgrade

* feat: add Blake2s hash functions

- Implemented Blake2s and Blake2sArray functions for hashing felt.Felt pointers.

* refactor: update compiledClassHash functions logic + new method for blake hash

- Introduced CompiledClassHashV2 for using the Blake2s hash function to generate Compiled Clash Hashes
- Make a compiledClassHash function that accepts a hash function as a parameter, and use it for the CompiledClassHash and CompiledClassHashV2 functions.

* refactor: simplify bytecode segment hashing logic + accept hashFunc param

-  Adds a new hashFunc param to make the function work with any hash function specified.
- Adjusted return values in hashCasmClassByteCode to return the computed hash instead of a function.

* test: enhance ClassHashes tests to include CompiledClassHashV2

* feat: add support for Blake2s hash in BuildDeclareTxn

- Introduced the UseBlake2sHash option in TxnOptions to allow selection of the Blake2s hash function for compiled class hash calculation.
- Updated BuildDeclareTxn to conditionally use Blake2s or the default hash function based on the new option.
- Added unit tests to validate the behavior of BuildDeclareTxn with both hash options.

* feat: implement support for dynamic hash selection in transaction methods

- Added the shouldUseBlake2sHash function to determine if the Blake2s hash function should be used for compiled class hashes based on the Starknet version.
- Updated BuildAndSendDeclareTxn and other transaction methods to utilize the new hash selection logic.
- Introduced unit tests for BuildAndSendDeclareTxn to validate behavior with different Starknet versions and their corresponding compiled class hashes.

* feat: enhance BuildAndSendDeclareTxn with TxnOptions for Blake2s hash selection

- Updated TxnOptions to accept a new UseBlake2sHash field, allowing users to specify whether to use the Blake2s hash function for compiled class hash calculation.
- Modified the logic to determine the hash function based on the provided options or default to fetching the Starknet version.
- Enhanced unit tests to cover various scenarios for hash selection based on Starknet versions and TxnOptions.

* test: fix TestBuildAndSendMethodsWithQueryBit test

* chore: use new Juno felt constructors

* chore: upgrade Juno version to v0.15.11

* refactor: update hash function calls to use curve package

- Modified hash function implementations in curve.go to return pointers to the computed hashes.
- Updated references in hash.go to utilize the new curve functions for Poseidon and Pedersen hashes, ensuring consistency across the codebase.

* chore: update changelog

Author: thiagodeev

CHANGELOG.md

@@ -15,6 +15,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Security
 -->
 
+### Added
+- curve pkg:
+  - new `Blake2s` and `Blake2sArray` functions.
+- hash pkg:
+  - new `CompiledClassHashV2` function to compute the compiled class hash using the Blake2s hash function.
+- utils pkg:
+  - new `UseBlake2sHash` param in the `TxnOptions` struct to be used by the `BuildDeclareTxn` function.
+- account pkg:
+  - new `UseBlake2sHash` param in the `TxnOptions` struct to be used by the `BuildAndSendDeclareTxn` method.
+
+### Changed
+- In the `account.BuildAndSendDeclareTxn` method, if the new `opts.UseBlake2sHash` param is nil,
+Starknet.go will automatically fetch the current Starknet version and decide
+whether to use the Blake2s hash function.
+
 ## [0.17.0](https://github.com/NethermindEth/starknet.go/releases/tag/v0.17.0) - 2025-11-06
 ### Added
 - New `paymaster` pkg for interacting with paymaster services via the SNIP-29 API.

account/transaction.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/Masterminds/semver/v3"
 	"github.com/NethermindEth/juno/core/felt"
 	"github.com/NethermindEth/starknet.go/client/rpcerr"
 	"github.com/NethermindEth/starknet.go/contracts"
@@ -59,8 +60,9 @@ func (account *Account) BuildAndSendInvokeTxn(
 		callData,
 		makeResourceBoundsMapWithZeroValues(),
 		&utils.TxnOptions{
-			Tip:         tip,
-			UseQueryBit: opts.UseQueryBit,
+			Tip:            tip,
+			UseQueryBit:    opts.UseQueryBit,
+			UseBlake2sHash: false,
 		},
 	)
 
@@ -138,6 +140,16 @@ func (account *Account) BuildAndSendDeclareTxn(
 		return response, err
 	}
 
+	var useBlake2sHash bool
+	if opts.UseBlake2sHash == nil {
+		useBlake2sHash, err = shouldUseBlake2sHash(ctx, account.Provider)
+		if err != nil {
+			return response, fmt.Errorf("failed to check whether to use Blake2s hash: %w", err)
+		}
+	} else {
+		useBlake2sHash = *opts.UseBlake2sHash
+	}
+
 	// building and signing the txn, as it needs a signature to estimate the fee
 	broadcastDeclareTxnV3, err := utils.BuildDeclareTxn(
 		account.Address,
@@ -146,8 +158,9 @@ func (account *Account) BuildAndSendDeclareTxn(
 		nonce,
 		makeResourceBoundsMapWithZeroValues(),
 		&utils.TxnOptions{
-			Tip:         tip,
-			UseQueryBit: opts.UseQueryBit,
+			Tip:            tip,
+			UseQueryBit:    opts.UseQueryBit,
+			UseBlake2sHash: useBlake2sHash,
 		},
 	)
 	if err != nil {
@@ -239,8 +252,9 @@ func (account *Account) BuildAndEstimateDeployAccountTxn(
 		classHash,
 		makeResourceBoundsMapWithZeroValues(),
 		&utils.TxnOptions{
-			Tip:         tip,
-			UseQueryBit: opts.UseQueryBit,
+			Tip:            tip,
+			UseQueryBit:    opts.UseQueryBit,
+			UseBlake2sHash: false,
 		},
 	)
 
@@ -465,3 +479,35 @@ func (account *Account) WaitForTransactionReceipt(
 		}
 	}
 }
+
+// shouldUseBlake2sHash determines whether to use the Blake2s hash function for the
+// compiled class hash.
+// Starknet v0.14.1 upgrade will deprecate the Poseidon hash function for the compiled class hash.
+//
+// Parameters:
+//   - ctx: The context
+//   - provider: The provider
+//
+// Returns:
+//   - bool: whether to use the Blake2s hash function for the compiled class hash
+//   - error: an error if any
+func shouldUseBlake2sHash(ctx context.Context, provider rpc.RPCProvider) (bool, error) {
+	block, err := provider.BlockWithTxHashes(ctx, rpc.WithBlockTag(rpc.BlockTagLatest))
+	if err != nil {
+		return false, fmt.Errorf("failed to get block with tx hashes: %w", err)
+	}
+
+	blockTxHashes, ok := block.(*rpc.BlockTxHashes)
+	if !ok {
+		return false, fmt.Errorf("block is not a BlockTxHashes: %T", block)
+	}
+
+	upgradeVersion := semver.MustParse("0.14.1")
+
+	currentVersion, err := semver.NewVersion(blockTxHashes.StarknetVersion)
+	if err != nil {
+		return false, fmt.Errorf("failed to parse block's starknet version: %w", err)
+	}
+
+	return currentVersion.Compare(upgradeVersion) >= 0, nil
+}

account/transaction_test.go

@@ -130,6 +130,155 @@ func TestBuildAndSendDeclareTxn(t *testing.T) {
 	assert.NotEqual(t, "0x0", txn.Transaction.(rpc.DeclareTxnV3).Tip)
 }
 
+func TestBuildAndSendDeclareTxnMock(t *testing.T) {
+	tests.RunTestOn(t, tests.MockEnv)
+
+	// Class
+	class := *internalUtils.TestUnmarshalJSONFileToType[contracts.ContractClass](
+		t,
+		"./testData/contracts_v2_HelloStarknet.sierra.json",
+		"",
+	)
+	// Casm Class
+	casmClass := *internalUtils.TestUnmarshalJSONFileToType[contracts.CasmClass](
+		t,
+		"./testData/contracts_v2_HelloStarknet.casm.json",
+		"",
+	)
+
+	t.Run("compiled class hash", func(t *testing.T) {
+		testcases := []struct {
+			name                     string
+			txnOptions               *account.TxnOptions
+			starknetVersion          string
+			expectedCompileClassHash string
+		}{
+			{
+				name:                     "before 0.14.1",
+				txnOptions:               nil,
+				starknetVersion:          "0.14.0",
+				expectedCompileClassHash: "0x6ff9f7df06da94198ee535f41b214dce0b8bafbdb45e6c6b09d4b3b693b1f17",
+			},
+			{
+				name: "before 0.14.1 + UseBlake2sHash true",
+				txnOptions: &account.TxnOptions{
+					UseBlake2sHash: &[]bool{true}[0],
+				},
+				starknetVersion:          "0.14.0",
+				expectedCompileClassHash: "0x23c2091df2547f77185ba592b06ee2e897b0c2a70f968521a6a24fc5bfc1b1e",
+			},
+			{
+				name: "before 0.14.1 + UseBlake2sHash false",
+				txnOptions: &account.TxnOptions{
+					UseBlake2sHash: &[]bool{false}[0],
+				},
+				starknetVersion:          "0.14.0",
+				expectedCompileClassHash: "0x6ff9f7df06da94198ee535f41b214dce0b8bafbdb45e6c6b09d4b3b693b1f17",
+			},
+			{
+				name:                     "after 0.14.1",
+				txnOptions:               nil,
+				starknetVersion:          "0.14.1",
+				expectedCompileClassHash: "0x23c2091df2547f77185ba592b06ee2e897b0c2a70f968521a6a24fc5bfc1b1e",
+			},
+			{
+				name: "after 0.14.1 + UseBlake2sHash true",
+				txnOptions: &account.TxnOptions{
+					UseBlake2sHash: &[]bool{true}[0],
+				},
+				starknetVersion:          "0.14.1",
+				expectedCompileClassHash: "0x23c2091df2547f77185ba592b06ee2e897b0c2a70f968521a6a24fc5bfc1b1e",
+			},
+			{
+				name: "after 0.14.1 + UseBlake2sHash false",
+				txnOptions: &account.TxnOptions{
+					UseBlake2sHash: &[]bool{false}[0],
+				},
+				starknetVersion:          "0.14.1",
+				expectedCompileClassHash: "0x6ff9f7df06da94198ee535f41b214dce0b8bafbdb45e6c6b09d4b3b693b1f17",
+			},
+		}
+
+		for _, test := range testcases {
+			t.Run(test.name, func(t *testing.T) {
+				ctrl := gomock.NewController(t)
+				mockRPCProvider := mocks.NewMockRPCProvider(ctrl)
+
+				ks, pub, _ := account.GetRandomKeys()
+				// called when instantiating the account
+				mockRPCProvider.EXPECT().ChainID(gomock.Any()).Return("SN_SEPOLIA", nil).Times(1)
+				acnt, err := account.NewAccount(
+					mockRPCProvider,
+					internalUtils.DeadBeef,
+					pub.String(),
+					ks,
+					account.CairoV2,
+				)
+				require.NoError(t, err)
+
+				// called in the BuildAndSendDeclareTxn method
+				mockRPCProvider.EXPECT().
+					Nonce(gomock.Any(), gomock.Any(), gomock.Any()).
+					Return(new(felt.Felt).SetUint64(1), nil).
+					Times(1)
+				mockRPCProvider.EXPECT().
+					BlockWithTxs(t.Context(), rpc.WithBlockTag(rpc.BlockTagLatest)).
+					Return(&rpc.Block{}, nil).Times(1)
+				mockRPCProvider.EXPECT().
+					EstimateFee(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
+					Return([]rpc.FeeEstimation{
+						{
+							FeeEstimationCommon: rpc.FeeEstimationCommon{
+								L1GasPrice:        new(felt.Felt).SetUint64(10),
+								L1GasConsumed:     new(felt.Felt).SetUint64(100),
+								L1DataGasPrice:    new(felt.Felt).SetUint64(5),
+								L1DataGasConsumed: new(felt.Felt).SetUint64(50),
+								L2GasPrice:        new(felt.Felt).SetUint64(3),
+								L2GasConsumed:     new(felt.Felt).SetUint64(200),
+							},
+						},
+					}, nil).
+					Times(1)
+
+				var compiledClassHash *felt.Felt
+
+				if test.txnOptions == nil {
+					// if txnOptions is nil, the code should call the BlockWithTxHashes method to get the
+					// Starknet version and decide whether to use the Blake2s hash function
+					mockRPCProvider.EXPECT().
+						BlockWithTxHashes(gomock.Any(), rpc.WithBlockTag(rpc.BlockTagLatest)).
+						Return(&rpc.BlockTxHashes{
+							BlockHeader: rpc.BlockHeader{StarknetVersion: test.starknetVersion},
+						}, nil).Times(1)
+				}
+
+				mockRPCProvider.EXPECT().
+					AddDeclareTransaction(gomock.Any(), gomock.Any()).
+					DoAndReturn(
+						func(_, txn any) (rpc.AddDeclareTransactionResponse, error) {
+							declareTxn, ok := txn.(*rpc.BroadcastDeclareTxnV3)
+							require.True(t, ok)
+
+							compiledClassHash = declareTxn.CompiledClassHash
+
+							return rpc.AddDeclareTransactionResponse{}, nil
+						},
+					).Times(1)
+
+				_, err = acnt.BuildAndSendDeclareTxn(
+					t.Context(),
+					&casmClass,
+					&class,
+					test.txnOptions,
+				)
+				require.NoError(t, err)
+
+				assert.Equal(t, test.expectedCompileClassHash, compiledClassHash.String())
+			})
+		}
+	})
+}
+
 // BuildAndEstimateDeployAccountTxn is a test function that tests the BuildAndSendDeployAccount method.
 //
 // This function tests the BuildAndSendDeployAccount method by setting up test data and invoking the method with different test sets.
@@ -411,6 +560,11 @@ func TestBuildAndSendMethodsWithQueryBit(t *testing.T) {
 		})
 
 		t.Run("BuildAndSendDeclareTxn", func(t *testing.T) {
+			mockRPCProvider.EXPECT().
+				BlockWithTxHashes(gomock.Any(), rpc.WithBlockTag(rpc.BlockTagLatest)).
+				Return(&rpc.BlockTxHashes{
+					BlockHeader: rpc.BlockHeader{StarknetVersion: "0.14.1"},
+				}, nil).Times(1)
 			mockRPCProvider.EXPECT().AddDeclareTransaction(gomock.Any(), gomock.Any()).DoAndReturn(
 				func(_, txn any) (rpc.AddDeclareTransactionResponse, error) {
 					bcTxn, ok := txn.(*rpc.BroadcastDeclareTxnV3)

account/txn_options.go

@@ -45,6 +45,14 @@ type TxnOptions struct {
 	UseLatest bool
 	// The simulation flag to be used when estimating fees. Default: none.
 	SimulationFlag rpc.SimulationFlag
+
+	// ONLY FOR THE `BuildAndSendDeclareTxn` METHOD: A pointer to a boolean flag
+	// indicating whether to use the Blake2s hash function to calculate the compiled
+	// class hash.
+	// If omitted (nil), Starknet.go will automatically fetch the current Starknet
+	// version and decide whether to use the Blake2s hash function.
+	UseBlake2sHash *bool
+	// TODO: remove this field after the Starknet v0.14.1 upgrade
 }
 
 // BlockID returns the block ID for fee estimation based on the UseLatest flag.

curve/curve.go

@@ -7,6 +7,7 @@ import (
 	"math/big"
 
 	junoCrypto "github.com/NethermindEth/juno/core/crypto"
+	"github.com/NethermindEth/juno/core/crypto/blake2s"
 	"github.com/NethermindEth/juno/core/felt"
 	internalUtils "github.com/NethermindEth/starknet.go/internal/utils"
 	starkcurve "github.com/consensys/gnark-crypto/ecc/stark-curve"
@@ -243,7 +244,9 @@ func ComputeHashOnElements(elems []*big.Int) (hash *big.Int) {
 // Returns:
 //   - *felt.Felt: a pointer to a felt.Felt storing the resulting hash.
 func Pedersen(a, b *felt.Felt) *felt.Felt {
-	return junoCrypto.Pedersen(a, b)
+	hash := junoCrypto.Pedersen(a, b)
+
+	return &hash
 }
 
 // Poseidon is a function that implements the Poseidon hash.
@@ -255,7 +258,24 @@ func Pedersen(a, b *felt.Felt) *felt.Felt {
 // Returns:
 //   - *felt.Felt: a pointer to a felt.Felt storing the resulting hash.
 func Poseidon(a, b *felt.Felt) *felt.Felt {
-	return junoCrypto.Poseidon(a, b)
+	hash := junoCrypto.Poseidon(a, b)
+
+	return &hash
+}
+
+// Blake2s is a function that implements the Blake2s hash.
+//
+// Parameters:
+//   - a: a pointers to felt.Felt to be hashed.
+//   - b: a pointers to felt.Felt to be hashed.
+//
+// Returns:
+//   - *felt.Felt: a pointer to a felt.Felt storing the resulting hash.
+func Blake2s(a, b *felt.Felt) *felt.Felt {
+	hash := blake2s.Blake2s(a, b)
+	hashFelt := felt.Felt(hash)
+
+	return &hashFelt
 }
 
 // PedersenArray is a function that takes a variadic number of felt.Felt
@@ -268,7 +288,9 @@ func Poseidon(a, b *felt.Felt) *felt.Felt {
 // Returns:
 //   - *felt.Felt: pointer to a felt.Felt
 func PedersenArray(felts ...*felt.Felt) *felt.Felt {
-	return junoCrypto.PedersenArray(felts...)
+	hash := junoCrypto.PedersenArray(felts...)
+
+	return &hash
 }
 
 // PoseidonArray is a function that takes a variadic number of felt.Felt
@@ -281,7 +303,25 @@ func PedersenArray(felts ...*felt.Felt) *felt.Felt {
 // Returns:
 //   - *felt.Felt: pointer to a felt.Felt
 func PoseidonArray(felts ...*felt.Felt) *felt.Felt {
-	return junoCrypto.PoseidonArray(felts...)
+	hash := junoCrypto.PoseidonArray(felts...)
+
+	return &hash
+}
+
+// Blake2sArray is a function that takes a variadic number of felt.Felt
+// pointers as parameters and calls the Blake2sArray function from the
+// junoCrypto package with the provided parameters.
+//
+// Parameters:
+//   - felts: A variadic number of pointers to felt.Felt
+//
+// Returns:
+//   - *felt.Felt: pointer to a felt.Felt
+func Blake2sArray(felts ...*felt.Felt) *felt.Felt {
+	hash := blake2s.Blake2sArray(felts...)
+	hashFelt := felt.Felt(hash)
+
+	return &hashFelt
 }
 
 // StarknetKeccak computes the Starknet Keccak hash of the given byte slice.
@@ -293,7 +333,9 @@ func PoseidonArray(felts ...*felt.Felt) *felt.Felt {
 //   - *felt.Felt: pointer to a felt.Felt
 //   - error: An error if any
 func StarknetKeccak(b []byte) *felt.Felt {
-	return junoCrypto.StarknetKeccak(b)
+	hash := junoCrypto.StarknetKeccak(b)
+
+	return &hash
 }
 
 // fmtPrivKey formats a private key to a 32 bytes array by padding it