@chainlink/cre-sdk 0.0.0 → 0.0.1-alpha

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

@@ -0,0 +1,36 @@
+import { Mode } from '../../generated/sdk/v1alpha/sdk_pb';
+import { type Logger } from '../logger';
+import type { Rand } from '../utils/random/random';
+/**
+ * Runtime guards are not actually causing / throwing errors.
+ * They pre-set the errors, depending on the current mode and then
+ * assert methods are used to check if feature can be called in given mode.
+ * If not the prepared error will be thrown.
+ */
+export declare const runtimeGuards: {
+    setMode: (mode: Mode) => void;
+    assertDonSafe: () => void;
+    assertNodeSafe: () => void;
+    getMode: () => Mode;
+};
+export type BaseRuntime<M extends Mode = Mode> = {
+    logger: Logger;
+    mode: M;
+    assertDonSafe(): asserts this is Runtime;
+    assertNodeSafe(): asserts this is NodeRuntime;
+    getRand(): Rand;
+    now(): Date;
+};
+export type Runtime = BaseRuntime<Mode.DON> & {
+    isNodeRuntime: false;
+    switchModes(mode: Mode.NODE): NodeRuntime;
+    switchModes(mode: Mode.DON): Runtime;
+    getSecret(id: string): Promise<any>;
+};
+export type NodeRuntime = BaseRuntime<Mode.NODE> & {
+    isNodeRuntime: true;
+    switchModes(mode: Mode.NODE): NodeRuntime;
+    switchModes(mode: Mode.DON): Runtime;
+};
+export declare const runtime: Runtime;
+export declare const nodeRuntime: NodeRuntime;

package/dist/sdk/runtime/runtime.js

@@ -0,0 +1,84 @@
+import { Mode } from '../../generated/sdk/v1alpha/sdk_pb';
+import { logger } from '../logger';
+import { DonModeError, NodeModeError } from './errors';
+import { hostBindings } from './host-bindings';
+import { getRand } from '../utils/random/get-rand';
+import { getSecret } from '../utils/secrets/get-secret';
+import { getTimeAsDate } from '../utils/time/get-time';
+/**
+ * Runtime guards are not actually causing / throwing errors.
+ * They pre-set the errors, depending on the current mode and then
+ * assert methods are used to check if feature can be called in given mode.
+ * If not the prepared error will be thrown.
+ */
+export const runtimeGuards = (() => {
+    let currentMode = Mode.UNSPECIFIED;
+    let donModeGuardError = null;
+    let nodeModeGuardError = new NodeModeError();
+    const setMode = (mode) => {
+        currentMode = mode;
+        if (mode === Mode.NODE) {
+            // In node mode, forbid DON runtime calls
+            donModeGuardError = new DonModeError();
+            nodeModeGuardError = null;
+        }
+        else if (mode === Mode.DON) {
+            // Back in DON mode, forbid node runtime calls
+            nodeModeGuardError = new NodeModeError();
+            donModeGuardError = null;
+        }
+        else {
+            donModeGuardError = null;
+            nodeModeGuardError = null;
+        }
+    };
+    const assertDonSafe = () => {
+        if (donModeGuardError) {
+            throw donModeGuardError;
+        }
+    };
+    const assertNodeSafe = () => {
+        if (nodeModeGuardError) {
+            throw nodeModeGuardError;
+        }
+    };
+    const getMode = () => currentMode;
+    return { setMode, assertDonSafe, assertNodeSafe, getMode };
+})();
+function switchModes(mode) {
+    // Changing to the same mode should be a noop, we make sure to actually call switching logic if it's different mode
+    if (mode !== runtimeGuards.getMode()) {
+        hostBindings.switchModes(mode);
+        runtimeGuards.setMode(mode);
+    }
+    return mode === Mode.NODE ? nodeRuntime : runtime;
+}
+export const runtime = {
+    mode: Mode.DON,
+    isNodeRuntime: false,
+    logger,
+    switchModes,
+    assertDonSafe: () => {
+        runtimeGuards.assertDonSafe();
+    },
+    assertNodeSafe: () => {
+        runtimeGuards.assertNodeSafe();
+    },
+    getSecret,
+    getRand: () => getRand(Mode.DON),
+    now: () => getTimeAsDate(),
+};
+export const nodeRuntime = {
+    mode: Mode.NODE,
+    isNodeRuntime: true,
+    logger,
+    switchModes,
+    assertNodeSafe: () => {
+        runtimeGuards.assertNodeSafe();
+    },
+    assertDonSafe: () => {
+        runtimeGuards.assertDonSafe();
+    },
+    getRand: () => getRand(Mode.NODE),
+    now: () => getTimeAsDate(),
+};

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

@@ -0,0 +1 @@
+import '../testhelpers/mock-host-bindings';

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

@@ -0,0 +1,58 @@
+import { beforeEach, describe, expect, test } from 'bun:test';
+import { Mode } from '../../generated/sdk/v1alpha/sdk_pb';
+// Mock the host bindings before importing runtime
+import '../testhelpers/mock-host-bindings';
+import { DonModeError, NodeModeError } from './errors';
+import { runtime, runtimeGuards } from './runtime';
+describe('Handling runtime in TS SDK', () => {
+    beforeEach(() => {
+        runtimeGuards.setMode(Mode.DON);
+    });
+    test('runtime should be DON by default', () => {
+        expect(runtime.mode).toBe(Mode.DON);
+    });
+    test('switching modes should work', () => {
+        // Start from DON mode
+        expect(runtime.isNodeRuntime).toBe(false);
+        // Switch to NODE mode and verify it works
+        const nodeRt = runtime.switchModes(Mode.NODE);
+        expect(nodeRt.isNodeRuntime).toBe(true);
+        expect(nodeRt.mode).toBe(Mode.NODE);
+        // Switch back to DON mode and verify it works
+        const rt = nodeRt.switchModes(Mode.DON);
+        expect(rt.mode).toBe(Mode.DON);
+        expect(rt.isNodeRuntime).toBe(false);
+    });
+    test('switching modes should be noop when already in that mode', () => {
+        // By default we are in DON mode, but we call switchModes to confirm that's a noop
+        const rt = runtime.switchModes(Mode.DON);
+        expect(rt.mode).toBe(Mode.DON);
+        expect(rt.isNodeRuntime).toBe(false);
+        // // Now actually switch to NODE mode
+        let nodeRuntime = rt.switchModes(Mode.NODE);
+        expect(nodeRuntime.mode).toBe(Mode.NODE);
+        expect(nodeRuntime.isNodeRuntime).toBe(true);
+        // And now switch to Node mode again, make sure it's a noop and the runtime is still in NODE mode.
+        nodeRuntime = nodeRuntime.switchModes(Mode.NODE);
+        expect(nodeRuntime.mode).toBe(Mode.NODE);
+        expect(nodeRuntime.isNodeRuntime).toBe(true);
+    });
+    test('assertDonSafe should throw an error if called in NODE mode', () => {
+        // DON mode is default so asserting DON safe should not throw an error
+        runtime.assertDonSafe();
+        // Switch to NODE mode and assert DON safe should throw an error
+        const nodeRuntime = runtime.switchModes(Mode.NODE);
+        expect(() => nodeRuntime.assertDonSafe()).toThrow(DonModeError);
+        // Asserting node safe should not throw however
+        nodeRuntime.assertNodeSafe();
+        const rt = nodeRuntime.switchModes(Mode.DON);
+        expect(() => rt.assertNodeSafe()).toThrow(NodeModeError);
+    });
+    test('getSecret is only available in DON mode', () => {
+        // Casting to any because typescript itself is not letting us do this
+        const nodeRuntime = runtime.switchModes(Mode.NODE);
+        expect(nodeRuntime.getSecret).toBeUndefined();
+        const rt = nodeRuntime.switchModes(Mode.DON);
+        expect(rt.getSecret).toBeDefined();
+    });
+});

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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,25 @@
+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

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

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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,22 @@
+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/capability-error.d.ts

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,17 @@
+export class CapabilityError extends Error {
+    name;
+    capabilityId;
+    method;
+    mode;
+    callbackId;
+    constructor(message, options) {
+        super(message);
+        this.name = 'CapabilityError';
+        if (options) {
+            this.capabilityId = options.capabilityId;
+            this.method = options.method;
+            this.mode = options.mode;
+            this.callbackId = options.callbackId;
+        }
+    }
+}

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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,63 @@
+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/chain-selectors/getAllNetworks.d.ts

@@ -0,0 +1,2 @@
+import type { NetworkInfo } from './types';
+export declare const getAllNetworks: () => NetworkInfo[];

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

@@ -0,0 +1,2 @@
+import { allNetworks } from '../../../generated/networks';
+export const getAllNetworks = () => allNetworks;

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

@@ -0,0 +1,14 @@
+import type { ChainFamily, NetworkInfo } from './types';
+interface GetNetworkOptions {
+    chainSelector?: string;
+    chainSelectorName?: string;
+    isTestnet?: boolean;
+    chainFamily?: ChainFamily;
+}
+/**
+ * High-performance network lookup using Maps for O(1) performance
+ * @param options - Search criteria
+ * @returns NetworkInfo if found, undefined otherwise
+ */
+export declare const getNetwork: (options: GetNetworkOptions) => NetworkInfo | undefined;
+export {};

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

@@ -0,0 +1,36 @@
+import { mainnetByName, mainnetByNameByFamily, mainnetBySelector, mainnetBySelectorByFamily, testnetByName, testnetByNameByFamily, testnetBySelector, testnetBySelectorByFamily, } from '../../../generated/networks';
+/**
+ * High-performance network lookup using Maps for O(1) performance
+ * @param options - Search criteria
+ * @returns NetworkInfo if found, undefined otherwise
+ */
+export const getNetwork = (options) => {
+    const { chainSelector, chainSelectorName, isTestnet = false, chainFamily } = options;
+    // 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 && chainSelectorName) {
+        const familyMap = isTestnet
+            ? testnetByNameByFamily[chainFamily]
+            : mainnetByNameByFamily[chainFamily];
+        return familyMap?.get(chainSelectorName);
+    }
+    // If only network type is specified, use the general maps
+    if (chainSelector) {
+        const selectorMap = isTestnet ? testnetBySelector : mainnetBySelector;
+        return selectorMap.get(chainSelector);
+    }
+    if (chainSelectorName) {
+        const nameMap = isTestnet ? testnetByName : mainnetByName;
+        return nameMap.get(chainSelectorName);
+    }
+    return undefined;
+};

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

@@ -0,0 +1,3 @@
+export * from './getAllNetworks';
+export * from './getNetwork';
+export * from './types';

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

@@ -0,0 +1,3 @@
+export * from './getAllNetworks';
+export * from './getNetwork';
+export * from './types';

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

@@ -0,0 +1,12 @@
+export type ChainFamily = 'evm' | 'solana' | 'aptos' | 'sui' | 'ton' | 'tron';
+export type NetworkType = 'mainnet' | 'testnet';
+export interface ChainSelector {
+    name: string;
+    selector: string;
+}
+export interface NetworkInfo {
+    chainId: string;
+    chainSelector: ChainSelector;
+    chainFamily: ChainFamily;
+    networkType: NetworkType;
+}

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

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

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

@@ -0,0 +1,9 @@
+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 declare const configHandler: <TConfig>({ configParser, configSchema, }?: ConfigHandlerParams) => Promise<TConfig>;