@ar.io/sdk 3.12.0-alpha.1 → 3.12.0-beta.1

package/lib/esm/types/wayfinder.js

@@ -0,0 +1,2 @@
+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/esm/utils/json.js

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function safeDecode(data) {
     try {
         return JSON.parse(data);

package/lib/esm/utils/url.js

@@ -25,7 +25,9 @@ export const urlWithSearchParams = ({ baseUrl, params, }) => {
                 urlObj.searchParams.append(key, v.toString());
             }
         }
-        urlObj.searchParams.set(key, value.toString());
+        else {
+            urlObj.searchParams.set(key, value.toString());
+        }
     });
     return urlObj.toString();
 };

package/lib/esm/version.js

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

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/wayfinder/gateways/network.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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

@@ -0,0 +1,31 @@
+/**
+ * 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

@@ -0,0 +1,23 @@
+/**
+ * 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

@@ -0,0 +1,26 @@
+/**
+ * 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

@@ -0,0 +1,27 @@
+/**
+ * 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/random.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 RandomRoutingStrategy implements RoutingStrategy {
+    selectGateway({ gateways }: {
+        gateways: URL[];
+    }): Promise<URL>;
+}

package/lib/types/common/wayfinder/routing/strategies/round-robin.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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';
+import { RoutingStrategy } from '../../../../types/wayfinder.js';
+export declare class RoundRobinRoutingStrategy implements RoutingStrategy {
+    private gateways;
+    private currentIndex;
+    private logger;
+    constructor({ gateways, logger, }: {
+        gateways: URL[];
+        logger?: Logger;
+    });
+    selectGateway({ gateways, }?: {
+        gateways?: URL[];
+    }): Promise<URL>;
+}

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

@@ -0,0 +1,29 @@
+/**
+ * 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';
+import { Logger } from '../../../logger.js';
+export declare class StaticRoutingStrategy implements RoutingStrategy {
+    readonly name = "static";
+    private gateway;
+    private logger;
+    constructor({ gateway, logger, }: {
+        gateway: string;
+        logger?: Logger;
+    });
+    selectGateway({ gateways, }?: {
+        gateways?: URL[];
+    }): Promise<URL>;
+}

package/lib/types/common/wayfinder/verification/strategies/data-root-verifier.d.ts

@@ -0,0 +1,31 @@
+import { Readable } from 'node:stream';
+import { DataRootProvider, DataVerificationStrategy } from '../../../../types/wayfinder.js';
+export declare function convertBufferToDataRoot({ buffer, }: {
+    buffer: Buffer;
+}): Promise<string>;
+export declare const convertReadableToDataRoot: <T extends AsyncIterable<Uint8Array>>({ iterable, }: {
+    iterable: T;
+}) => Promise<string>;
+export declare class DataRootVerificationStrategy implements DataVerificationStrategy {
+    private readonly trustedDataRootProvider;
+    constructor({ trustedDataRootProvider, }: {
+        trustedDataRootProvider: DataRootProvider;
+    });
+    verifyData({ data, txId, }: {
+        data: Buffer | Readable | ReadableStream;
+        txId: string;
+    }): Promise<void>;
+}
+/**
+ * - when you get a signature of a data item, you can only verify the owner
+ * - you still need to verify it's going back to the bundle, unpack it, and verify the data item exists at the offset
+ * - you need to the location of the chunks for the data item, and prove it's in the chunk and then prove the data root of the bundle, then you have fully verified the data verifier
+ * - how to prove the data item is on arweave - verify the merkle hash that the chunks for the data item, fit within the expected tree of the parent bundle
+ *
+ * Composite verifier - you'll want to be very efficient with streams
+ * - hash verifier
+ * - parent chunks verifier --> for any range of data within a single transaction, tell me that it's correct
+ * - signature verifier
+ * - offset verifier
+ * - data item verifier
+ */

package/lib/types/common/wayfinder/verification/strategies/hash-verifier.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 { Readable } from 'node:stream';
+import { DataHashProvider, DataVerificationStrategy } from '../../../../types/wayfinder.js';
+export declare class HashVerificationStrategy implements DataVerificationStrategy {
+    private readonly trustedHashProvider;
+    constructor({ trustedHashProvider, }: {
+        trustedHashProvider: DataHashProvider;
+    });
+    verifyData({ data, txId, }: {
+        data: Buffer | Readable | ReadableStream;
+        txId: string;
+    }): Promise<void>;
+}

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

@@ -0,0 +1,51 @@
+/**
+ * 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 { DataHashProvider, DataRootProvider } from '../../../types/wayfinder.js';
+import { GatewaysProvider } from '../../../types/wayfinder.js';
+export declare class TrustedGatewaysHashProvider implements DataHashProvider, DataRootProvider {
+    private gatewaysProvider;
+    constructor({ gatewaysProvider, }: {
+        gatewaysProvider: GatewaysProvider;
+    });
+    /**
+     * Gets the digest for a given txId from all trusted gateways and ensures they all match.
+     * @param txId - The txId to get the digest for.
+     * @returns The digest for the given txId.
+     */
+    getHash({ txId, }: {
+        txId: string;
+    }): Promise<{
+        hash: string;
+        algorithm: 'sha256';
+    }>;
+    /**
+     * Get the data root for a given txId from all trusted gateways and ensure they all match.
+     * @param txId - The txId to get the data root for.
+     * @returns The data root for the given txId.
+     */
+    getDataRoot({ txId }: {
+        txId: string;
+    }): Promise<string>;
+}
+/**
+ * Note from @djwhitt
+ *
+ * Calculating data roots this way is fine, but it may not reproduce the original data root.
+ * We could also implement a data root verifier that pulls all the chunks, checks that they
+ * reproduce the expected data root, and then compares the concatenated chunk data to the
+ * original data retrieved. That would take a while, but it should be able to verify any L1
+ * data where we can find the chunks.
+ */

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

@@ -0,0 +1,299 @@
+/**
+ * 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 EventEmitter from 'node:events';
+import { PassThrough, Readable } from 'node:stream';
+import { DataVerificationStrategy, GatewaysProvider, RoutingStrategy } from '../../types/wayfinder.js';
+import { Logger } from '../logger.js';
+type HttpClientArgs = unknown[];
+type HttpClientFunction = (...args: HttpClientArgs) => unknown;
+type WayfinderHttpClient<T extends HttpClientFunction> = T;
+export declare const arnsRegex: RegExp;
+export declare const txIdRegex: RegExp;
+/**
+ * Core function that converts a wayfinder url to the proper ar-io gateway URL
+ * @param originalUrl - the wayfinder url to resolve
+ * @param selectedGateway - 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, selectedGateway, logger, }: {
+    originalUrl: string | URL;
+    selectedGateway: URL;
+    logger?: Logger;
+}) => URL;
+/**
+ * Wayfinder event emitter with verification events
+ */
+export type WayfinderEvent = {
+    type: 'verification-succeeded';
+    txId: string;
+} | {
+    type: 'verification-failed';
+    txId: string;
+    error: Error;
+} | {
+    type: 'verification-skipped';
+    originalUrl: string;
+} | {
+    type: 'verification-progress';
+    txId: string;
+    processedBytes: number;
+    totalBytes: number;
+} | {
+    type: 'routing-started';
+    originalUrl: string;
+} | {
+    type: 'routing-skipped';
+    originalUrl: string;
+} | {
+    type: 'routing-succeeded';
+    originalUrl: string;
+    selectedGateway: string;
+    redirectUrl: string;
+} | {
+    type: 'routing-failed';
+    originalUrl: string;
+    error: Error;
+} | {
+    type: 'identified-transaction-id';
+    originalUrl: string;
+    selectedGateway: string;
+    txId: string;
+};
+export interface WayfinderEventArgs {
+    onVerificationPassed?: (payload: Omit<Extract<WayfinderEvent, {
+        type: 'verification-succeeded';
+    }>, 'type'>) => void;
+    onVerificationFailed?: (payload: Omit<Extract<WayfinderEvent, {
+        type: 'verification-failed';
+    }>, 'type'>) => void;
+    onVerificationProgress?: (payload: Omit<Extract<WayfinderEvent, {
+        type: 'verification-progress';
+    }>, 'type'>) => void;
+}
+export declare class WayfinderEmitter extends EventEmitter {
+    constructor({ onVerificationPassed, onVerificationFailed, onVerificationProgress, }?: WayfinderEventArgs);
+    emit<E extends WayfinderEvent['type']>(event: E, payload: Omit<Extract<WayfinderEvent, {
+        type: E;
+    }>, 'type'>): boolean;
+    on<E extends WayfinderEvent['type']>(event: E, listener: (payload: Omit<Extract<WayfinderEvent, {
+        type: E;
+    }>, 'type'>) => void): this;
+}
+export declare function tapAndVerifyStream<T extends Readable | ReadableStream>({ originalStream, contentLength, verifyData, txId, emitter, strict, }: {
+    originalStream: T;
+    contentLength: number;
+    verifyData: DataVerificationStrategy['verifyData'];
+    txId: string;
+    emitter?: WayfinderEmitter;
+    strict?: boolean;
+}): T extends Readable ? PassThrough : T;
+export declare function wrapVerifiedResponse(original: Response, newBody: ReadableStream<Uint8Array>, txId: string): Response;
+/**
+ * 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 HttpClientFunction>({ httpClient, resolveUrl, verifyData, selectGateway, emitter, logger, strict, }: {
+    httpClient: T;
+    selectGateway: () => Promise<URL>;
+    resolveUrl: (params: {
+        originalUrl: string | URL;
+        selectedGateway: URL;
+        logger?: Logger;
+    }) => URL;
+    verifyData?: <T_1 extends Readable | ReadableStream | Buffer>({ data, txId, }: {
+        data: T_1;
+        txId: string;
+    }) => Promise<void>;
+    logger?: Logger;
+    emitter?: WayfinderEmitter;
+    strict?: boolean;
+}) => 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 HttpClientFunction> {
+    /**
+     * The native http client used by wayfinder. By default, the native fetch api is used.
+     *
+     * @example
+     * const wayfinder = new Wayfinder({
+     *   httpClient: axios,
+     * });
+     *
+     */
+    readonly httpClient: T;
+    /**
+     * The gateways provider is responsible for providing the list of gateways to use for routing requests.
+     *
+     * @example
+     * const wayfinder = new Wayfinder({
+     *   gatewaysProvider: new SimpleCacheGatewaysProvider({
+     *     gatewaysProvider: new NetworkGatewaysProvider({ ario: ARIO.mainnet() }),
+     *     ttlSeconds: 60 * 60 * 24, // 1 day
+     *   }),
+     * });
+     */
+    readonly gatewaysProvider: GatewaysProvider;
+    /**
+     * The routing strategy to use when routing requests.
+     *
+     * @example
+     * const wayfinder = new Wayfinder({
+     *   strategy: new FastestPingStrategy({
+     *     timeoutMs: 1000,
+     *   }),
+     * });
+     */
+    readonly routingStrategy: RoutingStrategy;
+    /**
+     * A helper function that resolves the redirect url for ar:// requests to a target gateway.
+     *
+     * Note: no verification is done when resolving an ar://<path> url to a wayfinder route.
+     * In order to verify the data, you must use the `request` function or request the data and
+     * verify it yourself via the `verifyData` function.
+     *
+     * @example
+     * const { resolveUrl } = new Wayfinder();
+     *
+     * // returns the redirected URL based on the routing strategy and the original url
+     * const redirectUrl = await resolveUrl({ originalUrl: 'ar://example' });
+     *
+     * window.open(redirectUrl.toString(), '_blank');
+     */
+    readonly resolveUrl: (params: {
+        originalUrl: string;
+        logger?: Logger;
+    }) => Promise<URL>;
+    /**
+     *
+     * A wrapped http client that supports ar:// protocol. If a verification strategy is provided,
+     * the request will be verified and events will be emitted as the request is processed.
+     *
+     * @example
+     * const wayfinder = new Wayfinder({
+     *   verificationStrategy: new HashVerificationStrategy({
+     *     trustedHashProvider: new TrustedGatewaysHashProvider({
+     *       gatewaysProvider: new StaticGatewaysProvider({
+     *         gateways: ['https://permagate.io'],
+     *       }),
+     *     }),
+     *   }),
+     * })
+     *
+     * // request an arns name
+     * const response = await wayfinder.request('ar://ardrive')
+     *
+     * // request a transaction id
+     * const response = await wayfinder.request('ar://1234567890')
+     *
+     * // request a transaction id with a custom http client
+     * const response = await wayfinder.request('ar://1234567890')
+     *
+     * // Set strict mode to true to make verification blocking
+     * const wayfinder = new Wayfinder({
+     *   strict: true,
+     * });
+     *
+     * // This will throw an error if verification fails
+     * try {
+     *   const response = await wayfinder.request('ar://1234567890');
+     * } catch (error) {
+     *   console.error('Verification failed', error);
+     * }
+     */
+    readonly request: WayfinderHttpClient<T>;
+    /**
+     * The function that verifies the data hash for a given transaction id.
+     *
+     * @example
+     * const wayfinder = new Wayfinder({
+     *   verifyData: (data, txId) => {
+     *     // some custom verification logic
+     *     return true;
+     *   },
+     * });
+     */
+    readonly verifyData: DataVerificationStrategy['verifyData'];
+    /**
+     * Whether verification should be strict (blocking) or not.
+     * If true, verification failures will cause requests to fail.
+     * If false, verification will be performed asynchronously and failures will only emit events.
+     */
+    readonly strict: boolean;
+    /**
+     * The event emitter for wayfinder that emits verification events.
+     *
+     * const wayfinder = new Wayfinder()
+     *
+     * wayfinder.emitter.on('verification-succeeded', (event) => {
+     *   console.log('Verification passed!', event);
+     * })
+     *
+     * wayfinder.emitter.on('verification-failed', (event) => {
+     *   console.log('Verification failed!', event);
+     * })
+     *
+     * or implement the events interface and pass it in, using callback functions
+     *
+     * const wayfinder = new Wayfinder({
+     *   events: {
+     *     onVerificationPassed: (event) => {
+     *       console.log('Verification passed!', event);
+     *     },
+     *     onVerificationFailed: (event) => {
+     *       console.log('Verification failed!', event);
+     *     },
+     *     onVerificationProgress: (event) => {
+     *       console.log('Verification progress!', event);
+     *     },
+     *   }
+     * })
+     *
+     * const response = await wayfind('ar://example');
+     */
+    readonly emitter: WayfinderEmitter;
+    /**
+     * The constructor for the wayfinder
+     * @param httpClient - the http client to use for requests
+     * @param routingStrategy - the routing strategy to use for requests
+     * @param verificationStrategy - the verification strategy to use for requests
+     * @param gatewaysProvider - the gateways provider to use for routing requests
+     * @param logger - the logger to use for logging
+     * @param strict - if true, verification will be blocking and will fail requests if verification fails; if false, verification will be non-blocking
+     */
+    constructor({ httpClient, logger, gatewaysProvider, routingStrategy, verificationStrategy, events, strict, }: {
+        httpClient?: T;
+        routingStrategy?: RoutingStrategy;
+        gatewaysProvider?: GatewaysProvider;
+        verificationStrategy?: DataVerificationStrategy;
+        logger?: Logger;
+        events?: WayfinderEventArgs;
+        strict?: boolean;
+    });
+}
+export {};