@chainlink/cre-sdk 1.13.0 → 1.14.0-solana-alpha-1

package/README.md

@@ -237,6 +237,66 @@ const onCronTrigger = (runtime: Runtime<Config>) => {
 };
 ```
 
+### Solana Write Reports
+
+The Solana capability is **write-only**: reports are delivered through the
+keystone-forwarder to a receiver program's `on_report` entrypoint as a bare
+Borsh-encoded struct. The SDK ships the write plumbing under
+`utils/capabilities/blockchain/solana`:
+
+- `calculateAccountsHash(accounts)` — sha256 of the concatenated account
+  public keys (the forwarder's on-chain account verification),
+- `encodeForwarderReport({ accountHash, payload })` — the
+  `[32-byte hash][u32-LE len][payload]` forwarder envelope,
+- `encodeBorshVecU32(elements)` — Borsh `Vec` of pre-encoded elements,
+- `prepareSolanaReportRequest(payload)` — report request with the Solana
+  encoder (`solana`/`ecdsa`/`keccak256`),
+- `solanaAccountMeta(publicKey, isWritable)` / `solanaAddressToBytes(base58)`.
+
+The wire format is byte-identical to the Go SDK's
+`capabilities/blockchain/solana/bindings` package.
+
+Generate typed per-program bindings from an Anchor IDL with the CRE CLI:
+
+```bash
+cre generate-bindings solana --language typescript
+```
+
+```typescript
+import { cre, type Runtime, solanaAccountMeta, SolanaClient } from "@chainlink/cre-sdk";
+import { DataStorage } from "../contracts/solana/ts/generated";
+
+const onTrigger = (runtime: Runtime<Config>) => {
+  const client = new SolanaClient(SolanaClient.SUPPORTED_CHAIN_SELECTORS["solana-devnet"]);
+  const dataStorage = new DataStorage(client); // program ID baked in from the IDL
+
+  // remainingAccounts: forwarderState, forwarderAuthority PDA, then receiver accounts
+  const remainingAccounts = [
+    solanaAccountMeta(forwarderState),
+    solanaAccountMeta(forwarderAuthority),
+    solanaAccountMeta(receiverDataAccount, true),
+  ];
+
+  const reply = dataStorage.writeReportFromUserData(
+    runtime,
+    { key: "answer", value: "42" },
+    remainingAccounts,
+  );
+  runtime.log(`tx status: ${reply.txStatus}`);
+};
+```
+
+In tests, intercept writes with the generated mock:
+
+```typescript
+import { SolanaMock } from "@chainlink/cre-sdk/test";
+import { newDataStorageMock } from "../contracts/solana/ts/generated";
+
+const solanaMock = SolanaMock.testInstance(chainSelector);
+const dataStorage = newDataStorageMock(solanaMock);
+dataStorage.writeReport = ({ report }) => ({ txStatus: "TX_STATUS_SUCCESS" });
+```
+
 ## Configuration & Type Safety
 
 You, the developer, must declare config files in config.json files, co-located with your TypeScript workflow definition.

package/dist/sdk/test/contract-mock-core.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Chain-agnostic core of the per-contract mock routing used by
+ * `addContractMock` (EVM) and `addSolanaContractMock` (Solana).
+ *
+ * Builds a handler that routes a request to `handle` when `matches` returns
+ * true, falls through to the previously installed handler otherwise, and
+ * throws `noMatchError` when there is nothing to fall through to. Installing
+ * the returned handler over the previous one is what lets multiple contract
+ * mocks chain on the same capability mock.
+ */
+export declare function chainContractHandler<TReq, TReply>(options: {
+    previous: ((req: TReq) => TReply) | undefined;
+    matches: (req: TReq) => boolean;
+    handle: (req: TReq) => TReply;
+    noMatchError: (req: TReq) => string;
+}): (req: TReq) => TReply;

package/dist/sdk/test/contract-mock-core.js

@@ -0,0 +1,21 @@
+/**
+ * Chain-agnostic core of the per-contract mock routing used by
+ * `addContractMock` (EVM) and `addSolanaContractMock` (Solana).
+ *
+ * Builds a handler that routes a request to `handle` when `matches` returns
+ * true, falls through to the previously installed handler otherwise, and
+ * throws `noMatchError` when there is nothing to fall through to. Installing
+ * the returned handler over the previous one is what lets multiple contract
+ * mocks chain on the same capability mock.
+ */
+export function chainContractHandler(options) {
+    const { previous, matches, handle, noMatchError } = options;
+    return (req) => {
+        if (!matches(req)) {
+            if (previous)
+                return previous(req);
+            throw new Error(noMatchError(req));
+        }
+        return handle(req);
+    };
+}

package/dist/sdk/test/evm-contract-mock.js

@@ -1,4 +1,5 @@
 import { decodeFunctionData, encodeFunctionResult, } from 'viem';
+import { chainContractHandler } from './contract-mock-core';
 function bytesToHexAddress(bytes) {
     return `0x${Array.from(bytes)
         .map((b) => b.toString(16).padStart(2, '0'))
@@ -49,66 +50,67 @@ export function addContractMock(evmMock, options) {
     const mock = {};
     const normalizedAddress = options.address.toLowerCase();
     const previousCallContract = evmMock.callContract;
-    evmMock.callContract = (req) => {
-        const toBytes = req.call?.to;
-        if (!toBytes || bytesToHexAddress(toBytes) !== normalizedAddress) {
-            if (previousCallContract)
-                return previousCallContract(req);
-            throw new Error(`addContractMock: no mock registered for address ${toBytes ? bytesToHexAddress(toBytes) : '(empty)'}`);
-        }
-        const dataBytes = req.call?.data;
-        if (!dataBytes || dataBytes.length < 4) {
-            throw new Error('addContractMock: call data too short (need at least 4 bytes for selector)');
-        }
-        const callDataHex = bytesToHex(dataBytes);
-        let decoded;
-        try {
-            decoded = decodeFunctionData({
+    evmMock.callContract = chainContractHandler({
+        previous: previousCallContract,
+        matches: (req) => {
+            const toBytes = req.call?.to;
+            return !!toBytes && bytesToHexAddress(toBytes) === normalizedAddress;
+        },
+        noMatchError: (req) => `addContractMock: no mock registered for address ${req.call?.to ? bytesToHexAddress(req.call.to) : '(empty)'}`,
+        handle: (req) => {
+            const dataBytes = req.call?.data;
+            if (!dataBytes || dataBytes.length < 4) {
+                throw new Error('addContractMock: call data too short (need at least 4 bytes for selector)');
+            }
+            const callDataHex = bytesToHex(dataBytes);
+            let decoded;
+            try {
+                decoded = decodeFunctionData({
+                    abi: options.abi,
+                    data: callDataHex,
+                });
+            }
+            catch (e) {
+                if (previousCallContract)
+                    return previousCallContract(req);
+                throw new Error(`addContractMock: failed to decode function data for ${options.address}: ${e instanceof Error ? e.message : e}`);
+            }
+            const handler = mock[decoded.functionName];
+            if (typeof handler !== 'function') {
+                throw new Error(`addContractMock: no handler set for ${decoded.functionName} on ${options.address}`);
+            }
+            const result = handler(...(decoded.args ?? []));
+            const encoded = encodeFunctionResult({
                 abi: options.abi,
-                data: callDataHex,
+                functionName: decoded.functionName,
+                result: result,
             });
-        }
-        catch (e) {
-            if (previousCallContract)
-                return previousCallContract(req);
-            throw new Error(`addContractMock: failed to decode function data for ${options.address}: ${e instanceof Error ? e.message : e}`);
-        }
-        const handler = mock[decoded.functionName];
-        if (typeof handler !== 'function') {
-            throw new Error(`addContractMock: no handler set for ${decoded.functionName} on ${options.address}`);
-        }
-        const result = handler(...(decoded.args ?? []));
-        const encoded = encodeFunctionResult({
-            abi: options.abi,
-            functionName: decoded.functionName,
-            result: result,
-        });
-        return {
-            data: hexToUint8Array(encoded),
-        };
-    };
+            return {
+                data: hexToUint8Array(encoded),
+            };
+        },
+    });
     const previousWriteReport = evmMock.writeReport;
-    evmMock.writeReport = (req) => {
-        const receiverBytes = req.receiver;
-        if (!receiverBytes || bytesToHexAddress(receiverBytes) !== normalizedAddress) {
-            if (previousWriteReport)
-                return previousWriteReport(req);
-            throw new Error(`addContractMock: no writeReport mock registered for receiver ${receiverBytes ? bytesToHexAddress(receiverBytes) : '(empty)'}`);
-        }
-        if (typeof mock.writeReport !== 'function') {
-            throw new Error(`addContractMock: no writeReport handler set for ${options.address}`);
-        }
-        if (!req.report) {
-            throw new Error(`addContractMock: writeReport called without report for ${options.address}`);
-        }
-        if (!req.gasConfig) {
-            throw new Error(`addContractMock: writeReport called without gasConfig for ${options.address}`);
-        }
-        return mock.writeReport({
-            receiver: req.receiver,
-            report: req.report,
-            gasConfig: req.gasConfig,
-        });
-    };
+    evmMock.writeReport = chainContractHandler({
+        previous: previousWriteReport,
+        matches: (req) => !!req.receiver && bytesToHexAddress(req.receiver) === normalizedAddress,
+        noMatchError: (req) => `addContractMock: no writeReport mock registered for receiver ${req.receiver ? bytesToHexAddress(req.receiver) : '(empty)'}`,
+        handle: (req) => {
+            if (typeof mock.writeReport !== 'function') {
+                throw new Error(`addContractMock: no writeReport handler set for ${options.address}`);
+            }
+            if (!req.report) {
+                throw new Error(`addContractMock: writeReport called without report for ${options.address}`);
+            }
+            if (!req.gasConfig) {
+                throw new Error(`addContractMock: writeReport called without gasConfig for ${options.address}`);
+            }
+            return mock.writeReport({
+                receiver: req.receiver,
+                report: req.report,
+                gasConfig: req.gasConfig,
+            });
+        },
+    });
     return mock;
 }

package/dist/sdk/test/index.d.ts

@@ -6,3 +6,4 @@ export { type CapabilityHandler, DEFAULT_MAX_RESPONSE_SIZE_BYTES, getTestCapabil
 export { TestWriter } from '../testutils/test-writer';
 export { type AddContractMockOptions, addContractMock, type ContractMock, type WriteReportMockInput, } from './evm-contract-mock';
 export * from './generated';
+export { type AddSolanaContractMockOptions, addSolanaContractMock, type SolanaContractMock, type SolanaWriteReportMockInput, } from './solana-contract-mock';

package/dist/sdk/test/index.js

@@ -6,3 +6,4 @@ export { DEFAULT_MAX_RESPONSE_SIZE_BYTES, getTestCapabilityHandler, newTestRunti
 export { TestWriter } from '../testutils/test-writer';
 export { addContractMock, } from './evm-contract-mock';
 export * from './generated';
+export { addSolanaContractMock, } from './solana-contract-mock';

package/dist/sdk/test/solana-contract-mock.d.ts

@@ -0,0 +1,54 @@
+import type { AccountMeta, ComputeConfig, WriteReportReply, WriteReportReplyJson } from '../../generated/capabilities/blockchain/solana/v1alpha/client_pb';
+import type { ReportResponse } from '../../generated/sdk/v1alpha/sdk_pb';
+import type { SolanaMock } from './generated';
+/**
+ * Strict version of {@link WriteReportRequest} where `report` is guaranteed
+ * to be present. Used by mock handlers so tests don't need to check for
+ * undefined.
+ */
+export interface SolanaWriteReportMockInput {
+    receiver: Uint8Array;
+    report: ReportResponse;
+    remainingAccounts: AccountMeta[];
+    computeConfig?: ComputeConfig;
+}
+/**
+ * A program mock returned by {@link addSolanaContractMock}.
+ *
+ * The Solana CRE capability is write-only, so the only routable handler is
+ * `writeReport`. When set, write-report calls targeting this program's ID are
+ * routed here; calls for other receivers chain to previously registered mocks.
+ */
+export interface SolanaContractMock {
+    writeReport?: (input: SolanaWriteReportMockInput) => WriteReportReply | WriteReportReplyJson;
+}
+export interface AddSolanaContractMockOptions {
+    /** The receiver program ID — base58 string or 32 raw bytes. */
+    programId: string | Uint8Array;
+}
+/**
+ * Registers a typed program mock on a {@link SolanaMock} instance.
+ *
+ * This is the Solana counterpart of {@link addContractMock}: it intercepts
+ * `writeReport` on the provided mock, routing calls by receiver program ID.
+ * Multiple programs can be mocked on the same `SolanaMock` — each call to
+ * `addSolanaContractMock` chains with the previous handler.
+ *
+ * @example
+ * ```ts
+ * const solanaMock = SolanaMock.testInstance(chainSelector);
+ *
+ * const dataStorage = addSolanaContractMock(solanaMock, {
+ *   programId: 'ECL8142j2YQAvs9R9geSsRnkVH2wLEi7soJCRyJ74cfL',
+ * });
+ *
+ * dataStorage.writeReport = ({ report, remainingAccounts }) => {
+ *   return { txSignature: new Uint8Array(64) };
+ * };
+ * ```
+ *
+ * @param solanaMock - The `SolanaMock` instance to attach to.
+ * @param options - The receiver program ID to route on.
+ * @returns A mock object with a settable `writeReport` handler.
+ */
+export declare function addSolanaContractMock(solanaMock: SolanaMock, options: AddSolanaContractMockOptions): SolanaContractMock;

package/dist/sdk/test/solana-contract-mock.js

@@ -0,0 +1,63 @@
+import { solanaAddressToBytes } from '../utils/capabilities/blockchain/solana/solana-helpers';
+import { chainContractHandler } from './contract-mock-core';
+function bytesEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    return a.every((byte, i) => byte === b[i]);
+}
+function describeReceiver(receiver) {
+    return receiver ? `0x${Buffer.from(receiver).toString('hex')}` : '(empty)';
+}
+/**
+ * Registers a typed program mock on a {@link SolanaMock} instance.
+ *
+ * This is the Solana counterpart of {@link addContractMock}: it intercepts
+ * `writeReport` on the provided mock, routing calls by receiver program ID.
+ * Multiple programs can be mocked on the same `SolanaMock` — each call to
+ * `addSolanaContractMock` chains with the previous handler.
+ *
+ * @example
+ * ```ts
+ * const solanaMock = SolanaMock.testInstance(chainSelector);
+ *
+ * const dataStorage = addSolanaContractMock(solanaMock, {
+ *   programId: 'ECL8142j2YQAvs9R9geSsRnkVH2wLEi7soJCRyJ74cfL',
+ * });
+ *
+ * dataStorage.writeReport = ({ report, remainingAccounts }) => {
+ *   return { txSignature: new Uint8Array(64) };
+ * };
+ * ```
+ *
+ * @param solanaMock - The `SolanaMock` instance to attach to.
+ * @param options - The receiver program ID to route on.
+ * @returns A mock object with a settable `writeReport` handler.
+ */
+export function addSolanaContractMock(solanaMock, options) {
+    const mock = {};
+    const programIdBytes = typeof options.programId === 'string'
+        ? solanaAddressToBytes(options.programId)
+        : options.programId;
+    const programIdLabel = typeof options.programId === 'string' ? options.programId : describeReceiver(options.programId);
+    const previousWriteReport = solanaMock.writeReport;
+    solanaMock.writeReport = chainContractHandler({
+        previous: previousWriteReport,
+        matches: (req) => !!req.receiver && bytesEqual(req.receiver, programIdBytes),
+        noMatchError: (req) => `addSolanaContractMock: no writeReport mock registered for receiver ${describeReceiver(req.receiver)}`,
+        handle: (req) => {
+            if (typeof mock.writeReport !== 'function') {
+                throw new Error(`addSolanaContractMock: no writeReport handler set for ${programIdLabel}`);
+            }
+            if (!req.report) {
+                throw new Error(`addSolanaContractMock: writeReport called without report for ${programIdLabel}`);
+            }
+            return mock.writeReport({
+                receiver: req.receiver,
+                report: req.report,
+                remainingAccounts: req.remainingAccounts,
+                computeConfig: req.computeConfig,
+            });
+        },
+    });
+    return mock;
+}

package/dist/sdk/utils/capabilities/blockchain/{blockchain-helpers.d.ts → evm/evm-helpers.d.ts}

@@ -1,7 +1,8 @@
-import type { CallMsgJson, FilterLogTriggerRequestJson } from '../../../../generated/capabilities/blockchain/evm/v1alpha/client_pb';
-import type { ReportRequestJson } from '../../../../generated/sdk/v1alpha/sdk_pb';
-import { type BigInt as GeneratedBigInt } from '../../../../generated/values/v1/values_pb';
+import type { CallMsgJson, FilterLogTriggerRequestJson } from '../../../../../generated/capabilities/blockchain/evm/v1alpha/client_pb';
+import type { ReportRequestJson } from '../../../../../generated/sdk/v1alpha/sdk_pb';
+import { type BigInt as GeneratedBigInt } from '../../../../../generated/values/v1/values_pb';
 import type { Address, Hex } from 'viem';
+import { type ReportEncoder } from '../report-helpers';
 /**
  * Protobuf BigInt structure returned by SDK methods (e.g., headerByNumber).
  * Uses Pick to extract just the data fields from the generated type.
@@ -20,7 +21,7 @@ export type ProtoBigInt = Pick<GeneratedBigInt, 'absVal' | 'sign'>;
  * @param n - The native bigint, number, or string value.
  * @returns The protobuf BigInt JSON representation.
  */
-export declare const bigintToProtoBigInt: (n: number | bigint | string) => import("../../../../generated/values/v1/values_pb").BigIntJson;
+export declare const bigintToProtoBigInt: (n: number | bigint | string) => import("../../../../../generated/values/v1/values_pb").BigIntJson;
 /**
  * Converts a protobuf BigInt to a native JS bigint.
  * Use this when extracting bigint values from SDK responses.
@@ -41,7 +42,7 @@ export declare const protoBigIntToBigint: (pb: ProtoBigInt) => bigint;
  * @param n - The block number.
  * @returns The protobuf BigInt JSON representation.
  */
-export declare const blockNumber: (n: number | bigint | string) => import("../../../../generated/values/v1/values_pb").BigIntJson;
+export declare const blockNumber: (n: number | bigint | string) => import("../../../../../generated/values/v1/values_pb").BigIntJson;
 /**
  * EVM Capability Helper.
  *
@@ -106,7 +107,7 @@ export declare const EVM_DEFAULT_REPORT_ENCODER: {
  * @param reportEncoder - The report encoder to be used. Defaults to EVM_DEFAULT_REPORT_ENCODER.
  * @returns The prepared report request.
  */
-export declare const prepareReportRequest: (hexEncodedPayload: Hex, reportEncoder?: Omit<ReportRequestJson, "encodedPayload">) => ReportRequestJson;
+export declare const prepareReportRequest: (hexEncodedPayload: Hex, reportEncoder?: ReportEncoder) => ReportRequestJson;
 export interface LogTriggerConfigOptions {
     /** EVM addresses to monitor — hex strings with 0x prefix (20 bytes each) */
     addresses: Hex[];

package/dist/sdk/utils/capabilities/blockchain/{blockchain-helpers.js → evm/evm-helpers.js}

@@ -1,8 +1,9 @@
 import { create, toJson } from '@bufbuild/protobuf';
-import { BigIntSchema } from '../../../../generated/values/v1/values_pb';
-import { EVMClient } from '../../../cre';
-import { bigintToBytes, bytesToBigint, hexToBase64, hexToBytes } from '../../hex-utils';
-import { assertSafeIntegerNumber } from '../../safe-integer';
+import { BigIntSchema } from '../../../../../generated/values/v1/values_pb';
+import { EVMClient } from '../../../../cre';
+import { bigintToBytes, bytesToBigint, hexToBase64, hexToBytes } from '../../../hex-utils';
+import { assertSafeIntegerNumber } from '../../../safe-integer';
+import { prepareReportRequestFromBytes } from '../report-helpers';
 /**
  * Converts a native JS bigint to a protobuf BigInt JSON representation.
  * Use this when passing bigint values to SDK methods.
@@ -126,10 +127,7 @@ export const EVM_DEFAULT_REPORT_ENCODER = {
  * @param reportEncoder - The report encoder to be used. Defaults to EVM_DEFAULT_REPORT_ENCODER.
  * @returns The prepared report request.
  */
-export const prepareReportRequest = (hexEncodedPayload, reportEncoder = EVM_DEFAULT_REPORT_ENCODER) => ({
-    encodedPayload: hexToBase64(hexEncodedPayload),
-    ...reportEncoder,
-});
+export const prepareReportRequest = (hexEncodedPayload, reportEncoder = EVM_DEFAULT_REPORT_ENCODER) => prepareReportRequestFromBytes(hexToBytes(hexEncodedPayload), reportEncoder);
 /**
  * Validates a hex string and checks that the decoded bytes have the expected length.
  */

package/dist/sdk/utils/capabilities/blockchain/report-helpers.d.ts

@@ -0,0 +1,19 @@
+import type { ReportRequestJson } from '../../../../generated/sdk/v1alpha/sdk_pb';
+/**
+ * Report-encoder settings for a chain family (everything in a `ReportRequest`
+ * except the payload itself). See `EVM_DEFAULT_REPORT_ENCODER` and
+ * `SOLANA_DEFAULT_REPORT_ENCODER` for the per-chain defaults.
+ */
+export type ReportEncoder = Omit<ReportRequestJson, 'encodedPayload'>;
+/**
+ * Chain-agnostic core for building a `ReportRequest` from raw payload bytes.
+ *
+ * Per-chain wrappers (`prepareReportRequest` for EVM hex payloads,
+ * `prepareSolanaReportRequest` for Solana Borsh payloads) delegate here so
+ * there is a single payload-assembly path.
+ *
+ * @param payload - The raw payload bytes to be signed.
+ * @param reportEncoder - The report encoder settings to use.
+ * @returns The prepared report request.
+ */
+export declare const prepareReportRequestFromBytes: (payload: Uint8Array, reportEncoder: ReportEncoder) => ReportRequestJson;

package/dist/sdk/utils/capabilities/blockchain/report-helpers.js

@@ -0,0 +1,16 @@
+import { bytesToBase64 } from '../../hex-utils';
+/**
+ * Chain-agnostic core for building a `ReportRequest` from raw payload bytes.
+ *
+ * Per-chain wrappers (`prepareReportRequest` for EVM hex payloads,
+ * `prepareSolanaReportRequest` for Solana Borsh payloads) delegate here so
+ * there is a single payload-assembly path.
+ *
+ * @param payload - The raw payload bytes to be signed.
+ * @param reportEncoder - The report encoder settings to use.
+ * @returns The prepared report request.
+ */
+export const prepareReportRequestFromBytes = (payload, reportEncoder) => ({
+    encodedPayload: bytesToBase64(payload),
+    ...reportEncoder,
+});

package/dist/sdk/utils/capabilities/blockchain/solana/solana-helpers.d.ts

@@ -0,0 +1,101 @@
+import type { AccountMetaJson, ComputeConfigJson } from '../../../../../generated/capabilities/blockchain/solana/v1alpha/client_pb';
+import type { ReportRequestJson } from '../../../../../generated/sdk/v1alpha/sdk_pb';
+import { type ReportEncoder } from '../report-helpers';
+/**
+ * An account passed to the Solana capability's `remainingAccounts` list.
+ * Build instances with {@link solanaAccountMeta}; generated bindings convert
+ * to the capability's protobuf JSON shape internally.
+ */
+export interface SolanaAccountMeta {
+    publicKey: Uint8Array;
+    isWritable: boolean;
+}
+/**
+ * Compute settings for a Solana write-report request. Mirrors the
+ * capability's `ComputeConfig` protobuf JSON shape.
+ */
+export type SolanaComputeConfig = ComputeConfigJson;
+/**
+ * The minimal account shape needed by {@link calculateAccountsHash} —
+ * only the public key participates in the hash. Structurally compatible
+ * with both {@link SolanaAccountMeta} and the capability's protobuf
+ * `AccountMeta`.
+ */
+export type SolanaAccountInput = Pick<SolanaAccountMeta, 'publicKey'> & Partial<Pick<SolanaAccountMeta, 'isWritable'>>;
+/**
+ * Converts a base58-encoded Solana address to its 32 raw bytes.
+ *
+ * @param base58Address - The base58-encoded address (validated).
+ * @returns The 32-byte public key.
+ */
+export declare const solanaAddressToBytes: (base58Address: string) => Uint8Array;
+/**
+ * Builds an account entry for the Solana capability's `remainingAccounts` list.
+ *
+ * @param publicKey - The account's public key, as 32 raw bytes or a base58 string.
+ * @param isWritable - Whether the account is writable. Defaults to false.
+ * @returns The account meta.
+ */
+export declare const solanaAccountMeta: (publicKey: Uint8Array | string, isWritable?: boolean) => SolanaAccountMeta;
+/**
+ * Converts {@link SolanaAccountMeta} entries to the capability's protobuf
+ * JSON `AccountMeta` shape (base64 public keys), as expected by
+ * `SolanaClient.writeReport`. Used by generated bindings.
+ */
+export declare const solanaAccountMetasToJson: (accounts: ReadonlyArray<SolanaAccountMeta>) => AccountMetaJson[];
+/**
+ * Computes the SHA-256 hash of the concatenated public keys of the given
+ * accounts, matching the keystone-forwarder's on-chain account hash
+ * verification. Nullish entries are skipped; account order matters.
+ *
+ * Mirrors Go `bindings.CalculateAccountsHash`.
+ *
+ * @param accounts - The accounts whose public keys are hashed.
+ * @returns The 32-byte account hash.
+ */
+export declare const calculateAccountsHash: (accounts: ReadonlyArray<SolanaAccountInput | null | undefined>) => Uint8Array;
+export interface ForwarderReport {
+    /** The 32-byte hash from `calculateAccountsHash`. */
+    accountHash: Uint8Array;
+    /** The Borsh-encoded report payload the receiver's `on_report` deserializes. */
+    payload: Uint8Array;
+}
+/**
+ * Borsh-encodes a `ForwarderReport` for the keystone-forwarder:
+ * `[32-byte accountHash][u32-LE payload length][payload bytes]`.
+ *
+ * Mirrors Go `bindings.ForwarderReport.Marshal`.
+ *
+ * @param report - The account hash and payload to encode.
+ * @returns The encoded forwarder report.
+ */
+export declare const encodeForwarderReport: (report: ForwarderReport) => Uint8Array;
+/**
+ * Returns the Anchor/Borsh encoding of a Vec whose elements are opaque byte
+ * payloads: `[u32-LE element count][concatenated element payloads]`.
+ * Each element must already be fully serialized for one Vec item on the wire.
+ *
+ * Mirrors Go's generated `EncodeBorshVecU32`.
+ *
+ * @param elementPayloads - The pre-encoded Vec elements.
+ * @returns The encoded Vec.
+ */
+export declare const encodeBorshVecU32: (elementPayloads: ReadonlyArray<Uint8Array>) => Uint8Array;
+/**
+ * Default values expected by the Solana capability for report encoding.
+ * Mirrors the constants emitted by the Go Solana bindings generator.
+ */
+export declare const SOLANA_DEFAULT_REPORT_ENCODER: {
+    encoderName: string;
+    signingAlgo: string;
+    hashingAlgo: string;
+};
+/**
+ * Prepares a report request for the Solana capability to pass to `.report()`.
+ * Takes raw bytes (typically an encoded `ForwarderReport`), not hex.
+ *
+ * @param payload - The encoded payload bytes to be signed.
+ * @param reportEncoder - The report encoder to use. Defaults to SOLANA_DEFAULT_REPORT_ENCODER.
+ * @returns The prepared report request.
+ */
+export declare const prepareSolanaReportRequest: (payload: Uint8Array, reportEncoder?: ReportEncoder) => ReportRequestJson;

package/dist/sdk/utils/capabilities/blockchain/solana/solana-helpers.js

@@ -0,0 +1,100 @@
+import { bytesToBase64 } from '../../../hex-utils';
+import { sha256 } from '@noble/hashes/sha2';
+import { concatBytes } from '@noble/hashes/utils';
+import { address, getAddressEncoder } from '@solana/addresses';
+import { prepareReportRequestFromBytes } from '../report-helpers';
+const ACCOUNT_HASH_LENGTH = 32;
+const U32_LENGTH = 4;
+// Stateless address encoder; hoisted so the encoder stack isn't rebuilt per call.
+const ADDRESS_ENCODER = getAddressEncoder();
+/** Encodes a number as a little-endian Borsh u32. */
+const u32LE = (value) => {
+    const bytes = new Uint8Array(U32_LENGTH);
+    new DataView(bytes.buffer).setUint32(0, value, true);
+    return bytes;
+};
+/**
+ * Converts a base58-encoded Solana address to its 32 raw bytes.
+ *
+ * @param base58Address - The base58-encoded address (validated).
+ * @returns The 32-byte public key.
+ */
+export const solanaAddressToBytes = (base58Address) => new Uint8Array(ADDRESS_ENCODER.encode(address(base58Address)));
+/**
+ * Builds an account entry for the Solana capability's `remainingAccounts` list.
+ *
+ * @param publicKey - The account's public key, as 32 raw bytes or a base58 string.
+ * @param isWritable - Whether the account is writable. Defaults to false.
+ * @returns The account meta.
+ */
+export const solanaAccountMeta = (publicKey, isWritable = false) => ({
+    publicKey: typeof publicKey === 'string' ? solanaAddressToBytes(publicKey) : publicKey,
+    isWritable,
+});
+/**
+ * Converts {@link SolanaAccountMeta} entries to the capability's protobuf
+ * JSON `AccountMeta` shape (base64 public keys), as expected by
+ * `SolanaClient.writeReport`. Used by generated bindings.
+ */
+export const solanaAccountMetasToJson = (accounts) => accounts.map((account) => ({
+    publicKey: bytesToBase64(account.publicKey),
+    isWritable: account.isWritable,
+}));
+/**
+ * Computes the SHA-256 hash of the concatenated public keys of the given
+ * accounts, matching the keystone-forwarder's on-chain account hash
+ * verification. Nullish entries are skipped; account order matters.
+ *
+ * Mirrors Go `bindings.CalculateAccountsHash`.
+ *
+ * @param accounts - The accounts whose public keys are hashed.
+ * @returns The 32-byte account hash.
+ */
+export const calculateAccountsHash = (accounts) => {
+    const publicKeys = accounts.filter((acc) => acc != null).map(({ publicKey }) => publicKey);
+    return sha256(concatBytes(...publicKeys));
+};
+/**
+ * Borsh-encodes a `ForwarderReport` for the keystone-forwarder:
+ * `[32-byte accountHash][u32-LE payload length][payload bytes]`.
+ *
+ * Mirrors Go `bindings.ForwarderReport.Marshal`.
+ *
+ * @param report - The account hash and payload to encode.
+ * @returns The encoded forwarder report.
+ */
+export const encodeForwarderReport = (report) => {
+    if (report.accountHash.length !== ACCOUNT_HASH_LENGTH) {
+        throw new Error(`encodeForwarderReport: accountHash must be exactly ${ACCOUNT_HASH_LENGTH} bytes, got ${report.accountHash.length}`);
+    }
+    return concatBytes(report.accountHash, u32LE(report.payload.length), report.payload);
+};
+/**
+ * Returns the Anchor/Borsh encoding of a Vec whose elements are opaque byte
+ * payloads: `[u32-LE element count][concatenated element payloads]`.
+ * Each element must already be fully serialized for one Vec item on the wire.
+ *
+ * Mirrors Go's generated `EncodeBorshVecU32`.
+ *
+ * @param elementPayloads - The pre-encoded Vec elements.
+ * @returns The encoded Vec.
+ */
+export const encodeBorshVecU32 = (elementPayloads) => concatBytes(u32LE(elementPayloads.length), ...elementPayloads);
+/**
+ * Default values expected by the Solana capability for report encoding.
+ * Mirrors the constants emitted by the Go Solana bindings generator.
+ */
+export const SOLANA_DEFAULT_REPORT_ENCODER = {
+    encoderName: 'solana',
+    signingAlgo: 'ecdsa',
+    hashingAlgo: 'keccak256',
+};
+/**
+ * Prepares a report request for the Solana capability to pass to `.report()`.
+ * Takes raw bytes (typically an encoded `ForwarderReport`), not hex.
+ *
+ * @param payload - The encoded payload bytes to be signed.
+ * @param reportEncoder - The report encoder to use. Defaults to SOLANA_DEFAULT_REPORT_ENCODER.
+ * @returns The prepared report request.
+ */
+export const prepareSolanaReportRequest = (payload, reportEncoder = SOLANA_DEFAULT_REPORT_ENCODER) => prepareReportRequestFromBytes(payload, reportEncoder);

package/dist/sdk/utils/hex-utils.d.ts

@@ -13,6 +13,12 @@ export declare const hexToBytes: (hexStr: string) => Uint8Array;
  * Convert Uint8Array to hex string with 0x prefix
  */
 export declare const bytesToHex: (bytes: Uint8Array) => Hex;
+/**
+ * Encode raw bytes as base64 string
+ * @param bytes
+ * @returns
+ */
+export declare const bytesToBase64: (bytes: Uint8Array) => string;
 /**
  * Encode hex as base64 string
  * @param hex

package/dist/sdk/utils/hex-utils.js

@@ -28,6 +28,14 @@ export const bytesToHex = (bytes) => {
         .map((b) => b.toString(16).padStart(2, '0'))
         .join('')}`;
 };
+/**
+ * Encode raw bytes as base64 string
+ * @param bytes
+ * @returns
+ */
+export const bytesToBase64 = (bytes) => {
+    return Buffer.from(bytes).toString('base64');
+};
 /**
  * Encode hex as base64 string
  * @param hex

package/dist/sdk/utils/index.d.ts

@@ -1,4 +1,6 @@
-export * from './capabilities/blockchain/blockchain-helpers';
+export * from './capabilities/blockchain/evm/evm-helpers';
+export type { ReportEncoder } from './capabilities/blockchain/report-helpers';
+export * from './capabilities/blockchain/solana/solana-helpers';
 export * from './capabilities/http/http-helpers';
 export * from './chain-selectors';
 export * from './decode-json';

package/dist/sdk/utils/index.js

@@ -1,4 +1,5 @@
-export * from './capabilities/blockchain/blockchain-helpers';
+export * from './capabilities/blockchain/evm/evm-helpers';
+export * from './capabilities/blockchain/solana/solana-helpers';
 export * from './capabilities/http/http-helpers';
 export * from './chain-selectors';
 export * from './decode-json';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@chainlink/cre-sdk",
-	"version": "1.13.0",
+	"version": "1.14.0-solana-alpha-1",
 	"type": "module",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -61,7 +61,10 @@
 	"dependencies": {
 		"@bufbuild/protobuf": "2.6.3",
 		"@bufbuild/protoc-gen-es": "2.6.3",
-		"@chainlink/cre-sdk-javy-plugin": "1.7.0",
+		"@chainlink/cre-sdk-javy-plugin": "1.8.0-solana-alpha-1",
+		"@noble/hashes": "1.8.0",
+		"@solana/addresses": "6.9.0",
+		"@solana/codecs": "6.9.0",
 		"@standard-schema/spec": "1.0.0",
 		"viem": "2.34.0",
 		"zod": "3.25.76"