Uma foto de Shodipo Ayomide
Todos os artigos

Simplificando transações cross-chain com intents

·
18 de set. de 2025
·
7 min de leitura
·
••• visualizações
·
••• curtidas

Traduzido do artigo original em inglês. Ler em inglês

Simplificando transações cross-chain com intents

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:

 {
  "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

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
Fluxograma mostrando Criação da intent → Competição entre solvers → Pipeline de liquidação

O design em três camadas

A lógica central de verificação:

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
Diagrama mostrando a pilha de três camadas com o fluxo de dados

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:

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.

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:

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á:

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 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
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:

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:

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 domina o trading no Ethereum, o CoW Protocol se destaca na proteção contra MEV e o 1inch Fusion oferece agregação de DEXs.

Links essenciais

•••
Compartilhe este artigo:

Fique por dentro

Receba os artigos mais recentes no seu e-mail.