@ar.io/sdk 3.2.0 → 3.3.0-alpha.10

package/lib/esm/cli/cli.js

@@ -16,15 +16,15 @@
  */
 // eslint-disable-next-line header/header -- This is a CLI file
 import { program } from 'commander';
-import { spawnANT } from '../node/index.js';
+import { AOProcess, spawnANT } from '../node/index.js';
 import { mARIOToken } from '../types/token.js';
 import { version } from '../version.js';
 import { buyRecordCLICommand, extendLeaseCLICommand, increaseUndernameLimitCLICommand, requestPrimaryNameCLICommand, upgradeRecordCLICommand, } from './commands/arnsPurchaseCommands.js';
 import { cancelWithdrawal, decreaseDelegateStake, decreaseOperatorStake, delegateStake, increaseOperatorStake, instantWithdrawal, joinNetwork, leaveNetwork, redelegateStake, saveObservations, updateGatewaySettings, } from './commands/gatewayWriteCommands.js';
-import { getAllowedDelegates, getArNSRecord, getArNSReservedName, getArNSReturnedName, getCostDetails, getDelegations, getEpoch, getGateway, getGatewayDelegates, getGatewayVaults, getPrescribedNames, getPrescribedObservers, getPrimaryName, getTokenCost, getVault, listArNSRecords, listArNSReservedNames, listArNSReturnedNames, listGateways, } from './commands/readCommands.js';
+import { getAllowedDelegates, getArNSRecord, getArNSReservedName, getArNSReturnedName, getCostDetails, getDelegations, getEpoch, getGateway, getGatewayDelegates, getGatewayVaults, getPrescribedNames, getPrescribedObservers, getPrimaryName, getTokenCost, getVault, listAllDelegatesCLICommand, listArNSRecords, listArNSReservedNames, listArNSReturnedNames, listGateways, } from './commands/readCommands.js';
 import { transfer } from './commands/transfer.js';
 import { addressAndVaultIdOptions, antStateOptions, arnsPurchaseOptions, buyRecordOptions, decreaseDelegateStakeOptions, delegateStakeOptions, epochOptions, getVaultOptions, globalOptions, joinNetworkOptions, operatorStakeOptions, optionMap, paginationAddressOptions, paginationOptions, redelegateStakeOptions, tokenCostOptions, transferOptions, updateGatewaySettingsOptions, writeActionOptions, } from './options.js';
-import { applyOptions, arioProcessIdFromOptions, assertConfirmationPrompt, epochInputFromOptions, formatARIOWithCommas, getANTStateFromOptions, getLoggerFromOptions, makeCommand, paginationParamsFromOptions, readANTFromOptions, readARIOFromOptions, requiredAddressFromOptions, requiredAoSignerFromOptions, requiredStringArrayFromOptions, requiredStringFromOptions, writeANTFromOptions, writeActionTagsFromOptions, } from './utils.js';
+import { applyOptions, arioProcessIdFromOptions, assertConfirmationPrompt, epochInputFromOptions, formatARIOWithCommas, getANTStateFromOptions, getLoggerFromOptions, makeCommand, paginationParamsFromOptions, readANTFromOptions, readARIOFromOptions, requiredAddressFromOptions, requiredAoSignerFromOptions, requiredProcessIdFromOptions, requiredStringArrayFromOptions, requiredStringFromOptions, writeANTFromOptions, writeActionTagsFromOptions, } from './utils.js';
 applyOptions(program
     .name('ar.io')
     .version(version)
@@ -62,6 +62,12 @@ makeCommand({
     options: paginationOptions,
     action: listGateways,
 });
+makeCommand({
+    name: 'list-all-delegates',
+    description: 'List all paginated delegates from all gateways',
+    options: paginationOptions,
+    action: listAllDelegatesCLICommand,
+});
 makeCommand({
     name: 'get-gateway-delegates',
     description: 'Get the delegates of a gateway',
@@ -143,13 +149,17 @@ makeCommand({
     name: 'get-observations',
     description: 'Get observations for an epoch',
     options: epochOptions,
-    action: (o) => readARIOFromOptions(o).getObservations(epochInputFromOptions(o)),
+    action: (o) => readARIOFromOptions(o)
+        .getObservations(epochInputFromOptions(o))
+        .then((result) => result ?? { message: 'No observations found for epoch' }),
 });
 makeCommand({
     name: 'get-distributions',
     description: 'Get distributions for an epoch',
     options: epochOptions,
-    action: (o) => readARIOFromOptions(o).getDistributions(epochInputFromOptions(o)),
+    action: (o) => readARIOFromOptions(o)
+        .getDistributions(epochInputFromOptions(o))
+        .then((result) => result ?? { message: 'No distributions found for epoch' }),
 });
 makeCommand({
     name: 'get-token-cost',
@@ -652,6 +662,20 @@ makeCommand({
         }, writeActionTagsFromOptions(options));
     },
 });
+makeCommand({
+    name: 'write-action',
+    description: 'Send a write action to an AO Process',
+    options: [...writeActionOptions, optionMap.processId],
+    action: async (options) => {
+        const process = new AOProcess({
+            processId: requiredProcessIdFromOptions(options),
+        });
+        return process.send({
+            tags: writeActionTagsFromOptions(options).tags ?? [],
+            signer: requiredAoSignerFromOptions(options),
+        });
+    },
+});
 if (process.argv[1].includes('bin/ar.io') || // Running from global .bin
     process.argv[1].includes('cli/cli') // Running from source
 ) {

package/lib/esm/cli/commands/readCommands.js

@@ -11,6 +11,10 @@ export async function listGateways(o) {
     const gateways = await readARIOFromOptions(o).getGateways(paginationParamsFromOptions(o));
     return gateways.items.length ? gateways : { message: 'No gateways found' };
 }
+export async function listAllDelegatesCLICommand(o) {
+    const delegates = await readARIOFromOptions(o).getAllDelegates(paginationParamsFromOptions(o));
+    return delegates.items.length ? delegates : { message: 'No delegates found' };
+}
 export async function getGatewayDelegates(o) {
     const address = requiredAddressFromOptions(o);
     const result = await readARIOFromOptions(o).getGatewayDelegates({

package/lib/esm/common/ant-registry.js

@@ -19,12 +19,8 @@ import { createAoSigner } from '../utils/ao.js';
 import { AOProcess, InvalidContractConfigurationError } from './index.js';
 export class ANTRegistry {
     static init(config) {
-        if (config && config.signer) {
-            const { signer, ...rest } = config;
-            return new AoANTRegistryWriteable({
-                ...rest,
-                signer,
-            });
+        if (config !== undefined && 'signer' in config) {
+            return new AoANTRegistryWriteable(config);
         }
         return new AoANTRegistryReadable(config);
     }
@@ -32,25 +28,22 @@ export class ANTRegistry {
 export class AoANTRegistryReadable {
     process;
     constructor(config) {
-        if (config &&
-            (isProcessIdConfiguration(config) || isProcessConfiguration(config))) {
-            if (isProcessConfiguration(config)) {
-                this.process = config.process;
-            }
-            else if (isProcessIdConfiguration(config)) {
-                this.process = new AOProcess({
-                    processId: config.processId,
-                });
-            }
-            else {
-                throw new InvalidContractConfigurationError();
-            }
-        }
-        else {
+        if (config === undefined || Object.keys(config).length === 0) {
             this.process = new AOProcess({
                 processId: ANT_REGISTRY_ID,
             });
         }
+        else if (isProcessConfiguration(config)) {
+            this.process = config.process;
+        }
+        else if (isProcessIdConfiguration(config)) {
+            this.process = new AOProcess({
+                processId: config.processId,
+            });
+        }
+        else {
+            throw new InvalidContractConfigurationError();
+        }
     }
     // Should we rename this to "getANTsByAddress"? seems more clear, though not same as handler name
     async accessControlList({ address, }) {

package/lib/esm/common/ant.js

@@ -20,15 +20,12 @@ import { createAoSigner } from '../utils/ao.js';
 import { parseSchemaResult } from '../utils/schema.js';
 import { AOProcess, InvalidContractConfigurationError } from './index.js';
 export class ANT {
-    static init({ signer, strict = false, ...config }) {
-        // ao supported implementation
-        if (isProcessConfiguration(config) || isProcessIdConfiguration(config)) {
-            if (!signer) {
-                return new AoANTReadable({ strict, ...config });
-            }
-            return new AoANTWriteable({ signer, strict, ...config });
+    // implementation
+    static init(config) {
+        if (config !== undefined && 'signer' in config) {
+            return new AoANTWriteable(config);
         }
-        throw new InvalidContractConfigurationError();
+        return new AoANTReadable(config);
     }
 }
 export class AoANTReadable {

package/lib/esm/common/contracts/ao-process.js

@@ -21,8 +21,8 @@ import { WriteInteractionError } from '../error.js';
 import { Logger } from '../logger.js';
 export class AOProcess {
     logger;
-    processId;
     ao;
+    processId;
     constructor({ processId, ao = connect(), logger = Logger.default, }) {
         this.processId = processId;
         this.logger = logger;
@@ -39,8 +39,9 @@ export class AOProcess {
         let lastError;
         while (attempts < retries) {
             try {
-                this.logger.debug(`Evaluating read interaction on contract`, {
+                this.logger.debug(`Evaluating read interaction on process`, {
                     tags,
+                    processId: this.processId,
                 });
                 // map tags to inputs
                 const dryRunInput = {
@@ -53,13 +54,18 @@ export class AOProcess {
                 const result = await this.ao.dryrun(dryRunInput);
                 this.logger.debug(`Read interaction result`, {
                     result,
+                    processId: this.processId,
                 });
                 const error = errorMessageFromOutput(result);
                 if (error !== undefined) {
                     throw new Error(error);
                 }
                 if (result.Messages === undefined || result.Messages.length === 0) {
-                    this.logger.debug(`Process ${this.processId} does not support provided action.`, result, tags);
+                    this.logger.debug(`Process ${this.processId} does not support provided action.`, {
+                        result,
+                        tags,
+                        processId: this.processId,
+                    });
                     throw new Error(`Process ${this.processId} does not support provided action.`);
                 }
                 const messageData = result.Messages?.[0]?.Data;
@@ -67,16 +73,18 @@ export class AOProcess {
                 if (this.isMessageDataEmpty(messageData)) {
                     return undefined;
                 }
-                const response = safeDecode(result.Messages[0].Data);
+                const response = safeDecode(messageData);
                 return response;
             }
-            catch (e) {
+            catch (error) {
                 attempts++;
                 this.logger.debug(`Read attempt ${attempts} failed`, {
-                    error: e instanceof Error ? e.message : e,
+                    error: error?.message,
+                    stack: error?.stack,
                     tags,
+                    processId: this.processId,
                 });
-                lastError = e;
+                lastError = error;
                 // exponential backoff
                 await new Promise((resolve) => setTimeout(resolve, 2 ** attempts * 1000));
             }
@@ -144,16 +152,17 @@ export class AOProcess {
             }
             catch (error) {
                 this.logger.error('Error sending message to process', {
-                    error: error.message,
+                    error: error?.message,
+                    stack: error?.stack,
                     processId: this.processId,
                     tags,
                 });
-                // throw on write interaction errors. No point retrying wr ite interactions, waste of gas.
+                // throw on write interaction errors. No point retrying write interactions, waste of gas.
                 if (error.message.includes('500')) {
                     this.logger.debug('Retrying send interaction', {
                         attempts,
                         retries,
-                        error: error.message,
+                        error: error?.message,
                         processId: this.processId,
                     });
                     // exponential backoff
@@ -170,18 +179,16 @@ export class AOProcess {
 }
 function errorMessageFromOutput(output) {
     const errorData = output.Error;
-    if (errorData !== undefined) {
-        // TODO: Could clean this one up too, current error is verbose, but not always deterministic for parsing
-        // Throw the whole raw error if AO process level error
-        return errorData;
-    }
-    const error = output.Messages?.[0]?.Tags?.find((tag) => tag.name === 'Error')?.value;
+    // Attempt to extract error details from Messages.Tags if Error is undefined
+    const error = errorData ??
+        output.Messages?.[0]?.Tags?.find((tag) => tag.name === 'Error')?.value;
     if (error !== undefined) {
-        // from [string "aos"]:6846: Name is already registered
-        const lineNumber = error.match(/\d+/)?.[0];
-        const message = error.replace(/\[string "aos"\]:\d+:/, '');
-        // to more user friendly: Name is already registered (line 6846)
-        return `${message} (line ${lineNumber})`.trim();
+        // Consolidated regex to match and extract line number and AO error message or Error Tags
+        const match = error.match(/\[string "aos"]:(\d+):\s*(.+)/);
+        if (match) {
+            const [, lineNumber, errorMessage] = match;
+            return `${errorMessage.trim()} (line ${lineNumber.trim()})`.trim();
+        }
     }
     return undefined;
 }

package/lib/esm/common/io.js

@@ -1,32 +1,15 @@
-/**
- * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 import { ARIO_TESTNET_PROCESS_ID } from '../constants.js';
 import { isProcessConfiguration, isProcessIdConfiguration, } from '../types/io.js';
 import { createAoSigner } from '../utils/ao.js';
-import { paginationParamsToTags, pruneTags } from '../utils/arweave.js';
+import { getEpochDataFromGql, paginationParamsToTags, pruneTags, } from '../utils/arweave.js';
+import { defaultArweave } from './arweave.js';
 import { AOProcess } from './contracts/ao-process.js';
 import { InvalidContractConfigurationError } from './error.js';
 export class ARIO {
+    // Implementation
     static init(config) {
-        if (config && config.signer) {
-            const { signer, ...rest } = config;
-            return new ARIOWriteable({
-                ...rest,
-                signer,
-            });
+        if (config !== undefined && 'signer' in config) {
+            return new ARIOWriteable(config);
         }
         return new ARIOReadable(config);
     }
@@ -34,8 +17,10 @@ export class ARIO {
 export class ARIOReadable {
     process;
     epochSettings;
+    arweave;
     constructor(config) {
-        if (!config) {
+        this.arweave = config?.arweave ?? defaultArweave;
+        if (config === undefined || Object.keys(config).length === 0) {
             this.process = new AOProcess({
                 processId: ARIO_TESTNET_PROCESS_ID,
             });
@@ -68,6 +53,13 @@ export class ARIOReadable {
         const epochLengthMs = epochSettings.durationMs;
         return Math.floor((timestamp - epochZeroStartTimestamp) / epochLengthMs);
     }
+    async computeCurrentEpochIndex() {
+        const epochSettings = await this.getEpochSettings();
+        const epochZeroStartTimestamp = epochSettings.epochZeroStartTimestamp;
+        const epochLengthMs = epochSettings.durationMs;
+        const currentTimestamp = Date.now();
+        return Math.floor((currentTimestamp - epochZeroStartTimestamp) / epochLengthMs);
+    }
     async computeEpochIndex(params) {
         const epochIndex = params?.epochIndex;
         if (epochIndex !== undefined) {
@@ -85,6 +77,17 @@ export class ARIOReadable {
         }));
     }
     async getEpoch(epoch) {
+        const epochIndex = await this.computeEpochIndex(epoch);
+        const currentIndex = await this.computeCurrentEpochIndex();
+        if (epochIndex !== undefined && +epochIndex < currentIndex) {
+            const epochData = await getEpochDataFromGql({
+                arweave: this.arweave,
+                epochIndex: +epochIndex,
+                processId: this.process.processId,
+            });
+            return epochData;
+        }
+        // go to the process epoch and fetch the epoch data
         const allTags = [
             { name: 'Action', value: 'Epoch' },
             { name: 'Epoch-Index', value: await this.computeEpochIndex(epoch) },
@@ -215,7 +218,19 @@ export class ARIOReadable {
             tags: pruneTags(allTags),
         });
     }
+    // we need to find the epoch index for the epoch that is currently being distributed and fetch it from gql
     async getObservations(epoch) {
+        const epochIndex = await this.computeEpochIndex(epoch);
+        const currentIndex = await this.computeCurrentEpochIndex();
+        if (epochIndex !== undefined && +epochIndex < currentIndex) {
+            const epochData = await getEpochDataFromGql({
+                arweave: this.arweave,
+                epochIndex: +epochIndex,
+                processId: this.process.processId,
+            });
+            return epochData?.observations;
+        }
+        // go to the process epoch and fetch the observations
         const allTags = [
             { name: 'Action', value: 'Epoch-Observations' },
             { name: 'Epoch-Index', value: await this.computeEpochIndex(epoch) },
@@ -225,6 +240,17 @@ export class ARIOReadable {
         });
     }
     async getDistributions(epoch) {
+        const epochIndex = await this.computeEpochIndex(epoch);
+        const currentIndex = await this.computeCurrentEpochIndex();
+        if (epochIndex !== undefined && +epochIndex < currentIndex) {
+            const epochData = await getEpochDataFromGql({
+                arweave: this.arweave,
+                epochIndex: +epochIndex,
+                processId: this.process.processId,
+            });
+            return epochData?.distributions;
+        }
+        // go to the process epoch and fetch the distributions
         const allTags = [
             { name: 'Action', value: 'Epoch-Distributions' },
             { name: 'Epoch-Index', value: await this.computeEpochIndex(epoch) },
@@ -411,33 +437,29 @@ export class ARIOReadable {
             tags: [{ name: 'Action', value: 'Gateway-Registry-Settings' }],
         });
     }
+    async getAllDelegates(params) {
+        return this.process.read({
+            tags: [
+                { name: 'Action', value: 'All-Paginated-Delegates' },
+                ...paginationParamsToTags(params),
+            ],
+        });
+    }
 }
 export class ARIOWriteable extends ARIOReadable {
     signer;
     constructor({ signer, ...config }) {
-        if (Object.keys(config).length === 0) {
+        if (config === undefined) {
             super({
                 process: new AOProcess({
                     processId: ARIO_TESTNET_PROCESS_ID,
                 }),
             });
-            this.signer = createAoSigner(signer);
-        }
-        else if (isProcessConfiguration(config)) {
-            super({ process: config.process });
-            this.signer = createAoSigner(signer);
-        }
-        else if (isProcessIdConfiguration(config)) {
-            super({
-                process: new AOProcess({
-                    processId: config.processId,
-                }),
-            });
-            this.signer = createAoSigner(signer);
         }
         else {
-            throw new InvalidContractConfigurationError();
+            super(config);
         }
+        this.signer = createAoSigner(signer);
     }
     async transfer({ target, qty, }, options) {
         const { tags = [] } = options || {};

package/lib/esm/constants.js

@@ -26,6 +26,6 @@ export const arioDevnetProcessId = ARIO_DEVNET_PROCESS_ID;
 export const ARIO_TESTNET_PROCESS_ID = 'agYcCFJtrMG6cqMuZfskIkFTGvUPddICmtQSBIoPdiA';
 export const ANT_REGISTRY_ID = 'i_le_yKKPVstLTDSmkHRqf-wYphMnwB9OhleiTgMkWc';
 export const MARIO_PER_ARIO = 1_000_000;
-export const AOS_MODULE_ID = 'cbn0KKrBZH7hdNkNokuXLtGryrWM--PjSTBqIzw9Kkk';
-export const ANT_LUA_ID = '16_FyX-V2QU0RPSh1GIaEETSaUjNb0oVjCFpVbAfQq4';
+export const AOS_MODULE_ID = 'BRyNPIJWZaQ4IudfNnsfvMrZBO2YDPjgKqg_wCYT2U8';
+export const ANT_LUA_ID = 'k9tQkbnFYZOGp6ist1yFuaqk_wOkzM5KUSNDtWzCLtg';
 export const DEFAULT_SCHEDULER_ID = '_GQ33BkPtZrqxA84vM8Zk-N2aO0toNNu_C-l-rawrBA';

package/lib/esm/utils/ao.js

@@ -13,18 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { createData } from '@dha-team/arbundles';
+import { ArconnectSigner, DataItem, createData } from '@dha-team/arbundles';
 import { connect, createDataItemSigner } from '@permaweb/aoconnect';
 import { z } from 'zod';
 import { defaultArweave } from '../common/arweave.js';
 import { ANTRegistry, AOProcess, Logger } from '../common/index.js';
 import { ANT_LUA_ID, ANT_REGISTRY_ID, AOS_MODULE_ID, DEFAULT_SCHEDULER_ID, } from '../constants.js';
-export async function spawnANT({ signer, module = AOS_MODULE_ID, luaCodeTxId = ANT_LUA_ID, ao = connect(), scheduler = DEFAULT_SCHEDULER_ID, state, stateContractTxId, antRegistryId = ANT_REGISTRY_ID, logger = Logger.default, arweave = defaultArweave, }) {
-    //TODO: cache locally and only fetch if not cached
-    const luaString = (await arweave.transactions.getData(luaCodeTxId, {
-        decode: true,
-        string: true,
-    }));
+export async function spawnANT({ signer, module = AOS_MODULE_ID, ao = connect(), scheduler = DEFAULT_SCHEDULER_ID, state, stateContractTxId, antRegistryId = ANT_REGISTRY_ID, logger = Logger.default, }) {
+    // TODO: use On-Boot data handler for bootstrapping state instead of initialize-state
     const processId = await ao.spawn({
         module,
         scheduler,
@@ -34,10 +30,6 @@ export async function spawnANT({ signer, module = AOS_MODULE_ID, luaCodeTxId = A
                 name: 'ANT-Registry-Id',
                 value: antRegistryId,
             },
-            {
-                name: 'Source-Code-TX-ID', // utility for understanding what the original source id of the lua code was
-                value: luaCodeTxId,
-            },
         ],
     });
     const aosClient = new AOProcess({
@@ -45,21 +37,10 @@ export async function spawnANT({ signer, module = AOS_MODULE_ID, luaCodeTxId = A
         ao,
         logger,
     });
-    const { id: evalId } = await aosClient.send({
-        tags: [
-            { name: 'Action', value: 'Eval' },
-            { name: 'App-Name', value: 'ArNS-ANT' },
-            { name: 'Source-Code-TX-ID', value: luaCodeTxId },
-        ],
-        data: luaString,
-        signer,
-    });
     logger.debug(`Spawned ANT`, {
         processId,
         module,
         scheduler,
-        luaCodeTxId,
-        evalId,
     });
     if (state) {
         const { id: initializeMsgId } = await aosClient.send({
@@ -79,6 +60,7 @@ export async function spawnANT({ signer, module = AOS_MODULE_ID, luaCodeTxId = A
             initializeMsgId,
         });
     }
+    // This could be done by the ANT in On-Boot to self-register with its tagged ANT registry
     const registryClient = ANTRegistry.init({
         process: new AOProcess({
             processId: antRegistryId,
@@ -165,6 +147,20 @@ export function createAoSigner(signer) {
             typeof signer.setPublicKey === 'function') {
             await signer.setPublicKey();
         }
+        if (signer instanceof ArconnectSigner) {
+            // Sign using Arconnect signDataItem API
+            const signedDataItem = await signer['signer'].signDataItem({
+                data,
+                tags,
+                target,
+                anchor,
+            });
+            const dataItem = new DataItem(Buffer.from(signedDataItem));
+            return {
+                id: await dataItem.id,
+                raw: await dataItem.getRaw(),
+            };
+        }
         const dataItem = createData(data, signer, { tags, target, anchor });
         const signedData = dataItem.sign(signer).then(async () => ({
             id: await dataItem.id,
@@ -192,3 +188,20 @@ export function initANTStateForAddress({ owner, targetId, ttlSeconds = 3600, key
         },
     };
 }
+/**
+ * Uses zod schema to parse the epoch data
+ */
+export function parseAoEpochData(value) {
+    const epochDataSchema = z.object({
+        startTimestamp: z.number(),
+        startHeight: z.number(),
+        distributions: z.any(),
+        endTimestamp: z.number(),
+        prescribedObservers: z.any(),
+        prescribedNames: z.array(z.string()),
+        observations: z.any(),
+        distributionTimestamp: z.number(),
+        epochIndex: z.number(),
+    });
+    return epochDataSchema.parse(value);
+}

package/lib/esm/utils/arweave.js

@@ -1,19 +1,5 @@
-/**
- * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { ARWEAVE_TX_REGEX } from '../constants.js';
+import { ARIO_TESTNET_PROCESS_ID, ARWEAVE_TX_REGEX } from '../constants.js';
+import { parseAoEpochData } from './ao.js';
 export const validateArweaveId = (id) => {
     return ARWEAVE_TX_REGEX.test(id);
 };
@@ -37,3 +23,50 @@ export const paginationParamsToTags = (params) => {
     ];
     return pruneTags(tags);
 };
+/**
+ * Get the epoch with distribution data for the current epoch
+ * @param arweave - The Arweave instance
+ * @returns The epoch with distribution data
+ */
+export const getEpochDataFromGql = async ({ arweave, epochIndex, processId = ARIO_TESTNET_PROCESS_ID, }) => {
+    // fetch from gql
+    const query = epochDistributionNoticeGqlQuery({ epochIndex, processId });
+    const response = await arweave.api.post('graphql', query);
+    // parse the nodes to get the id
+    if (response.data.data.transactions?.edges?.length === 0) {
+        return undefined;
+    }
+    const id = response.data.data.transactions.edges[0].node.id;
+    // fetch the transaction from arweave
+    const transaction = await arweave.api.get(id);
+    const data = transaction.data;
+    // assert it is the correct type
+    return parseAoEpochData(data);
+};
+export const epochDistributionNoticeGqlQuery = ({ epochIndex, processId = ARIO_TESTNET_PROCESS_ID, }) => {
+    // write the query
+    const gqlQuery = JSON.stringify({
+        query: `
+      query {
+        transactions(
+          tags: [
+            { name: "From-Process", values: ["${processId}"] }
+            { name: "Action", values: ["Epoch-Distribution-Notice"] }
+            { name: "Epoch-Index", values: ["${epochIndex}"] }
+            { name: "Data-Protocol", values: ["ao"] }
+          ],
+          owners: ["fcoN_xJeisVsPXA-trzVAuIiqO3ydLQxM-L4XbrQKzY"],
+          first: 1,
+          sort: HEIGHT_DESC
+        ) {
+          edges {
+            node {
+              id
+            }
+          }
+        }
+      }
+    `,
+    });
+    return gqlQuery;
+};

package/lib/esm/version.js

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

package/lib/types/cli/commands/readCommands.d.ts

@@ -21,6 +21,9 @@ export declare function getGateway(o: AddressCLIOptions): Promise<import("../../
 export declare function listGateways(o: PaginationCLIOptions): Promise<import("../../types/io.js").PaginationResult<import("../../types/io.js").AoGatewayWithAddress> | {
     message: string;
 }>;
+export declare function listAllDelegatesCLICommand(o: PaginationCLIOptions): Promise<import("../../types/io.js").PaginationResult<import("../../types/io.js").AoAllDelegates> | {
+    message: string;
+}>;
 export declare function getGatewayDelegates(o: AddressCLIOptions): Promise<import("../../types/io.js").PaginationResult<import("../../types/io.js").AoGatewayDelegateWithAddress> | {
     message: string;
 }>;

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

@@ -1,12 +1,12 @@
 import { AoANTRegistryRead, AoANTRegistryWrite } from '../types/ant-registry.js';
 import { AoMessageResult, ProcessConfiguration, WithSigner } from '../types/index.js';
 import { AOProcess } from './index.js';
+type ANTRegistryNoSigner = ProcessConfiguration;
+type ANTRegistryWithSigner = WithSigner<ProcessConfiguration>;
 export declare class ANTRegistry {
     static init(): AoANTRegistryRead;
-    static init(config: Required<ProcessConfiguration> & {
-        signer?: undefined;
-    }): AoANTRegistryRead;
-    static init({ signer, ...config }: WithSigner<Required<ProcessConfiguration>>): AoANTRegistryWrite;
+    static init(config: ANTRegistryNoSigner): AoANTRegistryRead;
+    static init(config: ANTRegistryWithSigner): AoANTRegistryWrite;
 }
 export declare class AoANTRegistryReadable implements AoANTRegistryRead {
     protected process: AOProcess;
@@ -25,3 +25,4 @@ export declare class AoANTRegistryWriteable extends AoANTRegistryReadable implem
         processId: string;
     }): Promise<AoMessageResult>;
 }
+export {};