A photo of Shodipo Ayomide
All Posts

Simplifying Cross-Chain Transactions Using Intents

Sep 18, 2025
·
••• views
·
••• likes
Simplifying Cross-Chain Transactions Using Intents

Let's follow this scenario - You're trying to swap 1,000 USDC on Ethereum for some SOL on Solana. With traditional bridges, you'd need to wrap your USDC, find a bridge (hoping it doesn't get hacked), wait 20 minutes or more for finality, pay ridiculous fees, then unwrap on the other side. By the time you're done, the price has moved, you've burned through $50 in gas, and you're questioning your life choices, Damn!

What if I told you there's a better way? What if you could just say I want 100 SOL for my 1000 USDC and have the blockchain figure out the rest? That's exactly what intents do. They let you declare exactly what you want instead of going through the hassle of getting it.

What Are Intents?

Think of intents as the difference between telling someone "drive to the supermarket, turn left at ilford high road, park in spot 11 and walk to aisle 5..." versus just saying "get me milk". The outcome essentially is the same, but one approach is declarative "(exactly what you want) while the other is imperative (step-by-step instructions).

In technical terms, intents are signed messages that express a user's desired outcome without specifying execution details. Instead of crafting complex transaction sequences yourself, you broadcast your intent to a network of solvers (sophisticated actors) who then compete to fulfill your request.

This is what a sample intent looks like:

 {
  "user": "alice.near",
  "intent_type": "token_swap",
  "give": {
    "token": "usdc.near",
    "amount": "1000000000"
  },
  "receive": {
    "token": "sol.near", 
    "min_amount": "100000000000"
  },
  "deadline": 1735689600,
  "signature": "0x..."
}

Quite simple, right? Alice really doesn't care about routing complexity, she just wants her SOL in exchange for her USDC and that's all.

Why Intents Exist - The Cross-Chain Problem

Cross-chain DeFi protocols are quite complex for the normal user. They need to understand different protocols, manage multiple gas tokens, and navigate around with tons of security risks. Traditional solutions often involve:

  1. Complex multi-step workflows across different chains
  2. Security vulnerabilities from asset wrapping and bridging
  3. Poor regular user experience requiring deep technical knowledge
  4. Fragmented liquidity and suboptimal pricing

Intents flip this model around. Instead of pushing complexity to users, the system pulls it into a competitive solver network. Users express desires, solvers figure out execution, everyone wins 🔥.

What Are Solvers and How Do They Work?

Solvers in this context are the backbone of intent-based systems. They're specialized actors, could be market makers, AI agents, or sophisticated traders - who are competing to fulfill user intents within the system.

This is how it works: when you broadcast an intent, multiple solvers analyze it and submit competing quotes. They might route through different DEXs, use off-chain liquidity, or even batch your intent with others for better pricing. The best solution wins.

Now, think of solvers as your personal trading assistants who understand every connected protocol, every liquidity source, and every optimization trick in DeFi. They make money by providing better execution than you could achieve yourself and savs you a alot of time.

Traditional Intents

Intent-based architectures aren't an entirely new concept. UniswapX pioneered the concept for Ethereum, processing over $2B in volume through Dutch auctions where "fillers" compete to fulfill swap requests.

CoW Protocol expanded this with batch auctions and MEV protection, accumulating over $15B in trading volume. Their insight? By batching intents and finding coincidence of wants, they could eliminate MEV while improving execution.

But these systems are then single-chain solutions. UniswapX works great for ETH ecosystem trades, but cross-chain? You're back to complexity hell, welcome back!

How NEAR Protocol solved this

NEAR Protocol built the first genuinely cross-chain intent system. The numbers speak for themselves: over $1.075B in total volume, 2-3 second finality, and native Bitcoin support without wrapping.

How did they achieve this? Chain Signatures. Through multi-party computation (MPC), NEAR validators can collectively sign transactions on foreign blockchains without any single party holding private keys. It's like having a universal remote for the entire crypto ecosystem.

Creating an Intent

import { createIntent, signIntent } from '@defuse-protocol/intents-sdk';
 
const intent = createIntent({
  from: 'alice.near',
  give: { token: 'usdc.near', amount: '1000000000' },
  receive: { token: 'sol.near', minAmount: '100000000000' },
  expiry: Date.now() + 300000
});
 
const signedIntent = await signIntent(intent, wallet);
await broadcastIntent(signedIntent);

Flow chart showing Intent Creation → Solver Competition → Settlement Pipeline with three distinct phases and actors

Flow chart showing Intent Creation → Solver Competition → Settlement Pipeline
Flow chart showing Intent Creation → Solver Competition → Settlement Pipeline

The Three Layer Design

The core verification logic:

fn execute_token_diff_intents(intents: &[TokenDiff]) -> Result<(), Error> {
    let mut net_changes: HashMap<TokenId, i128> = HashMap::new();
    
    for intent in intents {
        *net_changes.entry(intent.token_in).or_default() -= intent.amount_in;
        *net_changes.entry(intent.token_out).or_default() += intent.amount_out;
    }
    
    for (_, net_change) in net_changes.iter() {
        if *net_change != 0 {
            return Err("Non-zero sum transaction".into());
        }
    }
    Ok(())
}

This guy ensures the perfect balance, for every token going out, an equivalent amount comes in across all batched intents.

Diagram showing the three layer stack with data flow between Distribution, Solver Networks, and the Verifier, including specific components like 1Click API, MPC Network, and Chain Signatures

Diagram showing the three layer stack with data flow
Diagram showing the three layer stack with data flow

Talking about the 1Click API

Part of the secret to making this work at scale is the 1Click API, this guy abstracts away all the complexity end to end. Developers can create cross-chain intents without thinking about MPC, Chain Signatures, or solver routing. It handles fetching quotes from multiple solvers, selects the best route across DEXs and bridges, watches the execution, handles retries, and even handles gas optimization and timing, all in one api call, everything else is taken care of under the hood.

Building with the 1Click API

What it looks like:

import { IntentsSDK } from '@near-intents/sdk';
 
const sdk = new IntentsSDK({
  network: 'mainnet',
  apiKey: process.env.NEAR_INTENTS_API_KEY
});
 
async function createSwapIntent(fromToken, toToken, amount) {
    const quote = await sdk.getQuote({
      tokenIn: fromToken,
      tokenOut: toToken,
      amountIn: amount,
    slippage: 0.005
    });
    
    const intent = await sdk.createIntent({
    tokenIn: { address: fromToken, amount },
      tokenOut: { address: toToken, minAmount: quote.amountOut },
    deadline: Date.now() + 300000
    });
    
    // watch the execution
  sdk.watchIntent(intent.id)
    .on('executed', (result) => console.log(`Done! TX: ${result.hash}`))
    .on('failed', (error) => console.error(`Failed: ${error.reason}`));
}

Read more about it here.

Looking at Defuse Protocol

Defuse just shows how to build production DEX interfaces with intents. Instead of managing complex routing logic, you get:

import { DefuseKit } from '@defuse-protocol/intents-sdk';
 
const defuse = new DefuseKit({ network: 'mainnet' });
 
const quotes = await defuse.requestQuotes({
  tokenIn: 'ethereum:0x...', 
  tokenOut: 'solana:native',
  amountIn: amount
});
 
const bestQuote = quotes.reduce((best, current) => 
  BigInt(current.amountOut) > BigInt(best.amountOut) ? current : best
);
        
const result = await defuse.executeIntent(bestQuote);

This gives you:

The client handles all the complexity, users just see the best price and fastest execution, and moves on.

Looking at Paycrest

Paycrest bridges blockchain intents with traditional payment systems. Here's how it works:

  1. Intent Creation: User says "pay this invoice with any token"
  2. Route Discovery: System finds optimal crypto-to-fiat conversion path
  3. Execution: Automatically swaps crypto to stable asset, then to fiat payment
func (a *Aggregator) ProcessPaymentIntent(intent *PaymentIntent) error {
    routes := a.findPaymentRoutes(intent)
    bestRoute := a.selectOptimalRoute(routes)
    
    switch bestRoute.Type {
    case "crypto_to_fiat":
        return a.executeCrossSystemPayment(intent, bestRoute)
    case "direct_crypto":
        return a.executeCryptoPayment(intent, bestRoute)
    }
}

The primary challenge lies in cross-system payments that bridge crypto and fiat. Paycrest handles this through multiple stages:

Why This Scales

  1. Solver Competition: A competitive market of solvers ensures efficient execution on-chain. As the number of solvers on the network increases, competition drives down costs and improves execution speed for users. This open market also encourages support for a wider variety of assets and allows for the integration of advanced solvers, such as AI agents, capable of complex algorithmic operations.

  2. Batching Network Effects: A higher volume of user intents allows a verifier to aggregate multiple operations into a single optimized on-chain transaction, this gradually writes off fixed costs (like gas fees) across many users, resulting in lower fees and greater capital efficiency for everyone on the network.

  3. Multi-Chain Parallelization: Intents can be parallelized and executed across multiple blockchains significantly improving over the sequential processing model of many traditional bridges. A complex trade involving assets on Ethereum, Solana, and Bitcoin can be settled concurrently, reducing total time and latency of the cross-chain transactions.

Simplifying Complex Routing

These mechanisms abstract the underlying operational complexity from the user. The below snippet demonstrates how a user can specify a multi-hop, gas-optimized, cross-chain transaction in a single request:

const response = await fetch('https://api.near-intents.org/v1/quote', {
  method: 'POST',
  body: JSON.stringify({
    tokenIn: 'usdc.near',
    tokenOut: 'bitcoin:native',
    routing: {
      maxHops: 3,
      excludeProtocols: ['slow_bridge'],
      preferredSolvers: ['defuse', 'paycrest'],
      gasOptimization: true
    }
  })
});

The API handles optimization, timing, and failure recovery automatically.

Industry Landscape

NEAR isn't the only one doing this. UniswapX dominates Ethereum trading, CoW Protocol excels at MEV protection, 1inch Fusion provides DEX aggregation.

Essential Links

•••
Share this post:
XWebsiteGitHub

Built with ❤️ © 2025