Documentação de Integração Sloteflix

https://{SLOTEFLIX_HOST}/api/v1

endpoint configurado : https://minhaoperacao.com
callback resolvido   : https://minhaoperacao.com/api/sloteflix_api

Content-Type: application/json
Accept: application/json
Connection: keep-alive
X-Attempt: 1        # 1, 2 ou 3

# 1) confirme que o catálogo responde
curl -s "https://{SLOTEFLIX_HOST}/api/v1/games/games-status" | head -c 300

# 2) abra um jogo (troque game_id por um game_code do catálogo)
curl -s -G "https://{SLOTEFLIX_HOST}/api/v1/games/game_launch" \
  --data-urlencode "agent_code=meu_agente" \
  --data-urlencode "agent_token=$SLOTEFLIX_AGENT_TOKEN" \
  --data-urlencode "game_id=vs20olympgate" \
  --data-urlencode "type=CHARGED" \
  --data-urlencode "currency=BRL" \
  --data-urlencode "lang=BR" \
  --data-urlencode "demo_agent=0" \
  --data-urlencode "user_id=1042"

use Illuminate\Support\Facades\Http;

$response = Http::withQueryParameters([
    'agent_code'  => config('sloteflix.agent_code'),
    'agent_token' => config('sloteflix.agent_token'),
    'game_id'     => 'vs20olympgate',
    'type'        => 'CHARGED',
    'currency'    => 'BRL',
    'lang'        => 'BR',
    'demo_agent'  => 0,
    'user_id'     => (string) $player->id,
])->get(config('sloteflix.base_url') . '/games/game_launch');

if ($response->successful() && $response->json('game_url')) {
    return redirect()->away($response->json('game_url'));
}

report(new RuntimeException('Sloteflix launch falhou: ' . $response->body()));
return back()->withErrors('Jogo indisponível no momento.');

const params = new URLSearchParams({
  agent_code:  process.env.SLOTEFLIX_AGENT_CODE,
  agent_token: process.env.SLOTEFLIX_AGENT_TOKEN,
  game_id:     'vs20olympgate',
  type:        'CHARGED',
  currency:    'BRL',
  lang:        'BR',
  demo_agent:  '0',
  user_id:     String(player.id),
});

const res  = await fetch(`${process.env.SLOTEFLIX_BASE_URL}/games/game_launch?${params}`);
const json = await res.json();

if (!res.ok || !json.game_url) throw new Error(`launch falhou: ${JSON.stringify(json)}`);
return json.game_url;

import os, requests

params = {
    "agent_code":  os.environ["SLOTEFLIX_AGENT_CODE"],
    "agent_token": os.environ["SLOTEFLIX_AGENT_TOKEN"],
    "game_id":     "vs20olympgate",
    "type":        "CHARGED",
    "currency":    "BRL",
    "lang":        "BR",
    "demo_agent":  0,
    "user_id":     str(player.id),
}

r = requests.get(
    f"{os.environ['SLOTEFLIX_BASE_URL']}/games/game_launch",
    params=params, timeout=10,
)
r.raise_for_status()
game_url = r.json()["game_url"]

{ "bet": 1.50, "win": 0 }      // ✅ R$ 1,50
{ "bet": 150,  "win": 0 }      // ❌ isso é R$ 150,00, não R$ 1,50

TOKEN=$(printf '%s:%s' "$SLOTEFLIX_AGENT_TOKEN" "$SLOTEFLIX_AGENT_SECRET" | base64)

curl -s -X POST "https://{SLOTEFLIX_HOST}/api/v1/auth/authentication" \
  -H "Authorization: Bearer $TOKEN"

use Illuminate\Support\Facades\Http;

$basic = base64_encode(config('sloteflix.agent_token') . ':' . config('sloteflix.agent_secret_key'));

$response = Http::withHeaders(['Authorization' => "Bearer {$basic}"])
    ->post(config('sloteflix.base_url') . '/auth/authentication');

abort_unless($response->successful(), 502, 'Sloteflix auth falhou');

$jwt = $response->json('access_token');

const basic = Buffer
  .from(`${process.env.SLOTEFLIX_AGENT_TOKEN}:${process.env.SLOTEFLIX_AGENT_SECRET}`)
  .toString('base64');

const res = await fetch(`${process.env.SLOTEFLIX_BASE_URL}/auth/authentication`, {
  method:  'POST',
  headers: { Authorization: `Bearer ${basic}` },
});

const { access_token } = await res.json();

{
  "access_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...",
  "token_type": "bearer"
}

// Bearer ausente, não-Base64, ou sem os dois-pontos
{ "status": false, "error": "INVALID_TOKEN" }

// par token:secret não corresponde a nenhum agente
{ "status": false, "error": "INVALID_AGENT" }

{
  "game_url": "https://provider.example/launch?token=eyJhbGciOi...&lang=BR"
}

// falta um parâmetro obrigatório (formato padrão do validador Laravel)
{ "game_id": ["The game id field is required."] }

// user_id vazio ou igual a 0
{ "error": "Invalid user ID" }

// agent_code não existe
{ "error": "Agent not found" }

// agent_token não corresponde ao agent_code
{ "error": "Invalid agent token" }

// jogo inexistente, inativo, ou nenhum distribuidor conseguiu abrir
{ "status": false, "error": "INVALID_GAME" }

{
  "status": true,
  "games": [
    {
      "id": 1841,
      "provider_id": 12,
      "game_server_url": null,
      "game_id": "1301",
      "game_name": "Gates of Olympus",
      "game_code": "vs20olympgate",
      "game_type": "slot",
      "description": null,
      "cover": "https://cdn.example/games/vs20olympgate.png",
      "status": "1",
      "technology": "html5",
      "has_lobby": 0,
      "is_mobile": 1,
      "has_freespins": 1,
      "has_tables": 0,
      "only_demo": 0,
      "distribution": "slots",
      "created_at": "2024-03-02T18:11:04.000000Z",
      "updated_at": "2025-06-18T09:42:57.000000Z"
    }
  ]
}

{
  "status": true,
  "games": ["vs20olympgate", "vs20fruitsw", "spribe_aviator", "pgs_fortunetiger"]
}

curl -s -X POST "https://{SLOTEFLIX_HOST}/api/v1/games/to-add" \
  -H "Content-Type: application/json" \
  -d '{"games":["vs20olympgate","vs20fruitsw"]}'

{
  "status": true,
  "games": [
    { "id": 1841, "game_code": "vs20olympgate", "game_name": "Gates of Olympus", "...": "..." }
  ]
}

curl -s "https://{SLOTEFLIX_HOST}/api/v1/games/provider" \
  -H "Authorization: Bearer $JWT"

$response = Http::withToken($jwt)
    ->get(config('sloteflix.base_url') . '/games/provider');

$providers = $response->json('providers');

{
  "status": true,
  "providers": [
    { "id": 12, "name": "Pragmatic Play", "code": "pragmatic-play", "status": 1 }
  ]
}

TOKEN=$(printf '%s:%s' "$SLOTEFLIX_AGENT_TOKEN" "$SLOTEFLIX_AGENT_SECRET" | base64)

curl -s -X POST "https://{SLOTEFLIX_HOST}/api/v1/games/get-clone-status" \
  -H "Authorization: Bearer $TOKEN"

// 200
{ "status": true, "is_cloned": 1 }

// 400 — Bearer ausente
{ "status": false, "error": "INVALID_TOKEN" }

// 400 — Base64 decodificado não tem o formato "token:secret"
{ "status": false, "error": "INVALID_TOKEN2" }

// 400 — par não corresponde a nenhum agente
{ "status": false, "error": "INVALID_AGENT" }

{ "status": true, "is_cloned": false }

curl -s -X POST "https://{SLOTEFLIX_HOST}/api/v1/games/freespin" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_code":    "meu_agente",
    "agent_token":   "'"$SLOTEFLIX_AGENT_TOKEN"'",
    "user_id":       "1042",
    "game_id":       "vs20olympgate",
    "betlevel":      1,
    "freespincount": 20,
    "expiretime":    "2026-08-30 23:59:59",
    "freespinID":    "promo-2026-08-1042"
  }'

// 200 — o conteúdo de "status" vem do distribuidor
{ "status": true }

// 400
{ "error": "Agent not found" }
{ "error": "Invalid agent token" }
{ "error": "Game not found or inactive" }
{ "error": "No active distributor found for this game" }

// Sucesso
{
  "status": 1,
  "balance": 1234.56
}

// Falha — use o código apropriado da tabela de status
{
  "status": 0,
  "error": "Insufficient funds"
}

{
  "method": "account_details",
  "game": "vs20olympgate",
  "agent_code": "meu_agente",
  "agent_token": "3f8a…",
  "agent_secret_key": "9b1c…",
  "user_id": "1042"
}

{
  "status": 1,
  "message": "SUCCESS",
  "balance": 1500.00,
  "user_id": "1042",
  "email": "jogador@example.com",
  "date": "2024-11-02 14:31:07"
}

{
  "method": "user_balance",
  "game": "vs20olympgate",
  "agent_code": "meu_agente",
  "agent_token": "3f8a…",
  "agent_secret_key": "9b1c…",
  "user_id": "1042"
}

{ "status": 1, "balance": 1498.50 }

{
  "method": "transaction",
  "type": "bet",
  "session_id": "eyJpdiI6IkQr…",
  "game": "vs20olympgate",
  "agent_code": "meu_agente",
  "agent_token": "3f8a…",
  "agent_secret_key": "9b1c…",
  "round_id": "timeless-88213004",
  "transaction_id": "timeless-99551277",
  "bet": 1.50,
  "win": 0,
  "user_id": "1042",
  "distributor": "timeless"
}

// Debitado com sucesso
{ "status": 1, "balance": 1497.00 }

// Saldo insuficiente — a rodada é rejeitada
{ "status": 0, "balance": 0.80, "error": "Insufficient funds" }

// Já processada — devolva sucesso com o saldo atual (idempotência)
{ "status": 1, "balance": 1497.00 }

{
  "method": "transaction",
  "type": "win",
  "session_id": "eyJpdiI6IkQr…",
  "game": "vs20olympgate",
  "agent_code": "meu_agente",
  "agent_token": "3f8a…",
  "agent_secret_key": "9b1c…",
  "transaction_id": "timeless-99551301",
  "transaction_id_old": "timeless-88213004",
  "round_id": "timeless-88213004",
  "bet": 0,
  "win": 45.00,
  "user_id": "1042",
  "distributor": "timeless"
}

{ "status": 1, "balance": 1542.00 }

{
  "method": "refund",
  "agent_code": "meu_agente",
  "agent_token": "3f8a…",
  "agent_secret_key": "9b1c…",
  "transaction_id": "timeless-99551277",
  "user_id": "1042",
  "distributor": "timeless",
  "balance": true
}

// Estornado
{ "status": 1, "balance": 1498.50 }

// Já estornado — devolva sucesso, não erro (idempotência)
{ "status": 1, "balance": 1498.50 }

// transaction_id desconhecido
{ "status": 14, "balance": 1498.50, "error": "Transaction not found" }

{
  "method": "rollback",
  "agent_code": "meu_agente",
  "agent_token": "3f8a…",
  "agent_secret_key": "9b1c…",
  "user_id": "1042",
  "transaction_id": "betby-77120043",
  "amount": 45.00,
  "distributor": "betby"
}

{ "status": 1, "balance": 1497.00 }

CREATE TABLE sloteflix_transactions (
  id              BIGSERIAL PRIMARY KEY,
  transaction_id  VARCHAR(191) NOT NULL,
  round_id        VARCHAR(191),
  player_id       BIGINT       NOT NULL,
  method          VARCHAR(32)  NOT NULL,   -- transaction | refund | rollback
  type            VARCHAR(16),             -- bet | win
  amount          DECIMAL(20,2) NOT NULL,
  balance_after   DECIMAL(20,2) NOT NULL,
  distributor     VARCHAR(32),
  game            VARCHAR(191),
  session_id      VARCHAR(191),
  refunded_at     TIMESTAMP NULL,
  created_at      TIMESTAMP NOT NULL DEFAULT now(),

  CONSTRAINT uq_sloteflix_tx UNIQUE (transaction_id)
);

CREATE INDEX idx_sloteflix_player_round ON sloteflix_transactions (player_id, round_id);

public function bet(array $payload): array
{
    return DB::transaction(function () use ($payload) {
        // 1) idempotência: já vi esse transaction_id?
        $existing = SloteflixTransaction::where('transaction_id', $payload['transaction_id'])->first();
        if ($existing) {
            return ['status' => 1, 'balance' => (float) $existing->balance_after];
        }

        // 2) trava a carteira — jogador com duas abas gera apostas concorrentes
        $wallet = Wallet::where('user_id', $payload['user_id'])->lockForUpdate()->first();
        if (! $wallet) {
            return ['status' => 4, 'balance' => 0, 'error' => 'Player not found'];
        }

        $bet = round((float) $payload['bet'], 2);
        if (bccomp((string) $wallet->balance, (string) $bet, 2) < 0) {
            return ['status' => 0, 'balance' => (float) $wallet->balance, 'error' => 'Insufficient funds'];
        }

        // 3) debita e registra na MESMA transação
        $wallet->decrement('balance', $bet);
        $wallet->refresh();

        SloteflixTransaction::create([
            'transaction_id' => $payload['transaction_id'],
            'round_id'       => $payload['round_id']    ?? null,
            'player_id'      => $payload['user_id'],
            'method'         => 'transaction',
            'type'           => 'bet',
            'amount'         => $bet,
            'balance_after'  => $wallet->balance,
            'distributor'    => $payload['distributor'] ?? null,
            'game'           => $payload['game']        ?? null,
            'session_id'     => $payload['session_id']  ?? null,
        ]);

        return ['status' => 1, 'balance' => (float) $wallet->balance];
    }, attempts: 3);
}

// routes/api.php
// IMPORTANTE: fora dos middlewares de sessão/CSRF, e fora do maintenance mode.
Route::post('/sloteflix_api', [SloteflixWalletController::class, 'handle'])
    ->withoutMiddleware([\App\Http\Middleware\VerifyCsrfToken::class]);


class SloteflixWalletController extends Controller
{
    public function handle(Request $request)
    {
        $payload = $request->all();

        // 1) autentica o trio de credenciais em tempo constante
        if (! $this->validCredentials($payload)) {
            return response()->json(['status' => 7, 'balance' => 0, 'error' => 'Invalid token']);
        }

        // 2) roteia por method (+ type quando for transaction)
        $key = $payload['method'] ?? '';
        if ($key === 'transaction') {
            $key .= ':' . ($payload['type'] ?? '');
        }

        try {
            return response()->json(match ($key) {
                'account_details'     => $this->wallet->accountDetails($payload),
                'user_balance',
                'balance'             => $this->wallet->balance($payload),
                'transaction:bet'     => $this->wallet->bet($payload),
                'transaction:win'     => $this->wallet->win($payload),
                'refund'              => $this->wallet->refund($payload),
                'rollback'            => $this->wallet->rollback($payload),
                default               => ['status' => 6, 'balance' => 0, 'error' => "Unknown method: {$key}"],
            });
        } catch (\Throwable $e) {
            // NUNCA deixe uma exceção virar HTML — sempre JSON com status numérico
            report($e);
            return response()->json(['status' => 5, 'balance' => 0, 'error' => 'Internal error']);
        }
    }

    private function validCredentials(array $p): bool
    {
        $agent = config('sloteflix.agents.' . ($p['agent_code'] ?? ''));
        if (! $agent) {
            return false;
        }

        return hash_equals($agent['token'],  (string) ($p['agent_token']      ?? ''))
            && hash_equals($agent['secret'], (string) ($p['agent_secret_key'] ?? ''));
    }
}

import express from 'express';
import crypto from 'node:crypto';

const app = express();
app.use(express.json({ limit: '256kb' }));

const AGENTS = {
  [process.env.SLOTEFLIX_AGENT_CODE]: {
    token:  process.env.SLOTEFLIX_AGENT_TOKEN,
    secret: process.env.SLOTEFLIX_AGENT_SECRET,
  },
};

const safeEqual = (a = '', b = '') => {
  const ba = Buffer.from(String(a));
  const bb = Buffer.from(String(b));
  return ba.length === bb.length && crypto.timingSafeEqual(ba, bb);
};

app.post('/api/sloteflix_api', async (req, res) => {
  const p = req.body ?? {};
  const agent = AGENTS[p.agent_code];

  if (!agent || !safeEqual(agent.token, p.agent_token) || !safeEqual(agent.secret, p.agent_secret_key)) {
    return res.json({ status: 7, balance: 0, error: 'Invalid token' });
  }

  const key = p.method === 'transaction' ? `transaction:${p.type}` : p.method;

  try {
    switch (key) {
      case 'account_details':  return res.json(await wallet.accountDetails(p));
      case 'user_balance':
      case 'balance':          return res.json(await wallet.balance(p));
      case 'transaction:bet':  return res.json(await wallet.bet(p));
      case 'transaction:win':  return res.json(await wallet.win(p));
      case 'refund':           return res.json(await wallet.refund(p));
      case 'rollback':         return res.json(await wallet.rollback(p));
      default:
        return res.json({ status: 6, balance: 0, error: `Unknown method: ${key}` });
    }
  } catch (err) {
    req.log?.error({ err, payload: p }, 'seamless handler failed');
    return res.json({ status: 5, balance: 0, error: 'Internal error' });
  }
});

// Handler de erro final: garante JSON mesmo em body malformado
app.use((err, _req, res, _next) => res.json({ status: 5, balance: 0, error: 'Internal error' }));

import hmac, os
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse

app = FastAPI()

AGENTS = {
    os.environ["SLOTEFLIX_AGENT_CODE"]: {
        "token":  os.environ["SLOTEFLIX_AGENT_TOKEN"],
        "secret": os.environ["SLOTEFLIX_AGENT_SECRET"],
    }
}

def valid(p: dict) -> bool:
    agent = AGENTS.get(p.get("agent_code", ""))
    if not agent:
        return False
    return (hmac.compare_digest(agent["token"],  str(p.get("agent_token", "")))
            and hmac.compare_digest(agent["secret"], str(p.get("agent_secret_key", ""))))

@app.post("/api/sloteflix_api")
async def sloteflix_api(request: Request):
    p = await request.json()

    if not valid(p):
        return JSONResponse({"status": 7, "balance": 0, "error": "Invalid token"})

    key = f"transaction:{p.get('type')}" if p.get("method") == "transaction" else p.get("method")

    handlers = {
        "account_details":  wallet.account_details,
        "user_balance":     wallet.balance,
        "balance":          wallet.balance,
        "transaction:bet":  wallet.bet,
        "transaction:win":  wallet.win,
        "refund":           wallet.refund,
        "rollback":         wallet.rollback,
    }

    handler = handlers.get(key)
    if handler is None:
        return JSONResponse({"status": 6, "balance": 0, "error": f"Unknown method: {key}"})

    try:
        return JSONResponse(await handler(p))
    except Exception:
        logger.exception("seamless handler failed", extra={"payload": p})
        return JSONResponse({"status": 5, "balance": 0, "error": "Internal error"})

curl -s -o /dev/null -w 'HTTP %{http_code} · %{time_total}s\n' \
  -X POST "https://minhaoperacao.com/api/sloteflix_api" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "X-Attempt: 1" \
  -d '{
    "method":           "transaction",
    "type":             "bet",
    "session_id":       "test-session",
    "game":             "vs20olympgate",
    "agent_code":       "meu_agente",
    "agent_token":      "'"$SLOTEFLIX_AGENT_TOKEN"'",
    "agent_secret_key": "'"$SLOTEFLIX_AGENT_SECRET"'",
    "round_id":         "test-round-1",
    "transaction_id":   "test-tx-1",
    "bet":              1.50,
    "win":              0,
    "user_id":          "1042",
    "distributor":      "timeless"
  }'

# time_total tem que ficar bem abaixo de 0.600s.
# Rode de novo com o MESMO transaction_id: o saldo não pode mudar (idempotência).

{
  "id": 87,
  "message": "Agente criado com sucesso",
  "data": {
    "agent_sponsor_id": 1,
    "agent_id": 412,
    "is_cloned": 1,
    "agent_code": "minhaoperacao",
    "agent_token": "Xk9pQ2mL7vRt4nZa8YbW3cJhF6sDgE1u",
    "agent_secret_key": "Tq5wH8jN2bV6xM1oPzL4rK7yA3cS9dFg",
    "agent_type": "default",
    "agent_status": 1,
    "api_type": "seamless",
    "ggr": 20,
    "ggr_cloned": 20,
    "balance": 200000000,
    "endpoint": "https://minhaoperacao.lumosgaming.com",
    "id": 87
  }
}

// 200 — e-mail já tem agente: devolve o existente, não cria outro
{ "message": "Agente já existente", "data": { "...": "..." } }

// 400 — e-mail existe como usuário, mas sem agente vinculado
{ "message": "Usuário existente, mas sem agente associado." }

// 400 — erro de validação
{ "email": ["The email field must be a valid email address."] }

// 403 — token mestre inválido
{ "message": "Acesso não autorizado. Token inválido." }

curl -s -X POST "https://{SLOTEFLIX_HOST}/api/v1/agents/consult" \
  -H "Content-Type: application/json" \
  -d '{
    "token":      "'"$SLOTEFLIX_MASTER_TOKEN"'",
    "agent_code": "minhaoperacao",
    "start_date": "2026-07-01",
    "end_date":   "2026-07-31"
  }'

// 200
{
  "data": [
    { "provider": "pragmatic-play", "total_bet": "184320.50", "total_win": "171004.25" },
    { "provider": "pgsoft",         "total_bet": "92110.00",  "total_win": "88740.10"  }
  ]
}

// 404 — agente inexistente
{ "message": "Agente não encontrado." }

// 404 — nenhum dado no período (note: 404, não 200 com lista vazia)
{ "message": "Nenhum dado encontrado para o período especificado." }

// 400 — formato de data inválido
{ "start_date": ["The start date does not match the format Y-m-d."] }

// 403 — token mestre inválido
{ "message": "Acesso não autorizado. Token inválido." }

curl -s -X POST "https://{SLOTEFLIX_HOST}/api/v1/agents/get-agent-data" \
  -H "Content-Type: application/json" \
  -d '{"agent_code":"minhaoperacao","agent_token":"'"$SLOTEFLIX_AGENT_TOKEN"'"}'

// 200
{ "id": 87, "agent_code": "minhaoperacao" }

// 400
{ "error": "Agent not found" }
{ "error": "Invalid agent token" }

{
  "message": "Status consultado com sucesso",
  "data": { "id": 87, "agent_code": "minhaoperacao", "status": true }
}

{
  "message": "Status ativado com sucesso para o agente minhaoperacao",
  "data": { "id": 87, "agent_code": "minhaoperacao", "status": true }
}

{
  "game_id": ["The game id field is required."],
  "currency": ["The currency field is required."]
}

{
  "status": 15,
  "error": "Falha após 3 tentativas: resposta não é JSON válido"
}