@ar.io/sdk 3.11.0-alpha.5 → 3.11.0-alpha.7

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

@@ -1,7 +1,15 @@
-export class ARIOGatewaysProvider {
+export class NetworkGatewaysProvider {
     ario;
-    constructor({ ario }) {
+    sortBy;
+    sortOrder;
+    limit;
+    filter;
+    constructor({ ario, sortBy = 'operatorStake', sortOrder = 'desc', limit = 1000, filter = (g) => g.status === 'joined', }) {
         this.ario = ario;
+        this.sortBy = sortBy;
+        this.sortOrder = sortOrder;
+        this.limit = limit;
+        this.filter = filter;
     }
     async getGateways() {
         let cursor;
@@ -9,9 +17,11 @@ export class ARIOGatewaysProvider {
         const gateways = [];
         do {
             try {
-                const { items: newGateways, nextCursor } = await this.ario.getGateways({
+                const { items: newGateways = [], nextCursor } = await this.ario.getGateways({
                     limit: 1000,
                     cursor,
+                    sortBy: this.sortBy,
+                    sortOrder: this.sortOrder,
                 });
                 gateways.push(...newGateways);
                 cursor = nextCursor;
@@ -27,13 +37,14 @@ export class ARIOGatewaysProvider {
             }
         } while (cursor !== undefined && attempts < 3);
         // filter out any gateways that are not joined
-        return gateways.filter((g) => g.status === 'joined');
+        const filteredGateways = gateways.filter(this.filter).slice(0, this.limit);
+        return filteredGateways.map((g) => new URL(`${g.settings.protocol}://${g.settings.fqdn}:${g.settings.port}`));
     }
 }
 export class StaticGatewaysProvider {
     gateways;
     constructor({ gateways }) {
-        this.gateways = gateways;
+        this.gateways = gateways.map((g) => new URL(g));
     }
     async getGateways() {
         return this.gateways;
@@ -57,7 +68,7 @@ export class SimpleCacheGatewaysProvider {
             try {
                 // preserve the cache if the fetch fails
                 const allGateways = await this.gatewaysProvider.getGateways();
-                this.gatewaysCache = allGateways.filter((g) => g.status === 'joined');
+                this.gatewaysCache = allGateways;
                 this.lastUpdated = now;
             }
             catch (error) {

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

@@ -17,6 +17,6 @@ export * from './wayfinder.js';
 // routers
 export * from './routers/random.js';
 export * from './routers/priority.js';
-export * from './routers/fixed.js';
+export * from './routers/static.js';
 // gateways providers
 export * from './gateways.js';

package/lib/esm/common/wayfinder/routers/priority.js

@@ -1,34 +1,25 @@
 import { randomInt } from '../../../utils/random.js';
+import { NetworkGatewaysProvider } from '../gateways.js';
 // TODO: one of N where N are in the last time window have met certain performance thresholds
 // TODO: look at bitorrent routing protocols for inspiration
 // TODO: router that looks at local stats/metrics and adjusts based on those
 export class PriorityGatewayRouter {
     name = 'priority';
     gatewaysProvider;
-    limit;
-    sortBy;
-    sortOrder;
-    blocklist;
-    constructor({ gatewaysProvider, limit = 1, sortBy = 'operatorStake', sortOrder = 'desc', blocklist = [], }) {
-        this.gatewaysProvider = gatewaysProvider;
-        this.limit = limit;
-        this.sortBy = sortBy;
-        this.sortOrder = sortOrder;
-        this.blocklist = blocklist;
+    constructor({ ario, sortBy, sortOrder, limit, }) {
+        this.gatewaysProvider = new NetworkGatewaysProvider({
+            ario,
+            sortBy,
+            sortOrder,
+            limit,
+        });
     }
     async getTargetGateway() {
-        const allGateways = await this.gatewaysProvider.getGateways();
-        const gateways = allGateways.filter((gateway) => gateway.status === 'joined' &&
-            !this.blocklist.includes(gateway.settings.fqdn));
-        const sortedGateways = gateways
-            .sort(this.sortOrder === 'asc'
-            ? (a, b) => a[this.sortBy] - b[this.sortBy]
-            : (a, b) => b[this.sortBy] - a[this.sortBy])
-            .slice(0, this.limit);
-        const targetGateway = sortedGateways[randomInt(0, sortedGateways.length)];
+        const gateways = await this.gatewaysProvider.getGateways();
+        const targetGateway = gateways[randomInt(0, gateways.length)];
         if (targetGateway === undefined) {
             throw new Error('No target gateway found');
         }
-        return new URL(`${targetGateway.settings.protocol}://${targetGateway.settings.fqdn}:${targetGateway.settings.port}`);
+        return targetGateway;
     }
 }

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

@@ -127,13 +127,13 @@ describe('PriorityRouter', () => {
             },
         },
     ];
-    const mockGatewaysProvider = {
-        getGateways: async () => mockGateways,
+    const mockArIOClient = {
+        getGateways: async () => ({ items: mockGateways }),
     };
     it('should prioritize gateway with highest success rate when using successRate weight', async () => {
         const router = new PriorityGatewayRouter({
-            gatewaysProvider: mockGatewaysProvider,
-            sortBy: 'totalDelegatedStake',
+            ario: mockArIOClient,
+            sortBy: 'operatorStake',
             sortOrder: 'desc',
             limit: 1,
         });
@@ -142,7 +142,7 @@ describe('PriorityRouter', () => {
     });
     it('should prioritize gateway with lowest latency when using latency weight', async () => {
         const router = new PriorityGatewayRouter({
-            gatewaysProvider: mockGatewaysProvider,
+            ario: mockArIOClient,
             sortBy: 'operatorStake',
             sortOrder: 'desc',
             limit: 1,

package/lib/esm/common/wayfinder/routers/random.js

@@ -9,11 +9,11 @@ export class RandomGatewayRouter {
     }
     async getTargetGateway() {
         const allGateways = await this.gatewaysProvider.getGateways();
-        const gateways = allGateways.filter((g) => g.status === 'joined' && !this.blocklist.includes(g.settings.fqdn));
+        const gateways = allGateways.filter((g) => !this.blocklist.includes(g.hostname));
         const targetGateway = gateways[randomInt(0, gateways.length)];
         if (targetGateway === undefined) {
             throw new Error('No target gateway found');
         }
-        return new URL(`${targetGateway.settings.protocol}://${targetGateway.settings.fqdn}:${targetGateway.settings.port}`);
+        return targetGateway;
     }
 }

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

@@ -3,88 +3,9 @@ import { describe, it } from 'node:test';
 import { RandomGatewayRouter } from './random.js';
 describe('RandomRouter', () => {
     const mockGateways = [
-        {
-            settings: {
-                fqdn: 'gateway1.net',
-                port: 443,
-                protocol: 'https',
-                allowDelegatedStaking: false,
-                delegateRewardShareRatio: 0.5,
-                allowedDelegates: [],
-                minDelegatedStake: 0,
-                autoStake: false,
-                properties: '',
-                label: '',
-                note: '',
-            },
-            gatewayAddress: 'addr1',
-            observerAddress: 'addr1',
-            totalDelegatedStake: 1000,
-            startTimestamp: 0,
-            endTimestamp: 0,
-            operatorStake: 100,
-            status: 'joined',
-            weights: {
-                normalizedCompositeWeight: 0.5,
-                stakeWeight: 0.5,
-                tenureWeight: 0.5,
-                gatewayPerformanceRatio: 0.5,
-                observerPerformanceRatio: 0.5,
-                compositeWeight: 0.5,
-                gatewayRewardRatioWeight: 0.5,
-                observerRewardRatioWeight: 0.5,
-            },
-            stats: {
-                passedConsecutiveEpochs: 10,
-                failedConsecutiveEpochs: 5,
-                totalEpochCount: 15,
-                passedEpochCount: 10,
-                failedEpochCount: 5,
-                observedEpochCount: 15,
-                prescribedEpochCount: 20,
-            },
-        },
-        {
-            settings: {
-                fqdn: 'gateway2.net',
-                port: 443,
-                protocol: 'https',
-                allowDelegatedStaking: false,
-                delegateRewardShareRatio: 0.5,
-                allowedDelegates: [],
-                minDelegatedStake: 0,
-                autoStake: false,
-                properties: '',
-                label: '',
-                note: '',
-            },
-            gatewayAddress: 'addr2',
-            observerAddress: 'addr2',
-            totalDelegatedStake: 0,
-            startTimestamp: 0,
-            endTimestamp: 0,
-            operatorStake: 0,
-            status: 'leaving',
-            weights: {
-                normalizedCompositeWeight: 0.5,
-                stakeWeight: 0.5,
-                tenureWeight: 0.5,
-                gatewayPerformanceRatio: 0.5,
-                observerPerformanceRatio: 0.5,
-                compositeWeight: 0.5,
-                gatewayRewardRatioWeight: 0.5,
-                observerRewardRatioWeight: 0.5,
-            },
-            stats: {
-                passedConsecutiveEpochs: 10,
-                failedConsecutiveEpochs: 5,
-                totalEpochCount: 15,
-                passedEpochCount: 10,
-                failedEpochCount: 5,
-                observedEpochCount: 15,
-                prescribedEpochCount: 20,
-            },
-        },
+        new URL('https://gateway1.net'),
+        new URL('https://gateway2.net'),
+        new URL('https://gateway3.net'),
     ];
     const mockGatewaysProvider = {
         getGateways: async () => mockGateways,
@@ -93,10 +14,10 @@ describe('RandomRouter', () => {
         const router = new RandomGatewayRouter({
             gatewaysProvider: mockGatewaysProvider,
         });
-        // Run multiple times to ensure we only get joined gateways
+        // random gateway should be one of the mock gateways
         for (let i = 0; i < 10; i++) {
             const result = await router.getTargetGateway();
-            assert.deepStrictEqual(result, new URL('https://gateway1.net'));
+            assert.ok(mockGateways.includes(result));
         }
     });
 });

package/lib/esm/common/wayfinder/routers/{fixed.js → static.js}

@@ -1,8 +1,8 @@
-export class FixedGatewayRouter {
-    name = 'fixed';
+export class StaticGatewayRouter {
+    name = 'static';
     gateway;
     constructor({ gateway }) {
-        this.gateway = gateway;
+        this.gateway = new URL(gateway);
     }
     async getTargetGateway() {
         return this.gateway;

package/lib/esm/common/wayfinder/routers/{fixed.test.js → static.test.js}

@@ -1,10 +1,10 @@
 import { strict as assert } from 'node:assert';
 import { describe, it } from 'node:test';
-import { FixedGatewayRouter } from './fixed.js';
-describe('FixedRouter', () => {
+import { StaticGatewayRouter } from './static.js';
+describe('StaticGatewayRouter', () => {
     it('should return the provided gateway', async () => {
-        const router = new FixedGatewayRouter({
-            gateway: new URL('http://test-gateway.net'),
+        const router = new StaticGatewayRouter({
+            gateway: 'http://test-gateway.net',
         });
         const result = await router.getTargetGateway();
         assert.deepStrictEqual(result, new URL('http://test-gateway.net'));

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

@@ -1,10 +1,10 @@
 import { ARIO } from '../io.js';
 import { Logger } from '../logger.js';
-import { ARIOGatewaysProvider } from './gateways.js';
+import { NetworkGatewaysProvider } from './gateways.js';
 import { RandomGatewayRouter } from './routers/random.js';
 // known regexes for wayfinder urls
 export const arnsRegex = /^[a-z0-9_-]{1,51}$/;
-export const txIdRegex = /^[a-z0-9]{43}$/;
+export const txIdRegex = /^[A-Za-z0-9_-]{43}$/;
 /**
  * Core function to resolve a wayfinder url against a target gateway
  * @param originalUrl - the wayfinder url to resolve
@@ -176,7 +176,7 @@ export class Wayfinder {
     // TODO: consider changing router to routingStrategy or strategy
     router = new RandomGatewayRouter({
         // optionally use a cache gateways provider to reduce the number of requests to the contract
-        gatewaysProvider: new ARIOGatewaysProvider({ ario: ARIO.mainnet() }),
+        gatewaysProvider: new NetworkGatewaysProvider({ ario: ARIO.mainnet() }),
     }), httpClient, logger = Logger.default,
     // TODO: add verifier interface that provides a verifyDataHash function
     // TODO: stats provider

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

@@ -3,23 +3,14 @@ import got from 'got';
 import assert from 'node:assert';
 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,
-    },
-};
+const gatewayUrl = 'permagate.io';
 const stubbedGatewaysProvider = {
-    getGateways: async () => [stubbedGateway],
+    getGateways: async () => [new URL(`https://${gatewayUrl}`)],
 };
+Logger.default.setLogLevel('debug');
 describe('Wayfinder', () => {
     describe('http wrapper', () => {
         describe('fetch', () => {
@@ -33,7 +24,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 +32,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 +112,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 +133,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 +144,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 +158,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 +201,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 +219,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,7 +227,7 @@ 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);
             });

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/version.js

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

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

@@ -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;

package/lib/types/common/wayfinder/gateways.d.ts

@@ -15,21 +15,30 @@
  */
 import { AoARIORead, AoGatewayWithAddress } from '../../types/io.js';
 export interface GatewaysProvider {
-    getGateways(): Promise<AoGatewayWithAddress[]>;
+    getGateways(): Promise<URL[]>;
 }
-export declare class ARIOGatewaysProvider implements GatewaysProvider {
+export declare class NetworkGatewaysProvider implements GatewaysProvider {
     private ario;
-    constructor({ ario }: {
+    private sortBy;
+    private sortOrder;
+    private limit;
+    private filter;
+    constructor({ ario, sortBy, sortOrder, limit, filter, }: {
         ario: AoARIORead;
+        sortBy?: 'totalDelegatedStake' | 'operatorStake' | 'startTimestamp';
+        sortOrder?: 'asc' | 'desc';
+        limit?: number;
+        blocklist?: string[];
+        filter?: (gateway: AoGatewayWithAddress) => boolean;
     });
-    getGateways(): Promise<AoGatewayWithAddress[]>;
+    getGateways(): Promise<URL[]>;
 }
 export declare class StaticGatewaysProvider implements GatewaysProvider {
     private gateways;
     constructor({ gateways }: {
-        gateways: AoGatewayWithAddress[];
+        gateways: string[];
     });
-    getGateways(): Promise<AoGatewayWithAddress[]>;
+    getGateways(): Promise<URL[]>;
 }
 export declare class SimpleCacheGatewaysProvider implements GatewaysProvider {
     private gatewaysProvider;
@@ -40,5 +49,5 @@ export declare class SimpleCacheGatewaysProvider implements GatewaysProvider {
         gatewaysProvider: GatewaysProvider;
         ttlSeconds?: number;
     });
-    getGateways(): Promise<AoGatewayWithAddress[]>;
+    getGateways(): Promise<URL[]>;
 }

package/lib/types/common/wayfinder/index.d.ts

@@ -16,5 +16,5 @@
 export * from './wayfinder.js';
 export * from './routers/random.js';
 export * from './routers/priority.js';
-export * from './routers/fixed.js';
+export * from './routers/static.js';
 export * from './gateways.js';

package/lib/types/common/wayfinder/routers/priority.d.ts

@@ -14,20 +14,16 @@
  * limitations under the License.
  */
 import { WayfinderRouter } from '../../../types/wayfinder.js';
-import { GatewaysProvider } from '../gateways.js';
+import { AoARIORead } from '../../../web/index.js';
+import { NetworkGatewaysProvider } from '../gateways.js';
 export declare class PriorityGatewayRouter implements WayfinderRouter {
     readonly name = "priority";
-    private gatewaysProvider;
-    private limit;
-    private sortBy;
-    private sortOrder;
-    private blocklist;
-    constructor({ gatewaysProvider, limit, sortBy, sortOrder, blocklist, }: {
-        gatewaysProvider: GatewaysProvider;
-        limit?: number;
-        sortBy?: 'totalDelegatedStake' | 'operatorStake' | 'startTimestamp';
-        sortOrder?: 'asc' | 'desc';
-        blocklist?: string[];
+    readonly gatewaysProvider: NetworkGatewaysProvider;
+    constructor({ ario, sortBy, sortOrder, limit, }: {
+        ario: AoARIORead;
+        sortBy: 'operatorStake' | 'totalDelegatedStake' | 'startTimestamp';
+        sortOrder: 'asc' | 'desc';
+        limit: number;
     });
     getTargetGateway(): Promise<URL>;
 }