@chainlink/cre-sdk 1.17.0-alpha.1 → 1.17.0-alpha.2

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/testutils/index.d.ts

@@ -2,5 +2,5 @@
  * Test-only utilities for the CRE SDK runtime. Not part of the public API.
  * Use for unit testing runtime logic without the WASM execution environment.
  */
-export { type CapabilityHandler, DEFAULT_MAX_RESPONSE_SIZE_BYTES, getTestCapabilityHandler, type NewTestRuntimeOptions, newTestRuntime, REPORT_METADATA_HEADER_LENGTH, RESPONSE_BUFFER_TOO_SMALL, registerTestCapability, type Secrets, TestRuntime, type TestRuntimeState, TestTeeRuntime, test, } from './test-runtime';
+export { type CapabilityHandler, DEFAULT_MAX_RESPONSE_SIZE_BYTES, getTestCapabilityHandler, type NewTestRuntimeOptions, newTestRuntime, REPORT_METADATA_HEADER_LENGTH, RESPONSE_BUFFER_TOO_SMALL, registerTestCapability, type Secrets, TestRuntime, type TestRuntimeState, test, } from './test-runtime';
 export { TestWriter } from './test-writer';

package/dist/sdk/testutils/index.js

@@ -2,5 +2,5 @@
  * Test-only utilities for the CRE SDK runtime. Not part of the public API.
  * Use for unit testing runtime logic without the WASM execution environment.
  */
-export { DEFAULT_MAX_RESPONSE_SIZE_BYTES, getTestCapabilityHandler, newTestRuntime, REPORT_METADATA_HEADER_LENGTH, RESPONSE_BUFFER_TOO_SMALL, registerTestCapability, TestRuntime, TestTeeRuntime, test, } from './test-runtime';
+export { DEFAULT_MAX_RESPONSE_SIZE_BYTES, getTestCapabilityHandler, newTestRuntime, REPORT_METADATA_HEADER_LENGTH, RESPONSE_BUFFER_TOO_SMALL, registerTestCapability, TestRuntime, test, } from './test-runtime';
 export { TestWriter } from './test-writer';

package/dist/sdk/testutils/test-runtime.d.ts

@@ -3,9 +3,8 @@
  * Registry is scoped per test via AsyncLocalStorage; use testWithRuntime to run tests with a registry.
  */
 import type { Any } from '@bufbuild/protobuf/wkt';
-import type { WorkflowUserMetric } from '../../generated/workflows/v2/workflow_user_metric_pb';
 import type { RuntimeHelpers } from '../impl/runtime-impl';
-import { RuntimeImpl, TeeRuntimeImpl } from '../impl/runtime-impl';
+import { RuntimeImpl } from '../impl/runtime-impl';
 import { TestWriter } from './test-writer';
 /** Error message when response exceeds max size. Used by the harness when its await implements the size check. */
 export declare const RESPONSE_BUFFER_TOO_SMALL = "response buffer too small";
@@ -71,27 +70,15 @@ export declare function test(title: string, fn: () => void | Promise<void>): voi
 /**
  * Creates a test runtime. This must be called from within a test in this package.
  */
-export declare function newTestRuntime<T = unknown>(secrets?: Secrets | null, options?: NewTestRuntimeOptions, config?: T | undefined): TestRuntime<T>;
+export declare function newTestRuntime(secrets?: Secrets | null, options?: NewTestRuntimeOptions): TestRuntime;
 /**
  * TestRuntime is a Runtime implementation for unit tests. Extends RuntimeImpl; construct via newTestRuntime.
  * Adds getLogs() and setTimeProvider(). Registry is accessed via getTestCapabilityHandler when inside testWithRuntime.
  */
-export declare class TestRuntime<T> extends RuntimeImpl<T> {
+export declare class TestRuntime extends RuntimeImpl<unknown> {
     private readonly testWriter;
     private readonly state;
-    constructor(helpers: RuntimeHelpers, maxResponseSize: bigint, testWriter: TestWriter, state: TestRuntimeState, config?: T | undefined);
+    constructor(helpers: RuntimeHelpers, maxResponseSize: bigint, testWriter: TestWriter, state: TestRuntimeState);
     getLogs(): string[];
     setTimeProvider(timeProvider: () => number): void;
 }
-/**
- * TestTeeRuntime is a TeeRuntime implementation for unit tests. Extends TeeRuntimeImpl; construct via newTestTEERuntime.
- * Adds getLogs() and setTimeProvider(). Registry is accessed via getTestCapabilityHandler when inside testWithRuntime.
- */
-export declare class TestTeeRuntime<T> extends TeeRuntimeImpl<T> {
-    private readonly testWriter;
-    private readonly state;
-    constructor(helpers: RuntimeHelpers, maxResponseSize: bigint, testWriter: TestWriter, state: TestRuntimeState, config: T);
-    getLogs(): string[];
-    getMetrics(): WorkflowUserMetric[];
-    setTimeProvider(timeProvider: () => number): void;
-}

package/dist/sdk/testutils/test-runtime.js

@@ -8,7 +8,7 @@ import { create, toBinary } from '@bufbuild/protobuf';
 import { anyPack, anyUnpack } from '@bufbuild/protobuf/wkt';
 import { AttributedSignatureSchema, AwaitCapabilitiesResponseSchema, AwaitSecretsResponseSchema, CapabilityResponseSchema, ReportRequestSchema, ReportResponseSchema, SecretErrorSchema, SecretResponseSchema, SecretResponsesSchema, SecretSchema, SimpleConsensusInputsSchema, } from '../../generated/sdk/v1alpha/sdk_pb';
 import { ValueSchema } from '../../generated/values/v1/values_pb';
-import { RuntimeImpl, TeeRuntimeImpl } from '../impl/runtime-impl';
+import { RuntimeImpl } from '../impl/runtime-impl';
 import { TestWriter } from './test-writer';
 /** Error message when response exceeds max size. Used by the harness when its await implements the size check. */
 export const RESPONSE_BUFFER_TOO_SMALL = 'response buffer too small';
@@ -239,10 +239,6 @@ function createTestRuntimeHelpers(registry, secrets, testWriter, state, _maxResp
         log(message) {
             testWriter.log(message);
         },
-        emitMetric(payload) {
-            testWriter.emitMetric(payload);
-            return true;
-        },
     };
 }
 /**
@@ -262,7 +258,7 @@ export function test(title, fn) {
 /**
  * Creates a test runtime. This must be called from within a test in this package.
  */
-export function newTestRuntime(secrets, options = {}, config = undefined) {
+export function newTestRuntime(secrets, options = {}) {
     const secretsMap = secrets ?? new Map();
     const testWriter = new TestWriter();
     const registry = registryStorage.getStore() ?? new Registry();
@@ -301,7 +297,7 @@ export function newTestRuntime(secrets, options = {}, config = undefined) {
     }
     const maxResponseSize = BigInt(configuredMaxResponseSize);
     const helpers = createTestRuntimeHelpers(registry, secretsMap, testWriter, state, maxResponseSize);
-    return new TestRuntime(helpers, maxResponseSize, testWriter, state, config);
+    return new TestRuntime(helpers, maxResponseSize, testWriter, state);
 }
 /**
  * TestRuntime is a Runtime implementation for unit tests. Extends RuntimeImpl; construct via newTestRuntime.
@@ -310,36 +306,14 @@ export function newTestRuntime(secrets, options = {}, config = undefined) {
 export class TestRuntime extends RuntimeImpl {
     testWriter;
     state;
-    constructor(helpers, maxResponseSize, testWriter, state, config = undefined) {
-        super(config ?? {}, 0, helpers, maxResponseSize);
-        this.testWriter = testWriter;
-        this.state = state;
-    }
-    getLogs() {
-        return this.testWriter.getLogs();
-    }
-    setTimeProvider(timeProvider) {
-        this.state.timeProvider = timeProvider;
-    }
-}
-/**
- * TestTeeRuntime is a TeeRuntime implementation for unit tests. Extends TeeRuntimeImpl; construct via newTestTEERuntime.
- * Adds getLogs() and setTimeProvider(). Registry is accessed via getTestCapabilityHandler when inside testWithRuntime.
- */
-export class TestTeeRuntime extends TeeRuntimeImpl {
-    testWriter;
-    state;
-    constructor(helpers, maxResponseSize, testWriter, state, config) {
-        super(config, 0, helpers, maxResponseSize);
+    constructor(helpers, maxResponseSize, testWriter, state) {
+        super({}, 0, helpers, maxResponseSize);
         this.testWriter = testWriter;
         this.state = state;
     }
     getLogs() {
         return this.testWriter.getLogs();
     }
-    getMetrics() {
-        return this.testWriter.getMetrics();
-    }
     setTimeProvider(timeProvider) {
         this.state.timeProvider = timeProvider;
     }

package/dist/sdk/testutils/test-writer.d.ts

@@ -1,19 +1,13 @@
-import { type WorkflowUserMetric } from '../../generated/workflows/v2/workflow_user_metric_pb';
 /**
  * In-memory log sink for tests. Captures messages so tests can assert on log output.
  * Equivalent to Go's cre/testutils/test_writer.go.
  */
 export declare class TestWriter {
     private logs;
-    private metrics;
     /** Appends a message to the captured log buffer. */
     log(message: string): void;
     /** Returns a copy of all captured log messages in order. */
     getLogs(): string[];
-    /** Captures a serialized WorkflowUserMetric payload. */
-    emitMetric(payload: Uint8Array): void;
-    /** Returns captured metric payloads decoded as `WorkflowUserMetric` protos. */
-    getMetrics(): WorkflowUserMetric[];
-    /** Clears captured logs and metrics. */
+    /** Clears the captured log buffer. */
     clear(): void;
 }

package/dist/sdk/testutils/test-writer.js

@@ -1,12 +1,9 @@
-import { fromBinary } from '@bufbuild/protobuf';
-import { WorkflowUserMetricSchema, } from '../../generated/workflows/v2/workflow_user_metric_pb';
 /**
  * In-memory log sink for tests. Captures messages so tests can assert on log output.
  * Equivalent to Go's cre/testutils/test_writer.go.
  */
 export class TestWriter {
     logs = [];
-    metrics = [];
     /** Appends a message to the captured log buffer. */
     log(message) {
         this.logs.push(message);
@@ -15,17 +12,8 @@ export class TestWriter {
     getLogs() {
         return [...this.logs];
     }
-    /** Captures a serialized WorkflowUserMetric payload. */
-    emitMetric(payload) {
-        this.metrics.push(payload);
-    }
-    /** Returns captured metric payloads decoded as `WorkflowUserMetric` protos. */
-    getMetrics() {
-        return this.metrics.map((bytes) => fromBinary(WorkflowUserMetricSchema, bytes));
-    }
-    /** Clears captured logs and metrics. */
+    /** Clears the captured log buffer. */
     clear() {
         this.logs = [];
-        this.metrics = [];
     }
 }

package/dist/sdk/types/global.d.ts

@@ -45,14 +45,6 @@ declare global {
 	 */
 	function log(message: string): void
 
-	/**
-	 * Emits a user metric to the host. The payload is a protobuf-encoded
-	 * `workflows.v2.WorkflowUserMetric` message.
-	 * @param payload - protobuf-encoded WorkflowUserMetric bytes
-	 * @returns 0 on success, negative on error (rate-limited, oversized, invalid name, etc.)
-	 */
-	function emitMetric(payload: Uint8Array): number
-
 	/**
 	 * Sends a response back to the host
 	 * @param response - bytes response

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,165 @@
+import type { AccountMetaJson, ComputeConfigJson, CPIFilterConfigJson, Log } 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;
+/**
+ * A filter value accepted by {@link prepareSubkeyValue}.
+ * Solana public keys must be passed as their 32 raw bytes
+ * (see {@link solanaAddressToBytes}), not as base58 strings.
+ */
+export type SolanaSubkeyValue = Uint8Array | string | bigint | number;
+/**
+ * Encodes a filter value for use in a `SubkeyConfig` `ValueComparator`,
+ * matching the byte representation the Solana log-trigger capability indexes.
+ *
+ * Encodings (mirrors Go `bindings.PrepareSubkeyValue`):
+ * - `Uint8Array` — used as-is (public keys, fixed byte arrays, `bytes` fields)
+ * - `string` — UTF-8 bytes
+ * - `bigint` / integer `number` — 8-byte big-endian two's complement
+ *
+ * For `f32`/`f64` event fields use {@link prepareSubkeyFloatValue}; passing a
+ * non-integer `number` here throws.
+ *
+ * @param value - The filter value to encode.
+ * @returns The encoded comparator value bytes.
+ */
+export declare const prepareSubkeyValue: (value: SolanaSubkeyValue) => Uint8Array;
+/**
+ * Encodes an `f32`/`f64` filter value into the 8-byte big-endian
+ * representation the Solana log-trigger capability indexes.
+ *
+ * Byte-compatible with Go `bindings.EncodeIndexedValue` for floats: positive
+ * values map to `float64bits + 2^63`, others to `2^63 - float64bits`
+ * (modulo 2^64). Ordering is preserved among values of the same sign.
+ *
+ * @param value - The float filter value to encode.
+ * @returns The encoded comparator value bytes.
+ */
+export declare const prepareSubkeyFloatValue: (value: number) => Uint8Array;
+/**
+ * A Solana log paired with its decoded event data. Generated log-trigger
+ * bindings adapt raw `Log` payloads into this shape.
+ *
+ * Mirrors Go `bindings.DecodedLog[T]`.
+ */
+export type SolanaDecodedLog<T> = {
+    log: Log;
+    data: T;
+};
+/** Options for generated Solana log-trigger bindings. */
+export interface SolanaLogTriggerOptions {
+    /**
+     * Listen for events emitted via Anchor's `emit_cpi!` (self-CPI) instead of
+     * program logs. Sets the trigger's CPI filter to the program's
+     * `anchor:event` method (see {@link anchorCPILogTriggerConfig}).
+     */
+    cpi?: boolean;
+}
+/**
+ * Builds the `CPIFilterConfig` for log triggers on events emitted via
+ * Anchor's `emit_cpi!`: destination is the program itself, method is
+ * `anchor:event`.
+ *
+ * Mirrors Go `bindings.AnchorCPILogTriggerConfig`.
+ *
+ * @param programId - The program's public key, as 32 raw bytes or a base58 string.
+ * @returns The CPI filter config in protobuf JSON shape.
+ */
+export declare const anchorCPILogTriggerConfig: (programId: Uint8Array | string) => CPIFilterConfigJson;