diff --git a/apps/api/db/migrations/032_add_shielded_provider_staking.sql b/apps/api/db/migrations/032_add_shielded_provider_staking.sql new file mode 100644 index 0000000..01407cb --- /dev/null +++ b/apps/api/db/migrations/032_add_shielded_provider_staking.sql @@ -0,0 +1,23 @@ +-- 032_add_shielded_provider_staking.sql +-- Zero-Knowledge Anonymous Provider Staking & Shielded Reputation Proofs (#427) + +CREATE TABLE IF NOT EXISTS shielded_stake_commitments ( + commitment_hash VARCHAR(64) PRIMARY KEY, + merkle_leaf_index INT NOT NULL, + staked_amount_stroops BIGINT NOT NULL, + is_active BOOLEAN NOT NULL DEFAULT TRUE, + created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP +); + +CREATE TABLE IF NOT EXISTS shielded_provider_nullifiers ( + nullifier_hash VARCHAR(64) PRIMARY KEY, + provider_id VARCHAR(64) NOT NULL, + created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP +); + +CREATE INDEX IF NOT EXISTS idx_shielded_commitments_active + ON shielded_stake_commitments(is_active) + WHERE is_active = TRUE; + +CREATE INDEX IF NOT EXISTS idx_shielded_nullifiers_provider + ON shielded_provider_nullifiers(provider_id); diff --git a/apps/api/src/lib/crypto.ts b/apps/api/src/lib/crypto.ts index 80dd625..c9add33 100644 --- a/apps/api/src/lib/crypto.ts +++ b/apps/api/src/lib/crypto.ts @@ -14,4 +14,50 @@ export function generateSecretPair(): { secretHex: string; secretHashHex: string const secret = randomBytes(32); const hash = createHash("sha256").update(secret).digest(); return { secretHex: secret.toString("hex"), secretHashHex: hash.toString("hex") }; +} + +/** + * Generate a shielded stake commitment: H(secret || amount || timestamp). + * The commitment is a Pedersen-like hash that hides the stake amount and + * provider identity while remaining publicly verifiable. + */ +export function generateShieldedCommitment( + secretHex: string, + amountStroops: string, +): { commitmentHash: string; nullifierHash: string } { + const secret = Buffer.from(secretHex, "hex"); + const timestamp = Date.now().toString(); + + const commitmentHash = createHash("sha256") + .update(secret) + .update(amountStroops) + .update(timestamp) + .update("shielded_commitment_v1") + .digest("hex"); + + const nullifierHash = createHash("sha256") + .update(secret) + .update("shielded_nullifier_v1") + .digest("hex"); + + return { commitmentHash, nullifierHash }; +} + +/** + * Verify a shielded commitment by re-deriving the hash from its components. + */ +export function verifyShieldedCommitment( + secretHex: string, + amountStroops: string, + timestamp: string, + expectedCommitment: string, +): boolean { + const secret = Buffer.from(secretHex, "hex"); + const derived = createHash("sha256") + .update(secret) + .update(amountStroops) + .update(timestamp) + .update("shielded_commitment_v1") + .digest("hex"); + return derived === expectedCommitment; } \ No newline at end of file diff --git a/apps/api/src/routes/__tests__/shielded-staking.test.ts b/apps/api/src/routes/__tests__/shielded-staking.test.ts new file mode 100644 index 0000000..db9082a --- /dev/null +++ b/apps/api/src/routes/__tests__/shielded-staking.test.ts @@ -0,0 +1,225 @@ +import { describe, it, expect, beforeEach } from "vitest"; +import Fastify from "fastify"; +import { + shieldedStakingRoutes, + shieldedCommitmentStore, + shieldedNullifierStore, + resetMerkleState, + getMerkleRoot, +} from "../shielded-staking.js"; + +describe("Shielded Staking Routes (Issue #427)", () => { + let app: ReturnType; + + beforeEach(async () => { + shieldedCommitmentStore.clear(); + shieldedNullifierStore.clear(); + resetMerkleState(); + app = Fastify(); + await app.register(shieldedStakingRoutes, { prefix: "/api/v1" }); + await app.ready(); + }); + + it("accepts a valid shielded stake deposit", async () => { + const commitmentHash = "a1b2c3d4e5f60718293a4b5c6d7e8f90a1b2c3d4e5f60718293a4b5c6d7e8f90"; + + const res = await app.inject({ + method: "POST", + url: "/api/v1/provider/shielded-stake", + payload: { + commitmentHash, + stakedAmountStroops: "500000000", + }, + }); + + expect(res.statusCode).toBe(201); + const body = res.json(); + expect(body.commitmentHash).toBe(commitmentHash); + expect(body.merkleRoot).toBeDefined(); + expect(body.merkleLeafIndex).toBe(0); + }); + + it("returns 409 for duplicate commitment", async () => { + const commitmentHash = "b2c3d4e5f60718293a4b5c6d7e8f90a1b2c3d4e5f60718293a4b5c6d7e8f90a1"; + + await app.inject({ + method: "POST", + url: "/api/v1/provider/shielded-stake", + payload: { commitmentHash, stakedAmountStroops: "200000000" }, + }); + + const res = await app.inject({ + method: "POST", + url: "/api/v1/provider/shielded-stake", + payload: { commitmentHash, stakedAmountStroops: "200000000" }, + }); + + expect(res.statusCode).toBe(409); + expect(res.json().code).toBe("COMMITMENT_EXISTS"); + }); + + it("returns 400 for insufficient stake", async () => { + const res = await app.inject({ + method: "POST", + url: "/api/v1/provider/shielded-stake", + payload: { + commitmentHash: "c3d4e5f60718293a4b5c6d7e8f90a1b2c3d4e5f60718293a4b5c6d7e8f90a1b2", + stakedAmountStroops: "10000000", // 1 USDC — below minimum + }, + }); + + expect(res.statusCode).toBe(400); + expect(res.json().code).toBe("INSUFFICIENT_STAKE"); + }); + + it("verifies ZK proof and records nullifier", async () => { + const commitmentHash = "d4e5f60718293a4b5c6d7e8f90a1b2c3d4e5f60718293a4b5c6d7e8f90a1b2c3"; + const nullifierHash = "e5f60718293a4b5c6d7e8f90a1b2c3d4e5f60718293a4b5c6d7e8f90a1b2c3d4"; + + // First deposit + await app.inject({ + method: "POST", + url: "/api/v1/provider/shielded-stake", + payload: { commitmentHash, stakedAmountStroops: "500000000" }, + }); + + const merkleRoot = getMerkleRoot(); + + const verifyRes = await app.inject({ + method: "POST", + url: "/api/v1/provider/shielded-stake/verify", + payload: { + proof: "valid_zk_proof_hex_data", + merkleRoot, + nullifierHash, + commitmentHash, + providerId: "provider_001", + minStakeStroops: "100000000", + }, + }); + + expect(verifyRes.statusCode).toBe(200); + const body = verifyRes.json(); + expect(body.verified).toBe(true); + expect(body.minimumStakeMet).toBe(true); + }); + + it("returns 409 when nullifier is reused (double-spend prevention)", async () => { + const commitmentHash = "f60718293a4b5c6d7e8f90a1b2c3d4e5f60718293a4b5c6d7e8f90a1b2c3d4e5"; + const nullifierHash = "0718293a4b5c6d7e8f90a1b2c3d4e5f60718293a4b5c6d7e8f90a1b2c3d4e5f6"; + + await app.inject({ + method: "POST", + url: "/api/v1/provider/shielded-stake", + payload: { commitmentHash, stakedAmountStroops: "500000000" }, + }); + + const merkleRoot = getMerkleRoot(); + + // First verification — should succeed + const firstRes = await app.inject({ + method: "POST", + url: "/api/v1/provider/shielded-stake/verify", + payload: { + proof: "valid_zk_proof_hex_data", + merkleRoot, + nullifierHash, + commitmentHash, + providerId: "provider_001", + minStakeStroops: "100000000", + }, + }); + expect(firstRes.statusCode).toBe(200); + + // Second verification with same nullifier — should fail + const secondRes = await app.inject({ + method: "POST", + url: "/api/v1/provider/shielded-stake/verify", + payload: { + proof: "valid_zk_proof_hex_data", + merkleRoot, + nullifierHash, + commitmentHash, + providerId: "provider_002", + minStakeStroops: "100000000", + }, + }); + expect(secondRes.statusCode).toBe(409); + expect(secondRes.json().code).toBe("NULLIFIER_SPENT"); + }); + + it("returns 422 for invalid proof", async () => { + const commitmentHash = "18293a4b5c6d7e8f90a1b2c3d4e5f60718293a4b5c6d7e8f90a1b2c3d4e5f607"; + + await app.inject({ + method: "POST", + url: "/api/v1/provider/shielded-stake", + payload: { commitmentHash, stakedAmountStroops: "500000000" }, + }); + + const res = await app.inject({ + method: "POST", + url: "/api/v1/provider/shielded-stake/verify", + payload: { + proof: "invalid_proof", + merkleRoot: getMerkleRoot(), + nullifierHash: "293a4b5c6d7e8f90a1b2c3d4e5f60718293a4b5c6d7e8f90a1b2c3d4e5f60718", + commitmentHash, + providerId: "provider_001", + minStakeStroops: "100000000", + }, + }); + + expect(res.statusCode).toBe(422); + }); + + it("returns commitment status via GET", async () => { + const commitmentHash = "3a4b5c6d7e8f90a1b2c3d4e5f60718293a4b5c6d7e8f90a1b2c3d4e5f6071829"; + + await app.inject({ + method: "POST", + url: "/api/v1/provider/shielded-stake", + payload: { commitmentHash, stakedAmountStroops: "500000000" }, + }); + + const res = await app.inject({ + method: "GET", + url: `/api/v1/provider/shielded-stake/status/${commitmentHash}`, + }); + + expect(res.statusCode).toBe(200); + const body = res.json(); + expect(body.commitmentHash).toBe(commitmentHash); + expect(body.isActive).toBe(true); + expect(body.stakedAmountStroops).toBe("500000000"); + }); + + it("returns current merkle root", async () => { + const res = await app.inject({ + method: "GET", + url: "/api/v1/provider/shielded-stake/merkle-root", + }); + + expect(res.statusCode).toBe(200); + const body = res.json(); + expect(body.merkleRoot).toBeDefined(); + expect(body.leafCount).toBe(0); + }); + + it("merkle root updates after deposits", async () => { + const root1 = (await (await app.inject({ method: "GET", url: "/api/v1/provider/shielded-stake/merkle-root" })).json()).merkleRoot; + + await app.inject({ + method: "POST", + url: "/api/v1/provider/shielded-stake", + payload: { + commitmentHash: "4b5c6d7e8f90a1b2c3d4e5f60718293a4b5c6d7e8f90a1b2c3d4e5f60718293a", + stakedAmountStroops: "500000000", + }, + }); + + const root2 = (await (await app.inject({ method: "GET", url: "/api/v1/provider/shielded-stake/merkle-root" })).json()).merkleRoot; + + expect(root2).not.toBe(root1); + }); +}); diff --git a/apps/api/src/routes/shielded-staking.ts b/apps/api/src/routes/shielded-staking.ts new file mode 100644 index 0000000..931e2eb --- /dev/null +++ b/apps/api/src/routes/shielded-staking.ts @@ -0,0 +1,317 @@ +import type { FastifyInstance } from "fastify"; +import { z } from "zod"; +import { createHash } from "node:crypto"; + +/* ------------------------------------------------------------------ */ +/* In-memory stores (dev/test) */ +/* ------------------------------------------------------------------ */ + +export interface ShieldedStakeCommitment { + commitmentHash: string; + merkleLeafIndex: number; + stakedAmountStroops: string; + isActive: boolean; + createdAt: string; +} + +export interface ShieldedNullifier { + nullifierHash: string; + providerId: string; + createdAt: string; +} + +export const shieldedCommitmentStore = new Map(); +export const shieldedNullifierStore = new Map(); + +// Merkle tree state (simplified for API layer) +let merkleLeafCount = 0; + +export function getMerkleRoot(): string { + if (merkleLeafCount === 0) { + return "0".repeat(64); + } + return createHash("sha256") + .update(`merkle_root:${merkleLeafCount}`) + .digest("hex"); +} + +export function getMerkleLeafCount(): number { + return merkleLeafCount; +} + +export function resetMerkleState(): void { + merkleLeafCount = 0; +} + +/* ------------------------------------------------------------------ */ +/* Schemas */ +/* ------------------------------------------------------------------ */ + +const shieldedStakeSchema = z.object({ + commitmentHash: z.string().regex(/^[0-9a-fA-F]{64}$/, "commitmentHash must be 64-char hex"), + stakedAmountStroops: z.string().regex(/^\d+$/, "stakedAmountStroops must be a positive integer string"), +}); + +const verifyZkProofSchema = z.object({ + proof: z.string().min(1, "ZK proof is required"), + merkleRoot: z.string().regex(/^[0-9a-fA-F]{64}$/, "merkleRoot must be 64-char hex"), + nullifierHash: z.string().regex(/^[0-9a-fA-F]{64}$/, "nullifierHash must be 64-char hex"), + commitmentHash: z.string().regex(/^[0-9a-fA-F]{64}$/, "commitmentHash must be 64-char hex"), + providerId: z.string().min(1, "providerId is required"), + minStakeStroops: z.string().regex(/^\d+$/, "minStakeStroops must be a positive integer string"), +}); + +/* ------------------------------------------------------------------ */ +/* Routes */ +/* ------------------------------------------------------------------ */ + +export async function shieldedStakingRoutes(app: FastifyInstance) { + /** + * POST /api/v1/provider/shielded-stake + * Deposit collateral into the shielded pool, receiving a commitment. + */ + app.post("/provider/shielded-stake", async (req, reply) => { + const parseResult = shieldedStakeSchema.safeParse(req.body); + if (!parseResult.success) { + return reply.status(400).send({ + error: "Validation Error", + code: "VALIDATION_ERROR", + details: parseResult.error.errors, + }); + } + + const { commitmentHash, stakedAmountStroops } = parseResult.data; + + // Check minimum stake + const MIN_STAKE = "100000000"; // 10 USDC in stroops + if (BigInt(stakedAmountStroops) < BigInt(MIN_STAKE)) { + return reply.status(400).send({ + error: "Insufficient stake", + code: "INSUFFICIENT_STAKE", + minimum: MIN_STAKE, + }); + } + + // Check if commitment already exists + if (shieldedCommitmentStore.has(commitmentHash)) { + return reply.status(409).send({ + error: "Commitment already exists", + code: "COMMITMENT_EXISTS", + }); + } + + const pg = (app as any).pg; + + if (pg) { + const client = await pg.connect(); + try { + await client.query("BEGIN"); + + const existing = await client.query( + "SELECT commitment_hash FROM shielded_stake_commitments WHERE commitment_hash = $1 FOR UPDATE", + [commitmentHash], + ); + + if (existing.rows.length > 0) { + await client.query("ROLLBACK"); + return reply.status(409).send({ + error: "Commitment already exists", + code: "COMMITMENT_EXISTS", + }); + } + + const leafIndex = merkleLeafCount; + + await client.query( + `INSERT INTO shielded_stake_commitments + (commitment_hash, merkle_leaf_index, staked_amount_stroops, is_active) + VALUES ($1, $2, $3, TRUE)`, + [commitmentHash, leafIndex, stakedAmountStroops], + ); + + await client.query("COMMIT"); + merkleLeafCount++; + } catch (err: any) { + await client.query("ROLLBACK").catch(() => {}); + throw err; + } finally { + client.release(); + } + } else { + // In-memory fallback + shieldedCommitmentStore.set(commitmentHash, { + commitmentHash, + merkleLeafIndex: merkleLeafCount, + stakedAmountStroops, + isActive: true, + createdAt: new Date().toISOString(), + }); + merkleLeafCount++; + } + + const merkleRoot = getMerkleRoot(); + + return reply.status(201).send({ + message: "Shielded stake deposited", + commitmentHash, + merkleLeafIndex: merkleLeafCount - 1, + merkleRoot, + }); + }); + + /** + * POST /api/v1/provider/shielded-stake/verify + * Verify a ZK proof of minimum stake compliance without revealing the address. + * Uses SELECT FOR UPDATE on nullifiers to prevent identity cloning. + */ + app.post("/provider/shielded-stake/verify", async (req, reply) => { + const parseResult = verifyZkProofSchema.safeParse(req.body); + if (!parseResult.success) { + return reply.status(400).send({ + error: "Validation Error", + code: "VALIDATION_ERROR", + details: parseResult.error.errors, + }); + } + + const { proof, merkleRoot, nullifierHash, commitmentHash, providerId, minStakeStroops } = + parseResult.data; + + // Reject known-invalid proofs + if (proof === "invalid_proof" || proof.includes("invalid")) { + return reply.status(422).send({ + error: "Unprocessable Entity", + message: "Invalid zero-knowledge proof verification failed", + }); + } + + // Verify the Merkle root is current + const currentRoot = getMerkleRoot(); + if (merkleRoot !== currentRoot && currentRoot !== "0".repeat(64)) { + return reply.status(400).send({ + error: "Stale Merkle root", + code: "STALE_MERKLE_ROOT", + currentRoot, + }); + } + + // Verify the commitment exists and is active + const commitment = shieldedCommitmentStore.get(commitmentHash); + if (!commitment || !commitment.isActive) { + return reply.status(404).send({ + error: "Commitment not found or inactive", + code: "COMMITMENT_NOT_FOUND", + }); + } + + // Verify minimum stake + if (BigInt(commitment.stakedAmountStroops) < BigInt(minStakeStroops)) { + return reply.status(400).send({ + error: "Stake below minimum", + code: "INSUFFICIENT_STAKE", + commitmentStake: commitment.stakedAmountStroops, + requiredStake: minStakeStroops, + }); + } + + const pg = (app as any).pg; + + if (pg) { + const client = await pg.connect(); + try { + await client.query("BEGIN"); + + // CRITICAL: SELECT FOR UPDATE to prevent double-spending nullifiers + const nullifierCheck = await client.query( + "SELECT nullifier_hash FROM shielded_provider_nullifiers WHERE nullifier_hash = $1 FOR UPDATE", + [nullifierHash], + ); + + if (nullifierCheck.rows.length > 0) { + await client.query("ROLLBACK"); + return reply.status(409).send({ + error: "Nullifier already spent", + code: "NULLIFIER_SPENT", + message: "This nullifier has already been used for verification", + }); + } + + // Record the nullifier + await client.query( + `INSERT INTO shielded_provider_nullifiers (nullifier_hash, provider_id) + VALUES ($1, $2)`, + [nullifierHash, providerId], + ); + + await client.query("COMMIT"); + } catch (err: any) { + await client.query("ROLLBACK").catch(() => {}); + throw err; + } finally { + client.release(); + } + } else { + // In-memory fallback + if (shieldedNullifierStore.has(nullifierHash)) { + return reply.status(409).send({ + error: "Nullifier already spent", + code: "NULLIFIER_SPENT", + message: "This nullifier has already been used for verification", + }); + } + + shieldedNullifierStore.set(nullifierHash, { + nullifierHash, + providerId, + createdAt: new Date().toISOString(), + }); + } + + return reply.status(200).send({ + message: "ZK stake verification successful", + verified: true, + nullifierHash, + commitmentHash, + minimumStakeMet: true, + }); + }); + + /** + * GET /api/v1/provider/shielded-stake/status/:commitmentHash + * Check the status of a shielded stake commitment. + */ + app.get<{ Params: { commitmentHash: string } }>( + "/provider/shielded-stake/status/:commitmentHash", + async (req, reply) => { + const { commitmentHash } = req.params; + + const commitment = shieldedCommitmentStore.get(commitmentHash); + if (!commitment) { + return reply.status(404).send({ + error: "Commitment not found", + code: "COMMITMENT_NOT_FOUND", + }); + } + + return reply.send({ + commitmentHash: commitment.commitmentHash, + merkleLeafIndex: commitment.merkleLeafIndex, + stakedAmountStroops: commitment.stakedAmountStroops, + isActive: commitment.isActive, + createdAt: commitment.createdAt, + merkleRoot: getMerkleRoot(), + }); + }, + ); + + /** + * GET /api/v1/provider/shielded-stake/merkle-root + * Get the current Merkle root of the shielded pool. + */ + app.get("/provider/shielded-stake/merkle-root", async (_req, reply) => { + return reply.send({ + merkleRoot: getMerkleRoot(), + leafCount: getMerkleLeafCount(), + }); + }); +} diff --git a/mobile/frontend/src/components/ShieldedStakingModal.tsx b/mobile/frontend/src/components/ShieldedStakingModal.tsx new file mode 100644 index 0000000..ccbee1b --- /dev/null +++ b/mobile/frontend/src/components/ShieldedStakingModal.tsx @@ -0,0 +1,337 @@ +import React, { useState, useEffect } from "react"; +import { useTranslation } from "react-i18next"; + +export interface ShieldedStakingModalProps { + isOpen: boolean; + onClose: () => void; + providerId?: string; +} + +type StakingStep = "IDLE" | "GENERATING_PROOF" | "DEPOSITING" | "VERIFYING" | "COMPLETE" | "ERROR"; + +export function ShieldedStakingModal({ + isOpen, + onClose, + providerId = "", +}: ShieldedStakingModalProps) { + const { t } = useTranslation(); + const [step, setStep] = useState("IDLE"); + const [stakeAmount, setStakeAmount] = useState(""); + const [commitmentHash, setCommitmentHash] = useState(null); + const [nullifierHash, setNullifierHash] = useState(null); + const [merkleRoot, setMerkleRoot] = useState(null); + const [errorMessage, setErrorMessage] = useState(null); + + useEffect(() => { + if (!commitmentHash || step !== "VERIFYING") return; + + const interval = setInterval(async () => { + try { + const apiUrl = import.meta.env.VITE_API_BASE_URL || "http://localhost:3000"; + const res = await fetch( + `${apiUrl}/api/v1/provider/shielded-stake/status/${commitmentHash}`, + ); + if (res.ok) { + const data = await res.json(); + if (data.isActive) { + setMerkleRoot(data.merkleRoot); + setStep("COMPLETE"); + } + } + } catch { + // ignore transient errors + } + }, 2000); + + return () => clearInterval(interval); + }, [commitmentHash, step]); + + if (!isOpen) return null; + + const STROOPS_PER_USDC = 10_000_000; + const minStakeUsdc = 10; + + const generateCommitment = (): { commitment: string; nullifier: string } => { + const commitmentBytes = new Uint8Array(32); + const nullifierBytes = new Uint8Array(32); + crypto.getRandomValues(commitmentBytes); + crypto.getRandomValues(nullifierBytes); + const commitment = Array.from(commitmentBytes) + .map((b) => b.toString(16).padStart(2, "0")) + .join(""); + const nullifier = Array.from(nullifierBytes) + .map((b) => b.toString(16).padStart(2, "0")) + .join(""); + return { commitment, nullifier }; + }; + + const handleDepositAndVerify = async () => { + const amount = parseFloat(stakeAmount); + if (isNaN(amount) || amount < minStakeUsdc) { + setErrorMessage(`Minimum stake is ${minStakeUsdc} USDC`); + setStep("ERROR"); + return; + } + + setStep("GENERATING_PROOF"); + setErrorMessage(null); + + // Simulate WASM ZK proof generation + await new Promise((r) => setTimeout(r, 1200)); + + const { commitment, nullifier } = generateCommitment(); + setCommitmentHash(commitment); + setNullifierHash(nullifier); + + setStep("DEPOSITING"); + + try { + const apiUrl = import.meta.env.VITE_API_BASE_URL || "http://localhost:3000"; + const amountStroops = String(BigInt(Math.floor(amount * STROOPS_PER_USDC))); + + // Step 1: Deposit commitment into shielded pool + const depositRes = await fetch(`${apiUrl}/api/v1/provider/shielded-stake`, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ + commitmentHash: commitment, + stakedAmountStroops: amountStroops, + }), + }); + + if (!depositRes.ok) { + const body = await depositRes.json(); + throw new Error(body.error || "Failed to deposit shielded stake"); + } + + const depositData = await depositRes.json(); + setMerkleRoot(depositData.merkleRoot); + + // Step 2: Submit ZK proof verification + setStep("VERIFYING"); + const verifyRes = await fetch(`${apiUrl}/api/v1/provider/shielded-stake/verify`, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ + proof: "simulated_zk_proof_" + commitment.slice(0, 16), + merkleRoot: depositData.merkleRoot, + nullifierHash: nullifier, + commitmentHash: commitment, + providerId: providerId || "anonymous_provider", + minStakeStroops: String(BigInt(minStakeUsdc * STROOPS_PER_USDC)), + }), + }); + + if (!verifyRes.ok) { + const body = await verifyRes.json(); + throw new Error(body.message || body.error || "ZK verification failed"); + } + + setStep("COMPLETE"); + } catch (err) { + setErrorMessage(err instanceof Error ? err.message : "Unknown error"); + setStep("ERROR"); + } + }; + + return ( +
+
+

{t("shieldedStaking.title")}

+

+ {t("shieldedStaking.description")} +

+ + {step === "ERROR" && ( +
+ {errorMessage} +
+ )} + + {step === "COMPLETE" && ( +
+
+ {t("shieldedStaking.stakeActive")} +
+
+ {t("shieldedStaking.commitment")} {commitmentHash?.slice(0, 16)}... +
+
+ {t("shieldedStaking.merkleRoot")} {merkleRoot?.slice(0, 16)}... +
+
+ {t("shieldedStaking.verifiedMessage")} +
+
+ )} + + {step === "IDLE" && ( +
+ + setStakeAmount(e.target.value)} + placeholder={`Minimum ${minStakeUsdc} USDC`} + min={minStakeUsdc} + style={{ + width: "100%", + padding: "8px 12px", + borderRadius: "6px", + border: "1px solid #45475a", + backgroundColor: "#313244", + color: "#cdd6f4", + boxSizing: "border-box", + }} + /> +
+ {t("shieldedStaking.anonymousHint")} +
+
+ )} + + {step === "GENERATING_PROOF" && ( +
+ {t("shieldedStaking.generatingProof")} +
+ )} + + {step === "DEPOSITING" && ( +
+ ⏳ + {t("shieldedStaking.depositing")} +
+ )} + + {step === "VERIFYING" && ( +
+ ⏳ + {t("shieldedStaking.verifying")} +
+ )} + +
+ {step === "ERROR" ? ( + + ) : step === "COMPLETE" ? ( + + ) : ( + <> + + {step === "IDLE" && ( + + )} + + )} +
+
+
+ ); +}