@ottocode/server 0.1.264 → 0.1.266

package/src/routes/ottorouter/topup.ts

@@ -0,0 +1,301 @@
+import type { Hono } from 'hono';
+import { logger } from '@ottocode/sdk';
+import { publish } from '../../events/bus.ts';
+import { openApiRoute } from '../../openapi/route.ts';
+import { serializeError } from '../../runtime/errors/api-error.ts';
+import {
+	getPendingTopup,
+	rejectTopupSelection,
+	resolveTopupMethodSelection,
+	type TopupMethod,
+} from '../../runtime/topup/manager.ts';
+
+export function registerOttoRouterTopupRoutes(app: Hono) {
+	openApiRoute(
+		app,
+		{
+			method: 'post',
+			path: '/v1/ottorouter/topup/select',
+			tags: ['ottorouter'],
+			operationId: 'selectTopupMethod',
+			summary: 'Select topup method for pending request',
+			requestBody: {
+				required: true,
+				content: {
+					'application/json': {
+						schema: {
+							type: 'object',
+							properties: {
+								sessionId: {
+									type: 'string',
+								},
+								method: {
+									type: 'string',
+									enum: ['crypto', 'fiat'],
+								},
+							},
+							required: ['sessionId', 'method'],
+						},
+					},
+				},
+			},
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									success: {
+										type: 'boolean',
+									},
+									method: {
+										type: 'string',
+									},
+								},
+								required: ['success', 'method'],
+							},
+						},
+					},
+				},
+				'404': {
+					description: 'No pending topup',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									error: {
+										type: 'string',
+									},
+								},
+								required: ['error'],
+							},
+						},
+					},
+				},
+			},
+		},
+		async (c) => {
+			try {
+				const body = await c.req.json();
+				const { sessionId, method } = body as {
+					sessionId: string;
+					method: TopupMethod;
+				};
+
+				if (!sessionId || typeof sessionId !== 'string') {
+					return c.json({ error: 'Missing sessionId' }, 400);
+				}
+
+				if (!method || !['crypto', 'fiat'].includes(method)) {
+					return c.json(
+						{ error: 'Invalid method, must be "crypto" or "fiat"' },
+						400,
+					);
+				}
+
+				const resolved = resolveTopupMethodSelection(sessionId, method);
+				if (!resolved) {
+					return c.json(
+						{ error: 'No pending topup request found for this session' },
+						404,
+					);
+				}
+
+				publish({
+					type: 'ottorouter.topup.method_selected',
+					sessionId,
+					payload: { method },
+				});
+
+				return c.json({ success: true, method });
+			} catch (error) {
+				logger.error('Failed to select topup method', error);
+				const errorResponse = serializeError(error);
+				return c.json(errorResponse, errorResponse.error.status || 500);
+			}
+		},
+	);
+
+	openApiRoute(
+		app,
+		{
+			method: 'post',
+			path: '/v1/ottorouter/topup/cancel',
+			tags: ['ottorouter'],
+			operationId: 'cancelTopup',
+			summary: 'Cancel pending topup',
+			requestBody: {
+				required: true,
+				content: {
+					'application/json': {
+						schema: {
+							type: 'object',
+							properties: {
+								sessionId: {
+									type: 'string',
+								},
+								reason: {
+									type: 'string',
+								},
+							},
+							required: ['sessionId'],
+						},
+					},
+				},
+			},
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									success: {
+										type: 'boolean',
+									},
+								},
+								required: ['success'],
+							},
+						},
+					},
+				},
+				'404': {
+					description: 'No pending topup',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									error: {
+										type: 'string',
+									},
+								},
+								required: ['error'],
+							},
+						},
+					},
+				},
+			},
+		},
+		async (c) => {
+			try {
+				const body = await c.req.json();
+				const { sessionId, reason } = body as {
+					sessionId: string;
+					reason?: string;
+				};
+
+				if (!sessionId || typeof sessionId !== 'string') {
+					return c.json({ error: 'Missing sessionId' }, 400);
+				}
+
+				const rejected = rejectTopupSelection(
+					sessionId,
+					reason ?? 'User cancelled',
+				);
+				if (!rejected) {
+					return c.json(
+						{ error: 'No pending topup request found for this session' },
+						404,
+					);
+				}
+
+				publish({
+					type: 'ottorouter.topup.cancelled',
+					sessionId,
+					payload: { reason: reason ?? 'User cancelled' },
+				});
+
+				return c.json({ success: true });
+			} catch (error) {
+				logger.error('Failed to cancel topup', error);
+				const errorResponse = serializeError(error);
+				return c.json(errorResponse, errorResponse.error.status || 500);
+			}
+		},
+	);
+
+	openApiRoute(
+		app,
+		{
+			method: 'get',
+			path: '/v1/ottorouter/topup/pending',
+			tags: ['ottorouter'],
+			operationId: 'getPendingTopup',
+			summary: 'Get pending topup for a session',
+			parameters: [
+				{
+					in: 'query',
+					name: 'sessionId',
+					required: true,
+					schema: {
+						type: 'string',
+					},
+				},
+			],
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									hasPending: {
+										type: 'boolean',
+									},
+									sessionId: {
+										type: 'string',
+									},
+									messageId: {
+										type: 'string',
+									},
+									amountUsd: {
+										type: 'number',
+									},
+									currentBalance: {
+										type: 'number',
+									},
+									createdAt: {
+										type: 'integer',
+									},
+								},
+								required: ['hasPending'],
+							},
+						},
+					},
+				},
+			},
+		},
+		async (c) => {
+			try {
+				const sessionId = c.req.query('sessionId');
+				if (!sessionId) {
+					return c.json({ error: 'Missing sessionId parameter' }, 400);
+				}
+
+				const pending = getPendingTopup(sessionId);
+				if (!pending) {
+					return c.json({ hasPending: false });
+				}
+
+				return c.json({
+					hasPending: true,
+					sessionId: pending.sessionId,
+					messageId: pending.messageId,
+					amountUsd: pending.amountUsd,
+					currentBalance: pending.currentBalance,
+					createdAt: pending.createdAt,
+				});
+			} catch (error) {
+				logger.error('Failed to get pending topup', error);
+				const errorResponse = serializeError(error);
+				return c.json(errorResponse, errorResponse.error.status || 500);
+			}
+		},
+	);
+}

package/src/routes/ottorouter/wallet.ts

@@ -0,0 +1,370 @@
+import type { Hono } from 'hono';
+import { getPublicKeyFromPrivate, logger } from '@ottocode/sdk';
+import { openApiRoute } from '../../openapi/route.ts';
+import { serializeError } from '../../runtime/errors/api-error.ts';
+import {
+	getOttoRouterBalance,
+	getOttoRouterBaseUrl,
+	getOttoRouterPrivateKey,
+	getOttoRouterWalletInfo,
+} from './service.ts';
+
+export function registerOttoRouterWalletRoutes(app: Hono) {
+	openApiRoute(
+		app,
+		{
+			method: 'get',
+			path: '/v1/ottorouter/balance',
+			tags: ['ottorouter'],
+			operationId: 'getOttoRouterBalance',
+			summary: 'Get OttoRouter account balance',
+			description:
+				'Returns wallet balance, subscription, account info, limits, and usage data',
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									walletAddress: {
+										type: 'string',
+									},
+									balance: {
+										type: 'number',
+									},
+									totalSpent: {
+										type: 'number',
+									},
+									totalTopups: {
+										type: 'number',
+									},
+									requestCount: {
+										type: 'number',
+									},
+									scope: {
+										type: 'string',
+										enum: ['wallet', 'account'],
+									},
+									payg: {
+										type: 'object',
+										properties: {
+											walletBalanceUsd: {
+												type: 'number',
+											},
+											accountBalanceUsd: {
+												type: 'number',
+											},
+											rawPoolUsd: {
+												type: 'number',
+											},
+											effectiveSpendableUsd: {
+												type: 'number',
+											},
+										},
+									},
+									limits: {
+										type: 'object',
+										nullable: true,
+										properties: {
+											enabled: {
+												type: 'boolean',
+											},
+											dailyLimitUsd: {
+												type: 'number',
+												nullable: true,
+											},
+											dailySpentUsd: {
+												type: 'number',
+											},
+											dailyRemainingUsd: {
+												type: 'number',
+												nullable: true,
+											},
+											monthlyLimitUsd: {
+												type: 'number',
+												nullable: true,
+											},
+											monthlySpentUsd: {
+												type: 'number',
+											},
+											monthlyRemainingUsd: {
+												type: 'number',
+												nullable: true,
+											},
+											capRemainingUsd: {
+												type: 'number',
+												nullable: true,
+											},
+										},
+									},
+									subscription: {
+										type: 'object',
+										nullable: true,
+										properties: {
+											active: {
+												type: 'boolean',
+											},
+											tierId: {
+												type: 'string',
+											},
+											tierName: {
+												type: 'string',
+											},
+											creditsIncluded: {
+												type: 'number',
+											},
+											creditsUsed: {
+												type: 'number',
+											},
+											creditsRemaining: {
+												type: 'number',
+											},
+											periodStart: {
+												type: 'string',
+											},
+											periodEnd: {
+												type: 'string',
+											},
+										},
+									},
+								},
+								required: [
+									'walletAddress',
+									'balance',
+									'totalSpent',
+									'totalTopups',
+									'requestCount',
+								],
+							},
+						},
+					},
+				},
+				'401': {
+					description: 'Wallet not configured',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									error: {
+										type: 'string',
+									},
+								},
+								required: ['error'],
+							},
+						},
+					},
+				},
+				'502': {
+					description: 'Failed to fetch balance from OttoRouter',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									error: {
+										type: 'string',
+									},
+								},
+								required: ['error'],
+							},
+						},
+					},
+				},
+			},
+		},
+		async (c) => {
+			try {
+				const result = await getOttoRouterBalance();
+				return result.ok
+					? c.json(result.body)
+					: c.json(result.body, result.status);
+			} catch (error) {
+				logger.error('Failed to fetch OttoRouter balance', error);
+				const errorResponse = serializeError(error);
+				return c.json(errorResponse, errorResponse.error.status || 500);
+			}
+		},
+	);
+
+	openApiRoute(
+		app,
+		{
+			method: 'get',
+			path: '/v1/ottorouter/wallet',
+			tags: ['ottorouter'],
+			operationId: 'getOttoRouterWallet',
+			summary: 'Get OttoRouter wallet info',
+			description:
+				'Returns whether the wallet is configured and its public key',
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									configured: {
+										type: 'boolean',
+									},
+									publicKey: {
+										type: 'string',
+									},
+									error: {
+										type: 'string',
+									},
+								},
+								required: ['configured'],
+							},
+						},
+					},
+				},
+			},
+		},
+		async (c) => {
+			try {
+				return c.json(await getOttoRouterWalletInfo());
+			} catch (error) {
+				logger.error('Failed to get OttoRouter wallet info', error);
+				const errorResponse = serializeError(error);
+				return c.json(errorResponse, errorResponse.error.status || 500);
+			}
+		},
+	);
+
+	openApiRoute(
+		app,
+		{
+			method: 'get',
+			path: '/v1/ottorouter/usdc-balance',
+			tags: ['ottorouter'],
+			operationId: 'getOttoRouterUsdcBalance',
+			summary: 'Get USDC token balance',
+			description:
+				'Fetches USDC balance from Solana blockchain for the configured wallet',
+			parameters: [
+				{
+					in: 'query',
+					name: 'network',
+					schema: {
+						type: 'string',
+						enum: ['mainnet', 'devnet'],
+						default: 'mainnet',
+					},
+					description: 'Solana network to query',
+				},
+			],
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									walletAddress: {
+										type: 'string',
+									},
+									usdcBalance: {
+										type: 'number',
+									},
+									network: {
+										type: 'string',
+										enum: ['mainnet', 'devnet'],
+									},
+								},
+								required: ['walletAddress', 'usdcBalance', 'network'],
+							},
+						},
+					},
+				},
+				'401': {
+					description: 'Wallet not configured',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									error: {
+										type: 'string',
+									},
+								},
+								required: ['error'],
+							},
+						},
+					},
+				},
+				'502': {
+					description: 'Failed to fetch USDC balance from Solana',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									error: {
+										type: 'string',
+									},
+								},
+								required: ['error'],
+							},
+						},
+					},
+				},
+			},
+		},
+		async (c) => {
+			try {
+				const privateKey = await getOttoRouterPrivateKey();
+				if (!privateKey) {
+					return c.json({ error: 'OttoRouter wallet not configured' }, 401);
+				}
+
+				const publicKey = getPublicKeyFromPrivate(privateKey);
+				if (!publicKey) {
+					return c.json({ error: 'Invalid private key' }, 400);
+				}
+
+				const baseUrl = getOttoRouterBaseUrl();
+				const response = await fetch(
+					`${baseUrl}/v1/wallet/${publicKey}/balances?limit=100&showNative=false&showNfts=false&showZeroBalance=false`,
+					{
+						method: 'GET',
+						headers: { 'Content-Type': 'application/json' },
+					},
+				);
+
+				if (!response.ok) {
+					return c.json({ error: 'Failed to fetch wallet balances' }, 502);
+				}
+
+				const data = (await response.json()) as {
+					balances: Array<{
+						mint: string;
+						symbol: string;
+						name: string;
+						balance: number;
+						decimals: number;
+						pricePerToken: number | null;
+						usdValue: number | null;
+					}>;
+					totalUsdValue: number;
+				};
+
+				const usdcEntry = data.balances.find((b) => b.symbol === 'USDC');
+
+				return c.json({
+					walletAddress: publicKey,
+					usdcBalance: usdcEntry?.balance ?? 0,
+					network: 'mainnet' as const,
+				});
+			} catch (error) {
+				logger.error('Failed to fetch USDC balance', error);
+				const errorResponse = serializeError(error);
+				return c.json(errorResponse, errorResponse.error.status || 500);
+			}
+		},
+	);
+}