Solana Integration Guide

npm install @t402/svm @t402/core @solana/web3.js @solana/spl-token

pip install t402[svm]

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

import { t402Client } from '@t402/core/client';
import { ExactSvmScheme, toClientSvmSigner } from '@t402/svm';
import { Keypair, Connection } from '@solana/web3.js';
import bs58 from 'bs58';
 
// Create connection
const connection = new Connection('https://api.mainnet-beta.solana.com');
 
// Create keypair from secret key
const secretKey = bs58.decode('your_base58_private_key');
const keypair = Keypair.fromSecretKey(secretKey);
 
// Create Solana signer
const svmSigner = toClientSvmSigner({
  keypair,
  connection,
});
 
// Create t402 client
const client = new t402Client()
  .register('solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp', new ExactSvmScheme(svmSigner));

from t402 import t402Client
from t402.svm import SvmSigner, ExactSvmScheme
from solana.keypair import Keypair
 
# Create keypair
keypair = Keypair.from_base58_string("your_base58_private_key")
 
# Create Solana signer
signer = SvmSigner(keypair)
 
# Create t402 client
client = t402Client()
client.register("solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp", ExactSvmScheme(signer))

import (
    "github.com/t402-io/t402/sdks/go/mechanisms/svm"
    t402 "github.com/t402-io/t402/sdks/go"
)
 
// Create Solana signer
signer, err := svm.NewSignerFromBase58(privateKeyBase58)
if err != nil {
    log.Fatal(err)
}
 
// Create t402 client
client := t402.NewClient()
client.Register("solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp", svm.NewExactScheme(signer))

import express from 'express';
import { paymentMiddleware } from '@t402/express';
import { t402ResourceServer, createFacilitatorClient } from '@t402/core/server';
import { registerExactSvmServerScheme } from '@t402/svm/exact/server';
 
const app = express();
 
// Create facilitator client
const facilitator = createFacilitatorClient({
  url: 'https://facilitator.t402.io',
});
 
// Create t402 server
const server = new t402ResourceServer(facilitator);
registerExactSvmServerScheme(server, {});
 
// Define routes with Solana payment
const routes = {
  '/api/premium/*': {
    accepts: {
      scheme: 'exact',
      network: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
      payTo: 'YourSolanaAddress',
      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="YourSolanaAddress",
        network="solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
    )
)
 
@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/svm"
)
 
func main() {
    r := gin.Default()
 
    // Create t402 server
    server := t402.NewResourceServer(facilitator)
    svm.RegisterExactScheme(server)
 
    // Configure routes
    routes := http.Routes{
        "/api/premium/*": {
            Accepts: http.PaymentConfig{
                Scheme:  "exact",
                Network: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
                PayTo:   "YourSolanaAddress",
                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)