@ar.io/sdk 4.0.0-solana.8 → 4.0.0

package/lib/esm/constants.js

@@ -29,22 +29,4 @@ export function arweaveUri(txIdOrName) {
 }
 /** FQDN regex that matches the one used in the ArNS contract. */
 export const FQDN_REGEX = new RegExp('^(?:(?!-)[A-Za-z0-9-]{1,63}(?<!-)\\.)+[A-Za-z]{1,63}$');
-export const ARIO_DEVNET_PROCESS_ID = 'GaQrvEMKBpkjofgnBi_B3IgIDmY_XYelVLB6GcRGrHc';
-// backwards compatibility - TODO: remove in v2.0.0
-export const arioDevnetProcessId = ARIO_DEVNET_PROCESS_ID;
-export const ARIO_TESTNET_PROCESS_ID = 'agYcCFJtrMG6cqMuZfskIkFTGvUPddICmtQSBIoPdiA';
-export const ARIO_MAINNET_PROCESS_ID = 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE';
-export const ANT_REGISTRY_TESTNET_ID = 'RR0vheYqtsKuJCWh6xj0beE35tjaEug5cejMw9n2aa8';
-export const ANT_REGISTRY_ID = 'i_le_yKKPVstLTDSmkHRqf-wYphMnwB9OhleiTgMkWc';
-export const MARKETPLACE_CONTRACT_ID = 'wPh88ziUF4meLpHfffmgdA6IFtzmXHgdeg-epzBjkao';
 export const MARIO_PER_ARIO = 1_000_000;
-/**
- * @deprecated - use ANT.versions.getLatestANTVersion() to get latest ANT module
- **/
-export const AOS_MODULE_ID = 'nEjlSFA_8narJlVHApbczDPkMc9znSqYtqtf1iOdoxM';
-/**
- * @deprecated - use ANT.versions.getLatestANTVersion() to get latest ANT module
- **/
-export const ANT_LUA_ID = 'sOW9Sdm1yoPRrzerC5iu1nsupp4e6I-HnJyYVHzvzQo';
-export const AO_AUTHORITY = 'fcoN_xJeisVsPXA-trzVAuIiqO3ydLQxM-L4XbrQKzY';
-export const DEFAULT_SCHEDULER_ID = '_GQ33BkPtZrqxA84vM8Zk-N2aO0toNNu_C-l-rawrBA';

package/lib/esm/solana/ant-readable.js

@@ -1,3 +1,18 @@
+/**
+ * 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.
+ */
 /**
  * Solana implementation of ANT (Arweave Name Token) read interface.
  *
@@ -7,21 +22,15 @@
  *   - AntControllers: list of controller pubkeys
  *   - AntRecord: undername records (transactionId, ttl, priority, etc.)
  */
-import { address, fetchEncodedAccount, } from '@solana/kit';
+import { address, fetchEncodedAccount, fetchEncodedAccounts, } from '@solana/kit';
 import bs58 from 'bs58';
-// AntRecordMetadata discriminator — regenerate via `yarn codegen` after IDL rebase
-// to expose ANT_RECORD_METADATA_DISCRIMINATOR. Until then, compute inline.
 import { createHash as __createHash } from 'crypto';
-import { ANT_RECORD_DISCRIMINATOR } from '@ar.io/solana-contracts/ant';
+import { ANT_RECORD_DISCRIMINATOR, ANT_RECORD_METADATA_DISCRIMINATOR, decodeAntConfig, decodeAntControllers, getAntRecordDecoder, getAntRecordMetadataDecoder, } from '@ar.io/solana-contracts/ant';
 import { Logger } from '../common/logger.js';
 import { SolanaANTRegistryReadable } from './ant-registry-readable.js';
 import { ANT_CONFIG_VERSION, ARIO_ANT_PROGRAM_ID } from './constants.js';
-import { deserializeAntConfig, deserializeAntControllers, deserializeAntRecord, deserializeAntRecordMetadata, } from './deserialize.js';
-const ANT_RECORD_METADATA_DISCRIMINATOR = new Uint8Array(__createHash('sha256')
-    .update('account:AntRecordMetadata')
-    .digest()
-    .subarray(0, 8));
 import { getAntConfigPDA, getAntControllersPDA, getAntRecordMetadataPDA, getAntRecordPDA, } from './pda.js';
+import { withRetry } from './retry.js';
 /**
  * Solana-backed read-only client for a single ANT (Arweave Name Token).
  *
@@ -102,9 +111,9 @@ export class SolanaANTReadable {
         });
     }
     async getAccount(pda) {
-        return fetchEncodedAccount(this.rpc, pda, {
+        return withRetry(() => fetchEncodedAccount(this.rpc, pda, {
             commitment: this.commitment,
-        });
+        }));
     }
     // =========================================
     // Config reads
@@ -115,7 +124,17 @@ export class SolanaANTReadable {
         if (!account.exists) {
             throw new Error(`ANT config not found for ${this.processId}`);
         }
-        return deserializeAntConfig(Buffer.from(account.data));
+        const decoded = decodeAntConfig(account).data;
+        return {
+            mint: decoded.mint,
+            name: decoded.name,
+            ticker: decoded.ticker,
+            logo: decoded.logo,
+            description: decoded.description,
+            keywords: decoded.keywords,
+            owner: decoded.lastKnownOwner,
+            version: decoded.version.major,
+        };
     }
     async fetchControllers() {
         const [pda] = await getAntControllersPDA(this.mint, this.antProgram);
@@ -123,7 +142,43 @@ export class SolanaANTReadable {
         if (!account.exists) {
             return { mint: this.processId, controllers: [] };
         }
-        return deserializeAntControllers(Buffer.from(account.data));
+        const decoded = decodeAntControllers(account).data;
+        return {
+            mint: decoded.mint,
+            controllers: decoded.controllers.map((c) => c),
+        };
+    }
+    /**
+     * Fetch AntConfig + AntControllers in a single `getMultipleAccounts` round
+     * trip (instead of two single-account reads). Used by `getState` to shave one
+     * RPC per ANT — meaningful when a UI loads many ANTs.
+     */
+    async _fetchConfigAndControllers() {
+        const [[configPda], [controllersPda]] = await Promise.all([
+            getAntConfigPDA(this.mint, this.antProgram),
+            getAntControllersPDA(this.mint, this.antProgram),
+        ]);
+        const [configAccount, controllersAccount] = await withRetry(() => fetchEncodedAccounts(this.rpc, [configPda, controllersPda], {
+            commitment: this.commitment,
+        }));
+        if (!configAccount.exists) {
+            throw new Error(`ANT config not found for ${this.processId}`);
+        }
+        const decodedConfig = decodeAntConfig(configAccount).data;
+        const config = {
+            mint: decodedConfig.mint,
+            name: decodedConfig.name,
+            ticker: decodedConfig.ticker,
+            logo: decodedConfig.logo,
+            description: decodedConfig.description,
+            keywords: decodedConfig.keywords,
+            owner: decodedConfig.lastKnownOwner,
+            version: decodedConfig.version.major,
+        };
+        const controllers = controllersAccount.exists
+            ? decodeAntControllers(controllersAccount).data.controllers.map((c) => c)
+            : [];
+        return { config, controllers };
     }
     async getOwner(_opts) {
         const config = await this.fetchConfig();
@@ -163,30 +218,47 @@ export class SolanaANTReadable {
             getAntRecordPDA(this.mint, undername, this.antProgram),
             getAntRecordMetadataPDA(this.mint, undername, this.antProgram),
         ]);
-        const [recordAccount, metaAccount] = await Promise.all([
-            this.getAccount(recordPda),
-            this.getAccount(metaPda),
-        ]);
+        const [recordAccount, metaAccount] = await withRetry(() => fetchEncodedAccounts(this.rpc, [recordPda, metaPda], {
+            commitment: this.commitment,
+        }));
         if (!recordAccount.exists)
             return undefined;
-        const record = deserializeAntRecord(Buffer.from(recordAccount.data));
+        const recordDecoder = getAntRecordDecoder();
+        const metaDecoder = getAntRecordMetadataDecoder();
+        const record = recordDecoder.decode(new Uint8Array(recordAccount.data));
         const meta = metaAccount.exists
-            ? deserializeAntRecordMetadata(Buffer.from(metaAccount.data))
-            : {};
+            ? metaDecoder.decode(new Uint8Array(metaAccount.data))
+            : undefined;
         return {
-            transactionId: record.transactionId,
+            transactionId: record.target,
             targetProtocol: record.targetProtocol,
             ttlSeconds: record.ttlSeconds,
-            priority: record.priority,
-            owner: record.owner,
-            displayName: meta.displayName,
-            logo: meta.logo,
-            description: meta.description,
-            keywords: meta.keywords,
+            priority: record.priority?.__option === 'Some'
+                ? record.priority.value
+                : undefined,
+            owner: record.owner?.__option === 'Some'
+                ? record.owner.value
+                : undefined,
+            displayName: meta?.displayName?.__option === 'Some'
+                ? meta.displayName.value
+                : undefined,
+            logo: meta?.recordLogo?.__option === 'Some'
+                ? meta.recordLogo.value
+                : undefined,
+            description: meta?.recordDescription?.__option === 'Some'
+                ? meta.recordDescription.value
+                : undefined,
+            keywords: meta?.recordKeywords?.__option === 'Some'
+                ? meta.recordKeywords.value
+                : undefined,
         };
     }
-    async getRecords(_opts) {
-        // Fetch all AntRecord + AntRecordMetadata accounts for this mint in parallel.
+    async getRecords(opts) {
+        // Fetch all AntRecord accounts for this mint. AntRecordMetadata
+        // (displayName/logo/description/keywords) is a SECOND program scan and is
+        // only needed in detail/edit views, so skip it unless `includeMetadata` is
+        // set — halving the per-ANT request cost on list reads. See AntReadOptions.
+        const includeMetadata = opts?.includeMetadata === true;
         const gpaFilter = (discriminator) => [
             {
                 memcmp: {
@@ -204,21 +276,25 @@ export class SolanaANTReadable {
             },
         ];
         const [recordAccounts, metaAccounts] = (await Promise.all([
-            this.rpc
+            withRetry(() => this.rpc
                 .getProgramAccounts(this.antProgram, {
                 commitment: this.commitment,
                 encoding: 'base64',
                 filters: gpaFilter(bs58.encode(ANT_RECORD_DISCRIMINATOR)),
             })
-                .send(),
-            this.rpc
-                .getProgramAccounts(this.antProgram, {
-                commitment: this.commitment,
-                encoding: 'base64',
-                filters: gpaFilter(bs58.encode(ANT_RECORD_METADATA_DISCRIMINATOR)),
-            })
-                .send(),
+                .send()),
+            includeMetadata
+                ? withRetry(() => this.rpc
+                    .getProgramAccounts(this.antProgram, {
+                    commitment: this.commitment,
+                    encoding: 'base64',
+                    filters: gpaFilter(bs58.encode(ANT_RECORD_METADATA_DISCRIMINATOR)),
+                })
+                    .send())
+                : Promise.resolve([]),
         ]));
+        const recordDecoder = getAntRecordDecoder();
+        const metaDecoder = getAntRecordMetadataDecoder();
         // Index metadata by undername hash for O(1) lookup.
         // AntRecordMetadata has undername_hash at offset 40 (8 disc + 32 mint).
         const metaByHash = new Map();
@@ -226,7 +302,7 @@ export class SolanaANTReadable {
             try {
                 const buf = Buffer.from(account.data[0], 'base64');
                 const hash = buf.subarray(40, 72).toString('hex');
-                metaByHash.set(hash, deserializeAntRecordMetadata(buf));
+                metaByHash.set(hash, metaDecoder.decode(new Uint8Array(buf)));
             }
             catch {
                 // Skip malformed
@@ -237,21 +313,33 @@ export class SolanaANTReadable {
         for (const { account } of recordAccounts) {
             try {
                 const buf = Buffer.from(account.data[0], 'base64');
-                const record = deserializeAntRecord(buf);
+                const record = recordDecoder.decode(new Uint8Array(buf));
                 const hash = __createHash('sha256')
                     .update(record.undername.toLowerCase())
                     .digest('hex');
-                const meta = metaByHash.get(hash) ?? {};
+                const meta = metaByHash.get(hash);
                 result[record.undername] = {
-                    transactionId: record.transactionId,
+                    transactionId: record.target,
                     targetProtocol: record.targetProtocol,
                     ttlSeconds: record.ttlSeconds,
-                    priority: record.priority,
-                    owner: record.owner,
-                    displayName: meta.displayName,
-                    logo: meta.logo,
-                    description: meta.description,
-                    keywords: meta.keywords,
+                    priority: record.priority?.__option === 'Some'
+                        ? record.priority.value
+                        : undefined,
+                    owner: record.owner?.__option === 'Some'
+                        ? record.owner.value
+                        : undefined,
+                    displayName: meta?.displayName?.__option === 'Some'
+                        ? meta.displayName.value
+                        : undefined,
+                    logo: meta?.recordLogo?.__option === 'Some'
+                        ? meta.recordLogo.value
+                        : undefined,
+                    description: meta?.recordDescription?.__option === 'Some'
+                        ? meta.recordDescription.value
+                        : undefined,
+                    keywords: meta?.recordKeywords?.__option === 'Some'
+                        ? meta.recordKeywords.value
+                        : undefined,
                     index: index++,
                 };
             }
@@ -261,6 +349,256 @@ export class SolanaANTReadable {
         }
         return result;
     }
+    /**
+     * Bulk-load lightweight {@link ANTSummary} state for many ANTs in a handful
+     * of `getMultipleAccounts` calls instead of `N × getState`. For each mint it
+     * batches AntConfig + AntControllers + the apex (`@`) AntRecord — everything a
+     * portfolio/names table needs. Full undername records are NOT loaded here;
+     * fetch them lazily per-ANT via {@link getRecords}/{@link getState} when a
+     * name is opened.
+     *
+     * Requests: ~`ceil(3N / 100)` calls for N mints (10 → 1, 250 → 8), versus
+     * ~`4N` with per-ANT `getState`. Assumes every mint is deployed under this
+     * instance's `antProgram` (true for the standard AR.IO ANT program).
+     *
+     * Mints whose AntConfig doesn't exist are omitted from the result.
+     */
+    async getANTSummaries(mints) {
+        const unique = Array.from(new Set(mints));
+        if (unique.length === 0)
+            return {};
+        // Derive config + controllers + apex('@') record PDAs for every mint.
+        const triples = await Promise.all(unique.map(async (m) => {
+            const mintAddr = address(m);
+            const [[configPda], [controllersPda], [apexPda]] = await Promise.all([
+                getAntConfigPDA(mintAddr, this.antProgram),
+                getAntControllersPDA(mintAddr, this.antProgram),
+                getAntRecordPDA(mintAddr, '@', this.antProgram),
+            ]);
+            return { mint: m, configPda, controllersPda, apexPda };
+        }));
+        // Batch-fetch all PDAs (3 per mint) — getMultipleAccounts caps at 100.
+        const allPdas = triples.flatMap((t) => [
+            t.configPda,
+            t.controllersPda,
+            t.apexPda,
+        ]);
+        const accounts = [];
+        for (let i = 0; i < allPdas.length; i += 100) {
+            const chunk = allPdas.slice(i, i + 100);
+            const res = await withRetry(() => fetchEncodedAccounts(this.rpc, chunk, { commitment: this.commitment }));
+            accounts.push(...res);
+        }
+        const recordDecoder = getAntRecordDecoder();
+        const result = {};
+        for (let i = 0; i < triples.length; i++) {
+            const { mint } = triples[i];
+            const configAccount = accounts[i * 3];
+            const controllersAccount = accounts[i * 3 + 1];
+            const apexAccount = accounts[i * 3 + 2];
+            if (!configAccount?.exists)
+                continue;
+            const config = decodeAntConfig(configAccount).data;
+            const controllers = controllersAccount?.exists
+                ? decodeAntControllers(controllersAccount).data.controllers.map((c) => c)
+                : [];
+            let apexRecord;
+            if (apexAccount?.exists) {
+                const rec = recordDecoder.decode(new Uint8Array(apexAccount.data));
+                apexRecord = {
+                    transactionId: rec.target,
+                    targetProtocol: rec.targetProtocol,
+                    ttlSeconds: rec.ttlSeconds,
+                    priority: rec.priority?.__option === 'Some' ? rec.priority.value : undefined,
+                    owner: rec.owner?.__option === 'Some'
+                        ? rec.owner.value
+                        : undefined,
+                };
+            }
+            result[mint] = {
+                processId: mint,
+                name: config.name,
+                ticker: config.ticker,
+                logo: config.logo,
+                description: config.description,
+                keywords: config.keywords,
+                owner: config.lastKnownOwner,
+                controllers,
+                apexRecord,
+            };
+        }
+        return result;
+    }
+    /**
+     * Bulk-load FULL {@link ANTState} (including all undername records) for many
+     * ANTs in a handful of calls instead of `N × getState`:
+     *   - AntConfig + AntControllers for every mint via `getMultipleAccounts`
+     *     (chunked at 100), and
+     *   - ALL undername records via a SINGLE program-wide `getProgramAccounts`
+     *     scan grouped by mint (offset 8), instead of one mint-filtered scan per
+     *     ANT.
+     *
+     * Requests: ~`ceil(2N / 100) + 1` (+1 when `includeMetadata`) regardless of
+     * N — e.g. 10 ANTs → 2 calls, 250 → ~6 — versus ~`2N` with per-ANT
+     * `getState`. The records scan reads every ANT's records program-wide (cheap
+     * per account, one round trip); prefer per-ANT {@link getState} when you only
+     * need one ANT. Mints with no AntConfig are omitted.
+     */
+    async getANTStates(mints, opts) {
+        const unique = Array.from(new Set(mints));
+        if (unique.length === 0)
+            return {};
+        // Config + controllers PDAs for every mint, batched (100 accounts/call).
+        const pairs = await Promise.all(unique.map(async (m) => {
+            const mintAddr = address(m);
+            const [[configPda], [controllersPda]] = await Promise.all([
+                getAntConfigPDA(mintAddr, this.antProgram),
+                getAntControllersPDA(mintAddr, this.antProgram),
+            ]);
+            return { mint: m, configPda, controllersPda };
+        }));
+        const allPdas = pairs.flatMap((p) => [p.configPda, p.controllersPda]);
+        const accounts = [];
+        for (let i = 0; i < allPdas.length; i += 100) {
+            const res = await withRetry(() => fetchEncodedAccounts(this.rpc, allPdas.slice(i, i + 100), {
+                commitment: this.commitment,
+            }));
+            accounts.push(...res);
+        }
+        const recordsByMint = await this._recordsByMint(opts?.includeMetadata === true);
+        const result = {};
+        for (let i = 0; i < pairs.length; i++) {
+            const { mint } = pairs[i];
+            const configAccount = accounts[i * 2];
+            const controllersAccount = accounts[i * 2 + 1];
+            if (!configAccount?.exists)
+                continue;
+            const config = decodeAntConfig(configAccount).data;
+            const controllers = controllersAccount?.exists
+                ? decodeAntControllers(controllersAccount).data.controllers.map((c) => c)
+                : [];
+            const sorted = recordsByMint.get(mint) ?? {};
+            const plainRecords = {};
+            for (const [key, val] of Object.entries(sorted)) {
+                const { index: _, ...rec } = val;
+                plainRecords[key] = rec;
+            }
+            const owner = config.lastKnownOwner;
+            result[mint] = {
+                Name: config.name,
+                Ticker: config.ticker,
+                Description: config.description,
+                Keywords: config.keywords,
+                Denomination: 0,
+                Owner: owner,
+                Controllers: controllers,
+                Records: plainRecords,
+                Balances: { [owner]: 1 },
+                Logo: config.logo,
+                TotalSupply: 1,
+                Initialized: true,
+            };
+        }
+        return result;
+    }
+    /**
+     * Group every AntRecord (+ optional metadata) in the program by mint via a
+     * single `getProgramAccounts` scan (the mint sits at offset 8). Used by
+     * {@link getANTStates} to load all ANTs' undername records in one round trip
+     * instead of one mint-filtered scan per ANT.
+     */
+    async _recordsByMint(includeMetadata) {
+        const discFilter = (discriminator) => [
+            {
+                memcmp: {
+                    offset: 0n,
+                    bytes: discriminator,
+                    encoding: 'base58',
+                },
+            },
+        ];
+        const [recordAccounts, metaAccounts] = (await Promise.all([
+            withRetry(() => this.rpc
+                .getProgramAccounts(this.antProgram, {
+                commitment: this.commitment,
+                encoding: 'base64',
+                filters: discFilter(bs58.encode(ANT_RECORD_DISCRIMINATOR)),
+            })
+                .send()),
+            includeMetadata
+                ? withRetry(() => this.rpc
+                    .getProgramAccounts(this.antProgram, {
+                    commitment: this.commitment,
+                    encoding: 'base64',
+                    filters: discFilter(bs58.encode(ANT_RECORD_METADATA_DISCRIMINATOR)),
+                })
+                    .send())
+                : Promise.resolve([]),
+        ]));
+        const recordDecoder = getAntRecordDecoder();
+        const metaDecoder = getAntRecordMetadataDecoder();
+        // Metadata keyed by `${mint}:${undernameHash}` (mint at 8, hash at 40).
+        const metaByKey = new Map();
+        for (const { account } of metaAccounts) {
+            try {
+                const buf = Buffer.from(account.data[0], 'base64');
+                const mint = bs58.encode(buf.subarray(8, 40));
+                const hash = buf.subarray(40, 72).toString('hex');
+                metaByKey.set(`${mint}:${hash}`, metaDecoder.decode(new Uint8Array(buf)));
+            }
+            catch {
+                // Skip malformed
+            }
+        }
+        const byMint = new Map();
+        const indexByMint = new Map();
+        for (const { account } of recordAccounts) {
+            try {
+                const buf = Buffer.from(account.data[0], 'base64');
+                const mint = bs58.encode(buf.subarray(8, 40));
+                const record = recordDecoder.decode(new Uint8Array(buf));
+                const hash = __createHash('sha256')
+                    .update(record.undername.toLowerCase())
+                    .digest('hex');
+                const meta = metaByKey.get(`${mint}:${hash}`);
+                const idx = indexByMint.get(mint) ?? 0;
+                let bucket = byMint.get(mint);
+                if (!bucket) {
+                    bucket = {};
+                    byMint.set(mint, bucket);
+                }
+                bucket[record.undername] = {
+                    transactionId: record.target,
+                    targetProtocol: record.targetProtocol,
+                    ttlSeconds: record.ttlSeconds,
+                    priority: record.priority?.__option === 'Some'
+                        ? record.priority.value
+                        : undefined,
+                    owner: record.owner?.__option === 'Some'
+                        ? record.owner.value
+                        : undefined,
+                    displayName: meta?.displayName?.__option === 'Some'
+                        ? meta.displayName.value
+                        : undefined,
+                    logo: meta?.recordLogo?.__option === 'Some'
+                        ? meta.recordLogo.value
+                        : undefined,
+                    description: meta?.recordDescription?.__option === 'Some'
+                        ? meta.recordDescription.value
+                        : undefined,
+                    keywords: meta?.recordKeywords?.__option === 'Some'
+                        ? meta.recordKeywords.value
+                        : undefined,
+                    index: idx,
+                };
+                indexByMint.set(mint, idx + 1);
+            }
+            catch {
+                // Skip malformed
+            }
+        }
+        return byMint;
+    }
     // =========================================
     // Balance reads (NFT model — owner has balance 1)
     // =========================================
@@ -275,11 +613,10 @@ export class SolanaANTReadable {
     // =========================================
     // State / Info composites
     // =========================================
-    async getState(_opts) {
-        const [config, controllersData, records] = await Promise.all([
-            this.fetchConfig(),
-            this.fetchControllers(),
-            this.getRecords(),
+    async getState(opts) {
+        const [{ config, controllers }, records] = await Promise.all([
+            this._fetchConfigAndControllers(),
+            this.getRecords(opts),
         ]);
         // Convert SortedANTRecords to ANTRecords (strip index)
         const plainRecords = {};
@@ -294,7 +631,7 @@ export class SolanaANTReadable {
             Keywords: config.keywords,
             Denomination: 0,
             Owner: config.owner,
-            Controllers: controllersData.controllers,
+            Controllers: controllers,
             Records: plainRecords,
             Balances: { [config.owner]: 1 },
             Logo: config.logo,

package/lib/esm/solana/ant-registry-readable.js

@@ -1,3 +1,18 @@
+/**
+ * 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.
+ */
 /**
  * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
  *

package/lib/esm/solana/ant-registry-writeable.js

@@ -1,3 +1,18 @@
+/**
+ * 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.
+ */
 /**
  * Solana implementation of the ANT Registry write interface.
  *
@@ -38,7 +53,7 @@
  * registry's signer) acts as the rent payer for everything bundled here.
  */
 import { address, } from '@solana/kit';
-import { getAddAclPageInstruction, getCloseAclConfigInstruction, getCloseAclPageInstruction, getRecordAclControllerInstructionAsync, getRecordAclOwnerInstruction, getRegisterAclConfigInstruction, getRemoveAclControllerInstructionAsync, getRemoveAclOwnerInstruction, } from '@ar.io/solana-contracts/ant';
+import { getAddAclPageInstruction, getCloseAclConfigInstruction, getCloseAclPageInstruction, getRecordAclControllerInstructionAsync, getRecordAclOwnerInstructionAsync, getRegisterAclConfigInstruction, getRemoveAclControllerInstructionAsync, getRemoveAclOwnerInstructionAsync, } from '@ar.io/solana-contracts/ant';
 import { SolanaANTRegistryReadable, } from './ant-registry-readable.js';
 import { ACL_ROLE_CONTROLLER, ACL_ROLE_OWNER, MAX_ACL_PAGE_ENTRIES, } from './constants.js';
 import { deserializeAclConfig, deserializeAclPage } from './deserialize.js';
@@ -63,7 +78,7 @@ export class SolanaANTRegistryWriteable extends SolanaANTRegistryReadable {
      * `AclConfig` is created lazily the first time a user becomes an owner
      * or controller (via `register_acl_config`, which `planAclMaintenance`
      * emits automatically). This method exists only to satisfy the
-     * cross-backend `AoANTRegistryWrite` interface.
+     * cross-backend `ANTRegistryWrite` interface.
      */
     async register(_params) {
         return { id: '' };
@@ -189,7 +204,7 @@ export class SolanaANTRegistryWriteable extends SolanaANTRegistryReadable {
         const [aclConfig] = await getAclConfigPDA(params.user, this.antProgram);
         const [aclPage] = await getAclPagePDA(params.user, params.pageIdx, this.antProgram);
         if (params.role === 'owner') {
-            return getRecordAclOwnerInstruction({ asset: params.asset, aclConfig, aclPage, payer: this.signer }, { programAddress: this.antProgram });
+            return getRecordAclOwnerInstructionAsync({ asset: params.asset, aclConfig, aclPage, payer: this.signer }, { programAddress: this.antProgram });
         }
         return getRecordAclControllerInstructionAsync({ asset: params.asset, aclConfig, aclPage, payer: this.signer }, { programAddress: this.antProgram });
     }
@@ -198,7 +213,7 @@ export class SolanaANTRegistryWriteable extends SolanaANTRegistryReadable {
         const [aclConfig] = await getAclConfigPDA(params.user, this.antProgram);
         const [aclPage] = await getAclPagePDA(params.user, params.pageIdx, this.antProgram);
         if (params.role === 'owner') {
-            return getRemoveAclOwnerInstruction({ asset: params.asset, aclConfig, aclPage, payer: this.signer }, { programAddress: this.antProgram });
+            return getRemoveAclOwnerInstructionAsync({ asset: params.asset, aclConfig, aclPage, payer: this.signer }, { programAddress: this.antProgram });
         }
         return getRemoveAclControllerInstructionAsync({ asset: params.asset, aclConfig, aclPage, payer: this.signer }, { programAddress: this.antProgram });
     }