TRON Integration Guide

npm install @t402/tron @t402/core tronweb

pip install t402[tron]

go get github.com/t402-io/t402/sdks/go/mechanisms/tron

import { t402Client } from '@t402/core/client';
import { ExactTronScheme, toClientTronSigner } from '@t402/tron';
import TronWeb from 'tronweb';
 
// Create TronWeb instance
const tronWeb = new TronWeb({
  fullHost: 'https://api.trongrid.io',
  privateKey: 'your_private_key_hex',
});
 
// Create TRON signer
const tronSigner = toClientTronSigner({
  tronWeb,
  privateKey: 'your_private_key_hex',
});
 
// Create t402 client
const client = new t402Client()
  .register('tron:mainnet', new ExactTronScheme(tronSigner))
  .register('tron:nile', new ExactTronScheme(tronSigner));

from t402 import t402Client
from t402.tron import TronSigner, ExactTronScheme
 
# Create TRON signer
signer = TronSigner.from_private_key("your_private_key_hex")
 
# Create t402 client
client = t402Client()
client.register("tron:mainnet", ExactTronScheme(signer))
client.register("tron:nile", ExactTronScheme(signer))

import (
    "github.com/t402-io/t402/sdks/go/mechanisms/tron"
    t402 "github.com/t402-io/t402/sdks/go"
)
 
// Create TRON signer
signer, err := tron.NewSignerFromPrivateKey(privateKeyHex)
if err != nil {
    log.Fatal(err)
}
 
// Create t402 client
client := t402.NewClient()
client.Register("tron:mainnet", tron.NewExactScheme(signer))
client.Register("tron:nile", tron.NewExactScheme(signer))

import express from 'express';
import { paymentMiddleware } from '@t402/express';
import { t402ResourceServer, createFacilitatorClient } from '@t402/core/server';
import { registerExactTronServerScheme } from '@t402/tron/exact/server';
 
const app = express();
 
// Create facilitator client
const facilitator = createFacilitatorClient({
  url: 'https://facilitator.t402.io',
});
 
// Create t402 server
const server = new t402ResourceServer(facilitator);
registerExactTronServerScheme(server, {});
 
// Define routes with TRON payment
const routes = {
  '/api/premium/*': {
    accepts: {
      scheme: 'exact',
      network: 'tron:mainnet',
      payTo: 'TYourTronAddress',
      price: '$0.01',
    },
    description: 'Premium API access',
  },
};
 
// Apply middleware
app.use(paymentMiddleware(routes, server));
 
app.get('/api/premium/data', (req, res) => {
  res.json({ data: 'Premium content' });
});
 
app.listen(3000);

from fastapi import FastAPI
from t402.fastapi.middleware import require_payment
 
app = FastAPI()
 
app.middleware("http")(
    require_payment(
        price="0.01",
        pay_to_address="TYourTronAddress",
        network="tron:mainnet",
    )
)
 
@app.get("/api/premium")
async def premium():
    return {"data": "Premium content"}

package main
 
import (
    "github.com/gin-gonic/gin"
    "github.com/t402-io/t402/sdks/go/http"
    "github.com/t402-io/t402/sdks/go/mechanisms/tron"
)
 
func main() {
    r := gin.Default()
 
    // Create t402 server
    server := t402.NewResourceServer(facilitator)
    tron.RegisterExactScheme(server)
 
    // Configure routes
    routes := http.Routes{
        "/api/premium/*": {
            Accepts: http.PaymentConfig{
                Scheme:  "exact",
                Network: "tron:mainnet",
                PayTo:   "TYourTronAddress",
                Price:   "$0.01",
            },
        },
    }
 
    r.Use(http.PaymentMiddleware(routes, server))
 
    r.GET("/api/premium/data", func(c *gin.Context) {
        c.JSON(200, gin.H{"data": "Premium content"})
    })
 
    r.Run(":3000")
}

import { wrapFetchWithPayment } from '@t402/fetch';
 
const fetchWithPay = wrapFetchWithPayment(fetch, client);
 
// Automatic payment handling
const response = await fetchWithPay('https://api.example.com/api/premium/data', {
  method: 'GET',
});
 
const data = await response.json();
console.log(data);

from t402.clients.httpx import t402HttpxClient
 
async with t402HttpxClient(client=client) as http:
    response = await http.get("https://api.example.com/api/premium/data")
    data = await response.json()
    print(data)

httpClient := t402.NewHTTPClient(client)
 
resp, err := httpClient.Get(ctx, "https://api.example.com/api/premium/data")
if err != nil {
    log.Fatal(err)
}
defer resp.Body.Close()
 
var data map[string]interface{}
json.NewDecoder(resp.Body).Decode(&data)
fmt.Println(data)