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

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

@@ -1,514 +0,0 @@
-import axios from 'axios';
-import got from 'got';
-import assert from 'node:assert';
-import { EventEmitter } from 'node:events';
-import { Readable } from 'node:stream';
-import { buffer } from 'node:stream/consumers';
-import { before, describe, it } from 'node:test';
-import { Logger } from '../../common/logger.js';
-import { RandomRoutingStrategy } from './routing/strategies/random.js';
-import { StaticRoutingStrategy } from './routing/strategies/static.js';
-import { Wayfinder, tapAndVerifyStream } from './wayfinder.js';
-// TODO: replace with locally running gateway
-const gatewayUrl = 'permagate.io';
-const stubbedGatewaysProvider = {
-    getGateways: async () => [new URL(`http://${gatewayUrl}`)],
-};
-Logger.default.setLogLevel('none');
-describe('Wayfinder', () => {
-    describe('http wrapper', () => {
-        describe('fetch', () => {
-            let wayfinder;
-            before(() => {
-                wayfinder = new Wayfinder({
-                    httpClient: fetch,
-                    routingStrategy: new RandomRoutingStrategy(),
-                    gatewaysProvider: stubbedGatewaysProvider,
-                });
-            });
-            it('should fetch the data using the selected gateway', async () => {
-                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);
-                // assert the arns headers are the same
-                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);
-            });
-            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://${gatewayUrl}/`, {
-                        method: 'HEAD',
-                        redirect: 'follow',
-                    }),
-                    wayfinder.request(`https://${gatewayUrl}/`, {
-                        method: 'HEAD',
-                        redirect: 'follow',
-                    }),
-                ]);
-                assert.strictEqual(response.status, 200);
-                assert.strictEqual(response.status, nativeFetch.status);
-                // TODO: ensure the headers are the same excluding unique headers
-            });
-            for (const api of ['/info', '/block/current']) {
-                it.skip(`supports native arweave node apis ${api}`, async () => {
-                    const [nativeFetch, response] = await Promise.all([
-                        fetch(`https://${gatewayUrl}${api}`, {
-                            redirect: 'follow',
-                        }),
-                        wayfinder.request(`ar://${api}`, {
-                            redirect: 'follow',
-                        }),
-                    ]);
-                    assert.strictEqual(response.status, 200);
-                    assert.strictEqual(response.status, nativeFetch.status);
-                    // TODO: ensure the headers are the same excluding unique headers
-                });
-            }
-            for (const api of ['/ar-io/info']) {
-                it(`supports native ario node gateway apis ${api}`, async () => {
-                    const [nativeFetch, response] = await Promise.all([
-                        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
-                });
-            }
-            it('supports a post request to graphql', async () => {
-                const response = await wayfinder.request('ar:///graphql', {
-                    method: 'POST',
-                    redirect: 'follow',
-                    headers: {
-                        'Content-Type': 'application/json',
-                    },
-                    body: JSON.stringify({
-                        query: `
-                query {
-                  transactions(
-                    ids: ["xf958qhCNGfDme1FtoiD6DtMfDENDbtxZpjOM_1tsMM"]
-                  ) {
-                    edges {
-                      cursor
-                      node {
-                        id
-                        tags {
-                          name
-                          value
-                        }
-                        block {
-                          height
-                          timestamp
-                        }
-                      }
-                    }
-                    pageInfo {
-                      hasNextPage
-                    }
-                  }
-                }
-            `,
-                    }),
-                });
-                assert.strictEqual(response.status, 200);
-            });
-            it('returns the error from the target gateway if the route is not found', async () => {
-                const [nativeFetch, response] = await Promise.all([
-                    fetch(`https://${gatewayUrl}/ar-io/not-found`, {
-                        redirect: 'follow',
-                    }),
-                    wayfinder.request('ar:///ar-io/not-found', {
-                        redirect: 'follow',
-                    }),
-                ]);
-                assert.strictEqual(response.status, nativeFetch.status);
-                assert.strictEqual(response.statusText, nativeFetch.statusText);
-            });
-        });
-        describe('axios', () => {
-            let wayfinder;
-            before(() => {
-                wayfinder = new Wayfinder({
-                    httpClient: axios,
-                    routingStrategy: new RandomRoutingStrategy(),
-                    gatewaysProvider: stubbedGatewaysProvider,
-                });
-            });
-            it('should fetch the data using axios default function against the target gateway', async () => {
-                const [nativeAxios, response] = await Promise.all([
-                    axios(`https://ao.${gatewayUrl}`),
-                    wayfinder.request('ar://ao', {
-                        maxRedirects: 5,
-                    }),
-                ]);
-                assert.strictEqual(response.status, nativeAxios.status);
-                // assert the arns headers are the same
-                const arnsHeaders = Object.entries(response.headers)
-                    .sort()
-                    .filter(([key]) => key.startsWith('x-arns-'));
-                const nativeAxiosHeaders = Object.entries(nativeAxios.headers).filter(([key]) => key.startsWith('x-arns-'));
-                assert.deepStrictEqual(arnsHeaders.sort(), nativeAxiosHeaders.sort());
-            });
-            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.${gatewayUrl}`),
-                    wayfinder.request.get('ar://ao'),
-                ]);
-                assert.strictEqual(response.status, nativeAxios.status);
-                // assert the arns headers are the same
-                const arnsHeaders = Object.entries(response.headers)
-                    .sort()
-                    .filter(([key]) => key.startsWith('x-arns-'));
-                const nativeAxiosHeaders = Object.entries(nativeAxios.headers).filter(([key]) => key.startsWith('x-arns-'));
-                assert.deepStrictEqual(arnsHeaders.sort(), nativeAxiosHeaders.sort());
-            });
-            it('should route a non-ar:// url as a normal axios request', async () => {
-                const [nativeAxios, response] = await Promise.all([
-                    axios(`https://${gatewayUrl}/`),
-                    wayfinder.request(`https://${gatewayUrl}/`),
-                ]);
-                assert.strictEqual(response.status, 200);
-                assert.strictEqual(response.status, nativeAxios.status);
-                // TODO: ensure the headers are the same excluding unique headers
-            });
-            for (const api of ['/info', '/block/current']) {
-                it.skip(`supports native arweave node apis ${api}`, async () => {
-                    const [nativeAxios, response] = await Promise.all([
-                        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
-                });
-            }
-            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://${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
-                });
-            }
-            it('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
-                });
-                const wayfinder = new Wayfinder({
-                    httpClient: axiosInstance,
-                    routingStrategy: new RandomRoutingStrategy(),
-                });
-                const [nativeAxios, response] = await Promise.all([
-                    axiosInstance(`https://${gatewayUrl}/ar-io/not-found`),
-                    wayfinder.request('ar:///ar-io/not-found'),
-                ]);
-                assert.strictEqual(response.status, nativeAxios.status);
-            });
-        });
-        describe('got', () => {
-            let wayfinder;
-            before(() => {
-                wayfinder = new Wayfinder({
-                    httpClient: got,
-                    routingStrategy: new RandomRoutingStrategy(),
-                    gatewaysProvider: stubbedGatewaysProvider,
-                });
-            });
-            it('should fetch the data using the got default function against the target gateway', async () => {
-                const [nativeGot, response] = await Promise.all([
-                    got(`https://ao.${gatewayUrl}`),
-                    wayfinder.request('ar://ao'),
-                ]);
-                assert.strictEqual(response.statusCode, nativeGot.statusCode);
-                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.${gatewayUrl}`, {
-                    decompress: false,
-                    followRedirect: true,
-                }));
-                const wayfinderBuffer = await buffer(await wayfinder.request.stream('ar://ao', {
-                    decompress: false,
-                    followRedirect: true,
-                }));
-                assert.deepStrictEqual(wayfinderBuffer, nativeBuffer);
-            });
-        });
-    });
-    describe('events', () => {
-        it('should emit events on the wayfinder event emitter', async () => {
-            const wayfinder = new Wayfinder({
-                httpClient: fetch,
-                routingStrategy: new StaticRoutingStrategy({
-                    gateway: `http://${gatewayUrl}`,
-                }),
-                verificationStrategy: {
-                    // @ts-expect-error
-                    verifyData: async (params) => {
-                        return;
-                    },
-                },
-            });
-            const events = [];
-            wayfinder.emitter.on('verification-failed', (event) => {
-                events.push({ type: 'verification-failed', ...event });
-            });
-            wayfinder.emitter.on('verification-progress', (event) => {
-                events.push({ type: 'verification-progress', ...event });
-            });
-            wayfinder.emitter.on('verification-succeeded', (event) => {
-                events.push({ type: 'verification-succeeded', ...event });
-            });
-            // request data and assert the event is emitted
-            const response = await wayfinder.request('ar://c7wkwt6TKgcWJUfgvpJ5q5qi4DIZyJ1_TqhjXgURh0U', {
-                redirect: 'follow',
-            });
-            // read the full response body to ensure the stream is fully consumed
-            await response.text();
-            assert.strictEqual(response.status, 200);
-            assert.ok(events.find((e) => e.type === 'verification-succeeded'), 'Should emit at least one verification-succeeded');
-        });
-        it('should execute callbacks provided to the wayfinder constructor', async () => {
-            let verificationFailed = false;
-            let verificationProgress = false;
-            let verificationPassed = false;
-            const wayfinder = new Wayfinder({
-                httpClient: fetch,
-                routingStrategy: new StaticRoutingStrategy({
-                    gateway: `http://${gatewayUrl}`,
-                }),
-                events: {
-                    onVerificationFailed: () => {
-                        verificationFailed = true;
-                    },
-                    onVerificationProgress: () => {
-                        verificationProgress = true;
-                    },
-                    onVerificationPassed: () => {
-                        verificationPassed = true;
-                    },
-                },
-                strict: true,
-            });
-            const response = await wayfinder.request('ar://c7wkwt6TKgcWJUfgvpJ5q5qi4DIZyJ1_TqhjXgURh0U', {
-                redirect: 'follow',
-            });
-            // read the full response body to ensure the stream is fully consumed
-            await response.text();
-            assert.strictEqual(response.status, 200);
-            assert.ok(verificationFailed === false, 'Should not emit verification-failed');
-            assert.ok(verificationProgress, 'Should emit verification-progress');
-            assert.ok(verificationPassed, 'Should emit verification-succeeded');
-        });
-    });
-    describe('tapAndVerifyRequest', () => {
-        describe('Readable', () => {
-            describe('strict mode enabled', () => {
-                it('should duplicate the stream, verify the first and return the second if verification passes', async () => {
-                    // create a simple readable
-                    const chunks = [
-                        Buffer.from('foo'),
-                        Buffer.from('bar'),
-                        Buffer.from('baz'),
-                    ];
-                    const contentLength = chunks.reduce((sum, c) => sum + c.length, 0);
-                    // a stream that will emit chunks
-                    const originalStream = Readable.from(chunks);
-                    let seen = Buffer.alloc(0);
-                    const verifyData = async ({ data, 
-                    // @ts-expect-error
-                    txId, }) => {
-                        return new Promise((resolve, reject) => {
-                            data.on('data', (chunk) => {
-                                seen = Buffer.concat([seen, chunk]);
-                            });
-                            data.on('end', () => {
-                                // Should have seen exactly the full payload
-                                assert.strictEqual(seen.length, contentLength);
-                                resolve();
-                            });
-                            data.on('error', reject);
-                        });
-                    };
-                    const txId = 'test-tx-1';
-                    const emitter = new EventEmitter();
-                    const events = [];
-                    emitter.on('verification-progress', (e) => {
-                        events.push({ type: 'verification-progress', ...e });
-                    });
-                    emitter.on('verification-succeeded', (e) => events.push({ type: 'verification-succeeded', ...e }));
-                    // tap with verification
-                    const tapped = tapAndVerifyStream({
-                        originalStream,
-                        contentLength,
-                        verifyData,
-                        txId,
-                        emitter,
-                        strict: true,
-                    });
-                    // read the stream
-                    const out = [];
-                    for await (const chunk of tapped) {
-                        out.push(chunk);
-                    }
-                    // assert the stream is the same
-                    assert.strictEqual(Buffer.concat(out).toString(), Buffer.concat(chunks).toString(), 'The tapped stream should emit exactly the original data');
-                    assert.ok(events.find((e) => e.type === 'verification-progress'), 'Should emit at least one verification-progress');
-                    assert.ok(events.find((e) => e.type === 'verification-succeeded' && e.txId === txId), 'Should emit at least one verification-succeeded');
-                });
-                it('should throw an error on the client stream if verification fails', async () => {
-                    const chunks = [
-                        Buffer.from('foo'),
-                        Buffer.from('bar'),
-                        Buffer.from('baz'),
-                    ];
-                    const contentLength = chunks.reduce((sum, c) => sum + c.length, 0);
-                    // a stream that will emit chunks
-                    const originalStream = Readable.from(chunks);
-                    const verifyData = async ({ 
-                    // @ts-expect-error
-                    data, txId, }) => {
-                        throw new Error('Verification failed for txId: ' + txId);
-                    };
-                    const txId = 'test-tx-1';
-                    const emitter = new EventEmitter();
-                    const events = [];
-                    emitter.on('verification-progress', (e) => events.push({ type: 'verification-progress', ...e }));
-                    emitter.on('verification-failed', (e) => events.push({ type: 'verification-failed', ...e }));
-                    // tap with verification (using strict mode)
-                    const tapped = tapAndVerifyStream({
-                        originalStream,
-                        contentLength,
-                        verifyData,
-                        txId,
-                        emitter,
-                        strict: true,
-                    });
-                    // read the stream
-                    try {
-                        const out = [];
-                        for await (const chunk of tapped) {
-                            out.push(chunk);
-                        }
-                    }
-                    catch (error) {
-                        assert.ok(events.find((e) => e.type === 'verification-failed' && e.txId === txId), 'Should emit at least one verification-failed');
-                        // stream should be closed
-                        assert.ok(tapped.closed);
-                    }
-                });
-            });
-        });
-        describe('ReadableStream', () => {
-            describe('strict mode enabled', () => {
-                it('should duplicate the ReadableStream, verify the first and return the second if verification passes', async () => {
-                    // create a simple readable
-                    const chunks = [
-                        Buffer.from('foo'),
-                        Buffer.from('bar'),
-                        Buffer.from('baz'),
-                    ];
-                    const contentLength = chunks.reduce((sum, c) => sum + c.length, 0);
-                    // a stream that will emit chunks
-                    const originalStream = ReadableStream.from(chunks);
-                    let seen = Buffer.alloc(0);
-                    const verifyData = async ({ data, 
-                    // @ts-expect-error
-                    txId, }) => {
-                        return new Promise(async (resolve, reject) => {
-                            const reader = data.getReader();
-                            while (true) {
-                                try {
-                                    const { done, value } = await reader.read();
-                                    if (done) {
-                                        resolve();
-                                        break;
-                                    }
-                                    seen = Buffer.concat([seen, value]);
-                                }
-                                catch (error) {
-                                    reject(error);
-                                }
-                            }
-                        });
-                    };
-                    const txId = 'test-tx-1';
-                    const emitter = new EventEmitter();
-                    const events = [];
-                    emitter.on('verification-progress', (e) => events.push({ type: 'verification-progress', ...e }));
-                    emitter.on('verification-succeeded', (e) => events.push({ type: 'verification-succeeded', ...e }));
-                    // tap with verification
-                    const tapped = tapAndVerifyStream({
-                        originalStream,
-                        contentLength,
-                        verifyData,
-                        txId,
-                        emitter,
-                        strict: true,
-                    });
-                    // read the stream
-                    const out = [];
-                    for await (const chunk of tapped) {
-                        out.push(chunk);
-                    }
-                    // assert the stream is the same
-                    assert.strictEqual(Buffer.concat(out).toString(), Buffer.concat(chunks).toString(), 'The tapped stream should emit exactly the original data');
-                    assert.ok(events.find((e) => e.type === 'verification-progress'), 'Should emit at least one verification-progress');
-                    assert.ok(events.find((e) => e.type === 'verification-succeeded' && e.txId === txId), 'Should emit at least one verification-succeeded');
-                });
-                it('should throw an error on the client stream if verification fails', async () => {
-                    const chunks = [
-                        Buffer.from('foo'),
-                        Buffer.from('bar'),
-                        Buffer.from('baz'),
-                    ];
-                    const contentLength = chunks.reduce((sum, c) => sum + c.length, 0);
-                    // a stream that will emit chunks
-                    const originalStream = ReadableStream.from(chunks);
-                    const verifyData = async ({ 
-                    // @ts-expect-error
-                    data, txId, }) => {
-                        throw new Error('Verification failed for txId: ' + txId);
-                    };
-                    const txId = 'test-tx-1';
-                    const emitter = new EventEmitter();
-                    const events = [];
-                    emitter.on('verification-progress', (e) => events.push({ type: 'verification-progress', ...e }));
-                    emitter.on('verification-failed', (e) => events.push({ type: 'verification-failed', ...e }));
-                    // tap with verification (using strict mode)
-                    const tapped = tapAndVerifyStream({
-                        originalStream,
-                        contentLength,
-                        verifyData,
-                        txId,
-                        emitter,
-                        strict: true,
-                    });
-                    // read the stream
-                    try {
-                        const out = [];
-                        for await (const chunk of tapped) {
-                            out.push(chunk);
-                        }
-                    }
-                    catch (error) {
-                        assert.ok(events.find((e) => e.type === 'verification-failed' && e.txId === txId), 'Should emit at least one verification-failed');
-                    }
-                });
-            });
-        });
-    });
-});

package/lib/esm/types/wayfinder.js

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

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

@@ -1,33 +0,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.
- */
-import { AoARIORead, AoGatewayWithAddress } from '../../../types/io.js';
-import { GatewaysProvider } from '../../../types/wayfinder.js';
-export declare class NetworkGatewaysProvider implements GatewaysProvider {
-    private 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<URL[]>;
-}

package/lib/types/common/wayfinder/gateways/simple-cache.d.ts

@@ -1,31 +0,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.
- */
-import { GatewaysProvider } from '../../../types/wayfinder.js';
-import { Logger } from '../../../web/index.js';
-export declare class SimpleCacheGatewaysProvider implements GatewaysProvider {
-    private gatewaysProvider;
-    private ttlSeconds;
-    private lastUpdated;
-    private gatewaysCache;
-    private logger;
-    constructor({ gatewaysProvider, ttlSeconds, // 1 hour
-    logger, }: {
-        gatewaysProvider: GatewaysProvider;
-        ttlSeconds?: number;
-        logger?: Logger;
-    });
-    getGateways(): Promise<URL[]>;
-}

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

@@ -1,23 +0,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.
- */
-import { GatewaysProvider } from '../../../types/wayfinder.js';
-export declare class StaticGatewaysProvider implements GatewaysProvider {
-    private gateways;
-    constructor({ gateways }: {
-        gateways: string[];
-    });
-    getGateways(): Promise<URL[]>;
-}

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

@@ -1,26 +0,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.
- */
-export * from './wayfinder.js';
-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 './gateways/network.js';
-export * from './gateways/simple-cache.js';
-export * from './gateways/static.js';
-export * from './verification/trusted.js';
-export * from './verification/strategies/data-root-verifier.js';
-export * from './verification/strategies/hash-verifier.js';

package/lib/types/common/wayfinder/routing/strategies/ping.d.ts

@@ -1,27 +0,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.
- */
-import { RoutingStrategy } from '../../../../types/wayfinder.js';
-export declare class FastestPingRoutingStrategy implements RoutingStrategy {
-    private timeoutMs;
-    private probePath;
-    constructor({ timeoutMs, probePath, }?: {
-        timeoutMs?: number;
-        probePath?: string;
-    });
-    selectGateway({ gateways }: {
-        gateways: URL[];
-    }): Promise<URL>;
-}

package/lib/types/common/wayfinder/routing/strategies/ping.test.d.ts

@@ -1 +0,0 @@
-export {};