@ar.io/sdk 3.10.2 → 3.11.0-alpha.10

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`');
     }
@@ -115,15 +116,39 @@ function aoProcessFromOptions(options) {
 }
 export function readARIOFromOptions(options) {
     setLoggerIfDebug(options);
+    console.log('options', {
+        cuUrl: 'https://cu.ardrive.io', // default to ardrive cu for ARIO process
+        ...options,
+    });
     return ARIO.init({
-        process: aoProcessFromOptions(options),
+        process: aoProcessFromOptions({
+            cuUrl: 'https://cu.ardrive.io', // default to ardrive cu for ARIO process
+            ...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 +160,7 @@ export function writeARIOFromOptions(options) {
         ario: ARIO.init({
             process: aoProcessFromOptions(options),
             signer,
+            paymentUrl: options.paymentUrl,
         }),
         signerAddress,
     };
@@ -155,10 +181,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 +306,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/ant.js

@@ -89,12 +89,12 @@ export class AoANTReadable {
      * ```
      */
     async getRecord({ undername }, { strict } = { strict: this.strict }) {
-        const tags = [
-            { name: 'Sub-Domain', value: undername },
-            { name: 'Action', value: 'Record' },
-        ];
+        // TODO: use sortedANTRecords to get priority on all records, even if ANT does not have a priority set
         const record = await this.process.read({
-            tags,
+            tags: [
+                { name: 'Action', value: 'Record' },
+                { name: 'Sub-Domain', value: undername },
+            ],
         });
         if (strict)
             parseSchemaResult(AntRecordSchema.passthrough(), record);

package/lib/esm/common/index.js

@@ -22,3 +22,5 @@ export * from './faucet.js';
 // ao
 export * from './io.js';
 export * from './contracts/ao-process.js';
+// wayfinder
+export * from './wayfinder/index.js';

package/lib/esm/common/io.js

@@ -18,10 +18,12 @@ import { ARIO_MAINNET_PROCESS_ID, ARIO_TESTNET_PROCESS_ID, } from '../constants.
 import { isProcessConfiguration, isProcessIdConfiguration, } from '../types/index.js';
 import { createAoSigner } from '../utils/ao.js';
 import { getEpochDataFromGqlWithCUFallback, paginationParamsToTags, pruneTags, removeEligibleRewardsFromEpochData, sortAndPaginateEpochDataIntoEligibleDistributions, } from '../utils/arweave.js';
+import { ANT } from './ant.js';
 import { defaultArweave } from './arweave.js';
 import { AOProcess } from './contracts/ao-process.js';
 import { InvalidContractConfigurationError } from './error.js';
 import { createFaucet } from './faucet.js';
+import { TurboArNSPaymentFactory, TurboArNSPaymentProviderAuthenticated, isTurboArNSSigner, } from './turbo.js';
 export class ARIO {
     // Implementation
     static init(config) {
@@ -89,6 +91,7 @@ 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) {
@@ -107,6 +110,9 @@ export class ARIOReadable {
         else {
             throw new InvalidContractConfigurationError();
         }
+        this.paymentProvider = TurboArNSPaymentFactory.init({
+            paymentUrl: config?.paymentUrl,
+        });
     }
     async getInfo() {
         return this.process.read({
@@ -438,6 +444,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' },
             {
@@ -601,10 +621,47 @@ export class ARIOReadable {
             ],
         });
     }
+    async resolveArNSName({ name, }) {
+        const baseName = name.split('_').pop();
+        if (baseName === undefined) {
+            throw new Error('Invalid name');
+        }
+        const undername = name === baseName ? '@' : name.replace(`_${baseName}`, '');
+        const nameData = await this.getArNSRecord({ name: baseName });
+        const ant = ANT.init({
+            process: new AOProcess({
+                ao: this.process.ao,
+                processId: nameData.processId,
+            }),
+        });
+        const [owner, antRecord] = await Promise.all([
+            ant.getOwner(),
+            ant.getRecord({ undername }),
+        ]);
+        if (antRecord === undefined) {
+            throw new Error(`Record for ${undername} not found on ANT.`);
+        }
+        if (antRecord.ttlSeconds === undefined ||
+            antRecord.transactionId === undefined) {
+            throw new Error(`Invalid record on ANT. Must have ttlSeconds and transactionId. Record: ${JSON.stringify(antRecord)}`);
+        }
+        return {
+            name: name,
+            owner: owner,
+            txId: antRecord.transactionId,
+            ttlSeconds: antRecord.ttlSeconds,
+            priority: antRecord.priority,
+            // NOTE: we may want return the actual index of the record based on sorting in case ANT tries to set duplicate priority values to get around undername limits
+            processId: nameData.processId,
+            undernameLimit: nameData.undernameLimit,
+            type: nameData.type,
+        };
+    }
 }
 export class ARIOWriteable extends ARIOReadable {
     signer;
-    constructor({ signer, ...config }) {
+    paymentProvider;
+    constructor({ signer, paymentUrl, ...config }) {
         if (config === undefined) {
             super({
                 process: new AOProcess({
@@ -616,6 +673,10 @@ export class ARIOWriteable extends ARIOReadable {
             super(config);
         }
         this.signer = createAoSigner(signer);
+        this.paymentProvider = TurboArNSPaymentFactory.init({
+            signer: isTurboArNSSigner(signer) ? signer : undefined,
+            paymentUrl,
+        });
     }
     async transfer({ target, qty, }, options) {
         const { tags = [] } = options || {};
@@ -890,6 +951,18 @@ export class ARIOWriteable extends ARIOReadable {
         });
     }
     async buyRecord(params, options) {
+        if (params.fundFrom === 'turbo') {
+            if (!(this.paymentProvider instanceof TurboArNSPaymentProviderAuthenticated)) {
+                throw new Error('Turbo funding is not supported for this payment provider');
+            }
+            return this.paymentProvider.initiateArNSPurchase({
+                intent: 'Buy-Name',
+                name: params.name,
+                years: params.years,
+                type: params.type,
+                processId: params.processId,
+            });
+        }
         const { tags = [] } = options || {};
         const allTags = [
             ...tags,
@@ -914,6 +987,15 @@ export class ARIOWriteable extends ARIOReadable {
      * @returns {Promise<AoMessageResult>} The result of the upgrade
      */
     async upgradeRecord(params, options) {
+        if (params.fundFrom === 'turbo') {
+            if (!(this.paymentProvider instanceof TurboArNSPaymentProviderAuthenticated)) {
+                throw new Error('Turbo funding is not supported for this payment provider');
+            }
+            return this.paymentProvider.initiateArNSPurchase({
+                intent: 'Upgrade-Name',
+                name: params.name,
+            });
+        }
         const { tags = [] } = options || {};
         const allTags = [
             ...tags,
@@ -936,6 +1018,16 @@ export class ARIOWriteable extends ARIOReadable {
      * @returns {Promise<AoMessageResult>} The result of the extension
      */
     async extendLease(params, options) {
+        if (params.fundFrom === 'turbo') {
+            if (!(this.paymentProvider instanceof TurboArNSPaymentProviderAuthenticated)) {
+                throw new Error('Turbo funding is not supported for this payment provider');
+            }
+            return this.paymentProvider.initiateArNSPurchase({
+                intent: 'Extend-Lease',
+                name: params.name,
+                years: params.years,
+            });
+        }
         const { tags = [] } = options || {};
         const allTags = [
             ...tags,
@@ -950,6 +1042,16 @@ export class ARIOWriteable extends ARIOReadable {
         });
     }
     async increaseUndernameLimit(params, options) {
+        if (params.fundFrom === 'turbo') {
+            if (!(this.paymentProvider instanceof TurboArNSPaymentProviderAuthenticated)) {
+                throw new Error('Turbo funding is not supported for this payment provider');
+            }
+            return this.paymentProvider.initiateArNSPurchase({
+                intent: 'Increase-Undername-Limit',
+                quantity: params.increaseCount,
+                name: params.name,
+            });
+        }
         const { tags = [] } = options || {};
         const allTags = [
             ...tags,
@@ -986,6 +1088,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,

package/lib/esm/common/turbo.js

@@ -0,0 +1,200 @@
+/**
+ * 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 { ArconnectSigner, ArweaveSigner, EthereumSigner, InjectedEthereumSigner, SignatureConfig, } from '@dha-team/arbundles';
+import { v4 as uuidv4 } from 'uuid';
+import { mARIOToken } from '../types/token.js';
+import { toB64Url } from '../utils/base64.js';
+import { createAxiosInstance } from '../utils/http-client.js';
+import { urlWithSearchParams } from '../utils/url.js';
+import { Logger } from './logger.js';
+export async function signedRequestHeadersFromSigner({ signer, nonce = uuidv4(), }) {
+    let signature = undefined;
+    let publicKey = undefined;
+    const signatureType = isWanderArweaveBrowserSigner(signer)
+        ? SignatureConfig.ARWEAVE
+        : signer.signatureType;
+    // equivalent to window.arweaveWallet
+    if (isWanderArweaveBrowserSigner(signer)) {
+        signature = toB64Url(Buffer.from(await signer.signMessage(Uint8Array.from(Buffer.from(nonce)))));
+    }
+    else if (signer instanceof ArconnectSigner) {
+        signature = toB64Url(Buffer.from(await signer['signer'].signMessage(Uint8Array.from(Buffer.from(nonce)))));
+    }
+    else if (signer instanceof ArweaveSigner ||
+        signer instanceof EthereumSigner ||
+        signer instanceof InjectedEthereumSigner) {
+        if ('setPublicKey' in signer && signer['publicKey'] === undefined) {
+            await signer.setPublicKey();
+        }
+        signature = toB64Url(Buffer.from(await signer.sign(Uint8Array.from(Buffer.from(nonce)))));
+    }
+    switch (signatureType) {
+        case SignatureConfig.ARWEAVE:
+            if (isWanderArweaveBrowserSigner(signer)) {
+                publicKey = await signer.getActivePublicKey();
+            }
+            else if ('setPublicKey' in signer) {
+                await signer.setPublicKey();
+                publicKey = toB64Url(signer.publicKey);
+            }
+            break;
+        case SignatureConfig.ETHEREUM:
+            if ('publicKey' in signer) {
+                publicKey = '0x' + signer.publicKey.toString('hex');
+            }
+            else {
+                throw new Error('Public key not found');
+            }
+            break;
+        // TODO: solana sig support
+        // case SignatureConfig.SOLANA:
+        // case SignatureConfig.ED25519:
+        default:
+            throw new Error(`Unsupported signer type for signing requests: ${signatureType}`);
+    }
+    if (publicKey === undefined || signature === undefined) {
+        throw new Error('Public key or signature not found');
+    }
+    return {
+        'x-public-key': publicKey,
+        'x-nonce': nonce,
+        'x-signature': signature,
+        'x-signature-type': signatureType,
+    };
+}
+export class TurboArNSPaymentFactory {
+    static init(config) {
+        const { signer, paymentUrl, axios, logger } = config ?? {};
+        if (signer !== undefined) {
+            return new TurboArNSPaymentProviderAuthenticated({
+                signer,
+                paymentUrl,
+                axios,
+                logger,
+            });
+        }
+        return new TurboArNSPaymentProviderUnauthenticated({
+            paymentUrl,
+            axios,
+            logger,
+        });
+    }
+}
+// Base class for unauthenticated operations
+export class TurboArNSPaymentProviderUnauthenticated {
+    paymentUrl;
+    axios;
+    logger;
+    constructor({ paymentUrl = 'https://payment.ardrive.io', axios = createAxiosInstance(), logger = Logger.default, }) {
+        this.paymentUrl = paymentUrl;
+        this.axios = axios;
+        this.logger = logger;
+    }
+    async getArNSPriceDetails({ intent, name, quantity, type, years, }) {
+        const url = urlWithSearchParams({
+            baseUrl: `${this.paymentUrl}/v1/arns/price/${intent}/${name}`,
+            params: {
+                increaseQty: quantity,
+                type,
+                years,
+            },
+        });
+        const { data, status } = await this.axios.get(url);
+        this.logger.debug('getArNSPriceDetails', {
+            intent,
+            name,
+            quantity,
+            type,
+            years,
+            data,
+            status,
+        });
+        if (status !== 200) {
+            throw new Error('Failed to get ArNS purchase price ' + JSON.stringify(data));
+        }
+        if (!data.winc || !data.mARIO) {
+            throw new Error('Invalid response from Turbo ' + JSON.stringify(data));
+        }
+        return {
+            winc: data.winc,
+            mARIO: new mARIOToken(+data.mARIO),
+        };
+    }
+    async getPrice(params) {
+        const { winc } = await this.getArNSPriceDetails(params);
+        return +winc;
+    }
+}
+// Class for authenticated operations, extending the base class
+export class TurboArNSPaymentProviderAuthenticated extends TurboArNSPaymentProviderUnauthenticated {
+    signer;
+    constructor({ signer, ...restConfig }) {
+        super(restConfig); // Pass unauthenticated config to base class+
+        if (!isTurboArNSSigner(signer)) {
+            throw new Error('Signer must be a TurboArNSSigner');
+        }
+        this.signer = signer;
+    }
+    async initiateArNSPurchase({ intent, name, quantity, type, processId, years, }) {
+        // Signer check is implicitly handled by requiring it in the constructor
+        const url = urlWithSearchParams({
+            baseUrl: `${this.paymentUrl}/v1/arns/purchase/${intent}/${name}`,
+            params: {
+                increaseQty: quantity,
+                processId,
+                type,
+                years,
+            },
+        });
+        const headers = await signedRequestHeadersFromSigner({
+            signer: this.signer,
+        });
+        const { data, status } = await this.axios.post(url, null, {
+            headers,
+        });
+        this.logger.debug('Initiated ArNS purchase', {
+            intent,
+            name,
+            quantity,
+            processId,
+            type,
+            years,
+            data,
+            status,
+        });
+        if (status !== 200) {
+            throw new Error('Failed to initiate ArNS purchase ' + JSON.stringify(data));
+        }
+        return {
+            id: data.arioWriteResult.id,
+            result: data.purchaseReceipt,
+        };
+    }
+}
+function isWanderArweaveBrowserSigner(signer) {
+    return (typeof signer === 'object' &&
+        signer !== null &&
+        'signMessage' in signer &&
+        'getActivePublicKey' in signer);
+}
+export function isTurboArNSSigner(signer) {
+    const isWanderWallet = isWanderArweaveBrowserSigner(signer);
+    const isSigner = signer instanceof EthereumSigner ||
+        signer instanceof InjectedEthereumSigner ||
+        signer instanceof ArweaveSigner ||
+        signer instanceof ArconnectSigner;
+    return isWanderWallet || isSigner;
+}

package/lib/esm/common/wayfinder/gateways/trusted-gateways.js

@@ -0,0 +1,102 @@
+const arioGatewayHeaders = {
+    digest: 'x-ar-io-digest',
+    verified: 'x-ar-io-verified',
+    txId: 'x-arns-resolved-tx-id',
+    processId: 'x-arns-resolved-process-id',
+};
+export class TrustedGatewaysHashProvider {
+    gatewaysProvider;
+    constructor({ gatewaysProvider,
+    // TODO: add threshold for allowed hash difference (i.e. by count or ratio of total gateways checked)
+     }) {
+        this.gatewaysProvider = gatewaysProvider;
+    }
+    /**
+     * Gets the digest for a given txId from all trusted gateways and ensures they all match.
+     * @param txId - The txId to get the digest for.
+     * @returns The digest for the given txId.
+     */
+    async getHash({ txId, }) {
+        // get the hash from every gateway, and ensure they all match
+        const hashSet = new Set();
+        const hashResults = [];
+        const gateways = await this.gatewaysProvider.getGateways();
+        const hashes = await Promise.all(gateways.map(async (gateway) => {
+            const response = await fetch(`${gateway.toString()}${txId}`, {
+                method: 'HEAD',
+                redirect: 'follow',
+            });
+            if (!response.ok) {
+                // skip this gateway
+                return undefined;
+            }
+            const txIdHash = response.headers.get(arioGatewayHeaders.digest);
+            if (txIdHash === null || txIdHash === undefined) {
+                // skip this gateway
+                return undefined;
+            }
+            hashResults.push({
+                gateway: gateway.hostname,
+                txIdHash,
+            });
+            return txIdHash;
+        }));
+        for (const hash of hashes) {
+            if (hash !== undefined) {
+                hashSet.add(hash);
+            }
+        }
+        if (hashSet.size === 0) {
+            throw new Error(`No trusted gateways returned a hash for txId ${txId}`);
+        }
+        if (hashSet.size > 1) {
+            throw new Error(`Failed to get consistent hash from all trusted gateways. ${JSON.stringify(hashResults)}`);
+        }
+        return { hash: hashResults[0].txIdHash, algorithm: 'sha256' };
+    }
+    /**
+     * Get the data root for a given txId from all trusted gateways and ensure they all match.
+     * @param txId - The txId to get the data root for.
+     * @returns The data root for the given txId.
+     */
+    async getDataRoot({ txId }) {
+        const dataRootSet = new Set();
+        const dataRootResults = [];
+        const gateways = await this.gatewaysProvider.getGateways();
+        const dataRoots = await Promise.all(gateways.map(async (gateway) => {
+            const response = await fetch(`${gateway.toString()}tx/${txId}/data_root`);
+            if (!response.ok) {
+                // skip this gateway
+                return undefined;
+            }
+            const dataRoot = await response.text();
+            dataRootResults.push({
+                gateway: gateway.hostname,
+                dataRoot,
+            });
+            return dataRoot;
+        }));
+        for (const dataRoot of dataRoots) {
+            if (dataRoot !== undefined) {
+                dataRootSet.add(dataRoot);
+            }
+        }
+        if (dataRootSet.size > 1) {
+            throw new Error(`Failed to get consistent data root from all trusted gateways. ${JSON.stringify(dataRootResults)}`);
+        }
+        return dataRootSet.values().next().value;
+    }
+}
+// client could check hashes of data items, match expected hash
+// if the gateway has the hash and they've verified it, you can trust the data item and offset
+// you would be only trusting the gateway that it is a valid bundle
+// you can request the offset from the gateway to verify the id
+/**
+ * Note from @djwhitt
+ *
+ * Calculating data roots this way is fine, but it may not reproduce the original data root.
+ * We could also implement a data root verifier that pulls all the chunks, checks that they
+ * reproduce the expected data root, and then compares the concatenated chunk data to the
+ * original data retrieved. That would take a while, but it should be able to verify any L1
+ * data where we can find the chunks.
+ */