@solgate/server 0.2.0

package/dist/chunk-MYF3SW4P.js

@@ -0,0 +1,43 @@
+import {
+  MemoryStorage,
+  createAllowlistApp,
+  createSqliteStorage
+} from "./chunk-MSHXG5G3.js";
+
+// src/node.ts
+import { serve } from "@hono/node-server";
+import { getConnInfo } from "@hono/node-server/conninfo";
+async function configFromEnv(env = process.env) {
+  const storage = env.ALLOWLIST_DB === "memory" ? new MemoryStorage() : await createSqliteStorage(env.ALLOWLIST_DB ?? "allowlist.db");
+  if (!env.SESSION_SECRET || env.SESSION_SECRET.length < 32) throw new Error("SESSION_SECRET must be at least 32 characters");
+  return {
+    storage,
+    baseUrl: env.BASE_URL ?? "http://localhost:8787",
+    sessionSecret: env.SESSION_SECRET,
+    adminApiKey: env.ADMIN_API_KEY,
+    corsOrigins: env.CORS_ORIGINS ? env.CORS_ORIGINS.split(",").map((s) => s.trim()) : "*",
+    eligibilityLookup: env.ELIGIBILITY_LOOKUP ?? "minimal",
+    trustProxy: env.TRUST_PROXY ?? "none",
+    allowedReturnOrigins: env.ALLOWED_RETURN_ORIGINS?.split(",").map((s) => s.trim()).filter(Boolean),
+    allowInsecureWebhooks: env.ALLOW_INSECURE_WEBHOOKS === "true",
+    solana: { rpcUrl: env.SOLANA_RPC_URL ?? "https://api.mainnet-beta.solana.com", dasUrl: env.SOLANA_DAS_URL },
+    oauth: {
+      x: env.X_CLIENT_ID ? { clientId: env.X_CLIENT_ID, clientSecret: env.X_CLIENT_SECRET ?? "" } : void 0,
+      discord: env.DISCORD_CLIENT_ID ? { clientId: env.DISCORD_CLIENT_ID, clientSecret: env.DISCORD_CLIENT_SECRET ?? "", botToken: env.DISCORD_BOT_TOKEN } : void 0,
+      google: env.GOOGLE_CLIENT_ID ? { clientId: env.GOOGLE_CLIENT_ID, clientSecret: env.GOOGLE_CLIENT_SECRET ?? "" } : void 0
+    },
+    telegram: env.TELEGRAM_BOT_TOKEN ? { botToken: env.TELEGRAM_BOT_TOKEN, botUsername: env.TELEGRAM_BOT_USERNAME ?? "" } : void 0,
+    captcha: { turnstileSecret: env.TURNSTILE_SECRET, hcaptchaSecret: env.HCAPTCHA_SECRET, recaptchaSecret: env.RECAPTCHA_SECRET }
+  };
+}
+async function startNodeServer(port = Number(process.env.PORT ?? 8787)) {
+  const config = await configFromEnv();
+  const { app } = createAllowlistApp(config, { getClientIp: (c) => getConnInfo(c).remote.address });
+  serve({ fetch: app.fetch, port }, () => console.log(`solgate API listening on http://localhost:${port}`));
+  return app;
+}
+
+export {
+  configFromEnv,
+  startNodeServer
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import {
+  startNodeServer
+} from "./chunk-MYF3SW4P.js";
+import "./chunk-MSHXG5G3.js";
+import "./chunk-MCKGQKYU.js";
+
+// src/cli.ts
+startNodeServer().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1,156 @@
+import { V as Verifier, a as Storage, b as SocialLink, W as Webhook, c as WebhookDelivery, d as ApiKey, e as Snapshot } from './app-CB9x11xM.js';
+export { f as AllowlistError, g as AllowlistService, A as AppEnv, E as EventBus, N as NormalizedConfig, S as ServerConfig, h as VerificationUnavailable, i as VerifyContext, j as createAllowlistApp, k as fail, p as pass, v as verifyWebhookSignature } from './app-CB9x11xM.js';
+import { NftOwnershipModule, TokenBalanceModule, DiscordVerificationModule, SocialTaskModule, TelegramVerificationModule, XVerificationModule, YouTubeVerificationModule, CaptchaModule, QuizModule, ReferralModule, Campaign, Entry } from '@solgate/core';
+import { z } from 'zod';
+import 'hono/types';
+import 'hono';
+
+type TokenCfg = z.infer<typeof TokenBalanceModule.configSchema>;
+type NftCfg = z.infer<typeof NftOwnershipModule.configSchema>;
+/** Scale a UI amount (e.g. 12.5) to raw units as a BigInt, exactly. */
+declare function toRawAmount(ui: number | string, decimals: number): bigint;
+/** Wallet signature is verified at session creation; this verifier just records it. */
+declare const walletSignatureVerifier: Verifier;
+/**
+ * SPL / Token-2022 balance. Filtering by `mint` alone returns accounts from
+ * whichever token program owns that mint, so one query covers both programs.
+ * Amounts are compared as exact integers (raw units), never floats.
+ * RPC failures are surfaced as VerificationUnavailable — an outage must not
+ * be recorded as "user has zero tokens".
+ */
+declare const tokenBalanceVerifier: Verifier<TokenCfg>;
+/** NFT ownership via DAS `getAssetsByOwner` (covers Token Metadata, Core, and compressed NFTs). */
+declare const nftOwnershipVerifier: Verifier<NftCfg>;
+
+/**
+ * Social verifiers. The OAuth dance itself lives in routes/oauth.ts; once a
+ * provider profile has been obtained, it is passed here as `input` where we
+ * (1) enforce one-social-account-per-wallet uniqueness and (2) check any
+ * extra requirement (follow, guild, role, subscription).
+ */
+
+interface SocialProfile {
+    provider: "x" | "discord" | "google" | "telegram";
+    id: string;
+    handle?: string;
+    accessToken?: string;
+    meta?: Record<string, unknown>;
+}
+type XCfg = z.infer<typeof XVerificationModule.configSchema>;
+declare const xVerifier: Verifier<XCfg, SocialProfile>;
+type DiscordCfg = z.infer<typeof DiscordVerificationModule.configSchema>;
+declare const discordVerifier: Verifier<DiscordCfg, SocialProfile>;
+type TgCfg = z.infer<typeof TelegramVerificationModule.configSchema>;
+interface TelegramLoginData {
+    id: number;
+    first_name?: string;
+    last_name?: string;
+    username?: string;
+    photo_url?: string;
+    auth_date: number;
+    hash: string;
+}
+/** Validate Telegram Login Widget payload per https://core.telegram.org/widgets/login#checking-authorization */
+declare function verifyTelegramLogin(botToken: string, data: TelegramLoginData, maxAgeSeconds?: number, clockSkewSeconds?: number): boolean;
+declare const telegramVerifier: Verifier<TgCfg, TelegramLoginData>;
+type YtCfg = z.infer<typeof YouTubeVerificationModule.configSchema>;
+declare const youtubeVerifier: Verifier<YtCfg, SocialProfile>;
+type TaskCfg = z.infer<typeof SocialTaskModule.configSchema>;
+interface SocialTaskInput {
+    /** "open" records the click; "complete" submits. */
+    action: "open" | "complete";
+    proofUrl?: string;
+}
+declare const socialTaskVerifier: Verifier<TaskCfg, SocialTaskInput>;
+
+type QuizCfg = z.infer<typeof QuizModule.configSchema>;
+interface QuizInput {
+    answers: Record<string, number | number[] | string>;
+}
+declare const quizVerifier: Verifier<QuizCfg, QuizInput>;
+type RefCfg = z.infer<typeof ReferralModule.configSchema>;
+interface ReferralInput {
+    code?: string;
+}
+declare const referralVerifier: Verifier<RefCfg, ReferralInput>;
+type CaptchaCfg = z.infer<typeof CaptchaModule.configSchema>;
+interface CaptchaInput {
+    token: string;
+}
+declare const captchaVerifier: Verifier<CaptchaCfg, CaptchaInput>;
+
+declare const builtinVerifiers: Verifier[];
+
+/** In-memory adapter: tests, demos, and stateless edge deployments with a warm cache. */
+declare class MemoryStorage implements Storage {
+    campaigns: Map<string, Campaign>;
+    entries: Map<string, Entry>;
+    temp: Map<string, {
+        v: string;
+        exp: number;
+    }>;
+    social: Map<string, SocialLink>;
+    webhooks: Map<string, Webhook>;
+    deliveries: WebhookDelivery[];
+    apiKeys: Map<string, ApiKey>;
+    snapshots: Map<string, Snapshot>;
+    getCampaign(id: string): Promise<Campaign | null>;
+    listCampaigns(): Promise<Campaign[]>;
+    putCampaign(c: Campaign): Promise<void>;
+    deleteCampaign(id: string): Promise<void>;
+    getEntry(campaignId: string, wallet: string): Promise<Entry | null>;
+    putEntry(e: Entry): Promise<void>;
+    listEntries(campaignId: string, opts?: {
+        eligibleOnly?: boolean;
+        offset?: number;
+        limit?: number;
+    }): Promise<Entry[]>;
+    countEntries(campaignId: string, opts?: {
+        eligibleOnly?: boolean;
+    }): Promise<number>;
+    findEntryByReferralCode(campaignId: string, code: string): Promise<Entry | null>;
+    private sweep;
+    setTemp(key: string, value: string, ttlSeconds: number): Promise<void>;
+    getTemp(key: string): Promise<string | null>;
+    deleteTemp(key: string): Promise<void>;
+    incrTemp(key: string, ttlSeconds: number): Promise<number>;
+    getSocialLink(campaignId: string, provider: string, providerUserId: string): Promise<SocialLink | null>;
+    claimSocialLink(link: SocialLink): Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        owner: string;
+    }>;
+    putSnapshot(s: Snapshot): Promise<void>;
+    getSnapshot(campaignId: string, id?: string): Promise<Snapshot | null>;
+    listSnapshots(campaignId: string): Promise<{
+        id: string;
+        campaignId: string;
+        createdAt: number;
+        count: number;
+        totalAllocation: number;
+        merkle?: {
+            scheme: string;
+            root: string;
+        };
+    }[]>;
+    listSocialLinksForWallet(campaignId: string, wallet: string): Promise<SocialLink[]>;
+    listWebhooks(): Promise<Webhook[]>;
+    putWebhook(w: Webhook): Promise<void>;
+    deleteWebhook(id: string): Promise<void>;
+    putDelivery(d: WebhookDelivery): Promise<void>;
+    listApiKeys(): Promise<ApiKey[]>;
+    putApiKey(k: ApiKey): Promise<void>;
+    deleteApiKey(id: string): Promise<void>;
+}
+
+/**
+ * SQLite adapter using better-sqlite3 (Node). Single-file, zero-ops.
+ * The same SQL works for Postgres with trivial changes — see docs/storage.md.
+ */
+declare function createSqliteStorage(file?: string): Promise<Storage>;
+
+/** Verify an ed25519 signature over a UTF-8 message from a base58 Solana pubkey. Signature may be base58 or base64. */
+declare function verifyWalletSignature(wallet: string, message: string, signature: string): boolean;
+
+export { ApiKey, type CaptchaInput, MemoryStorage, type QuizInput, type ReferralInput, SocialLink, type SocialProfile, type SocialTaskInput, Storage, type TelegramLoginData, Verifier, Webhook, builtinVerifiers, captchaVerifier, createSqliteStorage, discordVerifier, nftOwnershipVerifier, quizVerifier, referralVerifier, socialTaskVerifier, telegramVerifier, toRawAmount, tokenBalanceVerifier, verifyTelegramLogin, verifyTelegramLogin as verifyTelegramLoginData, verifyWalletSignature, walletSignatureVerifier, xVerifier, youtubeVerifier };

package/dist/index.js

@@ -0,0 +1,56 @@
+import {
+  AllowlistError,
+  AllowlistService,
+  EventBus,
+  MemoryStorage,
+  VerificationUnavailable,
+  builtinVerifiers,
+  captchaVerifier,
+  createAllowlistApp,
+  createSqliteStorage,
+  discordVerifier,
+  fail,
+  nftOwnershipVerifier,
+  pass,
+  quizVerifier,
+  referralVerifier,
+  socialTaskVerifier,
+  telegramVerifier,
+  toRawAmount,
+  tokenBalanceVerifier,
+  verifyTelegramLogin,
+  verifyWalletSignature,
+  verifyWebhookSignature,
+  walletSignatureVerifier,
+  xVerifier,
+  youtubeVerifier
+} from "./chunk-MSHXG5G3.js";
+import "./chunk-MCKGQKYU.js";
+export {
+  AllowlistError,
+  AllowlistService,
+  EventBus,
+  MemoryStorage,
+  VerificationUnavailable,
+  builtinVerifiers,
+  captchaVerifier,
+  createAllowlistApp,
+  createSqliteStorage,
+  discordVerifier,
+  fail,
+  nftOwnershipVerifier,
+  pass,
+  quizVerifier,
+  referralVerifier,
+  socialTaskVerifier,
+  telegramVerifier,
+  toRawAmount,
+  tokenBalanceVerifier,
+  verifyTelegramLogin,
+  verifyTelegramLogin as verifyTelegramLoginData,
+  verifyWalletSignature,
+  verifyWebhookSignature,
+  walletSignatureVerifier,
+  xVerifier,
+  youtubeVerifier
+};