Bot de Monitoramento para SushiSwap V3 em Go — Parte 1

mkdir sushiswap-v3-go && cd sushiswap-v3-go
go mod init example.com/sushiswap-v3-go
go get github.com/joho/godotenv
go get modernc.org/sqlite

CHAIN_ID=11155111
NETWORK=sepolia
INFURA_API_KEY=SUA_INFURA_KEY

TOKEN0_ADDRESS=0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14
TOKEN1_ADDRESS=0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238

QUOTE0_ADDRESS=0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2

WALLET=0xSUA_WALLET
PRIVATE_KEY=0xSUA_PRIVATE_KEY

ROUTER_ADDRESS=0x3b0aa7d38bf3c103bf02d1de2e37568cbed3d6e8

PRICE_TO_BUY=5000
AMOUNT_TO_BUY=0.1
PROFITABILITY=1.1

DB_PATH=./bot.db

package main

import (
    "fmt"
    "os"
    "strconv"

    "github.com/joho/godotenv"
)

type Config struct {
    ChainID       int
    Network       string
    InfuraAPIKey  string
    Token0Address string
    Token1Address string
    Quote0Address string
    Wallet        string
    PrivateKey    string
    RouterAddress string
    PriceToBuy    float64
    AmountToBuy   string
    Profitability float64
    DBPath        string
}

func LoadConfig() (*Config, error) {
    _ = godotenv.Load()

    var err error
    cfg := &Config{}

    if v := os.Getenv("CHAIN_ID"); v != "" {
        if cfg.ChainID, err = strconv.Atoi(v); err != nil {
            return nil, fmt.Errorf("CHAIN_ID inválido: %w", err)
        }
    } else {
        cfg.ChainID = 11155111
    }

    cfg.Network = os.Getenv("NETWORK")
    cfg.InfuraAPIKey = os.Getenv("INFURA_API_KEY")
    cfg.Token0Address = os.Getenv("TOKEN0_ADDRESS")
    cfg.Token1Address = os.Getenv("TOKEN1_ADDRESS")
    cfg.Quote0Address = os.Getenv("QUOTE0_ADDRESS")
    cfg.Wallet = os.Getenv("WALLET")
    cfg.PrivateKey = os.Getenv("PRIVATE_KEY")
    cfg.RouterAddress = os.Getenv("ROUTER_ADDRESS")
    cfg.AmountToBuy = os.Getenv("AMOUNT_TO_BUY")

    if v := os.Getenv("PRICE_TO_BUY"); v != "" {
        if cfg.PriceToBuy, err = strconv.ParseFloat(v, 64); err != nil {
            return nil, fmt.Errorf("PRICE_TO_BUY inválido: %w", err)
        }
    } else {
        return nil, fmt.Errorf("PRICE_TO_BUY ausente")
    }

    if v := os.Getenv("PROFITABILITY"); v != "" {
        if cfg.Profitability, err = strconv.ParseFloat(v, 64); err != nil {
            return nil, fmt.Errorf("PROFITABILITY inválido: %w", err)
        }
    } else {
        return nil, fmt.Errorf("PROFITABILITY ausente")
    }

    if cfg.Quote0Address == "" {
        return nil, fmt.Errorf("QUOTE0_ADDRESS ausente")
    }

    if v := os.Getenv("DB_PATH"); v != "" {
        cfg.DBPath = v
    } else {
        cfg.DBPath = "./bot.db"
    }

    return cfg, nil
}

package main

import (
    "database/sql"
    "fmt"

    _ "modernc.org/sqlite"
)

type BotState struct {
    IsOpened   bool
    EntryPrice *float64
}

func InitDB(path string) (*sql.DB, error) {
    db, err := sql.Open("sqlite", path)
    if err != nil {
        return nil, fmt.Errorf("erro abrindo sqlite: %w", err)
    }
    schema := `
    CREATE TABLE IF NOT EXISTS bot_state (
        id INTEGER PRIMARY KEY CHECK (id = 1),
        is_opened INTEGER NOT NULL,
        entry_price REAL
    );
    INSERT INTO bot_state (id, is_opened, entry_price)
        SELECT 1, 0, NULL
        WHERE NOT EXISTS (SELECT 1 FROM bot_state WHERE id = 1);
    `
    if _, err := db.Exec(schema); err != nil {
        return nil, fmt.Errorf("erro criando schema: %w", err)
    }
    return db, nil
}

func LoadBotState(db *sql.DB) (*BotState, error) {
    row := db.QueryRow(`SELECT is_opened, entry_price FROM bot_state WHERE id = 1`)
    var isOpenedInt int
    var entryPrice sql.NullFloat64
    if err := row.Scan(&isOpenedInt, &entryPrice); err != nil {
        return nil, fmt.Errorf("erro lendo estado: %w", err)
    }
    var ep *float64
    if entryPrice.Valid {
        v := entryPrice.Float64
        ep = &v
    }
    return &BotState{
        IsOpened:   isOpenedInt == 1,
        EntryPrice: ep,
    }, nil
}

func SaveBotState(db *sql.DB, st *BotState) error {
    var isOpenedInt int
    if st.IsOpened {
        isOpenedInt = 1
    } else {
        isOpenedInt = 0
    }

    var entry interface{}
    if st.EntryPrice != nil {
        entry = *st.EntryPrice
    }

    if _, err := db.Exec(
        `UPDATE bot_state SET is_opened = ?, entry_price = ? WHERE id = 1`,
        isOpenedInt, entry,
    ); err != nil {
        return fmt.Errorf("erro salvando estado: %w", err)
    }
    return nil
}

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "time"
)

func fetchPriceUSD(tokenAddress string) (float64, error) {
    url := fmt.Sprintf("https://api.sushi.com/price/v1/%d/%s", 1, tokenAddress)

    req, _ := http.NewRequest(http.MethodGet, url, nil)
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 10 * time.Second}
    res, err := client.Do(req)
    if err != nil {
        return 0, err
    }
    defer res.Body.Close()

    if res.StatusCode != http.StatusOK {
        body, _ := io.ReadAll(res.Body)
        return 0, fmt.Errorf("pricing api status %d: %s", res.StatusCode, string(body))
    }

    var price float64
    if err := json.NewDecoder(res.Body).Decode(&price); err != nil {
        return 0, fmt.Errorf("falha ao decodificar preço: %w", err)
    }
    return price, nil
}

package main

import (
    "fmt"
    "log"
    "time"
)

func monitor(cfg *Config) (float64, error) {
    price, err := fetchPriceUSD(cfg.Quote0Address)
    if err != nil {
        return 0, err
    }
    fmt.Print("\033[2J\033[H")
    fmt.Println("Price:", price)
    return price, nil
}

func main() {
    cfg, err := LoadConfig()
    if err != nil {
        log.Fatalf("config erro: %v", err)
    }

    db, err := InitDB(cfg.DBPath)
    if err != nil {
        log.Fatalf("db erro: %v", err)
    }
    defer db.Close()

    state, err := LoadBotState(db)
    if err != nil {
        log.Fatalf("erro carregando estado: %v", err)
    }

    cycle := func() {
        price, err := monitor(cfg)
        if err != nil {
            log.Printf("erro monitorando preço: %v", err)
            return
        }

        if !state.IsOpened && price <= cfg.PriceToBuy {
            state.IsOpened = true
            state.EntryPrice = &price
            if err := SaveBotState(db, state); err != nil {
                log.Printf("erro salvando estado (swap in): %v", err)
            }
            fmt.Printf("Swap in (entry=%.6f)\n", price)
            return
        }

        target := cfg.PriceToBuy * cfg.Profitability
        if state.IsOpened && price >= target {
            state.IsOpened = false
            state.EntryPrice = nil
            if err := SaveBotState(db, state); err != nil {
                log.Printf("erro salvando estado (swap out): %v", err)
            }
            fmt.Printf("Swap out (target=%.6f)\n", target)
            return
        }

        if state.IsOpened && state.EntryPrice != nil {
            fmt.Printf("Wait... (opened at %.6f, target %.6f)\n", *state.EntryPrice, target)
            return
        }

        fmt.Println("Wait...")
    }

    cycle()
    ticker := time.NewTicker(10 * time.Second)
    defer ticker.Stop()
    for range ticker.C {
        cycle()
    }
}

go run .