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

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

@@ -0,0 +1,42 @@
+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: () => O;
+    };
+    getNextCallId(): number;
+    now(): Date;
+    log(message: string): void;
+}
+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 unknown[], TOutput>(fn: (nodeRuntime: NodeRuntime<C>, ...args: TArgs) => TOutput, consesusAggretation: ConsensusAggregation<TOutput, true>, unwrapOptions?: TOutput extends PrimitiveTypes ? never : UnwrapOptions<TOutput>): (...args: TArgs) => {
+        result: () => TOutput;
+    };
+    getSecret(request: SecretRequest | SecretRequestJson): {
+        result: () => 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;
+    log(message: string): void;
+}

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

@@ -0,0 +1,213 @@
+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: () => {
+                    throw 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: () => {
+                    throw new CapabilityError(`Capability not found ${capabilityId}`, {
+                        callbackId,
+                        method,
+                        capabilityId,
+                    });
+                },
+            };
+        }
+        return {
+            result: () => {
+                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);
+    }
+    log(message) {
+        this.helpers.log(message);
+    }
+}
+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 (...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 = 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 instanceof Error && 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 call = consensus.simple(this, consensusInput);
+            return {
+                result: () => {
+                    const result = call.result();
+                    const wrappedValue = Value.wrap(result);
+                    return unwrapOptions
+                        ? wrappedValue.unwrapToType(unwrapOptions)
+                        : wrappedValue.unwrap();
+                },
+            };
+        };
+    }
+    getSecret(request) {
+        if (this.modeError) {
+            return {
+                result: () => {
+                    throw 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: () => {
+                    throw new SecretsError(secretRequest, 'host is not making the secrets request');
+                },
+            };
+        }
+        return {
+            result: () => {
+                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');
+                }
+            },
+        };
+    }
+}

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,27 @@
+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: () => O;
+    };
+    now(): Date;
+    log(message: string): void;
+};
+export type Runtime<C> = BaseRuntime<C> & SecretsProvider & {
+    runInNodeMode<TArgs extends unknown[], TOutput>(fn: (nodeRuntime: NodeRuntime<C>, ...args: TArgs) => TOutput, consensusAggregation: ConsensusAggregation<TOutput, true>, unwrapOptions?: TOutput extends PrimitiveTypes ? never : UnwrapOptions<TOutput>): (...args: TArgs) => {
+        result: () => 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/chain-selectors/getNetwork.d.ts

@@ -1,8 +1,8 @@
 import type { ChainFamily, NetworkInfo } from './types';
 interface GetNetworkOptions {
-    chainSelector?: string;
+    chainSelector?: bigint;
     chainSelectorName?: string;
-    isTestnet?: boolean;
+    isTestnet?: boolean | undefined;
     chainFamily?: ChainFamily;
 }
 /**

package/dist/sdk/utils/chain-selectors/getNetwork.js

@@ -5,32 +5,73 @@ import { mainnetByName, mainnetByNameByFamily, mainnetBySelector, mainnetBySelec
  * @returns NetworkInfo if found, undefined otherwise
  */
 export const getNetwork = (options) => {
-    const { chainSelector, chainSelectorName, isTestnet = false, chainFamily } = options;
+    const { chainSelector, chainSelectorName, isTestnet, chainFamily } = options;
+    const getBySelector = (map) => {
+        if (chainSelector === undefined)
+            return undefined;
+        return map.get(chainSelector);
+    };
     // Validate input - need either chainSelector or chainSelectorName
     if (!chainSelector && !chainSelectorName) {
         return undefined;
     }
     // If both chainFamily and network type are specified, use the most specific maps
-    if (chainFamily && chainSelector) {
-        const familyMap = isTestnet
-            ? testnetBySelectorByFamily[chainFamily]
-            : mainnetBySelectorByFamily[chainFamily];
-        return familyMap?.get(chainSelector);
+    if (chainFamily && chainSelector !== undefined) {
+        if (isTestnet === false) {
+            return getBySelector(mainnetBySelectorByFamily[chainFamily]);
+        }
+        if (isTestnet === true) {
+            return getBySelector(testnetBySelectorByFamily[chainFamily]);
+        }
+        // If user haven't defined if it's testnet or not we can try all networks, starting from testnet
+        let network = getBySelector(testnetBySelectorByFamily[chainFamily]);
+        if (!network) {
+            network = getBySelector(mainnetBySelectorByFamily[chainFamily]);
+        }
+        return network;
     }
     if (chainFamily && chainSelectorName) {
-        const familyMap = isTestnet
-            ? testnetByNameByFamily[chainFamily]
-            : mainnetByNameByFamily[chainFamily];
-        return familyMap?.get(chainSelectorName);
+        if (isTestnet === false) {
+            return mainnetByNameByFamily[chainFamily].get(chainSelectorName);
+        }
+        if (isTestnet === true) {
+            return testnetByNameByFamily[chainFamily].get(chainSelectorName);
+        }
+        // If user haven't defined if it's testnet or not we can try all networks, starting from testnet
+        let network = testnetByNameByFamily[chainFamily].get(chainSelectorName);
+        if (!network) {
+            network = mainnetByNameByFamily[chainFamily].get(chainSelectorName);
+        }
+        return network;
     }
     // If only network type is specified, use the general maps
-    if (chainSelector) {
-        const selectorMap = isTestnet ? testnetBySelector : mainnetBySelector;
-        return selectorMap.get(chainSelector);
+    if (chainSelector !== undefined) {
+        if (isTestnet === false) {
+            return getBySelector(mainnetBySelector);
+        }
+        if (isTestnet === true) {
+            return getBySelector(testnetBySelector);
+        }
+        // If user haven't defined if it's testnet or not we can try all networks, starting from testnet
+        let network = getBySelector(testnetBySelector);
+        if (!network) {
+            network = getBySelector(mainnetBySelector);
+        }
+        return network;
     }
     if (chainSelectorName) {
-        const nameMap = isTestnet ? testnetByName : mainnetByName;
-        return nameMap.get(chainSelectorName);
+        if (isTestnet === false) {
+            return mainnetByName.get(chainSelectorName);
+        }
+        if (isTestnet === true) {
+            return testnetByName.get(chainSelectorName);
+        }
+        // If user haven't defined if it's testnet or not we can try all networks, starting from testnet
+        let network = testnetByName.get(chainSelectorName);
+        if (!network) {
+            network = mainnetByName.get(chainSelectorName);
+        }
+        return network;
     }
     return undefined;
 };

package/dist/sdk/utils/chain-selectors/types.d.ts

@@ -2,7 +2,7 @@ export type ChainFamily = 'evm' | 'solana' | 'aptos' | 'sui' | 'ton' | 'tron';
 export type NetworkType = 'mainnet' | 'testnet';
 export interface ChainSelector {
     name: string;
-    selector: string;
+    selector: bigint;
 }
 export interface NetworkInfo {
     chainId: string;

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,5 @@
-export * from './error-boundary';
-export { withErrorBoundary } from './error-boundary';
+export * from './chain-selectors';
 export * from './hex-utils';
-export * from './send-response-value';
 export * from './values/consensus_aggregators';
 export * from './values/serializer_types';
 export * from './values/value';

package/dist/sdk/utils/index.js

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

package/dist/sdk/utils/safe-json-stringify.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Supports stringifying an object with bigints, treating bigints as strings.
+ * @param obj - The object to stringify
+ * @returns The stringified object
+ */
+export declare const safeJsonStringify: (obj: any) => string;

package/dist/sdk/utils/safe-json-stringify.js

@@ -0,0 +1,6 @@
+/**
+ * Supports stringifying an object with bigints, treating bigints as strings.
+ * @param obj - The object to stringify
+ * @returns The stringified object
+ */
+export const safeJsonStringify = (obj) => JSON.stringify(obj, (_, value) => (typeof value === 'bigint' ? value.toString() : value), 2);

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

@@ -17,5 +17,5 @@ export interface Trigger<TRawTriggerOutput extends Message<string>, TTriggerOutp
     /** Get the configuration as an Any type for protobuf serialization */
     configAsAny(): Any;
     /** Transform the raw trigger output to the adapted type */
-    adapt(rawOutput: TRawTriggerOutput): TTriggerOutput | Promise<TTriggerOutput>;
+    adapt(rawOutput: TRawTriggerOutput): TTriggerOutput;
 }

package/dist/sdk/utils/values/consensus_aggregators.d.ts

@@ -22,6 +22,6 @@ export declare class ConsensusFieldAggregation<T, U> {
     constructor(fieldDescriptor?: ConsensusDescriptor | undefined, t?: T | undefined, u?: U | undefined);
 }
 export type ConsensusAggregationFields<T extends object> = {
-    [K in keyof T]: () => ConsensusFieldAggregation<T[K], true>;
+    [K in keyof T as K extends '$typeName' ? never : K]: () => ConsensusFieldAggregation<T[K], true>;
 };
 export declare function ConsensusAggregationByFields<T extends object>(aggregation: ConsensusAggregationFields<T>): ConsensusAggregation<T, true>;

package/dist/sdk/utils/values/serializer_types.d.ts

@@ -1,7 +1,7 @@
 import type { Decimal, Int64, UInt64 } from './value';
 export type NumericType = number | bigint | Date | Decimal | Int64 | UInt64;
 export type PrimitiveTypes = NumericType | boolean | string;
-export type NonSerializable = null | Map<any, any> | Set<any> | RegExp | Int8Array;
+export type NonSerializable = null | Map<unknown, unknown> | Set<unknown> | RegExp | Int8Array | Promise<unknown>;
 export type CreSerializableNested<T> = T extends PrimitiveTypes ? T : T extends Function ? T : T extends NonSerializable ? never : T extends any[] ? CreSerializableNested<T[number]>[] : T extends object ? {
     [K in keyof T]: CreSerializableNested<T[K]>;
 } : never;

package/dist/sdk/{runtime → wasm}/host-bindings.d.ts

@@ -3,7 +3,6 @@ export declare const hostBindings: {
     switchModes: (args_0: Mode, ...args: unknown[]) => void;
     log: (args_0: string, ...args: unknown[]) => void;
     sendResponse: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, ...args: unknown[]) => number;
-    randomSeed: (args_0: Mode.DON | Mode.NODE, ...args: unknown[]) => number;
     versionV2: (...args: unknown[]) => void;
     callCapability: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, ...args: unknown[]) => number;
     awaitCapabilities: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, args_1: number, ...args: unknown[]) => Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>;

package/dist/sdk/{runtime → wasm}/host-bindings.js

@@ -8,10 +8,6 @@ const globalHostBindingsSchema = z.object({
         .function()
         .args(z.union([z.instanceof(Uint8Array), z.custom()]))
         .returns(z.number()),
-    randomSeed: z
-        .function()
-        .args(z.union([z.literal(Mode.DON), z.literal(Mode.NODE)]))
-        .returns(z.number()),
     versionV2: z.function().args().returns(z.void()),
     callCapability: z
         .function()

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

@@ -0,0 +1 @@
+export { Runner } from './runner';

package/dist/sdk/wasm/index.js

@@ -0,0 +1 @@
+export { Runner } from './runner';

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

@@ -0,0 +1,14 @@
+import { type ExecuteRequest, type ExecutionResult } from '../../generated/sdk/v1alpha/sdk_pb';
+import { type ConfigHandlerParams } from '../utils/config';
+import type { SecretsProvider, Workflow } from '../workflow';
+import { Runtime } from './runtime';
+export declare class Runner<TConfig> {
+    private readonly config;
+    private readonly request;
+    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<TConfig>(req: ExecuteRequest, workflow: Workflow<TConfig>, runtime: Runtime<TConfig>): Promise<ExecutionResult>;
+    handleSubscribePhase(req: ExecuteRequest, workflow: Workflow<TConfig>): ExecutionResult;
+}