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

package/dist/generated-sdk/capabilities/networking/http/v1alpha/http_sdk_gen.js

@@ -1,7 +1,8 @@
 import { create, fromJson } from '@bufbuild/protobuf';
 import { AnySchema, anyPack } from '@bufbuild/protobuf/wkt';
 import { ConfigSchema, PayloadSchema, } from '../../../../../generated/capabilities/networking/http/v1alpha/trigger_pb';
-import {} from '../../../../../sdk/runtime';
+import {} from '../../../../../sdk';
+import { Report } from '../../../../../sdk/report';
 import {} from '../../../../../sdk/utils/triggers/trigger-interface';
 /**
  * HTTP Capability
@@ -15,7 +16,6 @@ export class HTTPCapability {
     static CAPABILITY_ID = 'http-trigger@1.0.0-alpha';
     static CAPABILITY_NAME = 'http-trigger';
     static CAPABILITY_VERSION = '1.0.0-alpha';
-    constructor() { }
     trigger(config) {
         const capabilityId = HTTPCapability.CAPABILITY_ID;
         return new HTTPTrigger(config, capabilityId, 'Trigger');

package/dist/generated-sdk/capabilities/scheduler/cron/v1/cron_sdk_gen.d.ts

@@ -13,7 +13,6 @@ export declare class CronCapability {
     static readonly CAPABILITY_ID = "cron-trigger@1.0.0";
     static readonly CAPABILITY_NAME = "cron-trigger";
     static readonly CAPABILITY_VERSION = "1.0.0";
-    constructor();
     trigger(config: ConfigJson): CronTrigger;
 }
 /**

package/dist/generated-sdk/capabilities/scheduler/cron/v1/cron_sdk_gen.js

@@ -1,7 +1,8 @@
 import { create, fromJson } from '@bufbuild/protobuf';
 import { AnySchema, anyPack } from '@bufbuild/protobuf/wkt';
 import { ConfigSchema, LegacyPayloadSchema, PayloadSchema, } from '../../../../../generated/capabilities/scheduler/cron/v1/trigger_pb';
-import {} from '../../../../../sdk/runtime';
+import {} from '../../../../../sdk';
+import { Report } from '../../../../../sdk/report';
 import {} from '../../../../../sdk/utils/triggers/trigger-interface';
 /**
  * Cron Capability
@@ -15,7 +16,6 @@ export class CronCapability {
     static CAPABILITY_ID = 'cron-trigger@1.0.0';
     static CAPABILITY_NAME = 'cron-trigger';
     static CAPABILITY_VERSION = '1.0.0';
-    constructor() { }
     trigger(config) {
         const capabilityId = CronCapability.CAPABILITY_ID;
         return new CronTrigger(config, capabilityId, 'Trigger');

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from './sdk';
 export * from './sdk/runtime';
 export * from './sdk/utils';
+export * from './sdk/utils/capabilities/http/http-helpers';
 export * from './sdk/wasm';

package/dist/index.js

@@ -2,4 +2,6 @@
 export * from './sdk';
 export * from './sdk/runtime';
 export * from './sdk/utils';
+// Export HTTP response helpers
+export * from './sdk/utils/capabilities/http/http-helpers';
 export * from './sdk/wasm';

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

@@ -2,13 +2,14 @@
  * Public API for the CRE SDK.
  */
 import { ClientCapability as EVMClient } from '../../generated-sdk/capabilities/blockchain/evm/v1alpha/client_sdk_gen';
-import { ClientCapability as HTTPClient } from '../../generated-sdk/capabilities/networking/http/v1alpha/client_sdk_gen';
+import { ClientCapability as HTTPClient, type SendRequester as HTTPSendRequester } from '../../generated-sdk/capabilities/networking/http/v1alpha/client_sdk_gen';
 import { HTTPCapability } from '../../generated-sdk/capabilities/networking/http/v1alpha/http_sdk_gen';
 import { CronCapability } from '../../generated-sdk/capabilities/scheduler/cron/v1/cron_sdk_gen';
 export type { Log as EVMLog } from '../../generated/capabilities/blockchain/evm/v1alpha/client_pb';
 export type { Payload as HTTPPayload } from '../../generated/capabilities/networking/http/v1alpha/trigger_pb';
 export type { Payload as CronPayload } from '../../generated/capabilities/scheduler/cron/v1/trigger_pb';
 export type { NodeRuntime, Runtime } from '../runtime';
+export type { HTTPSendRequester };
 export declare const cre: {
     capabilities: {
         CronCapability: typeof CronCapability;

package/dist/sdk/cre/index.js

@@ -2,7 +2,7 @@
  * Public API for the CRE SDK.
  */
 import { ClientCapability as EVMClient } from '../../generated-sdk/capabilities/blockchain/evm/v1alpha/client_sdk_gen';
-import { ClientCapability as HTTPClient } from '../../generated-sdk/capabilities/networking/http/v1alpha/client_sdk_gen';
+import { ClientCapability as HTTPClient, } from '../../generated-sdk/capabilities/networking/http/v1alpha/client_sdk_gen';
 import { HTTPCapability } from '../../generated-sdk/capabilities/networking/http/v1alpha/http_sdk_gen';
 import { CronCapability } from '../../generated-sdk/capabilities/scheduler/cron/v1/cron_sdk_gen';
 import { prepareRuntime } from '../utils/prepare-runtime';

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

@@ -1,6 +1,7 @@
 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 { BaseRuntime, CallCapabilityParams, NodeRuntime, ReportRequest, ReportRequestJson, Runtime } from '..';
+import type { Report } from '../report';
 import { type ConsensusAggregation, type PrimitiveTypes, type UnwrapOptions } from '../utils';
 export declare class BaseRuntimeImpl<C> implements BaseRuntime<C> {
     config: C;
@@ -11,10 +12,11 @@ export declare class BaseRuntimeImpl<C> implements BaseRuntime<C> {
     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: () => Promise<O>;
+        result: () => O;
     };
     getNextCallId(): number;
     now(): Date;
+    log(message: string): void;
 }
 export declare class NodeRuntimeImpl<C> extends BaseRuntimeImpl<C> implements NodeRuntime<C> {
     _isNodeRuntime: true;
@@ -23,9 +25,14 @@ export declare class NodeRuntimeImpl<C> extends BaseRuntimeImpl<C> implements No
 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 any[], TOutput>(fn: (nodeRuntime: NodeRuntime<C>, ...args: TArgs) => Promise<TOutput> | TOutput, consesusAggretation: ConsensusAggregation<TOutput, true>, unwrapOptions?: TOutput extends PrimitiveTypes ? never : UnwrapOptions<TOutput>): (...args: TArgs) => Promise<TOutput>;
+    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: () => Promise<Secret>;
+        result: () => Secret;
+    };
+    report(input: ReportRequest | ReportRequestJson): {
+        result: () => Report;
     };
 }
 export interface RuntimeHelpers {
@@ -35,4 +42,5 @@ export interface RuntimeHelpers {
     awaitSecrets(request: AwaitSecretsRequest, maxResponseSize: bigint): AwaitSecretsResponse;
     switchModes(mode: Mode): void;
     now(): number;
+    log(message: string): void;
 }

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

@@ -22,7 +22,11 @@ export class BaseRuntimeImpl {
     }
     callCapability({ capabilityId, method, payload, inputSchema, outputSchema, }) {
         if (this.modeError) {
-            return { result: () => Promise.reject(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
@@ -34,10 +38,12 @@ export class BaseRuntimeImpl {
         //     - etc...
         const anyPayload = anyPack(inputSchema, payload);
         const callbackId = this.nextCallId;
-        if (this.mode == Mode.DON)
+        if (this.mode === Mode.DON) {
             this.nextCallId++;
-        else
+        }
+        else {
             this.nextCallId--;
+        }
         const req = create(CapabilityRequestSchema, {
             id: capabilityId,
             method,
@@ -47,17 +53,19 @@ export class BaseRuntimeImpl {
         if (!this.helpers.call(req)) {
             return {
                 result: () => {
-                    return Promise.reject(new CapabilityError(`Capability not found ${capabilityId}`, {
+                    throw new CapabilityError(`Capability not found ${capabilityId}`, {
                         callbackId,
                         method,
                         capabilityId,
-                    }));
+                    });
                 },
             };
         }
         return {
-            result: async () => {
-                const awaitRequest = create(AwaitCapabilitiesRequestSchema, { ids: [callbackId] });
+            result: () => {
+                const awaitRequest = create(AwaitCapabilitiesRequestSchema, {
+                    ids: [callbackId],
+                });
                 const awaitResponse = this.helpers.await(awaitRequest, this.maxResponseSize);
                 const capabilityResponse = awaitResponse.responses[callbackId];
                 if (!capabilityResponse) {
@@ -94,6 +102,9 @@ export class BaseRuntimeImpl {
         // ns to ms
         return new Date(this.helpers.now() / 1000000);
     }
+    log(message) {
+        this.helpers.log(message);
+    }
 }
 export class NodeRuntimeImpl extends BaseRuntimeImpl {
     _isNodeRuntime = true;
@@ -109,7 +120,7 @@ export class RuntimeImpl extends BaseRuntimeImpl {
         super(config, nextCallId, helpers, maxResponseSize, Mode.DON);
     }
     runInNodeMode(fn, consesusAggretation, unwrapOptions) {
-        return async (...args) => {
+        return (...args) => {
             this.modeError = new DonModeError();
             const nodeRuntime = new NodeRuntimeImpl(this.config, this.nextNodeCallId, this.helpers, this.maxResponseSize);
             const consensusInput = create(SimpleConsensusInputsSchema, {
@@ -120,7 +131,7 @@ export class RuntimeImpl extends BaseRuntimeImpl {
                 consensusInput.default = Value.from(consesusAggretation.defaultValue).proto();
             }
             try {
-                const observation = await fn(nodeRuntime, ...args);
+                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',
@@ -128,7 +139,10 @@ export class RuntimeImpl extends BaseRuntimeImpl {
                 };
             }
             catch (e) {
-                consensusInput.observation = { case: 'error', value: e.message || String(e) };
+                consensusInput.observation = {
+                    case: 'error',
+                    value: (e instanceof Error && e.message) || String(e),
+                };
             }
             finally {
                 // Always restore DON mode before invoking consensus
@@ -138,16 +152,25 @@ export class RuntimeImpl extends BaseRuntimeImpl {
                 this.helpers.switchModes(Mode.DON);
             }
             const consensus = new ConsensusCapability();
-            const result = await consensus.simple(this, consensusInput).result();
-            const wrappedValue = Value.wrap(result);
-            return unwrapOptions
-                ? wrappedValue.unwrapToType(unwrapOptions)
-                : wrappedValue.unwrap();
+            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: () => Promise.reject(this.modeError) };
+            return {
+                result: () => {
+                    throw this.modeError;
+                },
+            };
         }
         const secretRequest = request.$typeName
             ? create(SecretRequestSchema, request)
@@ -160,11 +183,13 @@ export class RuntimeImpl extends BaseRuntimeImpl {
         });
         if (!this.helpers.getSecrets(secretsReq, this.maxResponseSize)) {
             return {
-                result: () => Promise.reject(new SecretsError(secretRequest, 'host is not making the secrets request')),
+                result: () => {
+                    throw new SecretsError(secretRequest, 'host is not making the secrets request');
+                },
             };
         }
         return {
-            result: async () => {
+            result: () => {
                 const awaitRequest = create(AwaitSecretsRequestSchema, { ids: [id] });
                 const awaitResponse = this.helpers.awaitSecrets(awaitRequest, this.maxResponseSize);
                 const secretsResponse = awaitResponse.responses[id];
@@ -172,7 +197,7 @@ export class RuntimeImpl extends BaseRuntimeImpl {
                     throw new SecretsError(secretRequest, 'no response');
                 }
                 const responses = secretsResponse.responses;
-                if (responses.length != 1) {
+                if (responses.length !== 1) {
                     throw new SecretsError(secretRequest, 'invalid value returned from host');
                 }
                 const response = responses[0].response;
@@ -187,4 +212,13 @@ export class RuntimeImpl extends BaseRuntimeImpl {
             },
         };
     }
+    report(input) {
+        const consensus = new ConsensusCapability();
+        const call = consensus.report(this, input);
+        return {
+            result: () => {
+                return call.result();
+            },
+        };
+    }
 }

package/dist/sdk/index.d.ts

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

package/dist/sdk/index.js

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

package/dist/sdk/report.d.ts

@@ -0,0 +1,6 @@
+import { type ReportResponse, type ReportResponseJson } from '../generated/sdk/v1alpha/sdk_pb';
+export declare class Report {
+    private readonly report;
+    constructor(report: ReportResponse | ReportResponseJson);
+    x_generatedCodeOnly_unwrap(): ReportResponse;
+}

package/dist/sdk/report.js

@@ -0,0 +1,14 @@
+import { fromJson } from '@bufbuild/protobuf';
+import { ReportResponseSchema, } from '../generated/sdk/v1alpha/sdk_pb';
+export class Report {
+    report;
+    constructor(report) {
+        this.report = report.$typeName
+            ? report
+            : fromJson(ReportResponseSchema, report);
+    }
+    // x_generatedCodeOnly_unwrap is meant to be used by the code generator only.
+    x_generatedCodeOnly_unwrap() {
+        return this.report;
+    }
+}

package/dist/sdk/runtime.d.ts

@@ -1,7 +1,9 @@
 import type { Message } from '@bufbuild/protobuf';
 import type { GenMessage } from '@bufbuild/protobuf/codegenv2';
+import type { ReportRequest, ReportRequestJson } from '../generated/sdk/v1alpha/sdk_pb';
 import type { ConsensusAggregation, PrimitiveTypes, UnwrapOptions } from './utils';
 import type { SecretsProvider } from '.';
+export type { ReportRequest, ReportRequestJson };
 export type CallCapabilityParams<I extends Message, O extends Message> = {
     capabilityId: string;
     method: string;
@@ -9,15 +11,22 @@ export type CallCapabilityParams<I extends Message, O extends Message> = {
     inputSchema: GenMessage<I>;
     outputSchema: GenMessage<O>;
 };
+import type { Report } from './report';
 export type BaseRuntime<C> = {
     config: C;
     callCapability<I extends Message, O extends Message>(params: CallCapabilityParams<I, O>): {
-        result: () => Promise<O>;
+        result: () => O;
     };
     now(): Date;
+    log(message: string): void;
 };
 export type Runtime<C> = BaseRuntime<C> & SecretsProvider & {
-    runInNodeMode<TArgs extends any[], TOutput>(fn: (nodeRuntime: NodeRuntime<C>, ...args: TArgs) => Promise<TOutput> | TOutput, consensusAggregation: ConsensusAggregation<TOutput, true>, unwrapOptions?: TOutput extends PrimitiveTypes ? never : UnwrapOptions<TOutput>): (...args: TArgs) => Promise<TOutput>;
+    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;
+    };
+    report(input: ReportRequest | ReportRequestJson): {
+        result: () => Report;
+    };
 };
 export type NodeRuntime<C> = BaseRuntime<C> & {
     readonly _isNodeRuntime: true;

package/dist/sdk/utils/capabilities/blockchain/blockchain-helpers.d.ts

@@ -0,0 +1,50 @@
+import type { CallMsgJson } from '../../../../generated/capabilities/blockchain/evm/v1alpha/client_pb';
+import type { Address, Hex } from 'viem';
+/**
+ * EVM Capability Helper.
+ *
+ * `CallContractRequest`, used by EVM capability, has arguments for reading a contract as specified in the call message at a block height defined by blockNumber.
+ * That blockNumber can be:
+ *  - the latest mined block (`LATEST_BLOCK_NUMBER`) (default)
+ * 	- the last finalized block (`LAST_FINALIZED_BLOCK_NUMBER`)
+ *
+ * Using this constant will indicate that the call should be executed at the last finalized block.
+ */
+export declare const LAST_FINALIZED_BLOCK_NUMBER: {
+    absVal: string;
+    sign: string;
+};
+/**
+ * EVM Capability Helper.
+ *
+ * `CallContractRequest`, used by EVM capability, has arguments for reading a contract as specified in the call message at a block height defined by blockNumber.
+ * That blockNumber can be:
+ *  - the latest mined block (`LATEST_BLOCK_NUMBER`) (default)
+ * 	- the last finalized block (`LAST_FINALIZED_BLOCK_NUMBER`)
+ *
+ * Using this constant will indicate that the call should be executed at the latest mined block.
+ */
+export declare const LATEST_BLOCK_NUMBER: {
+    absVal: string;
+    sign: string;
+};
+export interface EncodeCallMsgPayload {
+    from: Address;
+    to: Address;
+    data: Hex;
+}
+/**
+ * Encodes a call message payload into a `CallMsgJson` protobuf structure, expected by the EVM capability.
+ *
+ * When creating a `CallContractRequest` 3 parameters are required:
+ *
+ * - `from` - The sender address.
+ * - `to` - The contract address.
+ * - `data` - The data to call the contract with.
+ *
+ * This helper wraps that data and packs into format acceptable by the EVM capability.
+ *
+ * @param payload - The call message payload to encode.
+ * @returns The encoded call message payload.
+ */
+export declare const encodeCallMsg: (payload: EncodeCallMsgPayload) => CallMsgJson;

package/dist/sdk/utils/capabilities/blockchain/blockchain-helpers.js

@@ -0,0 +1,48 @@
+import { hexToBase64 } from '../../hex-utils';
+/**
+ * EVM Capability Helper.
+ *
+ * `CallContractRequest`, used by EVM capability, has arguments for reading a contract as specified in the call message at a block height defined by blockNumber.
+ * That blockNumber can be:
+ *  - the latest mined block (`LATEST_BLOCK_NUMBER`) (default)
+ * 	- the last finalized block (`LAST_FINALIZED_BLOCK_NUMBER`)
+ *
+ * Using this constant will indicate that the call should be executed at the last finalized block.
+ */
+export const LAST_FINALIZED_BLOCK_NUMBER = {
+    absVal: Buffer.from([3]).toString('base64'), // 3 for finalized block
+    sign: '-1',
+};
+/**
+ * EVM Capability Helper.
+ *
+ * `CallContractRequest`, used by EVM capability, has arguments for reading a contract as specified in the call message at a block height defined by blockNumber.
+ * That blockNumber can be:
+ *  - the latest mined block (`LATEST_BLOCK_NUMBER`) (default)
+ * 	- the last finalized block (`LAST_FINALIZED_BLOCK_NUMBER`)
+ *
+ * Using this constant will indicate that the call should be executed at the latest mined block.
+ */
+export const LATEST_BLOCK_NUMBER = {
+    absVal: Buffer.from([2]).toString('base64'), // 2 for the latest block
+    sign: '-1',
+};
+/**
+ * Encodes a call message payload into a `CallMsgJson` protobuf structure, expected by the EVM capability.
+ *
+ * When creating a `CallContractRequest` 3 parameters are required:
+ *
+ * - `from` - The sender address.
+ * - `to` - The contract address.
+ * - `data` - The data to call the contract with.
+ *
+ * This helper wraps that data and packs into format acceptable by the EVM capability.
+ *
+ * @param payload - The call message payload to encode.
+ * @returns The encoded call message payload.
+ */
+export const encodeCallMsg = (payload) => ({
+    from: hexToBase64(payload.from),
+    to: hexToBase64(payload.to),
+    data: hexToBase64(payload.data),
+});

package/dist/sdk/utils/capabilities/http/http-helpers.d.ts

@@ -0,0 +1,112 @@
+import type { Response } from '../../../../generated/capabilities/networking/http/v1alpha/client_pb';
+/**
+ * HTTP Response Helper Functions
+ *
+ * These utility functions provide a convenient way to work with HTTP Response objects,
+ * mimicking the native Response API methods like .json(), .text(), and .arrayBuffer().
+ *
+ * @example
+ * ```typescript
+ * import { text, json, ok, getHeader } from './http-helpers'
+ *
+ * // Direct usage with Response object
+ * const response = sendRequester.sendRequest({ url: 'https://api.example.com/data' }).result()
+ *
+ * // Check if response is successful
+ * if (!ok(response)) {
+ *   throw new Error(`Request failed with status: ${response.statusCode}`)
+ * }
+ *
+ * // Get response as text (automatically trimmed)
+ * const responseText = text(response)
+ *
+ * // Parse JSON response
+ * const data = json(response)
+ *
+ * // Get specific header
+ * const contentType = getHeader(response, 'content-type')
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Function overload usage
+ * const responseFn = sendRequester.sendRequest({ url: 'https://api.example.com/data' })
+ *
+ * // Check if response is successful
+ * if (!ok(() => ({ result: responseFn.result() })).result()) {
+ *   const response = responseFn.result()
+ *   throw new Error(`Request failed with status: ${response.statusCode}`)
+ * }
+ *
+ * // Get response as text (automatically trimmed)
+ * const responseText = text(() => ({ result: responseFn.result() })).result()
+ * ```
+ */
+/**
+ * Returns the response body as a UTF-8 string, automatically trimmed
+ * @param response - The Response object
+ * @returns The body as a trimmed string
+ */
+export declare function text(response: Response): string;
+/**
+ * Returns the response body as a UTF-8 string, automatically trimmed
+ * @param responseFn - Function that returns an object with result function that returns Response
+ * @returns Object with result function that returns the body as a trimmed string
+ */
+export declare function text(responseFn: () => {
+    result: Response;
+}): {
+    result: () => string;
+};
+/**
+ * Parses the response body as JSON
+ * @param response - The Response object
+ * @returns The parsed JSON
+ * @throws Error if the body is not valid JSON
+ */
+export declare function json(response: Response): unknown;
+/**
+ * Parses the response body as JSON
+ * @param responseFn - Function that returns an object with result function that returns Response
+ * @returns Object with result function that returns the parsed JSON
+ * @throws Error if the body is not valid JSON
+ */
+export declare function json(responseFn: () => {
+    result: Response;
+}): {
+    result: () => unknown;
+};
+/**
+ * Gets a specific header value
+ * @param response - The Response object
+ * @param name - The header name (case-insensitive)
+ * @returns The header value or undefined if not found
+ */
+export declare function getHeader(response: Response, name: string): string | undefined;
+/**
+ * Gets a specific header value
+ * @param responseFn - Function that returns an object with result function that returns Response
+ * @param name - The header name (case-insensitive)
+ * @returns Object with result function that returns the header value or undefined if not found
+ */
+export declare function getHeader(responseFn: () => {
+    result: Response;
+}, name: string): {
+    result: () => string | undefined;
+};
+/**
+ * Checks if the response status indicates success (200-299)
+ * @param response - The Response object
+ * @returns True if the status code is in the 200-299 range
+ */
+export declare function ok(response: Response): boolean;
+/**
+ * Checks if the response status indicates success (200-299)
+ * @param responseFn - Function that returns an object with result function that returns Response
+ * @returns Object with result function that returns true if the status code is in the 200-299 range
+ */
+export declare function ok(responseFn: () => {
+    result: Response;
+}): {
+    result: () => boolean;
+};

package/dist/sdk/utils/capabilities/http/http-helpers.js

@@ -0,0 +1,44 @@
+export function text(responseOrFn) {
+    if (typeof responseOrFn === 'function') {
+        return {
+            result: () => text(responseOrFn().result),
+        };
+    }
+    else {
+        const decoder = new TextDecoder('utf-8');
+        return decoder.decode(responseOrFn.body).trim();
+    }
+}
+export function json(responseOrFn) {
+    if (typeof responseOrFn === 'function') {
+        return {
+            result: () => json(responseOrFn().result),
+        };
+    }
+    else {
+        const decoder = new TextDecoder('utf-8');
+        const textBody = decoder.decode(responseOrFn.body);
+        return JSON.parse(textBody);
+    }
+}
+export function getHeader(responseOrFn, name) {
+    if (typeof responseOrFn === 'function') {
+        return {
+            result: () => getHeader(responseOrFn().result, name),
+        };
+    }
+    else {
+        const lowerName = name.toLowerCase();
+        return Object.entries(responseOrFn.headers).find(([key]) => key.toLowerCase() === lowerName)?.[1];
+    }
+}
+export function ok(responseOrFn) {
+    if (typeof responseOrFn === 'function') {
+        return {
+            result: () => ok(responseOrFn().result),
+        };
+    }
+    else {
+        return responseOrFn.statusCode >= 200 && responseOrFn.statusCode < 300;
+    }
+}

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