@bloqzapi/api-ts 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export type BloqzClientOptions = {
+    baseUrl?: string;
+    apiKey?: string;
+    timeoutMs?: number;
+    maxRetries?: number;
+    retryDelayMs?: number;
+};
+export declare class BloqzClient {
+    private baseUrl;
+    private apiKey?;
+    private timeoutMs;
+    private maxRetries;
+    private retryDelayMs;
+    constructor(options?: BloqzClientOptions);
+    private request;
+    private isRetryableError;
+    private sleep;
+    parseIntent<T = unknown>(payload: unknown): Promise<T>;
+    buildPlan<T = unknown>(payload: unknown): Promise<T>;
+    simulatePlan<T = unknown>(payload: unknown): Promise<T>;
+    validatePlan<T = unknown>(payload: unknown): Promise<T>;
+    verifyPlan<T = unknown>(payload: unknown): Promise<T>;
+}

package/dist/index.js

@@ -0,0 +1,77 @@
+export class BloqzClient {
+    baseUrl;
+    apiKey;
+    timeoutMs;
+    maxRetries;
+    retryDelayMs;
+    constructor(options = {}) {
+        this.baseUrl = options.baseUrl || 'http://localhost:4000';
+        this.apiKey = options.apiKey;
+        this.timeoutMs = options.timeoutMs || 30000;
+        this.maxRetries = options.maxRetries || 2;
+        this.retryDelayMs = options.retryDelayMs || 300;
+    }
+    async request(path, payload) {
+        const headers = { 'Content-Type': 'application/json' };
+        if (this.apiKey) {
+            headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+        let attempt = 0;
+        while (true) {
+            attempt += 1;
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+            try {
+                const response = await fetch(`${this.baseUrl}${path}`, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify(payload),
+                    signal: controller.signal
+                });
+                if (!response.ok) {
+                    const errorBody = await response.json().catch(() => ({}));
+                    const message = errorBody.error || `Request failed (${response.status})`;
+                    if (attempt <= this.maxRetries && response.status >= 500) {
+                        await this.sleep(this.retryDelayMs * attempt);
+                        continue;
+                    }
+                    const error = new Error(message);
+                    error.details = errorBody.details;
+                    throw error;
+                }
+                return response.json();
+            }
+            catch (error) {
+                if (attempt <= this.maxRetries && this.isRetryableError(error)) {
+                    await this.sleep(this.retryDelayMs * attempt);
+                    continue;
+                }
+                throw error;
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+        }
+    }
+    isRetryableError(error) {
+        return Boolean(error && error.name === 'AbortError');
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    parseIntent(payload) {
+        return this.request('/v1/intents/parse', payload);
+    }
+    buildPlan(payload) {
+        return this.request('/v1/plans/build', payload);
+    }
+    simulatePlan(payload) {
+        return this.request('/v1/plans/simulate', payload);
+    }
+    validatePlan(payload) {
+        return this.request('/v1/plans/validate', payload);
+    }
+    verifyPlan(payload) {
+        return this.request('/v1/plans/verify', payload);
+    }
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@bloqzapi/api-ts",
+  "version": "1.0.0",
+  "description": "Bloqz Intent API SDK (TypeScript)",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "files": [
+    "dist",
+    "src/openapi.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "generate:types": "node scripts/generate-types.mjs"
+  },
+  "devDependencies": {
+    "openapi-typescript": "^7.5.0",
+    "typescript": "^5.4.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "UNLICENSED"
+}

package/src/openapi.d.ts

@@ -0,0 +1,361 @@
+export interface paths {
+    "/v1/intents/parse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Parse intent */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        text?: string;
+                        intent?: components["schemas"]["IntentSchemaV1"];
+                        context?: {
+                            [key: string]: unknown;
+                        };
+                    };
+                };
+            };
+            responses: {
+                /** @description Parsed intent */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": Record<string, never>;
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/plans/build": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Build execution plan */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        text?: string;
+                        intent?: components["schemas"]["IntentSchemaV1"];
+                        context?: {
+                            [key: string]: unknown;
+                        };
+                    };
+                };
+            };
+            responses: {
+                /** @description Execution plan */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ExecutionPlanSchemaV1"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/plans/simulate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Simulate plan */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        text?: string;
+                        intent?: components["schemas"]["IntentSchemaV1"];
+                        context?: {
+                            [key: string]: unknown;
+                        };
+                    };
+                };
+            };
+            responses: {
+                /** @description Simulation result */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": Record<string, never>;
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/plans/validate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Validate plan schema */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["ExecutionPlanSchemaV1"];
+                };
+            };
+            responses: {
+                /** @description Validation result */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": Record<string, never>;
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/plans/verify": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Verify plan hash proof */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["ExecutionPlanSchemaV1"];
+                };
+            };
+            responses: {
+                /** @description Verification result */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": Record<string, never>;
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/schemas": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get JSON schemas */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Schemas */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": Record<string, never>;
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        IntentSchemaV1: {
+            /** @enum {string} */
+            action: "stake" | "swap" | "transfer" | "bridge";
+            asset?: string;
+            amount?: string;
+            /** @enum {string} */
+            chain?: "ethereum" | "polygon" | "arbitrum" | "optimism" | "base" | "solana" | "bsc";
+            protocol?: string;
+            from_asset?: string;
+            to_asset?: string;
+            recipient?: string;
+            /** @enum {string} */
+            destination_chain?: "ethereum" | "polygon" | "arbitrum" | "optimism" | "base" | "solana" | "bsc";
+            constraints?: {
+                max_slippage?: string;
+                custody?: string;
+            } & {
+                [key: string]: unknown;
+            };
+            schedule?: {
+                cadence?: string;
+                duration?: string;
+            } & {
+                [key: string]: unknown;
+            };
+            targets?: {
+                asset: string;
+                allocation: number;
+            }[];
+        };
+        ExecutionPlanSchemaV1: {
+            /** @enum {string} */
+            version: "v1";
+            intent: {
+                /** @enum {string} */
+                action: "stake" | "swap" | "transfer" | "bridge";
+                asset?: string;
+                amount?: string;
+                /** @enum {string} */
+                chain?: "ethereum" | "polygon" | "arbitrum" | "optimism" | "base" | "solana" | "bsc";
+                protocol?: string;
+                from_asset?: string;
+                to_asset?: string;
+                recipient?: string;
+                /** @enum {string} */
+                destination_chain?: "ethereum" | "polygon" | "arbitrum" | "optimism" | "base" | "solana" | "bsc";
+                constraints?: {
+                    max_slippage?: string;
+                    custody?: string;
+                } & {
+                    [key: string]: unknown;
+                };
+                schedule?: {
+                    cadence?: string;
+                    duration?: string;
+                } & {
+                    [key: string]: unknown;
+                };
+                targets?: {
+                    asset: string;
+                    allocation: number;
+                }[];
+            };
+            plan: {
+                type: string;
+                steps: {
+                    id: string;
+                    type: string;
+                    params: {
+                        [key: string]: unknown;
+                    };
+                }[];
+                summary: string;
+            };
+            assumptions: string[];
+            constraints?: {
+                max_slippage?: string;
+                custody?: string;
+            } & {
+                [key: string]: unknown;
+            };
+            audit: {
+                hash: string;
+                deterministic: boolean;
+                /** @enum {string} */
+                hash_version: "sha256-v1";
+                proof: {
+                    hash: string;
+                    signer?: string;
+                    timestamp: string;
+                };
+            };
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export type operations = Record<string, never>;