@ar.io/sdk 4.0.0-solana.9 → 4.0.1

package/lib/esm/cli/utils.js

@@ -14,13 +14,17 @@
  * limitations under the License.
  */
 import { readFileSync } from 'fs';
-import { EthereumSigner } from '@dha-team/arbundles';
-import { connect } from '@permaweb/aoconnect';
-import { address, createKeyPairSignerFromBytes, createSolanaRpc, createSolanaRpcSubscriptions, } from '@solana/kit';
+import { address, createKeyPairSignerFromBytes, createSolanaRpcSubscriptions, } from '@solana/kit';
 import bs58 from 'bs58';
 import { program } from 'commander';
 import prompts from 'prompts';
-import { ANT, ANTRegistry, ANT_REGISTRY_ID, ANT_REGISTRY_TESTNET_ID, AOProcess, ARIO, ARIOToken, ARIO_DEVNET_PROCESS_ID, ARIO_MAINNET_PROCESS_ID, ARIO_TESTNET_PROCESS_ID, ArweaveSigner, Logger, createAoSigner, fromB64Url, fundFromOptions, initANTStateForAddress, isValidFundFrom, isValidIntent, mARIOToken, sha256B64Url, validIntents, } from '../node/index.js';
+import { ANTRegistry } from '../common/ant-registry.js';
+import { ANT } from '../common/ant.js';
+import { ARIO } from '../common/io.js';
+import { Logger } from '../common/logger.js';
+import { createCircuitBreakerRpc, defaultFallbackUrl, } from '../solana/rpc-circuit-breaker.js';
+import { fundFromOptions, isValidFundFrom, isValidIntent, validIntents, } from '../types/io.js';
+import { ARIOToken, mARIOToken } from '../types/token.js';
 import { globalOptions } from './options.js';
 export const defaultTtlSecondsCLI = 3600;
 export function stringifyJsonForCLIDisplay(json) {
@@ -68,46 +72,6 @@ export function makeCommand({ description, name, options = [], action, }) {
     }
     return appliedCommand;
 }
-export function arioProcessIdFromOptions({ arioProcessId, devnet, testnet, }) {
-    if (arioProcessId !== undefined) {
-        return arioProcessId;
-    }
-    if (devnet) {
-        return ARIO_DEVNET_PROCESS_ID;
-    }
-    if (testnet) {
-        return ARIO_TESTNET_PROCESS_ID;
-    }
-    return ARIO_MAINNET_PROCESS_ID;
-}
-export function antRegistryIdFromOptions({ antRegistryProcessId, testnet, }) {
-    if (antRegistryProcessId !== undefined) {
-        return antRegistryProcessId;
-    }
-    if (testnet) {
-        return ANT_REGISTRY_TESTNET_ID;
-    }
-    return ANT_REGISTRY_ID;
-}
-function walletFromOptions({ privateKey, walletFile, }) {
-    if (privateKey !== undefined) {
-        return JSON.parse(privateKey);
-    }
-    if (walletFile !== undefined) {
-        return JSON.parse(readFileSync(walletFile, 'utf-8'));
-    }
-    return undefined;
-}
-export function requiredJwkFromOptions(options) {
-    const jwk = walletFromOptions(options);
-    if (jwk === undefined) {
-        throw new Error('No JWK provided for signing!\nPlease provide a stringified JWK with `--private-key` or the file path of a jwk.json file with `--wallet-file`');
-    }
-    return jwk;
-}
-export function jwkToAddress(jwk) {
-    return sha256B64Url(fromB64Url(jwk.n));
-}
 function setLoggerIfDebug(options) {
     if (options.debug) {
         Logger.default.setLogLevel('debug');
@@ -117,31 +81,11 @@ export function getLoggerFromOptions(options) {
     setLoggerIfDebug(options);
     return Logger.default;
 }
-function aoProcessFromOptions(options) {
-    return new AOProcess({
-        processId: arioProcessIdFromOptions(options),
-        ao: connect({
-            MODE: 'legacy',
-            CU_URL: options.cuUrl,
-        }),
-    });
-}
 export function readARIOFromOptions(options) {
     setLoggerIfDebug(options);
-    if (options.ao) {
-        return ARIO.init({
-            hyperbeamUrl: options.hyperbeamUrl,
-            process: aoProcessFromOptions({
-                cuUrl: 'http://localhost:6363',
-                ...options,
-            }),
-            paymentUrl: options.paymentUrl,
-        });
-    }
     const rpcUrl = options.rpcUrl ?? 'https://api.mainnet-beta.solana.com';
     return ARIO.init({
-        backend: 'solana',
-        rpc: createSolanaRpc(rpcUrl),
+        rpc: createCliRpc(rpcUrl),
         ...(options.coreProgramId
             ? { coreProgramId: address(options.coreProgramId) }
             : {}),
@@ -155,46 +99,14 @@ export function readARIOFromOptions(options) {
 }
 export async function readANTRegistryFromOptions(options) {
     setLoggerIfDebug(options);
-    if (options.ao) {
-        return ANTRegistry.init({
-            process: aoProcessFromOptions(options),
-            hyperbeamUrl: options.hyperbeamUrl,
-        });
-    }
     const rpcUrl = options.rpcUrl ?? 'https://api.mainnet-beta.solana.com';
     return ANTRegistry.init({
-        backend: 'solana',
-        rpc: createSolanaRpc(rpcUrl),
+        rpc: createCliRpc(rpcUrl),
         ...(options.antProgramId
             ? { antProgramId: address(options.antProgramId) }
             : {}),
     });
 }
-export function contractSignerFromOptions(options) {
-    const wallet = walletFromOptions(options);
-    if (wallet === undefined) {
-        return undefined;
-    }
-    const token = options.token ?? 'arweave';
-    if (token === 'ethereum') {
-        const signer = new EthereumSigner(wallet);
-        // For EthereumSigner, we need to convert the JWK to a string
-        return { signer, signerAddress: signer.publicKey.toString('hex') };
-    }
-    // TODO: Support other wallet types
-    const signer = new ArweaveSigner(wallet);
-    return { signer, signerAddress: jwkToAddress(wallet) };
-}
-export function requiredContractSignerFromOptions(options) {
-    const contractSigner = contractSignerFromOptions(options);
-    if (contractSigner === undefined) {
-        throw new Error('No signer provided for signing!\nPlease provide a stringified JWK or Ethereum private key with `--private-key` or the file path of an arweave.jwk.json or eth.private.key.txt file with `--wallet-file`');
-    }
-    return contractSigner;
-}
-export function requiredAoSignerFromOptions(options) {
-    return createAoSigner(requiredContractSignerFromOptions(options).signer);
-}
 /** Derive a WS URL from an HTTP/HTTPS RPC URL by swapping the scheme. */
 function wsUrlFromRpcUrl(rpcUrl) {
     // Surfpool and `solana-test-validator` follow Solana's well-known localhost
@@ -218,6 +130,16 @@ function wsUrlFromRpcUrl(rpcUrl) {
     url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
     return url.toString().replace(/\/$/, '');
 }
+/**
+ * Create a {@link SolanaRpc} wrapped with a circuit-breaker that falls back to
+ * the cluster's public RPC when the primary endpoint becomes unhealthy.
+ */
+function createCliRpc(rpcUrl) {
+    return createCircuitBreakerRpc({
+        primaryUrl: rpcUrl,
+        fallbackUrl: defaultFallbackUrl(rpcUrl),
+    });
+}
 /**
  * Load a Solana KeyPairSigner from --private-key (base58) or --wallet-file
  * (JSON array of bytes). Throws with a helpful message if neither is set.
@@ -240,29 +162,15 @@ async function loadSolanaSignerFromOptions(options) {
 }
 export async function writeARIOFromOptions(options) {
     setLoggerIfDebug(options);
-    if (options.ao) {
-        const { signer, signerAddress } = requiredContractSignerFromOptions(options);
-        return {
-            ario: ARIO.init({
-                process: aoProcessFromOptions(options),
-                signer,
-                paymentUrl: options.paymentUrl,
-                hyperbeamUrl: options.hyperbeamUrl,
-            }),
-            signerAddress,
-        };
-    }
     const rpcUrl = options.rpcUrl ?? 'https://api.mainnet-beta.solana.com';
     const signer = await loadSolanaSignerFromOptions(options);
     return {
         ario: ARIO.init({
-            backend: 'solana',
-            rpc: createSolanaRpc(rpcUrl),
+            rpc: createCliRpc(rpcUrl),
             rpcSubscriptions: createSolanaRpcSubscriptions(wsUrlFromRpcUrl(rpcUrl)),
             signer,
-            // Forward program-id overrides to mirror `readARIOFromOptions` so
-            // localnet / devnet writes target the deployed program IDs instead of
-            // silently falling back to the SDK's mainnet defaults.
+            // Forward program-id overrides so localnet / devnet writes target the
+            // deployed program IDs instead of falling back to mainnet defaults.
             ...(options.coreProgramId
                 ? { coreProgramId: address(options.coreProgramId) }
                 : {}),
@@ -287,14 +195,51 @@ export function formatARIOWithCommas(value) {
 export function formatMARIOToARIOWithCommas(value) {
     return formatARIOWithCommas(value.toARIO());
 }
-/** helper to get address from --address option first, then check wallet options  */
+/**
+ * Resolve the wallet address from CLI options. Priority order:
+ *   1. `--address <addr>` — used verbatim.
+ *   2. `--wallet-file <path-to-keypair.json>` — derive the Solana pubkey
+ *      from the keypair file (last 32 bytes of the 64-byte secret-key
+ *      array are the public key; base58-encode them).
+ *   3. `--private-key <base58-secret>` — base58-decode the secret, take
+ *      the trailing 32 bytes as the pubkey. Matches the keypair-file
+ *      path; kept aligned with `loadSolanaSignerFromOptions` so cost
+ *      / funding lookups work even when the user authenticates with
+ *      only a private key.
+ *
+ * Returns `undefined` when none of those is set. Use
+ * `requiredAddressFromOptions` for callers that must have an address.
+ */
 export function addressFromOptions(options) {
     if (options.address !== undefined) {
         return options.address;
     }
-    const signer = contractSignerFromOptions(options);
-    if (signer !== undefined) {
-        return signer.signerAddress;
+    if (options.walletFile !== undefined) {
+        try {
+            const raw = readFileSync(options.walletFile, 'utf-8');
+            const bytes = new Uint8Array(JSON.parse(raw));
+            // Solana keypair JSON files are a 64-byte Uint8Array: first 32 bytes
+            // are the seed/secret, last 32 bytes are the Ed25519 public key.
+            if (bytes.length !== 64) {
+                throw new Error(`Wallet file is ${bytes.length} bytes — expected 64-byte Solana keypair JSON`);
+            }
+            return bs58.encode(bytes.slice(32));
+        }
+        catch (err) {
+            throw new Error(`Failed to read Solana pubkey from --wallet-file '${options.walletFile}': ${err.message}`);
+        }
+    }
+    if (options.privateKey !== undefined) {
+        try {
+            const bytes = bs58.decode(options.privateKey);
+            if (bytes.length !== 64) {
+                throw new Error(`Decoded private key is ${bytes.length} bytes — expected 64 (32-byte secret + 32-byte pubkey)`);
+            }
+            return bs58.encode(bytes.slice(32));
+        }
+        catch (err) {
+            throw new Error(`Failed to derive Solana pubkey from --private-key: ${err.message}`);
+        }
     }
     return undefined;
 }
@@ -303,7 +248,7 @@ export function requiredAddressFromOptions(options) {
     if (address !== undefined) {
         return address;
     }
-    throw new Error('No address provided. Use --address or --wallet-file');
+    throw new Error('No address provided. Use --address, --wallet-file, or --private-key');
 }
 const defaultCliPaginationLimit = 10; // more friendly UX than 100
 export function paginationParamsFromOptions(options) {
@@ -385,44 +330,8 @@ export function customTagsFromOptions(options) {
         tags,
     };
 }
-export function servicesFromOptions(services) {
-    if (services === undefined || services === null || services === '') {
-        return undefined;
-    }
-    try {
-        const parsed = JSON.parse(services);
-        // Validate structure
-        if (!parsed.bundlers || !Array.isArray(parsed.bundlers)) {
-            throw new Error('Services must have a "bundlers" array');
-        }
-        if (parsed.bundlers.length > 20) {
-            throw new Error('Maximum 20 bundlers allowed');
-        }
-        // Validate each bundler
-        for (const bundler of parsed.bundlers) {
-            if (!bundler.fqdn || typeof bundler.fqdn !== 'string') {
-                throw new Error('Each bundler must have a valid "fqdn" string');
-            }
-            if (typeof bundler.port !== 'number' ||
-                bundler.port < 0 ||
-                bundler.port > 65535) {
-                throw new Error('Each bundler must have a valid "port" (0-65535)');
-            }
-            if (bundler.protocol !== 'https') {
-                throw new Error('Each bundler protocol must be "https"');
-            }
-            if (!bundler.path || typeof bundler.path !== 'string') {
-                throw new Error('Each bundler must have a valid "path" string');
-            }
-        }
-        return parsed;
-    }
-    catch (error) {
-        throw new Error(`Invalid services JSON: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
 export function gatewaySettingsFromOptions(options) {
-    const { allowDelegatedStaking, autoStake, delegateRewardShareRatio, fqdn, label, minDelegatedStake, note, observerAddress, port, properties, allowedDelegates, services, } = options;
+    const { allowDelegatedStaking, autoStake, delegateRewardShareRatio, fqdn, label, minDelegatedStake, note, observerAddress, port, properties, allowedDelegates, } = options;
     return {
         observerAddress,
         allowDelegatedStaking,
@@ -437,7 +346,6 @@ export function gatewaySettingsFromOptions(options) {
         note,
         port: port !== undefined ? +port : undefined,
         properties,
-        services: servicesFromOptions(services),
     };
 }
 export function requiredTargetAndQuantityFromOptions(options) {
@@ -526,47 +434,22 @@ export function requiredProcessIdFromOptions(o) {
     }
     return o.processId;
 }
-function ANTProcessFromOptions(options) {
-    return new AOProcess({
-        processId: requiredProcessIdFromOptions(options),
-        ao: connect({
-            MODE: 'legacy',
-            CU_URL: options.cuUrl,
-        }),
-    });
-}
 export async function readANTFromOptions(options) {
-    if (options.ao) {
-        return ANT.init({
-            process: ANTProcessFromOptions(options),
-            hyperbeamUrl: options.hyperbeamUrl,
-        });
-    }
     const rpcUrl = options.rpcUrl ?? 'https://api.mainnet-beta.solana.com';
     return ANT.init({
-        backend: 'solana',
         processId: requiredProcessIdFromOptions(options),
-        rpc: createSolanaRpc(rpcUrl),
+        rpc: createCliRpc(rpcUrl),
         ...(options.antProgramId
             ? { antProgramId: address(options.antProgramId) }
             : {}),
     });
 }
-export async function writeANTFromOptions(options, signer) {
-    if (options.ao) {
-        signer ??= requiredContractSignerFromOptions(options).signer;
-        return ANT.init({
-            process: ANTProcessFromOptions(options),
-            signer,
-            hyperbeamUrl: options.hyperbeamUrl,
-        });
-    }
+export async function writeANTFromOptions(options) {
     const rpcUrl = options.rpcUrl ?? 'https://api.mainnet-beta.solana.com';
     const kitSigner = await loadSolanaSignerFromOptions(options);
     return ANT.init({
-        backend: 'solana',
         processId: requiredProcessIdFromOptions(options),
-        rpc: createSolanaRpc(rpcUrl),
+        rpc: createCliRpc(rpcUrl),
         rpcSubscriptions: createSolanaRpcSubscriptions(wsUrlFromRpcUrl(rpcUrl)),
         signer: kitSigner,
         ...(options.antProgramId
@@ -619,21 +502,6 @@ export function requiredPositiveIntegerFromOptions(options, key) {
     }
     return value;
 }
-export function getANTStateFromOptions(options) {
-    return initANTStateForAddress({
-        owner: requiredAddressFromOptions(options),
-        targetId: options.target,
-        controllers: options.controllers,
-        description: options.description,
-        ticker: options.ticker,
-        name: options.name,
-        keywords: options.keywords,
-        logo: options.logo,
-        ttlSeconds: options.ttlSeconds !== undefined
-            ? +options.ttlSeconds
-            : defaultTtlSecondsCLI,
-    });
-}
 /**
  * Spawn a fresh ANT on Solana from CLI options.
  *
@@ -642,10 +510,9 @@ export function getANTStateFromOptions(options) {
  * `ario_ant::initialize` into a single transaction. The signer's address
  * becomes the ANT owner on chain — no separate `--address` is required.
  *
- * Maps the CLI's AO-shaped options (`--name`, `--ticker`, `--description`,
+ * Maps the user-facing options (`--name`, `--ticker`, `--description`,
  * `--keywords`, `--logo`, `--target` for the @ record tx id) onto the Solana
- * `InitializeAntParams` payload. AO-only state fields like `controllers` and
- * `balances` are intentionally dropped — they don't exist on Solana.
+ * `InitializeAntParams` payload.
  */
 export async function spawnSolanaANTFromOptions(options) {
     setLoggerIfDebug(options);
@@ -668,7 +535,7 @@ export async function spawnSolanaANTFromOptions(options) {
             'See sdk/scripts/devnet-validation/populate-ant.ts for an end-to-end example.');
     }
     return spawnSolanaANT({
-        rpc: createSolanaRpc(rpcUrl),
+        rpc: createCliRpc(rpcUrl),
         rpcSubscriptions: createSolanaRpcSubscriptions(wsUrlFromRpcUrl(rpcUrl)),
         signer: kitSigner,
         state: {
@@ -678,9 +545,7 @@ export async function spawnSolanaANTFromOptions(options) {
             description: options.description,
             keywords: options.keywords,
             logo: options.logo,
-            // `--target` is the AO convention for the @ record's tx id (see
-            // initANTStateForAddress). Reuse it on Solana so the CLI surface stays
-            // identical between backends.
+            // `--target` carries the @ record's tx id for the initial record.
             transactionId: options.target,
         },
         ...(options.antProgramId
@@ -718,16 +583,25 @@ export function fundFromFromOptions(o) {
 export function referrerFromOptions(o) {
     return o.referrer;
 }
+/** Largest value representable by an unsigned 64-bit integer (2^64 - 1). */
+const U64_MAX = (1n << 64n) - 1n;
 /** Parse `--withdrawal-id` from CLI options into a bigint. */
 export function withdrawalIdFromOptions(o) {
     if (o.withdrawalId === undefined)
         return undefined;
+    let id;
     try {
-        return BigInt(o.withdrawalId);
+        id = BigInt(o.withdrawalId);
     }
     catch {
         throw new Error(`Invalid --withdrawal-id: '${o.withdrawalId}' is not a valid u64 integer`);
     }
+    // The on-chain seed encoder treats the id as a u64; reject out-of-range
+    // values here with a clear message instead of a downstream encoder error.
+    if (id < 0n || id > U64_MAX) {
+        throw new Error(`Invalid --withdrawal-id: '${o.withdrawalId}' is outside u64 range (0..${U64_MAX})`);
+    }
+    return id;
 }
 /**
  * Parse `--funding-plan-json` into a `FundingSourceSpec[]`. Validates each
@@ -782,6 +656,9 @@ export function fundingPlanFromOptions(o) {
         if (amount <= 0n) {
             throw new Error(`--funding-plan-json[${idx}].amount must be > 0 (got ${e.amount})`);
         }
+        if (amount > U64_MAX) {
+            throw new Error(`--funding-plan-json[${idx}].amount '${e.amount}' exceeds u64 max (${U64_MAX})`);
+        }
         const out = {
             kind: e.kind,
             amount,
@@ -793,6 +670,16 @@ export function fundingPlanFromOptions(o) {
             if (e.kind !== 'delegation' && e.kind !== 'operatorStake') {
                 throw new Error(`--funding-plan-json[${idx}].gateway is only valid for kind 'delegation' or 'operatorStake' (got '${e.kind}')`);
             }
+            // The gateway is going to be used: confirm it actually decodes as a
+            // base58 Solana address. `address()` throws on malformed input, so a
+            // bad string fails the CLI here rather than deep in instruction
+            // building.
+            try {
+                address(e.gateway);
+            }
+            catch {
+                throw new Error(`--funding-plan-json[${idx}].gateway '${e.gateway}' is not a valid base58 Solana address`);
+            }
             out.gateway = e.gateway;
         }
         return out;

package/lib/esm/common/ant-registry.js

@@ -1,171 +1,23 @@
-/**
- * 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.
- */
-import { ANT_REGISTRY_ID } from '../constants.js';
-import { isProcessConfiguration, isProcessIdConfiguration, } from '../types/index.js';
-import { createAoSigner } from '../utils/ao.js';
-import { AOProcess, InvalidContractConfigurationError } from './index.js';
-import { Logger } from './logger.js';
 export class ANTRegistry {
     static init(config) {
-        if (config && 'backend' in config && config.backend === 'solana') {
-            return (async () => {
-                if ('signer' in config) {
-                    const { SolanaANTRegistryWriteable } = await import('../solana/ant-registry-writeable.js');
-                    return new SolanaANTRegistryWriteable({
-                        rpc: config.rpc,
-                        signer: config.signer,
-                        commitment: config.commitment,
-                        logger: config.logger,
-                        antProgramId: config.antProgramId,
-                    });
-                }
-                const { SolanaANTRegistryReadable } = await import('../solana/ant-registry-readable.js');
-                return new SolanaANTRegistryReadable({
+        return (async () => {
+            if ('signer' in config) {
+                const { SolanaANTRegistryWriteable } = await import('../solana/ant-registry-writeable.js');
+                return new SolanaANTRegistryWriteable({
                     rpc: config.rpc,
+                    signer: config.signer,
                     commitment: config.commitment,
                     logger: config.logger,
                     antProgramId: config.antProgramId,
                 });
-            })();
-        }
-        const aoConfig = config;
-        if (aoConfig !== undefined && 'signer' in aoConfig) {
-            return new AoANTRegistryWriteable(aoConfig);
-        }
-        return new AoANTRegistryReadable(aoConfig);
-    }
-}
-export class AoANTRegistryReadable {
-    process;
-    hyperbeamUrl;
-    checkHyperBeamPromise;
-    logger;
-    constructor(config) {
-        this.logger = config?.logger ?? Logger.default;
-        if (config === undefined || Object.keys(config).length === 0) {
-            this.process = new AOProcess({
-                processId: ANT_REGISTRY_ID,
-            });
-        }
-        else if (isProcessConfiguration(config)) {
-            this.process = config.process;
-        }
-        else if (isProcessIdConfiguration(config)) {
-            this.process = new AOProcess({
-                processId: config.processId,
-            });
-        }
-        else {
-            throw new InvalidContractConfigurationError();
-        }
-        if (config?.hyperbeamUrl !== undefined) {
-            this.hyperbeamUrl = new URL(config.hyperbeamUrl).toString();
-            this.checkHyperBeamPromise = this.checkHyperBeamCompatibility();
-        }
-    }
-    /**
-     * Check if the process is HyperBeam compatible. If so, we'll use the HyperBeam node to fetch the state.
-     *
-     * @returns {Promise<boolean>} True if the process is HyperBeam compatible, false otherwise.
-     */
-    async checkHyperBeamCompatibility() {
-        if (this.hyperbeamUrl === undefined) {
-            return Promise.resolve(false);
-        }
-        if (this.checkHyperBeamPromise !== undefined) {
-            return this.checkHyperBeamPromise;
-        }
-        this.logger.debug('Checking HyperBeam compatibility');
-        this.checkHyperBeamPromise = fetch(
-        // use /now to force a refresh of the cache state, then compute when calling it for keys
-        `${this.hyperbeamUrl.toString()}${this.process.processId}~process@1.0/now/cache/acl`, {
-            method: 'HEAD',
-            signal: AbortSignal.timeout(5000), // 5 second timeout
-        })
-            .then((res) => {
-            if (res.ok) {
-                this.logger.debug('HyperBeam compatible');
-                return true;
             }
-            this.logger.debug('HyperBeam not compatible');
-            return false;
-        })
-            .catch((error) => {
-            this.logger.debug('Failed to check HyperBeam compatibility', {
-                cause: error,
+            const { SolanaANTRegistryReadable } = await import('../solana/ant-registry-readable.js');
+            return new SolanaANTRegistryReadable({
+                rpc: config.rpc,
+                commitment: config.commitment,
+                logger: config.logger,
+                antProgramId: config.antProgramId,
             });
-            return false;
-        });
-        return this.checkHyperBeamPromise;
-    }
-    // Should we rename this to "getANTsByAddress"? seems more clear, though not same as handler name
-    async accessControlList({ address, }) {
-        if (await this.checkHyperBeamCompatibility()) {
-            let retries = 0;
-            while (retries < 3) {
-                try {
-                    this.logger.debug('Fetching ant registry acl for address from hyperbeam', address);
-                    const res = await fetch(`${this.hyperbeamUrl?.toString()}${this.process.processId}~process@1.0/compute/cache/acl/${address}/serialize~json@1.0`);
-                    if (res.status !== 200) {
-                        this.logger.debug('Failed to fetch ant registry acl for address from hyperbeam', address, res.status, res.statusText);
-                        throw new Error(`Failed to fetch ant registry acl for address ${address}: ${res?.statusText ?? 'Unknown error'}`);
-                    }
-                    this.logger.debug('Fetched ant registry acl for address from hyperbeam', address);
-                    const json = (await res.json());
-                    return {
-                        Owned: json.Owned,
-                        Controlled: json.Controlled,
-                    };
-                }
-                catch (_error) {
-                    retries++;
-                    this.logger.debug('Failed to fetch ant registry acl for address from hyperbeam', address, retries);
-                    await new Promise((resolve) => setTimeout(resolve, 1000 * retries ** 2));
-                }
-            }
-        }
-        this.logger.debug('Fetching ant registry acl for address from process', address);
-        return this.process.read({
-            tags: [
-                { name: 'Action', value: 'Access-Control-List' },
-                { name: 'Address', value: address },
-            ],
-        });
-    }
-    /*
-     * This is the same as accessControlList, but with a cleaner DX to make it clearer
-     * that we're fetching the list of ANTs owned or controlled by an address.
-     */
-    async getAntsForAddress({ address, }) {
-        return this.accessControlList({ address });
-    }
-}
-export class AoANTRegistryWriteable extends AoANTRegistryReadable {
-    signer;
-    constructor({ signer, ...config }) {
-        super(config);
-        this.signer = createAoSigner(signer);
-    }
-    async register({ processId, }) {
-        return this.process.send({
-            tags: [
-                { name: 'Action', value: 'Register' },
-                { name: 'Process-Id', value: processId },
-            ],
-            signer: this.signer,
-        });
+        })();
     }
 }