PRocket API

npm install procketapi

# Библиотека не нужна — API это обычный POST с JSON

import { Bot } from "grammy";
import { PRocket } from "procketapi";

const bot = new Bot("ТОКЕН_БОТА");
const procket = new PRocket("ВАШ_КЛЮЧ");

bot.on("message", async (ctx, next) => {
  // Не подписан — клиент сам отправит спонсоров
  const result = await procket.check(ctx.from.id, { bot });
  if (!result.passed) return;

  await next();
});

bot.command("start", (ctx) => ctx.reply("Доступ открыт"));
bot.start();

curl -X POST https://app.procket.club/api/v2/check \
  -H "Content-Type: application/json" \
  -H "Auth: ВАШ_КЛЮЧ" \
  -d '{"user_id": 123456789, "language_code": "ru"}'

{
  "key": "ВАШ_КЛЮЧ",
  "user_id": 123456789
}

import TelegramBot from "node-telegram-bot-api";
import { PRocket } from "procketapi";

const bot = new TelegramBot("ТОКЕН_БОТА", { polling: true });
const procket = new PRocket("ВАШ_КЛЮЧ");

bot.onText(/\/start/, async (msg) => {
  const result = await procket.check(msg.from.id, {
    bot,
    languageCode: msg.from.language_code,
    isPremium: msg.from.is_premium
  });
  if (!result.passed) return;   // спонсоры уже отправлены

  await bot.sendMessage(msg.chat.id, "Доступ открыт");
});

bot.on("callback_query", async (query) => {
  if (query.data !== "procket_check") return;
  await bot.answerCallbackQuery(query.id);

  // Повторный вызов и есть проверка
  const result = await procket.check(query.from.id, { bot });
  await bot.sendMessage(
    query.message.chat.id,
    result.passed ? "Спасибо! Доступ открыт." : "Вы подписались не на всех спонсоров."
  );
});

<?php

function procketCheck(int $userId, ?string $lang = null): array
{
    $ch = curl_init('https://app.procket.club/api/v2/check');

    curl_setopt_array($ch, [
        CURLOPT_POST           => true,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT        => 10,
        CURLOPT_HTTPHEADER     => [
            'Content-Type: application/json',
            'Auth: ' . PROCKET_KEY,
        ],
        CURLOPT_POSTFIELDS => json_encode([
            'user_id'       => $userId,
            'language_code' => $lang,
        ]),
    ]);

    $response = curl_exec($ch);
    curl_close($ch);

    // Сервис недоступен — пропускаем: бот важнее офферов
    if ($response === false) {
        return ['passed' => true];
    }

    return json_decode($response, true) ?: ['passed' => true];
}

$result = procketCheck($userId, 'ru');

if (!$result['passed']) {
    // message отправляется в Telegram как есть
    sendTelegram('sendMessage', array_merge(
        ['chat_id' => $userId],
        $result['message']
    ));
    return;
}

package procket

import (
	"bytes"
	"encoding/json"
	"net/http"
	"time"
)

type Offer struct {
	ID       string  `json:"id"`
	Ticket   string  `json:"ticket"`
	Title    string  `json:"title"`
	URL      string  `json:"url"`
	Reward   float64 `json:"reward"`
	Currency string  `json:"currency"`
}

type Message struct {
	Text        string          `json:"text"`
	ParseMode   string          `json:"parse_mode"`
	ReplyMarkup json.RawMessage `json:"reply_markup"`
}

type CheckResult struct {
	Passed  bool     `json:"passed"`
	Reason  string   `json:"reason"`
	Offers  []Offer  `json:"offers"`
	Message *Message `json:"message"`
}

var client = &http.Client{Timeout: 10 * time.Second}

func Check(key string, userID int64, lang string) (*CheckResult, error) {
	body, _ := json.Marshal(map[string]any{
		"user_id":       userID,
		"language_code": lang,
	})

	req, err := http.NewRequest("POST", "https://app.procket.club/api/v2/check", bytes.NewReader(body))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Auth", key)

	resp, err := client.Do(req)
	if err != nil {
		// Сервис недоступен — пропускаем: бот важнее офферов
		return &CheckResult{Passed: true, Reason: "unavailable"}, nil
	}
	defer resp.Body.Close()

	var result CheckResult
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return nil, err
	}
	return &result, nil
}

using System.Net.Http.Json;
using System.Text.Json.Serialization;

public record Offer(
    [property: JsonPropertyName("id")] string Id,
    [property: JsonPropertyName("ticket")] string Ticket,
    [property: JsonPropertyName("title")] string Title,
    [property: JsonPropertyName("url")] string Url,
    [property: JsonPropertyName("reward")] decimal Reward);

public record CheckResult(
    [property: JsonPropertyName("passed")] bool Passed,
    [property: JsonPropertyName("reason")] string Reason,
    [property: JsonPropertyName("offers")] Offer[] Offers);

public sealed class PRocketClient
{
    private static readonly HttpClient Http = new()
    {
        BaseAddress = new Uri("https://app.procket.club"),
        Timeout = TimeSpan.FromSeconds(10)
    };

    private readonly string _key;

    public PRocketClient(string key) => _key = key;

    public async Task<CheckResult> CheckAsync(long userId, string? lang = null)
    {
        using var request = new HttpRequestMessage(HttpMethod.Post, "/api/v2/check")
        {
            Content = JsonContent.Create(new { user_id = userId, language_code = lang })
        };
        request.Headers.Add("Auth", _key);

        try
        {
            var response = await Http.SendAsync(request);
            return await response.Content.ReadFromJsonAsync<CheckResult>()
                   ?? new CheckResult(true, "unavailable", []);
        }
        catch (HttpRequestException)
        {
            // Сервис недоступен — пропускаем: бот важнее офферов
            return new CheckResult(true, "unavailable", []);
        }
    }
}

curl -X POST https://app.procket.club/api/v2/check \
  -H "Content-Type: application/json" \
  -H "Auth: ВАШ_КЛЮЧ" \
  -d '{
    "user_id": 123456789,
    "limit": 3,
    "language_code": "ru",
    "is_premium": false
  }'

import { PRocket } from "procketapi";

const procket = new PRocket("ВАШ_КЛЮЧ");

bot.command("tasks", async (ctx) => {
  const { tasks, message } = await procket.getTasks(ctx.from.id, { limit: 5 });

  if (!tasks.length) {
    return ctx.reply("Сейчас заданий нет. Загляните позже.");
  }

  // Готовое сообщение — клавиатуру верстать не нужно
  await ctx.reply(message.text, {
    parse_mode: message.parse_mode,
    reply_markup: message.reply_markup
  });
});

bot.callbackQuery("procket_check", async (ctx) => {
  await ctx.answerCallbackQuery();

  const { tasks } = await procket.getTasks(ctx.from.id);
  let earned = 0;

  for (const task of tasks) {
    const state = await procket.checkTask(task.ticket);

    // alreadyPaid — ваша таблица; без неё награда начислится дважды
    if (state.completed && !(await alreadyPaid(task.ticket))) {
      await markPaid(task.ticket);
      earned += state.reward;
    }
  }

  await ctx.reply(earned ? `Начислено: ${earned.toFixed(2)}` : "Задания ещё не выполнены.");
});

# Выдать задания
curl -X POST https://app.procket.club/api/v2/tasks \
  -H "Content-Type: application/json" \
  -H "Auth: ВАШ_КЛЮЧ" \
  -d '{"user_id": 123456789, "limit": 5}'

# Проверить одно задание
curl -X POST https://app.procket.club/api/v2/check_task \
  -H "Content-Type: application/json" \
  -H "Auth: ВАШ_КЛЮЧ" \
  -d '{"ticket": "atc_x9y8"}'

import { AdResult, PRocket } from "procketapi";

const procket = new PRocket("ВАШ_КЛЮЧ");

bot.command("start", async (ctx) => {
  // Привет: только для новых пользователей, первым делом после /start
  if (await isNewUser(ctx.from.id)) {
    await procket.sendAd(ctx.from.id, { hi: true });
  }

  await ctx.reply("Привет! Я умею…");
});

bot.command("profile", async (ctx) => {
  await ctx.reply(renderProfile(ctx.from.id));

  // Обычный показ — после осмысленного действия, а не на /start
  const result = await procket.sendAd(ctx.from.id);

  if (result.code === AdResult.USER_FORBIDDEN) {
    await markBlocked(ctx.from.id);
  }
});

curl -X POST https://app.procket.club/api/v2/ad/send \
  -H "Content-Type: application/json" \
  -H "Auth: ВАШ_КЛЮЧ" \
  -d '{"user_id": 123456789, "hi": true}'

# {"SendPostResult": 1, "result": 1, "ok": true,
#  "description": "Advertisement delivered"}

import express from "express";
import { verifyWebhook, WebhookSignatureError } from "procketapi";

const app = express();

// express.raw, не express.json: подпись считается по исходным байтам
app.post(
  "/procket/webhook",
  express.raw({ type: "application/json" }),
  async (req, res) => {
    try {
      verifyWebhook(req.body, req.get("X-Procket-Signature"), process.env.PROCKET_SECRET);
    } catch (error) {
      if (error instanceof WebhookSignatureError) return res.sendStatus(403);
      throw error;
    }

    const event = JSON.parse(req.body.toString("utf8"));
    const data = event.data;

    if (event.type === "task.completed") {
      // Повтор доставки — штатная ситуация, проверьте ticket у себя
      if (!(await alreadyPaid(data.ticket))) {
        await giveReward(data.user_id, data.reward);
        await markPaid(data.ticket);
      }
    }

    res.json({ ok: true });   // 2xx = доставлено
  }
);

app.listen(8080);

<?php

$secret = getenv('PROCKET_SECRET');
$body   = file_get_contents('php://input');   // исходные байты
$header = $_SERVER['HTTP_X_PROCKET_SIGNATURE'] ?? '';

parse_str(strtr($header, ',', '&'), $parts);
$timestamp = $parts['t'] ?? '';
$provided  = $parts['v1'] ?? '';

// Запросы старше 5 минут отвергаем: иначе перехваченный переигрывается
if (!$timestamp || abs(time() - (int) $timestamp) > 300) {
    http_response_code(403);
    exit;
}

$expected = hash_hmac('sha256', $timestamp . '.' . $body, $secret);

// hash_equals, а не ===: сравнение строк выдаёт подпись по времени ответа
if (!hash_equals($expected, $provided)) {
    http_response_code(403);
    exit;
}

$event = json_decode($body, true);

if ($event['type'] === 'task.completed') {
    $data = $event['data'];
    // Повтор доставки — штатная ситуация, проверьте ticket у себя
    if (!alreadyPaid($data['ticket'])) {
        giveReward($data['user_id'], $data['reward']);
        markPaid($data['ticket']);
    }
}

header('Content-Type: application/json');
echo json_encode(['ok' => true]);   // 2xx = доставлено

import { PRocket } from "procketapi";

const procket = new PRocket("ВАШ_КЛЮЧ");

bot.use(async (ctx, next) => {
  if (!ctx.from) return next();

  // /help должен работать без подписки
  if (ctx.message?.text?.startsWith("/help")) return next();

  const result = await procket.check(ctx.from.id, {
    bot,
    languageCode: ctx.from.language_code
  });
  if (!result.passed) return;

  return next();
});

await procket.check(userId, {
  bot,
  userName: ctx.from.first_name,
  message: {
    rows: 2,
    text: "<b>$name</b>, подпишитесь на {count} канала — и бот ваш:",
    button_channel: "Подписаться",
    button_check: "Готово ✅"
  }
});

curl -X POST https://app.procket.club/api/v2/check \
  -H "Content-Type: application/json" \
  -H "Auth: ВАШ_КЛЮЧ" \
  -d '{
    "user_id": 123456789,
    "user_name": "Иван",
    "message": {
      "rows": 2,
      "text": "$name, подпишитесь на {count} канала:",
      "button_channel": "Подписаться",
      "button_check": "Готово ✅"
    }
  }'