@relaycore/sdk 1.0.0

package/hooks.ts

@@ -0,0 +1,250 @@
+import { useState, useCallback, useMemo } from 'react';
+import { useAccount, useWalletClient } from 'wagmi';
+import { BrowserProvider } from 'ethers';
+import {
+    createConsumerSDK,
+    type ServiceQuery,
+    type DiscoveredService,
+    type ServiceCallResult,
+} from './consumer-sdk';
+import {
+    createProviderSDK,
+    type ServiceRegistration,
+    type RegisteredService,
+    type ProviderReputation,
+} from './provider-sdk';
+
+/**
+ * React hook for Service Consumer SDK
+ * 
+ * Provides easy access to service discovery and calling functionality
+ * with automatic wallet integration via wagmi.
+ */
+export function useConsumerSDK(config?: { apiUrl?: string }) {
+    const { address } = useAccount();
+    const { data: walletClient } = useWalletClient();
+
+    const sdk = useMemo(() => {
+        const instance = createConsumerSDK({
+            apiUrl: config?.apiUrl,
+            network: 'mainnet',
+        });
+        return instance;
+    }, [config?.apiUrl]);
+
+    // Connect signer when wallet is available
+    const connectSigner = useCallback(async () => {
+        if (walletClient) {
+            const provider = new BrowserProvider(walletClient.transport);
+            const signer = await provider.getSigner();
+            sdk.connectSigner(signer);
+            return true;
+        }
+        return false;
+    }, [walletClient, sdk]);
+
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+
+    /**
+     * Discover services matching criteria
+     */
+    const discoverServices = useCallback(async (
+        query: ServiceQuery
+    ): Promise<DiscoveredService[]> => {
+        setLoading(true);
+        setError(null);
+        try {
+            return await sdk.discoverServices(query);
+        } catch (err) {
+            setError((err as Error).message);
+            return [];
+        } finally {
+            setLoading(false);
+        }
+    }, [sdk]);
+
+    /**
+     * Get a single service
+     */
+    const getService = useCallback(async (
+        serviceId: string
+    ): Promise<DiscoveredService | null> => {
+        setLoading(true);
+        setError(null);
+        try {
+            return await sdk.getService(serviceId);
+        } catch (err) {
+            setError((err as Error).message);
+            return null;
+        } finally {
+            setLoading(false);
+        }
+    }, [sdk]);
+
+    /**
+     * Call a service with automatic payment
+     */
+    const callService = useCallback(async <T = unknown>(params: {
+        serviceId: string;
+        endpoint?: string;
+        method?: 'GET' | 'POST';
+        body?: unknown;
+    }): Promise<ServiceCallResult<T>> => {
+        setLoading(true);
+        setError(null);
+        try {
+            await connectSigner();
+            return await sdk.callService<T>(params);
+        } catch (err) {
+            setError((err as Error).message);
+            return {
+                success: false,
+                error: (err as Error).message,
+                latencyMs: 0,
+            };
+        } finally {
+            setLoading(false);
+        }
+    }, [sdk, connectSigner]);
+
+    /**
+     * Find compatible services by type
+     */
+    const findCompatible = useCallback(async (params: {
+        inputType?: string;
+        outputType?: string;
+        tags?: string[];
+    }): Promise<DiscoveredService[]> => {
+        setLoading(true);
+        setError(null);
+        try {
+            return await sdk.findCompatibleServices(params);
+        } catch (err) {
+            setError((err as Error).message);
+            return [];
+        } finally {
+            setLoading(false);
+        }
+    }, [sdk]);
+
+    return {
+        sdk,
+        address,
+        loading,
+        error,
+        discoverServices,
+        getService,
+        callService,
+        findCompatible,
+        connectSigner,
+    };
+}
+
+/**
+ * React hook for Service Provider SDK
+ * 
+ * Provides easy access to service registration and management
+ * with automatic wallet integration via wagmi.
+ */
+export function useProviderSDK(config?: { apiUrl?: string }) {
+    const { address } = useAccount();
+    const { data: walletClient } = useWalletClient();
+
+    const sdk = useMemo(() => {
+        if (!address) return null;
+        return createProviderSDK(address, {
+            apiUrl: config?.apiUrl,
+        });
+    }, [address, config?.apiUrl]);
+
+    // Connect signer when wallet is available
+    const connectSigner = useCallback(async () => {
+        if (walletClient && sdk) {
+            const provider = new BrowserProvider(walletClient.transport);
+            const signer = await provider.getSigner();
+            sdk.connectSigner(signer);
+            return true;
+        }
+        return false;
+    }, [walletClient, sdk]);
+
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+
+    /**
+     * Register a new service
+     */
+    const registerService = useCallback(async (
+        service: ServiceRegistration
+    ): Promise<RegisteredService | null> => {
+        if (!sdk) {
+            setError('Wallet not connected');
+            return null;
+        }
+
+        setLoading(true);
+        setError(null);
+        try {
+            return await sdk.registerService(service);
+        } catch (err) {
+            setError((err as Error).message);
+            return null;
+        } finally {
+            setLoading(false);
+        }
+    }, [sdk]);
+
+    /**
+     * Get provider reputation
+     */
+    const getReputation = useCallback(async (): Promise<ProviderReputation | null> => {
+        if (!sdk) {
+            setError('Wallet not connected');
+            return null;
+        }
+
+        setLoading(true);
+        setError(null);
+        try {
+            return await sdk.getReputation();
+        } catch (err) {
+            setError((err as Error).message);
+            return null;
+        } finally {
+            setLoading(false);
+        }
+    }, [sdk]);
+
+    /**
+     * Get all services for this provider
+     */
+    const getMyServices = useCallback(async (): Promise<RegisteredService[]> => {
+        if (!sdk) {
+            setError('Wallet not connected');
+            return [];
+        }
+
+        setLoading(true);
+        setError(null);
+        try {
+            return await sdk.getMyServices();
+        } catch (err) {
+            setError((err as Error).message);
+            return [];
+        } finally {
+            setLoading(false);
+        }
+    }, [sdk]);
+
+    return {
+        sdk,
+        address,
+        loading,
+        error,
+        registerService,
+        getReputation,
+        getMyServices,
+        connectSigner,
+    };
+}

package/index.ts

@@ -0,0 +1,153 @@
+/**
+ * Relay Core SDK
+ * 
+ * Complete SDK for interacting with the Relay Core platform.
+ * 
+ * NEW (Recommended):
+ * - RelayAgent - For AI agents to discover, decide, and execute
+ * - RelayService - For service providers to expose, deliver, and earn
+ * 
+ * LEGACY (Still supported):
+ * - ServiceProviderSDK
+ * - ServiceConsumerSDK
+ * - AgentSDK
+ */
+
+// =============================================================================
+// NEW IMPROVED SDKs (Recommended)
+// =============================================================================
+
+// RelayAgent - For AI agents
+export {
+    RelayAgent,
+    createAgent,
+    type AgentConfig,
+    type TrustPolicy,
+    type ServiceCriteria,
+    type SelectedService,
+    type ExecutionResult,
+    type ExecutionError,
+    type ErrorCode,
+    type WorkflowStep as AgentWorkflowStep,
+    type WorkflowResult,
+    type OutcomeRecord as AgentOutcome,
+    type AgentMemory,
+    type AgentCard,
+    type AgentCardResource,
+    type TaskArtifact,
+    type TaskState,
+    type TaskStats,
+} from './relay-agent';
+
+// RelayService - For service providers
+export {
+    RelayService,
+    createService,
+    defineService,
+    hashProof,
+    createPaymentMiddleware,
+    type ServiceConfig,
+    type ServiceDefinition,
+    type RegisteredService as ServiceRegistered,
+    type PaymentContext,
+    type DeliveryProof,
+    type PaymentStatus,
+    type PaymentEvent,
+    type OutcomeType,
+    type OutcomeRecord as ServiceOutcome,
+    type ServiceMetrics as ServiceMetricsData,
+    type ProviderReputation as ServiceReputation,
+    type PaymentRequirements as ServicePaymentRequirements,
+    type ServiceLogger,
+    type JsonSchema,
+} from './relay-service';
+
+// =============================================================================
+// LEGACY SDKs (Backwards compatible)
+// =============================================================================
+
+// Provider SDK - For registering and managing services
+export {
+    ServiceProviderSDK,
+    createProviderSDK,
+    type ProviderSDKConfig,
+    type ServiceRegistration,
+    type RegisteredService,
+    type ProviderReputation,
+    type PaymentReceived,
+    type ServiceMetrics,
+} from './provider-sdk';
+
+// Consumer SDK - For discovering and calling services
+export {
+    ServiceConsumerSDK,
+    createConsumerSDK,
+    type ConsumerSDKConfig,
+    type ServiceQuery,
+    type DiscoveredService,
+    type PaymentResult,
+    type ServiceCallResult,
+    type WorkflowStep,
+} from './consumer-sdk';
+
+// Legacy Agent SDK (for backwards compatibility)
+export {
+    AgentSDK,
+    createAgentSDK,
+    type AgentService,
+    type AgentProfile,
+} from './agent-sdk';
+
+// Re-export types for convenience
+export type { PaymentRequirements } from '@crypto.com/facilitator-client';
+
+// =============================================================================
+// X402 PROTOCOL (Cronos Standard)
+// =============================================================================
+
+export {
+    requireX402,
+    handleX402Settlement,
+    generatePaymentId,
+    isEntitled,
+    getEntitlement,
+    recordEntitlement,
+    createPaymentRequirements,
+} from './lib/x402';
+
+export type {
+    X402Accepts,
+    X402Response,
+    X402PaidRecord,
+    X402PayResult,
+    X402ProtectionOptions,
+    X402PayParams,
+} from './types/x402.types';
+
+// =============================================================================
+// CHAT TYPES (Control Plane Architecture)
+// =============================================================================
+
+export type {
+    ChatMode,
+    ChatResponseType,
+    ChatRequest,
+    ChatResponse,
+    ChatAction,
+    SimulationResult,
+} from './types/chat.types';
+
+export { CHAT_CAPABILITIES, PROHIBITED_OPERATIONS } from './types/chat.types';
+
+// =============================================================================
+// RWA SDK (State Machine & Asset Management)
+// =============================================================================
+
+export {
+    RelayRWASDK,
+    createRWASDK,
+    type RWAConfig,
+    type RWAStateMachine,
+    type TransitionParams,
+    type TransitionResult
+} from './relay-rwa';

package/lib/erc8004.ts

@@ -0,0 +1,51 @@
+import { ethers } from 'ethers';
+
+const IDENTITY_REGISTRY_ABI = [
+    'function registerAgent(string memory agentURI, address walletAddress) external returns (uint256)',
+    'event AgentRegistered(uint256 indexed agentId, address indexed owner, string agentURI, address walletAddress)',
+];
+
+export async function registerAgent(
+    agentURI: string,
+    walletAddress: string,
+    signer: ethers.Signer,
+    contractAddress: string
+): Promise<{ agentId: number; txHash: string }> {
+    try {
+        if (!contractAddress) {
+            throw new Error('Identity Registry address not configured');
+        }
+
+        const identityRegistry = new ethers.Contract(
+            contractAddress,
+            IDENTITY_REGISTRY_ABI,
+            signer
+        );
+
+        const tx = await identityRegistry.registerAgent(agentURI, walletAddress);
+        const receipt = await tx.wait();
+
+        // Extract agentId from event
+        const event = receipt.logs.find((log: any) => {
+            try {
+                const parsed = identityRegistry.interface.parseLog(log);
+                return parsed?.name === 'AgentRegistered';
+            } catch {
+                return false;
+            }
+        });
+
+        if (event) {
+            const parsed = identityRegistry.interface.parseLog(event);
+            return {
+                agentId: Number(parsed?.args.agentId),
+                txHash: receipt.hash,
+            };
+        }
+
+        throw new Error('AgentRegistered event not found');
+    } catch (error: any) {
+        console.error('Failed to register agent:', error);
+        throw new Error(`Agent registration failed: ${error.message}`);
+    }
+}

package/lib/facilitator.ts

@@ -0,0 +1,65 @@
+import { Facilitator, type PaymentRequirements, CronosNetwork } from '@crypto.com/facilitator-client';
+
+export class FacilitatorClient {
+    private facilitator: Facilitator;
+
+    constructor(network: CronosNetwork = 'cronos-testnet', privateKey?: string) {
+        // If privateKey is provided, set it in process.env for the Facilitator SDK to pick up
+        // Note: The Facilitator SDK currently relies on process.env.WALLET_PRIVATE_KEY
+        if (privateKey) {
+            process.env.WALLET_PRIVATE_KEY = privateKey;
+        }
+
+        this.facilitator = new Facilitator({ network });
+    }
+
+    async settlePayment(params: {
+        paymentHeader: string;
+        paymentRequirements: PaymentRequirements;
+    }) {
+        try {
+            // Build the verify request
+            const verifyRequest = this.facilitator.buildVerifyRequest(
+                params.paymentHeader,
+                params.paymentRequirements
+            );
+
+            // Step 1: Verify the EIP-3009 authorization
+            const verifyResult = await this.facilitator.verifyPayment(verifyRequest);
+
+            if (!verifyResult.isValid) {
+                throw new Error('Payment verification failed: Invalid signature or parameters');
+            }
+
+            // Step 2: Settle the payment on-chain
+            const settleResult = await this.facilitator.settlePayment(verifyRequest);
+
+            return {
+                success: true,
+                txHash: settleResult.txHash,
+                timestamp: Date.now(),
+            };
+        } catch (error) {
+            console.error('Payment settlement error', error);
+            throw error;
+        }
+    }
+
+    generatePaymentRequirements(params: {
+        merchantAddress: string;
+        amount: string;
+        resourceUrl: string;
+        description?: string;
+    }): PaymentRequirements {
+        return this.facilitator.generatePaymentRequirements({
+            payTo: params.merchantAddress,
+            maxAmountRequired: params.amount,
+            resource: params.resourceUrl,
+            description: params.description || 'Protected resource access',
+        });
+    }
+
+    getFacilitator(): Facilitator {
+        return this.facilitator;
+    }
+}

package/lib/ipfs.ts

@@ -0,0 +1,71 @@
+/**
+ * IPFS Metadata Service (SDK Version)
+ */
+
+export interface AgentMetadata {
+    name: string;
+    description: string;
+    image?: string;
+    external_url?: string;
+    attributes: {
+        trait_type: string;
+        value: string | number;
+    }[];
+    service_type: string;
+    endpoint: string;
+    price_per_request: string;
+    version: string;
+    created_at: string;
+}
+
+export async function uploadAgentMetadataToIPFS(
+    metadata: AgentMetadata,
+    apiBaseUrl: string
+): Promise<string> {
+    try {
+        const response = await fetch(`${apiBaseUrl}/api/ipfs/upload-metadata`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(metadata),
+        });
+
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(error.error || 'IPFS upload failed');
+        }
+
+        const result = await response.json();
+        return result.ipfsUri;
+    } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to upload to IPFS: ${message}`);
+    }
+}
+
+export function buildAgentMetadata(params: {
+    name: string;
+    description: string;
+    serviceType: string;
+    endpoint: string;
+    pricePerRequest: string;
+    imageUri?: string;
+}): AgentMetadata {
+    return {
+        name: params.name,
+        description: params.description,
+        image: params.imageUri,
+        external_url: 'https://relaycore.xyz',
+        attributes: [
+            { trait_type: 'Service Type', value: params.serviceType },
+            { trait_type: 'Network', value: 'Cronos Testnet' },
+            { trait_type: 'Protocol', value: 'x402' },
+        ],
+        service_type: params.serviceType,
+        endpoint: params.endpoint,
+        price_per_request: params.pricePerRequest,
+        version: '1.0.0',
+        created_at: new Date().toISOString(),
+    };
+}

package/lib/supabase.ts

@@ -0,0 +1,5 @@
+import { createClient, SupabaseClient } from '@supabase/supabase-js';
+
+export function createSupabaseClient(url: string, key: string): SupabaseClient {
+    return createClient(url, key);
+}