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

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;
-}

package/dist/sdk/utils/random/random.js

@@ -1,123 +0,0 @@
-// Full TypeScript port of Go's math/rand
-// Complete API: Int63, Uint64, Uint32, Int31, Int, Float64, Float32, Int63n, Int31n, Intn, Perm, Seed
-// See: https://cs.opensource.google/go/go/+/refs/tags/go1.22.0:src/math/rand/rand.go
-export class Source {
-    s0 = 0n;
-    s1 = 0n;
-    constructor(seed) {
-        this.Seed(seed);
-    }
-    Seed(seed) {
-        seed = BigInt.asUintN(64, seed);
-        this.s0 = this.splitMix64(seed);
-        this.s1 = this.splitMix64(this.s0);
-    }
-    splitMix64(seed) {
-        seed = (seed + 0x9e3779b97f4a7c15n) & 0xffffffffffffffffn;
-        let z = seed;
-        z = ((z ^ (z >> 30n)) * 0xbf58476d1ce4e5b9n) & 0xffffffffffffffffn;
-        z = ((z ^ (z >> 27n)) * 0x94d049bb133111ebn) & 0xffffffffffffffffn;
-        return z ^ (z >> 31n);
-    }
-    next() {
-        const s1 = this.s0;
-        let s0 = this.s1;
-        this.s0 = s0;
-        s0 ^= s0 << 23n;
-        this.s1 = s0 ^ s1 ^ (s0 >> 17n) ^ (s1 >> 26n);
-        return BigInt.asUintN(64, this.s1 + s1);
-    }
-    Int63() {
-        return this.next() & 0x7fffffffffffffffn;
-    }
-    Uint32() {
-        return Number(this.next() >> 32n) >>> 0;
-    }
-    Uint64() {
-        return this.next();
-    }
-    Int31() {
-        return Number(this.Int63() >> 32n);
-    }
-    Float64() {
-        // Use top 53 bits like Go's implementation: Int63() >> 11
-        return Number(this.Int63() >> 11n) * (1.0 / 9007199254740992.0); // 1.0 / (1 << 53)
-    }
-    Int63n(n) {
-        if (n <= 0n)
-            throw new Error('invalid argument to Int63n');
-        const max = (1n << 63n) - ((1n << 63n) % n);
-        let v;
-        do {
-            v = this.Int63();
-        } while (v >= max);
-        return v % n;
-    }
-    Int31n(n) {
-        if (n <= 0)
-            throw new Error('invalid argument to Int31n');
-        return Number(this.Int63n(BigInt(n)));
-    }
-    Intn(n) {
-        return this.Int31n(n);
-    }
-    Int() {
-        return Number(this.Int63() >> 32n);
-    }
-    Float32() {
-        // Use top 24 bits for float32 precision
-        return Number(this.Int63() >> 40n) * (1.0 / 8388608.0); // 1.0 / (1 << 23)
-    }
-    Perm(n) {
-        const m = new Array(n);
-        for (let i = 0; i < n; i++)
-            m[i] = i;
-        for (let i = 1; i < n; i++) {
-            const j = Number(this.Int63n(BigInt(i + 1)));
-            [m[i], m[j]] = [m[j], m[i]];
-        }
-        return m;
-    }
-}
-export class Rand {
-    src;
-    constructor(seed) {
-        this.src = new Source(seed);
-    }
-    Float64() {
-        return this.src.Float64();
-    }
-    Float32() {
-        return this.src.Float32();
-    }
-    Int63() {
-        return this.src.Int63();
-    }
-    Int63n(n) {
-        return this.src.Int63n(n);
-    }
-    Int31() {
-        return this.src.Int31();
-    }
-    Int31n(n) {
-        return this.src.Int31n(n);
-    }
-    Int() {
-        return this.src.Int();
-    }
-    Intn(n) {
-        return this.src.Intn(n);
-    }
-    Uint32() {
-        return this.src.Uint32();
-    }
-    Uint64() {
-        return this.src.Uint64();
-    }
-    Perm(n) {
-        return this.src.Perm(n);
-    }
-    Seed(seed) {
-        this.src.Seed(seed);
-    }
-}

package/dist/sdk/utils/secrets/await-async-secret.d.ts

@@ -1 +0,0 @@
-export declare const awaitAsyncSecret: (callbackId: number) => Promise<string>;

package/dist/sdk/utils/secrets/await-async-secret.js

@@ -1,29 +0,0 @@
-import { create, fromBinary, toBinary } from '@bufbuild/protobuf';
-import { AwaitSecretsRequestSchema, AwaitSecretsResponseSchema, } from '../../../generated/sdk/v1alpha/sdk_pb';
-import { SecretsError } from '../secrets-error';
-export const awaitAsyncSecret = async (callbackId) => {
-    // Create proper AwaitSecretsRequest protobuf message
-    const awaitSecretRequest = create(AwaitSecretsRequestSchema, {
-        ids: [callbackId],
-    });
-    // Encode to protobuf bytes
-    const awaitSecretRequestBytes = toBinary(AwaitSecretsRequestSchema, awaitSecretRequest);
-    const response = awaitSecrets(awaitSecretRequestBytes, 1024 * 1024);
-    // Convert array of numbers to Uint8Array if needed
-    const responseBytes = Array.isArray(response) ? new Uint8Array(response) : response;
-    // Decode as AwaitSecretsResponse first
-    const awaitResponse = fromBinary(AwaitSecretsResponseSchema, responseBytes);
-    // Get the specific secretId response for our callback ID
-    const secretResponses = awaitResponse.responses[callbackId];
-    if (!secretResponses || !secretResponses.responses.length) {
-        throw new Error(`No response found for callback ID ${callbackId}`);
-    }
-    const secretResponse = secretResponses.responses[0];
-    if (secretResponse.response.case === 'secret') {
-        return secretResponse.response.value.value;
-    }
-    if (secretResponse.response.case === 'error') {
-        throw new SecretsError(secretResponse.response.value.error);
-    }
-    throw new Error(`No secret found for callback ID ${callbackId}`);
-};

package/dist/sdk/utils/secrets/do-get-secret.d.ts

@@ -1 +0,0 @@
-export declare const doGetSecret: (id: string) => number;

package/dist/sdk/utils/secrets/do-get-secret.js

@@ -1,14 +0,0 @@
-import { create, toBinary } from '@bufbuild/protobuf';
-import { GetSecretsRequestSchema, Mode } from '../../../generated/sdk/v1alpha/sdk_pb';
-import { hostBindings } from '../../runtime/host-bindings';
-import { getLastCallbackId, incrementCallbackId } from '../capabilities/callback-id';
-export const doGetSecret = (id) => {
-    const callbackId = getLastCallbackId(Mode.DON);
-    incrementCallbackId(Mode.DON);
-    const request = create(GetSecretsRequestSchema, {
-        requests: [{ id }],
-        callbackId,
-    });
-    const result = hostBindings.getSecrets(toBinary(GetSecretsRequestSchema, request), 1024 * 1024);
-    return callbackId;
-};