ZK Social Login (Keyless Wallet)

Seed phrases are the #1 reason mainstream users bounce off crypto. ZK Social Login removes them: the user taps “Sign in with Google” and walks away with a real on-chain smart account on YouthChain — fully self-custodial, no key to write down or leak. Under the hood, a Groth16 zero-knowledge proof attests that a valid Google JWT authorizes a short-lived session key, without revealing the user’s sub, aud, or email. That session key signs ordinary transactions. It’s the same model as Sui zkLogin and Aptos Keyless.

Proof of concept — testnet only. Not audited. Do not use on mainnet. The full flow is validated end-to-end with a real production Google JWT, but the trusted-setup ceremony, salt-service custody, recovery, and audit are still open (see Security model).

How it works

Ephemeral session key

The app generates a throwaway session keypair and computes nonce = Poseidon(ephemeralPubkey, sessionExpiry, randomness).

Google OAuth

Google signs an id_token (JWT) that embeds that nonce — cryptographically binding the login to the session key.

Prove (server-side)

The zk-backend derives the user’s salt (HKDF, stateless) and produces a Groth16 proof that the JWT is validly signed and binds the ephemeral key — without revealing sub, aud, or email. This takes ~1–2 minutes on the first login.

Account & transact

The proof unlocks a deterministic CREATE2 smart account (address = f(iss, aud, sub, salt) — same Google account always maps to the same wallet). The session key signs transactions; the relayer submits them via execute (anti-replay, gas paid for you).

  App / RN (SDK)  ──ephemeral key + nonce──►  Google OAuth
                  ◄──────  id_token (JWT)  ──
        │  /salt · /prove · /relay
        ├──────────────────────────────►  zk-backend  (salt · prover · relayer · JWKS poller)
        │
        │  session key signs txs                       CREATE2 account · startSession · execute
        ▼                                                          ▼
  ┌────────────────────────────────────────────────────────────────────┐
  │  YouthChain testnet · chainId 7717                                   │
  │  JwksRegistry → ZkAccountFactory → ZkSocialAccount → Groth16Verifier │
  └────────────────────────────────────────────────────────────────────┘

What you integrate

You touch two things: the OAuth step, and the SDK. Everything else — salt derivation, proving, relaying, contracts — is encapsulated by the zk-backend and the SDK.

Install the SDK

npm install @yc/zk-login-core

Pure TypeScript, runs in Node and React Native, and carries only ethers + poseidon-lite (the heavy proving key stays server-side).

Wire Google Sign-In

Run native Google Sign-In (e.g. AppAuth / Expo AuthSession) with the nonce from the SDK. Google returns the id_token — that’s all the SDK needs from you.

One call: JWT → wallet → transaction

import { YouthWallet, generateEphemeralKey, buildNonce } from "@yc/zk-login-core";

// 1. Ephemeral session key + the OAuth nonce it binds to
const ephemeral = generateEphemeralKey();
const sessionExpiry = Math.floor(Date.now() / 1000) + 3600;
const jwtRandomness = 0x1234567890abcdefn;
const nonce = buildNonce(ephemeral.address, sessionExpiry, jwtRandomness);

// 2. Your OAuth step returns the id_token with that nonce
const jwt = await signInWithGoogle({ nonce });

// 3. One call: salt → Groth16 proof → CREATE2 account → session (~1–2 min first time)
const wallet = await YouthWallet.fromJwt({
  jwt,
  ephemeralPrivateKey: ephemeral.privateKey,
  sessionExpiry,
  jwtRandomness,
  backendUrl: "https://your-zk-backend.example",   // hosted zk-backend
  rpcUrl: "https://rpc.chain.youthapp.io",
});

// 4. Use it like any wallet — no seed phrase
console.log(wallet.address, await wallet.getBalance());
await wallet.send("0xRecipient…", 10n ** 16n);       // 0.01 YCE, gas paid by the relayer

SDK surface

The public API is the YouthWallet class plus a few protocol helpers.

Member	Description
`YouthWallet.fromJwt(params)`	Build a wallet from a Google JWT (does salt → proof → account → session).
`wallet.getBalance()`	Native balance of the smart account.
`wallet.send(to, amountWei)`	Transfer native YCE via the session key.
`wallet.call(to, data, value?)`	Arbitrary contract call via the session key.
`wallet.signMessage(message)`	Sign a message with the ephemeral key.
`generateEphemeralKey()` · `buildNonce(...)`	Create the session keypair and OAuth nonce.

The ~1–2 min proving time only happens once per session (the first login). Show a “Creating your wallet…” state. On-device proving (seconds, via Mopro) is a phase-2 optimization.

The backend dependency

The SDK requires a hosted zk-backend. The prover needs the ~588 MB Groth16 proving key, so it cannot run on-device. Point backendUrl at your deployment.

The zk-backend (Fastify) exposes:

Endpoint	Purpose
`POST /v1/salt`	Derive the user’s stateless salt (HKDF).
`POST /v1/prove`	Generate the Groth16 proof (snarkjs / rapidsnark).
`POST /v1/relay`	Relay `createAccount` / `startSession` / `execute` on-chain.
`GET /v1/account`	Resolve a user’s smart-account address + state.

A 4 vCPU / 8 GB host is enough for the MVP.

Testnet configuration

Deployed on the YouthChain EVM testnet.


Chain ID	`7717`
RPC	`https://rpc.chain.youthapp.io`
SDK	`@yc/zk-login-core`
Repository	`github.com/EduardoMelo00/yc-zk-login`
Google OAuth Client ID (`aud`)	`766934170697-544vsua9qpg0fvm0e4e2t8bneou5h73k.apps.googleusercontent.com`
ZkAccountFactory	`0xeA8d94123f55EFCed3C47c6B94E3A27733889101`
Groth16Verifier	`0x2bEA3833344507dA3019F46dd77a67b34738Bc67`
JwksRegistry	`0x3A989AB956Ead3AE653A0Da4d1B280829882169B`

The Client ID (aud) is part of the account address (f(iss, aud, sub, salt)). Changing it later changes every user’s address. Fine for the MVP; pin the canonical aud before production.

Security model

Honest about the trade-offs of a POC:

Trust boundary. Key theft requires both Google and the salt service to collude. Google alone never learns the salt; the backend alone has no JWT bound to the right nonce.
The relayer custodies nothing — it only pays gas.
JWK rotation is handled by an on-chain JwksRegistry (owner-gated) fed by a poller that tracks Google’s ~weekly RSA key rotation.
Ephemeral sessions. One proof authorizes one session key with a fixed expiry; the next login rotates it.

Open decisions before production: a real Groth16 trusted-setup ceremony, salt-service key custody, multi-provider account recovery, a security audit, and pinning the canonical aud.

Integration Guides

ZK Social Login (Keyless Wallet)

How it works

What you integrate

SDK surface

The backend dependency

Testnet configuration

Security model

Next steps

Blockchain integration

Mobile integration

​How it works

​What you integrate

​SDK surface

​The backend dependency

​Testnet configuration

​Security model

​Next steps

Blockchain integration

Mobile integration

How it works

What you integrate

SDK surface

The backend dependency

Testnet configuration

Security model

Next steps