Chains & Networks

// EVM chains
'eip155:1'      // Ethereum
'eip155:8453'   // Base
'eip155:42161'  // Arbitrum
 
// Non-EVM chains
'ton:mainnet'                                    // TON
'tron:mainnet'                                   // TRON
'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp'       // Solana Mainnet
'near:mainnet'                                   // NEAR
'aptos:1'                                        // Aptos Mainnet
'tezos:NetXdQprcVkpaWU'                         // Tezos Mainnet
'polkadot:68d56f15f85d3136970ec16946040bc1'    // Polkadot Asset Hub
'stacks:1'                                       // Stacks Mainnet
'cosmos:noble-1'                                 // Noble (Cosmos)

import { t402ResourceServer, createFacilitatorClient } from '@t402/core/server';
import { registerExactEvmScheme } from '@t402/evm/exact/server';
 
const facilitator = createFacilitatorClient({
  url: 'https://facilitator.t402.io',
});
 
const server = new t402ResourceServer(facilitator);
registerExactEvmScheme(server, {});
 
// Configure routes
const routes = {
  '/api/premium/*': {
    accepts: [
      { scheme: 'exact', network: 'eip155:8453', payTo: '0x...', price: '$0.01' },
      { scheme: 'exact', network: 'eip155:42161', payTo: '0x...', price: '$0.01' },
    ],
  },
};

interface TransferWithAuthorization {
  from: string;        // Payer address
  to: string;          // Recipient address
  value: bigint;       // Amount in smallest unit
  validAfter: bigint;  // Unix timestamp (usually 0)
  validBefore: bigint; // Deadline timestamp
  nonce: bytes32;      // Random nonce
}

const domain = {
  name: 'USD0',
  version: '1',
  chainId: 8453,
  verifyingContract: '0x...',
};
 
const types = {
  TransferWithAuthorization: [
    { name: 'from', type: 'address' },
    { name: 'to', type: 'address' },
    { name: 'value', type: 'uint256' },
    { name: 'validAfter', type: 'uint256' },
    { name: 'validBefore', type: 'uint256' },
    { name: 'nonce', type: 'bytes32' },
  ],
};

import { estimateGas } from '@t402/evm';
 
const estimate = await estimateGas({
  network: 'eip155:8453',
  operation: 'transferWithAuthorization',
  rpcUrl: 'https://mainnet.base.org',
});
 
console.log(`Estimated gas: ${estimate.gasLimit}`);
console.log(`Estimated cost: $${estimate.costUsd}`);

const payToAddress = '0x742d35Cc6634C0532925a3b844Bc9e7595f5b1A1';
 
const routes = {
  '/api/premium/*': {
    accepts: [
      { scheme: 'exact', network: 'eip155:1', payTo: payToAddress, price: '$0.01' },
      { scheme: 'exact', network: 'eip155:8453', payTo: payToAddress, price: '$0.01' },
      { scheme: 'exact', network: 'eip155:42161', payTo: payToAddress, price: '$0.01' },
    ],
  },
};

import { getNetworkDisplayName, getChainConfig } from '@t402/evm';
 
const supportedNetworks = [
  'eip155:8453',   // Base
  'eip155:42161',  // Arbitrum
  'eip155:10',     // Optimism
];
 
// Display network options to user
supportedNetworks.forEach(network => {
  const config = getChainConfig(network);
  console.log(`${getNetworkDisplayName(network)}: ~$${config.avgGasCost}`);
});

// Request account access
await window.ethereum.request({ method: 'eth_requestAccounts' });
 
// Get current chain
const chainId = await window.ethereum.request({ method: 'eth_chainId' });
 
// Switch to Base
await window.ethereum.request({
  method: 'wallet_switchEthereumChain',
  params: [{ chainId: '0x2105' }], // Base = 8453 = 0x2105
});

import { createWalletClient } from 'viem';
import { WalletConnectConnector } from '@wagmi/connectors/walletConnect';
 
const connector = new WalletConnectConnector({
  options: {
    projectId: 'your-project-id',
    chains: [base, arbitrum, optimism],
  },
});
 
await connector.connect();
const walletClient = await connector.getWalletClient();

import { createMultisigClient } from '@t402/wdk-multisig';
 
const multisigClient = await createMultisigClient({
  safeAddress: '0xYourSafeAddress',
  chainId: 8453,
  owners: ['0xOwner1', '0xOwner2', '0xOwner3'],
  threshold: 2,
});

const rpcConfig = {
  'eip155:1': process.env.ETH_RPC_URL || 'https://eth.llamarpc.com',
  'eip155:8453': process.env.BASE_RPC_URL || 'https://mainnet.base.org',
  'eip155:42161': process.env.ARB_RPC_URL || 'https://arb1.arbitrum.io/rpc',
};

import { verifySignature, decodePayment } from '@t402/evm';
 
// Decode payment header
const payment = decodePayment(xPaymentHeader);
console.log('Payment details:', payment);
 
// Verify signature locally
const isValid = await verifySignature({
  message: payment.message,
  signature: payment.signature,
  expectedSigner: payment.from,
});
console.log('Signature valid:', isValid);

import { registerExactTonScheme } from '@t402/ton/exact/server';
import { ExactTonScheme } from '@t402/ton/exact/client';
 
// Server
registerExactTonScheme(server, {});
 
// Client
const tonClient = new ExactTonScheme(tonConnectUI);
client.register('ton:mainnet', tonClient);

import { TonConnectUI } from '@tonconnect/ui';
 
const tonConnectUI = new TonConnectUI({
  manifestUrl: 'https://yourapp.com/tonconnect-manifest.json',
});
 
await tonConnectUI.connectWallet();

import { registerExactTronScheme } from '@t402/tron/exact/server';
import { ExactTronScheme } from '@t402/tron/exact/client';
 
// Server
registerExactTronScheme(server, {});
 
// Client (with TronLink)
const tronWeb = window.tronWeb;
const tronClient = new ExactTronScheme(tronWeb);
client.register('tron:mainnet', tronClient);

import { registerExactSvmScheme } from '@t402/svm/exact/server';
import { ExactSvmScheme } from '@t402/svm/exact/client';
import { useWallet } from '@solana/wallet-adapter-react';
 
// Server
registerExactSvmScheme(server, {});
 
// Client (with Phantom)
const { signMessage, publicKey } = useWallet();
const svmClient = new ExactSvmScheme({ signMessage, publicKey });
client.register('solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp', svmClient);

import { registerExactNearScheme } from '@t402/near/exact/server';
import { ExactNearScheme } from '@t402/near/exact/client';
 
// Server
registerExactNearScheme(server, {});
 
// Client
const nearClient = new ExactNearScheme(wallet);
client.register('near:mainnet', nearClient);

import { registerExactAptosScheme } from '@t402/aptos/exact/server';
import { ExactAptosScheme } from '@t402/aptos/exact/client';
 
// Server
registerExactAptosScheme(server, {});
 
// Client
const aptosClient = new ExactAptosScheme(wallet);
client.register('aptos:1', aptosClient);

import { registerExactTezosScheme } from '@t402/tezos/exact/server';
import { ExactTezosScheme } from '@t402/tezos/exact/client';
 
// Server
registerExactTezosScheme(server, {});
 
// Client
const tezosClient = new ExactTezosScheme(wallet);
client.register('tezos:NetXdQprcVkpaWU', tezosClient);

import { registerExactPolkadotScheme } from '@t402/polkadot/exact/server';
import { ExactPolkadotScheme } from '@t402/polkadot/exact/client';
 
// Server
registerExactPolkadotScheme(server, {});
 
// Client
const polkadotClient = new ExactPolkadotScheme(wallet);
client.register('polkadot:68d56f15f85d3136970ec16946040bc1', polkadotClient);

import { registerExactStacksScheme } from '@t402/stacks/exact/server';
import { ExactStacksScheme } from '@t402/stacks/exact/client';
 
// Server
registerExactStacksScheme(server, {});
 
// Client
const stacksClient = new ExactStacksScheme(wallet);
client.register('stacks:1', stacksClient);

import { registerExactCosmosScheme } from '@t402/cosmos/exact/server';
import { ExactCosmosScheme } from '@t402/cosmos/exact/client';
 
// Server
registerExactCosmosScheme(server, {});
 
// Client
const cosmosClient = new ExactCosmosScheme(wallet);
client.register('cosmos:noble-1', cosmosClient);

import { t402ResourceServer, createFacilitatorClient } from '@t402/core/server';
import { registerExactTonScheme } from '@t402/ton/exact/server';
import { registerExactTronScheme } from '@t402/tron/exact/server';
import { registerExactSvmScheme } from '@t402/svm/exact/server';
import { registerExactNearScheme } from '@t402/near/exact/server';
import { registerExactAptosScheme } from '@t402/aptos/exact/server';
import { registerExactTezosScheme } from '@t402/tezos/exact/server';
import { registerExactPolkadotScheme } from '@t402/polkadot/exact/server';
import { registerExactStacksScheme } from '@t402/stacks/exact/server';
import { registerExactCosmosScheme } from '@t402/cosmos/exact/server';
 
const server = new t402ResourceServer(facilitator);
 
// Register all mechanisms
registerExactTonScheme(server, {});
registerExactTronScheme(server, {});
registerExactSvmScheme(server, {});
registerExactNearScheme(server, {});
registerExactAptosScheme(server, {});
registerExactTezosScheme(server, {});
registerExactPolkadotScheme(server, {});
registerExactStacksScheme(server, {});
registerExactCosmosScheme(server, {});
 
// Configure routes
const routes = {
  '/api/premium/*': {
    accepts: [
      { scheme: 'exact', network: 'ton:mainnet', payTo: 'EQ...', price: '$0.01' },
      { scheme: 'exact', network: 'tron:mainnet', payTo: 'T...', price: '$0.01' },
      { scheme: 'exact', network: 'solana:5eykt...', payTo: '...', price: '$0.01' },
      { scheme: 'exact', network: 'near:mainnet', payTo: 'account.near', price: '$0.01' },
      { scheme: 'exact', network: 'aptos:1', payTo: '0x...', price: '$0.01' },
      { scheme: 'exact', network: 'tezos:NetXdQprcVkpaWU', payTo: 'tz1...', price: '$0.01' },
      { scheme: 'exact', network: 'polkadot:68d56f...', payTo: '15...', price: '$0.01' },
      { scheme: 'exact', network: 'stacks:1', payTo: 'SP...', price: '$0.01' },
      { scheme: 'exact', network: 'cosmos:noble-1', payTo: 'noble1...', price: '$0.01' },
    ],
  },
};

type FacilitatorBtcSigner interface {
    GetAddresses() []string
    VerifyPsbt(ctx context.Context, signedPsbt, expectedPayTo, expectedAmount string) (valid bool, reason string, payer string, err error)
    BroadcastPsbt(ctx context.Context, signedPsbt string) (txID string, err error)
    WaitForConfirmation(ctx context.Context, txID string, confirmations int) (confirmed bool, blockHash string, confs int, err error)
}

type ClientLightningSigner interface {
    // PayInvoice pays a BOLT11 invoice and returns the preimage and payment hash
    PayInvoice(bolt11 string) (preimage string, paymentHash string, err error)
 
    // GetNodePubKey returns the Lightning node's public key as hex
    GetNodePubKey() string
}

{
  "t402Version": 2,
  "payload": {
    "signedPsbt": "cHNidP8BAH..."
  },
  "accepted": {
    "scheme": "exact",
    "network": "bip122:000000000019d6689c085ae165831e93",
    "asset": "BTC",
    "amount": "100000",
    "payTo": "bc1q..."
  }
}

{
  "t402Version": 2,
  "payload": {
    "paymentHash": "abc123...",
    "preimage": "def456...",
    "bolt11Invoice": "lnbc10u1p..."
  },
  "accepted": {
    "scheme": "exact",
    "network": "lightning:mainnet",
    "asset": "BTC",
    "amount": "10000",
    "payTo": "02abc..."
  }
}

routes := t402http.RoutesConfig{
    "GET /api/data": {
        Accepts: t402http.PaymentOptions{
            {Scheme: "exact", PayTo: "bc1q...", Price: "10000", Network: btc.BtcMainnetCAIP2},
        },
        Description: "Data endpoint accepting BTC",
        MimeType:    "application/json",
    },
}

routes := t402http.RoutesConfig{
    "GET /api/data": {
        Accepts: t402http.PaymentOptions{
            {Scheme: "exact", PayTo: "bc1q...", Price: "10000", Network: btc.BtcMainnetCAIP2},
            {Scheme: "exact", PayTo: "0x...", Price: "$0.01", Network: "eip155:8453"},
        },
    },
}

const testnetRpcs = {
  'eip155:11155111': 'https://rpc.sepolia.org',
  'eip155:84532': 'https://sepolia.base.org',
  'eip155:421614': 'https://sepolia-rollup.arbitrum.io/rpc',
  'eip155:11155420': 'https://sepolia.optimism.io',
};

// testnet-config.ts
const testnetRoutes = {
  '/api/test/*': {
    accepts: [
      {
        scheme: 'exact',
        network: 'eip155:84532', // Base Sepolia
        payTo: '0xYourTestAddress',
        price: '$0.001',
      },
    ],
  },
};

const tonTestnetConfig = {
  network: 'ton:testnet',
  jettonMaster: 'kQD0GKBM8ZbryVk2aESmzfU6b9b_8era_IkvBSELujFZPsyy',
  rpcUrl: 'https://testnet.toncenter.com/api/v2/jsonRPC',
};

const nearTestnetConfig = {
  network: 'near:testnet',
  rpcUrl: 'https://rpc.testnet.near.org',
  tokenContract: 'usdt.fakes.testnet',
};

# .env.test
NODE_ENV=test
T402_NETWORK=eip155:84532
T402_RPC_URL=https://sepolia.base.org
T402_PAY_TO=0xYourTestAddress
T402_FACILITATOR_URL=https://facilitator.t402.io

const isTestnet = process.env.NODE_ENV === 'test';
 
const config = {
  network: isTestnet ? 'eip155:84532' : 'eip155:8453',
  facilitator: 'https://facilitator.t402.io', // Same for both
};

import { describe, it, expect } from 'vitest';
import { t402Client } from '@t402/core/client';
 
describe('T402 Integration', () => {
  it('should complete payment flow', async () => {
    const client = new t402Client();
    // ... setup with testnet
 
    const response = await client.fetch('https://api.example.com/test');
    expect(response.ok).toBe(true);
  });
});

// scripts/fund-test-wallet.ts
async function fundWallet(address: string, network: string) {
  switch (network) {
    case 'eip155:84532':
      // Base Sepolia faucet
      await requestBaseSepolia(address);
      break;
    case 'ton:testnet':
      console.log('Use @testgiver_ton_bot on Telegram');
      break;
    // ... other networks
  }
}

# Check supported networks
curl -s https://facilitator.t402.io/supported | jq '.kinds[] | select(.network | contains("testnet") or contains("sepolia"))'

Client signs → Facilitator settles on-chain

Client transfers on-chain → Submits tx hash → Facilitator verifies

Client authorizes max → Server tracks usage → Facilitator settles actual amount