Teleport Pay

Add to your MCP config (claude_desktop_config.json, .cursor/mcp.json, etc.):

{
  "mcpServers": {
    "teleport-pay": {
      "command": "python3",
      "args": ["/path/to/teleport-pay-server.py"],
      "env": { "TELEPORT_PAY_API_KEY": "tk_your_key" }
    }
  }
}

Available Tools

1. Install

1. Upload teleport-pay-gateway.php to /wp-content/plugins/
2. Activate in WordPress admin: Plugins → Teleport Pay Gateway

2. Configure

WooCommerce → Settings → Payments → Teleport Pay:

3. Webhook URL

https://yoursite.com/?wc-api=teleport_pay

Option 1: Buy Button / Custom Storefront

Use Shopify Storefront API + Teleport Pay for checkout:

// After Shopify cart is ready, create Teleport Pay invoice
const resp = await fetch('https://gate.teleport.ltd/api/crypto-acquiring/v1/invoice/create/', {
  method: 'POST',
  headers: {
    'X-API-Key': 'tk_your_key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    order_id: shopifyOrderId,
    amount: cart.totalPrice,
    currency: 'USD',
    description: `Order #${shopifyOrderId}`,
    customer_email: customer.email,
    return_url: `https://yourstore.com/orders/${shopifyOrderId}/thank-you`,
    webhook_url: 'https://yourstore.com/api/teleport-webhook'
  })
});
const { payment_url } = await resp.json();
window.location.href = payment_url;

Option 2: Shopify App (Draft Orders)

1. Create a draft order via Shopify Admin API
2. Create a Teleport Pay invoice with the order amount
3. On webhook paid callback, complete the draft order

Webhook Handler (Node.js)

app.post('/api/teleport-webhook', (req, res) => {
  const { status, order_id } = req.body;
  if (status === 'paid') {
    // Complete order in Shopify via Admin API
    shopify.draftOrder.complete(order_id);
  }
  res.status(200).send('OK');
});

1. Create extension files

Controller catalog/controller/extension/payment/teleport_pay.php:

class ControllerExtensionPaymentTeleportPay extends Controller {
  public function index() {
    return $this->load->view('extension/payment/teleport_pay');
  }

  public function confirm() {
    $order = $this->model_checkout_order->getOrder($this->session->data['order_id']);

    $ch = curl_init('https://gate.teleport.ltd/api/crypto-acquiring/v1/invoice/create/');
    curl_setopt_array($ch, [
      CURLOPT_POST => true,
      CURLOPT_HTTPHEADER => [
        'X-API-Key: ' . $this->config->get('payment_teleport_pay_api_key'),
        'Content-Type: application/json',
      ],
      CURLOPT_POSTFIELDS => json_encode([
        'order_id'   => $order['order_id'],
        'amount'     => $order['total'],
        'currency'   => $order['currency_code'],
        'description' => 'Order #' . $order['order_id'],
        'customer_email' => $order['email'],
        'return_url' => $this->url->link('checkout/success'),
        'webhook_url' => $this->url->link('extension/payment/teleport_pay/webhook'),
      ]),
      CURLOPT_RETURNTRANSFER => true,
    ]);
    $result = json_decode(curl_exec($ch), true);
    curl_close($ch);

    if ($result['success']) {
      $this->response->redirect($result['payment_url']);
    }
  }
}

2. Webhook handler

Add a webhook() method that verifies the signature and updates order status.

Module Structure

modules/teleportpay/
  teleportpay.php          # Main module class
  controllers/
    front/
      validation.php       # Create invoice on checkout
      webhook.php          # Handle webhook callbacks
  views/templates/hook/
    payment.tpl            # Payment button template

Key: validation.php

class TeleportPayValidationModuleFrontController extends ModuleFrontController {
  public function postProcess() {
    $cart = $this->context->cart;
    $customer = new Customer($cart->id_customer);

    $payload = [
      'order_id'    => $cart->id,
      'amount'      => (float) $cart->getOrderTotal(),
      'currency'    => Currency::getCurrencyInstance($cart->id_currency)->iso_code,
      'customer_email' => $customer->email,
      'return_url'  => $this->context->link->getModuleLink('teleportpay', 'confirmation'),
      'webhook_url' => $this->context->link->getModuleLink('teleportpay', 'webhook'),
    ];

    // POST to Teleport Pay API, redirect to payment_url
  }
}

Payment Handler

Create /local/php_interface/include/sale_payment/teleport_pay/handler.php:

use Bitrix\Sale\PaySystem;

class TeleportPayHandler extends PaySystem\ServiceHandler {
  public function initiatePay(PaySystem\Payment $payment, Request $request) {
    $order = $payment->getOrder();

    $data = [
      'order_id'   => $order->getId(),
      'amount'     => $payment->getSum(),
      'currency'   => $payment->getField('CURRENCY'),
      'description' => "Order #{$order->getId()}",
      'return_url' => $this->getReturnUrl(),
      'webhook_url' => $this->getCallbackUrl(),
    ];

    // cURL POST to /v1/invoice/create/
    // Redirect to payment_url
  }

  public function processRequest(PaySystem\Payment $payment, Request $request) {
    // Verify webhook signature, update order status
  }
}

Register Handler

Admin → Shop → Payment Systems → add new, select handler teleport_pay.

Service Class

class TeleportPay {
  private string $apiKey;
  private string $baseUrl = 'https://gate.teleport.ltd/api/crypto-acquiring/v1';

  public function createInvoice(array $params): array {
    $ch = curl_init("{$this->baseUrl}/invoice/create/");
    curl_setopt_array($ch, [
      CURLOPT_POST => true,
      CURLOPT_HTTPHEADER => [
        "X-API-Key: {$this->apiKey}",
        'Content-Type: application/json',
      ],
      CURLOPT_POSTFIELDS => json_encode($params),
      CURLOPT_RETURNTRANSFER => true,
    ]);
    $result = json_decode(curl_exec($ch), true);
    curl_close($ch);
    return $result;
  }
}

// Usage in controller:
$invoice = $teleport->createInvoice([
  'amount' => 49.99, 'currency' => 'USD',
  'order_id' => $order->id,
  'return_url' => route('orders.thanks', $order),
  'webhook_url' => route('webhooks.teleport'),
]);
return redirect($invoice['payment_url']);

Webhook Route

// routes/web.php
Route::post('/webhooks/teleport', function (Request $request) {
  $sig = $request->header('X-Webhook-Signature', '');
  $sig = Str::after($sig, 'sha256=');
  $expected = hash_hmac('sha256', $request->getContent(), config('services.teleport.webhook_secret'));

  if (! hash_equals($expected, $sig)) abort(403);

  $data = $request->json();
  $order = Order::where('external_id', $data->get('order_id'))->firstOrFail();

  match ($data->get('status')) {
    'paid' => $order->markPaid(),
    'expired', 'cancelled', 'failed' => $order->markFailed(),
    default => null,
  };
  return response('OK', 200);
});

import requests, hmac, hashlib

API_KEY = 'tk_your_key'
WEBHOOK_SECRET = 'whsec_your_secret'
BASE = 'https://gate.teleport.ltd/api/crypto-acquiring/v1'

def create_invoice(order_id, amount, currency, email, return_url, webhook_url):
    resp = requests.post(f'{BASE}/invoice/create/', json={
        'order_id': order_id, 'amount': amount, 'currency': currency,
        'customer_email': email,
        'return_url': return_url, 'webhook_url': webhook_url,
    }, headers={'X-API-Key': API_KEY})
    return resp.json()

def verify_webhook(body: bytes, signature: str) -> bool:
    sig = signature.removeprefix('sha256=')
    expected = hmac.new(WEBHOOK_SECRET.encode(), body, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, sig)

# Django view
from django.http import HttpResponse, JsonResponse
from django.views.decorators.csrf import csrf_exempt

@csrf_exempt
def webhook(request):
    sig = request.headers.get('X-Webhook-Signature', '')
    if not verify_webhook(request.body, sig):
        return HttpResponse(status=403)
    data = json.loads(request.body)
    # Process data['status'], data['order_id']
    return HttpResponse('OK')

const crypto = require('crypto');

const API_KEY = 'tk_your_key';
const WEBHOOK_SECRET = 'whsec_your_secret';
const BASE = 'https://gate.teleport.ltd/api/crypto-acquiring/v1';

async function createInvoice({ orderId, amount, currency, email, returnUrl, webhookUrl }) {
  const res = await fetch(`${BASE}/invoice/create/`, {
    method: 'POST',
    headers: { 'X-API-Key': API_KEY, 'Content-Type': 'application/json' },
    body: JSON.stringify({
      order_id: orderId, amount, currency,
      customer_email: email, return_url: returnUrl, webhook_url: webhookUrl,
    }),
  });
  return res.json();
}

function verifyWebhook(body, signature) {
  const sig = signature.replace('sha256=', '');
  const expected = crypto.createHmac('sha256', WEBHOOK_SECRET).update(body).digest('hex');
  return crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(sig));
}

// Express webhook route
app.post('/webhooks/teleport', express.raw({ type: '*/*' }), (req, res) => {
  if (!verifyWebhook(req.body, req.headers['x-webhook-signature'] || '')) {
    return res.status(403).send('Invalid signature');
  }
  const { status, order_id } = JSON.parse(req.body);
  // Update your order based on status
  res.status(200).send('OK');
});

API Route (app/api/pay/route.ts)

export async function POST(req: Request) {
  const { orderId, amount, currency, email } = await req.json();

  const res = await fetch(
    'https://gate.teleport.ltd/api/crypto-acquiring/v1/invoice/create/',
    {
      method: 'POST',
      headers: {
        'X-API-Key': process.env.TELEPORT_API_KEY!,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        order_id: orderId, amount, currency,
        customer_email: email,
        return_url: `${process.env.NEXT_PUBLIC_URL}/orders/${orderId}/success`,
        webhook_url: `${process.env.NEXT_PUBLIC_URL}/api/webhook`,
      }),
    }
  );
  return Response.json(await res.json());
}

Pay Button Component

function PayButton({ orderId, amount, currency, email }) {
  const [loading, setLoading] = useState(false);

  const handlePay = async () => {
    setLoading(true);
    const res = await fetch('/api/pay', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ orderId, amount, currency, email }),
    });
    const { payment_url } = await res.json();
    window.location.href = payment_url;
  };

  return <button onClick={handlePay} disabled={loading}>
    {loading ? 'Redirecting...' : 'Pay Now'}
  </button>;
}

1. Payment Button (Tilda HTML block)

<!-- Add as HTML block in Tilda page editor -->
<button id="tp-pay-btn" style="padding:12px 32px; background:#2563eb;
  color:#fff; border:none; border-radius:8px; font-size:16px; cursor:pointer;">
  Pay Now
</button>
<script>
document.getElementById('tp-pay-btn').onclick = async () => {
  const res = await fetch('https://your-backend.com/api/teleport-pay', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ amount: 49.99, currency: 'USD' }),
  });
  const { payment_url } = await res.json();
  window.location.href = payment_url;
};
</script>

2. Backend handler

Use any backend (PHP, Node.js, Python) that calls the Teleport Pay API and returns payment_url. See the Laravel, Django, or Node.js guides above.

Module Structure

app/code/Teleport/Pay/
  registration.php
  etc/
    module.xml
    config.xml            # Default config (api_key, webhook_secret)
    payment.xml           # Payment method declaration
  Model/
    TeleportPay.php       # Payment method model
  Controller/
    Payment/
      Redirect.php        # Redirect to payment_url
      Webhook.php          # Handle webhook callbacks

Payment Model (simplified)

class TeleportPay extends \Magento\Payment\Model\Method\AbstractMethod {
  protected $_code = 'teleport_pay';
  protected $_isOffline = false;

  public function getOrderPlaceRedirectUrl() {
    return $this->_urlBuilder->getUrl('teleport/payment/redirect');
  }
}

The Redirect controller creates the invoice via API and sends the customer to payment_url.

import requests
from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import ApplicationBuilder, CommandHandler, CallbackContext

API_KEY = 'tk_your_key'

async def pay(update: Update, ctx: CallbackContext):
    resp = requests.post(
      'https://gate.teleport.ltd/api/crypto-acquiring/v1/invoice/create/',
      json={
        'amount': 10.00, 'currency': 'USD',
        'order_id': f'tg_{update.effective_user.id}',
        'description': 'Premium subscription',
      },
      headers={'X-API-Key': API_KEY},
    ).json()

    kb = InlineKeyboardMarkup([[
      InlineKeyboardButton('Pay $10.00', url=resp['payment_url'])
    ]])
    await update.message.reply_text('Click to pay:', reply_markup=kb)

app = ApplicationBuilder().token('YOUR_BOT_TOKEN').build()
app.add_handler(CommandHandler('pay', pay))
app.run_polling()

# Create an invoice
curl -X POST https://gate.teleport.ltd/api/crypto-acquiring/v1/invoice/create/ \
  -H "X-API-Key: tk_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "amount": 49.99,
    "currency": "USD",
    "order_id": "12345",
    "return_url": "https://yoursite.com/success",
    "webhook_url": "https://yoursite.com/webhook"
  }'

# List payment methods
curl -s https://gate.teleport.ltd/api/crypto-acquiring/v1/payment-methods/ \
  -H "X-API-Key: tk_your_key"

# List currencies
curl -s https://gate.teleport.ltd/api/crypto-acquiring/v1/currencies/ \
  -H "X-API-Key: tk_your_key"