@ar.io/sdk 3.13.0 → 3.14.0-alpha.2

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 = new URL(config.hyperbeamUrl || 'https://hyperbeam.ario.permaweb.services').toString();
+        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(`${this.hyperbeamUrl.toString()}${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/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/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';
+exports.version = '3.14.0-alpha.2';

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 = new URL(config.hyperbeamUrl || 'https://hyperbeam.ario.permaweb.services').toString();
+        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(`${this.hyperbeamUrl.toString()}${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/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,
+    };
+};

package/lib/esm/version.js

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

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

@@ -3,6 +3,7 @@ import { AoMessageResult, ProcessConfiguration, WalletAddress, WithSigner, Write
 import { AOProcess } from './index.js';
 type ANTConfigOptionalStrict = Required<ProcessConfiguration> & {
     strict?: boolean;
+    hyperbeamUrl?: string;
 };
 type ANTConfigNoSigner = ANTConfigOptionalStrict;
 type ANTConfigWithSigner = WithSigner<ANTConfigOptionalStrict>;
@@ -15,7 +16,15 @@ export declare class AoANTReadable implements AoANTRead {
     protected process: AOProcess;
     readonly processId: string;
     private strict;
+    private hyperbeamUrl;
+    private checkHyperBeamPromise;
     constructor(config: ANTConfigOptionalStrict);
+    /**
+     * 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.
+     */
+    private checkHyperBeamCompatibility;
     getState({ strict }?: AntReadOptions): Promise<AoANTState>;
     getInfo({ strict }?: AntReadOptions): Promise<AoANTInfo>;
     /**
@@ -279,7 +288,6 @@ export declare class AoANTWriteable extends AoANTReadable implements AoANTWrite
     /**
      * 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/types/types/ant.d.ts

@@ -127,6 +127,23 @@ export declare const AntStateSchema: z.ZodObject<{
     Initialized: boolean;
 }>;
 export type AoANTState = z.infer<typeof AntStateSchema>;
+export type HyperBeamANTState = {
+    name: string;
+    ticker: string;
+    description: string;
+    keywords: string[];
+    denomination: string;
+    owner: string;
+    controllers: string[];
+    records: Record<string, {
+        transactionid: string;
+        ttlseconds: number;
+    }>;
+    balances: Record<string, number>;
+    logo: string;
+    totalsupply: number;
+    initialized: boolean;
+};
 export declare const SpawnANTStateSchema: z.ZodObject<{
     name: z.ZodString;
     ticker: z.ZodString;

package/lib/types/utils/ant.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ANTRecords, SortedANTRecords } from '../types/ant.js';
+import { ANTRecords, AoANTState, HyperBeamANTState, SortedANTRecords } from '../types/ant.js';
 /**
  * Sorts ANT records by priority and then lexicographically.
  *
@@ -24,3 +24,9 @@ import { ANTRecords, SortedANTRecords } from '../types/ant.js';
  * @param antRecords - The ANT records to sort.
  */
 export declare const sortANTRecords: (antRecords: ANTRecords) => SortedANTRecords;
+/**
+ * Convert HyperBeam serialized ANT state to backwards compatible format.
+ *
+ * @param state - The HyperBeam serialized ANT state.
+ */
+export declare const convertHyperBeamStateToAoANTState: (state: HyperBeamANTState) => AoANTState;

package/lib/types/version.d.ts

@@ -13,4 +13,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export declare const version = "3.13.0-alpha.1";
+export declare const version = "3.14.0-alpha.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ar.io/sdk",
-  "version": "3.13.0",
+  "version": "3.14.0-alpha.2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ar-io/ar-io-sdk.git"