@ar.io/sdk 3.12.2 → 3.13.0-beta.1

package/lib/cjs/utils/hash.js

@@ -1,6 +1,9 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hashBufferToB64Url = exports.hashReadableStreamToB64Url = exports.hashReadableToB64Url = void 0;
+exports.convertDataStreamToDataRoot = exports.hashDataStreamToB64Url = exports.readableStreamToAsyncIterable = exports.isReadableStream = exports.isAsyncIterable = void 0;
 /**
  * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
  *
@@ -16,41 +19,90 @@ exports.hashBufferToB64Url = exports.hashReadableStreamToB64Url = exports.hashRe
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+const arweave_1 = __importDefault(require("arweave"));
+const merkle_js_1 = require("arweave/node/lib/merkle.js");
 const crypto_1 = require("crypto");
 const base64_js_1 = require("./base64.js");
-const hashReadableToB64Url = (stream, algorithm = 'sha256') => {
-    return new Promise((resolve, reject) => {
-        const hash = (0, crypto_1.createHash)(algorithm);
-        stream.on('data', (chunk) => hash.update(chunk));
-        stream.on('end', () => resolve((0, base64_js_1.toB64Url)(hash.digest())));
-        stream.on('error', (err) => reject(err));
-    });
+const isAsyncIterable = (x) => {
+    return x && typeof x[Symbol.asyncIterator] === 'function';
+};
+exports.isAsyncIterable = isAsyncIterable;
+const isReadableStream = (x) => {
+    return x && typeof x.getReader === 'function';
 };
-exports.hashReadableToB64Url = hashReadableToB64Url;
-const hashReadableStreamToB64Url = (stream, algorithm = 'sha256') => {
-    return new Promise((resolve, reject) => {
-        const hash = (0, crypto_1.createHash)(algorithm);
+exports.isReadableStream = isReadableStream;
+// convert ReadableStream to async iterable
+const readableStreamToAsyncIterable = (stream) => ({
+    async *[Symbol.asyncIterator]() {
         const reader = stream.getReader();
-        const read = async () => {
-            try {
+        try {
+            while (true) {
                 const { done, value } = await reader.read();
-                if (done) {
-                    resolve((0, base64_js_1.toB64Url)(hash.digest()));
-                }
-                else {
-                    hash.update(value);
-                    read();
-                }
+                if (done)
+                    break;
+                if (value !== undefined)
+                    yield value;
             }
-            catch (err) {
-                reject(err);
-            }
-        };
-        read().catch(reject);
-    });
+        }
+        finally {
+            reader.releaseLock();
+        }
+    },
+});
+exports.readableStreamToAsyncIterable = readableStreamToAsyncIterable;
+const hashDataStreamToB64Url = async (stream, algorithm = 'sha256') => {
+    const asyncIterable = (0, exports.isAsyncIterable)(stream)
+        ? stream
+        : (0, exports.readableStreamToAsyncIterable)(stream);
+    const hash = (0, crypto_1.createHash)(algorithm);
+    for await (const chunk of asyncIterable) {
+        hash.update(chunk);
+    }
+    return (0, base64_js_1.toB64Url)(hash.digest());
 };
-exports.hashReadableStreamToB64Url = hashReadableStreamToB64Url;
-const hashBufferToB64Url = (buffer, algorithm = 'sha256') => {
-    return (0, base64_js_1.toB64Url)((0, crypto_1.createHash)(algorithm).update(buffer).digest());
+exports.hashDataStreamToB64Url = hashDataStreamToB64Url;
+const convertDataStreamToDataRoot = async ({ dataStream, }) => {
+    const chunks = [];
+    let leftover = new Uint8Array(0);
+    let cursor = 0;
+    const asyncIterable = (0, exports.isAsyncIterable)(dataStream)
+        ? dataStream
+        : (0, exports.readableStreamToAsyncIterable)(dataStream);
+    for await (const data of asyncIterable) {
+        const inputChunk = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        const combined = new Uint8Array(leftover.length + inputChunk.length);
+        combined.set(leftover, 0);
+        combined.set(inputChunk, leftover.length);
+        let startIndex = 0;
+        while (combined.length - startIndex >= merkle_js_1.MAX_CHUNK_SIZE) {
+            let chunkSize = merkle_js_1.MAX_CHUNK_SIZE;
+            const remainderAfterThis = combined.length - startIndex - merkle_js_1.MAX_CHUNK_SIZE;
+            if (remainderAfterThis > 0 && remainderAfterThis < merkle_js_1.MIN_CHUNK_SIZE) {
+                chunkSize = Math.ceil((combined.length - startIndex) / 2);
+            }
+            const chunkData = combined.slice(startIndex, startIndex + chunkSize);
+            const dataHash = await arweave_1.default.crypto.hash(chunkData);
+            chunks.push({
+                dataHash,
+                minByteRange: cursor,
+                maxByteRange: cursor + chunkSize,
+            });
+            cursor += chunkSize;
+            startIndex += chunkSize;
+        }
+        leftover = combined.slice(startIndex);
+    }
+    if (leftover.length > 0) {
+        // TODO: ensure a web friendly crypto hash function is used in web
+        const dataHash = await arweave_1.default.crypto.hash(leftover);
+        chunks.push({
+            dataHash,
+            minByteRange: cursor,
+            maxByteRange: cursor + leftover.length,
+        });
+    }
+    const leaves = await (0, merkle_js_1.generateLeaves)(chunks);
+    const root = await (0, merkle_js_1.buildLayers)(leaves);
+    return (0, base64_js_1.toB64Url)(Buffer.from(root.id));
 };
-exports.hashBufferToB64Url = hashBufferToB64Url;
+exports.convertDataStreamToDataRoot = convertDataStreamToDataRoot;

package/lib/cjs/version.js

@@ -17,4 +17,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // AUTOMATICALLY GENERATED FILE - DO NOT TOUCH
-exports.version = '3.12.2';
+exports.version = '3.13.0-beta.1';

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

@@ -1,10 +1,11 @@
-import { assertConfirmationPrompt, assertEnoughBalanceForArNSPurchase, customTagsFromOptions, fundFromFromOptions, positiveIntegerFromOptions, recordTypeFromOptions, requiredPositiveIntegerFromOptions, requiredStringFromOptions, stringArrayFromOptions, writeARIOFromOptions, } from '../utils.js';
+import { assertConfirmationPrompt, assertEnoughBalanceForArNSPurchase, customTagsFromOptions, fundFromFromOptions, positiveIntegerFromOptions, recordTypeFromOptions, referrerFromOptions, requiredPositiveIntegerFromOptions, requiredStringFromOptions, stringArrayFromOptions, writeARIOFromOptions, } from '../utils.js';
 export async function buyRecordCLICommand(o) {
     const { ario, signerAddress } = writeARIOFromOptions(o);
     const name = requiredStringFromOptions(o, 'name');
     const type = recordTypeFromOptions(o);
     const years = positiveIntegerFromOptions(o, 'years');
     const fundFrom = fundFromFromOptions(o);
+    const referrer = referrerFromOptions(o);
     const processId = o.processId;
     if (processId === undefined) {
         // TODO: Spawn ANT process, register it to ANT registry, get process ID
@@ -38,12 +39,14 @@ export async function buyRecordCLICommand(o) {
         years,
         fundFrom: fundFromFromOptions(o),
         paidBy: stringArrayFromOptions(o, 'paidBy'),
+        referrer,
     }, customTagsFromOptions(o));
 }
 export async function upgradeRecordCLICommand(o) {
     const name = requiredStringFromOptions(o, 'name');
     const { ario, signerAddress } = writeARIOFromOptions(o);
     const fundFrom = fundFromFromOptions(o);
+    const referrer = referrerFromOptions(o);
     if (!o.skipConfirmation) {
         const existingRecord = await ario.getArNSRecord({
             name,
@@ -70,12 +73,14 @@ export async function upgradeRecordCLICommand(o) {
         name,
         fundFrom,
         paidBy: stringArrayFromOptions(o, 'paidBy'),
+        referrer,
     });
 }
 export async function extendLeaseCLICommand(o) {
     const name = requiredStringFromOptions(o, 'name');
     const years = requiredPositiveIntegerFromOptions(o, 'years');
     const fundFrom = fundFromFromOptions(o);
+    const referrer = referrerFromOptions(o);
     const { ario, signerAddress } = writeARIOFromOptions(o);
     if (!o.skipConfirmation) {
         const existingRecord = await ario.getArNSRecord({
@@ -104,12 +109,14 @@ export async function extendLeaseCLICommand(o) {
         name,
         years,
         paidBy: stringArrayFromOptions(o, 'paidBy'),
+        referrer,
     }, customTagsFromOptions(o));
 }
 export async function increaseUndernameLimitCLICommand(o) {
     const name = requiredStringFromOptions(o, 'name');
     const increaseCount = requiredPositiveIntegerFromOptions(o, 'increaseCount');
     const fundFrom = fundFromFromOptions(o);
+    const referrer = referrerFromOptions(o);
     const { ario, signerAddress } = writeARIOFromOptions(o);
     if (!o.skipConfirmation) {
         const existingRecord = await ario.getArNSRecord({
@@ -135,11 +142,13 @@ export async function increaseUndernameLimitCLICommand(o) {
         name,
         increaseCount,
         paidBy: stringArrayFromOptions(o, 'paidBy'),
+        referrer,
     }, customTagsFromOptions(o));
 }
 export async function requestPrimaryNameCLICommand(o) {
     const { ario, signerAddress } = writeARIOFromOptions(o);
     const fundFrom = fundFromFromOptions(o);
+    const referrer = referrerFromOptions(o);
     const name = requiredStringFromOptions(o, 'name');
     if (!o.skipConfirmation) {
         // TODO: Assert name requested is not already owned?
@@ -160,5 +169,6 @@ export async function requestPrimaryNameCLICommand(o) {
         name,
         fundFrom,
         paidBy: stringArrayFromOptions(o, 'paidBy'),
+        referrer,
     }, customTagsFromOptions(o));
 }

package/lib/esm/cli/options.js

@@ -283,6 +283,10 @@ export const optionMap = {
         description: 'Addresses to pay for the interaction',
         type: 'array',
     },
+    referrer: {
+        alias: '--referrer <referrer>',
+        description: 'The referrer for ArNS purchase tracking',
+    },
 };
 export const walletOptions = [
     optionMap.walletFile,
@@ -306,6 +310,7 @@ export const arnsPurchaseOptions = [
     optionMap.fundFrom,
     optionMap.paidBy,
     optionMap.paymentUrl,
+    optionMap.referrer,
 ];
 export const epochOptions = [optionMap.epochIndex, optionMap.timestamp];
 export const addressAndVaultIdOptions = [optionMap.address, optionMap.vaultId];

package/lib/esm/cli/utils.js

@@ -458,6 +458,9 @@ export function fundFromFromOptions(o) {
     }
     return o.fundFrom ?? 'balance';
 }
+export function referrerFromOptions(o) {
+    return o.referrer;
+}
 export function assertLockLengthInRange(lockLengthMs, assertMin = true) {
     const minLockLengthMs = 1209600000; // 14 days
     const maxLockLengthMs = 378432000000; // ~12 years

package/lib/esm/common/index.js

@@ -22,3 +22,5 @@ export * from './faucet.js';
 // ao
 export * from './io.js';
 export * from './contracts/ao-process.js';
+// wayfinder
+export * from './wayfinder/index.js';

package/lib/esm/common/io.js

@@ -981,6 +981,7 @@ export class ARIOWriteable extends ARIOReadable {
             { name: 'Process-Id', value: params.processId },
             { name: 'Purchase-Type', value: params.type || 'lease' },
             { name: 'Fund-From', value: params.fundFrom },
+            { name: 'Referrer', value: params.referrer },
         ];
         return this.process.send({
             signer: this.signer,
@@ -1011,6 +1012,7 @@ export class ARIOWriteable extends ARIOReadable {
             { name: 'Action', value: 'Upgrade-Name' },
             { name: 'Name', value: params.name },
             { name: 'Fund-From', value: params.fundFrom },
+            { name: 'Referrer', value: params.referrer },
         ];
         return this.process.send({
             signer: this.signer,
@@ -1044,6 +1046,7 @@ export class ARIOWriteable extends ARIOReadable {
             { name: 'Name', value: params.name },
             { name: 'Years', value: params.years.toString() },
             { name: 'Fund-From', value: params.fundFrom },
+            { name: 'Referrer', value: params.referrer },
         ];
         return this.process.send({
             signer: this.signer,
@@ -1068,6 +1071,7 @@ export class ARIOWriteable extends ARIOReadable {
             { name: 'Name', value: params.name },
             { name: 'Quantity', value: params.increaseCount.toString() },
             { name: 'Fund-From', value: params.fundFrom },
+            { name: 'Referrer', value: params.referrer },
         ];
         return this.process.send({
             signer: this.signer,

package/lib/esm/common/turbo.js

@@ -148,7 +148,7 @@ export class TurboArNSPaymentProviderAuthenticated extends TurboArNSPaymentProvi
         }
         this.signer = signer;
     }
-    async initiateArNSPurchase({ intent, name, quantity, type, processId, years, paidBy = [], }) {
+    async initiateArNSPurchase({ intent, name, quantity, type, processId, years, paidBy = [], referrer, }) {
         // Signer check is implicitly handled by requiring it in the constructor
         const url = urlWithSearchParams({
             baseUrl: `${this.paymentUrl}/v1/arns/purchase/${intent}/${name}`,
@@ -158,6 +158,7 @@ export class TurboArNSPaymentProviderAuthenticated extends TurboArNSPaymentProvi
                 type,
                 years,
                 paidBy,
+                referrer,
             },
         });
         const headers = await signedRequestHeadersFromSigner({

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

@@ -0,0 +1,44 @@
+import { ARIO } from '../../io.js';
+export class NetworkGatewaysProvider {
+    ario;
+    sortBy;
+    sortOrder;
+    limit;
+    filter;
+    constructor({ ario = ARIO.mainnet(), 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;
+        let attempts = 0;
+        const gateways = [];
+        do {
+            try {
+                const { items: newGateways = [], nextCursor } = await this.ario.getGateways({
+                    limit: 1000,
+                    cursor,
+                    sortBy: this.sortBy,
+                    sortOrder: this.sortOrder,
+                });
+                gateways.push(...newGateways);
+                cursor = nextCursor;
+                attempts = 0; // reset attempts if we get a new cursor
+            }
+            catch (error) {
+                console.error('Error fetching gateways', {
+                    cursor,
+                    attempts,
+                    error,
+                });
+                attempts++;
+            }
+        } while (cursor !== undefined && attempts < 3);
+        // filter out any gateways that are not 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}`));
+    }
+}

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

@@ -0,0 +1,31 @@
+import { Logger } from '../../../web/index.js';
+export class SimpleCacheGatewaysProvider {
+    gatewaysProvider;
+    ttlSeconds;
+    lastUpdated;
+    gatewaysCache;
+    logger;
+    constructor({ gatewaysProvider, ttlSeconds = 60 * 60, // 1 hour
+    logger = 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;
+    }
+}

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

@@ -0,0 +1,9 @@
+export class StaticGatewaysProvider {
+    gateways;
+    constructor({ gateways }) {
+        this.gateways = gateways.map((g) => new URL(g));
+    }
+    async getGateways() {
+        return this.gateways;
+    }
+}

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

@@ -0,0 +1,32 @@
+/**
+ * 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.
+ */
+export * from './wayfinder.js';
+// routing strategies
+export * from './routing/strategies/random.js';
+export * from './routing/strategies/static.js';
+export * from './routing/strategies/ping.js';
+export * from './routing/strategies/round-robin.js';
+export * from './routing/strategies/preferred-with-fallback.js';
+// gateways providers
+export * from './gateways/network.js';
+export * from './gateways/simple-cache.js';
+export * from './gateways/static.js';
+// trusted gateways
+export * from './verification/trusted.js';
+// hash providers
+export * from './verification/strategies/data-root-verifier.js';
+export * from './verification/strategies/hash-verifier.js';
+// TODO: signature verification

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

@@ -0,0 +1,68 @@
+export 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)));
+        }
+    }
+}

package/lib/esm/common/wayfinder/routing/strategies/preferred-with-fallback.js

@@ -0,0 +1,46 @@
+import { Logger } from '../../../logger.js';
+import { FastestPingRoutingStrategy } from './ping.js';
+export class PreferredWithFallbackRoutingStrategy {
+    name = 'preferred-with-fallback';
+    preferredGateway;
+    fallbackStrategy;
+    logger;
+    constructor({ preferredGateway, fallbackStrategy = new FastestPingRoutingStrategy(), logger = Logger.default, }) {
+        try {
+            this.preferredGateway = new URL(preferredGateway);
+        }
+        catch (error) {
+            throw new Error(`Invalid URL provided for preferred gateway: ${preferredGateway}`);
+        }
+        this.fallbackStrategy = fallbackStrategy;
+        this.logger = logger;
+    }
+    async selectGateway({ gateways = [] }) {
+        this.logger.debug('Attempting to connect to preferred gateway', {
+            preferredGateway: this.preferredGateway.toString(),
+        });
+        try {
+            // Check if the preferred gateway is responsive
+            const response = await fetch(this.preferredGateway.toString(), {
+                method: 'HEAD',
+                signal: AbortSignal.timeout(1000),
+            });
+            if (response.ok) {
+                this.logger.debug('Successfully connected to preferred gateway', {
+                    preferredGateway: this.preferredGateway.toString(),
+                });
+                return this.preferredGateway;
+            }
+            throw new Error(`Preferred gateway responded with status: ${response.status}`);
+        }
+        catch (error) {
+            this.logger.warn('Failed to connect to preferred gateway, falling back to alternative strategy', {
+                preferredGateway: this.preferredGateway.toString(),
+                error: error instanceof Error ? error.message : String(error),
+                fallbackStrategy: this.fallbackStrategy.constructor.name,
+            });
+            // Fall back to the provided routing strategy
+            return this.fallbackStrategy.selectGateway({ gateways });
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import { randomInt } from '../../../../utils/random.js';
+export class RandomRoutingStrategy {
+    async selectGateway({ gateways }) {
+        if (gateways.length === 0) {
+            throw new Error('No gateways available');
+        }
+        return gateways[randomInt(0, gateways.length)];
+    }
+}

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

@@ -0,0 +1,38 @@
+/**
+ * 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 { Logger } from '../../../../common/logger.js';
+export class RoundRobinRoutingStrategy {
+    gateways;
+    currentIndex;
+    logger;
+    constructor({ gateways, logger = 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;
+    }
+}

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

@@ -0,0 +1,25 @@
+import { Logger } from '../../../logger.js';
+export class StaticRoutingStrategy {
+    name = 'static';
+    gateway;
+    logger;
+    constructor({ gateway, logger = 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;
+    }
+}