@ar.io/sdk 3.11.0-alpha.4 → 3.11.0-alpha.6

package/lib/cjs/common/io.js

@@ -51,6 +51,10 @@ class ARIO {
             ...config,
             process: new ao_process_js_1.AOProcess({
                 processId: constants_js_1.ARIO_MAINNET_PROCESS_ID,
+                ao: (0, aoconnect_1.connect)({
+                    CU_URL: 'https://cu.ardrive.io',
+                    ...config?.process?.ao,
+                }),
             }),
         });
     }

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Wayfinder = exports.createWayfinderClient = exports.resolveWayfinderUrl = exports.txIdRegex = exports.arnsRegex = void 0;
 const io_js_1 = require("../io.js");
+const logger_js_1 = require("../logger.js");
 const gateways_js_1 = require("./gateways.js");
 const random_js_1 = require("./routers/random.js");
 // known regexes for wayfinder urls
@@ -13,28 +14,46 @@ exports.txIdRegex = /^[a-z0-9]{43}$/;
  * @param targetGateway - the target gateway to resolve the url against
  * @returns the resolved url that can be used to make a request
  */
-const resolveWayfinderUrl = ({ originalUrl, targetGateway, }) => {
+const resolveWayfinderUrl = async ({ originalUrl, targetGateway, logger, }) => {
     if (originalUrl.toString().startsWith('ar://')) {
+        logger?.debug(`Applying wayfinder routing protocol to ${originalUrl}`, {
+            originalUrl,
+        });
+        const targetGatewayUrl = new URL(await targetGateway());
+        logger?.debug(`Selected target gateway: ${targetGatewayUrl}`, {
+            originalUrl,
+            targetGateway: targetGatewayUrl,
+        });
         const [, path] = originalUrl.toString().split('ar://');
         // e.g. ar:///info should route to the info endpoint of the target gateway
         if (path.startsWith('/')) {
-            return new URL(path.slice(1), targetGateway);
+            logger?.debug(`Routing to ${path.slice(1)} on ${targetGatewayUrl}`, {
+                originalUrl,
+                targetGateway: targetGatewayUrl,
+            });
+            return new URL(path.slice(1), targetGatewayUrl);
         }
         // TODO: this breaks 43 character named arns names - we should check a a local name cache list before resolving raw transaction ids
         if (exports.txIdRegex.test(path)) {
             const [txId, ...rest] = path.split('/');
-            return new URL(`${txId}${rest.join('/')}`, targetGateway);
+            return new URL(`${txId}${rest.join('/')}`, targetGatewayUrl);
         }
         if (exports.arnsRegex.test(path)) {
             // TODO: tests to ensure arns names support query params and paths
             const [name, ...rest] = path.split('/');
-            const targetGatewayUrl = new URL(targetGateway);
             const arnsUrl = `${targetGatewayUrl.protocol}//${name}.${targetGatewayUrl.hostname}${targetGatewayUrl.port ? `:${targetGatewayUrl.port}` : ''}`;
+            logger?.debug(`Routing to ${path} on ${arnsUrl}`, {
+                originalUrl,
+                targetGateway: targetGatewayUrl,
+            });
             return new URL(rest.join('/'), arnsUrl);
         }
         // TODO: support .eth addresses
         // TODO: "gasless" routing via DNS TXT records (e.g. ar://gatewaypie.com -> TXT record lookup for TX ID and redirect to that gateway)
     }
+    logger?.debug('No wayfinder routing protocol applied', {
+        originalUrl,
+    });
     // return the original url if it's not a wayfinder url (allows you to use the wayfinder client with non-wayfinder urls)
     return new URL(originalUrl);
 };
@@ -52,16 +71,25 @@ exports.resolveWayfinderUrl = resolveWayfinderUrl;
  * @param resolveUrl - the function to construct the redirect url for ar:// requests
  * @returns a wrapped http client that supports ar:// protocol
  */
-const createWayfinderClient = ({ httpClient, resolveUrl, }) => {
+const createWayfinderClient = ({ httpClient, resolveUrl, logger, }) => {
     const wayfinderRedirect = async (fn, rawArgs) => {
         // TODO: handle if first arg is not a string (i.e. just return the result of the function call)
         const [originalUrl, ...rest] = rawArgs;
         // route the request to the target gateway
         const redirectUrl = await resolveUrl({
             originalUrl,
+            logger,
+        });
+        logger?.debug(`Redirecting request to ${redirectUrl}`, {
+            originalUrl,
+            redirectUrl,
         });
         // make the request to the target gateway using the redirect url and http client
         const response = await fn(redirectUrl.toString(), ...rest);
+        logger?.debug(`Successfully routed request to ${redirectUrl}`, {
+            redirectUrl,
+            originalUrl,
+        });
         // TODO: if verifyDataHash is provided, verify the data hash before returning
         return response;
     };
@@ -154,21 +182,26 @@ class Wayfinder {
     router = new random_js_1.RandomGatewayRouter({
         // optionally use a cache gateways provider to reduce the number of requests to the contract
         gatewaysProvider: new gateways_js_1.ARIOGatewaysProvider({ ario: io_js_1.ARIO.mainnet() }),
-    }), httpClient,
+    }), httpClient, logger = logger_js_1.Logger.default,
     // TODO: add verifier interface that provides a verifyDataHash function
     // TODO: stats provider
      }) {
         this.router = router;
         this.httpClient = httpClient;
-        this.resolveUrl = async ({ originalUrl }) => (0, exports.resolveWayfinderUrl)({
-            originalUrl,
-            targetGateway: await this.router.getTargetGateway(),
-        });
+        this.resolveUrl = async ({ originalUrl, logger }) => {
+            return (0, exports.resolveWayfinderUrl)({
+                originalUrl,
+                targetGateway: async () => await this.router.getTargetGateway(),
+                logger,
+            });
+        };
         this.request = (0, exports.createWayfinderClient)({
             httpClient,
             resolveUrl: this.resolveUrl,
+            logger,
             // TODO: provide the verifyDataHash function from the verifier to the wayfinder client along with verificationSettings
         });
+        logger?.debug(`Wayfinder initialized with ${router.name} routing strategy`);
     }
 }
 exports.Wayfinder = Wayfinder;

package/lib/cjs/version.js

@@ -17,4 +17,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // AUTOMATICALLY GENERATED FILE - DO NOT TOUCH
-exports.version = '3.11.0-alpha.4';
+exports.version = '3.11.0-alpha.6';

package/lib/esm/common/io.js

@@ -48,6 +48,10 @@ export class ARIO {
             ...config,
             process: new AOProcess({
                 processId: ARIO_MAINNET_PROCESS_ID,
+                ao: connect({
+                    CU_URL: 'https://cu.ardrive.io',
+                    ...config?.process?.ao,
+                }),
             }),
         });
     }

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

@@ -1,4 +1,5 @@
 import { ARIO } from '../io.js';
+import { Logger } from '../logger.js';
 import { ARIOGatewaysProvider } from './gateways.js';
 import { RandomGatewayRouter } from './routers/random.js';
 // known regexes for wayfinder urls
@@ -10,28 +11,46 @@ export const txIdRegex = /^[a-z0-9]{43}$/;
  * @param targetGateway - the target gateway to resolve the url against
  * @returns the resolved url that can be used to make a request
  */
-export const resolveWayfinderUrl = ({ originalUrl, targetGateway, }) => {
+export const resolveWayfinderUrl = async ({ originalUrl, targetGateway, logger, }) => {
     if (originalUrl.toString().startsWith('ar://')) {
+        logger?.debug(`Applying wayfinder routing protocol to ${originalUrl}`, {
+            originalUrl,
+        });
+        const targetGatewayUrl = new URL(await targetGateway());
+        logger?.debug(`Selected target gateway: ${targetGatewayUrl}`, {
+            originalUrl,
+            targetGateway: targetGatewayUrl,
+        });
         const [, path] = originalUrl.toString().split('ar://');
         // e.g. ar:///info should route to the info endpoint of the target gateway
         if (path.startsWith('/')) {
-            return new URL(path.slice(1), targetGateway);
+            logger?.debug(`Routing to ${path.slice(1)} on ${targetGatewayUrl}`, {
+                originalUrl,
+                targetGateway: targetGatewayUrl,
+            });
+            return new URL(path.slice(1), targetGatewayUrl);
         }
         // TODO: this breaks 43 character named arns names - we should check a a local name cache list before resolving raw transaction ids
         if (txIdRegex.test(path)) {
             const [txId, ...rest] = path.split('/');
-            return new URL(`${txId}${rest.join('/')}`, targetGateway);
+            return new URL(`${txId}${rest.join('/')}`, targetGatewayUrl);
         }
         if (arnsRegex.test(path)) {
             // TODO: tests to ensure arns names support query params and paths
             const [name, ...rest] = path.split('/');
-            const targetGatewayUrl = new URL(targetGateway);
             const arnsUrl = `${targetGatewayUrl.protocol}//${name}.${targetGatewayUrl.hostname}${targetGatewayUrl.port ? `:${targetGatewayUrl.port}` : ''}`;
+            logger?.debug(`Routing to ${path} on ${arnsUrl}`, {
+                originalUrl,
+                targetGateway: targetGatewayUrl,
+            });
             return new URL(rest.join('/'), arnsUrl);
         }
         // TODO: support .eth addresses
         // TODO: "gasless" routing via DNS TXT records (e.g. ar://gatewaypie.com -> TXT record lookup for TX ID and redirect to that gateway)
     }
+    logger?.debug('No wayfinder routing protocol applied', {
+        originalUrl,
+    });
     // return the original url if it's not a wayfinder url (allows you to use the wayfinder client with non-wayfinder urls)
     return new URL(originalUrl);
 };
@@ -48,16 +67,25 @@ export const resolveWayfinderUrl = ({ originalUrl, targetGateway, }) => {
  * @param resolveUrl - the function to construct the redirect url for ar:// requests
  * @returns a wrapped http client that supports ar:// protocol
  */
-export const createWayfinderClient = ({ httpClient, resolveUrl, }) => {
+export const createWayfinderClient = ({ httpClient, resolveUrl, logger, }) => {
     const wayfinderRedirect = async (fn, rawArgs) => {
         // TODO: handle if first arg is not a string (i.e. just return the result of the function call)
         const [originalUrl, ...rest] = rawArgs;
         // route the request to the target gateway
         const redirectUrl = await resolveUrl({
             originalUrl,
+            logger,
+        });
+        logger?.debug(`Redirecting request to ${redirectUrl}`, {
+            originalUrl,
+            redirectUrl,
         });
         // make the request to the target gateway using the redirect url and http client
         const response = await fn(redirectUrl.toString(), ...rest);
+        logger?.debug(`Successfully routed request to ${redirectUrl}`, {
+            redirectUrl,
+            originalUrl,
+        });
         // TODO: if verifyDataHash is provided, verify the data hash before returning
         return response;
     };
@@ -149,20 +177,25 @@ export class Wayfinder {
     router = new RandomGatewayRouter({
         // optionally use a cache gateways provider to reduce the number of requests to the contract
         gatewaysProvider: new ARIOGatewaysProvider({ ario: ARIO.mainnet() }),
-    }), httpClient,
+    }), httpClient, logger = Logger.default,
     // TODO: add verifier interface that provides a verifyDataHash function
     // TODO: stats provider
      }) {
         this.router = router;
         this.httpClient = httpClient;
-        this.resolveUrl = async ({ originalUrl }) => resolveWayfinderUrl({
-            originalUrl,
-            targetGateway: await this.router.getTargetGateway(),
-        });
+        this.resolveUrl = async ({ originalUrl, logger }) => {
+            return resolveWayfinderUrl({
+                originalUrl,
+                targetGateway: async () => await this.router.getTargetGateway(),
+                logger,
+            });
+        };
         this.request = createWayfinderClient({
             httpClient,
             resolveUrl: this.resolveUrl,
+            logger,
             // TODO: provide the verifyDataHash function from the verifier to the wayfinder client along with verificationSettings
         });
+        logger?.debug(`Wayfinder initialized with ${router.name} routing strategy`);
     }
 }

package/lib/esm/version.js

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

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

@@ -9,12 +9,8 @@ export declare class ARIO {
     static init(config: ARIOConfigWithSigner): AoARIOWrite;
     static init(config: ARIOConfigNoSigner): AoARIORead;
     static mainnet(): AoARIORead;
-    static mainnet(config: ARIOConfigNoSigner & {
-        faucetUrl?: string;
-    }): AoARIORead;
-    static mainnet(config: ARIOConfigWithSigner & {
-        faucetUrl?: string;
-    }): AoARIOWrite;
+    static mainnet(config: ARIOConfigNoSigner): AoARIORead;
+    static mainnet(config: ARIOConfigWithSigner): AoARIOWrite;
     static testnet(): ARIOWithFaucet<AoARIORead>;
     static testnet(config: ARIOConfigNoSigner & {
         faucetUrl?: string;

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

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import { WayfinderRouter } from '../../types/wayfinder.js';
+import { Logger } from '../logger.js';
 type HttpClientArgs = [string | URL, ...unknown[]];
 type HttpClientFunction = (...args: HttpClientArgs) => unknown;
 type WayfinderHttpClient<T extends HttpClientFunction> = T;
@@ -25,10 +26,11 @@ export declare const txIdRegex: RegExp;
  * @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, }: {
+export declare const resolveWayfinderUrl: ({ originalUrl, targetGateway, logger, }: {
     originalUrl: string | URL;
-    targetGateway: string | URL;
-}) => URL;
+    targetGateway: () => Promise<string | URL>;
+    logger?: Logger;
+}) => Promise<URL>;
 /**
  * Creates a wrapped http client that supports ar:// protocol
  *
@@ -42,11 +44,13 @@ export declare const resolveWayfinderUrl: ({ originalUrl, targetGateway, }: {
  * @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, }: {
+export declare const createWayfinderClient: <T extends HttpClientFunction>({ httpClient, resolveUrl, logger, }: {
     httpClient: T;
     resolveUrl: (params: {
         originalUrl: string | URL;
+        logger?: Logger;
     }) => Promise<URL>;
+    logger?: Logger;
 }) => WayfinderHttpClient<T>;
 /**
  * The main class for the wayfinder
@@ -93,6 +97,7 @@ export declare class Wayfinder<T extends HttpClientFunction> {
      */
     readonly resolveUrl: (params: {
         originalUrl: string;
+        logger?: Logger;
     }) => Promise<URL>;
     /**
      * A wrapped http client that supports ar:// protocol
@@ -113,9 +118,10 @@ export declare class Wayfinder<T extends HttpClientFunction> {
      * })
      */
     readonly request: WayfinderHttpClient<T>;
-    constructor({ router, httpClient, }: {
+    constructor({ router, httpClient, logger, }: {
         router: WayfinderRouter;
         httpClient: T;
+        logger?: Logger;
     });
 }
 export {};

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ar.io/sdk",
-  "version": "3.11.0-alpha.4",
+  "version": "3.11.0-alpha.6",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ar-io/ar-io-sdk.git"

package/lib/cjs/cli/wayfinder.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-const commander_1 = require("commander");
-const version_js_1 = require("../version.js");
-const options_js_1 = require("./options.js");
-const utils_js_1 = require("./utils.js");
-(0, utils_js_1.applyOptions)(commander_1.program
-    .name('ar.io')
-    .version(version_js_1.version)
-    .description('AR.IO Network CLI')
-    .helpCommand(true), options_js_1.globalOptions);
-(0, utils_js_1.makeCommand)({
-    name: '',
-    description: 'Get network info',
-    action: () => {
-        console.log('wayfinder');
-        return Promise.resolve({});
-    },
-});

package/lib/esm/cli/wayfinder.js

@@ -1,32 +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 { program } from 'commander';
-import { version } from '../version.js';
-import { globalOptions } from './options.js';
-import { applyOptions, makeCommand } from './utils.js';
-applyOptions(program
-    .name('ar.io')
-    .version(version)
-    .description('AR.IO Network CLI')
-    .helpCommand(true), globalOptions);
-makeCommand({
-    name: '',
-    description: 'Get network info',
-    action: () => {
-        console.log('wayfinder');
-        return Promise.resolve({});
-    },
-});

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

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