test: add unit tests

Signed-off-by: dosi <dosi.kolev@limechain.tech>

Author: Dosik13

sdk/authorization_unit_test.go

@@ -0,0 +1,85 @@
+//go:build all || unit
+
+package hiero
+
+// SPDX-License-Identifier: Apache-2.0
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestUnitAuthorizationGettersSetters(t *testing.T) {
+	t.Parallel()
+
+	chainId := []byte{0x01, 0x2a}
+	addr := []byte{0xAA, 0xBB}
+	r := []byte{0x11}
+	s := []byte{0x22}
+
+	auth := NewAuthorization(chainId, addr, 5, 1, r, s)
+
+	assert.Equal(t, chainId, auth.GetChainId())
+	assert.Equal(t, addr, auth.GetAddress())
+	assert.Equal(t, uint64(5), auth.GetNonce())
+	assert.Equal(t, uint32(1), auth.GetYParity())
+	assert.Equal(t, r, auth.GetR())
+	assert.Equal(t, s, auth.GetS())
+
+	auth.SetChainId([]byte{0x09}).
+		SetAddress([]byte{0xCC}).
+		SetNonce(7).
+		SetYParity(0).
+		SetR([]byte{0x33}).
+		SetS([]byte{0x44})
+
+	assert.Equal(t, []byte{0x09}, auth.GetChainId())
+	assert.Equal(t, []byte{0xCC}, auth.GetAddress())
+	assert.Equal(t, uint64(7), auth.GetNonce())
+	assert.Equal(t, uint32(0), auth.GetYParity())
+	assert.Equal(t, []byte{0x33}, auth.GetR())
+	assert.Equal(t, []byte{0x44}, auth.GetS())
+}
+
+func TestUnitAuthorizationString(t *testing.T) {
+	t.Parallel()
+
+	auth := NewAuthorization([]byte{0xab, 0xcd}, []byte{0xde}, 3, 1, []byte{0x11}, []byte{0x22})
+	str := auth.String()
+	assert.Contains(t, str, "ChainId:")
+	assert.Contains(t, str, "abcd")
+	assert.Contains(t, str, "Nonce: 3")
+	assert.Contains(t, str, "YParity: 1")
+}
+
+func TestUnitAuthorizationRLPRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	auth := NewAuthorization([]byte{0x01, 0x2a}, make([]byte, 20), 5, 1, make([]byte, 32), make([]byte, 32))
+
+	encoded, err := auth._toRLPItem().Write()
+	require.NoError(t, err)
+
+	item := NewRLPItem(LIST_TYPE)
+	require.NoError(t, item.Read(encoded))
+
+	decoded, err := _authorizationFromRLPItem(item)
+	require.NoError(t, err)
+	assert.Equal(t, auth, decoded)
+}
+
+func TestUnitAuthorizationFromRLPItemErrors(t *testing.T) {
+	t.Parallel()
+
+	// Not a list.
+	_, err := _authorizationFromRLPItem(NewRLPItem(VALUE_TYPE).AssignValue([]byte{0x01}))
+	assert.Error(t, err)
+
+	// A list, but not 6 elements.
+	short := NewRLPItem(LIST_TYPE)
+	short.PushBack(NewRLPItem(VALUE_TYPE).AssignValue([]byte{0x01}))
+	_, err = _authorizationFromRLPItem(short)
+	assert.Error(t, err)
+}

sdk/ethereum_eip7702_transaction_unit_test.go

@@ -77,10 +77,10 @@ func TestUnitEthereumEIP7702AuthorizationList(t *testing.T) {
 	t.Parallel()
 
 	to, _ := hex.DecodeString("000000000000000000000000000000000000041d")
-	auth1 := AuthorizationTuple{{0x01, 0x2a}, to, {0x00}, {0x00}, make([]byte, 32), make([]byte, 32)}
-	auth2 := AuthorizationTuple{{0x01, 0x2a}, to, {0x01}, {0x01}, make([]byte, 32), make([]byte, 32)}
+	auth1 := NewAuthorization([]byte{0x01, 0x2a}, to, 0, 0, make([]byte, 32), make([]byte, 32))
+	auth2 := NewAuthorization([]byte{0x01, 0x2a}, to, 1, 1, make([]byte, 32), make([]byte, 32))
 
-	tx := (&EthereumEIP7702Transaction{}).SetAuthorizationList([]AuthorizationTuple{auth1})
+	tx := (&EthereumEIP7702Transaction{}).SetAuthorizationList([]Authorization{auth1})
 	require.Equal(t, 1, len(tx.GetAuthorizationList()))
 
 	tx.AddAuthorization(auth2)
@@ -101,8 +101,8 @@ func TestUnitEthereumEIP7702ToBytesRoundTripWithAuthList(t *testing.T) {
 	t.Parallel()
 
 	to, _ := hex.DecodeString("000000000000000000000000000000000000041d")
-	// Canonical (non-zero / minimal) field bytes so the RLP round-trip is exact.
-	auth := AuthorizationTuple{{0x01, 0x2a}, to, {0x05}, {0x01}, make([]byte, 32), make([]byte, 32)}
+	// Canonical (non-zero / minimal) field values so the RLP round-trip is exact.
+	auth := NewAuthorization([]byte{0x01, 0x2a}, to, 5, 1, make([]byte, 32), make([]byte, 32))
 
 	tx := (&EthereumEIP7702Transaction{}).
 		SetChainId(298).
@@ -132,7 +132,7 @@ func TestUnitEthereumEIP7702String(t *testing.T) {
 	to, _ := hex.DecodeString("000000000000000000000000000000000000041d")
 	tx := (&EthereumEIP7702Transaction{}).
 		SetChainId(1).
-		AddAuthorization(AuthorizationTuple{{0x01}, to, {0x00}, {0x00}, {0x11}, {0x22}})
+		AddAuthorization(NewAuthorization([]byte{0x01}, to, 0, 0, []byte{0x11}, []byte{0x22}))
 	s := tx.String()
 	assert.Contains(t, s, "ChainId:")
 	assert.Contains(t, s, "AuthorizationList:")

sdk/ethereum_transaction_body_unit_test.go

@@ -92,14 +92,7 @@ func TestUnitEthereumEIP7702BuilderAndSign(t *testing.T) {
 	key := newTestEcdsaKey(t)
 
 	to, _ := hex.DecodeString("000000000000000000000000000000000000041d")
-	authTuple := AuthorizationTuple{
-		{0x01, 0x2a},
-		to,
-		{0x00},
-		{0x00},
-		make([]byte, 32),
-		make([]byte, 32),
-	}
+	auth := NewAuthorization([]byte{0x01, 0x2a}, to, 0, 0, make([]byte, 32), make([]byte, 32))
 
 	tx := (&EthereumEIP7702Transaction{}).
 		SetChainId(298).
@@ -110,7 +103,7 @@ func TestUnitEthereumEIP7702BuilderAndSign(t *testing.T) {
 		SetTo(to).
 		SetValue(big.NewInt(0)).
 		SetCallData([]byte{0x01, 0x02}).
-		AddAuthorization(authTuple)
+		AddAuthorization(auth)
 
 	signed, err := tx.Sign(key)
 	require.NoError(t, err)

sdk/ethereum_transaction_e2e_test.go

@@ -319,21 +319,10 @@ func TestIntegrationEthereumEIP7702Transaction(t *testing.T) {
 	authR := authSignedBytes[0:32]
 	authS := authSignedBytes[32:64]
 	authRecoveryId := ecdsaPrivateKey.GetRecoveryId(authR, authS, authMessage)
-	authYParity := []byte{}
-	if authRecoveryId != 0 {
-		authYParity = []byte{byte(authRecoveryId)}
-	}
 
-	// Create authorization tuple: [chainId, contractAddress, nonce, yParity, r, s]
-	authorizationTuple := AuthorizationTuple{
-		chainId,
-		contractAddressForAuthorization,
-		nonce,
-		authYParity,
-		authR,
-		authS,
-	}
-	authorizationList := []AuthorizationTuple{authorizationTuple}
+	// Create authorization: [chainId, address, nonce, yParity, r, s]
+	authorization := NewAuthorization(chainId, contractAddressForAuthorization, _ethBytesToUint64(nonce), uint32(authRecoveryId), authR, authS)
+	authorizationList := []Authorization{authorization}
 
 	messageBytes, err := getEIP7702CallData(chainId, nonce, maxPriorityGas, maxGas, gasLimitBytes, contractBytes, value, callDataBytes, accessList, authorizationList, ecdsaPrivateKey)
 	require.NoError(t, err)
@@ -364,7 +353,7 @@ func TestIntegrationEthereumEIP7702Transaction(t *testing.T) {
 	require.NoError(t, err)
 }
 
-func getEIP7702CallData(chainId, nonce, maxPriorityGas, maxGas, gasLimitBytes, contractBytes, value, callDataBytes []byte, accessList [][]byte, authorizationList []AuthorizationTuple, ecdsaPrivateKey PrivateKey) ([]byte, error) {
+func getEIP7702CallData(chainId, nonce, maxPriorityGas, maxGas, gasLimitBytes, contractBytes, value, callDataBytes []byte, accessList [][]byte, authorizationList []Authorization, ecdsaPrivateKey PrivateKey) ([]byte, error) {
 	objectsList := &RLPItem{}
 	objectsList.AssignList()
 	objectsList.PushBack(NewRLPItem(VALUE_TYPE).AssignValue(chainId))
@@ -383,15 +372,10 @@ func getEIP7702CallData(chainId, nonce, maxPriorityGas, maxGas, gasLimitBytes, c
 	}
 	objectsList.PushBack(accessListItem)
 
-	// Add authorization list: array of [chainId, contractAddress, nonce, yParity, r, s] tuples
+	// Add authorization list: array of [chainId, address, nonce, yParity, r, s] tuples
 	authorizationListItem := NewRLPItem(LIST_TYPE)
-	for _, authTuple := range authorizationList {
-		// Each authorization entry is a tuple: [chainId, contractAddress, nonce, yParity, r, s]
-		authTupleItem := NewRLPItem(LIST_TYPE)
-		for i := 0; i < 6; i++ {
-			authTupleItem.PushBack(NewRLPItem(VALUE_TYPE).AssignValue(authTuple[i]))
-		}
-		authorizationListItem.PushBack(authTupleItem)
+	for _, auth := range authorizationList {
+		authorizationListItem.PushBack(auth._toRLPItem())
 	}
 	objectsList.PushBack(authorizationListItem)