@ar.io/sdk 3.13.0-beta.1 → 3.14.0-alpha.1

package/lib/esm/utils/hash.js

@@ -13,85 +13,38 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import Arweave from 'arweave';
-import { MAX_CHUNK_SIZE, MIN_CHUNK_SIZE, buildLayers, generateLeaves, } from 'arweave/node/lib/merkle.js';
 import { createHash } from 'crypto';
 import { toB64Url } from './base64.js';
-export const isAsyncIterable = (x) => {
-    return x && typeof x[Symbol.asyncIterator] === 'function';
+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 isReadableStream = (x) => {
-    return x && typeof x.getReader === 'function';
-};
-// convert ReadableStream to async iterable
-export const readableStreamToAsyncIterable = (stream) => ({
-    async *[Symbol.asyncIterator]() {
+export const hashReadableStreamToB64Url = (stream, algorithm = 'sha256') => {
+    return new Promise((resolve, reject) => {
+        const hash = createHash(algorithm);
         const reader = stream.getReader();
-        try {
-            while (true) {
+        const read = async () => {
+            try {
                 const { done, value } = await reader.read();
-                if (done)
-                    break;
-                if (value !== undefined)
-                    yield value;
+                if (done) {
+                    resolve(toB64Url(hash.digest()));
+                }
+                else {
+                    hash.update(value);
+                    read();
+                }
             }
-        }
-        finally {
-            reader.releaseLock();
-        }
-    },
-});
-export const hashDataStreamToB64Url = async (stream, algorithm = 'sha256') => {
-    const asyncIterable = isAsyncIterable(stream)
-        ? stream
-        : readableStreamToAsyncIterable(stream);
-    const hash = createHash(algorithm);
-    for await (const chunk of asyncIterable) {
-        hash.update(chunk);
-    }
-    return toB64Url(hash.digest());
-};
-export const convertDataStreamToDataRoot = async ({ dataStream, }) => {
-    const chunks = [];
-    let leftover = new Uint8Array(0);
-    let cursor = 0;
-    const asyncIterable = isAsyncIterable(dataStream)
-        ? dataStream
-        : 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 >= MAX_CHUNK_SIZE) {
-            let chunkSize = MAX_CHUNK_SIZE;
-            const remainderAfterThis = combined.length - startIndex - MAX_CHUNK_SIZE;
-            if (remainderAfterThis > 0 && remainderAfterThis < MIN_CHUNK_SIZE) {
-                chunkSize = Math.ceil((combined.length - startIndex) / 2);
+            catch (err) {
+                reject(err);
             }
-            const chunkData = combined.slice(startIndex, startIndex + chunkSize);
-            const dataHash = await Arweave.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.crypto.hash(leftover);
-        chunks.push({
-            dataHash,
-            minByteRange: cursor,
-            maxByteRange: cursor + leftover.length,
-        });
-    }
-    const leaves = await generateLeaves(chunks);
-    const root = await buildLayers(leaves);
-    return toB64Url(Buffer.from(root.id));
+        };
+        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.13.0-beta.1';
+export const version = '3.14.0-alpha.1';

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

@@ -3,6 +3,7 @@ import { AoMessageResult, ProcessConfiguration, WalletAddress, WithSigner, Write
 import { AOProcess } from './index.js';
 type ANTConfigOptionalStrict = Required<ProcessConfiguration> & {
     strict?: boolean;
+    hyperbeamUrl?: string;
 };
 type ANTConfigNoSigner = ANTConfigOptionalStrict;
 type ANTConfigWithSigner = WithSigner<ANTConfigOptionalStrict>;
@@ -15,7 +16,15 @@ export declare class AoANTReadable implements AoANTRead {
     protected process: AOProcess;
     readonly processId: string;
     private strict;
+    private hyperbeamUrl;
+    private checkHyperBeamPromise;
     constructor(config: ANTConfigOptionalStrict);
+    /**
+     * Check if the process is hyperbeam compatible. If so, we'll use the hyperbeam node to fetch the state.
+     *
+     * @returns {Promise<boolean>} True if the process is hyperbeam compatible, false otherwise.
+     */
+    private checkHyperBeamCompatibility;
     getState({ strict }?: AntReadOptions): Promise<AoANTState>;
     getInfo({ strict }?: AntReadOptions): Promise<AoANTInfo>;
     /**
@@ -279,7 +288,6 @@ export declare class AoANTWriteable extends AoANTReadable implements AoANTWrite
     /**
      * Releases an ArNS name associated with the ANT. This will release the name to the public and allow anyone to register it. All primary names must be removed before the name can be released.
      *
-     *
      * @param name @type {string} The name you want to release. The name will be put up for as a recently returned name on the ARIO contract. 50% of the winning bid will be distributed to the ANT owner at the time of purchase. If no purchase in the recently returned name period (14 epochs), the name will be released and can be reregistered by anyone.
      * @param arioProcessId @type {string} The processId of the ARIO contract. This is where the ANT will send the message to release the name.
      * @returns {Promise<AoMessageResult>} The result of the interaction.

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

@@ -21,4 +21,3 @@ export * from './ant-versions.js';
 export * from './faucet.js';
 export * from './io.js';
 export * from './contracts/ao-process.js';
-export * from './wayfinder/index.js';

package/lib/types/types/ant.d.ts

@@ -127,6 +127,23 @@ export declare const AntStateSchema: z.ZodObject<{
     Initialized: boolean;
 }>;
 export type AoANTState = z.infer<typeof AntStateSchema>;
+export type HyperBeamANTState = {
+    name: string;
+    ticker: string;
+    description: string;
+    keywords: string[];
+    denomination: string;
+    owner: string;
+    controllers: string[];
+    records: Record<string, {
+        transactionid: string;
+        ttlseconds: number;
+    }>;
+    balances: Record<string, number>;
+    logo: string;
+    totalsupply: number;
+    initialized: boolean;
+};
 export declare const SpawnANTStateSchema: z.ZodObject<{
     name: z.ZodString;
     ticker: z.ZodString;

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

@@ -353,15 +353,12 @@ export type AoBuyRecordParams = AoArNSPurchaseParams & {
     years?: number;
     type: 'lease' | 'permabuy';
     processId: string;
-    referrer?: string;
 };
 export type AoExtendLeaseParams = AoArNSPurchaseParams & {
     years: number;
-    referrer?: string;
 };
 export type AoIncreaseUndernameLimitParams = AoArNSPurchaseParams & {
     increaseCount: number;
-    referrer?: string;
 };
 export type AoVaultedTransferParams = {
     recipient: WalletAddress;

package/lib/types/utils/ant.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ANTRecords, SortedANTRecords } from '../types/ant.js';
+import { ANTRecords, AoANTState, HyperBeamANTState, SortedANTRecords } from '../types/ant.js';
 /**
  * Sorts ANT records by priority and then lexicographically.
  *
@@ -24,3 +24,9 @@ import { ANTRecords, SortedANTRecords } from '../types/ant.js';
  * @param antRecords - The ANT records to sort.
  */
 export declare const sortANTRecords: (antRecords: ANTRecords) => SortedANTRecords;
+/**
+ * Convert HyperBeam serialized ANT state to backwards compatible format.
+ *
+ * @param state - The HyperBeam serialized ANT state.
+ */
+export declare const convertHyperBeamStateToAoANTState: (state: HyperBeamANTState) => AoANTState;

package/lib/types/utils/hash.d.ts

@@ -1,8 +1,4 @@
-import { DataStream } from '../types/wayfinder.js';
-export declare const isAsyncIterable: <T = unknown>(x: any) => x is AsyncIterable<T>;
-export declare const isReadableStream: <T = unknown>(x: any) => x is ReadableStream<T>;
-export declare const readableStreamToAsyncIterable: (stream: ReadableStream<Uint8Array>) => AsyncIterable<Uint8Array>;
-export declare const hashDataStreamToB64Url: (stream: DataStream, algorithm?: string) => Promise<string>;
-export declare const convertDataStreamToDataRoot: ({ dataStream, }: {
-    dataStream: DataStream;
-}) => Promise<string>;
+import { Readable } from 'stream';
+export declare const hashReadableToB64Url: (stream: Readable, algorithm?: string) => Promise<string>;
+export declare const hashReadableStreamToB64Url: (stream: ReadableStream, algorithm?: string) => Promise<string>;
+export declare const hashBufferToB64Url: (buffer: Buffer, algorithm?: string) => string;

package/lib/types/version.d.ts

@@ -13,4 +13,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export declare const version = "3.13.0-alpha.1";
+export declare const version = "3.13.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ar.io/sdk",
-  "version": "3.13.0-beta.1",
+  "version": "3.14.0-alpha.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ar-io/ar-io-sdk.git"
@@ -136,7 +136,6 @@
     "eventemitter3": "^5.0.1",
     "plimit-lit": "^3.0.1",
     "prompts": "^2.4.2",
-    "rfc4648": "^1.5.4",
     "uuid": "^11.1.0",
     "winston": "^3.13.0",
     "zod": "^3.23.8"

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

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NetworkGatewaysProvider = void 0;
-const io_js_1 = require("../../io.js");
-class NetworkGatewaysProvider {
-    ario;
-    sortBy;
-    sortOrder;
-    limit;
-    filter;
-    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;
-        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}`));
-    }
-}
-exports.NetworkGatewaysProvider = NetworkGatewaysProvider;

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

@@ -1,35 +0,0 @@
-"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

@@ -1,13 +0,0 @@
-"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

@@ -1,48 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-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.
- */
-__exportStar(require("./wayfinder.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);
-__exportStar(require("./routing/strategies/preferred-with-fallback.js"), exports);
-// gateways providers
-__exportStar(require("./gateways/network.js"), exports);
-__exportStar(require("./gateways/simple-cache.js"), exports);
-__exportStar(require("./gateways/static.js"), exports);
-// trusted gateways
-__exportStar(require("./verification/trusted.js"), exports);
-// hash providers
-__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

@@ -1,72 +0,0 @@
-"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/preferred-with-fallback.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PreferredWithFallbackRoutingStrategy = void 0;
-const logger_js_1 = require("../../../logger.js");
-const ping_js_1 = require("./ping.js");
-class PreferredWithFallbackRoutingStrategy {
-    name = 'preferred-with-fallback';
-    preferredGateway;
-    fallbackStrategy;
-    logger;
-    constructor({ preferredGateway, fallbackStrategy = new ping_js_1.FastestPingRoutingStrategy(), logger = logger_js_1.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 });
-        }
-    }
-}
-exports.PreferredWithFallbackRoutingStrategy = PreferredWithFallbackRoutingStrategy;

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

@@ -1,13 +0,0 @@
-"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/round-robin.js

@@ -1,42 +0,0 @@
-"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/static.js

@@ -1,29 +0,0 @@
-"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;