@sip-protocol/api 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 RECTOR Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,187 @@
+# @sip-protocol/api
+
+REST API service for SIP Protocol SDK - Optional wrapper for non-JavaScript backends.
+
+## Overview
+
+This package provides a REST API wrapper around the `@sip-protocol/sdk`, allowing non-JavaScript applications to interact with the SIP Protocol through HTTP requests.
+
+## Features
+
+- RESTful API endpoints for all core SDK functionality
+- Request validation with Zod schemas
+- Comprehensive error handling
+- OpenAPI documentation
+- Docker support for easy deployment
+- Production-ready security (Helmet, CORS, rate limiting)
+
+## Installation
+
+```bash
+pnpm install
+```
+
+## Development
+
+```bash
+# Start development server with hot reload
+pnpm dev
+
+# Build for production
+pnpm build
+
+# Start production server
+pnpm start
+
+# Run tests
+pnpm test
+
+# Type check
+pnpm typecheck
+```
+
+## API Endpoints
+
+### Health Check
+- `GET /api/v1/health` - Service health check
+
+### Stealth Addresses
+- `POST /api/v1/stealth/generate` - Generate stealth address
+
+### Commitments
+- `POST /api/v1/commitment/create` - Create Pedersen commitment
+
+### Proofs
+- `POST /api/v1/proof/funding` - Generate funding proof
+
+### Swaps
+- `POST /api/v1/quote` - Get swap quote
+- `POST /api/v1/swap` - Execute swap
+- `GET /api/v1/swap/:id/status` - Get swap status
+
+## Usage Examples
+
+### Generate Stealth Address
+
+```bash
+curl -X POST http://localhost:3000/api/v1/stealth/generate \
+  -H "Content-Type: application/json" \
+  -d '{
+    "chain": "ethereum",
+    "recipientMetaAddress": {
+      "spendingKey": "0x02...",
+      "viewingKey": "0x03...",
+      "chain": "ethereum"
+    }
+  }'
+```
+
+### Create Commitment
+
+```bash
+curl -X POST http://localhost:3000/api/v1/commitment/create \
+  -H "Content-Type: application/json" \
+  -d '{
+    "value": "1000000000"
+  }'
+```
+
+### Get Swap Quote
+
+```bash
+curl -X POST http://localhost:3000/api/v1/quote \
+  -H "Content-Type: application/json" \
+  -d '{
+    "inputChain": "ethereum",
+    "inputToken": "ETH",
+    "inputAmount": "1000000000000000000",
+    "outputChain": "solana",
+    "outputToken": "SOL",
+    "slippageTolerance": 1
+  }'
+```
+
+## Docker Deployment
+
+```bash
+# Build image
+docker build -t sip-api .
+
+# Run container
+docker run -p 3000:3000 -e NODE_ENV=production sip-api
+
+# With environment variables
+docker run -p 3000:3000 \
+  -e NODE_ENV=production \
+  -e PORT=3000 \
+  -e CORS_ORIGIN=https://example.com \
+  sip-api
+```
+
+## Environment Variables
+
+- `PORT` - Server port (default: 3000)
+- `NODE_ENV` - Environment (development/production)
+- `CORS_ORIGIN` - CORS allowed origins (default: *)
+
+## Response Format
+
+All endpoints return responses in the following format:
+
+### Success Response
+```json
+{
+  "success": true,
+  "data": { ... }
+}
+```
+
+### Error Response
+```json
+{
+  "success": false,
+  "error": {
+    "code": "ERROR_CODE",
+    "message": "Human-readable error message",
+    "details": { ... }
+  }
+}
+```
+
+## Error Codes
+
+- `VALIDATION_ERROR` - Invalid request parameters
+- `NOT_FOUND` - Resource not found
+- `INTERNAL_SERVER_ERROR` - Unexpected server error
+- SDK-specific error codes from `@sip-protocol/sdk`
+
+## Architecture
+
+```
+src/
+├── routes/          # API route handlers
+│   ├── health.ts    # Health check
+│   ├── stealth.ts   # Stealth address generation
+│   ├── commitment.ts # Pedersen commitments
+│   ├── proof.ts     # ZK proof generation
+│   └── swap.ts      # Swap quotes and execution
+├── middleware/      # Express middleware
+│   ├── validation.ts    # Request validation
+│   └── error-handler.ts # Error handling
+├── types/          # TypeScript types
+│   └── api.ts      # API request/response types
+└── server.ts       # Main server setup
+```
+
+## Production Considerations
+
+1. **Database**: The in-memory swap tracking should be replaced with a proper database (PostgreSQL, MongoDB, etc.)
+2. **Authentication**: Add API key or JWT authentication for production use
+3. **Rate Limiting**: Consider adding rate limiting middleware
+4. **Logging**: Use structured logging (e.g., Winston, Pino) for production
+5. **Monitoring**: Add APM tools (e.g., New Relic, Datadog)
+6. **Load Balancing**: Deploy behind a load balancer for high availability
+
+## License
+
+MIT

package/dist/routes/index.d.ts

@@ -0,0 +1,5 @@
+import { Router } from 'express';
+
+declare const router: Router;
+
+export { router as default };

package/dist/routes/index.js

@@ -0,0 +1,378 @@
+"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/routes/index.ts
+var routes_exports = {};
+__export(routes_exports, {
+  default: () => routes_default
+});
+module.exports = __toCommonJS(routes_exports);
+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");
+
+// 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;
+/*! Bundled license information:
+
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/

package/dist/server.d.ts

@@ -0,0 +1,5 @@
+import { Express } from 'express';
+
+declare const app: Express;
+
+export { app as default };