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

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

@@ -0,0 +1,334 @@
+import { afterEach, describe, expect, mock, test } from 'bun:test';
+import { create } from '@bufbuild/protobuf';
+import { anyPack, anyUnpack } from '@bufbuild/protobuf/wkt';
+import { InputSchema, OutputSchema as OutputSchema, } from '../../generated/capabilities/internal/actionandtrigger/v1/action_and_trigger_pb';
+import { InputsSchema, OutputsSchema, } from '../../generated/capabilities/internal/basicaction/v1/basic_action_pb';
+import { NodeInputsSchema, NodeOutputsSchema, } from '../../generated/capabilities/internal/nodeaction/v1/node_action_pb';
+import { AggregationType, AwaitCapabilitiesResponseSchema, CapabilityResponseSchema, ConsensusDescriptorSchema, FieldsMapSchema, Mode, } from '../../generated/sdk/v1alpha/sdk_pb';
+import { BasicCapability } from '../../generated-sdk/capabilities/internal/actionandtrigger/v1/basic_sdk_gen';
+import { BasicActionCapability } from '../../generated-sdk/capabilities/internal/basicaction/v1/basicaction_sdk_gen';
+import { ConsensusCapability } from '../../generated-sdk/capabilities/internal/consensus/v1alpha/consensus_sdk_gen';
+import { BasicActionCapability as NodeActionCapability } from '../../generated-sdk/capabilities/internal/nodeaction/v1/basicaction_sdk_gen';
+import { ConsensusAggregationByFields, consensusMedianAggregation, median, Value, } from '../utils';
+import { CapabilityError } from '../utils/capabilities/capability-error';
+import { DonModeError, NodeModeError } from '../errors';
+import { RuntimeImpl } from './runtime-impl';
+// Helper function to create a RuntimeHelpers mock with error-throwing defaults
+function createRuntimeHelpersMock(overrides = {}) {
+    // Create default implementation that throws errors for all methods
+    const defaultMock = {
+        call: mock(() => {
+            throw new Error('Method not implemented: call');
+        }),
+        await: mock(() => {
+            throw new Error('Method not implemented: await');
+        }),
+        getSecrets: mock(() => {
+            throw new Error('Method not implemented: getSecrets');
+        }),
+        awaitSecrets: mock(() => {
+            throw new Error('Method not implemented: awaitSecrets');
+        }),
+        // switchModes is used in every test, most will ignore it, so it's safe to default to a no-op.
+        switchModes: mock(() => { }),
+        now: mock(() => {
+            throw new Error('Method not implemented: now');
+        }),
+    };
+    // Return a merged object with overrides taking precedence
+    return { ...defaultMock, ...overrides };
+}
+const anyMaxSize = 1024n * 1024n;
+// Store original prototypes for manual restoration
+const originalConsensusSimple = ConsensusCapability.prototype.simple;
+const originalNodeActionPerformAction = NodeActionCapability.prototype.performAction;
+afterEach(() => {
+    // Restore all mocks after each test
+    mock.restore();
+    // Manually restore prototype methods
+    ConsensusCapability.prototype.simple = originalConsensusSimple;
+    NodeActionCapability.prototype.performAction = originalNodeActionPerformAction;
+});
+describe('test runtime', () => {
+    describe('test call capability', () => {
+        // TODO:
+        test.skip('runs async - proper async implementation in progress', async () => {
+            const anyResult1 = 'ok1';
+            const anyResult2 = 'ok2';
+            var expectedCall = 1;
+            var expectedAwait = 2;
+            const input1 = create(InputsSchema, { inputThing: true });
+            const input2 = create(InputSchema, { name: 'input' });
+            const helpers = createRuntimeHelpersMock({
+                call: mock((request) => {
+                    switch (request.callbackId) {
+                        case 1:
+                            return expectCapabilityCall(request, input1, InputsSchema, BasicActionCapability.CAPABILITY_ID, expectedCall++);
+                        case 2:
+                            return expectCapabilityCall(request, input2, InputSchema, BasicCapability.CAPABILITY_ID, expectedCall++);
+                        default:
+                            throw new Error(`Unexpected call with callbackId: ${request.callbackId}`);
+                    }
+                }),
+                await: mock((request) => {
+                    expect(request.ids.length).toEqual(1);
+                    var payload;
+                    const id = request.ids[0];
+                    switch (id) {
+                        case 1:
+                            expect(1).toEqual(expectedAwait);
+                            expectedAwait--;
+                            payload = anyPack(OutputsSchema, create(OutputsSchema, { adaptedThing: anyResult1 }));
+                            break;
+                        case 2:
+                            expect(2).toEqual(expectedAwait);
+                            expectedAwait--;
+                            payload = anyPack(OutputSchema, create(OutputSchema, { welcome: anyResult2 }));
+                            break;
+                        default:
+                            throw new Error(`Unexpected await with id: ${request.ids[0]}`);
+                    }
+                    return create(AwaitCapabilitiesResponseSchema, {
+                        responses: {
+                            [id]: create(CapabilityResponseSchema, {
+                                response: { case: 'payload', value: payload },
+                            }),
+                        },
+                    });
+                }),
+            });
+            const runtime = new RuntimeImpl({}, 1, helpers, anyMaxSize);
+            const workflowAction1 = new BasicActionCapability();
+            const call1 = workflowAction1.performAction(runtime, input1);
+            const workflowAction2 = new BasicCapability();
+            const call2 = workflowAction2.action(runtime, input2);
+            const result2 = await call2.result();
+            expect(result2.welcome).toEqual(anyResult2);
+            const result1 = await call1.result();
+            expect(result1.adaptedThing).toEqual(anyResult1);
+        });
+        test('call capability errors', async () => {
+            const helpers = createRuntimeHelpersMock({
+                call: mock((_) => {
+                    return false;
+                }),
+            });
+            const runtime = new RuntimeImpl({}, 1, helpers, anyMaxSize);
+            const workflowAction1 = new BasicActionCapability();
+            const call1 = workflowAction1
+                .performAction(runtime, create(InputsSchema, { inputThing: true }))
+                .result();
+            expect(call1).rejects.toThrow(new CapabilityError(`Capability not found ${BasicActionCapability.CAPABILITY_ID}`, {
+                callbackId: 1,
+                capabilityId: BasicActionCapability.CAPABILITY_ID,
+                method: 'PerformAction',
+            }));
+        });
+        test('capability errors are returned to the caller', async () => {
+            const anyError = 'error';
+            const helpers = createRuntimeHelpersMock({
+                call: mock((_) => {
+                    return true;
+                }),
+                await: mock((request) => {
+                    expect(request.ids.length).toEqual(1);
+                    return create(AwaitCapabilitiesResponseSchema, {
+                        responses: {
+                            [request.ids[0]]: create(CapabilityResponseSchema, {
+                                response: { case: 'error', value: anyError },
+                            }),
+                        },
+                    });
+                }),
+            });
+            const runtime = new RuntimeImpl({}, 1, helpers, anyMaxSize);
+            const workflowAction1 = new BasicActionCapability();
+            const call1 = workflowAction1
+                .performAction(runtime, create(InputsSchema, { inputThing: true }))
+                .result();
+            expect(call1).rejects.toThrow(new CapabilityError('Error ' + anyError, {
+                callbackId: 1,
+                capabilityId: BasicActionCapability.CAPABILITY_ID,
+                method: 'PerformAction',
+            }));
+        });
+        test('await errors', async () => {
+            const anyError = 'error';
+            const helpers = createRuntimeHelpersMock({
+                call: mock((_) => {
+                    return true;
+                }),
+                await: mock((_) => {
+                    throw new Error(anyError);
+                }),
+            });
+            const runtime = new RuntimeImpl({}, 1, helpers, anyMaxSize);
+            const workflowAction1 = new BasicActionCapability();
+            const call1 = workflowAction1
+                .performAction(runtime, create(InputsSchema, { inputThing: true }))
+                .result();
+            expect(call1).rejects.toThrow(new CapabilityError(anyError, {
+                callbackId: 1,
+                capabilityId: BasicActionCapability.CAPABILITY_ID,
+                method: 'PerformAction',
+            }));
+        });
+        test('await missing response', async () => {
+            const helpers = createRuntimeHelpersMock({
+                call: mock((_) => {
+                    return true;
+                }),
+                await: mock((_) => {
+                    return create(AwaitCapabilitiesResponseSchema, { responses: {} });
+                }),
+            });
+            const runtime = new RuntimeImpl({}, 1, helpers, anyMaxSize);
+            const workflowAction1 = new BasicActionCapability();
+            const call1 = workflowAction1
+                .performAction(runtime, create(InputsSchema, { inputThing: true }))
+                .result();
+            expect(call1).rejects.toThrow(new CapabilityError('No response found for callback ID 1', {
+                callbackId: 1,
+                capabilityId: BasicActionCapability.CAPABILITY_ID,
+                method: 'PerformAction',
+            }));
+        });
+    });
+});
+describe('test now conversts to date', () => {
+    test('now converts to date', () => {
+        const helpers = createRuntimeHelpersMock({
+            now: mock(() => 1716153600000),
+        });
+        const runtime = new RuntimeImpl({}, 1, helpers, anyMaxSize);
+        const now = runtime.now();
+        expect(now).toEqual(new Date(1716153600000 / 1000000));
+    });
+});
+describe('test run in node mode', () => {
+    test('successful consensus', async () => {
+        const anyObservation = 10;
+        const anyMedian = 11;
+        const modes = [];
+        const helpers = createRuntimeHelpersMock({
+            switchModes: mock((mode) => {
+                modes.push(mode);
+            }),
+        });
+        ConsensusCapability.prototype.simple = mock((_, inputs) => {
+            expect(modes).toEqual([Mode.DON, Mode.NODE, Mode.DON]);
+            expect(inputs.default).toBeUndefined();
+            const consensusDescriptor = create(ConsensusDescriptorSchema, {
+                descriptor: {
+                    case: 'fieldsMap',
+                    value: create(FieldsMapSchema, {
+                        fields: {
+                            outputThing: create(ConsensusDescriptorSchema, {
+                                descriptor: { case: 'aggregation', value: AggregationType.MEDIAN },
+                            }),
+                        },
+                    }),
+                },
+            });
+            expect(inputs.descriptors).toEqual(consensusDescriptor);
+            expect(inputs.$typeName).not.toBeUndefined();
+            const inputsProto = inputs;
+            expect(inputsProto.observation.case).toEqual('value');
+            expect(Value.wrap(inputsProto.observation.value).unwrapToType({
+                factory: () => create(NodeOutputsSchema),
+            }).outputThing).toEqual(anyObservation);
+            return {
+                result: async () => Value.from(create(NodeOutputsSchema, { outputThing: anyMedian })).proto(),
+            };
+        });
+        NodeActionCapability.prototype.performAction = mock((_, __) => {
+            expect(modes).toEqual([Mode.DON, Mode.NODE]);
+            return {
+                result: async () => create(NodeOutputsSchema, { outputThing: anyObservation }),
+            };
+        });
+        const runtime = new RuntimeImpl({}, 1, helpers, anyMaxSize);
+        const result = await runtime.runInNodeMode(async (nodeRuntime) => {
+            const capability = new NodeActionCapability();
+            return await capability
+                .performAction(nodeRuntime, create(NodeInputsSchema, { inputThing: true }))
+                .result();
+        }, ConsensusAggregationByFields({ outputThing: median }))();
+        expect(result.outputThing).toEqual(anyMedian);
+    });
+    test('failed consensus', async () => {
+        const anyError = 'error';
+        const helpers = createRuntimeHelpersMock({
+            switchModes: mock((_) => { }),
+        });
+        ConsensusCapability.prototype.simple = mock((_, inputs) => {
+            expect(inputs.default).toBeUndefined();
+            expect(inputs.descriptors).toEqual(create(ConsensusDescriptorSchema, {
+                descriptor: { case: 'aggregation', value: AggregationType.MEDIAN },
+            }));
+            expect(inputs.$typeName).not.toBeUndefined();
+            const inputsProto = inputs;
+            expect(inputsProto.observation.case).toEqual('error');
+            expect(inputsProto.observation.value).toEqual(anyError);
+            return { result: async () => Promise.reject(new Error(anyError)) };
+        });
+        const runtime = new RuntimeImpl({}, 1, helpers, anyMaxSize);
+        const result = runtime.runInNodeMode(async (nodeRuntime) => {
+            throw new Error(anyError);
+        }, consensusMedianAggregation())();
+        expect(result).rejects.toThrow(new Error(anyError));
+    });
+    test('node runtime in don mode fails', async () => {
+        const helpers = createRuntimeHelpersMock({
+            switchModes: mock((_) => { }),
+            call: mock((_) => {
+                expect(false).toBe(true);
+                return false;
+            }),
+        });
+        ConsensusCapability.prototype.simple = mock((_, __) => {
+            return { result: async () => Promise.resolve(Value.from(0).proto()) };
+        });
+        const runtime = new RuntimeImpl({}, 1, helpers, anyMaxSize);
+        var nrt;
+        await runtime.runInNodeMode(async (nodeRuntime) => {
+            nrt = nodeRuntime;
+            return 0;
+        }, consensusMedianAggregation())();
+        const capability = new NodeActionCapability();
+        expect(nrt).toBeDefined();
+        expect(capability.performAction(nrt, create(NodeInputsSchema, { inputThing: true })).result()).rejects.toThrow(new NodeModeError());
+    });
+    test('don runtime in node mode fails', async () => {
+        const helpers = createRuntimeHelpersMock({
+            switchModes: mock((_) => { }),
+        });
+        ConsensusCapability.prototype.simple = mock((_, inputs) => {
+            expect(inputs.default).toBeUndefined();
+            expect(inputs.descriptors).toEqual(create(ConsensusDescriptorSchema, {
+                descriptor: { case: 'aggregation', value: AggregationType.MEDIAN },
+            }));
+            expect(inputs.$typeName).not.toBeUndefined();
+            const inputsProto = inputs;
+            expect(inputsProto.observation.case).toEqual('error');
+            expect(inputsProto.observation.value).toEqual(new DonModeError().message);
+            return { result: async () => Promise.reject(new DonModeError()) };
+        });
+        const runtime = new RuntimeImpl({}, 1, helpers, anyMaxSize);
+        const result = runtime.runInNodeMode(async (_) => {
+            const capability = new BasicActionCapability();
+            await capability.performAction(runtime, create(InputsSchema, { inputThing: true })).result();
+            return 0;
+        }, consensusMedianAggregation())();
+        expect(result).rejects.toThrow(new DonModeError());
+    });
+});
+function expectCapabilityCall(request, expectedPayload, desc, expectedCapabilityId, expectedCallbackId) {
+    expect(request.id).toEqual(expectedCapabilityId);
+    expect(request.method).toEqual('PerformAction');
+    expect(request.callbackId).toEqual(expectedCallbackId);
+    expect(request.payload).toBeDefined();
+    const payload = anyUnpack(request.payload, desc);
+    expect(payload).toEqual(expectedPayload);
+    return true;
+}

package/dist/sdk/index.d.ts

@@ -1 +1,4 @@
 export * from './cre';
+export type * from './runtime';
+export * from './runtime';
+export * from './workflow';

package/dist/sdk/index.js

@@ -1 +1,3 @@
 export * from './cre';
+export * from './runtime';
+export * from './workflow';

package/dist/sdk/runtime.d.ts

@@ -0,0 +1,24 @@
+import type { Message } from '@bufbuild/protobuf';
+import type { GenMessage } from '@bufbuild/protobuf/codegenv2';
+import type { ConsensusAggregation, PrimitiveTypes, UnwrapOptions } from './utils';
+import type { SecretsProvider } from '.';
+export type CallCapabilityParams<I extends Message, O extends Message> = {
+    capabilityId: string;
+    method: string;
+    payload: I;
+    inputSchema: GenMessage<I>;
+    outputSchema: GenMessage<O>;
+};
+export type BaseRuntime<C> = {
+    config: C;
+    callCapability<I extends Message, O extends Message>(params: CallCapabilityParams<I, O>): {
+        result: () => Promise<O>;
+    };
+    now(): Date;
+};
+export type Runtime<C> = BaseRuntime<C> & SecretsProvider & {
+    runInNodeMode<TArgs extends any[], TOutput>(fn: (nodeRuntime: NodeRuntime<C>, ...args: TArgs) => Promise<TOutput> | TOutput, consensusAggregation: ConsensusAggregation<TOutput, true>, unwrapOptions?: TOutput extends PrimitiveTypes ? never : UnwrapOptions<TOutput>): (...args: TArgs) => Promise<TOutput>;
+};
+export type NodeRuntime<C> = BaseRuntime<C> & {
+    readonly _isNodeRuntime: true;
+};

package/dist/sdk/utils/capabilities/capability-error.d.ts

@@ -1,14 +1,11 @@
-import type { Mode } from '../../../generated/sdk/v1alpha/sdk_pb';
 export declare class CapabilityError extends Error {
     name: string;
     capabilityId?: string;
     method?: string;
-    mode?: Mode;
     callbackId?: number;
     constructor(message: string, options?: {
         capabilityId?: string;
         method?: string;
-        mode?: Mode;
         callbackId?: number;
     });
 }

package/dist/sdk/utils/capabilities/capability-error.js

@@ -2,7 +2,6 @@ export class CapabilityError extends Error {
     name;
     capabilityId;
     method;
-    mode;
     callbackId;
     constructor(message, options) {
         super(message);
@@ -10,7 +9,6 @@ export class CapabilityError extends Error {
         if (options) {
             this.capabilityId = options.capabilityId;
             this.method = options.method;
-            this.mode = options.mode;
             this.callbackId = options.callbackId;
         }
     }

package/dist/sdk/utils/config/configHandler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sdk/utils/config/configHandler.test.js

@@ -0,0 +1,193 @@
+import { describe, expect, it } from 'bun:test';
+import { z } from 'zod';
+import { configHandler } from './index';
+// Mock schema for testing
+const mockSchema = {
+    '~standard': {
+        version: 1,
+        vendor: 'test',
+        validate: (input) => {
+            if (typeof input !== 'object' || input === null) {
+                return { issues: [{ message: 'Expected object' }] };
+            }
+            return { value: input };
+        },
+    },
+};
+// Helper to create mock ExecuteRequest
+const createMockRequest = (configData) => ({
+    config: new TextEncoder().encode(configData),
+});
+describe('configHandler', () => {
+    it('should work with no params passed in - uses default JSON parser', async () => {
+        const configData = '{"name": "test", "value": 42}';
+        const request = createMockRequest(configData);
+        const result = await configHandler(request);
+        expect(result).toEqual({ name: 'test', value: 42 });
+    });
+    it('should work with only parser passed in - JSON parsing', async () => {
+        const configData = '{"schedule": "0 0 * * *", "enabled": true}';
+        const request = createMockRequest(configData);
+        const customParser = (config) => {
+            const json = JSON.parse(Buffer.from(config).toString());
+            return { ...json, parsed: true };
+        };
+        const result = await configHandler(request, { configParser: customParser });
+        expect(result).toEqual({
+            schedule: '0 0 * * *',
+            enabled: true,
+            parsed: true,
+        });
+    });
+    it('should work with only parser passed in - noop parser (keeps Uint8Array)', async () => {
+        const configData = 'raw binary data';
+        const request = createMockRequest(configData);
+        const noopParser = (config) => config;
+        const result = await configHandler(request, { configParser: noopParser });
+        expect(result).toBeInstanceOf(Uint8Array);
+        expect(new TextDecoder().decode(result)).toBe(configData);
+    });
+    it('should work with only schema passed in - uses default parser', async () => {
+        const configData = '{"valid": "json", "number": 123}';
+        const request = createMockRequest(configData);
+        const result = await configHandler(request, { configSchema: mockSchema });
+        expect(result).toEqual({ valid: 'json', number: 123 });
+    });
+    it('should work with both parser and schema', async () => {
+        const configData = '{"raw": "data", "needs": "processing"}';
+        const request = createMockRequest(configData);
+        const customParser = (config) => {
+            const parsed = JSON.parse(Buffer.from(config).toString());
+            return { ...parsed, processed: true };
+        };
+        const result = await configHandler(request, {
+            configParser: customParser,
+            configSchema: mockSchema,
+        });
+        expect(result).toEqual({
+            raw: 'data',
+            needs: 'processing',
+            processed: true,
+        });
+    });
+    it('should throw error when schema validation fails', async () => {
+        const configData = 'invalid json';
+        const request = createMockRequest(configData);
+        expect(configHandler(request, { configSchema: mockSchema })).rejects.toThrow();
+    });
+    it('should handle empty JSON object', async () => {
+        const configData = '{}';
+        const request = createMockRequest(configData);
+        const result = await configHandler(request);
+        expect(result).toEqual({});
+    });
+    it('should handle complex nested JSON', async () => {
+        const configData = JSON.stringify({
+            nested: {
+                array: [1, 2, 3],
+                object: { key: 'value' },
+            },
+            boolean: true,
+            nullValue: null,
+        });
+        const request = createMockRequest(configData);
+        const result = await configHandler(request);
+        expect(result).toEqual({
+            nested: {
+                array: [1, 2, 3],
+                object: { key: 'value' },
+            },
+            boolean: true,
+            nullValue: null,
+        });
+    });
+    it('should work with custom parser that returns different type', async () => {
+        const configData = '{"count": 5}';
+        const request = createMockRequest(configData);
+        const customParser = (config) => {
+            const parsed = JSON.parse(Buffer.from(config).toString());
+            return parsed.count * 2; // Return number instead of object
+        };
+        const result = await configHandler(request, { configParser: customParser });
+        expect(result).toBe(10);
+    });
+    it('should work with Zod schema validation', async () => {
+        const configData = JSON.stringify({
+            schedule: '0 0 * * *',
+            apiUrl: 'https://api.example.com',
+            timeout: 5000,
+            retries: 3,
+        });
+        const request = createMockRequest(configData);
+        // Create Zod schema
+        const zodSchema = z.object({
+            schedule: z.string(),
+            apiUrl: z.string().url(),
+            timeout: z.number().min(1000).max(30000),
+            retries: z.number().min(0).max(10),
+        });
+        const result = await configHandler(request, { configSchema: zodSchema });
+        expect(result).toEqual({
+            schedule: '0 0 * * *',
+            apiUrl: 'https://api.example.com',
+            timeout: 5000,
+            retries: 3,
+        });
+    });
+    it('should throw error when Zod schema validation fails', async () => {
+        const configData = JSON.stringify({
+            schedule: 'invalid cron',
+            apiUrl: 'not-a-url', // Invalid URL
+            timeout: 100, // Too low
+            retries: 15, // Too high
+        });
+        const request = createMockRequest(configData);
+        const zodSchema = z.object({
+            schedule: z.string(),
+            apiUrl: z.string().url(),
+            timeout: z.number().min(1000).max(30000),
+            retries: z.number().min(0).max(10),
+        });
+        expect(configHandler(request, { configSchema: zodSchema })).rejects.toThrow();
+    });
+    it('should work with Zod schema and custom parser', async () => {
+        const configData = JSON.stringify({
+            rawData: 'base64encoded',
+            metadata: { version: '1.0', type: 'config' },
+        });
+        const request = createMockRequest(configData);
+        // Custom parser that processes the data
+        const customParser = (config) => {
+            const parsed = JSON.parse(Buffer.from(config).toString());
+            return {
+                schedule: '0 0 * * *', // Extract from rawData
+                apiUrl: 'https://api.example.com', // Extract from rawData
+                timeout: 5000,
+                retries: 3,
+                metadata: parsed.metadata,
+            };
+        };
+        // Zod schema for the processed data
+        const zodSchema = z.object({
+            schedule: z.string(),
+            apiUrl: z.string().url(),
+            timeout: z.number().min(1000).max(30000),
+            retries: z.number().min(0).max(10),
+            metadata: z.object({
+                version: z.string(),
+                type: z.string(),
+            }),
+        });
+        const result = await configHandler(request, {
+            configParser: customParser,
+            configSchema: zodSchema,
+        });
+        expect(result).toEqual({
+            schedule: '0 0 * * *',
+            apiUrl: 'https://api.example.com',
+            timeout: 5000,
+            retries: 3,
+            metadata: { version: '1.0', type: 'config' },
+        });
+    });
+});

package/dist/sdk/utils/config/index.d.ts

@@ -1,9 +1,7 @@
 import type { ExecuteRequest } from '../../../generated/sdk/v1alpha/sdk_pb';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-export declare const getConfigFromExecuteRequest: (executeRequest: ExecuteRequest) => any;
-export declare const getConfig: () => any;
-export type ConfigHandlerParams = {
-    configParser?: (config: unknown) => unknown;
-    configSchema?: StandardSchemaV1;
+export type ConfigHandlerParams<TConfig, TIntermediateConfig = TConfig> = {
+    configParser?: (config: Uint8Array) => TIntermediateConfig;
+    configSchema?: StandardSchemaV1<TIntermediateConfig, TConfig>;
 };
-export declare const configHandler: <TConfig>({ configParser, configSchema, }?: ConfigHandlerParams) => Promise<TConfig>;
+export declare const configHandler: <TConfig, TIntermediateConfig = TConfig>(request: ExecuteRequest, { configParser, configSchema }?: ConfigHandlerParams<TConfig, TIntermediateConfig>) => Promise<TConfig>;

package/dist/sdk/utils/config/index.js

@@ -1,26 +1,4 @@
-import { getRequest } from '../get-request';
-export const getConfigFromExecuteRequest = (executeRequest) => {
-    const config = executeRequest.config;
-    const configString = Buffer.from(config).toString();
-    try {
-        return JSON.parse(configString);
-    }
-    catch (e) {
-        if (typeof configString === 'string') {
-            return configString;
-        }
-        if (e instanceof Error) {
-            console.error(e.message);
-            console.error(e.stack);
-        }
-        throw e;
-    }
-};
-export const getConfig = () => {
-    const executeRequest = getRequest();
-    return getConfigFromExecuteRequest(executeRequest);
-};
-const standardValidate = async (schema, input) => {
+async function standardValidate(schema, input) {
     let result = schema['~standard'].validate(input);
     if (result instanceof Promise)
         result = await result;
@@ -32,15 +10,13 @@ const standardValidate = async (schema, input) => {
         throw new Error(JSON.stringify(result.issues, null, 2));
     }
     return result.value;
-};
-export const configHandler = async ({ configParser, configSchema, } = {}) => {
-    const config = getConfig();
-    let parsedConfig = config;
-    if (configParser) {
-        parsedConfig = configParser(config);
-    }
-    if (configSchema) {
-        parsedConfig = await standardValidate(configSchema, parsedConfig);
-    }
-    return parsedConfig;
+}
+const defaultJsonParser = (config) => JSON.parse(Buffer.from(config).toString());
+export const configHandler = async (request, { configParser, configSchema } = {}) => {
+    const config = request.config;
+    const parser = configParser || defaultJsonParser;
+    const intermediateConfig = parser(config);
+    return configSchema
+        ? standardValidate(configSchema, intermediateConfig)
+        : intermediateConfig;
 };

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

@@ -1,7 +1,4 @@
-export * from './error-boundary';
-export { withErrorBoundary } from './error-boundary';
 export * from './hex-utils';
-export * from './send-response-value';
 export * from './values/consensus_aggregators';
 export * from './values/serializer_types';
 export * from './values/value';