# Authentication & partner key Source: https://new-docs.velora.xyz/api-reference/authentication Authenticate API traffic with a partner key and protect production credentials. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # POST /delta/orders Source: https://new-docs.velora.xyz/api-reference/delta/orders /api-reference/specs/delta.json POST /delta/orders Submit a signed Delta order to the solver network. # POST /delta/orders/build Source: https://new-docs.velora.xyz/api-reference/delta/orders-build /api-reference/specs/delta.json POST /delta/orders/build Build a signable Delta order — EIP-712 typed data — from a Delta quote. # Delta API Source: https://new-docs.velora.xyz/api-reference/delta/overview OpenAPI reference for the Velora Delta intents API. This page is a stub. Content coming soon. ## Parameters ## Examples ## Related pages # GET /quote (Delta) Source: https://new-docs.velora.xyz/api-reference/delta/quote /api-reference/specs/delta.json GET /quote Retrieve a Delta price, with optional fallback to Market via mode=ALL or mode=MARKET. # Error reference Source: https://new-docs.velora.xyz/api-reference/error-reference Canonical catalogue of API error responses, codes, and recovery patterns. This page is a stub. Content coming soon. ## Parameters ## Examples ## Related pages # Introduction Source: https://new-docs.velora.xyz/api-reference/introduction Three OpenAPI-driven surfaces: Market (aggregation), Delta (intents), and Augustus RFQ (fungible limit orders). This page is a stub. Content coming soon. ## When to use this ## How it works ## Examples ## Related pages # Market API (v6.2) Source: https://new-docs.velora.xyz/api-reference/market/overview OpenAPI reference for the Velora Market aggregation API. This page is a stub. Content coming soon. ## Parameters ## Examples ## Related pages # GET /prices (Market) Source: https://new-docs.velora.xyz/api-reference/market/prices /api-reference/specs/market.json GET /prices Get a Market route from the Velora aggregator. # POST /transactions/:network (Market) Source: https://new-docs.velora.xyz/api-reference/market/transactions /api-reference/specs/market.json POST /transactions/{network} Build calldata for an Augustus v6.2 swap from a Market priceRoute. # Rate limits Source: https://new-docs.velora.xyz/api-reference/rate-limits Per-key rate limits, response headers, and best practices to avoid throttling. This page is a stub. Content coming soon. ## Parameters ## Examples ## Related pages # Augustus RFQ API Source: https://new-docs.velora.xyz/api-reference/rfq/overview OpenAPI reference for the Augustus RFQ API — fungible tokens only. This page is a stub. Content coming soon. ## Parameters ## Examples ## Related pages # Tokens & utilities Source: https://new-docs.velora.xyz/api-reference/tokens/overview OpenAPI reference for token lookups, balances, prices, and helpers. This page is a stub. Content coming soon. ## Parameters ## Examples ## Related pages # Troubleshooting Source: https://new-docs.velora.xyz/api-reference/troubleshooting Common failure modes across the Velora Market and Delta APIs — symptom, root cause, and fix. Each table covers a single endpoint and is updated from support tickets at each release. Jump straight to the endpoint you're calling. ## Market API ### GET /prices | Symptom | Root cause | Fix | | ------------------------------------------------------------ | ------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------- | | 400 `Invalid srcToken` or `Invalid destToken` | Native ETH sent as `0x0` or lowercase `0xeee...e` | Use the mixed-case placeholder `0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE` | | 422 `Unsupported chain` | `network` not in the supported-chain list for the current API host | Hit `GET /chains` to confirm the live list; see [Chains & contracts](/resources/chains-and-contracts) | | `priceRoute.maxImpactReached: true` | Price impact exceeds the configured ceiling for this route | Reduce trade size, split into hops, or pass an explicit higher `maxImpact` if your product accepts the risk | | Stale `priceRoute` rejected by `POST /transactions/:network` | More than \~30s elapsed between quote and tx-build, route became invalid | Re-quote and pass the fresh `priceRoute` verbatim; never cache across user gestures | | 429 from the gateway | Rate-limited without a partner key, or partner-key tier exceeded | See [Authentication](/api-reference/authentication) to attach a partner key, or back off and retry | Updated from support tickets at each release. Last updated: 2026-05-15. ### POST /transactions/:network | Symptom | Root cause | Fix | | ------------------------------------------------------------ | ------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | 400 `Invalid priceRoute` or `Stale priceRoute` | `priceRoute` modified between quote and tx-build, or older than \~30s | Pass the `priceRoute` block from `GET /prices` verbatim; re-quote if more than \~30s elapsed | | Calldata reverts on-chain with `INSUFFICIENT_OUTPUT` | Slippage tolerance too tight for current market depth | Increase `slippage` (in bps) on the rebuild, or surface a higher tolerance to the user before retrying | | Calldata reverts with `TransferHelper: TRANSFER_FROM_FAILED` | ERC-20 allowance to the v6.2 router insufficient (or pointed at the legacy v5 router) | Approve the Augustus v6.2 router address — see [Chains & contracts](/resources/chains-and-contracts); migrating off v5 → [Augustus v5 → v6.2](/resources/migrations/augustus-v5-to-v6-2) | | `txData` gas estimate fails on the user's RPC | RPC gas estimation can't simulate the exact block conditions | Use the `gas` field returned in the response as a baseline + 15–25% headroom | | Calldata builds for the wrong chain | `network` path parameter mismatched against the `priceRoute.network` | Always derive `:network` from `priceRoute.network`, not from a client-side variable | | 422 `Partner not allowed` | Partner-key tier doesn't permit the requested fee/surplus configuration | Drop the disallowed param, or contact partnerships to upgrade the tier | Updated from support tickets at each release. Last updated: 2026-05-15. ## Delta API ### GET /quote | Symptom | Root cause | Fix | | --------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- | | 400 `Invalid srcToken` | Native ETH sent as `0x0` or lowercase `0xeee...e` | Use the mixed-case placeholder `0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE` | | Response has `market` instead of `delta` | `mode=ALL` and Market won the routing decision | Force `mode=DELTA` if Delta is required, or branch on `response.delta` vs `response.market` | | 400 `Slippage required` | `slippage` omitted on a Delta quote | Pass `slippage` in basis points (e.g. `100` = 1%) | | 422 `Unsupported chain` for Delta | `chainId` is supported by Market but Delta hasn't shipped on that chain yet | Check `GET /chains` for the Delta-enabled subset; see [Chains & contracts](/resources/chains-and-contracts) | | `delta` block present but `delta.partiallyFillable` is unexpectedly `false` | The pair / size combination doesn't have partial-fill liquidity from solvers | Reduce size, or design the UX around all-or-nothing fills for this pair | | `/orders/build` returns 400 after a successful quote | `delta` block mutated between calls (recomputed amounts, decoded/re-encoded) | Pass the `delta` object **verbatim** as `price`; `hmac` unchanged from the quote response | Updated from support tickets at each release. Last updated: 2026-05-15. ### POST /delta/orders/build | Symptom | Root cause | Fix | | --------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | 400 `Invalid price` after a fresh quote | The `delta` block from `GET /quote` was mutated, re-encoded, or re-stringified before submit | Pass the `delta` object **verbatim** as `price`. Don't run it through JSON normalizers, sorters, or schema validators | | 400 `Invalid hmac` | The `hmac` from the quote response was dropped, modified, or paired with a different `delta` | Always send the `hmac` paired with the exact `delta` returned from the same quote response | | EIP-712 typed-data signature is rejected by the order server | Wallet signed against a different chain id, verifying contract, or version | Verify `domain.chainId`, `domain.verifyingContract`, and `domain.name`/`version` match what `POST /delta/orders/build` returned — see [EIP-712 typed data reference](/delta/eip-712-typed-data-reference) | | Approval reverts before signing | Token approval granted to the Augustus router instead of the Delta contract | Approve the **Delta contract** as spender — it's the spender on Delta flows, not Augustus. See [Chains & contracts](/resources/chains-and-contracts) | | Build succeeds but downstream `/delta/orders` returns `expired` | Long delay between build and signature (user wandered off, app backgrounded) | Re-quote and rebuild when the user returns; treat order-server `expiry` as a hard ceiling, surface a countdown in your UI | | 400 `Permit / Permit2 required` | The token requires Permit or Permit2 and the build request didn't include the payload | Detect Permit/Permit2 capability up front; see [Permit & Permit2 patterns](/guides/permit-and-permit2-patterns) | Updated from support tickets at each release. Last updated: 2026-05-15. ### POST /delta/orders | Symptom | Root cause | Fix | | ------------------------------------------------- | ------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | | 400 `Invalid signature` | Signed payload doesn't match the `order` field byte-for-byte | Sign the exact `order` returned by `POST /delta/orders/build`. Don't re-sort, re-stringify, or re-encode | | 400 `Order expired` immediately | More than \~30s elapsed between build and submit | Submit the signed order within the validity window; if the user pauses, re-quote and rebuild | | 200 OK, but order stays at `pending` indefinitely | Solver auction returned no fill (size, pair, or chain conditions) | Poll `GET /delta/orders/:id`; if still pending past your SLA, cancel and re-quote — see [Order lifecycle & status codes](/delta/order-lifecycle-and-status-codes) | | Order transitions to `failed` post-acceptance | Allowance revoked, balance moved, or token-approval points at the wrong spender | Confirm allowance to the Delta contract spender persists for the order's full lifecycle — see [Chains & contracts](/resources/chains-and-contracts) | | `partialFill` order settles partial then stalls | Solver network couldn't source the remainder at the signed price | Decide whether to cancel and re-quote the remainder, or wait for the full validity window | | 200 OK but no order id returned | Client treated empty response as success; gateway response was actually a 5xx | Always check status and presence of `id`; retry on 5xx with idempotent re-submission of the same signed payload | Updated from support tickets at each release. Last updated: 2026-05-15. # Versioning policy Source: https://new-docs.velora.xyz/api-reference/versioning-policy How Velora versions APIs and SDKs — deprecation timeline and breaking-change policy. This page is a stub. Content coming soon. ## Parameters ## Examples ## Related pages # API integration Source: https://new-docs.velora.xyz/delta/api-integration Integrate the Delta API end-to-end — quoting, signing, submitting, tracking. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Crosschain Delta Source: https://new-docs.velora.xyz/delta/crosschain-delta Issue Delta orders that move value between chains in a single user signature. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # EIP-712 typed data reference Source: https://new-docs.velora.xyz/delta/eip-712-typed-data-reference Canonical EIP-712 typed data structure for signing Delta orders. This page is a stub. Content coming soon. ## Parameters ## Examples ## Related pages # How it works Source: https://new-docs.velora.xyz/delta/how-it-works From signed intent to on-chain settlement — the full Delta flow end-to-end. Delta separates **what the user wants** (the intent) from **how it gets executed** (the solver fill). The user signs once, off-chain. A competitive solver network on **Portikus** races to fill the order at the best price, then settles on-chain via the Delta contract. ## The flow at a glance ```mermaid theme={null} sequenceDiagram autonumber actor User participant DApp as Your app / SDK participant API as Velora API participant OS as Order Server participant Solvers as Solver network
(Portikus) participant Delta as Delta contract
0x...c96d User->>DApp: "Swap 1000 USDC for USDT" DApp->>API: GET /quote?mode=DELTA API-->>DApp: priceRoute + delta payload (hmac) DApp->>API: POST /delta/orders/build
(delta payload as `price`) API-->>DApp: EIP-712 typed data DApp->>User: Request signature User-->>DApp: ERC-2098 compact signature DApp->>API: POST /delta/orders
(order + signature) API->>OS: Persist signed order rect rgb(232, 245, 233) note over OS,Solvers: Off-chain auction OS->>Solvers: Broadcast order Solvers-->>OS: Competing fill quotes OS->>Solvers: Award winner end Solvers->>Delta: settle(order, signature, fillData) Delta-->>User: destToken delivered loop Until terminal status DApp->>API: GET /delta/orders/:id API-->>DApp: status = PENDING / EXECUTED / FAILED end ``` ## The five stages ### 1. Quote You call `GET /quote?mode=DELTA` (or `mode=ALL` to get both Market and Delta in one response). The API returns a `delta` payload containing the indicative price, the expected `destAmount`, the deadline, the partner-and-fee header, and an `hmac` you must pass through verbatim in step 2. ### 2. Build You `POST /delta/orders/build` with the entire `delta` object from step 1 as the `price` field. The API returns EIP-712 typed data — domain (`name=Portikus, version=2.0.0, verifyingContract=0x...c96d`), types, and the order struct to sign. Pass the `delta` payload **verbatim**. Mutating any field (including `hmac`) will cause the build call to reject. ### 3. Sign The user signs the typed data with their wallet. Delta uses **ERC-2098 compact signatures** (64 bytes, not 65). Most modern libraries — viem, ethers v6, wagmi — produce or accept compact sigs natively. The user pays **no gas** for this step; it's a pure off-chain message. ### 4. Auction You `POST /delta/orders` with the order + signature. The order server persists it and broadcasts to the **Portikus solver network**. Solvers compete on price and execution quality. The winning solver commits to fill the order with their own capital — they take on inventory and settlement risk in exchange for the spread. ### 5. Settle The winning solver calls `settle(...)` on the Delta contract (`0x0000000000bbF5c5Fd284e657F01Bd000933C96D`, same address on every supported chain). The contract verifies the signature, pulls `srcToken` from the user via the approved spender (the Delta contract itself), runs the fill, and delivers `destToken` to the user. You track progress via `GET /delta/orders/:id` until the order reaches a terminal status (`EXECUTED`, `EXPIRED`, or `FAILED`). ## Why this design Users sign off-chain. Solvers pay gas and recoup it from their margin. Orders are auctioned privately. There's no public mempool to sandwich. Solvers compete on price. The user always gets the best committed fill. User funds only leave the wallet when settlement succeeds on-chain. No partial loss state. ## Related pages * [Quickstart](/overview/why-velora#quickstart) — run the flow end-to-end with cURL. * [Order lifecycle & status codes](/delta/order-lifecycle-and-status-codes) — every status an order can reach. * [EIP-712 typed data reference](/delta/eip-712-typed-data-reference) — exact domain, types, and struct layout. * [Delta contract](/resources/chains-and-contracts) — on-chain entry point and per-chain addresses. # Order lifecycle & status codes Source: https://new-docs.velora.xyz/delta/order-lifecycle-and-status-codes Every state a Delta order can be in, what triggers transitions, and how to interpret status codes. This page is a stub. Content coming soon. ## Parameters ## Examples ## Related pages # Why Delta Source: https://new-docs.velora.xyz/delta/overview Delta is Velora's intent protocol — gasless, MEV-protected, Crosschain swaps that settle in one signature. Here's what makes it different from a regular swap. Delta is Velora's intent protocol. Instead of building, signing, and submitting an on-chain transaction yourself, you sign an off-chain **order** describing what you want — and a competitive network of solvers (Portikus) fills it on your behalf. ## What you get The user never pays gas. Solvers cover execution cost out of their margin. Orders are filled via private auction. No public mempool. No sandwich risk. One signed order can resolve across chains via bridge-aware solvers. No second tx. ## Delta vs a normal swap | | Normal swap (Market API) | Delta intent | | -------------- | ----------------------------- | -------------------------------------------- | | User signs | A transaction (on-chain tx) | An EIP-712 order (off-chain message) | | User pays gas | Yes | No | | MEV exposure | Public mempool — sandwichable | Private auction — solver competition | | Crosschain | Separate tx per chain | One signature, multi-chain settlement | | Fill guarantee | Best-effort routing | Solver commits at quote time | | Failure mode | Tx reverts | Order expires or is rejected — no funds lost | ## See it work The full lifecycle is four calls — quote, build, sign, submit — and then you poll for status: ```bash theme={null} # 1. Get a Delta quote curl "https://api.velora.xyz/quote?...&mode=DELTA&partner=my-app-name" # 2. Build the order (returns EIP-712 typed data) curl -X POST "https://api.velora.xyz/delta/orders/build" -d @price.json # 3. Sign the typed data with the user's wallet (ERC-2098 compact) # 4. Submit the signed order curl -X POST "https://api.velora.xyz/delta/orders" -d @signed.json # 5. Poll status curl "https://api.velora.xyz/delta/orders/:id" ``` Walk through the full flow in the **[Quickstart →](/overview/why-velora#quickstart)** ## When to use Delta vs Market * **Use Delta** when the user is swapping at meaningful size, when MEV is a concern, when gasless UX matters (mobile, social, wallet onboarding), or when the swap is Crosschain. * **Use the Market API** when you need atomic on-chain execution inside a larger transaction (composability), when the swap is tiny and the gas overhead doesn't matter, or when `mode=DELTA` returns no quote (Delta is BUY-side and native-source restricted). * **Use `mode=ALL`** in the quote endpoint to get both responses and pick at runtime. ## Next steps cURL the full lifecycle end-to-end. Order server, solver auction, settlement. One signature, multi-chain settlement. # Fees & monetization Source: https://new-docs.velora.xyz/faq/fees-and-monetization How fees work on Velora — for users and for partners. This page is a stub. Content coming soon. ## Common questions ## Related pages # Getting started Source: https://new-docs.velora.xyz/faq/getting-started Connect a wallet, pick a chain, and complete your first trade on Velora. This page is a stub. Content coming soon. ## Common questions ## Related pages # Limit orders Source: https://new-docs.velora.xyz/faq/limit-orders Common questions about creating, canceling, and filling limit orders. This page is a stub. Content coming soon. ## Common questions ## Related pages # Route availability Source: https://new-docs.velora.xyz/faq/route-availability Why a route may be unavailable and how to widen options. This page is a stub. Content coming soon. ## Common questions ## Related pages # Slippage & price impact Source: https://new-docs.velora.xyz/faq/slippage-and-price-impact Understand slippage tolerance, price impact, and how to tune both. This page is a stub. Content coming soon. ## Common questions ## Related pages # Token support Source: https://new-docs.velora.xyz/faq/token-support Which tokens are supported, how custom tokens work, and what to do about tax tokens. This page is a stub. Content coming soon. ## Common questions ## Related pages # Trading Source: https://new-docs.velora.xyz/faq/trading Common questions about swaps, slippage, and supported tokens. This page is a stub. Content coming soon. ## Common questions ## Related pages # Troubleshooting Source: https://new-docs.velora.xyz/faq/troubleshooting Unstick a transaction, speed up a swap, add custom tokens, and handle tax tokens. This page is a stub. Content coming soon. ## Common questions ## Related pages # CLI commands Source: https://new-docs.velora.xyz/for-agents/cli/commands Full reference for Velora CLI commands and flags. This page is a stub. Content coming soon. ## Parameters ## Examples ## Related pages # CLI examples Source: https://new-docs.velora.xyz/for-agents/cli/examples Worked examples of CLI-driven Velora workflows. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # CLI installation Source: https://new-docs.velora.xyz/for-agents/cli/installation Install and authenticate the Velora CLI. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # CLI overview Source: https://new-docs.velora.xyz/for-agents/cli/overview Velora CLI — an agent-friendly command line for quoting, swapping, and tracking. This page is a stub. Content coming soon. ## When to use this ## How it works ## Examples ## Related pages # Concepts & objects Source: https://new-docs.velora.xyz/for-agents/concepts-and-objects Core objects an agent reasons about — orders, quotes, intents, fills, status. This page is a stub. Content coming soon. ## When to use this ## How it works ## Examples ## Related pages # MCP available tools Source: https://new-docs.velora.xyz/for-agents/mcp-server/available-tools Every tool the Velora MCP server exposes, with arguments and return types. This page is a stub. Content coming soon. ## Parameters ## Examples ## Related pages # MCP examples Source: https://new-docs.velora.xyz/for-agents/mcp-server/examples Worked examples of MCP-driven Velora workflows. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # MCP server installation Source: https://new-docs.velora.xyz/for-agents/mcp-server/installation Install and configure the Velora MCP server in your AI tool of choice. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # MCP server overview Source: https://new-docs.velora.xyz/for-agents/mcp-server/overview Connect Claude, Cursor, and other MCP clients to the Velora MCP server. This page is a stub. Content coming soon. ## When to use this ## How it works ## Examples ## Related pages # Overview Source: https://new-docs.velora.xyz/for-agents/overview The Velora docs as an LLM runbook — Delta is intent-native, which makes agent integration first-class. This page is a stub. Content coming soon. ## When to use this ## How it works ## Examples ## Related pages # Crosschain swap + Aave deposit Source: https://new-docs.velora.xyz/for-agents/prompt-library/crosschain-aave-deposit Prompt an AI agent to wire a one-tx Crosschain swap-and-deposit into Aave via Delta. ## Outcome A single user signature kicks off a **Crosschain Delta** order: source token on chain A is swapped to USDC on chain B, then immediately deposited into Aave v3 on chain B. The user pays no gas on either side. ## Prompt ```text Claude Code theme={null} You are building a React component that runs a Velora Crosschain Delta flow with a post-fill action hook into Aave v3. Requirements: - The user holds (say) USDC on Polygon. They want to end up with aUSDC supplied to Aave v3 on Base. One signature. - Use Velora's Crosschain Delta API. Endpoints: `GET /quote` (with the Crosschain params per [Crosschain Delta docs]), `POST /delta/orders/build`, `POST /delta/orders`. - Always pass `partner=my-app-name` on every quote call (replace with the host app's partner-key string). - The solver fills on Base; you provide a post-fill calldata hook that calls `aavePool.supply(USDC, amount, user, 0)` against Aave v3's Base pool address. - Read the Aave v3 pool address from a constants file (do NOT hardcode in component code). - Surface clear status: "Quoting" → "Signing" → "Filling on Base" → "Depositing into Aave" → "Done". - On failure at any stage, return the user to a recoverable state. Cancel the Delta order if it hasn't filled. Reference these docs and follow them exactly: - https://docs.velora.xyz/delta/overview - https://docs.velora.xyz/delta/crosschain-delta - https://docs.velora.xyz/api-reference/delta/quote - https://docs.velora.xyz/api-reference/delta/orders-build - https://docs.velora.xyz/api-reference/delta/orders - https://docs.velora.xyz/delta/order-lifecycle-and-status-codes Do NOT chain the Aave deposit as a separate signed transaction — it must be part of the Delta fill. Do NOT skip the order-status poll between fill and deposit. ``` ```text Cursor theme={null} [Same prompt body as Claude Code above.] ``` ```text Codex theme={null} [Same prompt body as Claude Code above.] ``` ## End-state check * One signature from the user. No gas paid on either chain. * Aave on Base shows the supplied position under the user's address. # Prompt library Source: https://new-docs.velora.xyz/for-agents/prompt-library/index Curated, copy-paste prompts that get AI coding agents to ship Velora integrations on the first pass. Each prompt is verified at every SDK or API minor release. The prompt library is a curated set of prompts that take an AI coding agent (Claude Code, Cursor, Codex) from cold start to a working Velora integration in one shot. Each prompt lists its outcome, target client, and a `last-verified` date — DevRel re-verifies at each minor release. Prompts ship page-by-page on `main`. The table below previews what's coming. ## Available prompts | # | Slug | Outcome | | - | ------------------------- | --------------------------------------------------------------- | | 1 | `nextjs-market-swap` | Integrate Velora Market swap into a Next.js dApp (Wagmi + Viem) | | 2 | `nextjs-delta-swap` | Add Delta gasless swaps to a Next.js dApp | | 3 | `parallel-aggregators` | Run Velora alongside another aggregator and route per-quote | | 4 | `telegram-trading-bot` | Telegram bot: quote, slippage check, swap with MEV protection | | 5 | `crosschain-aave-deposit` | One-tx Crosschain swap + Aave deposit via Delta | | 6 | `mcp-client-from-scratch` | Build a Velora MCP client in 50 lines | | 7 | `widget-react-embed` | Embed the Velora Widget with custom theming | | 8 | `rfq-otc-flow` | Sign and fill an AugustusRFQ order off-chain | ## How to use 1. Open the prompt page for the outcome you want. 2. Copy the body for your client (Claude Code, Cursor, Codex — one tab per client in a ``). 3. Paste into a fresh agent session with the linked Velora docs as context. 4. Run the verifiable end-state check listed at the bottom of each prompt page. If a prompt drifts and stops producing working code, [open an issue](https://github.com/VeloraDEX) — DevRel re-verifies at every minor release but real-world drift between releases is what we want to hear about. # Velora MCP client in 50 lines Source: https://new-docs.velora.xyz/for-agents/prompt-library/mcp-client-from-scratch Prompt an AI agent to build a minimal MCP client against the Velora MCP server. ## Outcome A minimal MCP client (≤50 lines of TypeScript) that connects to the Velora MCP server, lists available tools, and runs a single end-to-end `quote → swap` flow via tool calls. ## Prompt ```text Claude Code theme={null} You are building a tiny standalone MCP client in TypeScript using the `@modelcontextprotocol/sdk` package. Requirements: - Connect to the Velora MCP server (transport and endpoint per /for-agents/mcp-server/installation). - After connection, call `tools/list` and print the available tools. - Run a `quote` tool call for 1 ETH → USDC on Ethereum mainnet with `partner=my-app-name`, then a `swap` tool call against the resulting quote. - Print every tool result. Exit cleanly when the swap returns success or terminal failure. - Total file size: ≤ 50 lines, excluding imports. Reference these docs and follow them exactly: - https://docs.velora.xyz/for-agents/mcp-server/overview - https://docs.velora.xyz/for-agents/mcp-server/installation - https://docs.velora.xyz/for-agents/mcp-server/available-tools - https://docs.velora.xyz/for-agents/mcp-server/examples Do NOT hardcode tool schemas — read them from `tools/list` and use the response shape at runtime. ``` ```text Cursor theme={null} [Same prompt body as Claude Code above.] ``` ```text Codex theme={null} [Same prompt body as Claude Code above.] ``` ## End-state check * The script runs end-to-end and prints a successful `swap` result. * `wc -l` on the source file (sans imports) reports ≤ 50. # Next.js Delta swap Source: https://new-docs.velora.xyz/for-agents/prompt-library/nextjs-delta-swap Prompt an AI agent to add Velora Delta gasless swaps to a Next.js dApp. ## Outcome A Next.js 14 page that runs the full **Delta** flow: quote → build → EIP-712 sign → submit → poll. The user pays no gas; the solver network fills. ## Prompt ```text Claude Code theme={null} You are working in a Next.js 14 App Router project with Wagmi v2 and Viem already configured. Build a `/swap-gasless` page that lets the user place a Velora Delta intent for any ERC-20 → any ERC-20. Requirements: - Use the Velora Delta REST API at `https://api.velora.xyz`. Endpoints: `GET /quote` (with `mode=DELTA`), `POST /delta/orders/build`, `POST /delta/orders`, `GET /delta/orders/:id`. - Always pass `partner=my-app-name` on every quote call (replace `my-app-name` with the host app's partner-key string). - For the native ETH placeholder, use `0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE`. - Always include `slippage` (basis points) in the quote — omitting it returns 400. - Pass the `delta` block returned by the quote verbatim to `/delta/orders/build` as `price`. Do not normalize, sort, or re-stringify it. Include the `hmac` from the same quote response. - Use Viem's `signTypedData` to sign the EIP-712 payload returned by `/delta/orders/build`. Then submit to `/delta/orders`. - Poll `GET /delta/orders/:id` and display lifecycle states (`pending` → `filled` / `failed`). - Token approvals must be granted to the **Delta contract** (not Augustus). The address is per-chain — fetch from /resources/chains-and-contracts or read it from the typed-data `domain.verifyingContract`. Reference these docs and follow them exactly: - https://docs.velora.xyz/delta/overview - https://docs.velora.xyz/delta/how-it-works - https://docs.velora.xyz/api-reference/delta/quote - https://docs.velora.xyz/api-reference/delta/orders-build - https://docs.velora.xyz/api-reference/delta/orders - https://docs.velora.xyz/delta/eip-712-typed-data-reference - https://docs.velora.xyz/delta/order-lifecycle-and-status-codes Do NOT mutate the `delta` block between quote and build. Do NOT grant approval to Augustus — Delta has its own spender contract. ``` ```text Cursor theme={null} [Same prompt body as Claude Code above.] ``` ```text Codex theme={null} [Same prompt body as Claude Code above.] ``` ## End-state check * The user signs **once** (EIP-712 typed data) and pays **no gas**. * The order transitions through `pending` → `filled` and the user receives the `destToken`. * The token approval was granted to the Delta contract address from the typed-data domain, not Augustus. # Next.js Market swap Source: https://new-docs.velora.xyz/for-agents/prompt-library/nextjs-market-swap Prompt an AI agent to integrate Velora Market swap into a Next.js dApp using Wagmi and Viem. ## Outcome A Next.js 14 (App Router) page with a fully working **Velora Market** swap: quote → build calldata → sign and send via Wagmi/Viem. The user signs one transaction. The route uses Augustus v6.2 against the chain selected by their connected wallet. ## Prompt ```text Claude Code theme={null} You are working in a Next.js 14 App Router project with Wagmi v2 and Viem already configured. Build a `/swap` page that lets the user swap any ERC-20 → any ERC-20 on Velora's Market API. Requirements: - Use the Velora Market REST API at `https://api.velora.xyz`. Endpoints: `GET /prices` and `POST /transactions/:network`. - Always pass `partner=my-app-name` on every quote call (replace `my-app-name` with the host app's partner-key string). - For the native ETH placeholder, use `0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE` (mixed-case — lowercase is rejected). - Quote first, then call `/transactions/:network` with the `priceRoute` returned by the quote, passed verbatim. - Use Viem's `useWalletClient` to send the transaction. Read `chainId` from Wagmi. - Handle the three real failure modes: stale `priceRoute` (re-quote on submit), `INSUFFICIENT_OUTPUT` revert (increase slippage and retry), and ERC-20 allowance missing (prompt approval to the v6.2 router from the quote response's `contractAddress` field). - Show the user `srcUSD`, `destUSD`, `gasCostUSD`, and `partnerFee` from the response before they confirm. Reference these docs and follow them exactly: - https://docs.velora.xyz/overview/why-velora#quickstart - https://docs.velora.xyz/api-reference/market/prices - https://docs.velora.xyz/api-reference/market/transactions - https://docs.velora.xyz/guides/permit-and-permit2-patterns Do NOT invent endpoint paths. Do NOT cache `priceRoute` longer than 30 seconds. Always approve the address returned in `priceRoute.contractAddress` (not a hardcoded address). ``` ```text Cursor theme={null} [Same prompt body as Claude Code above. Cursor reads workspace docs by default — if you have the Velora docs cloned, point Cursor at them via @docs.] ``` ```text Codex theme={null} [Same prompt body as Claude Code above. With Codex, supply the four reference URLs as `--allowed-domains` and run the prompt in workspace-write mode.] ``` ## End-state check * A signed swap transaction lands on-chain in your wallet's history. * `priceRoute.version` on the most recent quote is `"6.2"`. * The token approval (if needed) was granted to `priceRoute.contractAddress`, not to a hardcoded address. # Run Velora alongside another aggregator Source: https://new-docs.velora.xyz/for-agents/prompt-library/parallel-aggregators Prompt an AI agent to wire Velora as a parallel quote source and route per-quote. ## Outcome A backend service that **fans out a single user swap intent** to Velora and one other aggregator, compares the quotes, and returns the winner. Velora is queried via `mode=ALL` so both Market and Delta paths compete in the same response. ## Prompt ```text Claude Code theme={null} You are extending an existing TypeScript backend that already wires one DEX aggregator (assume 1inch or 0x). Add Velora as a parallel quote source. Requirements: - Velora endpoint: `GET https://api.velora.xyz/quote` with `mode=ALL` and `partner=my-app-name` (replace with the host app's partner-key string). The response may contain `market` (Market route) and/or `delta` (Delta intent) — pick the better one within the Velora result, then compete it against the other aggregator's quote. - Compare on `destUSD` (or `destAmount` normalized to a common token) net of `gasCostUSD` and `partnerFee`. - Fan out in parallel; respect a hard 800ms budget per quote source; fall back gracefully if one source times out. - For the Velora native-ETH placeholder use `0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE` (mixed case). - If Velora wins via Delta, return both the `delta` block and `hmac` to the caller so they can sign and submit. If via Market, return the `market` block (same shape as `/prices`'s `priceRoute`). Reference these docs and follow them exactly: - https://docs.velora.xyz/overview/why-velora - https://docs.velora.xyz/api-reference/market/prices - https://docs.velora.xyz/api-reference/delta/quote Do NOT race-update shared state across the two aggregators' callbacks. Do NOT fall back silently to the slower source if the budget is exceeded — surface a clear error. ``` ```text Cursor theme={null} [Same prompt body as Claude Code above.] ``` ```text Codex theme={null} [Same prompt body as Claude Code above.] ``` ## End-state check * A side-by-side comparison log shows both aggregators quoting the same trade within the 800ms budget. * When Velora's Delta path wins on a large trade, the response carries the `delta` block + `hmac` ready to sign. # AugustusRFQ OTC flow Source: https://new-docs.velora.xyz/for-agents/prompt-library/rfq-otc-flow Prompt an AI agent to sign and fill an AugustusRFQ order off-chain. ## Outcome A pair of TypeScript scripts: one for the **maker** (constructs and signs an AugustusRFQ order off-chain, supports partial fills) and one for the **taker** (validates the signature and submits the fill on-chain). ## Prompt ```text Claude Code theme={null} You are building two CLI scripts in TypeScript using Viem. Maker script (`make-order.ts`): - Constructs an AugustusRFQ limit order: sell `srcAmount` of `srcToken` for at least `destAmount` of `destToken`, expires at a configurable timestamp, partial fills allowed. - Signs the EIP-712 typed data with the maker's private key. - Outputs the order JSON + signature to stdout (the taker can pick this up via stdin or a side-channel). Taker script (`fill-order.ts`): - Reads the maker's order + signature from stdin. - Validates the signature recovers to the maker's address. - Approves `srcToken` and `destToken` to the AugustusRFQ contract if not already approved. - Submits the fill on-chain via the AugustusRFQ `fillOrderNFT` or equivalent method, supporting partial fill `fillAmount`. Requirements: - Read the AugustusRFQ contract address per chain from `/resources/chains-and-contracts`. - Validate `order.expiry > now()` before submitting. - Catch and surface the common revert reasons (insufficient allowance, expired, already filled). Reference these docs and follow them exactly: - https://docs.velora.xyz/api-reference/rfq/overview - https://docs.velora.xyz/resources/chains-and-contracts - https://docs.velora.xyz/overview/security/audits/augustus-rfq Do NOT submit a fill without re-validating signature and expiry against the on-chain block timestamp. Do NOT skip the partial-fill amount check (taker could fill more than the maker intended otherwise). ``` ```text Cursor theme={null} [Same prompt body as Claude Code above.] ``` ```text Codex theme={null} [Same prompt body as Claude Code above.] ``` ## End-state check * Maker can sign offline; the taker fills on-chain successfully. * A partial fill (e.g. 50%) settles correctly; the remaining 50% is still fillable by a different taker. * Expired or double-fill attempts revert cleanly with the expected error. # Telegram trading bot Source: https://new-docs.velora.xyz/for-agents/prompt-library/telegram-trading-bot Prompt an AI agent to build a Telegram bot that quotes and executes Velora swaps with MEV protection. ## Outcome A Telegram bot in TypeScript that lets a user `/buy ` or `/sell `, quotes via Velora `mode=ALL`, surfaces slippage and price impact, and executes via Delta when available (gasless, MEV-protected). Falls back to Market with a conservative slippage when Delta is unavailable. ## Prompt ```text Claude Code theme={null} You are building a Telegram bot in TypeScript using `grammy` or `telegraf`. The bot has access to a user's connected EVM wallet via a custodied key tied to chat id (assume the wallet infra is solved; just call `signMessage` and `signTransaction`). Implement `/buy ` and `/sell `. Requirements: - Resolve token addresses against Velora's tokens endpoint (`/tokens/:network`). - Quote with `mode=ALL` at `GET https://api.velora.xyz/quote`. Always pass `partner=my-app-name` (replace with the bot's partner-key string). Native ETH placeholder: `0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE`. - Show the user `destAmount`, `destUSD`, `gasCostUSD`, and `priceImpact` BEFORE asking them to confirm. - If `response.delta` exists, prefer the Delta path: build → sign EIP-712 → submit → poll. The user pays no gas. - If only `response.market` exists, fall back to Market with `slippage=100` (1%) and warn the user about MEV exposure on larger trades (size > $5k). - Include the `priceImpact` warning at >2%. Reference these docs and follow them exactly: - https://docs.velora.xyz/overview/why-velora - https://docs.velora.xyz/api-reference/market/prices - https://docs.velora.xyz/api-reference/delta/quote - https://docs.velora.xyz/api-reference/delta/orders-build - https://docs.velora.xyz/api-reference/delta/orders - https://docs.velora.xyz/guides/mev-protection-patterns - https://docs.velora.xyz/delta/order-lifecycle-and-status-codes Do NOT auto-execute trades without explicit user confirmation. Do NOT swallow Delta polling errors silently. ``` ```text Cursor theme={null} [Same prompt body as Claude Code above.] ``` ```text Codex theme={null} [Same prompt body as Claude Code above.] ``` ## End-state check * A `/buy` flow on a \$1k trade routes through Delta and settles gaslessly within the lifecycle window. * On a tiny test trade where Delta returns no quote, Market is used with the slippage and MEV warning surfaced. # Velora Widget — React embed with theming Source: https://new-docs.velora.xyz/for-agents/prompt-library/widget-react-embed Prompt an AI agent to embed the Velora Widget into a React app with custom theming. ## Outcome A React component that mounts the Velora Widget with the host app's design tokens (colors, typography, border radius). No iframe — direct in-app embed. Partner key wired so swaps attribute fee-share to the host. ## Prompt ```text Claude Code theme={null} You are integrating the Velora Widget into an existing React 18 app. Requirements: - Install `@velora-dex/widget`. - Mount the widget at `/swap` route via React Router or Next.js routing. - Pass `chainId`, `partner` (a partner-key string from env, e.g. `my-app-name`), and optional `defaultSrcToken` / `defaultDestToken`. - Theme the widget: pass the host app's primary/secondary colors, fontFamily, and borderRadius through the widget's theming props (see `widget/customize`). - Subscribe to widget events (swap start, swap success, swap error) and pipe them into the host app's analytics module. Reference these docs and follow them exactly: - https://docs.velora.xyz/widget/install - https://docs.velora.xyz/widget/configure - https://docs.velora.xyz/widget/customize - https://docs.velora.xyz/widget/events-and-callbacks - https://docs.velora.xyz/widget/monetize Do NOT embed via iframe if the host app is also React — use the direct embed. Do NOT hardcode the partner key in client code; load it from env. ``` ```text Cursor theme={null} [Same prompt body as Claude Code above.] ``` ```text Codex theme={null} [Same prompt body as Claude Code above.] ``` ## End-state check * The widget visually matches the host app's design tokens. * A successful test swap fires the host's analytics events with the expected payload. * The partner key is present at runtime but not in the source tree. # Prompt patterns Source: https://new-docs.velora.xyz/for-agents/prompt-patterns Battle-tested prompt patterns for getting LLMs to reason reliably about Velora. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Code samples Source: https://new-docs.velora.xyz/for-agents/quickstart/code-samples End-to-end agent code samples — TypeScript and Python. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Decision tables Source: https://new-docs.velora.xyz/for-agents/quickstart/decision-tables If the user says X, call Y — flat decision tables for routing user intent to API actions. This page is a stub. Content coming soon. ## Parameters ## Examples ## Related pages # Five-call recipe Source: https://new-docs.velora.xyz/for-agents/quickstart/five-call-recipe The five API calls that cover 95% of agent workflows — copy-paste with annotations. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Data schemas Source: https://new-docs.velora.xyz/for-agents/reference/data-schemas JSON Schema reference for every object an agent will encounter. This page is a stub. Content coming soon. ## Parameters ## Examples ## Related pages # Endpoint specs Source: https://new-docs.velora.xyz/for-agents/reference/endpoint-specs Compact endpoint specs an LLM can read inline — request, response, side effects. This page is a stub. Content coming soon. ## Parameters ## Examples ## Related pages # Error playbooks Source: https://new-docs.velora.xyz/for-agents/reference/error-playbooks Every API error mapped to an agent recovery action. This page is a stub. Content coming soon. ## Parameters ## Examples ## Related pages # Partial completion Source: https://new-docs.velora.xyz/for-agents/workflows/partial-completion Handle partially filled Delta orders and aggregator multi-step swaps gracefully. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Status & recovery Source: https://new-docs.velora.xyz/for-agents/workflows/status-and-recovery Poll status, detect failures, and recover from partial state without user intervention. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Token approvals Source: https://new-docs.velora.xyz/for-agents/workflows/token-approvals Handle ERC-20 approvals and Permit2 in agent flows. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Transaction execution Source: https://new-docs.velora.xyz/for-agents/workflows/transaction-execution Build, sign, send, and confirm transactions from an agent loop. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Debug failed transactions Source: https://new-docs.velora.xyz/guides/debug-failed-transactions Diagnose why a transaction failed and pick the right recovery action. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Gas estimation & sponsorship Source: https://new-docs.velora.xyz/guides/gas-estimation-and-sponsorship Estimate gas accurately and sponsor user gas via paymaster patterns. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Handling stuck orders Source: https://new-docs.velora.xyz/guides/handling-stuck-orders Unstick limit orders and Delta intents that didn't settle. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Intermediate token routing Source: https://new-docs.velora.xyz/guides/intermediate-token-routing How Velora chooses intermediate tokens and how to override the default routing. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # MEV protection patterns Source: https://new-docs.velora.xyz/guides/mev-protection-patterns Patterns to harden Velora swaps against sandwiches and frontrunning. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Optimizing for latency Source: https://new-docs.velora.xyz/guides/optimizing-for-latency Cut quote-to-confirmation latency — caching, RPC selection, and parallel calls. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Permit / Permit2 patterns Source: https://new-docs.velora.xyz/guides/permit-and-permit2-patterns Gasless approvals via EIP-2612 Permit and Uniswap Permit2. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # How Velora works Source: https://new-docs.velora.xyz/overview/how-velora-works The Velora stack in one diagram — aggregation, Delta intents, Augustus router, Portikus settlement. This page is a stub. Content coming soon. ## When to use this ## How it works ## Examples ## Related pages # Product stack Source: https://new-docs.velora.xyz/overview/product-stack Decide between the API, SDK, Widget, and Delta — what each is for and when to use it. This page is a stub. Content coming soon. ## When to use this ## How it works ## Examples ## Related pages # Audits Source: https://new-docs.velora.xyz/overview/security/audits Velora's smart-contract audits and security approach across Augustus, RFQ, and supporting infrastructure. Every line of Velora's on-chain code goes through independent third-party audits before reaching production. This page lists every audit on record, plus the wider security posture — formal verification, monitoring, and Web2 testing. ## Smart-contract audits | Surface | Auditors | Notes | Detail | | ------------- | --------------------------------------------- | ------------------------------------------------------------------------------- | ------------------------------------------------------ | | Augustus v6.2 | 3 independent firms | Refinements to fee-claiming on top of v6.1; prior v6.1 audits remain applicable | [v6.2 audits](/overview/security/audits/augustus-v6-2) | | Augustus v6.1 | Certora, Hexens, Peckshield, Hacken, Astrasec | First DEX aggregator with formal verification (Certora) | [v6.1 audits](/overview/security/audits/augustus-v6-1) | | Augustus v5 | Independent auditors | Production-grade aggregator router | [v5 audits](/overview/security/audits/augustus-v5) | | Augustus RFQ | Independent auditor | Fungible-token RFQ contracts | [RFQ audits](/overview/security/audits/augustus-rfq) | Audit report PDFs are currently hosted on the legacy `developers.velora.xyz` site. They will be mirrored into this repo as the migration completes. ## Web3 security ### Independent audits Every contract that handles user funds — Augustus router, Delta settlement, Portikus, RFQ — is reviewed by at least one independent security firm before deployment. Reports are publicly disclosed. ### Formal verification Augustus v6.1 underwent **formal verification by Certora**, mathematically proving correctness for critical invariants. To our knowledge, ParaSwap was the first DEX aggregator to ship a formally-verified router. ### Continuous monitoring Live monitoring on production contracts detects abnormal flows, suspicious transaction patterns, and unexpected state transitions. Emergency pause mechanisms are in place for critical surfaces. ## Web2 security Annual third-party penetration testing covers the Velora API, the partner portal, and supporting backend infrastructure. ## Reporting a vulnerability Found something? Email [security@velora.xyz](mailto:security@velora.xyz) with a clear description, reproduction steps, affected surfaces, and your assessment of impact. Do not file public issues or post details on social media until the team has acknowledged the report and coordinated disclosure. ## Related pages * [Augustus v6.2 audits](/overview/security/audits/augustus-v6-2) * [Augustus v6.1 audits](/overview/security/audits/augustus-v6-1) * [Chains & contracts](/resources/chains-and-contracts) # Augustus RFQ audits Source: https://new-docs.velora.xyz/overview/security/audits/augustus-rfq Independent audit of the Augustus RFQ contracts for fungible-token limit orders. The Augustus RFQ contracts — which power fungible-token limit orders on Velora — were audited by an independent security firm. ## Audits RFQ contracts security review Auditor firm name will be added once confirmed with the team. Report PDF is currently hosted on the legacy `developers.velora.xyz` site. ## Scope The RFQ audit covers the Augustus RFQ contract suite for fungible-token limit orders. NFT settlement paths have been removed from production and are out of scope. ## Related pages * [Audits overview](/overview/security/audits) * [Augustus RFQ API](/api-reference/rfq/overview) * [Limit orders](/overview/trading-concepts/limit-orders) # Augustus v5 audits Source: https://new-docs.velora.xyz/overview/security/audits/augustus-v5 Independent audits of the Augustus v5 aggregator router. Augustus v5 — the production aggregator router prior to v6 — was reviewed by independent security firms before deployment. ## Audits v5 security review v5 security review Auditor firm names will be added once confirmed with the team. Report PDFs are currently hosted on the legacy `developers.velora.xyz` site. ## Scope Augustus v5 audits cover the v5 router, fee logic, and supported swap methods. ## Related pages * [Augustus v6.1 audits](/overview/security/audits/augustus-v6-1) * [Audits overview](/overview/security/audits) * [Chains & contracts](/resources/chains-and-contracts) # Augustus v6.1 audits Source: https://new-docs.velora.xyz/overview/security/audits/augustus-v6-1 Five independent audits plus formal verification by Certora — a first for DEX aggregators. Augustus v6.1 went through one of the most comprehensive audit programs in DEX aggregator history: five independent firms reviewed the contracts, and Certora delivered a formal verification — making ParaSwap the first DEX aggregator to ship a formally-verified router. ## Audits **Formal verification.** Mathematical proofs of critical contract invariants — the first DEX aggregator formal-verification. Independent security review of the Augustus v6.1 contract suite. Independent security review of the Augustus v6.1 contract suite. Independent security review of the Augustus v6.1 contract suite. Independent security review of the Augustus v6.1 contract suite. ## Formal verification Certora's formal verification proves that core invariants of Augustus v6.1 hold for *every* possible input — not just the ones a manual auditor tested. This is the strongest correctness guarantee available short of a full mathematical proof of the whole system, and at the time it was a first for any DEX aggregator. ## Scope The five-firm audit set covered the full Augustus v6.1 router, fee distribution, partner integrations, and supported swap methods. ## Related pages * [Augustus v6.2 audits](/overview/security/audits/augustus-v6-2) * [Augustus v5 audits](/overview/security/audits/augustus-v5) * [Audits overview](/overview/security/audits) # Augustus v6.2 audits Source: https://new-docs.velora.xyz/overview/security/audits/augustus-v6-2 Independent audits for Augustus v6.2 — fee-claiming refinements on top of the v6.1 audit baseline. Augustus v6.2 refines the partner fee-claiming flow on top of v6.1 with minimal contract surface changes. The [v6.1 audits](/overview/security/audits/augustus-v6-1) therefore remain applicable; three additional independent firms reviewed the v6.2 delta. ## Audits v6.2 review — independent third-party audit v6.2 review — independent third-party audit v6.2 review — independent third-party audit Auditor firm names for v6.2 will be added once confirmed with the team. Report PDFs are currently hosted on the legacy `developers.velora.xyz` site. ## Scope Augustus v6.2 audits focused on the fee-claiming flow changes since v6.1. All other invariants are covered by the [v6.1 audit set](/overview/security/audits/augustus-v6-1). ## Related pages * [Augustus v6.1 audits](/overview/security/audits/augustus-v6-1) * [Audits overview](/overview/security/audits) * [Chains & contracts](/resources/chains-and-contracts) # Crosschain swaps Source: https://new-docs.velora.xyz/overview/trading-concepts/crosschain-swaps Move value between chains in a single user signature using Delta crosschain orders. This page is a stub. Content coming soon. ## When to use this ## How it works ## Examples ## Related pages # Limit orders Source: https://new-docs.velora.xyz/overview/trading-concepts/limit-orders Signed orders, maker/taker flow, and on-chain settlement via Augustus RFQ. This page is a stub. Content coming soon. ## When to use this ## How it works ## Examples ## Related pages # Slippage, gas & MEV Source: https://new-docs.velora.xyz/overview/trading-concepts/slippage-gas-and-mev How Velora handles slippage tolerance, gas estimation, and MEV protection. This page is a stub. Content coming soon. ## When to use this ## How it works ## Examples ## Related pages # Swaps Source: https://new-docs.velora.xyz/overview/trading-concepts/swaps How a swap moves through Velora — quote, route, signature, settlement. This page is a stub. Content coming soon. ## When to use this ## How it works ## Examples ## Related pages # Transaction lifecycle Source: https://new-docs.velora.xyz/overview/trading-concepts/transaction-lifecycle End-to-end lifecycle of a Velora trade — from quote request to on-chain confirmation. This page is a stub. Content coming soon. ## When to use this ## How it works ## Examples ## Related pages # Who uses Velora Source: https://new-docs.velora.xyz/overview/who-uses-velora Velora at a glance — cumulative volume, supported chains, liquidity sources, and the wallets and apps shipping on it today. Velora is one of the longest-running and highest-volume execution venues in DeFi. The numbers below capture the scale of the network you're integrating against.
\$150B+
Cumulative trading volume
10+
EVM chains supported
100+
DEXs and liquidity sources
5+ years
Production since 2020 (as ParaSwap)
## Scope of execution * **Market aggregation.** Best price across every DEX, AMM, and on-chain liquidity venue Velora supports — across one chain or many. * **Delta intents.** Gasless, signature-based swaps filled by a competitive solver network (Portikus). MEV-protected by construction. * **Augustus RFQ.** On-chain limit orders and OTC for ERC-20 with optional partial fills. * **Crosschain.** Single-signature Delta orders that resolve across chains via bridge-aware solvers. ## Heritage Velora launched in 2020 under the name ParaSwap. The protocol rebranded to Velora in 2025 alongside the migration from PSP to VLR (the network's only token). The execution stack, contract addresses, and core API surface continue uninterrupted — same engine, new name. ## Audited The Augustus router (v6.2, v6.1, v5) and AugustusRFQ have been audited by multiple top-tier security firms including Certora formal verification. See [Security → Audits](/overview/security/audits) for the full list. ## Selected integrations Velora powers swap execution inside some of the most-used wallets, aggregators, and DeFi applications. Routing inside the MetaMask Swaps experience. Hardware-wallet-native swaps via Velora's Market API. In-app swap routing across EVM chains. Portfolio app with Velora-powered swaps and bridges. This page is illustrative. The canonical, up-to-date integration list lives at [velora.xyz/integrations](https://velora.xyz). Logos and partner status here should not be taken as endorsements. ## Building on Velora? * **Aggregators & wallets** → [Why Velora](/overview/why-velora#quickstart) * **AI agents** → [For Agents](/for-agents/overview) If you ship something on Velora, [tell us](mailto:support@velora.xyz) and we'll add you here. Get a partner key (no rate limits, fee-share enabled) by emailing [partnerships@velora.xyz](mailto:partnerships@velora.xyz). # Why Velora Source: https://new-docs.velora.xyz/overview/why-velora Velora is best execution across 10+ EVM chains — quote, swap, and gasless intents from one API, SDK, or Widget. Ship your first swap in 60 seconds. Velora is a DEX aggregator and intents protocol. One integration gives you: * **Market routing** — best price across every DEX, AMM, and bridge on every chain Velora supports (10+ EVM chains). * **Delta intents** — gasless, MEV-protected swaps filled by a competitive solver network. Single signature. * **Crosschain** — Delta orders that resolve across chains via bridge-aware solvers. * **Augustus RFQ** — on-chain limit orders and OTC for ERC-20, with optional partial fills. You can pick a single surface or run them side by side. The Market API exposes `GET /prices` for direct aggregator routing; the Delta API exposes `GET /quote`, which accepts a `mode` (`ALL`, `DELTA`, `MARKET`) and can return a `delta` block, a `market` block (same shape as `/prices`'s `priceRoute`), or both — letting you pick which to execute from a single call. ## Choose your integration | You want to… | Use | Time to first swap | | ------------------------------------------ | ----------------------------------------------------------------------------------------------------------- | ------------------ | | Maximum control, any language, any backend | [Market API](/api-reference/market/overview) / [Delta API](/api-reference/delta/overview) | \~60 seconds | | Type-safe TypeScript, your own UI | [@velora-dex/sdk](/sdk/install) | \~5 minutes | | Drop-in UI, zero design work | [@velora-dex/widget](/widget/install) | \~10 minutes | | Crosschain, gasless, MEV-protected fills | [Delta](/delta/overview) (via API or SDK) | \~10 minutes | | AI agent / LLM integration | [MCP server](/for-agents/mcp-server/overview) + [five-call recipe](/for-agents/quickstart/five-call-recipe) | \~5 minutes | ## Quickstart Get a quote for 1 ETH → USDC on Ethereum mainnet. `mode=ALL` returns the Market route and the Delta intent side-by-side in a single response, and you pick which to execute. ```bash Market (cURL) theme={null} curl -s "https://api.velora.xyz/prices" \ --data-urlencode "srcToken=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE" \ --data-urlencode "destToken=0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48" \ --data-urlencode "amount=1000000000000000000" \ --data-urlencode "srcDecimals=18" \ --data-urlencode "destDecimals=6" \ --data-urlencode "side=SELL" \ --data-urlencode "network=1" \ --data-urlencode "userAddress=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045" \ --data-urlencode "partner=my-app-name" \ -G | jq ``` ```bash Delta (cURL) theme={null} curl -s "https://api.velora.xyz/quote" \ --data-urlencode "srcToken=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE" \ --data-urlencode "destToken=0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48" \ --data-urlencode "amount=1000000000000000000" \ --data-urlencode "srcDecimals=18" \ --data-urlencode "destDecimals=6" \ --data-urlencode "side=SELL" \ --data-urlencode "chainId=1" \ --data-urlencode "mode=DELTA" \ --data-urlencode "userAddress=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045" \ --data-urlencode "partner=my-app-name" \ -G | jq ``` ```ts SDK (TypeScript) theme={null} import { constructSimpleSDK } from '@velora-dex/sdk'; const sdk = constructSimpleSDK({ chainId: 1, fetch }); const quote = await sdk.quote.getQuote({ srcToken: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE', // ETH destToken: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48', // USDC amount: '1000000000000000000', // 1 ETH srcDecimals: 18, destDecimals: 6, side: 'SELL', mode: 'ALL', userAddress: '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045', partner: 'my-app-name', }); if ('delta' in quote) { // gasless path — sign and submit via /delta/orders } else { // calldata path — submit `market` to /transactions } ``` ```tsx Widget (React) theme={null} import { VeloraWidget } from '@velora-dex/widget'; export default function SwapPage() { return ( ); } ``` `GET /prices` returns a `priceRoute` (calldata-ready against Augustus v6.2). `GET /quote?mode=DELTA` returns a `delta` block (sign with EIP-712, submit to `/delta/orders`). `GET /quote?mode=ALL` returns both — as `response.market` (Market route) and `response.delta` (Delta intent) — and you pick which to execute. ## Next steps Type-safe TypeScript wrapper for quote → build → sign → submit. Embeddable React component or vanilla iframe. Gasless, MEV-protected, single-signature swap. All endpoints work without a partner key for low-volume testing. To unlock production rate limits and fee-sharing, see [Authentication & partner key](/api-reference/authentication). # Chains & contracts Source: https://new-docs.velora.xyz/resources/chains-and-contracts Canonical reference for Augustus, Delta, Portikus, and AugustusRFQ contract addresses across every supported EVM chain. This page is the single source of truth for contract addresses across Velora's stack. Every other page links here rather than inlining addresses, with one exception: failure-mode rows on API reference pages may cite a specific deployed address inline when the address is the actual diagnostic. This page is a stub. The full per-chain address table — Augustus v6.2, Augustus v6.1, Augustus v5, Delta, Portikus settlement, AugustusRFQ — will land before the v3 docs go live. For the up-to-date list today, see the [open-source contracts repo](https://github.com/VeloraDEX) or contact [support@velora.xyz](mailto:support@velora.xyz). ## Supported chains Velora supports the following EVM networks. Each chain has Augustus v6.2 (Market routing) deployed; Delta and AugustusRFQ availability varies — see the per-chain table below when populated. * Ethereum (1) * Optimism (10) * BNB Chain (56) * Polygon (137) * Base (8453) * Arbitrum One (42161) * Avalanche (43114) * Polygon zkEVM (1101) * Sonic (146) * Unichain (130) The authoritative supported-chain list is queryable at runtime via `GET /chains` on the Market API. Code should treat this page as a human-readable index and `/chains` as the runtime source of truth. ## Contracts ### Augustus v6.2 The Market router. All Market `POST /transactions` calldata targets the Augustus v6.2 contract on the requested chain. ### Augustus v6.1, v5 Legacy router versions. Still operational but new integrations should target v6.2. Calldata returned by the Market API automatically uses v6.2 unless overridden. ### Delta contract On-chain entry point that validates signed Delta orders and dispatches settlement to Portikus solvers. The Delta contract is the spender on EIP-712 typed-data approvals — token approvals for Delta flows must be granted to this address (not Augustus). ### Portikus settlement The solver-facing settlement infrastructure. Solvers execute fills against Portikus; the Delta contract reconciles outcomes back to the user. ### AugustusRFQ On-chain limit-order and OTC contract. Supports partial fills and bilateral signed orders. ## Related * [Market API → Overview](/api-reference/market/overview) * [Delta → How it works](/delta/how-it-works) * [Security → Audits](/overview/security/audits) # Legacy paraswap.io host → api.velora.xyz Source: https://new-docs.velora.xyz/resources/migrations/apiv5-to-api-host Move off the deprecated apiv5.paraswap.io and api.paraswap.io hosts to api.velora.xyz, the production endpoint. This page is a stub. Full content lands in Workstream C.2. ## What breaks if you do nothing The legacy hosts `apiv5.paraswap.io` and `api.paraswap.io` are deprecated. They still answer today, but they are **not** the production endpoint and will be retired. Code pinned to either host will start failing once it goes offline — some endpoints have already moved. The production host is **`https://api.velora.xyz`**. ## Steps 1. Replace `https://apiv5.paraswap.io` and `https://api.paraswap.io` with `https://api.velora.xyz` in your code, env vars, and config files. 2. Re-check the endpoints you use. Most map 1:1; a small set were renamed when consolidated. 3. Re-run your integration tests against `api.velora.xyz` before flipping production traffic. ## End-state check `grep -RE "(apiv5\.paraswap\.io|api\.paraswap\.io)"` in your codebase returns zero hits. Smoke test: a known `GET /prices` call against `api.velora.xyz` returns the same `priceRoute` it did on the legacy host. # Augustus v5 → v6.2 Source: https://new-docs.velora.xyz/resources/migrations/augustus-v5-to-v6-2 Contract-integrator upgrade: calldata diffs, removed TokenTransferProxy, parameter renames. This page is a stub. Full content lands in Workstream C.2. ## What breaks if you do nothing Calldata returned by `POST /transactions` now targets Augustus v6.2 by default. If your contract integration hardcoded the v5 router or `TokenTransferProxy` address, those approvals and contract calls will silently route to a deprecated surface. ## High-level diffs * **`TokenTransferProxy` is gone.** v6.2 pulls tokens directly via the router contract. ERC-20 approvals must be granted to the v6.2 router address, not to a separate proxy. * **`excludeContractMethodsWithoutFeeModel`** has been renamed (see new param list in [API Reference](/api-reference/market/overview)). * **Method signatures changed.** v6.2 introduces `swapExactAmountIn` and `swapExactAmountOut` as canonical entry points; v5's `multiSwap`/`megaSwap` are deprecated. ## Steps 1. Look up the v6.2 router address per chain on [Chains & contracts](/resources/chains-and-contracts). 2. Re-grant ERC-20 approvals to the v6.2 router. Revoke the legacy v5 TokenTransferProxy approval if you want cleanup. 3. If you decode calldata server-side, regenerate ABIs against v6.2. 4. Update any hardcoded contract-method names in your dApp. ## End-state check `GET /prices` response → `priceRoute.version` is `"6.2"` and `priceRoute.contractAddress` matches the v6.2 router for the chain. # Migrations Source: https://new-docs.velora.xyz/resources/migrations/index Internal upgrades for existing Velora integrators — Market → Delta, Augustus v5 → v6.2, legacy hosts, SDK rename. These pages are for engineers already shipping on Velora. They cover the only kinds of changes that should ever break your integration: internal protocol upgrades, host cutovers, and SDK renames. Nothing here is about migrating *to* Velora from a third party. ## Available migrations Keep Market wired, add Delta via `mode=ALL`, branch per response shape. When to fully cut over: gasless UX, MEV exposure, surplus economics. Contract integrators: calldata diffs, no more TokenTransferProxy, parameter renames. Move off `apiv5.paraswap.io` and `api.paraswap.io` to `api.velora.xyz`. Package rename, breaking changes, and step-by-step upgrade. Each migration page leads with **what breaks if you do nothing** and ends with a verifiable end-state check. # Market → Delta (parallel) Source: https://new-docs.velora.xyz/resources/migrations/market-to-delta-parallel Keep your Market integration wired, opt into Delta intents alongside it, and branch on the response shape. This page is a stub. Full content lands in Workstream C.2. ## What breaks if you do nothing Nothing. This migration is opt-in. Your existing Market integration keeps working as-is. ## Why migrate * **Better UX** — Delta intents are gasless and MEV-protected. Users sign once; the solver network fills. * **No code rewrite** — `GET /quote` with `mode=ALL` returns both a Market `market` block (same shape as `/prices`'s `priceRoute`) and a Delta `delta` block in a single response. You pick which to execute per-quote. ## Steps 1. Switch from `GET /prices` to `GET /quote?mode=ALL`. 2. Branch on the response: if `response.delta` exists, take the gasless path; else fall back to `response.market` and the existing calldata flow (it's the same shape your code already handles). 3. For the Delta path, call `POST /delta/orders/build`, sign the EIP-712 typed data, then `POST /delta/orders`. ## End-state check Run a quote with `mode=ALL`. Confirm both `market` and `delta` are present. Pick one and complete a swap end-to-end. # Market → Delta (replace) Source: https://new-docs.velora.xyz/resources/migrations/market-to-delta-replace When and how to fully cut over from Market routing to Delta intents. This page is a stub. Full content lands in Workstream C.2. ## What breaks if you do nothing Nothing. Market routing isn't going away. This migration is for teams who want to consolidate on Delta for product reasons — not a forced cutover. ## When to fully cut over * **Gasless UX** is a meaningful differentiator for your users (consumer wallets, agent flows, sub-\$50 swaps). * **MEV exposure** is a known issue in your current Market flow (large trades, low-liquidity pairs). * **Surplus economics** — solver competition routinely returns positive slippage to your users on Delta orders. ## When to keep Market * Latency budget under \~1s end-to-end. * Heavy token coverage on pairs that Delta solvers don't yet quote. * You already amortize gas across many users (batched executor, account abstraction with paymaster). ## Steps 1. Call `GET /quote?mode=DELTA` instead of `GET /prices`. Treat a missing `delta` block as a routing failure for your UX. 2. Remove Augustus calldata signing paths. All execution goes through `/delta/orders`. 3. Update your token-approval flow: the Delta contract — not Augustus — is the spender. ## End-state check Wallet, balance, and history pages show only Delta-style settlements. Augustus calldata flow is no longer reachable from your UI. # paraswap-sdk → @velora-dex/sdk Source: https://new-docs.velora.xyz/resources/migrations/paraswap-sdk-to-velora-sdk Step-by-step migration from the legacy @paraswap/sdk package to @velora-dex/sdk. This page is a stub. Full content lands in Workstream C.2. ## What breaks if you do nothing `@paraswap/sdk` is no longer actively developed. New API features (latest Augustus version, Delta enhancements, Crosschain) land in `@velora-dex/sdk` only. Your build will keep compiling, but you'll silently fall behind. ## Steps 1. Remove `@paraswap/sdk` from `package.json`. Install `@velora-dex/sdk`. 2. Replace imports — most named exports kept the same shape. The factory rename is `constructSimpleSDK` (the function name itself is unchanged; only the package source changed). 3. Re-run your TypeScript build. Most projects compile clean on the first pass. ## Code diff (illustrative) ```diff theme={null} - import { constructSimpleSDK } from '@paraswap/sdk'; + import { constructSimpleSDK } from '@velora-dex/sdk'; const sdk = constructSimpleSDK({ chainId: 1, fetch }); ``` ## End-state check `grep -R "@paraswap/sdk"` returns zero hits. Existing quote-and-swap flow returns the same `priceRoute` shape it did before. # Recipes Source: https://new-docs.velora.xyz/resources/recipes/index Outcome-named, runnable end-to-end flows in ≤80 lines. Copy, paste, ship. Recipes are short, runnable flows. Each one solves a real outcome — not a feature demo. Pick the goal, copy the code, ship it. Recipes ship page-by-page on `main`. The list below previews what's coming; pages will land alongside their verified code samples. ## Planned * **`swap-and-stake`** — quote, swap, and stake into a lending market in one transaction. * **`dca-via-twap-delta`** — recurring buys using Delta-based TWAP (not RFQ). * **`sell-entire-balance-with-permit2`** — close out a position with Permit2 in a single signature. * **`refinance-debt-via-crosschain-swap`** — repay debt on chain A with collateral on chain B via Crosschain Delta. * **`one-click-buy-with-gas-sponsorship`** — sponsor the user's gas while routing through Market. * **`partner-fee-with-surplus`** — collect a partner fee and capture positive slippage as surplus. Want a recipe that isn't here? Open an issue or email [devrel@velora.xyz](mailto:devrel@velora.xyz). # Choose a variant Source: https://new-docs.velora.xyz/sdk/choose-a-variant Pick between Simple SDK (one-call entry point) and Composable SDK (tree-shakeable modules) based on bundle size and flexibility needs. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Composable SDK Source: https://new-docs.velora.xyz/sdk/composable-sdk Use the tree-shakeable, modular SDK when bundle size matters. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Configure providers Source: https://new-docs.velora.xyz/sdk/configure-providers Wire your own RPC providers, signer, and chain config into the SDK. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Install & quick example Source: https://new-docs.velora.xyz/sdk/install Install @velora-dex/sdk and fetch your first quote in under five minutes. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Delta module Source: https://new-docs.velora.xyz/sdk/modules/delta Submit and track Delta intents from the SDK. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Limit orders module Source: https://new-docs.velora.xyz/sdk/modules/limit-orders Create, sign, and manage limit orders from the SDK. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Swap module Source: https://new-docs.velora.xyz/sdk/modules/swap Build, sign, and execute swaps through the SDK swap module. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Monetize (fee config) Source: https://new-docs.velora.xyz/sdk/monetize Configure partner fees on SDK calls and collect revenue per trade. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Overview Source: https://new-docs.velora.xyz/sdk/overview Use @velora-dex/sdk to integrate quotes, swaps, limit orders, and Delta intents from JavaScript or TypeScript. This page is a stub. Content coming soon. ## When to use this ## How it works ## Examples ## Related pages # Simple SDK Source: https://new-docs.velora.xyz/sdk/simple-sdk Use the all-in-one entry point for the common quote-and-swap flow. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Testing integration Source: https://new-docs.velora.xyz/sdk/testing-integration Test your SDK integration against staging endpoints and verify expected behavior. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Compatibility Source: https://new-docs.velora.xyz/widget/compatibility Tested environments and known caveats — Next.js, Remix, Vite, and more. This page is a stub. Content coming soon. ## Parameters ## Examples ## Related pages # Configure Source: https://new-docs.velora.xyz/widget/configure Configure chains, default tokens, partner key, and behavior. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Customize (theming) Source: https://new-docs.velora.xyz/widget/customize Customize widget colors, typography, and components to match your brand. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Events & callbacks Source: https://new-docs.velora.xyz/widget/events-and-callbacks Listen to widget lifecycle events and respond to user actions. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Next.js Source: https://new-docs.velora.xyz/widget/examples/nextjs Working widget integration example for a Next.js app router project. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # React Source: https://new-docs.velora.xyz/widget/examples/react Working widget integration example for a plain React app. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Vanilla HTML embed Source: https://new-docs.velora.xyz/widget/examples/vanilla-html-embed Embed the Velora widget in any HTML page — zero React required. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Install Source: https://new-docs.velora.xyz/widget/install Install @velora-dex/widget and render the swap widget in your React app. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Internationalization Source: https://new-docs.velora.xyz/widget/internationalization Translate the widget UI and customize copy per locale. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Monetize (fees, partner key) Source: https://new-docs.velora.xyz/widget/monetize Configure partner fees on the widget and collect revenue per trade. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Overview Source: https://new-docs.velora.xyz/widget/overview Embed the Velora swap widget in your app with @velora-dex/widget — or drop it into plain HTML with zero code. This page is a stub. Content coming soon. ## Try it live Configure chains, tokens, theme, and partner fees in a live preview — opens in a new tab. ## When to use this ## How it works ## Examples ## Related pages # Variants Source: https://new-docs.velora.xyz/widget/variants Pick between compact, wide, and drawer widget variants. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Wallet management Source: https://new-docs.velora.xyz/widget/wallet-management Bring your own wallet connector or use the default integration. This page is a stub. Content coming soon. ## When to use this ## Quickstart ## Examples ## Related pages # Widget API reference Source: https://new-docs.velora.xyz/widget/widget-api-reference Props, methods, event payloads, and theme schema for @velora-dex/widget. This page is a stub. Content coming soon. ## Parameters ## Examples ## Related pages