sui.ski 0.1.0

package/src/utils/pricing.ts

@@ -0,0 +1,291 @@
+import { SuiJsonRpcClient as SuiClient } from '@mysten/sui/jsonRpc'
+import { mainPackage, SuinsClient } from '@mysten/suins'
+import type { Env } from '../types'
+import { cacheKey, getCached, setCache } from './cache'
+import { getNSSuiPrice, getUSDCSuiPrice, NS_SCALE } from './ns-price'
+import { calculatePremium } from './premium'
+import { getPythPriceInfoObjectId } from './pyth-price-info'
+import { getDefaultRpcUrl } from './rpc'
+
+const GRACE_PERIOD_MS = 30 * 24 * 60 * 60 * 1000
+const PRICING_CACHE_TTL = 300
+const NS_DISCOUNT_PERCENT = 25
+const SWAP_SLIPPAGE_BPS = 100
+
+interface PricingResult {
+	directSuiMist: bigint
+	discountedSuiMist: bigint
+	nsNeededMist: bigint
+	savingsMist: bigint
+	savingsPercent: number
+	nsPerSui: number
+	suiPerNs: number
+	isGracePeriod: boolean
+	priceInfoObjectId?: string
+	expirationMs?: number
+	gracePeriodEndMs?: number
+	breakdown: {
+		basePriceUsd: number
+		discountedPriceUsd: number
+		premiumUsd: number
+		suiPriceUsd: number
+		nsDiscountPercent: number
+		swapSlippageBps: number
+	}
+}
+
+interface CalculatePriceParams {
+	domain: string
+	years: number
+	expirationMs?: number
+	env: Env
+}
+
+export async function calculateRegistrationPrice(
+	params: CalculatePriceParams,
+): Promise<PricingResult> {
+	const { domain, years, expirationMs, env } = params
+	const cleanDomain = `${domain.toLowerCase().replace(/\.sui$/i, '')}.sui`
+
+	const key = cacheKey('reg-price-v3', cleanDomain, String(years), String(expirationMs || 0))
+	const cached = await getCached<Record<string, unknown>>(key)
+	if (cached) {
+		return deserializePricingResult(cached)
+	}
+
+	const client = new SuiClient({
+		url: env.SUI_RPC_URL || getDefaultRpcUrl(env.SUI_NETWORK),
+		network: env.SUI_NETWORK,
+	})
+	const network = env.SUI_NETWORK === 'mainnet' ? 'mainnet' : 'testnet'
+	const suinsClient = new SuinsClient({ client: client as never, network })
+
+	const nsFeedId =
+		network === 'mainnet' ? mainPackage.mainnet.coins.NS.feed : mainPackage.testnet.coins.NS.feed
+	const [basePriceUnits, usdcResult, nsPriceResult, priceInfoObjectId] = await Promise.all([
+		suinsClient.calculatePrice({ name: cleanDomain, years }),
+		getUSDCSuiPrice(env),
+		getNSSuiPrice(env),
+		nsFeedId
+			? getPythPriceInfoObjectId(client, network, nsFeedId).catch(() => undefined)
+			: Promise.resolve(undefined),
+	])
+	const suiPriceUsd = usdcResult.usdcPerSui
+
+	const basePriceUsd = Number(basePriceUnits) / 1e6
+
+	let premiumUsd = 0
+	let isGracePeriod = false
+	let gracePeriodEndMs: number | undefined
+
+	if (expirationMs) {
+		const now = Date.now()
+		gracePeriodEndMs = expirationMs + GRACE_PERIOD_MS
+
+		if (now < gracePeriodEndMs) {
+			isGracePeriod = true
+			const premiumResult = calculatePremium(expirationMs, now, suiPriceUsd)
+			premiumUsd = premiumResult.suiPremium * suiPriceUsd
+		}
+	}
+
+	const totalPriceUsd = basePriceUsd + premiumUsd
+	const discountedPriceUsd = totalPriceUsd * (1 - NS_DISCOUNT_PERCENT / 100)
+
+	const directSuiAmount = totalPriceUsd / suiPriceUsd
+	const directSuiMist = BigInt(Math.ceil(directSuiAmount * 1e9))
+
+	const discountedSuiAmount = discountedPriceUsd / suiPriceUsd
+	const nsNeeded = discountedSuiAmount * nsPriceResult.nsPerSui
+	const nsNeededMist = BigInt(Math.ceil(nsNeeded * NS_SCALE))
+
+	const suiForSwap = nsNeeded * nsPriceResult.suiPerNs
+	const suiWithSlippage = suiForSwap * (1 + SWAP_SLIPPAGE_BPS / 10000)
+	const discountedSuiMist = BigInt(Math.ceil(suiWithSlippage * 1e9))
+
+	const savingsMist = directSuiMist - discountedSuiMist
+	const savingsPercent = Number((savingsMist * 10000n) / directSuiMist) / 100
+
+	const result: PricingResult = {
+		directSuiMist,
+		discountedSuiMist,
+		nsNeededMist,
+		savingsMist,
+		savingsPercent,
+		nsPerSui: nsPriceResult.nsPerSui,
+		suiPerNs: nsPriceResult.suiPerNs,
+		isGracePeriod,
+		priceInfoObjectId,
+		expirationMs,
+		gracePeriodEndMs,
+		breakdown: {
+			basePriceUsd,
+			discountedPriceUsd,
+			premiumUsd,
+			suiPriceUsd,
+			nsDiscountPercent: NS_DISCOUNT_PERCENT,
+			swapSlippageBps: SWAP_SLIPPAGE_BPS,
+		},
+	}
+
+	await setCache(key, serializablePricingResult(result), PRICING_CACHE_TTL)
+
+	return result
+}
+
+function serializablePricingResult(result: PricingResult): Record<string, unknown> {
+	return {
+		...result,
+		directSuiMist: String(result.directSuiMist),
+		discountedSuiMist: String(result.discountedSuiMist),
+		nsNeededMist: String(result.nsNeededMist),
+		savingsMist: String(result.savingsMist),
+		priceInfoObjectId: result.priceInfoObjectId,
+	}
+}
+
+function deserializePricingResult(cached: Record<string, unknown>): PricingResult {
+	return {
+		...cached,
+		directSuiMist: BigInt(cached.directSuiMist as string),
+		discountedSuiMist: BigInt(cached.discountedSuiMist as string),
+		nsNeededMist: BigInt(cached.nsNeededMist as string),
+		savingsMist: BigInt(cached.savingsMist as string),
+	} as PricingResult
+}
+
+export function formatPricingResponse(result: PricingResult): Record<string, unknown> {
+	return {
+		directSuiMist: String(result.directSuiMist),
+		discountedSuiMist: String(result.discountedSuiMist),
+		nsNeededMist: String(result.nsNeededMist),
+		savingsMist: String(result.savingsMist),
+		savingsPercent: result.savingsPercent,
+		nsPerSui: result.nsPerSui,
+		suiPerNs: result.suiPerNs,
+		isGracePeriod: result.isGracePeriod,
+		priceInfoObjectId: result.priceInfoObjectId,
+		expirationMs: result.expirationMs,
+		gracePeriodEndMs: result.gracePeriodEndMs,
+		breakdown: result.breakdown,
+	}
+}
+
+export async function calculateRenewalPrice(params: CalculatePriceParams): Promise<PricingResult> {
+	const { domain, years, env } = params
+	const cleanDomain = `${domain.toLowerCase().replace(/\.sui$/i, '')}.sui`
+
+	const key = cacheKey('renew-price-v1', cleanDomain, String(years))
+	const cached = await getCached<Record<string, unknown>>(key)
+	if (cached) {
+		return deserializePricingResult(cached)
+	}
+
+	const client = new SuiClient({
+		url: env.SUI_RPC_URL || getDefaultRpcUrl(env.SUI_NETWORK),
+		network: env.SUI_NETWORK,
+	})
+	const network = env.SUI_NETWORK === 'mainnet' ? 'mainnet' : 'testnet'
+	const suinsClient = new SuinsClient({ client: client as never, network })
+
+	const nsFeedId =
+		network === 'mainnet' ? mainPackage.mainnet.coins.NS.feed : mainPackage.testnet.coins.NS.feed
+	const [basePriceUnits, usdcResult, nsPriceResult, priceInfoObjectId] = await Promise.all([
+		suinsClient.calculatePrice({ name: cleanDomain, years, isRegistration: false }),
+		getUSDCSuiPrice(env),
+		getNSSuiPrice(env),
+		nsFeedId
+			? getPythPriceInfoObjectId(client, network, nsFeedId).catch(() => undefined)
+			: Promise.resolve(undefined),
+	])
+	const suiPriceUsd = usdcResult.usdcPerSui
+
+	const basePriceUsd = Number(basePriceUnits) / 1e6
+	const discountedPriceUsd = basePriceUsd * (1 - NS_DISCOUNT_PERCENT / 100)
+
+	const directSuiAmount = basePriceUsd / suiPriceUsd
+	const directSuiMist = BigInt(Math.ceil(directSuiAmount * 1e9))
+
+	const discountedSuiAmount = discountedPriceUsd / suiPriceUsd
+	const nsNeeded = discountedSuiAmount * nsPriceResult.nsPerSui
+	const nsNeededMist = BigInt(Math.ceil(nsNeeded * NS_SCALE))
+
+	const suiForSwap = nsNeeded * nsPriceResult.suiPerNs
+	const suiWithSlippage = suiForSwap * (1 + SWAP_SLIPPAGE_BPS / 10000)
+	const discountedSuiMist = BigInt(Math.ceil(suiWithSlippage * 1e9))
+
+	const savingsMist = directSuiMist - discountedSuiMist
+	const savingsPercent = Number((savingsMist * 10000n) / directSuiMist) / 100
+
+	const result: PricingResult = {
+		directSuiMist,
+		discountedSuiMist,
+		nsNeededMist,
+		savingsMist,
+		savingsPercent,
+		nsPerSui: nsPriceResult.nsPerSui,
+		suiPerNs: nsPriceResult.suiPerNs,
+		isGracePeriod: false,
+		priceInfoObjectId,
+		breakdown: {
+			basePriceUsd,
+			discountedPriceUsd,
+			premiumUsd: 0,
+			suiPriceUsd,
+			nsDiscountPercent: NS_DISCOUNT_PERCENT,
+			swapSlippageBps: SWAP_SLIPPAGE_BPS,
+		},
+	}
+
+	await setCache(key, serializablePricingResult(result), PRICING_CACHE_TTL)
+
+	return result
+}
+
+export async function getBasePricing(env: Env): Promise<Record<string, unknown>> {
+	const client = new SuiClient({
+		url: env.SUI_RPC_URL || getDefaultRpcUrl(env.SUI_NETWORK),
+		network: env.SUI_NETWORK,
+	})
+	const network = env.SUI_NETWORK === 'mainnet' ? 'mainnet' : 'testnet'
+	const suinsClient = new SuinsClient({ client: client as never, network })
+
+	const [priceList, usdcResult, nsPriceResult] = await Promise.all([
+		suinsClient.getPriceList(),
+		getUSDCSuiPrice(env),
+		getNSSuiPrice(env),
+	])
+	const suiPriceUsd = usdcResult.usdcPerSui
+
+	const pricing: Record<string, unknown> = {
+		suiPriceUsd,
+		nsPerSui: nsPriceResult.nsPerSui,
+		suiPerNs: nsPriceResult.suiPerNs,
+		nsDiscountPercent: NS_DISCOUNT_PERCENT,
+		swapSlippageBps: SWAP_SLIPPAGE_BPS,
+		tiers: {} as Record<string, unknown>,
+	}
+
+	const tiers = pricing.tiers as Record<string, unknown>
+
+	for (const [key, value] of priceList.entries()) {
+		const [minLen, maxLen] = key
+		const keyStr = minLen === maxLen ? String(minLen) : `${minLen}-${maxLen}`
+		const usdAmount = value / 1e6
+		const discountedUsd = usdAmount * (1 - NS_DISCOUNT_PERCENT / 100)
+
+		const directSui = usdAmount / suiPriceUsd
+		const nsNeeded = (discountedUsd / suiPriceUsd) * nsPriceResult.nsPerSui
+		const suiForSwap = nsNeeded * nsPriceResult.suiPerNs * (1 + SWAP_SLIPPAGE_BPS / 10000)
+
+		tiers[keyStr] = {
+			usd: usdAmount,
+			discountedUsd,
+			directSuiMist: Math.ceil(directSui * 1e9),
+			discountedSuiMist: Math.ceil(suiForSwap * 1e9),
+			savingsPercent: Math.round((1 - suiForSwap / directSui) * 10000) / 100,
+		}
+	}
+
+	return pricing
+}

package/src/utils/pyth-price-info.ts

@@ -0,0 +1,63 @@
+import type { SuiJsonRpcClient as SuiClient } from '@mysten/sui/jsonRpc'
+import { parseStructTag } from '@mysten/sui/utils'
+import { mainPackage } from '@mysten/suins'
+
+const PYTH_MAINNET_STATE = mainPackage.mainnet.pyth.pythStateId
+const PYTH_TESTNET_STATE = mainPackage.testnet.pyth.pythStateId
+
+export async function getPythPriceInfoObjectId(
+	client: SuiClient,
+	network: 'mainnet' | 'testnet',
+	feedId: string,
+): Promise<string> {
+	const pythStateId = network === 'mainnet' ? PYTH_MAINNET_STATE : PYTH_TESTNET_STATE
+	const normalizedFeed = feedId.startsWith('0x') ? feedId : `0x${feedId}`
+
+	const priceTableResult = await client.getDynamicFieldObject({
+		parentId: pythStateId,
+		name: {
+			type: 'vector<u8>',
+			value: 'price_info',
+		},
+	})
+
+	if (!priceTableResult.data?.type) {
+		throw new Error('Pyth price table not found')
+	}
+
+	const priceIdentifier = parseStructTag(priceTableResult.data.type).typeParams[0]
+	if (
+		typeof priceIdentifier !== 'object' ||
+		priceIdentifier === null ||
+		priceIdentifier.name !== 'PriceIdentifier' ||
+		!('address' in priceIdentifier)
+	) {
+		throw new Error('Pyth price table field type not found')
+	}
+
+	const fieldType = (priceIdentifier as { address: string }).address
+	const hex = normalizedFeed.startsWith('0x') ? normalizedFeed.slice(2) : normalizedFeed
+	const feedBytes: number[] = []
+	for (let i = 0; i < hex.length; i += 2) {
+		feedBytes.push(parseInt(hex.slice(i, i + 2), 16))
+	}
+
+	const feedResult = await client.getDynamicFieldObject({
+		parentId: priceTableResult.data.objectId,
+		name: {
+			type: `${fieldType}::price_identifier::PriceIdentifier`,
+			value: { bytes: feedBytes },
+		},
+	})
+
+	if (!feedResult.data?.content || feedResult.data.content.dataType !== 'moveObject') {
+		throw new Error(`Pyth price feed object for feed ${feedId} not found`)
+	}
+
+	const fields = feedResult.data.content.fields as { value?: string }
+	if (typeof fields.value !== 'string') {
+		throw new Error('Pyth price feed object has no value field')
+	}
+
+	return fields.value
+}

package/src/utils/response.ts

@@ -0,0 +1,204 @@
+import { generateRegistrationPage } from '../handlers/register2'
+import type { Env, GatewayError } from '../types'
+
+const CORS_HEADERS = {
+	'Access-Control-Allow-Origin': '*',
+	'Access-Control-Allow-Methods': 'GET, HEAD, POST, PUT, DELETE, OPTIONS',
+	'Access-Control-Allow-Headers': '*',
+}
+
+export function jsonResponse<T>(data: T, status = 200, headers: Record<string, string> = {}) {
+	return new Response(JSON.stringify(data), {
+		status,
+		headers: {
+			'Content-Type': 'application/json',
+			...CORS_HEADERS,
+			...headers,
+		},
+	})
+}
+
+export function errorResponse(error: string, code: string, status = 400, details?: unknown) {
+	const body: GatewayError = { error, code, details }
+	return jsonResponse(body, status)
+}
+
+export function htmlResponse(html: string, status = 200, headers: Record<string, string> = {}) {
+	return new Response(html, {
+		status,
+		headers: {
+			'Content-Type': 'text/html; charset=utf-8',
+			...CORS_HEADERS,
+			...headers,
+		},
+	})
+}
+
+export function proxyResponse(response: Response) {
+	// Clone response and add CORS headers
+	const newHeaders = new Headers(response.headers)
+	for (const [key, value] of Object.entries(CORS_HEADERS)) {
+		newHeaders.set(key, value)
+	}
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: newHeaders,
+	})
+}
+
+export function notFoundPage(
+	name: string,
+	env?: Env,
+	available?: boolean,
+	session?: { address: string | null; walletName: string | null; verified: boolean },
+) {
+	// Only show registration page if env is provided AND we confirmed the name is available
+	// If available is false/undefined, there was a resolution error - don't show registration
+	if (env && available === true) {
+		return htmlResponse(generateRegistrationPage(name, env, session), 200)
+	}
+
+	const escapeHtml = (value: string) =>
+		value.replace(/[&<>"']/g, (char) => {
+			switch (char) {
+				case '&':
+					return '&amp;'
+				case '<':
+					return '&lt;'
+				case '>':
+					return '&gt;'
+				case '"':
+					return '&quot;'
+				case "'":
+					return '&#39;'
+				default:
+					return char
+			}
+		})
+
+	// Fallback for cases without env
+	return htmlResponse(
+		`<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>${escapeHtml(name)} - Not Found | sui.ski</title>
+	<style>
+		* { box-sizing: border-box; margin: 0; padding: 0; }
+		body {
+			font-family: 'Inter', system-ui, -apple-system, sans-serif;
+			background: #000;
+			background-attachment: fixed;
+			color: #e4e4e7;
+			min-height: 100vh;
+			display: flex;
+			align-items: center;
+			justify-content: center;
+			padding: 20px;
+		}
+		body::before {
+			content: '';
+			position: fixed;
+			top: 0;
+			left: 0;
+			right: 0;
+			bottom: 0;
+			background:
+				radial-gradient(ellipse at 20% 20%, rgba(96, 165, 250, 0.08) 0%, transparent 50%),
+				radial-gradient(ellipse at 80% 80%, rgba(139, 92, 246, 0.06) 0%, transparent 50%);
+			pointer-events: none;
+		}
+		.container {
+			max-width: 480px;
+			text-align: center;
+			position: relative;
+		}
+		.icon {
+			width: 80px;
+			height: 80px;
+			background: linear-gradient(135deg, rgba(96, 165, 250, 0.15), rgba(139, 92, 246, 0.12));
+			border-radius: 50%;
+			display: flex;
+			align-items: center;
+			justify-content: center;
+			margin: 0 auto 24px;
+		}
+		.icon svg {
+			width: 40px;
+			height: 40px;
+			color: #60a5fa;
+		}
+		h1 {
+			font-size: 1.75rem;
+			font-weight: 700;
+			background: linear-gradient(135deg, #60a5fa, #a78bfa);
+			-webkit-background-clip: text;
+			-webkit-text-fill-color: transparent;
+			background-clip: text;
+			margin-bottom: 16px;
+		}
+		p {
+			color: #71717a;
+			line-height: 1.6;
+			margin-bottom: 24px;
+		}
+		code {
+			background: rgba(96, 165, 250, 0.12);
+			padding: 3px 8px;
+			border-radius: 6px;
+			font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+			font-size: 0.9em;
+			color: #60a5fa;
+		}
+		.btn {
+			display: inline-block;
+			padding: 12px 24px;
+			background: linear-gradient(135deg, #3b82f6, #8b5cf6);
+			color: white;
+			text-decoration: none;
+			border-radius: 10px;
+			font-weight: 600;
+			transition: all 0.2s;
+			box-shadow: 0 4px 16px rgba(59, 130, 246, 0.3);
+		}
+		.btn:hover {
+			transform: translateY(-2px);
+			box-shadow: 0 6px 20px rgba(59, 130, 246, 0.4);
+		}
+		.footer {
+			margin-top: 40px;
+			color: #71717a;
+			font-size: 0.875rem;
+		}
+		.footer a {
+			color: #60a5fa;
+			text-decoration: none;
+		}
+		.footer a:hover {
+			text-decoration: underline;
+		}
+	</style>
+</head>
+<body>
+	<div class="container">
+		<div class="icon">
+			<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+				<circle cx="11" cy="11" r="8"></circle>
+				<line x1="21" y1="21" x2="16.65" y2="16.65"></line>
+				<line x1="8" y1="11" x2="14" y2="11"></line>
+			</svg>
+		</div>
+		<h1>Name Not Found</h1>
+		<p>The name <code>${escapeHtml(name)}</code> could not be resolved on the Sui network.</p>
+		<a href="https://suins.io" class="btn">Register on SuiNS</a>
+		<div class="footer">
+			<p><a href="https://sui.ski">← Back to sui.ski</a></p>
+		</div>
+	</div>
+</body>
+</html>`,
+		404,
+	)
+}

package/src/utils/rpc.ts

@@ -0,0 +1,25 @@
+import type { Env } from '../types'
+
+const DEFAULT_RPC_URLS: Record<Env['SUI_NETWORK'], string> = {
+	mainnet: 'https://fullnode.mainnet.sui.io:443',
+	testnet: 'https://fullnode.testnet.sui.io:443',
+	devnet: 'https://fullnode.devnet.sui.io:443',
+}
+
+export function getDefaultRpcUrl(network: Env['SUI_NETWORK']): string {
+	return DEFAULT_RPC_URLS[network] || DEFAULT_RPC_URLS.mainnet
+}
+
+export function ensureRpcEnv(env: Env): Env {
+	const configured = (env.SUI_RPC_URL ?? '').trim()
+	if (configured) {
+		if (configured === env.SUI_RPC_URL) {
+			return env
+		}
+		return { ...env, SUI_RPC_URL: configured }
+	}
+
+	const fallback = getDefaultRpcUrl(env.SUI_NETWORK)
+	console.warn(`[sui.ski] SUI_RPC_URL not configured. Falling back to public RPC ${fallback}`)
+	return { ...env, SUI_RPC_URL: fallback }
+}