feat: adds aptos chain providers (#123)

Author: jkongie

.changeset/four-pandas-rush.md

@@ -0,0 +1,5 @@
+---
+"chainlink-deployments-framework": patch
+---
+
+Adds Aptos Chain providers for RPC and CTF backed chains

chain/aptos/aptos_chain.go

@@ -1,7 +1,7 @@
 package aptos
 
 import (
-	"github.com/aptos-labs/aptos-go-sdk"
+	aptoslib "github.com/aptos-labs/aptos-go-sdk"
 
 	chain_common "github.com/smartcontractkit/chainlink-deployments-framework/chain/internal/common"
 )
@@ -10,8 +10,8 @@ import (
 type Chain struct {
 	Selector uint64
 
-	Client         aptos.AptosRpcClient
-	DeployerSigner aptos.TransactionSigner
+	Client         aptoslib.AptosRpcClient
+	DeployerSigner aptoslib.TransactionSigner
 	URL            string
 
 	Confirm func(txHash string, opts ...any) error

chain/aptos/provider/account_generator.go

@@ -0,0 +1,96 @@
+package provider
+
+import (
+	"crypto/ed25519"
+	"encoding/hex"
+	"fmt"
+	"strings"
+
+	aptoslib "github.com/aptos-labs/aptos-go-sdk"
+	"github.com/aptos-labs/aptos-go-sdk/crypto"
+	"github.com/smartcontractkit/chainlink-testing-framework/framework/components/blockchain"
+)
+
+// AccountGenerator is an interface for generating Aptos accounts.
+type AccountGenerator interface {
+	Generate() (*aptoslib.Account, error)
+}
+
+var (
+	_ AccountGenerator = (*accountGenCTFDefault)(nil)
+	_ AccountGenerator = (*accountGenNewSingleSender)(nil)
+	_ AccountGenerator = (*accountGenPrivateKey)(nil)
+)
+
+// accountGenCTFDefault is a default account generator for CTF (Chainlink Testing Framework).
+type accountGenCTFDefault struct {
+	// The account address string to use for generating the account.
+	accountStr string
+	// privateKeyStr is the private key string to use for generating the account.
+	privateKeyStr string
+}
+
+// AccountGenCTFDefault creates a new instance of accountGenCTFDefault. It uses the default
+// Aptos account and private key from the blockchain package.
+func AccountGenCTFDefault() *accountGenCTFDefault {
+	return &accountGenCTFDefault{
+		accountStr:    blockchain.DefaultAptosAccount,
+		privateKeyStr: blockchain.DefaultAptosPrivateKey,
+	}
+}
+
+// Generate generates an Aptos account using the default address and private key from the
+// blockchain package. It returns an error if the address or private key is invalid.
+func (g *accountGenCTFDefault) Generate() (*aptoslib.Account, error) {
+	var address aptoslib.AccountAddress
+
+	if err := address.ParseStringRelaxed(g.accountStr); err != nil {
+		return nil, fmt.Errorf("failed to parse account address %s: %w", g.accountStr, err)
+	}
+
+	privateKeyBytes, err := hex.DecodeString(strings.TrimPrefix(g.privateKeyStr, "0x"))
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode private key: %w", err)
+	}
+	privateKey := ed25519.NewKeyFromSeed(privateKeyBytes)
+
+	return aptoslib.NewAccountFromSigner(&crypto.Ed25519PrivateKey{Inner: privateKey}, address)
+}
+
+// accountGenNewSingleSender is an account generator that creates a new single sender account.
+type accountGenNewSingleSender struct{}
+
+// AccountGenNewSingleSender creates a new instance of accountGenNewSingleSender.
+func AccountGenNewSingleSender() *accountGenNewSingleSender {
+	return &accountGenNewSingleSender{}
+}
+
+// Generate generates a new Aptos account using the aptos library's single sender account creation
+// method.
+func (g *accountGenNewSingleSender) Generate() (*aptoslib.Account, error) {
+	return aptoslib.NewEd25519SingleSenderAccount()
+}
+
+// accountGenPrivateKey is an account generator that creates an account from the private key.
+type accountGenPrivateKey struct {
+	// PrivateKey is the hex formatted private key used to generate the Aptos account.
+	PrivateKey string
+}
+
+// AccountGenPrivateKey creates a new instance of accountGenPrivateKey with the provided private key.
+func AccountGenPrivateKey(privateKey string) *accountGenPrivateKey {
+	return &accountGenPrivateKey{
+		PrivateKey: privateKey,
+	}
+}
+
+// Generate generates an Aptos account from the provided private key. It returns an error if the
+// private key string cannot be parsed.
+func (g *accountGenPrivateKey) Generate() (*aptoslib.Account, error) {
+	privateKey := &crypto.Ed25519PrivateKey{}
+	if err := privateKey.FromHex(g.PrivateKey); err != nil {
+		return nil, fmt.Errorf("failed to parse private key: %w", err)
+	}
+
+	return aptoslib.NewAccountFromSigner(privateKey)
+}

chain/aptos/provider/account_generator_test.go

@@ -0,0 +1,109 @@
+package provider
+
+import (
+	"testing"
+
+	"github.com/smartcontractkit/chainlink-testing-framework/framework/components/blockchain"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_AccountGenCtfDefault(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name            string
+		giveAccountAddr string
+		givePrivateKey  string
+		wantErr         string
+	}{
+		{
+			name: "valid default account and private key",
+		},
+		{
+			name:            "invalid account address",
+			giveAccountAddr: "invalid_address",
+			givePrivateKey:  blockchain.DefaultAptosPrivateKey,
+			wantErr:         "failed to parse account address",
+		},
+		{
+			name:            "invalid private key",
+			giveAccountAddr: blockchain.DefaultAptosAccount,
+			givePrivateKey:  "invalid_private_key",
+			wantErr:         "failed to decode private key",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			var gen *accountGenCTFDefault
+			if tt.giveAccountAddr == "" && tt.givePrivateKey == "" {
+				gen = AccountGenCTFDefault() // Use the constructor with default values if we don't need to override
+			} else {
+				gen = &accountGenCTFDefault{
+					accountStr:    tt.giveAccountAddr,
+					privateKeyStr: tt.givePrivateKey,
+				}
+			}
+
+			got, err := gen.Generate()
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				require.ErrorContains(t, err, tt.wantErr)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, blockchain.DefaultAptosAccount, got.Address.String())
+			}
+		})
+	}
+}
+
+func Test_AccountGenNewSingleSender(t *testing.T) {
+	t.Parallel()
+
+	gen := AccountGenNewSingleSender()
+	got, err := gen.Generate()
+	require.NoError(t, err)
+	assert.NotNil(t, got)
+}
+
+func Test_AccountGenPrivateKey(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name           string
+		givePrivateKey string
+		wantAddr       string
+		wantErr        string
+	}{
+		{
+			name:           "valid private key",
+			givePrivateKey: testPrivateKey,
+			wantAddr:       testAccountAddr,
+		},
+		{
+			name:           "invalid private key",
+			givePrivateKey: "invalid_private_key",
+			wantErr:        "failed to parse private key",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			gen := AccountGenPrivateKey(tt.givePrivateKey)
+			account, err := gen.Generate()
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				require.ErrorContains(t, err, tt.wantErr)
+			} else {
+				require.NoError(t, err)
+				assert.NotNil(t, account)
+				assert.Equal(t, tt.wantAddr, account.Address.String())
+			}
+		})
+	}
+}

chain/aptos/provider/const_test.go

@@ -0,0 +1,9 @@
+package provider
+
+const (
+	// A valid Aptos private key in hex format
+	testPrivateKey = "0xE4FD0E90D32CB98DC6AD64516A421E8C2731870217CDBA64203CEB158A866304"
+
+	// The expected account address for above private key
+	testAccountAddr = "0x9b7a7333d1abd0e9c2a27d00a8a7a131d30d3b09908739d52693fe513e205c38"
+)