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

package/lib/cjs/cli/cli.js

@@ -634,6 +634,12 @@ const utils_js_1 = require("./utils.js");
     options: options_js_1.setAntUndernameOptions,
     action: antCommands_js_1.setAntRecordCLICommand,
 });
+(0, utils_js_1.makeCommand)({
+    name: 'upgrade-ant',
+    description: 'Upgrade an ANT by forking it to the latest version and reassigning names',
+    options: options_js_1.upgradeAntOptions,
+    action: antCommands_js_1.upgradeAntCLICommand,
+});
 (0, utils_js_1.makeCommand)({
     name: 'set-ant-ticker',
     description: 'Set the ticker of an ANT process',

package/lib/cjs/cli/commands/antCommands.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.setAntRecordCLICommand = setAntRecordCLICommand;
 exports.setAntBaseNameCLICommand = setAntBaseNameCLICommand;
 exports.setAntUndernameCLICommand = setAntUndernameCLICommand;
+exports.upgradeAntCLICommand = upgradeAntCLICommand;
 const utils_js_1 = require("../utils.js");
 /** @deprecated -- use set-ant-base-name and set-ant-undername */
 async function setAntRecordCLICommand(o) {
@@ -45,3 +46,52 @@ async function setAntUndernameCLICommand(o) {
         ttlSeconds,
     }, (0, utils_js_1.customTagsFromOptions)(o));
 }
+async function upgradeAntCLICommand(o) {
+    const writeAnt = (0, utils_js_1.writeANTFromOptions)(o);
+    const arioProcessId = (0, utils_js_1.arioProcessIdFromOptions)(o);
+    const ario = (0, utils_js_1.readARIOFromOptions)(o);
+    const reassignAffiliatedNames = (0, utils_js_1.booleanFromOptions)(o, 'reassignAffiliatedNames');
+    const names = (0, utils_js_1.stringArrayFromOptions)(o, 'names') || [];
+    if (reassignAffiliatedNames) {
+        // Fetch all ArNS records that point to this ANT process
+        const allRecords = await ario.getArNSRecords({
+            filters: {
+                processId: writeAnt.processId,
+            },
+        });
+        // Filter records that belong to this ANT
+        const affiliatedNames = allRecords.items.map((record) => record.name);
+        names.push(...affiliatedNames);
+    }
+    if (names.length === 0) {
+        throw new Error('No names to reassign');
+    }
+    if (!o.skipConfirmation) {
+        await (0, utils_js_1.assertConfirmationPrompt)(`Upgrade all names affiliated with this ANT on ARIO process?\n` +
+            `ARIO Process ID: ${arioProcessId}\n` +
+            `ANT Process ID: ${writeAnt.processId}\n` +
+            `Names that will be reassigned (${names.length}): ${names.join(', ')}`, o);
+    }
+    const result = reassignAffiliatedNames
+        ? await (0, utils_js_1.writeANTFromOptions)(o).upgrade({
+            reassignAffiliatedNames,
+            arioProcessId,
+        })
+        : await (0, utils_js_1.writeANTFromOptions)(o).upgrade({
+            names,
+            arioProcessId,
+        });
+    // Serialize error objects for JSON compatibility
+    const serializedFailedReassignedNames = {};
+    for (const [name, failure] of Object.entries(result.failedReassignedNames)) {
+        serializedFailedReassignedNames[name] = {
+            id: failure.id,
+            error: failure.error.message,
+        };
+    }
+    return {
+        forkedProcessId: result.forkedProcessId,
+        reassignedNames: result.reassignedNames,
+        failedReassignedNames: serializedFailedReassignedNames,
+    };
+}

package/lib/cjs/cli/options.js

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setAntUndernameOptions = exports.setAntBaseNameOptions = exports.antStateOptions = exports.buyRecordOptions = exports.joinNetworkOptions = exports.updateGatewaySettingsOptions = exports.decreaseDelegateStakeOptions = exports.delegateStakeOptions = exports.redelegateStakeOptions = exports.operatorStakeOptions = exports.vaultedTransferOptions = exports.transferOptions = exports.tokenCostOptions = exports.getVaultOptions = exports.paginationAddressOptions = exports.paginationOptions = exports.nameWriteOptions = exports.addressAndVaultIdOptions = exports.epochOptions = exports.arnsPurchaseOptions = exports.writeActionOptions = exports.globalOptions = exports.walletOptions = exports.optionMap = void 0;
+exports.upgradeAntOptions = exports.setAntUndernameOptions = exports.setAntBaseNameOptions = exports.antStateOptions = exports.buyRecordOptions = exports.joinNetworkOptions = exports.updateGatewaySettingsOptions = exports.decreaseDelegateStakeOptions = exports.delegateStakeOptions = exports.redelegateStakeOptions = exports.operatorStakeOptions = exports.vaultedTransferOptions = exports.transferOptions = exports.tokenCostOptions = exports.getVaultOptions = exports.paginationAddressOptions = exports.paginationOptions = exports.nameWriteOptions = exports.addressAndVaultIdOptions = exports.epochOptions = exports.arnsPurchaseOptions = exports.writeActionOptions = exports.globalOptions = exports.walletOptions = exports.optionMap = void 0;
 exports.optionMap = {
     walletFile: {
         alias: '-w, --wallet-file <walletFilePath>',
@@ -303,6 +303,11 @@ exports.optionMap = {
         alias: '--referrer <referrer>',
         description: 'The referrer for ArNS purchase tracking',
     },
+    reassignAffiliatedNames: {
+        alias: '--reassign-affiliated-names',
+        description: 'Reassign all affiliated names to the new process',
+        type: 'boolean',
+    },
 };
 exports.walletOptions = [
     exports.optionMap.walletFile,
@@ -422,3 +427,9 @@ exports.setAntUndernameOptions = [
     ...exports.setAntBaseNameOptions,
     exports.optionMap.undername,
 ];
+exports.upgradeAntOptions = [
+    exports.optionMap.processId,
+    exports.optionMap.names,
+    exports.optionMap.reassignAffiliatedNames,
+    ...exports.writeActionOptions,
+];

package/lib/cjs/cli/utils.js

@@ -9,11 +9,11 @@ exports.runCommand = runCommand;
 exports.applyOptions = applyOptions;
 exports.makeCommand = makeCommand;
 exports.arioProcessIdFromOptions = arioProcessIdFromOptions;
+exports.antRegistryIdFromOptions = antRegistryIdFromOptions;
 exports.requiredJwkFromOptions = requiredJwkFromOptions;
 exports.jwkToAddress = jwkToAddress;
 exports.getLoggerFromOptions = getLoggerFromOptions;
 exports.readARIOFromOptions = readARIOFromOptions;
-exports.ANTRegistryProcessFromOptions = ANTRegistryProcessFromOptions;
 exports.readANTRegistryFromOptions = readANTRegistryFromOptions;
 exports.contractSignerFromOptions = contractSignerFromOptions;
 exports.requiredContractSignerFromOptions = requiredContractSignerFromOptions;
@@ -130,6 +130,15 @@ function arioProcessIdFromOptions({ arioProcessId, devnet, testnet, }) {
     }
     return index_js_1.ARIO_MAINNET_PROCESS_ID;
 }
+function antRegistryIdFromOptions({ antRegistryProcessId, testnet, }) {
+    if (antRegistryProcessId !== undefined) {
+        return antRegistryProcessId;
+    }
+    if (testnet) {
+        return index_js_1.ANT_REGISTRY_TESTNET_ID;
+    }
+    return index_js_1.ANT_REGISTRY_ID;
+}
 function walletFromOptions({ privateKey, walletFile, }) {
     if (privateKey !== undefined) {
         return JSON.parse(privateKey);
@@ -177,18 +186,9 @@ function readARIOFromOptions(options) {
         paymentUrl: options.paymentUrl,
     });
 }
-function ANTRegistryProcessFromOptions(options) {
-    return new index_js_1.AOProcess({
-        processId: options.antRegistryProcessId ?? index_js_1.ANT_REGISTRY_ID,
-        ao: (0, aoconnect_1.connect)({
-            MODE: 'legacy',
-            CU_URL: options.cuUrl,
-        }),
-    });
-}
 function readANTRegistryFromOptions(options) {
     return index_js_1.ANTRegistry.init({
-        process: ANTRegistryProcessFromOptions(options),
+        process: aoProcessFromOptions(options),
         hyperbeamUrl: options.hyperbeamUrl,
     });
 }

package/lib/cjs/common/ant.js

@@ -17,6 +17,8 @@ exports.AoANTWriteable = exports.AoANTReadable = exports.ANT = void 0;
  * limitations under the License.
  */
 const zod_1 = require("zod");
+const constants_js_1 = require("../constants.js");
+const constants_js_2 = require("../constants.js");
 const ant_js_1 = require("../types/ant.js");
 const index_js_1 = require("../types/index.js");
 const ant_js_2 = require("../utils/ant.js");
@@ -43,6 +45,149 @@ class ANT {
      * @param config
      */
     static fork = ao_js_1.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 = constants_js_1.ARIO_MAINNET_PROCESS_ID, antRegistryId = constants_js_2.ANT_REGISTRY_ID, ao, logger = index_js_2.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 = index_js_2.ARIO.init({
+            process: new index_js_2.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 index_js_2.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);
@@ -54,9 +199,11 @@ exports.ANT = ANT;
 class AoANTReadable {
     process;
     processId;
-    strict;
     hyperbeamUrl;
+    strict;
     checkHyperBeamPromise;
+    moduleId;
+    moduleIdPromise;
     logger = index_js_2.Logger.default;
     constructor(config) {
         this.strict = config.strict || false;
@@ -189,6 +336,185 @@ 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 = constants_js_2.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 = ant_versions_js_1.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 = constants_js_2.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 = ant_versions_js_1.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.
@@ -721,5 +1047,61 @@ 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,
+            });
+        }
+    }
 }
 exports.AoANTWriteable = AoANTWriteable;

package/lib/cjs/common/io.js

@@ -684,12 +684,12 @@ class ARIOReadable {
      * @returns {Promise<AoArNSNameData[]>} The ARNS names associated with the address
      */
     async getArNSRecordsForAddress(params) {
-        const { antRegistryId = constants_js_1.ANT_REGISTRY_ID, address } = params;
+        const { antRegistryProcessId = constants_js_1.ANT_REGISTRY_ID, address } = params;
         const antRegistry = ant_registry_js_1.ANTRegistry.init({
             hyperbeamUrl: this.hyperbeamUrl,
             process: new ao_process_js_1.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/cjs/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_SCHEDULER_ID = exports.AO_AUTHORITY = exports.ANT_LUA_ID = exports.AOS_MODULE_ID = exports.MARIO_PER_ARIO = exports.ANT_REGISTRY_ID = exports.ARIO_MAINNET_PROCESS_ID = exports.ARIO_TESTNET_PROCESS_ID = exports.arioDevnetProcessId = exports.ARIO_DEVNET_PROCESS_ID = exports.FQDN_REGEX = exports.ARWEAVE_TX_REGEX = void 0;
+exports.DEFAULT_SCHEDULER_ID = exports.AO_AUTHORITY = exports.ANT_LUA_ID = exports.AOS_MODULE_ID = exports.MARIO_PER_ARIO = exports.ANT_REGISTRY_ID = exports.ANT_REGISTRY_TESTNET_ID = exports.ARIO_MAINNET_PROCESS_ID = exports.ARIO_TESTNET_PROCESS_ID = exports.arioDevnetProcessId = exports.ARIO_DEVNET_PROCESS_ID = exports.FQDN_REGEX = exports.ARWEAVE_TX_REGEX = void 0;
 /**
  * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
  *
@@ -24,6 +24,7 @@ exports.ARIO_DEVNET_PROCESS_ID = 'GaQrvEMKBpkjofgnBi_B3IgIDmY_XYelVLB6GcRGrHc';
 exports.arioDevnetProcessId = exports.ARIO_DEVNET_PROCESS_ID;
 exports.ARIO_TESTNET_PROCESS_ID = 'agYcCFJtrMG6cqMuZfskIkFTGvUPddICmtQSBIoPdiA';
 exports.ARIO_MAINNET_PROCESS_ID = 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE';
+exports.ANT_REGISTRY_TESTNET_ID = 'RR0vheYqtsKuJCWh6xj0beE35tjaEug5cejMw9n2aa8';
 exports.ANT_REGISTRY_ID = 'i_le_yKKPVstLTDSmkHRqf-wYphMnwB9OhleiTgMkWc';
 exports.MARIO_PER_ARIO = 1_000_000;
 /**

package/lib/cjs/utils/ant.js

@@ -41,6 +41,9 @@ const sortANTRecords = (antRecords) => {
     return Object.fromEntries(sortedEntries.map(([a, aRecord], index) => [a, { ...aRecord, index }]));
 };
 exports.sortANTRecords = sortANTRecords;
+/**
+ * @deprecated - this is no longer necessary because HyperBeam now uses the AoANTState type
+ */
 const isHyperBeamANTState = (state) => {
     return ('name' in state &&
         'ticker' in state &&
@@ -59,6 +62,7 @@ exports.isHyperBeamANTState = isHyperBeamANTState;
 /**
  * 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.
  */
 const convertHyperBeamStateToAoANTState = (initialState) => {

package/lib/cjs/utils/ao.js

@@ -223,7 +223,7 @@ async function spawnANT({ signer, module, ao = (0, aoconnect_1.connect)({
     }
     return processId;
 }
-async function forkANT({ signer, antProcessId, logger = index_js_1.Logger.default, ao, antRegistryId = constants_js_1.ANT_REGISTRY_ID, onSigningProgress = (name, payload) => {
+async function forkANT({ signer, antProcessId, logger = index_js_1.Logger.default, ao, moduleId, antRegistryId = constants_js_1.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
@@ -241,7 +241,9 @@ async function forkANT({ signer, antProcessId, logger = index_js_1.Logger.defaul
     const forkedProcessId = await spawnANT({
         signer,
         antRegistryId,
+        ao,
         logger,
+        module: moduleId,
         onSigningProgress,
         state: {
             owner: state.Owner,

package/lib/cjs/utils/processes.js

@@ -26,7 +26,7 @@ const io_js_1 = require("../common/io.js");
 const logger_js_1 = require("../common/logger.js");
 const constants_js_1 = require("../constants.js");
 /**
- * @beta This API is in beta and may change in the future.
+ * @deprecated Use getArNSRecordsForAddress instead
  */
 const getANTProcessesOwnedByWallet = async ({ address, registry = ant_registry_js_1.ANTRegistry.init(), }) => {
     const res = await registry.accessControlList({ address });

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.19.0-alpha.1';
+exports.version = '3.19.0-alpha.10';