@ar.io/sdk 3.10.0-alpha.5 → 3.10.0-alpha.6

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

@@ -0,0 +1,249 @@
+import axios from 'axios';
+import got from 'got';
+import assert from 'node:assert';
+import { buffer } from 'node:stream/consumers';
+import { before, describe, it } from 'node:test';
+import { RandomGatewayRouter } from './routers/random.js';
+import { Wayfinder } from './wayfinder.js';
+const stubbedGateway = {
+    status: 'joined',
+    gatewayAddress: 'arweave',
+    operatorStake: 1000,
+    totalDelegatedStake: 1000,
+    startTimestamp: 1000,
+    settings: {
+        protocol: 'https',
+        fqdn: 'arweave.net',
+        port: 443,
+    },
+};
+const stubbedGatewaysProvider = {
+    getGateways: async () => [stubbedGateway],
+};
+describe('Wayfinder', () => {
+    describe('http wrapper', () => {
+        describe('fetch', () => {
+            let wayfinder;
+            before(() => {
+                wayfinder = new Wayfinder({
+                    httpClient: fetch,
+                    router: new RandomGatewayRouter({
+                        gatewaysProvider: stubbedGatewaysProvider,
+                    }),
+                });
+            });
+            it('should fetch the data using the selected gateway', async () => {
+                const nativeFetch = await fetch('https://ao.arweave.net');
+                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);
+                assert.deepStrictEqual(await response.text(), await nativeFetch.text());
+            });
+            it('should route a non-ar:// url as a normal fetch', async () => {
+                const [nativeFetch, response] = await Promise.all([
+                    fetch('https://arweave.net/', {
+                        method: 'HEAD',
+                    }),
+                    wayfinder.request('https://arweave.net/', {
+                        method: 'HEAD',
+                    }),
+                ]);
+                assert.strictEqual(response.status, 200);
+                assert.strictEqual(response.status, nativeFetch.status);
+                // TODO: ensure the headers are the same excluding unique headers
+                assert.deepStrictEqual(await response.text(), await nativeFetch.text());
+            });
+            for (const api of ['/info', '/metrics', '/block/current']) {
+                it(`supports native arweave node apis ${api}`, async () => {
+                    const [nativeFetch, response] = await Promise.all([
+                        fetch(`https://arweave.net${api}`),
+                        wayfinder.request(`ar:///${api}`),
+                    ]);
+                    assert.strictEqual(response.status, 200);
+                    assert.strictEqual(response.status, nativeFetch.status);
+                    // TODO: ensure the headers are the same excluding unique headers
+                    assert.deepStrictEqual(await response.text(), await nativeFetch.text());
+                });
+            }
+            for (const api of ['/ar-io/info', '/ar-io/__gateway_metrics']) {
+                it(`supports native ario node gateway apis ${api}`, async () => {
+                    const [nativeFetch, response] = await Promise.all([
+                        fetch(`https://arweave.net${api}`),
+                        wayfinder.request(`ar:///${api}`),
+                    ]);
+                    assert.strictEqual(response.status, 200);
+                    assert.strictEqual(response.status, nativeFetch.status);
+                    // TODO: ensure the headers are the same excluding unique headers
+                    assert.deepStrictEqual(await response.text(), await nativeFetch.text());
+                });
+            }
+            it('supports a post request to graphql', async () => {
+                const response = await wayfinder.request('ar:///graphql', {
+                    method: 'POST',
+                    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://arweave.net/not-found'),
+                    wayfinder.request('https://arweave.net/not-found'),
+                ]);
+                assert.strictEqual(response.status, nativeFetch.status);
+                assert.strictEqual(response.statusText, nativeFetch.statusText);
+                assert.deepStrictEqual(await response.text(), await nativeFetch.text());
+            });
+        });
+        describe('axios', () => {
+            let wayfinder;
+            before(() => {
+                wayfinder = new Wayfinder({
+                    httpClient: axios,
+                    router: new RandomGatewayRouter({
+                        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.arweave.net'),
+                    wayfinder.request('ar://ao'),
+                ]);
+                assert.strictEqual(response.status, 200);
+                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());
+                assert.deepStrictEqual(response.data, nativeAxios.data);
+            });
+            it('should fetch the data using the axios.get method against the target gateway', async () => {
+                const [nativeAxios, response] = await Promise.all([
+                    axios.get('https://ao.arweave.net'),
+                    wayfinder.request.get('ar://ao'),
+                ]);
+                assert.strictEqual(response.status, 200);
+                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());
+                assert.deepStrictEqual(response.data, nativeAxios.data);
+            });
+            it('should route a non-ar:// url as a normal axios request', async () => {
+                const [nativeAxios, response] = await Promise.all([
+                    axios('https://arweave.net/'),
+                    wayfinder.request('https://arweave.net/'),
+                ]);
+                assert.strictEqual(response.status, 200);
+                assert.strictEqual(response.status, nativeAxios.status);
+                assert.deepStrictEqual(response.data, nativeAxios.data);
+                // TODO: ensure the headers are the same excluding unique headers
+            });
+            for (const api of ['/info', '/metrics', '/block/current']) {
+                it(`supports native arweave node apis ${api}`, async () => {
+                    const [nativeAxios, response] = await Promise.all([
+                        axios(`https://arweave.net${api}`),
+                        wayfinder.request(`ar:///${api}`),
+                    ]);
+                    assert.strictEqual(response.status, 200);
+                    assert.strictEqual(response.status, nativeAxios.status);
+                    // TODO: ensure the headers are the same excluding unique headers
+                    assert.deepStrictEqual(response.data, nativeAxios.data);
+                });
+            }
+            for (const api of ['/ar-io/info', '/ar-io/__gateway_metrics']) {
+                it(`supports native ario node gateway apis ${api}`, async () => {
+                    const [nativeAxios, response] = await Promise.all([
+                        axios(`https://arweave.net${api}`),
+                        wayfinder.request(`ar:///${api}`),
+                    ]);
+                    assert.strictEqual(response.status, 200);
+                    assert.strictEqual(response.status, nativeAxios.status);
+                    // TODO: ensure the headers are the same excluding unique headers
+                    assert.deepStrictEqual(response.data, nativeAxios.data);
+                });
+            }
+            it('should return the error from the target gateway if the route is not found', async () => {
+                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,
+                    router: new RandomGatewayRouter({
+                        gatewaysProvider: stubbedGatewaysProvider,
+                    }),
+                });
+                const [nativeAxios, response] = await Promise.all([
+                    axiosInstance('https://arweave.net/not-found'),
+                    wayfinder.request('https://arweave.net/not-found'),
+                ]);
+                assert.strictEqual(response.status, nativeAxios.status);
+                assert.strictEqual(response.data, nativeAxios.data);
+            });
+        });
+    });
+    describe('got', () => {
+        let wayfinder;
+        before(() => {
+            wayfinder = new Wayfinder({
+                httpClient: got,
+                router: new RandomGatewayRouter({
+                    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.arweave.net'),
+                wayfinder.request('ar://ao'),
+            ]);
+            assert.strictEqual(response.statusCode, 200);
+            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.arweave.net', { decompress: false }));
+            const wayfinderBuffer = await buffer(await wayfinder.request.stream('ar://ao', { decompress: false }));
+            assert.deepStrictEqual(wayfinderBuffer, nativeBuffer);
+        });
+    });
+    // TODO: streaming support using got.stream and got()
+});

package/lib/esm/types/index.js

@@ -19,3 +19,4 @@ export * from './common.js';
 export * from './faucet.js';
 export * from './io.js';
 export * from './token.js';
+export * from './wayfinder.js';

package/lib/esm/types/wayfinder.js

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

package/lib/esm/version.js

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

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

@@ -21,3 +21,4 @@ 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/common/io.d.ts

@@ -141,7 +141,6 @@ export declare class ARIOReadable implements AoARIORead {
     getAllGatewayVaults(params?: PaginationParams<AoAllGatewayVaults>): Promise<PaginationResult<AoAllGatewayVaults>>;
 }
 export declare class ARIOWriteable extends ARIOReadable implements AoARIOWrite {
-    readonly process: AOProcess;
     private signer;
     protected paymentProvider: TurboArNSPaymentProviderAuthenticated | TurboArNSPaymentProviderUnauthenticated;
     constructor({ signer, paymentUrl, ...config }: ARIOConfigWithSigner);

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

@@ -0,0 +1,44 @@
+/**
+ * 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';
+export interface GatewaysProvider {
+    getGateways(): Promise<AoGatewayWithAddress[]>;
+}
+export declare class ARIOGatewaysProvider implements GatewaysProvider {
+    private ario;
+    constructor({ ario }: {
+        ario: AoARIORead;
+    });
+    getGateways(): Promise<AoGatewayWithAddress[]>;
+}
+export declare class StaticGatewaysProvider implements GatewaysProvider {
+    private gateways;
+    constructor({ gateways }: {
+        gateways: AoGatewayWithAddress[];
+    });
+    getGateways(): Promise<AoGatewayWithAddress[]>;
+}
+export declare class SimpleCacheGatewaysProvider implements GatewaysProvider {
+    private gatewaysProvider;
+    private ttlSeconds;
+    private lastUpdated;
+    private gatewaysCache;
+    constructor({ gatewaysProvider, ttlSeconds, }: {
+        gatewaysProvider: GatewaysProvider;
+        ttlSeconds?: number;
+    });
+    getGateways(): Promise<AoGatewayWithAddress[]>;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * 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 './routers/random.js';
+export * from './routers/priority.js';
+export * from './routers/fixed.js';

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

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+/**
+ * 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 { WayfinderRouter } from '../../../types/wayfinder.js';
+export declare class FixedGatewayRouter implements WayfinderRouter {
+    readonly name = "fixed";
+    private gateway;
+    constructor({ gateway }: {
+        gateway: URL;
+    });
+    getTargetGateway(): Promise<URL>;
+}

package/lib/types/common/wayfinder/routers/fixed.test.d.ts

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

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

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+/**
+ * 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 { WayfinderRouter } from '../../../types/wayfinder.js';
+import { GatewaysProvider } from '../gateways.js';
+export declare class PriorityGatewayRouter implements WayfinderRouter {
+    readonly name = "priority";
+    private gatewaysProvider;
+    private limit;
+    private sortBy;
+    private sortOrder;
+    private blocklist;
+    constructor({ gatewaysProvider, limit, sortBy, sortOrder, blocklist, }: {
+        gatewaysProvider: GatewaysProvider;
+        limit?: number;
+        sortBy?: 'totalDelegatedStake' | 'operatorStake' | 'startTimestamp';
+        sortOrder?: 'asc' | 'desc';
+        blocklist?: string[];
+    });
+    getTargetGateway(): Promise<URL>;
+}

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

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

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

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+/**
+ * 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 { WayfinderRouter } from '../../../types/wayfinder.js';
+import { GatewaysProvider } from '../gateways.js';
+export declare class RandomGatewayRouter implements WayfinderRouter {
+    readonly name = "random";
+    private gatewaysProvider;
+    private blocklist;
+    constructor({ gatewaysProvider, blocklist, }: {
+        gatewaysProvider: GatewaysProvider;
+        blocklist?: string[];
+    });
+    getTargetGateway(): Promise<URL>;
+}

package/lib/types/common/wayfinder/routers/random.test.d.ts

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

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

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+/**
+ * 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 { WayfinderRouter } from '../../../types/wayfinder.js';
+export declare class SimpleCacheRouter implements WayfinderRouter {
+    readonly name: 'simple-cache';
+    private lastUpdatedTimestamp;
+    private ttlSeconds;
+    private targetGateway;
+    private router;
+    constructor({ router, ttlSeconds, }: {
+        router: WayfinderRouter;
+        ttlSeconds?: number;
+    });
+    getTargetGateway(): Promise<URL>;
+}

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

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

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

@@ -0,0 +1,106 @@
+/// <reference types="node" />
+import { WayfinderRouter } from '../../types/wayfinder.js';
+type AnyFunction = (...args: [string, ...unknown[]]) => unknown;
+type WayfinderHttpClient<T extends AnyFunction> = T;
+export declare const arnsRegex: RegExp;
+export declare const txIdRegex: RegExp;
+/**
+ * Cryptographically secure helper for randomness, does not support seeding
+ * @param min - the minimum value
+ * @param max - the maximum value
+ * @returns a random integer between min and max
+ */
+export declare const randomInt: (min: number, max: number) => number;
+/**
+ * Core function to resolve a wayfinder url against a target gateway
+ * @param originalUrl - the wayfinder url to resolve
+ * @param targetGateway - the target gateway to resolve the url against
+ * @returns the resolved url that can be used to make a request
+ */
+export declare const resolveWayfinderUrl: ({ originalUrl, targetGateway, }: {
+    originalUrl: string | URL;
+    targetGateway: string | URL;
+}) => URL;
+/**
+ * Creates a wrapped http client that supports ar:// protocol
+ *
+ * This function leverages a Proxy to intercept calls to the http client
+ * and redirects them to the target gateway using the resolveUrl function url.
+ * It also supports the http client methods like get(), post(), put(), delete(), etc.
+ *
+ * Any URLs provided that are not wayfinder urls will be returned as is.
+ *
+ * @param httpClient - the http client to wrap (e.g. axios, fetch, got, etc.)
+ * @param resolveUrl - the function to construct the redirect url for ar:// requests
+ * @returns a wrapped http client that supports ar:// protocol
+ */
+export declare const createWayfinderClient: <T extends AnyFunction>({ httpClient, resolveUrl, }: {
+    httpClient: T;
+    resolveUrl: (params: {
+        originalUrl: string | URL;
+    }) => Promise<URL>;
+}) => WayfinderHttpClient<T>;
+/**
+ * The main class for the wayfinder
+ * @param router - the router to use for requests
+ * @param httpClient - the http client to use for requests
+ * @param blocklist - the blocklist of gateways to avoid
+ */
+export declare class Wayfinder<T extends AnyFunction> {
+    /**
+     * The router to use for requests
+     *
+     * @example
+     * const wayfinder = new Wayfinder({
+     *   router: new RandomGatewayRouter({ ario: ARIO.mainnet() }),
+     * });
+     */
+    readonly router: WayfinderRouter;
+    /**
+     * The http client to use for requests
+     *
+     * @example
+     * const wayfinder = new Wayfinder({
+     *   router: new RandomGatewayRouter({ ario: ARIO.mainnet() }),
+     *   httpClient: axios,
+     * });
+     */
+    readonly httpClient: T;
+    /**
+     * The function that resolves the redirect url for ar:// requests to a target gateway
+     *
+     * @example
+     * const wayfinder = new Wayfinder({
+     *   router: new RandomGatewayRouter({ ario: ARIO.mainnet() }),
+     *   httpClient: axios,
+     * });
+     *
+     * const redirectUrl = await wayfinder.resolveUrl({ originalUrl: 'ar://example' });
+     */
+    readonly resolveUrl: (params: {
+        originalUrl: string;
+    }) => Promise<URL>;
+    /**
+     * A wrapped http client that supports ar:// protocol
+     *
+     * @example
+     * const { request: wayfind } = new Wayfinder({
+     *   router: new RandomGatewayRouter({ ario: ARIO.mainnet() }),
+     *   httpClient: axios,
+     * });;
+     *
+     * TODO: consider a top level function that supports wayfinder routing under the hood
+     * const response = await wayfind('ar://', {
+     *   method: 'POST',
+     *   data: {
+     *     name: 'John Doe',
+     *   },
+     * })
+     */
+    readonly request: WayfinderHttpClient<T>;
+    constructor({ router, httpClient, }: {
+        router: WayfinderRouter;
+        httpClient: T;
+    });
+}
+export {};

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

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

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

@@ -19,3 +19,4 @@ export * from './common.js';
 export * from './faucet.js';
 export * from './io.js';
 export * from './token.js';
+export * from './wayfinder.js';

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

@@ -421,6 +421,7 @@ export type DemandFactorSettings = {
     criteria: string;
 };
 export interface AoARIORead {
+    process: AOProcess;
     getInfo(): Promise<{
         Ticker: string;
         Name: string;

package/lib/types/types/token.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 interface Equatable<T> {
     equals(other: T): boolean;
 }

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

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+/**
+ * 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 interface WayfinderRouter {
+    readonly name: string;
+    getTargetGateway: () => Promise<URL>;
+}

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

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 export declare function fromB64Url(str: string): Buffer;
 export declare function toB64Url(buffer: Buffer): string;
 export declare function sha256B64Url(input: Buffer): 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.10.0-alpha.4";
+export declare const version = "3.10.0-alpha.5";