@ar.io/sdk 3.13.0-beta.1 → 3.14.0-alpha.1

package/lib/cjs/cli/cli.js

@@ -479,6 +479,14 @@ const utils_js_1 = require("./utils.js");
         return (0, utils_js_1.readANTFromOptions)(options).getTicker();
     },
 });
+(0, utils_js_1.makeCommand)({
+    name: 'get-ant-logo',
+    description: 'Get the logo of an ANT process',
+    options: [options_js_1.optionMap.processId],
+    action: async (options) => {
+        return (0, utils_js_1.readANTFromOptions)(options).getLogo();
+    },
+});
 (0, utils_js_1.makeCommand)({
     name: 'get-ant-balance',
     description: 'Get the balance of an ANT process',

package/lib/cjs/common/ant.js

@@ -39,6 +39,8 @@ class AoANTReadable {
     process;
     processId;
     strict;
+    hyperbeamUrl;
+    checkHyperBeamPromise;
     constructor(config) {
         this.strict = config.strict || false;
         if ((0, index_js_1.isProcessConfiguration)(config)) {
@@ -53,8 +55,43 @@ class AoANTReadable {
             throw new index_js_2.InvalidContractConfigurationError();
         }
         this.processId = this.process.processId;
+        this.hyperbeamUrl = config.hyperbeamUrl || 'https://permanode.xyz'; // TODO: replace this with hyperbeam.ario.permaweb.services once deployed
+        this.checkHyperBeamPromise = this.checkHyperBeamCompatibility();
+    }
+    /**
+     * Check if the process is hyperbeam compatible. If so, we'll use the hyperbeam node to fetch the state.
+     *
+     * @returns {Promise<boolean>} True if the process is hyperbeam compatible, false otherwise.
+     */
+    async checkHyperBeamCompatibility() {
+        if (this.checkHyperBeamPromise !== undefined) {
+            return this.checkHyperBeamPromise;
+        }
+        const res = await fetch(`https://permanode.xyz/${this.processId}~process@1.0/now/cache`, {
+            method: 'HEAD',
+        });
+        let isHyperBeamCompatible = false;
+        if (res.ok) {
+            isHyperBeamCompatible = true;
+        }
+        this.checkHyperBeamPromise = Promise.resolve(isHyperBeamCompatible);
+        return isHyperBeamCompatible;
     }
     async getState({ strict } = { strict: this.strict }) {
+        if (await this.checkHyperBeamCompatibility()) {
+            const res = await fetch(`${this.hyperbeamUrl}/${this.processId}~process@1.0/now/cache/serialize~json@1.0`, {
+                method: 'GET',
+                redirect: 'follow',
+                mode: 'cors',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (!res.ok) {
+                throw new Error('Failed to fetch ant state');
+            }
+            return (0, ant_js_2.convertHyperBeamStateToAoANTState)((await res.json()));
+        }
         const tags = [{ name: 'Action', value: 'State' }];
         const res = await this.process.read({
             tags,
@@ -67,6 +104,20 @@ class AoANTReadable {
         return res;
     }
     async getInfo({ strict } = { strict: this.strict }) {
+        if (await this.checkHyperBeamCompatibility()) {
+            const state = await this.getState();
+            return {
+                Name: state.Name,
+                Ticker: state.Ticker,
+                Description: state.Description,
+                Keywords: state.Keywords,
+                Denomination: state.Denomination.toString(),
+                Owner: state.Owner,
+                Logo: state.Logo,
+                'Total-Supply': state.TotalSupply.toString(),
+                Handlers: [], // TODO: support for handler in patched state
+            };
+        }
         const tags = [{ name: 'Action', value: 'Info' }];
         const info = await this.process.read({
             tags,
@@ -93,6 +144,15 @@ class AoANTReadable {
      * ```
      */
     async getRecord({ undername }, { strict } = { strict: this.strict }) {
+        if (await this.checkHyperBeamCompatibility()) {
+            const records = await this.getRecords();
+            const cachedRecord = records[undername];
+            // if the record is not found, throw an error
+            if (cachedRecord === undefined) {
+                throw new Error('Record not found');
+            }
+            return cachedRecord;
+        }
         // TODO: use sortedANTRecords to get priority on all records, even if ANT does not have a priority set
         const record = await this.process.read({
             tags: [
@@ -113,6 +173,10 @@ class AoANTReadable {
      * ````
      */
     async getRecords({ strict } = { strict: this.strict }) {
+        if (await this.checkHyperBeamCompatibility()) {
+            const state = await this.getState();
+            return (0, ant_js_2.sortANTRecords)(state.Records);
+        }
         const tags = [{ name: 'Action', value: 'Records' }];
         const records = await this.process.read({
             tags,
@@ -131,6 +195,10 @@ class AoANTReadable {
      * ```
      */
     async getOwner({ strict } = { strict: this.strict }) {
+        if (await this.checkHyperBeamCompatibility()) {
+            const state = await this.getState();
+            return state.Owner;
+        }
         const info = await this.getInfo({ strict });
         return info.Owner;
     }
@@ -143,6 +211,10 @@ class AoANTReadable {
      * ```
      */
     async getControllers({ strict } = { strict: this.strict }) {
+        if (await this.checkHyperBeamCompatibility()) {
+            const state = await this.getState();
+            return state.Controllers;
+        }
         const tags = [{ name: 'Action', value: 'Controllers' }];
         const controllers = await this.process.read({
             tags,
@@ -160,6 +232,10 @@ class AoANTReadable {
      * ```
      */
     async getName({ strict } = { strict: this.strict }) {
+        if (await this.checkHyperBeamCompatibility()) {
+            const state = await this.getState();
+            return state.Name;
+        }
         const info = await this.getInfo({ strict });
         return info.Name;
     }
@@ -172,6 +248,10 @@ class AoANTReadable {
      * ```
      */
     async getTicker({ strict } = { strict: this.strict }) {
+        if (await this.checkHyperBeamCompatibility()) {
+            const state = await this.getState();
+            return state.Ticker;
+        }
         const info = await this.getInfo({ strict });
         return info.Ticker;
     }
@@ -184,6 +264,21 @@ class AoANTReadable {
      * ```
      */
     async getBalances({ strict } = { strict: this.strict }) {
+        if (await this.checkHyperBeamCompatibility()) {
+            const res = await fetch(`${this.hyperbeamUrl}/${this.processId}~process@1.0/now/cache/balances/serialize~json@1.0`, {
+                method: 'GET',
+                redirect: 'follow',
+                mode: 'cors',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (!res.ok) {
+                throw new Error('Failed to fetch ant balances');
+            }
+            const result = (await res.json());
+            return result.balances;
+        }
         const tags = [{ name: 'Action', value: 'Balances' }];
         const balances = await this.process.read({
             tags,
@@ -202,6 +297,10 @@ class AoANTReadable {
      * ```
      */
     async getBalance({ address }, { strict } = { strict: this.strict }) {
+        if (await this.checkHyperBeamCompatibility()) {
+            const balances = await this.getBalances();
+            return balances[address] ?? 0;
+        }
         const tags = [
             { name: 'Action', value: 'Balance' },
             { name: 'Recipient', value: address },
@@ -222,6 +321,9 @@ class AoANTReadable {
      * ```
      */
     async getHandlers() {
+        if (await this.checkHyperBeamCompatibility()) {
+            throw new Error('Handlers are not supported on HyperBeam');
+        }
         const info = await this.getInfo();
         return (info.Handlers ?? info.HandlerNames);
     }
@@ -486,7 +588,6 @@ class AoANTWriteable extends AoANTReadable {
     /**
      * Releases an ArNS name associated with the ANT. This will release the name to the public and allow anyone to register it. All primary names must be removed before the name can be released.
      *
-     *
      * @param name @type {string} The name you want to release. The name will be put up for as a recently returned name on the ARIO contract. 50% of the winning bid will be distributed to the ANT owner at the time of purchase. If no purchase in the recently returned name period (14 epochs), the name will be released and can be reregistered by anyone.
      * @param arioProcessId @type {string} The processId of the ARIO contract. This is where the ANT will send the message to release the name.
      * @returns {Promise<AoMessageResult>} The result of the interaction.

package/lib/cjs/common/index.js

@@ -38,5 +38,3 @@ __exportStar(require("./faucet.js"), exports);
 // ao
 __exportStar(require("./io.js"), exports);
 __exportStar(require("./contracts/ao-process.js"), exports);
-// wayfinder
-__exportStar(require("./wayfinder/index.js"), exports);

package/lib/cjs/utils/ant.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sortANTRecords = void 0;
+exports.convertHyperBeamStateToAoANTState = exports.sortANTRecords = void 0;
 /**
  * Sorts ANT records by priority and then lexicographically.
  *
@@ -41,3 +41,34 @@ const sortANTRecords = (antRecords) => {
     return Object.fromEntries(sortedEntries.map(([a, aRecord], index) => [a, { ...aRecord, index }]));
 };
 exports.sortANTRecords = sortANTRecords;
+/**
+ * Convert HyperBeam serialized ANT state to backwards compatible format.
+ *
+ * @param state - The HyperBeam serialized ANT state.
+ */
+const convertHyperBeamStateToAoANTState = (state) => {
+    return {
+        Name: state.name,
+        Ticker: state.ticker,
+        Description: state.description,
+        Keywords: state.keywords,
+        Denomination: parseInt(state.denomination),
+        Owner: state.owner,
+        Controllers: state.controllers,
+        Records: Object.entries(state.records).reduce((acc, [key, record]) => {
+            acc[key] = {
+                transactionId: record.transactionid,
+                ttlSeconds: record.ttlseconds,
+                ...(record.priority !== undefined
+                    ? { priority: record.priority }
+                    : {}),
+            };
+            return acc;
+        }, {}),
+        Balances: state.balances,
+        Logo: state.logo,
+        TotalSupply: state.totalsupply || 1,
+        Initialized: state.initialized,
+    };
+};
+exports.convertHyperBeamStateToAoANTState = convertHyperBeamStateToAoANTState;

package/lib/cjs/utils/hash.js

@@ -1,9 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertDataStreamToDataRoot = exports.hashDataStreamToB64Url = exports.readableStreamToAsyncIterable = exports.isReadableStream = exports.isAsyncIterable = void 0;
+exports.hashBufferToB64Url = exports.hashReadableStreamToB64Url = exports.hashReadableToB64Url = void 0;
 /**
  * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
  *
@@ -19,90 +16,41 @@ exports.convertDataStreamToDataRoot = exports.hashDataStreamToB64Url = exports.r
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const arweave_1 = __importDefault(require("arweave"));
-const merkle_js_1 = require("arweave/node/lib/merkle.js");
 const crypto_1 = require("crypto");
 const base64_js_1 = require("./base64.js");
-const isAsyncIterable = (x) => {
-    return x && typeof x[Symbol.asyncIterator] === 'function';
-};
-exports.isAsyncIterable = isAsyncIterable;
-const isReadableStream = (x) => {
-    return x && typeof x.getReader === 'function';
+const hashReadableToB64Url = (stream, algorithm = 'sha256') => {
+    return new Promise((resolve, reject) => {
+        const hash = (0, crypto_1.createHash)(algorithm);
+        stream.on('data', (chunk) => hash.update(chunk));
+        stream.on('end', () => resolve((0, base64_js_1.toB64Url)(hash.digest())));
+        stream.on('error', (err) => reject(err));
+    });
 };
-exports.isReadableStream = isReadableStream;
-// convert ReadableStream to async iterable
-const readableStreamToAsyncIterable = (stream) => ({
-    async *[Symbol.asyncIterator]() {
+exports.hashReadableToB64Url = hashReadableToB64Url;
+const hashReadableStreamToB64Url = (stream, algorithm = 'sha256') => {
+    return new Promise((resolve, reject) => {
+        const hash = (0, crypto_1.createHash)(algorithm);
         const reader = stream.getReader();
-        try {
-            while (true) {
+        const read = async () => {
+            try {
                 const { done, value } = await reader.read();
-                if (done)
-                    break;
-                if (value !== undefined)
-                    yield value;
+                if (done) {
+                    resolve((0, base64_js_1.toB64Url)(hash.digest()));
+                }
+                else {
+                    hash.update(value);
+                    read();
+                }
             }
-        }
-        finally {
-            reader.releaseLock();
-        }
-    },
-});
-exports.readableStreamToAsyncIterable = readableStreamToAsyncIterable;
-const hashDataStreamToB64Url = async (stream, algorithm = 'sha256') => {
-    const asyncIterable = (0, exports.isAsyncIterable)(stream)
-        ? stream
-        : (0, exports.readableStreamToAsyncIterable)(stream);
-    const hash = (0, crypto_1.createHash)(algorithm);
-    for await (const chunk of asyncIterable) {
-        hash.update(chunk);
-    }
-    return (0, base64_js_1.toB64Url)(hash.digest());
-};
-exports.hashDataStreamToB64Url = hashDataStreamToB64Url;
-const convertDataStreamToDataRoot = async ({ dataStream, }) => {
-    const chunks = [];
-    let leftover = new Uint8Array(0);
-    let cursor = 0;
-    const asyncIterable = (0, exports.isAsyncIterable)(dataStream)
-        ? dataStream
-        : (0, exports.readableStreamToAsyncIterable)(dataStream);
-    for await (const data of asyncIterable) {
-        const inputChunk = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-        const combined = new Uint8Array(leftover.length + inputChunk.length);
-        combined.set(leftover, 0);
-        combined.set(inputChunk, leftover.length);
-        let startIndex = 0;
-        while (combined.length - startIndex >= merkle_js_1.MAX_CHUNK_SIZE) {
-            let chunkSize = merkle_js_1.MAX_CHUNK_SIZE;
-            const remainderAfterThis = combined.length - startIndex - merkle_js_1.MAX_CHUNK_SIZE;
-            if (remainderAfterThis > 0 && remainderAfterThis < merkle_js_1.MIN_CHUNK_SIZE) {
-                chunkSize = Math.ceil((combined.length - startIndex) / 2);
+            catch (err) {
+                reject(err);
             }
-            const chunkData = combined.slice(startIndex, startIndex + chunkSize);
-            const dataHash = await arweave_1.default.crypto.hash(chunkData);
-            chunks.push({
-                dataHash,
-                minByteRange: cursor,
-                maxByteRange: cursor + chunkSize,
-            });
-            cursor += chunkSize;
-            startIndex += chunkSize;
-        }
-        leftover = combined.slice(startIndex);
-    }
-    if (leftover.length > 0) {
-        // TODO: ensure a web friendly crypto hash function is used in web
-        const dataHash = await arweave_1.default.crypto.hash(leftover);
-        chunks.push({
-            dataHash,
-            minByteRange: cursor,
-            maxByteRange: cursor + leftover.length,
-        });
-    }
-    const leaves = await (0, merkle_js_1.generateLeaves)(chunks);
-    const root = await (0, merkle_js_1.buildLayers)(leaves);
-    return (0, base64_js_1.toB64Url)(Buffer.from(root.id));
+        };
+        read().catch(reject);
+    });
+};
+exports.hashReadableStreamToB64Url = hashReadableStreamToB64Url;
+const hashBufferToB64Url = (buffer, algorithm = 'sha256') => {
+    return (0, base64_js_1.toB64Url)((0, crypto_1.createHash)(algorithm).update(buffer).digest());
 };
-exports.convertDataStreamToDataRoot = convertDataStreamToDataRoot;
+exports.hashBufferToB64Url = hashBufferToB64Url;

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.13.0-beta.1';
+exports.version = '3.14.0-alpha.1';

package/lib/esm/cli/cli.js

@@ -477,6 +477,14 @@ makeCommand({
         return readANTFromOptions(options).getTicker();
     },
 });
+makeCommand({
+    name: 'get-ant-logo',
+    description: 'Get the logo of an ANT process',
+    options: [optionMap.processId],
+    action: async (options) => {
+        return readANTFromOptions(options).getLogo();
+    },
+});
 makeCommand({
     name: 'get-ant-balance',
     description: 'Get the balance of an ANT process',

package/lib/esm/common/ant.js

@@ -16,7 +16,7 @@
 import { z } from 'zod';
 import { AntBalancesSchema, AntControllersSchema, AntInfoSchema, AntRecordSchema, AntRecordsSchema, AntStateSchema, } from '../types/ant.js';
 import { isProcessConfiguration, isProcessIdConfiguration, } from '../types/index.js';
-import { sortANTRecords } from '../utils/ant.js';
+import { convertHyperBeamStateToAoANTState, sortANTRecords, } from '../utils/ant.js';
 import { createAoSigner } from '../utils/ao.js';
 import { parseSchemaResult } from '../utils/schema.js';
 import { ANTVersions } from './ant-versions.js';
@@ -35,6 +35,8 @@ export class AoANTReadable {
     process;
     processId;
     strict;
+    hyperbeamUrl;
+    checkHyperBeamPromise;
     constructor(config) {
         this.strict = config.strict || false;
         if (isProcessConfiguration(config)) {
@@ -49,8 +51,43 @@ export class AoANTReadable {
             throw new InvalidContractConfigurationError();
         }
         this.processId = this.process.processId;
+        this.hyperbeamUrl = config.hyperbeamUrl || 'https://permanode.xyz'; // TODO: replace this with hyperbeam.ario.permaweb.services once deployed
+        this.checkHyperBeamPromise = this.checkHyperBeamCompatibility();
+    }
+    /**
+     * Check if the process is hyperbeam compatible. If so, we'll use the hyperbeam node to fetch the state.
+     *
+     * @returns {Promise<boolean>} True if the process is hyperbeam compatible, false otherwise.
+     */
+    async checkHyperBeamCompatibility() {
+        if (this.checkHyperBeamPromise !== undefined) {
+            return this.checkHyperBeamPromise;
+        }
+        const res = await fetch(`https://permanode.xyz/${this.processId}~process@1.0/now/cache`, {
+            method: 'HEAD',
+        });
+        let isHyperBeamCompatible = false;
+        if (res.ok) {
+            isHyperBeamCompatible = true;
+        }
+        this.checkHyperBeamPromise = Promise.resolve(isHyperBeamCompatible);
+        return isHyperBeamCompatible;
     }
     async getState({ strict } = { strict: this.strict }) {
+        if (await this.checkHyperBeamCompatibility()) {
+            const res = await fetch(`${this.hyperbeamUrl}/${this.processId}~process@1.0/now/cache/serialize~json@1.0`, {
+                method: 'GET',
+                redirect: 'follow',
+                mode: 'cors',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (!res.ok) {
+                throw new Error('Failed to fetch ant state');
+            }
+            return convertHyperBeamStateToAoANTState((await res.json()));
+        }
         const tags = [{ name: 'Action', value: 'State' }];
         const res = await this.process.read({
             tags,
@@ -63,6 +100,20 @@ export class AoANTReadable {
         return res;
     }
     async getInfo({ strict } = { strict: this.strict }) {
+        if (await this.checkHyperBeamCompatibility()) {
+            const state = await this.getState();
+            return {
+                Name: state.Name,
+                Ticker: state.Ticker,
+                Description: state.Description,
+                Keywords: state.Keywords,
+                Denomination: state.Denomination.toString(),
+                Owner: state.Owner,
+                Logo: state.Logo,
+                'Total-Supply': state.TotalSupply.toString(),
+                Handlers: [], // TODO: support for handler in patched state
+            };
+        }
         const tags = [{ name: 'Action', value: 'Info' }];
         const info = await this.process.read({
             tags,
@@ -89,6 +140,15 @@ export class AoANTReadable {
      * ```
      */
     async getRecord({ undername }, { strict } = { strict: this.strict }) {
+        if (await this.checkHyperBeamCompatibility()) {
+            const records = await this.getRecords();
+            const cachedRecord = records[undername];
+            // if the record is not found, throw an error
+            if (cachedRecord === undefined) {
+                throw new Error('Record not found');
+            }
+            return cachedRecord;
+        }
         // TODO: use sortedANTRecords to get priority on all records, even if ANT does not have a priority set
         const record = await this.process.read({
             tags: [
@@ -109,6 +169,10 @@ export class AoANTReadable {
      * ````
      */
     async getRecords({ strict } = { strict: this.strict }) {
+        if (await this.checkHyperBeamCompatibility()) {
+            const state = await this.getState();
+            return sortANTRecords(state.Records);
+        }
         const tags = [{ name: 'Action', value: 'Records' }];
         const records = await this.process.read({
             tags,
@@ -127,6 +191,10 @@ export class AoANTReadable {
      * ```
      */
     async getOwner({ strict } = { strict: this.strict }) {
+        if (await this.checkHyperBeamCompatibility()) {
+            const state = await this.getState();
+            return state.Owner;
+        }
         const info = await this.getInfo({ strict });
         return info.Owner;
     }
@@ -139,6 +207,10 @@ export class AoANTReadable {
      * ```
      */
     async getControllers({ strict } = { strict: this.strict }) {
+        if (await this.checkHyperBeamCompatibility()) {
+            const state = await this.getState();
+            return state.Controllers;
+        }
         const tags = [{ name: 'Action', value: 'Controllers' }];
         const controllers = await this.process.read({
             tags,
@@ -156,6 +228,10 @@ export class AoANTReadable {
      * ```
      */
     async getName({ strict } = { strict: this.strict }) {
+        if (await this.checkHyperBeamCompatibility()) {
+            const state = await this.getState();
+            return state.Name;
+        }
         const info = await this.getInfo({ strict });
         return info.Name;
     }
@@ -168,6 +244,10 @@ export class AoANTReadable {
      * ```
      */
     async getTicker({ strict } = { strict: this.strict }) {
+        if (await this.checkHyperBeamCompatibility()) {
+            const state = await this.getState();
+            return state.Ticker;
+        }
         const info = await this.getInfo({ strict });
         return info.Ticker;
     }
@@ -180,6 +260,21 @@ export class AoANTReadable {
      * ```
      */
     async getBalances({ strict } = { strict: this.strict }) {
+        if (await this.checkHyperBeamCompatibility()) {
+            const res = await fetch(`${this.hyperbeamUrl}/${this.processId}~process@1.0/now/cache/balances/serialize~json@1.0`, {
+                method: 'GET',
+                redirect: 'follow',
+                mode: 'cors',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (!res.ok) {
+                throw new Error('Failed to fetch ant balances');
+            }
+            const result = (await res.json());
+            return result.balances;
+        }
         const tags = [{ name: 'Action', value: 'Balances' }];
         const balances = await this.process.read({
             tags,
@@ -198,6 +293,10 @@ export class AoANTReadable {
      * ```
      */
     async getBalance({ address }, { strict } = { strict: this.strict }) {
+        if (await this.checkHyperBeamCompatibility()) {
+            const balances = await this.getBalances();
+            return balances[address] ?? 0;
+        }
         const tags = [
             { name: 'Action', value: 'Balance' },
             { name: 'Recipient', value: address },
@@ -218,6 +317,9 @@ export class AoANTReadable {
      * ```
      */
     async getHandlers() {
+        if (await this.checkHyperBeamCompatibility()) {
+            throw new Error('Handlers are not supported on HyperBeam');
+        }
         const info = await this.getInfo();
         return (info.Handlers ?? info.HandlerNames);
     }
@@ -481,7 +583,6 @@ export class AoANTWriteable extends AoANTReadable {
     /**
      * Releases an ArNS name associated with the ANT. This will release the name to the public and allow anyone to register it. All primary names must be removed before the name can be released.
      *
-     *
      * @param name @type {string} The name you want to release. The name will be put up for as a recently returned name on the ARIO contract. 50% of the winning bid will be distributed to the ANT owner at the time of purchase. If no purchase in the recently returned name period (14 epochs), the name will be released and can be reregistered by anyone.
      * @param arioProcessId @type {string} The processId of the ARIO contract. This is where the ANT will send the message to release the name.
      * @returns {Promise<AoMessageResult>} The result of the interaction.

package/lib/esm/common/index.js

@@ -22,5 +22,3 @@ export * from './faucet.js';
 // ao
 export * from './io.js';
 export * from './contracts/ao-process.js';
-// wayfinder
-export * from './wayfinder/index.js';

package/lib/esm/utils/ant.js

@@ -37,3 +37,33 @@ export const sortANTRecords = (antRecords) => {
     // now that they are sorted, add the index to each record - this is their position in the sorted list and is used to enforce undername limits
     return Object.fromEntries(sortedEntries.map(([a, aRecord], index) => [a, { ...aRecord, index }]));
 };
+/**
+ * Convert HyperBeam serialized ANT state to backwards compatible format.
+ *
+ * @param state - The HyperBeam serialized ANT state.
+ */
+export const convertHyperBeamStateToAoANTState = (state) => {
+    return {
+        Name: state.name,
+        Ticker: state.ticker,
+        Description: state.description,
+        Keywords: state.keywords,
+        Denomination: parseInt(state.denomination),
+        Owner: state.owner,
+        Controllers: state.controllers,
+        Records: Object.entries(state.records).reduce((acc, [key, record]) => {
+            acc[key] = {
+                transactionId: record.transactionid,
+                ttlSeconds: record.ttlseconds,
+                ...(record.priority !== undefined
+                    ? { priority: record.priority }
+                    : {}),
+            };
+            return acc;
+        }, {}),
+        Balances: state.balances,
+        Logo: state.logo,
+        TotalSupply: state.totalsupply || 1,
+        Initialized: state.initialized,
+    };
+};