@sip-protocol/api 0.1.0

package/src/routes/commitment.ts

@@ -0,0 +1,64 @@
+import { Router, Request, Response } from 'express'
+import { commit } from '@sip-protocol/sdk'
+import { hexToBytes } from '@noble/hashes/utils'
+import { validateRequest, schemas } from '../middleware'
+import type { CreateCommitmentRequest, CommitmentResponse, ApiResponse } from '../types/api'
+
+const router: Router = Router()
+
+/**
+ * POST /commitment/create
+ * Create a Pedersen commitment to a value
+ *
+ * @openapi
+ * /commitment/create:
+ *   post:
+ *     summary: Create Pedersen commitment
+ *     description: Create a cryptographic commitment to hide transaction amounts
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - value
+ *             properties:
+ *               value:
+ *                 type: string
+ *                 description: Value to commit (as string to handle bigint)
+ *                 example: "1000000000"
+ *               blindingFactor:
+ *                 type: string
+ *                 description: Optional blinding factor (hex string)
+ *                 pattern: ^0x[0-9a-fA-F]+$
+ *     responses:
+ *       200:
+ *         description: Commitment created successfully
+ *       400:
+ *         description: Invalid request parameters
+ */
+router.post(
+  '/create',
+  validateRequest({ body: schemas.createCommitment }),
+  async (req: Request, res: Response) => {
+    const { value, blindingFactor } = req.body as CreateCommitmentRequest
+
+    const valueBigInt = BigInt(value)
+    const blindingBytes = blindingFactor ? hexToBytes(blindingFactor) : undefined
+
+    const result = commit(valueBigInt, blindingBytes)
+
+    const response: ApiResponse<CommitmentResponse> = {
+      success: true,
+      data: {
+        commitment: result.commitment,
+        blindingFactor: result.blinding,
+      },
+    }
+
+    res.json(response)
+  }
+)
+
+export default router

package/src/routes/health.ts

@@ -0,0 +1,54 @@
+import { Router, Request, Response } from 'express'
+import type { HealthResponse, ApiResponse } from '../types/api'
+
+const router: Router = Router()
+
+const startTime = Date.now()
+
+/**
+ * GET /health
+ * Health check endpoint
+ *
+ * @openapi
+ * /health:
+ *   get:
+ *     summary: Health check
+ *     description: Check if the API service is running
+ *     responses:
+ *       200:
+ *         description: Service is healthy
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                 data:
+ *                   type: object
+ *                   properties:
+ *                     status:
+ *                       type: string
+ *                       enum: [healthy]
+ *                     version:
+ *                       type: string
+ *                     timestamp:
+ *                       type: string
+ *                     uptime:
+ *                       type: number
+ */
+router.get('/', (req: Request, res: Response) => {
+  const response: ApiResponse<HealthResponse> = {
+    success: true,
+    data: {
+      status: 'healthy',
+      version: process.env.npm_package_version || '0.1.0',
+      timestamp: new Date().toISOString(),
+      uptime: Math.floor((Date.now() - startTime) / 1000),
+    },
+  }
+
+  res.json(response)
+})
+
+export default router

package/src/routes/index.ts

@@ -0,0 +1,18 @@
+import { Router } from 'express'
+import healthRouter from './health'
+import stealthRouter from './stealth'
+import commitmentRouter from './commitment'
+import proofRouter from './proof'
+import swapRouter from './swap'
+
+const router: Router = Router()
+
+// Mount routes
+router.use('/health', healthRouter)
+router.use('/stealth', stealthRouter)
+router.use('/commitment', commitmentRouter)
+router.use('/proof', proofRouter)
+router.use('/quote', swapRouter)  // POST /quote
+router.use('/swap', swapRouter)   // POST /swap and GET /swap/:id/status
+
+export default router

package/src/routes/proof.ts

@@ -0,0 +1,82 @@
+import { Router, Request, Response } from 'express'
+import { MockProofProvider } from '@sip-protocol/sdk'
+import { hexToBytes } from '@noble/hashes/utils'
+import { validateRequest, schemas } from '../middleware'
+import type { GenerateFundingProofRequest, FundingProofResponse, ApiResponse } from '../types/api'
+
+const router: Router = Router()
+
+// Initialize proof provider (use MockProofProvider for now)
+// In production, use NoirProofProvider from '@sip-protocol/sdk/proofs/noir'
+const proofProvider = new MockProofProvider()
+
+/**
+ * POST /proof/funding
+ * Generate a funding proof (proves balance >= minimum without revealing exact balance)
+ *
+ * @openapi
+ * /proof/funding:
+ *   post:
+ *     summary: Generate funding proof
+ *     description: Generate a zero-knowledge proof that balance meets minimum requirement
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - balance
+ *               - minRequired
+ *               - balanceBlinding
+ *             properties:
+ *               balance:
+ *                 type: string
+ *                 description: Actual balance (as string to handle bigint)
+ *                 example: "1000000000"
+ *               minRequired:
+ *                 type: string
+ *                 description: Minimum required balance
+ *                 example: "500000000"
+ *               balanceBlinding:
+ *                 type: string
+ *                 description: Blinding factor for balance commitment
+ *                 pattern: ^0x[0-9a-fA-F]+$
+ *     responses:
+ *       200:
+ *         description: Proof generated successfully
+ *       400:
+ *         description: Invalid request parameters or balance too low
+ */
+router.post(
+  '/funding',
+  validateRequest({ body: schemas.generateFundingProof }),
+  async (req: Request, res: Response) => {
+    const { balance, minRequired, balanceBlinding } = req.body as GenerateFundingProofRequest
+
+    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: ApiResponse<FundingProofResponse> = {
+      success: true,
+      data: {
+        proof: result.proof.proof,
+        publicInputs: result.proof.publicInputs,
+      },
+    }
+
+    res.json(response)
+  }
+)
+
+export default router

package/src/routes/stealth.ts

@@ -0,0 +1,76 @@
+import { Router, Request, Response } from 'express'
+import { generateStealthAddress } from '@sip-protocol/sdk'
+import { validateRequest, schemas } from '../middleware'
+import type { GenerateStealthRequest, StealthAddressResponse, ApiResponse } from '../types/api'
+
+const router: Router = Router()
+
+/**
+ * POST /stealth/generate
+ * Generate a stealth address for a recipient
+ *
+ * @openapi
+ * /stealth/generate:
+ *   post:
+ *     summary: Generate stealth address
+ *     description: Generate a one-time stealth address for privacy-preserving transactions
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - chain
+ *               - recipientMetaAddress
+ *             properties:
+ *               chain:
+ *                 type: string
+ *                 enum: [solana, ethereum, near, zcash, polygon, arbitrum, optimism, base, bitcoin]
+ *               recipientMetaAddress:
+ *                 type: object
+ *                 required:
+ *                   - spendingKey
+ *                   - viewingKey
+ *                   - chain
+ *                 properties:
+ *                   spendingKey:
+ *                     type: string
+ *                     pattern: ^0x[0-9a-fA-F]+$
+ *                   viewingKey:
+ *                     type: string
+ *                     pattern: ^0x[0-9a-fA-F]+$
+ *                   chain:
+ *                     type: string
+ *                   label:
+ *                     type: string
+ *     responses:
+ *       200:
+ *         description: Stealth address generated successfully
+ *       400:
+ *         description: Invalid request parameters
+ */
+router.post(
+  '/generate',
+  validateRequest({ body: schemas.generateStealth }),
+  async (req: Request, res: Response) => {
+    const { chain, recipientMetaAddress } = req.body as GenerateStealthRequest
+
+    const result = generateStealthAddress(recipientMetaAddress)
+
+    const response: ApiResponse<StealthAddressResponse> = {
+      success: true,
+      data: {
+        stealthAddress: {
+          address: result.stealthAddress.address,
+          ephemeralPublicKey: result.stealthAddress.ephemeralPublicKey,
+          viewTag: result.stealthAddress.viewTag,
+        },
+      },
+    }
+
+    res.json(response)
+  }
+)
+
+export default router

package/src/routes/swap.ts

@@ -0,0 +1,262 @@
+import { Router, Request, Response } from 'express'
+import { SIP, PrivacyLevel } from '@sip-protocol/sdk'
+import { validateRequest, schemas } from '../middleware'
+import type {
+  GetQuoteRequest,
+  ExecuteSwapRequest,
+  QuoteResponse,
+  SwapResponse,
+  SwapStatusResponse,
+  ApiResponse
+} from '../types/api'
+
+const router: Router = Router()
+
+// Initialize SIP client
+const sip = new SIP({ network: 'testnet' })
+
+import type { HexString } from '@sip-protocol/types'
+
+// In-memory swap tracking (in production, use a database)
+const swaps = new Map<string, {
+  id: string
+  status: 'pending' | 'processing' | 'completed' | 'failed'
+  transactionHash?: HexString
+  inputAmount: string
+  outputAmount?: string
+  createdAt: string
+  updatedAt: string
+  error?: string
+}>()
+
+/**
+ * POST /quote
+ * Get a swap quote
+ *
+ * @openapi
+ * /quote:
+ *   post:
+ *     summary: Get swap quote
+ *     description: Get a quote for a cross-chain swap
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - inputChain
+ *               - inputToken
+ *               - inputAmount
+ *               - outputChain
+ *               - outputToken
+ *             properties:
+ *               inputChain:
+ *                 type: string
+ *               inputToken:
+ *                 type: string
+ *               inputAmount:
+ *                 type: string
+ *               outputChain:
+ *                 type: string
+ *               outputToken:
+ *                 type: string
+ *               slippageTolerance:
+ *                 type: number
+ *                 minimum: 0
+ *                 maximum: 100
+ *     responses:
+ *       200:
+ *         description: Quote retrieved successfully
+ */
+router.post(
+  '/',
+  validateRequest({ body: schemas.getQuote }),
+  async (req: Request, res: Response) => {
+    const {
+      inputChain,
+      inputToken,
+      inputAmount,
+      outputChain,
+      outputToken,
+      slippageTolerance
+    } = req.body as GetQuoteRequest
+
+    // Create intent
+    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: PrivacyLevel.TRANSPARENT, // Default to transparent for quote
+    })
+
+    // Get quotes (using mock data for now)
+    // In production, this would query real DEX aggregators
+    const mockQuote: QuoteResponse = {
+      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: ApiResponse<QuoteResponse> = {
+      success: true,
+      data: mockQuote,
+    }
+
+    res.json(response)
+  }
+)
+
+/**
+ * POST /swap
+ * Execute a swap
+ *
+ * @openapi
+ * /swap:
+ *   post:
+ *     summary: Execute swap
+ *     description: Execute a cross-chain swap with optional privacy
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - intentId
+ *               - quoteId
+ *             properties:
+ *               intentId:
+ *                 type: string
+ *               quoteId:
+ *                 type: string
+ *               privacy:
+ *                 type: string
+ *                 enum: [transparent, shielded, compliant]
+ *               viewingKey:
+ *                 type: string
+ *                 pattern: ^0x[0-9a-fA-F]+$
+ *     responses:
+ *       200:
+ *         description: Swap initiated successfully
+ */
+router.post(
+  '/swap',
+  validateRequest({ body: schemas.executeSwap }),
+  async (req: Request, res: Response) => {
+    const { intentId, quoteId, privacy, viewingKey } = req.body as ExecuteSwapRequest
+
+    // Generate swap ID
+    const swapId = `swap-${Date.now()}`
+
+    // Store swap status
+    const swap = {
+      id: swapId,
+      status: 'pending' as const,
+      inputAmount: '1000000000', // Mock value
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    }
+    swaps.set(swapId, swap)
+
+    // In production, this would:
+    // 1. Sign the transaction
+    // 2. Submit to the network
+    // 3. Track the transaction
+    // For now, we just return a mock response
+
+    const response: ApiResponse<SwapResponse> = {
+      success: true,
+      data: {
+        swapId,
+        status: 'pending',
+        timestamp: new Date().toISOString(),
+      },
+    }
+
+    res.json(response)
+  }
+)
+
+/**
+ * GET /swap/:id/status
+ * Get swap status
+ *
+ * @openapi
+ * /swap/{id}/status:
+ *   get:
+ *     summary: Get swap status
+ *     description: Check the status of a swap transaction
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         required: true
+ *         schema:
+ *           type: string
+ *         description: Swap ID
+ *     responses:
+ *       200:
+ *         description: Swap status retrieved
+ *       404:
+ *         description: Swap not found
+ */
+router.get(
+  '/:id/status',
+  validateRequest({ params: schemas.swapStatus }),
+  async (req: Request, res: Response) => {
+    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: ApiResponse<SwapStatusResponse> = {
+      success: true,
+      data: swap,
+    }
+
+    res.json(response)
+  }
+)
+
+export default router

package/src/server.ts

@@ -0,0 +1,76 @@
+import express, { Express } from 'express'
+import cors from 'cors'
+import helmet from 'helmet'
+import compression from 'compression'
+import morgan from 'morgan'
+import router from './routes'
+import { errorHandler, notFoundHandler } from './middleware'
+
+const app: Express = express()
+
+// Environment configuration
+const PORT = process.env.PORT || 3000
+const NODE_ENV = process.env.NODE_ENV || 'development'
+const CORS_ORIGIN = process.env.CORS_ORIGIN || '*'
+
+// Security middleware
+app.use(helmet())
+app.use(cors({
+  origin: CORS_ORIGIN,
+  credentials: true,
+}))
+
+// Body parsing middleware
+app.use(express.json({ limit: '1mb' }))
+app.use(express.urlencoded({ extended: true, limit: '1mb' }))
+
+// Compression middleware
+app.use(compression())
+
+// Logging middleware
+app.use(morgan(NODE_ENV === 'development' ? 'dev' : 'combined'))
+
+// API routes
+app.use('/api/v1', router)
+
+// Root endpoint
+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',
+    },
+  })
+})
+
+// 404 handler
+app.use(notFoundHandler)
+
+// Error handler (must be last)
+app.use(errorHandler)
+
+// Start server
+if (require.main === module) {
+  app.listen(PORT, () => {
+    console.log(`
+╔════════════════════════════════════════════════════╗
+║  SIP Protocol REST API                             ║
+║  Version: 0.1.0                                    ║
+║  Port: ${PORT}                                         ║
+║  Environment: ${NODE_ENV}                              ║
+║  Documentation: http://localhost:${PORT}/              ║
+╚════════════════════════════════════════════════════╝
+    `)
+  })
+}
+
+export default app