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

package/dist/sdk/testhelpers/dangerously-call-capability.d.ts

@@ -1,10 +0,0 @@
-import { type CapabilityResponse } from '../../generated/sdk/v1alpha/sdk_pb';
-import type { CallCapabilityParams } from '../utils/capabilities/call-capability';
-/**
- * Dangerous call capability.
- * This function does not perform any runtime guard checks.
- * Use this function only in test code.
- *
- * @see callCapability implementation for actual proper usage.
- * */
-export declare function dangerouslyCallCapability({ capabilityId, method, mode, payload, }: CallCapabilityParams): Promise<CapabilityResponse>;

package/dist/sdk/testhelpers/dangerously-call-capability.js

@@ -1,26 +0,0 @@
-import { Mode } from '../../generated/sdk/v1alpha/sdk_pb';
-import { awaitAsyncRequest } from '../utils/await-async-request';
-import { doRequestAsync } from '../utils/do-request-async';
-import { LazyPromise } from '../utils/lazy-promise';
-/**
- * Dangerous call capability.
- * This function does not perform any runtime guard checks.
- * Use this function only in test code.
- *
- * @see callCapability implementation for actual proper usage.
- * */
-export function dangerouslyCallCapability({ capabilityId, method, mode = Mode.DON, payload, }) {
-    const callbackId = doRequestAsync({
-        capabilityId,
-        method,
-        mode,
-        payload,
-    });
-    return new LazyPromise(async () => {
-        return awaitAsyncRequest(callbackId, {
-            capabilityId,
-            method,
-            mode,
-        });
-    });
-}

package/dist/sdk/testhelpers/mock-host-bindings.d.ts

@@ -1,15 +0,0 @@
-import { Mode } from '../../generated/sdk/v1alpha/sdk_pb';
-export declare const calls: string[];
-export declare const mockHostBindings: {
-    sendResponse: import("bun:test").Mock<(_response: Uint8Array) => number>;
-    switchModes: import("bun:test").Mock<(mode: Mode) => void>;
-    log: import("bun:test").Mock<(_message: string) => void>;
-    callCapability: import("bun:test").Mock<(_request: string) => number>;
-    awaitCapabilities: import("bun:test").Mock<(_awaitRequest: string, _maxResponseLen: number) => string>;
-    getSecrets: import("bun:test").Mock<(_request: string, _maxResponseLen: number) => number>;
-    awaitSecrets: import("bun:test").Mock<(_awaitRequest: string, _maxResponseLen: number) => string>;
-    versionV2: import("bun:test").Mock<() => void>;
-    randomSeed: import("bun:test").Mock<(_mode: Mode.DON | Mode.NODE) => number>;
-    getWasiArgs: import("bun:test").Mock<() => string>;
-    now: import("bun:test").Mock<() => number>;
-};

package/dist/sdk/testhelpers/mock-host-bindings.js

@@ -1,25 +0,0 @@
-import { mock } from 'bun:test';
-import { Mode } from '../../generated/sdk/v1alpha/sdk_pb';
-// Mock hostBindings before importing runInNodeMode
-export const calls = [];
-export const mockHostBindings = {
-    sendResponse: mock((_response) => 0),
-    switchModes: mock((mode) => {
-        calls.push(mode === Mode.NODE ? 'NODE' : mode === Mode.DON ? 'DON' : 'UNSPECIFIED');
-    }),
-    log: mock((_message) => { }),
-    callCapability: mock((_request) => 1),
-    awaitCapabilities: mock((_awaitRequest, _maxResponseLen) => btoa('mock_await_capabilities_response')),
-    getSecrets: mock((_request, _maxResponseLen) => 1),
-    awaitSecrets: mock((_awaitRequest, _maxResponseLen) => btoa('mock_await_secrets_response')),
-    versionV2: mock(() => { }),
-    randomSeed: mock((_mode) => Math.random()),
-    getWasiArgs: mock(() => '["mock.wasm", ""]'),
-    now: mock(() => Date.now()),
-};
-// Set up global mocks before any modules are imported
-Object.assign(globalThis, mockHostBindings);
-// Mock the module
-mock.module('../runtime/host-bindings', () => ({
-    hostBindings: mockHostBindings,
-}));

package/dist/sdk/testhelpers/mock-runtime.d.ts

@@ -1,2 +0,0 @@
-import type { Runtime } from '../runtime/runtime';
-export declare const mockedRuntime: Runtime;

package/dist/sdk/testhelpers/mock-runtime.js

@@ -1,16 +0,0 @@
-import { Mode } from '../../generated/sdk/v1alpha/sdk_pb';
-import { logger } from '../logger';
-import { getRand } from '../utils/random/get-rand';
-import { getSecret } from '../utils/secrets/get-secret';
-import { getTimeAsDate } from '../utils/time/get-time';
-export const mockedRuntime = {
-    mode: Mode.DON,
-    logger,
-    isNodeRuntime: false,
-    assertDonSafe: () => { },
-    assertNodeSafe: () => { },
-    switchModes: (() => mockedRuntime),
-    getSecret,
-    getRand: () => getRand(Mode.DON),
-    now: () => getTimeAsDate(),
-};

package/dist/sdk/utils/await-async-request.d.ts

@@ -1,9 +0,0 @@
-import type { Mode } from '../../generated/sdk/v1alpha/sdk_pb';
-import { type CapabilityResponse } from '../../generated/sdk/v1alpha/sdk_pb';
-type Params = {
-    capabilityId: string;
-    method: string;
-    mode: Mode;
-};
-export declare function awaitAsyncRequest(callbackId: number, { capabilityId, method, mode }: Params): Promise<CapabilityResponse>;
-export {};

package/dist/sdk/utils/await-async-request.js

@@ -1,27 +0,0 @@
-import { create, fromBinary, toBinary } from '@bufbuild/protobuf';
-import { AwaitCapabilitiesRequestSchema, AwaitCapabilitiesResponseSchema, } from '../../generated/sdk/v1alpha/sdk_pb';
-import { hostBindings } from '../runtime/host-bindings';
-import { CapabilityError } from './capabilities/capability-error';
-// Implementation signature (general fallback)
-export async function awaitAsyncRequest(callbackId, { capabilityId, method, mode }) {
-    // Create proper AwaitCapabilitiesRequest protobuf message
-    const awaitRequest = create(AwaitCapabilitiesRequestSchema, {
-        ids: [callbackId],
-    });
-    // Encode to protobuf bytes
-    const awaitRequestBytes = toBinary(AwaitCapabilitiesRequestSchema, awaitRequest);
-    const response = hostBindings.awaitCapabilities(awaitRequestBytes, 1024 * 1024);
-    // Convert array of numbers to Uint8Array if needed
-    const responseBytes = Array.isArray(response) ? new Uint8Array(response) : response;
-    const awaitResponse = fromBinary(AwaitCapabilitiesResponseSchema, responseBytes);
-    const capabilityResponse = awaitResponse.responses[callbackId];
-    if (!capabilityResponse) {
-        throw new CapabilityError(`No response found for callback ID ${callbackId}`, {
-            capabilityId,
-            method,
-            mode,
-            callbackId,
-        });
-    }
-    return capabilityResponse;
-}

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

@@ -1,22 +0,0 @@
-import { type CapabilityResponse, Mode } from '../../../generated/sdk/v1alpha/sdk_pb';
-export type CallCapabilityParams = {
-    capabilityId: string;
-    method: string;
-    mode: Mode;
-    payload: {
-        typeUrl: string;
-        value: Uint8Array;
-    };
-};
-type CallCapabilityReturn = {
-    result: () => Promise<CapabilityResponse>;
-};
-/**
- * Calls a capability asynchronously and returns a promise for the response.
- * The actual call is deferred until the promise is awaited (lazy execution).
- *
- * @param params - The capability call parameters
- * @returns A promise that resolves to the capability response
- */
-export declare function callCapability({ capabilityId, method, mode, payload, }: CallCapabilityParams): CallCapabilityReturn;
-export {};

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

@@ -1,33 +0,0 @@
-import { Mode } from '../../../generated/sdk/v1alpha/sdk_pb';
-import { runtimeGuards } from '../../runtime/runtime';
-import { awaitAsyncRequest } from '../await-async-request';
-import { doRequestAsync } from '../do-request-async';
-/**
- * Calls a capability asynchronously and returns a promise for the response.
- * The actual call is deferred until the promise is awaited (lazy execution).
- *
- * @param params - The capability call parameters
- * @returns A promise that resolves to the capability response
- */
-export function callCapability({ capabilityId, method, mode = Mode.DON, payload, }) {
-    // Guards:
-    // - Block DON-mode calls while currently in NODE mode
-    // - Block NODE-mode calls while currently in DON mode
-    if (mode === Mode.DON)
-        runtimeGuards.assertDonSafe();
-    if (mode === Mode.NODE)
-        runtimeGuards.assertNodeSafe();
-    const callbackId = doRequestAsync({
-        capabilityId,
-        method,
-        mode,
-        payload,
-    });
-    return {
-        result: async () => awaitAsyncRequest(callbackId, {
-            capabilityId,
-            method,
-            mode,
-        }),
-    };
-}

package/dist/sdk/utils/capabilities/callback-id.d.ts

@@ -1,3 +0,0 @@
-import { Mode } from '../../../generated/sdk/v1alpha/sdk_pb';
-export declare const getLastCallbackId: (mode: Mode) => number;
-export declare const incrementCallbackId: (mode: Mode) => number;

package/dist/sdk/utils/capabilities/callback-id.js

@@ -1,22 +0,0 @@
-import { Mode } from '../../../generated/sdk/v1alpha/sdk_pb';
-// Tracks async requests using DON mode, increments to the positive side, 0, 1, 2, 3 ...
-let donCall = 0;
-// Tracks async requests using Node mode, increments to the negative side, -1, -2, -3, -4 ...
-let nodeCall = -1;
-export const getLastCallbackId = (mode) => {
-    if (mode !== Mode.DON && mode !== Mode.NODE) {
-        throw new Error(`Unsupported capability mode: ${mode}`);
-    }
-    return mode === Mode.DON ? donCall : nodeCall;
-};
-export const incrementCallbackId = (mode) => {
-    if (mode !== Mode.DON && mode !== Mode.NODE) {
-        throw new Error(`Unsupported capability mode: ${mode}`);
-    }
-    if (mode === Mode.DON) {
-        donCall++;
-        return donCall;
-    }
-    nodeCall--;
-    return nodeCall;
-};

package/dist/sdk/utils/capabilities/http/fetch.d.ts

@@ -1,44 +0,0 @@
-export type CreFetchRequest = {
-    url: string;
-    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'TRACE' | 'CONNECT';
-    headers?: Record<string, string>;
-    body?: string;
-    timeoutMs?: number;
-    cacheSettings?: {
-        readFromCache?: boolean;
-        maxAgeMs?: number;
-    };
-};
-/**
- * Enhanced HTTP fetch utility with validation and sensible defaults.
- *
- * Validates input parameters using Zod schema and sets default values:
- * - Default HTTP method is "GET"
- * - URL is required and must be valid
- * - HTTP method must be one of the standard methods
- *
- * @param input - Request configuration object
- * @returns Promise resolving to the HTTP response
- * @throws ZodError if input validation fails
- *
- * @example
- * ```typescript
- * // Simple GET request (method defaults to "GET")
- * const response = await creFetch({ url: "https://api.example.com/data" });
- *
- * // POST request with body and headers
- * const response = await creFetch({
- *   url: "https://api.example.com/submit",
- *   method: "POST",
- *   headers: { "Content-Type": "application/json" },
- *   body: JSON.stringify({ key: "value" })
- * });
- * ```
- */
-export declare const creFetch: (input: CreFetchRequest) => Promise<{
-    statusCode: number;
-    headers: {
-        [key: string]: string;
-    };
-    body: string;
-}>;

package/dist/sdk/utils/capabilities/http/fetch.js

@@ -1,63 +0,0 @@
-import { cre } from '../../../cre';
-import { z } from 'zod';
-const httpMethodSchema = z.enum([
-    'GET',
-    'POST',
-    'PUT',
-    'DELETE',
-    'PATCH',
-    'HEAD',
-    'OPTIONS',
-    'TRACE',
-    'CONNECT',
-]);
-const cacheSettingsSchema = z
-    .object({
-    readFromCache: z.boolean().optional(),
-    maxAgeMs: z.number().int().optional(),
-})
-    .optional();
-const creFetchRequestSchema = z.object({
-    url: z.string().startsWith('http'),
-    method: httpMethodSchema.optional().default('GET'),
-    headers: z.record(z.string()).optional(),
-    body: z.string().optional(),
-    timeoutMs: z.number().int().positive().optional(),
-    cacheSettings: cacheSettingsSchema,
-});
-/**
- * Enhanced HTTP fetch utility with validation and sensible defaults.
- *
- * Validates input parameters using Zod schema and sets default values:
- * - Default HTTP method is "GET"
- * - URL is required and must be valid
- * - HTTP method must be one of the standard methods
- *
- * @param input - Request configuration object
- * @returns Promise resolving to the HTTP response
- * @throws ZodError if input validation fails
- *
- * @example
- * ```typescript
- * // Simple GET request (method defaults to "GET")
- * const response = await creFetch({ url: "https://api.example.com/data" });
- *
- * // POST request with body and headers
- * const response = await creFetch({
- *   url: "https://api.example.com/submit",
- *   method: "POST",
- *   headers: { "Content-Type": "application/json" },
- *   body: JSON.stringify({ key: "value" })
- * });
- * ```
- */
-export const creFetch = async (input) => {
-    const validatedInput = creFetchRequestSchema.parse(input);
-    const httpClient = new cre.capabilities.HTTPClient();
-    const resp = await httpClient.sendRequest(validatedInput).result();
-    return {
-        statusCode: resp.statusCode,
-        headers: resp.headers,
-        body: new TextDecoder().decode(resp.body),
-    };
-};

package/dist/sdk/utils/do-request-async.d.ts

@@ -1,12 +0,0 @@
-import { type Mode } from '../../generated/sdk/v1alpha/sdk_pb';
-type Params = {
-    capabilityId: string;
-    method: string;
-    mode: Mode;
-    payload: {
-        typeUrl: string;
-        value: Uint8Array;
-    };
-};
-export declare const doRequestAsync: ({ capabilityId, method, mode, payload }: Params) => number;
-export {};

package/dist/sdk/utils/do-request-async.js

@@ -1,17 +0,0 @@
-import { create, toBinary } from '@bufbuild/protobuf';
-import { CapabilityRequestSchema, } from '../../generated/sdk/v1alpha/sdk_pb';
-import { hostBindings } from '../runtime/host-bindings';
-import { getLastCallbackId, incrementCallbackId } from './capabilities/callback-id';
-export const doRequestAsync = ({ capabilityId, method, mode, payload }) => {
-    const callbackId = getLastCallbackId(mode);
-    incrementCallbackId(mode);
-    const req = create(CapabilityRequestSchema, {
-        id: capabilityId,
-        method,
-        payload,
-        callbackId,
-    });
-    const reqBytes = toBinary(CapabilityRequestSchema, req);
-    hostBindings.callCapability(reqBytes);
-    return callbackId;
-};

package/dist/sdk/utils/error-boundary.d.ts

@@ -1,2 +0,0 @@
-export declare const errorBoundary: (e: any) => void;
-export declare const withErrorBoundary: (fn: () => Promise<void>) => Promise<void>;

package/dist/sdk/utils/error-boundary.js

@@ -1,30 +0,0 @@
-import { DonModeError, NodeModeError } from '../runtime/errors';
-export const errorBoundary = (e) => {
-    // TODO: links should be configurable
-    if (e instanceof DonModeError || e instanceof NodeModeError) {
-        console.log(`
-
-
-[${e.constructor.name}]: ${e.message}.
-
-Learn more about mode switching here: https://documentation-preview-git-cre-priv-577744-chainlink-labs-devrel.vercel.app/cre/getting-started/part-2-fetching-data#step-2-understand-the-runinnodemode-pattern
-
-
-`);
-    }
-    else if (e instanceof Error) {
-        console.log(e.message);
-        console.log(e.stack);
-    }
-    else {
-        console.log(e);
-    }
-};
-export const withErrorBoundary = async (fn) => {
-    try {
-        await fn();
-    }
-    catch (e) {
-        errorBoundary(e);
-    }
-};

package/dist/sdk/utils/get-request.d.ts

@@ -1 +0,0 @@
-export declare const getRequest: () => import("../../generated/sdk/v1alpha/sdk_pb").ExecuteRequest;

package/dist/sdk/utils/get-request.js

@@ -1,15 +0,0 @@
-import { fromBinary } from '@bufbuild/protobuf';
-import { ExecuteRequestSchema } from '../../generated/sdk/v1alpha/sdk_pb';
-export const getRequest = () => {
-    const argsString = getWasiArgs();
-    const args = JSON.parse(argsString);
-    // SDK expects exactly 2 args:
-    // 1st is the script name
-    // 2nd is the base64 encoded request
-    if (args.length !== 2) {
-        throw new Error('Invalid request: must contain payload');
-    }
-    const base64Request = args[1];
-    const bytes = Buffer.from(base64Request, 'base64');
-    return fromBinary(ExecuteRequestSchema, bytes);
-};

package/dist/sdk/utils/lazy-promise.d.ts

@@ -1,59 +0,0 @@
-/**
- * LazyPromise is a utility class that implements the Promise interface
- * but defers execution of the actual work until the promise is first accessed.
- *
- * This is useful when you want to return a promise immediately without
- * starting the async work, but ensure the work begins as soon as someone
- * tries to await, .then(), .catch(), or .finally() the promise.
- *
- * Example usage:
- * ```typescript
- * const lazyPromise = new LazyPromise(() => {
- *   // This expensive operation won't start until the promise is accessed
- *   return fetch('/api/data');
- * });
- *
- * // Promise is returned immediately, no work done yet
- * // Work starts when you await it:
- * const result = await lazyPromise;
- * ```
- *
- * This abstraction has been created for calling capabilities in a non-blocking way.
- */
-export declare class LazyPromise<T> implements Promise<T> {
-    private readonly factory;
-    /** Tracks whether the factory function has been executed */
-    private started;
-    /** The actual promise that gets created when work starts */
-    private promise;
-    /**
-     * Creates a new LazyPromise
-     * @param factory - Function that returns the value or promise to resolve with
-     */
-    constructor(factory: () => T | Promise<T>);
-    /**
-     * Ensures the factory function has been executed and the promise is created.
-     * This is called by all promise methods (.then, .catch, .finally) to start the work.
-     */
-    private ensureStarted;
-    /**
-     * Attaches callbacks for the resolution and/or rejection of the Promise.
-     * This triggers the lazy execution if it hasn't started yet.
-     */
-    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
-    /**
-     * Attaches a callback for only the rejection of the Promise.
-     * This triggers the lazy execution if it hasn't started yet.
-     */
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
-    /**
-     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected).
-     * This triggers the lazy execution if it hasn't started yet.
-     */
-    finally(onfinally?: (() => void) | null): Promise<T>;
-    /**
-     * Required to make this behave like a native Promise.
-     * This allows instanceof checks and proper string representation.
-     */
-    [Symbol.toStringTag]: string;
-}

package/dist/sdk/utils/lazy-promise.js

@@ -1,81 +0,0 @@
-/**
- * LazyPromise is a utility class that implements the Promise interface
- * but defers execution of the actual work until the promise is first accessed.
- *
- * This is useful when you want to return a promise immediately without
- * starting the async work, but ensure the work begins as soon as someone
- * tries to await, .then(), .catch(), or .finally() the promise.
- *
- * Example usage:
- * ```typescript
- * const lazyPromise = new LazyPromise(() => {
- *   // This expensive operation won't start until the promise is accessed
- *   return fetch('/api/data');
- * });
- *
- * // Promise is returned immediately, no work done yet
- * // Work starts when you await it:
- * const result = await lazyPromise;
- * ```
- *
- * This abstraction has been created for calling capabilities in a non-blocking way.
- */
-export class LazyPromise {
-    factory;
-    /** Tracks whether the factory function has been executed */
-    started = false;
-    /** The actual promise that gets created when work starts */
-    promise;
-    /**
-     * Creates a new LazyPromise
-     * @param factory - Function that returns the value or promise to resolve with
-     */
-    constructor(factory) {
-        this.factory = factory;
-    }
-    /**
-     * Ensures the factory function has been executed and the promise is created.
-     * This is called by all promise methods (.then, .catch, .finally) to start the work.
-     */
-    ensureStarted() {
-        if (!this.started) {
-            this.started = true;
-            try {
-                const result = this.factory();
-                this.promise = Promise.resolve(result);
-            }
-            catch (err) {
-                this.promise = Promise.reject(err);
-            }
-        }
-    }
-    /**
-     * Attaches callbacks for the resolution and/or rejection of the Promise.
-     * This triggers the lazy execution if it hasn't started yet.
-     */
-    then(onfulfilled, onrejected) {
-        this.ensureStarted();
-        return this.promise.then(onfulfilled, onrejected);
-    }
-    /**
-     * Attaches a callback for only the rejection of the Promise.
-     * This triggers the lazy execution if it hasn't started yet.
-     */
-    catch(onrejected) {
-        this.ensureStarted();
-        return this.promise.catch(onrejected);
-    }
-    /**
-     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected).
-     * This triggers the lazy execution if it hasn't started yet.
-     */
-    finally(onfinally) {
-        this.ensureStarted();
-        return this.promise.finally(onfinally);
-    }
-    /**
-     * Required to make this behave like a native Promise.
-     * This allows instanceof checks and proper string representation.
-     */
-    [Symbol.toStringTag] = 'Promise';
-}

package/dist/sdk/utils/random/get-rand.d.ts

@@ -1,3 +0,0 @@
-import type { Mode } from '../../../generated/sdk/v1alpha/sdk_pb';
-import { Rand } from './random';
-export declare const getRand: (mode: Mode.DON | Mode.NODE) => Rand;

package/dist/sdk/utils/random/get-rand.js

@@ -1,6 +0,0 @@
-import { hostBindings } from '../../runtime/host-bindings';
-import { Rand } from './random';
-export const getRand = (mode) => {
-    const seed = BigInt(hostBindings.randomSeed(mode));
-    return new Rand(seed);
-};

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

@@ -1,35 +0,0 @@
-export declare class Source {
-    private s0;
-    private s1;
-    constructor(seed: bigint);
-    Seed(seed: bigint): void;
-    private splitMix64;
-    private next;
-    Int63(): bigint;
-    Uint32(): number;
-    Uint64(): bigint;
-    Int31(): number;
-    Float64(): number;
-    Int63n(n: bigint): bigint;
-    Int31n(n: number): number;
-    Intn(n: number): number;
-    Int(): number;
-    Float32(): number;
-    Perm(n: number): number[];
-}
-export declare class Rand {
-    private src;
-    constructor(seed: bigint);
-    Float64(): number;
-    Float32(): number;
-    Int63(): bigint;
-    Int63n(n: bigint): bigint;
-    Int31(): number;
-    Int31n(n: number): number;
-    Int(): number;
-    Intn(n: number): number;
-    Uint32(): number;
-    Uint64(): bigint;
-    Perm(n: number): number[];
-    Seed(seed: bigint): void;
-}