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

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

@@ -0,0 +1,176 @@
+import { bytesToBase64 } from '../../../hex-utils';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { concatBytes } from '@noble/hashes/utils.js';
+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);
+const U64_LENGTH = 8;
+const U64_SIGN_BIT = 1n << 63n;
+const UTF8_ENCODER = new TextEncoder();
+/** Encodes a bigint as a big-endian u64, wrapping modulo 2^64 (two's complement). */
+const u64BE = (value) => {
+    const bytes = new Uint8Array(U64_LENGTH);
+    new DataView(bytes.buffer).setBigUint64(0, BigInt.asUintN(64, value), false);
+    return bytes;
+};
+/**
+ * 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 const prepareSubkeyValue = (value) => {
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return UTF8_ENCODER.encode(value);
+    }
+    if (typeof value === 'bigint') {
+        return u64BE(value);
+    }
+    if (typeof value === 'number') {
+        if (!Number.isInteger(value)) {
+            throw new Error('prepareSubkeyValue: non-integer number; use prepareSubkeyFloatValue for f32/f64 values');
+        }
+        return u64BE(BigInt(value));
+    }
+    throw new Error(`prepareSubkeyValue: unsupported subkey value type ${typeof value}`);
+};
+/**
+ * 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 const prepareSubkeyFloatValue = (value) => {
+    const view = new DataView(new ArrayBuffer(U64_LENGTH));
+    view.setFloat64(0, value, false);
+    const bits = view.getBigUint64(0, false);
+    return u64BE(value > 0 ? bits + U64_SIGN_BIT : U64_SIGN_BIT - bits);
+};
+/** Method name Anchor uses for `emit_cpi!` self-invocations. */
+const ANCHOR_CPI_METHOD_NAME = 'anchor:event';
+const ANCHOR_CPI_METHOD_NAME_B64 = bytesToBase64(UTF8_ENCODER.encode(ANCHOR_CPI_METHOD_NAME));
+/**
+ * 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 const anchorCPILogTriggerConfig = (programId) => ({
+    destAddress: bytesToBase64(typeof programId === 'string' ? solanaAddressToBytes(programId) : programId),
+    methodName: ANCHOR_CPI_METHOD_NAME_B64,
+});

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,9 +1,12 @@
-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';
 export * from './hex-utils';
 export * from './safe-json-stringify';
+export * from './triggers/trigger-interface';
 export * from './values/consensus_aggregators';
 export * from './values/serializer_types';
 export * from './values/value';

package/dist/sdk/utils/index.js

@@ -1,9 +1,11 @@
-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';
 export * from './hex-utils';
 export * from './safe-json-stringify';
+export * from './triggers/trigger-interface';
 export * from './values/consensus_aggregators';
 export * from './values/serializer_types';
 export * from './values/value';

package/dist/sdk/utils/triggers/trigger-interface.d.ts

@@ -19,3 +19,10 @@ export interface Trigger<TRawTriggerOutput extends Message<string>, TTriggerOutp
     /** Transform the raw trigger output to the adapted type */
     adapt(rawOutput: TRawTriggerOutput): TTriggerOutput;
 }
+/**
+ * Wraps a trigger with an extra output transformation, delegating everything
+ * else to the wrapped trigger. The TypeScript analog of Go bindings embedding
+ * `cre.Trigger` and overriding only `Adapt` — generated bindings use this to
+ * decode raw trigger outputs into typed data.
+ */
+export declare const adaptTrigger: <TRaw extends Message<string>, TIn, TOut>(trigger: Trigger<TRaw, TIn>, adapt: (output: TIn) => TOut) => Trigger<TRaw, TOut>;

package/dist/sdk/utils/triggers/trigger-interface.js

@@ -1 +1,13 @@
-export {};
+/**
+ * Wraps a trigger with an extra output transformation, delegating everything
+ * else to the wrapped trigger. The TypeScript analog of Go bindings embedding
+ * `cre.Trigger` and overriding only `Adapt` — generated bindings use this to
+ * decode raw trigger outputs into typed data.
+ */
+export const adaptTrigger = (trigger, adapt) => ({
+    capabilityId: () => trigger.capabilityId(),
+    method: () => trigger.method(),
+    outputSchema: () => trigger.outputSchema(),
+    configAsAny: () => trigger.configAsAny(),
+    adapt: (rawOutput) => adapt(trigger.adapt(rawOutput)),
+});

package/dist/sdk/wasm/host-bindings.d.ts

@@ -11,7 +11,6 @@ export declare const globalHostBindingsSchema: z.ZodObject<{
     awaitSecrets: z.ZodFunction<z.ZodTuple<[z.ZodUnion<[z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>, z.ZodType<Uint8Array<ArrayBufferLike>, z.ZodTypeDef, Uint8Array<ArrayBufferLike>>]>, z.ZodNumber], z.ZodUnknown>, z.ZodUnion<[z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>, z.ZodType<Uint8Array<ArrayBufferLike>, z.ZodTypeDef, Uint8Array<ArrayBufferLike>>]>>;
     getWasiArgs: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
     now: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodNumber>;
-    emitMetric: z.ZodFunction<z.ZodTuple<[z.ZodUnion<[z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>, z.ZodType<Uint8Array<ArrayBufferLike>, z.ZodTypeDef, Uint8Array<ArrayBufferLike>>]>], z.ZodUnknown>, z.ZodNumber>;
     sleep: z.ZodFunction<z.ZodTuple<[z.ZodNumber], z.ZodUnknown>, z.ZodVoid>;
 }, "strip", z.ZodTypeAny, {
     callCapability: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, ...args: unknown[]) => number;
@@ -19,7 +18,6 @@ export declare const globalHostBindingsSchema: z.ZodObject<{
     getSecrets: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, args_1: number, ...args: unknown[]) => any;
     awaitSecrets: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, args_1: number, ...args: unknown[]) => Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>;
     log: (args_0: string, ...args: unknown[]) => void;
-    emitMetric: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, ...args: unknown[]) => number;
     sendResponse: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, ...args: unknown[]) => number;
     switchModes: (args_0: Mode, ...args: unknown[]) => void;
     versionV2: (...args: unknown[]) => void;
@@ -32,7 +30,6 @@ export declare const globalHostBindingsSchema: z.ZodObject<{
     getSecrets: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, args_1: number, ...args: unknown[]) => any;
     awaitSecrets: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, args_1: number, ...args: unknown[]) => Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>;
     log: (args_0: string, ...args: unknown[]) => void;
-    emitMetric: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, ...args: unknown[]) => number;
     sendResponse: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, ...args: unknown[]) => number;
     switchModes: (args_0: Mode, ...args: unknown[]) => void;
     versionV2: (...args: unknown[]) => void;
@@ -46,7 +43,6 @@ export declare const hostBindings: {
     getSecrets: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, args_1: number, ...args: unknown[]) => any;
     awaitSecrets: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, args_1: number, ...args: unknown[]) => Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>;
     log: (args_0: string, ...args: unknown[]) => void;
-    emitMetric: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, ...args: unknown[]) => number;
     sendResponse: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, ...args: unknown[]) => number;
     switchModes: (args_0: Mode, ...args: unknown[]) => void;
     versionV2: (...args: unknown[]) => void;

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

@@ -27,10 +27,6 @@ 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,19 +2,13 @@ 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';
-declare class RunnerBase<TConfig> {
+export declare class Runner<TConfig> {
     private readonly config;
     private readonly request;
-    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 constructor();
+    static newRunner<TConfig, TIntermediateConfig = TConfig>(configHandlerParams?: ConfigHandlerParams<TConfig, TIntermediateConfig>): Promise<Runner<TConfig>>;
     private static getRequest;
     run(initFn: (config: TConfig, secretsProvider: SecretsProvider) => Promise<Workflow<TConfig>> | Workflow<TConfig>): Promise<void>;
-    handleExecutionPhase(req: ExecuteRequest, workflow: Workflow<TConfig>, runtime: Runtime<TConfig>): Promise<ExecutionResult>;
-    handlePreHookPhase(req: ExecuteRequest, workflow: Workflow<TConfig>): ExecutionResult;
+    handleExecutionPhase<TConfig>(req: ExecuteRequest, workflow: Workflow<TConfig>, runtime: Runtime<TConfig>): Promise<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, fromJson, toBinary } from '@bufbuild/protobuf';
-import { ExecuteRequestSchema, ExecutionResultSchema, RestrictionsSchema, TriggerSubscriptionRequestSchema, } from '../../generated/sdk/v1alpha/sdk_pb';
+import { create, fromBinary, toBinary } from '@bufbuild/protobuf';
+import { ExecuteRequestSchema, ExecutionResultSchema, TriggerSubscriptionRequestSchema, } from '../../generated/sdk/v1alpha/sdk_pb';
 import { configHandler } from '../utils/config';
 import { Value } from '../utils';
 import { hostBindings } from './host-bindings';
-import { Runtime, TeeRuntime } from './runtime';
-class RunnerBase {
+import { Runtime } from './runtime';
+export class Runner {
     config;
     request;
     constructor(config, request) {
         this.config = config;
         this.request = request;
     }
-    static async newRunnerHelper(newRunner, configHandlerParams) {
+    static async newRunner(configHandlerParams) {
         hostBindings.versionV2();
-        const request = RunnerBase.getRequest();
+        const request = Runner.getRequest();
         const config = await configHandler(request, configHandlerParams);
-        return newRunner(config, request);
+        return new Runner(config, request);
     }
     static getRequest() {
         const argsString = hostBindings.getWasiArgs();
@@ -38,15 +38,11 @@ class RunnerBase {
     }
     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, sp);
+            const workflow = await initFn(this.config, {
+                getSecret: runtime.getSecret.bind(runtime),
+            });
             switch (this.request.request.case) {
                 case 'subscribe':
                     result = this.handleSubscribePhase(this.request, workflow);
@@ -54,11 +50,8 @@ class RunnerBase {
                 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', 'trigger', or 'preHook'. 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' or 'trigger'. This may indicate a version mismatch between the SDK and the CRE runtime`);
             }
         }
         catch (e) {
@@ -102,10 +95,8 @@ class RunnerBase {
              * */
             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(handlerRuntime, adapted);
+                const result = await entry.fn(runtime, adapted);
                 const wrapped = Value.wrap(result);
                 return create(ExecutionResultSchema, {
                     result: { case: 'value', value: wrapped.proto() },
@@ -125,60 +116,6 @@ class RunnerBase {
             },
         });
     }
-    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, {
@@ -188,13 +125,11 @@ class RunnerBase {
                 },
             });
         }
-        // Build TriggerSubscriptionRequest from the workflow entries, including any per-handler requirements.
+        // Build TriggerSubscriptionRequest from the workflow entries
         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,
@@ -204,11 +139,3 @@ class RunnerBase {
         });
     }
 }
-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,10 +1,7 @@
-import { NodeRuntimeImpl, RuntimeImpl, TeeRuntimeImpl } from '../impl/runtime-impl';
+import { NodeRuntimeImpl, RuntimeImpl } 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, TeeRuntimeImpl, } from '../impl/runtime-impl';
+import { NodeRuntimeImpl, RuntimeImpl } from '../impl/runtime-impl';
 import { hostBindings } from './host-bindings';
 export class Runtime extends RuntimeImpl {
     constructor(config, nextCallId, maxResponseSize) {
@@ -12,11 +12,6 @@ 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) {
@@ -64,7 +59,4 @@ class WasmRuntimeHelpers {
     log(message) {
         hostBindings.log(message);
     }
-    emitMetric(payload) {
-        return hostBindings.emitMetric(payload) >= 0;
-    }
 }

package/dist/sdk/workflow.d.ts

@@ -1,24 +1,15 @@
 import type { Message } from '@bufbuild/protobuf';
-import type { Requirements, RestrictionsJson, Secret, SecretRequest, SecretRequestJson } from '../generated/sdk/v1alpha/sdk_pb';
-import type { Runtime, TeeRuntime } from './runtime';
+import type { Secret, SecretRequest, SecretRequestJson } from '../generated/sdk/v1alpha/sdk_pb';
+import { type Runtime } from './runtime';
 import type { Trigger } from './utils/triggers/trigger-interface';
 import type { CreSerializable } from './utils';
-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>> {
+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> {
     trigger: Trigger<TRawTriggerOutput, TTriggerOutput>;
-    fn: HandlerFn<TConfig, TTriggerOutput, TResult, TRuntime>;
-    requirements?: Requirements;
-    hooks?: Hooks<TConfig, TTriggerOutput>;
+    fn: HandlerFn<TConfig, 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 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 SecretsProvider = {
     getSecret(request: SecretRequest | SecretRequestJson): {
         result: () => Secret;

package/dist/sdk/workflow.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@chainlink/cre-sdk",
-	"version": "1.17.0-alpha.1",
+	"version": "1.17.0-alpha.3",
 	"type": "module",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -61,7 +61,11 @@
 	"dependencies": {
 		"@bufbuild/protobuf": "2.6.3",
 		"@bufbuild/protoc-gen-es": "2.6.3",
-		"@chainlink/cre-sdk-javy-plugin": "1.8.0-alpha.1",
+		"@chainlink/cre-sdk-javy-plugin": "1.7.0",
+		"@noble/hashes": "2.2.0",
+		"@noble/curves": "2.2.0",
+		"@solana/addresses": "6.10.0",
+		"@solana/codecs": "6.10.0",
 		"@standard-schema/spec": "1.0.0",
 		"viem": "2.34.0",
 		"zod": "3.25.76"
@@ -70,11 +74,11 @@
 		"@biomejs/biome": "2.3.14",
 		"@bufbuild/buf": "1.56.0",
 		"@types/bun": "1.3.8",
-		"chain-selectors": "https://github.com/smartcontractkit/chain-selectors.git#3e718d1c9910b2952c50befe378b0fe8707e6647",
+		"chain-selectors": "https://github.com/smartcontractkit/chain-selectors.git#7d1e9798b28404818eba5246383c0688c4ee0e1f",
 		"fast-glob": "3.3.3",
 		"ts-proto": "2.7.5",
 		"typescript": "5.9.3",
-		"yaml": "2.8.1"
+		"yaml": "2.9.0"
 	},
 	"publishConfig": {
 		"access": "public"

package/scripts/src/generate-sdks.ts

@@ -1,5 +1,4 @@
 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'
@@ -65,11 +64,6 @@ 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),