@varity-labs/sdk 2.0.0-alpha.1

package/dist/modules/webhooks/WebhooksModule.js

@@ -0,0 +1,359 @@
+/**
+ * Webhooks Module
+ *
+ * Universal webhook management for event-driven integrations
+ * Works across ALL templates (ISO, Healthcare, Finance, Retail)
+ *
+ * @example
+ * ```typescript
+ * // Register a webhook
+ * const webhook = await sdk.webhooks.register({
+ *   url: 'https://api.example.com/webhooks',
+ *   events: ['transaction.created', 'user.updated'],
+ *   secret: 'your-secret-key'
+ * })
+ *
+ * // Test webhook delivery
+ * await sdk.webhooks.test(webhook.id, { test_event: 'data' })
+ *
+ * // Get delivery logs
+ * const logs = await sdk.webhooks.getLogs({ webhook_id: webhook.id })
+ * ```
+ */
+// ============================================================================
+// WEBHOOKS MODULE CLASS
+// ============================================================================
+/**
+ * Webhooks Module
+ *
+ * Provides webhook management and event delivery for integrations
+ * Works universally across all templates with template-specific events
+ */
+export class WebhooksModule {
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    /**
+     * Register a new webhook
+     *
+     * @param options - Webhook registration options
+     * @returns Registered webhook configuration
+     *
+     * @example
+     * ```typescript
+     * const webhook = await sdk.webhooks.register({
+     *   url: 'https://api.example.com/webhooks',
+     *   events: ['transaction.created', 'user.updated'],
+     *   secret: 'your-secret-key',
+     *   retry: {
+     *     max_attempts: 5,
+     *     strategy: 'exponential'
+     *   }
+     * })
+     * ```
+     */
+    async register(options) {
+        const response = await fetch(`${this.sdk.getAPIEndpoint()}/api/v1/webhooks`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(this.sdk.getAPIKey() && { 'X-API-Key': this.sdk.getAPIKey() })
+            },
+            body: JSON.stringify(options)
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to register webhook: ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Get webhook by ID
+     *
+     * @param webhookId - Webhook ID
+     * @returns Webhook configuration
+     */
+    async get(webhookId) {
+        const response = await fetch(`${this.sdk.getAPIEndpoint()}/api/v1/webhooks/${webhookId}`, {
+            headers: {
+                ...(this.sdk.getAPIKey() && { 'X-API-Key': this.sdk.getAPIKey() })
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to get webhook: ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * List all webhooks
+     *
+     * @param options - List options
+     * @returns List of webhooks
+     */
+    async list(options) {
+        const params = new URLSearchParams();
+        if (options) {
+            Object.entries(options).forEach(([key, value]) => {
+                if (value !== undefined)
+                    params.append(key, String(value));
+            });
+        }
+        const response = await fetch(`${this.sdk.getAPIEndpoint()}/api/v1/webhooks?${params.toString()}`, {
+            headers: {
+                ...(this.sdk.getAPIKey() && { 'X-API-Key': this.sdk.getAPIKey() })
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to list webhooks: ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Update webhook configuration
+     *
+     * @param webhookId - Webhook ID
+     * @param options - Update options
+     * @returns Updated webhook configuration
+     */
+    async update(webhookId, options) {
+        const response = await fetch(`${this.sdk.getAPIEndpoint()}/api/v1/webhooks/${webhookId}`, {
+            method: 'PATCH',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(this.sdk.getAPIKey() && { 'X-API-Key': this.sdk.getAPIKey() })
+            },
+            body: JSON.stringify(options)
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to update webhook: ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Delete a webhook
+     *
+     * @param webhookId - Webhook ID to delete
+     * @returns Success status
+     */
+    async delete(webhookId) {
+        const response = await fetch(`${this.sdk.getAPIEndpoint()}/api/v1/webhooks/${webhookId}`, {
+            method: 'DELETE',
+            headers: {
+                ...(this.sdk.getAPIKey() && { 'X-API-Key': this.sdk.getAPIKey() })
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to delete webhook: ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Test webhook delivery
+     *
+     * @param webhookId - Webhook ID to test
+     * @param options - Test options
+     * @returns Test delivery result
+     *
+     * @example
+     * ```typescript
+     * const result = await sdk.webhooks.test('webhook-123', {
+     *   event: 'test.event',
+     *   payload: { test: true }
+     * })
+     * ```
+     */
+    async test(webhookId, options) {
+        const response = await fetch(`${this.sdk.getAPIEndpoint()}/api/v1/webhooks/${webhookId}/test`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(this.sdk.getAPIKey() && { 'X-API-Key': this.sdk.getAPIKey() })
+            },
+            body: JSON.stringify(options || {})
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to test webhook: ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Pause webhook delivery
+     *
+     * @param webhookId - Webhook ID to pause
+     * @returns Updated webhook configuration
+     */
+    async pause(webhookId) {
+        return await this.update(webhookId, { enabled: false });
+    }
+    /**
+     * Resume webhook delivery
+     *
+     * @param webhookId - Webhook ID to resume
+     * @returns Updated webhook configuration
+     */
+    async resume(webhookId) {
+        return await this.update(webhookId, { enabled: true });
+    }
+    /**
+     * Get webhook delivery logs
+     *
+     * @param options - Log query options
+     * @returns Delivery logs
+     *
+     * @example
+     * ```typescript
+     * const logs = await sdk.webhooks.getLogs({
+     *   webhook_id: 'webhook-123',
+     *   status: 'failed',
+     *   limit: 50
+     * })
+     * ```
+     */
+    async getLogs(options) {
+        const params = new URLSearchParams();
+        if (options) {
+            Object.entries(options).forEach(([key, value]) => {
+                if (value !== undefined)
+                    params.append(key, String(value));
+            });
+        }
+        const response = await fetch(`${this.sdk.getAPIEndpoint()}/api/v1/webhooks/logs?${params.toString()}`, {
+            headers: {
+                ...(this.sdk.getAPIKey() && { 'X-API-Key': this.sdk.getAPIKey() })
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to get webhook logs: ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Get delivery log by ID
+     *
+     * @param logId - Log entry ID
+     * @returns Delivery log details
+     */
+    async getLog(logId) {
+        const response = await fetch(`${this.sdk.getAPIEndpoint()}/api/v1/webhooks/logs/${logId}`, {
+            headers: {
+                ...(this.sdk.getAPIKey() && { 'X-API-Key': this.sdk.getAPIKey() })
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to get delivery log: ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Retry failed webhook delivery
+     *
+     * @param logId - Log entry ID to retry
+     * @returns Updated delivery log
+     */
+    async retry(logId) {
+        const response = await fetch(`${this.sdk.getAPIEndpoint()}/api/v1/webhooks/logs/${logId}/retry`, {
+            method: 'POST',
+            headers: {
+                ...(this.sdk.getAPIKey() && { 'X-API-Key': this.sdk.getAPIKey() })
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to retry webhook delivery: ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Manually deliver an event to webhooks
+     *
+     * @param options - Event delivery options
+     * @returns Delivery result
+     *
+     * @example
+     * ```typescript
+     * await sdk.webhooks.deliverEvent({
+     *   event: 'custom.event',
+     *   payload: { data: 'important data' },
+     *   webhook_ids: ['webhook-123'] // Optional: target specific webhooks
+     * })
+     * ```
+     */
+    async deliverEvent(options) {
+        const response = await fetch(`${this.sdk.getAPIEndpoint()}/api/v1/webhooks/deliver`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(this.sdk.getAPIKey() && { 'X-API-Key': this.sdk.getAPIKey() })
+            },
+            body: JSON.stringify(options)
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to deliver event: ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Get available webhook events
+     *
+     * @returns List of available events
+     */
+    async getAvailableEvents() {
+        const response = await fetch(`${this.sdk.getAPIEndpoint()}/api/v1/webhooks/events`, {
+            headers: {
+                ...(this.sdk.getAPIKey() && { 'X-API-Key': this.sdk.getAPIKey() })
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to get available events: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return data.events;
+    }
+    /**
+     * Get webhook statistics
+     *
+     * @returns Webhook statistics
+     */
+    async getStats() {
+        const response = await fetch(`${this.sdk.getAPIEndpoint()}/api/v1/webhooks/stats`, {
+            headers: {
+                ...(this.sdk.getAPIKey() && { 'X-API-Key': this.sdk.getAPIKey() })
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to get webhook stats: ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Verify webhook signature
+     *
+     * @param payload - Webhook payload (raw string)
+     * @param signature - Signature header value
+     * @param secret - Webhook secret key
+     * @returns True if signature is valid
+     *
+     * @example
+     * ```typescript
+     * // In your webhook handler
+     * const isValid = await sdk.webhooks.verifySignature(
+     *   JSON.stringify(req.body),
+     *   req.headers['x-webhook-signature'],
+     *   'your-secret-key'
+     * )
+     * ```
+     */
+    async verifySignature(payload, signature, secret) {
+        const response = await fetch(`${this.sdk.getAPIEndpoint()}/api/v1/webhooks/verify`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(this.sdk.getAPIKey() && { 'X-API-Key': this.sdk.getAPIKey() })
+            },
+            body: JSON.stringify({ payload, signature, secret })
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to verify signature: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return data.valid;
+    }
+}

package/dist/modules/webhooks/index.d.ts

@@ -0,0 +1,3 @@
+export { WebhooksModule } from './WebhooksModule';
+export type { WebhookStatus, DeliveryStatus, HttpMethod, RetryStrategy, RegisterWebhookOptions, UpdateWebhookOptions, ListWebhooksOptions, TestWebhookOptions, GetLogsOptions, DeliverEventOptions, Webhook, DeliveryLog, AvailableEvent, WebhookStats, TestDeliveryResult } from './WebhooksModule';
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/webhooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/modules/webhooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACjD,YAAY,EACV,aAAa,EACb,cAAc,EACd,UAAU,EACV,aAAa,EACb,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,kBAAkB,EAClB,cAAc,EACd,mBAAmB,EACnB,OAAO,EACP,WAAW,EACX,cAAc,EACd,YAAY,EACZ,kBAAkB,EACnB,MAAM,kBAAkB,CAAA"}

package/dist/modules/webhooks/index.js

@@ -0,0 +1 @@
+export { WebhooksModule } from './WebhooksModule';

package/dist/modules/zk/ZKModule.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Varity SDK - ZK Module
+ *
+ * Universal zero-knowledge proof generation and verification.
+ * Works across all templates (ISO, Healthcare, Retail, etc.)
+ */
+import type { VaritySDK } from '../../core/VaritySDK';
+import type { ZKProof, ZKMLProof, ZKMLProofInput, ZKMLVerificationResult, ZKMLProofStats } from '../../core/types';
+export interface ProofInputs {
+    public: any[];
+    private: any[];
+}
+export interface VerificationResult {
+    valid: boolean;
+    transactionHash?: string;
+    gasUsed?: bigint;
+}
+/**
+ * ZKModule - Universal zero-knowledge proof operations
+ *
+ * @example
+ * ```typescript
+ * // Generate proof
+ * const proof = await sdk.zk.generateProof('login-circuit', {
+ *   public: [address],
+ *   private: [password]
+ * })
+ *
+ * // Verify proof on-chain
+ * const result = await sdk.zk.verifyProofOnChain(proof, [address])
+ * ```
+ */
+export declare class ZKModule {
+    private sdk;
+    constructor(sdk: VaritySDK);
+    /**
+     * Generate zero-knowledge proof
+     *
+     * @param circuitId - Circuit identifier
+     * @param inputs - Proof inputs
+     * @returns ZK proof
+     */
+    generateProof(circuitId: string, inputs: ProofInputs): Promise<ZKProof>;
+    /**
+     * Generate login proof (simplified)
+     *
+     * @param credentials - Login credentials
+     * @returns ZK proof
+     */
+    generateLoginProof(credentials: any): Promise<ZKProof>;
+    /**
+     * Generate data ownership proof
+     *
+     * @param dataCID - Data CID
+     * @returns ZK proof
+     */
+    generateDataOwnershipProof(dataCID: string): Promise<ZKProof>;
+    /**
+     * Verify proof on-chain
+     *
+     * @param proof - ZK proof
+     * @param publicInputs - Public inputs
+     * @returns Verification result
+     */
+    verifyProofOnChain(proof: ZKProof, publicInputs: any[]): Promise<VerificationResult>;
+    /**
+     * Verify proof off-chain (local verification)
+     *
+     * @param proof - ZK proof
+     * @param publicInputs - Public inputs
+     * @returns True if valid
+     */
+    verifyProofOffChain(proof: ZKProof, publicInputs: any[]): Promise<boolean>;
+    /**
+     * Prove ML inference with ZKML
+     *
+     * Generates a zero-knowledge proof that an ML inference was performed correctly
+     * without revealing the model weights or full input/output data.
+     *
+     * @param modelId - Model identifier
+     * @param input - Input data to the model
+     * @param output - Output from the model
+     * @param options - Additional proof generation options
+     * @returns ZKML proof with verification data
+     *
+     * @example
+     * ```typescript
+     * const proof = await sdk.zk.proveMLInference(
+     *   'merchant-risk-model',
+     *   { merchantData: {...} },
+     *   { riskScore: 0.85 },
+     *   { submitOnChain: true }
+     * )
+     * console.log('Proof ID:', proof.proofId)
+     * console.log('Verified:', proof.verified)
+     * ```
+     */
+    proveMLInference(modelId: string, input: any, output: any, options?: Partial<ZKMLProofInput>): Promise<ZKMLProof>;
+    /**
+     * Verify ZKML proof
+     *
+     * Verifies a ZKML proof either on-chain or off-chain.
+     *
+     * @param proof - ZKML proof to verify
+     * @param onChain - Whether to verify on-chain (default: false)
+     * @returns Verification result
+     *
+     * @example
+     * ```typescript
+     * // Off-chain verification (faster, no gas)
+     * const result = await sdk.zk.verifyMLProof(proof)
+     * console.log('Valid:', result.valid)
+     *
+     * // On-chain verification (slower, requires gas)
+     * const result = await sdk.zk.verifyMLProof(proof, true)
+     * console.log('Transaction:', result.txHash)
+     * ```
+     */
+    verifyMLProof(proof: ZKMLProof, onChain?: boolean): Promise<ZKMLVerificationResult>;
+    /**
+     * Get ZKML proof statistics
+     *
+     * Returns statistics about ZKML proof generation and verification.
+     *
+     * @returns Proof statistics
+     *
+     * @example
+     * ```typescript
+     * const stats = await sdk.zk.getProofStats()
+     * console.log('Total proofs:', stats.totalProofsGenerated)
+     * console.log('Success rate:', stats.successRate)
+     * console.log('Avg generation time:', stats.avgGenerationTimeMs, 'ms')
+     * ```
+     */
+    getProofStats(): Promise<ZKMLProofStats>;
+    /**
+     * List available ZKML circuits
+     *
+     * Returns a list of compiled ZKML circuits available for proof generation.
+     *
+     * @returns Array of circuit configurations
+     *
+     * @example
+     * ```typescript
+     * const circuits = await sdk.zk.listCircuits()
+     * circuits.forEach(circuit => {
+     *   console.log(`${circuit.circuitId}: ${circuit.provingSystem}`)
+     * })
+     * ```
+     */
+    listCircuits(): Promise<any[]>;
+}
+//# sourceMappingURL=ZKModule.d.ts.map

package/dist/modules/zk/ZKModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ZKModule.d.ts","sourceRoot":"","sources":["../../../src/modules/zk/ZKModule.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AACrD,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,cAAc,EACd,sBAAsB,EACtB,cAAc,EACf,MAAM,kBAAkB,CAAA;AAEzB,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,GAAG,EAAE,CAAA;IACb,OAAO,EAAE,GAAG,EAAE,CAAA;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,OAAO,CAAA;IACd,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,GAAG,CAAW;gBAEV,GAAG,EAAE,SAAS;IAI1B;;;;;;OAMG;IACG,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAoB7E;;;;;OAKG;IACG,kBAAkB,CAAC,WAAW,EAAE,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC;IAQ5D;;;;;OAKG;IACG,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAQnE;;;;;;OAMG;IACG,kBAAkB,CACtB,KAAK,EAAE,OAAO,EACd,YAAY,EAAE,GAAG,EAAE,GAClB,OAAO,CAAC,kBAAkB,CAAC;IAe9B;;;;;;OAMG;IACG,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAqBhF;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,gBAAgB,CACpB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,GAAG,EACV,MAAM,EAAE,GAAG,EACX,OAAO,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,GAChC,OAAO,CAAC,SAAS,CAAC;IA8BrB;;;;;;;;;;;;;;;;;;;OAmBG;IACG,aAAa,CACjB,KAAK,EAAE,SAAS,EAChB,OAAO,GAAE,OAAe,GACvB,OAAO,CAAC,sBAAsB,CAAC;IAqBlC;;;;;;;;;;;;;;OAcG;IACG,aAAa,IAAI,OAAO,CAAC,cAAc,CAAC;IAmB9C;;;;;;;;;;;;;;OAcG;IACG,YAAY,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;CAkBrC"}