@paypol-protocol/aps-1 1.0.0

package/dist/aps1-client.d.ts

@@ -0,0 +1,64 @@
+/**
+ * APS-1 Reference Client
+ *
+ * A client that follows the full APS-1 protocol flow:
+ *   1. Discover agent via manifest
+ *   2. Optionally negotiate price
+ *   3. Lock funds in escrow (NexusV2 or StreamV1)
+ *   4. Send execution envelope to agent
+ *   5. Receive and validate result
+ *   6. Settle escrow
+ *
+ * Usage:
+ *   const client = new APS1Client({ agentServiceUrl: 'http://localhost:3001' });
+ *   const manifest = await client.discover('token-transfer');
+ *   const result = await client.execute('token-transfer', 'Send 100 AlphaUSD to 0x...', '0xMyWallet');
+ */
+import type { APS1Manifest, APS1Result, APS1EscrowParams, APS1NegotiationMessage } from './types';
+export interface APS1ClientConfig {
+    /** Base URL of the agent service (e.g. http://localhost:3001) */
+    agentServiceUrl: string;
+    /** Optional marketplace URL for discovery */
+    marketplaceUrl?: string;
+    /** Request timeout in ms (default: 120000) */
+    timeoutMs?: number;
+}
+export declare class APS1Client {
+    private config;
+    constructor(config: APS1ClientConfig);
+    /**
+     * Discover an agent's capabilities via its APS-1 manifest.
+     */
+    discover(agentId: string): Promise<APS1Manifest>;
+    /**
+     * List all available agents from the marketplace.
+     */
+    listAgents(): Promise<APS1Manifest[]>;
+    /**
+     * Search agents by category or capability.
+     */
+    searchAgents(query: {
+        category?: string;
+        maxPrice?: number;
+        capability?: string;
+    }): Promise<APS1Manifest[]>;
+    /**
+     * Propose a price for a job (optional - only if agent supports negotiation).
+     */
+    negotiate(agentId: string, message: APS1NegotiationMessage): Promise<APS1NegotiationMessage>;
+    /**
+     * Execute a job on an agent following APS-1 protocol.
+     * This is the main entry point for hiring an agent.
+     */
+    execute(agentId: string, prompt: string, callerWallet: string, options?: {
+        payload?: Record<string, unknown>;
+        jobId?: string;
+    }): Promise<APS1Result>;
+    /**
+     * Execute with full escrow flow (for integration with on-chain escrow).
+     */
+    executeWithEscrow(agentId: string, prompt: string, callerWallet: string, escrowParams: APS1EscrowParams): Promise<APS1Result>;
+    private fetch;
+    private toAPS1Manifest;
+    private toAPS1Result;
+}

package/dist/aps1-client.js

@@ -0,0 +1,188 @@
+/**
+ * APS-1 Reference Client
+ *
+ * A client that follows the full APS-1 protocol flow:
+ *   1. Discover agent via manifest
+ *   2. Optionally negotiate price
+ *   3. Lock funds in escrow (NexusV2 or StreamV1)
+ *   4. Send execution envelope to agent
+ *   5. Receive and validate result
+ *   6. Settle escrow
+ *
+ * Usage:
+ *   const client = new APS1Client({ agentServiceUrl: 'http://localhost:3001' });
+ *   const manifest = await client.discover('token-transfer');
+ *   const result = await client.execute('token-transfer', 'Send 100 AlphaUSD to 0x...', '0xMyWallet');
+ */
+import { APS1_VERSION } from './types';
+export class APS1Client {
+    config;
+    constructor(config) {
+        this.config = {
+            agentServiceUrl: config.agentServiceUrl.replace(/\/$/, ''),
+            marketplaceUrl: config.marketplaceUrl ?? config.agentServiceUrl.replace(/\/$/, ''),
+            timeoutMs: config.timeoutMs ?? 120000,
+        };
+    }
+    // ── Phase 1: Discovery ─────────────────────────────────
+    /**
+     * Discover an agent's capabilities via its APS-1 manifest.
+     */
+    async discover(agentId) {
+        const res = await this.fetch(`${this.config.agentServiceUrl}/agents/${agentId}`);
+        const data = await res.json();
+        // Wrap existing manifests in APS-1 format
+        return this.toAPS1Manifest(data, agentId);
+    }
+    /**
+     * List all available agents from the marketplace.
+     */
+    async listAgents() {
+        const res = await this.fetch(`${this.config.agentServiceUrl}/agents`);
+        const agents = await res.json();
+        return (Array.isArray(agents) ? agents : []).map((a) => this.toAPS1Manifest(a, a.id));
+    }
+    /**
+     * Search agents by category or capability.
+     */
+    async searchAgents(query) {
+        const all = await this.listAgents();
+        return all.filter(a => {
+            if (query.category && a.category !== query.category)
+                return false;
+            if (query.maxPrice && a.pricing.basePrice > query.maxPrice)
+                return false;
+            if (query.capability && !a.capabilities.includes(query.capability))
+                return false;
+            return true;
+        });
+    }
+    // ── Phase 2: Negotiation ───────────────────────────────
+    /**
+     * Propose a price for a job (optional - only if agent supports negotiation).
+     */
+    async negotiate(agentId, message) {
+        const manifest = await this.discover(agentId);
+        if (!manifest.endpoints.negotiate) {
+            throw new Error(`Agent ${agentId} does not support negotiation`);
+        }
+        const res = await this.fetch(manifest.endpoints.negotiate, {
+            method: 'POST',
+            body: JSON.stringify(message),
+        });
+        return res.json();
+    }
+    // ── Phase 4: Execution ─────────────────────────────────
+    /**
+     * Execute a job on an agent following APS-1 protocol.
+     * This is the main entry point for hiring an agent.
+     */
+    async execute(agentId, prompt, callerWallet, options) {
+        const jobId = options?.jobId ?? `aps1-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const envelope = {
+            jobId,
+            agentId,
+            prompt,
+            payload: options?.payload,
+            callerWallet,
+            timestamp: new Date().toISOString(),
+        };
+        const res = await this.fetch(`${this.config.agentServiceUrl}/agents/${agentId}/execute`, {
+            method: 'POST',
+            body: JSON.stringify({
+                jobId: envelope.jobId,
+                prompt: envelope.prompt,
+                payload: envelope.payload,
+                callerWallet: envelope.callerWallet,
+            }),
+        });
+        const result = await res.json();
+        // Normalize to APS-1 result format
+        return this.toAPS1Result(result, jobId, agentId);
+    }
+    /**
+     * Execute with full escrow flow (for integration with on-chain escrow).
+     */
+    async executeWithEscrow(agentId, prompt, callerWallet, escrowParams) {
+        // In production, this would:
+        // 1. Create escrow on-chain (NexusV2.createJob or StreamV1.createStream)
+        // 2. Wait for confirmation
+        // 3. Include escrow info in envelope
+        // 4. Execute agent
+        // 5. Settle escrow based on result
+        // For now, execute directly (escrow handled by marketplace backend)
+        return this.execute(agentId, prompt, callerWallet);
+    }
+    // ── Helpers ────────────────────────────────────────────
+    async fetch(url, init) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs);
+        try {
+            const res = await globalThis.fetch(url, {
+                ...init,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-APS-Version': APS1_VERSION,
+                    ...init?.headers,
+                },
+                signal: controller.signal,
+            });
+            if (!res.ok) {
+                throw new Error(`APS-1 request failed: ${res.status} ${res.statusText}`);
+            }
+            return res;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    toAPS1Manifest(data, agentId) {
+        return {
+            aps: '1.0',
+            id: data.id ?? agentId,
+            name: data.name ?? agentId,
+            description: data.description ?? '',
+            category: data.category ?? 'analytics',
+            version: data.version ?? '1.0.0',
+            pricing: {
+                basePrice: data.price ?? data.pricing?.basePrice ?? 0,
+                currency: 'USD',
+                negotiable: data.pricing?.negotiable ?? false,
+            },
+            capabilities: data.capabilities ?? data.skills ?? [],
+            paymentMethods: ['nexus-escrow', 'stream-milestone', 'direct-transfer'],
+            supportedTokens: [
+                { symbol: 'AlphaUSD', address: '0x20c0000000000000000000000000000000000001', decimals: 6 },
+            ],
+            proofEnabled: data.proofEnabled ?? true,
+            walletAddress: data.walletAddress ?? '0x33F7E5da060A7FEE31AB4C7a5B27F4cC3B020793',
+            endpoints: {
+                manifest: `${this.config.agentServiceUrl}/agents/${agentId}`,
+                execute: `${this.config.agentServiceUrl}/agents/${agentId}/execute`,
+            },
+        };
+    }
+    toAPS1Result(data, jobId, agentId) {
+        return {
+            jobId: data.jobId ?? jobId,
+            agentId: data.agentId ?? agentId,
+            status: data.status ?? 'error',
+            result: data.result,
+            error: data.error,
+            onChain: data.onChain ?? data.transaction ? {
+                executed: true,
+                transactions: data.transaction ? [{
+                        hash: data.transaction.hash,
+                        blockNumber: data.transaction.blockNumber ?? 0,
+                        gasUsed: data.transaction.gasUsed ?? '0',
+                        explorerUrl: data.transaction.explorerUrl ?? '',
+                    }] : [],
+                network: data.network ?? 'Tempo L1 Moderato',
+                chainId: data.chainId ?? 42431,
+            } : undefined,
+            proof: data.proof,
+            executionTimeMs: data.executionTimeMs ?? 0,
+            timestamp: new Date().toISOString(),
+        };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @paypol-protocol/aps-1 - Agent Payment Standard v1.0
+ *
+ * The open protocol standard for AI agent payments on Tempo L1.
+ *
+ * @example
+ * ```typescript
+ * // Build an APS-1 compliant agent
+ * import { APS1Agent } from '@paypol-protocol/aps-1';
+ *
+ * const agent = new APS1Agent({
+ *   id: 'my-agent',
+ *   name: 'My Agent',
+ *   description: 'Does amazing things',
+ *   category: 'analytics',
+ *   version: '1.0.0',
+ *   pricing: { basePrice: 5, currency: 'USD', negotiable: false },
+ *   capabilities: ['analyze'],
+ *   walletAddress: '0x...',
+ * });
+ *
+ * agent.onExecute(async (envelope) => {
+ *   return { status: 'success', result: { answer: 42 } };
+ * });
+ *
+ * agent.listen(3002);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Hire an APS-1 agent
+ * import { APS1Client } from '@paypol-protocol/aps-1';
+ *
+ * const client = new APS1Client({ agentServiceUrl: 'https://paypol.xyz' });
+ * const agents = await client.listAgents();
+ * const result = await client.execute('my-agent', 'Analyze this data', '0xMyWallet');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Validate APS-1 data
+ * import { validateManifest, validateResult } from '@paypol-protocol/aps-1';
+ *
+ * const valid = validateManifest(someData);
+ * if (valid.success) {
+ *   console.log('Valid manifest:', valid.data);
+ * } else {
+ *   console.error('Invalid:', valid.errors);
+ * }
+ * ```
+ */
+export type { APS1Manifest, APS1Category, APS1Pricing, APS1PaymentMethod, APS1TokenConfig, APS1Endpoints, APS1NegotiationMessage, APS1EscrowParams, APS1Milestone, APS1ExecutionEnvelope, APS1Result, APS1Transaction, APS1Settlement, } from './types';
+export { APS1_VERSION, APS1_CHAIN_ID, APS1_NETWORK, APS1_PLATFORM_FEE_BPS, APS1_DEFAULT_TOKENS, APS1_CONTRACTS, } from './types';
+export { validateManifest, validateEnvelope, validateResult, validateEscrowParams, validateNegotiation, validateSettlement, } from './validator';
+export type { ValidationResult } from './validator';
+export { APS1Agent } from './aps1-agent';
+export type { APS1AgentConfig, APS1ExecuteHandler, APS1NegotiateHandler } from './aps1-agent';
+export { APS1Client } from './aps1-client';
+export type { APS1ClientConfig } from './aps1-client';

package/dist/index.js

@@ -0,0 +1,58 @@
+/**
+ * @paypol-protocol/aps-1 - Agent Payment Standard v1.0
+ *
+ * The open protocol standard for AI agent payments on Tempo L1.
+ *
+ * @example
+ * ```typescript
+ * // Build an APS-1 compliant agent
+ * import { APS1Agent } from '@paypol-protocol/aps-1';
+ *
+ * const agent = new APS1Agent({
+ *   id: 'my-agent',
+ *   name: 'My Agent',
+ *   description: 'Does amazing things',
+ *   category: 'analytics',
+ *   version: '1.0.0',
+ *   pricing: { basePrice: 5, currency: 'USD', negotiable: false },
+ *   capabilities: ['analyze'],
+ *   walletAddress: '0x...',
+ * });
+ *
+ * agent.onExecute(async (envelope) => {
+ *   return { status: 'success', result: { answer: 42 } };
+ * });
+ *
+ * agent.listen(3002);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Hire an APS-1 agent
+ * import { APS1Client } from '@paypol-protocol/aps-1';
+ *
+ * const client = new APS1Client({ agentServiceUrl: 'https://paypol.xyz' });
+ * const agents = await client.listAgents();
+ * const result = await client.execute('my-agent', 'Analyze this data', '0xMyWallet');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Validate APS-1 data
+ * import { validateManifest, validateResult } from '@paypol-protocol/aps-1';
+ *
+ * const valid = validateManifest(someData);
+ * if (valid.success) {
+ *   console.log('Valid manifest:', valid.data);
+ * } else {
+ *   console.error('Invalid:', valid.errors);
+ * }
+ * ```
+ */
+// ── Constants ─────────────────────────────────────────────
+export { APS1_VERSION, APS1_CHAIN_ID, APS1_NETWORK, APS1_PLATFORM_FEE_BPS, APS1_DEFAULT_TOKENS, APS1_CONTRACTS, } from './types';
+// ── Validation ────────────────────────────────────────────
+export { validateManifest, validateEnvelope, validateResult, validateEscrowParams, validateNegotiation, validateSettlement, } from './validator';
+// ── Reference Implementations ─────────────────────────────
+export { APS1Agent } from './aps1-agent';
+export { APS1Client } from './aps1-client';

package/dist/types.d.ts

@@ -0,0 +1,246 @@
+/**
+ * APS-1: Agent Payment Standard v1.0
+ *
+ * Core type definitions for the PayPol Agent Payment Standard.
+ * These interfaces define the protocol for how AI agents discover,
+ * negotiate, escrow, execute, verify, and settle payments.
+ *
+ * Framework-agnostic - works with OpenAI, Anthropic, LangChain,
+ * CrewAI, MCP, Eliza, or any HTTP-based agent.
+ */
+/**
+ * APS-1 Agent Manifest - the identity card of every APS-1 compliant agent.
+ * Served at GET /manifest endpoint.
+ */
+export interface APS1Manifest {
+    /** Protocol version identifier */
+    aps: '1.0';
+    /** Unique agent identifier (kebab-case, e.g. "contract-auditor") */
+    id: string;
+    /** Human-readable agent name */
+    name: string;
+    /** What the agent does (1-3 sentences) */
+    description: string;
+    /** Agent category */
+    category: APS1Category;
+    /** Semantic version (semver) */
+    version: string;
+    /** Pricing configuration */
+    pricing: APS1Pricing;
+    /** List of capabilities/skills */
+    capabilities: string[];
+    /** Supported payment methods */
+    paymentMethods: APS1PaymentMethod[];
+    /** ERC20 token addresses the agent accepts */
+    supportedTokens: APS1TokenConfig[];
+    /** Whether the agent uses AIProofRegistry for verifiable execution */
+    proofEnabled: boolean;
+    /** Agent's reputation score (0-10000, from ReputationRegistry) */
+    reputationScore?: number;
+    /** Agent's wallet address on Tempo L1 */
+    walletAddress: string;
+    /** HTTP endpoints */
+    endpoints: APS1Endpoints;
+    /** Optional metadata */
+    metadata?: Record<string, unknown>;
+}
+export type APS1Category = 'security' | 'escrow' | 'payments' | 'streams' | 'analytics' | 'deployment' | 'privacy' | 'verification' | 'orchestration' | 'payroll' | 'admin';
+export interface APS1Pricing {
+    /** Base price in USD */
+    basePrice: number;
+    /** Currency (always USD in v1) */
+    currency: 'USD';
+    /** Whether the agent accepts price negotiation */
+    negotiable: boolean;
+    /** Minimum acceptable price (if negotiable) */
+    minPrice?: number;
+    /** Maximum price (if negotiable) */
+    maxPrice?: number;
+}
+export type APS1PaymentMethod = 'nexus-escrow' | 'stream-milestone' | 'direct-transfer';
+export interface APS1TokenConfig {
+    /** Token symbol (e.g. "AlphaUSD") */
+    symbol: string;
+    /** ERC20 contract address on Tempo L1 */
+    address: string;
+    /** Token decimals */
+    decimals: number;
+}
+export interface APS1Endpoints {
+    /** GET /manifest - returns APS1Manifest */
+    manifest: string;
+    /** POST /execute - executes a job */
+    execute: string;
+    /** POST /negotiate - optional price negotiation */
+    negotiate?: string;
+    /** GET /status/:jobId - check job status */
+    status?: string;
+    /** GET /health - health check */
+    health?: string;
+}
+/**
+ * APS-1 Negotiation Message - for optional price negotiation between
+ * client and agent before escrow lockup.
+ */
+export interface APS1NegotiationMessage {
+    /** Message type in the negotiation flow */
+    type: 'propose' | 'counter' | 'accept' | 'reject';
+    /** Job ID this negotiation is for */
+    jobId: string;
+    /** Proposed/countered price in USD */
+    price: number;
+    /** Currency */
+    currency: 'USD';
+    /** Optional human-readable message */
+    message?: string;
+    /** ISO timestamp */
+    timestamp: string;
+}
+/**
+ * APS-1 Escrow Parameters - defines how funds are locked before execution.
+ */
+export interface APS1EscrowParams {
+    /** Which payment method to use */
+    method: APS1PaymentMethod;
+    /** ERC20 token address */
+    token: string;
+    /** Amount to lock (in token's smallest unit) */
+    amount: string;
+    /** Amount in USD (for display) */
+    amountUSD: number;
+    /** Deadline in seconds from now */
+    deadlineSeconds: number;
+    /** Worker (agent) wallet address */
+    workerWallet: string;
+    /** Judge wallet address (for NexusV2 disputes) */
+    judgeWallet?: string;
+    /** Milestones (for stream-milestone method) */
+    milestones?: APS1Milestone[];
+}
+export interface APS1Milestone {
+    /** Amount for this milestone (in token's smallest unit) */
+    amount: string;
+    /** Description of the deliverable */
+    deliverable: string;
+}
+/**
+ * APS-1 Execution Envelope - the standardized job request sent to an agent.
+ * This is what gets POSTed to the agent's /execute endpoint.
+ */
+export interface APS1ExecutionEnvelope {
+    /** Unique job identifier */
+    jobId: string;
+    /** Agent identifier */
+    agentId: string;
+    /** Natural language prompt describing the task */
+    prompt: string;
+    /** Optional structured payload */
+    payload?: Record<string, unknown>;
+    /** Client's wallet address */
+    callerWallet: string;
+    /** Escrow information (if funds are locked) */
+    escrow?: {
+        /** Smart contract address holding the funds */
+        contractAddress: string;
+        /** On-chain job/stream ID */
+        onChainId: number;
+        /** Transaction hash of the escrow creation */
+        txHash: string;
+        /** Payment method used */
+        method: APS1PaymentMethod;
+    };
+    /** AI Proof commitment (if proofEnabled) */
+    proof?: {
+        /** keccak256 hash of the agent's planned approach */
+        planHash: string;
+        /** Commitment ID from AIProofRegistry */
+        commitmentId: string;
+        /** Transaction hash of the commit() call */
+        commitTxHash: string;
+    };
+    /** ISO timestamp */
+    timestamp: string;
+}
+/**
+ * APS-1 Execution Result - the standardized response from an agent.
+ */
+export interface APS1Result {
+    /** Job identifier (matches envelope.jobId) */
+    jobId: string;
+    /** Agent identifier */
+    agentId: string;
+    /** Execution status */
+    status: 'success' | 'error' | 'pending';
+    /** Result data (agent-specific) */
+    result?: unknown;
+    /** Error message (if status === 'error') */
+    error?: string;
+    /** On-chain execution details */
+    onChain?: {
+        /** Whether real on-chain transactions were executed */
+        executed: boolean;
+        /** Transaction hashes */
+        transactions: APS1Transaction[];
+        /** Network identifier */
+        network: string;
+        /** Chain ID */
+        chainId: number;
+    };
+    /** AI Proof verification (if proofEnabled) */
+    proof?: {
+        /** keccak256 hash of the actual execution result */
+        resultHash: string;
+        /** Transaction hash of the verify() call */
+        verifyTxHash: string;
+        /** Whether plan hash matched result hash */
+        matched: boolean;
+    };
+    /** Execution time in milliseconds */
+    executionTimeMs: number;
+    /** ISO timestamp */
+    timestamp: string;
+}
+export interface APS1Transaction {
+    /** Transaction hash */
+    hash: string;
+    /** Block number */
+    blockNumber: number;
+    /** Gas used */
+    gasUsed: string;
+    /** Tempo Explorer URL */
+    explorerUrl: string;
+    /** Description of what this TX did */
+    description?: string;
+}
+/**
+ * APS-1 Settlement Event - emitted when escrow is settled.
+ */
+export interface APS1Settlement {
+    /** Job identifier */
+    jobId: string;
+    /** Settlement type */
+    type: 'settle' | 'refund' | 'dispute';
+    /** Amount paid to agent (after fee deduction) */
+    agentPayout: string;
+    /** Platform fee amount */
+    platformFee: string;
+    /** Settlement transaction hash */
+    txHash: string;
+    /** ISO timestamp */
+    timestamp: string;
+}
+export declare const APS1_VERSION: "1.0";
+export declare const APS1_CHAIN_ID = 42431;
+export declare const APS1_NETWORK = "Tempo L1 Moderato";
+export declare const APS1_PLATFORM_FEE_BPS = 800;
+/** Default supported tokens on Tempo L1 */
+export declare const APS1_DEFAULT_TOKENS: APS1TokenConfig[];
+/** PayPol smart contract addresses on Tempo L1 */
+export declare const APS1_CONTRACTS: {
+    readonly NexusV2: "0x6A467Cd4156093bB528e448C04366586a1052Fab";
+    readonly ShieldVaultV2: "0x3B4b47971B61cB502DD97eAD9cAF0552ffae0055";
+    readonly MultisendV2: "0x25f4d3f12C579002681a52821F3a6251c46D4575";
+    readonly AIProofRegistry: "0x8fDB8E871c9eaF2955009566F41490Bbb128a014";
+    readonly StreamV1: "0x4fE37c46E3D442129c2319de3D24c21A6cbfa36C";
+    readonly Reputation: "0x9332c1B2bb94C96DA2D729423f345c76dB3494D0";
+};

package/dist/types.js

@@ -0,0 +1,31 @@
+/**
+ * APS-1: Agent Payment Standard v1.0
+ *
+ * Core type definitions for the PayPol Agent Payment Standard.
+ * These interfaces define the protocol for how AI agents discover,
+ * negotiate, escrow, execute, verify, and settle payments.
+ *
+ * Framework-agnostic - works with OpenAI, Anthropic, LangChain,
+ * CrewAI, MCP, Eliza, or any HTTP-based agent.
+ */
+// ── Protocol Constants ─────────────────────────────────────
+export const APS1_VERSION = '1.0';
+export const APS1_CHAIN_ID = 42431;
+export const APS1_NETWORK = 'Tempo L1 Moderato';
+export const APS1_PLATFORM_FEE_BPS = 800; // 8%
+/** Default supported tokens on Tempo L1 */
+export const APS1_DEFAULT_TOKENS = [
+    { symbol: 'AlphaUSD', address: '0x20c0000000000000000000000000000000000001', decimals: 6 },
+    { symbol: 'pathUSD', address: '0x20c0000000000000000000000000000000000000', decimals: 6 },
+    { symbol: 'BetaUSD', address: '0x20c0000000000000000000000000000000000002', decimals: 6 },
+    { symbol: 'ThetaUSD', address: '0x20c0000000000000000000000000000000000003', decimals: 6 },
+];
+/** PayPol smart contract addresses on Tempo L1 */
+export const APS1_CONTRACTS = {
+    NexusV2: '0x6A467Cd4156093bB528e448C04366586a1052Fab',
+    ShieldVaultV2: '0x3B4b47971B61cB502DD97eAD9cAF0552ffae0055',
+    MultisendV2: '0x25f4d3f12C579002681a52821F3a6251c46D4575',
+    AIProofRegistry: '0x8fDB8E871c9eaF2955009566F41490Bbb128a014',
+    StreamV1: '0x4fE37c46E3D442129c2319de3D24c21A6cbfa36C',
+    Reputation: '0x9332c1B2bb94C96DA2D729423f345c76dB3494D0',
+};