@ar.io/sdk 3.24.0 → 4.0.0-solana.3

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

@@ -0,0 +1,387 @@
+/**
+ * Solana implementation of ANT (Arweave Name Token) read interface.
+ *
+ * Reads ANT state from Metaplex Core NFT + PDA accounts on Solana.
+ * Each ANT is a Metaplex Core NFT with extended state in PDAs:
+ *   - AntConfig: name, ticker, logo, description, keywords, owner
+ *   - AntControllers: list of controller pubkeys
+ *   - AntRecord: undername records (transactionId, ttl, priority, etc.)
+ */
+import { address, fetchEncodedAccount, } 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 { 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';
+import { ANT_RECORD_DISCRIMINATOR } from './generated/ant/accounts/antRecord.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';
+/**
+ * Solana-backed read-only client for a single ANT (Arweave Name Token).
+ *
+ * Usage:
+ * ```ts
+ * import { createSolanaRpc } from '@solana/kit';
+ * import { SolanaANTReadable } from '@ar.io/sdk/solana';
+ *
+ * const rpc = createSolanaRpc('https://api.mainnet-beta.solana.com');
+ * const ant = new SolanaANTReadable({
+ *   rpc,
+ *   processId: 'MetaplexCoreAssetAddress...',
+ * });
+ *
+ * const owner = await ant.getOwner();
+ * const record = await ant.getRecord({ undername: '@' });
+ * ```
+ */
+export class SolanaANTReadable {
+    processId;
+    rpc;
+    commitment;
+    logger;
+    antProgram;
+    mint;
+    /**
+     * Composed registry instance — the source of truth for the per-user
+     * paginated ACL (ADR-012). Sharing one instance across the read and
+     * write classes keeps program id / commitment / RPC configuration
+     * coherent for both `accessControlList` reads and the maintenance
+     * planner used during writes.
+     */
+    registry;
+    constructor(config) {
+        this.processId = config.processId;
+        this.rpc = config.rpc;
+        this.commitment = config.commitment ?? 'confirmed';
+        this.logger = config.logger ?? Logger.default;
+        this.antProgram = config.antProgramId ?? ARIO_ANT_PROGRAM_ID;
+        this.mint = address(config.processId);
+        this.registry =
+            config.registry ??
+                new SolanaANTRegistryReadable({
+                    rpc: this.rpc,
+                    commitment: this.commitment,
+                    logger: this.logger,
+                    antProgramId: this.antProgram,
+                });
+    }
+    /**
+     * Build a `SolanaANTReadable` whose program id is read from the
+     * asset's `ANT Program` Attributes-plugin entry (ADR-016 / BD-100).
+     *
+     * Falls back to the canonical `ARIO_ANT_PROGRAM_ID` when the asset
+     * has no plugin section, no `ANT Program` trait, or any layer of the
+     * walk fails to decode — matching the on-chain leniency in
+     * `programs/ario-core/src/mpl_core.rs::read_ant_program`. This is the
+     * factory resolution paths should reach for: it does the asset fetch
+     * once, hands the resulting program id to the constructor, and
+     * shares one `SolanaANTRegistryReadable` instance with the new ANT.
+     *
+     * Use the plain constructor when the program id is already known
+     * (e.g. inside a freshly-spawned ANT flow where you've just minted
+     * the asset and know the program you targeted).
+     */
+    static async fromAsset(config) {
+        const { fetchAntProgramFromAsset } = await import('./mpl-core.js');
+        const mint = address(config.processId);
+        const fromAsset = await fetchAntProgramFromAsset(config.rpc, mint, {
+            commitment: config.commitment ?? 'confirmed',
+        });
+        return new SolanaANTReadable({
+            rpc: config.rpc,
+            processId: config.processId,
+            commitment: config.commitment,
+            logger: config.logger,
+            antProgramId: fromAsset ?? ARIO_ANT_PROGRAM_ID,
+        });
+    }
+    async getAccount(pda) {
+        return fetchEncodedAccount(this.rpc, pda, {
+            commitment: this.commitment,
+        });
+    }
+    // =========================================
+    // Config reads
+    // =========================================
+    async fetchConfig() {
+        const [pda] = await getAntConfigPDA(this.mint, this.antProgram);
+        const account = await this.getAccount(pda);
+        if (!account.exists) {
+            throw new Error(`ANT config not found for ${this.processId}`);
+        }
+        return deserializeAntConfig(Buffer.from(account.data));
+    }
+    async fetchControllers() {
+        const [pda] = await getAntControllersPDA(this.mint, this.antProgram);
+        const account = await this.getAccount(pda);
+        if (!account.exists) {
+            return { mint: this.processId, controllers: [] };
+        }
+        return deserializeAntControllers(Buffer.from(account.data));
+    }
+    async getOwner(_opts) {
+        const config = await this.fetchConfig();
+        return config.owner;
+    }
+    /** Get the on-chain schema version of this ANT's config. */
+    async getConfigVersion() {
+        const config = await this.fetchConfig();
+        return config.version;
+    }
+    /** Check if this ANT needs a schema migration to the latest version. */
+    async needsMigration() {
+        const version = await this.getConfigVersion();
+        return version < ANT_CONFIG_VERSION;
+    }
+    async getName(_opts) {
+        const config = await this.fetchConfig();
+        return config.name;
+    }
+    async getTicker(_opts) {
+        const config = await this.fetchConfig();
+        return config.ticker;
+    }
+    async getLogo(_opts) {
+        const config = await this.fetchConfig();
+        return config.logo;
+    }
+    async getControllers() {
+        const data = await this.fetchControllers();
+        return data.controllers;
+    }
+    // =========================================
+    // Record reads
+    // =========================================
+    async getRecord({ undername }, _opts) {
+        const [[recordPda], [metaPda]] = await Promise.all([
+            getAntRecordPDA(this.mint, undername, this.antProgram),
+            getAntRecordMetadataPDA(this.mint, undername, this.antProgram),
+        ]);
+        const [recordAccount, metaAccount] = await Promise.all([
+            this.getAccount(recordPda),
+            this.getAccount(metaPda),
+        ]);
+        if (!recordAccount.exists)
+            return undefined;
+        const record = deserializeAntRecord(Buffer.from(recordAccount.data));
+        const meta = metaAccount.exists
+            ? deserializeAntRecordMetadata(Buffer.from(metaAccount.data))
+            : {};
+        return {
+            transactionId: record.transactionId,
+            targetProtocol: record.targetProtocol,
+            ttlSeconds: record.ttlSeconds,
+            priority: record.priority,
+            owner: record.owner,
+            displayName: meta.displayName,
+            logo: meta.logo,
+            description: meta.description,
+            keywords: meta.keywords,
+        };
+    }
+    async getRecords(_opts) {
+        // Fetch all AntRecord + AntRecordMetadata accounts for this mint in parallel.
+        const gpaFilter = (discriminator) => [
+            {
+                memcmp: {
+                    offset: 0n,
+                    bytes: discriminator,
+                    encoding: 'base58',
+                },
+            },
+            {
+                memcmp: {
+                    offset: 8n,
+                    bytes: this.mint,
+                    encoding: 'base58',
+                },
+            },
+        ];
+        const [recordAccounts, metaAccounts] = (await Promise.all([
+            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(),
+        ]));
+        // Index metadata by undername hash for O(1) lookup.
+        // AntRecordMetadata has undername_hash at offset 40 (8 disc + 32 mint).
+        const metaByHash = new Map();
+        for (const { account } of metaAccounts) {
+            try {
+                const buf = Buffer.from(account.data[0], 'base64');
+                const hash = buf.subarray(40, 72).toString('hex');
+                metaByHash.set(hash, deserializeAntRecordMetadata(buf));
+            }
+            catch {
+                // Skip malformed
+            }
+        }
+        const result = {};
+        let index = 0;
+        for (const { account } of recordAccounts) {
+            try {
+                const buf = Buffer.from(account.data[0], 'base64');
+                const record = deserializeAntRecord(buf);
+                const hash = __createHash('sha256')
+                    .update(record.undername.toLowerCase())
+                    .digest('hex');
+                const meta = metaByHash.get(hash) ?? {};
+                result[record.undername] = {
+                    transactionId: record.transactionId,
+                    targetProtocol: record.targetProtocol,
+                    ttlSeconds: record.ttlSeconds,
+                    priority: record.priority,
+                    owner: record.owner,
+                    displayName: meta.displayName,
+                    logo: meta.logo,
+                    description: meta.description,
+                    keywords: meta.keywords,
+                    index: index++,
+                };
+            }
+            catch {
+                // Skip malformed
+            }
+        }
+        return result;
+    }
+    // =========================================
+    // Balance reads (NFT model — owner has balance 1)
+    // =========================================
+    async getBalance({ address: queryAddress }, _opts) {
+        const config = await this.fetchConfig();
+        return config.owner === queryAddress ? 1 : 0;
+    }
+    async getBalances(_opts) {
+        const config = await this.fetchConfig();
+        return { [config.owner]: 1 };
+    }
+    // =========================================
+    // State / Info composites
+    // =========================================
+    async getState(_opts) {
+        const [config, controllersData, records] = await Promise.all([
+            this.fetchConfig(),
+            this.fetchControllers(),
+            this.getRecords(),
+        ]);
+        // Convert SortedANTRecords to ANTRecords (strip index)
+        const plainRecords = {};
+        for (const [key, val] of Object.entries(records)) {
+            const { index: _, ...record } = val;
+            plainRecords[key] = record;
+        }
+        return {
+            Name: config.name,
+            Ticker: config.ticker,
+            Description: config.description,
+            Keywords: config.keywords,
+            Denomination: 0,
+            Owner: config.owner,
+            Controllers: controllersData.controllers,
+            Records: plainRecords,
+            Balances: { [config.owner]: 1 },
+            Logo: config.logo,
+            TotalSupply: 1,
+            Initialized: true,
+        };
+    }
+    async getInfo(_opts) {
+        const config = await this.fetchConfig();
+        return {
+            Name: config.name,
+            Owner: config.owner,
+            Ticker: config.ticker,
+            'Total-Supply': '1',
+            Description: config.description,
+            Keywords: config.keywords,
+            Logo: config.logo,
+            Denomination: '0',
+            Handlers: [
+                'balance',
+                'balances',
+                'totalSupply',
+                'info',
+                'controllers',
+                'record',
+                'records',
+                'state',
+                'transfer',
+                'addController',
+                'removeController',
+                'setRecord',
+                'removeRecord',
+                'setName',
+                'setTicker',
+                'setDescription',
+                'setKeywords',
+                'setLogo',
+                'initializeState',
+                'releaseName',
+                'reassignName',
+                'approvePrimaryName',
+                'removePrimaryNames',
+                'transferRecordOwnership',
+                '_eval',
+                '_default',
+            ],
+        };
+    }
+    async getHandlers() {
+        // Solana ANT supports all standard handlers
+        return [
+            'balance',
+            'balances',
+            'totalSupply',
+            'info',
+            'controllers',
+            'record',
+            'records',
+            'state',
+            'transfer',
+            'addController',
+            'removeController',
+            'setRecord',
+            'removeRecord',
+            'setName',
+            'setTicker',
+            'setDescription',
+            'setKeywords',
+            'setLogo',
+            'initializeState',
+            'releaseName',
+            'reassignName',
+            'approvePrimaryName',
+            'removePrimaryNames',
+            'transferRecordOwnership',
+            '_eval',
+            '_default',
+        ];
+    }
+    async getModuleId(_opts) {
+        // Solana programs don't have module IDs — return the program address
+        return this.antProgram;
+    }
+    async getVersion(_opts) {
+        return '1.0.0-solana';
+    }
+    async isLatestVersion(_opts) {
+        return true;
+    }
+}

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

@@ -0,0 +1,118 @@
+/**
+ * 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
+ */
+/**
+ * Solana implementation of the ANT Registry read interface.
+ *
+ * Backed by the per-user paginated ACL (ADR-012): a head `AclConfig` PDA
+ * and N content-addressable `AclPage` PDAs, each holding up to
+ * `MAX_ACL_PAGE_ENTRIES` `(asset, role)` tuples. Frontends can fetch a
+ * user's ANTs in two RPC calls — one `getAccountInfo` for `AclConfig` plus
+ * one `getMultipleAccountsInfo` for every page — instead of a
+ * `getProgramAccounts` scan, a DAS provider, or a foundation-hosted
+ * indexer.
+ *
+ * Usage:
+ * ```ts
+ * import { createSolanaRpc } from '@solana/kit';
+ * import { ANTRegistry } from '@ar.io/sdk';
+ *
+ * const registry = ANTRegistry.init({
+ *   backend: 'solana',
+ *   rpc: createSolanaRpc('https://api.mainnet-beta.solana.com'),
+ * });
+ *
+ * const { Owned, Controlled } = await registry.accessControlList({
+ *   address: 'SomeSolanaWalletAddress...',
+ * });
+ * ```
+ *
+ * When a user has no on-chain `AclConfig` (never registered / not yet
+ * populated), both lists return empty. The write path (SDK ANT write
+ * methods + migration tooling) is responsible for keeping the ACL in sync
+ * as owners / controllers change.
+ */
+import { address } from '@solana/kit';
+import { Logger } from '../common/logger.js';
+import { ACL_ROLE_CONTROLLER, ACL_ROLE_OWNER, ARIO_ANT_PROGRAM_ID, } from './constants.js';
+import { deserializeAclConfig, deserializeAclPage } from './deserialize.js';
+import { getAccountInfoLegacy, getMultipleAccountsInfoLegacy, } from './json-rpc.js';
+import { getAclConfigPDA, getAclPagePDA } from './pda.js';
+export class SolanaANTRegistryReadable {
+    rpc;
+    commitment;
+    /** Deployed `ario-ant` program id this registry talks to. */
+    antProgram;
+    logger;
+    constructor(config) {
+        this.rpc = config.rpc;
+        this.commitment = config.commitment ?? 'confirmed';
+        this.antProgram = config.antProgramId ?? ARIO_ANT_PROGRAM_ID;
+        this.logger = config.logger ?? Logger.default;
+    }
+    /**
+     * Read a user's `AclConfig` head plus every `AclPage` and return owned +
+     * controlled ANT mint lists. Returns empty lists if the head PDA does not
+     * exist yet.
+     *
+     * **Note:** This is an eventually-consistent secondary index, not a
+     * canonical source of truth. Marketplace transfers update NFT ownership
+     * on-chain immediately but the ACL is only updated when someone calls
+     * `record_acl_owner` / `remove_acl_owner`. For real-time accuracy on a
+     * specific ANT, check the Metaplex Core asset owner directly.
+     */
+    async accessControlList({ address: addr, }) {
+        const userAddr = address(addr);
+        const [configPda] = await getAclConfigPDA(userAddr, this.antProgram);
+        this.logger.debug?.('Fetching AclConfig PDA', {
+            address: addr,
+            pda: configPda,
+        });
+        const configAccount = await getAccountInfoLegacy(this.rpc, configPda, this.commitment);
+        if (!configAccount) {
+            this.logger.debug?.('AclConfig not found — returning empty lists', {
+                address: addr,
+            });
+            return { Owned: [], Controlled: [] };
+        }
+        const config = deserializeAclConfig(configAccount.data);
+        if (config.pageCount === 0n) {
+            return { Owned: [], Controlled: [] };
+        }
+        // Derive every page PDA up-front, then load them in a single
+        // `getMultipleAccountsInfo` round trip.
+        const pageAddrs = [];
+        for (let i = 0n; i < config.pageCount; i++) {
+            const [pagePda] = await getAclPagePDA(userAddr, i, this.antProgram);
+            pageAddrs.push(pagePda);
+        }
+        const pageAccounts = await getMultipleAccountsInfoLegacy(this.rpc, pageAddrs, this.commitment);
+        const owned = [];
+        const controlled = [];
+        for (const acct of pageAccounts) {
+            if (!acct)
+                continue;
+            const page = deserializeAclPage(acct.data);
+            for (const entry of page.entries) {
+                if (entry.role === ACL_ROLE_OWNER)
+                    owned.push(entry.asset);
+                else if (entry.role === ACL_ROLE_CONTROLLER)
+                    controlled.push(entry.asset);
+            }
+        }
+        return { Owned: owned, Controlled: controlled };
+    }
+    /**
+     * Cleaner alias for `accessControlList` — matches the AO backend so
+     * consumers can switch backends without renaming calls.
+     */
+    async getAntsForAddress({ address, }) {
+        return this.accessControlList({ address });
+    }
+}