@ar.io/sdk 2.5.0-alpha.1 → 2.5.0-alpha.11

package/lib/esm/common/ant.js

@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 import { z } from 'zod';
-import { AntBalancesSchema, AntControllersSchema, AntInfoSchema, AntRecordSchema, AntRecordsSchema, AntStateSchema, } from '../types/ant.js';
+import { AntBalancesSchema, AntControllersSchema, AntEntriesSchema, AntInfoSchema, AntRecordSchema, AntStateSchema, } from '../types/ant.js';
 import { isProcessConfiguration, isProcessIdConfiguration, } from '../types/index.js';
-import { createAoSigner } from '../utils/ao.js';
+import { createAoSigner, parseAntRecords } from '../utils/ao.js';
 import { parseSchemaResult } from '../utils/schema.js';
 import { AOProcess, InvalidContractConfigurationError } from './index.js';
 export class ANT {
@@ -92,7 +92,7 @@ export class AoANTReadable {
         return record;
     }
     /**
-     * @returns {Promise<Record<string, AoANTRecord>>} All the undernames managed by the ANT.
+     * @returns {Promise<AoANTRecordEntry[]>} All the undernames managed by the ANT.
      * @example
      * Get the current records
      * ```ts
@@ -104,9 +104,10 @@ export class AoANTReadable {
         const records = await this.process.read({
             tags,
         });
+        const result = parseAntRecords(records);
         if (strict)
-            parseSchemaResult(AntRecordsSchema, records);
-        return records;
+            parseSchemaResult(AntEntriesSchema, result);
+        return result;
     }
     /**
      * @returns {Promise<string>} The owner of the ANT.
@@ -199,6 +200,18 @@ export class AoANTReadable {
             parseSchemaResult(z.number(), balance);
         return balance;
     }
+    /**
+     * @returns {Promise<AoANTHandler[]>} The handlers of the ANT.
+     * @example
+     * Get the handlers of the ANT.
+     * ```ts
+     * const handlers = await ant.getHandlers();
+     * ```
+     */
+    async getHandlers() {
+        const info = await this.getInfo();
+        return (info.Handlers ?? info.HandlerNames);
+    }
 }
 export class AoANTWriteable extends AoANTReadable {
     signer;
@@ -375,6 +388,25 @@ export class AoANTWriteable extends AoANTReadable {
             signer: this.signer,
         });
     }
+    /**
+     * @param txId @type {string} - Arweave transaction id of the logo we want to set
+     * @param options @type {WriteOptions} - additional options to add to the write interaction (optional)
+     * @returns {Promise<AoMessageResult>} The result of the interaction.
+     * @example
+     * ```ts
+     * ant.setLogo({ logo: "U7RXcpaVShG4u9nIcPVmm2FJSM5Gru9gQCIiRaIPV7f" });
+     * ```
+     */
+    async setLogo({ txId }, options) {
+        return this.process.send({
+            tags: [
+                ...(options?.tags ?? []),
+                { name: 'Action', value: 'Set-Logo' },
+                { name: 'Logo', value: txId },
+            ],
+            signer: this.signer,
+        });
+    }
     /**
      * @param name @type {string} The name you want to release. The name will be put up for auction on the IO contract. 50% of the winning bid will be distributed to the ANT owner at the time of release. If no bids, the name will be released and can be reregistered by anyone.
      * @param ioProcessId @type {string} The processId of the IO contract. This is where the ANT will send the message to release the name.
@@ -418,4 +450,30 @@ export class AoANTWriteable extends AoANTReadable {
             signer: this.signer,
         });
     }
+    /**
+     * Approves a primary name request for a given name or address.
+     */
+    async approvePrimaryNameRequest({ name, address, ioProcessId, }, options) {
+        return this.process.send({
+            tags: [
+                ...(options?.tags ?? []),
+                { name: 'Action', value: 'Approve-Primary-Name' },
+                { name: 'Name', value: name },
+                { name: 'Recipient', value: address },
+                { name: 'IO-Process-Id', value: ioProcessId },
+            ],
+            signer: this.signer,
+        });
+    }
+    async removePrimaryNames({ names, ioProcessId }, options) {
+        return this.process.send({
+            tags: [
+                ...(options?.tags ?? []),
+                { name: 'Action', value: 'Remove-Primary-Names' },
+                { name: 'Names', value: names.join(',') },
+                { name: 'IO-Process-Id', value: ioProcessId },
+            ],
+            signer: this.signer,
+        });
+    }
 }

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

@@ -47,11 +47,12 @@ export class AOProcess {
                     this.logger.debug(`Process ${this.processId} does not support provided action.`, result, tags);
                     throw new Error(`Process ${this.processId} does not support provided action.`);
                 }
-                const tagsOutput = result.Messages[0].Tags;
-                const messageData = result.Messages[0].Data;
-                const error = tagsOutput.find((tag) => tag.name === 'Error');
+                const tagsOutput = result.Messages?.[0]?.Tags;
+                const messageData = result.Messages?.[0]?.Data;
+                const errorData = result.Error;
+                const error = errorData || tagsOutput?.find((tag) => tag.name === 'Error')?.value;
                 if (error) {
-                    throw new Error(`${error.value}${messageData ? `: ${messageData}` : ''}`);
+                    throw new Error(`${error}${messageData ? `: ${messageData}` : ''}`);
                 }
                 // return empty object if no data is returned
                 if (messageData === undefined) {
@@ -106,17 +107,17 @@ export class AOProcess {
                     messageId,
                     processId: this.processId,
                 });
+                const errorData = output.Error;
+                const error = errorData ||
+                    output.Messages?.[0]?.Tags?.find((tag) => tag.name === 'Error')
+                        ?.value;
+                if (error) {
+                    throw new WriteInteractionError(error);
+                }
                 // check if there are any Messages in the output
                 if (output.Messages?.length === 0 || output.Messages === undefined) {
                     return { id: messageId };
                 }
-                const tagsOutput = output.Messages[0].Tags;
-                const error = tagsOutput.find((tag) => tag.name === 'Error');
-                // if there's an Error tag, throw an error related to it
-                if (error) {
-                    const result = output.Messages[0].Data;
-                    throw new WriteInteractionError(`${error.Value}: ${result}`);
-                }
                 if (output.Messages.length === 0) {
                     throw new Error(`Process ${this.processId} does not support provided action.`);
                 }

package/lib/esm/common/io.js

@@ -1,7 +1,7 @@
 import { IO_TESTNET_PROCESS_ID } from '../constants.js';
 import { isProcessConfiguration, isProcessIdConfiguration, } from '../types/io.js';
 import { createAoSigner } from '../utils/ao.js';
-import { getCurrentBlockUnixTimestampMs, pruneTags } from '../utils/arweave.js';
+import { getCurrentBlockUnixTimestampMs, paginationParamsToTags, pruneTags, } from '../utils/arweave.js';
 import { defaultArweave } from './arweave.js';
 import { AOProcess } from './contracts/ao-process.js';
 import { InvalidContractConfigurationError } from './error.js';
@@ -92,20 +92,19 @@ export class IOReadable {
         });
     }
     async getArNSRecords(params) {
-        const allTags = [
-            { name: 'Action', value: 'Paginated-Records' },
-            { name: 'Cursor', value: params?.cursor?.toString() },
-            { name: 'Limit', value: params?.limit?.toString() },
-            { name: 'Sort-By', value: params?.sortBy },
-            { name: 'Sort-Order', value: params?.sortOrder },
-        ];
         return this.process.read({
-            tags: pruneTags(allTags),
+            tags: [
+                { name: 'Action', value: 'Paginated-Records' },
+                ...paginationParamsToTags(params),
+            ],
         });
     }
-    async getArNSReservedNames() {
+    async getArNSReservedNames(params) {
         return this.process.read({
-            tags: [{ name: 'Action', value: 'Reserved-Names' }],
+            tags: [
+                { name: 'Action', value: 'Reserved-Names' },
+                ...paginationParamsToTags(params),
+            ],
         });
     }
     async getArNSReservedName({ name, }) {
@@ -125,15 +124,11 @@ export class IOReadable {
         });
     }
     async getBalances(params) {
-        const allTags = [
-            { name: 'Action', value: 'Paginated-Balances' },
-            { name: 'Cursor', value: params?.cursor?.toString() },
-            { name: 'Limit', value: params?.limit?.toString() },
-            { name: 'Sort-By', value: params?.sortBy },
-            { name: 'Sort-Order', value: params?.sortOrder },
-        ];
         return this.process.read({
-            tags: pruneTags(allTags),
+            tags: [
+                { name: 'Action', value: 'Paginated-Balances' },
+                ...paginationParamsToTags(params),
+            ],
         });
     }
     async getVault({ address, vaultId, }) {
@@ -146,15 +141,11 @@ export class IOReadable {
         });
     }
     async getVaults(params) {
-        const allTags = [
-            { name: 'Action', value: 'Paginated-Vaults' },
-            { name: 'Cursor', value: params?.cursor?.toString() },
-            { name: 'Limit', value: params?.limit?.toString() },
-            { name: 'Sort-By', value: params?.sortBy },
-            { name: 'Sort-Order', value: params?.sortOrder },
-        ];
         return this.process.read({
-            tags: pruneTags(allTags),
+            tags: [
+                { name: 'Action', value: 'Paginated-Vaults' },
+                ...paginationParamsToTags(params),
+            ],
         });
     }
     async getGateway({ address, }) {
@@ -166,41 +157,29 @@ export class IOReadable {
         });
     }
     async getGatewayDelegates({ address, ...pageParams }) {
-        const allTags = [
-            { name: 'Action', value: 'Paginated-Delegates' },
-            { name: 'Address', value: address },
-            { name: 'Cursor', value: pageParams?.cursor?.toString() },
-            { name: 'Limit', value: pageParams?.limit?.toString() },
-            { name: 'Sort-By', value: pageParams?.sortBy },
-            { name: 'Sort-Order', value: pageParams?.sortOrder },
-        ];
         return this.process.read({
-            tags: pruneTags(allTags),
+            tags: [
+                { name: 'Action', value: 'Paginated-Delegates' },
+                { name: 'Address', value: address },
+                ...paginationParamsToTags(pageParams),
+            ],
         });
     }
     async getGatewayDelegateAllowList({ address, ...pageParams }) {
-        const allTags = [
-            { name: 'Action', value: 'Paginated-Allowed-Delegates' },
-            { name: 'Address', value: address },
-            { name: 'Cursor', value: pageParams?.cursor?.toString() },
-            { name: 'Limit', value: pageParams?.limit?.toString() },
-            { name: 'Sort-Order', value: pageParams?.sortOrder },
-            // note: sortBy is omitted because it's not supported for this action as table is an of addresses
-        ];
         return this.process.read({
-            tags: pruneTags(allTags),
+            tags: [
+                { name: 'Action', value: 'Paginated-Allowed-Delegates' },
+                { name: 'Address', value: address },
+                ...paginationParamsToTags(pageParams),
+            ],
         });
     }
     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 },
-        ];
         return this.process.read({
-            tags: pruneTags(allTags),
+            tags: [
+                { name: 'Action', value: 'Paginated-Gateways' },
+                ...paginationParamsToTags(pageParams),
+            ],
         });
     }
     async getCurrentEpoch() {
@@ -209,14 +188,7 @@ export class IOReadable {
                 { name: 'Action', value: 'Epoch' },
                 {
                     name: 'Timestamp',
-                    value: (await this.arweave.blocks
-                        .getCurrent()
-                        .then((block) => {
-                        return { timestamp: block.timestamp * 1000 };
-                    })
-                        .catch(() => {
-                        return { timestamp: Date.now() }; // fallback to current time
-                    })).timestamp.toString(),
+                    value: (await getCurrentBlockUnixTimestampMs(this.arweave)).toString(),
                 },
             ],
         });
@@ -261,14 +233,7 @@ export class IOReadable {
             {
                 name: 'Timestamp',
                 value: epoch?.timestamp?.toString() ??
-                    (await this.arweave.blocks
-                        .getCurrent()
-                        .then((block) => {
-                        return { timestamp: block.timestamp * 1000 };
-                    })
-                        .catch(() => {
-                        return { timestamp: `${Date.now()}` }; // fallback to current time
-                    })).timestamp.toString(),
+                    (await getCurrentBlockUnixTimestampMs(this.arweave)).toString(),
             },
             {
                 name: 'Epoch-Index',
@@ -347,15 +312,11 @@ export class IOReadable {
     }
     // Auctions
     async getArNSAuctions(params) {
-        const allTags = [
-            { name: 'Action', value: 'Auctions' },
-            { name: 'Cursor', value: params?.cursor?.toString() },
-            { name: 'Limit', value: params?.limit?.toString() },
-            { name: 'Sort-By', value: params?.sortBy },
-            { name: 'Sort-Order', value: params?.sortOrder },
-        ];
         return this.process.read({
-            tags: pruneTags(allTags),
+            tags: [
+                { name: 'Action', value: 'Auctions' },
+                ...paginationParamsToTags(params),
+            ],
         });
     }
     async getArNSAuction({ name, }) {
@@ -384,7 +345,8 @@ export class IOReadable {
             { name: 'Name', value: name },
             {
                 name: 'Timestamp',
-                value: timestamp?.toString() ?? Date.now().toString(),
+                value: timestamp?.toString() ??
+                    (await getCurrentBlockUnixTimestampMs(this.arweave)).toString(),
             },
             { name: 'Purchase-Type', value: type ?? 'lease' },
             {
@@ -405,16 +367,73 @@ export class IOReadable {
     async getDelegations(params) {
         const allTags = [
             { name: 'Action', value: 'Paginated-Delegations' },
-            { name: 'Cursor', value: params.cursor?.toString() },
-            { name: 'Limit', value: params.limit?.toString() },
-            { name: 'Sort-By', value: params.sortBy },
-            { name: 'Sort-Order', value: params.sortOrder },
             { name: 'Address', value: params.address },
+            ...paginationParamsToTags(params),
         ];
         return this.process.read({
             tags: pruneTags(allTags),
         });
     }
+    async getAllowedDelegates(params) {
+        return this.process.read({
+            tags: [
+                { name: 'Action', value: 'Paginated-Allowed-Delegates' },
+                { name: 'Address', value: params.address },
+                ...paginationParamsToTags(params),
+            ],
+        });
+    }
+    async getGatewayVaults(params) {
+        return this.process.read({
+            tags: [
+                { name: 'Action', value: 'Paginated-Gateway-Vaults' },
+                { name: 'Address', value: params.address },
+                ...paginationParamsToTags(params),
+            ],
+        });
+    }
+    async getPrimaryNameRequest(params) {
+        const allTags = [
+            { name: 'Action', value: 'Primary-Name-Request' },
+            { name: 'Name', value: params.name },
+            {
+                name: 'Initiator',
+                value: params.initiator,
+            },
+        ];
+        return this.process.read({
+            tags: allTags,
+        });
+    }
+    async getPrimaryNameRequests(params) {
+        return this.process.read({
+            tags: [
+                { name: 'Action', value: 'Primary-Name-Requests' },
+                ...paginationParamsToTags(params),
+            ],
+        });
+    }
+    async getPrimaryName(params) {
+        const allTags = [
+            { name: 'Action', value: 'Primary-Name' },
+            {
+                name: 'Address',
+                value: params?.address,
+            },
+            { name: 'Name', value: params?.name },
+        ];
+        return this.process.read({
+            tags: pruneTags(allTags),
+        });
+    }
+    async getPrimaryNames(params) {
+        return this.process.read({
+            tags: [
+                { name: 'Action', value: 'Primary-Names' },
+                ...paginationParamsToTags(params),
+            ],
+        });
+    }
 }
 export class IOWriteable extends IOReadable {
     signer;
@@ -757,4 +776,13 @@ export class IOWriteable extends IOReadable {
             tags: pruneTags(allTags),
         });
     }
+    async requestPrimaryName(params) {
+        return this.process.send({
+            signer: this.signer,
+            tags: [
+                { name: 'Action', value: 'Primary-Name-Request' },
+                { name: 'Name', value: params.name },
+            ],
+        });
+    }
 }

package/lib/esm/constants.js

@@ -27,5 +27,5 @@ export const IO_TESTNET_PROCESS_ID = 'agYcCFJtrMG6cqMuZfskIkFTGvUPddICmtQSBIoPdi
 export const ANT_REGISTRY_ID = 'i_le_yKKPVstLTDSmkHRqf-wYphMnwB9OhleiTgMkWc';
 export const MIO_PER_IO = 1_000_000;
 export const AOS_MODULE_ID = 'cbn0KKrBZH7hdNkNokuXLtGryrWM--PjSTBqIzw9Kkk';
-export const ANT_LUA_ID = 'pOh2yupSaQCrLI_-ah8tVTiusUdVNTxxeWTQQHNdf30';
+export const ANT_LUA_ID = 'AWO2a2lVfQnjPFThjE4Uuw4ZFAd9EsCHBEgDYkJA-kk'; // v8 id test - remove comment when updated with actual v8 id.
 export const DEFAULT_SCHEDULER_ID = '_GQ33BkPtZrqxA84vM8Zk-N2aO0toNNu_C-l-rawrBA';

package/lib/esm/types/ant.js

@@ -48,7 +48,9 @@ export const AntRecordSchema = z.object({
     transactionId: ArweaveTxIdSchema.describe('The Target ID of the undername'),
     ttlSeconds: z.number(),
 });
+export const AntEntrySchema = z.intersection(AntRecordSchema, z.object({ name: z.string() }));
 export const AntRecordsSchema = z.record(z.string(), AntRecordSchema);
+export const AntEntriesSchema = z.array(AntEntrySchema);
 export const AntControllersSchema = z.array(ArweaveTxIdSchema.describe('Controller address'));
 export const AntBalancesSchema = z.record(ArweaveTxIdSchema.describe('Holder address'), z.number());
 export const AntStateSchema = z.object({
@@ -72,33 +74,36 @@ export const AntStateSchema = z.object({
     Initialized: z
         .boolean()
         .describe('Flag indicating whether the ANT has been initialized.'),
-    ['Source-Code-TX-ID']: ArweaveTxIdSchema.describe('Transaction ID of the Source Code for the ANT.'),
 });
-export const AntHandlerNames = [
-    'evolve',
-    '_eval',
-    '_default',
-    'transfer',
+export const AntReadHandlers = [
     'balance',
     'balances',
     'totalSupply',
     'info',
+    'controllers',
+    'record',
+    'records',
+    'state',
+];
+export const AntWriteHandlers = [
+    'evolve',
+    '_eval',
+    '_default',
+    'transfer',
     'addController',
     'removeController',
-    'controllers',
     'setRecord',
     'removeRecord',
-    'record',
-    'records',
     'setName',
     'setTicker',
     'setDescription',
     'setKeywords',
+    'setLogo',
     'initializeState',
-    'state',
     'releaseName',
     'reassignName',
 ];
+export const AntHandlerNames = [...AntReadHandlers, ...AntWriteHandlers];
 export const AntHandlersSchema = z
     .array(z.string({ description: 'Handler Name' }))
     .refine((antHandlers) => {
@@ -109,7 +114,6 @@ export const AntHandlersSchema = z
 export const AntInfoSchema = z.object({
     Name: z.string().describe('The name of the ANT.'),
     Owner: ArweaveTxIdSchema.describe('The Owners address.'),
-    ['Source-Code-TX-ID']: ArweaveTxIdSchema.describe('Transaction ID of the Source Code for the ANT.'),
     Ticker: z.string().describe('The ticker symbol for the ANT.'),
     ['Total-Supply']: IntegerStringSchema.describe('Total supply of the ANT in circulation.'),
     Description: AntDescriptionSchema.describe('The description for the ANT.'),

package/lib/esm/utils/ao.js

@@ -42,6 +42,10 @@ export async function spawnANT({ signer, module = AOS_MODULE_ID, luaCodeTxId = A
                 name: 'ANT-Registry-Id',
                 value: antRegistryId,
             },
+            {
+                name: 'Source-Code-TX-ID', // utility for understanding what the original source id of the lua code was
+                value: luaCodeTxId,
+            },
         ],
     });
     const aosClient = new AOProcess({
@@ -170,3 +174,28 @@ export function createAoSigner(signer) {
     };
     return aoSigner;
 }
+/**
+ * @param records @type {AoANTRecordEntry[] | Record<string, AoANTRecord>} - the records returned by an ANT
+ * @returns @type {AoANTRecordEntry[]} - the alphabetically sorted records
+ */
+export function parseAntRecords(records) {
+    const result = Array.isArray(records)
+        ? records // assumes if records is an array that its AoANTRecordEntry[]
+        : // backwards compatibility for when ANTs returned as Record<string, AoANTRecord>
+            Object.keys(records) // sort the keys since string indexed maps in lua do not retain order
+                .sort((a, b) => {
+                if (a == '@')
+                    return -1;
+                if (b == '@')
+                    return 1;
+                return a.localeCompare(b);
+            })
+                .reduce((acc, undername) => {
+                acc.push({
+                    ...records[undername],
+                    name: undername,
+                });
+                return acc;
+            }, []);
+    return result;
+}

package/lib/esm/utils/arweave.js

@@ -18,3 +18,12 @@ export const getCurrentBlockUnixTimestampMs = async (arweave) => {
         return Date.now(); // fallback to current time
     });
 };
+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() },
+    ];
+    return pruneTags(tags);
+};

package/lib/esm/utils/schema.js

@@ -1,5 +1,4 @@
 /**
- *
  * @param schema - zod schema
  * @param v - value to parse
  * @throws {z.SafeParseError<any>} - if the value fails to parse

package/lib/esm/version.js

@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 // AUTOMATICALLY GENERATED FILE - DO NOT TOUCH
-export const version = '2.5.0-alpha.1';
+export const version = '2.5.0-alpha.11';

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

@@ -1,4 +1,4 @@
-import { AntReadOptions, AoANTInfo, AoANTRead, AoANTRecord, AoANTState, AoANTWrite } from '../types/ant.js';
+import { AntReadOptions, AoANTHandler, AoANTInfo, AoANTRead, AoANTRecord, AoANTRecordEntry, AoANTState, AoANTWrite } from '../types/ant.js';
 import { AoMessageResult, ProcessConfiguration, WalletAddress, WithSigner, WriteOptions } from '../types/index.js';
 import { AOProcess } from './index.js';
 export declare class ANT {
@@ -31,14 +31,14 @@ export declare class AoANTReadable implements AoANTRead {
         undername: string;
     }, { strict }?: AntReadOptions): Promise<AoANTRecord>;
     /**
-     * @returns {Promise<Record<string, AoANTRecord>>} All the undernames managed by the ANT.
+     * @returns {Promise<AoANTRecordEntry[]>} All the undernames managed by the ANT.
      * @example
      * Get the current records
      * ```ts
      * ant.getRecords();
      * ````
      */
-    getRecords({ strict }?: AntReadOptions): Promise<Record<string, AoANTRecord>>;
+    getRecords({ strict }?: AntReadOptions): Promise<AoANTRecordEntry[]>;
     /**
      * @returns {Promise<string>} The owner of the ANT.
      * @example
@@ -96,6 +96,15 @@ export declare class AoANTReadable implements AoANTRead {
     getBalance({ address }: {
         address: string;
     }, { strict }?: AntReadOptions): Promise<number>;
+    /**
+     * @returns {Promise<AoANTHandler[]>} The handlers of the ANT.
+     * @example
+     * Get the handlers of the ANT.
+     * ```ts
+     * const handlers = await ant.getHandlers();
+     * ```
+     */
+    getHandlers(): Promise<AoANTHandler[]>;
 }
 export declare class AoANTWriteable extends AoANTReadable implements AoANTWrite {
     private signer;
@@ -205,6 +214,18 @@ export declare class AoANTWriteable extends AoANTReadable implements AoANTWrite
     setKeywords({ keywords }: {
         keywords: string[];
     }, options?: WriteOptions): Promise<AoMessageResult>;
+    /**
+     * @param txId @type {string} - Arweave transaction id of the logo we want to set
+     * @param options @type {WriteOptions} - additional options to add to the write interaction (optional)
+     * @returns {Promise<AoMessageResult>} The result of the interaction.
+     * @example
+     * ```ts
+     * ant.setLogo({ logo: "U7RXcpaVShG4u9nIcPVmm2FJSM5Gru9gQCIiRaIPV7f" });
+     * ```
+     */
+    setLogo({ txId }: {
+        txId: string;
+    }, options?: WriteOptions): Promise<AoMessageResult>;
     /**
      * @param name @type {string} The name you want to release. The name will be put up for auction on the IO contract. 50% of the winning bid will be distributed to the ANT owner at the time of release. If no bids, the name will be released and can be reregistered by anyone.
      * @param ioProcessId @type {string} The processId of the IO contract. This is where the ANT will send the message to release the name.
@@ -234,4 +255,16 @@ export declare class AoANTWriteable extends AoANTReadable implements AoANTWrite
         ioProcessId: string;
         antProcessId: string;
     }, options?: WriteOptions): Promise<AoMessageResult>;
+    /**
+     * Approves a primary name request for a given name or address.
+     */
+    approvePrimaryNameRequest({ name, address, ioProcessId, }: {
+        name: string;
+        address: WalletAddress;
+        ioProcessId: string;
+    }, options?: WriteOptions): Promise<AoMessageResult>;
+    removePrimaryNames({ names, ioProcessId }: {
+        names: string[];
+        ioProcessId: string;
+    }, options?: WriteOptions): Promise<AoMessageResult>;
 }