Market Order

A market order executes immediately at the best available price Flash can route. It takes no price field; for a standard market order, maxSlippage bounds the final output against the amount quoted. QuickTrade uses maxPriceImpact instead because its output is not fixed at quote time. For the concepts behind these parameters, see Placing Orders. This page shows the full same-chain flow end to end (quote, sign, submit) as a runnable script for each chain. The EVM example buys WETH with USDC on Base; the Solana example buys WSOL with USDC.

Market parameters

Field	Required	Meaning
`orderType`	Yes	`"market"`
`side`	Yes	`"buy"` or `"sell"`
`qty`	Yes	Spend amount, as a string. Contra units on a buy, target units on a sell
`maxSlippage`	Optional on standard market orders	Maximum difference between quoted and executed output, as a decimal string. If omitted, Flash computes and applies the `recommendedSlippage` returned in the quote response
`maxPriceImpact`	Optional with QuickTrade	Maximum difference between the effective execution price and execution-time reference price, as a decimal string

Market orders do not accept a limit price (limitNotionalPrice or limitCrossPrice), expireTime, or triggers. The onchain deadline is set automatically (roughly 5 minutes from quote time).

End-to-end example

Prerequisites. EVM examples use viem; Solana examples use @solana/web3.js, tweetnacl, and bs58. All requests go to https://flash.definitive.fi/v1 with your key in the x-definitive-api-key header. The public integrator key dpka_513a2bd7_57a2_46d2_927b_2a3857fe271b is safe for development. The onchain steps (token approval on EVM, delegation on Solana) also need an RPC endpoint and the funder wallet’s key, supplied here through environment variables.

EVM

Buy WETH with 100 USDC on Base, with 5% slippage protection. If the spent token needs an allowance, the quote returns evm.approveTx (or evm.permitTypedData on the Permit2 path); submit or sign whichever it returns, then sign the order payload and submit.

import { createWalletClient, createPublicClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { base } from "viem/chains";

const BASE_URL = "https://flash.definitive.fi/v1";
const API_KEY = "dpka_513a2bd7_57a2_46d2_927b_2a3857fe271b";

const account = privateKeyToAccount(process.env.EVM_PRIVATE_KEY as `0x${string}`);
const wallet = createWalletClient({ account, chain: base, transport: http(process.env.EVM_RPC_URL) });
const publicClient = createPublicClient({ chain: base, transport: http(process.env.EVM_RPC_URL) });

const post = (path: string, body: unknown) =>
  fetch(`${BASE_URL}${path}`, {
    method: "POST",
    headers: { "content-type": "application/json", "x-definitive-api-key": API_KEY },
    body: JSON.stringify(body),
  }).then((r) => r.json());

const order = {
  targetChain: "base",
  contraChain: "base",
  targetAsset: "0x4200000000000000000000000000000000000006", // WETH
  contraAsset: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", // USDC
  side: "buy",
  qty: "100",
  orderType: "market",
  maxSlippage: "0.05",
};

const quote = await post("/quote", { ...order, funderAddress: account.address });

if (quote.evm.approveTx) {
  const hash = await wallet.sendTransaction({
    to: quote.evm.approveTx.to,
    data: quote.evm.approveTx.data,
    value: 0n,
  });
  await publicClient.waitForTransactionReceipt({ hash });
}

let permitFields = {};
if (quote.evm.permitTypedData) {
  const evmPermitSignature = await account.signTypedData(JSON.parse(quote.evm.permitTypedData));
  permitFields = { evmPermitTypedData: quote.evm.permitTypedData, evmPermitSignature };
}

const { domain, types, primaryType, message } = JSON.parse(quote.evm.orderTypedData);
const userSignature = await account.signTypedData({ domain, types, primaryType, message });

const { orderId } = await post("/order", {
  ...order,
  funderAddress: account.address,
  quoteId: quote.quoteId,
  userSignature,
  evmOrderTypedData: quote.evm.orderTypedData,
  ...permitFields,
});

console.log("orderId", orderId);

SVM (Solana)

Buy WSOL with 100 USDC. Before the first trade of a token the swap needs the funder’s token accounts (svm.ataSetupIxs) and a delegation (svm.delegateIx or a sponsor-paid svm.sponsoredDelegateTx). Run the onchain steps in order, then sign the order message offchain and submit.

import {
  Connection,
  Keypair,
  PublicKey,
  TransactionInstruction,
  TransactionMessage,
  VersionedTransaction,
} from "@solana/web3.js";
import nacl from "tweetnacl";
import bs58 from "bs58";

const BASE_URL = "https://flash.definitive.fi/v1";
const API_KEY = "dpka_513a2bd7_57a2_46d2_927b_2a3857fe271b";

const connection = new Connection(process.env.SOLANA_RPC_URL!, "confirmed");
const funder = Keypair.fromSecretKey(bs58.decode(process.env.SOLANA_SECRET_KEY!));

const post = (path: string, body: unknown) =>
  fetch(`${BASE_URL}${path}`, {
    method: "POST",
    headers: { "content-type": "application/json", "x-definitive-api-key": API_KEY },
    body: JSON.stringify(body),
  }).then((r) => r.json());

const toIx = (ix: any) =>
  new TransactionInstruction({
    programId: new PublicKey(ix.programId),
    keys: ix.accounts.map((a: any) => ({
      pubkey: new PublicKey(a.pubkey),
      isSigner: a.isSigner,
      isWritable: a.isWritable,
    })),
    data: Buffer.from(bs58.decode(ix.data)),
  });

async function sendIxs(instructions: any[]) {
  const { blockhash } = await connection.getLatestBlockhash();
  const message = new TransactionMessage({
    payerKey: funder.publicKey,
    recentBlockhash: blockhash,
    instructions: instructions.map(toIx),
  }).compileToV0Message();
  const tx = new VersionedTransaction(message);
  tx.sign([funder]);
  const sig = await connection.sendRawTransaction(tx.serialize());
  await connection.confirmTransaction(sig, "confirmed");
}

const order = {
  targetChain: "solana",
  contraChain: "solana",
  targetAsset: "So11111111111111111111111111111111111111112", // WSOL
  contraAsset: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC
  side: "buy",
  qty: "100",
  orderType: "market",
  maxSlippage: "0.05",
};

const quote = await post("/quote", { ...order, funderAddress: funder.publicKey.toBase58() });

if (quote.svm.ataSetupIxs) await sendIxs(quote.svm.ataSetupIxs);

let delegateFields = {};
if (quote.svm.sponsoredDelegateTx) {
  const tx = VersionedTransaction.deserialize(Buffer.from(quote.svm.sponsoredDelegateTx, "base64"));
  tx.sign([funder]);
  delegateFields = { svmSponsoredDelegateTx: Buffer.from(tx.serialize()).toString("base64") };
} else if (quote.svm.delegateIx) {
  await sendIxs([quote.svm.delegateIx]);
}

const signature = nacl.sign.detached(new TextEncoder().encode(quote.svm.orderMessage), funder.secretKey);
const userSignature = bs58.encode(signature);

const { orderId } = await post("/order", {
  ...order,
  funderAddress: funder.publicKey.toBase58(),
  quoteId: quote.quoteId,
  userSignature,
  svmNonce: quote.svm.nonce,
  svmDeadline: quote.svm.deadline,
  ...delegateFields,
});

console.log("orderId", orderId);

To sell instead, set side to "sell" and denominate qty in the target asset (for example "0.05" to sell 0.05 WETH). Everything else stays the same.

To track the order after submit, poll GET /orders or stream live updates over the Orders WebSocket.

Crosschain Orders

Move funds across chains in one order.

Limit Order

Fill only at a set price or better.

Bracket Orders

Attach a take-profit / stop-loss pair to this order at placement.

Placing Orders

The full parameter reference for every order type.

Agents

End-To-End Flows

Market parameters

End-to-end example

Crosschain Orders

Limit Order

Bracket Orders

Placing Orders

​Market parameters

​End-to-end example

Crosschain Orders

Limit Order

Bracket Orders

Placing Orders

Market parameters

End-to-end example