# Simplificando transações cross-chain com intents

> E se eu te dissesse que existe um jeito melhor? E se você pudesse simplesmente dizer que quer 100 SOL pelos seus 1000 USDC e deixar a blockchain resolver o resto?

Por Shodipo Ayomide, publicado em 18 de set. de 2025. Versão web: https://blog.shodipoayomide.com/pt/simplifying-cross-chain-transactions-using-intents

![Simplificando transações cross-chain com intents](https://blog.shodipoayomide.com/banners/Simplifying-Cross-Chain-Transactions-Using-Intents.png)

Vamos seguir este cenário - Você está tentando trocar `1,000 USDC` no `Ethereum` por um pouco de `SOL` na `Solana`. Com as bridges tradicionais, você teria que fazer o wrap dos seus USDC, encontrar uma bridge **(torcendo para ela não ser hackeada)**, esperar 20 minutos ou mais pela finalidade, pagar taxas absurdas e depois fazer o unwrap do outro lado. Quando você termina, o preço já mudou, você já queimou `$50` em gas e está questionando as suas escolhas de vida, Caramba!

E se eu te dissesse que existe um jeito melhor? E se você pudesse simplesmente dizer **quero 100 SOL pelos meus 1000 USDC** e deixar a blockchain resolver o resto? É exatamente isso que as intents fazem. Elas deixam você declarar exatamente o que quer, em vez de passar por todo o trabalho de conseguir isso.

## O que são intents?

Pense em `intents` como a diferença entre dizer para alguém **"dirija até o supermercado, vire à esquerda na ilford high road, estacione na vaga 11 e vá a pé até o corredor 5..."** e simplesmente dizer **"me traz leite"**. O resultado é basicamente o mesmo, mas uma abordagem é declarativa **"(exatamente o que você quer)** enquanto a outra é imperativa **(instruções passo a passo)**.

Em termos técnicos, `intents` são mensagens assinadas que expressam o resultado que um usuário deseja sem especificar os detalhes de execução. Em vez de montar sequências complexas de transações você mesmo, você transmite a sua intent para uma rede de `solvers` **(atores sofisticados)** que então competem para atender ao seu pedido.

É assim que uma intent de exemplo se parece:

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

Bem simples, né? A Alice não está nem aí para a complexidade do roteamento, ela só quer os seus SOL em troca dos seus USDC e pronto.

## Por que as intents existem - O problema cross-chain

Os protocolos DeFi cross-chain são bem complexos para o usuário comum. Ele precisa entender protocolos diferentes, gerenciar vários tokens de gas e se virar no meio de um monte de riscos de segurança. As soluções tradicionais muitas vezes envolvem:

1. Fluxos complexos de várias etapas em chains diferentes
2. Vulnerabilidades de segurança vindas do wrapping e do bridging de ativos
3. Uma experiência ruim para o usuário comum, que exige conhecimento técnico profundo
4. Liquidez fragmentada e preços abaixo do ideal

As intents viram esse modelo de cabeça para baixo. Em vez de empurrar a complexidade para os usuários, o sistema a puxa para uma rede competitiva de solvers. Os usuários expressam o que desejam, os solvers descobrem como executar, todo mundo ganha 🔥.

## O que são solvers e como eles funcionam?

Os solvers, neste contexto, são a espinha dorsal dos sistemas baseados em intents. Eles são atores especializados, podem ser market makers, agentes de IA ou traders sofisticados - que competem para atender às intents dos usuários dentro do sistema.

**É assim que funciona:** quando você transmite uma intent, vários solvers a analisam e enviam cotações concorrentes. Eles podem rotear por `DEXs` diferentes, usar liquidez off-chain ou até agrupar a sua intent com outras para conseguir preços melhores. A melhor solução vence.

Agora, pense nos solvers como os seus assistentes pessoais de trading, que entendem cada protocolo conectado, cada fonte de liquidez e cada truque de otimização em DeFi. Eles ganham dinheiro oferecendo uma execução melhor do que você conseguiria sozinho e ainda te poupam muito tempo.

## Intents tradicionais

Arquiteturas baseadas em intents não são um conceito totalmente novo. O `UniswapX` foi pioneiro no conceito para o `Ethereum`, processando mais de **$2B** em volume por meio de `Dutch auctions` em que **"fillers"** competem para atender a pedidos de swap.

O `CoW` Protocol expandiu isso com `batch auctions` e proteção contra `MEV`, acumulando mais de **$15B** em volume negociado. A sacada deles? Agrupando intents e encontrando coincidências de desejos, eles conseguiram eliminar o `MEV` e ao mesmo tempo melhorar a execução.

Mas esses sistemas ainda são soluções de uma única chain. O `UniswapX` funciona muito bem para trades no ecossistema `ETH`, mas e cross-chain? Você volta para o inferno da complexidade, bem-vindo de volta!

## Como o NEAR Protocol resolveu isso

O NEAR Protocol construiu o primeiro sistema de intents de fato cross-chain. Os números falam por si: mais de **$1.075B** em volume total, finalidade de 2-3 segundos e suporte nativo a Bitcoin sem wrapping.

Como eles conseguiram isso? `Chain Signatures`. Por meio de computação multipartidária (MPC), os validadores da NEAR conseguem assinar transações em blockchains externas de forma coletiva, sem que nenhuma parte sozinha tenha as chaves privadas. É como ter um controle remoto universal para todo o ecossistema cripto.

## Criando uma intent

```typescript
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);
```

_Fluxograma mostrando Criação da intent → Competição entre solvers → Pipeline de liquidação, com três fases e atores distintos_
![Fluxograma mostrando Criação da intent → Competição entre solvers → Pipeline de liquidação](https://i.ibb.co/ymmnn7ym/Screenshot-2025-09-18-at-9-29-13-PM.png)

### O design em três camadas

- **Distribuição**: Apps, carteiras e exchanges onde os usuários criam essas intents.

- **Redes de solvers**: Market makers descentralizados, agentes de IA ou similares competindo para atender aos pedidos. Eles acessam liquidez de CEXs, DEXs ou fontes off-chain.

- **Verificador**: O smart contract da NEAR que garante a liquidação atômica das intents.

A lógica central de verificação:

```rust
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(())
}
```

Esse cara garante o equilíbrio perfeito, para cada token que sai, uma quantidade equivalente entra, considerando todas as intents agrupadas.

_Diagrama mostrando a pilha de três camadas com o fluxo de dados entre Distribuição, Redes de solvers e o Verificador, incluindo componentes específicos como 1Click API, MPC Network e Chain Signatures_
![Diagrama mostrando a pilha de três camadas com o fluxo de dados](https://i.ibb.co/JRwJPB28/Screenshot-2025-09-18-at-9-30-22-PM.png)

### Falando sobre a 1Click API

Parte do segredo para fazer isso funcionar em escala é a `1Click API`, esse cara abstrai toda a complexidade de ponta a ponta. Os desenvolvedores conseguem criar intents cross-chain sem pensar em `MPC`, `Chain Signatures` ou `solver routing`. Ela cuida de buscar cotações de vários solvers, escolhe a melhor rota entre `DEXs` e `bridges`, acompanha a execução, lida com as novas tentativas e até cuida da otimização de gas e do timing, tudo em uma única chamada de api, todo o resto é resolvido por baixo dos panos.

### Construindo com a 1Click API

Como fica:

```javascript
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}`));
}
```

Leia mais sobre isso [aqui](https://docs.near-intents.org/near-intents/integration/distribution-channels/1click-api).

### Olhando para o Defuse Protocol

O Defuse simplesmente mostra como construir interfaces de `DEX` de produção com intents. Em vez de gerenciar uma lógica de roteamento complexa, você tem:

```typescript
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);
```

Isso te dá:

- Vários solvers competindo pelos melhores preços
- Liquidação cross-chain
- Cotações em tempo real a cada 10 segundos

O client cuida de toda a complexidade, os usuários só veem o melhor preço e a execução mais rápida, e seguem em frente.

### Olhando para o Paycrest

O [Paycrest](https://paycrest.io) conecta as intents da blockchain aos sistemas de pagamento tradicionais. Funciona assim:

1. Criação da intent: O usuário diz **"pague esta fatura com qualquer token"**
2. Descoberta de rota: O sistema encontra o caminho ideal de conversão `crypto-to-fiat`
3. Execução: Faz automaticamente o swap de `crypto` para um ativo estável e depois para um pagamento em fiat

```go
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)
    }
}
```

O principal desafio está nos pagamentos entre sistemas que conectam cripto e fiat. O Paycrest lida com isso em várias etapas:

- Passo 1: Converter a cripto do usuário em um ativo estável (USDC)
- Passo 2: Fazer o off-ramp da stable para fiat por meio de parceiros de pagamento
- Passo 3: Entregar o pagamento em fiat ao destinatário

## Por que isso escala

1. **Competição entre solvers:** Um mercado competitivo de solvers garante uma execução eficiente on-chain. À medida que o número de solvers na rede aumenta, a competição derruba os custos e melhora a velocidade de execução para os usuários. Esse mercado aberto também incentiva o suporte a uma variedade maior de ativos e permite a integração de solvers avançados, como agentes de IA, capazes de operações algorítmicas complexas.

2. Efeitos de rede do batching: Um volume maior de intents dos usuários permite que um `verifier` agregue várias operações em uma única transação on-chain otimizada, o que vai diluindo os custos fixos (como as taxas de gas) entre muitos usuários, resultando em taxas menores e mais eficiência de capital para todo mundo na rede.

3. Paralelização multi-chain: As intents podem ser paralelizadas e executadas em várias blockchains, o que melhora bastante em relação ao modelo de processamento sequencial de muitas bridges tradicionais. Um trade complexo envolvendo ativos no Ethereum, na Solana e no Bitcoin pode ser liquidado de forma concorrente, reduzindo o tempo total e a latência das transações cross-chain.

**Simplificando o roteamento complexo**

Esses mecanismos abstraem do usuário a complexidade operacional por baixo. O snippet abaixo mostra como um usuário pode especificar uma transação cross-chain com vários hops e gas otimizado em um único pedido:

```javascript
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
    }
  })
});
```

A API cuida da otimização, do timing e da recuperação de falhas automaticamente.

## Considerações finais

A `NEAR` não é a única fazendo isso. O [UniswapX](https://x.uniswap.org/) domina o trading no `Ethereum`, o [CoW Protocol](https://cow.fi) se destaca na proteção contra MEV e o [1inch Fusion](https://fusion.1inch.io) oferece agregação de DEXs.

## Links essenciais

- [Documentação oficial do NEAR Intents](https://docs.near.org/chain-abstraction/intents/overview) - Visão geral técnica completa e guias de integração
- [Hub do projeto NEAR Intents](https://near-intents.org/) - Site principal do projeto com novidades do ecossistema
- [Documentação da 1Click API](https://docs.near-intents.org/near-intents/integration/distribution-channels/1click-api) - Referência da API REST para desenvolvedores
- [Documentação do NEAR Intents SDK](https://docs.near-intents.org/near-intents/sdk) - Referência completa do SDK e exemplos
- [Contratos principais do NEAR Intents](https://github.com/near/intents) - Implementações dos smart contracts e código Rust
- [Defuse Protocol SDK](https://www.npmjs.com/package/@defuse-protocol/intents-sdk) - Pacote NPM para integração de DEX cross-chain
- [Implementação do frontend do Defuse](https://github.com/defuse-protocol/defuse-frontend) - Frontend de DEX em produção usando intents
- [Paycrest Aggregator](https://github.com/paycrest/aggregator) - Processamento de intents de pagamento e integração entre sistemas
- [Paycrest NoBlocks](https://github.com/paycrest/noblocks) - Execução de transações sem gas para intents