@bluxcc/core 0.2.6 → 0.2.8

package/dist/exports/core/getTokenMetadata.d.ts

@@ -0,0 +1,32 @@
+/** Options for {@link getTokenMetadata}. */
+export type GetTokenMetadataOptions = {
+    /** Network passphrase to read from. Defaults to the active network. */
+    network?: string;
+};
+/** Metadata read from a SEP-41 token / Stellar Asset Contract. */
+export type TokenMetadata = {
+    /** Number of decimal places the token uses. */
+    decimals: number;
+    /** Human-readable token name. */
+    name: string;
+    /** Token symbol / code. */
+    symbol: string;
+    /**
+     * The token's owner, when the contract exposes an `owner()` function. Absent
+     * for contracts without one — notably Stellar Asset Contracts, which expose
+     * `admin()` rather than `owner()`.
+     */
+    owner?: string;
+};
+/**
+ * Reads a token contract's metadata by simulating its read-only entrypoints — no
+ * account, signing, or fees required. `decimals`, `name`, and `symbol` come from
+ * the standard SEP-41 token interface; `owner` is read separately and omitted
+ * when the contract has no `owner()` function.
+ *
+ * @param address - The token contract id (`C...`), e.g. a SAC from {@link getSacAddress}.
+ * @param options - Network to read from.
+ * @returns The token's {@link TokenMetadata}.
+ * @throws If called before {@link createConfig}, if `address` is not a contract id, or if the contract is missing the standard `decimals`/`name`/`symbol` entrypoints.
+ */
+export declare const getTokenMetadata: (address: string, options?: GetTokenMetadataOptions) => Promise<TokenMetadata>;

package/dist/exports/core/getTradeAggregation.d.ts

@@ -1,4 +1,15 @@
-import { Asset } from '@stellar/stellar-sdk';
+import { type AssetArg } from './helpers';
 import { CallBuilderOptions } from '../utils';
+/** The Horizon call builder plus the first page of trade-aggregation buckets. */
 export type GetTradeAggregationResult = any;
-export declare const getTradeAggregation: (args: [base: Asset, counter: Asset, start_time: number, end_time: number, resolution: number, offset: number], options: CallBuilderOptions) => Promise<GetTradeAggregationResult>;
+/**
+ * Fetches time-bucketed trade aggregations (OHLC-style price/volume data) for an
+ * asset pair.
+ *
+ * @param args - `[base, counter, start_time, end_time, resolution, offset]`.
+ *   `base`/`counter` accept `'xlm'`, `'CODE:ISSUER'`, or an `Asset`; times are in
+ *   epoch milliseconds; `resolution` is the bucket size in milliseconds.
+ * @param options - Pagination and network.
+ * @returns The `builder` (for further paging) and the first-page `response`.
+ */
+export declare const getTradeAggregation: (args: [base: AssetArg, counter: AssetArg, start_time: number, end_time: number, resolution: number, offset: number], options: CallBuilderOptions) => Promise<GetTradeAggregationResult>;

package/dist/exports/core/getTrades.d.ts

@@ -1,15 +1,30 @@
-import { Asset, Horizon } from '@stellar/stellar-sdk';
-import { TradesCallBuilder } from '@stellar/stellar-sdk/lib/horizon/trades_call_builder';
+import { Horizon } from '@stellar/stellar-sdk';
+import { TradesCallBuilder } from '@stellar/stellar-sdk/lib/esm/horizon/trades_call_builder';
+import { type AssetArg } from './helpers';
 import { CallBuilderOptions } from '../utils';
+/** Options for {@link getTrades}. Extends the shared {@link CallBuilderOptions}. */
 export type GetTradesOptions = CallBuilderOptions & {
-    forAssetPair?: [base: Asset, counter: Asset];
+    /** Only trades for this `[base, counter]` asset pair. Each accepts `'xlm'`, `'CODE:ISSUER'`, or an `Asset`. */
+    forAssetPair?: [base: AssetArg, counter: AssetArg];
+    /** Only trades against this offer id. */
     forOffer?: string;
+    /** Only trades of this type (e.g. `orderbook`, `liquidity_pool`). */
     forType?: Horizon.ServerApi.TradeType;
+    /** Only trades involving this account (address or federated address). */
     forAccount?: string;
+    /** Only trades for this liquidity pool id. */
     forLiquidityPool?: string;
 };
+/** The Horizon call builder plus the first page of trades. */
 export type GetTradesResult = {
     builder: TradesCallBuilder;
     response: Horizon.ServerApi.CollectionPage<Horizon.ServerApi.TradeRecord>;
 };
+/**
+ * Lists trades, optionally scoped to an asset pair, offer, type, account, or
+ * liquidity pool.
+ *
+ * @param options - Filters, pagination, and network.
+ * @returns The `builder` (for further paging) and the first-page `response`.
+ */
 export declare const getTrades: (options: GetTradesOptions) => Promise<GetTradesResult>;

package/dist/exports/core/getTransactions.d.ts

@@ -1,15 +1,29 @@
 import { Horizon } from '@stellar/stellar-sdk';
-import { TransactionCallBuilder } from '@stellar/stellar-sdk/lib/horizon/transaction_call_builder';
+import { TransactionCallBuilder } from '@stellar/stellar-sdk/lib/esm/horizon/transaction_call_builder';
 import { CallBuilderOptions } from '../utils';
+/** Options for {@link getTransactions}. Extends the shared {@link CallBuilderOptions}. */
 export type GetTransactionsOptions = CallBuilderOptions & {
+    /** Only transactions touching this account (address or federated address). */
     forAccount?: string;
+    /** Only transactions affecting this claimable balance id. */
     forClaimableBalance?: string;
+    /** Only transactions in this ledger, by sequence number. */
     forLedger?: string | number;
+    /** Only transactions affecting this liquidity pool id. */
     forLiquidityPool?: string;
+    /** Include failed transactions. Defaults to `false`. */
     includeFailed?: boolean;
 };
+/** The Horizon call builder plus the first page of transactions. */
 export type GetTransactionsResult = {
     builder: TransactionCallBuilder;
     response: Horizon.ServerApi.CollectionPage<Horizon.ServerApi.TransactionRecord>;
 };
+/**
+ * Lists transactions, optionally scoped to an account, ledger, claimable
+ * balance, or liquidity pool.
+ *
+ * @param options - Filters, pagination, and network.
+ * @returns The `builder` (for further paging) and the first-page `response`.
+ */
 export declare const getTransactions: (options: GetTransactionsOptions) => Promise<GetTransactionsResult>;

package/dist/exports/core/helpers/account.d.ts

@@ -0,0 +1,20 @@
+import { Asset, Horizon } from '@stellar/stellar-sdk';
+/**
+ * Loads an account from Horizon, returning `null` instead of throwing when the
+ * account does not exist on the network yet.
+ *
+ * @param horizon - The Horizon server to query.
+ * @param address - The account id (`G...`) to load.
+ * @returns The account, or `null` if it is not found.
+ */
+export declare const loadAccount: (horizon: Horizon.Server, address: string) => Promise<Horizon.AccountResponse | null>;
+/**
+ * Reports whether `account` can receive `asset` directly: always true for the
+ * native asset, otherwise true only when the account already holds a trustline
+ * for that exact code + issuer.
+ *
+ * @param account - The recipient account.
+ * @param asset - The asset to check.
+ * @returns `true` if a direct payment of `asset` would be accepted.
+ */
+export declare const hasTrustline: (account: Horizon.AccountResponse, asset: Asset) => boolean;

package/dist/exports/core/helpers/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared, hook-free helpers for the interacting core functions. Re-exporting
+ * `numberish` here lets a caller pull the address resolver, the asset resolver,
+ * and the number coercion from a single place.
+ */
+export { resolveAsset, type AssetArg } from './resolveAsset';
+export { resolveAddress, resolveAddressKey, type ResolvedAddress, } from './resolveAddress';
+export { loadAccount, hasTrustline } from './account';
+export { numberish, type Numberish } from '../toScVal';

package/dist/exports/core/helpers/resolveAddress.d.ts

@@ -0,0 +1,47 @@
+import { Federation } from '@stellar/stellar-sdk';
+/** The outcome of resolving a recipient with {@link resolveAddress}. */
+export type ResolvedAddress = {
+    /**
+     * The address to drop into an operation. A muxed (`M...`) input is preserved
+     * here so its embedded memo id survives a classic payment; for every other
+     * input this equals {@link ResolvedAddress.publicKey}.
+     */
+    destination: string;
+    /**
+     * The underlying Ed25519 account id (`G...`). Use this for account-existence
+     * lookups, createAccount destinations, and claimable-balance claimants — none
+     * of which accept a muxed address.
+     */
+    publicKey: string;
+    /** The memo a federation record asks senders to attach, when it provided one. */
+    memo?: string;
+    /** The type of {@link ResolvedAddress.memo} (`text` | `id` | `hash` | `return`). */
+    memoType?: string;
+    /** `true` when the input was a federated address that required a network lookup. */
+    federated: boolean;
+};
+/**
+ * Turns whatever a caller passed as a recipient into a usable account id:
+ *
+ * - A valid Stellar address (`G...` or muxed `M...`) is used as-is.
+ * - A SEP-2 federated address (e.g. `alice*example.com`) is looked up against
+ *   the domain's federation server.
+ * - Anything else throws, so a transaction is never built toward garbage.
+ *
+ * @param value - An address or federated address.
+ * @param opts - Optional federation lookup options (e.g. `timeout`, `allowHttp`).
+ * @returns The resolved address details — see {@link ResolvedAddress}.
+ * @throws If the value is neither a valid address nor a resolvable federated address.
+ */
+export declare const resolveAddress: (value: string, opts?: Federation.Api.Options) => Promise<ResolvedAddress>;
+/**
+ * Convenience wrapper for the common "I only need the account id" case (Horizon
+ * query filters such as `forAccount`/`sponsor`/`claimant`). Passes `undefined`
+ * through untouched so optional filters stay optional, and resolves everything
+ * else — including federated addresses — down to its base Ed25519 key.
+ *
+ * @param address - An optional address or federated address.
+ * @returns The base `G...` key, or `undefined` when no address was given.
+ * @throws If a non-empty `address` is neither valid nor resolvable.
+ */
+export declare const resolveAddressKey: (address?: string) => Promise<string | undefined>;

package/dist/exports/core/helpers/resolveAsset.d.ts

@@ -0,0 +1,19 @@
+import { Asset } from '@stellar/stellar-sdk';
+/**
+ * Loose asset input accepted across the SDK and normalized by
+ * {@link resolveAsset}:
+ *
+ * - `'xlm'` / `'native'` — the native lumen
+ * - `'USDC:GA5Z...KZVN'` — an issued asset in `CODE:ISSUER` form
+ * - an {@link Asset} instance — returned unchanged
+ */
+export type AssetArg = string | Asset;
+/**
+ * Normalizes an {@link AssetArg} into a stellar-sdk {@link Asset}. Shared by the
+ * core functions so they all parse assets the same way.
+ *
+ * @param asset - `'xlm'`/`'native'`, a `CODE:ISSUER` string, or an `Asset`.
+ * @returns The corresponding `Asset` (native for `'xlm'`/`'native'`).
+ * @throws If the value is not a recognized form, or the issuer is not a valid Ed25519 public key.
+ */
+export declare const resolveAsset: (asset: AssetArg) => Asset;

package/dist/exports/core/index.d.ts

@@ -4,6 +4,7 @@ export { getAssets } from './getAssets';
 export { getBalances } from './getBalances';
 export { getClaimableBalances } from './getClaimableBalances';
 export { getEffects } from './getEffects';
+export { fundAccount, type FundAccountOptions, type FundAccountResult, type FundAccountStatus, } from './fundAccount';
 export { getLedgers } from './getLedgers';
 export { getLiquidityPools } from './getLiquidityPools';
 export { getNetwork } from './getNetwork';
@@ -18,6 +19,12 @@ export { getTrades } from './getTrades';
 export { getTransactions } from './getTransactions';
 export { readContracts } from './readContracts';
 export { writeContract } from './writeContract';
+export { transfer, type TransferOptions } from './transfer';
+export { swap, type SwapOptions, type SwapType } from './swap';
+export { getSacAddress } from './getSacAddress';
+export { getTokenMetadata, type TokenMetadata, type GetTokenMetadataOptions, } from './getTokenMetadata';
 export { networks } from './networks';
 export { switchNetwork } from './switchNetwork';
 export { type Numberish, numberish, ToScVal } from './toScVal';
+export { resolveAsset, resolveAddress, resolveAddressKey, type AssetArg, type ResolvedAddress, } from './helpers';
+export type { ISubmittedTransaction, TransactionReturnValue, SendTransactionResult, } from '../../types';

package/dist/exports/core/networks.d.ts

@@ -1,8 +1,18 @@
 import { Networks } from '@stellar/stellar-sdk';
+/**
+ * Convenience map of friendly network names to their Stellar passphrases. Pass a
+ * value from here as the `network` option on any core function or to
+ * {@link switchNetwork}.
+ */
 export declare const networks: {
+    /** Public network (mainnet) passphrase. */
     mainnet: Networks;
+    /** Testnet passphrase. */
     testnet: Networks;
+    /** Sandbox passphrase. */
     sandbox: Networks;
+    /** Futurenet passphrase. */
     futurenet: Networks;
+    /** Standalone (local) network passphrase. */
     standalone: Networks;
 };

package/dist/exports/core/readContracts.d.ts

@@ -1,5 +1,18 @@
 import { rpc } from '@stellar/stellar-sdk';
 import { IContractCall, ReadContractsOptions } from '../utils';
+/**
+ * Reads from one or more Soroban contracts by simulating the calls — no
+ * transaction is submitted and no account is required, so this is free and
+ * read-only. Each call's return value is decoded to a native JS value (`bigint`
+ * results are stringified).
+ *
+ * @param calls - The contract calls to simulate; build `args` with {@link ToScVal}.
+ * @param options - Network to simulate against.
+ * @returns `{ raws, values }` aligned to `calls` — `raws` holds the full
+ *   simulation per call, `values` the decoded return values (`null` for a call
+ *   that returned nothing). An empty array is returned when `calls` is empty.
+ * @throws If called before {@link createConfig}, if `calls` is not an array, or if any simulation fails.
+ */
 export declare const readContracts: (calls: IContractCall[], options?: ReadContractsOptions) => Promise<never[] | {
     raws: (rpc.Api.SimulateTransactionSuccessResponse | rpc.Api.SimulateTransactionRestoreResponse | undefined)[];
     values: any[];

package/dist/exports/core/swap.d.ts

@@ -0,0 +1,52 @@
+import { ISubmittedTransaction } from '../../types';
+import { type Numberish } from './toScVal';
+import { type AssetArg } from './helpers';
+/**
+ * Which side of the swap is fixed:
+ *
+ * - `'exactIn'` — send exactly `amount` of `fromAsset` (the received amount floats).
+ * - `'exactOut'` — receive exactly `amount` of `toAsset` (the sent amount floats).
+ */
+export type SwapType = 'exactIn' | 'exactOut';
+/** Options for {@link swap}. */
+export type SwapOptions = {
+    /** Asset being sold. Accepts `'xlm'` / `'native'`, a `CODE:ISSUER` string, or an `Asset`. */
+    fromAsset: AssetArg;
+    /** Asset being bought. Accepts `'xlm'` / `'native'`, a `CODE:ISSUER` string, or an `Asset`. */
+    toAsset: AssetArg;
+    /**
+     * The fixed amount. For `'exactIn'` this is how much `fromAsset` to send; for
+     * `'exactOut'` it is how much `toAsset` to receive. Numbers and bigints are
+     * coerced to a string.
+     */
+    amount: Numberish;
+    /** Which side is fixed. Defaults to `'exactIn'`. */
+    type?: SwapType;
+    /**
+     * Where the bought asset is delivered: a Stellar address (`G...`/`M...`) or a
+     * SEP-2 federated address. Defaults to the logged-in account (a self-swap).
+     */
+    to?: string;
+    /**
+     * Maximum acceptable slippage as a fraction, where `0.005` = 0.5%. Sets the
+     * `destMin` (exactIn) / `sendMax` (exactOut) guardrail off the quoted price.
+     * Defaults to `0.005`.
+     */
+    slippage?: number;
+    /** Optional text memo to attach to the transaction. */
+    memo?: string;
+    /** Network passphrase to swap on. Defaults to the active network. */
+    network?: string;
+};
+/**
+ * Swaps one asset for another through the Stellar DEX / liquidity pools using a
+ * path payment, picking the best available path automatically. Defaults to a
+ * self-swap; pass `to` to deliver the bought asset to another account. When the
+ * recipient is the logged-in account and lacks a trustline for `toAsset`, the
+ * required `changeTrust` is added automatically. Requires a logged-in account.
+ *
+ * @param options - What to swap and how — see {@link SwapOptions}.
+ * @returns The submitted transaction.
+ * @throws If no account is logged in, the inputs are invalid, no path exists, the destination account does not exist, or the destination (when not self) lacks a trustline for `toAsset`.
+ */
+export declare const swap: (options: SwapOptions) => Promise<ISubmittedTransaction>;

package/dist/exports/core/switchNetwork.d.ts

@@ -1 +1,8 @@
+/**
+ * Switches the active network and stops automatic network syncing with the
+ * connected wallet (so the choice sticks until changed again).
+ *
+ * @param newNetwork - Passphrase of the network to switch to; must be listed in `config.networks`.
+ * @throws If called before {@link createConfig} or if the network is not in `config.networks`.
+ */
 export declare const switchNetwork: (newNetwork: string) => void;

package/dist/exports/core/toScVal.d.ts

@@ -1,30 +1,66 @@
 import { xdr } from '@stellar/stellar-sdk';
+/** A numeric value accepted in string, number, or bigint form. */
 export type Numberish = string | number | bigint;
+/**
+ * Coerces a {@link Numberish} into a specific primitive type.
+ *
+ * @param val - The value to convert.
+ * @param targetType - The primitive to coerce to: `'string'`, `'number'`, or `'bigint'`.
+ * @returns `val` as the requested type.
+ */
 export declare const numberish: <T extends Numberish>(val: Numberish, targetType: "string" | "number" | "bigint") => T;
 type MapEntry = Record<string, xdr.ScVal | Object>;
+/**
+ * Encoders that turn JS values into Soroban {@link xdr.ScVal} arguments for
+ * {@link readContracts} / {@link writeContract} calls. Each method maps to one
+ * Soroban value type.
+ */
 export declare class ToScVal {
+    /** Encodes a signed 32-bit integer (`i32`). */
     static i32(value: Numberish): xdr.ScVal;
+    /** Encodes a signed 64-bit integer (`i64`). */
     static i64(value: Numberish): xdr.ScVal;
+    /** Encodes a signed 128-bit integer (`i128`). */
     static i128(value: Numberish): xdr.ScVal;
+    /** Encodes a signed 256-bit integer (`i256`). */
     static i256(value: Numberish): xdr.ScVal;
+    /** Encodes an unsigned 32-bit integer (`u32`). */
     static u32(value: Numberish): xdr.ScVal;
+    /** Encodes an unsigned 64-bit integer (`u64`). */
     static u64(value: Numberish): xdr.ScVal;
+    /** Encodes an unsigned 128-bit integer (`u128`). */
     static u128(value: Numberish): xdr.ScVal;
+    /** Encodes an unsigned 256-bit integer (`u256`). */
     static u256(value: Numberish): xdr.ScVal;
+    /** Encodes a contract error value. */
     static error(value: xdr.ScError): xdr.ScVal;
+    /** Encodes a duration (seconds, as an unsigned 64-bit value). */
     static duration(value: Numberish): xdr.ScVal;
+    /** Encodes a timepoint (Unix seconds, as an unsigned 64-bit value). */
     static timepoint(value: Numberish): xdr.ScVal;
+    /** Encodes a ledger-key nonce. */
     static ledgerKeyNonce(value: xdr.ScNonceKey): xdr.ScVal;
+    /** Encodes a contract instance value. */
     static contractInstance(value: xdr.ScContractInstance): xdr.ScVal;
+    /** Encodes a map from pre-built {@link xdr.ScMapEntry} entries (or `null`). */
     static scvMap(value: null | xdr.ScMapEntry[]): xdr.ScVal;
+    /** Encodes a map from a plain object, recursing into nested objects (keys become symbols). */
     static map(value: MapEntry | null): xdr.ScVal;
+    /** Encodes a string value. */
     static string(value: string | Buffer): xdr.ScVal;
+    /** Encodes a vector of pre-built ScVals (or `null`). */
     static vec(value: null | xdr.ScVal[]): xdr.ScVal;
+    /** Encodes the void value. */
     static void(): xdr.ScVal;
+    /** Encodes a raw byte array. */
     static bytes(value: Buffer): xdr.ScVal;
+    /** Encodes the ledger-key for a contract instance. */
     static ledgerKeyContractInstance(): xdr.ScVal;
+    /** Encodes a symbol (short identifier, e.g. a function or enum name). */
     static symbol(symbol: string | Buffer): xdr.ScVal;
+    /** Encodes a boolean. */
     static boolean(bool: boolean): xdr.ScVal;
+    /** Encodes an address — an account (`G...`) or contract (`C...`). */
     static address(address: string): xdr.ScVal;
 }
 export {};

package/dist/exports/core/transfer.d.ts

@@ -0,0 +1,49 @@
+import { ISubmittedTransaction } from '../../types';
+import { type Numberish } from './toScVal';
+import { type AssetArg } from './helpers';
+/** Options for {@link transfer}. */
+export type TransferOptions = {
+    /**
+     * Recipient: a Stellar address (`G...` or muxed `M...`) or a SEP-2 federated
+     * address (`alice*example.com`). For a `token` transfer a contract id (`C...`)
+     * is also accepted.
+     */
+    to: string;
+    /**
+     * Amount to send. Numbers and bigints are coerced to a string. For classic
+     * assets this is a decimal amount (`"10.5"`); for a `token` it is the integer
+     * base-unit amount the contract expects.
+     */
+    amount: Numberish;
+    /**
+     * Asset to send. Accepts `'xlm'` / `'native'`, a `CODE:ISSUER` string, or an
+     * `Asset`. Defaults to the native lumen. Ignored when `token` is set.
+     */
+    asset?: AssetArg;
+    /** Optional text memo. Ignored for `token` (Soroban) transfers. */
+    memo?: string;
+    /**
+     * When the recipient cannot receive the asset directly (its account does not
+     * exist, or it has no trustline for an issued asset), send a claimable balance
+     * it can claim later instead of failing. Defaults to `false`.
+     */
+    claimable?: boolean;
+    /**
+     * A SEP-41 token contract id (`C...`). When set, value moves through the
+     * contract's `transfer(from, to, amount)` entrypoint instead of a classic op.
+     */
+    token?: string;
+    /** Network passphrase to send on. Defaults to the active network. */
+    network?: string;
+};
+/**
+ * Sends value from the logged-in account to `to`, choosing the right mechanism
+ * automatically: createAccount for a new recipient, payment for an existing one,
+ * a claimable balance when asked, or a SEP-41 contract call when `token` is set.
+ * Requires a logged-in account.
+ *
+ * @param options - Recipient, amount, and how to send — see {@link TransferOptions}.
+ * @returns The submitted transaction.
+ * @throws If no account is logged in, the inputs are invalid, or the recipient cannot receive the asset (and `claimable` was not set).
+ */
+export declare const transfer: (options: TransferOptions) => Promise<ISubmittedTransaction>;

package/dist/exports/core/writeContract.d.ts

@@ -1,2 +1,13 @@
 import { IContractCall, WriteContractsOptions } from '../utils';
-export declare const writeContract: (call: IContractCall, options?: WriteContractsOptions) => Promise<unknown>;
+import { ISubmittedTransaction } from '../../types';
+/**
+ * Invokes a state-changing Soroban contract function: builds the call, simulates
+ * it to attach resource fees / footprint / auth, then signs and submits it with
+ * the logged-in account. Requires a logged-in user.
+ *
+ * @param call - The contract call to make; build `args` with {@link ToScVal}.
+ * @param options - Network to submit on.
+ * @returns The submitted transaction, whose `returnValue()` resolves to the contract's decoded return value.
+ * @throws If called before {@link createConfig}, if `call.address`/`call.fn` are missing, or if simulation fails.
+ */
+export declare const writeContract: (call: IContractCall, options?: WriteContractsOptions) => Promise<ISubmittedTransaction>;

package/dist/exports/createConfig.d.ts

@@ -1,3 +1,12 @@
 import { IConfig } from '../types';
 import '../tailwind.css';
+/**
+ * Initializes the Blux SDK: validates the config, mounts the Blux UI, loads
+ * available wallets, wires up integrations (WalletConnect, Trezor), and
+ * authenticates the app id. Call this once before any other Blux function.
+ *
+ * @param config - The app configuration — see {@link IConfig}.
+ * @param element - DOM element to mount the Blux UI into. Defaults to `document.body`.
+ * @throws If `config` is empty or missing `appId`, `appName`, or `networks`, or if the network options are invalid.
+ */
 export declare function createConfig(config: IConfig, element?: HTMLElement): void;

package/dist/exports/utils.d.ts

@@ -1,26 +1,68 @@
 import { Horizon, rpc, xdr } from '@stellar/stellar-sdk';
+/**
+ * A single Soroban contract invocation, consumed by {@link readContracts} and
+ * {@link writeContract}.
+ */
 export type IContractCall = {
+    /** Contract id (`C...`) to invoke. */
     address: string;
+    /** Name of the contract function to call. */
     fn: string;
+    /** Call arguments, encoded as Soroban values — build these with {@link ToScVal}. */
     args: xdr.ScVal[];
 };
+/** Options for {@link readContracts}. */
 export type ReadContractsOptions = {
+    /** Network passphrase to simulate against. Defaults to the active network. */
     network?: string;
 };
+/** Options for {@link writeContract}. */
 export type WriteContractsOptions = {
+    /** Network passphrase to submit on. Defaults to the active network. */
     network?: string;
 };
+/** Pagination and network options shared by every Horizon list query. */
 export type CallBuilderOptions = {
+    /** Paging token; pass the previous page's cursor to fetch the next page. */
     cursor?: string;
+    /** Maximum number of records returned per page. */
     limit?: number;
+    /** Network passphrase to query. Defaults to the active network. */
     network?: string;
+    /** Sort direction by ledger sequence. Defaults to Horizon's `asc`. */
     order?: 'asc' | 'desc';
 };
+/**
+ * Reports whether {@link createConfig} has run and the SDK is initialized.
+ *
+ * @returns `true` once the Stellar transports are configured.
+ */
 export declare const checkConfigCreated: () => boolean;
+/**
+ * Resolves which address to act on, defaulting to the logged-in account.
+ *
+ * @param address - An explicit address to use instead of the logged-in account.
+ * @returns The chosen address.
+ * @throws If no address is provided and no account is logged in.
+ */
 export declare const getAddress: (address?: string) => string;
+/**
+ * Resolves the Horizon server, Soroban RPC server, and passphrase for a network.
+ *
+ * @param network - Passphrase of the network to use. Defaults to the active network.
+ * @returns The `horizon` server, `soroban` RPC server, and `networkPassphrase`.
+ * @throws If no network is given and the SDK has no configured transports.
+ */
 export declare const getNetwork: (network?: string) => {
     horizon: Horizon.Server;
     soroban: rpc.Server;
     networkPassphrase: string;
 };
+/**
+ * Switches the active network in the store and emits a network-changed event.
+ * Internal plumbing for the exported {@link switchNetwork}.
+ *
+ * @param newNetwork - Passphrase of the network to switch to; must be listed in `config.networks`.
+ * @throws If called before {@link createConfig}, if the network is not configured, or if there is no active network.
+ */
 export declare const internalSwitchNetwork: (newNetwork: string) => void;