NEAR Intents: Intent-Based Blockchain Transactions

The Problem With Blockchain Transactions Today

If you've ever tried to move funds across chains and abandoned the attempt halfway through, you already understand the problem NEAR Intents was built to solve.

Multi-chain DeFi (decentralized finance) is powerful on paper. In practice, it asks a lot from users. You need to be on the right network, hold the right gas token, find the right bridge, confirm you're using the right pool, and hope nothing fails mid-route. Gas fees can surprise you. A bridge can time out. A wrong click can strand funds in an intermediate state.

None of that friction comes from technical necessity. It comes from the fact that blockchains, historically, require users to specify every step of a transaction rather than just declaring what they want to achieve.

NEAR Intents takes a different approach. Instead of asking you to describe the route, it asks you to describe the destination. You don't need to be a NEAR Protocol expert to follow along. This guide covers everything you need to know about the underlying network as we go.

What Is NEAR Intents?

NEAR Intents is a transaction paradigm on NEAR Protocol in which users declare a desired outcome (for example, receiving 500 USDC in exchange for 0.2 ETH) rather than specifying each step of the transaction. A network of competing third-party actors called solvers then fulfills that intent via the most efficient available route.

Clarification: NEAR Intents is not a cryptocurrency, token, or separate blockchain. It is a protocol feature built on NEAR Protocol that changes how transactions are constructed and executed.

What Does "Intent" Mean in Blockchain?

In blockchain, an intent is a declaration of what outcome you want, not a set of instructions for how to achieve it. Traditional blockchain transactions require you to write the recipe. An intent-based system asks you to describe the dish.

This design pattern has gained traction across the crypto ecosystem because it separates user goals from execution mechanics. The user focuses on what they want. The system figures out how to deliver it.

Think of it this way: placing a food order means telling the kitchen what you want, not how to cook it. NEAR Intents works on the same principle. You declare the blockchain outcome you want (for instance, "receive 500 USDC for 0.2 ETH"), and the network determines the optimal path to get you there.

More precisely: your signed intent is broadcast to a network of competing solvers, each of which calculates the best fulfillment path across available liquidity sources and chains. The winning solver executes the transaction atomically on your behalf.

Why This Matters for Everyday Users

The practical result is that users no longer need to understand the underlying plumbing. You don't need to know whether your swap routes through Ethereum, NEAR Protocol, or an intermediate chain. You don't need to hold gas tokens for every network you touch. You state what you want, and the solver network handles the rest.

This is the core UX shift that NEAR Intents introduces: moving execution complexity from the user to a competitive market of specialized actors.

What Is NEAR Protocol?

NEAR Protocol, a layer-1 proof-of-stake (PoS) blockchain designed for scalability and mainstream accessibility, is the foundational network on which NEAR Intents operates. NEAR Protocol achieves high throughput through Nightshade, its dynamic sharding system, which splits the blockchain's state and computation across parallel shards rather than forcing every node to process every transaction.

Compared to Ethereum, NEAR Protocol offers faster transaction finality, lower fees, and a more accessible account model. These are not competing philosophies so much as different architectural trade-offs: Ethereum prioritizes decentralization and composability within its own ecosystem, while NEAR Protocol prioritizes throughput and user accessibility, particularly for applications that span multiple chains. NEAR's ecosystem also includes Aurora, NEAR's EVM-compatible environment, which allows Ethereum developers to deploy Solidity smart contracts on NEAR infrastructure.

The NEAR Account Model

NEAR Protocol's account system works differently from Ethereum's wallet model. Instead of a cryptographic hash like 0x4aB3..., a NEAR account has a human-readable name: alice.near. This design makes accounts recognizable and shareable, but the architectural significance goes deeper than readability.

NEAR accounts support multiple access keys with different permission levels. One key might authorize full account access; another might only authorize specific smart contract calls. This multi-key structure matters for how NEAR Intents work: your wallet can grant a limited key that allows the solver network to execute on your behalf, scoped to the exact terms of your declared intent, without exposing full account control.

The NEAR Token

The NEAR token (ticker: NEAR) is the native utility token of NEAR Protocol. It is used to pay transaction fees (gas) on the network and to stake for network validation. The NEAR token is not specific to NEAR Intents. It is the base economic layer of the protocol on which NEAR Intents operates.

NEAR Protocol's design makes it the natural foundation for a more ambitious goal: removing the complexity of multi-chain interactions entirely.

What Is Chain Abstraction? The Vision Behind NEAR Intents

NEAR Protocol's chain abstraction vision describes a design goal in which the complexity of operating across multiple blockchains (selecting the right network, holding gas tokens, navigating bridges) becomes invisible to the end user. The NEAR Foundation (the non-profit supporting NEAR Protocol's development) has positioned chain abstraction as the central pillar of NEAR's 2024-2025 strategic direction.

The Problem Chain Abstraction Addresses

As crypto users increasingly operate across multiple blockchains, multichain interoperability (the ability to move assets and data between chains) has become one of the most persistent friction points in Web3. A user who wants to participate in DeFi across Ethereum, NEAR Protocol, and other networks currently faces a different set of requirements on each one: different wallets, different gas tokens, different bridges.

Cross-chain bridges, infrastructure that transfers tokens between separate blockchains, add their own layer of complexity. Users must select the right bridge, confirm transfer times, and manage the risk of failed transfers. Gas fees vary by network and denomination. None of this complexity is inherent to the financial goal the user actually wants to achieve.

NEAR Intents as the Engine

Chain abstraction is the destination. NEAR Intents is the engine that gets there.

Chain abstraction describes what users experience: interacting with any chain, any asset, any protocol, without needing to think about which network they're on. NEAR Intents is the technical mechanism that makes this experience possible. It routes outcomes through whichever chains and liquidity sources are most efficient, invisibly.

The NEAR Foundation has framed this connection explicitly: NEAR Intents is not a standalone product but the execution layer of a broader architectural vision. The next section walks through exactly how that execution works.

How NEAR Intents Work: The Lifecycle of an Intent

Every NEAR Intent follows the same process, from the moment you state what you want to the moment the outcome lands in your wallet.

The Intent Lifecycle, Step by Step

1. You declare your intent. You state the outcome you want (for example, "I want to receive 500 USDC in exchange for 0.2 ETH") without specifying which chain, which liquidity pool, or which route to use.
2. Your signed intent is broadcast to the solver network. All participating solvers receive your intent simultaneously, creating a competitive fulfillment market.
3. Solvers calculate fulfillment paths. Each solver analyzes available liquidity across chains and DEXs to determine the best way to fulfill your stated outcome.
4. The winning solver is selected. The solver offering the best fulfillment terms (best price, lowest net cost, or fastest execution depending on your criteria) wins the right to execute.
5. The transaction executes atomically. Either your intent is fulfilled exactly as declared, or it fails entirely. There is no partial fulfillment and no stranded intermediate state.
6. You receive the declared outcome. The result lands in your wallet without you having specified a single step of the execution path.

One additional benefit of this architecture is gas abstraction. Solvers can pay gas on your behalf across whichever chains are involved. You don't need to hold the correct native gas token for each network a transaction touches. The solver handles this as part of fulfillment.

How NEAR Intents Differ From Traditional Transactions

The difference between a traditional blockchain transaction and a NEAR Intent is the difference between writing a recipe and placing a restaurant order.

The Solver Network: Who Fulfills Your Intents

What Is a Solver?

A solver, in the context of NEAR Intents, is a permissionless third-party actor that monitors broadcast intents, computes an optimal fulfillment path across available liquidity sources and chains, and executes the transaction on the user's behalf. Solvers are permissionless: anyone meeting the technical requirements can operate as one. They earn a portion of the value they generate through efficient execution.

Think of it this way: several travel agents are competing to book your trip. You've told them your destination and your budget, not which airline, which layover, or which booking site to use. Each agent comes back with their best offer. You take the best one. NEAR Intents works the same way: you state your desired outcome, solvers compete to fulfill it, and you receive the best result the market can deliver.

More precisely: solvers receive your signed intent via a broadcast channel, calculate fulfillment paths across liquidity pools, decentralized exchanges (DEXs), and chains, then submit competing quotes. The best quote is selected for atomic execution.

How Solvers Compete

Solvers compete through a broadcast-and-quote process. When your intent is published, every active solver sees it simultaneously. Each solver evaluates the current state of liquidity across all relevant chains and pools, then calculates the most efficient fulfillment path it can offer.

Each solver submits a fulfillment quote. The quote that delivers the best outcome by your criteria (typically the best net price, though speed and cost can also factor in) is selected. The selected solver then executes the transaction.

The incentive structure keeps this process aligned with your interests. Solvers earn value by finding execution paths more efficient than what a user would find manually. A solver that consistently delivers poor execution stops winning quotes and stops earning. Better execution means more reward, which means solvers are economically motivated to work on your behalf.

Who Executes Your Intent, and Is It Safe?

Solvers execute your intent, but the execution is governed by three mechanisms that protect users from solver misbehavior.

Atomic execution: Intent fulfillment is all-or-nothing. Either your intent is fulfilled exactly as you declared, or it fails entirely. Solvers cannot execute a partial fulfillment, deliver a different token pair, or substitute a worse route. The declared outcome is the only acceptable outcome.

Smart contract governance: The execution terms are enforced by smart contracts on NEAR Protocol. Once you submit your intent, the terms are locked. A solver cannot alter the outcome you specified, and the smart contract will not release settlement unless the declared terms are met.

Incentive alignment: Solvers are economically motivated to fulfill your intent accurately and efficiently. A solver that manipulates outcomes or consistently underperforms loses competitive selection for future intents, which means losing the revenue that execution earns.

No blockchain system is risk-free, and NEAR Intents is no exception. The mechanisms above reduce execution risk significantly, but users should verify current implementation details at the NEAR Protocol official documentation before transacting.

What Can You Do With NEAR Intents? Use Cases

NEAR Intents currently enables or is architecturally designed to enable the following:

• Cross-chain token swaps without bridge interaction: Swap ETH for USDC, or any supported token pair, without selecting a bridge, a chain, or a liquidity pool. The solver network routes the swap optimally across all available sources.
• Gas abstraction: Transact across multiple chains without holding the native gas token for each network. Solvers handle gas payment as part of fulfillment.
• Optimal trade routing across DEXs and chains: Rather than manually finding the best price on a single decentralized exchange, solvers scan liquidity across multiple DEXs and chains simultaneously and execute via the best available route.
• Multi-step DeFi interactions expressed as a single intent: Complex actions that would normally require multiple sequential transactions (swapping assets, routing cross-chain, then depositing into a yield protocol) can be expressed as one declared outcome.
• Chain-agnostic execution: Use NEAR Intents without knowing or selecting which blockchain processes your transaction. The solver network determines the optimal chain based on your stated outcome.

Cross-chain token swaps are the flagship use case. A user declares "swap 0.5 ETH for USDC." They don't specify Ethereum, Arbitrum, or any other network. They don't choose a bridge or a liquidity pool. The solver network evaluates all available routes across supported chains and executes via the optimal path. The user receives USDC. That's the entirety of what they needed to know.

DeFi participation benefits particularly from this model. The barrier to multi-chain DeFi has historically been expertise: knowing which protocols exist on which chains, which pools have the best rates, which bridges are currently reliable. NEAR Intents redistributes that expertise to the solver network, making DeFi accessible without making it less capable.

Defuse: NEAR Intents in Practice

NEAR Intents is live on mainnet, with Defuse, the primary protocol implementing NEAR Intents, as the flagship application where users can interact with it today.

Defuse is a protocol built on NEAR Protocol that enables cross-chain, intent-based trading and interactions in live production. The distinction is worth stating clearly: Defuse is one implementation of the NEAR Intents standard, not NEAR Intents itself. NEAR Intents is the broader paradigm and technical standard; Defuse demonstrates what that standard makes possible for end users.

⚠️ Freshness Note: The NEAR Intents ecosystem is actively evolving. The supported chains, dApp integrations, and wallet support listed below reflect information available at time of writing. Verify current availability at NEAR Protocol official documentation before relying on specific implementation details.

Supported chains (verify current list at docs.near.org):

• NEAR Protocol (native)
• Ethereum
• Bitcoin
• Additional chains are added as the ecosystem develops

Supporting dApps and wallets (verify current list at publication):

• Defuse Protocol (primary implementation)
• Additional dApps and wallet integrations are being developed and verified at time of publication

The ecosystem building around NEAR Intents is growing as the standard gains adoption. Developers building on NEAR Protocol can implement the NEAR Intents standard in their own applications, which means Defuse is the current flagship but not the ceiling. The NEAR Foundation has positioned the expansion of this ecosystem as a direct measure of chain abstraction progress.

NEAR Intents vs. Account Abstraction, ERC-4337, and Traditional DEXs

NEAR Intents, account abstraction, and traditional DEXs address overlapping problems through different architectural approaches. Here is how they compare.

NEAR Intents vs. Account Abstraction and ERC-4337

Account abstraction is a design paradigm that separates account ownership logic from transaction execution, enabling flexible wallet behavior, sponsored gas, batch transactions, and programmable account policies. ERC-4337, Ethereum's account abstraction standard (ERC stands for Ethereum Request for Comment, the standard format for Ethereum protocol proposals), introduced these capabilities to Ethereum in 2023 without requiring a consensus-layer change to the network.

NEAR Protocol's account model has had native abstraction-like properties since its launch, predating ERC-4337. Named accounts like alice.near, multi-key access with different permission levels, and function call keys that scope authorization to specific contract interactions are all features NEAR Protocol shipped before Ethereum's account abstraction effort reached mainnet.

NEAR Intents vs. ERC-4337: A Direct Comparison

No, NEAR Intents and ERC-4337, Ethereum's account abstraction standard, are not the same thing. They address related but distinct problems. ERC-4337 abstracts account management on Ethereum: it changes how your wallet behaves. NEAR Intents abstracts the transaction outcome and execution path: it changes what you need to know to get a result. They operate at different layers of the stack. NEAR Intents goes further than ERC-4337 in scope, abstracting not just wallet behavior but the entire execution path across multiple chains and eliminating the need to specify chain, route, or gas token.

NEAR Intents vs. Traditional DEXs

A traditional decentralized exchange requires the user to be on the correct chain, hold the correct token pair, know which liquidity pool to use, and pay gas in that chain's native token. NEAR Intents removes all of these requirements. The user states a desired outcome; the solver network determines the optimal execution path.

The key distinction is scope. A traditional DEX operates within a single chain and a single liquidity pool. NEAR Intents operates across any supported chain and any available liquidity source. The solver network searches the full available market, not just the pool in front of it.

Protocols like CoW Protocol, an intent-based trading protocol on Ethereum, and UniswapX have introduced intent-based trading at the DEX level on Ethereum. NEAR Intents extends this concept beyond a single chain or single application type to cover any blockchain action.

Composability: What Intent-Based Architecture Changes for Builders

For developers building on NEAR Protocol, intents-based architecture changes how application logic can be composed. Intents can be bundled and composed in ways that individual transactions cannot. A single user-declared intent can trigger a sequence of cross-chain actions that would otherwise require multiple separate transactions, each requiring user confirmation and gas. This composability opens design space for multi-step DeFi interactions expressed as single declarative calls, reducing both user friction and application complexity.

Frequently Asked Questions

What is NEAR Intents?

NEAR Intents is a transaction paradigm on NEAR Protocol where users declare a desired outcome (such as receiving a specific token in exchange for another) rather than specifying each transaction step. A network of competing third-party actors called solvers then fulfills that intent via the most efficient route available. NEAR Intents is not a cryptocurrency or a separate blockchain.

What is chain abstraction in crypto?

Chain abstraction, as coined by NEAR Protocol, is a design vision where the complexity of interacting with multiple blockchains (choosing the right network, managing gas tokens, navigating bridges) is handled by the system rather than the user. NEAR Intents is the primary technical mechanism through which NEAR Protocol delivers on this vision.

What is a solver in blockchain?

A solver, in the context of NEAR Intents, is a permissionless third-party actor that receives broadcast user intents, computes a fulfillment path across available liquidity sources and chains, and executes the transaction on the user's behalf. Solvers compete with each other for each intent, which drives better execution outcomes. They earn a portion of the value their efficient execution creates.

What is the difference between NEAR Intents and account abstraction?

Account abstraction, as implemented by ERC-4337 on Ethereum, abstracts wallet and account management: it changes how your account behaves. NEAR Intents abstracts the transaction outcome and execution path: it changes what you need to know to get a result. The two operate at different layers of the stack. NEAR Protocol's account model has also had native abstraction properties since its launch, predating ERC-4337.

What is Defuse on NEAR?

Defuse is the primary protocol implementing NEAR Intents on mainnet. Built on NEAR Protocol, Defuse enables cross-chain, intent-based trading in live production. It is the flagship application of the NEAR Intents standard, but NEAR Intents is a broader paradigm that any protocol can implement. Defuse shows what the standard makes possible in practice.

How are NEAR Intents different from regular blockchain transactions?

A regular blockchain transaction requires the user to specify every step: the chain, the contract, the route, and the gas payment. A NEAR Intent requires only the desired outcome. The solver network determines the execution path, handles gas, and routes across chains automatically. The result is atomic: either the intent is fulfilled exactly as declared, or it fails entirely with no stranded funds.

What are the use cases of NEAR Intents?

NEAR Intents enables cross-chain token swaps without manual bridging, gas abstraction so users don't need native gas tokens for each chain, optimal trade routing across multiple DEXs simultaneously, multi-step DeFi interactions expressed as single declared outcomes, and chain-agnostic execution where the user does not need to select which blockchain processes their transaction.

Is NEAR Intents the same as ERC-4337?

No. ERC-4337 is Ethereum's account abstraction standard: it changes how wallets and accounts work on Ethereum. NEAR Intents is a transaction outcome paradigm: it changes what users need to specify to complete a blockchain action. The two operate at different layers, and NEAR Protocol has had native account abstraction properties since before ERC-4337 was proposed.

What blockchains does NEAR Intents support?

NEAR Intents, through the Defuse Protocol implementation, supports NEAR Protocol natively along with several other major blockchains including Ethereum and Bitcoin. The list of supported chains expands as the ecosystem develops. For the current and complete list, check the NEAR Protocol official documentation.

Can NEAR Intents do cross-chain swaps?

Yes. Cross-chain token swaps are the flagship use case of NEAR Intents. A user declares the outcome (such as receiving a specific amount of USDC in exchange for ETH) without specifying which chain, which liquidity pool, or which bridge to use. The solver network evaluates all available routes across supported chains and executes via the best path available.

How do solvers compete in NEAR Intents?

When a user's intent is broadcast, all participating solvers receive it simultaneously. Each solver calculates a fulfillment path given current liquidity conditions across chains and DEXs, then submits a quote. The quote offering the best outcome (by price, speed, or user-defined criteria) is selected for execution. This competitive structure aligns solver incentives with the user: better execution earns more reward.

What is the NEAR token used for?

The NEAR token (ticker: NEAR) is the native utility token of NEAR Protocol. It is used to pay transaction fees (gas) on the NEAR Protocol network and to stake for network validation. The NEAR token is not specific to NEAR Intents. It is the base economic layer of the NEAR Protocol blockchain on which NEAR Intents operates.

Official Resources

• NEAR Protocol official documentation - technical details on NEAR Intents architecture and implementation
• NEAR Foundation blog - chain abstraction strategy and NEAR Intents announcements
• ERC-4337 specification - Ethereum's account abstraction standard for comparison
• Defuse Protocol - the primary live implementation of NEAR Intents