@monolythium/core-sdk 0.3.9 → 0.3.11

package/dist/{submission-D8xzCLNl.d.ts → submission-CA8L21An.d.ts}

@@ -180,6 +180,155 @@ interface BridgeRoutesResponse {
     bridgeRouteDisclosures?: BridgeRouteDisclosure[] | null;
     source?: BridgeRoutesSource | null;
 }
+/**
+ * Per-asset drain rate-limit + circuit-breaker state (MB-2).
+ *
+ * Mirrors the `TAG_DRAIN_CAP` (`0x26`) family in the chain bridge
+ * storage. `capPerWindow === "0"` disables the breaker for the
+ * `(bridge, asset)` pair. `drained` is the running total for the active
+ * window; `remaining` is the SDK-computed `cap - drained` floored at
+ * zero (decimal string), or `null` when the cap is disabled.
+ */
+interface BridgeDrainCap {
+    /** Maximum aggregate drain per rolling window (`uint256` decimal). */
+    capPerWindow: string;
+    /** Window length in Protocore blocks. */
+    windowBlocks: string;
+    /** `block_number / window_blocks` at the last drain. */
+    currentBucket: string;
+    /** Running drained total for the active window (`uint256` decimal). */
+    drained: string;
+    /** SDK-computed `capPerWindow - drained` floored at `0`; `null` if disabled. */
+    remaining?: string | null;
+}
+/**
+ * Bridge route circuit-breaker + resume-cooldown health (MB-2).
+ *
+ * Mirrors the bridge-record fields `PAUSED_AT_BLOCK` (`0x13`),
+ * `RESUME_COOLDOWN_BLOCKS` (`0x12`), `ROUTE_FINALITY_BLOCKS` (`0x14`),
+ * and `ADMIN_LOCKED_AT_BLOCK` (`0x11`) plus the per-asset drain cap.
+ * `paused` is derived from `pausedAt !== "0"`.
+ */
+interface BridgeBreakerState {
+    /** Bridge id the breaker state belongs to (`0x` 32 bytes). */
+    bridgeId: string;
+    /** `true` when the route is in a recorded pause window. */
+    paused: boolean;
+    /** Block at which the current pause was committed; `"0"` when not paused. */
+    pausedAt: string;
+    /** Cooldown blocks that must elapse after a pause before resume. */
+    resumeCooldownBlocks: string;
+    /** Route-specific foreign-chain finality depth. */
+    routeFinalityBlocks: string;
+    /** Block at which mutable route config was frozen; `"0"` = unlocked. */
+    adminLockedAtBlock: string;
+    /** Per-asset drain rate-limit + breaker counters, when a cap is set. */
+    drainCap?: BridgeDrainCap | null;
+}
+/**
+ * Latest light-client anchor metadata on a {@link BridgeHealthRecord}.
+ */
+interface BridgeAnchorState {
+    /** Latest verified foreign-chain header root (`0x` 32 bytes). */
+    headerRoot: string;
+    /** Latest verified foreign-chain block number. */
+    headerBlock: number;
+    /** Protocore block at which the latest anchor was recorded. */
+    updatedAtProtocoreBlock: number;
+}
+/**
+ * MB-2 — bridge-level circuit-breaker + pause posture on a
+ * {@link BridgeHealthRecord}. Amounts are `0x`-hex `uint256` strings;
+ * block counts are numbers.
+ */
+interface BridgeCircuitBreakerFields {
+    /** Bridge-default drain cap per rolling window (`0x`-hex `uint256`); `0x0` disables it. */
+    defaultDrainCapPerWindow: string;
+    /** Bridge-default drain-window length in Protocore blocks. */
+    defaultDrainWindowBlocks: number;
+    /** `true` when the route is currently in a recorded pause window. */
+    paused: boolean;
+    /** Protocore block the current pause was committed at; `null` when not paused. */
+    pausedAtBlock: number | null;
+    /** Cooldown (blocks) that must elapse after a pause before resume. */
+    resumeCooldownBlocks: number;
+}
+/** One bridge-health row in a {@link BridgeHealthResponse}. */
+interface BridgeHealthRecord {
+    /** 32-byte bridge id (`0x` hex). */
+    bridgeId: string;
+    /** Stable bridge lifecycle status label. */
+    status: string;
+    /** Raw bridge lifecycle status byte. */
+    statusCode: number;
+    /** Latest light-client anchor metadata. */
+    latestAnchor: BridgeAnchorState;
+    /** MB-2 bridge-level circuit-breaker / pause posture. */
+    circuitBreaker: BridgeCircuitBreakerFields;
+}
+/**
+ * `lyth_bridgeHealth` response — a page of bridge-record health envelopes
+ * (MB-2). The chain pages the **global** bridge set keyed by `cursor` +
+ * `limit`; there is no single-bridge form. Each record's `circuitBreaker`
+ * answers "is this route paused / rate-limited" in one round-trip; the
+ * per-route live drain bucket is `lyth_bridgeDrainStatus`.
+ */
+interface BridgeHealthResponse {
+    /** Response schema version (`1`). */
+    schemaVersion: number;
+    /** Data source — `"native_state_storage"`. */
+    source: string;
+    /** Bridge precompile address (`0x1008`). */
+    precompile: string;
+    /** Bridge-health rows in this page. */
+    records: BridgeHealthRecord[];
+    /** Opaque cursor for the next page (`0x` hex), or `null` at the end. */
+    nextCursor: string | null;
+}
+/**
+ * `lyth_bridgeDrainStatus` response — the live per-route circuit-breaker
+ * drain bucket for one `(bridgeId, wrappedAsset)` route (MB-2).
+ *
+ * `remaining` is `capPerWindow - drainedThisBucket` (clamped at `0x0`)
+ * when a per-asset cap is set; `0x0` when no per-asset cap exists (no
+ * per-asset rate limit — the `bridgeDefault` applies). Amounts are
+ * `0x`-hex `uint256` strings; block counts are numbers.
+ */
+interface BridgeDrainStatus {
+    /** Response schema version (`1`). */
+    schemaVersion: number;
+    /** Data source — `"native_state_storage"`. */
+    source: string;
+    /** Bridge precompile address (`0x1008`). */
+    precompile: string;
+    /** Bridge id the bucket belongs to (`0x` 32 bytes). */
+    bridgeId: string;
+    /** Wrapped (Protocore-side) asset (`mono` bech32m). */
+    wrappedAsset: string;
+    /** Per-asset drain cap per window (`0x`-hex `uint256`); `0x0` = no per-asset cap. */
+    capPerWindow: string;
+    /** Per-asset window length in Protocore blocks. */
+    windowBlocks: number;
+    /** `block_number / window_blocks` at the last drain. */
+    currentBucket: number;
+    /** Running drained total for the active window (`0x`-hex `uint256`). */
+    drainedThisBucket: string;
+    /** `capPerWindow - drainedThisBucket` clamped at `0x0` (`0x0` when no per-asset cap). */
+    remaining: string;
+    /** Bridge-default fallback fields, surfaced when no per-asset cap is configured. */
+    bridgeDefault: {
+        /** Bridge-default drain cap per window (`0x`-hex `uint256`). */
+        drainCapPerWindow: string;
+        /** Bridge-default drain-window length in Protocore blocks. */
+        drainWindowBlocks: number;
+    };
+}
+/**
+ * Compute the `remaining` field for a {@link BridgeDrainCap} from its
+ * `capPerWindow` and `drained` decimal strings, floored at `0`. Returns
+ * `null` when the cap is disabled (`capPerWindow === "0"`).
+ */
+declare function bridgeDrainRemaining(capPerWindow: string, drained: string): string | null;
 declare function assessBridgeRoute(route: BridgeRouteDisclosure): BridgeRouteAssessment;
 declare function rankBridgeRoutes(routes: readonly BridgeRouteDisclosure[]): RankedBridgeRoute[];
 declare function bridgeTransferCandidates(intent: BridgeTransferIntent, routes: readonly BridgeRouteDisclosure[]): BridgeRouteCandidate[];
@@ -2194,6 +2343,1429 @@ declare function isNativeMarketOrderBookStreamPayload(value: unknown): value is
 declare function assertNativeMarketOrderBookStreamPayload(value: unknown): asserts value is NativeMarketOrderBookStreamPayload;
 declare function decodeNativeMarketOrderBookDeltasResponse(value: unknown): NativeMarketOrderBookDeltasResponse;
 
+/**
+ * Node-registry precompile ABI helpers and service capability constants.
+ *
+ * These constants mirror `protocore-node-registry::capabilities` and
+ * `protocore-node-registry::abi`. They are exported for wallets,
+ * service probers, faucets, and operator dashboards that need to build
+ * canonical registry transactions without retyping low-level values.
+ */
+declare const NODE_REGISTRY_CAPABILITIES: {
+    readonly SERVES_RPC: 1;
+    readonly SERVES_INDEXER: 2;
+    readonly SERVES_BROADCASTER: 4;
+    readonly SERVES_ARCHIVE: 8;
+    readonly SERVES_WEBSOCKET: 16;
+    readonly SERVES_LIGHT_CLIENT: 32;
+    readonly SERVES_ORACLE_WRITER: 64;
+    readonly SERVES_BRIDGE_RELAY: 128;
+    readonly SERVES_PUBLIC_API: 256;
+    /** GPU prover — may bid on + serve the GPU prover market (MB-4, bit 9). */
+    readonly SERVES_GPU_PROVE: 512;
+};
+/** Maximum basis-point value for any PF-6 diversity term / the headline score. */
+declare const DIVERSITY_SCORE_MAX = 10000;
+/** BLAKE3 multisig address-derivation domain (cluster-anchor preimage, MB-5). */
+declare const MULTISIG_ADDRESS_DERIVATION_DOMAIN: "MONO_MULTISIG_BLAKE3_20_V1";
+declare const NODE_REGISTRY_CAPABILITY_MASK = 65535;
+declare const NODE_REGISTRY_PUBLIC_SERVICE_MASK: number;
+declare const SERVICE_PROBE_STATUS: {
+    readonly UNKNOWN: 0;
+    readonly REACHABLE: 1;
+    readonly DEGRADED: 2;
+    readonly UNREACHABLE: 3;
+};
+declare const NODE_REGISTRY_SELECTORS: {
+    readonly reportServiceProbe: "0xeee31bba";
+    readonly getServiceProbe: "0x1fcbfbce";
+    /** `setNetworkMetadata(bytes32,uint16,bytes3,bytes)` — owner-callable (PF-6). */
+    readonly setNetworkMetadata: string;
+    /** `getOperatorNetworkMetadata(bytes32)` view (PF-6). */
+    readonly getOperatorNetworkMetadata: string;
+    /** `getClusterDiversity(uint32)` view (PF-6). */
+    readonly getClusterDiversity: string;
+};
+/** Canonical `ClusterFormed(uint32,uint64,address,bytes)` event topic0 (MB-5). */
+declare const CLUSTER_FORMED_EVENT_SIG: "ClusterFormed(uint32,uint64,address,bytes)";
+interface ReportServiceProbeCalldataArgs {
+    peerId: string | Uint8Array | readonly number[];
+    serviceMask: number;
+    status: number;
+    latencyMs: number;
+    probeDigest: string | Uint8Array | readonly number[];
+}
+declare class NodeRegistryError extends Error {
+    constructor(message: string);
+}
+declare function nodeRegistryAddressHex(): string;
+declare function isValidNodeRegistryCapabilities(flags: number): boolean;
+declare function isValidPublicServiceProbeMask(mask: number): boolean;
+declare function isSinglePublicServiceProbeMask(mask: number): boolean;
+declare function isConcreteServiceProbeStatus(status: number): boolean;
+declare function serviceProbeStatusLabel(status: number): string;
+declare function encodeReportServiceProbeCalldata(args: ReportServiceProbeCalldataArgs): string;
+/**
+ * Hosting class an operator runs under (PF-6). Mirrors
+ * `node-registry::registration::HostingClass`. Any byte outside `0..=2`
+ * decodes to `cloud` (the least-diverse class).
+ */
+type NodeHostingClass = "bareMetal" | "coLocation" | "cloud";
+/** Decode a hosting-class byte. Values outside `0..=2` → `cloud`. */
+declare function nodeHostingClassFromByte(b: number): NodeHostingClass;
+/** Encode a hosting class to its right-aligned `u8` enum byte. */
+declare function nodeHostingClassToByte(c: NodeHostingClass): number;
+/**
+ * `lyth_getOperatorNetworkMetadata` view (PF-6). Mirrors the
+ * `(uint16 asn, bytes3 geoRegion, uint8 hostingClass, bytes32
+ * ipAddressHash, bytes32 pcrDigest)` return tuple. The raw IP never
+ * lives on-chain — `ipAddressHash` is `keccak256(ipHint)`.
+ */
+interface OperatorNetworkMetadata {
+    /** Autonomous-system number; `0` = not declared. */
+    asn: number;
+    /** ISO-3166-1 alpha-3 region as `0x` 3-byte hex; all-zero = not declared. */
+    geoRegion: string;
+    /** Declared hosting class. */
+    hostingClass: NodeHostingClass;
+    /** `keccak256` of the operator's public IP (`0x` 32 bytes). */
+    ipAddressHash: string;
+    /** `keccak256` of the TPM PCR digest (`0x` 32 bytes). */
+    pcrDigest: string;
+}
+/**
+ * `lyth_getClusterDiversity` view (PF-6). Mirrors the
+ * `(uint16 score, uint16 asnVariance, uint16 geoVariance, uint16
+ * hostingSpread)` return tuple. Every field is in `0..=10000` bps.
+ */
+interface ClusterDiversity {
+    /** Headline diversity score (`0..=10000`). */
+    score: number;
+    /** Normalised ASN-distribution entropy (`0..=10000`). */
+    asnVariance: number;
+    /** Normalised country-distribution entropy (`0..=10000`). */
+    geoVariance: number;
+    /** Normalised hosting-class-distribution entropy (`0..=10000`). */
+    hostingSpread: number;
+}
+/**
+ * `lyth_getClusterDiversity` RPC response (PF-6).
+ *
+ * Distinct from {@link ClusterDiversity} (which decodes the
+ * `getClusterDiversity(uint32)` ABI return tuple from an `eth_call`):
+ * this is the JSON the `lyth_getClusterDiversity` method returns,
+ * serialized from the chain's `ClusterDiversity` struct with camelCase
+ * keys. It carries the `clusterId` echo that the ABI tuple omits. Every
+ * value is in `0..=10000` basis points.
+ */
+interface ClusterDiversityView {
+    /** Cluster id whose roster was scored. */
+    clusterId: number;
+    /** Headline diversity score (`0..=10000`). */
+    score: number;
+    /** Normalised ASN-distribution entropy (`0..=10000`). */
+    asnVariance: number;
+    /** Normalised country-distribution entropy (`0..=10000`). */
+    geoVariance: number;
+    /** Normalised hosting-class-distribution entropy (`0..=10000`). */
+    hostingSpread: number;
+}
+/**
+ * `lyth_getOperatorNetworkMetadata` RPC response (PF-6).
+ *
+ * Distinct from {@link OperatorNetworkMetadata} (the ABI-decode tuple):
+ * this is the JSON the `lyth_getOperatorNetworkMetadata` method returns,
+ * read from the node-registry registration record (`0x1005`). `geoRegion`
+ * here is the decoded ISO-3166-1 alpha-3 region **string** (or `null`);
+ * `hostingClass` is the snake_case wire string (`bare_metal` /
+ * `co_location` / `cloud`); `asn` is `null` when not declared.
+ */
+interface OperatorNetworkMetadataView {
+    /** Response schema version (`1`). */
+    schemaVersion: number;
+    /** Data source — `"native_state_storage"`. */
+    source: string;
+    /** Node-registry precompile address (`0x1005`). */
+    precompile: string;
+    /** Operator/peer id (`0x` 32-byte hex). */
+    operatorId: string;
+    /** Autonomous-system number; `null` when not declared. */
+    asn: number | null;
+    /** Decoded ISO-3166-1 alpha-3 region string; `null` when not declared. */
+    geoRegion: string | null;
+    /** Declared hosting class as the wire string. */
+    hostingClass: "bare_metal" | "co_location" | "cloud";
+    /** `keccak256` of the operator's public IP (`0x` 32 bytes). */
+    ipAddressHash: string;
+    /** `keccak256` of the TPM PCR digest (`0x` 32 bytes). */
+    pcrDigest: string;
+}
+/**
+ * Decoded `ClusterFormed(uint32,uint64,address,bytes)` event (MB-5).
+ * Mirrors `node-registry::events::CLUSTER_FORMED`.
+ */
+interface ClusterFormedEvent {
+    /** Cluster identifier (indexed topic 1). */
+    clusterId: number;
+    /** Activation epoch (indexed topic 2). */
+    effectiveEpoch: bigint;
+    /** Primary anchor address (`0x` 20 bytes). */
+    anchorAddress: string;
+    /** Concatenated 48-byte compressed BLS pubkeys (`0x` hex). */
+    operatorRoster: string;
+}
+/**
+ * Decode a `getOperatorNetworkMetadata` return tuple — a flat 5-word
+ * head: `(uint16 asn, bytes3 geoRegion, uint8 hostingClass, bytes32
+ * ipAddressHash, bytes32 pcrDigest)`.
+ */
+declare function decodeOperatorNetworkMetadata(returnData: string | Uint8Array | readonly number[]): OperatorNetworkMetadata;
+/**
+ * Decode a `getClusterDiversity` return tuple — a flat 4-word head:
+ * `(uint16 score, uint16 asnVariance, uint16 geoVariance, uint16
+ * hostingSpread)`.
+ */
+declare function decodeClusterDiversity(returnData: string | Uint8Array | readonly number[]): ClusterDiversity;
+/**
+ * Decode a `ClusterFormed` log (MB-5) into a typed {@link ClusterFormedEvent}.
+ *
+ * `topics` is the log topic vector (`topic0`, indexed `clusterId`,
+ * indexed `effectiveEpoch`); `data` is the non-indexed ABI payload
+ * `(address anchorAddress, bytes operatorRoster)`.
+ */
+declare function decodeClusterFormedEvent(topics: readonly (string | Uint8Array | readonly number[])[], data: string | Uint8Array | readonly number[]): ClusterFormedEvent;
+/**
+ * Derive a runtime-formed cluster's primary-anchor address from its
+ * operator roster (MB-5 / Law §7.13).
+ *
+ * Mirrors `node-registry::cluster_anchor::derive_cluster_anchor_address`:
+ * the order-insensitive multisig rule `address = BLAKE3(
+ * MONO_MULTISIG_BLAKE3_20_V1 || threshold_be16 ||
+ * (member_len_be8 || member)*sorted)[..20]`. Returns the `0x`-prefixed
+ * 20-byte address payload.
+ */
+declare function deriveClusterAnchorAddress(roster: readonly (string | Uint8Array | readonly number[])[], threshold: number): string;
+
+/**
+ * Address display helpers.
+ *
+ * Monolythium keeps 20-byte account identifiers on the wire, but
+ * user-facing surfaces display them as `mono1...` bech32m strings.
+ */
+declare const ADDRESS_HRP: "mono";
+declare const ADDRESS_KIND_HRPS: {
+    readonly user: "mono";
+    readonly smartAccount: "monos";
+    readonly contract: "monoc";
+    readonly cluster: "monok";
+    readonly multisig: "monom";
+    readonly systemModule: "monox";
+};
+declare const RESERVED_ADDRESS_HRPS: readonly ["monor", "monop", "monoi", "monoa"];
+type AddressKind = keyof typeof ADDRESS_KIND_HRPS;
+interface TypedAddress {
+    kind: AddressKind;
+    address: string;
+    bytes: Uint8Array;
+    hex: string;
+}
+declare class AddressError extends Error {
+    constructor(message: string);
+}
+declare function hexToAddressBytes(address: string): Uint8Array;
+declare function addressBytesToHex(address: Uint8Array | readonly number[]): string;
+declare function addressToBech32(address: string | Uint8Array | readonly number[]): string;
+declare function addressToTypedBech32(kind: AddressKind, address: string | Uint8Array | readonly number[]): string;
+declare function bech32ToAddressBytes(address: string): Uint8Array;
+declare function bech32ToAddress(address: string): string;
+declare function typedBech32ToAddress(address: string, expectedKind?: AddressKind): TypedAddress;
+declare function requireTypedAddress(address: string, expectedKind: AddressKind, label?: string): string;
+declare function parseAddress(address: string): Uint8Array;
+/** Address-validation result for non-throwing callers (UI forms, search). */
+type AddressValidation = {
+    valid: true;
+    /** Lower-case bech32m representation; matches what the wire format expects. */
+    normalized: string;
+    /** Bech32m kind when the input is a typed bech32m address, otherwise null. */
+    kind: AddressKind | null;
+    /** Which surface the input came from. */
+    format: "hex" | "bech32m";
+    /** Raw 20-byte payload, useful for client-side bytes-derived lookups. */
+    bytes: Uint8Array;
+} | {
+    valid: false;
+    reason: string;
+};
+/**
+ * Validate an address string without throwing. Accepts both raw hex and
+ * typed bech32m. On success returns the canonical bech32m form along with
+ * the kind/format/bytes; on failure returns a short reason string.
+ */
+declare function validateAddress(address: string): AddressValidation;
+declare function normalizeAddressHex(address: string): string;
+
+declare const ML_KEM_768_CIPHERTEXT_LEN = 1088;
+declare const ML_KEM_768_ENCAPSULATION_KEY_LEN = 1184;
+declare const ML_KEM_768_SHARED_SECRET_LEN = 32;
+declare const DKG_NONCE_LEN = 12;
+declare const DKG_AEAD_TAG_LEN = 16;
+declare const MempoolClass: {
+    readonly Transfer: 0;
+    readonly ContractCall: 1;
+    readonly PrivacyOp: 2;
+    readonly CLOBOp: 3;
+    readonly AgentOp: 4;
+    readonly FoundationOp: 5;
+    /** @deprecated Use FoundationOp. */
+    readonly GovernanceOp: 5;
+    readonly RWAOp: 6;
+};
+type MempoolClass = (typeof MempoolClass)[keyof typeof MempoolClass];
+interface NonceAad {
+    sender: Uint8Array;
+    nonce: bigint;
+    chainId: bigint;
+    class: MempoolClass;
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+    gasLimit: bigint;
+}
+interface DecryptHint {
+    epoch: bigint;
+    scheme: number;
+}
+interface EncryptedEnvelope {
+    nonceAad: NonceAad;
+    ciphertext: Uint8Array;
+    decryptionHint: DecryptHint;
+    senderPubkey: Uint8Array;
+    outerSignature: Uint8Array;
+    sender: Uint8Array;
+}
+declare function bincodeNonceAad(aad: NonceAad): Uint8Array;
+declare function bincodeDecryptHint(hint: DecryptHint): Uint8Array;
+declare function bincodeEncryptedEnvelope(env: EncryptedEnvelope): Uint8Array;
+declare function encryptInnerTx(signedInnerTxBincode: Uint8Array, nonceAad: NonceAad, kemEncapsulationKey: Uint8Array): Uint8Array;
+declare function outerSigDigest(nonceAad: NonceAad, ciphertext: Uint8Array, decryptionHint: DecryptHint, senderPubkey: Uint8Array): Uint8Array;
+declare function buildEncryptedEnvelope(args: {
+    signedInnerTxBincode: Uint8Array;
+    nonceAad: NonceAad;
+    decryptionHint: DecryptHint;
+    kemEncapsulationKey: Uint8Array;
+    senderAddress: Uint8Array;
+    senderPubkey: Uint8Array;
+    signOuterDigest: (digest: Uint8Array) => Promise<Uint8Array> | Uint8Array;
+}): Promise<{
+    envelope: EncryptedEnvelope;
+    wireBytes: Uint8Array;
+    wireHex: string;
+}>;
+
+/**
+ * Native market transaction-plan builders.
+ *
+ * These helpers only build signer-ready transaction requests or native module
+ * call material. They do not predict fills, trades, or execution success.
+ */
+
+declare const CLOB_MARKET_ID_DOMAIN_TAG: 193;
+declare const NATIVE_MARKET_MODULE_ADDRESS_BYTES: "0x4d41524b45545f4e41544956455f4d4f445f5631";
+declare const NATIVE_MARKET_MODULE_ADDRESS: string;
+declare const NATIVE_CALL_FORWARDER_ARTIFACT_PROFILE: "native-call-forwarder-v1";
+declare const NATIVE_CALL_FORWARDER_RESPONSE_OFFSET: 768;
+declare const NATIVE_CALL_FORWARDER_RESPONSE_CAPACITY: 256;
+declare const MAX_NATIVE_CALL_FORWARDER_REQUEST_BYTES: 2047;
+declare const CLOB_SELECTORS: {
+    /**
+     * `placeLimitOrder(bytes32,bytes32,uint8,uint256,uint256,uint64)`
+     *
+     * Args: `baseTokenId, quoteTokenId, side, price, amount, expiresAtBlock`.
+     */
+    readonly placeLimitOrder: "0x2468786f";
+    /**
+     * `placeMarketOrder(bytes32,bytes32,uint8,uint256,uint16)`
+     *
+     * Args: `baseTokenId, quoteTokenId, side, quantity, maxSlippageBps`.
+     */
+    readonly placeMarketOrder: "0xb9b1fa86";
+    /**
+     * `placeMarketOrderEx(bytes32,bytes32,uint8,uint256,uint16,uint8)`
+     *
+     * Args: `baseTokenId, quoteTokenId, side, quantity, maxSlippageBps, mode`.
+     */
+    readonly placeMarketOrderEx: "0xa6f092f0";
+    /** `cancelOrder(bytes32)` */
+    readonly cancelOrder: "0x7489ec23";
+    /** `setMinNotional(bytes32,bytes32,uint256)` — foundation-authorized. */
+    readonly setMinNotional: "0x395dc48f";
+    /** `setTickSize(bytes32,bytes32,uint256)` — foundation-authorized per-market grid tune. */
+    readonly setTickSize: "0x10666f0b";
+    /** `setLotSize(bytes32,bytes32,uint256)` — foundation-authorized per-market grid tune. */
+    readonly setLotSize: "0x9909be80";
+};
+/**
+ * Canonical operator-fee router selector signatures (`0x100B`).
+ *
+ * Mirrors `mono-core/crates/precompiles/platform/operator-router/src/abi.rs`
+ * (`sig::*`). Selectors are `keccak256(signature)[0..4]`.
+ */
+declare const OPERATOR_ROUTER_SIGS: {
+    /** `registerOperator(address recipient, uint16 feeBps)`. */
+    readonly registerOperator: "registerOperator(address,uint16)";
+    /** `updateOperator(address recipient, uint16 feeBps)`. */
+    readonly updateOperator: "updateOperator(address,uint16)";
+    /** `disableOperator(address operator)` — foundation-authorized. */
+    readonly disableOperator: "disableOperator(address)";
+    /**
+     * `placeLimitOrderVia(address operator, bytes32 base, bytes32 quote,
+     *  uint8 side, uint256 price, uint256 amount, uint64 expiresAtBlock)`
+     *  → `bytes32 orderId`.
+     *
+     * Skims the operator fee (quote token, `user -> recipient`) then
+     * re-enters the CLOB `placeLimitOrder` op with `caller = user`, so the
+     * resting order is owned + escrowed + cancellable by the user,
+     * identical to a direct CLOB placement.
+     */
+    readonly placeLimitOrderVia: "placeLimitOrderVia(address,bytes32,bytes32,uint8,uint256,uint256,uint64)";
+};
+/** Operator-router selectors as `0x`-prefixed 4-byte hex. */
+declare const OPERATOR_ROUTER_SELECTORS: {
+    readonly registerOperator: string;
+    readonly updateOperator: string;
+    readonly disableOperator: string;
+    readonly placeLimitOrderVia: string;
+};
+/**
+ * Canonical operator-router event declaration strings (`0x100B`).
+ *
+ * Mirrors `operator-router/src/events.rs::sig`. Indexed args are
+ * `operator`, `user`, `marketId` (for `OperatorFeeCharged`).
+ */
+declare const OPERATOR_ROUTER_EVENT_SIGS: {
+    readonly operatorFeeCharged: "OperatorFeeCharged(address,address,bytes32,address,bytes32,uint256,bytes32)";
+    readonly operatorRegistered: "OperatorRegistered(address,address,uint16)";
+    readonly operatorUpdated: "OperatorUpdated(address,address,uint16,bool)";
+};
+type SpotLimitOrderSide = "buy" | "sell";
+type SpotMarketOrderMode = "fill-or-refund" | "fill-or-rest-at-cap";
+type NativeMarketAddressKind = AddressKind;
+type NativeMarketAddressInput = string | {
+    kind?: NativeMarketAddressKind;
+    address: string;
+};
+interface PlaceSpotLimitOrderArgs {
+    /**
+     * Canonical 32-byte CLOB market id, derived as
+     * `keccak256(0xC1 || baseTokenId || quoteTokenId)`.
+     */
+    marketId: string;
+    /** 32-byte base token id accepted by the CLOB precompile. */
+    baseTokenId: string;
+    /** 32-byte quote token id accepted by the CLOB precompile. */
+    quoteTokenId: string;
+    /** `buy` maps to side byte `0`; `sell` maps to side byte `1`. */
+    side: SpotLimitOrderSide;
+    /** Positive integer decimal string encoded as uint256. */
+    price: string;
+    /** Positive integer decimal string encoded as uint256 amount. */
+    quantity: string;
+    /** Optional uint64 block height; omitted means `0` / no explicit expiry. */
+    expiryBlock?: string | number | bigint;
+}
+interface PlaceLimitOrderViaArgs {
+    /**
+     * Operator the order routes through (`mono` bech32m user address). Its
+     * fee registration (`lyth_operatorFeeConfig`) sets the surcharge skimmed
+     * from the quote escrow.
+     */
+    operator: string;
+    /** 32-byte base token id accepted by the CLOB precompile. */
+    base: string;
+    /** 32-byte quote token id accepted by the CLOB precompile. */
+    quote: string;
+    /** `buy` maps to side byte `0`; `sell` maps to side byte `1`. */
+    side: SpotLimitOrderSide;
+    /** Positive integer decimal string encoded as uint256 price. */
+    price: string;
+    /** Positive integer decimal string encoded as uint256 amount. */
+    amount: string;
+    /** Optional uint64 block height; omitted means `0` / no explicit expiry. */
+    expiresAtBlock?: string | number | bigint;
+}
+/**
+ * Wallet-display projection of the declared operator fee for a
+ * {@link PlaceLimitOrderViaArgs} order, computed off-chain as
+ * `quoteBasis * feeBps / 10_000` where `quoteBasis = price * amount`.
+ *
+ * Advisory only — the binding fee is skimmed on-chain at execution time
+ * from the same `quoteBasis`. The fee is denominated in the quote token.
+ */
+interface OperatorFeeQuote {
+    /** Operator the order routes through (`mono` bech32m). */
+    operator: string;
+    /** Declared operator fee in basis points (from `lyth_operatorFeeConfig`). */
+    feeBps: number;
+    /** `price * amount` (the quote-token basis the fee is skimmed from), decimal string. */
+    quoteBasis: string;
+    /** `quoteBasis * feeBps / 10_000`, floored, decimal string of quote-token atoms. */
+    feeAmount: string;
+}
+/** A {@link MarketTransactionPlan} that also carries the declared operator fee. */
+interface PlaceLimitOrderViaPlan extends MarketTransactionPlan {
+    /** Off-chain operator-fee projection for wallet display. */
+    operatorFee: OperatorFeeQuote;
+}
+/**
+ * Decoded `OperatorFeeCharged` log (`0x100B`). Mirrors
+ * `operator-router/src/events.rs::emit_operator_fee_charged_to_host`:
+ * indexed `operator` / `user` / `marketId`; body `recipient`,
+ * `quoteToken`, `feeAmount`, `clobOrderId`. `clobOrderId` joins the
+ * router fee to the CLOB `OrderPlaced` / `OrderMatched` rows.
+ */
+interface OperatorFeeChargedEvent {
+    /** Operator that charged the fee (`0x` 20-byte hex, indexed). */
+    operator: string;
+    /** User that paid the fee (`0x` 20-byte hex, indexed). */
+    user: string;
+    /** CLOB market id the order targets (`0x` 32 bytes, indexed). */
+    marketId: string;
+    /** Fee recipient configured by the operator (`0x` 20-byte hex). */
+    recipient: string;
+    /** Quote token the fee was skimmed in (`0x` 32 bytes). */
+    quoteToken: string;
+    /** Fee amount skimmed (quote-token atoms, decimal string). */
+    feeAmount: string;
+    /** CLOB order id the routed placement produced (`0x` 32 bytes). */
+    clobOrderId: string;
+}
+/**
+ * `lyth_operatorRouterConfig` response — the router's static posture.
+ *
+ * Mirrors the chain JSON exactly (camelCase). `enabled` reflects whether
+ * the gateable router precompile is currently milestone-activated; the
+ * read surfaces work regardless.
+ */
+interface OperatorRouterConfig {
+    /** Response schema version (`1`). */
+    schemaVersion: number;
+    /** Data source — `"native_state_storage"`. */
+    source: string;
+    /** Router precompile address (`0x100B`). */
+    routerAddress: string;
+    /** On-chain protocol fee ceiling in bps (`100` = 1.00%). */
+    protocolMaxOperatorFeeBps: number;
+    /** `true` when the router precompile is milestone-activated. */
+    enabled: boolean;
+}
+/**
+ * `lyth_operatorFeeConfig` response — one operator's fee registration.
+ *
+ * Mirrors the chain JSON exactly (camelCase). A zero recipient is the
+ * "operator not registered" sentinel on-chain, so the chain returns a
+ * not-found error rather than this shape in that case.
+ */
+interface OperatorFeeConfig {
+    /** Response schema version (`1`). */
+    schemaVersion: number;
+    /** Data source — `"native_state_storage"`. */
+    source: string;
+    /** Router precompile address (`0x100B`). */
+    precompile: string;
+    /** Operator the registration belongs to (`mono` bech32m). */
+    operator: string;
+    /** Configured fee recipient (`mono` bech32m). */
+    recipient: string;
+    /** Operator surcharge in basis points. */
+    feeBps: number;
+    /** `true` when the operator's surcharge is active. */
+    enabled: boolean;
+    /** Block height the operator was first registered at. */
+    registeredAtBlock: number;
+}
+interface PlaceSpotMarketOrderArgs {
+    /**
+     * Canonical 32-byte CLOB market id, derived as
+     * `keccak256(0xC1 || baseTokenId || quoteTokenId)`.
+     */
+    marketId: string;
+    /** 32-byte base token id accepted by the CLOB precompile. */
+    baseTokenId: string;
+    /** 32-byte quote token id accepted by the CLOB precompile. */
+    quoteTokenId: string;
+    /** `buy` maps to side byte `0`; `sell` maps to side byte `1`. */
+    side: SpotLimitOrderSide;
+    /** Positive integer decimal string encoded as uint256 amount. */
+    quantity: string;
+    /** Slippage bound in basis points; must be less than 10,000. */
+    maxSlippageBps: string | number | bigint;
+}
+interface PlaceSpotMarketOrderExArgs extends PlaceSpotMarketOrderArgs {
+    /**
+     * `fill-or-refund` keeps legacy market-order semantics; `fill-or-rest-at-cap`
+     * rests the unfilled remainder at the slippage cap.
+     */
+    mode: SpotMarketOrderMode;
+}
+interface CancelSpotOrderArgs {
+    /** 32-byte order id returned by the CLOB precompile. */
+    orderId: string;
+}
+interface EncodeNativeSpotLimitOrderArgs {
+    /** 32-byte native spot market id. */
+    marketId: string;
+    /** Owner typed bech32m MonoAddress; optional object `kind` asserts the expected HRP. */
+    owner: NativeMarketAddressInput;
+    /** Per-owner order nonce encoded as uint64. */
+    nonce: string | number | bigint;
+    /** `buy` maps to native `OrderSide::Bid`; `sell` maps to native `OrderSide::Ask`. */
+    side: SpotLimitOrderSide;
+    /** Positive integer decimal string encoded as native MrcAmount/u128. */
+    price: string;
+    /** Positive integer decimal string encoded as native MrcAmount/u128. */
+    quantity: string;
+    /** uint64 expiry block encoded as `expires_at_block`. */
+    expiresAtBlock: string | number | bigint;
+}
+interface EncodeNativeSpotCreateMarketArgs {
+    /** Market owner typed bech32m MonoAddress; optional object `kind` asserts the expected HRP. */
+    owner: NativeMarketAddressInput;
+    /** Owner-local market nonce encoded as uint64. */
+    nonce: string | number | bigint;
+    /** 32-byte base asset id. */
+    baseAsset: string;
+    /** 32-byte quote asset id. */
+    quoteAsset: string;
+    /** Positive integer decimal string encoded as native MrcAmount/u128. */
+    tickSize: string;
+    /** Positive integer decimal string encoded as native MrcAmount/u128. */
+    lotSize: string;
+    /** Positive integer decimal string encoded as native MrcAmount/u128. */
+    minQuantity: string;
+    /** Nonnegative integer decimal string encoded as native MrcAmount/u128; 0 disables the floor. */
+    minNotional: string;
+}
+interface EncodeNativeSpotCancelOrderArgs {
+    /** 32-byte native order id. */
+    orderId: string;
+    /** Caller typed bech32m MonoAddress; optional object `kind` asserts the expected HRP. */
+    caller: NativeMarketAddressInput;
+}
+interface EncodeNativeSpotSettleLimitOrderArgs {
+    /** Resting maker order id to match. */
+    makerOrderId: string;
+    /** Taker limit order parameters. */
+    takerOrder: EncodeNativeSpotLimitOrderArgs;
+}
+interface EncodeNativeSpotSettleRoutedLimitOrderArgs {
+    /** Resting maker order ids in deterministic settlement order; mono-core accepts 1..64 ids. */
+    makerOrderIds: readonly string[];
+    /** Taker limit order parameters. */
+    takerOrder: EncodeNativeSpotLimitOrderArgs;
+}
+type NativeNftAssetStandard = "mrc721" | "mrc1155";
+type NativeNftListingKind = "fixed-price" | {
+    english: {
+        /** Minimum starting bid encoded as native MrcAmount/u128. */
+        reserve: string;
+        /** Auction end block encoded as uint64. */
+        endBlock: string | number | bigint;
+        /** Minimum bid bump in basis points; must be less than 10,000. */
+        minBidIncrementBps: string | number | bigint;
+    };
+};
+interface EncodeNativeNftCreateListingArgs {
+    /** Seller typed bech32m MonoAddress; optional object `kind` asserts the expected HRP. */
+    seller: NativeMarketAddressInput;
+    /** Seller-local listing nonce encoded as uint64. */
+    nonce: string | number | bigint;
+    /** Native NFT asset standard. */
+    standard: NativeNftAssetStandard;
+    /** 32-byte collection id. */
+    collectionId: string;
+    /** 32-byte token id. */
+    tokenId: string;
+    /** Positive integer decimal string encoded as native MrcAmount/u128. */
+    quantity: string;
+    /** 32-byte payment asset id. */
+    paymentAsset: string;
+    /** Positive integer decimal string encoded as native MrcAmount/u128. */
+    price: string;
+    /** Fixed-price or English-auction sale model. */
+    kind: NativeNftListingKind;
+    /** uint64 expiry block encoded as `expires_at_block`; 0 means never. */
+    expiresAtBlock: string | number | bigint;
+}
+interface EncodeNativeNftBuyListingArgs {
+    /** 32-byte native NFT listing id. */
+    listingId: string;
+    /** Buyer typed bech32m MonoAddress; optional object `kind` asserts the expected HRP. */
+    buyer: NativeMarketAddressInput;
+    /** Current block attached to the native buy call. */
+    currentBlock: string | number | bigint;
+}
+interface EncodeNativeNftCancelListingArgs {
+    /** 32-byte native NFT listing id. */
+    listingId: string;
+    /** Caller typed bech32m MonoAddress; optional object `kind` asserts the expected HRP. */
+    caller: NativeMarketAddressInput;
+}
+interface EncodeNativeNftPlaceAuctionBidArgs {
+    /** 32-byte native NFT auction listing id. */
+    listingId: string;
+    /** Bidder typed bech32m MonoAddress; optional object `kind` asserts the expected HRP. */
+    bidder: NativeMarketAddressInput;
+    /** Positive integer decimal string encoded as native MrcAmount/u128. */
+    amount: string;
+    /** Current block attached to the native auction bid call. */
+    currentBlock: string | number | bigint;
+}
+interface EncodeNativeNftSettleAuctionArgs {
+    /** 32-byte native NFT auction listing id. */
+    listingId: string;
+    /** Current block attached to the native auction settlement call. */
+    currentBlock: string | number | bigint;
+}
+interface EncodeNativeNftSweepExpiredListingsArgs {
+    /** Candidate 32-byte native NFT listing ids; mono-core accepts 1..64 ids. */
+    listingIds: readonly string[];
+    /** Current block attached to the native listing sweep call. */
+    currentBlock: string | number | bigint;
+}
+interface NativeMarketModuleContractCall {
+    /** Stable typed system-module address (`MARKET_NATIVE_MOD_V1`). */
+    to: string;
+    /** Native market router bincode payload. */
+    input: string;
+    /** Native market module calls must not carry native value. */
+    valueLythoshi: "0";
+    /** Maximum cycles delegated to the RISC-V host call. */
+    maxCycles: string;
+}
+interface NativeMarketModuleCallEnvelope {
+    module: "market";
+    call: NativeMarketModuleContractCall;
+}
+interface NativeMarketForwarderInput {
+    /** Canonical `SyscallRequest::CallContract` bytes for MRV call input. */
+    input: string;
+    /** Byte length of `input`, useful because the minimal forwarder artifact pins this as an immediate. */
+    requestBytes: number;
+}
+interface NativeCallForwarderArtifact {
+    /** Raw bincode MRV artifact bytes for a fixed-size native-call forwarder. */
+    artifactBytes: string;
+    /** Byte length accepted by the generated forwarder. */
+    requestBytes: number;
+    /** Stable runtime profile string used for capability matching. */
+    artifactProfile: typeof NATIVE_CALL_FORWARDER_ARTIFACT_PROFILE;
+    /** Forwarder code-section hash as `0x` hex. */
+    codeHash: string;
+}
+interface EthSendTransactionRequest {
+    to: string;
+    value: "0x0";
+    data: string;
+}
+interface MarketTransactionPlan {
+    method: "eth_sendTransaction";
+    params: [EthSendTransactionRequest];
+    mempoolClass: MempoolClass;
+}
+declare class MarketActionError extends Error {
+    constructor(message: string);
+}
+declare function clobAddressHex(): string;
+declare function deriveClobMarketId(baseTokenId: string, quoteTokenId: string): string;
+declare function deriveNativeSpotMarketId(args: Pick<EncodeNativeSpotCreateMarketArgs, "owner" | "baseAsset" | "quoteAsset" | "nonce">): string;
+declare function deriveNativeSpotOrderId(args: Pick<EncodeNativeSpotLimitOrderArgs, "marketId" | "owner" | "side" | "nonce">): string;
+declare function encodePlaceLimitOrderCalldata(args: PlaceSpotLimitOrderArgs): string;
+declare function encodePlaceMarketOrderCalldata(args: PlaceSpotMarketOrderArgs): string;
+declare function encodePlaceMarketOrderExCalldata(args: PlaceSpotMarketOrderExArgs): string;
+declare function encodeCancelOrderCalldata(args: CancelSpotOrderArgs): string;
+/** Three foundation-authorized per-market grid tuners share the
+ *  same `(bytes32,bytes32,uint256)` shape: minNotional, tickSize,
+ *  lotSize. They auto-create the market record if absent. */
+interface MarketGridTuneArgs {
+    baseTokenId: string;
+    quoteTokenId: string;
+    /** Decimal string of quote atoms (minNotional) or atoms-per-unit (tick/lot). */
+    newValue: string;
+}
+declare function encodeSetMinNotionalCalldata(args: MarketGridTuneArgs): string;
+declare function encodeSetTickSizeCalldata(args: MarketGridTuneArgs): string;
+declare function encodeSetLotSizeCalldata(args: MarketGridTuneArgs): string;
+declare function encodeNativeSpotLimitOrderCall(args: EncodeNativeSpotLimitOrderArgs): string;
+declare function encodeNativeSpotCreateMarketCall(args: EncodeNativeSpotCreateMarketArgs): string;
+declare function encodeNativeSpotCancelOrderCall(args: EncodeNativeSpotCancelOrderArgs): string;
+declare function encodeNativeSpotSettleLimitOrderCall(args: EncodeNativeSpotSettleLimitOrderArgs): string;
+declare function encodeNativeSpotSettleRoutedLimitOrderCall(args: EncodeNativeSpotSettleRoutedLimitOrderArgs): string;
+declare function encodeNativeNftCreateListingCall(args: EncodeNativeNftCreateListingArgs): string;
+declare function encodeNativeNftBuyListingCall(args: EncodeNativeNftBuyListingArgs): string;
+declare function encodeNativeNftCancelListingCall(args: EncodeNativeNftCancelListingArgs): string;
+declare function encodeNativeNftPlaceAuctionBidCall(args: EncodeNativeNftPlaceAuctionBidArgs): string;
+declare function encodeNativeNftSettleAuctionCall(args: EncodeNativeNftSettleAuctionArgs): string;
+declare function encodeNativeNftSweepExpiredListingsCall(args: EncodeNativeNftSweepExpiredListingsArgs): string;
+declare function buildNativeMarketModuleCallEnvelope(input: string, maxCycles: string | number | bigint): NativeMarketModuleCallEnvelope;
+declare function encodeNativeMarketModuleForwarderInput(envelope: NativeMarketModuleCallEnvelope): NativeMarketForwarderInput;
+declare function buildNativeSpotLimitOrderForwarderInput(args: EncodeNativeSpotLimitOrderArgs, maxCycles: string | number | bigint): NativeMarketForwarderInput;
+declare function buildNativeSpotCreateMarketForwarderInput(args: EncodeNativeSpotCreateMarketArgs, maxCycles: string | number | bigint): NativeMarketForwarderInput;
+declare function buildNativeSpotCancelOrderForwarderInput(args: EncodeNativeSpotCancelOrderArgs, maxCycles: string | number | bigint): NativeMarketForwarderInput;
+declare function buildNativeSpotSettleLimitOrderForwarderInput(args: EncodeNativeSpotSettleLimitOrderArgs, maxCycles: string | number | bigint): NativeMarketForwarderInput;
+declare function buildNativeSpotSettleRoutedLimitOrderForwarderInput(args: EncodeNativeSpotSettleRoutedLimitOrderArgs, maxCycles: string | number | bigint): NativeMarketForwarderInput;
+declare function buildNativeNftCreateListingForwarderInput(args: EncodeNativeNftCreateListingArgs, maxCycles: string | number | bigint): NativeMarketForwarderInput;
+declare function buildNativeNftBuyListingForwarderInput(args: EncodeNativeNftBuyListingArgs, maxCycles: string | number | bigint): NativeMarketForwarderInput;
+declare function buildNativeNftCancelListingForwarderInput(args: EncodeNativeNftCancelListingArgs, maxCycles: string | number | bigint): NativeMarketForwarderInput;
+declare function buildNativeNftPlaceAuctionBidForwarderInput(args: EncodeNativeNftPlaceAuctionBidArgs, maxCycles: string | number | bigint): NativeMarketForwarderInput;
+declare function buildNativeNftSettleAuctionForwarderInput(args: EncodeNativeNftSettleAuctionArgs, maxCycles: string | number | bigint): NativeMarketForwarderInput;
+declare function buildNativeNftSweepExpiredListingsForwarderInput(args: EncodeNativeNftSweepExpiredListingsArgs, maxCycles: string | number | bigint): NativeMarketForwarderInput;
+declare function buildNativeSpotLimitOrderModuleCall(args: EncodeNativeSpotLimitOrderArgs, maxCycles: string | number | bigint): NativeMarketModuleCallEnvelope;
+declare function buildNativeSpotCreateMarketModuleCall(args: EncodeNativeSpotCreateMarketArgs, maxCycles: string | number | bigint): NativeMarketModuleCallEnvelope;
+declare function buildNativeSpotCancelOrderModuleCall(args: EncodeNativeSpotCancelOrderArgs, maxCycles: string | number | bigint): NativeMarketModuleCallEnvelope;
+declare function buildNativeSpotSettleLimitOrderModuleCall(args: EncodeNativeSpotSettleLimitOrderArgs, maxCycles: string | number | bigint): NativeMarketModuleCallEnvelope;
+declare function buildNativeSpotSettleRoutedLimitOrderModuleCall(args: EncodeNativeSpotSettleRoutedLimitOrderArgs, maxCycles: string | number | bigint): NativeMarketModuleCallEnvelope;
+declare function buildNativeNftCreateListingModuleCall(args: EncodeNativeNftCreateListingArgs, maxCycles: string | number | bigint): NativeMarketModuleCallEnvelope;
+declare function buildNativeNftBuyListingModuleCall(args: EncodeNativeNftBuyListingArgs, maxCycles: string | number | bigint): NativeMarketModuleCallEnvelope;
+declare function buildNativeNftCancelListingModuleCall(args: EncodeNativeNftCancelListingArgs, maxCycles: string | number | bigint): NativeMarketModuleCallEnvelope;
+declare function buildNativeNftPlaceAuctionBidModuleCall(args: EncodeNativeNftPlaceAuctionBidArgs, maxCycles: string | number | bigint): NativeMarketModuleCallEnvelope;
+declare function buildNativeNftSettleAuctionModuleCall(args: EncodeNativeNftSettleAuctionArgs, maxCycles: string | number | bigint): NativeMarketModuleCallEnvelope;
+declare function buildNativeNftSweepExpiredListingsModuleCall(args: EncodeNativeNftSweepExpiredListingsArgs, maxCycles: string | number | bigint): NativeMarketModuleCallEnvelope;
+declare function buildPlaceSpotLimitOrderPlan(args: PlaceSpotLimitOrderArgs): MarketTransactionPlan;
+declare function buildPlaceSpotMarketOrderPlan(args: PlaceSpotMarketOrderArgs): MarketTransactionPlan;
+declare function buildPlaceSpotMarketOrderExPlan(args: PlaceSpotMarketOrderExArgs): MarketTransactionPlan;
+declare function buildCancelSpotOrderPlan(args: CancelSpotOrderArgs): MarketTransactionPlan;
+/**
+ * Encode `placeLimitOrderVia(address,bytes32,bytes32,uint8,uint256,
+ * uint256,uint64)` calldata for the operator-fee router (`0x100B`).
+ *
+ * The argument layout mirrors the direct CLOB `placeLimitOrder` encoder
+ * exactly, prefixed with the left-padded `operator` address word. The
+ * router strips that leading word and forwards the remaining six fields
+ * to the CLOB unchanged.
+ */
+declare function encodePlaceLimitOrderViaCalldata(args: PlaceLimitOrderViaArgs): string;
+/**
+ * Compute the off-chain declared operator fee for wallet display:
+ * `quoteBasis * feeBps / 10_000` (floored) where `quoteBasis =
+ * price * amount`. `feeBps` is the operator's registered fee
+ * (`lyth_operatorFeeConfig`). Rejects a `feeBps` above the protocol
+ * ceiling so a stale / hostile registration can't be displayed as valid.
+ */
+declare function quoteOperatorFee(args: Pick<PlaceLimitOrderViaArgs, "operator" | "price" | "amount">, feeBps: number): OperatorFeeQuote;
+/**
+ * Build a routed limit-order plan (`placeLimitOrderVia` against the
+ * operator router at `0x100B`) plus the declared operator-fee projection
+ * for wallet display.
+ *
+ * Two-spender approval model: the user must approve **two** spenders for
+ * this order to succeed — the CLOB (`0x1001`) for the order's quote/base
+ * escrow, AND the operator router (`0x100B`) for the fee skim. A wallet
+ * surfacing this plan should prompt both approvals (or one combined
+ * approval covering `quoteBasis + feeAmount`).
+ */
+declare function buildPlaceLimitOrderViaPlan(args: PlaceLimitOrderViaArgs, feeBps: number): PlaceLimitOrderViaPlan;
+/**
+ * Decode an `OperatorFeeCharged` log (`0x100B`) into a typed
+ * {@link OperatorFeeChargedEvent}. `topics` is the log topic vector
+ * (`topic0`, indexed `operator`, indexed `user`, indexed `marketId`);
+ * `data` is the non-indexed ABI body
+ * `(address recipient, bytes32 quoteToken, uint256 feeAmount, bytes32 clobOrderId)`.
+ */
+declare function decodeOperatorFeeChargedEvent(topics: readonly (string | Uint8Array | readonly number[])[], data: string | Uint8Array | readonly number[]): OperatorFeeChargedEvent;
+declare function buildNativeCallForwarderArtifact(requestBytes: string | number | bigint): NativeCallForwarderArtifact;
+
+/**
+ * Oracle-precompile (`0x1009`) event decode types + read-method
+ * signatures (MB-6).
+ *
+ * Mirrors `mono-core/crates/precompiles/platform/oracle/src/events.rs`:
+ * the canonical event signatures and a pure decoder that turns one EVM
+ * log (topics + data) into a typed {@link OracleEvent}. The decoder is
+ * the exact inverse of the chain-side `emit_*` helpers.
+ */
+declare const ORACLE_EVENT_SIGS: {
+    readonly oracleRoundFinalized: "OracleRoundFinalized(bytes32,uint64,uint256,uint64,uint32)";
+    readonly observationSubmitted: "ObservationSubmitted(bytes32,uint64,address,uint256,uint64)";
+    readonly feedAdded: "FeedAdded(bytes32,uint8,uint16,uint32,uint32)";
+    readonly feedUpdated: "FeedUpdated(bytes32,uint8,uint16,uint32,uint32)";
+    readonly oracleFraudSlashed: "OracleFraudSlashed(bytes32,uint64,address,bytes32)";
+    readonly oracleAdminUpdated: "OracleAdminUpdated(address)";
+    readonly oracleWriterAdded: "OracleWriterAdded(address,address)";
+    readonly oracleWriterRemoved: "OracleWriterRemoved(address,address)";
+};
+declare class OracleEventError extends Error {
+    constructor(message: string);
+}
+/** One active oracle writer in a {@link OracleSignersResponse}. */
+interface OracleSignerRow {
+    /** Writer address in the active global oracle signer roster (`mono` bech32m). */
+    writer: string;
+    /** Admin that last authorized this writer's membership (`mono` bech32m). */
+    admin: string;
+    /** Block height of the latest membership fold. */
+    updatedAtBlock: number;
+}
+/**
+ * `lyth_oracleSigners` response — the global oracle writer roster, folded
+ * from `OracleWriterAdded` / `OracleWriterRemoved` by the oracle indexer
+ * projection (MB-6).
+ *
+ * When the node runs without that projection it returns the graceful
+ * fallback `{ status: "indexer_unavailable", writers: [] }` — `writers`
+ * is always present so callers can iterate unconditionally; use
+ * `lyth_oracleWriters(feedId)` for the per-feed writer set in that case.
+ */
+interface OracleSignersResponse {
+    /** Response schema version (`1`). */
+    schemaVersion: number;
+    /** `"indexer_unavailable"` on the graceful-fallback path; absent when served. */
+    status?: "indexer_unavailable";
+    /** Data source — `"oracle_indexer_projection"`. */
+    source: string;
+    /** Oracle precompile address (`0x1009`). */
+    precompile: string;
+    /** Active writers; empty on the fallback path. */
+    writers: OracleSignerRow[];
+    /** Human-readable reason on the fallback path. */
+    reason?: string;
+}
+/**
+ * `lyth_oracleWriters` response — the allowed-writer roster for one feed
+ * (MB-6), read from the feed-config writer list (`0x1009`).
+ */
+interface OracleWriters {
+    /** Response schema version (`1`). */
+    schemaVersion: number;
+    /** Data source — `"native_state_storage"`. */
+    source: string;
+    /** Oracle precompile address (`0x1009`). */
+    precompile: string;
+    /** Feed the writers are scoped to (`0x` 32 bytes). */
+    feedId: string;
+    /** Allowed writer addresses (`mono` bech32m). */
+    writers: string[];
+}
+/**
+ * `lyth_oracleLatestPrice` response — the latest finalized round's median
+ * for one feed (MB-6). A registered feed with no closed round yet returns
+ * `round: 0`, `median: null`, `finalized: false`.
+ */
+interface OracleLatestPrice {
+    /** Response schema version (`1`). */
+    schemaVersion: number;
+    /** Data source — `"native_state_storage"`. */
+    source: string;
+    /** Oracle precompile address (`0x1009`). */
+    precompile: string;
+    /** Feed id (`0x` 32 bytes). */
+    feedId: string;
+    /** Feed decimals. */
+    decimals: number;
+    /** Latest round id; `0` before the first round closes. */
+    round: number;
+    /** `true` once the latest round is finalized. */
+    finalized: boolean;
+    /** Finalized median (`0x`-hex `uint256`); `null` while unfinalized. */
+    median: string | null;
+    /** Block the latest round finalized at; `null` while unfinalized. */
+    finalizedAtBlock: number | null;
+}
+/**
+ * `lyth_oracleFeedConfig` response — one feed's decimals / heartbeat /
+ * deviation-bps (circuit breaker) / min-signers config (MB-6).
+ */
+interface OracleFeedConfig {
+    /** Response schema version (`1`). */
+    schemaVersion: number;
+    /** Data source — `"native_state_storage"`. */
+    source: string;
+    /** Oracle precompile address (`0x1009`). */
+    precompile: string;
+    /** Feed id (`0x` 32 bytes). */
+    feedId: string;
+    /** Feed decimals. */
+    decimals: number;
+    /** Minimum signers required to finalize a round. */
+    minSigners: number;
+    /** Max observation age (heartbeat) in seconds. */
+    heartbeatSeconds: number;
+    /** Circuit-breaker deviation bound in basis points. */
+    deviationBps: number;
+    /** Number of allowed writers configured for the feed. */
+    allowedWritersLen: number;
+}
+/** Return the oracle precompile address (`0x1009`) as lower-case hex. */
+declare function oracleAddressHex(): string;
+/**
+ * Typed view of one oracle-precompile log (MB-6). One variant per
+ * chain-side emit helper. `feedId` / `evidenceHash` / address fields are
+ * `0x`-prefixed hex; `computedMedian` / `value` are decimal strings of
+ * their on-chain `uint256` value.
+ */
+type OracleEvent = {
+    kind: "roundFinalized";
+    feedId: string;
+    roundId: bigint;
+    computedMedian: string;
+    finalizedAtBlock: bigint;
+    observationsLen: number;
+} | {
+    kind: "observationSubmitted";
+    feedId: string;
+    roundId: bigint;
+    writer: string;
+    value: string;
+    observedAt: bigint;
+} | {
+    kind: "fraudSlashed";
+    feedId: string;
+    roundId: bigint;
+    writer: string;
+    evidenceHash: string;
+} | {
+    kind: "feedAdded";
+    feedId: string;
+    decimals: number;
+    minSigners: number;
+    circuitBreakerBps: number;
+    allowedWritersLen: number;
+} | {
+    kind: "feedUpdated";
+    feedId: string;
+    decimals: number;
+    minSigners: number;
+    circuitBreakerBps: number;
+    allowedWritersLen: number;
+} | {
+    kind: "adminUpdated";
+    admin: string;
+} | {
+    kind: "writerAdded";
+    admin: string;
+    writer: string;
+} | {
+    kind: "writerRemoved";
+    admin: string;
+    writer: string;
+};
+/**
+ * Decode one EVM log emitted by the oracle precompile into a typed
+ * {@link OracleEvent}. Pure + deterministic; dispatches on `topic0`,
+ * then reads fixed-width 32-byte words.
+ *
+ * @throws {OracleEventError} on a foreign `topic0`, a topic-arity
+ *   mismatch, or a data-length mismatch.
+ */
+declare function decodeOracleEvent(topics: readonly (string | Uint8Array | readonly number[])[], data: string | Uint8Array | readonly number[]): OracleEvent;
+
+/**
+ * GPU prover-market precompile ABI helpers + read types (MB-4).
+ *
+ * Mirrors `mono-core/crates/precompiles/platform/prover-market`. The six
+ * ops (`createRequest` / `submitBid` / `closeRequest` / `submitProof` /
+ * `settle` / `slash`) all take a single `bytes` canonical payload; their
+ * selectors are `keccak256(sig)[..4]`.
+ *
+ * Only the `createRequest` canonical payload is finalized on the chain
+ * side today (`ProofRequest::encode_canonical`). The other five op
+ * bodies land at the deferred runtime-wiring wave, so their canonical
+ * payload encoders carry a `TODO(monolythium-vision)` below.
+ */
+/**
+ * GPU prover-market precompile address (`0x100C`).
+ *
+ * Final, registered slot. (The earlier first-pass guess of `0x1110`
+ * assumed MB-5 took `0x1110` for a new precompile; MB-5 instead shipped
+ * `attestDkgReshare` as a selector inside node-registry `0x1005`, so the
+ * platform extension band's lowest free slot — `0x100C`, after the
+ * operator router at `0x100B` — is where the prover market binds.) The
+ * precompile is gateable + genesis-disabled per ADR-0015 §3; activation
+ * is a foundation milestone flip, but the `lyth_*` read surfaces work
+ * regardless.
+ */
+declare const PROVER_MARKET_ADDRESS: "0x000000000000000000000000000000000000100C";
+/** `SERVES_GPU_PROVE` capability bit (MB-4) — bit 9 of the node-registry field. */
+declare const SERVES_GPU_PROVE: 512;
+declare const PROVER_MARKET_SELECTORS: {
+    readonly createRequest: string;
+    readonly submitBid: string;
+    readonly closeRequest: string;
+    readonly submitProof: string;
+    readonly settle: string;
+    readonly slash: string;
+};
+declare const PROVER_MARKET_EVENT_SIGS: {
+    readonly proofRequested: "ProofRequested(bytes32,address,bytes32,uint128,uint64)";
+    readonly bidSubmitted: "BidSubmitted(bytes32,address,uint128)";
+    readonly requestAssigned: "RequestAssigned(bytes32,address,uint128)";
+    readonly proofSettled: "ProofSettled(bytes32,address,uint128,uint128)";
+    readonly proverSlashed: "ProverSlashed(bytes32,address,uint16,bytes32)";
+    readonly requestExpired: "RequestExpired(bytes32,address,uint128)";
+};
+/** `ProverSlashed` reason code: non-delivery past deadline. */
+declare const PROVER_SLASH_REASON_NON_DELIVERY: 1024;
+/** `ProverSlashed` reason code: bad proof. */
+declare const PROVER_SLASH_REASON_BAD_PROOF: 1025;
+declare const PROVER_MARKET_REQUEST_DOMAIN: "prover_market.request.v1";
+declare const PROVER_MARKET_BID_DOMAIN: "prover_market.bid.v1";
+declare const PROVER_MARKET_SUBMIT_DOMAIN: "prover_market.submit.v1";
+/** State machine for a proof request (mirrors `ProverMarketState`). */
+type ProverMarketState = "open" | "assigned" | "settled" | "slashed" | "expired";
+/** Decode a `ProverMarketState` from its on-chain wire byte, or `null`. */
+declare function proverMarketStateFromByte(b: number): ProverMarketState | null;
+/**
+ * `lyth_getProofRequest` response — one proof-request record read
+ * directly from the prover-market state tree (`0x100C`).
+ *
+ * Mirrors the chain JSON exactly (camelCase keys). Fee amounts are
+ * `0x`-hex `uint256` strings; addresses are `mono` bech32m (null while
+ * unset); hashes are `0x`-hex words. This is the exact-lookup shape; the
+ * indexer-backed list rows ({@link ProofRequestRow}) carry a different
+ * field set.
+ */
+interface ProofRequestView {
+    /** Response schema version (`1`). */
+    schemaVersion: number;
+    /** Data source — `"native_state_storage"`. */
+    source: string;
+    /** Prover-market precompile address (`0x100C`). */
+    precompile: string;
+    /** Canonical request id (`0x` 32 bytes). */
+    requestId: string;
+    /** Lifecycle state name. */
+    state: ProverMarketState | string;
+    /** Lifecycle state wire byte (`0`..=`4`). */
+    stateCode: number;
+    /** Buyer (`mono` bech32m); `null` when unset. */
+    buyer: string | null;
+    /** Verification-key hash the proof must satisfy (`0x` 32 bytes). */
+    vkeyHash: string;
+    /** Public-inputs commitment (`0x` 32 bytes). */
+    inputsHash: string;
+    /** Maximum fee escrowed (`0x`-hex `uint256`). */
+    maxFee: string;
+    /** Deterministic Unix-seconds deadline. */
+    deadlineUnixSeconds: number;
+    /** Assigned prover (`mono` bech32m); `null` while Open/Expired. */
+    assignedProver: string | null;
+    /** Winning fee bid (`0x`-hex `uint256`); `0x0` while Open. */
+    winningFee: string;
+    /** Unix seconds of the last state transition. */
+    stateAtUnixSeconds: number;
+    /** Delivered proof hash (`0x` 32 bytes); zero until `submitProof`. */
+    proofHash: string;
+    /** Number of bids recorded against the request. */
+    bidCount: number;
+}
+/**
+ * `lyth_listProofRequests` row — one indexer-projection proof-request
+ * record. Distinct from {@link ProofRequestView}: fee amounts here are
+ * decimal atomic-unit strings (the indexer projection's wire form), and
+ * the row carries `feePaid` + `createdAtBlock` instead of the
+ * state-tree-only `inputsHash` / `stateCode` / `proofHash` fields.
+ */
+interface ProofRequestRow {
+    /** Content-addressed request id (`0x` 32 bytes). */
+    requestId: string;
+    /** Requesting buyer (`mono` bech32m). */
+    buyer: string;
+    /** Verification-key hash bound to the request (`0x` 32 bytes). */
+    vkeyHash: string;
+    /** Maximum fee escrowed (decimal atomic-unit string). */
+    maxFee: string;
+    /** Deadline (unix seconds). */
+    deadlineUnixSeconds: number;
+    /** Lifecycle state name. */
+    state: ProverMarketState | string;
+    /** Assigned prover (`mono` bech32m); `null` until a winner is selected. */
+    assignedProver: string | null;
+    /** Winning fee (decimal atomic-unit string); `null` until assigned. */
+    winningFee: string | null;
+    /** Number of bids recorded against the request. */
+    bidCount: number;
+    /** Fee paid out on settlement (decimal atomic-unit string); `null` otherwise. */
+    feePaid: string | null;
+    /** Block height the request was first observed at. */
+    createdAtBlock: number;
+}
+/**
+ * `lyth_listProofRequests` response envelope.
+ *
+ * When the node runs without the prover-market indexer projection it
+ * returns the graceful fallback `{ status: "indexer_unavailable", … }`
+ * with an empty `requests` array — `requests` is always present so
+ * callers can iterate unconditionally.
+ */
+interface ListProofRequestsResponse {
+    /** Response schema version (`1`). */
+    schemaVersion: number;
+    /** `"indexer_unavailable"` on the graceful-fallback path; absent when served. */
+    status?: "indexer_unavailable";
+    /** Data source — `"prover_market_indexer_projection"`. */
+    source: string;
+    /** Prover-market precompile address (`0x100C`). */
+    precompile: string;
+    /** Echo of the lifecycle-state filter, when one was supplied. */
+    stateFilter?: ProverMarketState | string | null;
+    /** Echo of the page cap, when served. */
+    limit?: number;
+    /** Matching rows, newest-first. Empty on the fallback path. */
+    requests: ProofRequestRow[];
+    /** Human-readable reason on the fallback path. */
+    reason?: string;
+}
+/**
+ * `lyth_getProverBids` response — every recorded bid against one request,
+ * read from the prover-market bid slots (`0x100C`).
+ */
+interface ProverBidsResponse {
+    /** Response schema version (`1`). */
+    schemaVersion: number;
+    /** Data source — `"native_state_storage"`. */
+    source: string;
+    /** Prover-market precompile address (`0x100C`). */
+    precompile: string;
+    /** Request the bids target (`0x` 32 bytes). */
+    requestId: string;
+    /** Number of bids recorded. */
+    bidCount: number;
+    /** Recorded fee bids. */
+    bids: ProverBidView[];
+}
+/** One prover fee bid in a {@link ProverBidsResponse}. */
+interface ProverBidView {
+    /** Slot index of this bid within the request's bid list. */
+    index: number;
+    /** Bidding prover (`mono` bech32m); must hold `SERVES_GPU_PROVE`. */
+    prover: string;
+    /** Fee bid (`0x`-hex `uint256`); must be `<= maxFee`. */
+    fee: string;
+}
+/**
+ * `lyth_proverMarketStatus` response — market-wide prover-market stats.
+ *
+ * `feeFloor` is the on-chain genesis singleton (always present, read
+ * directly from `0x100C`). The aggregate counts come from the indexer
+ * projection; when the node runs without it the response carries
+ * `status: "indexer_unavailable"` and the count fields are `null`.
+ */
+interface ProverMarketStatusResponse {
+    /** Response schema version (`1`). */
+    schemaVersion: number;
+    /** `"indexer_unavailable"` on the graceful-fallback path; absent when served. */
+    status?: "indexer_unavailable";
+    /** Data source — `"prover_market_indexer_projection"`. */
+    source: string;
+    /** Prover-market precompile address (`0x100C`). */
+    precompile: string;
+    /** Genesis-configured minimum prover fee (`0x`-hex `uint256`). */
+    feeFloor: string;
+    /** Requests in the `open` state; `null` on the fallback path. */
+    openRequests: number | null;
+    /** Requests in the `assigned` state; `null` on the fallback path. */
+    assignedRequests: number | null;
+    /** Requests in the `settled` state; `null` on the fallback path. */
+    settledRequests: number | null;
+    /** Requests in the `slashed` state; absent on the fallback path. */
+    slashedRequests?: number | null;
+    /** Requests in the `expired` state; absent on the fallback path. */
+    expiredRequests?: number | null;
+    /** Total requests observed; absent on the fallback path. */
+    totalRequests?: number | null;
+    /** Human-readable reason on the fallback path. */
+    reason?: string;
+}
+declare class ProverMarketError extends Error {
+    constructor(message: string);
+}
+/** Compute the buyer's `request` sighash (`prover_market.request.v1`). */
+declare function requestSighash(vkeyHash: string | Uint8Array | readonly number[], inputsHash: string | Uint8Array | readonly number[], maxFee: bigint | number | string, deadline: bigint | number | string, nonce: bigint | number | string): string;
+/** Compute the prover's `bid` sighash (`prover_market.bid.v1`). */
+declare function bidSighash(requestId: string | Uint8Array | readonly number[], fee: bigint | number | string): string;
+/** Compute the assigned prover's `submit` sighash (`prover_market.submit.v1`). */
+declare function submitSighash(requestId: string | Uint8Array | readonly number[], proofHash: string | Uint8Array | readonly number[]): string;
+interface CreateRequestCanonicalArgs {
+    /** Buyer address (`0x` 20 bytes). */
+    buyer: string | Uint8Array | readonly number[];
+    /** Buyer's ML-DSA-65 pubkey bytes. */
+    buyerPubkey: string | Uint8Array | readonly number[];
+    /** Verification-key hash (`0x` 32 bytes). */
+    vkeyHash: string | Uint8Array | readonly number[];
+    /** Public-inputs commitment (`0x` 32 bytes). */
+    inputsHash: string | Uint8Array | readonly number[];
+    /** Maximum fee escrowed (lythoshi). */
+    maxFee: bigint | number | string;
+    /** Deterministic Unix-seconds deadline. */
+    deadline: bigint | number | string;
+    /** Buyer-supplied uniqueness nonce. */
+    nonce: bigint | number | string;
+    /** Buyer's ML-DSA-65 signature over {@link requestSighash}. */
+    sig: string | Uint8Array | readonly number[];
+}
+/**
+ * Encode the canonical `createRequest` payload (the `bytes` body the
+ * precompile accepts). Mirrors `ProofRequest::encode_canonical`:
+ *
+ * ```text
+ * buyer (20) || buyerPubkeyLen (be16) || buyerPubkey
+ *   || vkeyHash (32) || inputsHash (32) || maxFee (be16)
+ *   || deadline (be8) || nonce (be8) || sigLen (be16) || sig
+ * ```
+ */
+declare function encodeCreateRequestCanonical(args: CreateRequestCanonicalArgs): string;
+/**
+ * Encode full `createRequest(bytes)` calldata: the 4-byte selector
+ * followed by the ABI-`bytes`-wrapped canonical payload.
+ */
+declare function encodeCreateRequestCalldata(args: CreateRequestCanonicalArgs): string;
+
+/**
+ * Spending-policy precompile ABI helpers.
+ *
+ * These helpers build calldata and claim messages for the live
+ * `mono-core` spending-policy precompile. Fresh sub-account claims
+ * must use `setPolicyClaim` or `claimPolicyByAddress`; legacy
+ * `setPolicy` is only for re-claims where the principal is already
+ * recorded on-chain.
+ */
+
+declare const SET_POLICY_CLAIM_DOMAIN_TAG: "lyth.spending-policy.claim.v1";
+declare const ML_DSA_65_PUBLIC_KEY_LEN$1 = 1952;
+declare const ML_DSA_65_SIGNATURE_LEN$1 = 3309;
+declare const SPENDING_POLICY_SELECTORS: {
+    readonly setPolicy: "0x8da1a765";
+    readonly setPolicyClaim: "0x35531f6c";
+    readonly claimPolicyByAddress: "0x0c21376c";
+    readonly enable: "0x5bfa1b68";
+    readonly disable: "0xe6c09edf";
+    readonly recordSpend: "0xdca04292";
+};
+interface SpendingPolicyArgs {
+    /** Typed `mono` bech32m sub-account address. */
+    subAccount: string;
+    /** Typed `mono` bech32m principal address. */
+    principal: string;
+    dailyCapLythoshi: bigint | number | string;
+    perTxCapLythoshi: bigint | number | string;
+    allowRoot: string | Uint8Array | readonly number[];
+    denyRoot: string | Uint8Array | readonly number[];
+    /**
+     * WP §18.8 per-week rolling cap in lythoshi (wire code `0x07`).
+     * Omit or `0` for "no weekly cap".
+     */
+    weeklyCapLythoshi?: bigint | number | string;
+    /**
+     * WP §18.8 per-month rolling cap in lythoshi (wire code `0x08`).
+     * Omit or `0` for "no monthly cap".
+     */
+    monthlyCapLythoshi?: bigint | number | string;
+    /**
+     * WP §18.8 per-category allow-list Merkle root (wire code `0x09`).
+     * Omit or the zero hash for "no category constraint".
+     */
+    categoryAllowRoot?: string | Uint8Array | readonly number[];
+    /**
+     * WP §18.8 packed time-of-day window (wire code `0x0A`), a 32-byte
+     * `uint256` word. Build it with {@link packTimeWindow}; omit or the
+     * zero word for "no time-of-day window".
+     */
+    timeWindow?: string | Uint8Array | readonly number[];
+    /**
+     * WP §18.8 explicit policy-expiry timestamp in unix seconds (wire
+     * code `0x0B`), encoded as a `uint256`. Omit or `0` for "never
+     * auto-expires".
+     */
+    policyExpiry?: bigint | number | string;
+}
+/**
+ * Decoded `lyth_getSpendingPolicy` time-of-day window. `enabled` is
+ * always `true` when present (the chain omits the object as `null` when
+ * no window is configured). `[startHour, endHour]` are `0..=23`,
+ * inclusive, and may wrap past midnight.
+ */
+interface SpendingPolicyTimeWindow {
+    /** Always `true` when the window object is present. */
+    enabled: boolean;
+    /** Window start hour (`0..=23`). */
+    startHour: number;
+    /** Window end hour (`0..=23`). */
+    endHour: number;
+}
+/**
+ * `lyth_getSpendingPolicy` response — the §18.8 spending-policy view for
+ * a sub-account, read directly from the spending-policy precompile slots
+ * (`0x110C`).
+ *
+ * Mirrors the chain JSON exactly (camelCase keys). Caps are `0x`-hex
+ * `uint256` strings; roots are `0x`-hex 32-byte words. `timeOfDayWindow`
+ * is `null` when no window is configured; `expiryUnixSeconds` is `null`
+ * when the policy never auto-expires. Note: the chain surfaces the policy
+ * keyed by the controlled sub-account (`address`); the managing principal
+ * is NOT part of this read shape.
+ */
+interface SpendingPolicyView {
+    /** Response schema version (`1`). */
+    schemaVersion: number;
+    /** Data source — `"native_state_storage"`. */
+    source: string;
+    /** Spending-policy precompile address (`0x110C`). */
+    precompile: string;
+    /** Sub-account the policy controls (`mono` bech32m). */
+    address: string;
+    /** `true` when a policy is written for this sub-account. */
+    exists: boolean;
+    /** `true` when the policy exists and is not disabled. */
+    enabled: boolean;
+    /** Monotonic policy version; `0` means no policy is written. */
+    version: number;
+    /** Per-transaction cap (`0x`-hex `uint256`); `0x0` = no cap. */
+    perTxCap: string;
+    /** Daily spend cap (`0x`-hex `uint256`); `0x0` = no cap. */
+    dailyCap: string;
+    /** §18.8 per-week cap (`0x`-hex `uint256`); `0x0` = no weekly cap. */
+    weeklyCap: string;
+    /** §18.8 per-month cap (`0x`-hex `uint256`); `0x0` = no monthly cap. */
+    monthlyCap: string;
+    /** §18.8 category allow-list root (`0x` 32 bytes). */
+    categoryAllowRoot: string;
+    /** Destination allow-list Merkle root (`0x` 32 bytes). */
+    destinationAllowRoot: string;
+    /** Destination deny-list Merkle root (`0x` 32 bytes). */
+    destinationDenyRoot: string;
+    /** §18.8 decoded time-of-day window, or `null` if unset. */
+    timeOfDayWindow: SpendingPolicyTimeWindow | null;
+    /** §18.8 policy-expiry unix seconds; `null` = never expires. */
+    expiryUnixSeconds: number | null;
+}
+declare class SpendingPolicyError extends Error {
+    constructor(message: string);
+}
+declare function spendingPolicyAddressHex(): string;
+declare function composeClaimBoundMessage(chainId: bigint | number | string, args: SpendingPolicyArgs, opts?: {
+    precompileAddress?: string | Uint8Array | readonly number[];
+    expectedPolicyVersion?: bigint | number | string;
+}): Uint8Array;
+declare function encodeSetPolicyCalldata(args: SpendingPolicyArgs): string;
+declare function encodeSetPolicyClaimCalldata(args: SpendingPolicyArgs, subAccountPubkey: Uint8Array | readonly number[] | string, subAccountSig: Uint8Array | readonly number[] | string): string;
+declare function encodeClaimPolicyByAddressCalldata(args: SpendingPolicyArgs, subAccountSig: Uint8Array | readonly number[] | string): string;
+declare function encodeEnableCalldata(subAccount: string): string;
+declare function encodeDisableCalldata(subAccount: string): string;
+/**
+ * Pack a time-of-day window into the 32-byte `timeWindow` word used by
+ * the WP §18.8 spending-policy dimensions.
+ *
+ * Mirrors `spending-policy::storage::pack_time_window`: hours clamp to
+ * `0..=23`; when `enabled` is `false` the word is all-zero (the "no
+ * window configured" sentinel). Layout (low 3 bytes of the big-endian
+ * word): byte 29 = enabled sentinel (`0x01`), byte 30 = `startHour`,
+ * byte 31 = `endHour`.
+ */
+declare function packTimeWindow(enabled: boolean, startHour: number, endHour: number): Uint8Array;
+/**
+ * Decode a packed `timeWindow` word into `[startHour, endHour]`, or
+ * `null` when no window is configured. Inverse of {@link packTimeWindow}.
+ */
+declare function decodeTimeWindow(word: string | Uint8Array | readonly number[]): [number, number] | null;
+
 declare const NO_EVM_RECEIPT_PROOF_SCHEMA = "mono.no_evm_receipt_proof.v1";
 declare const NO_EVM_RECEIPT_PROOF_TYPE = "canonicalReceiptsTranscript";
 declare const NO_EVM_RECEIPT_ROOT_ALGORITHM = "keccak256-binary-merkle(monolythium/v4.1/receipt_leaf/1, monolythium/v4.1/receipt_node/1, duplicate-last padding)";
@@ -3526,6 +5098,73 @@ declare class RpcClient {
     lythClusterDirectory(page?: number, limit?: number): Promise<ClusterDirectoryPageResponse>;
     /** `lyth_clusters` — alias for `lyth_clusterDirectory`. */
     lythClusters(page?: number, limit?: number): Promise<ClusterDirectoryPageResponse>;
+    /** PF-4 — `lyth_getSpendingPolicy`: the §18.8 spending-policy view for a sub-account. */
+    lythGetSpendingPolicy(subAccount: string): Promise<SpendingPolicyView>;
+    /** PF-6 — `lyth_getClusterDiversity`: diversity score + asn/geo/hosting breakdown. */
+    lythGetClusterDiversity(clusterId: number): Promise<ClusterDiversityView>;
+    /**
+     * PF-6 — `lyth_getOperatorNetworkMetadata`: ASN/geo/hosting-class/IP/PCR
+     * for a peer. `operatorId` is the 32-byte operator/peer id as `0x…` hex
+     * (the form `lyth_operatorInfo` returns).
+     */
+    lythGetOperatorNetworkMetadata(operatorId: string): Promise<OperatorNetworkMetadataView>;
+    /**
+     * MB-6 — `lyth_oracleSigners`: the global oracle writer roster (folded
+     * from `OracleWriterAdded` / `OracleWriterRemoved`). Returns the
+     * `{ status: "indexer_unavailable", writers: [] }` fallback when the
+     * node runs without the oracle writer-roster indexer projection.
+     */
+    lythOracleSigners(): Promise<OracleSignersResponse>;
+    /** MB-6 — `lyth_oracleWriters`: the allowed writer set for a feed. */
+    lythOracleWriters(feedId: string): Promise<OracleWriters>;
+    /** MB-6 — `lyth_oracleLatestPrice`: the latest finalized median for a feed. */
+    lythOracleLatestPrice(feedId: string): Promise<OracleLatestPrice>;
+    /** MB-6 — `lyth_oracleFeedConfig`: a feed's decimals / min-signers / circuit-breaker config. */
+    lythOracleFeedConfig(feedId: string): Promise<OracleFeedConfig>;
+    /** MB-4 — `lyth_getProofRequest`: a single GPU prover-market proof request. */
+    lythGetProofRequest(requestId: string): Promise<ProofRequestView>;
+    /**
+     * MB-4 — `lyth_listProofRequests`: open/recent prover-market proof
+     * requests. Params are `[stateFilter?, limit?]` (the chain's order),
+     * where `stateFilter` is one of `open|assigned|settled|slashed|expired`.
+     * Returns the `{ status: "indexer_unavailable", requests: [] }` fallback
+     * when the node runs without the prover-market indexer projection.
+     */
+    lythListProofRequests(stateFilter?: string | null, limit?: number): Promise<ListProofRequestsResponse>;
+    /** MB-4 — `lyth_getProverBids`: the fee bids placed on one proof request. */
+    lythGetProverBids(requestId: string): Promise<ProverBidsResponse>;
+    /**
+     * MB-4 — `lyth_proverMarketStatus`: prover-market summary. `feeFloor` is
+     * always present (on-chain genesis singleton); the aggregate counts are
+     * `null` on the `{ status: "indexer_unavailable" }` fallback path.
+     */
+    lythProverMarketStatus(): Promise<ProverMarketStatusResponse>;
+    /**
+     * Operator-router — `lyth_operatorRouterConfig`: the router's static
+     * posture (`0x100B` address, the protocol fee ceiling, and whether the
+     * gateable router precompile is currently milestone-activated).
+     */
+    lythOperatorRouterConfig(): Promise<OperatorRouterConfig>;
+    /**
+     * Operator-router — `lyth_operatorFeeConfig`: one operator's fee
+     * registration (recipient, fee bps, enabled flag, registered-at block).
+     * `operator` is a `mono` bech32m user address.
+     */
+    lythOperatorFeeConfig(operator: string): Promise<OperatorFeeConfig>;
+    /**
+     * MB-2 — `lyth_bridgeHealth`: a paged set of bridge-record health
+     * envelopes. Each record carries the circuit-breaker posture
+     * (`defaultDrainCapPerWindow`, `defaultDrainWindowBlocks`, `paused`,
+     * `pausedAtBlock`, `resumeCooldownBlocks`). Params are `[cursor?, limit?]`
+     * (the chain pages the global bridge set; there is no single-bridge form).
+     */
+    lythBridgeHealth(cursor?: string | null, limit?: number): Promise<BridgeHealthResponse>;
+    /**
+     * MB-2 — `lyth_bridgeDrainStatus`: the live per-route circuit-breaker
+     * drain bucket for one `(bridgeId, wrappedAsset)` route. `bridgeId` is a
+     * 32-byte `0x…` hex id; `wrappedAsset` is a `mono` bech32m user address.
+     */
+    lythBridgeDrainStatus(bridgeId: string, wrappedAsset: string): Promise<BridgeDrainStatus>;
     /**
      * `lyth_submitPendingChange` — operator-onboarding transport for the
      * pending-change ledger. Server validates the envelope shape.
@@ -3674,63 +5313,6 @@ declare function nativeEventsFromHistory<TDecoded extends NativeDecodedEvent = N
 declare function nativeMarketEventsFromHistory<TDecoded extends NativeDecodedEvent = NativeDecodedEvent>(response: NativeEventsResponse<unknown>): NativeEventsResponse<TDecoded>;
 declare function consumeNativeEvents<TDecoded extends NativeDecodedEvent = NativeDecodedEvent>(receipt: NativeReceiptResponse<unknown>, consumer: NativeEventConsumer<TDecoded>, filter?: NativeEventFilter): Promise<number>;
 
-declare const ML_KEM_768_CIPHERTEXT_LEN = 1088;
-declare const ML_KEM_768_ENCAPSULATION_KEY_LEN = 1184;
-declare const ML_KEM_768_SHARED_SECRET_LEN = 32;
-declare const DKG_NONCE_LEN = 12;
-declare const DKG_AEAD_TAG_LEN = 16;
-declare const MempoolClass: {
-    readonly Transfer: 0;
-    readonly ContractCall: 1;
-    readonly PrivacyOp: 2;
-    readonly CLOBOp: 3;
-    readonly AgentOp: 4;
-    readonly FoundationOp: 5;
-    /** @deprecated Use FoundationOp. */
-    readonly GovernanceOp: 5;
-    readonly RWAOp: 6;
-};
-type MempoolClass = (typeof MempoolClass)[keyof typeof MempoolClass];
-interface NonceAad {
-    sender: Uint8Array;
-    nonce: bigint;
-    chainId: bigint;
-    class: MempoolClass;
-    maxFeePerGas: bigint;
-    maxPriorityFeePerGas: bigint;
-    gasLimit: bigint;
-}
-interface DecryptHint {
-    epoch: bigint;
-    scheme: number;
-}
-interface EncryptedEnvelope {
-    nonceAad: NonceAad;
-    ciphertext: Uint8Array;
-    decryptionHint: DecryptHint;
-    senderPubkey: Uint8Array;
-    outerSignature: Uint8Array;
-    sender: Uint8Array;
-}
-declare function bincodeNonceAad(aad: NonceAad): Uint8Array;
-declare function bincodeDecryptHint(hint: DecryptHint): Uint8Array;
-declare function bincodeEncryptedEnvelope(env: EncryptedEnvelope): Uint8Array;
-declare function encryptInnerTx(signedInnerTxBincode: Uint8Array, nonceAad: NonceAad, kemEncapsulationKey: Uint8Array): Uint8Array;
-declare function outerSigDigest(nonceAad: NonceAad, ciphertext: Uint8Array, decryptionHint: DecryptHint, senderPubkey: Uint8Array): Uint8Array;
-declare function buildEncryptedEnvelope(args: {
-    signedInnerTxBincode: Uint8Array;
-    nonceAad: NonceAad;
-    decryptionHint: DecryptHint;
-    kemEncapsulationKey: Uint8Array;
-    senderAddress: Uint8Array;
-    senderPubkey: Uint8Array;
-    signOuterDigest: (digest: Uint8Array) => Promise<Uint8Array> | Uint8Array;
-}): Promise<{
-    envelope: EncryptedEnvelope;
-    wireBytes: Uint8Array;
-    wireHex: string;
-}>;
-
 interface NativeEvmTxFields {
     chainId: bigint | number | string;
     nonce: bigint | number | string;
@@ -3793,6 +5375,29 @@ interface EncryptedSubmission {
     innerTxHashHex: string;
     innerWireBytes: number;
 }
+/**
+ * A built plaintext submission — the bincode-encoded chain-side
+ * `SignedTransaction` (`0x`-prefixed hex) ready to hand to
+ * `mesh_submitTx`, plus the canonical hashes the wallet validates the
+ * node echo against.
+ *
+ * Mirrors the chain-side artefacts produced by the Rust SDK's
+ * `build_chain_signed_tx` (`mono-core/crates/core/sdk/src/tx.rs`): the
+ * ML-DSA-65 signature is taken over the canonical chain-side `sighash`
+ * (keccak-256 of the 0x01-tagged preimage) and the canonical native tx
+ * hash is the keccak-256 of the 0x02-tagged preimage with the signature
+ * and public key appended.
+ */
+interface PlaintextSubmission {
+    /** Bincode `SignedTransaction` wire bytes, `0x`-prefixed. */
+    signedTxWireHex: string;
+    /** Canonical native tx hash the node echoes on admission. */
+    innerTxHashHex: string;
+    /** Canonical chain-side sighash that was signed. */
+    innerSighashHex: string;
+    /** Length in bytes of the bincode `SignedTransaction`. */
+    innerWireBytes: number;
+}
 declare function fetchEncryptionKey(client: RpcClient): Promise<EncryptionKey>;
 declare function buildEncryptedSubmission(args: {
     backend: MlDsa65Backend;
@@ -3801,5 +5406,64 @@ declare function buildEncryptedSubmission(args: {
     class?: MempoolClass;
 }): Promise<EncryptedSubmission>;
 declare function submitEncryptedEnvelope(client: RpcClient, envelopeWireHex: string): Promise<string>;
+/**
+ * Build a PLAINTEXT submission — the opt-OUT-of-privacy counterpart to
+ * {@link buildEncryptedSubmission}.
+ *
+ * Unlike the encrypted path, this never engages the Ferveo
+ * threshold-decrypt pipeline. It re-shapes the native tx into the
+ * chain-side `SignedTransaction`, signs over the canonical `sighash`
+ * with the ML-DSA-65 backend, bincode-serializes the result, and
+ * `0x`-hex-encodes it. The bytes are forwarded verbatim through
+ * `mesh_submitTx` (the node routes them to `MempoolTx::plaintext` via
+ * `submit_raw`) — the functional inclusion path on a chain running with
+ * `encrypted_mempool_required = false`.
+ *
+ * Mirrors `TxClient::submit_plaintext` in the Rust SDK.
+ */
+declare function buildPlaintextSubmission(args: {
+    backend: MlDsa65Backend;
+    tx: NativeEvmTxFields;
+}): PlaintextSubmission;
+/**
+ * Submit a bincode-encoded chain-side `SignedTransaction` (`0x`-hex)
+ * through the plaintext `mesh_submitTx` path and validate the node's
+ * echoed canonical tx hash against the locally computed one.
+ *
+ * Mirrors the validation in `TxClient::submit_plaintext`: the node
+ * echoes the 32-byte canonical native tx hash on admission, and any
+ * mismatch (or non-32-byte response) is rejected loud so a wallet never
+ * trusts a hash it did not derive itself.
+ *
+ * @returns the validated canonical native tx hash (`0x`-prefixed).
+ */
+declare function submitPlaintextTransaction(client: RpcClient, signedTxWireHex: string, expectedTxHashHex: string): Promise<string>;
+/**
+ * Build, sign, and submit a native transaction with an explicit
+ * encryption toggle. `private == false` (the default for the RC testnet
+ * / operator posture) routes through the plaintext `mesh_submitTx`
+ * path; `private == true` routes through the Ferveo encrypt-then-submit
+ * pipeline. Wallets wire a UI privacy toggle straight onto `private`.
+ *
+ * Mirrors `TxClient::build_sign_submit_with_privacy` in the Rust SDK.
+ * The default is PLAINTEXT; the encrypted path is engaged only when
+ * `private === true`, and requires an {@link EncryptionKey} (fetch it
+ * via {@link fetchEncryptionKey}).
+ *
+ * @returns the canonical native tx hash (`0x`-prefixed). For the
+ *   plaintext path this is the node-echoed-and-validated hash; for the
+ *   encrypted path it is the locally computed inner tx hash (the
+ *   `lyth_submitEncrypted` RPC returns the encrypted-envelope admission
+ *   hash, so wallets track the canonical inner hash for receipts /
+ *   `lyth_txStatus` / indexer history).
+ */
+declare function submitTransactionWithPrivacy(args: {
+    client: RpcClient;
+    backend: MlDsa65Backend;
+    tx: NativeEvmTxFields;
+    private: boolean;
+    encryptionKey?: EncryptionKey;
+    class?: MempoolClass;
+}): Promise<string>;
 
-export { type AgentReputationResponse as $, type ApiStreamsIndexResponse as A, type BlockSelector as B, type ChainStatsResponse as C, type NativeEvmTxFields as D, type EncryptionKey as E, MempoolClass as F, RpcClient as G, MlDsa65Backend as H, API_STREAM_TOPICS as I, type AccountPolicy as J, type AccountProofResponse as K, type Address as L, type MrcMetadataResponse as M, type NativeReceiptFee as N, type OperatorCapabilitiesResponse as O, type PendingRewardsResponse as P, type AddressActivityArchiveRedirect as Q, type RuntimeBuildProvenance as R, type SearchResponse as S, type TxFeedResponse as T, type AddressActivityEntry as U, type AddressActivityKind as V, type AddressActivityKindResponse as W, type AddressActivityKindRetention as X, type AddressLabelRecord as Y, type AgentReputationCategoryScope as Z, type AgentReputationRecord as _, type RuntimeUpgradeStatus as a, type EntityRatchetResponse as a$, type ApiStreamTopic as a0, type ApiStreamTopicMetadata as a1, type ApiStreamTopicRetention as a2, type AssetPolicy as a3, type AttestationWindow as a4, BRIDGE_QUOTE_API_BLOCKED_REASON as a5, BRIDGE_REVERT_TAGS as a6, BRIDGE_SELECTORS as a7, BRIDGE_SUBMIT_API_BLOCKED_REASON as a8, type BlockHeader as a9, type ChainInfo as aA, type ChainRegistry as aB, type CheckpointRecord as aC, type ClobMarketRecord as aD, type ClobMarketSummary as aE, type ClobTrade as aF, type ClusterDelegatorsResponse as aG, type ClusterDirectoryEntryResponse as aH, type ClusterDirectoryPageResponse as aI, type ClusterEntityResponse as aJ, type ClusterMemberResponse as aK, type ClusterResignationRow as aL, type ClusterResignationsResponse as aM, type ClusterStatusResponse as aN, type DagParent as aO, type DagParentsResponse as aP, type DagSyncStatus as aQ, type DecodeTxExtension as aR, type DecodeTxLog as aS, type DecodeTxPqAttestation as aT, type DecodeTxResponse as aU, type DelegationCapResponse as aV, type DelegationHistoryRecord as aW, type DelegationRow as aX, type DelegationsResponse as aY, type DutyAbsence as aZ, type EncryptionKeyResponse as a_, type BlockTag as aa, type BlsCertificateResponse as ab, type BridgeAdminControl as ac, type BridgeBytesInput as ad, type BridgeCircuitBreakerState as ae, BridgePrecompileError as af, type BridgeQuoteSubmitReadiness as ag, type BridgeRiskTier as ah, type BridgeRouteAssessment as ai, type BridgeRouteCandidate as aj, type BridgeRouteCatalogue as ak, BridgeRouteCatalogueError as al, type BridgeRouteCatalogueJsonOptions as am, type BridgeRouteCataloguePayload as an, type BridgeRouteCatalogueRoute as ao, type BridgeRouteCatalogueValidation as ap, type BridgeRouteDisclosure as aq, type BridgeRouteSelection as ar, type BridgeRoutesSource as as, type BridgeTransferIntent as at, type BridgeTransferRequest as au, type BridgeVerifierDisclosure as av, CHAIN_REGISTRY as aw, CHAIN_REGISTRY_RAW_BASE as ax, type CapabilitiesResponse as ay, type CapabilityDescriptor as az, type NativeReceiptResponse as b, type NativeMarketStateSource as b$, type ExecutionUnitPriceResponse as b0, type ExplorerEndpoint as b1, type FeeHistoryResponse as b2, type GapRange as b3, type GapRecord as b4, type GapRecordsResponse as b5, type Hash as b6, type Hex as b7, type IndexerStatus as b8, type JailStatusWindow as b9, NO_EVM_RECEIPT_PROOF_TYPE as bA, NO_EVM_RECEIPT_ROOT_ALGORITHM as bB, type NativeAgentArbiterStateRecord as bC, type NativeAgentAttestationStateRecord as bD, type NativeAgentAvailabilityStateRecord as bE, type NativeAgentConsentStateRecord as bF, type NativeAgentEscrowStateRecord as bG, type NativeAgentIssuerStateRecord as bH, type NativeAgentPolicySpendStateRecord as bI, type NativeAgentPolicyStateRecord as bJ, type NativeAgentReputationReviewStateRecord as bK, type NativeAgentServiceStateRecord as bL, type NativeAgentStateFilterParamValue as bM, type NativeAgentStateResponseFilters as bN, type NativeAgentStateSource as bO, type NativeCollectionRoyaltyStateRecord as bP, type NativeEventConsumer as bQ, type NativeEventProjection as bR, type NativeEventsResponseFilters as bS, type NativeEventsSource as bT, type NativeMarketOrderBookDelta as bU, type NativeMarketOrderBookDeltasResponseFilters as bV, type NativeMarketOrderBookDeltasSource as bW, type NativeMarketOrderBookStreamAction as bX, type NativeMarketOrderBookStreamPayload as bY, type NativeMarketStateFilterParamValue as bZ, type NativeMarketStateResponseFilters as b_, type KeyRotationWindow as ba, type LythUpgradePlanStatus as bb, type LythUpgradeStatusResponse as bc, MAX_NATIVE_RECEIPT_EVENTS as bd, type MempoolSnapshot as be, type MeshDecodedTx as bf, type MeshSignedTxResponse as bg, type MeshTxIntent as bh, type MeshUnsignedTxResponse as bi, type MetricsRangeResponse as bj, type MetricsRangeSample as bk, type MetricsRangeSeries as bl, type MetricsRangeStatus as bm, type MrcAccountRecord as bn, type MrcMetadataRecord as bo, type MrcPolicyRecord as bp, type MrcPolicySpendRecord as bq, NATIVE_MARKET_EVENT_FAMILY as br, NATIVE_MARKET_ORDER_BOOK_STREAM_TOPIC as bs, NO_EVM_ARCHIVE_PROOF_SCHEMA as bt, NO_EVM_ARCHIVE_SIGNATURE_SCHEME as bu, NO_EVM_FINALITY_EVIDENCE_SCHEMA as bv, NO_EVM_FINALITY_EVIDENCE_SOURCE as bw, NO_EVM_RECEIPTS_ROOT_DOMAIN as bx, NO_EVM_RECEIPT_CODEC as by, NO_EVM_RECEIPT_PROOF_SCHEMA as bz, type NativeDecodedEvent as c, type ServiceProbeStatusLabel as c$, type NativeModuleForwarderDescriptor as c0, type NativeMrcPolicyProjection as c1, type NativeNftListingStateRecord as c2, type NativeReceiptCounters as c3, type NativeReceiptEvent as c4, type NativeReceiptSource as c5, type NativeSpotMarketStateRecord as c6, type NativeSpotOrderStateRecord as c7, type NetworkClientOptions as c8, type NetworkSlug as c9, type OperatorSurfaceCapability as cA, type OperatorSurfaceStatus as cB, type P2pSeed as cC, type PeerSummary as cD, type PeerSummaryAggregate as cE, type PendingRewardsRow as cF, type PendingTxSummary as cG, type PrecompileCatalogueResponse as cH, type PrecompileDescriptor as cI, type Quantity as cJ, type RankedBridgeRoute as cK, type ReceiptProofTrustArchivePolicy as cL, type ReceiptProofTrustArchiveSigner as cM, type ReceiptProofTrustFinalityPolicy as cN, type ReceiptProofTrustFinalitySigner as cO, type ReceiptProofTrustPolicy as cP, type RedemptionQueueTicket as cQ, type RegistryRecord as cR, type ReportServiceProbeRequest as cS, type ReportServiceProbeResponse as cT, type RichListHolder as cU, type RichListResponse as cV, type RoundInfo as cW, type RpcClientOptions as cX, type RpcEndpoint as cY, type RuntimeProvenanceResponse as cZ, type SearchHit as c_, type NoEvmArchiveCoveringSnapshot as ca, type NoEvmArchiveProof as cb, type NoEvmArchiveSignatureVerification as cc, type NoEvmArchiveSignatureVerificationIssue as cd, type NoEvmArchiveSignatureVerificationIssueCode as ce, type NoEvmArchiveTrustedSigner as cf, type NoEvmBlockBlsFinalityVerification as cg, type NoEvmBlsFinalityVerification as ch, type NoEvmFinalityBlockReference as ci, type NoEvmFinalityCertificate as cj, type NoEvmFinalityEvidence as ck, type NoEvmReceiptFinalityTrustPolicy as cl, type NoEvmReceiptProof as cm, NoEvmReceiptProofError as cn, type NoEvmReceiptProofErrorCode as co, type NoEvmReceiptProofVerification as cp, type NoEvmReceiptTrustIssue as cq, type NoEvmReceiptTrustIssueCode as cr, type NoEvmReceiptTrustPolicy as cs, type NoEvmReceiptTrustVerification as ct, type NoEvmReceiptTrustedBlsSigner as cu, type OperatorAuthorityResponse as cv, type OperatorInfoResponse as cw, type OperatorRiskResponse as cx, type OperatorSigningActivityResponse as cy, type OperatorSigningEntry as cz, type NativeEventFilter as d, nativeMarketEventsFromHistory as d$, type SigningEntryStatus as d0, type StorageProofBatch as d1, type SyncStatus as d2, TESTNET_69420 as d3, type TokenBalanceMrcIdentity as d4, type TokenBalanceRecord as d5, type TpmAttestationResponse as d6, type TransactionReceipt as d7, type TransactionView as d8, type TxFeedReceipt as d9, decodeNativeMarketOrderBookDeltasResponse as dA, decodeNativeReceiptResponse as dB, decodeNoEvmReceiptTranscript as dC, decodeTxFeedResponse as dD, encodeBlockSelector as dE, encodeLockBridgeConfigCalldata as dF, encodeSetBridgeResumeCooldownCalldata as dG, encodeSetBridgeRouteFinalityCalldata as dH, exportBridgeRouteCatalogueJson as dI, fetchChainInfoLatest as dJ, fetchChainRegistryLatest as dK, getChainInfo as dL, getNoEvmReceiptTrustPolicy as dM, getP2pSeeds as dN, getRpcEndpoints as dO, isBridgeAdminLockedRevert as dP, isBridgeCooldownZeroRevert as dQ, isBridgeFinalityZeroRevert as dR, isBridgeResumeCooldownActiveRevert as dS, isNativeDecodedEvent as dT, isNativeMarketOrderBookStreamPayload as dU, nativeAgentStateFilterParams as dV, nativeEventMatches as dW, nativeEventsFilterParams as dX, nativeEventsFromHistory as dY, nativeEventsFromReceipt as dZ, nativeMarketEventFilter as d_, type TxFeedTransaction as da, type TxStatusFoundResponse as db, type TxStatusNotFoundResponse as dc, type TxStatusResponse as dd, type UpcomingDutiesResponse as de, type UpcomingDutyMap as df, type UserAddressInput as dg, V1_BRIDGE_ALLOWED_FEE_TOKEN as dh, V1_BRIDGE_ALLOWED_PROTOCOL as di, type VertexAtRound as dj, type VerticesAtRoundResponse as dk, assertNativeMarketOrderBookStreamPayload as dl, assessBridgeRoute as dm, bridgeAddressHex as dn, bridgeQuoteSubmitReadiness as dp, bridgeRoutesReadiness as dq, bridgeTransferCandidates as dr, buildBridgeRouteCatalogue as ds, computeNoEvmDacFinalityMessage as dt, computeNoEvmLeaderFinalityMessage as du, computeNoEvmReceiptsRoot as dv, computeNoEvmRoundFinalityMessage as dw, computeNoEvmTargetReceiptHash as dx, consumeNativeEvents as dy, decodeNativeAgentStateResponse as dz, type TypedNativeReceiptEvent as e, nativeMarketEventsFromReceipt as e0, nativeMarketStateFilterParams as e1, noEvmReceiptTrustPolicyFromChainInfo as e2, normalizeBridgeRouteCatalogue as e3, parseBridgeRouteCatalogueJson as e4, parseChainRegistryToml as e5, parseNativeDecodedEvent as e6, parseQuantity as e7, parseQuantityBig as e8, rankBridgeRoutes as e9, type NonceAad as eA, STANDARD_ALGO_NUMBER_ML_DSA_65 as eB, bincodeDecryptHint as eC, bincodeEncryptedEnvelope as eD, bincodeNonceAad as eE, bincodeSignedTransaction as eF, buildEncryptedEnvelope as eG, buildEncryptedSubmission as eH, encodeMlDsa65Opaque as eI, encodeTransactionForHash as eJ, encryptInnerTx as eK, fetchEncryptionKey as eL, mlDsa65AddressBytes as eM, mlDsa65AddressFromPublicKey as eN, outerSigDigest as eO, submitEncryptedEnvelope as eP, selectBridgeTransferRoute as ea, validateBridgeRouteCatalogue as eb, verifyNoEvmArchiveProofSignatures as ec, verifyNoEvmBlockFinalityEvidenceMultisig as ed, verifyNoEvmBlockFinalityEvidenceThreshold as ee, verifyNoEvmFinalityEvidenceMultisig as ef, verifyNoEvmFinalityEvidenceThreshold as eg, verifyNoEvmReceiptProof as eh, verifyNoEvmReceiptProofTrust as ei, ADDRESS_DERIVATION_DOMAIN as ej, DKG_AEAD_TAG_LEN as ek, DKG_NONCE_LEN as el, type DecryptHint as em, ENUM_VARIANT_INDEX_ML_DSA_65 as en, type EncryptedEnvelope as eo, type EncryptedSubmission as ep, ML_DSA_65_PUBLIC_KEY_LEN as eq, ML_DSA_65_SEED_LEN as er, ML_DSA_65_SIGNATURE_LEN as es, ML_DSA_65_SIGNING_KEY_LEN as et, ML_KEM_768_CIPHERTEXT_LEN as eu, ML_KEM_768_ENCAPSULATION_KEY_LEN as ev, ML_KEM_768_SHARED_SECRET_LEN as ew, type NativeTxExtension as ex, type NativeTxExtensionDescriptor as ey, type NativeTxExtensionLike as ez, type NativeEventsFilter as f, type NativeEventsResponse as g, type NativeAgentStateFilter as h, type NativeAgentStateResponse as i, type NativeMarketStateFilter as j, type NativeMarketStateResponse as k, type NativeMarketOrderBookDeltasRequest as l, type NativeMarketOrderBookDeltasResponse as m, type AddressProfileResponse as n, type AddressFlowResponse as o, type RedemptionQueueResponse as p, type MrcAccountResponse as q, type MrcHoldersResponse as r, type BridgeRoutesRequest as s, type BridgeRoutesResponse as t, type ServiceProbeResponse as u, type ClobMarketsResponse as v, type ClobMarketResponse as w, type ClobTradesResponse as x, type ClobOhlcResponse as y, type ClobOrderBookResponse as z };
+export { type AddressActivityKindRetention as $, type ApiStreamsIndexResponse as A, type BlockSelector as B, type ChainStatsResponse as C, type NativeEvmTxFields as D, type EncryptionKey as E, MempoolClass as F, type TypedAddress as G, RpcClient as H, MlDsa65Backend as I, type AddressKind as J, ADDRESS_HRP as K, ADDRESS_KIND_HRPS as L, type MrcMetadataResponse as M, type NativeReceiptFee as N, type OperatorCapabilitiesResponse as O, type PendingRewardsResponse as P, API_STREAM_TOPICS as Q, type RuntimeBuildProvenance as R, type SearchResponse as S, type TxFeedResponse as T, type AccountPolicy as U, type AccountProofResponse as V, type Address as W, type AddressActivityArchiveRedirect as X, type AddressActivityEntry as Y, type AddressActivityKind as Z, type AddressActivityKindResponse as _, type RuntimeUpgradeStatus as a, type ClusterDiversityView as a$, AddressError as a0, type AddressLabelRecord as a1, type AddressValidation as a2, type AgentReputationCategoryScope as a3, type AgentReputationRecord as a4, type AgentReputationResponse as a5, type ApiStreamTopic as a6, type ApiStreamTopicMetadata as a7, type ApiStreamTopicRetention as a8, type AssetPolicy as a9, type BridgeRouteCataloguePayload as aA, type BridgeRouteCatalogueRoute as aB, type BridgeRouteCatalogueValidation as aC, type BridgeRouteDisclosure as aD, type BridgeRouteSelection as aE, type BridgeRoutesSource as aF, type BridgeTransferIntent as aG, type BridgeTransferRequest as aH, type BridgeVerifierDisclosure as aI, CHAIN_REGISTRY as aJ, CHAIN_REGISTRY_RAW_BASE as aK, CLOB_MARKET_ID_DOMAIN_TAG as aL, CLOB_SELECTORS as aM, CLUSTER_FORMED_EVENT_SIG as aN, type CancelSpotOrderArgs as aO, type CapabilitiesResponse as aP, type CapabilityDescriptor as aQ, type ChainInfo as aR, type ChainRegistry as aS, type CheckpointRecord as aT, type ClobMarketRecord as aU, type ClobMarketSummary as aV, type ClobTrade as aW, type ClusterDelegatorsResponse as aX, type ClusterDirectoryEntryResponse as aY, type ClusterDirectoryPageResponse as aZ, type ClusterDiversity as a_, type AttestationWindow as aa, BRIDGE_QUOTE_API_BLOCKED_REASON as ab, BRIDGE_REVERT_TAGS as ac, BRIDGE_SELECTORS as ad, BRIDGE_SUBMIT_API_BLOCKED_REASON as ae, type BlockHeader as af, type BlockTag as ag, type BlsCertificateResponse as ah, type BridgeAdminControl as ai, type BridgeAnchorState as aj, type BridgeBreakerState as ak, type BridgeBytesInput as al, type BridgeCircuitBreakerFields as am, type BridgeCircuitBreakerState as an, type BridgeDrainCap as ao, type BridgeDrainStatus as ap, type BridgeHealthRecord as aq, type BridgeHealthResponse as ar, BridgePrecompileError as as, type BridgeQuoteSubmitReadiness as at, type BridgeRiskTier as au, type BridgeRouteAssessment as av, type BridgeRouteCandidate as aw, type BridgeRouteCatalogue as ax, BridgeRouteCatalogueError as ay, type BridgeRouteCatalogueJsonOptions as az, type NativeReceiptResponse as b, type MetricsRangeStatus as b$, type ClusterEntityResponse as b0, type ClusterFormedEvent as b1, type ClusterMemberResponse as b2, type ClusterResignationRow as b3, type ClusterResignationsResponse as b4, type ClusterStatusResponse as b5, type CreateRequestCanonicalArgs as b6, DIVERSITY_SCORE_MAX as b7, type DagParent as b8, type DagParentsResponse as b9, type FeeHistoryResponse as bA, type GapRange as bB, type GapRecord as bC, type GapRecordsResponse as bD, type Hash as bE, type Hex as bF, type IndexerStatus as bG, type JailStatusWindow as bH, type KeyRotationWindow as bI, type ListProofRequestsResponse as bJ, type LythUpgradePlanStatus as bK, type LythUpgradeStatusResponse as bL, MAX_NATIVE_CALL_FORWARDER_REQUEST_BYTES as bM, MAX_NATIVE_RECEIPT_EVENTS as bN, ML_DSA_65_PUBLIC_KEY_LEN$1 as bO, ML_DSA_65_SIGNATURE_LEN$1 as bP, MULTISIG_ADDRESS_DERIVATION_DOMAIN as bQ, MarketActionError as bR, type MarketTransactionPlan as bS, type MempoolSnapshot as bT, type MeshDecodedTx as bU, type MeshSignedTxResponse as bV, type MeshTxIntent as bW, type MeshUnsignedTxResponse as bX, type MetricsRangeResponse as bY, type MetricsRangeSample as bZ, type MetricsRangeSeries as b_, type DagSyncStatus as ba, type DecodeTxExtension as bb, type DecodeTxLog as bc, type DecodeTxPqAttestation as bd, type DecodeTxResponse as be, type DelegationCapResponse as bf, type DelegationHistoryRecord as bg, type DelegationRow as bh, type DelegationsResponse as bi, type DutyAbsence as bj, type EncodeNativeNftBuyListingArgs as bk, type EncodeNativeNftCancelListingArgs as bl, type EncodeNativeNftCreateListingArgs as bm, type EncodeNativeNftPlaceAuctionBidArgs as bn, type EncodeNativeNftSettleAuctionArgs as bo, type EncodeNativeNftSweepExpiredListingsArgs as bp, type EncodeNativeSpotCancelOrderArgs as bq, type EncodeNativeSpotCreateMarketArgs as br, type EncodeNativeSpotLimitOrderArgs as bs, type EncodeNativeSpotSettleLimitOrderArgs as bt, type EncodeNativeSpotSettleRoutedLimitOrderArgs as bu, type EncryptionKeyResponse as bv, type EntityRatchetResponse as bw, type EthSendTransactionRequest as bx, type ExecutionUnitPriceResponse as by, type ExplorerEndpoint as bz, type NativeDecodedEvent as c, type NativeReceiptSource as c$, type MrcAccountRecord as c0, type MrcMetadataRecord as c1, type MrcPolicyRecord as c2, type MrcPolicySpendRecord as c3, NATIVE_CALL_FORWARDER_ARTIFACT_PROFILE as c4, NATIVE_CALL_FORWARDER_RESPONSE_CAPACITY as c5, NATIVE_CALL_FORWARDER_RESPONSE_OFFSET as c6, NATIVE_MARKET_EVENT_FAMILY as c7, NATIVE_MARKET_MODULE_ADDRESS as c8, NATIVE_MARKET_MODULE_ADDRESS_BYTES as c9, type NativeAgentStateSource as cA, type NativeCallForwarderArtifact as cB, type NativeCollectionRoyaltyStateRecord as cC, type NativeEventConsumer as cD, type NativeEventProjection as cE, type NativeEventsResponseFilters as cF, type NativeEventsSource as cG, type NativeMarketAddressInput as cH, type NativeMarketAddressKind as cI, type NativeMarketForwarderInput as cJ, type NativeMarketModuleCallEnvelope as cK, type NativeMarketModuleContractCall as cL, type NativeMarketOrderBookDelta as cM, type NativeMarketOrderBookDeltasResponseFilters as cN, type NativeMarketOrderBookDeltasSource as cO, type NativeMarketOrderBookStreamAction as cP, type NativeMarketOrderBookStreamPayload as cQ, type NativeMarketStateFilterParamValue as cR, type NativeMarketStateResponseFilters as cS, type NativeMarketStateSource as cT, type NativeModuleForwarderDescriptor as cU, type NativeMrcPolicyProjection as cV, type NativeNftAssetStandard as cW, type NativeNftListingKind as cX, type NativeNftListingStateRecord as cY, type NativeReceiptCounters as cZ, type NativeReceiptEvent as c_, NATIVE_MARKET_ORDER_BOOK_STREAM_TOPIC as ca, NODE_REGISTRY_CAPABILITIES as cb, NODE_REGISTRY_CAPABILITY_MASK as cc, NODE_REGISTRY_PUBLIC_SERVICE_MASK as cd, NODE_REGISTRY_SELECTORS as ce, NO_EVM_ARCHIVE_PROOF_SCHEMA as cf, NO_EVM_ARCHIVE_SIGNATURE_SCHEME as cg, NO_EVM_FINALITY_EVIDENCE_SCHEMA as ch, NO_EVM_FINALITY_EVIDENCE_SOURCE as ci, NO_EVM_RECEIPTS_ROOT_DOMAIN as cj, NO_EVM_RECEIPT_CODEC as ck, NO_EVM_RECEIPT_PROOF_SCHEMA as cl, NO_EVM_RECEIPT_PROOF_TYPE as cm, NO_EVM_RECEIPT_ROOT_ALGORITHM as cn, type NativeAgentArbiterStateRecord as co, type NativeAgentAttestationStateRecord as cp, type NativeAgentAvailabilityStateRecord as cq, type NativeAgentConsentStateRecord as cr, type NativeAgentEscrowStateRecord as cs, type NativeAgentIssuerStateRecord as ct, type NativeAgentPolicySpendStateRecord as cu, type NativeAgentPolicyStateRecord as cv, type NativeAgentReputationReviewStateRecord as cw, type NativeAgentServiceStateRecord as cx, type NativeAgentStateFilterParamValue as cy, type NativeAgentStateResponseFilters as cz, type NativeEventFilter as d, type PendingRewardsRow as d$, type NativeSpotMarketStateRecord as d0, type NativeSpotOrderStateRecord as d1, type NetworkClientOptions as d2, type NetworkSlug as d3, type NoEvmArchiveCoveringSnapshot as d4, type NoEvmArchiveProof as d5, type NoEvmArchiveSignatureVerification as d6, type NoEvmArchiveSignatureVerificationIssue as d7, type NoEvmArchiveSignatureVerificationIssueCode as d8, type NoEvmArchiveTrustedSigner as d9, type OperatorInfoResponse as dA, type OperatorNetworkMetadata as dB, type OperatorNetworkMetadataView as dC, type OperatorRiskResponse as dD, type OperatorRouterConfig as dE, type OperatorSigningActivityResponse as dF, type OperatorSigningEntry as dG, type OperatorSurfaceCapability as dH, type OperatorSurfaceStatus as dI, type OracleEvent as dJ, OracleEventError as dK, type OracleFeedConfig as dL, type OracleLatestPrice as dM, type OracleSignerRow as dN, type OracleSignersResponse as dO, type OracleWriters as dP, type P2pSeed as dQ, PROVER_MARKET_ADDRESS as dR, PROVER_MARKET_BID_DOMAIN as dS, PROVER_MARKET_EVENT_SIGS as dT, PROVER_MARKET_REQUEST_DOMAIN as dU, PROVER_MARKET_SELECTORS as dV, PROVER_MARKET_SUBMIT_DOMAIN as dW, PROVER_SLASH_REASON_BAD_PROOF as dX, PROVER_SLASH_REASON_NON_DELIVERY as dY, type PeerSummary as dZ, type PeerSummaryAggregate as d_, type NoEvmBlockBlsFinalityVerification as da, type NoEvmBlsFinalityVerification as db, type NoEvmFinalityBlockReference as dc, type NoEvmFinalityCertificate as dd, type NoEvmFinalityEvidence as de, type NoEvmReceiptFinalityTrustPolicy as df, type NoEvmReceiptProof as dg, NoEvmReceiptProofError as dh, type NoEvmReceiptProofErrorCode as di, type NoEvmReceiptProofVerification as dj, type NoEvmReceiptTrustIssue as dk, type NoEvmReceiptTrustIssueCode as dl, type NoEvmReceiptTrustPolicy as dm, type NoEvmReceiptTrustVerification as dn, type NoEvmReceiptTrustedBlsSigner as dp, type NodeHostingClass as dq, NodeRegistryError as dr, OPERATOR_ROUTER_EVENT_SIGS as ds, OPERATOR_ROUTER_SELECTORS as dt, OPERATOR_ROUTER_SIGS as du, ORACLE_EVENT_SIGS as dv, type OperatorAuthorityResponse as dw, type OperatorFeeChargedEvent as dx, type OperatorFeeConfig as dy, type OperatorFeeQuote as dz, type TypedNativeReceiptEvent as e, V1_BRIDGE_ALLOWED_FEE_TOKEN as e$, type PendingTxSummary as e0, type PlaceLimitOrderViaArgs as e1, type PlaceLimitOrderViaPlan as e2, type PlaceSpotLimitOrderArgs as e3, type PlaceSpotMarketOrderArgs as e4, type PlaceSpotMarketOrderExArgs as e5, type PrecompileCatalogueResponse as e6, type PrecompileDescriptor as e7, type ProofRequestRow as e8, type ProofRequestView as e9, SET_POLICY_CLAIM_DOMAIN_TAG as eA, SPENDING_POLICY_SELECTORS as eB, type SearchHit as eC, type ServiceProbeStatusLabel as eD, type SigningEntryStatus as eE, type SpendingPolicyArgs as eF, SpendingPolicyError as eG, type SpendingPolicyTimeWindow as eH, type SpendingPolicyView as eI, type SpotLimitOrderSide as eJ, type SpotMarketOrderMode as eK, type StorageProofBatch as eL, type SyncStatus as eM, TESTNET_69420 as eN, type TokenBalanceMrcIdentity as eO, type TokenBalanceRecord as eP, type TpmAttestationResponse as eQ, type TransactionReceipt as eR, type TransactionView as eS, type TxFeedReceipt as eT, type TxFeedTransaction as eU, type TxStatusFoundResponse as eV, type TxStatusNotFoundResponse as eW, type TxStatusResponse as eX, type UpcomingDutiesResponse as eY, type UpcomingDutyMap as eZ, type UserAddressInput as e_, type ProverBidView as ea, type ProverBidsResponse as eb, ProverMarketError as ec, type ProverMarketState as ed, type ProverMarketStatusResponse as ee, type Quantity as ef, RESERVED_ADDRESS_HRPS as eg, type RankedBridgeRoute as eh, type ReceiptProofTrustArchivePolicy as ei, type ReceiptProofTrustArchiveSigner as ej, type ReceiptProofTrustFinalityPolicy as ek, type ReceiptProofTrustFinalitySigner as el, type ReceiptProofTrustPolicy as em, type RedemptionQueueTicket as en, type RegistryRecord as eo, type ReportServiceProbeCalldataArgs as ep, type ReportServiceProbeRequest as eq, type ReportServiceProbeResponse as er, type RichListHolder as es, type RichListResponse as et, type RoundInfo as eu, type RpcClientOptions as ev, type RpcEndpoint as ew, type RuntimeProvenanceResponse as ex, SERVES_GPU_PROVE as ey, SERVICE_PROBE_STATUS as ez, type NativeEventsFilter as f, decodeTimeWindow as f$, V1_BRIDGE_ALLOWED_PROTOCOL as f0, type VertexAtRound as f1, type VerticesAtRoundResponse as f2, addressBytesToHex as f3, addressToBech32 as f4, addressToTypedBech32 as f5, assertNativeMarketOrderBookStreamPayload as f6, assessBridgeRoute as f7, bech32ToAddress as f8, bech32ToAddressBytes as f9, buildNativeSpotLimitOrderForwarderInput as fA, buildNativeSpotLimitOrderModuleCall as fB, buildNativeSpotSettleLimitOrderForwarderInput as fC, buildNativeSpotSettleLimitOrderModuleCall as fD, buildNativeSpotSettleRoutedLimitOrderForwarderInput as fE, buildNativeSpotSettleRoutedLimitOrderModuleCall as fF, buildPlaceLimitOrderViaPlan as fG, buildPlaceSpotLimitOrderPlan as fH, buildPlaceSpotMarketOrderExPlan as fI, buildPlaceSpotMarketOrderPlan as fJ, clobAddressHex as fK, composeClaimBoundMessage as fL, computeNoEvmDacFinalityMessage as fM, computeNoEvmLeaderFinalityMessage as fN, computeNoEvmReceiptsRoot as fO, computeNoEvmRoundFinalityMessage as fP, computeNoEvmTargetReceiptHash as fQ, consumeNativeEvents as fR, decodeClusterDiversity as fS, decodeClusterFormedEvent as fT, decodeNativeAgentStateResponse as fU, decodeNativeMarketOrderBookDeltasResponse as fV, decodeNativeReceiptResponse as fW, decodeNoEvmReceiptTranscript as fX, decodeOperatorFeeChargedEvent as fY, decodeOperatorNetworkMetadata as fZ, decodeOracleEvent as f_, bidSighash as fa, bridgeAddressHex as fb, bridgeDrainRemaining as fc, bridgeQuoteSubmitReadiness as fd, bridgeRoutesReadiness as fe, bridgeTransferCandidates as ff, buildBridgeRouteCatalogue as fg, buildCancelSpotOrderPlan as fh, buildNativeCallForwarderArtifact as fi, buildNativeMarketModuleCallEnvelope as fj, buildNativeNftBuyListingForwarderInput as fk, buildNativeNftBuyListingModuleCall as fl, buildNativeNftCancelListingForwarderInput as fm, buildNativeNftCancelListingModuleCall as fn, buildNativeNftCreateListingForwarderInput as fo, buildNativeNftCreateListingModuleCall as fp, buildNativeNftPlaceAuctionBidForwarderInput as fq, buildNativeNftPlaceAuctionBidModuleCall as fr, buildNativeNftSettleAuctionForwarderInput as fs, buildNativeNftSettleAuctionModuleCall as ft, buildNativeNftSweepExpiredListingsForwarderInput as fu, buildNativeNftSweepExpiredListingsModuleCall as fv, buildNativeSpotCancelOrderForwarderInput as fw, buildNativeSpotCancelOrderModuleCall as fx, buildNativeSpotCreateMarketForwarderInput as fy, buildNativeSpotCreateMarketModuleCall as fz, type NativeEventsResponse as g, nativeMarketStateFilterParams as g$, decodeTxFeedResponse as g0, deriveClobMarketId as g1, deriveClusterAnchorAddress as g2, deriveNativeSpotMarketId as g3, deriveNativeSpotOrderId as g4, encodeBlockSelector as g5, encodeCancelOrderCalldata as g6, encodeClaimPolicyByAddressCalldata as g7, encodeCreateRequestCalldata as g8, encodeCreateRequestCanonical as g9, encodeSetTickSizeCalldata as gA, exportBridgeRouteCatalogueJson as gB, fetchChainInfoLatest as gC, fetchChainRegistryLatest as gD, getChainInfo as gE, getNoEvmReceiptTrustPolicy as gF, getP2pSeeds as gG, getRpcEndpoints as gH, hexToAddressBytes as gI, isBridgeAdminLockedRevert as gJ, isBridgeCooldownZeroRevert as gK, isBridgeFinalityZeroRevert as gL, isBridgeResumeCooldownActiveRevert as gM, isConcreteServiceProbeStatus as gN, isNativeDecodedEvent as gO, isNativeMarketOrderBookStreamPayload as gP, isSinglePublicServiceProbeMask as gQ, isValidNodeRegistryCapabilities as gR, isValidPublicServiceProbeMask as gS, nativeAgentStateFilterParams as gT, nativeEventMatches as gU, nativeEventsFilterParams as gV, nativeEventsFromHistory as gW, nativeEventsFromReceipt as gX, nativeMarketEventFilter as gY, nativeMarketEventsFromHistory as gZ, nativeMarketEventsFromReceipt as g_, encodeDisableCalldata as ga, encodeEnableCalldata as gb, encodeLockBridgeConfigCalldata as gc, encodeNativeMarketModuleForwarderInput as gd, encodeNativeNftBuyListingCall as ge, encodeNativeNftCancelListingCall as gf, encodeNativeNftCreateListingCall as gg, encodeNativeNftPlaceAuctionBidCall as gh, encodeNativeNftSettleAuctionCall as gi, encodeNativeNftSweepExpiredListingsCall as gj, encodeNativeSpotCancelOrderCall as gk, encodeNativeSpotCreateMarketCall as gl, encodeNativeSpotLimitOrderCall as gm, encodeNativeSpotSettleLimitOrderCall as gn, encodeNativeSpotSettleRoutedLimitOrderCall as go, encodePlaceLimitOrderCalldata as gp, encodePlaceLimitOrderViaCalldata as gq, encodePlaceMarketOrderCalldata as gr, encodePlaceMarketOrderExCalldata as gs, encodeReportServiceProbeCalldata as gt, encodeSetBridgeResumeCooldownCalldata as gu, encodeSetBridgeRouteFinalityCalldata as gv, encodeSetLotSizeCalldata as gw, encodeSetMinNotionalCalldata as gx, encodeSetPolicyCalldata as gy, encodeSetPolicyClaimCalldata as gz, type NativeAgentStateFilter as h, fetchEncryptionKey as h$, noEvmReceiptTrustPolicyFromChainInfo as h0, nodeHostingClassFromByte as h1, nodeHostingClassToByte as h2, nodeRegistryAddressHex as h3, normalizeAddressHex as h4, normalizeBridgeRouteCatalogue as h5, oracleAddressHex as h6, packTimeWindow as h7, parseAddress as h8, parseBridgeRouteCatalogueJson as h9, type DecryptHint as hA, ENUM_VARIANT_INDEX_ML_DSA_65 as hB, type EncryptedEnvelope as hC, type EncryptedSubmission as hD, ML_DSA_65_PUBLIC_KEY_LEN as hE, ML_DSA_65_SEED_LEN as hF, ML_DSA_65_SIGNATURE_LEN as hG, ML_DSA_65_SIGNING_KEY_LEN as hH, ML_KEM_768_CIPHERTEXT_LEN as hI, ML_KEM_768_ENCAPSULATION_KEY_LEN as hJ, ML_KEM_768_SHARED_SECRET_LEN as hK, type NativeTxExtension as hL, type NativeTxExtensionDescriptor as hM, type NativeTxExtensionLike as hN, type NonceAad as hO, type PlaintextSubmission as hP, STANDARD_ALGO_NUMBER_ML_DSA_65 as hQ, bincodeDecryptHint as hR, bincodeEncryptedEnvelope as hS, bincodeNonceAad as hT, bincodeSignedTransaction as hU, buildEncryptedEnvelope as hV, buildEncryptedSubmission as hW, buildPlaintextSubmission as hX, encodeMlDsa65Opaque as hY, encodeTransactionForHash as hZ, encryptInnerTx as h_, parseChainRegistryToml as ha, parseNativeDecodedEvent as hb, parseQuantity as hc, parseQuantityBig as hd, proverMarketStateFromByte as he, quoteOperatorFee as hf, rankBridgeRoutes as hg, requestSighash as hh, requireTypedAddress as hi, selectBridgeTransferRoute as hj, serviceProbeStatusLabel as hk, spendingPolicyAddressHex as hl, submitSighash as hm, typedBech32ToAddress as hn, validateAddress as ho, validateBridgeRouteCatalogue as hp, verifyNoEvmArchiveProofSignatures as hq, verifyNoEvmBlockFinalityEvidenceMultisig as hr, verifyNoEvmBlockFinalityEvidenceThreshold as hs, verifyNoEvmFinalityEvidenceMultisig as ht, verifyNoEvmFinalityEvidenceThreshold as hu, verifyNoEvmReceiptProof as hv, verifyNoEvmReceiptProofTrust as hw, ADDRESS_DERIVATION_DOMAIN as hx, DKG_AEAD_TAG_LEN as hy, DKG_NONCE_LEN as hz, type NativeAgentStateResponse as i, mlDsa65AddressBytes as i0, mlDsa65AddressFromPublicKey as i1, outerSigDigest as i2, submitEncryptedEnvelope as i3, submitPlaintextTransaction as i4, submitTransactionWithPrivacy as i5, type NativeMarketStateFilter as j, type NativeMarketStateResponse as k, type NativeMarketOrderBookDeltasRequest as l, type NativeMarketOrderBookDeltasResponse as m, type AddressProfileResponse as n, type AddressFlowResponse as o, type RedemptionQueueResponse as p, type MrcAccountResponse as q, type MrcHoldersResponse as r, type BridgeRoutesRequest as s, type BridgeRoutesResponse as t, type ServiceProbeResponse as u, type ClobMarketsResponse as v, type ClobMarketResponse as w, type ClobTradesResponse as x, type ClobOhlcResponse as y, type ClobOrderBookResponse as z };