Solana plugin codec implementation

.changeset/violet-bears-try.md

@@ -0,0 +1,5 @@
+---
+"chainlink": minor
+---
+
+Solana CCIP plugin codec support for both commit and execute report #added

core/capabilities/ccip/ccipsolana/commitcodec.go

@@ -0,0 +1,138 @@
+package ccipsolana
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"math/big"
+
+	agbinary "github.com/gagliardetto/binary"
+	"github.com/gagliardetto/solana-go"
+
+	"github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings/ccip_router"
+	"github.com/smartcontractkit/chainlink-ccip/chains/solana/utils/common"
+	cciptypes "github.com/smartcontractkit/chainlink-ccip/pkg/types/ccipocr3"
+)
+
+// CommitPluginCodecV1 is a codec for encoding and decoding commit plugin reports.
+// Compatible with:
+// - "OffRamp 1.6.0-dev"
+type CommitPluginCodecV1 struct{}
+
+func NewCommitPluginCodecV1() *CommitPluginCodecV1 {
+	return &CommitPluginCodecV1{}
+}
+
+func (c *CommitPluginCodecV1) Encode(ctx context.Context, report cciptypes.CommitPluginReport) ([]byte, error) {
+	var buf bytes.Buffer
+	encoder := agbinary.NewBorshEncoder(&buf)
+	mr := ccip_router.MerkleRoot{}
+
+	if len(report.MerkleRoots) != 0 {
+		mr = ccip_router.MerkleRoot{
+			SourceChainSelector: uint64(report.MerkleRoots[0].ChainSel),
+			OnRampAddress:       report.MerkleRoots[0].OnRampAddress,
+			MinSeqNr:            uint64(report.MerkleRoots[0].SeqNumsRange.Start()),
+			MaxSeqNr:            uint64(report.MerkleRoots[0].SeqNumsRange.End()),
+			MerkleRoot:          report.MerkleRoots[0].MerkleRoot,
+		}
+	}
+
+	tpu := make([]ccip_router.TokenPriceUpdate, 0, len(report.PriceUpdates.TokenPriceUpdates))
+	for _, update := range report.PriceUpdates.TokenPriceUpdates {
+		token, err := solana.PublicKeyFromBase58(string(update.TokenID))
+		if err != nil {
+			return nil, fmt.Errorf("invalid token address: %s, %w", update.TokenID, err)
+		}
+		if update.Price.IsEmpty() {
+			return nil, fmt.Errorf("empty price for token: %s", update.TokenID)
+		}
+		tpu = append(tpu, ccip_router.TokenPriceUpdate{
+			SourceToken: token,
+			UsdPerToken: common.To28BytesBE(update.Price.Int.Uint64()),
+		})
+	}
+
+	gpu := make([]ccip_router.GasPriceUpdate, 0, len(report.PriceUpdates.GasPriceUpdates))
+	for _, update := range report.PriceUpdates.GasPriceUpdates {
+		gpu = append(gpu, ccip_router.GasPriceUpdate{
+			DestChainSelector: uint64(update.ChainSel),
+			UsdPerUnitGas:     common.To28BytesBE(update.GasPrice.Int.Uint64()),
+		})
+	}
+
+	commit := ccip_router.CommitInput{
+		MerkleRoot: mr,
+		PriceUpdates: ccip_router.PriceUpdates{
+			TokenPriceUpdates: tpu,
+			GasPriceUpdates:   gpu,
+		},
+	}
+
+	err := commit.MarshalWithEncoder(encoder)
+	if err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+func (c *CommitPluginCodecV1) Decode(ctx context.Context, bytes []byte) (cciptypes.CommitPluginReport, error) {
+	decoder := agbinary.NewBorshDecoder(bytes)
+	commitReport := ccip_router.CommitInput{}
+	err := commitReport.UnmarshalWithDecoder(decoder)
+	if err != nil {
+		return cciptypes.CommitPluginReport{}, err
+	}
+
+	merkleRoots := []cciptypes.MerkleRootChain{
+		{
+			ChainSel:      cciptypes.ChainSelector(commitReport.MerkleRoot.SourceChainSelector),
+			OnRampAddress: commitReport.MerkleRoot.OnRampAddress,
+			SeqNumsRange: cciptypes.NewSeqNumRange(
+				cciptypes.SeqNum(commitReport.MerkleRoot.MinSeqNr),
+				cciptypes.SeqNum(commitReport.MerkleRoot.MaxSeqNr),
+			),
+			MerkleRoot: commitReport.MerkleRoot.MerkleRoot,
+		},
+	}
+
+	tokenPriceUpdates := make([]cciptypes.TokenPrice, 0, len(commitReport.PriceUpdates.TokenPriceUpdates))
+	for _, update := range commitReport.PriceUpdates.TokenPriceUpdates {
+		tokenPriceUpdates = append(tokenPriceUpdates, cciptypes.TokenPrice{
+			TokenID: cciptypes.UnknownEncodedAddress(update.SourceToken.String()),
+			Price:   priceHelper(update.UsdPerToken[:]),
+		})
+	}
+
+	gasPriceUpdates := make([]cciptypes.GasPriceChain, 0, len(commitReport.PriceUpdates.GasPriceUpdates))
+	for _, update := range commitReport.PriceUpdates.GasPriceUpdates {
+		gasPriceUpdates = append(gasPriceUpdates, cciptypes.GasPriceChain{
+			GasPrice: priceHelper(update.UsdPerUnitGas[:]),
+			ChainSel: cciptypes.ChainSelector(update.DestChainSelector),
+		})
+	}
+
+	return cciptypes.CommitPluginReport{
+		MerkleRoots: merkleRoots,
+		PriceUpdates: cciptypes.PriceUpdates{
+			TokenPriceUpdates: tokenPriceUpdates,
+			GasPriceUpdates:   gasPriceUpdates,
+		},
+	}, nil
+}
+
+func priceHelper(input []byte) cciptypes.BigInt {
+	var tokenPrice cciptypes.BigInt
+	price := new(big.Int).SetBytes(input)
+	if price.Int64() == 0 {
+		tokenPrice = cciptypes.NewBigInt(big.NewInt(0))
+	} else {
+		tokenPrice = cciptypes.NewBigInt(price)
+	}
+
+	return tokenPrice
+}
+
+// Ensure CommitPluginCodec implements the CommitPluginCodec interface
+var _ cciptypes.CommitPluginCodec = (*CommitPluginCodecV1)(nil)

core/capabilities/ccip/ccipsolana/commitcodec_test.go

@@ -0,0 +1,133 @@
+package ccipsolana
+
+import (
+	"math/big"
+	"math/rand"
+	"testing"
+
+	solanago "github.com/gagliardetto/solana-go"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	cciptypes "github.com/smartcontractkit/chainlink-ccip/pkg/types/ccipocr3"
+	"github.com/smartcontractkit/chainlink/v2/core/chains/evm/utils"
+	"github.com/smartcontractkit/chainlink/v2/core/internal/testutils"
+)
+
+var randomCommitReport = func() cciptypes.CommitPluginReport {
+	pubkey, err := solanago.NewRandomPrivateKey()
+	if err != nil {
+		panic(err)
+	}
+
+	return cciptypes.CommitPluginReport{
+		MerkleRoots: []cciptypes.MerkleRootChain{
+			{
+				OnRampAddress: cciptypes.UnknownAddress(pubkey.PublicKey().String()),
+				ChainSel:      cciptypes.ChainSelector(rand.Uint64()),
+				SeqNumsRange: cciptypes.NewSeqNumRange(
+					cciptypes.SeqNum(rand.Uint64()),
+					cciptypes.SeqNum(rand.Uint64()),
+				),
+				MerkleRoot: utils.RandomBytes32(),
+			},
+		},
+		PriceUpdates: cciptypes.PriceUpdates{
+			TokenPriceUpdates: []cciptypes.TokenPrice{
+				{
+					TokenID: "C8WSPj3yyus1YN3yNB6YA5zStYtbjQWtpmKadmvyUXq8",
+					Price:   cciptypes.NewBigInt(big.NewInt(rand.Int63())),
+				},
+			},
+			GasPriceUpdates: []cciptypes.GasPriceChain{
+				{GasPrice: cciptypes.NewBigInt(big.NewInt(rand.Int63())), ChainSel: cciptypes.ChainSelector(rand.Uint64())},
+				{GasPrice: cciptypes.NewBigInt(big.NewInt(rand.Int63())), ChainSel: cciptypes.ChainSelector(rand.Uint64())},
+				{GasPrice: cciptypes.NewBigInt(big.NewInt(rand.Int63())), ChainSel: cciptypes.ChainSelector(rand.Uint64())},
+			},
+		},
+	}
+}
+
+func TestCommitPluginCodecV1(t *testing.T) {
+	testCases := []struct {
+		name   string
+		report func(report cciptypes.CommitPluginReport) cciptypes.CommitPluginReport
+		expErr bool
+	}{
+		{
+			name: "base report",
+			report: func(report cciptypes.CommitPluginReport) cciptypes.CommitPluginReport {
+				return report
+			},
+		},
+		{
+			name: "empty token address",
+			report: func(report cciptypes.CommitPluginReport) cciptypes.CommitPluginReport {
+				report.PriceUpdates.TokenPriceUpdates[0].TokenID = ""
+				return report
+			},
+			expErr: true,
+		},
+		{
+			name: "empty merkle root",
+			report: func(report cciptypes.CommitPluginReport) cciptypes.CommitPluginReport {
+				report.MerkleRoots[0].MerkleRoot = cciptypes.Bytes32{}
+				return report
+			},
+		},
+		{
+			name: "zero token price",
+			report: func(report cciptypes.CommitPluginReport) cciptypes.CommitPluginReport {
+				report.PriceUpdates.TokenPriceUpdates[0].Price = cciptypes.NewBigInt(big.NewInt(0))
+				return report
+			},
+		},
+		{
+			name: "zero gas price",
+			report: func(report cciptypes.CommitPluginReport) cciptypes.CommitPluginReport {
+				report.PriceUpdates.GasPriceUpdates[0].GasPrice = cciptypes.NewBigInt(big.NewInt(0))
+				return report
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			report := tc.report(randomCommitReport())
+			commitCodec := NewCommitPluginCodecV1()
+			ctx := testutils.Context(t)
+			encodedReport, err := commitCodec.Encode(ctx, report)
+			if tc.expErr {
+				assert.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+			decodedReport, err := commitCodec.Decode(ctx, encodedReport)
+			require.NoError(t, err)
+			require.Equal(t, report, decodedReport)
+		})
+	}
+}
+
+func BenchmarkCommitPluginCodecV1_Encode(b *testing.B) {
+	commitCodec := NewCommitPluginCodecV1()
+	ctx := testutils.Context(b)
+
+	rep := randomCommitReport()
+	for i := 0; i < b.N; i++ {
+		_, err := commitCodec.Encode(ctx, rep)
+		require.NoError(b, err)
+	}
+}
+
+func BenchmarkCommitPluginCodecV1_Decode(b *testing.B) {
+	commitCodec := NewCommitPluginCodecV1()
+	ctx := testutils.Context(b)
+	encodedReport, err := commitCodec.Encode(ctx, randomCommitReport())
+	require.NoError(b, err)
+
+	for i := 0; i < b.N; i++ {
+		_, err := commitCodec.Decode(ctx, encodedReport)
+		require.NoError(b, err)
+	}
+}