@epochcore/qaas-sdk 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,220 @@
+/**
+ * EpochCore QaaS SDK
+ * Official TypeScript/JavaScript SDK for Quantum as a Service API
+ *
+ * @packageDocumentation
+ */
+interface QaaSConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    timeout?: number;
+}
+interface Algorithm {
+    id: number;
+    name: string;
+    category: string;
+    description: string;
+}
+interface AlgorithmsResponse {
+    tier: string;
+    total_available: number;
+    algorithms: Algorithm[];
+    categories: string[];
+}
+interface PricingTier {
+    id: string;
+    name: string;
+    price: number;
+    runs_per_day: number;
+    runs_per_month: number;
+    algorithms: number;
+    backends: string[];
+    priority: string;
+    support: string;
+    payment_link: string;
+}
+interface PricingResponse {
+    tiers: PricingTier[];
+    currency: string;
+    billing: string;
+}
+interface RunRequest {
+    algorithm_id: string;
+    parameters: Record<string, unknown>;
+    backend?: 'simulator' | 'qiskit_aer' | 'cirq' | 'pennylane' | 'ibm_quantum';
+    shots?: number;
+}
+interface RunResponse {
+    job_id: string;
+    status: 'queued' | 'running' | 'completed' | 'failed';
+    algorithm: string;
+    result?: Record<string, unknown>;
+    execution_time_ms?: number;
+    backend_used: string;
+    shots_executed: number;
+    quantum_watermark: string;
+}
+interface UsageResponse {
+    tier: string;
+    period: string;
+    usage: {
+        runs_today: number;
+        runs_this_month: number;
+        remaining_today: number;
+        remaining_month: number;
+    };
+    limits: {
+        runs_per_day: number;
+        runs_per_month: number;
+    };
+}
+interface HealthResponse {
+    status: string;
+    service: string;
+    version: string;
+    algorithms_available: number;
+    frameworks: string[];
+    timestamp: string;
+}
+type AlgorithmCategory = 'amplitude_estimation' | 'grover_search' | 'qaoa_optimization' | 'qubo' | 'bernstein_vazirani' | 'deutsch_jozsa' | 'simon' | 'phase_estimation' | 'variational' | 'qml_classification' | 'qml_regression' | 'qml_clustering' | 'qml_anomaly';
+/**
+ * EpochCore QaaS Client
+ *
+ * @example
+ * ```typescript
+ * import { QaaSClient } from '@epochcore/qaas-sdk';
+ *
+ * const client = new QaaSClient({ apiKey: 'your-api-key' });
+ *
+ * // Get available algorithms
+ * const algorithms = await client.getAlgorithms();
+ *
+ * // Run a quantum algorithm
+ * const result = await client.runAlgorithm({
+ *   algorithm_id: 'QAOA_PORT_001',
+ *   parameters: {
+ *     assets: ['AAPL', 'GOOGL', 'MSFT'],
+ *     returns: [0.12, 0.15, 0.10],
+ *     covariance: [[0.04, 0.01, 0.02], [0.01, 0.05, 0.01], [0.02, 0.01, 0.03]],
+ *     risk_tolerance: 0.5
+ *   },
+ *   backend: 'qiskit_aer'
+ * });
+ * ```
+ */
+declare class QaaSClient {
+    private readonly baseUrl;
+    private readonly apiKey?;
+    private readonly timeout;
+    constructor(config?: QaaSConfig);
+    private request;
+    /**
+     * Check API health and status
+     */
+    health(): Promise<HealthResponse>;
+    /**
+     * Get pricing information for all tiers
+     */
+    getPricing(): Promise<PricingResponse>;
+    /**
+     * Get available algorithms for your tier
+     */
+    getAlgorithms(): Promise<AlgorithmsResponse>;
+    /**
+     * Get algorithms filtered by category
+     */
+    getAlgorithmsByCategory(category: AlgorithmCategory): Promise<Algorithm[]>;
+    /**
+     * Run a quantum algorithm
+     */
+    runAlgorithm(request: RunRequest): Promise<RunResponse>;
+    /**
+     * Get current usage statistics
+     */
+    getUsage(): Promise<UsageResponse>;
+    /**
+     * Run Markowitz portfolio optimization (QAOA)
+     */
+    optimizePortfolio(params: {
+        assets: string[];
+        returns: number[];
+        covariance: number[][];
+        risk_tolerance?: number;
+        backend?: RunRequest['backend'];
+    }): Promise<RunResponse>;
+    /**
+     * Run Value at Risk (VaR) estimation
+     */
+    estimateVaR(params: {
+        portfolio_value: number;
+        returns_history: number[];
+        confidence_level?: number;
+        backend?: RunRequest['backend'];
+    }): Promise<RunResponse>;
+    /**
+     * Run Grover search for arbitrage opportunities
+     */
+    findArbitrage(params: {
+        price_matrix: number[][];
+        threshold?: number;
+        backend?: RunRequest['backend'];
+    }): Promise<RunResponse>;
+    /**
+     * Solve a QUBO problem
+     */
+    solveQUBO(params: {
+        Q_matrix: number[][];
+        num_reads?: number;
+        backend?: RunRequest['backend'];
+    }): Promise<RunResponse>;
+    /**
+     * Run Monte Carlo amplitude estimation
+     */
+    monteCarloEstimate(params: {
+        target_function: string;
+        num_samples?: number;
+        epsilon?: number;
+        backend?: RunRequest['backend'];
+    }): Promise<RunResponse>;
+}
+/**
+ * QaaS API Error
+ */
+declare class QaaSError extends Error {
+    readonly statusCode: number;
+    readonly response?: unknown | undefined;
+    constructor(message: string, statusCode: number, response?: unknown | undefined);
+}
+declare const qaas: QaaSClient;
+declare const ALGORITHMS: {
+    readonly AMPLITUDE_ESTIMATION: {
+        readonly PROB_001: "AE_PROB_001";
+        readonly PROB_002: "AE_PROB_002";
+        readonly PROB_003: "AE_PROB_003";
+        readonly VAR: "AE_PROB_004";
+        readonly CVAR: "AE_PROB_005";
+    };
+    readonly GROVER: {
+        readonly BOOLEAN_SAT: "GROVER_BOOL_001";
+        readonly PORTFOLIO_CONSTRAINT: "GROVER_BOOL_002";
+        readonly ARBITRAGE: "GROVER_BOOL_003";
+        readonly COMPLIANCE: "GROVER_BOOL_004";
+        readonly PATTERN: "GROVER_BOOL_005";
+    };
+    readonly QAOA_PORTFOLIO: {
+        readonly MARKOWITZ: "QAOA_PORT_001";
+        readonly RISK_PARITY: "QAOA_PORT_002";
+        readonly MAX_SHARPE: "QAOA_PORT_003";
+        readonly MIN_VARIANCE: "QAOA_PORT_004";
+        readonly BLACK_LITTERMAN: "QAOA_PORT_005";
+    };
+    readonly QUBO: {
+        readonly GENERAL: "QAOA_QUBO_001";
+        readonly MAX_CUT: "QAOA_QUBO_002";
+        readonly GRAPH_COLORING: "QAOA_QUBO_003";
+        readonly TSP: "QAOA_QUBO_004";
+        readonly KNAPSACK: "QAOA_QUBO_005";
+    };
+};
+
+export { ALGORITHMS, type Algorithm, type AlgorithmCategory, type AlgorithmsResponse, type HealthResponse, type PricingResponse, type PricingTier, QaaSClient, type QaaSConfig, QaaSError, type RunRequest, type RunResponse, type UsageResponse, qaas };

package/dist/index.d.ts

@@ -0,0 +1,220 @@
+/**
+ * EpochCore QaaS SDK
+ * Official TypeScript/JavaScript SDK for Quantum as a Service API
+ *
+ * @packageDocumentation
+ */
+interface QaaSConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    timeout?: number;
+}
+interface Algorithm {
+    id: number;
+    name: string;
+    category: string;
+    description: string;
+}
+interface AlgorithmsResponse {
+    tier: string;
+    total_available: number;
+    algorithms: Algorithm[];
+    categories: string[];
+}
+interface PricingTier {
+    id: string;
+    name: string;
+    price: number;
+    runs_per_day: number;
+    runs_per_month: number;
+    algorithms: number;
+    backends: string[];
+    priority: string;
+    support: string;
+    payment_link: string;
+}
+interface PricingResponse {
+    tiers: PricingTier[];
+    currency: string;
+    billing: string;
+}
+interface RunRequest {
+    algorithm_id: string;
+    parameters: Record<string, unknown>;
+    backend?: 'simulator' | 'qiskit_aer' | 'cirq' | 'pennylane' | 'ibm_quantum';
+    shots?: number;
+}
+interface RunResponse {
+    job_id: string;
+    status: 'queued' | 'running' | 'completed' | 'failed';
+    algorithm: string;
+    result?: Record<string, unknown>;
+    execution_time_ms?: number;
+    backend_used: string;
+    shots_executed: number;
+    quantum_watermark: string;
+}
+interface UsageResponse {
+    tier: string;
+    period: string;
+    usage: {
+        runs_today: number;
+        runs_this_month: number;
+        remaining_today: number;
+        remaining_month: number;
+    };
+    limits: {
+        runs_per_day: number;
+        runs_per_month: number;
+    };
+}
+interface HealthResponse {
+    status: string;
+    service: string;
+    version: string;
+    algorithms_available: number;
+    frameworks: string[];
+    timestamp: string;
+}
+type AlgorithmCategory = 'amplitude_estimation' | 'grover_search' | 'qaoa_optimization' | 'qubo' | 'bernstein_vazirani' | 'deutsch_jozsa' | 'simon' | 'phase_estimation' | 'variational' | 'qml_classification' | 'qml_regression' | 'qml_clustering' | 'qml_anomaly';
+/**
+ * EpochCore QaaS Client
+ *
+ * @example
+ * ```typescript
+ * import { QaaSClient } from '@epochcore/qaas-sdk';
+ *
+ * const client = new QaaSClient({ apiKey: 'your-api-key' });
+ *
+ * // Get available algorithms
+ * const algorithms = await client.getAlgorithms();
+ *
+ * // Run a quantum algorithm
+ * const result = await client.runAlgorithm({
+ *   algorithm_id: 'QAOA_PORT_001',
+ *   parameters: {
+ *     assets: ['AAPL', 'GOOGL', 'MSFT'],
+ *     returns: [0.12, 0.15, 0.10],
+ *     covariance: [[0.04, 0.01, 0.02], [0.01, 0.05, 0.01], [0.02, 0.01, 0.03]],
+ *     risk_tolerance: 0.5
+ *   },
+ *   backend: 'qiskit_aer'
+ * });
+ * ```
+ */
+declare class QaaSClient {
+    private readonly baseUrl;
+    private readonly apiKey?;
+    private readonly timeout;
+    constructor(config?: QaaSConfig);
+    private request;
+    /**
+     * Check API health and status
+     */
+    health(): Promise<HealthResponse>;
+    /**
+     * Get pricing information for all tiers
+     */
+    getPricing(): Promise<PricingResponse>;
+    /**
+     * Get available algorithms for your tier
+     */
+    getAlgorithms(): Promise<AlgorithmsResponse>;
+    /**
+     * Get algorithms filtered by category
+     */
+    getAlgorithmsByCategory(category: AlgorithmCategory): Promise<Algorithm[]>;
+    /**
+     * Run a quantum algorithm
+     */
+    runAlgorithm(request: RunRequest): Promise<RunResponse>;
+    /**
+     * Get current usage statistics
+     */
+    getUsage(): Promise<UsageResponse>;
+    /**
+     * Run Markowitz portfolio optimization (QAOA)
+     */
+    optimizePortfolio(params: {
+        assets: string[];
+        returns: number[];
+        covariance: number[][];
+        risk_tolerance?: number;
+        backend?: RunRequest['backend'];
+    }): Promise<RunResponse>;
+    /**
+     * Run Value at Risk (VaR) estimation
+     */
+    estimateVaR(params: {
+        portfolio_value: number;
+        returns_history: number[];
+        confidence_level?: number;
+        backend?: RunRequest['backend'];
+    }): Promise<RunResponse>;
+    /**
+     * Run Grover search for arbitrage opportunities
+     */
+    findArbitrage(params: {
+        price_matrix: number[][];
+        threshold?: number;
+        backend?: RunRequest['backend'];
+    }): Promise<RunResponse>;
+    /**
+     * Solve a QUBO problem
+     */
+    solveQUBO(params: {
+        Q_matrix: number[][];
+        num_reads?: number;
+        backend?: RunRequest['backend'];
+    }): Promise<RunResponse>;
+    /**
+     * Run Monte Carlo amplitude estimation
+     */
+    monteCarloEstimate(params: {
+        target_function: string;
+        num_samples?: number;
+        epsilon?: number;
+        backend?: RunRequest['backend'];
+    }): Promise<RunResponse>;
+}
+/**
+ * QaaS API Error
+ */
+declare class QaaSError extends Error {
+    readonly statusCode: number;
+    readonly response?: unknown | undefined;
+    constructor(message: string, statusCode: number, response?: unknown | undefined);
+}
+declare const qaas: QaaSClient;
+declare const ALGORITHMS: {
+    readonly AMPLITUDE_ESTIMATION: {
+        readonly PROB_001: "AE_PROB_001";
+        readonly PROB_002: "AE_PROB_002";
+        readonly PROB_003: "AE_PROB_003";
+        readonly VAR: "AE_PROB_004";
+        readonly CVAR: "AE_PROB_005";
+    };
+    readonly GROVER: {
+        readonly BOOLEAN_SAT: "GROVER_BOOL_001";
+        readonly PORTFOLIO_CONSTRAINT: "GROVER_BOOL_002";
+        readonly ARBITRAGE: "GROVER_BOOL_003";
+        readonly COMPLIANCE: "GROVER_BOOL_004";
+        readonly PATTERN: "GROVER_BOOL_005";
+    };
+    readonly QAOA_PORTFOLIO: {
+        readonly MARKOWITZ: "QAOA_PORT_001";
+        readonly RISK_PARITY: "QAOA_PORT_002";
+        readonly MAX_SHARPE: "QAOA_PORT_003";
+        readonly MIN_VARIANCE: "QAOA_PORT_004";
+        readonly BLACK_LITTERMAN: "QAOA_PORT_005";
+    };
+    readonly QUBO: {
+        readonly GENERAL: "QAOA_QUBO_001";
+        readonly MAX_CUT: "QAOA_QUBO_002";
+        readonly GRAPH_COLORING: "QAOA_QUBO_003";
+        readonly TSP: "QAOA_QUBO_004";
+        readonly KNAPSACK: "QAOA_QUBO_005";
+    };
+};
+
+export { ALGORITHMS, type Algorithm, type AlgorithmCategory, type AlgorithmsResponse, type HealthResponse, type PricingResponse, type PricingTier, QaaSClient, type QaaSConfig, QaaSError, type RunRequest, type RunResponse, type UsageResponse, qaas };

package/dist/index.js

@@ -0,0 +1,226 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ALGORITHMS: () => ALGORITHMS,
+  QaaSClient: () => QaaSClient,
+  QaaSError: () => QaaSError,
+  qaas: () => qaas
+});
+module.exports = __toCommonJS(index_exports);
+var QaaSClient = class {
+  constructor(config = {}) {
+    this.baseUrl = config.baseUrl || "https://api.qaas.epochcoreqcs.com";
+    this.apiKey = config.apiKey;
+    this.timeout = config.timeout || 3e4;
+  }
+  async request(path, options = {}) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers || {}
+    };
+    if (this.apiKey) {
+      headers["X-API-Key"] = this.apiKey;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}${path}`, {
+        ...options,
+        headers,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: "Unknown error" }));
+        throw new QaaSError(
+          error.error || `Request failed with status ${response.status}`,
+          response.status,
+          error
+        );
+      }
+      return await response.json();
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Check API health and status
+   */
+  async health() {
+    return this.request("/health");
+  }
+  /**
+   * Get pricing information for all tiers
+   */
+  async getPricing() {
+    return this.request("/api/pricing");
+  }
+  /**
+   * Get available algorithms for your tier
+   */
+  async getAlgorithms() {
+    return this.request("/api/quantum/algorithms");
+  }
+  /**
+   * Get algorithms filtered by category
+   */
+  async getAlgorithmsByCategory(category) {
+    const response = await this.getAlgorithms();
+    return response.algorithms.filter((algo) => algo.category === category);
+  }
+  /**
+   * Run a quantum algorithm
+   */
+  async runAlgorithm(request) {
+    return this.request("/api/quantum/run", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * Get current usage statistics
+   */
+  async getUsage() {
+    return this.request("/api/quantum/usage");
+  }
+  // ==========================================
+  // Convenience methods for common algorithms
+  // ==========================================
+  /**
+   * Run Markowitz portfolio optimization (QAOA)
+   */
+  async optimizePortfolio(params) {
+    return this.runAlgorithm({
+      algorithm_id: "QAOA_PORT_001",
+      parameters: {
+        assets: params.assets,
+        returns: params.returns,
+        covariance: params.covariance,
+        risk_tolerance: params.risk_tolerance ?? 0.5
+      },
+      backend: params.backend || "simulator"
+    });
+  }
+  /**
+   * Run Value at Risk (VaR) estimation
+   */
+  async estimateVaR(params) {
+    return this.runAlgorithm({
+      algorithm_id: "AE_PROB_004",
+      parameters: {
+        portfolio_value: params.portfolio_value,
+        returns_history: params.returns_history,
+        confidence_level: params.confidence_level ?? 0.95
+      },
+      backend: params.backend || "simulator"
+    });
+  }
+  /**
+   * Run Grover search for arbitrage opportunities
+   */
+  async findArbitrage(params) {
+    return this.runAlgorithm({
+      algorithm_id: "GROVER_BOOL_003",
+      parameters: {
+        price_matrix: params.price_matrix,
+        threshold: params.threshold ?? 1e-3
+      },
+      backend: params.backend || "simulator"
+    });
+  }
+  /**
+   * Solve a QUBO problem
+   */
+  async solveQUBO(params) {
+    return this.runAlgorithm({
+      algorithm_id: "QAOA_QUBO_001",
+      parameters: {
+        Q: params.Q_matrix,
+        num_reads: params.num_reads ?? 1e3
+      },
+      backend: params.backend || "simulator"
+    });
+  }
+  /**
+   * Run Monte Carlo amplitude estimation
+   */
+  async monteCarloEstimate(params) {
+    return this.runAlgorithm({
+      algorithm_id: "AE_PROB_002",
+      parameters: {
+        target_function: params.target_function,
+        num_samples: params.num_samples ?? 1e4,
+        epsilon: params.epsilon ?? 0.01
+      },
+      backend: params.backend || "simulator"
+    });
+  }
+};
+var QaaSError = class extends Error {
+  constructor(message, statusCode, response) {
+    super(message);
+    this.statusCode = statusCode;
+    this.response = response;
+    this.name = "QaaSError";
+  }
+};
+var qaas = new QaaSClient();
+var ALGORITHMS = {
+  // Amplitude Estimation
+  AMPLITUDE_ESTIMATION: {
+    PROB_001: "AE_PROB_001",
+    PROB_002: "AE_PROB_002",
+    PROB_003: "AE_PROB_003",
+    VAR: "AE_PROB_004",
+    CVAR: "AE_PROB_005"
+  },
+  // Grover Search
+  GROVER: {
+    BOOLEAN_SAT: "GROVER_BOOL_001",
+    PORTFOLIO_CONSTRAINT: "GROVER_BOOL_002",
+    ARBITRAGE: "GROVER_BOOL_003",
+    COMPLIANCE: "GROVER_BOOL_004",
+    PATTERN: "GROVER_BOOL_005"
+  },
+  // QAOA Portfolio
+  QAOA_PORTFOLIO: {
+    MARKOWITZ: "QAOA_PORT_001",
+    RISK_PARITY: "QAOA_PORT_002",
+    MAX_SHARPE: "QAOA_PORT_003",
+    MIN_VARIANCE: "QAOA_PORT_004",
+    BLACK_LITTERMAN: "QAOA_PORT_005"
+  },
+  // QUBO
+  QUBO: {
+    GENERAL: "QAOA_QUBO_001",
+    MAX_CUT: "QAOA_QUBO_002",
+    GRAPH_COLORING: "QAOA_QUBO_003",
+    TSP: "QAOA_QUBO_004",
+    KNAPSACK: "QAOA_QUBO_005"
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALGORITHMS,
+  QaaSClient,
+  QaaSError,
+  qaas
+});