@agirails/sdk 2.0.0 → 2.0.1-beta

package/src/protocol/ProofGenerator.ts

@@ -2,83 +2,11 @@ import { keccak256, toUtf8Bytes, AbiCoder, BytesLike } from 'ethers';
 import { DeliveryProof } from '../types';
 import { DeliveryProofData, deliveryProofDataFromProof } from '../types/eip712';
 
-/**
- * SECURITY FIX (MEDIUM-2): URL validation configuration for SSRF prevention
- */
-export interface URLValidationConfig {
-  /**
-   * Allowed URL protocols (default: ['https:'])
-   * Set to ['https:', 'http:'] to allow HTTP in development
-   */
-  allowedProtocols?: string[];
-
-  /**
-   * Allow localhost URLs (default: false in production, true in dev)
-   */
-  allowLocalhost?: boolean;
-
-  /**
-   * Maximum response size in bytes (default: 10MB)
-   */
-  maxSize?: number;
-
-  /**
-   * Request timeout in milliseconds (default: 30000)
-   */
-  timeout?: number;
-
-  /**
-   * Blocked hostnames (e.g., internal services)
-   */
-  blockedHosts?: string[];
-}
-
-/**
- * Default URL validation config - SECURE by default
- */
-const DEFAULT_URL_CONFIG: Required<URLValidationConfig> = {
-  allowedProtocols: ['https:'],
-  allowLocalhost: false,
-  maxSize: 10 * 1024 * 1024, // 10MB
-  timeout: 30000, // 30 seconds
-  blockedHosts: [
-    'metadata.google.internal',
-    '169.254.169.254', // AWS/GCP metadata
-    'metadata.aws.internal',
-    'localhost',
-    '127.0.0.1',
-    '0.0.0.0',
-    '[::1]',
-  ],
-};
-
 /**
  * ProofGenerator - Content hashing and delivery proofs
  * Reference: Yellow Paper §11.4.1
- *
- * SECURITY FIX (MEDIUM-2): Now includes URL validation for SSRF prevention
  */
 export class ProofGenerator {
-  private readonly urlConfig: Required<URLValidationConfig>;
-
-  /**
-   * Create ProofGenerator with optional URL validation config
-   *
-   * @param urlConfig - URL validation configuration for hashFromUrl()
-   */
-  constructor(urlConfig?: URLValidationConfig) {
-    this.urlConfig = {
-      ...DEFAULT_URL_CONFIG,
-      ...urlConfig,
-    };
-
-    // If localhost is explicitly allowed, remove from blocked hosts
-    if (urlConfig?.allowLocalhost) {
-      this.urlConfig.blockedHosts = this.urlConfig.blockedHosts.filter(
-        (h) => !['localhost', '127.0.0.1', '0.0.0.0', '[::1]'].includes(h)
-      );
-    }
-  }
   /**
    * Hash deliverable content
    * Uses Keccak256 per Yellow Paper §11.4.1
@@ -176,163 +104,16 @@ export class ProofGenerator {
 
   /**
    * Generate content hash from URL (for IPFS/Arweave)
-   *
-   * SECURITY FIX (MEDIUM-2): Now includes:
-   * - Protocol validation (HTTPS only by default)
-   * - Hostname blocklist (prevents SSRF to internal services)
-   * - Size limits (prevents DoS via large responses)
-   * - Request timeout
-   *
-   * @param url - URL to fetch content from
-   * @returns Keccak256 hash of content
-   * @throws Error if URL is blocked, too large, or fetch fails
    */
   async hashFromUrl(url: string): Promise<string> {
-    // SECURITY FIX (MEDIUM-2): Validate URL before fetching
-    this.validateUrl(url);
-
     // In browser/Node.js environment with fetch
     try {
-      // Create AbortController for timeout
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), this.urlConfig.timeout);
-
-      try {
-        const response = await fetch(url, {
-          signal: controller.signal,
-          // Prevent following redirects to blocked hosts
-          redirect: 'follow',
-        });
-
-        clearTimeout(timeoutId);
-
-        if (!response.ok) {
-          throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
-        }
-
-        // SECURITY FIX (MEDIUM-2): Check Content-Length header first
-        const contentLength = response.headers.get('content-length');
-        if (contentLength) {
-          const size = parseInt(contentLength, 10);
-          if (size > this.urlConfig.maxSize) {
-            throw new Error(
-              `Content too large: ${size} bytes exceeds maximum of ${this.urlConfig.maxSize} bytes`
-            );
-          }
-        }
-
-        // SECURITY FIX (MEDIUM-2): Read response with size limit
-        const chunks: Uint8Array[] = [];
-        let totalSize = 0;
-        const reader = response.body?.getReader();
-
-        if (!reader) {
-          throw new Error('Response body is not readable');
-        }
-
-        while (true) {
-          const { done, value } = await reader.read();
-
-          if (done) break;
-
-          totalSize += value.length;
-
-          // Check size limit during streaming
-          if (totalSize > this.urlConfig.maxSize) {
-            reader.cancel();
-            throw new Error(
-              `Content too large: ${totalSize}+ bytes exceeds maximum of ${this.urlConfig.maxSize} bytes`
-            );
-          }
-
-          chunks.push(value);
-        }
-
-        // Concatenate chunks
-        const buffer = Buffer.concat(chunks.map(c => Buffer.from(c)));
-        return this.hashContent(buffer);
-      } finally {
-        clearTimeout(timeoutId);
-      }
+      const response = await fetch(url);
+      const arrayBuffer = await response.arrayBuffer();
+      const buffer = Buffer.from(arrayBuffer);
+      return this.hashContent(buffer);
     } catch (error) {
-      if (error instanceof Error && error.name === 'AbortError') {
-        throw new Error(`Request timed out after ${this.urlConfig.timeout}ms for ${url}`);
-      }
       throw new Error(`Failed to fetch content from ${url}: ${error}`);
     }
   }
-
-  /**
-   * SECURITY FIX (MEDIUM-2): Validate URL against security rules
-   *
-   * @param url - URL to validate
-   * @throws Error if URL is not allowed
-   */
-  private validateUrl(url: string): void {
-    let parsed: URL;
-
-    try {
-      parsed = new URL(url);
-    } catch {
-      throw new Error(`Invalid URL: ${url}`);
-    }
-
-    // Check protocol
-    if (!this.urlConfig.allowedProtocols.includes(parsed.protocol)) {
-      throw new Error(
-        `URL protocol "${parsed.protocol}" not allowed. ` +
-        `Allowed protocols: ${this.urlConfig.allowedProtocols.join(', ')}`
-      );
-    }
-
-    // Check blocked hosts
-    const hostname = parsed.hostname.toLowerCase();
-    if (this.urlConfig.blockedHosts.includes(hostname)) {
-      throw new Error(
-        `URL hostname "${hostname}" is blocked for security reasons. ` +
-        `This prevents SSRF attacks to internal services.`
-      );
-    }
-
-    // Check for private IP ranges (additional SSRF protection)
-    if (this.isPrivateIP(hostname)) {
-      throw new Error(
-        `URL hostname "${hostname}" resolves to a private IP address. ` +
-        `This is blocked for security reasons (SSRF prevention).`
-      );
-    }
-  }
-
-  /**
-   * Check if hostname is a private IP address
-   *
-   * @param hostname - Hostname to check
-   * @returns true if hostname is a private IP
-   */
-  private isPrivateIP(hostname: string): boolean {
-    // IPv4 private ranges
-    const ipv4PrivateRanges = [
-      /^10\./,          // 10.0.0.0 - 10.255.255.255
-      /^172\.(1[6-9]|2[0-9]|3[0-1])\./, // 172.16.0.0 - 172.31.255.255
-      /^192\.168\./,    // 192.168.0.0 - 192.168.255.255
-      /^127\./,         // 127.0.0.0 - 127.255.255.255 (loopback)
-      /^169\.254\./,    // 169.254.0.0 - 169.254.255.255 (link-local)
-      /^0\./,           // 0.0.0.0/8
-    ];
-
-    for (const range of ipv4PrivateRanges) {
-      if (range.test(hostname)) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  /**
-   * Get the URL validation config (for testing/inspection)
-   */
-  getUrlConfig(): Required<URLValidationConfig> {
-    return { ...this.urlConfig };
-  }
 }

package/src/types/escrow.ts

@@ -2,26 +2,25 @@
  * Escrow creation parameters
  */
 export interface CreateEscrowParams {
-  /** Escrow identifier (bytes32). In ACTP standard this is typically the txId. */
-  escrowId: string;
-  /** Consumer/requester who funds the escrow */
-  requester: string;
-  /** Provider who receives payout on settlement */
-  provider: string;
-  /** Amount locked in escrow (USDC wei, 6 decimals) */
+  kernelAddress: string;
+  txId: string;
+  token: string;
   amount: bigint;
+  beneficiary: string;
 }
 
 /**
- * Escrow state (matches on-chain EscrowVault.EscrowData struct)
+ * Escrow state
  */
 export interface Escrow {
   escrowId: string;
-  requester: string;
-  provider: string;
+  kernel: string;
+  txId: string;
+  token: string;
   amount: bigint;
-  releasedAmount: bigint;
-  active: boolean;
+  beneficiary: string;
+  createdAt: number;
+  released: boolean;
 }
 
 

package/src/types/index.ts

@@ -7,8 +7,4 @@ export * from './transaction';
 export * from './escrow';
 export * from './message';
 export * from './eip712';
-export * from './agent';
-export * from './did';
-// Note: storage and archive types are not yet implemented in this version
-// export * from './storage';
-// export * from './archive';
+

package/src/types/state.ts

@@ -17,23 +17,14 @@ export enum State {
 export class StateMachine {
   /**
    * Valid state transitions per Yellow Paper §3.2.2
-   *
-   * SECURITY FIX (CRITICAL-1): State machine must match ACTPKernel contract exactly
-   * Per CLAUDE.md §Architecture Overview - ACTP Protocol State Machine:
-   * - COMMITTED can transition to IN_PROGRESS, DELIVERED, or CANCELLED
-   * - IN_PROGRESS can transition to DELIVERED or CANCELLED (not DISPUTED)
-   * - DISPUTED can only transition to SETTLED (not CANCELLED)
    */
   private static readonly TRANSITIONS: Record<State, State[]> = {
     [State.INITIATED]: [State.QUOTED, State.COMMITTED, State.CANCELLED], // Allow direct INITIATED → COMMITTED (AIP-3)
     [State.QUOTED]: [State.COMMITTED, State.CANCELLED],
-    // SECURITY FIX (CRITICAL-1): Add DELIVERED (can skip IN_PROGRESS)
-    [State.COMMITTED]: [State.IN_PROGRESS, State.DELIVERED, State.CANCELLED],
-    // SECURITY FIX (CRITICAL-1): Remove DISPUTED, add CANCELLED
-    [State.IN_PROGRESS]: [State.DELIVERED, State.CANCELLED],
+    [State.COMMITTED]: [State.IN_PROGRESS, State.CANCELLED],
+    [State.IN_PROGRESS]: [State.DELIVERED, State.DISPUTED],
     [State.DELIVERED]: [State.SETTLED, State.DISPUTED],
-    // SECURITY FIX (CRITICAL-1): Remove CANCELLED (disputes resolve to SETTLED only)
-    [State.DISPUTED]: [State.SETTLED],
+    [State.DISPUTED]: [State.SETTLED, State.CANCELLED],
     [State.SETTLED]: [], // Terminal state
     [State.CANCELLED]: [] // Terminal state
   };

package/src/types/transaction.ts

@@ -11,15 +11,11 @@ export interface Transaction {
   amount: bigint;
   state: State;
   createdAt: number;
-  updatedAt: number;
   deadline: number;
   disputeWindow: number;
   escrowContract: string;
   escrowId: string;
-  serviceHash: string;
-  attestationUID: string;
   metadata: string;
-  platformFeeBpsLocked: number;
 }
 
 /**
@@ -55,3 +51,4 @@ export interface EconomicParams {
   providerPenaltyBps: number;
 }
 
+

package/src/utils/IPFSClient.ts

@@ -59,24 +59,6 @@ export interface IPFSClientConfig {
    * Default: 60000 (60 seconds)
    */
   timeout?: number;
-
-  /**
-   * SECURITY FIX (MEDIUM-3): Maximum content size in bytes
-   * Default: 50MB (50 * 1024 * 1024)
-   */
-  maxSize?: number;
-
-  /**
-   * SECURITY FIX (MEDIUM-3): Allowed URL protocols
-   * Default: ['http:', 'https:'] (http for localhost, https for remote)
-   */
-  allowedProtocols?: string[];
-
-  /**
-   * SECURITY FIX (MEDIUM-3): Allow localhost URLs
-   * Default: true (required for local IPFS daemon)
-   */
-  allowLocalhost?: boolean;
 }
 
 /**
@@ -99,45 +81,21 @@ export const IPFS_CONFIGS = {
 /**
  * IPFS HTTP Client Implementation
  * Uses ipfs-http-client library
- *
- * SECURITY FIX (MEDIUM-3): Now includes URL and size validation
  */
 export class IPFSHTTPClientImpl implements IPFSClient {
   private client: IPFSHTTPClient;
-  private config: Required<IPFSClientConfig>;
-
-  // SECURITY FIX (MEDIUM-3): Default security settings
-  private static readonly DEFAULT_MAX_SIZE = 50 * 1024 * 1024; // 50MB
-  private static readonly DEFAULT_ALLOWED_PROTOCOLS = ['http:', 'https:'];
-  private static readonly BLOCKED_HOSTS = [
-    'metadata.google.internal',
-    '169.254.169.254',
-    'metadata.aws.internal',
-  ];
+  private config: IPFSClientConfig;
 
   /**
    * Create IPFS client
-   *
-   * SECURITY FIX (MEDIUM-3): Validates URL and adds size limits
-   *
    * @param config - IPFS client configuration
-   * @throws Error if URL is invalid or blocked
    */
   constructor(config: IPFSClientConfig = {}) {
-    const url = config.url || 'http://localhost:5001';
-
-    // SECURITY FIX (MEDIUM-3): Validate URL
-    this.validateUrl(url, config.allowLocalhost ?? true, config.allowedProtocols);
-
     this.config = {
-      url,
+      url: config.url || 'http://localhost:5001',
       timeout: config.timeout || 60000,
-      maxSize: config.maxSize || IPFSHTTPClientImpl.DEFAULT_MAX_SIZE,
-      allowedProtocols: config.allowedProtocols || IPFSHTTPClientImpl.DEFAULT_ALLOWED_PROTOCOLS,
-      allowLocalhost: config.allowLocalhost ?? true,
-      auth: config.auth,
-      headers: config.headers,
-    } as Required<IPFSClientConfig>;
+      ...config
+    };
 
     const options: Options = {
       url: this.config.url,
@@ -159,76 +117,15 @@ export class IPFSHTTPClientImpl implements IPFSClient {
     this.client = create(options);
   }
 
-  /**
-   * SECURITY FIX (MEDIUM-3): Validate IPFS endpoint URL
-   */
-  private validateUrl(
-    url: string,
-    allowLocalhost: boolean,
-    allowedProtocols?: string[]
-  ): void {
-    let parsed: URL;
-
-    try {
-      parsed = new URL(url);
-    } catch {
-      throw new Error(`Invalid IPFS endpoint URL: ${url}`);
-    }
-
-    const protocols = allowedProtocols || IPFSHTTPClientImpl.DEFAULT_ALLOWED_PROTOCOLS;
-    if (!protocols.includes(parsed.protocol)) {
-      throw new Error(
-        `IPFS endpoint protocol "${parsed.protocol}" not allowed. ` +
-        `Allowed protocols: ${protocols.join(', ')}`
-      );
-    }
-
-    const hostname = parsed.hostname.toLowerCase();
-
-    // Check blocked hosts (cloud metadata endpoints)
-    if (IPFSHTTPClientImpl.BLOCKED_HOSTS.includes(hostname)) {
-      throw new Error(
-        `IPFS endpoint hostname "${hostname}" is blocked for security reasons.`
-      );
-    }
-
-    // Check localhost
-    const isLocalhost = ['localhost', '127.0.0.1', '0.0.0.0', '[::1]'].includes(hostname);
-    if (isLocalhost && !allowLocalhost) {
-      throw new Error(
-        `Localhost IPFS endpoints are disabled. Set allowLocalhost: true to enable.`
-      );
-    }
-
-    // For remote hosts, require HTTPS
-    if (!isLocalhost && parsed.protocol !== 'https:') {
-      console.warn(
-        `[SECURITY WARNING] Using non-HTTPS protocol "${parsed.protocol}" for remote IPFS endpoint "${hostname}". ` +
-        `This may expose data in transit. Consider using HTTPS.`
-      );
-    }
-  }
-
   /**
    * Upload data to IPFS
-   *
-   * SECURITY FIX (MEDIUM-3): Validates size before upload
-   *
    * @param data - JSON string or buffer
    * @returns CIDv1 string (base32)
-   * @throws Error if data exceeds maxSize
    */
   async add(data: string | Buffer): Promise<string> {
     try {
       const content = typeof data === 'string' ? Buffer.from(data, 'utf-8') : data;
 
-      // SECURITY FIX (MEDIUM-3): Check size before upload
-      if (content.length > this.config.maxSize) {
-        throw new Error(
-          `Content too large: ${content.length} bytes exceeds maximum of ${this.config.maxSize} bytes`
-        );
-      }
-
       const result = await this.client.add(content, {
         cidVersion: 1, // Use CIDv1 (base32)
         hashAlg: 'sha2-256',
@@ -256,33 +153,19 @@ export class IPFSHTTPClientImpl implements IPFSClient {
 
   /**
    * Retrieve content from IPFS
-   *
-   * SECURITY FIX (MEDIUM-3): Validates size during retrieval
-   *
    * @param cid - IPFS CID
    * @returns Content as string
-   * @throws Error if content exceeds maxSize
    */
   async get(cid: string): Promise<string> {
     try {
       const chunks: Uint8Array[] = [];
-      let totalLength = 0;
 
       for await (const chunk of this.client.cat(cid)) {
-        totalLength += chunk.length;
-
-        // SECURITY FIX (MEDIUM-3): Check size during streaming to prevent DoS
-        if (totalLength > this.config.maxSize) {
-          throw new Error(
-            `Content too large: ${totalLength}+ bytes exceeds maximum of ${this.config.maxSize} bytes. ` +
-            `Consider increasing maxSize in IPFSClientConfig if this is expected.`
-          );
-        }
-
         chunks.push(chunk);
       }
 
       // Concatenate all chunks
+      const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
       const result = new Uint8Array(totalLength);
       let offset = 0;