@sip-protocol/api 0.1.0

package/dist/server.js

@@ -0,0 +1,483 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  default: () => server_default
+});
+module.exports = __toCommonJS(server_exports);
+var import_express7 = __toESM(require("express"));
+var import_cors = __toESM(require("cors"));
+var import_helmet = __toESM(require("helmet"));
+var import_compression = __toESM(require("compression"));
+var import_morgan = __toESM(require("morgan"));
+
+// src/routes/index.ts
+var import_express6 = require("express");
+
+// src/routes/health.ts
+var import_express = require("express");
+var router = (0, import_express.Router)();
+var startTime = Date.now();
+router.get("/", (req, res) => {
+  const response = {
+    success: true,
+    data: {
+      status: "healthy",
+      version: process.env.npm_package_version || "0.1.0",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      uptime: Math.floor((Date.now() - startTime) / 1e3)
+    }
+  };
+  res.json(response);
+});
+var health_default = router;
+
+// src/routes/stealth.ts
+var import_express2 = require("express");
+var import_sdk2 = require("@sip-protocol/sdk");
+
+// src/middleware/error-handler.ts
+var import_sdk = require("@sip-protocol/sdk");
+function errorHandler(err, req, res, next) {
+  console.error("[API Error]", {
+    path: req.path,
+    method: req.method,
+    error: err.message,
+    stack: err.stack
+  });
+  if ((0, import_sdk.isSIPError)(err)) {
+    const sipError = err;
+    return res.status(400).json({
+      success: false,
+      error: {
+        code: sipError.code,
+        message: sipError.message,
+        details: {
+          field: sipError.field,
+          expected: sipError.expected
+        }
+      }
+    });
+  }
+  res.status(500).json({
+    success: false,
+    error: {
+      code: "INTERNAL_SERVER_ERROR",
+      message: "An unexpected error occurred",
+      details: process.env.NODE_ENV === "development" ? err.message : void 0
+    }
+  });
+}
+function notFoundHandler(req, res) {
+  res.status(404).json({
+    success: false,
+    error: {
+      code: "NOT_FOUND",
+      message: `Route ${req.method} ${req.path} not found`
+    }
+  });
+}
+
+// src/middleware/validation.ts
+var import_zod = require("zod");
+function validateRequest(schema) {
+  return async (req, res, next) => {
+    try {
+      if (schema.body) {
+        req.body = await schema.body.parseAsync(req.body);
+      }
+      if (schema.query) {
+        req.query = await schema.query.parseAsync(req.query);
+      }
+      if (schema.params) {
+        req.params = await schema.params.parseAsync(req.params);
+      }
+      next();
+    } catch (error) {
+      if (error instanceof import_zod.z.ZodError) {
+        return res.status(400).json({
+          success: false,
+          error: {
+            code: "VALIDATION_ERROR",
+            message: "Invalid request data",
+            details: error.errors
+          }
+        });
+      }
+      next(error);
+    }
+  };
+}
+var schemas = {
+  generateStealth: import_zod.z.object({
+    chain: import_zod.z.enum(["solana", "ethereum", "near", "zcash", "polygon", "arbitrum", "optimism", "base", "bitcoin", "aptos", "sui", "cosmos", "osmosis", "injective", "celestia", "sei", "dydx"]),
+    recipientMetaAddress: import_zod.z.object({
+      spendingKey: import_zod.z.string().regex(/^0x[0-9a-fA-F]+$/),
+      viewingKey: import_zod.z.string().regex(/^0x[0-9a-fA-F]+$/),
+      chain: import_zod.z.enum(["solana", "ethereum", "near", "zcash", "polygon", "arbitrum", "optimism", "base", "bitcoin", "aptos", "sui", "cosmos", "osmosis", "injective", "celestia", "sei", "dydx"]),
+      label: import_zod.z.string().optional()
+    })
+  }),
+  createCommitment: import_zod.z.object({
+    value: import_zod.z.string().regex(/^\d+$/),
+    // bigint as string
+    blindingFactor: import_zod.z.string().regex(/^0x[0-9a-fA-F]+$/).optional()
+  }),
+  generateFundingProof: import_zod.z.object({
+    balance: import_zod.z.string().regex(/^\d+$/),
+    minRequired: import_zod.z.string().regex(/^\d+$/),
+    balanceBlinding: import_zod.z.string().regex(/^0x[0-9a-fA-F]+$/)
+  }),
+  getQuote: import_zod.z.object({
+    inputChain: import_zod.z.enum(["solana", "ethereum", "near", "zcash", "polygon", "arbitrum", "optimism", "base", "bitcoin", "aptos", "sui", "cosmos", "osmosis", "injective", "celestia", "sei", "dydx"]),
+    inputToken: import_zod.z.string().min(1),
+    inputAmount: import_zod.z.string().regex(/^\d+$/),
+    outputChain: import_zod.z.enum(["solana", "ethereum", "near", "zcash", "polygon", "arbitrum", "optimism", "base", "bitcoin", "aptos", "sui", "cosmos", "osmosis", "injective", "celestia", "sei", "dydx"]),
+    outputToken: import_zod.z.string().min(1),
+    slippageTolerance: import_zod.z.number().min(0).max(100).optional()
+  }),
+  executeSwap: import_zod.z.object({
+    intentId: import_zod.z.string().min(1),
+    quoteId: import_zod.z.string().min(1),
+    privacy: import_zod.z.enum(["transparent", "shielded", "compliant"]).optional(),
+    viewingKey: import_zod.z.string().regex(/^0x[0-9a-fA-F]+$/).optional()
+  }),
+  swapStatus: import_zod.z.object({
+    id: import_zod.z.string().min(1)
+  })
+};
+
+// src/routes/stealth.ts
+var router2 = (0, import_express2.Router)();
+router2.post(
+  "/generate",
+  validateRequest({ body: schemas.generateStealth }),
+  async (req, res) => {
+    const { chain, recipientMetaAddress } = req.body;
+    const result = (0, import_sdk2.generateStealthAddress)(recipientMetaAddress);
+    const response = {
+      success: true,
+      data: {
+        stealthAddress: {
+          address: result.stealthAddress.address,
+          ephemeralPublicKey: result.stealthAddress.ephemeralPublicKey,
+          viewTag: result.stealthAddress.viewTag
+        }
+      }
+    };
+    res.json(response);
+  }
+);
+var stealth_default = router2;
+
+// src/routes/commitment.ts
+var import_express3 = require("express");
+var import_sdk3 = require("@sip-protocol/sdk");
+
+// ../../../../node_modules/@noble/hashes/esm/utils.js
+var hasHexBuiltin = /* @__PURE__ */ (() => (
+  // @ts-ignore
+  typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function"
+))();
+var asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function asciiToBase16(ch) {
+  if (ch >= asciis._0 && ch <= asciis._9)
+    return ch - asciis._0;
+  if (ch >= asciis.A && ch <= asciis.F)
+    return ch - (asciis.A - 10);
+  if (ch >= asciis.a && ch <= asciis.f)
+    return ch - (asciis.a - 10);
+  return;
+}
+function hexToBytes(hex) {
+  if (typeof hex !== "string")
+    throw new Error("hex string expected, got " + typeof hex);
+  if (hasHexBuiltin)
+    return Uint8Array.fromHex(hex);
+  const hl = hex.length;
+  const al = hl / 2;
+  if (hl % 2)
+    throw new Error("hex string expected, got unpadded hex of length " + hl);
+  const array = new Uint8Array(al);
+  for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+    const n1 = asciiToBase16(hex.charCodeAt(hi));
+    const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+    if (n1 === void 0 || n2 === void 0) {
+      const char = hex[hi] + hex[hi + 1];
+      throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+    }
+    array[ai] = n1 * 16 + n2;
+  }
+  return array;
+}
+
+// src/routes/commitment.ts
+var router3 = (0, import_express3.Router)();
+router3.post(
+  "/create",
+  validateRequest({ body: schemas.createCommitment }),
+  async (req, res) => {
+    const { value, blindingFactor } = req.body;
+    const valueBigInt = BigInt(value);
+    const blindingBytes = blindingFactor ? hexToBytes(blindingFactor) : void 0;
+    const result = (0, import_sdk3.commit)(valueBigInt, blindingBytes);
+    const response = {
+      success: true,
+      data: {
+        commitment: result.commitment,
+        blindingFactor: result.blinding
+      }
+    };
+    res.json(response);
+  }
+);
+var commitment_default = router3;
+
+// src/routes/proof.ts
+var import_express4 = require("express");
+var import_sdk4 = require("@sip-protocol/sdk");
+var router4 = (0, import_express4.Router)();
+var proofProvider = new import_sdk4.MockProofProvider();
+router4.post(
+  "/funding",
+  validateRequest({ body: schemas.generateFundingProof }),
+  async (req, res) => {
+    const { balance, minRequired, balanceBlinding } = req.body;
+    const balanceBigInt = BigInt(balance);
+    const minRequiredBigInt = BigInt(minRequired);
+    const balanceBlindingBytes = hexToBytes(balanceBlinding);
+    const result = await proofProvider.generateFundingProof({
+      balance: balanceBigInt,
+      minimumRequired: minRequiredBigInt,
+      blindingFactor: balanceBlindingBytes,
+      assetId: "SOL",
+      // Default asset
+      userAddress: "0x0000000000000000000000000000000000000000",
+      ownershipSignature: new Uint8Array(64)
+    });
+    const response = {
+      success: true,
+      data: {
+        proof: result.proof.proof,
+        publicInputs: result.proof.publicInputs
+      }
+    };
+    res.json(response);
+  }
+);
+var proof_default = router4;
+
+// src/routes/swap.ts
+var import_express5 = require("express");
+var import_sdk5 = require("@sip-protocol/sdk");
+var router5 = (0, import_express5.Router)();
+var sip = new import_sdk5.SIP({ network: "testnet" });
+var swaps = /* @__PURE__ */ new Map();
+router5.post(
+  "/",
+  validateRequest({ body: schemas.getQuote }),
+  async (req, res) => {
+    const {
+      inputChain,
+      inputToken,
+      inputAmount,
+      outputChain,
+      outputToken,
+      slippageTolerance
+    } = req.body;
+    const intent = await sip.createIntent({
+      input: {
+        asset: {
+          chain: inputChain,
+          address: null,
+          // Native token
+          symbol: inputToken,
+          decimals: 9
+        },
+        amount: BigInt(inputAmount)
+      },
+      output: {
+        asset: {
+          chain: outputChain,
+          address: null,
+          // Native token
+          symbol: outputToken,
+          decimals: 9
+        },
+        minAmount: BigInt(inputAmount) * 95n / 100n,
+        // 5% slippage
+        maxSlippage: (slippageTolerance || 1) / 100
+      },
+      privacy: import_sdk5.PrivacyLevel.TRANSPARENT
+      // Default to transparent for quote
+    });
+    const mockQuote = {
+      quoteId: `quote-${Date.now()}`,
+      inputAmount,
+      outputAmount: (BigInt(inputAmount) * 95n / 100n).toString(),
+      // Mock 5% fee
+      rate: "0.95",
+      estimatedTime: 30,
+      fees: {
+        network: "0.001",
+        protocol: "0.003"
+      },
+      route: {
+        steps: [
+          {
+            chain: inputChain,
+            protocol: "NEAR Intents",
+            fromToken: inputToken,
+            toToken: outputToken
+          }
+        ]
+      }
+    };
+    const response = {
+      success: true,
+      data: mockQuote
+    };
+    res.json(response);
+  }
+);
+router5.post(
+  "/swap",
+  validateRequest({ body: schemas.executeSwap }),
+  async (req, res) => {
+    const { intentId, quoteId, privacy, viewingKey } = req.body;
+    const swapId = `swap-${Date.now()}`;
+    const swap = {
+      id: swapId,
+      status: "pending",
+      inputAmount: "1000000000",
+      // Mock value
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    swaps.set(swapId, swap);
+    const response = {
+      success: true,
+      data: {
+        swapId,
+        status: "pending",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+    res.json(response);
+  }
+);
+router5.get(
+  "/:id/status",
+  validateRequest({ params: schemas.swapStatus }),
+  async (req, res) => {
+    const { id } = req.params;
+    const swap = swaps.get(id);
+    if (!swap) {
+      return res.status(404).json({
+        success: false,
+        error: {
+          code: "SWAP_NOT_FOUND",
+          message: `Swap ${id} not found`
+        }
+      });
+    }
+    const response = {
+      success: true,
+      data: swap
+    };
+    res.json(response);
+  }
+);
+var swap_default = router5;
+
+// src/routes/index.ts
+var router6 = (0, import_express6.Router)();
+router6.use("/health", health_default);
+router6.use("/stealth", stealth_default);
+router6.use("/commitment", commitment_default);
+router6.use("/proof", proof_default);
+router6.use("/quote", swap_default);
+router6.use("/swap", swap_default);
+var routes_default = router6;
+
+// src/server.ts
+var app = (0, import_express7.default)();
+var PORT = process.env.PORT || 3e3;
+var NODE_ENV = process.env.NODE_ENV || "development";
+var CORS_ORIGIN = process.env.CORS_ORIGIN || "*";
+app.use((0, import_helmet.default)());
+app.use((0, import_cors.default)({
+  origin: CORS_ORIGIN,
+  credentials: true
+}));
+app.use(import_express7.default.json({ limit: "1mb" }));
+app.use(import_express7.default.urlencoded({ extended: true, limit: "1mb" }));
+app.use((0, import_compression.default)());
+app.use((0, import_morgan.default)(NODE_ENV === "development" ? "dev" : "combined"));
+app.use("/api/v1", routes_default);
+app.get("/", (req, res) => {
+  res.json({
+    name: "@sip-protocol/api",
+    version: "0.1.0",
+    description: "REST API service for SIP Protocol SDK",
+    documentation: "/api/v1/health",
+    endpoints: {
+      health: "GET /api/v1/health",
+      stealth: "POST /api/v1/stealth/generate",
+      commitment: "POST /api/v1/commitment/create",
+      proof: "POST /api/v1/proof/funding",
+      quote: "POST /api/v1/quote",
+      swap: "POST /api/v1/swap",
+      swapStatus: "GET /api/v1/swap/:id/status"
+    }
+  });
+});
+app.use(notFoundHandler);
+app.use(errorHandler);
+if (require.main === module) {
+  app.listen(PORT, () => {
+    console.log(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551  SIP Protocol REST API                             \u2551
+\u2551  Version: 0.1.0                                    \u2551
+\u2551  Port: ${PORT}                                         \u2551
+\u2551  Environment: ${NODE_ENV}                              \u2551
+\u2551  Documentation: http://localhost:${PORT}/              \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+    `);
+  });
+}
+var server_default = app;
+/*! Bundled license information:
+
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@sip-protocol/api",
+  "version": "0.1.0",
+  "description": "REST API service for SIP Protocol SDK - Optional wrapper for non-JS backends",
+  "author": "SIP Protocol <hello@sip-protocol.org>",
+  "homepage": "https://sip-protocol.org",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sip-protocol/sip-protocol.git",
+    "directory": "packages/api"
+  },
+  "bugs": {
+    "url": "https://github.com/sip-protocol/sip-protocol/issues"
+  },
+  "main": "./dist/server.js",
+  "types": "./dist/server.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@sip-protocol/sdk": "^0.6.0",
+    "@sip-protocol/types": "^0.2.0",
+    "compression": "^1.8.1",
+    "cors": "^2.8.5",
+    "express": "^4.22.1",
+    "helmet": "^7.2.0",
+    "morgan": "^1.10.1",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/compression": "^1.8.1",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^4.17.25",
+    "@types/morgan": "^1.9.10",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.1.0"
+  },
+  "keywords": [
+    "sip",
+    "privacy",
+    "rest-api",
+    "stealth-addresses",
+    "commitments",
+    "api"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "start": "node dist/server.js",
+    "dev": "tsx watch src/server.ts",
+    "build": "tsup src/server.ts src/routes/index.ts --format cjs --dts",
+    "lint": "eslint --ext .ts src/",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "test": "vitest"
+  }
+}

package/src/middleware/error-handler.ts

@@ -0,0 +1,59 @@
+import { Request, Response, NextFunction } from 'express'
+import { SIPError, isSIPError } from '@sip-protocol/sdk'
+
+/**
+ * Global error handler middleware
+ */
+export function errorHandler(
+  err: Error,
+  req: Request,
+  res: Response,
+  next: NextFunction
+) {
+  // Log error for debugging
+  console.error('[API Error]', {
+    path: req.path,
+    method: req.method,
+    error: err.message,
+    stack: err.stack,
+  })
+
+  // Handle SIP SDK errors
+  if (isSIPError(err)) {
+    const sipError = err as SIPError
+    return res.status(400).json({
+      success: false,
+      error: {
+        code: sipError.code,
+        message: sipError.message,
+        details: {
+          field: (sipError as any).field,
+          expected: (sipError as any).expected,
+        },
+      },
+    })
+  }
+
+  // Handle generic errors
+  res.status(500).json({
+    success: false,
+    error: {
+      code: 'INTERNAL_SERVER_ERROR',
+      message: 'An unexpected error occurred',
+      details: process.env.NODE_ENV === 'development' ? err.message : undefined,
+    },
+  })
+}
+
+/**
+ * 404 handler
+ */
+export function notFoundHandler(req: Request, res: Response) {
+  res.status(404).json({
+    success: false,
+    error: {
+      code: 'NOT_FOUND',
+      message: `Route ${req.method} ${req.path} not found`,
+    },
+  })
+}

package/src/middleware/index.ts

@@ -0,0 +1,2 @@
+export { errorHandler, notFoundHandler } from './error-handler'
+export { validateRequest, schemas } from './validation'

package/src/middleware/validation.ts

@@ -0,0 +1,84 @@
+import { Request, Response, NextFunction } from 'express'
+import { z, ZodSchema } from 'zod'
+
+/**
+ * Zod schema validation middleware factory
+ */
+export function validateRequest(schema: {
+  body?: ZodSchema
+  query?: ZodSchema
+  params?: ZodSchema
+}) {
+  return async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      if (schema.body) {
+        req.body = await schema.body.parseAsync(req.body)
+      }
+      if (schema.query) {
+        req.query = await schema.query.parseAsync(req.query)
+      }
+      if (schema.params) {
+        req.params = await schema.params.parseAsync(req.params)
+      }
+      next()
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        return res.status(400).json({
+          success: false,
+          error: {
+            code: 'VALIDATION_ERROR',
+            message: 'Invalid request data',
+            details: error.errors,
+          },
+        })
+      }
+      next(error)
+    }
+  }
+}
+
+/**
+ * Validation schemas
+ */
+export const schemas = {
+  generateStealth: z.object({
+    chain: z.enum(['solana', 'ethereum', 'near', 'zcash', 'polygon', 'arbitrum', 'optimism', 'base', 'bitcoin', 'aptos', 'sui', 'cosmos', 'osmosis', 'injective', 'celestia', 'sei', 'dydx']),
+    recipientMetaAddress: z.object({
+      spendingKey: z.string().regex(/^0x[0-9a-fA-F]+$/),
+      viewingKey: z.string().regex(/^0x[0-9a-fA-F]+$/),
+      chain: z.enum(['solana', 'ethereum', 'near', 'zcash', 'polygon', 'arbitrum', 'optimism', 'base', 'bitcoin', 'aptos', 'sui', 'cosmos', 'osmosis', 'injective', 'celestia', 'sei', 'dydx']),
+      label: z.string().optional(),
+    }),
+  }),
+
+  createCommitment: z.object({
+    value: z.string().regex(/^\d+$/), // bigint as string
+    blindingFactor: z.string().regex(/^0x[0-9a-fA-F]+$/).optional(),
+  }),
+
+  generateFundingProof: z.object({
+    balance: z.string().regex(/^\d+$/),
+    minRequired: z.string().regex(/^\d+$/),
+    balanceBlinding: z.string().regex(/^0x[0-9a-fA-F]+$/),
+  }),
+
+  getQuote: z.object({
+    inputChain: z.enum(['solana', 'ethereum', 'near', 'zcash', 'polygon', 'arbitrum', 'optimism', 'base', 'bitcoin', 'aptos', 'sui', 'cosmos', 'osmosis', 'injective', 'celestia', 'sei', 'dydx']),
+    inputToken: z.string().min(1),
+    inputAmount: z.string().regex(/^\d+$/),
+    outputChain: z.enum(['solana', 'ethereum', 'near', 'zcash', 'polygon', 'arbitrum', 'optimism', 'base', 'bitcoin', 'aptos', 'sui', 'cosmos', 'osmosis', 'injective', 'celestia', 'sei', 'dydx']),
+    outputToken: z.string().min(1),
+    slippageTolerance: z.number().min(0).max(100).optional(),
+  }),
+
+  executeSwap: z.object({
+    intentId: z.string().min(1),
+    quoteId: z.string().min(1),
+    privacy: z.enum(['transparent', 'shielded', 'compliant']).optional(),
+    viewingKey: z.string().regex(/^0x[0-9a-fA-F]+$/).optional(),
+  }),
+
+  swapStatus: z.object({
+    id: z.string().min(1),
+  }),
+}