@geeqdev/geeq-sdk 0.2.0 → 0.2.2

package/dist/types/index.d.ts

@@ -0,0 +1,2224 @@
+/** Account ids and public keys are both 32 bytes. */
+declare const ACCOUNT_ID_BYTES = 32;
+declare const PUBLIC_KEY_BYTES = 32;
+/**
+ * Any way of naming an account that does not need the engine.
+ *
+ * Structural on purpose: a {@link GeeqKeypair} already carries `accountId`, so it
+ * satisfies this without the crypto layer importing the keypair type and without the
+ * caller unwrapping anything.
+ */
+type AccountRef = Uint8Array | {
+    readonly accountId: Uint8Array;
+} | {
+    readonly publicKey: Uint8Array;
+};
+/**
+ * Derive the 32-byte account id for a public key.
+ *
+ * This is a pure hash — it needs no engine and no network, so it works before
+ * {@link initGeeq} has resolved.
+ */
+declare function accountIdFromPublicKey(publicKey: Uint8Array): Uint8Array;
+
+/** Which coin record subtype an account is. Only `'asset'` may sign an attestation. */
+type GeeqCoinRecordKind = 'asset' | 'hl' | 'micro' | 'unknown';
+/** One coin account record, as plain values. */
+interface GeeqCoinAccount {
+    readonly accountId: Uint8Array;
+    readonly kind: GeeqCoinRecordKind;
+    /**
+     * `undefined` for a hash-lock record, which carries no nonce field at all, and for a
+     * record whose subtype could not be read.
+     */
+    readonly nonce: number | undefined;
+    /** Balance in pennies. Use `formatGeeq` to show it. */
+    readonly balance: bigint;
+    /** The NFTs it holds, in the order its record lists them. Read for coin-asset records only. */
+    readonly nfts: readonly GeeqHeldNft[];
+}
+/** One NFT an account holds, as its record lists it. */
+interface GeeqHeldNft {
+    /** The NFT's 32-byte id. */
+    readonly id: Uint8Array;
+    /** A counterparty NFT moves only with a counterparty transaction, never a plain transfer. */
+    readonly counterparty: boolean;
+}
+/** What we keep per account. The id is the map key, so it is not repeated here. */
+interface CoinAccountFacts {
+    readonly kind: GeeqCoinRecordKind;
+    readonly nonce: number | undefined;
+    readonly balance: bigint;
+    readonly nfts: readonly GeeqHeldNft[];
+}
+
+/** Which kind of proxy a record is. Only `'nft-mint'` is read further. */
+type GeeqProxyKind = 'nft-mint' | 'token-mint' | 'funding' | 'multisig' | 'dce' | 'unknown';
+/** One proxy account record, as plain values. */
+interface GeeqProxyAccount {
+    readonly accountId: Uint8Array;
+    readonly kind: GeeqProxyKind;
+    /**
+     * The proxy's own nonce. A mint through it spends this one, not the admin's — a proxy
+     * carries its nonce on the record itself.
+     */
+    readonly nonce: number;
+    /** Balance in pennies. Use `formatGeeq` to show it. */
+    readonly balance: bigint;
+    /** The account id of the only key that can sign for it. Read for NFT mint proxies only. */
+    readonly admin: Uint8Array | undefined;
+}
+/** What we keep per proxy. The id is the map key, so it is not repeated here. */
+type ProxyAccountFacts = Omit<GeeqProxyAccount, 'accountId'>;
+
+/**
+ * Where the WebAssembly engine should be loaded from. Leave it unset and the SDK
+ * uses the copy shipped beside its own bundle, which every common bundler emits
+ * as a hashed asset automatically.
+ */
+type WasmSource = string | URL | Request | Response | ArrayBuffer | Uint8Array | WebAssembly.Module;
+interface InitOptions {
+    /** Override where `geeq_core_bg.wasm` is fetched from. */
+    readonly wasm?: WasmSource;
+}
+/**
+ * The kind of ledger record an address points at. Most applications only ever
+ * need `'coin-asset'`, which is the default and is what a normal user account is.
+ */
+type GeeqRecordType = 'coin-asset' | 'coin-hl' | 'coin-micro' | 'app-counterparty' | 'app-dce' | 'app-nft' | 'app-stackable' | 'proxy-nft-mint' | 'proxy-funding' | 'proxy-multisig' | 'proxy-dce' | 'proxy-token-mint' | 'gt-nwa' | 'param-boolean' | 'param-count-2' | 'param-count-8' | 'sys';
+/** Which coin family a derivation path belongs to. */
+type GeeqCoinType = 'mainnet' | 'testnet';
+interface WalletAddressOptions {
+    /** The chain this address belongs to. Addresses are not portable across chains. */
+    readonly chainNumber: number;
+    /** Defaults to `'coin-asset'` — an ordinary user account. */
+    readonly recordType?: GeeqRecordType;
+}
+interface DecodedWalletAddress {
+    /** The address that was decoded, unchanged. */
+    readonly address: string;
+    readonly chainNumber: number;
+    readonly recordType: GeeqRecordType;
+    /** The 32-byte account id this address points at. */
+    readonly accountId: Uint8Array;
+}
+/** Options for deriving a keypair from a BIP-39 mnemonic along the Geeq path. */
+interface MnemonicOptions {
+    /** Optional BIP-39 passphrase. Defaults to an empty string. */
+    readonly passphrase?: string;
+    /** Defaults to `'coin-asset'`. */
+    readonly recordType?: GeeqRecordType;
+    /** Defaults to `'mainnet'`. */
+    readonly coinType?: GeeqCoinType;
+    /** Defaults to 0. */
+    readonly account?: number;
+    /** Defaults to 0. */
+    readonly addressIndex?: number;
+}
+/**
+ * An Ed25519 keypair plus the identifiers derived from it.
+ *
+ * `privateKey` is raw secret material. Never log it, never put it in an error
+ * message, and never send it anywhere. Call {@link GeeqKeypair.dispose} when done
+ * to release the engine-side copy.
+ */
+interface GeeqKeypair {
+    /** 32-byte Ed25519 public key. */
+    readonly publicKey: Uint8Array;
+    /** 32-byte Ed25519 secret key. Secret material. */
+    readonly privateKey: Uint8Array;
+    /** 32-byte account id derived from the public key. */
+    readonly accountId: Uint8Array;
+    /** The base58 wallet address for this keypair on a given chain. */
+    getAddress(options: WalletAddressOptions): string;
+    /** Sign a message. Throws once {@link GeeqKeypair.dispose} has been called. */
+    sign(message: Uint8Array): Uint8Array;
+    /** Release the engine-side keypair. The byte fields stay readable afterwards. */
+    dispose(): void;
+}
+/** The metadata limits this chain publishes in its own ledger. */
+interface GeeqMetadataLimits {
+    /** Maximum NUMBER of metadata entries. From the `metadataVarNum` parameter. */
+    readonly maxEntries: number;
+    /** Maximum bytes in ONE entry. There is no aggregate cap. From `metadataVarBytes`. */
+    readonly maxBytesPerEntry: number;
+}
+/**
+ * The live chain values a transaction is pinned to.
+ *
+ * `blockNumber` is the block being *asked for*, which is the ledger's last committed
+ * block plus one. Read it from a node with {@link GeeqChain}, or supply it yourself for
+ * replay and offline signing.
+ */
+interface ChainStateInput {
+    /** The chain this transaction targets — the ledger's own chain number. */
+    readonly chainNumber: number;
+    /** The block it asks to be included in: the ledger's block **+ 1**. */
+    readonly blockNumber: number;
+    /** The receiving node's own number, from the net actor list in the ledger. */
+    readonly nodeNumber: number;
+    /** The signing account's current nonce, from its coin account record. */
+    readonly nonce: number;
+    /** When present, metadata is checked against it before anything is signed. */
+    readonly metadataLimits?: GeeqMetadataLimits | undefined;
+    /**
+     * The chain's `geeqNorm` parameter, which every fee is a multiple of. When present, the
+     * built transaction carries its {@link GeeqFee}.
+     */
+    readonly geeqNorm?: bigint | undefined;
+    /**
+     * The node this state describes, and therefore the only node that will accept a
+     * transaction built from it — `nodeNumber` is checked with strict equality.
+     */
+    readonly nodeUrl?: string | undefined;
+    /**
+     * N, the ledger block this was read from. Present only when a chain produced it —
+     * there is nothing to report when the caller supplied the numbers.
+     */
+    readonly ledgerBlockNumber?: number | undefined;
+    /** `Date.now()` at the read. Present only when a chain produced it. */
+    readonly readAt?: number | undefined;
+}
+/**
+ * Chain state read from a node, carrying where and when it came from.
+ *
+ * The same fields as {@link ChainStateInput}, with the provenance ones narrowed from
+ * optional to always present — a chain can always say which ledger block and which node
+ * it read.
+ */
+interface GeeqChainState extends ChainStateInput {
+    /** N — the ledger's last committed block. {@link blockNumber} is this plus one. */
+    readonly ledgerBlockNumber: number;
+    /** `Date.now()` when the ledger was read, so callers can see how stale this is. */
+    readonly readAt: number;
+    /** The node it was read from, and therefore the node it must be submitted to. */
+    readonly nodeUrl: string;
+    /** The signing account's balance, in pennies, as at this read. */
+    readonly balance: bigint;
+    /** The smallest transfer this chain accepts, in pennies, if it publishes one. */
+    readonly minimumTransfer: bigint | undefined;
+    /** The chain's `geeqNorm` parameter, if it publishes one. */
+    readonly geeqNorm: bigint | undefined;
+}
+/**
+ * What the chain charges for a transaction, in pennies, on top of any amount it sends.
+ *
+ * Worked out by the SDK the way the node works it out, from the signed bytes, so it is
+ * the exact figure rather than an estimate.
+ */
+interface GeeqFee {
+    /** The whole fee: {@link data} plus {@link coin}. */
+    readonly total: bigint;
+    /** `geeqNorm` per byte of the signed transaction, and of its payload when it has one. */
+    readonly data: bigint;
+    /**
+     * A quarter of a percent of the amount sent, rounded down and capped at
+     * `geeqNorm × 10⁷`. Zero for an attestation, which sends no amount.
+     */
+    readonly coin: bigint;
+    /** How many bytes {@link data} charges for. */
+    readonly bytes: number;
+}
+/** What is being attested, independent of any chain state. */
+interface AttestationContent {
+    /** The account that signs both the attestation and the transaction. */
+    readonly keypair: GeeqKeypair;
+    /** 32-byte hash of the content. The content itself never leaves the device. */
+    readonly attestHash: Uint8Array;
+    /**
+     * Optional labels stored alongside the hash, in the order given. Strings are encoded
+     * as UTF-8. Anything here is public once submitted.
+     */
+    readonly metadata?: readonly (string | Uint8Array)[];
+}
+/**
+ * The four chain values supplied explicitly.
+ *
+ * Kept for replay, deterministic tests and air-gapped signing, where there is no node
+ * to ask. Most callers should let {@link GeeqChain} read them instead — none of them can
+ * be derived offline, and a wrong one is rejected by the chain.
+ */
+type AttestationTxFlatInput = AttestationContent & {
+    readonly chainNumber: number;
+    readonly blockNumber: number;
+    readonly nodeNumber: number;
+    readonly nonce: number;
+    readonly chainState?: never;
+};
+/** The same four values as one object, which is what a chain read produces. */
+type AttestationTxStateInput = AttestationContent & {
+    readonly chainState: ChainStateInput;
+    readonly chainNumber?: never;
+    readonly blockNumber?: never;
+    readonly nodeNumber?: never;
+    readonly nonce?: never;
+};
+type AttestationTxInput = AttestationTxFlatInput | AttestationTxStateInput;
+/**
+ * A signed attestation transaction, ready to submit. The SDK does not submit it — post
+ * {@link AttestationTx.transaction} and {@link AttestationTx.payload} to the node named
+ * by {@link AttestationTx.nodeUrl}, after handing it to `GeeqSocket.track` to hear the
+ * verdict.
+ */
+interface AttestationTx {
+    /** base64 packed `UserAppTx`. Submit as the `transaction` field. */
+    readonly transaction: string;
+    /** base64 packed `Payload`. Submit as the `payload` field. */
+    readonly payload: string;
+    /** 32-byte BLAKE3 of the flattened payload, as embedded in the transaction. */
+    readonly refHashPayload: Uint8Array;
+    /**
+     * 32-byte BLAKE3 of the signed, flattened transaction — how a node identifies it, and
+     * the `refHash` its status events carry. `transactionIdOf(tx)` gives it as the base64
+     * string a {@link GeeqSocket} matches on.
+     */
+    readonly transactionHash: Uint8Array;
+    /** The signer's 32-byte public key — whose status events to subscribe to. */
+    readonly publicKey: Uint8Array;
+    /**
+     * What the chain charges the signing account for it. Undefined when the chain state
+     * carried no `geeqNorm`.
+     */
+    readonly fee: GeeqFee | undefined;
+    /** Exactly what this transaction is pinned to. Frozen. */
+    readonly chainState: ChainStateInput;
+    /**
+     * The last block a node takes it at: its target block plus 8. Once the chain's latest
+     * block is past this, every node refuses it as too old, and it has to be built and
+     * signed again. `GeeqChain.isExpired` checks.
+     */
+    readonly validUntilBlock: number;
+    /**
+     * Where this must be submitted, when a chain read chose the node.
+     *
+     * Not a convenience: the node checks that `nodeNumber` is its own, with strict
+     * equality, so posting to any other node is a guaranteed rejection. Undefined only
+     * when the caller supplied the four values themselves and the SDK never saw a node.
+     */
+    readonly nodeUrl?: string | undefined;
+}
+/** What is being transferred, independent of any chain state. */
+interface CoinTransferContent {
+    /** The account paying. Must be a coin-asset account on this chain. */
+    readonly keypair: GeeqKeypair;
+    /** Who receives it. Resolved to a 32-byte account id. */
+    readonly to: AccountRef;
+    /**
+     * How much, in pennies. Use `toPennies` to get here from a figure. Never
+     * zero: the node reads a zero amount as the sender's whole balance.
+     */
+    readonly amount: bigint;
+    /** NFTs sent with it. Each must be one the sender holds, named once. */
+    readonly nfts?: readonly NftTransferEntry[];
+}
+/** One NFT a transfer moves. */
+interface NftTransferEntry {
+    /** The NFT's 32-byte id. */
+    readonly id: Uint8Array;
+    /** Where it sits in the sender's list of NFTs, from 0 — as `GeeqCoinAccount.nfts` orders them. */
+    readonly position: number;
+}
+/** The four chain values supplied explicitly. For replay and air-gapped signing. */
+type CoinTransferTxFlatInput = CoinTransferContent & {
+    readonly chainNumber: number;
+    readonly blockNumber: number;
+    readonly nodeNumber: number;
+    readonly nonce: number;
+    readonly chainState?: never;
+};
+/** The same four as one object, which is what a chain read produces. */
+type CoinTransferTxStateInput = CoinTransferContent & {
+    readonly chainState: ChainStateInput;
+    readonly chainNumber?: never;
+    readonly blockNumber?: never;
+    readonly nodeNumber?: never;
+    readonly nonce?: never;
+};
+type CoinTransferTxInput = CoinTransferTxFlatInput | CoinTransferTxStateInput;
+/**
+ * A signed coin transfer, ready to submit.
+ *
+ * Note there is no `payload`: a validation-layer transaction is self-contained, unlike an
+ * attestation. Post it with `coinTransferSubmitBody`, which sends it as type `uvt`, after
+ * handing it to `GeeqSocket.track` to hear the verdict.
+ */
+interface CoinTransferTx {
+    /** base64 packed `UserValTx`. Submit as the `transaction` field. */
+    readonly transaction: string;
+    /**
+     * 32-byte BLAKE3 of the flattened transaction **without** its signature — how the chain
+     * identifies a validation-layer transaction, and the `refHash` its status events carry.
+     * Note this is the opposite of an attestation, whose hash includes the signature.
+     */
+    readonly transactionHash: Uint8Array;
+    /** The sender's 32-byte public key — whose status events to subscribe to. */
+    readonly publicKey: Uint8Array;
+    /** What was sent, in pennies. */
+    readonly amount: bigint;
+    /** The ids of the NFTs sent with it, if any. */
+    readonly nfts: readonly Uint8Array[];
+    /**
+     * What the chain charges the sender, on top of {@link amount}. Undefined when the chain
+     * state carried no `geeqNorm`.
+     */
+    readonly fee: GeeqFee | undefined;
+    /** The 32-byte account id it was sent to. */
+    readonly to: Uint8Array;
+    /** Exactly what this transaction is pinned to. Frozen. */
+    readonly chainState: ChainStateInput;
+    /**
+     * The last block a node takes it at: its target block plus 8. Once the chain's latest
+     * block is past this, every node refuses it as too old, and it has to be built and
+     * signed again. `GeeqChain.isExpired` checks.
+     */
+    readonly validUntilBlock: number;
+    /** Where it must be submitted, when a chain read chose the node. */
+    readonly nodeUrl?: string | undefined;
+}
+/**
+ * What a proxy creation needs. The chain values come as one object only — there is no
+ * flat form, since a proxy is always built against a ledger read.
+ */
+interface NftMintProxyTxInput {
+    /**
+     * The account paying for the proxy, which also becomes its admin: the only key that
+     * can later mint through it. Must be a coin-asset account on this chain.
+     */
+    readonly keypair: GeeqKeypair;
+    /**
+     * Which of the admin's proxies this is, from 1. The proxy's id is derived from the
+     * admin's public key and this index, as the Geeq wallet derives it, so it must be one
+     * the admin has not used — `GeeqChain.findNftMintProxies` gives the next one.
+     */
+    readonly index: number;
+    /** Coin moved onto the proxy, in pennies. It pays for the mints made through it. */
+    readonly amount: bigint;
+    readonly chainState: ChainStateInput;
+}
+/**
+ * A signed transaction creating an NFT mint proxy, ready to submit.
+ *
+ * A validation-layer transaction, like a transfer: post it with `coinTransferSubmitBody`,
+ * after handing it to `GeeqSocket.track` to hear the verdict.
+ */
+interface NftMintProxyTx {
+    /** base64 packed `UserValTx`. Submit as the `transaction` field. */
+    readonly transaction: string;
+    /** 32-byte BLAKE3 of the signature-excluded flatten — the `refHash` its status events carry. */
+    readonly transactionHash: Uint8Array;
+    /** The admin's 32-byte public key — whose status events to subscribe to. */
+    readonly publicKey: Uint8Array;
+    /** The coin moved onto the proxy, in pennies. */
+    readonly amount: bigint;
+    /** Which of the admin's proxies this is, from 1. */
+    readonly index: number;
+    /** The new proxy's 32-byte account id, derived from the admin's key and {@link index}. */
+    readonly proxyAccountId: Uint8Array;
+    /** The new proxy's wallet address on this chain, record type `proxy-nft-mint`. */
+    readonly proxyAddress: string;
+    /**
+     * What the chain charges the admin, on top of {@link amount}. Undefined when the chain
+     * state carried no `geeqNorm`.
+     */
+    readonly fee: GeeqFee | undefined;
+    /** Exactly what this transaction is pinned to. Frozen. */
+    readonly chainState: ChainStateInput;
+    /**
+     * The last block a node takes it at: its target block plus 8. Once the chain's latest
+     * block is past this, every node refuses it as too old, and it has to be built and
+     * signed again. `GeeqChain.isExpired` checks.
+     */
+    readonly validUntilBlock: number;
+    /** Where it must be submitted, when a chain read chose the node. */
+    readonly nodeUrl?: string | undefined;
+}
+/**
+ * What an NFT mint needs. The chain values come as one object only, as for a proxy.
+ */
+interface NftMintTxInput {
+    /** The proxy's admin. It signs both the NFT and the transaction. */
+    readonly keypair: GeeqKeypair;
+    /** The 32-byte account id of the proxy minting it, which pays for it. */
+    readonly proxyAccountId: Uint8Array;
+    /** 32-byte hash of what the NFT stands for. The content itself never leaves the device. */
+    readonly attestHash: Uint8Array;
+    /** Optional public labels stored with the NFT, in the order given. */
+    readonly metadata?: readonly (string | Uint8Array)[];
+    /** Who receives the NFT. Resolved to a 32-byte account id. */
+    readonly to: AccountRef;
+    /** Coin the proxy sends to the receiver along with the NFT, in pennies. */
+    readonly amount: bigint;
+    /** Its `nonce` is the proxy's own, not the admin's. */
+    readonly chainState: ChainStateInput;
+}
+/**
+ * A signed NFT mint, ready to submit.
+ *
+ * An application-layer transaction, like an attestation: post `transaction` and `payload`
+ * with `attestationSubmitBody`, after handing it to `GeeqSocket.track` to hear the verdict.
+ */
+interface NftMintTx {
+    /** base64 packed `UserAppTx`. Submit as the `transaction` field. */
+    readonly transaction: string;
+    /** base64 packed `Payload`. Submit as the `payload` field. */
+    readonly payload: string;
+    /** 32-byte BLAKE3 of the flattened payload, as embedded in the transaction. */
+    readonly refHashPayload: Uint8Array;
+    /** 32-byte BLAKE3 of the signed, flattened transaction — the `refHash` its status events carry. */
+    readonly transactionHash: Uint8Array;
+    /** The admin's 32-byte public key — whose status events to subscribe to. */
+    readonly publicKey: Uint8Array;
+    /** The new NFT's 32-byte id: the hash of its attestation subgroup, as the wallet derives it. */
+    readonly nftId: Uint8Array;
+    /** The proxy minting it. */
+    readonly proxyAccountId: Uint8Array;
+    /** The 32-byte account id receiving it. */
+    readonly to: Uint8Array;
+    /** The coin sent along with it, in pennies. */
+    readonly amount: bigint;
+    /**
+     * What the chain charges the proxy — not the admin — on top of {@link amount}. Undefined
+     * when the chain state carried no `geeqNorm`.
+     */
+    readonly fee: GeeqFee | undefined;
+    /** Exactly what this transaction is pinned to. Frozen. */
+    readonly chainState: ChainStateInput;
+    /**
+     * The last block a node takes it at: its target block plus 8. Once the chain's latest
+     * block is past this, every node refuses it as too old, and it has to be built and
+     * signed again. `GeeqChain.isExpired` checks.
+     */
+    readonly validUntilBlock: number;
+    /** Where it must be submitted, when a chain read chose the node. */
+    readonly nodeUrl?: string | undefined;
+}
+/** One of an admin's NFT mint proxies, as the ledger holds it. */
+interface GeeqNftMintProxy extends GeeqProxyAccount {
+    /**
+     * Which of the admin's proxies it is, from 1. Undefined for a proxy whose id was not
+     * derived from the admin's key — one made with an id of its own.
+     */
+    readonly index: number | undefined;
+    /** Its wallet address on this chain, record type `proxy-nft-mint`. */
+    readonly address: string;
+}
+/** The NFT mint proxies one admin has, and the index its next one takes. */
+interface GeeqNftMintProxies {
+    /** In index order; any without an index come last. */
+    readonly proxies: readonly GeeqNftMintProxy[];
+    /** One past the highest index in use, or 1 when there is none. */
+    readonly nextIndex: number;
+}
+/** An NFT an account holds, with the hash and labels it was minted with. */
+interface GeeqNft extends GeeqHeldNft {
+    /** The hash of what it stands for. Undefined when the application layer ledger has no record of it. */
+    readonly attestHash: Uint8Array | undefined;
+    /** Its public labels as text, in order. */
+    readonly metadata: readonly string[];
+}
+
+/**
+ * Load the Geeq engine. Idempotent and single-flight: concurrent callers share one
+ * load, and repeat calls after success resolve immediately.
+ *
+ * You rarely need to call this yourself — every async entry point in the SDK awaits
+ * it first. Call it at startup if you would rather pay the cost up front.
+ */
+declare function initGeeq(options?: InitOptions): Promise<void>;
+/** True once the engine is loaded and the synchronous APIs are usable. */
+declare function isGeeqReady(): boolean;
+
+/** Create a brand new random keypair. Synchronous; requires a loaded engine. */
+declare function generateKeypairSync(): GeeqKeypair;
+/** Create a brand new random keypair, loading the engine if needed. */
+declare function generateKeypair(): Promise<GeeqKeypair>;
+/** Re-create a keypair from stored public and private key bytes. */
+declare function importKeypairSync(publicKey: Uint8Array, privateKey: Uint8Array): GeeqKeypair;
+/** Re-create a keypair from stored key bytes, loading the engine if needed. */
+declare function importKeypair(publicKey: Uint8Array, privateKey: Uint8Array): Promise<GeeqKeypair>;
+/** Recover a keypair from its 32-byte secret key alone. */
+declare function keypairFromSecretKeySync(privateKey: Uint8Array): GeeqKeypair;
+/** Recover a keypair from its secret key, loading the engine if needed. */
+declare function keypairFromSecretKey(privateKey: Uint8Array): Promise<GeeqKeypair>;
+/**
+ * Derive a keypair from a BIP-39 mnemonic along Geeq's standard derivation path.
+ *
+ * The same mnemonic and options always produce the same keypair, so this is how a
+ * wallet is restored on another device.
+ */
+declare function keypairFromMnemonicSync(mnemonic: string, options?: MnemonicOptions): GeeqKeypair;
+/** Derive a keypair from a mnemonic, loading the engine if needed. */
+declare function keypairFromMnemonic(mnemonic: string, options?: MnemonicOptions): Promise<GeeqKeypair>;
+/** Verify an Ed25519 signature. Requires a loaded engine. */
+declare function verifySignature(publicKey: Uint8Array, signature: Uint8Array, message: Uint8Array): boolean;
+
+/** Supported mnemonic lengths. 12 words is the common default; 24 is the strongest. */
+type MnemonicWordCount = 12 | 15 | 18 | 21 | 24;
+declare const MNEMONIC_WORD_COUNTS: readonly [12, 15, 18, 21, 24];
+interface GenerateMnemonicOptions {
+    /** How many words to generate. Defaults to 12. */
+    readonly words?: MnemonicWordCount;
+}
+/**
+ * Generate a fresh BIP-39 recovery phrase, using the platform's cryptographically
+ * secure random source.
+ *
+ * Pure JavaScript — no engine needed, so this works before {@link initGeeq}
+ * resolves. Phrases are generated from the English wordlist, which is what
+ * {@link keypairFromMnemonic} expects.
+ *
+ * The phrase is the *only* way to recover the wallet. Show it to the user once,
+ * let them write it down, and never transmit or persist it in plaintext.
+ *
+ * ```ts
+ * const mnemonic = generateMnemonic()            // 12 words
+ * const long = generateMnemonic({ words: 24 })   // 24 words
+ * ```
+ */
+declare function generateMnemonic(options?: GenerateMnemonicOptions): string;
+/**
+ * Check a recovery phrase for the right word count, known words, and a valid
+ * checksum. Use it to give immediate feedback on a restore form rather than
+ * waiting for {@link keypairFromMnemonic} to throw.
+ *
+ * Pure JavaScript — no engine needed.
+ */
+declare function validateMnemonic(mnemonic: string): boolean;
+/** Trim and collapse whitespace so pasted phrases validate as typed ones do. */
+declare function normalizeMnemonic(mnemonic: string): string;
+
+/** Identify the account either by its public key or by its account id. */
+type AccountIdentifier = {
+    readonly publicKey: Uint8Array;
+    readonly accountId?: never;
+} | {
+    readonly accountId: Uint8Array;
+    readonly publicKey?: never;
+};
+type CreateWalletAddressInput = AccountIdentifier & WalletAddressOptions;
+/**
+ * Build the base58 wallet address for an account. Synchronous; requires the engine
+ * to be loaded already. Most callers want {@link createWalletAddress} instead.
+ */
+declare function createWalletAddressSync(input: CreateWalletAddressInput): string;
+/**
+ * Build the base58 wallet address for an account, loading the engine if needed.
+ *
+ * ```ts
+ * const address = await createWalletAddress({ publicKey, chainNumber: 1 })
+ * ```
+ */
+declare function createWalletAddress(input: CreateWalletAddressInput): Promise<string>;
+/** Decode a base58 wallet address. Synchronous; requires the engine to be loaded. */
+declare function decodeWalletAddressSync(address: string): DecodedWalletAddress;
+/** Decode a base58 wallet address, loading the engine if needed. */
+declare function decodeWalletAddress(address: string): Promise<DecodedWalletAddress>;
+/**
+ * True when `address` decodes as a Geeq wallet address. Requires a loaded engine.
+ *
+ * Throws `not-initialized` rather than answering before the engine has loaded: `false`
+ * would call every address invalid, including good ones.
+ */
+declare function isValidWalletAddress(address: string): boolean;
+
+/** Every record type this SDK understands, for validation and tooling. */
+declare const GEEQ_RECORD_TYPES: readonly GeeqRecordType[];
+declare const DEFAULT_RECORD_TYPE: GeeqRecordType;
+
+/**
+ * An amount of coin, with its unit stated.
+ *
+ * The protocol counts only **pennies**, as geeq_node_core calls them. A Geeq is a display
+ * unit, and how many pennies make one is not on the chain: the app says, as
+ * `penniesPerGeeq` when it connects, and every conversion takes it from there.
+ *
+ * Every amount crossing this SDK's surface names its unit, because the alternative is a
+ * bare number that means one thing to the caller and another to the chain. That mistake
+ * does not throw — it just moves the wrong amount.
+ *
+ * ```ts
+ * { geeq: "12.34" }     // human-facing: what someone typed
+ * { pennies: balance }  // protocol-facing: as the chain counts it
+ * ```
+ */
+type GeeqAmount = {
+    readonly geeq: string | number;
+} | {
+    readonly pennies: bigint | number;
+};
+/**
+ * Resolve any {@link GeeqAmount} to pennies, the unit the protocol uses. A `{ geeq }`
+ * figure is read at `penniesPerGeeq` to the Geeq; `{ pennies }` is taken as it is.
+ */
+declare function toPennies(amount: GeeqAmount, penniesPerGeeq: bigint): bigint;
+/**
+ * Format pennies as a decimal Geeq string at `penniesPerGeeq` to the Geeq, the way the Geeq
+ * wallet shows amounts: every place the unit has, trailing zeros dropped.
+ *
+ * A negative figure — a shortfall, say — keeps its sign: `-1.5`, not `-1.-5`.
+ */
+declare function formatGeeq(pennies: bigint, penniesPerGeeq: bigint): string;
+
+/** A response, narrowed to what this SDK reads. A WHATWG `Response` satisfies it. */
+interface GeeqHttpResponse {
+    readonly ok: boolean;
+    readonly status: number;
+    text(): Promise<string>;
+}
+/** A request, narrowed to what this SDK sends. Assignable to `RequestInit`. */
+interface GeeqRequestInit {
+    readonly method?: string;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly body?: string;
+    readonly signal?: AbortSignal;
+}
+/**
+ * How the SDK reaches a node.
+ *
+ * Deliberately a structural subset of WHATWG `fetch`, so `{ transport: fetch }`
+ * typechecks with no adapter, and so does undici with a custom dispatcher, a relative
+ * URL through a dev proxy, or a scripted array of responses in a test.
+ */
+type GeeqTransport = (url: string, init?: GeeqRequestInit) => Promise<GeeqHttpResponse>;
+/**
+ * `globalThis.fetch`, resolved at call time.
+ *
+ * Never a stored reference: an unbound `fetch` throws `Illegal invocation` in a
+ * browser, and capturing it would defeat any test that swaps `globalThis.fetch` after
+ * this module is imported.
+ */
+declare const defaultTransport: GeeqTransport;
+interface RequestOptions {
+    readonly transport: GeeqTransport;
+    readonly timeoutMs: number;
+    readonly retries: number;
+    readonly headers?: Readonly<Record<string, string>> | undefined;
+    readonly signal?: AbortSignal | undefined;
+    readonly method?: string | undefined;
+    readonly body?: string | undefined;
+}
+
+/** How the directory classifies a node. Only `'active'` processes transactions. */
+type GeeqNodeKind = 'active' | 'relay' | 'listener' | 'chain-admin' | 'none' | 'unknown';
+/** One chain the directory knows about. */
+interface GeeqDiscoveredChain {
+    /** The directory's own row id, which every other directory route calls `systemId`. */
+    readonly systemId: number;
+    /** The protocol chain number — what a transaction carries and a node checks. */
+    readonly chainNumber: number;
+    readonly name: string | undefined;
+}
+/**
+ * One node the directory knows about.
+ *
+ * Note what is **missing**: a node number. The directory can say where a node is but
+ * not who it is in the chain's own net actor list, so the ledger read is still the only
+ * way to learn the number a transaction must carry.
+ */
+interface GeeqDiscoveredNode {
+    readonly host: string;
+    readonly kind: GeeqNodeKind;
+    /** The directory's own lifecycle state — `new`, `ready`, `stopped`. */
+    readonly status: string;
+    /** Where to reach it. Always the client port; the directory's own port is internal. */
+    readonly url: string;
+}
+/** Every chain the directory knows about. */
+declare function listChains(origin: string, request: RequestOptions): Promise<GeeqDiscoveredChain[]>;
+interface NodeAddressing {
+    /** Scheme for the node URLs. Defaults to the directory's own. */
+    readonly protocol?: string | undefined;
+    /** Client port. Defaults to {@link GEEQ_NODE_PORT}; override only for local setups. */
+    readonly port?: number | undefined;
+}
+/** Every node the directory lists for one chain. */
+declare function listNodes(origin: string, systemId: number, request: RequestOptions, addressing?: NodeAddressing): Promise<GeeqDiscoveredNode[]>;
+interface DiscoverOptions extends NodeAddressing {
+    readonly origin: string;
+    /** Select the chain by the name the directory gives it. Matched case-insensitively. */
+    readonly chainName?: string | undefined;
+    /** Select by protocol chain number, or — alongside `chainName` — assert it. */
+    readonly chainNumber?: number | undefined;
+    readonly request: RequestOptions;
+}
+interface Discovery {
+    readonly chain: GeeqDiscoveredChain;
+    /** Every node listed for the chain, in directory order. */
+    readonly nodes: readonly GeeqDiscoveredNode[];
+    /** Those that will actually take a transaction. */
+    readonly usable: readonly GeeqDiscoveredNode[];
+}
+/**
+ * Find a chain in the directory and list its nodes.
+ *
+ * This reads two routes and nothing else. The directory is a deployment control plane:
+ * it has no authentication, and its other routes create and destroy machines and serve
+ * private keys. Treat every value it returns as a hint about *where* to look, never as
+ * authority about the chain itself — that comes from the ledger.
+ */
+declare function discover(options: DiscoverOptions): Promise<Discovery>;
+
+/** What kind of actor a net actor record describes. */
+type GeeqNodeRole = 'anchor-node' | 'anon-node' | 'cert-node' | 'cert-authority' | 'chain-admin' | 'relay' | 'treasury-agent' | 'unknown';
+/** What that actor is currently doing. */
+type GeeqNodeStatus = 'chain-admin' | 'hub' | 'leaving' | 'listening' | 'node' | 'ready' | 'relay' | 'suspended' | 'unknown';
+/** One net actor record, as plain values. */
+interface GeeqLedgerNode {
+    /** `nodeNumSelf` — what a transaction must name, checked with strict equality. */
+    readonly nodeNumber: number;
+    /** The bare IP the ledger records. Nodes are matched on this and nothing else. */
+    readonly host: string;
+    /**
+     * The port recorded against this node in the ledger.
+     *
+     * **Not the port you connect to.** Clients always reach a node on 2082, where TLS is
+     * terminated; every first-party client ignores this field and rebuilds the URL from
+     * its own configuration. Exposed for diagnostics, and used only to break a tie when
+     * one address carries several records.
+     */
+    readonly port: number;
+    readonly role: GeeqNodeRole;
+    readonly status: GeeqNodeStatus;
+    /**
+     * True when the protocol permits this node to accept transactions.
+     *
+     * **Not a liveness signal.** Nothing in the protocol evicts a crashed node from the
+     * net actor list, and `blockNumLiveness` is rewritten for every actor on every commit
+     * rather than per node, so it carries no health information at all. A node that died
+     * an hour ago still reads as processing here. The only way to learn a node is up is
+     * to talk to it.
+     */
+    readonly processing: boolean;
+    /**
+     * `blockNumRemove` — the block at which this node's turn in the active set ends.
+     *
+     * Reset 100–355 blocks ahead each time the node is promoted, so it is a rotation
+     * deadline rather than a departure flag.
+     */
+    readonly retiresAtBlock: number;
+    /**
+     * True when this node is inside its own shutdown window and will refuse work.
+     *
+     * The node's submit handler answers HTTP 503 `'Block chain is stopped'` once its
+     * `blockNumRemove` is less than its current block plus two, so this is knowable from
+     * the ledger before a transaction is ever built.
+     */
+    readonly retiring: boolean;
+}
+
+/** @internal — built by {@link decodeValidationLedger}, never by hand. */
+interface GeeqLedgerInit {
+    readonly chainNumber: number;
+    readonly blockNumber: number;
+    readonly nodes: readonly GeeqLedgerNode[];
+    readonly metadataLimits: GeeqMetadataLimits | undefined;
+    readonly minimumTransfer: bigint | undefined;
+    readonly geeqNorm: bigint | undefined;
+    readonly accounts: ReadonlyMap<string, CoinAccountFacts>;
+    readonly proxies: ReadonlyMap<string, ProxyAccountFacts>;
+    readonly readAt: number;
+    readonly nodeUrl: string | undefined;
+}
+/**
+ * One validation layer ledger, decoded into plain values.
+ *
+ * This is a snapshot, not a view: the Cap'n Proto `Message` it came from is released
+ * the moment decoding finishes. That is deliberate and load-bearing. capnp-ts counts a
+ * traversal budget per `Message` and never resets it, so a retained handle rescanned on
+ * every transaction eventually throws `PTR_TRAVERSAL_LIMIT_EXCEEDED`; and reading a
+ * malformed union arm mutates the message in place. Neither can happen to a snapshot.
+ *
+ * It holds no WebAssembly handle, so unlike a keypair it needs no `dispose()`.
+ */
+declare class GeeqLedger {
+    /** The ledger's own chain number. A transaction must name exactly this. */
+    readonly chainNumber: number;
+    /** N — the last block committed to this ledger. */
+    readonly blockNumber: number;
+    /** N + 1 — the block a transaction built now should ask for. */
+    readonly targetBlockNumber: number;
+    /** Every net actor, in ledger order. */
+    readonly nodes: readonly GeeqLedgerNode[];
+    /** Undefined when this chain publishes no metadata parameters. */
+    readonly metadataLimits: GeeqMetadataLimits | undefined;
+    /**
+     * The smallest transfer this chain accepts, in pennies.
+     *
+     * Undefined when the chain does not publish the parameters it is derived from.
+     */
+    readonly minimumTransfer: bigint | undefined;
+    /**
+     * The chain's `geeqNorm` parameter, which the minimum transfer and every fee are
+     * multiples of. Undefined when the chain does not publish it.
+     */
+    readonly geeqNorm: bigint | undefined;
+    /** `Date.now()` when this was read, so callers can judge staleness. */
+    readonly readAt: number;
+    /** The node it was read from, when it came from one. */
+    readonly nodeUrl: string | undefined;
+    private readonly accounts;
+    private readonly proxies;
+    /** @internal */
+    constructor(init: GeeqLedgerInit);
+    /** The nodes that will actually accept a transaction. */
+    get processingNodes(): readonly GeeqLedgerNode[];
+    /**
+     * Find a net actor record.
+     *
+     * By `host` this matches the bare IP and nothing else — every first-party client does
+     * the same, because a record's `port` is the node's internal listen port while clients
+     * connect through a proxy on another one. Matching on both finds nothing.
+     */
+    findNode(match: {
+        readonly host: string;
+    } | {
+        readonly nodeNumber: number;
+    }): GeeqLedgerNode | undefined;
+    /** Every net actor record at one host. More than one is possible, and ambiguous. */
+    findNodes(host: string): readonly GeeqLedgerNode[];
+    /**
+     * The signing account's coin record, or `undefined` when this chain has none for it.
+     *
+     * Absence is the ordinary state of a freshly generated keypair: an account appears in
+     * the ledger only once it has been funded.
+     */
+    findCoinAccount(account: AccountRef): GeeqCoinAccount | undefined;
+    /** A proxy record, or `undefined` when this chain has none with that id. */
+    findProxyAccount(account: AccountRef): GeeqProxyAccount | undefined;
+    /**
+     * Every NFT mint proxy an account administers — the ones it can mint through.
+     *
+     * Found by the admin each record names, so it needs nothing remembered from when they
+     * were created.
+     */
+    findProxyAccounts(match: {
+        readonly admin: AccountRef;
+    }): readonly GeeqProxyAccount[];
+    /** How many coin accounts this ledger carries. Mostly useful for diagnostics. */
+    get coinAccountCount(): number;
+    /** Summary only — the account table is far too large to serialise. */
+    toJSON(): Record<string, unknown>;
+    toString(): string;
+}
+
+/** The protocol attests a 32-byte BLAKE3 digest and rejects any other length. */
+declare const ATTEST_HASH_BYTES = 32;
+/**
+ * Anything that can be attested.
+ *
+ * A `File` from an `<input type="file">` is a `Blob`, so it can be passed straight in —
+ * there is no need to read it into a buffer first. A string is encoded as UTF-8.
+ */
+type GeeqContent = Uint8Array | ArrayBuffer | Blob | string;
+/** Read any accepted content into bytes. Async only because a `Blob` requires it. */
+declare function readContent(content: GeeqContent): Promise<Uint8Array>;
+/**
+ * The digest that goes on chain.
+ *
+ * The content itself never leaves the device; only this does. Pure BLAKE3, so it needs
+ * no engine and no network and works before {@link initGeeq} has resolved — which is
+ * what lets a UI show the digest as someone types.
+ *
+ * Use this rather than calling a hash library directly: the length and the algorithm are
+ * both fixed by the protocol, and a digest of any other width is rejected when the
+ * transaction is built.
+ */
+declare function attestHashOfSync(content: Uint8Array | ArrayBuffer | string): Uint8Array;
+/** {@link attestHashOfSync}, also accepting a `Blob` or a `File`. */
+declare function attestHashOf(content: GeeqContent): Promise<Uint8Array>;
+/** Reject a digest the chain would refuse, naming what was wrong. */
+declare function assertAttestHash(attestHash: unknown): Uint8Array;
+
+/** @internal */
+interface NodeRequestConfig {
+    readonly transport: GeeqTransport;
+    readonly timeoutMs: number;
+    readonly retries: number;
+    readonly headers: Readonly<Record<string, string>> | undefined;
+}
+/** @internal */
+interface GeeqNodeInit extends NodeRequestConfig {
+    readonly url: string;
+    readonly nodeNumber: number;
+    readonly host: string;
+    readonly port: number;
+    readonly role: GeeqNodeRole;
+    readonly status: GeeqNodeStatus;
+    readonly processing: boolean;
+}
+/**
+ * One node, identified in its own chain's ledger.
+ *
+ * A node is only meaningful once a ledger has confirmed which actor it is: the number a
+ * transaction must carry is the node's own `nodeNumSelf`, checked with strict equality,
+ * and nothing outside the ledger reports it.
+ */
+declare class GeeqNode {
+    /** Absolute origin, no trailing slash. */
+    readonly url: string;
+    /** `nodeNumSelf` — what a transaction targeting this node must name. */
+    readonly nodeNumber: number;
+    /** The bare IP the ledger records for it. */
+    readonly host: string;
+    /** Its own listen port from the ledger, which is not necessarily {@link url}'s. */
+    readonly port: number;
+    readonly role: GeeqNodeRole;
+    readonly status: GeeqNodeStatus;
+    /** Whether it accepts transactions at all. */
+    readonly processing: boolean;
+    private readonly request;
+    /** @internal */
+    constructor(init: GeeqNodeInit);
+    /**
+     * Where a transaction built for this node must be POSTed.
+     *
+     * The SDK does not submit. This exists so an application posts to the node the SDK
+     * actually read from, instead of keeping a second copy of the URL that can drift.
+     */
+    get submitUrl(): string;
+    /** Read this node's current ledger. No caching — {@link GeeqChain} owns that. */
+    readLedger(options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<GeeqLedger>;
+    toJSON(): Record<string, unknown>;
+    toString(): string;
+}
+
+interface GeeqChainOptions {
+    /**
+     * How many pennies make one Geeq: a power of ten, as a bigint.
+     *
+     * The chain counts only pennies and does not publish this, so the app says — use the
+     * divisor its wallet and explorer show amounts with. {@link GeeqChain.toPennies} reads
+     * `{ geeq }` figures with it, and {@link GeeqChain.formatGeeq} and the chain's own
+     * messages show amounts with it.
+     */
+    readonly penniesPerGeeq: bigint;
+    /**
+     * The chain's node directory — the simulator URL for your environment — which the SDK
+     * asks for an active node. Works for every chain and environment.
+     *
+     * Supply this or {@link endpoint}, not both. The directory is the only thing that
+     * knows which nodes exist and which are running; the ledger then says which actor the
+     * chosen one is. Note the directory is a deployment control plane with no
+     * authentication — the SDK reads two of its routes and never touches the rest.
+     */
+    readonly discovery?: string | URL;
+    /**
+     * A specific node, when you already know one.
+     *
+     * Supply this or {@link discovery}, not both.
+     */
+    readonly endpoint?: string | URL;
+    /**
+     * Which chain to use, by the name its directory gives it.
+     *
+     * Only meaningful with {@link discovery} — a name exists nowhere but the directory.
+     * Matched case-insensitively.
+     */
+    readonly chainName?: string;
+    /**
+     * Which chain to use, by protocol number.
+     *
+     * With {@link discovery} this selects the chain when no {@link chainName} is given,
+     * and asserts it when one is. With {@link endpoint} it asserts the node serves the
+     * chain you expect, and a mismatch throws `chain-mismatch` on the first ledger read.
+     */
+    readonly chainNumber?: number;
+    /** Defaults to a call through `globalThis.fetch`. */
+    readonly transport?: GeeqTransport;
+    /** Per request. Defaults to 10000. */
+    readonly timeoutMs?: number;
+    /** Extra headers on every request — a proxy token, a trace id. */
+    readonly headers?: Readonly<Record<string, string>>;
+    /** How long a read ledger may be reused. Defaults to 5000. 0 disables the cache. */
+    readonly ledgerMaxAgeMs?: number;
+    /** Skip host matching. Required behind a gateway or when using a DNS name. */
+    readonly nodeNumber?: number;
+    /**
+     * The port discovered nodes are reached on. Defaults to 2082.
+     *
+     * Deployment configuration, not node selection — override it only when running
+     * against nodes that are not behind the standard TLS front door, such as a local
+     * test harness.
+     */
+    readonly nodePort?: number;
+    /** Retries on transport failure only, never on a response. Defaults to 1. */
+    readonly retries?: number;
+    readonly signal?: AbortSignal;
+}
+interface AttestationRequest {
+    /** The account that signs. Must be a coin-asset account on this chain. */
+    readonly keypair: GeeqKeypair;
+    /**
+     * What to attest. Hashed here with BLAKE3-32; the content never leaves the device.
+     *
+     * A `File` straight from a file input works, as does a string or raw bytes.
+     */
+    readonly content?: GeeqContent;
+    /** Or supply the digest yourself. Exactly one of `content` and `attestHash`. */
+    readonly attestHash?: Uint8Array;
+    /** Public labels, checked against this chain's limits before anything is signed. */
+    readonly metadata?: readonly (string | Uint8Array)[];
+    /** Override the derived nonce. See {@link NonceGuard} for when that is needed. */
+    readonly nonce?: number;
+    readonly signal?: AbortSignal;
+}
+interface CoinTransferRequest {
+    /** The account paying. Must be a coin-asset account on this chain. */
+    readonly from: GeeqKeypair;
+    /**
+     * Who receives it.
+     *
+     * A base58 wallet address is the usual thing — it is what a person pastes — and the
+     * chain it encodes is checked against this one. A raw account id or public key works
+     * too, but carries no chain to check.
+     */
+    readonly to: string | AccountRef;
+    /**
+     * How much. State the unit: `{ geeq: "1.5" }`, read at {@link GeeqChainOptions.penniesPerGeeq},
+     * or `{ pennies }` as the chain counts them. May be left out
+     * when sending NFTs, which then go with the chain's minimum transfer.
+     */
+    readonly amount?: GeeqAmount;
+    /** NFTs to send, by id — see {@link GeeqChain.findNfts}. The sender must hold each one. */
+    readonly nfts?: readonly Uint8Array[];
+    /** Override the derived nonce. See {@link NonceGuard}. */
+    readonly nonce?: number;
+    readonly signal?: AbortSignal;
+}
+interface ChainStateRequest {
+    readonly account: AccountRef;
+    readonly maxAgeMs?: number;
+    readonly signal?: AbortSignal;
+}
+interface NftMintProxyRequest {
+    /**
+     * The account paying for the proxy, which also becomes its admin: the only key that
+     * can later mint NFTs through it. Must be a coin-asset account on this chain.
+     */
+    readonly admin: GeeqKeypair;
+    /**
+     * Coin moved onto the proxy, `{ geeq }` or `{ pennies }` like any amount. It pays for the
+     * mints made through it, so fund it for more than one.
+     */
+    readonly amount: GeeqAmount;
+    /**
+     * Which of the admin's proxies this is, from 1. Leave it out to take the next one —
+     * one past the highest the ledger holds for this admin, see
+     * {@link GeeqChain.findNftMintProxies}. An index already in use is refused.
+     */
+    readonly index?: number;
+    /** Override the derived nonce. See {@link NonceGuard}. */
+    readonly nonce?: number;
+    readonly signal?: AbortSignal;
+}
+interface NftMintProxiesRequest {
+    /**
+     * The admin whose proxies to find. A keypair will do; so will a bare public key, since
+     * listing needs no signature. Not an account id: an index is derived from the key.
+     */
+    readonly admin: {
+        readonly publicKey: Uint8Array;
+    };
+    /** How old a cached ledger may be. 0 reads afresh — a new proxy shows only once confirmed. */
+    readonly maxAgeMs?: number;
+    readonly signal?: AbortSignal;
+}
+interface NftsRequest {
+    /** Whose NFTs. A keypair will do, as will an account id or a public key. */
+    readonly owner: AccountRef;
+    /** How old a cached ledger may be. 0 reads afresh — a new NFT shows only once confirmed. */
+    readonly maxAgeMs?: number;
+    readonly signal?: AbortSignal;
+}
+interface NftMintRequest {
+    /** The proxy's admin: the only key that can mint through it. It signs the mint. */
+    readonly admin: GeeqKeypair;
+    /**
+     * Which of the admin's proxies mints it, by index — see
+     * {@link GeeqChain.findNftMintProxies}. The proxy pays the fee and {@link amount}, and
+     * spends its own nonce, not the admin's.
+     */
+    readonly index: number;
+    /**
+     * What the NFT stands for. Hashed here with BLAKE3-32; the content never leaves the
+     * device. A `File` straight from a file input works, as does a string or raw bytes.
+     */
+    readonly content?: GeeqContent;
+    /** Or supply the digest yourself. Exactly one of `content` and `attestHash`. */
+    readonly attestHash?: Uint8Array;
+    /** Public labels stored with the NFT, checked against this chain's limits before signing. */
+    readonly metadata?: readonly (string | Uint8Array)[];
+    /** Who receives the NFT. Defaults to the admin. An address is checked against this chain. */
+    readonly to?: string | AccountRef;
+    /** Coin the proxy sends to the receiver with it. Defaults to the chain's minimum transfer. */
+    readonly amount?: GeeqAmount;
+    /** Override the proxy's derived nonce. See {@link NonceGuard}. */
+    readonly nonce?: number;
+    readonly signal?: AbortSignal;
+}
+/**
+ * A chain, reached through one node.
+ *
+ * Holds the node directory, the metadata limits and a short-lived ledger cache, so an
+ * attestation needs only a keypair and something to attest. Everything a transaction is
+ * pinned to — chain number, target block, node number, nonce — is read from the ledger
+ * rather than asked of the caller, because none of it can be known offline and a wrong
+ * value is rejected by the chain.
+ *
+ * A chain is bound to the endpoint it was connected to. To use a different node, connect
+ * another one: a different node means a different address, certificate and CORS origin,
+ * which is not something to switch silently.
+ *
+ * In a reactive framework, mark an instance raw (Vue's `markRaw`) rather than letting it
+ * be proxied.
+ */
+declare class GeeqChain {
+    /** The node this chain reads from and builds transactions for. */
+    readonly endpoint: string;
+    /** What the directory said about the nodes on this chain, when one was used. */
+    readonly candidates: readonly GeeqDiscoveredNode[];
+    /** The chain's name, when a directory supplied one. Display only — chains are numbered. */
+    readonly chainName: string | undefined;
+    /** How many pennies make one Geeq, as given to {@link GeeqChain.connect}. */
+    readonly penniesPerGeeq: bigint;
+    private readonly request;
+    private readonly ledgerMaxAgeMs;
+    private readonly nonces;
+    private readonly declaredChainNumber;
+    private readonly nodeNumberOverride;
+    private cached;
+    private resolved;
+    private inflight;
+    /** @internal */
+    constructor(init: {
+        endpoint: string;
+        candidates: readonly GeeqDiscoveredNode[];
+        chainName: string | undefined;
+        chainNumber: number | undefined;
+        nodeNumber: number | undefined;
+        penniesPerGeeq: bigint;
+        request: NodeRequestConfig;
+        ledgerMaxAgeMs: number;
+    });
+    /**
+     * Choose a chain and a node, without reading anything from the chain itself.
+     *
+     * With `discovery`, the directory is asked which nodes exist and one of the active
+     * ones is taken. With `endpoint`, that node is used as given. Either way **no ledger
+     * is fetched here** — a ledger read is only valid for a few blocks, so it happens when
+     * a transaction is actually being built rather than when the app starts.
+     */
+    static connect(options: GeeqChainOptions): Promise<GeeqChain>;
+    /** {@link GeeqChain.connect}, and install the result as the process-wide default. */
+    static init(options: GeeqChainOptions): Promise<GeeqChain>;
+    /** The default chain. Throws `not-initialized` when there is none. */
+    static current(): GeeqChain;
+    /** Whether a default chain has been installed. */
+    static get initialized(): boolean;
+    /** Clear the default. Call this from `afterEach` so tests do not leak into each other. */
+    static reset(): void;
+    /** Resolve an amount to pennies, reading a `{ geeq }` figure at {@link penniesPerGeeq}. */
+    toPennies(amount: GeeqAmount): bigint;
+    /** Show pennies as a Geeq figure at {@link penniesPerGeeq}, as the Geeq wallet does. */
+    formatGeeq(pennies: bigint): string;
+    /**
+     * This chain's number.
+     *
+     * Known immediately when a directory named the chain, or once a ledger has been read.
+     * `undefined` in between — with a bare endpoint and no declared number, only the node
+     * can say.
+     */
+    get chainNumber(): number | undefined;
+    /**
+     * The node, once a ledger read has identified it in the net actor list.
+     *
+     * `undefined` until then: a node's number is the one thing the directory cannot say,
+     * so it is not known before the first read.
+     */
+    get node(): GeeqNode | undefined;
+    /** The net actor directory from the last ledger read, if there has been one. */
+    get nodes(): readonly GeeqLedgerNode[];
+    /** Those of them that accept transactions. */
+    get processingNodes(): readonly GeeqLedgerNode[];
+    /** The ledger from the last read, if it is still cached. */
+    get ledger(): GeeqLedger | undefined;
+    /**
+     * A URL for another node in this chain.
+     *
+     * Every node answers client traffic on {@link GEEQ_NODE_PORT}, so only the scheme is
+     * carried over from the endpoint in use. The port recorded against a node in the
+     * ledger is its own internal listener and is never what you connect to.
+     */
+    endpointFor(host: string): string;
+    /**
+     * The current ledger, from cache when it is fresh enough.
+     *
+     * Staleness is safe in exactly one direction. The node accepts a target block within
+     * `[N-8, N+1]` of its own head, and a cached ledger can only be *behind*, so the
+     * target it yields is never in the future — the only rejected direction. The default
+     * five seconds is set by the node list and metadata limits, which have no such
+     * tolerance, not by the block window.
+     */
+    getLedger(options?: {
+        readonly maxAgeMs?: number;
+        readonly signal?: AbortSignal;
+    }): Promise<GeeqLedger>;
+    /** Discard the cached ledger and read again. */
+    refresh(options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<GeeqLedger>;
+    /**
+     * One read at a time.
+     *
+     * Same single-flight shape as `initGeeq`, including clearing the promise on failure so
+     * a later call can retry rather than being stuck with the first error. Without it, a
+     * page that builds several transactions at once pulls the whole ledger several times
+     * from an endpoint with no rate limiting of any kind.
+     *
+     * The read is shared, so it carries no caller's signal: one caller aborting must not
+     * fail the others waiting on it. Each caller stops waiting on its own signal instead,
+     * and the read runs on, bounded by `timeoutMs`, to fill the cache for whoever is next.
+     */
+    private read;
+    /**
+     * Everything a transaction must be pinned to, read from this chain.
+     *
+     * Throws rather than guessing when the account cannot sign: absent from the ledger
+     * (the ordinary state of an unfunded keypair), or present as a record type the
+     * protocol will not accept.
+     */
+    getChainState(request: ChainStateRequest): Promise<GeeqChainState>;
+    /**
+     * What every transaction built from `ledger` is pinned to, bar the signer's nonce: the
+     * same for a signer's own transaction and for a proxy's.
+     */
+    private pinnedTo;
+    /** {@link getChainState} against a ledger already in hand, so a build reads only one. */
+    private stateIn;
+    /**
+     * The ledger a build is made from, and the state of `signer` in it.
+     *
+     * A cached ledger is up to a few seconds old, so "this account already built against
+     * this block" may only mean "we are looking at an old block". Look again once before
+     * letting the nonce guard refuse — otherwise a caller who waited out the block interval
+     * is told to wait for a block that has already passed. An explicit nonce is the caller
+     * taking responsibility, so it skips the check.
+     *
+     * Everything the build then needs — what the sender holds, which proxies exist — comes
+     * from this same ledger, so it all describes one block.
+     */
+    private readForBuild;
+    /** Read afresh if `guardKey` already built against `ledger`'s block. See {@link readForBuild}. */
+    private recheckIfClaimed;
+    /**
+     * Build and sign an attestation, deriving everything the chain decides.
+     *
+     * This is where the ledger is read, because this is the first moment the values it
+     * carries are actually needed — and they go stale within a handful of blocks, so
+     * reading them any earlier would only mean reading them twice.
+     *
+     * The result is **not submitted**. Hand it to {@link GeeqSocket.track} first, so its
+     * verdict has somewhere to arrive, then POST `transaction` and `payload` to
+     * {@link AttestationTx.nodeUrl}; any other node rejects it, because the node number is
+     * checked with strict equality.
+     */
+    createAttestation(input: AttestationRequest): Promise<AttestationTx>;
+    /**
+     * Record the nonce a finished build took, so a second build against the same block is
+     * refused rather than sent to share it.
+     *
+     * Claimed only once a transaction really exists, so a build that failed validation does
+     * not consume the account's one nonce for this block. An explicit nonce is the caller
+     * taking responsibility, so it bypasses the guard entirely.
+     */
+    private claimNonce;
+    /**
+     * Resolve a recipient, checking the chain it belongs to when one is stated.
+     *
+     * An address carries a chain number, and an address from another chain is almost
+     * always a paste from the wrong place. The account id inside it would still be
+     * technically usable here, which is exactly why this is worth refusing rather than
+     * quietly sending.
+     */
+    private resolveRecipient;
+    /**
+     * Send coin to another account, and NFTs with it if you name them.
+     *
+     * Reads the ledger, so it also knows what the sender holds and what the chain's minimum
+     * transfer is. The amount is checked against the minimum, and the sender's NFTs against
+     * the ones named, before anything is signed; the balance against the amount plus the
+     * fee once the signed transaction gives the fee. NFTs always travel with coin: leave
+     * `amount` out and they go with the chain's minimum transfer.
+     *
+     * The result is **not submitted**. Hand it to {@link GeeqSocket.track} first, then POST
+     * `transaction` to {@link CoinTransferTx.nodeUrl} using `coinTransferSubmitBody`, which
+     * sends it as type `uvt` — a different shape from an attestation, and with no separate
+     * payload.
+     */
+    createTransfer(input: CoinTransferRequest): Promise<CoinTransferTx>;
+    /**
+     * The NFTs an account holds on this chain, in the order its record lists them, each with
+     * the hash and labels it was minted with.
+     *
+     * Which NFTs it holds comes from the validation layer ledger; what each stands for, from
+     * the application layer ledger, which is read afresh every time. An account the chain
+     * does not know holds none. A new NFT shows once a block has confirmed it, so pass
+     * `maxAgeMs: 0` to look straight after one was minted or sent.
+     */
+    findNfts(request: NftsRequest): Promise<readonly GeeqNft[]>;
+    /**
+     * The NFT mint proxies an admin has on this chain, each with its index, and the index
+     * its next proxy takes: one past the highest in use, or 1 for an admin with none.
+     *
+     * A proxy appears once a block has confirmed it, so pass `maxAgeMs: 0` to look
+     * straight after one was submitted.
+     */
+    findNftMintProxies(request: NftMintProxiesRequest): Promise<GeeqNftMintProxies>;
+    /**
+     * Create a proxy to mint NFTs through.
+     *
+     * A proxy is a record of its own: it holds coin, carries its own nonce, and names one
+     * admin — `admin` here — who signs every mint made through it. Its id is derived from
+     * the admin's key and an index, as the Geeq wallet derives it: by default the next
+     * index {@link findNftMintProxies} reports, so it is found again from the key alone.
+     *
+     * Checks the funding against the chain's minimum, and the admin's balance against the
+     * funding plus the fee. The result is **not submitted** — track it, then post it with
+     * `coinTransferSubmitBody`, exactly as a transfer. The proxy exists once a block
+     * confirms it.
+     */
+    createNftMintProxy(input: NftMintProxyRequest): Promise<NftMintProxyTx>;
+    /**
+     * Mint an NFT through one of the admin's proxies.
+     *
+     * The proxy is the sender: it pays the fee and the coin sent with the NFT, and spends
+     * its own nonce, not the admin's. The admin signs. The NFT itself is the content's hash
+     * and labels, as an attestation is, and its id is derived from them — so the same
+     * content with the same labels through the same proxy cannot be minted twice.
+     *
+     * Reads the ledger to find the proxy and check what it holds. The result is **not
+     * submitted** — track it, then post it with `attestationSubmitBody`, exactly as an
+     * attestation: two fields, as `uat`.
+     */
+    mintNft(input: NftMintRequest): Promise<NftMintTx>;
+    /**
+     * Whether a built transaction is now too old to send: the chain is past its
+     * `validUntilBlock`, and a node would refuse it with an HTTP 400.
+     *
+     * Reads the ledger afresh, because a cached one can only be behind the chain and would
+     * say "not yet" when it already is. Call it before submitting a transaction that may
+     * have waited.
+     */
+    isExpired(tx: {
+        readonly validUntilBlock: number;
+    }): Promise<boolean>;
+    /**
+     * Give back the nonce a built transaction took, because it will never be sent — the
+     * user changed something and is building again. The next build may then take the same
+     * nonce in the same block instead of being refused with `nonce-collision`.
+     *
+     * Only for a transaction that was not submitted: if it reaches the node as well as its
+     * rebuild, the two share a nonce and the node rejects both.
+     */
+    discard(tx: {
+        readonly transactionHash: Uint8Array;
+    }): void;
+    /** Forget which accounts have built a transaction against the current block. */
+    forgetNonces(): void;
+    /** Drop cached state, and step down as the default if this chain holds that slot. */
+    dispose(): void;
+    toJSON(): Record<string, unknown>;
+    toString(): string;
+}
+/**
+ * Connect to a chain and make it the default.
+ *
+ * Thin alias for {@link GeeqChain.init} — the name most applications reach for, and one
+ * line so there is no second implementation to keep in step.
+ *
+ * ```ts
+ * await initChain({ endpoint: 'https://1.2.3.4:2082' })
+ * const tx = await attest({ keypair, content: fileBytes })
+ * ```
+ */
+declare function initChain(options: GeeqChainOptions): Promise<GeeqChain>;
+/** Build an attestation on the default chain. See {@link GeeqChain.createAttestation}. */
+declare function attest(input: AttestationRequest): Promise<AttestationTx>;
+/** Send coin on the default chain. See {@link GeeqChain.createTransfer}. */
+declare function transfer(input: CoinTransferRequest): Promise<CoinTransferTx>;
+
+/**
+ * The port every Geeq node answers client traffic on.
+ *
+ * Nodes terminate TLS on 2082 and that is the only client-facing port; an endpoint
+ * given without one is resolved to it rather than to the scheme's default, because a
+ * request to 443 would fail opaquely in a browser with no way to tell why.
+ */
+declare const GEEQ_NODE_PORT = 2082;
+interface SelectNodeOptions {
+    /** Skip host matching entirely. Required behind a gateway or a DNS name. */
+    readonly nodeNumber?: number | undefined;
+}
+/**
+ * Choose the net actor record that a transaction should name.
+ *
+ * Matching is on **host only**. A record's `port` is the node's own listen port, while
+ * a client reaches it through a proxy on another one, so requiring both to agree finds
+ * nothing on a correctly deployed chain. Port is used solely to disambiguate when one
+ * address carries several records.
+ *
+ * This never silently retargets. A different node means a different address, a
+ * different certificate, a different CORS origin and a different operator seeing the
+ * transaction, so an unusable node is reported with its alternatives and the caller
+ * decides.
+ */
+declare function selectNode(ledger: GeeqLedger, endpoint: string | URL, options?: SelectNodeOptions): GeeqLedgerNode;
+
+/**
+ * Every node route the SDK knows, in one place.
+ *
+ * `origin` is an absolute node URL with no trailing slash — see `originOf`.
+ */
+/** `GET` the current validation layer ledger, base64 packed capnp under `result`. */
+declare function ledgerRoute(origin: string): string;
+/**
+ * Where a signed transaction is POSTed.
+ *
+ * The SDK does not submit — this is exported so an application builds the same URL the
+ * SDK read from, rather than keeping its own copy of the path.
+ */
+declare function submitRoute(origin: string): string;
+/**
+ * The node's client WebSocket, where transaction status events arrive.
+ *
+ * Same host and port as the HTTP API — the node's TLS front door routes `/ws/` to the
+ * socket server and `/api/` to the HTTP one — so the only change is the scheme. The
+ * trailing slash is part of the route: the proxy answers `/ws` with a redirect, and a
+ * WebSocket handshake treats a redirect as failure.
+ */
+declare function socketRoute(origin: string): string;
+/**
+ * The body a node expects for an application-layer transaction: an attestation or an NFT
+ * mint, each a transaction and its payload.
+ */
+declare function attestationSubmitBody(transaction: string, payload: string): string;
+/**
+ * The body a node expects for a coin transfer.
+ *
+ * A different type and a different shape from an attestation: a validation-layer
+ * transaction carries no separate payload, so there is one blob rather than two.
+ */
+declare function coinTransferSubmitBody(transaction: string): string;
+
+/** A transaction as a block explorer reports it, field for field. */
+interface GeeqExplorerTransaction {
+    /** Hex — the form the explorer files transactions under. */
+    readonly refHash: string;
+    /** The transaction's kind, such as `coin`. */
+    readonly type: string;
+    /** The explorer's verdict on it. */
+    readonly status: string;
+    readonly block: number;
+    readonly chainName: string;
+    readonly chainNumber: number;
+    /** The sender's wallet address. */
+    readonly from: string;
+    readonly senderType: string;
+    /** The receiver's wallet address, or empty when it has none. */
+    readonly to: string;
+    readonly receiverType: string;
+    readonly publicKey: string;
+    readonly signature: string;
+    readonly createdAt: string;
+    readonly fee: string;
+    readonly acctNumApp?: string;
+    /** What it moved — coin, tokens, NFTs — with amounts as decimal strings. */
+    readonly values: readonly {
+        readonly type: string;
+        readonly value: string;
+        readonly name?: string;
+    }[];
+    /** An attestation's hash and metadata. */
+    readonly payload?: {
+        readonly attestationHash: string;
+        readonly metadata: readonly string[];
+    };
+}
+interface ExplorerTransactionRequest {
+    /** The explorer's base URL, such as `https://blkexp.geeq-test.io`. */
+    readonly explorerUrl: string | URL;
+    /**
+     * The transaction's refHash in base64 — what `transactionIdOf(tx)` returns and socket
+     * status events carry. It is sent to the explorer as hex.
+     */
+    readonly refHash: string;
+    /** Defaults to `globalThis.fetch`. */
+    readonly transport?: GeeqTransport;
+    /** Defaults to 10000. */
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+}
+/**
+ * Look a transaction up in a block explorer by its refHash.
+ *
+ * Resolves `null` when the explorer does not have it — not indexed yet, or never put in a
+ * block. The explorer only knows a transaction once a block has decided it, so for one
+ * you have just sent, the node socket answers first.
+ */
+declare function getExplorerTransaction(request: ExplorerTransactionRequest): Promise<GeeqExplorerTransaction | null>;
+
+/** What a WebSocket hands its `message` listeners, narrowed to the one field read. */
+interface GeeqWebSocketMessageEvent {
+    readonly data: unknown;
+}
+/**
+ * A WebSocket, narrowed to what this SDK uses.
+ *
+ * Deliberately structural, like {@link GeeqTransport}: a browser `WebSocket`, Node 22's
+ * global one and the `ws` package's class all satisfy it with no adapter, and so does a
+ * scripted fake in a test. Listeners are attached with `addEventListener` rather than
+ * `onmessage` and friends because a method is compared bivariantly, which is what lets
+ * each implementation's own event types through.
+ */
+interface GeeqWebSocketLike {
+    readonly readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: 'open', listener: (event: unknown) => void): void;
+    addEventListener(type: 'message', listener: (event: GeeqWebSocketMessageEvent) => void): void;
+    addEventListener(type: 'close', listener: (event: unknown) => void): void;
+    addEventListener(type: 'error', listener: (event: unknown) => void): void;
+}
+/**
+ * How the SDK opens a socket.
+ *
+ * `(url) => new WebSocket(url)` is the whole contract. Pass one to use the `ws` package on
+ * Node 20, to add headers or a TLS agent there, or to script a connection in a test.
+ */
+type GeeqWebSocketFactory = (url: string) => GeeqWebSocketLike;
+/**
+ * `new globalThis.WebSocket(url)`, resolved at call time.
+ *
+ * Never a stored reference, for the same reason as `defaultTransport`: a test that swaps
+ * the global after import must still be honoured. Node 20 has no global WebSocket at all,
+ * and a library that supports Node 20 cannot assume one, so its absence is reported with
+ * the one-line fix rather than as a `TypeError`.
+ */
+declare const defaultWebSocketFactory: GeeqWebSocketFactory;
+
+/**
+ * The four verdicts a node reports for a transaction, by their protocol names.
+ *
+ * - `valid` — committed in a block. Final.
+ * - `invalid` — placed in a block's invalid list, typically a nonce or solvency failure
+ *   found at commit. Final, and **the sender is still charged the fee**.
+ * - `incorrectlyIncluded` — carried by a node the chain judged dishonest. Final; not the
+ *   sender's fault.
+ * - `nonsane` — refused by the receiving node, at intake (alongside an HTTP 400) or at block
+ *   selection (after a 200). The node drops it, so it is final in practice — but a node
+ *   restarting can carry its buffer forward, and then a later verdict follows.
+ *
+ * From geeq_node_core `UutStatuses` (actors/interfaces.ts).
+ */
+type GeeqTxVerdict = 'nonsane' | 'incorrectlyIncluded' | 'invalid' | 'valid';
+/**
+ * One `uut_status` event, normalised.
+ *
+ * Every field is what the node sent, renamed only where the wire name misleads. Nothing
+ * is inferred: in particular `vlbBlock` is passed through as reported and not treated as
+ * the inclusion block, because on current nodes it is one ahead of it for `valid` and
+ * `invalid` events.
+ */
+interface GeeqTxStatusEvent {
+    /**
+     * The transaction's refHash, standard base64 — compare it with `transactionIdOf(tx)`.
+     * Always the transaction hash, never the payload hash.
+     */
+    readonly id: string;
+    readonly verdict: GeeqTxVerdict;
+    /** The node's own boolean: true exactly when `verdict` is `valid`. */
+    readonly isValid: boolean;
+    /** The node's reason, verbatim. Empty when valid. Show it; never parse it. */
+    readonly error: string | undefined;
+    /** The transaction's own target block, as the node reports it. */
+    readonly blockNumber: number | undefined;
+    /** The node's `vlbBlock`, as reported. See the note above before relying on it. */
+    readonly vlbBlock: number | undefined;
+    /**
+     * `outgoing` on the sender's copy, `incoming` on the receiver's, when the node says —
+     * older nodes do not. Do not use it to tell your own transactions apart: match on
+     * {@link id} instead.
+     */
+    readonly direction: 'incoming' | 'outgoing' | undefined;
+    /** The signer's base64 public key. */
+    readonly signer: string | undefined;
+    /** When the node stamped it. Second precision. */
+    readonly createdAt: Date | undefined;
+    /** The event's payload exactly as it arrived, for logging and support. */
+    readonly raw: unknown;
+}
+/**
+ * A transaction's id as status events name it: its `transactionHash`, in base64.
+ *
+ * Works on anything the SDK builds — an attestation or a transfer — because each already
+ * carries the hash its kind is identified by, and the two kinds are hashed differently.
+ */
+declare function transactionIdOf(tx: {
+    readonly transactionHash: Uint8Array;
+}): string;
+
+/** The node committed it. */
+interface GeeqTxConfirmed {
+    readonly status: 'confirmed';
+    readonly id: string;
+    /** The `valid` event that settled it. */
+    readonly event: GeeqTxStatusEvent;
+    readonly at: Date;
+}
+/**
+ * Why a transaction was rejected. Branch on this, never on {@link GeeqTxRejected.message}.
+ *
+ * - `invalid` — found wrong at commit, usually the nonce or the balance. The fee is still
+ *   charged.
+ * - `incorrectly-included` — carried by a node the chain judged dishonest. Not your fault.
+ * - `nonsane` — the receiving node refused it and dropped it.
+ * - `refused` — the node answered the submission with an error status. It never entered
+ *   a block and will produce no status event.
+ */
+type GeeqTxRejectionReason = 'invalid' | 'incorrectly-included' | 'nonsane' | 'refused';
+interface GeeqTxRejected {
+    readonly status: 'rejected';
+    readonly id: string;
+    readonly reason: GeeqTxRejectionReason;
+    /** The node's own words when it gave any. For display and support — never parse it. */
+    readonly message: string;
+    /** The event that settled it. Undefined for a `refused` submission the socket never saw. */
+    readonly event: GeeqTxStatusEvent | undefined;
+    /** The HTTP status of a `refused` submission, when the caller reported one. */
+    readonly httpStatus: number | undefined;
+    readonly at: Date;
+}
+/**
+ * No verdict, and none is coming to this handle.
+ *
+ * - `timeout` — nothing final arrived in time. **This is not a rejection**: statuses sent
+ *   while the socket was reconnecting are lost, so it may well have settled. Read the
+ *   ledger (has the account's nonce moved on?) before sending it again.
+ * - `closed` — the socket was disposed while it was pending.
+ * - `released` — the caller stopped tracking it.
+ */
+type GeeqTxUnknownReason = 'timeout' | 'closed' | 'released';
+interface GeeqTxUnknown {
+    readonly status: 'unknown';
+    readonly id: string;
+    readonly reason: GeeqTxUnknownReason;
+    readonly message: string;
+    readonly at: Date;
+}
+type GeeqTxOutcome = GeeqTxConfirmed | GeeqTxRejected | GeeqTxUnknown;
+/** `pending` until an outcome, then the outcome's own status. Never goes back. */
+type GeeqTxState = 'pending' | GeeqTxOutcome['status'];
+/** What a submission refusal looked like, for {@link GeeqTrackedTx.refused}. */
+interface GeeqTxRefusal {
+    /** The HTTP status the node answered with. */
+    readonly status?: number;
+    /** The node's `details`, or the body — whatever it said. */
+    readonly message?: string;
+}
+/** @internal */
+interface TrackedTxInit {
+    readonly id: string;
+    readonly timeoutMs: number;
+    readonly nonsaneGraceMs: number;
+    /** Called once, when it settles — the socket drops it from its table. */
+    readonly detach: () => void;
+}
+/**
+ * One submitted transaction, followed to its verdict.
+ *
+ * Returned by {@link GeeqSocket.track}. It collapses the node's four verdicts, some of
+ * which arrive more than once and one of which is only usually final, into one of three
+ * outcomes an application can branch on — and it never rejects, because a rejected
+ * transaction is an answer, not a failure:
+ *
+ * ```ts
+ * const outcome = await tracked.settled()
+ * if (outcome.status === 'confirmed') …
+ * else if (outcome.status === 'rejected') show(outcome.reason, outcome.message)
+ * else checkLedgerBeforeRetrying()          // 'unknown'
+ * ```
+ *
+ * In a reactive framework, keep it raw (Vue's `markRaw`) and re-read `status` and
+ * `events` from {@link onChange}.
+ */
+declare class GeeqTrackedTx {
+    /** The transaction's refHash, base64 — the same string status events carry. */
+    readonly id: string;
+    private readonly received;
+    private readonly listeners;
+    private readonly nonsaneGraceMs;
+    private readonly detach;
+    private readonly promise;
+    private readonly resolve;
+    private current;
+    private deadline;
+    private grace;
+    /** @internal */
+    constructor(init: TrackedTxInit);
+    /** `pending`, then `confirmed`, `rejected` or `unknown` — once, and for good. */
+    get status(): GeeqTxState;
+    /** The outcome, once there is one. */
+    get outcome(): GeeqTxOutcome | undefined;
+    /** Every status event received for this transaction, oldest first. */
+    get events(): readonly GeeqTxStatusEvent[];
+    /** Resolves with the outcome. Never rejects — see the class notes. */
+    settled(): Promise<GeeqTxOutcome>;
+    /**
+     * Call `listener` whenever an event arrives for this transaction or it settles.
+     *
+     * Returns the function that removes it. Read {@link status}, {@link events} and
+     * {@link outcome} inside; they are already up to date.
+     */
+    onChange(listener: (tx: GeeqTrackedTx) => void): () => void;
+    /**
+     * Report that the node refused the submission — answered it with an error status.
+     *
+     * Settles it `rejected` at once. A refused transaction never reaches a block, so no
+     * status event would ever arrive to settle it, and waiting would only turn a clear
+     * answer into a timeout. Do **not** call this when the POST failed to arrive at all
+     * (a network error): the node may have it, so leave it tracked.
+     */
+    refused(refusal?: GeeqTxRefusal): void;
+    /** Stop tracking. Settles `unknown` with reason `released` if it was still pending. */
+    release(): void;
+    /** @internal Settle as unknown because the socket is going away, or on release. */
+    abandon(reason: 'closed' | 'released', message: string): void;
+    /**
+     * @internal Take one status event for this transaction.
+     *
+     * The only place the protocol's rules live. First-event-wins would report false
+     * failures: a `nonsane` can be followed by a real verdict when a node carries its buffer
+     * over a restart, so it only settles if nothing final follows within the grace window.
+     * Everything after the outcome — a second node's copy, a duplicate — is ignored.
+     */
+    receive(event: GeeqTxStatusEvent): void;
+    private finish;
+    private notify;
+    toJSON(): Record<string, unknown>;
+    toString(): string;
+}
+
+/**
+ * - `connecting` — the first handshake, inside {@link GeeqSocket.connect}.
+ * - `open` — subscribed and receiving.
+ * - `reconnecting` — dropped after being open; retrying with backoff. Anything the node
+ *   sends meanwhile is lost.
+ * - `closed` — disposed. Final.
+ */
+type GeeqSocketState = 'connecting' | 'open' | 'reconnecting' | 'closed';
+/** One JSON frame from the node, as `{ event, payload }`. */
+interface GeeqSocketMessage {
+    readonly event: string;
+    readonly payload: unknown;
+}
+interface GeeqSocketOptions {
+    /**
+     * The node the socket belongs to — normally `chain.endpoint`, which is also where the
+     * transactions go. Its socket is derived: `https://ip:2082` becomes
+     * `wss://ip:2082/ws/`.
+     *
+     * Supply this or {@link url}, not both. Use the node you submit to: only that node
+     * reports a `nonsane` refusal, though every node reports the final verdicts.
+     */
+    readonly endpoint?: string | URL;
+    /**
+     * The socket URL itself, when it is not the one derived from the node — a local
+     * harness reaching the socket server directly on its own port, for instance.
+     */
+    readonly url?: string | URL;
+    /** Defaults to `new globalThis.WebSocket(url)`. Supply one on Node 20 — see README. */
+    readonly webSocket?: GeeqWebSocketFactory;
+    /**
+     * How long a handshake, or a send waiting on one, may take. Defaults to 15000. 0 waits
+     * for ever — including a first handshake that neither opens nor fails.
+     */
+    readonly openTimeoutMs?: number;
+    /** How often to send the keepalive `'ping'`. Defaults to 25000; 0 disables it. */
+    readonly heartbeatMs?: number;
+    /** Reconnect after a drop. Defaults to true. */
+    readonly reconnect?: boolean;
+    /** The first reconnect delay, doubled on each failure. Defaults to 1000. */
+    readonly reconnectDelayMs?: number;
+    /** The ceiling on that delay. Defaults to 30000. */
+    readonly maxReconnectDelayMs?: number;
+    /** Abandons the first handshake. Once connected, use {@link GeeqSocket.dispose}. */
+    readonly signal?: AbortSignal;
+}
+interface GeeqSendOptions {
+    /**
+     * Re-send the frame on every reconnect. A node forgets a connection's subscriptions
+     * when it drops, so anything that subscribes should set this. Only the latest frame for
+     * each event name is kept.
+     */
+    readonly replay?: boolean;
+}
+interface GeeqListenOptions {
+    readonly blockNumber?: number;
+    /** Defaults to true. */
+    readonly now?: boolean;
+}
+interface GeeqTrackOptions {
+    /** How long to wait for a final status. Defaults to 300000. 0 waits for ever. */
+    readonly timeoutMs?: number;
+    /** How long a `nonsane` may be overturned by a real verdict. Defaults to 30000. */
+    readonly nonsaneGraceMs?: number;
+    /** More accounts to subscribe alongside the signer. */
+    readonly accounts?: readonly (AccountRef | string)[];
+}
+/**
+ * Anything with the hash a status event names. Every transaction this SDK builds fits,
+ * and brings its signer's `publicKey` for the subscription.
+ */
+interface GeeqTrackable {
+    readonly transactionHash: Uint8Array;
+    readonly publicKey?: Uint8Array;
+}
+/**
+ * A node's WebSocket: the channel through which it reports what happened to the
+ * transactions you sent, and pushes account and chain updates.
+ *
+ * One class for every use an application has for the socket:
+ *
+ * - {@link track} a transaction you are about to submit, and get its verdict;
+ * - {@link subscribe} to accounts and read their events with {@link on};
+ * - {@link send} any frame the node understands, and receive any it sends.
+ *
+ * The protocol's hazards are handled here, once: subscriptions replace rather than add,
+ * so the full set of keys is always sent; the node forgets a connection's subscriptions
+ * when it drops, so they are replayed on every reconnect before anything is announced;
+ * the edge proxy drops an idle socket, so it is kept alive; a transaction's first status
+ * is not always its last, so {@link GeeqTrackedTx} decides when it is final.
+ *
+ * ```ts
+ * const socket = await GeeqSocket.connect({ endpoint: chain.endpoint })
+ * const tx = await chain.createTransfer({ from, to, amount })
+ * const tracked = await socket.track(tx)          // before submitting — always
+ * const response = await fetch(submitRoute(tx.nodeUrl), { … })
+ * if (!response.ok) tracked.refused({ status: response.status })
+ * const outcome = await tracked.settled()
+ * ```
+ *
+ * In a reactive framework, mark an instance raw (Vue's `markRaw`) rather than letting it
+ * be proxied — a proxied native WebSocket throws on every call.
+ */
+declare class GeeqSocket {
+    /** The socket URL, normalised. */
+    readonly url: string;
+    private readonly factory;
+    private readonly openTimeoutMs;
+    private readonly heartbeatMs;
+    private readonly reconnects;
+    private readonly reconnectDelayMs;
+    private readonly maxReconnectDelayMs;
+    /** The frames in force, by event name, replayed on every connection. */
+    private readonly persisted;
+    /** What this connection has already been told, so a repeat is not sent twice. */
+    private readonly told;
+    private readonly keys;
+    private readonly tracked;
+    private readonly eventListeners;
+    private readonly messageListeners;
+    private readonly statusListeners;
+    private readonly stateListeners;
+    private readonly waiters;
+    private socket;
+    private current;
+    private everOpened;
+    private attempts;
+    private openTimer;
+    private reconnectTimer;
+    private heartbeatTimer;
+    /** @internal */
+    constructor(init: {
+        url: string;
+        factory: GeeqWebSocketFactory;
+        openTimeoutMs: number;
+        heartbeatMs: number;
+        reconnect: boolean;
+        reconnectDelayMs: number;
+        maxReconnectDelayMs: number;
+    });
+    /**
+     * Open a node's socket and resolve once it is open.
+     *
+     * Throws `socket-unreachable` if the first handshake fails, rather than retrying
+     * quietly: a socket that never opened is almost always a certificate, a mixed-content
+     * page or a wrong URL, and retrying hides which. After that first open, a drop is
+     * retried automatically and reported through {@link onConnectionChange}.
+     */
+    static connect(options: GeeqSocketOptions): Promise<GeeqSocket>;
+    /** Where the connection stands. See {@link GeeqSocketState}. */
+    get state(): GeeqSocketState;
+    /** Every account key subscribed so far, base64. The set only grows. */
+    get subscriptions(): readonly string[];
+    /**
+     * Subscribe to accounts' events: their transactions' statuses and record updates.
+     *
+     * Takes a keypair, a `{ publicKey }`, a 32-byte account id, a base64 key, or a list of
+     * them. The node has no unsubscribe and treats every subscription as a replacement, so
+     * this adds to the set this socket holds and sends all of it — calling it for one
+     * account never silences another. Resolves once the node has been told.
+     */
+    subscribe(accounts: AccountRef | string | readonly (AccountRef | string)[]): Promise<void>;
+    /** Ask for events from now, or from a block. Replayed on reconnect. */
+    listen(options?: GeeqListenOptions): Promise<void>;
+    /**
+     * Subscribe to the whole chain's record feed — every account, fee and parameter update.
+     * What a block explorer or an indexer wants; an ordinary application does not.
+     */
+    subscribeBlockExplorer(): Promise<void>;
+    /**
+     * Send a frame, `{ event, payload }`, waiting for the connection if it is down.
+     *
+     * The escape hatch for anything the node understands that this class has no method
+     * for. Rejects with `socket-unreachable` if the socket does not reopen within
+     * `openTimeoutMs` — a replayed frame is still kept, and goes out when it does.
+     */
+    send(event: string, payload?: unknown, options?: GeeqSendOptions): Promise<void>;
+    /**
+     * Follow a transaction to its verdict. Call it **before** submitting.
+     *
+     * Subscribes the signer — the node pushes a transaction's statuses only to connections
+     * subscribed to its account — and resolves once the node has been told, so a status
+     * cannot arrive before anyone is listening for it. If this throws, do not submit: a
+     * transaction sent with no way to hear its verdict leaves the user guessing.
+     *
+     * Tracking the same transaction twice returns the same handle.
+     */
+    track(tx: GeeqTrackable, options?: GeeqTrackOptions): Promise<GeeqTrackedTx>;
+    /**
+     * Call `listener` with the payload of every frame named `event`, whatever it is —
+     * `'uut_status'`, `'coin-account-update'`, `'fee-update'`, or one this SDK has never
+     * heard of. Returns the function that removes it.
+     */
+    on(event: string, listener: (payload: unknown) => void): () => void;
+    /** Call `listener` with every JSON frame the node sends. */
+    onMessage(listener: (message: GeeqSocketMessage) => void): () => void;
+    /** Call `listener` with every transaction status, tracked or not, already parsed. */
+    onTxStatus(listener: (event: GeeqTxStatusEvent) => void): () => void;
+    /** Call `listener` whenever {@link state} changes. */
+    onConnectionChange(listener: (state: GeeqSocketState) => void): () => void;
+    /**
+     * Close for good. Pending sends reject with `socket-closed`, and every transaction still
+     * being tracked settles `unknown` with reason `closed` — it may yet be decided, just
+     * not heard about here.
+     */
+    dispose(): void;
+    toJSON(): Record<string, unknown>;
+    toString(): string;
+    private assertOpenable;
+    private setState;
+    /** Resolves when the socket is open, or rejects after `openTimeoutMs` or on dispose. */
+    private whenOpen;
+    private dial;
+    private opened;
+    /** A handshake failed, or an open socket dropped. */
+    private attemptFailed;
+    /**
+     * Put one frame on the current connection. True once it is there — or already was.
+     *
+     * False means the connection is gone. If our books still said it was open, it is
+     * treated as the drop it is, here and now, so the caller waits for the next connection
+     * instead of spinning on this one.
+     */
+    private transmit;
+    private receive;
+    private startHeartbeat;
+    private stopHeartbeat;
+}
+
+/** What one metadata entry costs, and whether the chain would take it. */
+interface MetadataEntryReport {
+    readonly index: number;
+    /** Length once encoded as UTF-8, which is what the limit is measured in. */
+    readonly bytes: number;
+    readonly overLimit: boolean;
+}
+interface MetadataReport {
+    readonly entries: readonly MetadataEntryReport[];
+    readonly count: number;
+    readonly tooManyEntries: boolean;
+    readonly withinLimits: boolean;
+    /** Undefined when the chain publishes no limits, in which case nothing is checked. */
+    readonly limits: GeeqMetadataLimits | undefined;
+}
+/**
+ * Measure metadata against a chain's limits without throwing.
+ *
+ * The same rules {@link assertMetadataWithinLimits} enforces, reported rather than
+ * raised, so a UI can colour a field as someone types instead of waiting for a failed
+ * build. Byte lengths are UTF-8, which is the only measure that matters here — a label
+ * of ten emoji is forty bytes, and counting characters would call it short.
+ */
+declare function inspectMetadata(metadata: readonly (string | Uint8Array)[] | undefined, limits: GeeqMetadataLimits | undefined): MetadataReport;
+
+declare function toBase64(bytes: Uint8Array): string;
+/**
+ * Decode base64, rejecting anything the alphabet does not cover.
+ *
+ * `label` names the thing being decoded so the message points at the caller's data
+ * rather than at this function.
+ */
+declare function fromBase64(value: string, label?: string): Uint8Array;
+
+declare function toHex(bytes: Uint8Array): string;
+declare function fromHex(value: string, label?: string): Uint8Array;
+
+interface DecodeLedgerOptions {
+    /** The node this came from, carried through onto the snapshot. */
+    readonly nodeUrl?: string | undefined;
+    /** Overrides the read timestamp. For deterministic tests. */
+    readonly readAt?: number | undefined;
+}
+/**
+ * Decode a validation layer ledger.
+ *
+ * `source` is what a node's `result` field holds: base64, or the bytes behind it. The
+ * message is Cap'n Proto **packed**, which is what the node writes with
+ * `toPackedArrayBuffer()` — not the flattened form used for signing.
+ *
+ * Everything is read in this one pass and the message is then dropped, so the caller
+ * gets plain values with no traversal budget attached. See {@link GeeqLedger}.
+ */
+declare function decodeValidationLedger(source: Uint8Array | ArrayBuffer | string, options?: DecodeLedgerOptions): GeeqLedger;
+
+/**
+ * Build and sign an attestation transaction. Synchronous; requires a loaded engine.
+ *
+ * This function is offline: it opens no sockets and reads no ledger. It needs chain
+ * state that only a node can supply, so either pass the four values yourself or let
+ * {@link GeeqChain} read them and hand you a `chainState`.
+ *
+ * The transaction is signed but **not submitted**. Post
+ * {@link AttestationTx.transaction} and {@link AttestationTx.payload} to the node named
+ * by {@link AttestationTx.nodeUrl}.
+ */
+declare function createAttestationTxSync(input: AttestationTxInput): AttestationTx;
+/** Build and sign an attestation transaction, loading the engine if needed. */
+declare function createAttestationTx(input: AttestationTxInput): Promise<AttestationTx>;
+
+/**
+ * Build and sign a coin transfer. Synchronous; requires a loaded engine.
+ *
+ * Unlike an attestation this is a **validation layer** transaction: it carries no
+ * separate payload, so there is one base64 blob to submit rather than two, and it is
+ * posted as type `uvt`.
+ *
+ * NFTs ride along in the same transaction, with coin: the chain's minimum transfer
+ * applies even when the point is the NFTs.
+ *
+ * Offline — it opens no sockets and reads no ledger. It cannot check that the sender can
+ * afford the transfer, that the amount clears the chain's minimum, or that it holds the
+ * NFTs; all three need a ledger. {@link GeeqChain.createTransfer} does check them.
+ */
+declare function createCoinTransferTxSync(input: CoinTransferTxInput): CoinTransferTx;
+/** Build and sign a coin transfer, loading the engine if needed. */
+declare function createCoinTransferTx(input: CoinTransferTxInput): Promise<CoinTransferTx>;
+
+/**
+ * Build and sign a transaction that creates an NFT mint proxy. Synchronous; requires a
+ * loaded engine.
+ *
+ * A proxy is a record of its own on the chain. It holds coin, carries its own nonce, and
+ * names one admin — the signer here — who is the only key that can mint NFTs through it.
+ * The signer pays `amount` onto it, plus the fee.
+ *
+ * Offline: it cannot check that the index is unused or that the signer can afford it.
+ * {@link GeeqChain.createNftMintProxy} does both.
+ */
+declare function createNftMintProxyTxSync(input: NftMintProxyTxInput): NftMintProxyTx;
+/** Build and sign a proxy creation, loading the engine if needed. */
+declare function createNftMintProxyTx(input: NftMintProxyTxInput): Promise<NftMintProxyTx>;
+
+/**
+ * Build and sign an NFT mint. Synchronous; requires a loaded engine.
+ *
+ * An NFT is minted through a proxy, and the proxy is the sender: it pays the fee and
+ * `amount`, which goes to the receiver with the NFT, and it spends its own nonce. Its
+ * admin — the signer here — is the only key the chain accepts for it. The NFT itself is an
+ * attestation subgroup, as an attestation carries: the content's hash and its labels,
+ * signed by the admin and naming the proxy.
+ *
+ * Offline: it cannot check that the proxy exists, is the signer's, or can pay.
+ * {@link GeeqChain.mintNft} does all three.
+ */
+declare function createNftMintTxSync(input: NftMintTxInput): NftMintTx;
+/** Build and sign an NFT mint, loading the engine if needed. */
+declare function createNftMintTx(input: NftMintTxInput): Promise<NftMintTx>;
+
+/**
+ * Every error thrown by this SDK is a {@link GeeqError} carrying a stable
+ * {@link GeeqErrorCode}. Branch on `code`, never on the message text.
+ */
+type GeeqErrorCode = 
+/** An SDK function was called before the engine finished loading. */
+'not-initialized'
+/** The WebAssembly engine could not be loaded. */
+ | 'init-failed'
+/** A public or private key was the wrong length, or the pair did not match. */
+ | 'invalid-key'
+/** A wallet address was malformed, or encoded a record type we do not know. */
+ | 'invalid-address'
+/** A caller-supplied argument was outside its allowed range. */
+ | 'invalid-argument'
+/** A node could not be reached at all — no HTTP response arrived. */
+ | 'network-unreachable'
+/** A node, simulator or explorer answered with an error status. See `status` and `nodeDetails`. */
+ | 'node-error'
+/** A node answered, but its ledger could not be decoded. */
+ | 'ledger-unreadable'
+/** The node's chain is not the one the caller said to expect. */
+ | 'chain-mismatch'
+/** The signing account has no record on this chain yet — it needs funding. */
+ | 'account-not-found'
+/** The account exists but its record type cannot sign this transaction. */
+ | 'account-not-attestable'
+/**
+ * The node being targeted cannot be identified, or cannot process transactions. Also
+ * thrown when a simulator or explorer answers with something it should not serve.
+ */
+ | 'node-unusable'
+/** Metadata exceeds a limit this chain publishes in its ledger. */
+ | 'metadata-too-large'
+/** A second transaction was built for one account against one block. */
+ | 'nonce-collision'
+/** The sending account does not hold enough coin. */
+ | 'insufficient-funds'
+/** The amount is below the smallest transfer this chain accepts. */
+ | 'amount-below-minimum'
+/** The sending account does not hold an NFT it was asked to send. */
+ | 'nft-not-owned'
+/** A node's WebSocket could not be opened, or this runtime has no WebSocket at all. */
+ | 'socket-unreachable'
+/** The {@link GeeqSocket} was disposed, so it will not send or receive again. */
+ | 'socket-closed';
+interface GeeqErrorOptions {
+    readonly cause?: unknown;
+    /** HTTP status, when a server answered. */
+    readonly status?: number;
+    /**
+     * The server's own `details`, verbatim; a list of them is joined with `; `. Never parse
+     * it — branch on `code`.
+     */
+    readonly nodeDetails?: string;
+}
+declare class GeeqError extends Error {
+    readonly code: GeeqErrorCode;
+    readonly status?: number | undefined;
+    readonly nodeDetails?: string | undefined;
+    constructor(code: GeeqErrorCode, message: string, options?: GeeqErrorOptions);
+}
+
+export { ACCOUNT_ID_BYTES, ATTEST_HASH_BYTES, type AccountIdentifier, type AccountRef, type AttestationContent, type AttestationRequest, type AttestationTx, type AttestationTxFlatInput, type AttestationTxInput, type AttestationTxStateInput, type ChainStateInput, type ChainStateRequest, type CoinTransferContent, type CoinTransferRequest, type CoinTransferTx, type CoinTransferTxFlatInput, type CoinTransferTxInput, type CoinTransferTxStateInput, type CreateWalletAddressInput, DEFAULT_RECORD_TYPE, type DecodeLedgerOptions, type DecodedWalletAddress, type Discovery, type ExplorerTransactionRequest, GEEQ_NODE_PORT, GEEQ_RECORD_TYPES, type GeeqAmount, GeeqChain, type GeeqChainOptions, type GeeqChainState, type GeeqCoinAccount, type GeeqCoinRecordKind, type GeeqCoinType, type GeeqContent, type GeeqDiscoveredChain, type GeeqDiscoveredNode, GeeqError, type GeeqErrorCode, type GeeqExplorerTransaction, type GeeqFee, type GeeqHeldNft, type GeeqHttpResponse, type GeeqKeypair, GeeqLedger, type GeeqLedgerNode, type GeeqListenOptions, type GeeqMetadataLimits, type GeeqNft, type GeeqNftMintProxies, type GeeqNftMintProxy, GeeqNode, type GeeqNodeKind, type GeeqNodeRole, type GeeqNodeStatus, type GeeqProxyAccount, type GeeqProxyKind, type GeeqRecordType, type GeeqRequestInit, type GeeqSendOptions, GeeqSocket, type GeeqSocketMessage, type GeeqSocketOptions, type GeeqSocketState, type GeeqTrackOptions, type GeeqTrackable, GeeqTrackedTx, type GeeqTransport, type GeeqTxConfirmed, type GeeqTxOutcome, type GeeqTxRefusal, type GeeqTxRejected, type GeeqTxRejectionReason, type GeeqTxState, type GeeqTxStatusEvent, type GeeqTxUnknown, type GeeqTxUnknownReason, type GeeqTxVerdict, type GeeqWebSocketFactory, type GeeqWebSocketLike, type GeeqWebSocketMessageEvent, type GenerateMnemonicOptions, type InitOptions, MNEMONIC_WORD_COUNTS, type MetadataEntryReport, type MetadataReport, type MnemonicOptions, type MnemonicWordCount, type NftMintProxiesRequest, type NftMintProxyRequest, type NftMintProxyTx, type NftMintProxyTxInput, type NftMintRequest, type NftMintTx, type NftMintTxInput, type NftTransferEntry, type NftsRequest, PUBLIC_KEY_BYTES, type WalletAddressOptions, type WasmSource, accountIdFromPublicKey, assertAttestHash, attest, attestHashOf, attestHashOfSync, attestationSubmitBody, coinTransferSubmitBody, createAttestationTx, createAttestationTxSync, createCoinTransferTx, createCoinTransferTxSync, createNftMintProxyTx, createNftMintProxyTxSync, createNftMintTx, createNftMintTxSync, createWalletAddress, createWalletAddressSync, decodeValidationLedger, decodeWalletAddress, decodeWalletAddressSync, defaultTransport, defaultWebSocketFactory, discover, formatGeeq, fromBase64, fromHex, generateKeypair, generateKeypairSync, generateMnemonic, getExplorerTransaction, importKeypair, importKeypairSync, initChain, initGeeq, inspectMetadata, isGeeqReady, isValidWalletAddress, keypairFromMnemonic, keypairFromMnemonicSync, keypairFromSecretKey, keypairFromSecretKeySync, ledgerRoute, listChains, listNodes, normalizeMnemonic, readContent, selectNode, socketRoute, submitRoute, toBase64, toHex, toPennies, transactionIdOf, transfer, validateMnemonic, verifySignature };