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

package/lib/esm/common/wayfinder/wayfinder.test.js

@@ -1,27 +1,22 @@
 import axios from 'axios';
 import got from 'got';
 import assert from 'node:assert';
+import { EventEmitter } from 'node:events';
+import { Readable } from 'node:stream';
 import { buffer } from 'node:stream/consumers';
 import { before, describe, it } from 'node:test';
+import { Logger } from '../../common/logger.js';
 import { RandomGatewayRouter } from './routers/random.js';
-import { Wayfinder } from './wayfinder.js';
-const stubbedGateway = {
-    status: 'joined',
-    gatewayAddress: 'arweave',
-    operatorStake: 1000,
-    totalDelegatedStake: 1000,
-    startTimestamp: 1000,
-    settings: {
-        protocol: 'https',
-        fqdn: 'arweave.net',
-        port: 443,
-    },
-};
+import { StaticGatewayRouter } from './routers/static.js';
+import { Wayfinder, tapAndVerifyStream } from './wayfinder.js';
+// TODO: replace with locally running gateway
+const gatewayUrl = 'permagate.io';
 const stubbedGatewaysProvider = {
-    getGateways: async () => [stubbedGateway],
+    getGateways: async () => [new URL(`http://${gatewayUrl}`)],
 };
+Logger.default.setLogLevel('none');
 describe('Wayfinder', () => {
-    describe('http wrapper', () => {
+    describe.skip('http wrapper', () => {
         describe('fetch', () => {
             let wayfinder;
             before(() => {
@@ -33,7 +28,7 @@ describe('Wayfinder', () => {
                 });
             });
             it('should fetch the data using the selected gateway', async () => {
-                const nativeFetch = await fetch('https://ao.arweave.net');
+                const nativeFetch = await fetch(`https://ao.${gatewayUrl}`);
                 const response = await wayfinder.request('ar://ao');
                 assert.strictEqual(response.status, 200);
                 assert.strictEqual(response.status, nativeFetch.status);
@@ -41,44 +36,48 @@ describe('Wayfinder', () => {
                 const arnsHeaders = Array.from(response.headers.entries()).filter(([key]) => key.startsWith('x-arns-'));
                 const nativeFetchHeaders = Array.from(nativeFetch.headers.entries()).filter(([key]) => key.startsWith('x-arns-'));
                 assert.deepStrictEqual(arnsHeaders, nativeFetchHeaders);
-                assert.deepStrictEqual(await response.text(), await nativeFetch.text());
+            });
+            it('should fetch a tx id using the selected gateway', async () => {
+                const nativeFetch = await fetch(`https://${gatewayUrl}/KKmRbIfrc7wiLcG0zvY1etlO0NBx1926dSCksxCIN3A`, 
+                // follow redirects
+                { redirect: 'follow' });
+                const response = await wayfinder.request('ar://KKmRbIfrc7wiLcG0zvY1etlO0NBx1926dSCksxCIN3A', { redirect: 'follow' });
+                assert.strictEqual(response.status, 200);
+                assert.strictEqual(response.status, nativeFetch.status);
             });
             it('should route a non-ar:// url as a normal fetch', async () => {
                 const [nativeFetch, response] = await Promise.all([
-                    fetch('https://arweave.net/', {
+                    fetch(`https://${gatewayUrl}/`, {
                         method: 'HEAD',
                     }),
-                    wayfinder.request('https://arweave.net/', {
+                    wayfinder.request(`https://${gatewayUrl}/`, {
                         method: 'HEAD',
                     }),
                 ]);
                 assert.strictEqual(response.status, 200);
                 assert.strictEqual(response.status, nativeFetch.status);
                 // TODO: ensure the headers are the same excluding unique headers
-                assert.deepStrictEqual(await response.text(), await nativeFetch.text());
             });
-            for (const api of ['/info', '/metrics', '/block/current']) {
+            for (const api of ['/info', '/block/current']) {
                 it(`supports native arweave node apis ${api}`, async () => {
                     const [nativeFetch, response] = await Promise.all([
-                        fetch(`https://arweave.net${api}`),
-                        wayfinder.request(`ar:///${api}`),
+                        fetch(`https://${gatewayUrl}${api}`),
+                        wayfinder.request(`ar://${api}`),
                     ]);
                     assert.strictEqual(response.status, 200);
                     assert.strictEqual(response.status, nativeFetch.status);
                     // TODO: ensure the headers are the same excluding unique headers
-                    assert.deepStrictEqual(await response.text(), await nativeFetch.text());
                 });
             }
-            for (const api of ['/ar-io/info', '/ar-io/__gateway_metrics']) {
+            for (const api of ['/ar-io/info']) {
                 it(`supports native ario node gateway apis ${api}`, async () => {
                     const [nativeFetch, response] = await Promise.all([
-                        fetch(`https://arweave.net${api}`),
+                        fetch(`https://${gatewayUrl}${api}`),
                         wayfinder.request(`ar:///${api}`),
                     ]);
                     assert.strictEqual(response.status, 200);
                     assert.strictEqual(response.status, nativeFetch.status);
                     // TODO: ensure the headers are the same excluding unique headers
-                    assert.deepStrictEqual(await response.text(), await nativeFetch.text());
                 });
             }
             it('supports a post request to graphql', async () => {
@@ -117,14 +116,13 @@ describe('Wayfinder', () => {
                 });
                 assert.strictEqual(response.status, 200);
             });
-            it('returns the error from the target gateway if the route is not found', async () => {
+            it.skip('returns the error from the target gateway if the route is not found', async () => {
                 const [nativeFetch, response] = await Promise.all([
-                    fetch('https://arweave.net/not-found'),
-                    wayfinder.request('https://arweave.net/not-found'),
+                    fetch(`https://${gatewayUrl}/ar-io/not-found`),
+                    wayfinder.request('ar:///not-found'),
                 ]);
                 assert.strictEqual(response.status, nativeFetch.status);
                 assert.strictEqual(response.statusText, nativeFetch.statusText);
-                assert.deepStrictEqual(await response.text(), await nativeFetch.text());
             });
         });
         describe('axios', () => {
@@ -139,7 +137,7 @@ describe('Wayfinder', () => {
             });
             it('should fetch the data using axios default function against the target gateway', async () => {
                 const [nativeAxios, response] = await Promise.all([
-                    axios('https://ao.arweave.net'),
+                    axios(`https://ao.${gatewayUrl}`),
                     wayfinder.request('ar://ao'),
                 ]);
                 assert.strictEqual(response.status, 200);
@@ -150,11 +148,10 @@ describe('Wayfinder', () => {
                     .filter(([key]) => key.startsWith('x-arns-'));
                 const nativeAxiosHeaders = Object.entries(nativeAxios.headers).filter(([key]) => key.startsWith('x-arns-'));
                 assert.deepStrictEqual(arnsHeaders.sort(), nativeAxiosHeaders.sort());
-                assert.deepStrictEqual(response.data, nativeAxios.data);
             });
             it('should fetch the data using the axios.get method against the target gateway', async () => {
                 const [nativeAxios, response] = await Promise.all([
-                    axios.get('https://ao.arweave.net'),
+                    axios.get(`https://ao.${gatewayUrl}`),
                     wayfinder.request.get('ar://ao'),
                 ]);
                 assert.strictEqual(response.status, 200);
@@ -165,43 +162,39 @@ describe('Wayfinder', () => {
                     .filter(([key]) => key.startsWith('x-arns-'));
                 const nativeAxiosHeaders = Object.entries(nativeAxios.headers).filter(([key]) => key.startsWith('x-arns-'));
                 assert.deepStrictEqual(arnsHeaders.sort(), nativeAxiosHeaders.sort());
-                assert.deepStrictEqual(response.data, nativeAxios.data);
             });
             it('should route a non-ar:// url as a normal axios request', async () => {
                 const [nativeAxios, response] = await Promise.all([
-                    axios('https://arweave.net/'),
-                    wayfinder.request('https://arweave.net/'),
+                    axios(`https://${gatewayUrl}/`),
+                    wayfinder.request(`https://${gatewayUrl}/`),
                 ]);
                 assert.strictEqual(response.status, 200);
                 assert.strictEqual(response.status, nativeAxios.status);
-                assert.deepStrictEqual(response.data, nativeAxios.data);
                 // TODO: ensure the headers are the same excluding unique headers
             });
-            for (const api of ['/info', '/metrics', '/block/current']) {
+            for (const api of ['/info', '/block/current']) {
                 it(`supports native arweave node apis ${api}`, async () => {
                     const [nativeAxios, response] = await Promise.all([
-                        axios(`https://arweave.net${api}`),
-                        wayfinder.request(`ar:///${api}`),
+                        axios(`https://${gatewayUrl}${api}`),
+                        wayfinder.request(`ar://${api}`),
                     ]);
                     assert.strictEqual(response.status, 200);
                     assert.strictEqual(response.status, nativeAxios.status);
                     // TODO: ensure the headers are the same excluding unique headers
-                    assert.deepStrictEqual(response.data, nativeAxios.data);
                 });
             }
             for (const api of ['/ar-io/info', '/ar-io/__gateway_metrics']) {
                 it(`supports native ario node gateway apis ${api}`, async () => {
                     const [nativeAxios, response] = await Promise.all([
-                        axios(`https://arweave.net${api}`),
+                        axios(`https://${gatewayUrl}${api}`),
                         wayfinder.request(`ar:///${api}`),
                     ]);
                     assert.strictEqual(response.status, 200);
                     assert.strictEqual(response.status, nativeAxios.status);
                     // TODO: ensure the headers are the same excluding unique headers
-                    assert.deepStrictEqual(response.data, nativeAxios.data);
                 });
             }
-            it('should return the error from the target gateway if the route is not found', async () => {
+            it.skip('should return the error from the target gateway if the route is not found', async () => {
                 const axiosInstance = axios.create({
                     validateStatus: () => true, // don't throw so we can compare axios result with wrapped axios result
                 });
@@ -212,11 +205,10 @@ describe('Wayfinder', () => {
                     }),
                 });
                 const [nativeAxios, response] = await Promise.all([
-                    axiosInstance('https://arweave.net/not-found'),
-                    wayfinder.request('https://arweave.net/not-found'),
+                    axiosInstance(`https://${gatewayUrl}/ar-io/not-found`),
+                    wayfinder.request('ar:///not-found'),
                 ]);
                 assert.strictEqual(response.status, nativeAxios.status);
-                assert.strictEqual(response.data, nativeAxios.data);
             });
         });
         describe('got', () => {
@@ -231,7 +223,7 @@ describe('Wayfinder', () => {
             });
             it('should fetch the data using the got default function against the target gateway', async () => {
                 const [nativeGot, response] = await Promise.all([
-                    got('https://ao.arweave.net'),
+                    got(`https://ao.${gatewayUrl}`),
                     wayfinder.request('ar://ao'),
                 ]);
                 assert.strictEqual(response.statusCode, 200);
@@ -239,10 +231,265 @@ describe('Wayfinder', () => {
                 assert.deepStrictEqual(response.body, nativeGot.body);
             });
             it('should stream the data using got.stream against the selected target gateway', async () => {
-                const nativeBuffer = await buffer(await got.stream('https://ao.arweave.net', { decompress: false }));
+                const nativeBuffer = await buffer(await got.stream(`https://ao.${gatewayUrl}`, { decompress: false }));
                 const wayfinderBuffer = await buffer(await wayfinder.request.stream('ar://ao', { decompress: false }));
                 assert.deepStrictEqual(wayfinderBuffer, nativeBuffer);
             });
         });
     });
+    describe('events', () => {
+        it('should emit events on the wayfinder event emitter', async () => {
+            const wayfinder = new Wayfinder({
+                httpClient: fetch,
+                router: new StaticGatewayRouter({
+                    gateway: `http://${gatewayUrl}`,
+                }),
+                verifier: {
+                    // @ts-expect-error
+                    verifyData: async (params) => {
+                        return;
+                    },
+                },
+            });
+            const events = [];
+            wayfinder.emitter.on('verification-failed', (event) => {
+                events.push({ type: 'verification-failed', ...event });
+            });
+            wayfinder.emitter.on('verification-progress', (event) => {
+                events.push({ type: 'verification-progress', ...event });
+            });
+            wayfinder.emitter.on('verification-passed', (event) => {
+                events.push({ type: 'verification-passed', ...event });
+            });
+            // request data and assert the event is emitted
+            const response = await wayfinder.request('ar://c7wkwt6TKgcWJUfgvpJ5q5qi4DIZyJ1_TqhjXgURh0U', {
+                redirect: 'follow',
+            });
+            // read the full response body to ensure the stream is fully consumed
+            await response.text();
+            assert.strictEqual(response.status, 200);
+            assert.ok(events.find((e) => e.type === 'verification-passed'), 'Should emit at least one verification-passed');
+        });
+        it('should execute callbacks provided to the wayfinder constructor', async () => {
+            let verificationFailed = false;
+            let verificationProgress = false;
+            let verificationPassed = false;
+            const wayfinder = new Wayfinder({
+                httpClient: fetch,
+                router: new StaticGatewayRouter({
+                    gateway: `http://${gatewayUrl}`,
+                }),
+                events: {
+                    onVerificationFailed: () => {
+                        verificationFailed = true;
+                    },
+                    onVerificationProgress: () => {
+                        verificationProgress = true;
+                    },
+                    onVerificationPassed: () => {
+                        verificationPassed = true;
+                    },
+                },
+            });
+            const response = await wayfinder.request('ar://c7wkwt6TKgcWJUfgvpJ5q5qi4DIZyJ1_TqhjXgURh0U', {
+                redirect: 'follow',
+            });
+            // read the full response body to ensure the stream is fully consumed
+            await response.text();
+            assert.strictEqual(response.status, 200);
+            assert.ok(verificationFailed === false, 'Should not emit verification-failed');
+            assert.ok(verificationProgress, 'Should emit verification-progress');
+            assert.ok(verificationPassed, 'Should emit verification-passed');
+        });
+    });
+    describe.skip('tapAndVerifyRequest', () => {
+        describe('Readable', () => {
+            it('should duplicate the stream, verify the first and return the second if verification passes', async () => {
+                // create a simple readable
+                const chunks = [
+                    Buffer.from('foo'),
+                    Buffer.from('bar'),
+                    Buffer.from('baz'),
+                ];
+                const contentLength = chunks.reduce((sum, c) => sum + c.length, 0);
+                // a stream that will emit chunks
+                const originalStream = Readable.from(chunks);
+                let seen = Buffer.alloc(0);
+                const verifyData = async ({ data, 
+                // @ts-expect-error
+                txId, }) => {
+                    return new Promise((resolve, reject) => {
+                        data.on('data', (chunk) => {
+                            seen = Buffer.concat([seen, chunk]);
+                        });
+                        data.on('end', () => {
+                            // Should have seen exactly the full payload
+                            assert.strictEqual(seen.length, contentLength);
+                            resolve();
+                        });
+                        data.on('error', reject);
+                    });
+                };
+                const txId = 'test-tx-1';
+                const emitter = new EventEmitter();
+                const events = [];
+                emitter.on('verification-progress', (e) => {
+                    console.log('verification-progress', e);
+                    events.push({ type: 'verification-progress', ...e });
+                });
+                emitter.on('verification-passed', (e) => events.push({ type: 'verification-passed', ...e }));
+                // tap with verification
+                const tapped = tapAndVerifyStream({
+                    originalStream,
+                    contentLength,
+                    verifyData,
+                    txId,
+                    emitter,
+                });
+                // read the stream
+                const out = [];
+                for await (const chunk of tapped) {
+                    out.push(chunk);
+                }
+                // assert the stream is the same
+                assert.strictEqual(Buffer.concat(out).toString(), Buffer.concat(chunks).toString(), 'The tapped stream should emit exactly the original data');
+                assert.ok(events.find((e) => e.type === 'verification-progress'), 'Should emit at least one verification-progress');
+                assert.ok(events.find((e) => e.type === 'verification-passed' && e.txId === txId), 'Should emit at least one verification-passed');
+            });
+            it('should throw an error on the client stream if verification fails', async () => {
+                const chunks = [
+                    Buffer.from('foo'),
+                    Buffer.from('bar'),
+                    Buffer.from('baz'),
+                ];
+                const contentLength = chunks.reduce((sum, c) => sum + c.length, 0);
+                // a stream that will emit chunks
+                const originalStream = Readable.from(chunks);
+                const verifyData = async ({ 
+                // @ts-expect-error
+                data, txId, }) => {
+                    throw new Error('Verification failed for txId: ' + txId);
+                };
+                const txId = 'test-tx-1';
+                const emitter = new EventEmitter();
+                const events = [];
+                emitter.on('verification-progress', (e) => events.push({ type: 'verification-progress', ...e }));
+                emitter.on('verification-failed', (e) => events.push({ type: 'verification-failed', ...e }));
+                // tap with verification
+                const tapped = tapAndVerifyStream({
+                    originalStream,
+                    contentLength,
+                    verifyData,
+                    txId,
+                    emitter,
+                });
+                // read the stream
+                try {
+                    const out = [];
+                    for await (const chunk of tapped) {
+                        out.push(chunk);
+                    }
+                }
+                catch (error) {
+                    assert.ok(events.find((e) => e.type === 'verification-failed' && e.txId === txId), 'Should emit at least one verification-failed');
+                    // stream should be closed
+                    assert.ok(tapped.closed);
+                }
+            });
+        });
+        describe('ReadableStream', () => {
+            it('should duplicate the ReadableStream, verify the first and return the second if verification passes', async () => {
+                // create a simple readable
+                const chunks = [
+                    Buffer.from('foo'),
+                    Buffer.from('bar'),
+                    Buffer.from('baz'),
+                ];
+                const contentLength = chunks.reduce((sum, c) => sum + c.length, 0);
+                // a stream that will emit chunks
+                const originalStream = ReadableStream.from(chunks);
+                let seen = Buffer.alloc(0);
+                const verifyData = async ({ data, 
+                // @ts-expect-error
+                txId, }) => {
+                    return new Promise(async (resolve, reject) => {
+                        const reader = data.getReader();
+                        while (true) {
+                            try {
+                                const { done, value } = await reader.read();
+                                if (done) {
+                                    resolve();
+                                    break;
+                                }
+                                seen = Buffer.concat([seen, value]);
+                            }
+                            catch (error) {
+                                reject(error);
+                            }
+                        }
+                    });
+                };
+                const txId = 'test-tx-1';
+                const emitter = new EventEmitter();
+                const events = [];
+                emitter.on('verification-progress', (e) => events.push({ type: 'verification-progress', ...e }));
+                emitter.on('verification-passed', (e) => events.push({ type: 'verification-passed', ...e }));
+                // tap with verification
+                const tapped = tapAndVerifyStream({
+                    originalStream,
+                    contentLength,
+                    verifyData,
+                    txId,
+                    emitter,
+                });
+                // read the stream
+                const out = [];
+                for await (const chunk of tapped) {
+                    out.push(chunk);
+                }
+                // assert the stream is the same
+                assert.strictEqual(Buffer.concat(out).toString(), Buffer.concat(chunks).toString(), 'The tapped stream should emit exactly the original data');
+                assert.ok(events.find((e) => e.type === 'verification-progress'), 'Should emit at least one verification-progress');
+                assert.ok(events.find((e) => e.type === 'verification-passed' && e.txId === txId), 'Should emit at least one verification-passed');
+            });
+            it('should throw an error on the client stream if verification fails', async () => {
+                const chunks = [
+                    Buffer.from('foo'),
+                    Buffer.from('bar'),
+                    Buffer.from('baz'),
+                ];
+                const contentLength = chunks.reduce((sum, c) => sum + c.length, 0);
+                // a stream that will emit chunks
+                const originalStream = ReadableStream.from(chunks);
+                const verifyData = async ({ 
+                // @ts-expect-error
+                data, txId, }) => {
+                    throw new Error('Verification failed for txId: ' + txId);
+                };
+                const txId = 'test-tx-1';
+                const emitter = new EventEmitter();
+                const events = [];
+                emitter.on('verification-progress', (e) => events.push({ type: 'verification-progress', ...e }));
+                emitter.on('verification-failed', (e) => events.push({ type: 'verification-failed', ...e }));
+                // tap with verification
+                const tapped = tapAndVerifyStream({
+                    originalStream,
+                    contentLength,
+                    verifyData,
+                    txId,
+                    emitter,
+                });
+                // read the stream
+                try {
+                    const out = [];
+                    for await (const chunk of tapped) {
+                        out.push(chunk);
+                    }
+                }
+                catch (error) {
+                    assert.ok(events.find((e) => e.type === 'verification-failed' && e.txId === txId), 'Should emit at least one verification-failed');
+                }
+            });
+        });
+    });
 });

package/lib/esm/types/wayfinder.js

@@ -1 +1,2 @@
 export {};
+// TODO: add an offset provider that returns offsets for data items so we can use them to verify the signatures of a data item within a bundle

package/lib/esm/utils/ao.js

@@ -43,6 +43,43 @@ export async function spawnANT({ signer, module = AOS_MODULE_ID, ao = connect(),
             },
         ],
     });
+    let bootRes;
+    let attempts = 0;
+    while (attempts < 5 && bootRes === undefined) {
+        try {
+            bootRes = await ao.result({
+                process: processId,
+                message: processId,
+            });
+            break;
+        }
+        catch (error) {
+            logger.debug('Retrying ANT boot result fetch', {
+                processId,
+                module,
+                scheduler,
+                attempts,
+                error,
+            });
+            attempts++;
+            await new Promise((resolve) => setTimeout(resolve, 1000 * attempts ** 2));
+        }
+    }
+    if (bootRes === undefined ||
+        bootRes.Messages.find((m) => m.Tags.find((t) => t.value === 'Invalid-Boot-Notice'))) {
+        if (bootRes === undefined) {
+            throw new Error('Failed to get boot result');
+        }
+        const bootError = errorMessageFromOutput(bootRes);
+        logger.error('ANT failed to boot correctly', {
+            processId,
+            module,
+            scheduler,
+            bootRes,
+            bootError,
+        });
+        throw new Error(`ANT failed to boot correctly: ${bootError}`);
+    }
     logger.debug(`Spawned ANT`, {
         processId,
         module,

package/lib/esm/utils/arweave.js

@@ -107,7 +107,7 @@ export const getEpochDataFromGqlFallback = async ({ ao, epochIndex, processId =
         if (!messageResult) {
             continue;
         }
-        for (const message of messageResult.Messages) {
+        for (const message of messageResult?.Messages ?? []) {
             const data = JSON.parse(message.Data);
             const tags = message.Tags;
             // check if the message results include epoch-distribution-notice for the requested epoch index

package/lib/esm/utils/hash.js

@@ -0,0 +1,50 @@
+/**
+ * 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 { createHash } from 'crypto';
+import { toB64Url } from './base64.js';
+export const hashReadableToB64Url = (stream, algorithm = 'sha256') => {
+    return new Promise((resolve, reject) => {
+        const hash = createHash(algorithm);
+        stream.on('data', (chunk) => hash.update(chunk));
+        stream.on('end', () => resolve(toB64Url(hash.digest())));
+        stream.on('error', (err) => reject(err));
+    });
+};
+export const hashReadableStreamToB64Url = (stream, algorithm = 'sha256') => {
+    return new Promise((resolve, reject) => {
+        const hash = createHash(algorithm);
+        const reader = stream.getReader();
+        const read = async () => {
+            try {
+                const { done, value } = await reader.read();
+                if (done) {
+                    resolve(toB64Url(hash.digest()));
+                }
+                else {
+                    hash.update(value);
+                    read();
+                }
+            }
+            catch (err) {
+                reject(err);
+            }
+        };
+        read().catch(reject);
+    });
+};
+export const hashBufferToB64Url = (buffer, algorithm = 'sha256') => {
+    return toB64Url(createHash(algorithm).update(buffer).digest());
+};

package/lib/esm/version.js

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

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

@@ -68,3 +68,4 @@ export declare function getAllGatewayVaults(o: PaginationCLIOptions): Promise<im
     message: string;
 }>;
 export declare function getVault(o: AddressAndVaultIdCLIOptions): Promise<import("../../types/io.js").AoVaultData>;
+export declare function resolveArNSName(o: NameCLIOptions): Promise<import("../../types/io.js").ArNSNameResolutionData>;

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

@@ -1,5 +1,5 @@
 import Arweave from 'arweave';
-import { ARIOWithFaucet, AoARIORead, AoARIOWrite, AoAllDelegates, AoAllGatewayVaults, AoArNSNameData, AoArNSNameDataWithName, AoArNSPurchaseParams, AoArNSReservedNameData, AoArNSReservedNameDataWithName, AoBalanceWithAddress, AoBuyRecordParams, AoCreateVaultParams, AoDelegation, AoEligibleDistribution, AoEpochData, AoEpochDistributed, AoEpochDistributionData, AoEpochDistributionTotalsData, AoEpochObservationData, AoEpochSettings, AoExtendLeaseParams, AoExtendVaultParams, AoGateway, AoGatewayDelegateWithAddress, AoGatewayRegistrySettings, AoGatewayVault, AoGatewayWithAddress, AoGetCostDetailsParams, AoIncreaseUndernameLimitParams, AoIncreaseVaultParams, AoJoinNetworkParams, AoMessageResult, AoPaginatedAddressParams, AoPrimaryName, AoPrimaryNameRequest, AoRedelegationFeeInfo, AoRegistrationFees, AoReturnedName, AoRevokeVaultParams, AoTokenSupplyData, AoUpdateGatewaySettingsParams, AoVaultData, AoVaultedTransferParams, AoWalletVault, AoWeightedObserver, CostDetailsResult, DemandFactorSettings, EpochInput, OptionalArweave, OptionalPaymentUrl, PaginationParams, PaginationResult, ProcessConfiguration, TransactionId, WalletAddress, WithSigner, WriteOptions, mARIOToken } from '../types/index.js';
+import { ARIOWithFaucet, AoARIORead, AoARIOWrite, AoAllDelegates, AoAllGatewayVaults, AoArNSNameData, AoArNSNameDataWithName, AoArNSPurchaseParams, AoArNSReservedNameData, AoArNSReservedNameDataWithName, AoBalanceWithAddress, AoBuyRecordParams, AoCreateVaultParams, AoDelegation, AoEligibleDistribution, AoEpochData, AoEpochDistributed, AoEpochDistributionData, AoEpochDistributionTotalsData, AoEpochObservationData, AoEpochSettings, AoExtendLeaseParams, AoExtendVaultParams, AoGateway, AoGatewayDelegateWithAddress, AoGatewayRegistrySettings, AoGatewayVault, AoGatewayWithAddress, AoGetCostDetailsParams, AoIncreaseUndernameLimitParams, AoIncreaseVaultParams, AoJoinNetworkParams, AoMessageResult, AoPaginatedAddressParams, AoPrimaryName, AoPrimaryNameRequest, AoRedelegationFeeInfo, AoRegistrationFees, AoReturnedName, AoRevokeVaultParams, AoTokenSupplyData, AoUpdateGatewaySettingsParams, AoVaultData, AoVaultedTransferParams, AoWalletVault, AoWeightedObserver, ArNSNameResolutionData, ArNSNameResolver, CostDetailsResult, DemandFactorSettings, EpochInput, OptionalArweave, OptionalPaymentUrl, PaginationParams, PaginationResult, ProcessConfiguration, TransactionId, WalletAddress, WithSigner, WriteOptions, mARIOToken } from '../types/index.js';
 import { AOProcess } from './contracts/ao-process.js';
 import { TurboArNSPaymentProviderAuthenticated, TurboArNSPaymentProviderUnauthenticated } from './turbo.js';
 type ARIOConfigNoSigner = OptionalPaymentUrl<OptionalArweave<ProcessConfiguration>>;
@@ -9,12 +9,8 @@ export declare class ARIO {
     static init(config: ARIOConfigWithSigner): AoARIOWrite;
     static init(config: ARIOConfigNoSigner): AoARIORead;
     static mainnet(): AoARIORead;
-    static mainnet(config: ARIOConfigNoSigner & {
-        faucetUrl?: string;
-    }): AoARIORead;
-    static mainnet(config: ARIOConfigWithSigner & {
-        faucetUrl?: string;
-    }): AoARIOWrite;
+    static mainnet(config: ARIOConfigNoSigner): AoARIORead;
+    static mainnet(config: ARIOConfigWithSigner): AoARIOWrite;
     static testnet(): ARIOWithFaucet<AoARIORead>;
     static testnet(config: ARIOConfigNoSigner & {
         faucetUrl?: string;
@@ -23,7 +19,7 @@ export declare class ARIO {
         faucetUrl?: string;
     }): ARIOWithFaucet<AoARIOWrite>;
 }
-export declare class ARIOReadable implements AoARIORead {
+export declare class ARIOReadable implements AoARIORead, ArNSNameResolver {
     readonly process: AOProcess;
     protected epochSettings: AoEpochSettings | undefined;
     protected arweave: Arweave;
@@ -139,6 +135,9 @@ export declare class ARIOReadable implements AoARIORead {
     getGatewayRegistrySettings(): Promise<AoGatewayRegistrySettings>;
     getAllDelegates(params?: PaginationParams<AoAllDelegates>): Promise<PaginationResult<AoAllDelegates>>;
     getAllGatewayVaults(params?: PaginationParams<AoAllGatewayVaults>): Promise<PaginationResult<AoAllGatewayVaults>>;
+    resolveArNSName({ name, }: {
+        name: string;
+    }): Promise<ArNSNameResolutionData>;
 }
 export declare class ARIOWriteable extends ARIOReadable implements AoARIOWrite {
     private signer;