@ar.io/sdk 1.2.1 → 2.0.0-alpha.1

package/lib/esm/common/contracts/remote-contract.js

@@ -1,51 +0,0 @@
-import { AxiosHTTPService } from '../http.js';
-import { DefaultLogger } from '../logger.js';
-// TODO: this assumes the API structure matches the current arns-service API - we will want to consider another interface that exposes relevant APIs with client implementations (arns-service, DRE nodes, etc.)
-export class RemoteContract {
-    logger;
-    http;
-    contractTxId;
-    cacheUrl;
-    constructor({ cacheUrl = 'https://api.arns.app', contractTxId, logger = new DefaultLogger(), }) {
-        this.cacheUrl = cacheUrl;
-        this.contractTxId = contractTxId;
-        this.logger = logger;
-        this.http = new AxiosHTTPService({
-            url: `${cacheUrl}/v1/contract/${contractTxId}`,
-        });
-    }
-    configuration() {
-        return {
-            contractTxId: this.contractTxId,
-            cacheUrl: this.cacheUrl,
-        };
-    }
-    async getState({ evaluationOptions } = {}) {
-        this.logger.debug(`Fetching contract state`, {
-            contractTxId: this.contractTxId,
-            evaluationOptions,
-        });
-        const { state } = await this.http.get({
-            endpoint: ``,
-            params: {
-                ...evaluationOptions?.evalTo,
-            },
-        });
-        return state;
-    }
-    async readInteraction({ functionName, inputs, evaluationOptions, }) {
-        this.logger.debug(`Evaluating read interaction on contract`, {
-            functionName,
-            inputs,
-            evaluationOptions,
-        });
-        const { result } = await this.http.get({
-            endpoint: `/read/${functionName}`,
-            params: {
-                ...evaluationOptions?.evalTo,
-                ...inputs,
-            },
-        });
-        return result;
-    }
-}

package/lib/esm/common/contracts/warp-contract.js

@@ -1,172 +0,0 @@
-/**
- * Copyright (C) 2022-2024 Permanent Data Solutions, Inc. All Rights Reserved.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-import { LoggerFactory, Signature, Tag, } from 'warp-contracts';
-import { sha256B64Url, toB64Url } from '../../utils/base64.js';
-import { getContractManifest } from '../../utils/smartweave.js';
-import { FailedRequestError, WriteInteractionError } from '../error.js';
-import { DefaultLogger } from '../logger.js';
-import { defaultWarp } from '../warp.js';
-LoggerFactory.INST.logLevel('error');
-export class WarpContract {
-    contract;
-    contractTxId;
-    cacheUrl;
-    logger;
-    warp;
-    constructor({ contractTxId, cacheUrl = 'https://api.arns.app', warp = defaultWarp, logger = new DefaultLogger({
-        level: 'info',
-    }), }) {
-        this.contractTxId = contractTxId;
-        this.contract = warp.contract(contractTxId);
-        this.cacheUrl = cacheUrl;
-        this.warp = warp;
-        this.logger = logger;
-    }
-    configuration() {
-        return {
-            contractTxId: this.contractTxId,
-            cacheUrl: this.cacheUrl,
-        };
-    }
-    // TODO: could abstract into our own interface that constructs different signers
-    async createWarpSigner(signer) {
-        // ensure appropriate permissions are granted with injected signers.
-        if (signer.publicKey === undefined && 'setPublicKey' in signer) {
-            await signer.setPublicKey();
-        }
-        const warpSigner = new Signature(this.warp, {
-            signer: async (tx) => {
-                tx.setOwner(toB64Url(signer.publicKey));
-                const dataToSign = await tx.getSignatureData();
-                const signatureUint8Array = await signer.sign(dataToSign);
-                const signatureBuffer = Buffer.from(signatureUint8Array);
-                const id = sha256B64Url(signatureBuffer);
-                tx.setSignature({
-                    id: id,
-                    owner: toB64Url(signer.publicKey),
-                    signature: toB64Url(signatureBuffer),
-                });
-            },
-            type: 'arweave',
-        });
-        return warpSigner;
-    }
-    async getState({ evaluationOptions = {} }) {
-        await this.ensureContractInit();
-        const evalTo = evaluationOptions?.evalTo;
-        let sortKeyOrBlockHeight;
-        if (evalTo && 'sortKey' in evalTo) {
-            sortKeyOrBlockHeight = evalTo.sortKey;
-        }
-        else if (evalTo && 'blockHeight' in evalTo) {
-            sortKeyOrBlockHeight = evalTo.blockHeight;
-        }
-        const evaluationResult = await this.contract.readState(sortKeyOrBlockHeight);
-        if (!evaluationResult.cachedValue.state) {
-            throw new FailedRequestError(502, 'Failed to evaluate contract state');
-        }
-        return evaluationResult.cachedValue.state;
-    }
-    async ensureContractInit({ signer } = {}) {
-        this.logger.debug(`Checking contract initialized`, {
-            contractTxId: this.contractTxId,
-        });
-        // Get contact manifest and sync state
-        this.logger.debug(`Fetching contract manifest`, {
-            contractTxId: this.contractTxId,
-        });
-        const { evaluationOptions = {} } = await getContractManifest({
-            arweave: this.warp.arweave,
-            contractTxId: this.contractTxId,
-        });
-        this.contract.setEvaluationOptions(evaluationOptions);
-        if (signer)
-            this.contract.connect(await this.createWarpSigner(signer));
-        if (this.cacheUrl !== undefined) {
-            this.logger.debug(`Syncing contract state`, {
-                contractTxId: this.contractTxId,
-                remoteCacheUrl: this.cacheUrl,
-            });
-            await this.contract.syncState(`${this.cacheUrl}/v1/contract/${this.contractTxId}`, {
-                validity: true,
-            });
-        }
-    }
-    async readInteraction({ functionName, inputs,
-    // TODO: view state only supports sort key so we won't be able to use block height
-     }) {
-        await this.ensureContractInit();
-        this.logger.debug(`Read interaction: ${functionName}`, {
-            contractTxId: this.contractTxId,
-            inputs,
-        });
-        const evaluationResult = await this.contract.viewState({
-            function: functionName,
-            ...inputs,
-        });
-        if (evaluationResult.result === undefined) {
-            throw new FailedRequestError(502, 'Failed to evaluate contract read interaction: ' +
-                JSON.stringify({ error: evaluationResult.errorMessage, functionName, inputs }, null, 2));
-        }
-        this.logger.debug('Successfully evaluated contract read interaction', {
-            contractTxId: this.contractTxId,
-            result: evaluationResult.result,
-        });
-        return evaluationResult.result;
-    }
-    async writeInteraction({ functionName, inputs, signer,
-    // TODO: support dryWrite
-     }, options) {
-        try {
-            this.logger.debug(`Write interaction: ${functionName}`, {
-                contractTxId: this.contractTxId,
-            });
-            // Sync state before writing
-            await this.ensureContractInit({ signer });
-            // run dry write before actual write
-            const result = await this.contract.dryWrite({
-                function: functionName,
-                ...inputs,
-            });
-            if (result.type !== 'ok') {
-                throw new Error(`Failed to dry write contract interaction ${functionName}: ${result.errorMessage}`);
-            }
-            const writeResult = await this.contract.writeInteraction({
-                function: functionName,
-                ...inputs,
-            }, {
-                disableBundling: true,
-                tags: options?.tags?.map((tag) => new Tag(tag.name, tag.value)),
-            });
-            if (!writeResult?.interactionTx) {
-                throw new Error(`Failed to write contract interaction: ${functionName}`);
-            }
-            this.logger.debug('Successfully wrote contract interaction', {
-                contractTxId: this.contractTxId,
-                interactionTxId: writeResult.originalTxId,
-            });
-            // hack - we only support L1 for interactions so they should always be transactions
-            return writeResult.interactionTx;
-        }
-        catch (error) {
-            this.logger.error(`Failed to write contract interaction: ${error.message}`, {
-                contractTxId: this.contractTxId,
-            });
-            throw new WriteInteractionError(error);
-        }
-    }
-}

package/lib/esm/common/warp.js

@@ -1,22 +0,0 @@
-/**
- * Copyright (C) 2022-2024 Permanent Data Solutions, Inc. All Rights Reserved.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-import { WarpFactory, defaultCacheOptions } from 'warp-contracts';
-import { defaultArweave } from './arweave.js';
-export const defaultWarp = WarpFactory.forMainnet({
-    ...defaultCacheOptions,
-    inMemory: true,
-}, true, defaultArweave);

package/lib/esm/utils/graphql/smartweave.js

@@ -1,303 +0,0 @@
-import { AbortError } from '../../common/error.js';
-export const MAX_REQUEST_SIZE = 100;
-/**
- * @param arweave - arweave instance to perform gql request
- * @param address - address of the wallet to get transactions for
- * @param signal - signal to abort the request
- * @returns @type {Promise<DataProtocolTransaction[]>} - returns the list of data protocol txs, for e.g smartweave contracts
- */
-export async function getSmartweaveContractsFromGQL({ address, arweave, signal = AbortSignal.timeout(10_000),
-// TODO: add retry provider - eg pass in fetcher for the query
- }) {
-    let hasNextPage = false;
-    let cursor;
-    const protocolTxs = new Set();
-    do {
-        const queryObject = {
-            query: `
-      { 
-          transactions (
-              owners:["${address}"]
-              tags: [
-                      {
-                        name: "App-Name",
-                        values: ["SmartWeaveContract"],
-                      },
-                    ],
-              sort: HEIGHT_DESC,
-              first: ${MAX_REQUEST_SIZE},
-              bundledIn: null,
-              ${cursor !== undefined ? `after: "${cursor}"` : ''}
-          ) {
-              pageInfo {
-                  hasNextPage
-              }
-              edges {
-                  cursor
-                  node {
-                      id
-                      block {
-                          height
-                      }
-                      tags {
-                          name
-                          value
-                      }
-                  }
-              }
-          }
-      }`,
-        };
-        if (signal?.aborted) {
-            throw new AbortError('GraphQL request was aborted.');
-        }
-        const { status, ...response } = await arweave.api.post('/graphql', queryObject, {
-            signal,
-        });
-        if (status == 429) {
-            await new Promise((resolve) => setTimeout(resolve, 10_000));
-            continue;
-        }
-        if (status !== 200) {
-            console.dir(response, { depth: null });
-            throw Error(`Failed to fetch contracts for wallet. Status code: ${status}`);
-        }
-        if (!response.data.data?.transactions?.edges?.length) {
-            continue;
-        }
-        response.data.data.transactions.edges
-            .map((e) => ({
-            id: e.node.id,
-            tags: e.node.tags,
-            data: e.node.data,
-        }))
-            .forEach((c) => {
-            protocolTxs.add(c.def);
-        });
-        cursor =
-            response.data.data.transactions.edges[MAX_REQUEST_SIZE - 1]?.cursor;
-        hasNextPage =
-            response.data.data.transactions.pageInfo?.hasNextPage ?? false;
-    } while (hasNextPage);
-    return [...protocolTxs];
-}
-/**
- * @param arweave - arweave instance to perform gql request
- * @param address - address of the wallet to get transactions for
- * @param contractTxId - contract tx id to filter the transactions
- * @param signal - signal to abort the request
- * @returns @type {Promise<DataProtocolTransaction[]>} - returns the list of data protocol txs, for e.g smartweave contracts
- */
-export async function getSmartweaveTransactionsFromGQL({ address, contractTxId, arweave, signal = AbortSignal.timeout(10_000),
-// TODO: add retry provider - eg pass in fetcher for the query
- }) {
-    let hasNextPage = false;
-    let cursor;
-    const protocolTxs = new Set();
-    do {
-        const queryObject = {
-            query: `
-      { 
-          transactions (
-              owners:["${address}"]
-              tags: [
-                      {
-                        name: "App-Name",
-                        values: ["SmartWeaveAction"],
-                      },
-                      {
-                        name: "Contract",
-                        values: ["${contractTxId}"],
-                      },
-                    ],
-              sort: HEIGHT_DESC,
-              first: ${MAX_REQUEST_SIZE},
-              bundledIn: null,
-              ${cursor !== undefined ? `after: "${cursor}"` : ''}
-          ) {
-              pageInfo {
-                  hasNextPage
-              }
-              edges {
-                  cursor
-                  node {
-                      id
-                      block {
-                          height
-                      }
-                      tags {
-                          name
-                          value
-                      }
-                  }
-              }
-          }
-      }`,
-        };
-        if (signal?.aborted) {
-            throw new AbortError('GraphQL request was aborted.');
-        }
-        const { status, ...response } = await arweave.api.post('/graphql', queryObject, {
-            signal,
-        });
-        if (status == 429) {
-            await new Promise((resolve) => setTimeout(resolve, 10_000));
-            continue;
-        }
-        if (status !== 200) {
-            throw Error(`Failed to fetch contracts for wallet. Status code: ${status}`);
-        }
-        if (!response.data.data?.transactions?.edges?.length) {
-            continue;
-        }
-        response.data.data.transactions.edges
-            .map((e) => ({
-            id: e.node.id,
-            tags: e.node.tags,
-            data: e.node.data,
-        }))
-            .forEach((c) => {
-            protocolTxs.add(c.def);
-        });
-        cursor =
-            response.data.data.transactions.edges[MAX_REQUEST_SIZE - 1]?.cursor;
-        hasNextPage =
-            response.data.data.transactions.pageInfo?.hasNextPage ?? false;
-    } while (hasNextPage);
-    return [...protocolTxs];
-}
-export async function getContractsTransferredToOrControlledByWallet(arweave, params, signal) {
-    const { address } = params;
-    let hasNextPage = false;
-    let cursor;
-    const protocolTxs = new Set();
-    do {
-        const queryObject = {
-            query: `
-          { 
-              transactions (
-                  tags:[
-                    {
-                      name: "App-Name",
-                      values: ["SmartWeaveAction"]
-                    },
-                    {
-                      name: "Input",
-                      values: ${JSON.stringify([
-                // duplicated because the order of the input matters when querying gql
-                {
-                    function: 'setController',
-                    target: address,
-                },
-                {
-                    target: address,
-                    function: 'setController',
-                },
-                {
-                    function: 'transfer',
-                    target: address,
-                    qty: 1,
-                },
-                {
-                    function: 'transfer',
-                    qty: 1,
-                    target: address,
-                },
-                {
-                    target: address,
-                    function: 'transfer',
-                    qty: 1,
-                },
-                {
-                    target: address,
-                    qty: 1,
-                    function: 'transfer',
-                },
-                {
-                    qty: 1,
-                    target: address,
-                    function: 'transfer',
-                },
-                {
-                    qty: 1,
-                    function: 'transfer',
-                    target: address,
-                },
-                // removing qty just for coverage
-                {
-                    function: 'transfer',
-                    target: address,
-                },
-                {
-                    target: address,
-                    function: 'transfer',
-                },
-            ])
-                .replace(/"/g, '\\"')
-                .replace(/\{/g, '"{')
-                .replace(/\}/g, '}"')}
-                   }
-                  ],
-                  sort: HEIGHT_DESC,
-                  first: ${MAX_REQUEST_SIZE},
-                  bundledIn: null,
-                  ${cursor !== undefined ? `after: "${cursor}"` : ''}
-              ) {
-                  pageInfo {
-                      hasNextPage
-                  }
-                  edges {
-                      cursor
-                      node {
-                          id
-                          tags {
-                            name
-                            value
-                          }
-                          block {
-                              height
-                          }
-                      }
-                  }
-              }
-          }`,
-        };
-        if (signal?.aborted) {
-            throw new AbortError('GraphQL request was aborted.');
-        }
-        const { status, ...response } = await arweave.api.post('/graphql', queryObject, {
-            signal,
-        });
-        if (status == 429) {
-            await new Promise((resolve) => setTimeout(resolve, 10_000));
-            continue;
-        }
-        if (status !== 200) {
-            throw Error(`Failed to fetch contracts for wallet. Status code: ${status}`);
-        }
-        if (!response.data.data?.transactions?.edges?.length) {
-            continue;
-        }
-        response.data.data.transactions.edges
-            .map((e) => {
-            const contractTag = e.node.tags.find((t) => t.name === 'Contract');
-            // we want to preserve the cursor here, so add even if a duplicate and the set will handle removing the contract if its a duplicate
-            return {
-                id: contractTag?.value,
-                tags: [],
-                data: 0,
-            };
-        })
-            .forEach((c) => {
-            if (c.tx?.id) {
-                protocolTxs.add(c.tx);
-            }
-        });
-        cursor =
-            response.data.data.transactions.edges[MAX_REQUEST_SIZE - 1]?.cursor ??
-                undefined;
-        hasNextPage =
-            response.data.data.transactions.pageInfo?.hasNextPage ?? false;
-    } while (hasNextPage);
-    return [...protocolTxs];
-}

package/lib/esm/utils/smartweave.js

@@ -1,50 +0,0 @@
-import { SORT_KEY_REGEX } from '../constants.js';
-import { tagsToObject, validateArweaveId } from './arweave.js';
-export function isSortKey(sortKey) {
-    return SmartWeaveSortKey.validate(sortKey);
-}
-export class SmartWeaveSortKey {
-    _sortKey;
-    constructor(sortKey) {
-        if (!SmartWeaveSortKey.validate(sortKey)) {
-            throw new Error(`Invalid sort key: ${sortKey}`);
-        }
-        this._sortKey = sortKey;
-    }
-    static validate(sortKey) {
-        return SORT_KEY_REGEX.test(sortKey);
-    }
-    toString() {
-        return this._sortKey;
-    }
-    parts() {
-        return this._sortKey.split(',');
-    }
-    blockHeight() {
-        return parseInt(this.parts()[0]);
-    }
-    timestamp() {
-        return parseInt(this.parts()[1]);
-    }
-    hash() {
-        return this.parts()[2];
-    }
-}
-export async function getContractManifest({ arweave, contractTxId, }) {
-    const { tags: encodedTags } = await arweave.transactions
-        .get(contractTxId)
-        .catch(() => ({ tags: [] }));
-    const decodedTags = tagsToObject(encodedTags);
-    const contractManifestString = decodedTags['Contract-Manifest'] ?? '{}';
-    // TODO throw if manifest is missing
-    const contractManifest = JSON.parse(contractManifestString);
-    return contractManifest;
-}
-export function isContractConfiguration(config) {
-    return 'contract' in config;
-}
-export function isContractTxIdConfiguration(config) {
-    return ('contractTxId' in config &&
-        typeof config.contractTxId === 'string' &&
-        validateArweaveId(config.contractTxId) === true);
-}

package/lib/types/arns-service.d.ts

@@ -1,23 +0,0 @@
-/**
- * Copyright (C) 2022-2024 Permanent Data Solutions, Inc. All Rights Reserved.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-import { EvalStateResult, EvaluationOptions } from 'warp-contracts';
-export type EvaluatedContractState<ContractState> = EvalStateResult<ContractState> & {
-    sortKey: string;
-    evaluationOptions: EvaluationOptions;
-    contractTxId: string;
-};
-export type ArNSStateResponse<StateKey extends string, StateObject> = Pick<EvaluatedContractState<unknown>, 'contractTxId' | 'sortKey' | 'evaluationOptions'> & Record<StateKey, StateObject>;