Aptos CCIP e2e tests

.changeset/warm-toys-give.md

@@ -0,0 +1,6 @@
+---
+"chainlink": patch
+---
+
+add support for Aptos CCIP #added
+

.github/actions/setup-aptos/action.yml

@@ -0,0 +1,9 @@
+name: Setup Aptos CLI
+description: Setup Aptos CLI
+runs:
+  using: composite
+  steps:
+    - name: Install Aptos CLI
+      uses: aptos-labs/actions/install-aptos-cli@ce57287eb852b9819c1d74fecc3be187677559fd # v0.1
+      with:
+        CLI_VERSION: 7.2.0

.github/integration-in-memory-tests.yml

@@ -297,4 +297,17 @@ runner-test-matrix:
     test_cmd: cd smoke/ccip/ && go test ccip_disable_lane_test.go -timeout 10m -test.parallel=1 -count=1 -json
     test_go_project_path: integration-tests
 
+  # Aptos tests
+  - id: smoke/ccip/ccip_aptos_messaging_test.go:*
+    path: integration-tests/smoke/ccip/ccip_aptos_messaging_test.go
+    test_env_type: in-memory
+    runs_on: ubuntu-latest
+    triggers:
+      - PR Integration CCIP Tests
+      - Nightly Integration CCIP Tests
+    test_cmd: cd smoke/ccip && go test ccip_aptos_messaging_test.go -timeout 15m -test.parallel=1 -count=1 -json
+    test_go_project_path: integration-tests
+    aptos_cli: 7.2.0
+    install_plugins_public: true
+
   # END: CCIP tests

.github/workflows/integration-in-memory-tests.yml

@@ -74,7 +74,7 @@ jobs:
       contents: read
     needs: changes
     if: github.event_name == 'pull_request' && ( needs.changes.outputs.ccip_changes == 'true' || needs.changes.outputs.core_changes == 'true' || needs.changes.outputs.github_ci_changes == 'true')
-    uses: smartcontractkit/.github/.github/workflows/run-e2e-tests.yml@608298f511acfbcfd1099e5907ba1b1b0dda8b14
+    uses: smartcontractkit/.github/.github/workflows/run-e2e-tests.yml@50a6cb250423d2a1d8edfd8e42c53f63135043e0
     with:
       workflow_name: Run CCIP Integration Tests For PR
       chainlink_version: ${{ inputs.cl_ref || github.sha }}
@@ -102,7 +102,7 @@ jobs:
       contents: read
     needs: changes
     if: github.event_name == 'merge_group' && ( needs.changes.outputs.ccip_changes == 'true' || needs.changes.outputs.core_changes == 'true' || needs.changes.outputs.github_ci_changes == 'true')
-    uses: smartcontractkit/.github/.github/workflows/run-e2e-tests.yml@608298f511acfbcfd1099e5907ba1b1b0dda8b14
+    uses: smartcontractkit/.github/.github/workflows/run-e2e-tests.yml@50a6cb250423d2a1d8edfd8e42c53f63135043e0
     with:
       workflow_name: Run CCIP Integration Tests For Merge Queue
       chainlink_version: ${{ inputs.cl_ref || github.sha }}

core/capabilities/ccip/ccipaptos/addresscodec.go

@@ -0,0 +1,67 @@
+package ccipaptos
+
+import (
+	"encoding/hex"
+	"fmt"
+	"strings"
+)
+
+type AddressCodec struct{}
+
+func (a AddressCodec) AddressBytesToString(addr []byte) (string, error) {
+	return addressBytesToString(addr)
+}
+
+func (a AddressCodec) AddressStringToBytes(addr string) ([]byte, error) {
+	return addressStringToBytes(addr)
+}
+
+func addressBytesToString(addr []byte) (string, error) {
+	if len(addr) < 1 || len(addr) > 32 {
+		return "", fmt.Errorf("invalid Aptos address length (%d)", len(addr))
+	}
+
+	return fmt.Sprintf("0x%064x", addr), nil
+}
+
+func addressStringToBytes(addr string) ([]byte, error) {
+	a := strings.TrimPrefix(addr, "0x")
+	if len(a) == 0 {
+		return nil, fmt.Errorf("invalid Aptos address length, expected at least 1 character: %s", addr)
+	}
+	if len(a) > 64 {
+		return nil, fmt.Errorf("invalid Aptos address length, expected at most 64 characters: %s", addr)
+	}
+	for len(a) < 64 {
+		a = "0" + a
+	}
+
+	bytes, err := hex.DecodeString(a)
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode Aptos address '%s': %w", addr, err)
+	}
+	return bytes, nil
+}
+
+func addressBytesToBytes32(addr []byte) ([32]byte, error) {
+	if len(addr) > 32 {
+		return [32]byte{}, fmt.Errorf("invalid Aptos address length, expected 32, got %d", len(addr))
+	}
+	var result [32]byte
+	// Left pad by copying to the end of the 32 byte array
+	copy(result[32-len(addr):], addr)
+	return result, nil
+}
+
+func addressStringToBytes32(addr string) ([32]byte, error) {
+	bytes, err := addressStringToBytes(addr)
+	if err != nil {
+		return [32]byte{}, err
+	}
+	return addressBytesToBytes32(bytes)
+}
+
+func addressIsValid(addr string) bool {
+	_, err := addressStringToBytes(addr)
+	return err == nil
+}

core/capabilities/ccip/ccipaptos/addresscodec_test.go

@@ -0,0 +1,121 @@
+package ccipaptos
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func generateAddressBytes32() [32]byte {
+	var result [32]byte
+	_, err := rand.Read(result[:])
+	if err != nil {
+		panic(fmt.Sprintf("failed to generate random address bytes: %v", err))
+	}
+	return result
+}
+
+func generateAddressBytes() []byte {
+	a := generateAddressBytes32()
+	return a[:]
+}
+
+func generateAddressString() string {
+	addressBytes := generateAddressBytes()
+	addressString, err := addressBytesToString(addressBytes)
+	if err != nil {
+		panic(fmt.Sprintf("failed to generate random address string: %v", err))
+	}
+	return addressString
+}
+
+func TestAddressBytesToString(t *testing.T) {
+	tests := []struct {
+		name     string
+		inHex    string
+		isErr    bool
+		expected string
+	}{
+		{
+			"empty",
+			"",
+			true,
+			"",
+		},
+		{
+			"equal to 32 bytes",
+			"0102030405060102030405060102030405060102030405060102030405060101",
+			false,
+			"0x0102030405060102030405060102030405060102030405060102030405060101",
+		},
+		{
+			"longer than required",
+			"0102030405060102030405060102030405060102030405060102030405060101FFFFFFFFFF",
+			true,
+			"",
+		},
+	}
+
+	codec := AddressCodec{}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			bytes, err := hex.DecodeString(test.inHex)
+			require.NoError(t, err)
+
+			if test.isErr {
+				_, err := codec.AddressBytesToString(bytes)
+				require.Error(t, err, fmt.Sprintf("expected error for %s, input %s", test.name, test.inHex))
+			} else {
+				actual, err := codec.AddressBytesToString(bytes)
+				require.NoError(t, err)
+				require.Equal(t, test.expected, actual)
+			}
+		})
+	}
+}
+
+func TestAddressStringToBytes(t *testing.T) {
+	tests := []struct {
+		name        string
+		in          string
+		expected    []byte
+		expectedErr error
+	}{
+		{
+			"hand crafted",
+			"0x0102030405060102030405060102030405060102030405060102030405060101",
+			[]byte{
+				0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
+				0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
+				0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
+				0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
+				0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
+				0x01, 0x01,
+			},
+			nil,
+		},
+		{
+			"hand crafted error",
+			"invalidAddress",
+			nil,
+			errors.New("failed to decode Aptos address 'invalidAddress': invalid address"),
+		},
+	}
+
+	codec := AddressCodec{}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			actual, err := codec.AddressStringToBytes(test.in)
+			if test.expectedErr == nil {
+				require.NoError(t, err)
+				require.Equal(t, test.expected, actual)
+			} else {
+				require.Error(t, err)
+			}
+		})
+	}
+}