@chainlink/cre-sdk 1.17.0-alpha.3 → 1.17.0-alpha.4

package/dist/sdk/wasm/host-bindings.js

@@ -27,6 +27,10 @@ export const globalHostBindingsSchema = z.object({
         .returns(z.union([z.instanceof(Uint8Array), z.custom()])),
     getWasiArgs: z.function().args().returns(z.string()),
     now: z.function().args().returns(z.number()),
+    emitMetric: z
+        .function()
+        .args(z.union([z.instanceof(Uint8Array), z.custom()]))
+        .returns(z.number()),
     sleep: z.function().args(z.number()).returns(z.void()),
 });
 // Validate global host functions at runtime

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

@@ -2,13 +2,19 @@ import { type ExecuteRequest, type ExecutionResult } from '../../generated/sdk/v
 import { type ConfigHandlerParams } from '../utils/config';
 import type { SecretsProvider, Workflow } from '../workflow';
 import { Runtime } from './runtime';
-export declare class Runner<TConfig> {
+declare class RunnerBase<TConfig> {
     private readonly config;
     private readonly request;
-    private constructor();
-    static newRunner<TConfig, TIntermediateConfig = TConfig>(configHandlerParams?: ConfigHandlerParams<TConfig, TIntermediateConfig>): Promise<Runner<TConfig>>;
+    protected constructor(config: TConfig, request: ExecuteRequest);
+    protected static newRunnerHelper<TConfig, TIntermediateConfig, TRunner>(newRunner: (config: TConfig, request: ExecuteRequest) => TRunner, configHandlerParams?: ConfigHandlerParams<TConfig, TIntermediateConfig>): Promise<TRunner>;
     private static getRequest;
     run(initFn: (config: TConfig, secretsProvider: SecretsProvider) => Promise<Workflow<TConfig>> | Workflow<TConfig>): Promise<void>;
-    handleExecutionPhase<TConfig>(req: ExecuteRequest, workflow: Workflow<TConfig>, runtime: Runtime<TConfig>): Promise<ExecutionResult>;
+    handleExecutionPhase(req: ExecuteRequest, workflow: Workflow<TConfig>, runtime: Runtime<TConfig>): Promise<ExecutionResult>;
+    handlePreHookPhase(req: ExecuteRequest, workflow: Workflow<TConfig>): ExecutionResult;
     handleSubscribePhase(req: ExecuteRequest, workflow: Workflow<TConfig>): ExecutionResult;
 }
+export declare class Runner<TConfig> extends RunnerBase<TConfig> {
+    private constructor();
+    static newRunner<TConfig, TIntermediateConfig = TConfig>(configHandlerParams?: ConfigHandlerParams<TConfig, TIntermediateConfig>): Promise<Runner<TConfig>>;
+}
+export {};

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/frequency_list/test.ts

@@ -0,0 +1,75 @@
+import { BasicCapability as BasicTriggerCapability } from '@cre/generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen'
+import { BasicActionCapability as NodeActionCapability } from '@cre/generated-sdk/capabilities/internal/nodeaction/v1/basicaction_sdk_gen'
+import { cre, type Runtime } from '@cre/sdk/cre'
+import type { NodeRuntime } from '@cre/sdk/runtime'
+import {
+	ConsensusAggregationByFields,
+	type FrequencyListEntry,
+	frequencyList,
+	identical,
+} from '@cre/sdk/utils'
+import { Runner } from '@cre/sdk/wasm'
+
+class NodeObservation {
+	constructor(
+		public payload: Uint8Array,
+		public signatures: Uint8Array,
+	) {}
+}
+
+type ConsensusResult = {
+	payload: Uint8Array
+	signatures: FrequencyListEntry<Uint8Array>[]
+}
+
+const bytesToHex = (bytes: Uint8Array): string =>
+	Array.from(bytes)
+		.map((b) => b.toString(16).padStart(2, '0'))
+		.join('')
+
+const formatFrequencyList = (entries: FrequencyListEntry<Uint8Array>[]): string =>
+	entries.map((entry) => `${bytesToHex(entry.value)}x${entry.count.value}`).join(',')
+
+const formatResult = (result: ConsensusResult): string =>
+	`${bytesToHex(result.payload)}|${formatFrequencyList(result.signatures)}`
+
+const handler = (runtime: Runtime<Uint8Array>) => {
+	const encoder = new TextEncoder()
+	const result = runtime
+		.runInNodeMode(
+			(nodeRuntime: NodeRuntime<Uint8Array>): NodeObservation => {
+				const nodeResponse = new NodeActionCapability()
+					.performAction(nodeRuntime, { inputThing: true })
+					.result()
+
+				return new NodeObservation(
+					encoder.encode(`payload-${nodeResponse.outputThing}`),
+					encoder.encode(`sig-${nodeResponse.outputThing}`),
+				)
+			},
+			ConsensusAggregationByFields<NodeObservation, ConsensusResult>({
+				payload: identical,
+				signatures: frequencyList,
+			}),
+		)()
+		.result()
+
+	return formatResult(result)
+}
+
+const initWorkflow = () => {
+	const basicTrigger = new BasicTriggerCapability()
+
+	return [cre.handler(basicTrigger.trigger({}), handler)]
+}
+
+export async function main() {
+	console.log(`TS workflow: standard test: frequency_list [${new Date().toISOString()}]`)
+
+	const runner = await Runner.newRunner<Uint8Array>({
+		configParser: (c) => c,
+	})
+	await runner.run(initWorkflow)
+}
+
+await main()

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.17.0-alpha.3",
+	"version": "1.17.0-alpha.4",
 	"type": "module",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -61,7 +61,7 @@
 	"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-alpha.2",
 		"@noble/hashes": "2.2.0",
 		"@noble/curves": "2.2.0",
 		"@solana/addresses": "6.10.0",

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),