@chainlink/cre-sdk 0.0.1-alpha → 0.0.2-alpha

package/dist/generated-sdk/capabilities/networking/http/v1alpha/http_sdk_gen.js

@@ -1,44 +1,34 @@
-import { create, fromBinary, fromJson, toBinary } from '@bufbuild/protobuf';
-import { AnySchema } from '@bufbuild/protobuf/wkt';
+import { create, fromJson } from '@bufbuild/protobuf';
+import { AnySchema, anyPack } from '@bufbuild/protobuf/wkt';
 import { ConfigSchema, PayloadSchema, } from '../../../../../generated/capabilities/networking/http/v1alpha/trigger_pb';
-import { Mode } from '../../../../../generated/sdk/v1alpha/sdk_pb';
-import { callCapability } from '../../../../../sdk/utils/capabilities/call-capability';
-import { CapabilityError } from '../../../../../sdk/utils/capabilities/capability-error';
+import {} from '../../../../../sdk/runtime';
 import {} from '../../../../../sdk/utils/triggers/trigger-interface';
-import { getTypeUrl } from '../../../../../sdk/utils/typeurl';
 /**
  * HTTP Capability
  *
  * Capability ID: http-trigger@1.0.0-alpha
- * Default Mode: Mode.DON
  * Capability Name: http-trigger
  * Capability Version: 1.0.0-alpha
  */
 export class HTTPCapability {
-    mode;
     /** The capability ID for this service */
     static CAPABILITY_ID = 'http-trigger@1.0.0-alpha';
-    /** The default execution mode for this capability */
-    static DEFAULT_MODE = Mode.DON;
     static CAPABILITY_NAME = 'http-trigger';
     static CAPABILITY_VERSION = '1.0.0-alpha';
-    constructor(mode = HTTPCapability.DEFAULT_MODE) {
-        this.mode = mode;
-    }
+    constructor() { }
     trigger(config) {
-        return new HTTPTrigger(this.mode, config, HTTPCapability.CAPABILITY_ID, 'Trigger');
+        const capabilityId = HTTPCapability.CAPABILITY_ID;
+        return new HTTPTrigger(config, capabilityId, 'Trigger');
     }
 }
 /**
  * Trigger implementation for Trigger
  */
 class HTTPTrigger {
-    mode;
     _capabilityId;
     _method;
     config;
-    constructor(mode, config, _capabilityId, _method) {
-        this.mode = mode;
+    constructor(config, _capabilityId, _method) {
         this._capabilityId = _capabilityId;
         this._method = _method;
         // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
@@ -56,10 +46,7 @@ class HTTPTrigger {
         return PayloadSchema;
     }
     configAsAny() {
-        return create(AnySchema, {
-            typeUrl: getTypeUrl(ConfigSchema),
-            value: toBinary(ConfigSchema, this.config),
-        });
+        return anyPack(ConfigSchema, this.config);
     }
     /**
      * Transform the raw trigger output - override this method if needed

package/dist/generated-sdk/capabilities/scheduler/cron/v1/cron_sdk_gen.d.ts

@@ -1,35 +1,29 @@
 import { type Any } from '@bufbuild/protobuf/wkt';
 import { type Config, type ConfigJson, type Payload } from '../../../../../generated/capabilities/scheduler/cron/v1/trigger_pb';
-import { Mode } from '../../../../../generated/sdk/v1alpha/sdk_pb';
 import { type Trigger } from '../../../../../sdk/utils/triggers/trigger-interface';
 /**
  * Cron Capability
  *
  * Capability ID: cron-trigger@1.0.0
- * Default Mode: Mode.DON
  * Capability Name: cron-trigger
  * Capability Version: 1.0.0
  */
 export declare class CronCapability {
-    private readonly mode;
     /** The capability ID for this service */
     static readonly CAPABILITY_ID = "cron-trigger@1.0.0";
-    /** The default execution mode for this capability */
-    static readonly DEFAULT_MODE = Mode.DON;
     static readonly CAPABILITY_NAME = "cron-trigger";
     static readonly CAPABILITY_VERSION = "1.0.0";
-    constructor(mode?: Mode);
+    constructor();
     trigger(config: ConfigJson): CronTrigger;
 }
 /**
  * Trigger implementation for Trigger
  */
 declare class CronTrigger implements Trigger<Payload, Payload> {
-    readonly mode: Mode;
     private readonly _capabilityId;
     private readonly _method;
     readonly config: Config;
-    constructor(mode: Mode, config: Config | ConfigJson, _capabilityId: string, _method: string);
+    constructor(config: Config | ConfigJson, _capabilityId: string, _method: string);
     capabilityId(): string;
     method(): string;
     outputSchema(): import("@bufbuild/protobuf/codegenv2").GenMessage<Payload, {

package/dist/generated-sdk/capabilities/scheduler/cron/v1/cron_sdk_gen.js

@@ -1,44 +1,34 @@
-import { create, fromBinary, fromJson, toBinary } from '@bufbuild/protobuf';
-import { AnySchema } from '@bufbuild/protobuf/wkt';
+import { create, fromJson } from '@bufbuild/protobuf';
+import { AnySchema, anyPack } from '@bufbuild/protobuf/wkt';
 import { ConfigSchema, LegacyPayloadSchema, PayloadSchema, } from '../../../../../generated/capabilities/scheduler/cron/v1/trigger_pb';
-import { Mode } from '../../../../../generated/sdk/v1alpha/sdk_pb';
-import { callCapability } from '../../../../../sdk/utils/capabilities/call-capability';
-import { CapabilityError } from '../../../../../sdk/utils/capabilities/capability-error';
+import {} from '../../../../../sdk/runtime';
 import {} from '../../../../../sdk/utils/triggers/trigger-interface';
-import { getTypeUrl } from '../../../../../sdk/utils/typeurl';
 /**
  * Cron Capability
  *
  * Capability ID: cron-trigger@1.0.0
- * Default Mode: Mode.DON
  * Capability Name: cron-trigger
  * Capability Version: 1.0.0
  */
 export class CronCapability {
-    mode;
     /** The capability ID for this service */
     static CAPABILITY_ID = 'cron-trigger@1.0.0';
-    /** The default execution mode for this capability */
-    static DEFAULT_MODE = Mode.DON;
     static CAPABILITY_NAME = 'cron-trigger';
     static CAPABILITY_VERSION = '1.0.0';
-    constructor(mode = CronCapability.DEFAULT_MODE) {
-        this.mode = mode;
-    }
+    constructor() { }
     trigger(config) {
-        return new CronTrigger(this.mode, config, CronCapability.CAPABILITY_ID, 'Trigger');
+        const capabilityId = CronCapability.CAPABILITY_ID;
+        return new CronTrigger(config, capabilityId, 'Trigger');
     }
 }
 /**
  * Trigger implementation for Trigger
  */
 class CronTrigger {
-    mode;
     _capabilityId;
     _method;
     config;
-    constructor(mode, config, _capabilityId, _method) {
-        this.mode = mode;
+    constructor(config, _capabilityId, _method) {
         this._capabilityId = _capabilityId;
         this._method = _method;
         // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
@@ -56,10 +46,7 @@ class CronTrigger {
         return PayloadSchema;
     }
     configAsAny() {
-        return create(AnySchema, {
-            typeUrl: getTypeUrl(ConfigSchema),
-            value: toBinary(ConfigSchema, this.config),
-        });
+        return anyPack(ConfigSchema, this.config);
     }
     /**
      * Transform the raw trigger output - override this method if needed

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './sdk';
 export * from './sdk/runtime';
 export * from './sdk/utils';
+export * from './sdk/wasm';

package/dist/index.js

@@ -2,3 +2,4 @@
 export * from './sdk';
 export * from './sdk/runtime';
 export * from './sdk/utils';
+export * from './sdk/wasm';

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

@@ -5,9 +5,10 @@ import { ClientCapability as EVMClient } from '../../generated-sdk/capabilities/
 import { ClientCapability as HTTPClient } from '../../generated-sdk/capabilities/networking/http/v1alpha/client_sdk_gen';
 import { HTTPCapability } from '../../generated-sdk/capabilities/networking/http/v1alpha/http_sdk_gen';
 import { CronCapability } from '../../generated-sdk/capabilities/scheduler/cron/v1/cron_sdk_gen';
-import { runInNodeMode } from '../runtime/run-in-node-mode';
-import { Runner } from '../workflow';
-export type { NodeRuntime, Runtime } from '../runtime/runtime';
+export type { Log as EVMLog } from '../../generated/capabilities/blockchain/evm/v1alpha/client_pb';
+export type { Payload as HTTPPayload } from '../../generated/capabilities/networking/http/v1alpha/trigger_pb';
+export type { Payload as CronPayload } from '../../generated/capabilities/scheduler/cron/v1/trigger_pb';
+export type { NodeRuntime, Runtime } from '../runtime';
 export declare const cre: {
     capabilities: {
         CronCapability: typeof CronCapability;
@@ -15,20 +16,5 @@ export declare const cre: {
         HTTPClient: typeof HTTPClient;
         EVMClient: typeof EVMClient;
     };
-    config: <TConfig>({ configParser, configSchema, }?: import("../utils/config").ConfigHandlerParams) => Promise<TConfig>;
-    handler: <TRawTriggerOutput extends import("@bufbuild/protobuf").Message<string>, TTriggerOutput = TRawTriggerOutput, TConfig = unknown>(trigger: import("../utils/triggers/trigger-interface").Trigger<TRawTriggerOutput, TTriggerOutput>, fn: import("../workflow").HandlerFn<TConfig, TTriggerOutput>) => import("../workflow").HandlerEntry<TConfig, TRawTriggerOutput, TTriggerOutput>;
-    newRunner: typeof Runner.newRunner;
-    runInNodeMode: typeof runInNodeMode;
-    utils: {
-        fetch: (input: import("../utils/capabilities/http/fetch").CreFetchRequest) => Promise<{
-            statusCode: number;
-            headers: {
-                [key: string]: string;
-            };
-            body: string;
-        }>;
-    };
-    sendResponseValue: (value: import("../utils").Value) => void;
-    sendError: (error: string | Error) => void;
-    withErrorBoundary: (fn: () => Promise<void>) => Promise<void>;
+    handler: <TRawTriggerOutput extends import("@bufbuild/protobuf").Message<string>, TTriggerOutput, TConfig, TResult>(trigger: import("../utils/triggers/trigger-interface").Trigger<TRawTriggerOutput, TTriggerOutput>, fn: import("../workflow").HandlerFn<TConfig, TTriggerOutput, TResult>) => import("../workflow").HandlerEntry<TConfig, TRawTriggerOutput, TTriggerOutput, TResult>;
 };

package/dist/sdk/cre/index.js

@@ -5,16 +5,9 @@ import { ClientCapability as EVMClient } from '../../generated-sdk/capabilities/
 import { ClientCapability as HTTPClient } from '../../generated-sdk/capabilities/networking/http/v1alpha/client_sdk_gen';
 import { HTTPCapability } from '../../generated-sdk/capabilities/networking/http/v1alpha/http_sdk_gen';
 import { CronCapability } from '../../generated-sdk/capabilities/scheduler/cron/v1/cron_sdk_gen';
-import { runInNodeMode } from '../runtime/run-in-node-mode';
-import { creFetch } from '../utils/capabilities/http/fetch';
-import { configHandler } from '../utils/config';
-import { withErrorBoundary } from '../utils/error-boundary';
 import { prepareRuntime } from '../utils/prepare-runtime';
-import { sendError } from '../utils/send-error';
-import { sendResponseValue } from '../utils/send-response-value';
-import { handler, Runner } from '../workflow';
+import { handler } from '../workflow';
 prepareRuntime();
-versionV2();
 export const cre = {
     capabilities: {
         CronCapability,
@@ -22,14 +15,5 @@ export const cre = {
         HTTPClient,
         EVMClient,
     },
-    config: configHandler,
     handler,
-    newRunner: Runner.newRunner,
-    runInNodeMode,
-    utils: {
-        fetch: creFetch,
-    },
-    sendResponseValue,
-    sendError,
-    withErrorBoundary,
 };

package/dist/sdk/errors.d.ts

@@ -0,0 +1,12 @@
+import { type SecretRequest } from '../generated/sdk/v1alpha/sdk_pb';
+export declare class DonModeError extends Error {
+    constructor();
+}
+export declare class NodeModeError extends Error {
+    constructor();
+}
+export declare class SecretsError extends Error {
+    sceretRequest: SecretRequest;
+    error: String;
+    constructor(sceretRequest: SecretRequest, error: String);
+}

package/dist/sdk/errors.js

@@ -0,0 +1,21 @@
+import { Mode } from '../generated/sdk/v1alpha/sdk_pb';
+export class DonModeError extends Error {
+    constructor() {
+        super('cannot use Runtime inside RunInNodeMode');
+    }
+}
+export class NodeModeError extends Error {
+    constructor() {
+        super('cannot use NodeRuntime outside RunInNodeMode');
+        this.name = 'NodeModeError';
+    }
+}
+export class SecretsError extends Error {
+    sceretRequest;
+    error;
+    constructor(sceretRequest, error) {
+        super(`error fetching ${sceretRequest}: ${error}`);
+        this.sceretRequest = sceretRequest;
+        this.error = error;
+    }
+}

package/dist/sdk/impl/runtime-impl.d.ts

@@ -0,0 +1,38 @@
+import { type Message } from '@bufbuild/protobuf';
+import { type AwaitCapabilitiesRequest, type AwaitCapabilitiesResponse, type AwaitSecretsRequest, type AwaitSecretsResponse, type CapabilityRequest, type GetSecretsRequest, Mode, type Secret, type SecretRequest, type SecretRequestJson } from '../../generated/sdk/v1alpha/sdk_pb';
+import type { BaseRuntime, CallCapabilityParams, NodeRuntime, Runtime } from '../runtime';
+import { type ConsensusAggregation, type PrimitiveTypes, type UnwrapOptions } from '../utils';
+export declare class BaseRuntimeImpl<C> implements BaseRuntime<C> {
+    config: C;
+    nextCallId: number;
+    protected helpers: RuntimeHelpers;
+    protected maxResponseSize: bigint;
+    private mode;
+    modeError?: Error;
+    constructor(config: C, nextCallId: number, helpers: RuntimeHelpers, maxResponseSize: bigint, mode: Mode);
+    callCapability<I extends Message, O extends Message>({ capabilityId, method, payload, inputSchema, outputSchema, }: CallCapabilityParams<I, O>): {
+        result: () => Promise<O>;
+    };
+    getNextCallId(): number;
+    now(): Date;
+}
+export declare class NodeRuntimeImpl<C> extends BaseRuntimeImpl<C> implements NodeRuntime<C> {
+    _isNodeRuntime: true;
+    constructor(config: C, nextCallId: number, helpers: RuntimeHelpers, maxResponseSize: bigint);
+}
+export declare class RuntimeImpl<C> extends BaseRuntimeImpl<C> implements Runtime<C> {
+    private nextNodeCallId;
+    constructor(config: C, nextCallId: number, helpers: RuntimeHelpers, maxResponseSize: bigint);
+    runInNodeMode<TArgs extends any[], TOutput>(fn: (nodeRuntime: NodeRuntime<C>, ...args: TArgs) => Promise<TOutput> | TOutput, consesusAggretation: ConsensusAggregation<TOutput, true>, unwrapOptions?: TOutput extends PrimitiveTypes ? never : UnwrapOptions<TOutput>): (...args: TArgs) => Promise<TOutput>;
+    getSecret(request: SecretRequest | SecretRequestJson): {
+        result: () => Promise<Secret>;
+    };
+}
+export interface RuntimeHelpers {
+    call(request: CapabilityRequest): boolean;
+    await(request: AwaitCapabilitiesRequest, maxResponseSize: bigint): AwaitCapabilitiesResponse;
+    getSecrets(request: GetSecretsRequest, maxResponseSize: bigint): boolean;
+    awaitSecrets(request: AwaitSecretsRequest, maxResponseSize: bigint): AwaitSecretsResponse;
+    switchModes(mode: Mode): void;
+    now(): number;
+}

package/dist/sdk/impl/runtime-impl.js

@@ -0,0 +1,190 @@
+import { create } from '@bufbuild/protobuf';
+import { anyPack, anyUnpack } from '@bufbuild/protobuf/wkt';
+import { AwaitCapabilitiesRequestSchema, AwaitSecretsRequestSchema, CapabilityRequestSchema, GetSecretsRequestSchema, Mode, SecretRequestSchema, SimpleConsensusInputsSchema, } from '../../generated/sdk/v1alpha/sdk_pb';
+import { ConsensusCapability } from '../../generated-sdk/capabilities/internal/consensus/v1alpha/consensus_sdk_gen';
+import { Value, } from '../utils';
+import { CapabilityError } from '../utils/capabilities/capability-error';
+import { DonModeError, NodeModeError, SecretsError } from '../errors';
+export class BaseRuntimeImpl {
+    config;
+    nextCallId;
+    helpers;
+    maxResponseSize;
+    mode;
+    // modeError must only be set from within NodeRuntimeImpl
+    modeError;
+    constructor(config, nextCallId, helpers, maxResponseSize, mode) {
+        this.config = config;
+        this.nextCallId = nextCallId;
+        this.helpers = helpers;
+        this.maxResponseSize = maxResponseSize;
+        this.mode = mode;
+    }
+    callCapability({ capabilityId, method, payload, inputSchema, outputSchema, }) {
+        if (this.modeError) {
+            return { result: () => Promise.reject(this.modeError) };
+        }
+        // nextCallId tracks the unique id for a request to the WASM host.
+        // to avoid collisions of the ID in different modes, it is
+        // incremented in DON mode and decremented in Node mode.
+        // eg. - first call don mode: nextCallId = 1
+        //     - second call: nextCallId = 2
+        //     - first call node mode: nextCallId = -1
+        //     - second call node mode: nextCallId = -2
+        //     - etc...
+        const anyPayload = anyPack(inputSchema, payload);
+        const callbackId = this.nextCallId;
+        if (this.mode == Mode.DON)
+            this.nextCallId++;
+        else
+            this.nextCallId--;
+        const req = create(CapabilityRequestSchema, {
+            id: capabilityId,
+            method,
+            payload: anyPayload,
+            callbackId,
+        });
+        if (!this.helpers.call(req)) {
+            return {
+                result: () => {
+                    return Promise.reject(new CapabilityError(`Capability not found ${capabilityId}`, {
+                        callbackId,
+                        method,
+                        capabilityId,
+                    }));
+                },
+            };
+        }
+        return {
+            result: async () => {
+                const awaitRequest = create(AwaitCapabilitiesRequestSchema, { ids: [callbackId] });
+                const awaitResponse = this.helpers.await(awaitRequest, this.maxResponseSize);
+                const capabilityResponse = awaitResponse.responses[callbackId];
+                if (!capabilityResponse) {
+                    throw new CapabilityError(`No response found for callback ID ${callbackId}`, {
+                        capabilityId,
+                        method,
+                        callbackId,
+                    });
+                }
+                const response = capabilityResponse.response;
+                switch (response.case) {
+                    case 'payload':
+                        return anyUnpack(response.value, outputSchema);
+                    case 'error':
+                        throw new CapabilityError(`Error ${response.value}`, {
+                            capabilityId,
+                            method,
+                            callbackId,
+                        });
+                    default:
+                        throw new CapabilityError(`Error cannot unwrap ${response.case}`, {
+                            capabilityId,
+                            method,
+                            callbackId,
+                        });
+                }
+            },
+        };
+    }
+    getNextCallId() {
+        return this.nextCallId;
+    }
+    now() {
+        // ns to ms
+        return new Date(this.helpers.now() / 1000000);
+    }
+}
+export class NodeRuntimeImpl extends BaseRuntimeImpl {
+    _isNodeRuntime = true;
+    constructor(config, nextCallId, helpers, maxResponseSize) {
+        helpers.switchModes(Mode.NODE);
+        super(config, nextCallId, helpers, maxResponseSize, Mode.NODE);
+    }
+}
+export class RuntimeImpl extends BaseRuntimeImpl {
+    nextNodeCallId = -1;
+    constructor(config, nextCallId, helpers, maxResponseSize) {
+        helpers.switchModes(Mode.DON);
+        super(config, nextCallId, helpers, maxResponseSize, Mode.DON);
+    }
+    runInNodeMode(fn, consesusAggretation, unwrapOptions) {
+        return async (...args) => {
+            this.modeError = new DonModeError();
+            const nodeRuntime = new NodeRuntimeImpl(this.config, this.nextNodeCallId, this.helpers, this.maxResponseSize);
+            const consensusInput = create(SimpleConsensusInputsSchema, {
+                descriptors: consesusAggretation.descriptor,
+            });
+            if (consesusAggretation.defaultValue) {
+                // This cast is safe, since ConsensusAggregation can only have true its second argument if T extends CreSerializable<TOutput>
+                consensusInput.default = Value.from(consesusAggretation.defaultValue).proto();
+            }
+            try {
+                const observation = await fn(nodeRuntime, ...args);
+                // This cast is safe, since ConsensusAggregation can only have true its second argument if T extends CreSerializable<TOutput>
+                consensusInput.observation = {
+                    case: 'value',
+                    value: Value.from(observation).proto(),
+                };
+            }
+            catch (e) {
+                consensusInput.observation = { case: 'error', value: e.message || String(e) };
+            }
+            finally {
+                // Always restore DON mode before invoking consensus
+                this.modeError = undefined;
+                this.nextNodeCallId = nodeRuntime.nextCallId;
+                nodeRuntime.modeError = new NodeModeError();
+                this.helpers.switchModes(Mode.DON);
+            }
+            const consensus = new ConsensusCapability();
+            const result = await consensus.simple(this, consensusInput).result();
+            const wrappedValue = Value.wrap(result);
+            return unwrapOptions
+                ? wrappedValue.unwrapToType(unwrapOptions)
+                : wrappedValue.unwrap();
+        };
+    }
+    getSecret(request) {
+        if (this.modeError) {
+            return { result: () => Promise.reject(this.modeError) };
+        }
+        const secretRequest = request.$typeName
+            ? create(SecretRequestSchema, request)
+            : request;
+        const id = this.nextCallId;
+        this.nextCallId++;
+        const secretsReq = create(GetSecretsRequestSchema, {
+            callbackId: id,
+            requests: [request],
+        });
+        if (!this.helpers.getSecrets(secretsReq, this.maxResponseSize)) {
+            return {
+                result: () => Promise.reject(new SecretsError(secretRequest, 'host is not making the secrets request')),
+            };
+        }
+        return {
+            result: async () => {
+                const awaitRequest = create(AwaitSecretsRequestSchema, { ids: [id] });
+                const awaitResponse = this.helpers.awaitSecrets(awaitRequest, this.maxResponseSize);
+                const secretsResponse = awaitResponse.responses[id];
+                if (!secretsResponse) {
+                    throw new SecretsError(secretRequest, 'no response');
+                }
+                const responses = secretsResponse.responses;
+                if (responses.length != 1) {
+                    throw new SecretsError(secretRequest, 'invalid value returned from host');
+                }
+                const response = responses[0].response;
+                switch (response.case) {
+                    case 'secret':
+                        return response.value;
+                    case 'error':
+                        throw new SecretsError(secretRequest, response.value.error);
+                    default:
+                        throw new SecretsError(secretRequest, 'cannot unmashal returned value from host');
+                }
+            },
+        };
+    }
+}