@ar.io/sdk 3.11.0-alpha.9 → 3.11.0-beta.1

package/lib/cjs/cli/utils.js

@@ -165,7 +165,10 @@ function aoProcessFromOptions(options) {
 function readARIOFromOptions(options) {
     setLoggerIfDebug(options);
     return index_js_1.ARIO.init({
-        process: aoProcessFromOptions(options),
+        process: aoProcessFromOptions({
+            cuUrl: 'https://cu.ardrive.io', // default to ardrive cu for ARIO process
+            ...options,
+        }),
         paymentUrl: options.paymentUrl,
     });
 }

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

@@ -98,7 +98,8 @@ class AOProcess {
                 tags,
                 processId: this.processId,
             });
-            throw new Error(`Process ${this.processId} does not support provided action.`);
+            throw new Error(result.message ||
+                `Process ${this.processId} did not return a valid response. Response: ${JSON.stringify(result)}`);
         }
         const messageData = result.Messages?.[0]?.Data;
         // return undefined if no data is returned

package/lib/cjs/common/wayfinder/{gateways.js → gateways/network.js}

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimpleCacheGatewaysProvider = exports.StaticGatewaysProvider = exports.NetworkGatewaysProvider = void 0;
+exports.NetworkGatewaysProvider = void 0;
+const io_js_1 = require("../../io.js");
 class NetworkGatewaysProvider {
     ario;
     sortBy;
     sortOrder;
     limit;
     filter;
-    constructor({ ario, sortBy = 'operatorStake', sortOrder = 'desc', limit = 1000, filter = (g) => g.status === 'joined', }) {
+    constructor({ ario = io_js_1.ARIO.mainnet(), sortBy = 'operatorStake', sortOrder = 'desc', limit = 1000, filter = (g) => g.status === 'joined', }) {
         this.ario = ario;
         this.sortBy = sortBy;
         this.sortOrder = sortOrder;
@@ -45,42 +46,3 @@ class NetworkGatewaysProvider {
     }
 }
 exports.NetworkGatewaysProvider = NetworkGatewaysProvider;
-class StaticGatewaysProvider {
-    gateways;
-    constructor({ gateways }) {
-        this.gateways = gateways.map((g) => new URL(g));
-    }
-    async getGateways() {
-        return this.gateways;
-    }
-}
-exports.StaticGatewaysProvider = StaticGatewaysProvider;
-class SimpleCacheGatewaysProvider {
-    gatewaysProvider;
-    ttlSeconds;
-    lastUpdated;
-    gatewaysCache;
-    constructor({ gatewaysProvider, ttlSeconds = 5 * 60, // 5 minutes
-     }) {
-        this.gatewaysCache = [];
-        this.gatewaysProvider = gatewaysProvider;
-        this.ttlSeconds = ttlSeconds;
-    }
-    async getGateways() {
-        const now = Date.now();
-        if (this.gatewaysCache.length === 0 ||
-            now - this.lastUpdated > this.ttlSeconds * 1000) {
-            try {
-                // preserve the cache if the fetch fails
-                const allGateways = await this.gatewaysProvider.getGateways();
-                this.gatewaysCache = allGateways;
-                this.lastUpdated = now;
-            }
-            catch (error) {
-                console.error('Error fetching gateways', error);
-            }
-        }
-        return this.gatewaysCache;
-    }
-}
-exports.SimpleCacheGatewaysProvider = SimpleCacheGatewaysProvider;

package/lib/cjs/common/wayfinder/gateways/simple-cache.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleCacheGatewaysProvider = void 0;
+const index_js_1 = require("../../../web/index.js");
+class SimpleCacheGatewaysProvider {
+    gatewaysProvider;
+    ttlSeconds;
+    lastUpdated;
+    gatewaysCache;
+    logger;
+    constructor({ gatewaysProvider, ttlSeconds = 60 * 60, // 1 hour
+    logger = index_js_1.Logger.default, }) {
+        this.gatewaysCache = [];
+        this.gatewaysProvider = gatewaysProvider;
+        this.ttlSeconds = ttlSeconds;
+        this.logger = logger;
+    }
+    async getGateways() {
+        const now = Date.now();
+        if (this.gatewaysCache.length === 0 ||
+            now - this.lastUpdated > this.ttlSeconds * 1000) {
+            try {
+                // preserve the cache if the fetch fails
+                const allGateways = await this.gatewaysProvider.getGateways();
+                this.gatewaysCache = allGateways;
+                this.lastUpdated = now;
+            }
+            catch (error) {
+                this.logger.error('Error fetching gateways', error);
+            }
+        }
+        return this.gatewaysCache;
+    }
+}
+exports.SimpleCacheGatewaysProvider = SimpleCacheGatewaysProvider;

package/lib/cjs/common/wayfinder/gateways/static.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticGatewaysProvider = void 0;
+class StaticGatewaysProvider {
+    gateways;
+    constructor({ gateways }) {
+        this.gateways = gateways.map((g) => new URL(g));
+    }
+    async getGateways() {
+        return this.gateways;
+    }
+}
+exports.StaticGatewaysProvider = StaticGatewaysProvider;

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

@@ -30,15 +30,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * limitations under the License.
  */
 __exportStar(require("./wayfinder.js"), exports);
-// routers
-__exportStar(require("./routers/random.js"), exports);
-__exportStar(require("./routers/priority.js"), exports);
-__exportStar(require("./routers/static.js"), exports);
+// routing strategies
+__exportStar(require("./routing/strategies/random.js"), exports);
+__exportStar(require("./routing/strategies/static.js"), exports);
+__exportStar(require("./routing/strategies/ping.js"), exports);
+__exportStar(require("./routing/strategies/round-robin.js"), exports);
 // gateways providers
-__exportStar(require("./gateways.js"), exports);
+__exportStar(require("./gateways/network.js"), exports);
+__exportStar(require("./gateways/simple-cache.js"), exports);
+__exportStar(require("./gateways/static.js"), exports);
 // trusted gateways
-__exportStar(require("./gateways/trusted-gateways.js"), exports);
+__exportStar(require("./verification/trusted.js"), exports);
 // hash providers
-__exportStar(require("./verification/data-root-verifier.js"), exports);
-__exportStar(require("./verification/hash-verifier.js"), exports);
+__exportStar(require("./verification/strategies/data-root-verifier.js"), exports);
+__exportStar(require("./verification/strategies/hash-verifier.js"), exports);
 // TODO: signature verification

package/lib/cjs/common/wayfinder/routing/strategies/ping.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastestPingRoutingStrategy = void 0;
+class FastestPingRoutingStrategy {
+    timeoutMs;
+    probePath;
+    constructor({ timeoutMs = 500, probePath = '/ar-io/info', // TODO: limit to allowed /ar-io and arweave node endpoints
+     } = {}) {
+        this.timeoutMs = timeoutMs;
+        this.probePath = probePath;
+    }
+    async selectGateway({ gateways }) {
+        if (gateways.length === 0) {
+            throw new Error('No gateways provided');
+        }
+        try {
+            const results = await Promise.allSettled(gateways.map(async (gateway) => {
+                try {
+                    const startTime = Date.now();
+                    const response = await fetch(`${gateway.toString().replace(/\/$/, '')}${this.probePath}`, {
+                        method: 'HEAD',
+                        signal: AbortSignal.timeout(this.timeoutMs),
+                    });
+                    const endTime = Date.now();
+                    const durationMs = endTime - startTime;
+                    return {
+                        gateway,
+                        status: response.status,
+                        durationMs,
+                        error: null,
+                    };
+                }
+                catch (error) {
+                    // Handle network errors
+                    return {
+                        gateway,
+                        status: 'rejected',
+                        durationMs: Infinity,
+                        error,
+                    };
+                }
+            }));
+            // Process results
+            const processedResults = results.map((result, index) => {
+                if (result.status === 'fulfilled') {
+                    return result.value;
+                }
+                else {
+                    return {
+                        gateway: gateways[index],
+                        status: 'rejected',
+                        durationMs: Infinity,
+                        error: result.reason,
+                    };
+                }
+            });
+            // Filter healthy gateways and sort by latency
+            const healthyGateways = processedResults
+                .filter((result) => result.status === 200)
+                .sort((a, b) => a.durationMs - b.durationMs);
+            if (healthyGateways.length > 0) {
+                return healthyGateways[0].gateway;
+            }
+            throw new Error('No healthy gateways found');
+        }
+        catch (error) {
+            throw new Error('Failed to ping gateways: ' +
+                (error instanceof Error ? error.message : String(error)));
+        }
+    }
+}
+exports.FastestPingRoutingStrategy = FastestPingRoutingStrategy;

package/lib/cjs/common/wayfinder/routing/strategies/ping.test.js

@@ -0,0 +1,156 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 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.
+ */
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = require("node:test");
+const ping_js_1 = require("./ping.js");
+(0, node_test_1.describe)('FastestPingRoutingStrategy', () => {
+    // Original fetch function
+    const originalFetch = global.fetch;
+    // Mock response options for each gateway
+    const mockResponses = new Map();
+    (0, node_test_1.beforeEach)(() => {
+        // reset mock responses
+        mockResponses.clear();
+        // mock fetch to simulate network latency and response status
+        global.fetch = async (url) => {
+            const urlString = url.toString();
+            // find the matching gateway
+            let matchingGateway = '';
+            for (const gateway of mockResponses.keys()) {
+                if (urlString.startsWith(gateway)) {
+                    matchingGateway = gateway;
+                    break;
+                }
+            }
+            if (!matchingGateway) {
+                return Promise.reject(new Error(`No mock response for URL: ${urlString}`));
+            }
+            const { status, delayMs } = mockResponses.get(matchingGateway);
+            // simulate network delay
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+            return new Response(null, { status });
+        };
+        // mock AbortSignal.timeout
+        if (!AbortSignal.timeout) {
+            AbortSignal.timeout = (ms) => {
+                const controller = new AbortController();
+                setTimeout(() => controller.abort(), ms);
+                return controller.signal;
+            };
+        }
+    });
+    // restore original fetch after tests
+    (0, node_test_1.afterEach)(() => {
+        global.fetch = originalFetch;
+    });
+    (0, node_test_1.it)('selects the gateway with the lowest latency', async () => {
+        const gateways = [
+            new URL('https://slow.com'),
+            new URL('https://fast.com'),
+            new URL('https://medium.com'),
+        ];
+        // configure mock responses
+        mockResponses.set('https://slow.com', { status: 200, delayMs: 300 });
+        mockResponses.set('https://fast.com', { status: 200, delayMs: 50 });
+        mockResponses.set('https://medium.com', { status: 200, delayMs: 150 });
+        const strategy = new ping_js_1.FastestPingRoutingStrategy({ timeoutMs: 500 });
+        // select the gateway with the lowest latency
+        const selectedGateway = await strategy.selectGateway({
+            gateways,
+        });
+        strict_1.default.equal(selectedGateway.toString(), 'https://fast.com/', 'Should select the gateway with the lowest latency');
+    });
+    (0, node_test_1.it)('ignores gateways that return non-200 status codes', async () => {
+        const gateways = [
+            new URL('https://error.com'),
+            new URL('https://success.com'),
+            new URL('https://another-error.com'),
+        ];
+        // configure mock responses
+        mockResponses.set('https://error.com', { status: 404, delayMs: 50 });
+        mockResponses.set('https://success.com', { status: 200, delayMs: 100 });
+        mockResponses.set('https://another-error.com', {
+            status: 500,
+            delayMs: 75,
+        });
+        const strategy = new ping_js_1.FastestPingRoutingStrategy({ timeoutMs: 500 });
+        // select the gateway with the lowest latency
+        const selectedGateway = await strategy.selectGateway({
+            gateways,
+        });
+        strict_1.default.equal(selectedGateway.toString(), 'https://success.com/', 'Should select the gateway that returns a 200 status code');
+    });
+    (0, node_test_1.it)('throws an error when all gateways fail', async () => {
+        const gateways = [
+            new URL('https://error1.com'),
+            new URL('https://error2.com'),
+        ];
+        // configure mock responses
+        mockResponses.set('https://error1.com', { status: 404, delayMs: 50 });
+        mockResponses.set('https://error2.com', { status: 500, delayMs: 75 });
+        const strategy = new ping_js_1.FastestPingRoutingStrategy({ timeoutMs: 500 });
+        // select the gateway with the lowest latency
+        await strict_1.default.rejects(async () => await strategy.selectGateway({ gateways }), /No healthy gateways found/, 'Should throw an error when all gateways fail');
+    });
+    (0, node_test_1.it)('handles network errors gracefully', async () => {
+        const gateways = [
+            new URL('https://network-error.com'),
+            new URL('https://success.com'),
+        ];
+        // configure mock responses
+        mockResponses.set('https://success.com', { status: 200, delayMs: 100 });
+        // override fetch for the network error case
+        const originalFetchMock = global.fetch;
+        global.fetch = async (url) => {
+            if (url.toString().includes('network-error')) {
+                throw new Error('Network error');
+            }
+            return originalFetchMock(url);
+        };
+        const strategy = new ping_js_1.FastestPingRoutingStrategy({ timeoutMs: 500 });
+        // select the gateway with the lowest latency
+        const selectedGateway = await strategy.selectGateway({
+            gateways,
+        });
+        strict_1.default.equal(selectedGateway.toString(), 'https://success.com/', 'Should handle network errors and select the working gateway');
+    });
+    (0, node_test_1.it)('respects the timeout parameter', async () => {
+        const gateways = [
+            new URL('https://timeout.com'),
+            new URL('https://fast.com'),
+        ];
+        // configure mock responses
+        mockResponses.set('https://timeout.com', { status: 200, delayMs: 300 });
+        mockResponses.set('https://fast.com', { status: 200, delayMs: 50 });
+        // set a short timeout
+        const strategy = new ping_js_1.FastestPingRoutingStrategy({ timeoutMs: 100 });
+        const selectedGateway = await strategy.selectGateway({
+            gateways,
+        });
+        strict_1.default.equal(selectedGateway.toString(), 'https://fast.com/', 'Should respect the timeout and select only gateways that respond within the timeout');
+    });
+    (0, node_test_1.it)('throws an error when no gateways are provided', async () => {
+        const gateways = [];
+        const strategy = new ping_js_1.FastestPingRoutingStrategy();
+        // select the gateway with the lowest latency
+        await strict_1.default.rejects(async () => await strategy.selectGateway({ gateways }), /No gateways provided/, 'Should throw an error when no gateways are provided');
+    });
+});

package/lib/cjs/common/wayfinder/routing/strategies/random.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RandomRoutingStrategy = void 0;
+const random_js_1 = require("../../../../utils/random.js");
+class RandomRoutingStrategy {
+    async selectGateway({ gateways }) {
+        if (gateways.length === 0) {
+            throw new Error('No gateways available');
+        }
+        return gateways[(0, random_js_1.randomInt)(0, gateways.length)];
+    }
+}
+exports.RandomRoutingStrategy = RandomRoutingStrategy;

package/lib/cjs/common/wayfinder/routing/strategies/random.test.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 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.
+ */
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = require("node:test");
+const random_js_1 = require("./random.js");
+(0, node_test_1.describe)('RandomRoutingStrategy', () => {
+    (0, node_test_1.it)('selects a gateway from the provided list', async () => {
+        // Arrange
+        const gateways = [
+            new URL('https://example1.com'),
+            new URL('https://example2.com'),
+            new URL('https://example3.com'),
+        ];
+        const strategy = new random_js_1.RandomRoutingStrategy();
+        const selectedGateway = await strategy.selectGateway({ gateways });
+        strict_1.default.ok(gateways.includes(selectedGateway), 'The selected gateway should be one of the gateways provided');
+    });
+    (0, node_test_1.it)('throws error when no gateways are provided', async () => {
+        const gateways = [];
+        const strategy = new random_js_1.RandomRoutingStrategy();
+        await strict_1.default.rejects(async () => await strategy.selectGateway({ gateways }), /No gateways available/, 'Should throw an error when no gateways are provided');
+    });
+    (0, node_test_1.it)('should distribute gateway selection somewhat randomly', async () => {
+        const gateways = [
+            new URL('https://example1.com'),
+            new URL('https://example2.com'),
+            new URL('https://example3.com'),
+            new URL('https://example4.com'),
+            new URL('https://example5.com'),
+        ];
+        const strategy = new random_js_1.RandomRoutingStrategy();
+        const selections = new Map();
+        // select gateways multiple times
+        const iterations = 100;
+        for (let i = 0; i < iterations; i++) {
+            const gateway = await strategy.selectGateway({ gateways });
+            const key = gateway.toString();
+            selections.set(key, (selections.get(key) || 0) + 1);
+        }
+        // each gateway should be selected at least once
+        for (const gateway of gateways) {
+            const key = gateway.toString();
+            strict_1.default.ok(selections.has(key), `Gateway ${key} should be selected at least once`);
+        }
+        // no gateway should be selected more than 50% of the time
+        for (const [key, count] of selections.entries()) {
+            strict_1.default.ok(count < iterations * 0.5, `Gateway ${key} was selected ${count} times, which is more than 50% of iterations`);
+        }
+    });
+});

package/lib/cjs/common/wayfinder/routing/strategies/round-robin.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoundRobinRoutingStrategy = void 0;
+/**
+ * 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.
+ */
+const logger_js_1 = require("../../../../common/logger.js");
+class RoundRobinRoutingStrategy {
+    gateways;
+    currentIndex;
+    logger;
+    constructor({ gateways, logger = logger_js_1.Logger.default, }) {
+        this.gateways = gateways;
+        this.currentIndex = 0;
+        this.logger = logger;
+    }
+    // provided gateways are ignored
+    async selectGateway({ gateways = [], } = {}) {
+        if (gateways.length > 0) {
+            this.logger.warn('RoundRobinRoutingStrategy does not accept provided gateways. Ignoring provided gateways...', {
+                providedGateways: gateways.length,
+                internalGateways: this.gateways,
+            });
+        }
+        const gateway = this.gateways[this.currentIndex];
+        this.currentIndex = (this.currentIndex + 1) % this.gateways.length;
+        return gateway;
+    }
+}
+exports.RoundRobinRoutingStrategy = RoundRobinRoutingStrategy;

package/lib/cjs/common/wayfinder/routing/strategies/round-robin.test.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 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.
+ */
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = require("node:test");
+const logger_js_1 = require("../../../../common/logger.js");
+const round_robin_js_1 = require("./round-robin.js");
+logger_js_1.Logger.default.setLogLevel('none');
+(0, node_test_1.describe)('RoundRobinRoutingStrategy', () => {
+    (0, node_test_1.it)('selects gateways in order and cycles back to the beginning', async () => {
+        const gateways = [
+            new URL('https://example1.com'),
+            new URL('https://example2.com'),
+            new URL('https://example3.com'),
+        ];
+        const strategy = new round_robin_js_1.RoundRobinRoutingStrategy({ gateways });
+        const selection1 = await strategy.selectGateway();
+        strict_1.default.equal(selection1.toString(), gateways[0].toString(), 'Should select the first gateway first');
+        const selection2 = await strategy.selectGateway();
+        strict_1.default.equal(selection2.toString(), gateways[1].toString(), 'Should select the second gateway second');
+        const selection3 = await strategy.selectGateway();
+        strict_1.default.equal(selection3.toString(), gateways[2].toString(), 'Should select the third gateway third');
+        // should cycle back to the first gateway
+        const selection4 = await strategy.selectGateway();
+        strict_1.default.equal(selection4.toString(), gateways[0].toString(), 'Should cycle back to the first gateway');
+    });
+    (0, node_test_1.it)('uses the internal list even when a different list is provided', async () => {
+        const initialGateways = [
+            new URL('https://example1.com'),
+            new URL('https://example2.com'),
+        ];
+        const newGateways = [
+            new URL('https://example3.com'),
+            new URL('https://example4.com'),
+        ];
+        const strategy = new round_robin_js_1.RoundRobinRoutingStrategy({
+            gateways: initialGateways,
+        });
+        const selection1 = await strategy.selectGateway({
+            gateways: newGateways,
+        });
+        strict_1.default.equal(selection1.toString(), initialGateways[0].toString(), 'Should use the internal list even when a different list is provided');
+        const selection2 = await strategy.selectGateway({
+            // @ts-ignore
+            gateways: newGateways,
+        });
+        strict_1.default.equal(selection2.toString(), initialGateways[1].toString(), 'Should use the internal list even when a different list is provided');
+    });
+    (0, node_test_1.it)('handles a single gateway by returning it repeatedly', async () => {
+        const gateways = [new URL('https://example1.com')];
+        const strategy = new round_robin_js_1.RoundRobinRoutingStrategy({ gateways });
+        const selection1 = await strategy.selectGateway({
+            gateways: [new URL('https://example2.com')],
+        });
+        strict_1.default.equal(selection1.toString(), gateways[0].toString(), 'Should return the single gateway');
+        const selection2 = await strategy.selectGateway({
+            gateways: [new URL('https://example2.com')],
+        });
+        strict_1.default.equal(selection2.toString(), gateways[0].toString(), 'Should return the single gateway again');
+    });
+});

package/lib/cjs/common/wayfinder/routing/strategies/static.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticRoutingStrategy = void 0;
+const logger_js_1 = require("../../../logger.js");
+class StaticRoutingStrategy {
+    name = 'static';
+    gateway;
+    logger;
+    constructor({ gateway, logger = logger_js_1.Logger.default, }) {
+        try {
+            this.gateway = new URL(gateway);
+        }
+        catch (error) {
+            throw new Error(`Invalid URL provided for static gateway: ${gateway}`);
+        }
+        this.logger = logger;
+    }
+    // provided gateways are ignored
+    async selectGateway({ gateways = [], } = {}) {
+        if (gateways.length > 0) {
+            this.logger.warn('StaticRoutingStrategy does not accept provided gateways. Ignoring provided gateways...', {
+                providedGateways: gateways.length,
+                internalGateway: this.gateway,
+            });
+        }
+        return this.gateway;
+    }
+}
+exports.StaticRoutingStrategy = StaticRoutingStrategy;

package/lib/cjs/common/wayfinder/routing/strategies/static.test.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 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.
+ */
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = require("node:test");
+const static_js_1 = require("./static.js");
+(0, node_test_1.describe)('StaticRoutingStrategy', () => {
+    (0, node_test_1.it)('returns the configured gateway regardless of the gateways parameter', async () => {
+        const staticGateway = 'https://static-example.com/';
+        const strategy = new static_js_1.StaticRoutingStrategy({
+            gateway: staticGateway,
+        });
+        const result1 = await strategy.selectGateway();
+        const result2 = await strategy.selectGateway();
+        const result3 = await strategy.selectGateway();
+        strict_1.default.equal(result1.toString(), staticGateway, 'Should return the static gateway');
+        strict_1.default.equal(result2.toString(), staticGateway, 'Should return the static gateway');
+        strict_1.default.equal(result3.toString(), staticGateway, 'Should return the static gateway even when no gateways are provided');
+    });
+    (0, node_test_1.it)('throws an error when an invalid URL is provided', () => {
+        strict_1.default.throws(() => new static_js_1.StaticRoutingStrategy({ gateway: 'not-a-valid-url' }), /Invalid URL provided for static gateway/, 'Should throw an error when an invalid URL is provided');
+    });
+});