Multi-Chain Agent Protection

YoorQuezt provides MEV protection across 15 chains. Each chain has a dedicated RPC endpoint that intercepts transactions, applies chain-specific protection strategies, and returns MEV rebates to the originating wallet.

Supported Chains

Cross-Chain Intent Execution (ERC-7683)

For agents that need to execute operations across multiple chains, YoorQuezt supports cross-chain intents via the ERC-7683 standard. Submit a single intent describing your desired outcome, and YoorQuezt's solver network handles routing, bridging, and execution across chains.

const intent = {
  type: "swap",
  source_chain: "ethereum",
  destination_chain: "arbitrum",
  token_in: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH on Ethereum
  token_out: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1", // WETH on Arbitrum
  amount_in: "1000000000000000000", // 1 ETH
  min_amount_out: "990000000000000000", // 0.99 ETH (1% slippage)
  deadline: Math.floor(Date.now() / 1000) + 3600,
};

const response = await fetch("https://api.yoorquezt.io/intent", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "Authorization": "Bearer YOUR_API_KEY",
  },
  body: JSON.stringify(intent),
});

const { intent_id, status } = await response.json();

Per-Chain Behavior

Ethereum (12s blocks)

Transactions are routed to Flashbots Protect. They never enter the public mempool. Backrun opportunities are captured via MEV-Share and 90% of extracted value is rebated.

Arbitrum (250ms blocks)

Arbitrum uses a centralized sequencer with FCFS (first-come-first-served) ordering. YoorQuezt submits transactions directly to the sequencer with optimized timing to minimize MEV exposure from cross-domain attacks.

Base (200ms blocks)

Similar to Arbitrum, Base uses a sequencer. YoorQuezt optimizes submission timing and monitors for cross-domain MEV vectors between Base and Ethereum L1.

Optimism (2s blocks)

Optimism's sequencer processes transactions in order of receipt. YoorQuezt ensures fast submission and monitors for L1-to-L2 message-based MEV.

Solana (400ms slots)

Transactions are submitted via Jito block engine as bundles. This prevents sandwich attacks from validators and searchers operating on the Solana mempool. Backrun tips are rebated at 90%.

EVM Integration

For any EVM-compatible chain, replace the RPC URL in your provider:

import { ethers } from "ethers";

// Ethereum
const ethProvider = new ethers.JsonRpcProvider("https://rpc.yoorquezt.io/ethereum");

// Arbitrum
const arbProvider = new ethers.JsonRpcProvider("https://rpc.yoorquezt.io/arbitrum");

// Base
const baseProvider = new ethers.JsonRpcProvider("https://rpc.yoorquezt.io/base");

// Create wallet with any protected provider
const wallet = new ethers.Wallet(PRIVATE_KEY, ethProvider);

// Transactions are automatically MEV-protected
const tx = await wallet.sendTransaction({
  to: recipient,
  value: ethers.parseEther("1.0"),
});
console.log("Protected tx:", tx.hash);

Multi-Chain Agent Example

import { ethers } from "ethers";

const chains = {
  ethereum: new ethers.JsonRpcProvider("https://rpc.yoorquezt.io/ethereum"),
  arbitrum: new ethers.JsonRpcProvider("https://rpc.yoorquezt.io/arbitrum"),
  base: new ethers.JsonRpcProvider("https://rpc.yoorquezt.io/base"),
  optimism: new ethers.JsonRpcProvider("https://rpc.yoorquezt.io/optimism"),
};

async function executeOnChain(chainName: string, tx: ethers.TransactionRequest) {
  const provider = chains[chainName];
  if (!provider) throw new Error(`Unsupported chain: ${chainName}`);

  const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
  const response = await wallet.sendTransaction(tx);
  console.log(`[${chainName}] Protected tx: ${response.hash}`);
  return response;
}

// Agent decides which chain to use
await executeOnChain("arbitrum", {
  to: SWAP_ROUTER,
  data: swapCalldata,
  value: 0,
});

Solana Integration

import { Connection, Keypair, Transaction } from "@solana/web3.js";

const connection = new Connection("https://rpc.yoorquezt.io/solana");
const keypair = Keypair.fromSecretKey(secretKey);

const tx = new Transaction().add(/* swap instruction */);
tx.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
tx.feePayer = keypair.publicKey;
tx.sign(keypair);

const signature = await connection.sendRawTransaction(tx.serialize());
console.log("Protected Solana tx:", signature);