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

package/lib/cjs/types/io.js

@@ -28,18 +28,19 @@ const isValidIntent = (intent) => {
     return exports.validIntents.indexOf(intent) !== -1;
 };
 exports.isValidIntent = isValidIntent;
-exports.fundFromOptions = ['balance', 'stakes', 'any'];
+exports.fundFromOptions = ['balance', 'stakes', 'any', 'turbo'];
 const isValidFundFrom = (fundFrom) => {
     return exports.fundFromOptions.indexOf(fundFrom) !== -1;
 };
 exports.isValidFundFrom = isValidFundFrom;
 // Type-guard functions
 function isProcessConfiguration(config) {
-    return 'process' in config;
+    return config !== undefined && 'process' in config;
 }
 exports.isProcessConfiguration = isProcessConfiguration;
 function isProcessIdConfiguration(config) {
-    return ('processId' in config &&
+    return (config !== undefined &&
+        'processId' in config &&
         typeof config.processId === 'string' &&
         (0, arweave_js_1.validateArweaveId)(config.processId) === true);
 }

package/lib/cjs/utils/ao.js

@@ -137,6 +137,8 @@ function createAoSigner(signer) {
         }));
         return signedData;
     };
+    // eslint-disable-next-line
+    // @ts-ignore Buffer vs ArrayBuffer type mismatch
     return aoSigner;
 }
 exports.createAoSigner = createAoSigner;

package/lib/cjs/utils/url.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.urlWithSearchParams = void 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.
+ */
+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();
+};
+exports.urlWithSearchParams = urlWithSearchParams;

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

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const url_js_1 = require("./url.js");
+(0, node_test_1.test)('urlWithSearchParams prunes undefined values but keeps other falsey values', () => {
+    const result = (0, url_js_1.urlWithSearchParams)({
+        baseUrl: 'https://example.com',
+        params: {
+            number: 1,
+            string: 'string',
+            boolean: true,
+            empty: '',
+            zero: 0,
+            false: false,
+            null: null,
+            undef: undefined,
+        },
+    });
+    node_assert_1.default.strictEqual(result, 'https://example.com/?number=1&string=string&boolean=true&empty=&zero=0&false=false');
+});

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.9.1';
+exports.version = '3.10.0-alpha.2';

package/lib/esm/cli/options.js

@@ -49,6 +49,10 @@ export const optionMap = {
         alias: '--cu-url <cuUrl>',
         description: 'The URL for a custom compute unit',
     },
+    paymentUrl: {
+        alias: '--payment-url <paymentUrl>',
+        description: 'The URL for a custom turbo payment service',
+    },
     processId: {
         alias: '--process-id <processId>',
         description: 'The process ID to interact with',
@@ -269,9 +273,15 @@ export const optionMap = {
         alias: '--logo <logo>',
         description: 'The ANT logo',
     },
+    token: {
+        alias: '-t, --token <type>',
+        description: 'Crypto token type for wallet or action',
+        default: 'arweave',
+    },
 };
 export const walletOptions = [
     optionMap.walletFile,
+    optionMap.token,
     // optionMap.mnemonic,
     optionMap.privateKey,
 ];
@@ -289,6 +299,7 @@ export const arnsPurchaseOptions = [
     ...writeActionOptions,
     optionMap.name,
     optionMap.fundFrom,
+    optionMap.paymentUrl,
 ];
 export const epochOptions = [optionMap.epochIndex, optionMap.timestamp];
 export const addressAndVaultIdOptions = [optionMap.address, optionMap.vaultId];
@@ -312,6 +323,7 @@ export const tokenCostOptions = [
     optionMap.quantity,
     optionMap.address,
     optionMap.fundFrom,
+    optionMap.paymentUrl,
 ];
 export const transferOptions = [
     ...writeActionOptions,

package/lib/esm/cli/utils.js

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { EthereumSigner } from '@dha-team/arbundles';
 import { connect } from '@permaweb/aoconnect';
 import { program } from 'commander';
 import { readFileSync } from 'fs';
@@ -77,7 +78,7 @@ export function arioProcessIdFromOptions({ arioProcessId, devnet, testnet, }) {
     }
     return ARIO_MAINNET_PROCESS_ID;
 }
-function jwkFromOptions({ privateKey, walletFile, }) {
+function walletFromOptions({ privateKey, walletFile, }) {
     if (privateKey !== undefined) {
         return JSON.parse(privateKey);
     }
@@ -87,7 +88,7 @@ function jwkFromOptions({ privateKey, walletFile, }) {
     return undefined;
 }
 export function requiredJwkFromOptions(options) {
-    const jwk = jwkFromOptions(options);
+    const jwk = walletFromOptions(options);
     if (jwk === undefined) {
         throw new Error('No JWK provided for signing!\nPlease provide a stringified JWK with `--private-key` or the file path of a jwk.json file with `--wallet-file`');
     }
@@ -117,13 +118,30 @@ export function readARIOFromOptions(options) {
     setLoggerIfDebug(options);
     return ARIO.init({
         process: aoProcessFromOptions(options),
+        paymentUrl: options.paymentUrl,
     });
 }
-export function requiredContractSignerFromOptions(options) {
+export function contractSignerFromOptions(options) {
+    const wallet = walletFromOptions(options);
+    if (wallet === undefined) {
+        return undefined;
+    }
+    const token = options.token ?? 'arweave';
+    if (token === 'ethereum') {
+        const signer = new EthereumSigner(wallet);
+        // For EthereumSigner, we need to convert the JWK to a string
+        return { signer, signerAddress: signer.publicKey.toString('hex') };
+    }
     // TODO: Support other wallet types
-    const jwk = requiredJwkFromOptions(options);
-    const signer = new ArweaveSigner(jwk);
-    return { signer, signerAddress: jwkToAddress(jwk) };
+    const signer = new ArweaveSigner(wallet);
+    return { signer, signerAddress: jwkToAddress(wallet) };
+}
+export function requiredContractSignerFromOptions(options) {
+    const contractSigner = contractSignerFromOptions(options);
+    if (contractSigner === undefined) {
+        throw new Error('No signer provided for signing!\nPlease provide a stringified JWK or Ethereum private key with `--private-key` or the file path of an arweave.jwk.json or eth.private.key.txt file with `--wallet-file`');
+    }
+    return contractSigner;
 }
 export function requiredAoSignerFromOptions(options) {
     return createAoSigner(requiredContractSignerFromOptions(options).signer);
@@ -135,6 +153,7 @@ export function writeARIOFromOptions(options) {
         ario: ARIO.init({
             process: aoProcessFromOptions(options),
             signer,
+            paymentUrl: options.paymentUrl,
         }),
         signerAddress,
     };
@@ -155,10 +174,9 @@ export function addressFromOptions(options) {
     if (options.address !== undefined) {
         return options.address;
     }
-    // TODO: Support other wallet types
-    const jwk = jwkFromOptions(options);
-    if (jwk !== undefined) {
-        return jwkToAddress(jwk);
+    const signer = contractSignerFromOptions(options);
+    if (signer !== undefined) {
+        return signer.signerAddress;
     }
     return undefined;
 }
@@ -281,6 +299,9 @@ export function requiredMARIOFromOptions(options, key) {
     return new ARIOToken(+options[key]).toMARIO();
 }
 export async function assertEnoughBalanceForArNSPurchase({ ario, address, costDetailsParams, }) {
+    if (costDetailsParams.fundFrom === 'turbo') {
+        return;
+    }
     const costDetails = await ario.getCostDetails(costDetailsParams);
     if (costDetails.fundingPlan) {
         if (costDetails.fundingPlan.shortfall > 0) {

package/lib/esm/common/ant-versions.js

@@ -70,14 +70,14 @@ export class ANTVersionsWritable extends ANTVersionsReadable {
         super(config);
         this.signer = createAoSigner(signer);
     }
-    async addVersion(params, { tags }) {
+    async addVersion({ version, moduleId, luaSourceId, notes, }, { tags }) {
         return this.process.send({
             tags: pruneTags([
                 { name: 'Action', value: 'Add-Version' },
-                { name: 'Version', value: params.version },
-                { name: 'Module-Id', value: params.moduleId },
-                { name: 'Lua-Source-Id', value: params.luaSourceId },
-                { name: 'Notes', value: params.notes },
+                { name: 'Version', value: version },
+                { name: 'Module-Id', value: moduleId },
+                { name: 'Lua-Source-Id', value: luaSourceId },
+                { name: 'Notes', value: notes },
                 ...(tags ?? []),
             ]),
             signer: this.signer,

package/lib/esm/common/faucet.js

@@ -0,0 +1,145 @@
+const DEFAULT_FAUCET_API_URL = 'https://faucet.ario.permaweb.services';
+/**
+ * Creates a proxy object that implements the TokenFaucet interface. It wraps the ARIOReadable instance and adds methods for claiming tokens from the faucet API.
+ * @param arioInstance - The ARIOReadable instance
+ * @param faucetApiUrl - The URL of the faucet API
+ * @returns A proxy object that implements the TokenFaucet interface
+ */
+export function createFaucet({ arioInstance, faucetApiUrl = DEFAULT_FAUCET_API_URL, }) {
+    const faucet = new ARIOTokenFaucet({
+        faucetUrl: faucetApiUrl,
+        processId: arioInstance.process.processId,
+    });
+    const proxy = new Proxy(arioInstance, {
+        get(target, prop) {
+            if (prop === 'faucet') {
+                return faucet;
+            }
+            if (prop in target) {
+                const result = target[prop];
+                if (typeof result === 'function') {
+                    return result.bind(target);
+                }
+                return result;
+            }
+            return undefined;
+        },
+    });
+    return proxy;
+}
+export class ARIOTokenFaucet {
+    faucetUrl;
+    processId;
+    constructor({ faucetUrl, processId, }) {
+        this.faucetUrl = faucetUrl;
+        this.processId = processId;
+    }
+    /**
+     * Returns the captcha URL for a process. The captcha is used to verify a human is solving the captcha. Once you have a captcha response, you can use it to request an authorization token via the requestAuthToken method.
+     * @returns The captcha URL for a process
+     */
+    async captchaUrl() {
+        const res = await fetch(`${this.faucetUrl}/api/captcha/url?process-id=${this.processId}`, {
+            method: 'GET',
+        });
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(body.error);
+        }
+        const data = (await res.json());
+        return data;
+    }
+    /**
+     * Claim tokens for a process using a captcha response. This method is used to synchronously claim tokens for a process using a captcha response.
+     * @param captchaResponse - The captcha response
+     * @param recipient - The recipient address
+     * @param quantity - The quantity of tokens to claim
+     * @returns The claim id and success status
+     */
+    async claimWithCaptchaResponse({ captchaResponse, recipient, quantity, }) {
+        const res = await fetch(`${this.faucetUrl}/api/claim/sync`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                processId: this.processId,
+                recipient,
+                quantity,
+                captchaResponse,
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(body.error);
+        }
+        const data = (await res.json());
+        return data;
+    }
+    /**
+     * Requests an authorization token for a process. The captcha response is used to verify a human is solving the captcha. Once you have an authorization token, you can use it to claim tokens from the faucet via the claimWithAuthToken method.
+     * @param captchaResponse - The captcha response
+     * @returns The status of the request, the authorization token, and the expiration time
+     */
+    async requestAuthToken({ captchaResponse, }) {
+        const res = await fetch(`${this.faucetUrl}/api/captcha/verify`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                processId: this.processId,
+                captchaResponse,
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(body.error);
+        }
+        const data = (await res.json());
+        return data;
+    }
+    /**
+     * Transfers tokens from the faucet wallet to a recipient address using an authorization token. To request an authorization token, solve the captcha from the captchaUrl method.
+     * @param authToken - The authorization token
+     * @param recipient - The recipient address
+     * @param quantity - The quantity of tokens to claim
+     * @returns The message id of the transfer and success status
+     */
+    async claimWithAuthToken({ authToken, recipient, quantity, }) {
+        const res = await fetch(`${this.faucetUrl}/api/claim/async`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${authToken}`,
+            },
+            body: JSON.stringify({
+                recipient,
+                qty: quantity,
+                processId: this.processId,
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(body.error);
+        }
+        const data = (await res.json());
+        return data;
+    }
+    /**
+     * Verifies an authorization token is valid.
+     * @param authToken - The authorization token
+     * @returns The validity of the authorization token and the expiration time
+     */
+    async verifyAuthToken({ authToken }) {
+        const res = await fetch(`${this.faucetUrl}/api/token/verify?process-id=${this.processId}`, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${authToken}`,
+            },
+        });
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(body.error);
+        }
+        const data = (await res.json());
+        return data;
+    }
+}

package/lib/esm/common/index.js

@@ -18,6 +18,7 @@ export * from './logger.js';
 export * from './ant.js';
 export * from './ant-registry.js';
 export * from './ant-versions.js';
+export * from './faucet.js';
 // ao
 export * from './io.js';
 export * from './contracts/ao-process.js';

package/lib/esm/common/io.js

@@ -1,10 +1,13 @@
-import { ARIO_MAINNET_PROCESS_ID } from '../constants.js';
-import { isProcessConfiguration, isProcessIdConfiguration, } from '../types/io.js';
+import { connect } from '@permaweb/aoconnect';
+import { ARIO_MAINNET_PROCESS_ID, ARIO_TESTNET_PROCESS_ID, } from '../constants.js';
+import { isProcessConfiguration, isProcessIdConfiguration, } from '../types/index.js';
 import { createAoSigner } from '../utils/ao.js';
 import { getEpochDataFromGqlWithCUFallback, paginationParamsToTags, pruneTags, removeEligibleRewardsFromEpochData, sortAndPaginateEpochDataIntoEligibleDistributions, } from '../utils/arweave.js';
 import { defaultArweave } from './arweave.js';
 import { AOProcess } from './contracts/ao-process.js';
 import { InvalidContractConfigurationError } from './error.js';
+import { createFaucet } from './faucet.js';
+import { TurboArNSPaymentProvider } from './turbo.js';
 export class ARIO {
     // Implementation
     static init(config) {
@@ -13,11 +16,62 @@ export class ARIO {
         }
         return new ARIOReadable(config);
     }
+    static mainnet(config) {
+        if (config !== undefined && 'signer' in config) {
+            return new ARIOWriteable({
+                ...config,
+                process: new AOProcess({
+                    processId: ARIO_MAINNET_PROCESS_ID,
+                    ao: connect({
+                        CU_URL: 'https://cu.ardrive.io',
+                        ...config?.process?.ao,
+                    }),
+                }),
+            });
+        }
+        return new ARIOReadable({
+            ...config,
+            process: new AOProcess({
+                processId: ARIO_MAINNET_PROCESS_ID,
+            }),
+        });
+    }
+    static testnet(config) {
+        if (config !== undefined && 'signer' in config) {
+            return createFaucet({
+                arioInstance: new ARIOWriteable({
+                    ...config,
+                    process: new AOProcess({
+                        processId: ARIO_TESTNET_PROCESS_ID,
+                        ao: connect({
+                            CU_URL: 'https://cu.ardrive.io',
+                            ...config?.process?.ao,
+                        }),
+                    }),
+                }),
+                faucetApiUrl: config?.faucetUrl,
+            });
+        }
+        return createFaucet({
+            arioInstance: new ARIOReadable({
+                ...config,
+                process: new AOProcess({
+                    processId: ARIO_TESTNET_PROCESS_ID,
+                    ao: connect({
+                        CU_URL: 'https://cu.ardrive.io',
+                        ...config?.process?.ao,
+                    }),
+                }),
+            }),
+            faucetApiUrl: config?.faucetUrl,
+        });
+    }
 }
 export class ARIOReadable {
     process;
     epochSettings;
     arweave;
+    paymentProvider; // TODO: this could be an array/map of payment providers
     constructor(config) {
         this.arweave = config?.arweave ?? defaultArweave;
         if (config === undefined || Object.keys(config).length === 0) {
@@ -36,6 +90,9 @@ export class ARIOReadable {
         else {
             throw new InvalidContractConfigurationError();
         }
+        this.paymentProvider = new TurboArNSPaymentProvider({
+            paymentUrl: config?.paymentUrl,
+        });
     }
     async getInfo() {
         return this.process.read({
@@ -367,6 +424,20 @@ export class ARIOReadable {
     // TODO: Can overload this function to refine different types of cost details params
     async getCostDetails({ intent, type, years, name, quantity, fromAddress, fundFrom, }) {
         const replacedBuyRecordWithBuyName = intent === 'Buy-Record' ? 'Buy-Name' : intent;
+        if (fundFrom === 'turbo') {
+            const { mARIO, winc } = await this.paymentProvider.getArNSPriceDetails({
+                intent: replacedBuyRecordWithBuyName,
+                name,
+                quantity,
+                type,
+                years,
+            });
+            return {
+                tokenCost: +mARIO,
+                wincQty: winc,
+                discounts: [],
+            };
+        }
         const allTags = [
             { name: 'Action', value: 'Cost-Details' },
             {
@@ -533,7 +604,8 @@ export class ARIOReadable {
 }
 export class ARIOWriteable extends ARIOReadable {
     signer;
-    constructor({ signer, ...config }) {
+    paymentProvider;
+    constructor({ signer, paymentUrl, ...config }) {
         if (config === undefined) {
             super({
                 process: new AOProcess({
@@ -545,6 +617,10 @@ export class ARIOWriteable extends ARIOReadable {
             super(config);
         }
         this.signer = createAoSigner(signer);
+        this.paymentProvider = new TurboArNSPaymentProvider({
+            signer: signer,
+            paymentUrl,
+        });
     }
     async transfer({ target, qty, }, options) {
         const { tags = [] } = options || {};
@@ -819,6 +895,12 @@ export class ARIOWriteable extends ARIOReadable {
         });
     }
     async buyRecord(params, options) {
+        if (params.fundFrom === 'turbo') {
+            return this.paymentProvider.initiateArNSPurchase({
+                intent: 'Buy-Name',
+                ...params,
+            });
+        }
         const { tags = [] } = options || {};
         const allTags = [
             ...tags,
@@ -843,6 +925,12 @@ export class ARIOWriteable extends ARIOReadable {
      * @returns {Promise<AoMessageResult>} The result of the upgrade
      */
     async upgradeRecord(params, options) {
+        if (params.fundFrom === 'turbo') {
+            return this.paymentProvider.initiateArNSPurchase({
+                intent: 'Upgrade-Name',
+                name: params.name,
+            });
+        }
         const { tags = [] } = options || {};
         const allTags = [
             ...tags,
@@ -865,6 +953,12 @@ export class ARIOWriteable extends ARIOReadable {
      * @returns {Promise<AoMessageResult>} The result of the extension
      */
     async extendLease(params, options) {
+        if (params.fundFrom === 'turbo') {
+            return this.paymentProvider.initiateArNSPurchase({
+                intent: 'Extend-Lease',
+                ...params,
+            });
+        }
         const { tags = [] } = options || {};
         const allTags = [
             ...tags,
@@ -879,6 +973,12 @@ export class ARIOWriteable extends ARIOReadable {
         });
     }
     async increaseUndernameLimit(params, options) {
+        if (params.fundFrom === 'turbo') {
+            return this.paymentProvider.initiateArNSPurchase({
+                intent: 'Increase-Undername-Limit',
+                ...params,
+            });
+        }
         const { tags = [] } = options || {};
         const allTags = [
             ...tags,
@@ -915,6 +1015,9 @@ export class ARIOWriteable extends ARIOReadable {
         });
     }
     async requestPrimaryName(params, options) {
+        if (params.fundFrom === 'turbo') {
+            throw new Error('Turbo funding is not yet supported for primary name requests');
+        }
         const { tags = [] } = options || {};
         const allTags = [
             ...tags,