Moxie API, RPC, and settlement reference.

Introduction

Moxie is a programmable exchange for contract markets. A contract market can be as simple as an in-game item resale market or as complex as a racing pool, parlay, royalty-linked asset, insurance payout, coupon, or cross-market portfolio. The developer surface is ordinary SDK + JSON-RPC: create the market, quote the trade, submit the order, read the receipt, and subscribe to updates.

Under the hood, Moxie owns price discovery, clearing, settlement, liquidity, receipts, release/recovery, and reliance export. Mass supplies the institutional admissibility plane. The terminal runtime primitive is AdmissibleObligationTransition; event-contingent settlement, brand/IP, securities, insurance, parimutuels, coupons, payouts, non-event trading, and agent actions are TemplatePack/AOT lanes over the same kernel. ClaimGraph and ClaimCompiler are the typed source-IR/lowering layer for contracts and claims; the lowered AOT remains consensus truth.

The API is JSON-RPC 2.0 over HTTPS plus staged REST surfaces. The registered moxie_* catalog includes moxie_getBrandExperiences, moxie_merchOrder, the PTJC moxie_racing* surface, the settlement-job pair moxie_estimateSettlementBatch + moxie_submitSettlementBatch, and the terminal-kernel surface moxie_getTerminalKernelState, moxie_getTerminalTemplatePacks, moxie_getTerminalRelianceInstruments, moxie_getTerminalHotMarketStatus, moxie_lowerClaimGraph, and moxie_buildTransaction { method: "terminalKernel" }. The @moxie/sdk TypeScript client exposes flat named methods, SDK-owned wire types, typed errors, and the webapp compatibility facade; moxie-sdk (Rust, Python) are the Tier 1 counterparts. The SDK can call the mounted compliance preflight route today; signed native writes can echo a preflight binding into moxie_submitSigned, and racing writes also require idempotency plus a chain-bound chain_binding.settlement_batch. PTJC production wagering remains gated by the Thai legal opinion and deployment smoke witness. REST parity gating currently covers OAuth, corridor, webhooks, audit-chain, regulator, portfolio, app-install, agent-invocations, and revenue REST surfaces.

Base URLs

Content Type

All requests and responses use application/json.

SDK Method Families

Authentication

The API uses Bearer token authentication. Four credential classes are issued in distinct forms: secret developer keys are prefixed mxk_sk_<env>_<kid>_, publishable developer keys mxk_pk_<env>_<kid>_, OAuth-exchanged bearer tokens mxat_, SIWE player sessions mxs_player_<addr>_, and short-lived Mass-app-install tokens miat_ (TTL ≤ 900s). Exchange a secret key into a bearer via the mounted gateway or ops route POST /oauth/token; pass the bearer as Authorization: Bearer on every request.

The SDK accepts the token via the apiKey constructor option. For client-side signing, pass a signer with addressFromPrivateKey() and signTransactionHash(). For admin routes, submit signed envelopes from an HSM-rotatable admin signer; see the Authentication overview above for the four auth profiles.

Mutating Calls

Writes use explicit idempotency, validation, and confirmation discipline. callMutation()-backed methods generate an Idempotency-Key from the registered RPC method when the caller does not provide one; racing JSON-RPC writes enforce same-key/same-body replay and same-key/different-body mismatch semantics, while broader mutation replay enforcement remains route-specific. SDK validators reject malformed event windows, amounts above MAX_TRANSFER_AMOUNT / MAX_STAKE_AMOUNT / MAX_ORDER_SIZE, reserved addresses, and oversized serialized transactions before transport. Signer-backed native helpers map SDK aliases such as ammSwap, spotOrder, and createContinuousMarket to their moxie_* RPC names for idempotency, then build, sign, submit through moxie_submitSigned, and wait for receipt confirmation by default. Pass waitForReceipt: false only when the caller owns polling.

Compliance preflight is available on supported NativeMutationOptions surfaces and on direct signed submissions through the preflight binding object accepted by moxie_submitSigned. When Mass compliance write admission is enabled, enhanced mutating calls fail closed unless the binding matches sender, purpose, entity ids, as-of block, TTL, jurisdiction, and commitment. A blocked verdict raises MoxieComplianceBlockedError with the server verdict preserved in error metadata.

Write Headers

Errors

The API returns standard JSON-RPC wire errors as { code, message, data? }. The TypeScript SDK maps those and HTTP failures into subclasses of MoxieSdkError: MoxieRateLimitError, MoxieTimeoutError, MoxieNetworkError, MoxieJsonRpcError, MoxieComplianceBlockedError, MoxieAuthError, and MoxieInvalidInputError. Each preserves available JSON-RPC code, HTTP status, backend error code, request ID, retry-after value, and retryability metadata.

Server errors (5xx), rate-limit responses, JSON-RPC -32005, timeouts, and retryable network failures are automatically retried with exponential backoff up to maxRetries (default 3). Rate limit responses may include Retry-After and X-RateLimit-Remaining headers when the node or gateway provides them.

HTTP Status Codes

Pagination

Canonical pagination follows the Moxie PLATONIC I-9 cursor-only contract: clients pass opaque cursors through unchanged, never decode them, and treat null / absent cursor as the first page. Current-node legacy JSON-RPC list handlers still accept limit and offset on explicitly documented surfaces and cap limit at 200.

Do not inspect or derive meaning from pagination tokens. Cursor surfaces advance with the backend-provided cursor. Current-node legacy offset surfaces advance by the number of returned items until the handler migrates to the cursor envelope.

Response Fields

Amounts

All monetary values on the wire are raw 18-decimal strings. "1000000000000000000" equals 1.0 USDC (the primary settlement currency). Never use parseFloat() on raw amounts: they exceed JavaScript’s safe integer range.

The SDK exports wire-safe helpers directly from @moxie/sdk.

Utilities

Brands

A Brand represents an IP-linked derivative on the clearing network: a sports league, entertainment property, or cultural franchise whose token price is coupled to real-world event outcomes. Each brand has a token, a market stage, a temperature regime (Cold/Warm/Hot regulatory graduation), and a revenue pool that accumulates fees from trading, licensing, drops, and auctions.

Lists all brands. The current JSON-RPC handler is moxie_getBrands; the REST route returns the same RpcBrand[] wire objects without pagination metadata.

Scheduled brand experiences are exposed by moxie_getBrandExperiences with an optional brand ID filter. The Tier 1 SDK names are TypeScript getBrandExperiences(brandId?), Rust client.brands().experiences(Some(brand_id)), and Python client.brands.get_brand_experiences(brand_id). Each experience carries id, brand_id, title, subtitle, category, starts_at, location, points_cost, capacity fields, tier requirement, featured flag, and status.

Merchandise is exposed by moxie_getMerchandise, moxie_purchaseMerch, moxie_merchOrder, and moxie_merchFulfill. The typed order path is TypeScript merchOrder(params), Rust client.brands().merch_order(params), and Python client.brands.merch_order(...); it returns the RpcMerchOrderReceipt fields documented in the method-family summary.

REST Notes

Brand Object

Markets

Markets represent trading venues for brand tokens. Each market progresses through five stages: BondingCurve, EquilibriumAmm, HybridAmmClob, FullClob, and CrossListed. The orderbook merges synthetic AMM levels with resting CLOB orders.

Lists all markets through JSON-RPC. Filter client-side by brand, regime, volume, spread, or price.

Retrieves candle data for a market. Single-market summary reads use SDK/JSON-RPC helpers.

Returns L2 orderbook depth. Bids and asks include price, quantity, and order count at each level.

Market Object

Swaps

AMM swaps execute against constant-product pools with Probability-Weighted AMM coupling. The pool price adjusts based on prediction market outcomes through a bounded geometric function.

Lists all AMM pools with reserves, fees, and 24h volume.

Returns the token-side quote fixture exposed by the REST node. For executable slippage protection, compute and pass min_amount_out to the SDK mutation.

Executes an AMM swap. SDK write helpers return a transaction hash and wait for a successful receipt by default; use waitForReceipt(txHash) only when polling manually.

Body Parameters

Continuous-CPCAM

Continuous-outcome AMM over an interval [omega_lo, omega_hi], discretised on a grid, paired with a convex entropy generator. Three creator choices are integer-coded on the wire: grid_size_code ∈ 0..=5 (N8, N16, N32, N64, N128, N256), generator_code ∈ 0..=4 (Quadratic, Entropy, Logarithmic, PowerMean2, ExponentialKernel), and an optional swap_fee_bps ∈ 0..=10000 (basis points of every Buy accruing to LP positions prorated by liquidity_budget). LPs provide range liquidity with a shape (shape_code ∈ 0..=2: PiecewiseConstant, Gaussian, Exponential); withdraw returns principal plus accrued fees. Quotes may defer when the integrator has not converged; a deferred quote returns pending_id and the caller polls getPendingClearings.

Creates a continuous market. Body fields: key (64-hex transaction key), market_id (64-hex), omega_lo / omega_hi (18-decimal FixedPoint wire strings), grid_size_code, generator_code, initial_mu (array of FixedPoint; size matches the grid), and optional swap_fee_bps.

Reads market state by market_id: generator, grid, current mu, total liquidity budget, fee accumulator.

Returns { deferred, post_mu, state_prices, total_payout, iterations_used, pending_id, last_iterate }. A non-deferred quote is directly executable; a deferred quote means the integrator needs more iterations than the per-block budget permits. Poll moxie_getPendingClearings until the pending id resolves.

Submits a continuous swap. Body: { key, market_id, omega_a, omega_b, delta_amount, direction_code } where direction_code is 0 (Buy) or 1 (Sell). Returns a transaction hash.

Commits a range [omega_lo, omega_hi] with a weighting shape_code (and shape_param_a, optional shape_param_b) and a liquidity_budget. The caller’s swap_fee_bps share accrues to the position prorated by liquidity_budget across all LP positions in range for the duration of residency.

Closes an LP position and returns principal plus accrued fees.

Terminates an active market. Only the creator may resolve. Every open ContinuousLpPosition for market_id is paid out (liquidity_budget + accrued_fees from custody back to owner) and removed; subsequent swapContinuous and provideContinuousLiquidity calls against the market return InvalidParameter. The market entry remains in state for historical queries until pruned.

Lifecycle close: removes resolved markets whose resolution block is older than CONTINUOUS_MARKET_RESOLUTION_RETENTION_BLOCKS = 10_000. Wall-clock duration depends on node cadence: about 5.56h at the default 2,000ms block time and 2.22h at the chained 800ms target. Open access: any nonce-holding account may submit once the retention threshold has elapsed.

Reads a single LP position by position_id: range, shape, liquidity budget, accrued fees since last withdraw.

Observability read: all LP positions in a market. Supports dashboards and fee-accrual monitoring.

Paginated read of every LP position held by an owner across all continuous markets. Capped at 200 positions per call; callers page through larger inventories. Backs LP-dashboard workflows where a provider tracks accrued fees and ranges across concurrent markets.

Returns the block number at which a given market_id was resolved, or indicates the market is not yet resolved. Backs audit tooling and the retention-window check before pruneResolvedContinuousMarkets.

Lists deferred quotes awaiting further integrator iterations. Each entry carries pending_id, last_iterate, and estimated blocks-to-completion.

Enum codes (wire)

Predictions

Prediction events are binary or multi-outcome markets tied to real-world outcomes, settled in USDC. Events resolve in Phase 1 of each block, before any trades execute: this is event-atomic settlement, where prediction resolution and spot repricing happen in a single block. Resolution reprices the coupled brand token through the PW-AMM.

Lists prediction events. Filter by brand, status (Open, Closed, Resolved, Settled).

Retrieves prediction odds for a single event through JSON-RPC.

Creates a new prediction event through the signed native SDK path.

Mints outcome shares for a prediction position. Specify prediction ID, event ID, outcome index, and amount.

Trades prediction shares through the signed native SDK path.

Event Object

Drops

VRF-based reward distributions. A creator funds a pool, sets a weight function and duration. At the designated block, the on-chain VRF selects winners weighted by stake. Winners claim rewards before the deadline.

Lists drops. Filter by brand or status (Upcoming, Active, Revealing, Completed).

Creates a new drop with reward pool, weight function, execution block, and claim deadline.

Claims winnings for a completed drop. Only callable by winners.

Weight Functions

Personas

Belief-weighted character tokens tied to a parent brand. Each persona has an LMSR belief state coupled to the brand’s prediction markets. Shares trade on a bonding curve until graduation to a full brand token.

Lists persona tokens. Filter by brand.

Retrieves a single persona with belief weight, supply, price, and holder count.

Buys persona shares. Cost determined by the bonding curve.

Sells persona shares. Proceeds determined by the bonding curve.

Persona Object

Accounts

Query account state: balances across all tokens, transaction history, staking positions, and KYC tier. Transfer tokens, stake to validators, and unstake.

Lists all token balances for an account. Each entry includes token symbol, balance, and current price.

Paginated transaction history. Each transaction includes type, block, success status, and error message if failed.

Transfers and staking are native signed SDK mutations, not REST account routes.

KYC Tiers

Positions

Cross-margined clearinghouse positions. A single USDC-denominated margin pool backs spot, prediction, perpetual, and liquidity positions. Diversified portfolios require less capital because the clearinghouse understands brand correlation and offsets hedged exposure.

Lists positions for an account. Filter client-side by market or kind (BrandSpot, BrandPrediction, Standalone).

Position Object

Governance

On-chain governance through ve$MOXIE vote-escrowed tokens. Proposals progress through Pending, Active, Passed, Rejected, and Executed states. Voting power is proportional to locked MOXIE amount and lock duration.

Lists governance proposals. Filter by status or proposer.

Submits a new governance proposal with title, description, and executable actions.

Casts a vote on a proposal. Pass support: true/false and optional amount to weight.

IP Graph

The IP licensing relationship graph. Nodes represent entities (brands, licensors, distributors). Edges represent licensing agreements, revenue splits, and IP transfer relationships with weights.

Returns the current IP graph as { nodes, edges, totalNodes, totalEdges }. Filter client-side by brand, entity, or relationship.

Chain

Chain-level queries: node health, block retrieval, transaction receipts, and historical state-root proofs. Blocks execute in three deterministic phases. The default block-time constant is 2,000ms; chained execution targets 800ms, while consensus tests still exercise the 600ms centerline.

Returns chain ID, current block number, sync status, peer count, and pending transaction count.

Retrieves a block by number. Use latest for the most recent block.

Returns a transaction receipt when present; a missing receipt serializes as null. The SDK’s signed mutation helpers poll via waitForReceipt(txHash) by default.

Returns the historical block-header state root at a hex block height plus the current retained chain window. Heights older than retained history fail closed with JSON-RPC code -32004 and a pruned history unavailable envelope carrying requested_height, chain_oldest_height, chain_newest_height, and pruned_count.

Returns the current bare receipt by tx hash. The Tier 1 SDK method is getTransactionReceipt(txHash); signed mutation helpers call the same receipt path through waitForReceipt(txHash). RpcReceipt carries optional camelCase settlementBatchRoot: string | null and events: RpcReceiptEvent[]. Terminal or single-chunk SettlementBatch receipts populate settlementBatchRoot; NativeTx::PayoutReturned receipts include a PayoutReturned event with payoutId, recipient, amount, and returnCode. A23 proof methods (moxie_getReceipt with includeProof and moxie_getReceiptsForBlock) are publicly registered; their RpcMerkleReceipt.digestInput mirrors settlementBatchRoot and commits receipt events through eventsRoot.

Per-tx gas estimation. EvmCall paths reserve the declared gas_limit at admission, reject underpriced max_fee_per_gas/max_priority_fee_per_gas caps against the current base fee, execute at the effective EIP-1559 gas price, and reconcile block gas to revm-metered receipt.gas_used after execution. Non-EVM variants still use their static consensus tiers.

Settlement-job dry-run for the moat #1 primitive. Single named param { payload: SettlementBatchPayload }. Returns { gas_estimate: u64, manifest_root: 0x-prefixed 32-byte hex, validation: { ok: bool, errors: string[] }, chunked_mode: bool, is_terminal_chunk: bool, staging_complete: bool }. Per invariant I-12, dev-input failures return HTTP 200 with validation.ok = false rather than a JSON-RPC envelope error; reserved 4xx / Internal envelopes are transport-only. Public read class — no auth required. The gas heuristic constants are pub-exported in crates/moxie-rpc/src/types.rs: BASE_GAS = 21,000, GAS_PER_PAYOUT = 5,000, GAS_PER_MINT = 5,000, GAS_PER_BURN = 5,000, GAS_PER_ORACLE = 3,000, GAS_PER_MARGIN = 3,000, GAS_PER_CHUNK = 1,000.

Settlement-job write for the moat #1 primitive. Auth class: AuthWrite (mirrors moxie_submitSigned rate-limiting and auth). Mandatory Idempotency-Key header on every request (I-3). Bi-modal envelope: trusted-gateway auth-only mode { payload }, or client-side ECDSA signed mode { payload, signature: 0x-prefixed-hex, signer: 0x-prefixed-20-byte-hex, cryptographic_epoch?: number }. Half-pair envelopes (signature without signer or vice versa) return RpcErr::InvalidParams. The handler re-runs payload.validate_cheap_checks() and payload.compute_manifest_root() before mempool dispatch and rejects manifest-root mismatch. Dispatches via the same submit_signed_transaction() path as moxie_submitSigned: HEAL A1 active-suite verification plus the downgrade gate. Returns { tx_hash: 0x-prefixed 32-byte hex }; clients then call waitForReceipt(txHash) and read settlementBatchRoot on the terminal receipt. Returned payouts are submitted as signed NativeTx::PayoutReturned transactions and observed through receipt.events.

Returns the live { baseFeePerGas, maxPriorityFeePerGas } envelope. Base-fee adjusts per block via the canonical Roughgarden 2021 update rule (±12.5% bound, denominator δ = 8, 1-wei wake-up bump, MIN_BASE_FEE_PER_GAS floor). maxPriorityFeePerGas is the nonzero deterministic suggestion; EvmCall mempool ordering derives its cleartext priority byte from the paid priority-fee cap.

Returns the terminal clearing-kernel snapshot: root registry, role-scoped authority grants and action nonces, ProductLegalProfile and TemplatePack registries, RiskGeneratorV1 snapshots, executable-depth certificates and consumed keys, release/recovery authorizations, recognized reliance instruments and envelopes, admitted AOT ledger, certified hot-market deltas/status, and bounded CPCAM adapter certificates. Sibling reads expose narrower views: moxie_getTerminalKernelRoot, moxie_getTerminalTemplatePacks, moxie_getTerminalRelianceInstruments, and moxie_getTerminalHotMarketStatus.

Deterministic source-layer preflight for product compilers. Single named param { program: ClaimProgramDefinition, graph: ClaimGraph, context: ClaimLoweringContext }. The node validates the program, graph, evidence, risk, reliance, and lowering context, then returns { program_id, graph_id, graph_root, compiler_version, aot } without mutating chain state. Consensus truth remains the lowered AdmissibleObligationTransition.

Perpetuals

Perpetual contracts on IP-linked tokens. Open long or short positions, receive periodic funding payments, and close at any time. Funding rates are computed from mark-index price divergence and exposed on the perp market read model; the exact wall-clock interval follows configured block cadence.

Lists perpetual markets with funding rates, mark/index prices, open interest, and funding interval. Opening and closing positions are signed SDK mutations.

Body Parameters

Reads a specific perpetual position. Closing positions is the signed perpClose() SDK mutation.

Body Parameters

Funding is visible on each PerpMarket; perpFunding() submits the funding-settlement native transaction when an operator needs to crystallize funding.

Funding Object

Contingent Orders

Event-contingent order state is exposed as a read model per account. The current TypeScript write helper is conditionalOrder() for price-triggered orders with optional event context; stop-event and parlay state appear in the pending-order read model as the native executor matures.

Lists pending contingent, stop-event, and parlay orders for a 20-byte account address.

Body Parameters

Submits a signed conditional order through the SDK/native transaction path.

Body Parameters

Reads all pending contingent-order families for the account; clients filter by type.

Body Parameters

Lists all active contingent, stop-event, and parlay orders for the supplied account.

Autonomous Events

Self-resolving prediction events are submitted through the signed createAutonomousEvent() SDK helper. The current node does not expose a REST create route; REST observability should be layered on the event read model as parity work.

Creates a signed CreateAutonomousEvent native transaction.

Body Parameters

Event read-side visibility is served through getEvents() and /api/v1/events.

Reflexivity

The calibration and risk-reflexivity surfaces expose the reflexivity coefficient ρ (rho): a measure of how strongly prediction market outcomes feed back into the brand token price. When ρ is high, event resolution has outsized price impact; when low, the brand token trades independently of prediction markets.

Returns the current calibration state, including reflexivity diagnostics and OI cap controller state.

ReflexivityResult Object

Returns the REST reflexivity diagnostic view. Use moxie_getCalibration for the consensus calibration state.

Circuit Breakers

The CircuitBreakerState endpoint reports node-wide halt state. Circuit breakers trigger on extreme price moves, abnormal reflexivity spikes, or governance action. During a halt, new orders are rejected; existing positions remain open but cannot be modified.

Returns the node-wide current CircuitBreakerState.

CircuitBreakerState Object

TypeScript SDK JSON-RPC helper for the same state.

Coupling Modes

The clearing engine supports three coupling modes that determine how prediction event outcomes affect the brand token price. The active mode is selected automatically based on the reflexivity coefficient ρ and can be overridden by governance.

Returns LMSR calibration for a market; coupling-mode governance remains a consensus-layer concept rather than a dedicated REST route.

CouplingMode Variants

Calibration Object

Mutual Information

The MutualInformationEstimator computes the mutual information (MI) between prediction event outcomes and brand token price movements. The MI-derived κ (kappa) parameter controls the coupling strength in the PW-AMM: higher MI means tighter coupling between predictions and price.

Returns recently updated correlation estimates used by the intelligence layer.

MutualInformation Object

Returns top correlations and cohort summary statistics.

Soulbound Status

Non-transferable reputation credentials issued to accounts based on on-chain clearing activity. SoulboundStatus tokens are ERC-5192-style: they live in a wallet permanently and represent earned standing in the clearing network. Badges unlock tier promotions, governance weight boosts, and drop eligibility.

Lists all soulbound badges held by an account.

Returns the participant engagement profile that badge issuance is based on.

Badge Types

SoulboundStatus Object

Temperature Compliance

The TemperatureComplianceMapping defines regulatory graduation thresholds for brand tokens. Temperature graduation (Cold → Warm → Hot) is the clearing network's regulatory ramp: Cold brands trade with minimal KYC and no leverage; Warm brands unlock perpetuals and higher limits; Hot brands require full accredited-investor attestation and enable maximum leverage. This endpoint exposes the mapping between temperature regimes and required compliance checks, KYC tiers, and position limits.

Returns the current execution regime and compliance requirements for a token.

The TypeScript SDK exposes the same state via getTokenTemperature(tokenId).

TemperatureComplianceMapping Object

Mass-Moxie Bridge

The bridge has two directions. Inbound: a Mass kernel signs a MassIdentityAttestation { attestor, subject, kyc_level, jurisdiction, expiry_block, signature }; the Moxie chain verifies it against a genesis-pinned Mass public key (updatable only via Moxie governance, never discovered from the attestation itself), and the subject’s KYC tier is upgraded on-chain. Per-subject monotonic issued_at_block blocks downgrade-rollback replay. A ComplianceGatePayload carries {brand_id, target_stage, composed_tensor_hash, verdict, expires_at, authority, nonce} as a consensus-affecting NativeTx: absent or expired Approved gates block market promotion past HybridAmmClob; a Rejected gate at Warm+ demotes the market back to EquilibriumAmm.

Outbound: MassObservationRelay runs under a configured bridge mode and produces signed POST /v1/corpus/observe requests to the Mass kernel (OAuth bearer from MOXIE_BRIDGE_TOKEN, or mTLS). Aggregation emits per-epoch jurisdiction roll-ups, never trade-level data. Revenue distribution flows through Mass with harbor-level withholding computed against the composed compliance tensor; Moxie anchors the returned Merkle root via RevenueDistribute and a claim contract validates Merkle proofs against the stored root.

A universal correlation thread corridor_id = blake3(u32_le(|ik|) ‖ ik ‖ u32_le(|tx|) ‖ tx ‖ entity_32 ‖ u64_le(asof)) threads the five cross-kernel surfaces: ComplianceQuery, ComplianceAssertion, AttestationProof, MassObservation, and the Moxie 3PC operation_envelope. The current REST surface is /api/v1/corridors/id, /status, /preflight, and /trace/{cid}. Every kill path routed through the bridge traces back to an accepted contract version, a triggered policy code, a dispute or safety case, or a compliance verdict; regulator takedowns require an F38 CeremonyOverrideReceipt participating in block commit. No kill-by-Slack-DM.

Submits a Mass identity attestation to the Moxie chain via JSON-RPC. The attestation is a signed credential from a Mass kernel proving that an identity has passed a specific compliance check. Once attested, the Moxie account is upgraded to the corresponding KYC tier.

Body Parameters

Checks whether the target entities are likely to pass the compliance tensor for a specific operation. The chain remains the binding authority at admit time.

Body Parameters

Reads the account KYC level after attestations have been applied.

Preflight Response

WebSockets

Real-time subscriptions over WebSocket. The TypeScript SDK exposes connectBlockSubscription(wsUrl, onBlock) for moxie_subscribe("newBlocks"), including reconnect backoff and decimal/hex block-number parsing. The broader WsClient with authentication and topic routing remains the parity target.

Channels

Connection URL

Pass an explicit node WebSocket URL such as wss://api.moxie.xyz or ws://localhost:8545. The current SDK helper is not derived from baseUrl.

SDK Installation

The official TypeScript SDK wraps the JSON-RPC surface with SDK-owned wire types, named methods, typed errors, retry logic for HTTP and JSON-RPC rate limits, client-side signer injection, idempotent native mutations, compliance preflight on supported mutation surfaces, A27 validation preflight, receipt polling, getBrandExperiences(), typed merch order receipts, PTJC racing, terminal-kernel resources, expanded leaderboard types, the webapp compatibility facade, and the block-subscription helper used by the webapp. The Rust and Python SDKs expose matching Tier 1 resources for brand experiences, merch order receipts, racing, settlement, gas, and terminal kernel access plus raw RPC escape hatches for the registered catalog; their continuous-market helpers mirror the consensus MAX_ORDER_SIZE cap before transport. For Rust release dry-runs, moxie-types must publish before moxie-sdk because the SDK depends on the pinned protocol type crate. The conformance corpus and parity tooling keep the SDK surface aligned with the node; scripts/sdk-parity-check.mjs covers registered methods, racing methods, and REST surfaces. Full topic-routed WebSockets remain tracked as parity work.

Requirements

Client Options

Amount Utilities

The SDK exports fixed-point helpers for converting between human-readable decimal strings and the 18-decimal raw wire format used by the protocol. Always use these instead of manual arithmetic.

Raw wire amounts are strings because they exceed JavaScript’s Number.MAX_SAFE_INTEGER. Mutating SDK methods send raw wire amounts; convert display input before submitting writes.