@ar.io/sdk 3.10.0 → 3.11.0-alpha.2

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

@@ -0,0 +1,248 @@
+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);
+            });
+        });
+    });
+});

package/lib/esm/types/ant.js

@@ -77,6 +77,17 @@ export const AntStateSchema = z.object({
         .boolean()
         .describe('Flag indicating whether the ANT has been initialized.'),
 });
+export const SpawnANTStateSchema = z.object({
+    name: z.string().describe('The name of the ANT.'),
+    ticker: z.string().describe('The ticker symbol for the ANT.'),
+    description: z.string().describe('The description for the ANT.'),
+    keywords: AntKeywordsSchema.describe('The keywords for the ANT.'),
+    owner: AOAddressSchema.describe('The Owners address.'),
+    controllers: AntControllersSchema.describe('Controllers of the ANT who have administrative privileges.'),
+    records: AntRecordsSchema.describe('Records associated with the ANT.'),
+    balances: AntBalancesSchema.describe('Balance details for each address holding the ANT.'),
+    logo: ArweaveTxIdSchema.describe('Transaction ID of the ANT logo.'),
+});
 export const AntReadHandlers = [
     'balance',
     'balances',

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/io.js

@@ -22,7 +22,7 @@ export const intentsUsingYears = [
 export const isValidIntent = (intent) => {
     return validIntents.indexOf(intent) !== -1;
 };
-export const fundFromOptions = ['balance', 'stakes', 'any'];
+export const fundFromOptions = ['balance', 'stakes', 'any', 'turbo'];
 export const isValidFundFrom = (fundFrom) => {
     return fundFromOptions.indexOf(fundFrom) !== -1;
 };

package/lib/esm/types/wayfinder.js

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

package/lib/esm/utils/ao.js

@@ -19,8 +19,13 @@ import { z } from 'zod';
 import { defaultArweave } from '../common/arweave.js';
 import { AOProcess, Logger } from '../common/index.js';
 import { ANT_LUA_ID, ANT_REGISTRY_ID, AOS_MODULE_ID, AO_AUTHORITY, DEFAULT_SCHEDULER_ID, } from '../constants.js';
+import { SpawnANTStateSchema } from '../types/ant.js';
+import { parseSchemaResult } from './schema.js';
 export async function spawnANT({ signer, module = AOS_MODULE_ID, ao = connect(), scheduler = DEFAULT_SCHEDULER_ID, state, antRegistryId = ANT_REGISTRY_ID, logger = Logger.default, authority = AO_AUTHORITY, }) {
     // TODO: use On-Boot data handler for bootstrapping state instead of initialize-state
+    if (state) {
+        parseSchemaResult(SpawnANTStateSchema, state);
+    }
     const processId = await ao.spawn({
         module,
         scheduler,

package/lib/esm/utils/random.js

@@ -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.
+ */
+import { webcrypto } from 'crypto';
+/**
+ * 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 const randomInt = (min, max) => {
+    const [rand] = webcrypto.getRandomValues(new Uint32Array(1));
+    return min + (rand % (max - min));
+};

package/lib/esm/utils/url.js

@@ -0,0 +1,24 @@
+/**
+ * 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 const urlWithSearchParams = ({ baseUrl, params, }) => {
+    const urlObj = new URL(baseUrl);
+    Object.entries(params).forEach(([key, value]) => {
+        if (value === undefined || value === null)
+            return;
+        urlObj.searchParams.set(key, value.toString());
+    });
+    return urlObj.toString();
+};

package/lib/esm/utils/url.test.js

@@ -0,0 +1,19 @@
+import assert from 'node:assert';
+import { test } from 'node:test';
+import { urlWithSearchParams } from './url.js';
+test('urlWithSearchParams prunes undefined values but keeps other falsey values', () => {
+    const result = urlWithSearchParams({
+        baseUrl: 'https://example.com',
+        params: {
+            number: 1,
+            string: 'string',
+            boolean: true,
+            empty: '',
+            zero: 0,
+            false: false,
+            null: null,
+            undef: undefined,
+        },
+    });
+    assert.strictEqual(result, 'https://example.com/?number=1&string=string&boolean=true&empty=&zero=0&false=false');
+});

package/lib/esm/utils/utils.test.js

@@ -1,7 +1,7 @@
 import { strict as assert } from 'node:assert';
 import { describe, it } from 'node:test';
+import { errorMessageFromOutput } from './ao.js';
 import { pruneTags, sortAndPaginateEpochDataIntoEligibleDistributions, } from './arweave.js';
-import { errorMessageFromOutput } from './index.js';
 describe('pruneTags', () => {
     it('should remove tags with undefined values', () => {
         const tags = [

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';
+export const version = '3.11.0-alpha.2';

package/lib/esm/web/index.js

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export { ArweaveSigner, ArconnectSigner } from '@dha-team/arbundles';
+export { ArweaveSigner, ArconnectSigner, InjectedEthereumSigner, EthereumSigner, } from '@dha-team/arbundles';
 export * from '../types/index.js';
 export * from '../common/index.js';
 export * from '../constants.js';

package/lib/types/cli/commands/antCommands.d.ts

@@ -16,6 +16,6 @@
 import { AoANTSetBaseNameRecordParams, AoANTSetUndernameRecordParams } from '../../types/ant.js';
 import { CLIWriteOptionsFromAoAntParams } from '../types.js';
 /** @deprecated -- use set-ant-base-name and set-ant-undername */
-export declare function setAntRecordCLICommand(o: CLIWriteOptionsFromAoAntParams<AoANTSetUndernameRecordParams>): Promise<import("../../types/common.js").AoMessageResult>;
-export declare function setAntBaseNameCLICommand(o: CLIWriteOptionsFromAoAntParams<AoANTSetBaseNameRecordParams>): Promise<import("../../types/common.js").AoMessageResult>;
-export declare function setAntUndernameCLICommand(o: CLIWriteOptionsFromAoAntParams<AoANTSetUndernameRecordParams>): Promise<import("../../types/common.js").AoMessageResult>;
+export declare function setAntRecordCLICommand(o: CLIWriteOptionsFromAoAntParams<AoANTSetUndernameRecordParams>): Promise<import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>>;
+export declare function setAntBaseNameCLICommand(o: CLIWriteOptionsFromAoAntParams<AoANTSetBaseNameRecordParams>): Promise<import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>>;
+export declare function setAntUndernameCLICommand(o: CLIWriteOptionsFromAoAntParams<AoANTSetUndernameRecordParams>): Promise<import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>>;

package/lib/types/cli/commands/arnsPurchaseCommands.d.ts

@@ -19,4 +19,4 @@ export declare function buyRecordCLICommand(o: CLIWriteOptionsFromAoParams<AoBuy
 export declare function upgradeRecordCLICommand(o: CLIWriteOptionsFromAoParams<AoArNSPurchaseParams>): Promise<import("../../types/common.js").AoMessageResult>;
 export declare function extendLeaseCLICommand(o: CLIWriteOptionsFromAoParams<AoExtendLeaseParams>): Promise<import("../../types/common.js").AoMessageResult>;
 export declare function increaseUndernameLimitCLICommand(o: CLIWriteOptionsFromAoParams<AoIncreaseUndernameLimitParams>): Promise<import("../../types/common.js").AoMessageResult>;
-export declare function requestPrimaryNameCLICommand(o: CLIWriteOptionsFromAoParams<AoArNSPurchaseParams>): Promise<import("../../types/common.js").AoMessageResult>;
+export declare function requestPrimaryNameCLICommand(o: CLIWriteOptionsFromAoParams<AoArNSPurchaseParams>): Promise<import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>>;

package/lib/types/cli/commands/gatewayWriteCommands.d.ts

@@ -1,11 +1,11 @@
 import { AddressAndVaultIdCLIWriteOptions, DecreaseDelegateStakeCLIOptions, JoinNetworkCLIOptions, OperatorStakeCLIOptions, RedelegateStakeCLIOptions, TransferCLIOptions, UpdateGatewaySettingsCLIOptions, WriteActionCLIOptions } from '../types.js';
 export declare function joinNetwork(options: JoinNetworkCLIOptions): Promise<{
-    joinNetworkResult: import("../../types/common.js").AoMessageResult;
+    joinNetworkResult: import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>;
     joinedAddress: string;
     message: string;
 }>;
 export declare function updateGatewaySettings(options: UpdateGatewaySettingsCLIOptions): Promise<{
-    updateGatewaySettingsResult: import("../../types/common.js").AoMessageResult;
+    updateGatewaySettingsResult: import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>;
     updatedGatewayAddress: string;
     message: string;
 }>;
@@ -13,26 +13,26 @@ export declare function leaveNetwork(options: WriteActionCLIOptions): Promise<im
 export declare function saveObservations(o: WriteActionCLIOptions & {
     failedGateways?: string[];
     transactionId?: string;
-}): Promise<import("../../types/common.js").AoMessageResult>;
+}): Promise<import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>>;
 export declare function increaseOperatorStake(o: OperatorStakeCLIOptions): Promise<import("../../types/common.js").WriteOptions>;
-export declare function decreaseOperatorStake(o: OperatorStakeCLIOptions): Promise<import("../../types/common.js").AoMessageResult>;
-export declare function instantWithdrawal(o: AddressAndVaultIdCLIWriteOptions): Promise<import("../../types/common.js").AoMessageResult>;
-export declare function cancelWithdrawal(o: AddressAndVaultIdCLIWriteOptions): Promise<import("../../types/common.js").AoMessageResult>;
+export declare function decreaseOperatorStake(o: OperatorStakeCLIOptions): Promise<import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>>;
+export declare function instantWithdrawal(o: AddressAndVaultIdCLIWriteOptions): Promise<import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>>;
+export declare function cancelWithdrawal(o: AddressAndVaultIdCLIWriteOptions): Promise<import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>>;
 export declare function delegateStake(options: TransferCLIOptions): Promise<{
     senderAddress: string;
-    transferResult: import("../../types/common.js").AoMessageResult;
+    transferResult: import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>;
     message: string;
 } | {
     message: string;
 }>;
 export declare function decreaseDelegateStake(options: DecreaseDelegateStakeCLIOptions): Promise<{
     targetGateway: string;
-    decreaseDelegateStakeResult: import("../../types/common.js").AoMessageResult;
+    decreaseDelegateStakeResult: import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>;
     message: string;
 }>;
 export declare function redelegateStake(options: RedelegateStakeCLIOptions): Promise<{
     sourceGateway: string;
     targetGateway: string;
-    redelegateStakeResult: import("../../types/common.js").AoMessageResult;
+    redelegateStakeResult: import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>;
     message: string;
 }>;

package/lib/types/cli/commands/readCommands.d.ts

@@ -58,6 +58,7 @@ export declare function getCostDetails(o: GlobalCLIOptions & CLIOptionsFromAoPar
         basePrice: number;
     };
     fundingPlan?: import("../../types/io.js").AoFundingPlan;
+    wincQty?: string;
 }>;
 export declare function getPrimaryName(o: AddressAndNameCLIOptions): Promise<import("../../types/common.js").AoPrimaryName>;
 export declare function getGatewayVaults(o: PaginationAddressCLIOptions): Promise<import("../../types/io.js").PaginationResult<AoGatewayVault> | {

package/lib/types/cli/commands/transfer.d.ts

@@ -17,7 +17,7 @@ import { AoCreateVaultParams, AoExtendVaultParams, AoIncreaseVaultParams, AoRevo
 import { CLIWriteOptionsFromAoParams, JsonSerializable, TransferCLIOptions } from '../types.js';
 export declare function transferCLICommand(options: TransferCLIOptions): Promise<{
     senderAddress: string;
-    transferResult: import("../../types/common.js").AoMessageResult;
+    transferResult: import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>;
     message: string;
 } | {
     message: string;
@@ -27,14 +27,14 @@ export declare function revokeVaultCLICommand(o: CLIWriteOptionsFromAoParams<AoR
 export declare function createVaultCLICommand(o: CLIWriteOptionsFromAoParams<AoCreateVaultParams>): Promise<JsonSerializable>;
 export declare function extendVaultCLICommand(o: CLIWriteOptionsFromAoParams<AoExtendVaultParams>): Promise<{
     senderAddress: string;
-    transferResult: import("../../types/common.js").AoMessageResult;
+    transferResult: import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>;
     message: string;
 } | {
     message: string;
 }>;
 export declare function increaseVaultCLICommand(o: CLIWriteOptionsFromAoParams<AoIncreaseVaultParams>): Promise<{
     senderAddress: string;
-    transferResult: import("../../types/common.js").AoMessageResult;
+    transferResult: import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>;
     message: string;
 } | {
     message: string;

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

@@ -45,6 +45,10 @@ export declare const optionMap: {
         alias: string;
         description: string;
     };
+    paymentUrl: {
+        alias: string;
+        description: string;
+    };
     processId: {
         alias: string;
         description: string;
@@ -265,6 +269,11 @@ export declare const optionMap: {
         alias: string;
         description: string;
     };
+    token: {
+        alias: string;
+        description: string;
+        default: string;
+    };
 };
 export declare const walletOptions: {
     alias: string;

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

@@ -14,8 +14,10 @@
  * limitations under the License.
  */
 import { AoAddressParams, AoArNSNameParams, AoGetVaultParams, AoJoinNetworkParams, AoTokenCostParams, PaginationParams } from '../types/io.js';
+export type SupportedCLITokenType = 'ethereum' | 'arweave';
 export type WalletCLIOptions = {
     walletFile?: string;
+    token?: SupportedCLITokenType;
     privateKey?: string;
 };
 export type GlobalCLIOptions = WalletCLIOptions & {
@@ -25,6 +27,7 @@ export type GlobalCLIOptions = WalletCLIOptions & {
     debug: boolean;
     arioProcessId?: string;
     cuUrl?: string;
+    paymentUrl?: string;
 };
 export type WriteActionCLIOptions = GlobalCLIOptions & {
     tags?: string[];

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

@@ -22,6 +22,10 @@ export declare function requiredJwkFromOptions(options: WalletCLIOptions): JWKIn
 export declare function jwkToAddress(jwk: JWKInterface): string;
 export declare function getLoggerFromOptions(options: GlobalCLIOptions): Logger;
 export declare function readARIOFromOptions(options: GlobalCLIOptions): AoARIORead;
+export declare function contractSignerFromOptions(options: WalletCLIOptions): {
+    signer: ContractSigner;
+    signerAddress: string;
+} | undefined;
 export declare function requiredContractSignerFromOptions(options: WalletCLIOptions): {
     signer: ContractSigner;
     signerAddress: string;

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

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

package/lib/types/common/ant-versions.d.ts

@@ -1,5 +1,5 @@
 import { AoANTVersionsRead, AoANTVersionsWrite } from '../types/ant.js';
-import { WithSigner } from '../types/common.js';
+import { AoMessageResult, WithSigner } from '../types/common.js';
 import { ProcessConfiguration } from '../types/io.js';
 import { AOProcess } from './contracts/ao-process.js';
 type ANTVersionsNoSigner = ProcessConfiguration;
@@ -27,16 +27,13 @@ export declare class ANTVersionsReadable implements AoANTVersionsRead {
 export declare class ANTVersionsWritable extends ANTVersionsReadable implements AoANTVersionsWrite {
     private signer;
     constructor({ signer, ...config }: WithSigner<ProcessConfiguration>);
-    addVersion(params: {
+    addVersion({ version, moduleId, luaSourceId, notes, }: {
         version: string;
         moduleId: string;
         luaSourceId?: string;
         notes?: string;
     }, { tags }: {
         tags: any;
-    }): Promise<{
-        id: string;
-        result?: unknown;
-    }>;
+    }): Promise<AoMessageResult>;
 }
 export {};

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';