Projeto de Swap em Pools Raydium CPMM

Guia prático com códigos em Python e TypeScript para swaps em Raydium

physical liquidity pool network hardware

Principais Destaques

Integração Direta com Solana: Uso das APIs e SDKs oficiais para interação com a blockchain.
Códigos Exemplificados: Exemplos detalhados tanto em Python quanto em TypeScript.
Modelo CPMM: Implementação utilizando a fórmula de Produto Constante com \( K = X \times Y \) para determinar os preços nos pools.

Visão Geral do Projeto

Este projeto tem como objetivo criar um swap de moedas em pools de liquidez do Raydium utilizando o modelo Constant Product Market Maker (CPMM). O Raydium é um Automated Market Maker (AMM) construído na blockchain Solana e permite a troca rápida de tokens através de pools de liquidez. A essência do modelo CPMM está na fórmula \(\( K = X \times Y \)\), onde \(X\) e \(Y\) são as quantidades dos tokens presentes no pool e \(K\) é uma constante.

Este guia apresenta duas abordagens principais: uma usando Python e outra utilizando TypeScript. Cada exemplo demonstra a configuração do ambiente, a interação com a blockchain Solana e o código necessário para realizar o swap. Adicionalmente, você encontrará detalhes sobre como calcular as trocas segundo os parâmetros do CPMM, manipular chaves privadas e interagir com os endpoints da Raydium.

Configuração do Ambiente

Pré-requisitos

Conta na blockchain Solana (pode utilizar a rede de testes antes da mainnet).
Chave privada segura configurada para a carteira (ex. Phantom).
Instalação do SDK da Solana e do Raydium SDK conforme a linguagem utilizada.

Instalação das Dependências

Python

Para Python, instale as bibliotecas necessárias via pip:

# Comente: Instalando dependências necessárias para interagir com Solana e requisições HTTP
pip install solana==0.35.0
pip install requests
pip install jsonschema  # Opcional para validação de dados, se necessário

TypeScript

Para projetos com TypeScript, você poderá usar o Raydium SDK instalado via npm:

// Comente: Instalando o Raydium SDK para swap de tokens
npm install @raydium-io/raydium-sdk

Implementação do Swap de Moedas

Lógica do Modelo CPMM

No modelo CPMM, a fórmula fundamental é:

\( \displaystyle K = X \times Y \)

Para calcular a quantidade do token de saída (\(Y_{out}\)) dado um input de token (\( \Delta X \)), a lógica é a seguinte:

\( \displaystyle Y_{out} = Y - \frac{K}{X+\Delta X} \)

Essa lógica garante que o valor de \(K\) permaneça constante após o swap, considerando também ajustes para slippage e taxas, se aplicáveis.

Exemplos com Código

Código em Python para Swap

A seguir, um exemplo simplificado em Python que demonstra como construir uma transação de swap em um pool Raydium CPMM, utilizando a biblioteca Solana para comunicação com a blockchain. Este exemplo inclui a configuração de rede, cálculo dos tokens trocados e a execução da transação.


# Comente: Exemplo de swap de moedas usando Python com a API do Solana e simulação do cálculo CPMM
import json
import requests
from solana.rpc.api import Client
from solana.account import Account
from solana.transaction import Transaction
from solana.publickey import PublicKey

# Configurações iniciais
SOLANA_NETWORK = "https://api.devnet.solana.com"
client = Client(SOLANA_NETWORK)

# Substitua pela sua chave privada (em formato adequado, ex: bytes ou lista de ints)
PRIVATE_KEY = [/* sua chave privada em integers */]
account = Account(PRIVATE_KEY)

# Endereços dos tokens e pool
POOL_ADDRESS = PublicKey("ENDEREÇO_DO_POOL_AQUI")
TOKEN_IN = "TOKEN_A"  # Ex: SOL
TOKEN_OUT = "TOKEN_B"  # Ex: USDC

# Função para listar quantidades atuais do pool via API do Raydium (simulada)
def get_current_pool_quantities():
    # Exemplo estático, implemente a lógica usando as APIs do Raydium para pegar valores reais.
    # x e y representam as reservas dos tokens no pool.
    x = 1_000_000  # Quantidade de TOKEN_IN no pool
    y = 2_000_000  # Quantidade de TOKEN_OUT no pool
    return x, y

def calculate_amount_out(amount_in):
    x, y = get_current_pool_quantities()
    k = x * y
    new_x = x + amount_in
    new_y = k // new_x  # Divisão inteira para simulação
    amount_out = y - new_y
    return amount_out

def perform_swap(token_in, token_out, amount_in):
    amount_out = calculate_amount_out(amount_in)
    
    # Defina o endpoint para o swap, se houver um serviço de backend de Raydium.
    swap_url = "https://api.raydium.io/swap"  # Exemplo, ajuste conforme necessário
    payload = {
        "tokenIn": token_in,
        "tokenOut": token_out,
        "amountIn": amount_in,
        "minAmountOut": amount_out,  # Valor mínimo esperado para o token de saída
        "slippage": 0.01  # tolerância 1%
    }
    
    response = requests.post(swap_url, json=payload)
    if response.status_code == 200:
        print("Swap realizado com sucesso!", response.json())
    else:
        print("Erro ao realizar o swap:", response.text)

# Exemplo de uso: trocando 1_000_000 unidades de TOKEN_IN
perform_swap(TOKEN_IN, TOKEN_OUT, 1_000_000)

Observação: Este exemplo utiliza valores estáticos para obter as reservas do pool. Em um cenário real, você deverá buscar os valores atuais utilizando as APIs do Raydium ou de um serviço de indexação para a blockchain Solana.

Código em TypeScript para Swap

A seguir, um exemplo usando a biblioteca Raydium SDK em TypeScript. Este exemplo cria uma conexão com a blockchain pela rede de desenvolvimento (devnet), configura a carteira e constrói uma transação de swap.


// Comente: Exemplo de swap utilizando o Raydium SDK em TypeScript

import { Connection, PublicKey, Keypair } from '@solana/web3.js';
import { Market, Liquidity, TokenAmount, buildSimpleTransaction } from '@raydium-io/raydium-sdk';
import bs58 from 'bs58';

// Configurações iniciais
const CONNECTION_URL = 'https://api.devnet.solana.com';
const connection = new Connection(CONNECTION_URL);
const WALLET_PRIVATE_KEY = 'SUA_CHAVE_PRIVADA_AQUI'; // em formato base58
const keypair = Keypair.fromSecretKey(bs58.decode(WALLET_PRIVATE_KEY));

// Endereço do pool e tokens envolvidos
const POOL_ADDRESS = 'ENDEREÇO_DO_POOL_AQUI';
const TOKEN_A = 'TOKEN_A'; // Ex: SOL
const TOKEN_B = 'TOKEN_B'; // Ex: USDC
const AMOUNT_IN = 100;  // Quantidade de tokens a serem trocados

async function swapTokens() {
  // Inicializa o mercado com o endereço do pool
  const market = new Market(new PublicKey(POOL_ADDRESS), connection);

  // Cria o objeto de liquidez usando o mercado e o keypair
  const liquidity = new Liquidity(market, keypair);

  // Cria a quantidade de token de entrada
  const tokenAAmount = new TokenAmount(TOKEN_A, AMOUNT_IN);

  // Calcula a quantidade de token de saída com base no CPMM
  const tokenBAmount = await liquidity.calculateAmountOut(tokenAAmount, TOKEN_B);

  // Constrói a transação simples para swap
  const transaction = await buildSimpleTransaction(
    connection,
    keypair,
    market,
    tokenAAmount,
    tokenBAmount
  );

  // Envie a transação para a blockchain
  const txid = await connection.sendTransaction(transaction, [keypair]);
  console.log('Transação enviada:', txid);
}

// Executar a função de swap
swapTokens().catch((error) => {
  console.error('Erro ao processar o swap:', error);
});

Lembre-se de substituir os placeholders (por exemplo, "SUA_CHAVE_PRIVADA_AQUI" e "ENDEREÇO_DO_POOL_AQUI") pelas informações reais correspondentes ao seu projeto. Teste sempre em uma rede de desenvolvimento antes de migrar para a mainnet.

Integração e Monitoramento

Monitorando os Pools de Liquidez

Para manter o controle sobre os valores dos pools de liquidez, recomenda-se a utilização de conexões WebSocket. Isso possibilita que seu sistema seja notificado sobre atualizações em tempo real, observando a mudança nas reservas de tokens e adaptando as transações de swap conforme necessário.

Ferramenta	Descrição	Linguagem
Solana Web3.js	Biblioteca para integração com a blockchain Solana usando TypeScript/JavaScript.	TypeScript/JavaScript
Solana Python SDK	Biblioteca para interagir com Solana e construir transações em Python.	Python
Raydium SDK	SDK para facilitar operações com pools de liquidez e swaps no Raydium.	TypeScript/JavaScript
WebSocket APIs	Para monitoramento em tempo real das atualizações dos pools.	Multiplataforma