IntentVM (U.S. Patent App. 19/571,463)

The Problem: Traditional blockchains require users to specify exact execution steps. A simple "swap then stake" requires 2 transactions, 2 signatures, and 2 consensus rounds.

The Solution: IntentVM accepts a single intent -- expressed as structured JSON or natural language -- and decomposes it into the optimal sequence of native operations, executed atomically in one block slot.

User: "swap 100 VXS for USDC and stake the rest"

IntentVM decomposes:
  1. Swap (VXS -> USDC via VexiDEX)
  2. Stake (remaining VXS to validator)

Result: 1 intent, 1 signature, 2 operations, 1 block slot

Key Advantage -- 1 Intent, 1 Signature, N Operations

On Solana or Ethereum, "swap then stake" = 2 transactions, 2 signatures, 2 consensus rounds. On Vexidus, it is 1 bundle, 1 signature, 1 round. This gives Vexidus 3-5x effective throughput per user action compared to per-transaction chains.

Multi-Input Atomic Swaps: IntentVM can process multi-input operations -- for example, "swap 10 USDC and 10 USDT for VXS" -- in a single atomic execution. On other chains this requires 2 separate transactions with slippage risk between them. On Vexidus, both inputs are converted in one block slot with unified slippage protection.

Provenance

IntentVM was first built and tested as a Solana on-chain program (Program ID: AcfdgJoduQxLLPwFDVTi3FWrqEERPhmQ9UAwNkrkYfnJ). Real transaction proofs exist from Solana localnet (slot 331,223, 12,099 compute units). It was then rebuilt as a core protocol feature on Vexidus -- not a theoretical design, but a port of working code.

Supported Goals

Core Operations

Swap -- Token exchange via VexiDEX pools with auto-routing
Stake -- Delegate VXS to validators
Provide Liquidity -- Add to AMM pools
Transfer -- Send tokens to an address (Vx, 0x, or .vex name). VNS names like cjf.vex are resolved automatically at execution time.
Bridge -- Cross-chain with tier-aware proof verification
Composite -- Atomic multi-step. Supports N-input token consolidation: "swap 10 USDC, 20 USDT, and 30 DAI for VXS" creates N atomic swaps in one intent.
Program -- Execute a registered VIP (Vexidus Intent Program). Developers register reusable, parameterized operation sequences that users invoke by name. No smart contracts needed.
Custom -- VNS registration ("register myname.vex"), future LLM-parsed intents

Outcome-Based Intents

Users specify what they want, not the steps to get there. The planner reverse-engineers the optimal execution path.

Acquire -- "Get me 10 SOL, max 200 USDC". Specify target asset + amount + optional cost constraint. The planner reverse-calculates the required swap input from pool reserves using AMM math, validates against your max cost, and executes atomically.
Liquidate -- "Liquidate to 500 USDC, keep VXS". Specify target asset + amount needed. The planner queries your portfolio holdings, finds the optimal sell path (best swap rates first), and greedily sells until the target is covered. Exclude tokens you want to keep.
Rebalance -- "Rebalance to 50% VXS, 30% USDC, 20% ETH". Reads current portfolio, computes delta trades from current allocation to target percentages, and executes the optimal swap sequence atomically.

Portfolio Intelligence

Allocate -- "Put 100 VXS split 60/40 between staking and liquidity". Divides an amount across multiple operations by percentage.
Recurring (DCA) -- "Buy 10 VXS with USDC every day for 7 days". Scheduled execution with configurable interval and count.
Conditional (Limit Orders) -- "Swap 100 USDC for VXS if price below 0.15". Price-triggered execution using on-chain spot prices.

Synthetic Assets (VSC-71 -- Licensee Interface)

MintSynthetic -- Tokenized stocks, commodities, indices (e.g. "buy 10 AAPL with USDC")
OpenPosition -- Leveraged perpetual contracts (e.g. "open 5x long ETH perp with 100 USDC")
ClosePosition -- Close an existing leveraged position

VSC-71 defines the IntentVM interface for synthetic assets. Oracle pricing, margin engines, and liquidation logic are not built into the protocol -- licensees wire their own oracle partners and risk management systems. See the VSC-71 Integration Guide for implementation details.

Routing & Price Intelligence

Auto-Routing

When no direct liquidity pool exists between two tokens, IntentVM automatically discovers intermediate routes. For example, swapping DAI → SOL may route through DAI → VXS → SOL if no direct DAI/SOL pool exists.

The router evaluates all available intermediate tokens and selects the route with the deepest liquidity (highest minimum reserve across both legs). Slippage constraints are applied per leg to protect against multi-hop price impact.

Price Oracle (TWAP Foundation)

Every swap on VexiDEX records a cumulative price observation. This enables:

Spot pricing -- Current pool ratio for any token pair
TWAP pricing -- Time-weighted average price over configurable windows
Auto-routed pricing -- Price quotes through intermediate pools when no direct pair exists

Price Impact Protection

Before execution, IntentVM checks that no single swap would drain more than 25% of any pool's reserves. This is tighter than the 50% circuit breaker in the swap handler, protecting users from excessive slippage on large orders. Simulation endpoints return price impact in basis points with human-readable warnings.

Constraint Enforcement

All constraints can be set programmatically (JSON) or extracted automatically from natural language:

Constraint	NL Example	Effect
Slippage	"with 3% slippage"	Rejects if output deviates beyond threshold
Deadline	"within 5 minutes"	Rejects if intent not executed before deadline
Max Fee	"max fee 50000"	Reverts if gas cost exceeds cap (in nanoVXS)
Min Output	"minimum 95 USDC"	Rejects if output below floor
Route Preference	Automatic / PreferDex / Custom	Controls DEX selection

Execution Previews

IntentVM provides three levels of pre-execution analysis:

Method	Purpose
`vex_getExecutionPlan`	Execution steps + gas estimate
`vex_simulateIntent`	Full dry-run: per-pool quotes, price impact (bps), balance checks, warnings
`vex_previewIntent`	Human-readable wallet confirmation: summary text, fee in VXS, slippage %, route type

Wallet developers should call vex_previewIntent before vex_submitIntent to show users a confirmation screen with estimated costs and warnings.

Multi-Language Support

The NL parser accepts intents in 7 languages. Non-English input is normalized to English before parsing. All intent types -- swaps, transfers, staking, outcome-based intents, and constraints -- work in every language.

Written number support: The parser converts written-out numbers to digits before processing: "swap five hundred VXS for ETH" becomes "swap 500 VXS for ETH". Supports compounds ("two thousand"), decimals ("one point five"), and multipliers ("a hundred").

Language	Swap Example	Buy Example (→ Acquire)
English	"swap 100 USDC for VXS"	"buy 10 VXS with USDC"
Spanish	"intercambiar 100 USDC por VXS"	"comprar 10 VXS con USDC"
Portuguese	"trocar 100 USDC por VXS"	"comprar 10 VXS com USDC"
French	"échanger 50 ETH pour VXS"	"acheter 10 VXS avec USDC"
German	"tauschen 100 USDC für VXS"	"kaufen 10 VXS mit USDC"
Italian	"scambiare 100 USDC per VXS"	"comprare 10 VXS con USDC"
Japanese	"100 USDCをVXSに交換"	--

Note: "buy" verbs produce Acquire intents (target output amount), while "swap" verbs produce Swap intents (input amount). See the Developer Guide for full verb and connector mappings.

Architecture

User Input (NL or JSON, any supported language)
    |
    v
Multi-Language Normalizer
    |  maps non-English verbs to English equivalents
    v
Constraint Extractor
    |  strips deadline, max_fee, slippage from text
    v
NL Parser / JSON Deserializer
    |  pattern matching → Goal enum
    v
IntentBuilder
    |  fluent API, builds Goal + Constraints
    v
RPC: vex_previewIntent (optional)
    |  wallet confirmation screen
    v
RPC: vex_submitIntent
    |  builds intent bundle, submits to leader
    v
Execution Engine
    |  decomposes Goal → native Operations
    |  auto-routing, price impact check
    |  constraint enforcement (deadline, fees, slippage)
    v
Block Execution (atomic)

Future: LLM Integration

The NL parser currently uses regex patterns. For more complex intents, integrate an LLM:

User: "Buy VXS with half my USDC and stake it with the highest-APY validator"
  -> LLM extracts: Composite([
       Swap { from: USDC, to: VXS, amount: 50% of balance },
       Stake { token: VXS, amount: all, validator: highest_apy }
     ])

Integration path:

Client sends NL to LLM API (Grok, Claude, etc.)
LLM returns structured Goal JSON
Client submits structured JSON via vex_submitIntent

Developer Guide

For code examples, SDK usage, and RPC integration, see the IntentVM Developer Guide.

For VSC-71 synthetic asset integration (tokenized stocks, perpetuals), see the VSC-71 Integration Guide.

Key Advantage -- 1 Intent, 1 Signature, N Operations​

Provenance​

Supported Goals​

Core Operations​

Outcome-Based Intents​

Portfolio Intelligence​

Synthetic Assets (VSC-71 -- Licensee Interface)​

Routing & Price Intelligence​

Auto-Routing​

Price Oracle (TWAP Foundation)​

Price Impact Protection​

Constraint Enforcement​

Execution Previews​

Multi-Language Support​

Architecture​

Future: LLM Integration​

Developer Guide​