@utxopia/sdk 0.1.0-alpha.1

package/packages/sdk/dist/sns-resolver.js

@@ -0,0 +1,229 @@
+/**
+ * SNS Subdomain Resolver for Stealth Addresses
+ *
+ * Resolves `<name>.utxopia.sol` (or configured parent domain) to stealth
+ * address keys stored in the SNS name record data field.
+ *
+ * On-chain data layout (after 96-byte SNS header):
+ *   version(1) + viewingPubKey(32) + mpk(32) = 65 bytes
+ *
+ * - viewingPubKey: Ed25519 public key (for X25519 ECDH)
+ * - mpk:          Master Public Key = Poseidon(spendingPub.x, spendingPub.y, nullifyingKey)
+ *
+ * These two keys are all a sender needs to create a stealth deposit.
+ * spendingPubKey is NOT stored — senders never use it.
+ *
+ * @module sns-resolver
+ */
+import { getConfig } from "./config";
+import { sha256Hash } from "./crypto";
+// ========== Constants ==========
+/** SNS name record header size (parent:32 + owner:32 + class:32) */
+const SNS_HEADER_SIZE = 96;
+/** Stealth data size: version(1) + viewingPubKey(32) + mpk(32) = 65 bytes */
+export const SNS_STEALTH_DATA_SIZE = 65;
+/** SNS hash prefix used for PDA derivation */
+const HASH_PREFIX = "SPL Name Service";
+/**
+ * Bit-flags a recipient can opt into on their SNS subdomain. The byte sits
+ * at offset 65 of the stealth payload (i.e. byte 161 of the on-chain
+ * account, after the 96-byte SNS header). Absent → all bits 0.
+ */
+export const SnsComplianceFlags = {
+    /**
+     * Recipient is "auditor-disclosable by default" — they've signalled to
+     * senders that they're OK receiving outgoing audit memos, and likely
+     * already share a `DelegatedViewKey` with a designated auditor
+     * out-of-band.
+     */
+    AUDITOR_DISCLOSABLE: 1 << 0,
+};
+/** Returns true if the recipient has set the AUDITOR_DISCLOSABLE bit. */
+export function isAuditorDisclosable(addr) {
+    return (addr.complianceFlags & SnsComplianceFlags.AUDITOR_DISCLOSABLE) !== 0;
+}
+/**
+ * Total bytes of the stealth payload's compliance extension when both
+ * pieces are present:
+ *   [byte 65]      complianceFlags (u8)
+ *   [bytes 66..97] auditorPubkey   (32-byte Solana pubkey)
+ *
+ * Records may carry only the base 65-byte payload, the payload plus
+ * `complianceFlags`, or the payload plus `complianceFlags` and `auditorPubkey`.
+ */
+export const SNS_COMPLIANCE_AUDITOR_OFFSET = 66;
+export const SNS_COMPLIANCE_AUDITOR_BYTES = 32;
+// ========== PDA Derivation ==========
+/**
+ * Hash a name for SNS PDA derivation (SHA256 of HASH_PREFIX + name)
+ */
+function hashSnsName(name) {
+    const input = HASH_PREFIX + name;
+    return sha256Hash(new TextEncoder().encode(input));
+}
+// ========== PDA Derivation (internal) ==========
+/**
+ * Derive the SNS key for a parent domain (e.g., "utxopia.sol")
+ */
+export async function deriveParentDomainKey(parentDomain) {
+    const { address, getProgramDerivedAddress, getAddressEncoder } = await import("@solana/kit");
+    const config = getConfig();
+    if (!config.snsRootDomain) {
+        throw new Error("SNS root domain not configured for this network");
+    }
+    const hashedParent = hashSnsName(parentDomain);
+    const encoder = getAddressEncoder();
+    const [pda] = await getProgramDerivedAddress({
+        seeds: [
+            hashedParent,
+            new Uint8Array(32), // no class
+            new Uint8Array(encoder.encode(address(config.snsRootDomain))),
+        ],
+        programAddress: address(config.snsNameServiceProgramId),
+    });
+    return pda;
+}
+/**
+ * Derive the SNS key for a subdomain (e.g., "alice" under "utxopia.sol")
+ *
+ * Seeds: [hash("SPL Name Service" + "\0" + name), zeros(32), parentKey]
+ */
+async function deriveSubdomainKey(subdomain, parentKey) {
+    const { address, getProgramDerivedAddress, getAddressEncoder } = await import("@solana/kit");
+    const config = getConfig();
+    const hashedSub = hashSnsName("\0" + subdomain);
+    const encoder = getAddressEncoder();
+    const [pda] = await getProgramDerivedAddress({
+        seeds: [
+            hashedSub,
+            new Uint8Array(32), // no class
+            new Uint8Array(encoder.encode(address(parentKey))),
+        ],
+        programAddress: address(config.snsNameServiceProgramId),
+    });
+    return pda;
+}
+// ========== Parsing ==========
+/**
+ * Parse stealth address data from an SNS name record.
+ *
+ * Supports the current format:
+ * - Base (65 bytes, version 2): version(1) + viewingPubKey(32) + mpk(32)
+ *
+ * Optional trailing byte (offset 65 of the stealth payload, byte 161 of the
+ * account) carries `complianceFlags: u8` — see {@link SnsComplianceFlags}.
+ * When absent, the parsed result has `complianceFlags = 0`.
+ *
+ * @param accountData - Raw account data (including 96-byte header)
+ * @returns Parsed stealth keys + compliance flags, or null if invalid
+ */
+export function parseSnsStealthData(accountData) {
+    // Need at least header + 65 bytes of stealth data
+    if (accountData.length < SNS_HEADER_SIZE + SNS_STEALTH_DATA_SIZE) {
+        return null;
+    }
+    const data = accountData.slice(SNS_HEADER_SIZE);
+    const version = data[0];
+    const allZero = (buf) => buf.every((b) => b === 0);
+    if (version !== 2) {
+        return null;
+    }
+    const viewingPubKey = data.slice(1, 33);
+    const mpk = data.slice(33, 65);
+    if (allZero(viewingPubKey) || allZero(mpk)) {
+        return null;
+    }
+    const complianceFlags = data.length > SNS_STEALTH_DATA_SIZE ? data[SNS_STEALTH_DATA_SIZE] : 0;
+    let auditorPubkey;
+    if (data.length >= SNS_COMPLIANCE_AUDITOR_OFFSET + SNS_COMPLIANCE_AUDITOR_BYTES) {
+        const buf = data.slice(SNS_COMPLIANCE_AUDITOR_OFFSET, SNS_COMPLIANCE_AUDITOR_OFFSET + SNS_COMPLIANCE_AUDITOR_BYTES);
+        // All-zero pubkey means "no auditor set" — distinguishes from the
+        // case where a recipient flips the flag bit but skips the pubkey.
+        if (!allZero(buf)) {
+            auditorPubkey = new Uint8Array(buf);
+        }
+    }
+    return {
+        viewingPubKey: new Uint8Array(viewingPubKey),
+        mpk: new Uint8Array(mpk),
+        version,
+        complianceFlags,
+        auditorPubkey,
+    };
+}
+// ========== Resolution ==========
+/**
+ * Resolve a name to a stealth address via SNS subdomain.
+ *
+ * Accepts multiple formats:
+ *   - "alice"              → resolves alice.<parentDomain>.sol
+ *   - "alice.utxopia"       → resolves alice.utxopia.sol
+ *   - "alice.utxopia.sol"   → resolves alice.utxopia.sol
+ *
+ * @param connection - RPC connection adapter
+ * @param name - Name to resolve
+ * @returns Stealth address or null if not found / no stealth data
+ */
+export async function resolveSnsName(connection, name) {
+    const config = getConfig();
+    if (!config.snsNameServiceProgramId || !config.snsParentDomain) {
+        return null; // SNS not configured
+    }
+    // Normalize: strip .sol and parent domain suffix
+    const parentDomain = config.snsParentDomain;
+    let subdomain = name.trim().toLowerCase();
+    if (subdomain.endsWith(".sol")) {
+        subdomain = subdomain.slice(0, -4);
+    }
+    if (subdomain.endsWith("." + parentDomain)) {
+        subdomain = subdomain.slice(0, -(parentDomain.length + 1));
+    }
+    if (!subdomain || subdomain.includes(".")) {
+        return null; // Invalid: either empty or has extra dots
+    }
+    try {
+        // Derive parent domain key
+        const parentKey = await deriveParentDomainKey(parentDomain);
+        // Derive subdomain key
+        const subKey = await deriveSubdomainKey(subdomain, parentKey);
+        // Fetch account
+        const accountInfo = await connection.getAccountInfo(subKey);
+        if (!accountInfo) {
+            return null;
+        }
+        // Parse stealth data
+        const parsed = parseSnsStealthData(new Uint8Array(accountInfo.data));
+        if (!parsed) {
+            return null;
+        }
+        const fullDomain = `${subdomain}.${parentDomain}.sol`;
+        return {
+            name: subdomain,
+            fullDomain,
+            viewingPubKey: parsed.viewingPubKey,
+            mpk: parsed.mpk,
+            version: parsed.version,
+            complianceFlags: parsed.complianceFlags,
+            auditorPubkey: parsed.auditorPubkey,
+        };
+    }
+    catch (err) {
+        console.error(`Failed to resolve SNS name "${name}":`, err);
+        return null;
+    }
+}
+/**
+ * Resolve a stealth name via SNS subdomain.
+ *
+ * This is the unified resolver that the frontend should use.
+ * All names are resolved as SNS subdomains under the configured parent domain.
+ */
+export async function resolveStealthName(connection, name) {
+    return resolveSnsName(connection, name);
+}
+/**
+ * Type guard to check if a resolved address is from SNS
+ */
+export function isSnsStealthAddress(addr) {
+    return typeof addr === "object" && addr !== null && "fullDomain" in addr;
+}

package/packages/sdk/dist/solana/connection.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Connection Adapter Factory
+ *
+ * Creates ConnectionAdapter instances for use with SDK functions.
+ * Supports both @solana/kit and @solana/web3.js connections.
+ */
+import type { ConnectionAdapter } from "../stealth";
+export interface RpcConfig {
+    /** RPC endpoint URL */
+    endpoint: string;
+    /** Commitment level */
+    commitment?: "processed" | "confirmed" | "finalized";
+}
+/**
+ * Minimal interface for @solana/web3.js Connection-like objects
+ */
+export interface Web3Connection {
+    getAccountInfo(publicKey: {
+        toBase58(): string;
+    } | string, commitment?: string): Promise<{
+        data: Buffer | Uint8Array;
+    } | null>;
+}
+/**
+ * Minimal interface for @solana/kit Rpc-like objects
+ */
+export interface KitRpc {
+    getAccountInfo(address: string, config?: {
+        encoding: string;
+    }): {
+        send(): Promise<{
+            value: {
+                data: string | string[];
+            } | null;
+        }>;
+    };
+}
+/**
+ * Create a ConnectionAdapter using fetch (works everywhere)
+ *
+ * This is the most portable option - works in browser, Node.js, and React Native.
+ *
+ * @param endpoint - Solana RPC endpoint URL
+ * @returns ConnectionAdapter instance
+ */
+export declare function createFetchConnectionAdapter(endpoint: string): ConnectionAdapter;
+/**
+ * Create a ConnectionAdapter from @solana/web3.js Connection
+ *
+ * Use this when you already have a Connection instance from wallet adapter.
+ *
+ * @param connection - @solana/web3.js Connection instance
+ * @returns ConnectionAdapter instance
+ */
+export declare function createConnectionAdapterFromWeb3(connection: Web3Connection): ConnectionAdapter;
+/**
+ * Create a ConnectionAdapter from @solana/kit Rpc
+ *
+ * Use this when using the modern @solana/kit library.
+ *
+ * @param rpc - @solana/kit Rpc instance
+ * @returns ConnectionAdapter instance
+ */
+export declare function createConnectionAdapterFromKit(rpc: KitRpc): ConnectionAdapter;
+/**
+ * Get or create a cached ConnectionAdapter
+ *
+ * Caches the adapter for the given endpoint to avoid creating multiple instances.
+ *
+ * @param endpoint - Solana RPC endpoint URL
+ * @returns ConnectionAdapter instance
+ */
+export declare function getConnectionAdapter(endpoint: string): ConnectionAdapter;
+/**
+ * Clear the cached ConnectionAdapter
+ */
+export declare function clearConnectionAdapterCache(): void;

package/packages/sdk/dist/solana/connection.js

@@ -0,0 +1,133 @@
+/**
+ * Connection Adapter Factory
+ *
+ * Creates ConnectionAdapter instances for use with SDK functions.
+ * Supports both @solana/kit and @solana/web3.js connections.
+ */
+import { base64ToBinaryString } from "../utils/encoding";
+// =============================================================================
+// Connection Adapter Factory
+// =============================================================================
+/**
+ * Create a ConnectionAdapter using fetch (works everywhere)
+ *
+ * This is the most portable option - works in browser, Node.js, and React Native.
+ *
+ * @param endpoint - Solana RPC endpoint URL
+ * @returns ConnectionAdapter instance
+ */
+export function createFetchConnectionAdapter(endpoint) {
+    return {
+        getAccountInfo: async (address) => {
+            const response = await fetch(endpoint, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: 1,
+                    method: "getAccountInfo",
+                    params: [address, { encoding: "base64" }],
+                }),
+            });
+            const result = await response.json();
+            if (!result.result?.value) {
+                return null;
+            }
+            // Decode base64 data
+            const base64Data = Array.isArray(result.result.value.data)
+                ? result.result.value.data[0]
+                : result.result.value.data;
+            if (!base64Data) {
+                return { data: new Uint8Array() };
+            }
+            // Decode base64 (works in browser and Node.js)
+            const binaryString = base64ToBinaryString(base64Data);
+            const bytes = new Uint8Array(binaryString.length);
+            for (let i = 0; i < binaryString.length; i++) {
+                bytes[i] = binaryString.charCodeAt(i);
+            }
+            return { data: bytes };
+        },
+    };
+}
+/**
+ * Create a ConnectionAdapter from @solana/web3.js Connection
+ *
+ * Use this when you already have a Connection instance from wallet adapter.
+ *
+ * @param connection - @solana/web3.js Connection instance
+ * @returns ConnectionAdapter instance
+ */
+export function createConnectionAdapterFromWeb3(connection) {
+    return {
+        getAccountInfo: async (address) => {
+            // Handle both string and PublicKey-like objects
+            const info = await connection.getAccountInfo(address);
+            if (!info)
+                return null;
+            return { data: new Uint8Array(info.data) };
+        },
+    };
+}
+/**
+ * Create a ConnectionAdapter from @solana/kit Rpc
+ *
+ * Use this when using the modern @solana/kit library.
+ *
+ * @param rpc - @solana/kit Rpc instance
+ * @returns ConnectionAdapter instance
+ */
+export function createConnectionAdapterFromKit(rpc) {
+    return {
+        getAccountInfo: async (address) => {
+            const result = await rpc
+                .getAccountInfo(address, { encoding: "base64" })
+                .send();
+            if (!result.value) {
+                return null;
+            }
+            // Decode base64 data
+            const base64Data = typeof result.value.data === "string"
+                ? result.value.data
+                : result.value.data[0];
+            if (!base64Data) {
+                return { data: new Uint8Array() };
+            }
+            // Decode base64
+            const binaryString = base64ToBinaryString(base64Data);
+            const bytes = new Uint8Array(binaryString.length);
+            for (let i = 0; i < binaryString.length; i++) {
+                bytes[i] = binaryString.charCodeAt(i);
+            }
+            return { data: bytes };
+        },
+    };
+}
+// =============================================================================
+// Cached Connection Adapter
+// =============================================================================
+let cachedAdapter = null;
+let cachedEndpoint = null;
+/**
+ * Get or create a cached ConnectionAdapter
+ *
+ * Caches the adapter for the given endpoint to avoid creating multiple instances.
+ *
+ * @param endpoint - Solana RPC endpoint URL
+ * @returns ConnectionAdapter instance
+ */
+export function getConnectionAdapter(endpoint) {
+    if (cachedAdapter && cachedEndpoint === endpoint) {
+        return cachedAdapter;
+    }
+    cachedAdapter = createFetchConnectionAdapter(endpoint);
+    cachedEndpoint = endpoint;
+    return cachedAdapter;
+}
+/**
+ * Clear the cached ConnectionAdapter
+ */
+export function clearConnectionAdapterCache() {
+    cachedAdapter = null;
+    cachedEndpoint = null;
+}

package/packages/sdk/dist/solana/priority-fee.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Priority Fee Estimation
+ *
+ * Utilities for estimating Solana transaction priority fees.
+ * Supports Helius API for accurate fee estimation.
+ */
+export interface PriorityFeeConfig {
+    /** Helius API key (optional, falls back to default fees without it) */
+    heliusApiKey?: string;
+    /** RPC endpoint (defaults to Helius if API key provided) */
+    rpcEndpoint?: string;
+    /** Default compute unit limit */
+    defaultComputeUnits?: number;
+    /** Default priority fee in microLamports (fallback) */
+    defaultPriorityFee?: number;
+}
+export interface PriorityFeeEstimate {
+    /** Recommended priority fee in microLamports */
+    priorityFee: number;
+    /** Compute unit limit to set */
+    computeUnits: number;
+}
+export interface PriorityFeeInstructions {
+    /** SetComputeUnitLimit instruction data */
+    setComputeUnitLimit: {
+        discriminator: number;
+        units: number;
+    };
+    /** SetComputeUnitPrice instruction data (null if no priority fee) */
+    setComputeUnitPrice: {
+        discriminator: number;
+        microLamports: bigint;
+    } | null;
+}
+/** Default compute unit limit for UTXOpia transactions */
+export declare const DEFAULT_COMPUTE_UNITS = 200000;
+/** Default priority fee in microLamports when estimation fails */
+export declare const DEFAULT_PRIORITY_FEE = 1000;
+/** ComputeBudgetProgram discriminators */
+export declare const COMPUTE_BUDGET_DISCRIMINATORS: {
+    readonly SET_COMPUTE_UNIT_LIMIT: 2;
+    readonly SET_COMPUTE_UNIT_PRICE: 3;
+};
+/**
+ * Estimate priority fee using Helius API
+ *
+ * @param accountKeys - Array of account public key strings involved in the transaction
+ * @param config - Configuration options
+ * @returns Priority fee estimate
+ */
+export declare function estimatePriorityFee(accountKeys: string[], config?: PriorityFeeConfig): Promise<PriorityFeeEstimate>;
+/**
+ * Build priority fee instruction data
+ *
+ * Returns raw instruction data for ComputeBudgetProgram instructions.
+ * Use this when building transactions manually.
+ *
+ * @param accountKeys - Array of account public key strings
+ * @param config - Configuration options
+ * @returns Instruction data for compute budget instructions
+ */
+export declare function buildPriorityFeeInstructionData(accountKeys: string[], config?: PriorityFeeConfig): Promise<PriorityFeeInstructions>;
+/**
+ * Encode SetComputeUnitLimit instruction
+ */
+export declare function encodeSetComputeUnitLimit(units: number): Uint8Array;
+/**
+ * Encode SetComputeUnitPrice instruction
+ */
+export declare function encodeSetComputeUnitPrice(microLamports: bigint): Uint8Array;
+/**
+ * Get RPC URL with Helius API key
+ *
+ * @param network - "devnet" or "mainnet"
+ * @param heliusApiKey - Optional Helius API key
+ * @returns RPC URL
+ */
+export declare function getHeliusRpcUrl(network: "devnet" | "mainnet", heliusApiKey?: string): string;

package/packages/sdk/dist/solana/priority-fee.js

@@ -0,0 +1,137 @@
+/**
+ * Priority Fee Estimation
+ *
+ * Utilities for estimating Solana transaction priority fees.
+ * Supports Helius API for accurate fee estimation.
+ */
+// =============================================================================
+// Constants
+// =============================================================================
+/** Default compute unit limit for UTXOpia transactions */
+export const DEFAULT_COMPUTE_UNITS = 200000;
+/** Default priority fee in microLamports when estimation fails */
+export const DEFAULT_PRIORITY_FEE = 1000;
+/** ComputeBudgetProgram discriminators */
+export const COMPUTE_BUDGET_DISCRIMINATORS = {
+    SET_COMPUTE_UNIT_LIMIT: 2,
+    SET_COMPUTE_UNIT_PRICE: 3,
+};
+// =============================================================================
+// Priority Fee Estimation
+// =============================================================================
+/**
+ * Estimate priority fee using Helius API
+ *
+ * @param accountKeys - Array of account public key strings involved in the transaction
+ * @param config - Configuration options
+ * @returns Priority fee estimate
+ */
+export async function estimatePriorityFee(accountKeys, config = {}) {
+    const { heliusApiKey, rpcEndpoint, defaultComputeUnits = DEFAULT_COMPUTE_UNITS, defaultPriorityFee = DEFAULT_PRIORITY_FEE, } = config;
+    // Determine endpoint
+    const endpoint = rpcEndpoint || (heliusApiKey
+        ? `https://mainnet.helius-rpc.com/?api-key=${heliusApiKey}`
+        : null);
+    if (!endpoint) {
+        // No API available, return defaults
+        return {
+            priorityFee: defaultPriorityFee,
+            computeUnits: defaultComputeUnits,
+        };
+    }
+    try {
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: "priority-fee",
+                method: "getPriorityFeeEstimate",
+                params: [{
+                        accountKeys,
+                        options: { recommended: true },
+                    }],
+            }),
+        });
+        const data = await response.json();
+        const priorityFee = data?.result?.priorityFeeEstimate || defaultPriorityFee;
+        return {
+            priorityFee: Math.round(priorityFee),
+            computeUnits: defaultComputeUnits,
+        };
+    }
+    catch (error) {
+        console.warn("Failed to get priority fee estimate:", error);
+        return {
+            priorityFee: defaultPriorityFee,
+            computeUnits: defaultComputeUnits,
+        };
+    }
+}
+/**
+ * Build priority fee instruction data
+ *
+ * Returns raw instruction data for ComputeBudgetProgram instructions.
+ * Use this when building transactions manually.
+ *
+ * @param accountKeys - Array of account public key strings
+ * @param config - Configuration options
+ * @returns Instruction data for compute budget instructions
+ */
+export async function buildPriorityFeeInstructionData(accountKeys, config = {}) {
+    const estimate = await estimatePriorityFee(accountKeys, config);
+    return {
+        setComputeUnitLimit: {
+            discriminator: COMPUTE_BUDGET_DISCRIMINATORS.SET_COMPUTE_UNIT_LIMIT,
+            units: estimate.computeUnits,
+        },
+        setComputeUnitPrice: estimate.priorityFee > 0
+            ? {
+                discriminator: COMPUTE_BUDGET_DISCRIMINATORS.SET_COMPUTE_UNIT_PRICE,
+                microLamports: BigInt(estimate.priorityFee),
+            }
+            : null,
+    };
+}
+/**
+ * Encode SetComputeUnitLimit instruction
+ */
+export function encodeSetComputeUnitLimit(units) {
+    const data = new Uint8Array(5);
+    data[0] = COMPUTE_BUDGET_DISCRIMINATORS.SET_COMPUTE_UNIT_LIMIT;
+    // Little-endian u32
+    data[1] = units & 0xff;
+    data[2] = (units >> 8) & 0xff;
+    data[3] = (units >> 16) & 0xff;
+    data[4] = (units >> 24) & 0xff;
+    return data;
+}
+/**
+ * Encode SetComputeUnitPrice instruction
+ */
+export function encodeSetComputeUnitPrice(microLamports) {
+    const data = new Uint8Array(9);
+    data[0] = COMPUTE_BUDGET_DISCRIMINATORS.SET_COMPUTE_UNIT_PRICE;
+    // Little-endian u64
+    for (let i = 0; i < 8; i++) {
+        data[1 + i] = Number((microLamports >> BigInt(i * 8)) & 0xffn);
+    }
+    return data;
+}
+/**
+ * Get RPC URL with Helius API key
+ *
+ * @param network - "devnet" or "mainnet"
+ * @param heliusApiKey - Optional Helius API key
+ * @returns RPC URL
+ */
+export function getHeliusRpcUrl(network, heliusApiKey) {
+    if (heliusApiKey) {
+        return network === "mainnet"
+            ? `https://mainnet.helius-rpc.com/?api-key=${heliusApiKey}`
+            : `https://devnet.helius-rpc.com/?api-key=${heliusApiKey}`;
+    }
+    return network === "mainnet"
+        ? "https://api.mainnet-beta.solana.com"
+        : "https://api.devnet.solana.com";
+}