@noosphere/agent-core 0.2.0-alpha.1 → 0.2.0-alpha.2

package/dist/index.d.ts

@@ -6,6 +6,8 @@ import { RegistryManager } from '@noosphere/registry';
 export { RegistryConfig, ContainerMetadata as RegistryContainerMetadata, RegistryManager, VerifierMetadata as RegistryVerifierMetadata } from '@noosphere/registry';
 import { PayloadData } from '@noosphere/contracts';
 export { InputType, PayloadData } from '@noosphere/contracts';
+import { IpfsConfig, S3Config, IpfsStorage, S3Storage } from '@noosphere/payload';
+export { DataUriStorage, HttpStorage, IPayloadStorage, IpfsConfig, IpfsStorage, IpfsConfig as IpfsStorageConfig, PayloadType, S3Config, S3Storage, S3Config as S3StorageConfig, UploadResult, computeContentHash, createDataUriPayload, detectPayloadType, verifyContentHash } from '@noosphere/payload';
 
 interface Commitment {
     requestId: string;
@@ -465,6 +467,13 @@ interface RetryableEvent {
     interval: number;
     containerId: string;
     retryCount: number;
+    feeAmount: string;
+    feeToken: string;
+    walletAddress: string;
+    verifier: string;
+    coordinator: string;
+    redundancy: number;
+    useDeliveryInbox: boolean;
 }
 interface ContainerExecutionConfig {
     timeout?: number;
@@ -701,294 +710,14 @@ declare class ConfigLoader {
     static getContainerConfig(config: NoosphereAgentConfig, containerId: string): NoosphereAgentConfig['containers'][0] | undefined;
 }
 
-/**
- * Payload Storage Interface
- *
- * Defines the contract for storage providers that can upload/download payload data.
- * Implementations: IpfsStorage, ArweaveStorage, HttpStorage, etc.
- */
-/**
- * Storage provider configuration
- */
-interface StorageConfig {
-    /** API endpoint URL */
-    apiUrl?: string;
-    /** Gateway URL for fetching content */
-    gateway?: string;
-    /** API key for authentication */
-    apiKey?: string;
-    /** API secret for authentication */
-    apiSecret?: string;
-    /** Request timeout in milliseconds */
-    timeout?: number;
-}
-/**
- * Upload result containing the URI and metadata
- */
-interface UploadResult {
-    /** Full URI (e.g., "ipfs://Qm...", "ar://...") */
-    uri: string;
-    /** Content identifier (CID for IPFS, txId for Arweave) */
-    contentId: string;
-    /** Size of uploaded content in bytes */
-    size: number;
-}
-/**
- * Storage provider interface
- */
-interface IPayloadStorage {
-    /**
-     * Upload content to storage
-     * @param content - Content to upload (string or Buffer)
-     * @returns Upload result with URI
-     */
-    upload(content: string | Buffer): Promise<UploadResult>;
-    /**
-     * Download content from storage
-     * @param uri - Full URI (e.g., "ipfs://Qm...")
-     * @returns Downloaded content as string
-     */
-    download(uri: string): Promise<string>;
-    /**
-     * Check if the storage provider is configured and available
-     * @returns true if storage is ready to use
-     */
-    isConfigured(): boolean;
-    /**
-     * Get the URI scheme this storage provider handles
-     * @returns Scheme string (e.g., "ipfs", "ar", "https")
-     */
-    getScheme(): string;
-}
-
-/**
- * IPFS Storage Provider
- *
- * Supports both local IPFS nodes and Pinata API for pinning.
- *
- * @example
- * ```typescript
- * // Local IPFS node
- * const storage = new IpfsStorage({
- *   apiUrl: 'http://localhost:5001',
- *   gateway: 'http://localhost:8080/ipfs/'
- * });
- *
- * // Pinata
- * const storage = new IpfsStorage({
- *   apiUrl: 'https://api.pinata.cloud',
- *   apiKey: 'your-api-key',
- *   apiSecret: 'your-api-secret',
- *   gateway: 'https://gateway.pinata.cloud/ipfs/'
- * });
- *
- * const result = await storage.upload('Hello, IPFS!');
- * console.log(result.uri); // "ipfs://Qm..."
- * ```
- */
-
-/**
- * IPFS-specific configuration
- */
-interface IpfsStorageConfig extends StorageConfig {
-    /** IPFS API URL (default: http://localhost:5001) */
-    apiUrl?: string;
-    /** IPFS Gateway URL (default: http://localhost:8080/ipfs/) */
-    gateway?: string;
-    /** Pinata API key (required for Pinata) */
-    apiKey?: string;
-    /** Pinata API secret (required for Pinata) */
-    apiSecret?: string;
-}
-declare class IpfsStorage implements IPayloadStorage {
-    private apiUrl;
-    private gateway;
-    private apiKey?;
-    private apiSecret?;
-    private timeout;
-    private isLocalNode;
-    constructor(config?: IpfsStorageConfig);
-    getScheme(): string;
-    isConfigured(): boolean;
-    upload(content: string | Buffer): Promise<UploadResult>;
-    private uploadToLocalNode;
-    private uploadToPinata;
-    download(uri: string): Promise<string>;
-    /**
-     * Extract CID from IPFS URI
-     */
-    private extractCid;
-    /**
-     * Get the gateway URL for a given CID
-     */
-    getGatewayUrl(cidOrUri: string): string;
-}
-
-/**
- * Data URI Storage Provider
- *
- * Handles inline data using data: URI scheme (RFC 2397).
- * Used for small payloads that can be embedded directly.
- *
- * @example
- * ```typescript
- * const storage = new DataUriStorage();
- * const result = await storage.upload('{"action":"ping"}');
- * console.log(result.uri);
- * // "data:application/json;base64,eyJhY3Rpb24iOiJwaW5nIn0="
- * ```
- */
-
-interface DataUriStorageConfig {
-    /** MIME type for the data (default: application/json) */
-    mimeType?: string;
-}
-declare class DataUriStorage implements IPayloadStorage {
-    private mimeType;
-    constructor(config?: DataUriStorageConfig);
-    getScheme(): string;
-    isConfigured(): boolean;
-    upload(content: string | Buffer): Promise<UploadResult>;
-    download(uri: string): Promise<string>;
-}
-
-/**
- * HTTP/HTTPS Storage Provider
- *
- * Handles fetching content from HTTP/HTTPS URLs.
- * Upload is not supported - use a dedicated storage service instead.
- *
- * @example
- * ```typescript
- * const storage = new HttpStorage();
- * const content = await storage.download('https://api.example.com/data/123');
- * ```
- */
-
-interface HttpStorageConfig {
-    /** Request timeout in milliseconds (default: 30000) */
-    timeout?: number;
-    /** Default headers to include in requests */
-    headers?: Record<string, string>;
-}
-declare class HttpStorage implements IPayloadStorage {
-    private timeout;
-    private headers;
-    constructor(config?: HttpStorageConfig);
-    getScheme(): string;
-    isConfigured(): boolean;
-    upload(_content: string | Buffer): Promise<UploadResult>;
-    download(uri: string): Promise<string>;
-}
-
-/**
- * S3-Compatible Storage Provider
- *
- * Supports AWS S3, Cloudflare R2, MinIO, and other S3-compatible storage services.
- * Uses the AWS SDK v3 for S3 operations.
- *
- * @example
- * ```typescript
- * // Cloudflare R2
- * const storage = new S3Storage({
- *   endpoint: 'https://xxx.r2.cloudflarestorage.com',
- *   bucket: 'my-bucket',
- *   region: 'auto',
- *   accessKeyId: 'your-access-key',
- *   secretAccessKey: 'your-secret-key',
- *   publicUrlBase: 'https://pub-xxx.r2.dev'
- * });
- *
- * // AWS S3
- * const storage = new S3Storage({
- *   bucket: 'my-bucket',
- *   region: 'us-east-1',
- *   accessKeyId: 'your-access-key',
- *   secretAccessKey: 'your-secret-key',
- *   publicUrlBase: 'https://my-bucket.s3.us-east-1.amazonaws.com'
- * });
- *
- * // MinIO (local)
- * const storage = new S3Storage({
- *   endpoint: 'http://localhost:9000',
- *   bucket: 'my-bucket',
- *   region: 'us-east-1',
- *   accessKeyId: 'minioadmin',
- *   secretAccessKey: 'minioadmin',
- *   publicUrlBase: 'http://localhost:9000/my-bucket',
- *   forcePathStyle: true
- * });
- *
- * const result = await storage.upload('Hello, S3!');
- * console.log(result.uri); // "https://pub-xxx.r2.dev/abc123.json"
- * ```
- */
-
-/**
- * S3-compatible storage configuration
- */
-interface S3StorageConfig {
-    /** S3-compatible endpoint URL (required for R2/MinIO, optional for AWS S3) */
-    endpoint?: string;
-    /** Bucket name */
-    bucket: string;
-    /** AWS region (default: 'auto' for R2, 'us-east-1' for others) */
-    region?: string;
-    /** Access key ID */
-    accessKeyId: string;
-    /** Secret access key */
-    secretAccessKey: string;
-    /**
-     * Public URL base for generating accessible URLs
-     * e.g., "https://pub-xxx.r2.dev" or "https://cdn.example.com"
-     */
-    publicUrlBase: string;
-    /**
-     * Key prefix for organizing files
-     * e.g., "noosphere/outputs/"
-     */
-    keyPrefix?: string;
-    /**
-     * Use path-style URLs (required for MinIO)
-     * Default: false (uses virtual-hosted style)
-     */
-    forcePathStyle?: boolean;
-    /** Request timeout in milliseconds (default: 30000) */
-    timeout?: number;
-    /** Content type for uploaded files (default: 'application/json') */
-    contentType?: string;
-}
-declare class S3Storage implements IPayloadStorage {
-    private config;
-    private client;
-    private PutObjectCommandClass;
-    private initialized;
-    private initError;
-    constructor(config: S3StorageConfig);
-    /**
-     * Lazily initialize the S3 client
-     * This allows the class to be instantiated even if @aws-sdk/client-s3 is not installed
-     */
-    private initClient;
-    getScheme(): string;
-    isConfigured(): boolean;
-    /**
-     * Generate a unique key for the content based on its hash
-     */
-    private generateKey;
-    upload(content: string | Buffer): Promise<UploadResult>;
-    download(uri: string): Promise<string>;
-    /**
-     * Get the public URL for a given key
-     */
-    getPublicUrl(key: string): string;
-}
-
 /**
  * PayloadResolver - Unified Payload Resolution
  *
+ * This module wraps @noosphere/payload for backward compatibility.
+ * New code should use @noosphere/payload directly.
+ *
  * Resolves PayloadData to actual content by:
- * 1. Detecting URI scheme (data:, ipfs://, https://, ar://)
+ * 1. Detecting URI scheme (data:, ipfs://, https://, http://)
  * 2. Fetching content from appropriate storage
  * 3. Verifying content hash for integrity
  *
@@ -1018,20 +747,16 @@ declare enum PayloadScheme {
     DATA = "data",
     IPFS = "ipfs",
     HTTPS = "https",
-    HTTP = "http",
-    ARWEAVE = "ar",
-    CHAIN = "chain"
+    HTTP = "http"
 }
 /**
  * PayloadResolver configuration
  */
 interface PayloadResolverConfig {
     /** IPFS storage configuration */
-    ipfs?: IpfsStorageConfig;
+    ipfs?: IpfsConfig;
     /** S3-compatible storage configuration (R2, S3, MinIO) */
-    s3?: S3StorageConfig;
-    /** Arweave gateway URL */
-    arweaveGateway?: string;
+    s3?: S3Config;
     /** Size threshold for auto-upload (bytes, default: 1024) */
     uploadThreshold?: number;
     /** Default storage for large payloads ('ipfs' | 's3' | 'data') */
@@ -1053,14 +778,24 @@ interface ResolvedPayload {
     verified: boolean;
 }
 declare class PayloadResolver {
+    private baseResolver;
     private ipfsStorage;
     private s3Storage;
     private dataUriStorage;
     private httpStorage;
     private uploadThreshold;
     private defaultStorage;
-    private arweaveGateway;
     constructor(config?: PayloadResolverConfig);
+    /**
+     * Convert agent-core PayloadData to @noosphere/payload PayloadData
+     * Note: URI is decoded from hex if needed
+     */
+    private toBasePayload;
+    /**
+     * Convert @noosphere/payload PayloadData to agent-core PayloadData
+     * Note: URI is hex-encoded for on-chain compatibility
+     */
+    private fromBasePayload;
     /**
      * Detect URI scheme from PayloadData
      */
@@ -1073,10 +808,6 @@ declare class PayloadResolver {
      * @returns Resolved content and metadata
      */
     resolve(payload: PayloadData, verifyHash?: boolean): Promise<ResolvedPayload>;
-    /**
-     * Resolve Arweave URI
-     */
-    private resolveArweave;
     /**
      * Encode content as PayloadData
      *
@@ -1128,4 +859,4 @@ declare class PayloadResolver {
     deserialize(serialized: string): PayloadData;
 }
 
-export { type AgentConfig, type CheckpointData$1 as CheckpointData, type Commitment, type CommitmentSuccessCallbackEvent, type CommitmentSuccessEvent, CommitmentUtils, type ComputeDeliveredEvent, type ComputeSubscription, ConfigLoader, type ContainerConfig, type ContainerExecutionConfig, ContainerManager, type ContainerMetadata, DataUriStorage, type DataUriStorageConfig, EventMonitor, FulfillResult, HttpStorage, type HttpStorageConfig, type IPayloadStorage, IpfsStorage, type IpfsStorageConfig, NoosphereAgent, type NoosphereAgentConfig, PayloadResolver, type PayloadResolverConfig, PayloadScheme, PayloadUtils, type Payment, type ProofVerificationRequest, RequestIdUtils, type RequestStartedCallbackEvent, type RequestStartedEvent, type ResolvedPayload, type RetryableEvent, S3Storage, type S3StorageConfig, SchedulerService, type StorageConfig, type UploadResult, type VerifierMetadata };
+export { type AgentConfig, type CheckpointData$1 as CheckpointData, type Commitment, type CommitmentSuccessCallbackEvent, type CommitmentSuccessEvent, CommitmentUtils, type ComputeDeliveredEvent, type ComputeSubscription, ConfigLoader, type ContainerConfig, type ContainerExecutionConfig, ContainerManager, type ContainerMetadata, EventMonitor, FulfillResult, NoosphereAgent, type NoosphereAgentConfig, PayloadResolver, type PayloadResolverConfig, PayloadScheme, PayloadUtils, type Payment, type ProofVerificationRequest, RequestIdUtils, type RequestStartedCallbackEvent, type RequestStartedEvent, type ResolvedPayload, type RetryableEvent, SchedulerService, type VerifierMetadata };