faucet-server-app 0.0.1

package/src/api/index.ts

@@ -0,0 +1,179 @@
+import {Hono} from 'hono';
+import {ServerOptions} from '../types.js';
+import {setup} from '../setup.js';
+import {Env} from '../env.js';
+import {
+	createWalletClient,
+	http,
+	isAddress,
+	parseEther,
+	type Hex,
+	type Address,
+} from 'viem';
+import {privateKeyToAccount} from 'viem/accounts';
+
+const PROSOPO_VERIFY_ENDPOINT = 'https://api.prosopo.io/siteverify';
+
+type VerifyResponse = {
+	verified: boolean;
+	[key: string]: unknown;
+};
+
+type ClaimRequest = {
+	token: string;
+	chainId: string;
+	address: string;
+};
+
+async function verifyProsopoCaptcha(
+	token: string,
+	secret: string,
+): Promise<boolean> {
+	const body = {
+		token,
+		secret,
+	};
+
+	const response = await fetch(PROSOPO_VERIFY_ENDPOINT, {
+		method: 'POST',
+		headers: {
+			'Content-Type': 'application/json',
+		},
+		body: JSON.stringify(body),
+	});
+
+	const result = (await response.json()) as VerifyResponse;
+	return result.verified === true;
+}
+
+function parseChainConfig(
+	configValue: string,
+): {amount: string; rpcUrl: string} | null {
+	// Format: <amount>:<rpc_endpoint>
+	const colonIndex = configValue.indexOf(':');
+	if (colonIndex === -1) {
+		return null;
+	}
+	const amount = configValue.substring(0, colonIndex);
+	const rpcUrl = configValue.substring(colonIndex + 1);
+	if (!amount || !rpcUrl) {
+		return null;
+	}
+	return {amount, rpcUrl};
+}
+
+export function getAPI<CustomEnv extends Env>(
+	options: ServerOptions<CustomEnv>,
+) {
+	const app = new Hono<{Bindings: CustomEnv}>()
+		.use(setup({serverOptions: options}))
+		.post('/claim', async (c) => {
+			const config = c.get('config');
+			const env = config.env;
+
+			// Check if captcha is disabled (for localhost development)
+			const captchaDisabled = env.DISABLE_CAPTCHA === 'true';
+
+			// Validate PROSOPO secret (only required if captcha is enabled)
+			const secret = env.PROSOPO_SITE_PRIVATE_KEY;
+			if (!captchaDisabled && !secret) {
+				return c.json({error: 'PROSOPO_SITE_PRIVATE_KEY not configured'}, 500);
+			}
+
+			// Validate FAUCET_PRIVATE_KEY
+			const faucetPrivateKey = env.FAUCET_PRIVATE_KEY;
+			if (!faucetPrivateKey) {
+				return c.json({error: 'FAUCET_PRIVATE_KEY not configured'}, 500);
+			}
+
+			const body = await c.req.json<ClaimRequest>();
+			const {token, chainId, address} = body;
+
+			// Validate required fields
+			if (!token) {
+				return c.json({error: 'Missing token'}, 400);
+			}
+
+			if (!chainId) {
+				return c.json({error: 'Missing chainId'}, 400);
+			}
+
+			if (!address) {
+				return c.json({error: 'Missing address'}, 400);
+			}
+
+			// Validate address format
+			if (!isAddress(address)) {
+				return c.json({error: 'Invalid Ethereum address'}, 400);
+			}
+
+			// Parse chainId
+			const chainIdNum = parseInt(chainId, 10);
+			if (isNaN(chainIdNum) || chainIdNum <= 0) {
+				return c.json({error: 'Invalid chainId'}, 400);
+			}
+
+			// Check for chain-specific config (format: <amount>:<rpc_endpoint>)
+			const chainConfigKey = `CHAIN_${chainId}` as `CHAIN_${string}`;
+			const chainConfigValue = env[chainConfigKey];
+
+			if (!chainConfigValue) {
+				return c.json(
+					{error: `Faucet not configured for chain ${chainId}`},
+					400,
+				);
+			}
+
+			const chainConfig = parseChainConfig(chainConfigValue);
+			if (!chainConfig) {
+				return c.json(
+					{
+						error: `Invalid chain config format for chain ${chainId}. Expected: <amount>:<rpc_endpoint>`,
+					},
+					500,
+				);
+			}
+
+			// Verify captcha (skip if disabled for localhost development)
+			if (!captchaDisabled) {
+				const verified = await verifyProsopoCaptcha(token, secret!);
+
+				if (!verified) {
+					return c.json({error: 'Captcha verification failed'}, 401);
+				}
+			}
+
+			try {
+				// Create wallet client and send transaction
+				const account = privateKeyToAccount(faucetPrivateKey as Hex);
+				const {amount, rpcUrl} = chainConfig;
+
+				const walletClient = createWalletClient({
+					account,
+					chain: {
+						id: chainIdNum,
+						name: `Chain ${chainIdNum}`,
+						nativeCurrency: {name: 'ETH', symbol: 'ETH', decimals: 18},
+						rpcUrls: {
+							default: {http: [rpcUrl]},
+						},
+					},
+					transport: http(rpcUrl),
+				});
+
+				const txHash = await walletClient.sendTransaction({
+					to: address as Address,
+					value: BigInt(amount),
+				});
+
+				return c.json({success: true, txHash});
+			} catch (err) {
+				console.error('Transaction error:', err);
+				const errorMessage =
+					err instanceof Error ? err.message : 'Transaction failed';
+				return c.json({error: errorMessage}, 500);
+			}
+		});
+
+	return app;
+}

package/src/env.ts

@@ -0,0 +1,9 @@
+export type Env = {
+	DEV?: string;
+	PROSOPO_SITE_PRIVATE_KEY?: string;
+	FAUCET_PRIVATE_KEY?: string;
+	// Set to 'true' to disable captcha verification (useful for localhost development)
+	DISABLE_CAPTCHA?: string;
+	// Dynamic env variables: CHAIN_<CHAIN_ID>=<amount>:<rpc_endpoint> for chain config
+	[key: `CHAIN_${string}`]: string | undefined;
+};

package/src/index.ts

@@ -0,0 +1,72 @@
+import {Hono} from 'hono';
+import {cors} from 'hono/cors';
+import {ServerOptions} from './types.js';
+import {hc} from 'hono/client';
+import {HTTPException} from 'hono/http-exception';
+import {Env} from './env.js';
+import {getAPI} from './api/index.js';
+
+export type {Env};
+
+// export type {Storage} from './storage/index.js';
+
+const corsSetup = cors({
+	origin: '*',
+	allowHeaders: [
+		'X-Custom-Header',
+		'Upgrade-Insecure-Requests',
+		'Content-Type',
+		'SIGNATURE',
+	],
+	allowMethods: ['POST', 'GET', 'HEAD', 'OPTIONS'],
+	exposeHeaders: ['Content-Length', 'X-Kuma-Revision'],
+	maxAge: 600,
+	credentials: true,
+});
+
+export function createServer<CustomEnv extends Env>(
+	options: ServerOptions<CustomEnv>,
+) {
+	const app = new Hono<{Bindings: CustomEnv}>();
+
+	const api = getAPI(options);
+
+	return app
+		.use('/api/*', corsSetup)
+		.route('/api/', api)
+		.onError((err, c) => {
+			const config = c.get('config');
+			const env = config?.env || {};
+			console.error(err);
+			if (err instanceof HTTPException) {
+				if (err.res) {
+					return err.getResponse();
+				}
+			}
+
+			return c.json(
+				{
+					success: false,
+					errors: [
+						{
+							name: 'name' in err ? err.name : undefined,
+							code: 'code' in err ? err.code : 5000,
+							status: 'status' in err ? err.status : undefined,
+							message: err.message,
+							cause: env.DEV ? err.cause : undefined,
+							stack: env.DEV ? err.stack : undefined,
+						},
+					],
+				},
+				500,
+			);
+		});
+}
+
+export type App = ReturnType<typeof createServer>;
+
+// this is a trick to calculate the type when compiling
+const client = hc<App>('');
+export type Client = typeof client;
+export const createClient = (...args: Parameters<typeof hc>): Client =>
+	hc<App>(...args);

package/src/schema/sql/db.sql

@@ -0,0 +1,5 @@
+CREATE TABLE IF NOT EXISTS Users (
+    id TEXT PRIMARY KEY,
+    email TEXT NOT NULL UNIQUE,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);

package/src/schema/ts/db.sql.ts

@@ -0,0 +1,6 @@
+export default `CREATE TABLE IF NOT EXISTS Users (
+    id TEXT PRIMARY KEY,
+    email TEXT NOT NULL UNIQUE,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+`

package/src/setup.ts

@@ -0,0 +1,45 @@
+import {MiddlewareHandler} from 'hono/types';
+import {ServerOptions} from './types.js';
+import {Env} from './env.js';
+// import {RemoteSQLStorage} from './storage/RemoteSQLStorage.js';
+
+export type SetupOptions<CustomEnv extends Env> = {
+	serverOptions: ServerOptions<CustomEnv>;
+};
+
+export type Config<CustomEnv extends Env> = {
+	// storage: RemoteSQLStorage;
+	env: CustomEnv;
+};
+
+declare module 'hono' {
+	interface ContextVariableMap {
+		config: Config<Env>; // We cannot use generics here, but that is fine as server code is expected to only use Env
+	}
+}
+
+export function setup<CustomEnv extends Env>(
+	options: SetupOptions<CustomEnv>,
+): MiddlewareHandler {
+	const {getDB, getEnv} = options.serverOptions;
+
+	return async (c, next) => {
+		const env = getEnv(c);
+
+		const db = getDB(c);
+		// use db
+		// const storage = new RemoteSQLStorage(db);
+
+		c.set('config', {
+			// storage,
+			env,
+		});
+
+		// // auto setup
+		// if (c.req.query('_initDB') == 'true') {
+		// 	await storage.setup();
+		// }
+
+		return next();
+	};
+}

package/src/types.ts

@@ -0,0 +1,8 @@
+import {Context} from 'hono';
+import {Bindings} from 'hono/types';
+import {RemoteSQL} from 'remote-sql';
+
+export type ServerOptions<Env extends Bindings = Bindings> = {
+	getDB: (c: Context<{Bindings: Env}>) => RemoteSQL;
+	getEnv: (c: Context<{Bindings: Env}>) => Env;
+};