@ar.io/sdk 1.2.2 → 2.0.0-alpha.10

package/lib/esm/common/ant.js

@@ -14,47 +14,10 @@
  * 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 { ANT_CONTRACT_FUNCTIONS, isProcessConfiguration, isProcessIdConfiguration, } from '../types.js';
-import { isContractConfiguration, isContractTxIdConfiguration, } from '../utils/smartweave.js';
-import { RemoteContract } from './contracts/remote-contract.js';
-import { AoANTReadable, AoANTWriteable, InvalidContractConfigurationError, WarpContract, } from './index.js';
+import { isProcessConfiguration, isProcessIdConfiguration, } from '../types.js';
+import { AOProcess, InvalidContractConfigurationError } from './index.js';
 export class ANT {
-    /**
-     * @param config - @type {ContractConfiguration} The configuration object.
-     * @returns {WarpContract<ANTState>} The contract object.
-     * @example
-     * Using the contract object
-     * ```ts
-     * ANT.createContract({ contract: new WarpContract<ANTState>({ contractTxId: 'myContractTxId' });
-     * ```
-     * Using the contractTxId
-     * ```ts
-     * ANT.createContract({ contractTxId: 'myContractTxId' });
-     * ```
-     */
-    static createWriteableContract(config) {
-        if (isContractConfiguration(config)) {
-            return config.contract instanceof WarpContract
-                ? config.contract
-                : new WarpContract(config.contract.configuration());
-        }
-        else if (isContractTxIdConfiguration(config)) {
-            return new WarpContract({ contractTxId: config.contractTxId });
-        }
-        else {
-            throw new InvalidContractConfigurationError();
-        }
-    }
     static init({ signer, ...config }) {
-        // TODO: these will be deprecated in the future
-        if (isContractConfiguration(config) ||
-            isContractTxIdConfiguration(config)) {
-            if (!signer) {
-                return new ANTReadable(config);
-            }
-            const contract = this.createWriteableContract(config);
-            return new ANTWritable({ signer, contract });
-        }
         // ao supported implementation
         if (isProcessConfiguration(config) || isProcessIdConfiguration(config)) {
             if (!signer) {
@@ -65,171 +28,136 @@ export class ANT {
         throw new InvalidContractConfigurationError();
     }
 }
-export class ANTReadable {
-    contract;
+export class AoANTReadable {
+    process;
     constructor(config) {
-        if (isContractConfiguration(config)) {
-            this.contract = config.contract;
+        if (isProcessConfiguration(config)) {
+            this.process = config.process;
         }
-        else if (isContractTxIdConfiguration(config)) {
-            this.contract = new RemoteContract({
-                contractTxId: config.contractTxId,
+        else if (isProcessIdConfiguration(config)) {
+            this.process = new AOProcess({
+                processId: config.processId,
             });
         }
         else {
             throw new InvalidContractConfigurationError();
         }
     }
-    /**
-     * @param evaluationOptions @type {EvaluationOptions} The evaluation options.
-     * @returns {Promise<ANTState>} The state of the contract.
-     * @example
-     * Get the current state
-     * ```ts
-     * ant.getState();
-     * ```
-     * Get the state at a specific block height or sortkey
-     * ```ts
-     *  ant.getState({ evaluationOptions: { evalTo: { blockHeight: 1000 } } });
-     *  ant.getState({ evaluationOptions: { evalTo: { sortKey: 'mySortKey' } } });
-     * ```
-     */
-    async getState({ evaluationOptions, } = {}) {
-        const state = await this.contract.getState({ evaluationOptions });
-        return state;
+    async getState() {
+        const tags = [{ name: 'Action', value: 'State' }];
+        const res = await this.process.read({
+            tags,
+        });
+        return res;
+    }
+    async getInfo() {
+        const tags = [{ name: 'Action', value: 'Info' }];
+        const info = await this.process.read({
+            tags,
+        });
+        return info;
     }
     /**
-     * @param domain @type {string} The domain name.
-     * @param evaluationOptions @type {EvaluationOptions} The evaluation options.
+     * @param undername @type {string} The domain name.
      * @returns {Promise<ANTRecord>} The record of the undername domain.
      * @example
      * Get the current record
      * ```ts
-     * ant.getRecord({ domain: "john" });
-     * ```
-     * Get the record at a specific block height or sortkey
-     * ```ts
-     *  ant.getRecord({ domain: "john", evaluationOptions: { evalTo: { blockHeight: 1000 } } });
-     *  ant.getRecord({  domain: "john", evaluationOptions: { evalTo: { sortKey: 'mySortKey' } } });
+     * ant.getRecord({ undername: "john" });
      * ```
      */
-    async getRecord({ domain, evaluationOptions, }) {
-        const records = await this.getRecords({ evaluationOptions });
-        return records[domain];
+    async getRecord({ undername }) {
+        const tags = [
+            { name: 'Sub-Domain', value: undername },
+            { name: 'Action', value: 'Record' },
+        ];
+        const record = await this.process.read({
+            tags,
+        });
+        return record;
     }
     /**
-     * @param evaluationOptions @type {EvaluationOptions} The evaluation options.
      * @returns {Promise<Record<string, ANTRecord>>} All the undernames managed by the ANT.
      * @example
      * Get the current records
      * ```ts
      * ant.getRecords();
-     * ```
-     * Get the records at a specific block height or sortkey
-     * ```ts
-     *  ant.getRecords({ evaluationOptions: { evalTo: { blockHeight: 1000 } } });
-     *  ant.getRecords({ evaluationOptions: { evalTo: { sortKey: 'mySortKey' } } });
-     * ```
+     * ````
      */
-    async getRecords({ evaluationOptions, } = {}) {
-        const state = await this.contract.getState({ evaluationOptions });
-        return state.records;
+    async getRecords() {
+        const tags = [{ name: 'Action', value: 'Records' }];
+        const records = await this.process.read({
+            tags,
+        });
+        return records;
     }
     /**
-     * @param evaluationOptions @type {EvaluationOptions} The evaluation options.
      * @returns {Promise<string>} The owner of the ANT.
      * @example
      * Get the current owner
      * ```ts
      *  ant.getOwner();
      * ```
-     * Get the owner at a specific block height or sortkey
-     * ```ts
-     * ant.getOwner({ evaluationOptions: { evalTo: { blockHeight: 1000 } } });
-     * ant.getOwner({ evaluationOptions: { evalTo: { sortKey: 'mySortKey' } } });
-     * ```
      */
-    async getOwner({ evaluationOptions, } = {}) {
-        const state = await this.contract.getState({ evaluationOptions });
-        return state.owner;
+    async getOwner() {
+        const info = await this.getInfo();
+        return info.Owner;
     }
     /**
-     * @param evaluationOptions @type {EvaluationOptions} The evaluation options.
      * @returns {Promise<string[]>} The controllers of the ANT.
      * @example
      * Get the controllers of the ANT.
      * ```ts
      * ant.getControllers();
      * ```
-     * Get the controllers at a specific block height or sortkey
-     * ```ts
-     * ant.getControllers({ evaluationOptions: { evalTo: { blockHeight: 1000 } } });
-     * ant.getControllers({ evaluationOptions: { evalTo: { sortKey: 'mySortKey' } } });
-     * ```
      */
-    async getControllers({ evaluationOptions, } = {}) {
-        const state = await this.contract.getState({ evaluationOptions });
-        return state.controllers;
+    async getControllers() {
+        const tags = [{ name: 'Action', value: 'Controllers' }];
+        const controllers = await this.process.read({
+            tags,
+        });
+        return controllers;
     }
     /**
-     * @param evaluationOptions @type {EvaluationOptions} The evaluation options.
      * @returns {Promise<string>} The name of the ANT (not the same as ArNS name).
      * @example
      * Get the current name
      * ```ts
      * ant.getName();
      * ```
-     * @example
-     * Get the ticker at a specific block height or sortkey
-     * ```ts
-     * ant.getName({ evaluationOptions: { evalTo: { blockHeight: 1000 } } });
-     * ant.getName({ evaluationOptions: { evalTo: { sortKey: 'mySortKey' } } });
-     * ```
      */
-    async getName({ evaluationOptions, } = {}) {
-        const state = await this.contract.getState({ evaluationOptions });
-        return state.name;
+    async getName() {
+        const info = await this.getInfo();
+        return info.Name;
     }
     /**
-     * @param evaluationOptions @type {EvaluationOptions} The evaluation options.
      * @returns {Promise<string>} The name of the ANT (not the same as ArNS name).
      * @example
      * The current ticker of the ANT.
      * ```ts
      * ant.getTicker();
      * ```
-     * @example
-     * Get the ticker at a specific block height or sortkey
-     * ```ts
-     * ant.getTicker({ evaluationOptions: { evalTo: { blockHeight: 1000 } } });
-     * ant.getTicker({ evaluationOptions: { evalTo: { sortKey: 'mySortKey' } } });
-     * ```
      */
-    async getTicker({ evaluationOptions, } = {}) {
-        const state = await this.contract.getState({ evaluationOptions });
-        return state.ticker;
+    async getTicker() {
+        const info = await this.getInfo();
+        return info.Ticker;
     }
     /**
-     * @param evaluationOptions @type {EvaluationOptions} The evaluation options.
-     * @returns {Promise<Record<string, number>>} The balances of the ANT
+     * @returns {Promise<Record<WalletAddress, number>>} The balances of the ANT
      * @example
      * The current balances of the ANT.
      * ```ts
      * ant.getBalances();
      * ```
-     * @example
-     * Get the balances at a specific block height or sortkey
-     * ```ts
-     * ant.getBalances({ evaluationOptions: { evalTo: { blockHeight: 1000 } } });
-     * ant.getBalances({ evaluationOptions: { evalTo: { sortKey: 'mySortKey' } } });
-     * ```
      */
-    async getBalances({ evaluationOptions, } = {}) {
-        const state = await this.contract.getState({ evaluationOptions });
-        return state.balances;
+    async getBalances() {
+        const tags = [{ name: 'Action', value: 'Balances' }];
+        const balances = await this.process.read({
+            tags,
+        });
+        return balances;
     }
     /**
-     * @param evaluationOptions @type {EvaluationOptions} The evaluation options.
      * @param address @type {string} The address of the account you want the balance of.
      * @returns {Promise<number>} The balance of the provided address
      * @example
@@ -237,142 +165,155 @@ export class ANTReadable {
      * ```ts
      * ant.getBalance({ address });
      * ```
-     * @example
-     * Get the balance at a specific block height or sortkey
-     * ```ts
-     * ant.getBalance({ address, evaluationOptions: { evalTo: { blockHeight: 1000 } } });
-     * ant.getBalance({ address, evaluationOptions: { evalTo: { sortKey: 'mySortKey' } } });
-     * ```
      */
-    async getBalance({ address, evaluationOptions, }) {
-        const balances = await this.getBalances({ evaluationOptions });
-        return balances[address] || 0;
+    async getBalance({ address }) {
+        const tags = [
+            { name: 'Action', value: 'Balance' },
+            { name: 'Recipient', value: address },
+        ];
+        const balance = await this.process.read({
+            tags,
+        });
+        return balance;
     }
 }
-export class ANTWritable extends ANTReadable {
+export class AoANTWriteable extends AoANTReadable {
     signer;
     constructor({ signer, ...config }) {
-        if (isContractConfiguration(config)) {
-            super({ contract: config.contract });
-            this.signer = signer;
-        }
-        else if (isContractTxIdConfiguration(config)) {
-            super({
-                contract: new WarpContract({
-                    contractTxId: config.contractTxId,
-                }),
-            });
-            this.signer = signer;
-        }
-        else {
-            throw new InvalidContractConfigurationError();
-        }
+        super(config);
+        this.signer = signer;
     }
     /**
      * @param target @type {string} The address of the account you want to transfer the ANT to.
-     * @returns {Promise<WriteInteractionResult>} The result of the interaction.
+     * @returns {Promise<AoMessageResult>} The result of the interaction.
      * @example
      * ```ts
      * ant.transfer({ target: "fGht8v4STuwPnTck1zFVkQqJh5K9q9Zik4Y5-5dV7nk" });
      * ```
      */
-    async transfer({ target, }, options) {
-        return this.contract.writeInteraction({
-            functionName: ANT_CONTRACT_FUNCTIONS.TRANSFER,
-            inputs: { target },
+    async transfer({ target }) {
+        const tags = [
+            { name: 'Action', value: 'Transfer' },
+            { name: 'Recipient', value: target },
+        ];
+        return this.process.send({
+            tags,
+            data: {},
             signer: this.signer,
-        }, options);
+        });
     }
     /**
      * @param controller @type {string} The address of the account you want to set as a controller.
-     * @returns {Promise<WriteInteractionResult>} The result of the interaction.
+     * @returns {Promise<AoMessageResult>} The result of the interaction.
      * @example
      * ```ts
      * ant.setController({ controller: "fGht8v4STuwPnTck1zFVkQqJh5K9q9Zik4Y5-5dV7nk" });
      * ```
      */
-    async setController({ controller, }, options) {
-        return this.contract.writeInteraction({
-            functionName: ANT_CONTRACT_FUNCTIONS.SET_CONTROLLER,
-            inputs: { target: controller },
+    async addController({ controller, }) {
+        const tags = [
+            { name: 'Action', value: 'Add-Controller' },
+            { name: 'Controller', value: controller },
+        ];
+        return this.process.send({
+            tags,
+            data: {},
             signer: this.signer,
-        }, options);
+        });
     }
     /**
      * @param controller @type {string} The address of the account you want to remove from the controllers list
-     * @returns {Promise<WriteInteractionResult>} The result of the interaction.
+     * @returns {Promise<AoMessageResult>} The result of the interaction.
      * @example
      * ```ts
      * ant.removeController({ controller: "fGht8v4STuwPnTck1zFVkQqJh5K9q9Zik4Y5-5dV7nk" });
      * ```
      */
-    async removeController({ controller, }, options) {
-        return this.contract.writeInteraction({
-            functionName: ANT_CONTRACT_FUNCTIONS.REMOVE_CONTROLLER,
-            inputs: { target: controller },
+    async removeController({ controller, }) {
+        const tags = [
+            { name: 'Action', value: 'Remove-Controller' },
+            { name: 'Controller', value: controller },
+        ];
+        return this.process.send({
+            tags,
+            data: {},
             signer: this.signer,
-        }, options);
+        });
     }
     /**
-     * @param subDomain @type {string} The record you want to set the transactionId and ttlSeconds of.
+     * @param undername @type {string} The record you want to set the transactionId and ttlSeconds of.
      * @param transactionId @type {string} The transactionId of the record.
      * @param ttlSeconds @type {number} The time to live of the record.
-     * @returns {Promise<WriteInteractionResult>} The result of the interaction.
+     * @returns {Promise<AoMessageResult>} The result of the interaction.
      * @example
      * ```ts
      * ant.setController({ controller: "fGht8v4STuwPnTck1zFVkQqJh5K9q9Zik4Y5-5dV7nk" });
      * ```
      */
-    async setRecord({ subDomain, transactionId, ttlSeconds, }, options) {
-        return this.contract.writeInteraction({
-            functionName: ANT_CONTRACT_FUNCTIONS.SET_RECORD,
-            inputs: { subDomain, transactionId, ttlSeconds },
+    async setRecord({ undername, transactionId, ttlSeconds, }) {
+        return this.process.send({
+            tags: [
+                { name: 'Action', value: 'Set-Record' },
+                { name: 'Sub-Domain', value: undername },
+                { name: 'Transaction-Id', value: transactionId },
+                { name: 'TTL-Seconds', value: ttlSeconds.toString() },
+            ],
+            data: { transactionId, ttlSeconds },
             signer: this.signer,
-        }, options);
+        });
     }
     /**
-     * @param subDomain @type {string} The record you want to remove.
-     * @returns {Promise<WriteInteractionResult>} The result of the interaction.
+     * @param undername @type {string} The record you want to remove.
+     * @returns {Promise<AoMessageResult>} The result of the interaction.
      * @example
      * ```ts
      * ant.removeRecord({ subDomain: "shorts" });
      * ```
      */
-    async removeRecord({ subDomain, }, options) {
-        return this.contract.writeInteraction({
-            functionName: ANT_CONTRACT_FUNCTIONS.REMOVE_RECORD,
-            inputs: { subDomain },
+    async removeRecord({ undername, }) {
+        return this.process.send({
+            tags: [
+                { name: 'Action', value: 'Remove-Record' },
+                { name: 'Sub-Domain', value: undername },
+            ],
+            data: { undername },
             signer: this.signer,
-        }, options);
+        });
     }
     /**
      * @param ticker @type {string} Sets the ANT Ticker.
-     * @returns {Promise<WriteInteractionResult>} The result of the interaction.
+     * @returns {Promise<AoMessageResult>} The result of the interaction.
      * @example
      * ```ts
      * ant.setTicker({ ticker: "KAPOW" });
      * ```
      */
-    async setTicker({ ticker, }, options) {
-        return this.contract.writeInteraction({
-            functionName: ANT_CONTRACT_FUNCTIONS.SET_TICKER,
-            inputs: { ticker },
+    async setTicker({ ticker }) {
+        return this.process.send({
+            tags: [
+                { name: 'Action', value: 'Set-Ticker' },
+                { name: 'Ticker', value: ticker },
+            ],
+            data: { ticker },
             signer: this.signer,
-        }, options);
+        });
     }
     /**
      * @param name @type {string} Sets the Name of the ANT.
-     * @returns {Promise<WriteInteractionResult>} The result of the interaction.
+     * @returns {Promise<AoMessageResult>} The result of the interaction.
      * @example
      * ```ts
      * ant.setName({ name: "ships at sea" });
      * ```
      */
-    async setName({ name }, options) {
-        return this.contract.writeInteraction({
-            functionName: ANT_CONTRACT_FUNCTIONS.SET_NAME,
-            inputs: { name },
+    async setName({ name }) {
+        return this.process.send({
+            tags: [
+                { name: 'Action', value: 'Set-Name' },
+                { name: 'Name', value: name },
+            ],
+            data: { name },
             signer: this.signer,
-        }, options);
+        });
     }
 }

package/lib/esm/common/contracts/ao-process.js

@@ -19,12 +19,12 @@ import { createData } from 'arbundles';
 import { safeDecode } from '../../utils/json.js';
 import { version } from '../../version.js';
 import { WriteInteractionError } from '../error.js';
-import { DefaultLogger } from '../logger.js';
+import { Logger } from '../logger.js';
 export class AOProcess {
     logger;
     processId;
     ao;
-    constructor({ processId, ao = connect(), logger = new DefaultLogger({ level: 'info' }), }) {
+    constructor({ processId, ao = connect(), logger = Logger.default, }) {
         this.processId = processId;
         this.logger = logger;
         this.ao = ao;

package/lib/esm/common/http.js

@@ -1,11 +1,10 @@
 import { createAxiosInstance } from '../utils/index.js';
 import { FailedRequestError, NotFound, UnknownError } from './error.js';
-import { DefaultLogger } from './logger.js';
+import { Logger } from './logger.js';
 export class AxiosHTTPService {
     axios;
     logger;
-    // TODO: re-implement axios-retry. Currently that package is broken for nodenext.
-    constructor({ url, logger = new DefaultLogger(), }) {
+    constructor({ url, logger = Logger.default, }) {
         this.logger = logger;
         this.axios = createAxiosInstance({
             axiosConfig: {

package/lib/esm/common/index.js

@@ -14,14 +14,9 @@
  * 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/>.
  */
-export * from './ar-io.js';
 export * from './error.js';
 export * from './logger.js';
 export * from './ant.js';
-// contracts - deprecated
-export * from './contracts/remote-contract.js';
-export * from './contracts/warp-contract.js';
 // ao
 export * from './io.js';
-export * from './ant-ao.js';
 export * from './contracts/ao-process.js';

package/lib/esm/common/io.js

@@ -1,25 +1,8 @@
-/**
- * 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 Arweave from 'arweave';
 import { IO_TESTNET_PROCESS_ID } from '../constants.js';
 import { isProcessConfiguration, isProcessIdConfiguration, } from '../io.js';
+import { defaultArweave } from './arweave.js';
 import { AOProcess } from './contracts/ao-process.js';
 import { InvalidContractConfigurationError } from './error.js';
-import { DefaultLogger } from './logger.js';
 export class IO {
     static init(config) {
         if (config && config.signer) {
@@ -35,7 +18,7 @@ export class IO {
 export class IOReadable {
     process;
     arweave;
-    constructor(config, arweave = Arweave.init({})) {
+    constructor(config, arweave = defaultArweave) {
         if (!config) {
             this.process = new AOProcess({
                 processId: IO_TESTNET_PROCESS_ID,
@@ -47,9 +30,6 @@ export class IOReadable {
         else if (isProcessIdConfiguration(config)) {
             this.process = new AOProcess({
                 processId: config.processId,
-                logger: new DefaultLogger({
-                    level: 'info',
-                }),
             });
         }
         else {
@@ -120,9 +100,17 @@ export class IOReadable {
             ],
         });
     }
-    async getArNSRecords() {
+    async getArNSRecords(pageParams) {
+        const allTags = [
+            { name: 'Action', value: 'Paginated-Records' },
+            { name: 'Cursor', value: pageParams?.cursor?.toString() },
+            { name: 'Limit', value: pageParams?.limit?.toString() },
+            { name: 'Sort-By', value: pageParams?.sortBy },
+            { name: 'Sort-Order', value: pageParams?.sortOrder },
+        ];
+        const prunedTags = allTags.filter((tag) => tag.value !== undefined);
         return this.process.read({
-            tags: [{ name: 'Action', value: 'Records' }],
+            tags: prunedTags,
         });
     }
     async getArNSReservedNames() {
@@ -146,9 +134,17 @@ export class IOReadable {
             ],
         });
     }
-    async getBalances() {
+    async getBalances(pageParams) {
+        const allTags = [
+            { name: 'Action', value: 'Paginated-Balances' },
+            { name: 'Cursor', value: pageParams?.cursor?.toString() },
+            { name: 'Limit', value: pageParams?.limit?.toString() },
+            { name: 'Sort-By', value: pageParams?.sortBy },
+            { name: 'Sort-Order', value: pageParams?.sortOrder },
+        ];
+        const prunedTags = allTags.filter((tag) => tag.value !== undefined);
         return this.process.read({
-            tags: [{ name: 'Action', value: 'Balances' }],
+            tags: prunedTags,
         });
     }
     async getGateway({ address, }) {
@@ -159,9 +155,17 @@ export class IOReadable {
             ],
         });
     }
-    async getGateways() {
+    async getGateways(pageParams) {
+        const allTags = [
+            { name: 'Action', value: 'Paginated-Gateways' },
+            { name: 'Cursor', value: pageParams?.cursor?.toString() },
+            { name: 'Limit', value: pageParams?.limit?.toString() },
+            { name: 'Sort-By', value: pageParams?.sortBy },
+            { name: 'Sort-Order', value: pageParams?.sortOrder },
+        ];
+        const prunedTags = allTags.filter((tag) => tag.value !== undefined);
         return this.process.read({
-            tags: [{ name: 'Action', value: 'Gateways' }],
+            tags: prunedTags,
         });
     }
     async getCurrentEpoch() {
@@ -428,6 +432,13 @@ export class IOWriteable extends IOReadable {
             tags: prunedTags,
         });
     }
+    async leaveNetwork(options) {
+        const { tags = [] } = options || {};
+        return this.process.send({
+            signer: this.signer,
+            tags: [...tags, { name: 'Action', value: 'Leave-Network' }],
+        });
+    }
     async updateGatewaySettings({ allowDelegatedStaking, delegateRewardShareRatio, fqdn, label, minDelegatedStake, note, port, properties, protocol, autoStake, observerAddress, }, options) {
         const { tags = [] } = options || {};
         const allTags = [