test(kms): move AWS sign test to integration with LocalStack

Author: renatomaia

Makefile

@@ -561,7 +561,7 @@ INTEGRATION_SHARD_prt        := ^Test(EchoPrt|RejectExceptionPrt|ForeclosePrt)$$
 INTEGRATION_SHARD_replay     := ^Test(Foreclose|ForecloseReplay|DivergentClaim)$$
 INTEGRATION_SHARD_restart    := ^Test(Restart|SnapshotPolicy)$$
 INTEGRATION_SHARD_withdrawal := ^TestWithdrawalLifecycle$$
-INTEGRATION_SHARD_awskms     := ^TestLocalStackAWSTransactOptsFactory$$
+INTEGRATION_SHARD_awskms     := ^TestLocalStackAWS(SignTx|TransactionOptsFactory)$$
 
 # -----------------------------------------------------------------------------
 # Node topology axis — orthogonal to shards.

internal/kms/signtx_test.go

@@ -11,95 +11,15 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/cartesi/rollups-node/pkg/ethutil"
-
 	"github.com/ethereum/go-ethereum/common"
 	ethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/ethclient"
 
-	awscfg "github.com/aws/aws-sdk-go-v2/config"
 	awskms "github.com/aws/aws-sdk-go-v2/service/kms"
 	kmstypes "github.com/aws/aws-sdk-go-v2/service/kms/types"
 	"github.com/stretchr/testify/require"
 )
 
-var ARN = ""
-
-/* Create a SignTxFn from a private key. Useful for testing */
-func CreateSignTxFnFromPrivateKey(privateKey *ecdsa.PrivateKey) SignTxFn {
-	return func(_ context.Context, tx *ethtypes.Transaction, s ethtypes.Signer) (*ethtypes.Transaction, error) {
-		return ethtypes.SignTx(tx, s, privateKey)
-	}
-}
-
-func sendFunds(
-	value *big.Int,
-	SignTx SignTxFn,
-	ctx context.Context,
-	sender common.Address,
-	recipient common.Address,
-) {
-	client, err := ethclient.Dial("http://127.0.0.1:8545") // anvil
-	if err != nil {
-		panic(err)
-	}
-
-	nonce, err := client.PendingNonceAt(context.Background(), sender)
-	if err != nil {
-		panic(err)
-	}
-	gasLimit := uint64(21000)
-	gasPrice, err := client.SuggestGasPrice(ctx)
-	if err != nil {
-		panic(err)
-	}
-	var data []byte
-	tx := ethtypes.NewTransaction(nonce, recipient, value, gasLimit, gasPrice, data)
-	chainID, err := client.NetworkID(context.Background())
-	if err != nil {
-		panic(err)
-	}
-	signedTx, err := SignTx(ctx, tx, ethtypes.NewEIP155Signer(chainID))
-	if err != nil {
-		panic(err)
-	}
-	err = client.SendTransaction(context.Background(), signedTx)
-	if err != nil {
-		panic(err)
-	}
-}
-
-func TestSignTx(t *testing.T) {
-	if len(ARN) == 0 {
-		t.Skip("Skipping test, ARN for KMS key is unset")
-	}
-	value20 := big.NewInt(2000000000000000000) // in wei (2 eth)
-	value10 := big.NewInt(1000000000000000000) // in wei (1 eth)
-
-	anvilPrivateKey, err := ethutil.MnemonicToPrivateKey(ethutil.FoundryMnemonic, 0)
-	if err != nil {
-		panic(err)
-	}
-	anvilPublicKey := anvilPrivateKey.Public().(*ecdsa.PublicKey)
-	anvilAddress := crypto.PubkeyToAddress(*anvilPublicKey)
-
-	config, err := awscfg.LoadDefaultConfig(context.Background())
-	if err != nil {
-		panic(err)
-	}
-	kms := awskms.NewFromConfig(config)
-	SignTx, _, KMSAddress, err := CreateAWSSignTxFn(context.Background(), kms, &ARN)
-	if err != nil {
-		panic(err)
-	}
-
-	sendFunds(value20, CreateSignTxFnFromPrivateKey(anvilPrivateKey),
-		context.Background(), anvilAddress, KMSAddress)
-	sendFunds(value10, SignTx,
-		context.Background(), KMSAddress, anvilAddress)
-}
-
 func TestAWSTransactOptsFactorySignsWithSubmitContext(t *testing.T) {
 	privateKey, err := crypto.GenerateKey()
 	require.NoError(t, err)

test/integration/localstack_integration_test.go

@@ -7,35 +7,41 @@ package integration
 
 import (
 	"context"
+	"crypto/ecdsa"
 	"math/big"
 	"os"
 	"testing"
 
+	"github.com/cartesi/rollups-node/internal/config"
 	"github.com/cartesi/rollups-node/internal/kms"
+	"github.com/cartesi/rollups-node/pkg/ethutil"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
-	"github.com/aws/aws-sdk-go-v2/config"
+	awscfg "github.com/aws/aws-sdk-go-v2/config"
 	awskms "github.com/aws/aws-sdk-go-v2/service/kms"
 	kmstypes "github.com/aws/aws-sdk-go-v2/service/kms/types"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/stretchr/testify/require"
 )
 
-func TestLocalStackAWSTransactOptsFactory(t *testing.T) {
+func setupTesting(t *testing.T) (*awskms.Client, *awskms.CreateKeyOutput) {
+	t.Helper()
+
 	endpoint := os.Getenv("LOCALSTACK_KMS_ENDPOINT")
 	if endpoint == "" {
 		t.Skip("LOCALSTACK_KMS_ENDPOINT is not set; skipping LocalStack KMS integration test")
 	}
-	ctx := context.Background()
-	cfg, err := config.LoadDefaultConfig(ctx,
-		config.WithRegion("us-east-1"),
-		config.WithBaseEndpoint(endpoint),
+ 	cfg, err := awscfg.LoadDefaultConfig(t.Context(),
+		awscfg.WithRegion("us-east-1"),
+		awscfg.WithBaseEndpoint(endpoint),
 	)
 	require.NoError(t, err)
 	client := awskms.NewFromConfig(cfg)
 
-	created, err := client.CreateKey(ctx, &awskms.CreateKeyInput{
+	created, err := client.CreateKey(t.Context(), &awskms.CreateKeyInput{
 		KeyUsage: kmstypes.KeyUsageTypeSignVerify,
 		KeySpec:  kmstypes.KeySpecEccSecgP256k1,
 	})
@@ -49,13 +55,70 @@ func TestLocalStackAWSTransactOptsFactory(t *testing.T) {
 	require.NotNil(t, created.KeyMetadata)
 	require.NotNil(t, created.KeyMetadata.KeyId)
 
+	return client, created
+}
+
+func sendFunds(
+	t *testing.T,
+	value *big.Int,
+	SignTx kms.SignTxFn,
+	sender common.Address,
+	recipient common.Address,
+) {
+	ethEndpoint, err := config.GetBlockchainHttpEndpoint()
+	require.NoError(t, err)
+	client, err := ethclient.Dial(ethEndpoint.Raw()) // anvil
+	require.NoError(t, err)
+
+	nonce, err := client.PendingNonceAt(t.Context(), sender)
+	require.NoError(t, err)
+	gasLimit := uint64(21000)
+	gasPrice, err := client.SuggestGasPrice(t.Context())
+	require.NoError(t, err)
+	var data []byte
+	tx := types.NewTransaction(nonce, recipient, value, gasLimit, gasPrice, data)
+	chainID, err := client.NetworkID(t.Context())
+	require.NoError(t, err)
+	signedTx, err := SignTx(t.Context(), tx, types.LatestSignerForChainID(chainID))
+	require.NoError(t, err)
+	err = client.SendTransaction(t.Context(), signedTx)
+	require.NoError(t, err)
+}
+
+func TestLocalStackAWSSignTx(t *testing.T) {
+	client, created := setupTesting(t)
+
+	awsSignTx, _, awsAddress, err := kms.CreateAWSSignTxFn(
+		t.Context(), client, created.KeyMetadata.KeyId,
+	)
+	require.NoError(t, err)
+
+	value20 := big.NewInt(2000000000000000000) // in wei (2 eth)
+	value10 := big.NewInt(1000000000000000000) // in wei (1 eth)
+	anvilPrivateKey, err := ethutil.MnemonicToPrivateKey(ethutil.FoundryMnemonic, 0)
+	if err != nil {
+		panic(err)
+	}
+	anvilPublicKey := anvilPrivateKey.Public().(*ecdsa.PublicKey)
+	anvilAddress := crypto.PubkeyToAddress(*anvilPublicKey)
+	anvilSignTx := func(_ context.Context, tx *types.Transaction, s types.Signer) (*types.Transaction, error) {
+		return types.SignTx(tx, s, anvilPrivateKey)
+	}
+
+	sendFunds(t, value20, anvilSignTx, anvilAddress, awsAddress)
+	sendFunds(t, value10, awsSignTx, awsAddress, anvilAddress)
+}
+
+func TestLocalStackAWSTransactionOptsFactory(t *testing.T) {
+	client, created := setupTesting(t)
+
 	chainID := big.NewInt(31337)
 	factory, err := kms.CreateAWSTransactOptsFactory(
-		ctx, client, created.KeyMetadata.KeyId, types.LatestSignerForChainID(chainID),
+		t.Context(), client, created.KeyMetadata.KeyId, types.LatestSignerForChainID(chainID),
 	)
 	require.NoError(t, err)
 	require.NotEqual(t, common.Address{}, factory.From())
-	opts, err := factory.NewTransactOpts(ctx)
+	opts, err := factory.NewTransactOpts(t.Context())
 	require.NoError(t, err)
 
 	to := common.Address{0x01}
@@ -78,7 +141,7 @@ func TestLocalStackAWSTransactOptsFactory(t *testing.T) {
 		})
 	}
 
-	_, _ = client.ScheduleKeyDeletion(ctx, &awskms.ScheduleKeyDeletionInput{
+	_, _ = client.ScheduleKeyDeletion(t.Context(), &awskms.ScheduleKeyDeletionInput{
 		KeyId: created.KeyMetadata.KeyId, PendingWindowInDays: aws.Int32(7), //nolint:mnd
 	})
 }