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

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

@@ -1,5 +1,5 @@
 import Arweave from 'arweave';
-import { ARIOWithFaucet, AoARIORead, AoARIOWrite, AoAllDelegates, AoAllGatewayVaults, AoArNSNameData, AoArNSNameDataWithName, AoArNSPurchaseParams, AoArNSReservedNameData, AoArNSReservedNameDataWithName, AoBalanceWithAddress, AoBuyRecordParams, AoCreateVaultParams, AoDelegation, AoEligibleDistribution, AoEpochData, AoEpochDistributed, AoEpochDistributionData, AoEpochDistributionTotalsData, AoEpochObservationData, AoEpochSettings, AoExtendLeaseParams, AoExtendVaultParams, AoGateway, AoGatewayDelegateWithAddress, AoGatewayRegistrySettings, AoGatewayVault, AoGatewayWithAddress, AoGetCostDetailsParams, AoIncreaseUndernameLimitParams, AoIncreaseVaultParams, AoJoinNetworkParams, AoMessageResult, AoPaginatedAddressParams, AoPrimaryName, AoPrimaryNameRequest, AoRedelegationFeeInfo, AoRegistrationFees, AoReturnedName, AoRevokeVaultParams, AoTokenSupplyData, AoUpdateGatewaySettingsParams, AoVaultData, AoVaultedTransferParams, AoWalletVault, AoWeightedObserver, CostDetailsResult, DemandFactorSettings, EpochInput, OptionalArweave, OptionalPaymentUrl, PaginationParams, PaginationResult, ProcessConfiguration, TransactionId, WalletAddress, WithSigner, WriteOptions, mARIOToken } from '../types/index.js';
+import { ARIOWithFaucet, AoARIORead, AoARIOWrite, AoAllDelegates, AoAllGatewayVaults, AoArNSNameData, AoArNSNameDataWithName, AoArNSPurchaseParams, AoArNSReservedNameData, AoArNSReservedNameDataWithName, AoBalanceWithAddress, AoBuyRecordParams, AoCreateVaultParams, AoDelegation, AoEligibleDistribution, AoEpochData, AoEpochDistributed, AoEpochDistributionData, AoEpochDistributionTotalsData, AoEpochObservationData, AoEpochSettings, AoExtendLeaseParams, AoExtendVaultParams, AoGateway, AoGatewayDelegateWithAddress, AoGatewayRegistrySettings, AoGatewayVault, AoGatewayWithAddress, AoGetCostDetailsParams, AoIncreaseUndernameLimitParams, AoIncreaseVaultParams, AoJoinNetworkParams, AoMessageResult, AoPaginatedAddressParams, AoPrimaryName, AoPrimaryNameRequest, AoRedelegationFeeInfo, AoRegistrationFees, AoReturnedName, AoRevokeVaultParams, AoTokenSupplyData, AoUpdateGatewaySettingsParams, AoVaultData, AoVaultedTransferParams, AoWalletVault, AoWeightedObserver, ArNSNameResolutionData, ArNSNameResolver, CostDetailsResult, DemandFactorSettings, EpochInput, OptionalArweave, OptionalPaymentUrl, PaginationParams, PaginationResult, ProcessConfiguration, TransactionId, WalletAddress, WithSigner, WriteOptions, mARIOToken } from '../types/index.js';
 import { AOProcess } from './contracts/ao-process.js';
 import { TurboArNSPaymentProviderAuthenticated, TurboArNSPaymentProviderUnauthenticated } from './turbo.js';
 type ARIOConfigNoSigner = OptionalPaymentUrl<OptionalArweave<ProcessConfiguration>>;
@@ -19,7 +19,7 @@ export declare class ARIO {
         faucetUrl?: string;
     }): ARIOWithFaucet<AoARIOWrite>;
 }
-export declare class ARIOReadable implements AoARIORead {
+export declare class ARIOReadable implements AoARIORead, ArNSNameResolver {
     readonly process: AOProcess;
     protected epochSettings: AoEpochSettings | undefined;
     protected arweave: Arweave;
@@ -135,6 +135,9 @@ export declare class ARIOReadable implements AoARIORead {
     getGatewayRegistrySettings(): Promise<AoGatewayRegistrySettings>;
     getAllDelegates(params?: PaginationParams<AoAllDelegates>): Promise<PaginationResult<AoAllDelegates>>;
     getAllGatewayVaults(params?: PaginationParams<AoAllGatewayVaults>): Promise<PaginationResult<AoAllGatewayVaults>>;
+    resolveArNSName({ name, }: {
+        name: string;
+    }): Promise<ArNSNameResolutionData>;
 }
 export declare class ARIOWriteable extends ARIOReadable implements AoARIOWrite {
     private signer;

package/lib/types/common/wayfinder/{gateways.d.ts → gateways/network.d.ts}

@@ -13,10 +13,8 @@
  * 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<URL[]>;
-}
+import { AoARIORead, AoGatewayWithAddress } from '../../../types/io.js';
+import { GatewaysProvider } from '../../../types/wayfinder.js';
 export declare class NetworkGatewaysProvider implements GatewaysProvider {
     private ario;
     private sortBy;
@@ -24,7 +22,7 @@ export declare class NetworkGatewaysProvider implements GatewaysProvider {
     private limit;
     private filter;
     constructor({ ario, sortBy, sortOrder, limit, filter, }: {
-        ario: AoARIORead;
+        ario?: AoARIORead;
         sortBy?: 'totalDelegatedStake' | 'operatorStake' | 'startTimestamp';
         sortOrder?: 'asc' | 'desc';
         limit?: number;
@@ -33,21 +31,3 @@ export declare class NetworkGatewaysProvider implements GatewaysProvider {
     });
     getGateways(): Promise<URL[]>;
 }
-export declare class StaticGatewaysProvider implements GatewaysProvider {
-    private gateways;
-    constructor({ gateways }: {
-        gateways: string[];
-    });
-    getGateways(): Promise<URL[]>;
-}
-export declare class SimpleCacheGatewaysProvider implements GatewaysProvider {
-    private gatewaysProvider;
-    private ttlSeconds;
-    private lastUpdated;
-    private gatewaysCache;
-    constructor({ gatewaysProvider, ttlSeconds, }: {
-        gatewaysProvider: GatewaysProvider;
-        ttlSeconds?: number;
-    });
-    getGateways(): Promise<URL[]>;
-}

package/lib/types/common/wayfinder/{routers/random.d.ts → gateways/simple-cache.d.ts}

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

package/lib/types/common/wayfinder/{routers → gateways}/static.d.ts

@@ -13,12 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { WayfinderRouter } from '../../../types/wayfinder.js';
-export declare class StaticGatewayRouter implements WayfinderRouter {
-    readonly name = "static";
-    private gateway;
-    constructor({ gateway }: {
-        gateway: string;
+import { GatewaysProvider } from '../../../types/wayfinder.js';
+export declare class StaticGatewaysProvider implements GatewaysProvider {
+    private gateways;
+    constructor({ gateways }: {
+        gateways: string[];
     });
-    getTargetGateway(): Promise<URL>;
+    getGateways(): Promise<URL[]>;
 }

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

@@ -14,10 +14,13 @@
  * limitations under the License.
  */
 export * from './wayfinder.js';
-export * from './routers/random.js';
-export * from './routers/priority.js';
-export * from './routers/static.js';
-export * from './gateways.js';
-export * from './gateways/trusted-gateways.js';
-export * from './verification/data-root-verifier.js';
-export * from './verification/hash-verifier.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/{routers/simple-cache.d.ts → routing/strategies/ping.d.ts}

@@ -13,16 +13,15 @@
  * 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;
+import { RoutingStrategy } from '../../../../types/wayfinder.js';
+export declare class FastestPingRoutingStrategy implements RoutingStrategy {
+    private timeoutMs;
+    private probePath;
+    constructor({ timeoutMs, probePath, }?: {
+        timeoutMs?: number;
+        probePath?: string;
     });
-    getTargetGateway(): Promise<URL>;
+    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/{data-root-verifier.d.ts → strategies/data-root-verifier.d.ts}

@@ -1,12 +1,12 @@
 import { Readable } from 'node:stream';
-import { DataRootProvider, DataVerifier } from '../../../types/wayfinder.js';
+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 DataRootVerifier implements DataVerifier {
+export declare class DataRootVerificationStrategy implements DataVerificationStrategy {
     private readonly trustedDataRootProvider;
     constructor({ trustedDataRootProvider, }: {
         trustedDataRootProvider: DataRootProvider;

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

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 import { Readable } from 'node:stream';
-import { DataHashProvider, DataVerifier } from '../../../types/wayfinder.js';
-export declare class HashVerifier implements DataVerifier {
+import { DataHashProvider, DataVerificationStrategy } from '../../../../types/wayfinder.js';
+export declare class HashVerificationStrategy implements DataVerificationStrategy {
     private readonly trustedHashProvider;
     constructor({ trustedHashProvider, }: {
         trustedHashProvider: DataHashProvider;

package/lib/types/common/wayfinder/{gateways/trusted-gateways.d.ts → verification/trusted.d.ts}

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import { DataHashProvider, DataRootProvider } from '../../../types/wayfinder.js';
-import { GatewaysProvider } from '../gateways.js';
+import { GatewaysProvider } from '../../../types/wayfinder.js';
 export declare class TrustedGatewaysHashProvider implements DataHashProvider, DataRootProvider {
     private gatewaysProvider;
     constructor({ gatewaysProvider, }: {

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

@@ -15,7 +15,7 @@
  */
 import EventEmitter from 'node:events';
 import { PassThrough, Readable } from 'node:stream';
-import { DataHashProvider, DataVerifier, WayfinderRouter } from '../../types/wayfinder.js';
+import { DataVerificationStrategy, GatewaysProvider, RoutingStrategy } from '../../types/wayfinder.js';
 import { Logger } from '../logger.js';
 type HttpClientArgs = unknown[];
 type HttpClientFunction = (...args: HttpClientArgs) => unknown;
@@ -23,21 +23,21 @@ type WayfinderHttpClient<T extends HttpClientFunction> = T;
 export declare const arnsRegex: RegExp;
 export declare const txIdRegex: RegExp;
 /**
- * Core function to resolve a wayfinder url against a target gateway
+ * Core function that converts a wayfinder url to the proper ar-io gateway URL
  * @param originalUrl - the wayfinder url to resolve
- * @param targetGateway - the target gateway to resolve the url against
+ * @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, targetGateway, logger, }: {
+export declare const resolveWayfinderUrl: ({ originalUrl, selectedGateway, logger, }: {
     originalUrl: string | URL;
-    targetGateway: () => Promise<string | URL>;
+    selectedGateway: URL;
     logger?: Logger;
-}) => Promise<URL>;
+}) => URL;
 /**
  * Wayfinder event emitter with verification events
  */
 export type WayfinderEvent = {
-    type: 'verification-passed';
+    type: 'verification-succeeded';
     txId: string;
 } | {
     type: 'verification-failed';
@@ -54,10 +54,14 @@ export type WayfinderEvent = {
 } | {
     type: 'routing-started';
     originalUrl: string;
+} | {
+    type: 'routing-skipped';
+    originalUrl: string;
 } | {
     type: 'routing-succeeded';
     originalUrl: string;
-    targetGateway: string;
+    selectedGateway: string;
+    redirectUrl: string;
 } | {
     type: 'routing-failed';
     originalUrl: string;
@@ -65,12 +69,12 @@ export type WayfinderEvent = {
 } | {
     type: 'identified-transaction-id';
     originalUrl: string;
-    targetGateway: string;
+    selectedGateway: string;
     txId: string;
 };
 export interface WayfinderEventArgs {
     onVerificationPassed?: (payload: Omit<Extract<WayfinderEvent, {
-        type: 'verification-passed';
+        type: 'verification-succeeded';
     }>, 'type'>) => void;
     onVerificationFailed?: (payload: Omit<Extract<WayfinderEvent, {
         type: 'verification-failed';
@@ -88,12 +92,13 @@ export declare class WayfinderEmitter extends EventEmitter {
         type: E;
     }>, 'type'>) => void): this;
 }
-export declare function tapAndVerifyStream<T extends Readable | ReadableStream>({ originalStream, contentLength, verifyData, txId, emitter, }: {
+export declare function tapAndVerifyStream<T extends Readable | ReadableStream>({ originalStream, contentLength, verifyData, txId, emitter, strict, }: {
     originalStream: T;
     contentLength: number;
-    verifyData: DataVerifier['verifyData'];
+    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;
 /**
@@ -109,18 +114,21 @@ export declare function wrapVerifiedResponse(original: Response, newBody: Readab
  * @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, emitter, logger, }: {
+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;
-    }) => Promise<URL>;
+    }) => 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
@@ -130,88 +138,119 @@ export declare const createWayfinderClient: <T extends HttpClientFunction>({ htt
  */
 export declare class Wayfinder<T extends HttpClientFunction> {
     /**
-     * The router to use for requests
+     * The native http client used by wayfinder. By default, the native fetch api is used.
      *
      * @example
      * const wayfinder = new Wayfinder({
-     *   router: new RandomGatewayRouter({
-     *     gatewaysProvider: new SimpleCacheGatewaysProvider({
-     *       gatewaysProvider: new NetworkGatewaysProvider({ ario: ARIO.mainnet() }),
-     *       ttlSeconds: 60 * 60 * 24, // 1 day
-     *     }),
-     *   }),
+     *   httpClient: axios,
      * });
      *
-     * // Returns a target gateway based on the routing strategy
-     * const targetGateway = await wayfinder.router.getTargetGateway();
      */
-    readonly router: WayfinderRouter;
+    readonly httpClient: T;
     /**
-     * The native http client used by wayfinder
+     * The gateways provider is responsible for providing the list of gateways to use for routing requests.
      *
      * @example
      * const wayfinder = new Wayfinder({
-     *   router: new RandomGatewayRouter({
-     *     gatewaysProvider: new SimpleCacheGatewaysProvider({
-     *       gatewaysProvider: new NetworkGatewaysProvider({ ario: ARIO.mainnet() }),
-     *       ttlSeconds: 60 * 60 * 24, // 1 day
-     *     }),
+     *   gatewaysProvider: new SimpleCacheGatewaysProvider({
+     *     gatewaysProvider: new NetworkGatewaysProvider({ ario: ARIO.mainnet() }),
+     *     ttlSeconds: 60 * 60 * 24, // 1 day
      *   }),
-     *   httpClient: axios,
      * });
-     *
      */
-    readonly httpClient: T;
+    readonly gatewaysProvider: GatewaysProvider;
     /**
-     * The function that resolves the redirect url for ar:// requests to a target gateway
+     * The routing strategy to use when routing requests.
      *
      * @example
      * const wayfinder = new Wayfinder({
-     *   router: new RandomGatewayRouter({
-     *     gatewaysProvider: new SimpleCacheGatewaysProvider({
-     *       gatewaysProvider: new NetworkGatewaysProvider({ ario: ARIO.mainnet() }),
-     *       ttlSeconds: 60 * 60 * 24, // 1 day
-     *     }),
+     *   strategy: new FastestPingStrategy({
+     *     timeoutMs: 1000,
      *   }),
-     *   httpClient: axios,
      * });
+     */
+    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 wayfinder.resolveUrl({ originalUrl: 'ar://example' });
+     * 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
+     *
+     * 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 { request: wayfind } = new Wayfinder({
-     *   router: new RandomGatewayRouter({
-     *     gatewaysProvider: new SimpleCacheGatewaysProvider({
-     *       gatewaysProvider: new NetworkGatewaysProvider({ ario: ARIO.mainnet() }),
-     *       ttlSeconds: 60 * 60 * 24, // 1 day
+     * const wayfinder = new Wayfinder({
+     *   verificationStrategy: new HashVerificationStrategy({
+     *     trustedHashProvider: new TrustedGatewaysHashProvider({
+     *       gatewaysProvider: new StaticGatewaysProvider({
+     *         gateways: ['https://permagate.io'],
+     *       }),
      *     }),
      *   }),
-     *   httpClient: axios,
-     * });;
-     *
-     * const response = await wayfind('ar://example', {
-     *   method: 'POST',
-     *   data: {
-     *     name: 'John Doe',
-     *   },
      * })
+     *
+     * // 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>;
-    readonly verifyData: DataVerifier['verifyData'];
+    /**
+     * 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-passed', (event) => {
+     * wayfinder.emitter.on('verification-succeeded', (event) => {
      *   console.log('Verification passed!', event);
      * })
      *
@@ -238,28 +277,23 @@ export declare class Wayfinder<T extends HttpClientFunction> {
      * const response = await wayfind('ar://example');
      */
     readonly emitter: WayfinderEmitter;
-    constructor({ httpClient, router, logger, verifier, events, }: {
-        httpClient: T;
-        router?: WayfinderRouter;
+    /**
+     * 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;
-        verifier?: DataVerifier;
-        hashProvider?: DataHashProvider;
         events?: WayfinderEventArgs;
+        strict?: boolean;
     });
 }
 export {};
-/**
- *
- *  type    | complexity | performance | security
- * ---------|------------|-------------|---------
- *  hash    | low        | high        | low
- * ---------|------------|-------------|---------
- *  data root    | medium       | medium      | low | only L1
- * ---------|------------|-------------|---------
- * signature    | medium       | medium      | medium
- * ---------|------------|-------------|---------
- *  composite | high       | low         | high
- * ---------|------------|-------------|---------
- *
- *
- */

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

@@ -420,7 +420,22 @@ export type DemandFactorSettings = {
     maxPeriodsAtMinDemandFactor: number;
     criteria: string;
 };
-export interface AoARIORead {
+export type ArNSNameResolutionData = {
+    name: string;
+    owner?: string;
+    txId: string;
+    type: 'lease' | 'permabuy';
+    processId: string;
+    ttlSeconds: number;
+    priority?: number;
+    undernameLimit: number;
+};
+export interface ArNSNameResolver {
+    resolveArNSName({ name }: {
+        name: string;
+    }): Promise<ArNSNameResolutionData>;
+}
+export interface AoARIORead extends ArNSNameResolver {
     process: AOProcess;
     getInfo(): Promise<{
         Ticker: string;

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

@@ -14,11 +14,15 @@
  * limitations under the License.
  */
 import { Readable } from 'stream';
-export interface WayfinderRouter {
-    readonly name: string;
-    getTargetGateway: () => Promise<URL>;
+export interface RoutingStrategy {
+    selectGateway: ({ gateways }: {
+        gateways: URL[];
+    }) => Promise<URL>;
 }
-export interface DataVerifier {
+export interface GatewaysProvider {
+    getGateways: () => Promise<URL[]>;
+}
+export interface DataVerificationStrategy {
     /**
      * Verifies the provided data for a given txId
      *

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.11.0-alpha.7";
+export declare const version = "3.11.0-alpha.12";