@ar.io/sdk 3.24.0 → 4.0.0-alpha.2

package/lib/esm/utils/arweave.js

@@ -1,271 +0,0 @@
-import { Logger } from '../common/logger.js';
-import { ARIO_MAINNET_PROCESS_ID, ARWEAVE_TX_REGEX } from '../constants.js';
-import { isDistributedEpoch, } from '../types/io.js';
-import { parseAoEpochData } from './ao.js';
-export const validateArweaveId = (id) => {
-    return ARWEAVE_TX_REGEX.test(id);
-};
-export function isBlockHeight(height) {
-    return height !== undefined && !isNaN(parseInt(height.toString()));
-}
-/**
- * Prune tags that are undefined or empty.
- * @param tags - The tags to prune.
- * @returns The pruned tags.
- */
-export const pruneTags = (tags) => {
-    return tags.filter((tag) => tag.value !== undefined && tag.value !== '');
-};
-export const paginationParamsToTags = (params) => {
-    const tags = [
-        { name: 'Cursor', value: params?.cursor?.toString() },
-        { name: 'Limit', value: params?.limit?.toString() },
-        { name: 'Sort-By', value: params?.sortBy?.toString() },
-        { name: 'Sort-Order', value: params?.sortOrder?.toString() },
-        ...(params?.filters
-            ? [{ name: 'Filters', value: JSON.stringify(params.filters) }]
-            : []),
-    ];
-    return pruneTags(tags);
-};
-/**
- * Get the epoch with distribution data for the current epoch
- * @param arweave - The Arweave instance
- * @returns The epoch with distribution data
- */
-export const getEpochDataFromGql = async ({ arweave, epochIndex, processId = ARIO_MAINNET_PROCESS_ID, retries = 3, gqlUrl = 'https://arweave-search.goldsky.com/graphql', }) => {
-    // fetch from gql
-    const query = epochDistributionNoticeGqlQuery({ epochIndex, processId });
-    // add three retries with exponential backoff
-    for (let i = 0; i < retries; i++) {
-        try {
-            const response = (await fetch(gqlUrl, {
-                method: 'POST',
-                body: query,
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-            }).then((res) => res.json()));
-            // parse the nodes to get the id
-            if (response?.data?.transactions?.edges?.length === 0) {
-                return undefined;
-            }
-            const id = response.data.transactions.edges[0].node.id;
-            // fetch the transaction from arweave
-            const transaction = await arweave.api.get(id);
-            // assert it is the correct type
-            return parseAoEpochData(transaction.data);
-        }
-        catch (error) {
-            if (i === retries - 1)
-                throw error; // Re-throw on final attempt
-            // exponential backoff
-            await new Promise((resolve) => setTimeout(resolve, Math.pow(2, i) * 1000));
-        }
-    }
-    return undefined;
-};
-export const getEpochDataFromGqlWithCUFallback = async ({ arweave, ao, epochIndex, processId = ARIO_MAINNET_PROCESS_ID, }) => {
-    const gqlResult = await getEpochDataFromGql({
-        arweave,
-        epochIndex,
-        processId,
-    });
-    if (gqlResult) {
-        return gqlResult;
-    }
-    const gqlFallbackResult = await getEpochDataFromGqlFallback({
-        ao,
-        epochIndex,
-        processId,
-    });
-    if (gqlFallbackResult) {
-        return gqlFallbackResult;
-    }
-    return undefined;
-};
-export const getEpochDataFromGqlFallback = async ({ ao, epochIndex, processId = ARIO_MAINNET_PROCESS_ID, gqlUrl = 'https://arweave-search.goldsky.com/graphql', }) => {
-    const query = epochDistributionNoticeGqlQueryFallback({
-        epochIndex,
-        processId,
-    });
-    const response = await fetch(gqlUrl, {
-        method: 'POST',
-        body: query,
-        headers: {
-            'Content-Type': 'application/json',
-        },
-    });
-    const responseJson = (await response.json());
-    if (responseJson.data.transactions.edges.length === 0) {
-        return undefined;
-    }
-    for (const edge of responseJson.data.transactions.edges) {
-        const id = edge.node.id;
-        const messageResult = await ao
-            .result({
-            message: id,
-            process: processId,
-        })
-            .catch(() => undefined);
-        if (!messageResult) {
-            continue;
-        }
-        for (const message of messageResult?.Messages ?? []) {
-            if (!message.Data) {
-                continue;
-            }
-            try {
-                const tags = message.Tags;
-                // check if the message results include epoch-distribution-notice for the requested epoch index
-                if (tags.some((tag) => tag.name === 'Action' &&
-                    tag.value === 'Epoch-Distribution-Notice') &&
-                    tags.some((tag) => tag.name === 'Epoch-Index' && tag.value === epochIndex.toString())) {
-                    const data = JSON.parse(message.Data);
-                    return parseAoEpochData(data);
-                }
-            }
-            catch (error) {
-                // report but continue to next message
-                Logger.default.error('Failed to parse AO epoch distribution message:', error, '\nMessage:', message);
-            }
-        }
-    }
-    return undefined;
-};
-/**
- * Get the epoch with distribution data for the current epoch
- * @param arweave - The Arweave instance
- * @param epochIndex - The index of the epoch
- * @param processId - The process ID (optional, defaults to ARIO_MAINNET_PROCESS_ID)
- * @returns string - The stringified GQL query
- */
-export const epochDistributionNoticeGqlQuery = ({ epochIndex, processId = ARIO_MAINNET_PROCESS_ID, authorities = ['fcoN_xJeisVsPXA-trzVAuIiqO3ydLQxM-L4XbrQKzY'], }) => {
-    // write the query
-    const gqlQuery = JSON.stringify({
-        query: `
-      query {
-        transactions(
-          tags: [
-            { name: "From-Process", values: ["${processId}"] }
-            { name: "Action", values: ["Epoch-Distribution-Notice"] }
-            { name: "Epoch-Index", values: ["${epochIndex}"] }
-            { name: "Data-Protocol", values: ["ao"] }
-          ],
-          owners: [${authorities.map((a) => `"${a}"`).join(',')}],
-          first: 1,
-          sort: HEIGHT_DESC
-        ) {
-          edges {
-            node {
-              id
-            }
-          }
-        }
-      }
-    `,
-    });
-    return gqlQuery;
-};
-// fallback query if the distribution notice does not get cranked
-export const epochDistributionNoticeGqlQueryFallback = ({ processId = ARIO_MAINNET_PROCESS_ID, owners = ['OAb-n-ZugyN598kZNpfOy0ACelGVmwCQ0kYbgNGDUK8'], // ar.io team wallet ticks once a day
- }) => {
-    return JSON.stringify({
-        query: `
-      query {
-        transactions(
-          tags: [
-            { name: "Action", values: ["Tick"] }
-          ],
-          first: 100,
-          owners: [${owners.map((a) => `"${a}"`).join(',')}],
-          recipients: ["${processId}"],
-          sort: HEIGHT_DESC
-        ) {
-          edges {
-            node {
-              id  
-            }
-          }
-        }
-      }
-    `,
-    });
-};
-export function sortAndPaginateEpochDataIntoEligibleDistributions(epochData, params) {
-    const rewards = [];
-    const sortBy = params?.sortBy ?? 'eligibleReward';
-    const sortOrder = params?.sortOrder ?? 'desc';
-    const limit = params?.limit ?? 100;
-    if (!isDistributedEpoch(epochData)) {
-        return {
-            hasMore: false,
-            items: [],
-            totalItems: 0,
-            limit,
-            sortOrder,
-            sortBy,
-        };
-    }
-    const eligibleDistributions = epochData?.distributions.rewards.eligible;
-    for (const [gatewayAddress, reward] of Object.entries(eligibleDistributions)) {
-        rewards.push({
-            type: 'operatorReward',
-            recipient: gatewayAddress,
-            eligibleReward: reward.operatorReward,
-            cursorId: gatewayAddress + '_' + gatewayAddress,
-            gatewayAddress,
-        });
-        for (const [delegateAddress, delegateRewardQty] of Object.entries(reward.delegateRewards)) {
-            rewards.push({
-                type: 'delegateReward',
-                recipient: delegateAddress,
-                eligibleReward: delegateRewardQty,
-                cursorId: gatewayAddress + '_' + delegateAddress,
-                gatewayAddress,
-            });
-        }
-    }
-    // sort the rewards by the sortBy
-    rewards.sort((a, b) => {
-        const aSort = a[sortBy];
-        const bSort = b[sortBy];
-        if (aSort === bSort || aSort === undefined || bSort === undefined) {
-            return 0;
-        }
-        if (sortOrder === 'asc') {
-            return aSort > bSort ? 1 : -1;
-        }
-        return aSort < bSort ? 1 : -1;
-    });
-    // paginate the rewards
-    const start = params?.cursor !== undefined
-        ? rewards.findIndex((r) => r.cursorId === params.cursor) + 1
-        : 0;
-    const end = limit ? start + limit : rewards.length;
-    return {
-        hasMore: end < rewards.length,
-        items: rewards.slice(start, end),
-        totalItems: rewards.length,
-        limit,
-        sortOrder,
-        nextCursor: rewards[end]?.cursorId,
-        sortBy,
-    };
-}
-export function removeEligibleRewardsFromEpochData(epochData) {
-    if (!isDistributedEpoch(epochData)) {
-        return epochData;
-    }
-    return {
-        ...epochData,
-        distributions: {
-            ...epochData.distributions,
-            rewards: {
-                ...epochData.distributions.rewards,
-                // @ts-expect-error -- remove eligible rewards
-                eligible: undefined,
-            },
-        },
-    };
-}

package/lib/esm/utils/processes.js

@@ -1,167 +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 { connect } from '@permaweb/aoconnect';
-import { EventEmitter } from 'eventemitter3';
-import { ANTRegistry } from '../common/ant-registry.js';
-import { ANT } from '../common/ant.js';
-import { AOProcess } from '../common/index.js';
-import { ARIO } from '../common/io.js';
-import { Logger } from '../common/logger.js';
-import { ARIO_MAINNET_PROCESS_ID } from '../constants.js';
-/**
- * @deprecated Use getArNSRecordsForAddress instead
- */
-export const getANTProcessesOwnedByWallet = async ({ address, registry = ANTRegistry.init(), }) => {
-    const res = await registry.accessControlList({ address });
-    return [...new Set([...res.Owned, ...res.Controlled])];
-};
-function timeout(ms, promise) {
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            reject(new Error('Timeout'));
-        }, ms);
-        promise
-            .then((value) => {
-            clearTimeout(timer);
-            resolve(value);
-        })
-            .catch((err) => {
-            clearTimeout(timer);
-            reject(err);
-        });
-    });
-}
-/**
- * @deprecated This is an inefficient way to get ArNS records for a wallet address. Use getArNSRecordsForAddress instead.
- */
-export class ArNSEventEmitter extends EventEmitter {
-    contract;
-    timeoutMs;
-    logger;
-    strict;
-    antAoClient;
-    constructor({ contract = ARIO.init({
-        processId: ARIO_MAINNET_PROCESS_ID,
-    }), timeoutMs = 60_000, logger = Logger.default, strict = false, antAoClient = connect({
-        MODE: 'legacy',
-    }), } = {}) {
-        super();
-        this.contract = contract;
-        this.timeoutMs = timeoutMs;
-        this.logger = logger;
-        this.strict = strict;
-        this.antAoClient = antAoClient;
-    }
-    async fetchProcessesOwnedByWallet({ address, pageSize, antRegistry = ANTRegistry.init(), }) {
-        const uniqueContractProcessIds = {};
-        const antIdRes = await antRegistry.accessControlList({ address });
-        const antIds = new Set([...antIdRes.Owned, ...antIdRes.Controlled]);
-        await timeout(this.timeoutMs, fetchAllArNSRecords({ contract: this.contract, emitter: this, pageSize }))
-            .catch((e) => {
-            this.emit('error', `Error getting ArNS records: ${e}`);
-            this.logger.error(`Error getting ArNS records`, {
-                message: e?.message,
-                stack: e?.stack,
-            });
-            return {};
-        })
-            .then((records) => {
-            Object.entries(records).forEach(([name, arnsRecord]) => {
-                if (antIds.has(arnsRecord.processId)) {
-                    if (uniqueContractProcessIds[arnsRecord.processId] === undefined) {
-                        uniqueContractProcessIds[arnsRecord.processId] = {
-                            state: undefined,
-                            names: {},
-                        };
-                    }
-                    uniqueContractProcessIds[arnsRecord.processId].names[name] =
-                        arnsRecord;
-                }
-            });
-        });
-        const idCount = Object.keys(uniqueContractProcessIds).length;
-        this.emit('progress', 0, idCount);
-        // check the contract owner and controllers
-        await Promise.all(Object.keys(uniqueContractProcessIds).map(async (processId, i) => {
-            if (uniqueContractProcessIds[processId].state !== undefined) {
-                this.emit('progress', i + 1, idCount);
-                return;
-            }
-            const ant = ANT.init({
-                process: new AOProcess({
-                    processId,
-                    ao: this.antAoClient,
-                }),
-                strict: this.strict,
-            });
-            const state = (await timeout(this.timeoutMs, ant.getState()).catch((e) => {
-                this.emit('error', `Error getting state for process ${processId}: ${e}`);
-                return undefined;
-            }));
-            if (state?.Owner === address || state?.Controllers.includes(address)) {
-                uniqueContractProcessIds[processId].state = state;
-                this.emit('process', processId, uniqueContractProcessIds[processId]);
-            }
-            this.emit('progress', i + 1, idCount);
-        }));
-        this.emit('end', uniqueContractProcessIds);
-    }
-}
-export const fetchAllArNSRecords = async ({ contract = ARIO.init({
-    processId: ARIO_MAINNET_PROCESS_ID,
-}), emitter, logger = Logger.default, pageSize = 1000, }) => {
-    let cursor;
-    const startTimestamp = Date.now();
-    const records = {};
-    do {
-        const pageResult = await contract
-            .getArNSRecords({ cursor, limit: pageSize })
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            .catch((e) => {
-            logger?.error(`Error getting ArNS records`, {
-                message: e?.message,
-                stack: e?.stack,
-            });
-            emitter?.emit('arns:error', `Error getting ArNS records: ${e}`);
-            return undefined;
-        });
-        if (!pageResult) {
-            return {};
-        }
-        pageResult.items.forEach((record) => {
-            const { name, ...recordDetails } = record;
-            records[name] = recordDetails;
-        });
-        logger.debug('Fetched page of ArNS records', {
-            totalRecordCount: pageResult.totalItems,
-            fetchedRecordCount: Object.keys(records).length,
-            cursor: pageResult.nextCursor,
-        });
-        emitter?.emit('arns:pageLoaded', {
-            totalRecordCount: pageResult.totalItems,
-            fetchedRecordCount: Object.keys(records).length,
-            records: pageResult.items,
-            cursor: pageResult.nextCursor,
-        });
-        cursor = pageResult.nextCursor;
-    } while (cursor !== undefined);
-    emitter?.emit('arns:end', records);
-    logger.debug('Fetched all ArNS records', {
-        totalRecordCount: Object.keys(records).length,
-        durationMs: Date.now() - startTimestamp,
-    });
-    return records;
-};

package/lib/esm/web/index.js

@@ -1,20 +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.
- */
-export { ArweaveSigner, ArconnectSigner, InjectedEthereumSigner, EthereumSigner, } from '@dha-team/arbundles';
-export * from '../types/index.js';
-export * from '../common/index.js';
-export * from '../constants.js';
-export * from '../utils/index.js';

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

@@ -1,39 +0,0 @@
-import { AoANTVersionsRead, AoANTVersionsWrite } from '../types/ant.js';
-import { AoMessageResult, WithSigner, WriteOptions } from '../types/common.js';
-import { ProcessConfiguration } from '../types/io.js';
-import { AOProcess } from './contracts/ao-process.js';
-type ANTVersionsNoSigner = ProcessConfiguration;
-type ANTVersionsWithSigner = WithSigner<ProcessConfiguration>;
-export declare class ANTVersions {
-    static init(): AoANTVersionsRead;
-    static init(config: ANTVersionsNoSigner): AoANTVersionsRead;
-    static init(config: ANTVersionsWithSigner): AoANTVersionsWrite;
-}
-export declare class ANTVersionsReadable implements AoANTVersionsRead {
-    protected process: AOProcess;
-    constructor(config?: ProcessConfiguration);
-    getANTVersions(): Promise<Record<string, {
-        moduleId: string;
-        luaSourceId?: string;
-        notes?: string;
-        releaseTimestamp: number;
-    }>>;
-    getLatestANTVersion(): Promise<{
-        version: string;
-        moduleId: string;
-        luaSourceId?: string;
-        notes?: string;
-        releaseTimestamp: number;
-    }>;
-}
-export declare class ANTVersionsWritable extends ANTVersionsReadable implements AoANTVersionsWrite {
-    private signer;
-    constructor({ signer, ...config }: WithSigner<ProcessConfiguration>);
-    addVersion(params: {
-        version: string;
-        moduleId: string;
-        luaSourceId?: string;
-        notes?: string;
-    }, options?: WriteOptions): Promise<AoMessageResult>;
-}
-export {};

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

@@ -1,17 +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 Arweave from 'arweave/node/index.js';
-export declare const defaultArweave: Arweave;

package/lib/types/common/contracts/ao-process.d.ts

@@ -1,47 +0,0 @@
-import { AOContract, AoClient, AoSigner } from '../../types/index.js';
-import { ILogger } from '../logger.js';
-export declare class AOProcess implements AOContract {
-    private logger;
-    readonly ao: AoClient;
-    readonly processId: string;
-    constructor({ processId, ao, logger, }: {
-        processId: string;
-        ao?: AoClient;
-        logger?: ILogger;
-    });
-    private isMessageDataEmpty;
-    read<K>({ tags, retries, fromAddress, select, }: {
-        tags?: Array<{
-            name: string;
-            value: string;
-        }>;
-        retries?: number;
-        fromAddress?: string;
-        select?: (message: {
-            Data: string;
-            Tags: Array<{
-                name: string;
-                value: string;
-            }>;
-        }) => boolean;
-    }): Promise<K>;
-    send<K>({ tags, data, signer, retries, select, }: {
-        tags: Array<{
-            name: string;
-            value: string;
-        }>;
-        data?: string | undefined;
-        signer: AoSigner;
-        retries?: number;
-        select?: (message: {
-            Data: string;
-            Tags: Array<{
-                name: string;
-                value: string;
-            }>;
-        }) => boolean;
-    }): Promise<{
-        id: string;
-        result?: K;
-    }>;
-}

package/lib/types/common/hyperbeam/hb.d.ts

@@ -1,88 +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 { JSONValue } from '../../types/common.js';
-import { Logger } from '../logger.js';
-export type HBConfig = {
-    url: string;
-    processId: string;
-    logger?: Logger;
-    hbTimeoutMs?: number;
-};
-export declare class HB {
-    readonly url: string;
-    readonly processId: string;
-    protected isHyperBeamCompatible: boolean | undefined;
-    protected checkHyperBeamPromise: Promise<boolean> | undefined;
-    private logger;
-    private hbTimeoutMs;
-    constructor(config: HBConfig);
-    /**
-     * fetches the meta data for the process
-     *
-     * @returns The meta data for the process
-     *
-     * @example
-     * const hyperbeam = new Hyperbeam({ url: 'https://hyperbeam.ario.permaweb.services', processId: 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE' });
-     * const meta = await hyperbeam.meta();
-     * console.log(meta);
-     */
-    meta(): Promise<Record<string, JSONValue>>;
-    /**
-     * calls the process device /now function, which evaluates the current process state pulling new messages
-     * to get the latest state
-     *
-     * @param path - The path to the hb state
-     * @param json - Whether to return the result as JSON, defaults to true
-     * @returns The result of the compute operation
-     *
-     * @example
-     * const hyperbeam = new Hyperbeam({ url: 'https://hyperbeam.ario.permaweb.services', processId: 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE' });
-     * const result = await hyperbeam.now({ path: 'balances/QGWqtJdLLgm2ehFWiiPzMaoFLD50CnGuzZIPEdoDRGQ' });
-     * console.log(result);
-     */
-    now<T extends JSONValue>({ path, json, }: {
-        path: string;
-        json?: boolean;
-    }): Promise<T>;
-    /**
-     * calls the process device /compute function, which uses the currently evaluated state in the node
-     *
-     * @param path - The path to the compute resource
-     * @param json - Whether to return the result as JSON, defaults to true
-     * @returns The result of the compute operation
-     *
-     * @example
-     * const hyperbeam = new Hyperbeam({ url: 'https://hyperbeam.ario.permaweb.services', processId: 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE' });
-     * const result = await hyperbeam.compute({ path: 'balances/QGWqtJdLLgm2ehFWiiPzMaoFLD50CnGuzZIPEdoDRGQ' });
-     * console.log(result);
-     */
-    compute<T extends JSONValue>({ path, json, }: {
-        path: string;
-        json?: boolean;
-    }): Promise<T>;
-    /**
-     * Checks if the process is HyperBeam compatible and caches the result.
-     *
-     * @returns {Promise<boolean>} True if the process is HyperBeam compatible, false otherwise.
-     */
-    checkHyperBeamCompatibility({ minSlot, }?: {
-        minSlot?: number;
-    }): Promise<boolean>;
-    fetchHyperbeamPath<T extends JSONValue>({ path, json, }: {
-        path: string;
-        json?: boolean;
-    }): Promise<T>;
-}