Other Chain Mechanisms

pnpm add @t402/near

import { ExactDirectNearClient } from '@t402/near/exact-direct/client'
 
const client = new ExactDirectNearClient({
  accountId: 'alice.near',
  signAndSendTransaction: async (receiverId, actions) => {
    // Use your NEAR wallet to sign and send
    const result = await wallet.signAndSendTransaction({ receiverId, actions })
    return result.transaction.hash
  }
})
 
// Create payment payload (executes transfer on-chain)
const payload = await client.createPaymentPayload(2, requirements)

import { ExactDirectNearServer } from '@t402/near/exact-direct/server'
 
const server = new ExactDirectNearServer({
  rpcUrl: 'https://rpc.mainnet.near.org'
})
 
// Enhance requirements with NEAR-specific fields
const enhanced = await server.enhancePaymentRequirements(baseRequirements)

import { ExactDirectNearFacilitator } from '@t402/near/exact-direct/facilitator'
 
const facilitator = new ExactDirectNearFacilitator({
  rpcUrl: 'https://rpc.mainnet.near.org',
  indexerUrl: 'https://api.nearblocks.io' // optional
})
 
// Verify the transaction hash from client
const result = await facilitator.verify(payload, requirements)
// For exact-direct, settle is a no-op (already settled by client)
const settled = await facilitator.settle(payload, requirements)

const requirements = {
  scheme: 'exact-direct',
  network: 'near:mainnet',
  amount: '1000000', // 1 USDT (6 decimals)
  asset: 'usdt.tether-token.near', // NEP-141 contract ID
  payTo: 'merchant.near',
  maxTimeoutSeconds: 300
}

interface ExactDirectNearPayload {
  txHash: string;   // base58 transaction hash
  from: string;     // sender account ID
  to: string;       // recipient account ID
  amount: string;   // amount in smallest units
}

import "github.com/t402-io/t402/sdks/go/mechanisms/near"
 
// Client
client := near.NewExactDirectNearScheme(signer, &near.ExactDirectNearClientConfig{
    GasAmount: "30000000000000", // 30 TGas
})
payload, err := client.CreatePaymentPayload(ctx, requirements)
 
// Facilitator
facilitator := near.NewExactDirectNearFacilitator(rpcURL)
result, err := facilitator.Verify(ctx, payload, requirements)

pnpm add @t402/aptos

import { ExactDirectAptosClient } from '@t402/aptos/exact-direct/client'
 
const client = new ExactDirectAptosClient({
  address: '0x1234...abcd',
  signAndSubmitTransaction: async (payload) => {
    // Use your Aptos wallet (Petra, Martian, etc.)
    const result = await wallet.signAndSubmitTransaction(payload)
    return result.hash
  }
})
 
const payload = await client.createPaymentPayload(2, requirements)

import { ExactDirectAptosServer } from '@t402/aptos/exact-direct/server'
 
const server = new ExactDirectAptosServer({
  rpcUrl: 'https://fullnode.mainnet.aptoslabs.com/v1'
})
 
const enhanced = await server.enhancePaymentRequirements(baseRequirements)

import { ExactDirectAptosFacilitator } from '@t402/aptos/exact-direct/facilitator'
 
const facilitator = new ExactDirectAptosFacilitator({
  rpcUrl: 'https://fullnode.mainnet.aptoslabs.com/v1'
})
 
const result = await facilitator.verify(payload, requirements)
const settled = await facilitator.settle(payload, requirements)

const requirements = {
  scheme: 'exact-direct',
  network: 'aptos:1',
  amount: '1000000', // 1 USDT (6 decimals)
  asset: '0xf73e887a8754f540ee6e1a93bdc6dde2af69fc7ca5de32013e89dd44244473cb', // FA metadata address
  payTo: '0xRecipientAddress...',
  maxTimeoutSeconds: 600
}

interface ExactDirectAptosPayload {
  txHash: string;           // Aptos transaction hash
  from: string;             // sender address (0x format)
  to: string;               // recipient address
  amount: string;           // amount as string
  metadataAddress: string;  // FA metadata address
}

0x1::primary_fungible_store::transfer

import "github.com/t402-io/t402/sdks/go/mechanisms/aptos"
 
// Client
client := aptos.NewExactDirectAptosScheme(signer, &aptos.Config{
    MaxGasAmount: 100000,
    GasUnitPrice: 100,
})
payload, err := client.CreatePaymentPayload(ctx, requirements)
 
// Facilitator
facilitator := aptos.NewExactDirectAptosFacilitator(rpcURL)
result, err := facilitator.Verify(ctx, payload, requirements)

pnpm add @t402/tezos

import { ExactDirectTezosClient } from '@t402/tezos/exact-direct/client'
 
const client = new ExactDirectTezosClient({
  address: 'tz1YourAddress...',
  signAndSendOperation: async (params) => {
    // Use your Tezos wallet (Temple, Kukai, etc.)
    const result = await wallet.sendOperation(params)
    return result.opHash
  }
})
 
const payload = await client.createPaymentPayload(2, requirements)

import { ExactDirectTezosServer } from '@t402/tezos/exact-direct/server'
 
const server = new ExactDirectTezosServer({
  rpcUrl: 'https://mainnet.api.tez.ie'
})
 
const enhanced = await server.enhancePaymentRequirements(baseRequirements)

import { ExactDirectTezosFacilitator } from '@t402/tezos/exact-direct/facilitator'
 
const facilitator = new ExactDirectTezosFacilitator({
  rpcUrl: 'https://mainnet.api.tez.ie',
  indexerUrl: 'https://api.tzkt.io' // TzKT indexer for verification
})
 
const result = await facilitator.verify(payload, requirements)
const settled = await facilitator.settle(payload, requirements)

const requirements = {
  scheme: 'exact-direct',
  network: 'tezos:NetXdQprcVkpaWU',
  amount: '1000000', // 1 USDT (6 decimals)
  asset: 'KT1XnTn74bUtxHfDtBmm2bGZAQfhPbvKWR8o', // FA2 contract
  payTo: 'tz1MerchantAddress...',
  maxTimeoutSeconds: 300,
  extra: {
    tokenId: 0 // Token ID within the FA2 contract
  }
}

interface ExactDirectTezosPayload {
  opHash: string;           // operation hash (o prefix, base58)
  from: string;             // sender address (tz1/tz2/tz3 prefix)
  to: string;               // recipient address
  amount: string;           // amount in smallest units
  contractAddress: string;  // FA2 contract address (KT1 prefix)
  tokenId: number;          // token ID within contract
}

transfer: list(
  pair(
    address,  // from
    list(pair(address, pair(nat, nat)))  // [(to, (token_id, amount))]
  )
)

import "github.com/t402-io/t402/sdks/go/mechanisms/tezos"
 
// Client
client := tezos.NewExactDirectTezosScheme(signer, &tezos.Config{})
payload, err := client.CreatePaymentPayload(ctx, requirements)
 
// Facilitator
facilitator := tezos.NewExactDirectTezosFacilitator(rpcURL, indexerURL)
result, err := facilitator.Verify(ctx, payload, requirements)

pnpm add @t402/polkadot

import { createExactDirectPolkadotClient } from '@t402/polkadot/exact-direct/client'
 
const client = createExactDirectPolkadotClient({
  address: '15oF4uVJwmo4TdGW7VfQxNLavjCXviqWrb9sGQgMT9kNNQjL',
  signAndSubmitExtrinsic: async (call, network) => {
    // Use your Polkadot wallet (Polkadot.js, Talisman, SubWallet)
    const result = await wallet.signAndSubmit(call)
    return {
      extrinsicHash: result.hash,
      extrinsicId: `${result.blockHash}-${result.index}`
    }
  }
})
 
const payload = await client.createPaymentPayload(2, requirements)

import { registerExactDirectPolkadotServer } from '@t402/polkadot/exact-direct/server'
 
const server = registerExactDirectPolkadotServer({
  rpcUrl: 'wss://polkadot-asset-hub-rpc.polkadot.io'
})

import { createExactDirectPolkadotFacilitator } from '@t402/polkadot/exact-direct/facilitator'
 
const facilitator = createExactDirectPolkadotFacilitator({
  indexerUrl: 'https://assethub-polkadot.api.subscan.io'
})
 
const result = await facilitator.verify(payload, requirements)
const settled = await facilitator.settle(payload, requirements)

const requirements = {
  scheme: 'exact-direct',
  network: 'polkadot:68d56f15f85d3136970ec16946040bc1',
  amount: '1000000', // 1 USDT (6 decimals)
  asset: '1984', // Asset ID for USDT on Asset Hub
  payTo: '15oF4uVJwmo4TdGW7VfQxNLavjCXviqWrb9sGQgMT9kNNQjL',
  maxTimeoutSeconds: 300
}

interface ExactDirectPolkadotPayload {
  extrinsicHash: string;  // extrinsic hash
  extrinsicId: string;    // format: "{blockHash}-{extrinsicIndex}"
  from: string;           // sender SS58 address
  to: string;             // recipient SS58 address
  amount: string;         // amount in smallest units
  assetId: number;        // Asset ID (1984 for USDT)
}

import "github.com/t402-io/t402/sdks/go/mechanisms/polkadot"
 
// Client
client := polkadot.NewExactDirectPolkadotScheme(signer, &polkadot.Config{})
payload, err := client.CreatePaymentPayload(ctx, requirements)
 
// Facilitator
facilitator := polkadot.NewExactDirectPolkadotFacilitator(indexerURL)
result, err := facilitator.Verify(ctx, payload, requirements)

pnpm add @t402/stacks

import { createExactDirectStacksClient } from '@t402/stacks/exact-direct/client'
 
const client = createExactDirectStacksClient({
  address: 'SP3Y2ZSH8P7D50B0VBTSX11S7XSG24M1VB9YFQA4K',
  signAndBroadcast: async (txOptions) => {
    // Use Hiro Wallet or Leather
    const result = await wallet.signAndBroadcast(txOptions)
    return result.txId
  }
})
 
const payload = await client.createPaymentPayload(2, requirements)

import { registerExactDirectStacksServer } from '@t402/stacks/exact-direct/server'
 
const server = registerExactDirectStacksServer({
  apiUrl: 'https://api.mainnet.hiro.so'
})

import { createExactDirectStacksFacilitator } from '@t402/stacks/exact-direct/facilitator'
 
const facilitator = createExactDirectStacksFacilitator({
  apiUrl: 'https://api.mainnet.hiro.so'
})
 
const result = await facilitator.verify(payload, requirements)
const settled = await facilitator.settle(payload, requirements)

const requirements = {
  scheme: 'exact-direct',
  network: 'stacks:1',
  amount: '1000000', // 1 sUSDC (6 decimals)
  asset: 'SP3Y2ZSH8P7D50B0VBTSX11S7XSG24M1VB9YFQA4K.token-susdc', // SIP-010 contract
  payTo: 'SP1MERCHANT...',
  maxTimeoutSeconds: 600
}

interface ExactDirectStacksPayload {
  txId: string;              // Stacks transaction ID
  from: string;              // sender principal
  to: string;                // recipient principal
  amount: string;            // amount in smallest units
  contractAddress: string;   // full SIP-010 contract address
}

(define-public (transfer
  (amount uint)
  (sender principal)
  (recipient principal)
  (memo (optional (buff 34)))
)

import "github.com/t402-io/t402/sdks/go/mechanisms/stacks"
 
// Client
client := stacks.NewExactDirectStacksScheme(signer, &stacks.Config{})
payload, err := client.CreatePaymentPayload(ctx, requirements)
 
// Facilitator
facilitator := stacks.NewExactDirectStacksFacilitator(apiURL)
result, err := facilitator.Verify(ctx, payload, requirements)

import { ExactDirectCosmosClient } from '@t402/cosmos/exact-direct/client'
 
const client = new ExactDirectCosmosClient({
  address: 'noble1abc...xyz',
  signAndBroadcast: async (txRaw) => {
    // Use your Cosmos wallet to sign and broadcast
    const result = await wallet.signAndBroadcast(txRaw)
    return result.transactionHash
  }
})
 
// Create payment payload (executes transfer on-chain)
const payload = await client.createPaymentPayload(2, requirements)

import { ExactDirectCosmosClient } from '@t402/cosmos/exact-direct/client'
 
const client = new ExactDirectCosmosClient({
  address: 'noble1ejc2c2gvk46h7kyulx9fus85vdpq0zdjwkfav0',
  signAndBroadcast: async (txRaw) => {
    // Sign and broadcast the MsgSend transaction
    const result = await wallet.signAndBroadcast(txRaw)
    return result.transactionHash
  },
  gasLimit: '200000',      // optional, default 200000
  gasPrice: '0.025uusdc'   // optional, default 0.025uusdc
})
 
// Create payment payload (executes transfer on-chain)
const payload = await client.createPaymentPayload(2, requirements)

import { ExactDirectCosmosServer } from '@t402/cosmos/exact-direct/server'
 
const server = new ExactDirectCosmosServer({
  rpcUrl: 'https://noble-rpc.polkachu.com',
  restUrl: 'https://noble-api.polkachu.com'
})
 
// Enhance requirements with Cosmos-specific fields
const enhanced = await server.enhancePaymentRequirements(baseRequirements)

import { ExactDirectCosmosFacilitator } from '@t402/cosmos/exact-direct/facilitator'
 
const facilitator = new ExactDirectCosmosFacilitator({
  rpcUrl: 'https://noble-rpc.polkachu.com',
  restUrl: 'https://noble-api.polkachu.com'
})
 
// Verify the transaction hash from client
const result = await facilitator.verify(payload, requirements)
// For exact-direct, settle is a no-op (already settled by client)
const settled = await facilitator.settle(payload, requirements)

const requirements = {
  scheme: 'exact-direct',
  network: 'cosmos:noble-1',
  amount: '1000000', // 1 USDC (6 decimals)
  asset: 'uusdc', // denomination (microUSDC)
  payTo: 'noble1ejc2c2gvk46h7kyulx9fus85vdpq0zdjwkfav0',
  maxTimeoutSeconds: 300
}

interface ExactDirectCosmosPayload {
  txHash: string;    // Transaction hash (hex, no 0x prefix)
  from: string;      // noble1... sender address
  to: string;        // noble1... recipient address
  amount: string;    // Amount in uusdc (smallest unit)
  denom?: string;    // Token denomination (default: uusdc)
}

import express from 'express'
import { paymentMiddleware } from '@t402/express'
 
const app = express()
 
app.use(paymentMiddleware({
  'GET /api/premium': {
    price: '$0.01',
    network: 'cosmos:noble-1',
    asset: 'uusdc',
    payTo: 'noble1ejc2c2gvk46h7kyulx9fus85vdpq0zdjwkfav0',
    description: 'Premium API access'
  }
}))
 
app.get('/api/premium', (req, res) => {
  res.json({ data: 'premium content' })
})
 
app.listen(3000)

npm install bitcoinjs-lib

import { registerExactBtcScheme } from '@t402/btc/exact/client'
import { t402Client } from '@t402/core/client'
 
const client = new t402Client()
registerExactBtcScheme(client, {
  signer: {
    signPsbt: async (psbt) => { /* sign with wallet */ },
    getAddress: () => 'bc1q...',
    getPublicKey: () => '02...',
  },
})
 
const response = await client.fetch('https://api.example.com/premium')

import { registerLightningScheme } from '@t402/btc/lightning/client'
import { t402Client } from '@t402/core/client'
 
const client = new t402Client()
registerLightningScheme(client, {
  signer: {
    payInvoice: async (bolt11) => {
      const result = await lightningNode.pay(bolt11)
      return { preimage: result.preimage, paymentHash: result.paymentHash }
    },
    getNodePubKey: () => '02...',
  },
})

import { registerExactBtcScheme } from '@t402/btc/exact/client'
import { t402Client } from '@t402/core/client'
 
const client = new t402Client()
registerExactBtcScheme(client, {
  signer: {
    signPsbt: async (psbt) => {
      // Sign the PSBT using your Bitcoin wallet (e.g., bitcoinjs-lib)
      return signedPsbt
    },
    getAddress: () => 'bc1q...',
    getPublicKey: () => '02...',
  },
})
 
// Create payment payload (constructs and signs PSBT)
const payload = await client.createPaymentPayload(requirements)

import { registerLightningScheme } from '@t402/btc/lightning/client'
import { t402Client } from '@t402/core/client'
 
const client = new t402Client()
registerLightningScheme(client, {
  signer: {
    payInvoice: async (bolt11) => {
      // Pay BOLT11 invoice via your Lightning node (LND, CLN, etc.)
      const result = await lndClient.payInvoice({ paymentRequest: bolt11 })
      return {
        preimage: result.preimage,
        paymentHash: result.paymentHash,
      }
    },
    getNodePubKey: () => '02abc...def',
  },
})

import { registerExactBtcScheme } from '@t402/btc/exact/server'
import { registerLightningScheme } from '@t402/btc/lightning/server'
import { t402ResourceServer } from '@t402/core/server'
 
const server = new t402ResourceServer(facilitatorClient)
 
// BTC on-chain
registerExactBtcScheme(server, {
  schemeConfig: { payTo: 'bc1q...' },
})
 
// Lightning
registerLightningScheme(server, {
  schemeConfig: {
    generateInvoice: async (amountSats, description, expiry) => {
      // Generate BOLT11 invoice via your Lightning node
      const invoice = await lndClient.addInvoice({
        value: amountSats,
        memo: description,
        expiry: expiry,
      })
      return {
        bolt11Invoice: invoice.paymentRequest,
        paymentHash: invoice.rHash,
      }
    },
  },
})

import { registerExactBtcScheme } from '@t402/btc/exact/facilitator'
import { registerLightningScheme } from '@t402/btc/lightning/facilitator'
import { t402Facilitator } from '@t402/core/facilitator'
 
const facilitator = new t402Facilitator()
 
// BTC on-chain
registerExactBtcScheme(facilitator, {
  signer: btcFacilitatorSigner,
  networks: 'bip122:000000000019d6689c085ae165831e93',
})
 
// Lightning
registerLightningScheme(facilitator, {
  signer: lnFacilitatorSigner,
  networks: 'lightning:mainnet',
})

const requirements = {
  scheme: 'exact',
  network: 'bip122:000000000019d6689c085ae165831e93',
  payTo: 'bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh',
  maxAmountRequired: '100000', // satoshis
  maxTimeoutSeconds: 3600
}

const requirements = {
  scheme: 'lightning',
  network: 'lightning:mainnet',
  payTo: '02abc...def', // node pubkey
  maxAmountRequired: '1000', // satoshis
  maxTimeoutSeconds: 300,
  extra: {
    bolt11Invoice: 'lnbc10u1p...',
    paymentHash: 'abc123...',
  }
}

import express from 'express'
import { paymentMiddleware } from '@t402/express'
 
const app = express()
 
app.use(paymentMiddleware({
  'GET /api/premium': {
    price: '$1.00',
    network: 'lightning:mainnet',
    payTo: '02abc...def',
    description: 'Premium API access'
  }
}))
 
app.get('/api/premium', (req, res) => {
  res.json({ data: 'premium content' })
})
 
app.listen(3000)

npm install @t402/stellar

npm install @t402/spark