@ar.io/sdk 3.22.0-alpha.1 → 3.22.0-alpha.2

package/lib/cjs/cli/cli.js

@@ -448,11 +448,7 @@ const utils_js_1 = require("./utils.js");
 (0, utils_js_1.makeCommand)({
     name: 'get-ants-for-address',
     description: 'Get the list of ANTs owned by an address according to the ANT registry',
-    options: [
-        options_js_1.optionMap.address,
-        options_js_1.optionMap.antRegistryProcessId,
-        options_js_1.optionMap.hyperbeamUrl,
-    ],
+    options: [options_js_1.optionMap.address, options_js_1.optionMap.antRegistryProcessId],
     action: readCommands_js_1.listAntsForAddress,
 });
 // # ANTS

package/lib/cjs/cli/options.js

@@ -339,6 +339,7 @@ exports.globalOptions = [
     exports.optionMap.debug,
     exports.optionMap.arioProcessId,
     exports.optionMap.cuUrl,
+    exports.optionMap.hyperbeamUrl,
 ];
 exports.writeActionOptions = [exports.optionMap.skipConfirmation, exports.optionMap.tags];
 exports.arnsPurchaseOptions = [

package/lib/cjs/cli/utils.js

@@ -181,6 +181,7 @@ function aoProcessFromOptions(options) {
 function readARIOFromOptions(options) {
     setLoggerIfDebug(options);
     return index_js_1.ARIO.init({
+        hyperbeamUrl: options.hyperbeamUrl,
         process: aoProcessFromOptions({
             cuUrl: 'https://cu.ardrive.io', // default to ardrive cu for ARIO process
             ...options,
@@ -227,6 +228,7 @@ function writeARIOFromOptions(options) {
             process: aoProcessFromOptions(options),
             signer,
             paymentUrl: options.paymentUrl,
+            hyperbeamUrl: options.hyperbeamUrl,
         }),
         signerAddress,
     };

package/lib/cjs/common/hyperbeam/hb.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HB = void 0;
+const logger_js_1 = require("../logger.js");
+class HB {
+    url;
+    processId;
+    isHyperBeamCompatible;
+    checkHyperBeamPromise;
+    logger;
+    hbTimeoutMs;
+    constructor(config) {
+        this.url = config.url;
+        this.processId = config.processId;
+        this.logger = config.logger ?? logger_js_1.Logger.default;
+        this.hbTimeoutMs = config.hbTimeoutMs ?? 5000;
+        this.isHyperBeamCompatible = undefined;
+        this.checkHyperBeamPromise = this.checkHyperBeamCompatibility();
+    }
+    /**
+     * fetches the meta data for the process
+     *
+     * @returns The meta data for the process
+     *
+     * @example
+     * const hyperbeam = new Hyperbeam({ url: 'https://hyperbeam.ario.permaweb.services', processId: 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE' });
+     * const meta = await hyperbeam.meta();
+     * console.log(meta);
+     */
+    async meta() {
+        const url = new URL(`${this.url}/${this.processId}~process@1.0/meta`);
+        return this.fetchHyperbeamPath({
+            path: url.toString(),
+        });
+    }
+    /**
+     * calls the process device /now function, which evaluates the current process state pulling new messages
+     * to get the latest state
+     *
+     * @param path - The path to the hb state
+     * @param json - Whether to return the result as JSON, defaults to true
+     * @returns The result of the compute operation
+     *
+     * @example
+     * const hyperbeam = new Hyperbeam({ url: 'https://hyperbeam.ario.permaweb.services', processId: 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE' });
+     * const result = await hyperbeam.now({ path: 'balances/QGWqtJdLLgm2ehFWiiPzMaoFLD50CnGuzZIPEdoDRGQ' });
+     * console.log(result);
+     */
+    async now({ path, json = false, }) {
+        return this.fetchHyperbeamPath({
+            path: `${this.url}/${this.processId}~process@1.0/now/${path}`,
+            json,
+        });
+    }
+    /**
+     * calls the process device /compute function, which uses the currently evaluated state in the node
+     *
+     * @param path - The path to the compute resource
+     * @param json - Whether to return the result as JSON, defaults to true
+     * @returns The result of the compute operation
+     *
+     * @example
+     * const hyperbeam = new Hyperbeam({ url: 'https://hyperbeam.ario.permaweb.services', processId: 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE' });
+     * const result = await hyperbeam.compute({ path: 'balances/QGWqtJdLLgm2ehFWiiPzMaoFLD50CnGuzZIPEdoDRGQ' });
+     * console.log(result);
+     */
+    async compute({ path, json = false, }) {
+        return this.fetchHyperbeamPath({
+            path: `${this.url}/${this.processId}~process@1.0/compute/${path}`,
+            json,
+        });
+    }
+    /**
+     * Checks if the process is HyperBeam compatible and caches the result.
+     *
+     * @returns {Promise<boolean>} True if the process is HyperBeam compatible, false otherwise.
+     */
+    async checkHyperBeamCompatibility({ minSlot, } = {}) {
+        // refetch if min slot is provided
+        if (minSlot !== undefined) {
+            this.isHyperBeamCompatible = undefined;
+            this.checkHyperBeamPromise = undefined;
+        }
+        if (this.checkHyperBeamPromise !== undefined) {
+            return this.checkHyperBeamPromise;
+        }
+        if (this.isHyperBeamCompatible !== undefined) {
+            return Promise.resolve(this.isHyperBeamCompatible);
+        }
+        const result = fetch(
+        // use /now to force a refresh of the cache state, then compute when calling it for keys
+        `${this.url.toString()}/${this.processId}~process@1.0/now`, {
+            method: 'HEAD',
+            signal: AbortSignal.timeout(this.hbTimeoutMs),
+        })
+            .then(async (res) => {
+            if (res.ok) {
+                if (minSlot !== undefined) {
+                    const slotRes = await this.compute({
+                        path: 'at-slot',
+                        json: false,
+                    });
+                    const slot = Number(slotRes);
+                    if (slot < minSlot) {
+                        return false;
+                    }
+                }
+                this.isHyperBeamCompatible = true;
+                return true;
+            }
+            this.isHyperBeamCompatible = false;
+            return false;
+        })
+            .catch((error) => {
+            this.logger.debug('Failed to check HyperBeam compatibility', {
+                cause: error,
+            });
+            this.isHyperBeamCompatible = false;
+            return false;
+        });
+        this.checkHyperBeamPromise = result;
+        return result;
+    }
+    async fetchHyperbeamPath({ path, json = true, }) {
+        try {
+            const url = new URL(path);
+            if (json) {
+                this.logger.debug('Fetching path as JSON', { path });
+                /**
+                 * This is the (current) way to access data as json
+                 * the old way is /~json@1.0/serialize path
+                 */
+                url.searchParams.set('require-codec', 'application/json');
+                url.searchParams.set('accept-bundle', 'true');
+                const res = await fetch(url);
+                if (!res.ok) {
+                    throw new Error(`Failed to fetch path as JSON: ${res.statusText}`);
+                }
+                const jsonResult = await res
+                    .json()
+                    .then((json) => json)
+                    .catch((error) => {
+                    this.logger.error('Failed to parse JSON', {
+                        cause: error,
+                    });
+                    throw new Error(`Received response but failed to parse JSON: ${error.message}`);
+                });
+                if (typeof jsonResult !== 'object' ||
+                    jsonResult === null ||
+                    !('body' in jsonResult)) {
+                    throw new Error('Response body missing in JSON response');
+                }
+                return jsonResult.body;
+            }
+            else {
+                this.logger.debug('Fetching path as text', { path });
+                const res = await fetch(url);
+                if (!res.ok) {
+                    throw new Error(`Failed to fetch path: ${res.statusText}`);
+                }
+                const body = await res.text();
+                return body;
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to fetch path as JSON', {
+                cause: error,
+            });
+            throw error;
+        }
+    }
+}
+exports.HB = HB;

package/lib/cjs/common/io.js

@@ -27,6 +27,7 @@ const arweave_js_2 = require("./arweave.js");
 const ao_process_js_1 = require("./contracts/ao-process.js");
 const error_js_1 = require("./error.js");
 const faucet_js_1 = require("./faucet.js");
+const hb_js_1 = require("./hyperbeam/hb.js");
 const logger_js_1 = require("./logger.js");
 const turbo_js_1 = require("./turbo.js");
 class ARIO {
@@ -104,9 +105,9 @@ class ARIOReadable {
     hyperbeamUrl;
     paymentProvider; // TODO: this could be an array/map of payment providers
     logger = logger_js_1.Logger.default;
+    hb;
     constructor(config) {
         this.arweave = config?.arweave ?? arweave_js_2.defaultArweave;
-        this.hyperbeamUrl = config?.hyperbeamUrl;
         if (config === undefined || Object.keys(config).length === 0) {
             this.process = new ao_process_js_1.AOProcess({
                 processId: constants_js_1.ARIO_MAINNET_PROCESS_ID,
@@ -123,6 +124,19 @@ class ARIOReadable {
         else {
             throw new error_js_1.InvalidContractConfigurationError();
         }
+        // only use hyperbeam if the client has provided a hyperbeamUrl
+        // this will avoid overwhelming the HyperBeam node with requests
+        // as we shift using HyperBEAM for all ANT operations
+        if (config?.hyperbeamUrl !== undefined) {
+            this.hyperbeamUrl = config.hyperbeamUrl;
+            this.hb = new hb_js_1.HB({
+                url: this.hyperbeamUrl,
+                processId: this.process.processId,
+            });
+            this.logger.debug(`Using HyperBEAM node for process ${this.process.processId}`, {
+                hyperbeamUrl: this.hyperbeamUrl,
+            });
+        }
         this.paymentProvider = turbo_js_1.TurboArNSPaymentFactory.init({
             paymentUrl: config?.paymentUrl,
         });
@@ -222,6 +236,24 @@ class ARIOReadable {
         });
     }
     async getBalance({ address }) {
+        if (this.hb && (await this.hb.checkHyperBeamCompatibility())) {
+            this.logger.debug('Getting balance from HyperBEAM', { address });
+            const res = await this.hb
+                .compute({
+                path: `balances/${address}`,
+            })
+                .then((res) => Number(res))
+                .catch((error) => {
+                this.logger.error('Failed to get balance from HyperBEAM', {
+                    cause: error,
+                });
+                return null;
+            });
+            if (res !== null)
+                return res;
+            // else fall through to CU read
+            this.logger.info('Failed to get balance from HyperBEAM, failing over to to CU read', { address });
+        }
         return this.process.read({
             tags: [
                 { name: 'Action', value: 'Balance' },

package/lib/cjs/version.js

@@ -17,4 +17,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // AUTOMATICALLY GENERATED FILE - DO NOT TOUCH
-exports.version = '3.22.0-alpha.1';
+exports.version = '3.22.0-alpha.2';

package/lib/esm/cli/cli.js

@@ -446,11 +446,7 @@ makeCommand({
 makeCommand({
     name: 'get-ants-for-address',
     description: 'Get the list of ANTs owned by an address according to the ANT registry',
-    options: [
-        optionMap.address,
-        optionMap.antRegistryProcessId,
-        optionMap.hyperbeamUrl,
-    ],
+    options: [optionMap.address, optionMap.antRegistryProcessId],
     action: listAntsForAddress,
 });
 // # ANTS

package/lib/esm/cli/options.js

@@ -336,6 +336,7 @@ export const globalOptions = [
     optionMap.debug,
     optionMap.arioProcessId,
     optionMap.cuUrl,
+    optionMap.hyperbeamUrl,
 ];
 export const writeActionOptions = [optionMap.skipConfirmation, optionMap.tags];
 export const arnsPurchaseOptions = [

package/lib/esm/cli/utils.js

@@ -127,6 +127,7 @@ function aoProcessFromOptions(options) {
 export function readARIOFromOptions(options) {
     setLoggerIfDebug(options);
     return ARIO.init({
+        hyperbeamUrl: options.hyperbeamUrl,
         process: aoProcessFromOptions({
             cuUrl: 'https://cu.ardrive.io', // default to ardrive cu for ARIO process
             ...options,
@@ -173,6 +174,7 @@ export function writeARIOFromOptions(options) {
             process: aoProcessFromOptions(options),
             signer,
             paymentUrl: options.paymentUrl,
+            hyperbeamUrl: options.hyperbeamUrl,
         }),
         signerAddress,
     };

package/lib/esm/common/hyperbeam/hb.js

@@ -0,0 +1,169 @@
+import { Logger } from '../logger.js';
+export class HB {
+    url;
+    processId;
+    isHyperBeamCompatible;
+    checkHyperBeamPromise;
+    logger;
+    hbTimeoutMs;
+    constructor(config) {
+        this.url = config.url;
+        this.processId = config.processId;
+        this.logger = config.logger ?? Logger.default;
+        this.hbTimeoutMs = config.hbTimeoutMs ?? 5000;
+        this.isHyperBeamCompatible = undefined;
+        this.checkHyperBeamPromise = this.checkHyperBeamCompatibility();
+    }
+    /**
+     * fetches the meta data for the process
+     *
+     * @returns The meta data for the process
+     *
+     * @example
+     * const hyperbeam = new Hyperbeam({ url: 'https://hyperbeam.ario.permaweb.services', processId: 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE' });
+     * const meta = await hyperbeam.meta();
+     * console.log(meta);
+     */
+    async meta() {
+        const url = new URL(`${this.url}/${this.processId}~process@1.0/meta`);
+        return this.fetchHyperbeamPath({
+            path: url.toString(),
+        });
+    }
+    /**
+     * calls the process device /now function, which evaluates the current process state pulling new messages
+     * to get the latest state
+     *
+     * @param path - The path to the hb state
+     * @param json - Whether to return the result as JSON, defaults to true
+     * @returns The result of the compute operation
+     *
+     * @example
+     * const hyperbeam = new Hyperbeam({ url: 'https://hyperbeam.ario.permaweb.services', processId: 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE' });
+     * const result = await hyperbeam.now({ path: 'balances/QGWqtJdLLgm2ehFWiiPzMaoFLD50CnGuzZIPEdoDRGQ' });
+     * console.log(result);
+     */
+    async now({ path, json = false, }) {
+        return this.fetchHyperbeamPath({
+            path: `${this.url}/${this.processId}~process@1.0/now/${path}`,
+            json,
+        });
+    }
+    /**
+     * calls the process device /compute function, which uses the currently evaluated state in the node
+     *
+     * @param path - The path to the compute resource
+     * @param json - Whether to return the result as JSON, defaults to true
+     * @returns The result of the compute operation
+     *
+     * @example
+     * const hyperbeam = new Hyperbeam({ url: 'https://hyperbeam.ario.permaweb.services', processId: 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE' });
+     * const result = await hyperbeam.compute({ path: 'balances/QGWqtJdLLgm2ehFWiiPzMaoFLD50CnGuzZIPEdoDRGQ' });
+     * console.log(result);
+     */
+    async compute({ path, json = false, }) {
+        return this.fetchHyperbeamPath({
+            path: `${this.url}/${this.processId}~process@1.0/compute/${path}`,
+            json,
+        });
+    }
+    /**
+     * Checks if the process is HyperBeam compatible and caches the result.
+     *
+     * @returns {Promise<boolean>} True if the process is HyperBeam compatible, false otherwise.
+     */
+    async checkHyperBeamCompatibility({ minSlot, } = {}) {
+        // refetch if min slot is provided
+        if (minSlot !== undefined) {
+            this.isHyperBeamCompatible = undefined;
+            this.checkHyperBeamPromise = undefined;
+        }
+        if (this.checkHyperBeamPromise !== undefined) {
+            return this.checkHyperBeamPromise;
+        }
+        if (this.isHyperBeamCompatible !== undefined) {
+            return Promise.resolve(this.isHyperBeamCompatible);
+        }
+        const result = fetch(
+        // use /now to force a refresh of the cache state, then compute when calling it for keys
+        `${this.url.toString()}/${this.processId}~process@1.0/now`, {
+            method: 'HEAD',
+            signal: AbortSignal.timeout(this.hbTimeoutMs),
+        })
+            .then(async (res) => {
+            if (res.ok) {
+                if (minSlot !== undefined) {
+                    const slotRes = await this.compute({
+                        path: 'at-slot',
+                        json: false,
+                    });
+                    const slot = Number(slotRes);
+                    if (slot < minSlot) {
+                        return false;
+                    }
+                }
+                this.isHyperBeamCompatible = true;
+                return true;
+            }
+            this.isHyperBeamCompatible = false;
+            return false;
+        })
+            .catch((error) => {
+            this.logger.debug('Failed to check HyperBeam compatibility', {
+                cause: error,
+            });
+            this.isHyperBeamCompatible = false;
+            return false;
+        });
+        this.checkHyperBeamPromise = result;
+        return result;
+    }
+    async fetchHyperbeamPath({ path, json = true, }) {
+        try {
+            const url = new URL(path);
+            if (json) {
+                this.logger.debug('Fetching path as JSON', { path });
+                /**
+                 * This is the (current) way to access data as json
+                 * the old way is /~json@1.0/serialize path
+                 */
+                url.searchParams.set('require-codec', 'application/json');
+                url.searchParams.set('accept-bundle', 'true');
+                const res = await fetch(url);
+                if (!res.ok) {
+                    throw new Error(`Failed to fetch path as JSON: ${res.statusText}`);
+                }
+                const jsonResult = await res
+                    .json()
+                    .then((json) => json)
+                    .catch((error) => {
+                    this.logger.error('Failed to parse JSON', {
+                        cause: error,
+                    });
+                    throw new Error(`Received response but failed to parse JSON: ${error.message}`);
+                });
+                if (typeof jsonResult !== 'object' ||
+                    jsonResult === null ||
+                    !('body' in jsonResult)) {
+                    throw new Error('Response body missing in JSON response');
+                }
+                return jsonResult.body;
+            }
+            else {
+                this.logger.debug('Fetching path as text', { path });
+                const res = await fetch(url);
+                if (!res.ok) {
+                    throw new Error(`Failed to fetch path: ${res.statusText}`);
+                }
+                const body = await res.text();
+                return body;
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to fetch path as JSON', {
+                cause: error,
+            });
+            throw error;
+        }
+    }
+}

package/lib/esm/common/io.js

@@ -24,6 +24,7 @@ import { defaultArweave } from './arweave.js';
 import { AOProcess } from './contracts/ao-process.js';
 import { InvalidContractConfigurationError } from './error.js';
 import { createFaucet } from './faucet.js';
+import { HB } from './hyperbeam/hb.js';
 import { Logger } from './logger.js';
 import { TurboArNSPaymentFactory, TurboArNSPaymentProviderAuthenticated, isTurboArNSSigner, } from './turbo.js';
 export class ARIO {
@@ -100,9 +101,9 @@ export class ARIOReadable {
     hyperbeamUrl;
     paymentProvider; // TODO: this could be an array/map of payment providers
     logger = Logger.default;
+    hb;
     constructor(config) {
         this.arweave = config?.arweave ?? defaultArweave;
-        this.hyperbeamUrl = config?.hyperbeamUrl;
         if (config === undefined || Object.keys(config).length === 0) {
             this.process = new AOProcess({
                 processId: ARIO_MAINNET_PROCESS_ID,
@@ -119,6 +120,19 @@ export class ARIOReadable {
         else {
             throw new InvalidContractConfigurationError();
         }
+        // only use hyperbeam if the client has provided a hyperbeamUrl
+        // this will avoid overwhelming the HyperBeam node with requests
+        // as we shift using HyperBEAM for all ANT operations
+        if (config?.hyperbeamUrl !== undefined) {
+            this.hyperbeamUrl = config.hyperbeamUrl;
+            this.hb = new HB({
+                url: this.hyperbeamUrl,
+                processId: this.process.processId,
+            });
+            this.logger.debug(`Using HyperBEAM node for process ${this.process.processId}`, {
+                hyperbeamUrl: this.hyperbeamUrl,
+            });
+        }
         this.paymentProvider = TurboArNSPaymentFactory.init({
             paymentUrl: config?.paymentUrl,
         });
@@ -218,6 +232,24 @@ export class ARIOReadable {
         });
     }
     async getBalance({ address }) {
+        if (this.hb && (await this.hb.checkHyperBeamCompatibility())) {
+            this.logger.debug('Getting balance from HyperBEAM', { address });
+            const res = await this.hb
+                .compute({
+                path: `balances/${address}`,
+            })
+                .then((res) => Number(res))
+                .catch((error) => {
+                this.logger.error('Failed to get balance from HyperBEAM', {
+                    cause: error,
+                });
+                return null;
+            });
+            if (res !== null)
+                return res;
+            // else fall through to CU read
+            this.logger.info('Failed to get balance from HyperBEAM, failing over to to CU read', { address });
+        }
         return this.process.read({
             tags: [
                 { name: 'Action', value: 'Balance' },

package/lib/esm/version.js

@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 // AUTOMATICALLY GENERATED FILE - DO NOT TOUCH
-export const version = '3.22.0-alpha.1';
+export const version = '3.22.0-alpha.2';

package/lib/types/common/hyperbeam/hb.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { JSONValue } from '../../types/common.js';
+import { Logger } from '../logger.js';
+export type HBConfig = {
+    url: string;
+    processId: string;
+    logger?: Logger;
+    hbTimeoutMs?: number;
+};
+export declare class HB {
+    readonly url: string;
+    readonly processId: string;
+    protected isHyperBeamCompatible: boolean | undefined;
+    protected checkHyperBeamPromise: Promise<boolean> | undefined;
+    private logger;
+    private hbTimeoutMs;
+    constructor(config: HBConfig);
+    /**
+     * fetches the meta data for the process
+     *
+     * @returns The meta data for the process
+     *
+     * @example
+     * const hyperbeam = new Hyperbeam({ url: 'https://hyperbeam.ario.permaweb.services', processId: 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE' });
+     * const meta = await hyperbeam.meta();
+     * console.log(meta);
+     */
+    meta(): Promise<Record<string, JSONValue>>;
+    /**
+     * calls the process device /now function, which evaluates the current process state pulling new messages
+     * to get the latest state
+     *
+     * @param path - The path to the hb state
+     * @param json - Whether to return the result as JSON, defaults to true
+     * @returns The result of the compute operation
+     *
+     * @example
+     * const hyperbeam = new Hyperbeam({ url: 'https://hyperbeam.ario.permaweb.services', processId: 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE' });
+     * const result = await hyperbeam.now({ path: 'balances/QGWqtJdLLgm2ehFWiiPzMaoFLD50CnGuzZIPEdoDRGQ' });
+     * console.log(result);
+     */
+    now<T extends JSONValue>({ path, json, }: {
+        path: string;
+        json?: boolean;
+    }): Promise<T>;
+    /**
+     * calls the process device /compute function, which uses the currently evaluated state in the node
+     *
+     * @param path - The path to the compute resource
+     * @param json - Whether to return the result as JSON, defaults to true
+     * @returns The result of the compute operation
+     *
+     * @example
+     * const hyperbeam = new Hyperbeam({ url: 'https://hyperbeam.ario.permaweb.services', processId: 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE' });
+     * const result = await hyperbeam.compute({ path: 'balances/QGWqtJdLLgm2ehFWiiPzMaoFLD50CnGuzZIPEdoDRGQ' });
+     * console.log(result);
+     */
+    compute<T extends JSONValue>({ path, json, }: {
+        path: string;
+        json?: boolean;
+    }): Promise<T>;
+    /**
+     * Checks if the process is HyperBeam compatible and caches the result.
+     *
+     * @returns {Promise<boolean>} True if the process is HyperBeam compatible, false otherwise.
+     */
+    checkHyperBeamCompatibility({ minSlot, }?: {
+        minSlot?: number;
+    }): Promise<boolean>;
+    fetchHyperbeamPath<T extends JSONValue>({ path, json, }: {
+        path: string;
+        json?: boolean;
+    }): Promise<T>;
+}

package/lib/types/common/io.d.ts

@@ -1,6 +1,7 @@
 import Arweave from 'arweave';
 import { ARIOWithFaucet, AoARIORead, AoARIOWrite, AoAllDelegates, AoAllGatewayVaults, AoArNSNameData, AoArNSNameDataWithName, AoArNSPurchaseParams, AoArNSReservedNameData, AoArNSReservedNameDataWithName, AoBalanceWithAddress, AoBuyRecordParams, AoCreatePrimaryNameRequest, AoCreateVaultParams, AoDelegation, AoEligibleDistribution, AoEpochData, AoEpochDistributed, AoEpochDistributionData, AoEpochDistributionTotalsData, AoEpochObservationData, AoEpochSettings, AoExtendLeaseParams, AoExtendVaultParams, AoGateway, AoGatewayDelegateWithAddress, AoGatewayRegistrySettings, AoGatewayVault, AoGatewayWithAddress, AoGetCostDetailsParams, AoIncreaseUndernameLimitParams, AoIncreaseVaultParams, AoJoinNetworkParams, AoMessageResult, AoPaginatedAddressParams, AoPrimaryName, AoPrimaryNameRequest, AoRedelegationFeeInfo, AoRegistrationFees, AoReturnedName, AoRevokeVaultParams, AoTokenSupplyData, AoUpdateGatewaySettingsParams, AoVaultData, AoVaultedTransferParams, AoWalletVault, AoWeightedObserver, ArNSNameResolutionData, ArNSNameResolver, BuyArNSNameProgressEvents, CostDetailsResult, DemandFactorSettings, EpochInput, OptionalArweave, OptionalPaymentUrl, PaginationParams, PaginationResult, ProcessConfiguration, SetPrimaryNameProgressEvents, TransactionId, WalletAddress, WithSigner, WriteOptions, mARIOToken } from '../types/index.js';
 import { AOProcess } from './contracts/ao-process.js';
+import { HB } from './hyperbeam/hb.js';
 import { Logger } from './logger.js';
 import { TurboArNSPaymentProviderAuthenticated, TurboArNSPaymentProviderUnauthenticated } from './turbo.js';
 type ARIOConfigNoSigner = OptionalPaymentUrl<OptionalArweave<ProcessConfiguration & {
@@ -31,6 +32,7 @@ export declare class ARIOReadable implements AoARIORead, ArNSNameResolver {
     protected hyperbeamUrl: string | undefined;
     protected paymentProvider: TurboArNSPaymentProviderUnauthenticated;
     protected logger: Logger;
+    protected hb: HB | undefined;
     constructor(config?: ARIOConfigNoSigner);
     getInfo(): Promise<{
         Name: string;

package/lib/types/types/common.d.ts

@@ -206,3 +206,6 @@ export type MessageResult = {
     Spawns: any[];
     Error?: any;
 };
+export type JSONValue = string | number | boolean | null | JSONValue[] | {
+    [key: string]: JSONValue;
+};