@chainlink/cre-sdk 1.0.8 → 1.1.0

package/dist/sdk/test/generated/capabilities/internal/consensus/v1alpha/consensus_mock_gen.js

@@ -0,0 +1,67 @@
+import { fromJson } from '@bufbuild/protobuf';
+import { anyPack, anyUnpack } from '@bufbuild/protobuf/wkt';
+import { ReportRequestSchema, ReportResponseSchema, SimpleConsensusInputsSchema, } from '../../../../../../../generated/sdk/v1alpha/sdk_pb';
+import { ValueSchema } from '../../../../../../../generated/values/v1/values_pb';
+import { __getTestMockInstance, __setTestMockInstance, registerTestCapability, } from '../../../../../../testutils/test-runtime';
+/**
+ * Mock for ConsensusCapability. Use testInstance() to obtain an instance; do not construct directly.
+ * Set per-method properties (e.g. performAction) to define return values. If a method is invoked without a handler set, an error is thrown.
+ */
+export class ConsensusMock {
+    static CAPABILITY_ID = 'consensus@1.0.0-alpha';
+    /** Set to define the return value for Simple. May return a plain object (ValueJson) or the message type. */
+    simple;
+    /** Set to define the return value for Report. May return a plain object (ReportResponseJson) or the message type. */
+    report;
+    constructor() {
+        const self = this;
+        const qualifiedId = ConsensusMock.CAPABILITY_ID;
+        try {
+            registerTestCapability(qualifiedId, (req) => {
+                switch (req.method) {
+                    case 'Simple': {
+                        const input = anyUnpack(req.payload, SimpleConsensusInputsSchema);
+                        const handler = self.simple;
+                        if (typeof handler !== 'function')
+                            throw new Error("Simple: no implementation provided; set the mock's simple property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(ValueSchema, raw);
+                        return { response: { case: 'payload', value: anyPack(ValueSchema, output) } };
+                    }
+                    case 'Report': {
+                        const input = anyUnpack(req.payload, ReportRequestSchema);
+                        const handler = self.report;
+                        if (typeof handler !== 'function')
+                            throw new Error("Report: no implementation provided; set the mock's report property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(ReportResponseSchema, raw);
+                        return { response: { case: 'payload', value: anyPack(ReportResponseSchema, output) } };
+                    }
+                    default:
+                        return { response: { case: 'error', value: `unknown method ${req.method}` } };
+                }
+            });
+        }
+        catch {
+            throw new Error("Capability mocks must be used within the CRE test framework's test() method.");
+        }
+    }
+    /**
+     * Returns the mock instance for this capability.
+     * Multiple calls with the same arguments return the same instance.
+     * Must be called within the test framework's test() method.
+     */
+    static testInstance() {
+        const qualifiedId = ConsensusMock.CAPABILITY_ID;
+        let instance = __getTestMockInstance(qualifiedId);
+        if (!instance) {
+            instance = new ConsensusMock();
+            __setTestMockInstance(qualifiedId, instance);
+        }
+        return instance;
+    }
+}

package/dist/sdk/test/generated/capabilities/internal/nodeaction/v1/basic_test_node_action_mock_gen.d.ts

@@ -0,0 +1,17 @@
+import { type NodeInputs, type NodeOutputs, type NodeOutputsJson } from '../../../../../../../generated/capabilities/internal/nodeaction/v1/node_action_pb';
+/**
+ * Mock for BasicActionCapability. Use testInstance() to obtain an instance; do not construct directly.
+ * Set per-method properties (e.g. performAction) to define return values. If a method is invoked without a handler set, an error is thrown.
+ */
+export declare class BasicTestNodeActionMock {
+    static readonly CAPABILITY_ID = "basic-test-node-action@1.0.0";
+    /** Set to define the return value for PerformAction. May return a plain object (NodeOutputsJson) or the message type. */
+    performAction?: (input: NodeInputs) => NodeOutputs | NodeOutputsJson;
+    private constructor();
+    /**
+     * Returns the mock instance for this capability.
+     * Multiple calls with the same arguments return the same instance.
+     * Must be called within the test framework's test() method.
+     */
+    static testInstance(): BasicTestNodeActionMock;
+}

package/dist/sdk/test/generated/capabilities/internal/nodeaction/v1/basic_test_node_action_mock_gen.js

@@ -0,0 +1,53 @@
+import { fromJson } from '@bufbuild/protobuf';
+import { anyPack, anyUnpack } from '@bufbuild/protobuf/wkt';
+import { NodeInputsSchema, NodeOutputsSchema, } from '../../../../../../../generated/capabilities/internal/nodeaction/v1/node_action_pb';
+import { __getTestMockInstance, __setTestMockInstance, registerTestCapability, } from '../../../../../../testutils/test-runtime';
+/**
+ * Mock for BasicActionCapability. Use testInstance() to obtain an instance; do not construct directly.
+ * Set per-method properties (e.g. performAction) to define return values. If a method is invoked without a handler set, an error is thrown.
+ */
+export class BasicTestNodeActionMock {
+    static CAPABILITY_ID = 'basic-test-node-action@1.0.0';
+    /** Set to define the return value for PerformAction. May return a plain object (NodeOutputsJson) or the message type. */
+    performAction;
+    constructor() {
+        const self = this;
+        const qualifiedId = BasicTestNodeActionMock.CAPABILITY_ID;
+        try {
+            registerTestCapability(qualifiedId, (req) => {
+                switch (req.method) {
+                    case 'PerformAction': {
+                        const input = anyUnpack(req.payload, NodeInputsSchema);
+                        const handler = self.performAction;
+                        if (typeof handler !== 'function')
+                            throw new Error("PerformAction: no implementation provided; set the mock's performAction property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(NodeOutputsSchema, raw);
+                        return { response: { case: 'payload', value: anyPack(NodeOutputsSchema, output) } };
+                    }
+                    default:
+                        return { response: { case: 'error', value: `unknown method ${req.method}` } };
+                }
+            });
+        }
+        catch {
+            throw new Error("Capability mocks must be used within the CRE test framework's test() method.");
+        }
+    }
+    /**
+     * Returns the mock instance for this capability.
+     * Multiple calls with the same arguments return the same instance.
+     * Must be called within the test framework's test() method.
+     */
+    static testInstance() {
+        const qualifiedId = BasicTestNodeActionMock.CAPABILITY_ID;
+        let instance = __getTestMockInstance(qualifiedId);
+        if (!instance) {
+            instance = new BasicTestNodeActionMock();
+            __setTestMockInstance(qualifiedId, instance);
+        }
+        return instance;
+    }
+}

package/dist/sdk/test/generated/capabilities/networking/confidentialhttp/v1alpha/confidential_http_mock_gen.d.ts

@@ -0,0 +1,17 @@
+import { type ConfidentialHTTPRequest, type HTTPResponse, type HTTPResponseJson } from '../../../../../../../generated/capabilities/networking/confidentialhttp/v1alpha/client_pb';
+/**
+ * Mock for ClientCapability. Use testInstance() to obtain an instance; do not construct directly.
+ * Set per-method properties (e.g. performAction) to define return values. If a method is invoked without a handler set, an error is thrown.
+ */
+export declare class ConfidentialHttpMock {
+    static readonly CAPABILITY_ID = "confidential-http@1.0.0-alpha";
+    /** Set to define the return value for SendRequest. May return a plain object (HTTPResponseJson) or the message type. */
+    sendRequest?: (input: ConfidentialHTTPRequest) => HTTPResponse | HTTPResponseJson;
+    private constructor();
+    /**
+     * Returns the mock instance for this capability.
+     * Multiple calls with the same arguments return the same instance.
+     * Must be called within the test framework's test() method.
+     */
+    static testInstance(): ConfidentialHttpMock;
+}

package/dist/sdk/test/generated/capabilities/networking/confidentialhttp/v1alpha/confidential_http_mock_gen.js

@@ -0,0 +1,53 @@
+import { fromJson } from '@bufbuild/protobuf';
+import { anyPack, anyUnpack } from '@bufbuild/protobuf/wkt';
+import { ConfidentialHTTPRequestSchema, HTTPResponseSchema, } from '../../../../../../../generated/capabilities/networking/confidentialhttp/v1alpha/client_pb';
+import { __getTestMockInstance, __setTestMockInstance, registerTestCapability, } from '../../../../../../testutils/test-runtime';
+/**
+ * Mock for ClientCapability. Use testInstance() to obtain an instance; do not construct directly.
+ * Set per-method properties (e.g. performAction) to define return values. If a method is invoked without a handler set, an error is thrown.
+ */
+export class ConfidentialHttpMock {
+    static CAPABILITY_ID = 'confidential-http@1.0.0-alpha';
+    /** Set to define the return value for SendRequest. May return a plain object (HTTPResponseJson) or the message type. */
+    sendRequest;
+    constructor() {
+        const self = this;
+        const qualifiedId = ConfidentialHttpMock.CAPABILITY_ID;
+        try {
+            registerTestCapability(qualifiedId, (req) => {
+                switch (req.method) {
+                    case 'SendRequest': {
+                        const input = anyUnpack(req.payload, ConfidentialHTTPRequestSchema);
+                        const handler = self.sendRequest;
+                        if (typeof handler !== 'function')
+                            throw new Error("SendRequest: no implementation provided; set the mock's sendRequest property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(HTTPResponseSchema, raw);
+                        return { response: { case: 'payload', value: anyPack(HTTPResponseSchema, output) } };
+                    }
+                    default:
+                        return { response: { case: 'error', value: `unknown method ${req.method}` } };
+                }
+            });
+        }
+        catch {
+            throw new Error("Capability mocks must be used within the CRE test framework's test() method.");
+        }
+    }
+    /**
+     * Returns the mock instance for this capability.
+     * Multiple calls with the same arguments return the same instance.
+     * Must be called within the test framework's test() method.
+     */
+    static testInstance() {
+        const qualifiedId = ConfidentialHttpMock.CAPABILITY_ID;
+        let instance = __getTestMockInstance(qualifiedId);
+        if (!instance) {
+            instance = new ConfidentialHttpMock();
+            __setTestMockInstance(qualifiedId, instance);
+        }
+        return instance;
+    }
+}

package/dist/sdk/test/generated/capabilities/networking/http/v1alpha/http_actions_mock_gen.d.ts

@@ -0,0 +1,17 @@
+import { type Request, type Response, type ResponseJson } from '../../../../../../../generated/capabilities/networking/http/v1alpha/client_pb';
+/**
+ * Mock for ClientCapability. Use testInstance() to obtain an instance; do not construct directly.
+ * Set per-method properties (e.g. performAction) to define return values. If a method is invoked without a handler set, an error is thrown.
+ */
+export declare class HttpActionsMock {
+    static readonly CAPABILITY_ID = "http-actions@1.0.0-alpha";
+    /** Set to define the return value for SendRequest. May return a plain object (ResponseJson) or the message type. */
+    sendRequest?: (input: Request) => Response | ResponseJson;
+    private constructor();
+    /**
+     * Returns the mock instance for this capability.
+     * Multiple calls with the same arguments return the same instance.
+     * Must be called within the test framework's test() method.
+     */
+    static testInstance(): HttpActionsMock;
+}

package/dist/sdk/test/generated/capabilities/networking/http/v1alpha/http_actions_mock_gen.js

@@ -0,0 +1,53 @@
+import { fromJson } from '@bufbuild/protobuf';
+import { anyPack, anyUnpack } from '@bufbuild/protobuf/wkt';
+import { RequestSchema, ResponseSchema, } from '../../../../../../../generated/capabilities/networking/http/v1alpha/client_pb';
+import { __getTestMockInstance, __setTestMockInstance, registerTestCapability, } from '../../../../../../testutils/test-runtime';
+/**
+ * Mock for ClientCapability. Use testInstance() to obtain an instance; do not construct directly.
+ * Set per-method properties (e.g. performAction) to define return values. If a method is invoked without a handler set, an error is thrown.
+ */
+export class HttpActionsMock {
+    static CAPABILITY_ID = 'http-actions@1.0.0-alpha';
+    /** Set to define the return value for SendRequest. May return a plain object (ResponseJson) or the message type. */
+    sendRequest;
+    constructor() {
+        const self = this;
+        const qualifiedId = HttpActionsMock.CAPABILITY_ID;
+        try {
+            registerTestCapability(qualifiedId, (req) => {
+                switch (req.method) {
+                    case 'SendRequest': {
+                        const input = anyUnpack(req.payload, RequestSchema);
+                        const handler = self.sendRequest;
+                        if (typeof handler !== 'function')
+                            throw new Error("SendRequest: no implementation provided; set the mock's sendRequest property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(ResponseSchema, raw);
+                        return { response: { case: 'payload', value: anyPack(ResponseSchema, output) } };
+                    }
+                    default:
+                        return { response: { case: 'error', value: `unknown method ${req.method}` } };
+                }
+            });
+        }
+        catch {
+            throw new Error("Capability mocks must be used within the CRE test framework's test() method.");
+        }
+    }
+    /**
+     * Returns the mock instance for this capability.
+     * Multiple calls with the same arguments return the same instance.
+     * Must be called within the test framework's test() method.
+     */
+    static testInstance() {
+        const qualifiedId = HttpActionsMock.CAPABILITY_ID;
+        let instance = __getTestMockInstance(qualifiedId);
+        if (!instance) {
+            instance = new HttpActionsMock();
+            __setTestMockInstance(qualifiedId, instance);
+        }
+        return instance;
+    }
+}

package/dist/sdk/test/generated/index.d.ts

@@ -0,0 +1,8 @@
+/** Auto-generated barrel of capability mocks. Do not edit. */
+export { EvmMock } from './capabilities/blockchain/evm/v1alpha/evm_mock_gen';
+export { BasicTestActionTriggerMock } from './capabilities/internal/actionandtrigger/v1/basic_test_action_trigger_mock_gen';
+export { BasicTestActionMock } from './capabilities/internal/basicaction/v1/basic_test_action_mock_gen';
+export { ConsensusMock } from './capabilities/internal/consensus/v1alpha/consensus_mock_gen';
+export { BasicTestNodeActionMock } from './capabilities/internal/nodeaction/v1/basic_test_node_action_mock_gen';
+export { ConfidentialHttpMock } from './capabilities/networking/confidentialhttp/v1alpha/confidential_http_mock_gen';
+export { HttpActionsMock } from './capabilities/networking/http/v1alpha/http_actions_mock_gen';

package/dist/sdk/test/generated/index.js

@@ -0,0 +1,8 @@
+/** Auto-generated barrel of capability mocks. Do not edit. */
+export { EvmMock } from './capabilities/blockchain/evm/v1alpha/evm_mock_gen';
+export { BasicTestActionTriggerMock } from './capabilities/internal/actionandtrigger/v1/basic_test_action_trigger_mock_gen';
+export { BasicTestActionMock } from './capabilities/internal/basicaction/v1/basic_test_action_mock_gen';
+export { ConsensusMock } from './capabilities/internal/consensus/v1alpha/consensus_mock_gen';
+export { BasicTestNodeActionMock } from './capabilities/internal/nodeaction/v1/basic_test_node_action_mock_gen';
+export { ConfidentialHttpMock } from './capabilities/networking/confidentialhttp/v1alpha/confidential_http_mock_gen';
+export { HttpActionsMock } from './capabilities/networking/http/v1alpha/http_actions_mock_gen';

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

@@ -0,0 +1,7 @@
+/**
+ * Test-only surface for the CRE SDK: test framework and (when generated) capability mocks.
+ * Use for unit testing runtime logic without the WASM execution environment.
+ */
+export { type CapabilityHandler, DEFAULT_MAX_RESPONSE_SIZE_BYTES, getTestCapabilityHandler, type NewTestRuntimeOptions, newTestRuntime, REPORT_METADATA_HEADER_LENGTH, RESPONSE_BUFFER_TOO_SMALL, registerTestCapability, type Secrets, TestRuntime, type TestRuntimeState, test, } from '../testutils/test-runtime';
+export { TestWriter } from '../testutils/test-writer';
+export * from './generated';

package/dist/sdk/test/index.js

@@ -0,0 +1,7 @@
+/**
+ * Test-only surface for the CRE SDK: test framework and (when generated) capability mocks.
+ * Use for unit testing runtime logic without the WASM execution environment.
+ */
+export { DEFAULT_MAX_RESPONSE_SIZE_BYTES, getTestCapabilityHandler, newTestRuntime, REPORT_METADATA_HEADER_LENGTH, RESPONSE_BUFFER_TOO_SMALL, registerTestCapability, TestRuntime, test, } from '../testutils/test-runtime';
+export { TestWriter } from '../testutils/test-writer';
+export * from './generated';

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

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

package/dist/sdk/testutils/index.js

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

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

@@ -0,0 +1,84 @@
+/**
+ * TestRuntime and harness for testing the CRE SDK runtime without WASM.
+ * Registry is scoped per test via AsyncLocalStorage; use testWithRuntime to run tests with a registry.
+ */
+import type { Any } from '@bufbuild/protobuf/wkt';
+import type { RuntimeHelpers } from '../impl/runtime-impl';
+import { RuntimeImpl } from '../impl/runtime-impl';
+import { TestWriter } from './test-writer';
+/** Error message when response exceeds max size. Used by the harness when its await implements the size check. */
+export declare const RESPONSE_BUFFER_TOO_SMALL = "response buffer too small";
+export declare const DEFAULT_MAX_RESPONSE_SIZE_BYTES: number;
+export declare const REPORT_METADATA_HEADER_LENGTH = 109;
+export type Secrets = Map<string, Map<string, string>>;
+export type CapabilityHandler = (request: {
+    id: string;
+    method: string;
+    payload: Any;
+}) => {
+    response: {
+        case: 'payload';
+        value: Any;
+    };
+} | {
+    response: {
+        case: 'error';
+        value: string;
+    };
+};
+/**
+ * Returns the capability handler for the given id from the current test's registry, if any.
+ * Only defined when called inside a testWithRuntime scope (after the handler is registered).
+ */
+export declare function getTestCapabilityHandler(id: string): CapabilityHandler | undefined;
+/**
+ * Registers a capability handler for the current test's registry.
+ * Must be called inside a testWithRuntime scope; throws if no registry is active.
+ */
+export declare function registerTestCapability(id: string, handler: CapabilityHandler): void;
+/**
+ * Gets a mock instance from the current test's registry, or undefined if not found or no registry active.
+ * @internal Used by generated mocks for singleton pattern.
+ */
+export declare function __getTestMockInstance<T>(id: string): T | undefined;
+/**
+ * Stores a mock instance in the current test's registry.
+ * @internal Used by generated mocks for singleton pattern.
+ */
+export declare function __setTestMockInstance<T>(id: string, instance: T): void;
+/**
+ * Test-only: returns the current registry store (for cleanup/isolation assertions).
+ * Do not use in production code.
+ */
+export declare function __testOnlyRegistryStore(): object | undefined;
+/**
+ * Test-only: runs a callback with a fresh registry and cleans up (for cleanup/failure tests).
+ * Do not use in production code.
+ */
+export declare function __testOnlyRunWithRegistry(fn: () => void | Promise<void>): Promise<void>;
+export interface TestRuntimeState {
+    timeProvider?: () => number;
+}
+export interface NewTestRuntimeOptions {
+    timeProvider?: () => number;
+    maxResponseSize?: number;
+}
+/**
+ * Runs a test using the CRE runtime.
+ */
+export declare function test(title: string, fn: () => void | Promise<void>): void;
+/**
+ * Creates a test runtime. This must be called from within a test in this package.
+ */
+export declare function newTestRuntime(secrets?: Secrets | null, options?: NewTestRuntimeOptions): TestRuntime;
+/**
+ * TestRuntime is a Runtime implementation for unit tests. Extends RuntimeImpl; construct via newTestRuntime.
+ * Adds getLogs() and setTimeProvider(). Registry is accessed via getTestCapabilityHandler when inside testWithRuntime.
+ */
+export declare class TestRuntime extends RuntimeImpl<unknown> {
+    private readonly testWriter;
+    private readonly state;
+    constructor(helpers: RuntimeHelpers, maxResponseSize: bigint, testWriter: TestWriter, state: TestRuntimeState);
+    getLogs(): string[];
+    setTimeProvider(timeProvider: () => number): void;
+}