Machine Integration Examples

Python Client

import requests
import hmac
import hashlib
import base64
from eth_account import Account
from eth_account.messages import encode_structured_data

class SigweiClient:
    def __init__(self, private_key, base_url="https://402ify.com"):
        self.account = Account.from_key(private_key)
        self.base_url = base_url
        self.access_token = None
    
    def authenticate(self):
        # Get message to sign
        response = requests.get(
            f"{self.base_url}/api/v1/auth/message",
            params={"walletAddress": self.account.address}
        )
        message = response.json()["message"]
        
        # Sign message
        encoded_msg = encode_structured_data(primitive=message)
        signature = self.account.sign_message(encoded_msg)
        
        # Login
        auth_response = requests.post(
            f"{self.base_url}/api/v1/auth/login",
            json={"message": message, "signature": signature.signature.hex()}
        )
        self.access_token = auth_response.json()["accessToken"]
    
    def create_paygate(self, target_url, method="GET", price="0.01",
                      network="base-sepolia", require_auth=False, header_auth_mode="hmac", assume_valid=False):
        if not self.access_token:
            self.authenticate()

        response = requests.post(
            f"{self.base_url}/api/v1/paygates",
            headers={"Authorization": f"Bearer {self.access_token}"},
            json={
                "targetUrl": target_url,
                "method": method,
                "price": price,
                "network": network,
                "paymentAddress": self.account.address,
                "requireAuth": require_auth,
                "headerAuthMode": header_auth_mode,
                "assumeValid": assume_valid
            }
        )
        return response.json()
    
    def get_paygates(self):
        if not self.access_token:
            self.authenticate()
        
        response = requests.get(
            f"{self.base_url}/api/v1/paygates",
            headers={"Authorization": f"Bearer {self.access_token}"}
        )
        return response.json()
    
    def execute_transfer(self, to_address, amount_usdc):
        # Generate EIP-712 signature for USDC transfer
        nonce = "0x" + secrets.token_hex(32)
        valid_before = int(time.time()) + 3600  # 1 hour validity
        
        authorization = {
            "from": self.account.address,
            "to": to_address,
            "value": str(int(amount_usdc * 1e6)),  # Convert to USDC wei
            "validAfter": "0",
            "validBefore": str(valid_before),
            "nonce": nonce
        }
        
        # Sign with EIP-712 (implementation depends on your signing library)
        signature = self.sign_transfer_authorization(authorization)
        
        response = requests.post(
            f"{self.base_url}/api/v1/transfer",
            json={
                "network": "base-sepolia",
                "signature": signature,
                "authorization": authorization
            }
        )
        return response.json()

# Usage example
client = SigweiClient("0xYOUR_PRIVATE_KEY")

# Create a PayGate
paygate = client.create_paygate(
    target_url="https://api.example.com/data",
    method="GET",
    price="0.05",
    require_auth=True,
    header_auth_mode="hmac"
)

print(f"PayGate created: {paygate['accessUrl']}")

JavaScript/Node.js Client

import axios from 'axios';
import { withPaymentInterceptor } from 'x402-axios';
import { createWalletClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { baseSepolia } from 'viem/chains';

class SigweiClient {
  constructor(privateKey, baseURL = 'https://402ify.com') {
    this.account = privateKeyToAccount(privateKey);
    this.walletClient = createWalletClient({
      account: this.account,
      chain: baseSepolia,
      transport: http()
    });
    this.baseURL = baseURL;
    this.authToken = null;
    
    // Create x402-enabled HTTP client
    this.paymentClient = withPaymentInterceptor(axios, this.walletClient);
  }

  async authenticate() {
    const walletAddress = this.account.address;
    
    // Get auth message
    const messageResponse = await axios.get(
      `${this.baseURL}/api/v1/auth/message?walletAddress=${walletAddress}`
    );
    const { message } = messageResponse.data;

    // Sign message
    const signature = await this.walletClient.signMessage({
      message: { raw: message }
    });

    // Login
    const loginResponse = await axios.post(`${this.baseURL}/api/v1/auth/login`, {
      message,
      signature
    });

    this.authToken = loginResponse.data.accessToken;
    return this.authToken;
  }

  async createPayGate(config) {
    if (!this.authToken) {
      await this.authenticate();
    }

    const response = await axios.post(
      `${this.baseURL}/api/v1/paygates`,
      {
        targetUrl: config.targetUrl,
        method: config.method || 'GET',
        price: config.price || '0.01',
        network: config.network || 'base-sepolia',
        paymentAddress: this.account.address,
        requireAuth: config.requireAuth || false,
        headerAuthMode: config.headerAuthMode || 'hmac',
        title: config.title || '',
        description: config.description || ''
      },
      {
        headers: {
          Authorization: `Bearer ${this.authToken}`,
          'Content-Type': 'application/json'
        }
      }
    );

    return response.data;
  }

  async accessPayGate(shortCode, requiresAuth = false) {
    let headers = {};
    
    if (requiresAuth) {
      if (!this.authToken) {
        await this.authenticate();
      }
      headers.Authorization = `Bearer ${this.authToken}`;
    }

    try {
      const response = await this.paymentClient.get(
        `${this.baseURL}/${shortCode}`,
        { headers }
      );
      return response.data;
    } catch (error) {
      if (error.response?.status === 401) {
        // Re-authenticate and retry
        await this.authenticate();
        headers.Authorization = `Bearer ${this.authToken}`;
        
        const retryResponse = await this.paymentClient.get(
          `${this.baseURL}/${shortCode}`,
          { headers }
        );
        return retryResponse.data;
      }
      throw error;
    }
  }

  async getDashboardStats() {
    if (!this.authToken) {
      await this.authenticate();
    }

    const response = await axios.get(
      `${this.baseURL}/api/v1/dashboard/stats`,
      {
        headers: {
          Authorization: `Bearer ${this.authToken}`
        }
      }
    );

    return response.data;
  }
}

// Usage example
const client = new SigweiClient('0xYOUR_PRIVATE_KEY');

// Create an authenticated PayGate
const paygate = await client.createPayGate({
  targetUrl: 'https://api.example.com/premium',
  method: 'GET',
  price: '0.10',
  requireAuth: true,
  headerAuthMode: 'hmac',
  title: 'Premium API Access'
});

console.log(`PayGate created: ${paygate.accessUrl}`);

// Access the PayGate (payment handled automatically)
const data = await client.accessPayGate(paygate.shortCode, true);
console.log('Protected data:', data);

Go Client

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "time"
)

type SigweiClient struct {
    BaseURL     string
    PrivateKey  string
    AuthToken   string
    HTTPClient  *http.Client
}

type PayGateConfig struct {
    TargetURL      string `json:"targetUrl"`
    Method         string `json:"method"`
    Price          string `json:"price"`
    Network        string `json:"network"`
    PaymentAddress string `json:"paymentAddress"`
    RequireAuth    bool   `json:"requireAuth"`
    HeaderAuthMode string `json:"headerAuthMode"`
    Title          string `json:"title,omitempty"`
    Description    string `json:"description,omitempty"`
}

func NewSigweiClient(privateKey, baseURL string) *SigweiClient {
    return &SigweiClient{
        BaseURL:    baseURL,
        PrivateKey: privateKey,
        HTTPClient: &http.Client{Timeout: 30 * time.Second},
    }
}

func (c *SigweiClient) Authenticate() error {
    // Implementation would include wallet address derivation
    // and message signing logic
    walletAddress := deriveWalletAddress(c.PrivateKey)
    
    // Get message to sign
    resp, err := c.HTTPClient.Get(
        fmt.Sprintf("%s/api/v1/auth/message?walletAddress=%s", 
                   c.BaseURL, walletAddress))
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    var messageResp struct {
        Message string `json:"message"`
    }
    if err := json.NewDecoder(resp.Body).Decode(&messageResp); err != nil {
        return err
    }

    // Sign message (implementation depends on your signing library)
    signature := signMessage(c.PrivateKey, messageResp.Message)

    // Login
    loginData := map[string]string{
        "message":   messageResp.Message,
        "signature": signature,
    }
    
    jsonData, _ := json.Marshal(loginData)
    resp, err = c.HTTPClient.Post(
        c.BaseURL+"/api/v1/auth/login",
        "application/json",
        bytes.NewBuffer(jsonData))
    
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    var authResp struct {
        AccessToken string `json:"accessToken"`
    }
    if err := json.NewDecoder(resp.Body).Decode(&authResp); err != nil {
        return err
    }

    c.AuthToken = authResp.AccessToken
    return nil
}

func (c *SigweiClient) CreatePayGate(config PayGateConfig) (map[string]interface{}, error) {
    if c.AuthToken == "" {
        if err := c.Authenticate(); err != nil {
            return nil, err
        }
    }

    jsonData, _ := json.Marshal(config)
    req, _ := http.NewRequest("POST", c.BaseURL+"/api/v1/paygates", bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer "+c.AuthToken)
    req.Header.Set("Content-Type", "application/json")

    resp, err := c.HTTPClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    return result, nil
}

// Usage example
func main() {
    client := NewSigweiClient("0xYOUR_PRIVATE_KEY", "https://402ify.com")

    paygate, err := client.CreatePayGate(PayGateConfig{
        TargetURL:      "https://api.example.com/data",
        Method:         "GET", 
        Price:          "0.05",
        PaymentAddress: "0xYOUR_WALLET_ADDRESS",
        RequireAuth:    true,
        HeaderAuthMode: "hmac",
        IsTest:         true,
        Title:          "Premium Data API",
    })

    if err != nil {
        panic(err)
    }

    fmt.Printf("PayGate created: %v\n", paygate["accessUrl"])
}

cURL Examples

# Authentication Flow
curl -X GET "https://402ify.com/api/v1/auth/message?walletAddress=0x742d35Cc6634C0532925a3b8c2414F4e456C10F4"

curl -X POST "https://402ify.com/api/v1/auth/login" \
  -H "Content-Type: application/json" \
  -d '{
    "message": "Sigwei Authentication\n\nWallet: 0x742d35cc6634c0532925a3b8c2414f4e456c10f4\nNonce: abc123def456\nTime: 2024-01-01T12:00:00Z\n\nSign this message to authenticate.",
    "signature": "0x1234567890abcdef..."
  }'

# Create PayGate
curl -X POST "https://402ify.com/api/v1/paygates" \
  -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..." \
  -H "Content-Type: application/json" \
  -d '{
    "targetUrl": "https://api.example.com/data",
    "method": "GET",
    "price": "0.01",
    "network": "base-sepolia",
    "paymentAddress": "0x742d35Cc6634C0532925a3b8c2414F4e456C10F4",
    "requireAuth": false,
    "headerAuthMode": "hmac",
    "assumeValid": false
  }'

# List PayGates
curl -X GET "https://402ify.com/api/v1/paygates" \
  -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."

# Access PayGate (first request - returns 402)
curl -X GET "https://402ify.com/abc123"

# Access PayGate with payment proof
curl -X GET "https://402ify.com/abc123" \
  -H "X-Payment: <base64-encoded-payment-data>"

# Get dashboard statistics
curl -X GET "https://402ify.com/api/v1/dashboard/stats" \
  -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."

# Update PayGate settings
curl -X PUT "https://402ify.com/api/v1/paygates/123" \
  -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..." \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Updated API Access",
    "requireAuth": true,
    "headerAuthMode": "plaintext",
    "assumeValid": false
  }'

# Regenerate PayGate secret
curl -X PATCH "https://402ify.com/api/v1/paygates/123/secret" \
  -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..." \
  -H "Content-Type: application/json" \
  -d '{"sigweiSecret": ""}'

AI Agent Integration

For AI agents and automated systems, use x402-compatible HTTP libraries that handle payment flows automatically:

# Python with x402 support
import x402_requests  # Hypothetical x402-enabled requests library

session = x402_requests.Session(wallet_client=your_wallet)
response = session.get('https://402ify.com/abc123')
# Automatically handles 402 responses and payments

// JavaScript with automatic payment handling
import { withPaymentInterceptor } from 'x402-axios';

const client = withPaymentInterceptor(axios, walletClient);
const response = await client.get('https://402ify.com/abc123');
// Payments handled automatically in background