@ar.io/sdk 3.19.0-alpha.1 → 3.19.0-alpha.11

package/lib/esm/common/ant.js

@@ -14,13 +14,15 @@
  * limitations under the License.
  */
 import { z } from 'zod';
+import { ARIO_MAINNET_PROCESS_ID } from '../constants.js';
+import { ANT_REGISTRY_ID } from '../constants.js';
 import { AntBalancesSchema, AntControllersSchema, AntInfoSchema, AntRecordSchema, AntRecordsSchema, AntStateSchema, } from '../types/ant.js';
 import { isProcessConfiguration, isProcessIdConfiguration, } from '../types/index.js';
 import { convertHyperBeamStateToAoANTState, isHyperBeamANTState, sortANTRecords, } from '../utils/ant.js';
 import { createAoSigner, forkANT, spawnANT } from '../utils/ao.js';
 import { parseSchemaResult } from '../utils/schema.js';
 import { ANTVersions } from './ant-versions.js';
-import { AOProcess, InvalidContractConfigurationError, Logger, } from './index.js';
+import { AOProcess, ARIO, InvalidContractConfigurationError, Logger, } from './index.js';
 export class ANT {
     /**
      * Versions of ANTs according to the ANT registry.
@@ -40,6 +42,149 @@ export class ANT {
      * @param config
      */
     static fork = forkANT;
+    /**
+     * Upgrade an ANT by forking it to the latest version and reassigning names.
+     *
+     *
+     * @param config Configuration object for the upgrade process
+     * @returns Promise resolving to the forked process ID and successfully reassigned names
+     */
+    static async upgrade({ signer, antProcessId, reassignAffiliatedNames = true, names, arioProcessId = ARIO_MAINNET_PROCESS_ID, antRegistryId = ANT_REGISTRY_ID, ao, logger = Logger.default, skipVersionCheck = false, onSigningProgress, hyperbeamUrl, }) {
+        // run time check if names is not empty but reassignAffiliatedNames it true, throw
+        if (names !== undefined &&
+            names.length > 0 &&
+            reassignAffiliatedNames !== undefined &&
+            reassignAffiliatedNames !== false) {
+            throw new Error('Cannot reassign all affiliated names and provide specific names');
+        }
+        let namesToReassign = names !== undefined && names.length > 0 ? new Set(names) : new Set();
+        // use reassignAffiliatedNames if names is empty
+        const shouldReassignAll = names === undefined || names.length === 0
+            ? (reassignAffiliatedNames ?? true)
+            : false;
+        const ario = ARIO.init({
+            process: new AOProcess({ processId: arioProcessId, ao }),
+        });
+        const getAllAffiliatedNames = async () => {
+            let cursor = undefined;
+            let hasMore = true;
+            const affiliatedNames = new Set();
+            while (hasMore) {
+                const page = await ario.getArNSRecords({
+                    filters: { processId: antProcessId },
+                    cursor,
+                    limit: 100,
+                });
+                page.items.forEach((r) => {
+                    affiliatedNames.add(r.name);
+                });
+                cursor = page.nextCursor;
+                hasMore = page.hasMore;
+            }
+            return affiliatedNames;
+        };
+        // get all the affiliated names if reassign all affiliated names is true
+        if (shouldReassignAll) {
+            onSigningProgress?.('fetching-affiliated-names', {
+                arioProcessId,
+                antProcessId,
+            });
+            namesToReassign = await getAllAffiliatedNames();
+        }
+        else {
+            if (names === undefined || names.length === 0) {
+                throw new Error('Names are required when reassignAffiliatedNames is false.');
+            }
+            onSigningProgress?.('validating-names', {
+                arioProcessId,
+                antProcessId,
+                names,
+            });
+            // confirm all names are affiliated with the ANT
+            const allAffiliatedNames = await getAllAffiliatedNames();
+            if (!names.every((name) => allAffiliatedNames.has(name))) {
+                // find any that are not affiliated with the ANT
+                const notAffiliatedNames = names.filter((name) => !allAffiliatedNames.has(name));
+                throw new Error(`All names must be affiliated with the ANT on the provided ARIO process. The following names are not affiliated to this ANT: ${notAffiliatedNames.join(', ')}`);
+            }
+        }
+        // if names is empty and reassign all affiliated names is false, throw an error
+        if (namesToReassign.size === 0) {
+            throw new Error('There are no names to reassign for this ANT.');
+        }
+        const existingAntProcess = ANT.init({
+            process: new AOProcess({
+                processId: antProcessId,
+                ao,
+                logger,
+            }),
+            hyperbeamUrl,
+            signer,
+        });
+        if (!skipVersionCheck) {
+            onSigningProgress?.('checking-version', {
+                antProcessId,
+                antRegistryId,
+            });
+            const isLatestVersion = await existingAntProcess.isLatestVersion({
+                antRegistryId,
+            });
+            if (isLatestVersion) {
+                return {
+                    forkedProcessId: antProcessId,
+                    reassignedNames: {},
+                    failedReassignedNames: {},
+                };
+            }
+        }
+        const forkedProcessId = await ANT.fork({
+            signer,
+            antProcessId,
+            ao,
+            logger,
+            antRegistryId,
+            onSigningProgress,
+        });
+        // we could parallelize this, but then signing progress would be harder to track
+        const reassignedNames = {};
+        const failedReassignedNames = {};
+        for (const name of namesToReassign) {
+            let reassignmentResult;
+            try {
+                onSigningProgress?.('reassigning-name', {
+                    name,
+                    arioProcessId,
+                    antProcessId: forkedProcessId,
+                });
+                reassignmentResult = await existingAntProcess.reassignName({
+                    name,
+                    arioProcessId,
+                    antProcessId: forkedProcessId,
+                });
+                onSigningProgress?.('successfully-reassigned-name', {
+                    name,
+                    arioProcessId,
+                    antProcessId: forkedProcessId,
+                });
+                reassignedNames[name] = reassignmentResult;
+            }
+            catch (error) {
+                logger.error(`Failed to reassign name ${name}:`, { error });
+                onSigningProgress?.('failed-to-reassign-name', {
+                    name,
+                    arioProcessId,
+                    antProcessId: forkedProcessId,
+                    error,
+                });
+                // Continue with other names rather than failing completely
+                failedReassignedNames[name] = {
+                    id: reassignmentResult?.id,
+                    error,
+                };
+            }
+        }
+        return { forkedProcessId, reassignedNames, failedReassignedNames };
+    }
     static init(config) {
         if (config !== undefined && 'signer' in config) {
             return new AoANTWriteable(config);
@@ -50,9 +195,11 @@ export class ANT {
 export class AoANTReadable {
     process;
     processId;
-    strict;
     hyperbeamUrl;
+    strict;
     checkHyperBeamPromise;
+    moduleId;
+    moduleIdPromise;
     logger = Logger.default;
     constructor(config) {
         this.strict = config.strict || false;
@@ -185,6 +332,185 @@ export class AoANTReadable {
         const info = await this.getInfo();
         return info.Logo;
     }
+    /**
+     * Gets the module ID of the current ANT process by querying its spawn transaction tags.
+     * Results are cached after the first successful fetch.
+     *
+     * @param graphqlUrl The GraphQL endpoint URL (defaults to Arweave's GraphQL endpoint)
+     * @param retries Number of retry attempts (defaults to 3)
+     * @returns Promise<string> The module ID used to spawn this ANT process
+     * @example
+     * ```ts
+     * const moduleId = await ant.getModuleId();
+     * console.log(`ANT was spawned with module: ${moduleId}`);
+     * ```
+     */
+    async getModuleId({ 
+    // TODO: we could use wayfinder for this
+    graphqlUrl = 'https://arweave.net/graphql', retries = 3, } = {}) {
+        // Return cached result if available
+        if (this.moduleId !== undefined) {
+            this.logger.debug('Returning cached module ID', {
+                processId: this.processId,
+                moduleId: this.moduleId,
+            });
+            return this.moduleId;
+        }
+        // Return existing promise if already in flight
+        if (this.moduleIdPromise) {
+            this.logger.debug('Returning in-flight module ID promise', {
+                processId: this.processId,
+            });
+            return this.moduleIdPromise;
+        }
+        // Create and cache the promise to prevent multiple concurrent requests
+        this.moduleIdPromise = this.fetchModuleId({ graphqlUrl, retries });
+        try {
+            const moduleId = await this.moduleIdPromise;
+            this.moduleId = moduleId;
+            this.logger.debug('Successfully fetched and cached module ID', {
+                processId: this.processId,
+                moduleId,
+            });
+            return moduleId;
+        }
+        finally {
+            // Clear the promise so future calls can retry if this one failed
+            this.moduleIdPromise = undefined;
+        }
+    }
+    /**
+     * Internal method to fetch the module ID from GraphQL.
+     *
+     * TODO: this could be more like get process headers/metadata and fetch additional details.
+     *
+     * It seems like module is the only relevant one, but scheduler and authority are also available.
+     */
+    async fetchModuleId({ graphqlUrl, retries, }) {
+        const query = JSON.stringify({
+            query: `
+        query {
+          transactions(
+            ids: ["${this.processId}"]
+            first: 1
+          ) {
+            edges {
+              node {
+                tags {
+                  name
+                  value
+                }
+              }
+            }
+          }
+        }
+      `,
+        });
+        for (let i = 0; i < retries; i++) {
+            try {
+                const response = await fetch(graphqlUrl, {
+                    method: 'POST',
+                    body: query,
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    signal: AbortSignal.timeout(10_000), // 10 second timeout
+                });
+                if (!response.ok) {
+                    throw new Error(`GraphQL request failed: ${response.statusText}`);
+                }
+                const result = (await response.json());
+                if (result.errors) {
+                    throw new Error(`GraphQL errors: ${result.errors.map((e) => e.message).join(', ')}`);
+                }
+                const edges = result.data?.transactions?.edges;
+                if (!edges || edges.length === 0) {
+                    throw new Error(`No transaction found for process ID: ${this.processId}`);
+                }
+                const tags = edges[0].node.tags;
+                const moduleTag = tags.find((tag) => tag.name === 'Module');
+                if (!moduleTag) {
+                    throw new Error(`No Module tag found for process ID: ${this.processId}`);
+                }
+                return moduleTag.value;
+            }
+            catch (error) {
+                if (i === retries - 1) {
+                    // Final attempt failed
+                    this.logger.error('Failed to get ANT module ID after all retries:', {
+                        error,
+                    });
+                    throw new Error(`Unable to determine module ID for ANT process ${this.processId}: ${error.message}`);
+                }
+                // Exponential backoff
+                await new Promise((resolve) => setTimeout(resolve, Math.pow(2, i) * 1000));
+            }
+        }
+        throw new Error(`Unexpected error getting module ID for process ${this.processId}`);
+    }
+    /**
+     * Gets the version string of the current ANT by matching its module ID
+     * with versions from the ANT registry.
+     *
+     * @param antRegistryId The ANT registry process ID (defaults to mainnet registry)
+     * @param graphqlUrl The GraphQL endpoint URL for getModuleId (defaults to Arweave's GraphQL endpoint)
+     * @param retries Number of retry attempts for getModuleId (defaults to 3)
+     * @returns Promise<string> The version string (e.g., "1.0.15") or "unknown" if not found
+     * @example
+     * ```ts
+     * const version = await ant.getVersion();
+     * console.log(`ANT is running version: ${version}`);
+     * ```
+     */
+    async getVersion({ antRegistryId = ANT_REGISTRY_ID, graphqlUrl = 'https://arweave.net/graphql', retries = 3, } = {}) {
+        // Get the current ANT's module ID
+        const currentModuleId = await this.getModuleId({ graphqlUrl, retries });
+        // Get all versions from the ANT registry
+        const antVersions = ANTVersions.init({
+            processId: antRegistryId,
+        });
+        const versions = await antVersions.getANTVersions();
+        // Find the version that matches our module ID
+        for (const [version, versionInfo] of Object.entries(versions)) {
+            if (versionInfo.moduleId === currentModuleId) {
+                this.logger.debug('Found matching ANT version', {
+                    processId: this.processId,
+                    moduleId: currentModuleId,
+                    version,
+                });
+                return version;
+            }
+        }
+        const versionForModuleId = Object.entries(versions)
+            .map(([version, versionInfo]) => ({
+            version,
+            ...versionInfo,
+        }))
+            .find((obj) => obj.moduleId === currentModuleId);
+        return versionForModuleId?.version ?? 'unknown';
+    }
+    /**
+     * Checks if the current ANT version is the latest according to the ANT registry.
+     *
+     * @param antRegistryId Optional ANT registry process ID. Defaults to mainnet ANT registry.
+     * @param graphqlUrl Optional GraphQL endpoint. Defaults to https://arweave.net/graphql.
+     * @param retries Optional number of retries for fetching module ID. Defaults to 3.
+     * @returns {Promise<boolean>} True if current ANT version is the latest, false otherwise.
+     */
+    async isLatestVersion({ antRegistryId = ANT_REGISTRY_ID, graphqlUrl = 'https://arweave.net/graphql', retries = 3, } = {}) {
+        // Get the current ANT's version
+        const currentVersion = await this.getVersion({
+            antRegistryId,
+            graphqlUrl,
+            retries,
+        });
+        // Get all versions from the ANT registry
+        const antVersions = ANTVersions.init({
+            processId: antRegistryId,
+        });
+        const latestVersion = await antVersions.getLatestANTVersion();
+        return currentVersion === latestVersion.version;
+    }
     /**
      * @param undername @type {string} The domain name.
      * @returns {Promise<ANTRecord>} The record of the undername domain.
@@ -432,17 +758,31 @@ export class AoANTWriteable extends AoANTReadable {
      * @param undername @type {string} The record you want to set the transactionId and ttlSeconds of.
      * @param transactionId @type {string} The transactionId of the record.
      * @param ttlSeconds @type {number} The time to live of the record.
+     * @param owner @type {string} Optional owner address for the record.
+     * @param displayName @type {string} Optional display name for the record.
+     * @param logo @type {string} Optional logo transaction ID for the record.
+     * @param description @type {string} Optional description for the record.
+     * @param keywords @type {string[]} Optional keywords array for the record.
      * @returns {Promise<AoMessageResult>} The result of the interaction.
      */
-    async setRecord({ undername, transactionId, ttlSeconds }, options) {
+    async setRecord({ undername, transactionId, ttlSeconds, owner, displayName, logo, description, keywords, }, options) {
+        const tags = [
+            ...(options?.tags ?? []),
+            { name: 'Action', value: 'Set-Record' },
+            { name: 'Sub-Domain', value: undername },
+            { name: 'Transaction-Id', value: transactionId },
+            { name: 'TTL-Seconds', value: ttlSeconds.toString() },
+            { name: 'Record-Owner', value: owner },
+            { name: 'Display-Name', value: displayName },
+            { name: 'Logo', value: logo },
+            { name: 'Description', value: description },
+            {
+                name: 'Keywords',
+                value: keywords ? JSON.stringify(keywords) : undefined,
+            },
+        ].filter((tag) => tag.value !== undefined);
         return this.process.send({
-            tags: [
-                ...(options?.tags ?? []),
-                { name: 'Action', value: 'Set-Record' },
-                { name: 'Sub-Domain', value: undername },
-                { name: 'Transaction-Id', value: transactionId },
-                { name: 'TTL-Seconds', value: ttlSeconds.toString() },
-            ],
+            tags,
             signer: this.signer,
         });
     }
@@ -451,17 +791,27 @@ export class AoANTWriteable extends AoANTReadable {
      *
      * @param transactionId @type {string} The transactionId of the record.
      * @param ttlSeconds @type {number} The time to live of the record.
+     * @param owner @type {string} Optional owner address for the record.
+     * @param displayName @type {string} Optional display name for the record.
+     * @param logo @type {string} Optional logo transaction ID for the record.
+     * @param description @type {string} Optional description for the record.
+     * @param keywords @type {string[]} Optional keywords array for the record.
      * @returns {Promise<AoMessageResult>} The result of the interaction.
      * @example
      * ```ts
      * ant.setBaseNameRecord({ transactionId: "432l1cy0aksiL_x9M359faGzM_yjralacHIUo8_nQXM", ttlSeconds: 100 }); // ardrive.ar.io will resolve to the provided transaction id and be cached for 100 seconds by clients
      * ```
      */
-    async setBaseNameRecord({ transactionId, ttlSeconds }, options) {
+    async setBaseNameRecord({ transactionId, ttlSeconds, owner, displayName, logo, description, keywords, }, options) {
         return this.setRecord({
             transactionId,
             ttlSeconds,
             undername: '@',
+            owner,
+            displayName,
+            logo,
+            description,
+            keywords,
         }, options);
     }
     /**
@@ -470,17 +820,27 @@ export class AoANTWriteable extends AoANTReadable {
      * @param undername @type {string} The undername of the ANT.
      * @param transactionId @type {string} The transactionId of the record.
      * @param ttlSeconds @type {number} The time to live of the record.
+     * @param owner @type {string} Optional owner address for the record.
+     * @param displayName @type {string} Optional display name for the record.
+     * @param logo @type {string} Optional logo transaction ID for the record.
+     * @param description @type {string} Optional description for the record.
+     * @param keywords @type {string[]} Optional keywords array for the record.
      * @returns {Promise<AoMessageResult>} The result of the interaction.
      * @example
      * ```ts
      * ant.setUndernameRecord({ undername: "dapp", transactionId: "432l1cy0aksiL_x9M359faGzM_yjralacHIUo8_nQXM", ttlSeconds: 100 }); // dapp_ardrive.ar.io will resolve to the provided transaction id and be cached for 100 seconds by clients
      * ```
      */
-    async setUndernameRecord({ undername, transactionId, ttlSeconds }, options) {
+    async setUndernameRecord({ undername, transactionId, ttlSeconds, owner, displayName, logo, description, keywords, }, options) {
         return this.setRecord({
             undername,
             transactionId,
             ttlSeconds,
+            owner,
+            displayName,
+            logo,
+            description,
+            keywords,
         }, options);
     }
     /**
@@ -703,7 +1063,9 @@ export class AoANTWriteable extends AoANTReadable {
      * ant.removePrimaryNames({ names: ["ardrive", "dapp_ardrive"], arioProcessId: ARIO_MAINNET_PROCESS_ID, notifyOwners: true }); // removes the primary names and associated wallet addresses assigned to "ardrive" and "dapp_ardrive"
      * ```
      */
-    async removePrimaryNames({ names, arioProcessId, notifyOwners = false, }, options) {
+    async removePrimaryNames({ names, arioProcessId, 
+    // TODO: remove this param, its not used on the ANT contract
+    notifyOwners = false, }, options) {
         return this.process.send({
             tags: [
                 ...(options?.tags ?? []),
@@ -716,4 +1078,82 @@ export class AoANTWriteable extends AoANTReadable {
             signer: this.signer,
         });
     }
+    /**
+     * Upgrade this ANT by forking it to the latest version and reassigning names.
+     *
+     * This is a convenience method that calls the static ANT.upgrade() method
+     * using this instance's process ID and signer.
+     *
+     * current version with latest ANT registry version and skip if already up to date.
+     *
+     * @param names @type {string[]} The ArNS names to reassign to the upgraded ANT.
+     * @param arioProcessId @type {string} The processId of the ARIO contract.
+     * @param antRegistryId @type {string} Optional ANT registry ID.
+     * @param onSigningProgress Progress callback function.
+     * @returns {Promise} The upgrade results.
+     * @example
+     * ```ts
+     * const result = await ant.upgrade({
+     *   names: ["example", "test"],
+     *   arioProcessId: ARIO_MAINNET_PROCESS_ID
+     * });
+     * console.log(`Upgraded to process: ${result.forkedProcessId}`);
+     * ```
+     */
+    async upgrade(params) {
+        const { names, reassignAffiliatedNames, arioProcessId, antRegistryId, skipVersionCheck, onSigningProgress, } = params ?? {};
+        // Determine if we should reassign all names or specific names
+        const shouldReassignAll = names === undefined || names.length === 0
+            ? (reassignAffiliatedNames ?? true)
+            : false;
+        if (shouldReassignAll) {
+            return ANT.upgrade({
+                signer: this.signer,
+                antProcessId: this.processId,
+                ao: this.process.ao,
+                hyperbeamUrl: this.hyperbeamUrl?.toString(),
+                reassignAffiliatedNames: true,
+                arioProcessId: arioProcessId,
+                antRegistryId: antRegistryId,
+                onSigningProgress: onSigningProgress,
+                skipVersionCheck: skipVersionCheck,
+            });
+        }
+        else {
+            return ANT.upgrade({
+                signer: this.signer,
+                antProcessId: this.processId,
+                ao: this.process.ao,
+                hyperbeamUrl: this.hyperbeamUrl?.toString(),
+                names: names,
+                reassignAffiliatedNames: false,
+                arioProcessId: arioProcessId,
+                antRegistryId: antRegistryId,
+                onSigningProgress: onSigningProgress,
+                skipVersionCheck: skipVersionCheck,
+            });
+        }
+    }
+    /**
+     * Transfers ownership of a specific record (undername) to another address. This allows delegation of control for individual records within an ANT while maintaining the ANT owner's ultimate authority.
+     *
+     * @param undername @type {string} The subdomain/record whose ownership you want to transfer.
+     * @param recipient @type {string} The address of the new owner for this record.
+     * @returns {Promise<AoMessageResult>} The result of the interaction.
+     * @example
+     * ```ts
+     * ant.transferRecord({ undername: "alice", recipient: "new-owner-address-123..." }); // transfers ownership of the "alice" record to the new owner
+     * ```
+     */
+    async transferRecord({ undername, recipient, }, options) {
+        return this.process.send({
+            tags: [
+                ...(options?.tags ?? []),
+                { name: 'Action', value: 'Transfer-Record' },
+                { name: 'Sub-Domain', value: undername },
+                { name: 'Recipient', value: recipient },
+            ],
+            signer: this.signer,
+        });
+    }
 }

package/lib/esm/common/io.js

@@ -680,12 +680,12 @@ export class ARIOReadable {
      * @returns {Promise<AoArNSNameData[]>} The ARNS names associated with the address
      */
     async getArNSRecordsForAddress(params) {
-        const { antRegistryId = ANT_REGISTRY_ID, address } = params;
+        const { antRegistryProcessId = ANT_REGISTRY_ID, address } = params;
         const antRegistry = ANTRegistry.init({
             hyperbeamUrl: this.hyperbeamUrl,
             process: new AOProcess({
                 ao: this.process.ao,
-                processId: antRegistryId,
+                processId: antRegistryProcessId,
             }),
         });
         // Note: there could be a race condition here if the ACL changes during pagination requests, resulting in different results from the `getArNSRecords`.

package/lib/esm/constants.js

@@ -21,6 +21,7 @@ export const ARIO_DEVNET_PROCESS_ID = 'GaQrvEMKBpkjofgnBi_B3IgIDmY_XYelVLB6GcRGr
 export const arioDevnetProcessId = ARIO_DEVNET_PROCESS_ID;
 export const ARIO_TESTNET_PROCESS_ID = 'agYcCFJtrMG6cqMuZfskIkFTGvUPddICmtQSBIoPdiA';
 export const ARIO_MAINNET_PROCESS_ID = 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE';
+export const ANT_REGISTRY_TESTNET_ID = 'RR0vheYqtsKuJCWh6xj0beE35tjaEug5cejMw9n2aa8';
 export const ANT_REGISTRY_ID = 'i_le_yKKPVstLTDSmkHRqf-wYphMnwB9OhleiTgMkWc';
 export const MARIO_PER_ARIO = 1_000_000;
 /**

package/lib/esm/types/ant.js

@@ -51,6 +51,23 @@ export const AntRecordSchema = z.object({
     transactionId: ArweaveTxIdSchema.describe('The Target ID of the undername'),
     ttlSeconds: z.number(),
     priority: z.number().optional(),
+    owner: AOAddressSchema.describe('The owner address of the record').optional(),
+    displayName: z
+        .string()
+        .max(61)
+        .describe('Display name of the record (max 61 chars)')
+        .optional(),
+    logo: ArweaveTxIdSchema.describe('Logo transaction ID for the record').optional(),
+    description: z
+        .string()
+        .max(512)
+        .describe('Description of the record (max 512 chars)')
+        .optional(),
+    keywords: z
+        .array(z.string().max(32))
+        .max(16)
+        .describe('Keywords array (max 16, each max 32 chars)')
+        .optional(),
 });
 export const AntRecordsSchema = z.record(z.string(), AntRecordSchema);
 export const AntControllersSchema = z.array(AOAddressSchema.describe('Controller address'));
@@ -116,6 +133,7 @@ export const AntWriteHandlers = [
     'reassignName',
     'approvePrimaryName',
     'removePrimaryNames',
+    'transferRecordOwnership',
 ];
 export const AntHandlerNames = [...AntReadHandlers, ...AntWriteHandlers];
 export const AntHandlersSchema = z

package/lib/esm/utils/ant.js

@@ -37,6 +37,9 @@ 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 }]));
 };
+/**
+ * @deprecated - this is no longer necessary because HyperBeam now uses the AoANTState type
+ */
 export const isHyperBeamANTState = (state) => {
     return ('name' in state &&
         'ticker' in state &&
@@ -54,6 +57,7 @@ export const isHyperBeamANTState = (state) => {
 /**
  * Convert HyperBeam serialized ANT state to backwards compatible format.
  *
+ * @deprecated - this is no longer necessary because HyperBeam now uses the AOANTState type
  * @param state - The HyperBeam serialized ANT state.
  */
 export const convertHyperBeamStateToAoANTState = (initialState) => {

package/lib/esm/utils/ao.js

@@ -211,7 +211,7 @@ export async function spawnANT({ signer, module, ao = connect({
     }
     return processId;
 }
-export async function forkANT({ signer, antProcessId, logger = Logger.default, ao, antRegistryId = ANT_REGISTRY_ID, onSigningProgress = (name, payload) => {
+export async function forkANT({ signer, antProcessId, logger = Logger.default, ao, moduleId, antRegistryId = ANT_REGISTRY_ID, onSigningProgress = (name, payload) => {
     logger.debug('Forking ANT', { name, payload });
 }, }) {
     // get the state of the current ANT and use it to spawn a new ANT
@@ -229,7 +229,9 @@ export async function forkANT({ signer, antProcessId, logger = Logger.default, a
     const forkedProcessId = await spawnANT({
         signer,
         antRegistryId,
+        ao,
         logger,
+        module: moduleId,
         onSigningProgress,
         state: {
             owner: state.Owner,

package/lib/esm/utils/processes.js

@@ -23,7 +23,7 @@ import { ARIO } from '../common/io.js';
 import { Logger } from '../common/logger.js';
 import { ARIO_MAINNET_PROCESS_ID } from '../constants.js';
 /**
- * @beta This API is in beta and may change in the future.
+ * @deprecated Use getArNSRecordsForAddress instead
  */
 export const getANTProcessesOwnedByWallet = async ({ address, registry = ANTRegistry.init(), }) => {
     const res = await registry.accessControlList({ address });

package/lib/esm/version.js

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