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

package/dist/sdk/wasm/runner.js

@@ -1,21 +1,21 @@
-import { create, fromBinary, toBinary } from '@bufbuild/protobuf';
-import { ExecuteRequestSchema, ExecutionResultSchema, TriggerSubscriptionRequestSchema, } from '../../generated/sdk/v1alpha/sdk_pb';
+import { create, fromBinary, fromJson, toBinary } from '@bufbuild/protobuf';
+import { ExecuteRequestSchema, ExecutionResultSchema, RestrictionsSchema, TriggerSubscriptionRequestSchema, } from '../../generated/sdk/v1alpha/sdk_pb';
 import { configHandler } from '../utils/config';
 import { Value } from '../utils';
 import { hostBindings } from './host-bindings';
-import { Runtime } from './runtime';
-export class Runner {
+import { Runtime, TeeRuntime } from './runtime';
+class RunnerBase {
     config;
     request;
     constructor(config, request) {
         this.config = config;
         this.request = request;
     }
-    static async newRunner(configHandlerParams) {
+    static async newRunnerHelper(newRunner, configHandlerParams) {
         hostBindings.versionV2();
-        const request = Runner.getRequest();
+        const request = RunnerBase.getRequest();
         const config = await configHandler(request, configHandlerParams);
-        return new Runner(config, request);
+        return newRunner(config, request);
     }
     static getRequest() {
         const argsString = hostBindings.getWasiArgs();
@@ -38,11 +38,15 @@ export class Runner {
     }
     async run(initFn) {
         const runtime = new Runtime(this.config, 0, this.request.maxResponseSize);
+        // wrap runtime's getSecret so other methods cannot be used
+        const sp = {
+            getSecret: (request) => {
+                return runtime.getSecret(request);
+            },
+        };
         let result;
         try {
-            const workflow = await initFn(this.config, {
-                getSecret: runtime.getSecret.bind(runtime),
-            });
+            const workflow = await initFn(this.config, sp);
             switch (this.request.request.case) {
                 case 'subscribe':
                     result = this.handleSubscribePhase(this.request, workflow);
@@ -50,8 +54,11 @@ export class Runner {
                 case 'trigger':
                     result = this.handleExecutionPhase(this.request, workflow, runtime);
                     break;
+                case 'preHook':
+                    result = this.handlePreHookPhase(this.request, workflow);
+                    break;
                 default:
-                    throw new Error(`Unknown request type '${this.request.request.case}': expected 'subscribe' or 'trigger'. This may indicate a version mismatch between the SDK and the CRE runtime`);
+                    throw new Error(`Unknown request type '${this.request.request.case}': expected 'subscribe', 'trigger', or 'preHook'. This may indicate a version mismatch between the SDK and the CRE runtime`);
             }
         }
         catch (e) {
@@ -95,8 +102,10 @@ export class Runner {
              * */
             const decoded = fromBinary(schema, payloadAny.value);
             const adapted = entry.trigger.adapt(decoded);
+            // If the handler has requirements (e.g. TEE), use TeeRuntime; otherwise use the default runtime.
+            const handlerRuntime = entry.requirements != null ? new TeeRuntime(this.config, 0, req.maxResponseSize) : runtime;
             try {
-                const result = await entry.fn(runtime, adapted);
+                const result = await entry.fn(handlerRuntime, adapted);
                 const wrapped = Value.wrap(result);
                 return create(ExecutionResultSchema, {
                     result: { case: 'value', value: wrapped.proto() },
@@ -116,6 +125,60 @@ export class Runner {
             },
         });
     }
+    handlePreHookPhase(req, workflow) {
+        if (req.request.case !== 'preHook') {
+            return create(ExecutionResultSchema, {
+                result: {
+                    case: 'error',
+                    value: `preHook request expected but received '${req.request.case}' in handlePreHookPhase. This is an internal SDK error`,
+                },
+            });
+        }
+        const triggerMsg = req.request.value;
+        const id = BigInt(triggerMsg.id);
+        if (id > BigInt(Number.MAX_SAFE_INTEGER)) {
+            return create(ExecutionResultSchema, {
+                result: {
+                    case: 'error',
+                    value: `Trigger ID ${id} exceeds JavaScript safe integer range (Number.MAX_SAFE_INTEGER = ${Number.MAX_SAFE_INTEGER}). This trigger ID cannot be safely represented as a number`,
+                },
+            });
+        }
+        const index = Number(triggerMsg.id);
+        if (!Number.isFinite(index) || index < 0 || index >= workflow.length) {
+            return create(ExecutionResultSchema, {
+                result: {
+                    case: 'error',
+                    value: `trigger not found: no workflow handler registered at index ${index} (trigger ID ${triggerMsg.id}). The workflow has ${workflow.length} handler(s) registered. Verify the trigger subscription matches a registered handler`,
+                },
+            });
+        }
+        const entry = workflow[index];
+        if (!entry.hooks?.preHook) {
+            return create(ExecutionResultSchema, {
+                result: {
+                    case: 'error',
+                    value: `no preHook registered for handler at index ${index} (trigger ID ${triggerMsg.id}). The handler was subscribed with preHook enabled but no preHook function was provided`,
+                },
+            });
+        }
+        if (!triggerMsg.payload) {
+            return create(ExecutionResultSchema, {
+                result: {
+                    case: 'error',
+                    value: `trigger payload is missing for preHook at index ${index} (trigger ID ${triggerMsg.id}). The trigger event must include a payload`,
+                },
+            });
+        }
+        const schema = entry.trigger.outputSchema();
+        const decoded = fromBinary(schema, triggerMsg.payload.value);
+        const adapted = entry.trigger.adapt(decoded);
+        const restrictionsJson = entry.hooks.preHook(this.config, adapted);
+        const restrictions = fromJson(RestrictionsSchema, restrictionsJson);
+        return create(ExecutionResultSchema, {
+            result: { case: 'restrictions', value: restrictions },
+        });
+    }
     handleSubscribePhase(req, workflow) {
         if (req.request.case !== 'subscribe') {
             return create(ExecutionResultSchema, {
@@ -125,11 +188,13 @@ export class Runner {
                 },
             });
         }
-        // Build TriggerSubscriptionRequest from the workflow entries
+        // Build TriggerSubscriptionRequest from the workflow entries, including any per-handler requirements.
         const subscriptions = workflow.map((entry) => ({
             id: entry.trigger.capabilityId(),
             method: entry.trigger.method(),
             payload: entry.trigger.configAsAny(),
+            requirements: entry.requirements,
+            preHook: !!entry.hooks?.preHook,
         }));
         const subscriptionRequest = create(TriggerSubscriptionRequestSchema, {
             subscriptions,
@@ -139,3 +204,11 @@ export class Runner {
         });
     }
 }
+export class Runner extends RunnerBase {
+    constructor(config, request) {
+        super(config, request);
+    }
+    static async newRunner(configHandlerParams) {
+        return RunnerBase.newRunnerHelper((config, request) => new Runner(config, request), configHandlerParams);
+    }
+}

package/dist/sdk/wasm/runtime.d.ts

@@ -1,7 +1,10 @@
-import { NodeRuntimeImpl, RuntimeImpl } from '../impl/runtime-impl';
+import { NodeRuntimeImpl, RuntimeImpl, TeeRuntimeImpl } from '../impl/runtime-impl';
 export declare class Runtime<C> extends RuntimeImpl<C> {
     constructor(config: C, nextCallId: number, maxResponseSize: bigint);
 }
 export declare class NodeRuntime<C> extends NodeRuntimeImpl<C> {
     constructor(config: C, nextCallId: number, maxResponseSize: bigint);
 }
+export declare class TeeRuntime<C> extends TeeRuntimeImpl<C> {
+    constructor(config: C, nextCallId: number, maxResponseSize: bigint);
+}

package/dist/sdk/wasm/runtime.js

@@ -1,6 +1,6 @@
 import { fromBinary, toBinary } from '@bufbuild/protobuf';
 import { AwaitCapabilitiesRequestSchema, AwaitCapabilitiesResponseSchema, AwaitSecretsRequestSchema, AwaitSecretsResponseSchema, CapabilityRequestSchema, GetSecretsRequestSchema, } from '../../generated/sdk/v1alpha/sdk_pb';
-import { NodeRuntimeImpl, RuntimeImpl } from '../impl/runtime-impl';
+import { NodeRuntimeImpl, RuntimeImpl, TeeRuntimeImpl, } from '../impl/runtime-impl';
 import { hostBindings } from './host-bindings';
 export class Runtime extends RuntimeImpl {
     constructor(config, nextCallId, maxResponseSize) {
@@ -12,6 +12,11 @@ export class NodeRuntime extends NodeRuntimeImpl {
         super(config, nextCallId, WasmRuntimeHelpers.getInstance(), maxResponseSize);
     }
 }
+export class TeeRuntime extends TeeRuntimeImpl {
+    constructor(config, nextCallId, maxResponseSize) {
+        super(config, nextCallId, WasmRuntimeHelpers.getInstance(), maxResponseSize);
+    }
+}
 /** Convert bigint maxResponseSize to i32 for WASM host binding, with range validation. */
 function toI32ResponseSize(maxResponseSize) {
     if (maxResponseSize > 2147483647n || maxResponseSize < -2147483648n) {
@@ -59,4 +64,7 @@ class WasmRuntimeHelpers {
     log(message) {
         hostBindings.log(message);
     }
+    emitMetric(payload) {
+        return hostBindings.emitMetric(payload) >= 0;
+    }
 }

package/dist/sdk/workflow.d.ts

@@ -1,15 +1,24 @@
 import type { Message } from '@bufbuild/protobuf';
-import type { Secret, SecretRequest, SecretRequestJson } from '../generated/sdk/v1alpha/sdk_pb';
-import { type Runtime } from './runtime';
+import type { Requirements, RestrictionsJson, Secret, SecretRequest, SecretRequestJson } from '../generated/sdk/v1alpha/sdk_pb';
+import type { Runtime, TeeRuntime } from './runtime';
 import type { Trigger } from './utils/triggers/trigger-interface';
 import type { CreSerializable } from './utils';
-export type HandlerFn<TConfig, TTriggerOutput, TResult> = (runtime: Runtime<TConfig>, triggerOutput: TTriggerOutput) => Promise<CreSerializable<TResult>> | CreSerializable<TResult>;
-export interface HandlerEntry<TConfig, TRawTriggerOutput extends Message<string>, TTriggerOutput, TResult> {
+export type { AnyTeeConstraint, NitroBinding, NitroRegion, OneOfTees, Region, TeeBinding, TeeConstraint, } from './tee-constraints';
+export { buildTeeRequirements, NITRO_REGIONS, REGIONS, teeConstraintSchema, } from './tee-constraints';
+import type { TeeConstraint } from './tee-constraints';
+export type HandlerFn<TConfig, TTriggerOutput, TResult, TRuntime = Runtime<TConfig>> = (runtime: TRuntime, triggerOutput: TTriggerOutput) => Promise<CreSerializable<TResult>> | CreSerializable<TResult>;
+export interface Hooks<TConfig, TTriggerOutput> {
+    preHook?: (config: TConfig, triggerOutput: TTriggerOutput) => RestrictionsJson;
+}
+export interface HandlerEntry<TConfig, TRawTriggerOutput extends Message<string>, TTriggerOutput, TResult, TRuntime = Runtime<TConfig>> {
     trigger: Trigger<TRawTriggerOutput, TTriggerOutput>;
-    fn: HandlerFn<TConfig, TTriggerOutput, TResult>;
+    fn: HandlerFn<TConfig, TTriggerOutput, TResult, TRuntime>;
+    requirements?: Requirements;
+    hooks?: Hooks<TConfig, TTriggerOutput>;
 }
-export type Workflow<TConfig> = ReadonlyArray<HandlerEntry<TConfig, any, any, any>>;
-export declare const handler: <TRawTriggerOutput extends Message<string>, TTriggerOutput, TConfig, TResult>(trigger: Trigger<TRawTriggerOutput, TTriggerOutput>, fn: HandlerFn<TConfig, TTriggerOutput, TResult>) => HandlerEntry<TConfig, TRawTriggerOutput, TTriggerOutput, TResult>;
+export type Workflow<TConfig> = ReadonlyArray<HandlerEntry<TConfig, any, any, any, any>>;
+export declare const handler: <TRawTriggerOutput extends Message<string>, TTriggerOutput, TConfig, TResult, TRuntime = Runtime<TConfig>>(trigger: Trigger<TRawTriggerOutput, TTriggerOutput>, fn: HandlerFn<TConfig, TTriggerOutput, TResult, TRuntime>, hooks?: Hooks<TConfig, TTriggerOutput>) => HandlerEntry<TConfig, TRawTriggerOutput, TTriggerOutput, TResult, TRuntime>;
+export declare const handlerInTee: <TRawTriggerOutput extends Message<string>, TTriggerOutput, TConfig, TResult>(trigger: Trigger<TRawTriggerOutput, TTriggerOutput>, fn: HandlerFn<TConfig, TTriggerOutput, TResult, TeeRuntime<TConfig>>, tees: TeeConstraint, hooks?: Hooks<TConfig, TTriggerOutput>) => HandlerEntry<TConfig, TRawTriggerOutput, TTriggerOutput, TResult, TeeRuntime<TConfig>>;
 export type SecretsProvider = {
     getSecret(request: SecretRequest | SecretRequestJson): {
         result: () => Secret;

package/dist/sdk/workflow.js

@@ -1,5 +1,13 @@
-import {} from './runtime';
-export const handler = (trigger, fn) => ({
+export { buildTeeRequirements, NITRO_REGIONS, REGIONS, teeConstraintSchema, } from './tee-constraints';
+import { buildTeeRequirements } from './tee-constraints';
+export const handler = (trigger, fn, hooks) => ({
     trigger,
     fn,
+    hooks,
+});
+export const handlerInTee = (trigger, fn, tees, hooks) => ({
+    trigger,
+    fn,
+    requirements: buildTeeRequirements(tees),
+    hooks,
 });

package/dist/workflows/standard_tests/restrictions/test.ts

@@ -0,0 +1,41 @@
+import type { Outputs } from '@cre/generated/capabilities/internal/basictrigger/v1/basic_trigger_pb'
+import type { RestrictionsJson } from '@cre/generated/sdk/v1alpha/sdk_pb'
+import { BasicActionCapability } from '@cre/generated-sdk/capabilities/internal/basicaction/v1/basicaction_sdk_gen'
+import { BasicCapability as BasicTriggerCapability } from '@cre/generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen'
+import type { Workflow } from '@cre/sdk'
+import { cre, type Runtime } from '@cre/sdk/cre'
+import { Runner } from '@cre/sdk/wasm'
+import type { ByteArray } from 'viem'
+
+const trigger = (runtime: Runtime<Uint8Array>, __: Outputs): string => {
+	const basicCapability = new BasicActionCapability()
+	const result = basicCapability.performAction(runtime, { inputThing: true }).result()
+	return result.adaptedThing
+}
+
+const preHook = (_: ByteArray, __: Outputs): RestrictionsJson => {
+	return {
+		capabilities: {
+			maxTotalCalls: 0,
+		},
+	}
+}
+
+const initWorkflow = (_: ByteArray): Workflow<Uint8Array> => {
+	const basicTrigger = new BasicTriggerCapability()
+
+	return [
+		cre.handler(basicTrigger.trigger({ name: 'first-trigger', number: 100 }), trigger, {
+			preHook: preHook,
+		}),
+	]
+}
+
+export async function main() {
+	const runner = await Runner.newRunner<Uint8Array>({
+		configParser: (c) => c,
+	})
+	await runner.run(initWorkflow)
+}
+
+await main()

package/dist/workflows/standard_tests/tee_runtime/test.ts

@@ -0,0 +1,29 @@
+import type { Outputs } from '@cre/generated/capabilities/internal/basictrigger/v1/basic_trigger_pb'
+import { BasicCapability as BasicTriggerCapability } from '@cre/generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen'
+import { cre, type Runtime, type TeeRuntime } from '@cre/sdk/cre'
+import { Runner } from '@cre/sdk/wasm'
+import { handlerInTee } from '@cre/sdk/workflow'
+
+const teeTrigger = (_: TeeRuntime<Uint8Array>, __: Outputs) => 0
+const regularTrigger = (_: Runtime<Uint8Array>, __: Outputs) => 0
+
+const initWorkflow = () => {
+	const basicTrigger = new BasicTriggerCapability()
+	return [
+		handlerInTee(basicTrigger.trigger({ name: 'first-trigger', number: 100 }), teeTrigger, [
+			{ tee: 'nitro', regions: ['us-west-2'] },
+		]),
+		cre.handler(basicTrigger.trigger({ name: 'second-trigger', number: 200 }), regularTrigger),
+	]
+}
+
+export async function main() {
+	console.log(`TS workflow: standard test: config [${new Date().toISOString()}]`)
+
+	const runner = await Runner.newRunner<Uint8Array>({
+		configParser: (c: Uint8Array) => c,
+	})
+	await runner.run(initWorkflow)
+}
+
+await main()

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@chainlink/cre-sdk",
-	"version": "1.16.0",
+	"version": "1.17.0-alpha.1",
 	"type": "module",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -61,10 +61,7 @@
 	"dependencies": {
 		"@bufbuild/protobuf": "2.6.3",
 		"@bufbuild/protoc-gen-es": "2.6.3",
-		"@chainlink/cre-sdk-javy-plugin": "1.7.0",
-		"@noble/hashes": "2.2.0",
-		"@solana/addresses": "6.10.0",
-		"@solana/codecs": "6.10.0",
+		"@chainlink/cre-sdk-javy-plugin": "1.8.0-alpha.1",
 		"@standard-schema/spec": "1.0.0",
 		"viem": "2.34.0",
 		"zod": "3.25.76"
@@ -77,7 +74,7 @@
 		"fast-glob": "3.3.3",
 		"ts-proto": "2.7.5",
 		"typescript": "5.9.3",
-		"yaml": "2.9.0"
+		"yaml": "2.8.1"
 	},
 	"publishConfig": {
 		"access": "public"

package/scripts/src/generate-sdks.ts

@@ -1,4 +1,5 @@
 import { rmSync } from 'node:fs'
+import { file_capabilities_blockchain_aptos_v1alpha_client } from '@cre/generated/capabilities/blockchain/aptos/v1alpha/client_pb'
 import { file_capabilities_blockchain_evm_v1alpha_client } from '@cre/generated/capabilities/blockchain/evm/v1alpha/client_pb'
 import { file_capabilities_blockchain_solana_v1alpha_client } from '@cre/generated/capabilities/blockchain/solana/v1alpha/client_pb'
 import { file_capabilities_internal_actionandtrigger_v1_action_and_trigger } from '@cre/generated/capabilities/internal/actionandtrigger/v1/action_and_trigger_pb'
@@ -64,6 +65,11 @@ export const main = () => {
 		...generateMocks(file_capabilities_blockchain_evm_v1alpha_client, TEST_GENERATED_DIR),
 	)
 
+	generateSdk(file_capabilities_blockchain_aptos_v1alpha_client, './src/generated-sdk')
+	allMockExports.push(
+		...generateMocks(file_capabilities_blockchain_aptos_v1alpha_client, TEST_GENERATED_DIR),
+	)
+
 	generateSdk(file_capabilities_blockchain_solana_v1alpha_client, './src/generated-sdk')
 	allMockExports.push(
 		...generateMocks(file_capabilities_blockchain_solana_v1alpha_client, TEST_GENERATED_DIR),

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

@@ -1,16 +0,0 @@
-/**
- * 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

@@ -1,21 +0,0 @@
-/**
- * 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/solana-contract-mock.d.ts

@@ -1,54 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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/report-helpers.d.ts

@@ -1,19 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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,
-});