├── .nvmrc
├── .prettierignore
├── .eslintrc.json
├── components
    ├── ClaimButton
    │   ├── index.tsx
    │   ├── _GoogleReCaptchaClaimButton.tsx
    │   ├── ClaimButton.tsx
    │   └── _BaseClaimButton.tsx
    ├── Content.tsx
    ├── Layout.tsx
    ├── Alert.tsx
    ├── Item.tsx
    ├── RoundedBox.tsx
    ├── OpenSourceMemo.tsx
    ├── CaptchaProvider.tsx
    ├── Footer.tsx
    └── Header.tsx
├── screenshot.png
├── .yarnrc.yml
├── .prettierrc
├── interfaces
    ├── Captcha.ts
    ├── Nonce.ts
    ├── TransactionHistory.ts
    ├── Blockchain.ts
    └── Response.ts
├── errors
    ├── InvalidCaptcha.ts
    ├── NonEmptyWalletError.ts
    ├── NonceExpiredError.ts
    ├── SignatureMismatchError.ts
    ├── InsufficientFundsError.ts
    ├── IpLimitExceeded.ts
    └── WalletAlreadyFunded.ts
├── next.config.js
├── window.d.ts
├── consts
    ├── wallets.ts
    └── env.ts
├── next-env.d.ts
├── public
    └── eth.svg
├── utils
    ├── ethAddressUtils.ts
    ├── textMessage.ts
    ├── bootstrapCaptcha.ts
    ├── bootstrapEthereum.ts
    └── bootstrapTransactionHistory.ts
├── .editorconfig
├── hooks
    ├── hasMetamask.ts
    └── useWalletClassification.ts
├── _scripts
    └── createWallet.ts
├── services
    ├── HttpClient.ts
    ├── GoogleReCaptcha.ts
    ├── WalletClassification.ts
    ├── TimestampNonce.ts
    ├── IpTransactionHistory.ts
    ├── EtherscanTransactionHistory.ts
    ├── RedisTransactionHistory.ts
    └── Ethereum.ts
├── pages
    ├── _document.tsx
    ├── api
    │   ├── nonce.ts
    │   └── claim.ts
    ├── _app.tsx
    └── index.tsx
├── tsconfig.json
├── .env
├── .gitignore
├── LICENSE
├── package.json
└── README.md


/.nvmrc:
--------------------------------------------------------------------------------
1 | 16
2 | 


--------------------------------------------------------------------------------
/.prettierignore:
--------------------------------------------------------------------------------
1 | .next/
2 | 


--------------------------------------------------------------------------------
/.eslintrc.json:
--------------------------------------------------------------------------------
1 | {
2 |   "extends": "next/core-web-vitals"
3 | }
4 | 


--------------------------------------------------------------------------------
/components/ClaimButton/index.tsx:
--------------------------------------------------------------------------------
1 | export { ClaimButton } from "./ClaimButton"
2 | 


--------------------------------------------------------------------------------
/screenshot.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mateuszsokola/eth-faucet/main/screenshot.png


--------------------------------------------------------------------------------
/.yarnrc.yml:
--------------------------------------------------------------------------------
1 | nodeLinker: node-modules
2 | 
3 | yarnPath: .yarn/releases/yarn-3.2.2.cjs
4 | 


--------------------------------------------------------------------------------
/.prettierrc:
--------------------------------------------------------------------------------
1 | {
2 |   "semi": false,
3 |   "printWidth": 120,
4 |   "trailingComma": "none"
5 | }
6 | 


--------------------------------------------------------------------------------
/interfaces/Captcha.ts:
--------------------------------------------------------------------------------
1 | export interface Captcha {
2 |   verifyCaptcha(token: string): Promise<boolean>
3 | }
4 | 


--------------------------------------------------------------------------------
/components/Content.tsx:
--------------------------------------------------------------------------------
1 | import { styled } from "@mui/material"
2 | 
3 | export const Content = styled("div")(() => ({
4 |   flex: 1
5 | }))
6 | 


--------------------------------------------------------------------------------
/errors/InvalidCaptcha.ts:
--------------------------------------------------------------------------------
1 | export class InvalidCaptcha extends Error {
2 |   code = 403
3 |   message = "Provided captcha was invalid."
4 | }
5 | 


--------------------------------------------------------------------------------
/errors/NonEmptyWalletError.ts:
--------------------------------------------------------------------------------
1 | export class NonEmptyWalletError extends Error {
2 |   code = 403
3 |   message = "Your wallet has enough Görli ETH."
4 | }
5 | 


--------------------------------------------------------------------------------
/errors/NonceExpiredError.ts:
--------------------------------------------------------------------------------
1 | export class NonceExpiredError extends Error {
2 |   code = 401
3 |   message = "Your nonce has expired. Try again."
4 | }
5 | 


--------------------------------------------------------------------------------
/next.config.js:
--------------------------------------------------------------------------------
1 | /** @type {import('next').NextConfig} */
2 | const nextConfig = {
3 |   reactStrictMode: true
4 | }
5 | 
6 | module.exports = nextConfig
7 | 


--------------------------------------------------------------------------------
/errors/SignatureMismatchError.ts:
--------------------------------------------------------------------------------
1 | export class SignatureMismatchError extends Error {
2 |   code = 401
3 |   message = "The message has not been signed by your wallet"
4 | }
5 | 


--------------------------------------------------------------------------------
/errors/InsufficientFundsError.ts:
--------------------------------------------------------------------------------
1 | export class InsufficientFundsError extends Error {
2 |   code = 500
3 |   message = "Our wallet run out of Görli ETH. Try again later."
4 | }
5 | 


--------------------------------------------------------------------------------
/window.d.ts:
--------------------------------------------------------------------------------
1 | import { MetaMaskInpageProvider } from "@metamask/providers"
2 | 
3 | declare global {
4 |   interface Window {
5 |     ethereum: MetaMaskInpageProvider
6 |   }
7 | }
8 | 


--------------------------------------------------------------------------------
/consts/wallets.ts:
--------------------------------------------------------------------------------
1 | import { normalizeAddress } from "../utils/ethAddressUtils"
2 | 
3 | const rawPrivilegedWallets: string[] = []
4 | 
5 | export const privilegedWallets = rawPrivilegedWallets.map(normalizeAddress)
6 | 


--------------------------------------------------------------------------------
/interfaces/Nonce.ts:
--------------------------------------------------------------------------------
1 | export interface NonceResponseBody {
2 |   nonce: string
3 | }
4 | 
5 | export interface Nonce {
6 |   generate: () => Promise<string>
7 |   verify: (nonce: string) => Promise<boolean>
8 | }
9 | 


--------------------------------------------------------------------------------
/errors/IpLimitExceeded.ts:
--------------------------------------------------------------------------------
1 | export class IpLimitExceeded extends Error {
2 |   code = 403
3 |   message = "Your IP address has received Görli ETH from us already. You need to wait 24 hours to claim tokens again."
4 | }
5 | 


--------------------------------------------------------------------------------
/errors/WalletAlreadyFunded.ts:
--------------------------------------------------------------------------------
1 | export class WalletAlreadyFunded extends Error {
2 |   code = 403
3 |   message = "Your wallet has received Görli ETH from us already. You need to wait 24 hours to claim tokens again."
4 | }
5 | 


--------------------------------------------------------------------------------
/interfaces/TransactionHistory.ts:
--------------------------------------------------------------------------------
1 | export interface TransactionHistory {
2 |   hasReceivedTokens: (address: string, minLayover?: number) => Promise<boolean>
3 |   recordTransaction: (address: string) => Promise<void>
4 | }
5 | 


--------------------------------------------------------------------------------
/next-env.d.ts:
--------------------------------------------------------------------------------
1 | /// <reference types="next" />
2 | /// <reference types="next/image-types/global" />
3 | 
4 | // NOTE: This file should not be edited
5 | // see https://nextjs.org/docs/basic-features/typescript for more information.
6 | 


--------------------------------------------------------------------------------
/components/Layout.tsx:
--------------------------------------------------------------------------------
1 | import { styled } from "@mui/material"
2 | 
3 | export const Layout = styled("div")(() => ({
4 |   background: "rgb(242, 244, 246)",
5 |   display: "flex",
6 |   minHeight: "100vh",
7 |   flexDirection: "column"
8 | }))
9 | 


--------------------------------------------------------------------------------
/public/eth.svg:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" ?><svg role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title/><path d="M11.944 17.97L4.58 13.62 11.943 24l7.37-10.38-7.372 4.35h.003zM12.056 0L4.69 12.223l7.365 4.354 7.365-4.35L12.056 0z"/></svg>


--------------------------------------------------------------------------------
/utils/ethAddressUtils.ts:
--------------------------------------------------------------------------------
1 | export const normalizeAddress = (address: string) => {
2 |   return address.toLocaleLowerCase()
3 | }
4 | 
5 | export const compareAddresses = (a: string, b: string) => {
6 |   return normalizeAddress(a) === normalizeAddress(b)
7 | }
8 | 


--------------------------------------------------------------------------------
/interfaces/Blockchain.ts:
--------------------------------------------------------------------------------
1 | export interface Blockchain {
2 |   fundWallet: (address: string) => Promise<void>
3 |   verifyMessage: (address: string, message: string, signature: string) => Promise<boolean>
4 |   isEligible: (address: string) => Promise<void>
5 | }
6 | 


--------------------------------------------------------------------------------
/interfaces/Response.ts:
--------------------------------------------------------------------------------
 1 | export interface SuccessResponse<K = undefined> {
 2 |   status: "ok"
 3 |   data?: K
 4 | }
 5 | 
 6 | export interface ErrorResponse {
 7 |   status: "error"
 8 |   message: string
 9 | }
10 | 
11 | export type DefaultResponse<K = undefined> = SuccessResponse<K> | ErrorResponse
12 | 


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
 1 | # Editor configuration, see http://editorconfig.org
 2 | root = true
 3 | 
 4 | [*]
 5 | charset = utf-8
 6 | indent_style = space
 7 | indent_size = 2
 8 | insert_final_newline = true
 9 | trim_trailing_whitespace = true
10 | 
11 | [*.md]
12 | max_line_length = off
13 | trim_trailing_whitespace = false
14 | 


--------------------------------------------------------------------------------
/components/Alert.tsx:
--------------------------------------------------------------------------------
1 | import { Alert as MuiAlert, AlertProps, styled } from "@mui/material"
2 | 
3 | const StyledAlert = styled(MuiAlert)(({ theme }) => ({
4 |   marginTop: theme.spacing(2)
5 | }))
6 | 
7 | export const Alert = ({ children, severity }: AlertProps) => <StyledAlert severity={severity}>{children}</StyledAlert>
8 | 


--------------------------------------------------------------------------------
/components/Item.tsx:
--------------------------------------------------------------------------------
 1 | import { styled } from "@mui/material"
 2 | 
 3 | export const Item = styled("div")(({ theme }) => ({
 4 |   display: "flex",
 5 |   margin: `${theme.spacing(1)} 0`,
 6 |   ...theme.typography.body2,
 7 |   "& > span": {
 8 |     flex: 1
 9 |   },
10 |   "& > span:last-child": {
11 |     textAlign: "right"
12 |   }
13 | }))
14 | 


--------------------------------------------------------------------------------
/utils/textMessage.ts:
--------------------------------------------------------------------------------
 1 | export const messageTemplate = (nonce: string = "") =>
 2 |   `Please sign this message to confirm you own this wallet.\n\n\nNonce: ${nonce}`
 3 | 
 4 | export const extractNonceFromMessage = (message: string) => {
 5 |   const truncate = messageTemplate()
 6 |   const nonce = message.replace(truncate, "")
 7 | 
 8 |   return nonce.trim()
 9 | }
10 | 


--------------------------------------------------------------------------------
/hooks/hasMetamask.ts:
--------------------------------------------------------------------------------
 1 | import { useEffect, useState } from "react"
 2 | 
 3 | export const hasMetamask = () => {
 4 |   const [installed, setInstalled] = useState(false)
 5 | 
 6 |   useEffect(() => {
 7 |     if (typeof window !== "undefined" && typeof window.ethereum !== "undefined") {
 8 |       setInstalled(true)
 9 |     }
10 |   }, [installed])
11 | 
12 |   return installed
13 | }
14 | 


--------------------------------------------------------------------------------
/components/RoundedBox.tsx:
--------------------------------------------------------------------------------
 1 | import { Box, styled } from "@mui/material"
 2 | 
 3 | export const RoundedBox = styled(Box)(({ theme }) => ({
 4 |   background: theme.palette.background.default,
 5 |   borderRadius: theme.shape.borderRadius,
 6 |   margin: `${theme.spacing(2)} auto`,
 7 |   padding: theme.spacing(2),
 8 |   minWidth: theme.spacing(40),
 9 |   maxWidth: theme.spacing(70),
10 |   width: "100%",
11 |   ...theme.typography.body2
12 | }))
13 | 


--------------------------------------------------------------------------------
/utils/bootstrapCaptcha.ts:
--------------------------------------------------------------------------------
 1 | import { GoogleReCaptcha } from "../services/GoogleReCaptcha"
 2 | 
 3 | export const bootstrapCaptcha = () => {
 4 |   switch (process.env.NEXT_PUBLIC_ENABLE_CAPTCHA) {
 5 |     case "recaptcha_v3": {
 6 |       const apiKey = process.env.RECAPTCHA_SECRET_KEY as string
 7 |       const captchaService = new GoogleReCaptcha(apiKey)
 8 | 
 9 |       return captchaService
10 |     }
11 |     default: {
12 |       return undefined
13 |     }
14 |   }
15 | }
16 | 


--------------------------------------------------------------------------------
/_scripts/createWallet.ts:
--------------------------------------------------------------------------------
 1 | import { ethers } from "ethers"
 2 | 
 3 | const run = async () => {
 4 |   const wallet = ethers.Wallet.createRandom()
 5 | 
 6 |   console.log("Your new Ethereum wallet credentials:")
 7 |   console.log("\n\n")
 8 |   console.log(`export WALLET_ADDRESS=${wallet.address}\n`)
 9 |   console.log(`export WALLET_MNEMONIC_PHRASE=${wallet.mnemonic.phrase}\n`)
10 |   console.log(`export WALLET_PRIVATE_KEY=${wallet.privateKey}\n`)
11 |   console.log("\n\n")
12 | }
13 | 
14 | run()
15 | 


--------------------------------------------------------------------------------
/services/HttpClient.ts:
--------------------------------------------------------------------------------
 1 | import axios from "axios"
 2 | 
 3 | const httpClient = axios.create({ baseURL: "/api" })
 4 | 
 5 | export const retrieveNonce = async () => {
 6 |   const response = await httpClient.get("/nonce").then(({ data }) => data)
 7 | 
 8 |   return response.data.nonce
 9 | }
10 | 
11 | export const claimTokens = async (address: string, message: string, signature: string, captcha: string) => {
12 |   return await httpClient.post("/claim", { address, message, signature, captcha }).then(({ data }) => data)
13 | }
14 | 


--------------------------------------------------------------------------------
/hooks/useWalletClassification.ts:
--------------------------------------------------------------------------------
 1 | import { useCallback } from "react"
 2 | import { privilegedWallets } from "../consts/wallets"
 3 | import { WalletClassification } from "../services/WalletClassification"
 4 | 
 5 | export const useWalletClassification = () => {
 6 |   const classificationService = new WalletClassification(privilegedWallets)
 7 | 
 8 |   const retriveAmount = useCallback((address: string | undefined) => {
 9 |     return classificationService.retrieveAmount(address)
10 |   }, [])
11 | 
12 |   return [retriveAmount]
13 | }
14 | 


--------------------------------------------------------------------------------
/components/OpenSourceMemo.tsx:
--------------------------------------------------------------------------------
 1 | import { Link as MuiLink } from "@mui/material"
 2 | import Link from "next/link"
 3 | import { RoundedBox } from "./RoundedBox"
 4 | 
 5 | export const OpenSourceMemo = () => (
 6 |   <RoundedBox>
 7 |     <b>Would you like to build similar app?</b> Feel free to browse the&nbsp;
 8 |     <Link href="https://github.com/mateuszsokola/eth-faucet" passHref>
 9 |       <MuiLink target="_blank" rel="noopener referrer">
10 |         source code on Github
11 |       </MuiLink>
12 |     </Link>
13 |   </RoundedBox>
14 | )
15 | 


--------------------------------------------------------------------------------
/pages/_document.tsx:
--------------------------------------------------------------------------------
 1 | import { Html, Head, Main, NextScript } from "next/document"
 2 | 
 3 | const Document = () => (
 4 |   <Html>
 5 |     <Head>
 6 |       <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Roboto:300,400,500,700&display=swap" />
 7 |       <link rel="stylesheet" href="https://fonts.googleapis.com/icon?family=Material+Icons" />
 8 |       <link rel="icon" href="/eth.svg" />
 9 |     </Head>
10 |     <body>
11 |       <Main />
12 |       <p>IP: </p>
13 |       <NextScript />
14 |     </body>
15 |   </Html>
16 | )
17 | 
18 | export default Document
19 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "target": "es5",
 4 |     "lib": ["dom", "dom.iterable", "esnext"],
 5 |     "allowJs": true,
 6 |     "skipLibCheck": true,
 7 |     "strict": true,
 8 |     "forceConsistentCasingInFileNames": true,
 9 |     "noEmit": true,
10 |     "esModuleInterop": true,
11 |     "module": "commonjs",
12 |     "moduleResolution": "node",
13 |     "resolveJsonModule": true,
14 |     "isolatedModules": true,
15 |     "jsx": "preserve",
16 |     "incremental": true
17 |   },
18 |   "include": ["next-env.d.ts", "window.d.ts", "**/*.ts", "**/*.tsx"],
19 |   "exclude": ["node_modules"]
20 | }
21 | 


--------------------------------------------------------------------------------
/services/GoogleReCaptcha.ts:
--------------------------------------------------------------------------------
 1 | import axios from "axios"
 2 | import { InvalidCaptcha } from "../errors/InvalidCaptcha"
 3 | import { Captcha } from "../interfaces/Captcha"
 4 | 
 5 | export class GoogleReCaptcha implements Captcha {
 6 |   constructor(private readonly apiKey: string) {}
 7 | 
 8 |   async verifyCaptcha(token: string) {
 9 |     const url = `https://www.google.com/recaptcha/api/siteverify?secret=${this.apiKey}&response=${token}`
10 |     const response = await axios.post(url).then((response) => response.data)
11 | 
12 |     if (response.success === true) {
13 |       return true
14 |     }
15 | 
16 |     throw new InvalidCaptcha()
17 |   }
18 | }
19 | 


--------------------------------------------------------------------------------
/.env:
--------------------------------------------------------------------------------
 1 | # Create a copy of this file and replace with correct values. Find more details in README.md
 2 | WALLET_PRIVATE_KEY=0x0000000000000000000000000000000000000000000000000000000000000000
 3 | NEXT_PUBLIC_ETH_API_URL=https://goerli.infura.io/v3/00000000000000000000000000000000
 4 | NEXT_PUBLIC_DEFAULT_WALLET_ETH_AMOUNT=0.25
 5 | NEXT_PUBLIC_PRIVILEGED_WALLET_ETH_AMOUNT=1
 6 | ENABLE_TRANSACTION_CHECKS=none
 7 | ETHERSCAN_API_KEY=00000000000000000000000000000000
 8 | REDIS_URL=rediss://user:password@redis:6379
 9 | NEXT_PUBLIC_ENABLE_CAPTCHA=none
10 | NEXT_PUBLIC_RECAPTCHA_SITE_KEY=0000000000000000000000000000000000000000
11 | RECAPTCHA_SECRET_KEY=0000000000000000000000000000000000000000
12 | 


--------------------------------------------------------------------------------
/pages/api/nonce.ts:
--------------------------------------------------------------------------------
 1 | import type { NextApiRequest, NextApiResponse } from "next"
 2 | import { NonceResponseBody } from "../../interfaces/Nonce"
 3 | import { DefaultResponse } from "../../interfaces/Response"
 4 | import { TimestampNonce } from "../../services/TimestampNonce"
 5 | 
 6 | type NonceResponse = DefaultResponse<NonceResponseBody>
 7 | 
 8 | const handler = async (req: NextApiRequest, res: NextApiResponse<NonceResponse>) => {
 9 |   const nonceService = new TimestampNonce()
10 |   const nonce = await nonceService.generate()
11 | 
12 |   res.status(200).json({
13 |     status: "ok",
14 |     data: {
15 |       nonce
16 |     }
17 |   })
18 | }
19 | 
20 | export default handler
21 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
 2 | 
 3 | # yarn@3.x.x
 4 | .yarn/*
 5 | !.yarn/patches
 6 | !.yarn/releases
 7 | !.yarn/plugins
 8 | !.yarn/sdks
 9 | !.yarn/versions
10 | .pnp.*
11 | 
12 | # dependencies
13 | /node_modules
14 | /.pnp
15 | .pnp.js
16 | 
17 | # testing
18 | /coverage
19 | 
20 | # next.js
21 | /.next/
22 | /out/
23 | 
24 | # production
25 | /build
26 | 
27 | # misc
28 | .DS_Store
29 | *.pem
30 | 
31 | # debug
32 | npm-debug.log*
33 | yarn-debug.log*
34 | yarn-error.log*
35 | .pnpm-debug.log*
36 | 
37 | # local env files
38 | .env*.local
39 | 
40 | # vercel
41 | .vercel
42 | 
43 | # typescript
44 | *.tsbuildinfo
45 | 


--------------------------------------------------------------------------------
/components/CaptchaProvider.tsx:
--------------------------------------------------------------------------------
 1 | import { GoogleReCaptchaProvider } from "react-google-recaptcha-v3"
 2 | 
 3 | type CaptchaProviderProps = {
 4 |   children: JSX.Element
 5 | }
 6 | 
 7 | export const CaptchaProvider = ({ children }: CaptchaProviderProps) => {
 8 |   switch (process.env.NEXT_PUBLIC_ENABLE_CAPTCHA) {
 9 |     case "recaptcha_v3": {
10 |       const siteApiKey = process.env.NEXT_PUBLIC_RECAPTCHA_SITE_KEY as string
11 | 
12 |       return (
13 |         <GoogleReCaptchaProvider reCaptchaKey={siteApiKey} language="en">
14 |           {children}
15 |         </GoogleReCaptchaProvider>
16 |       )
17 |     }
18 |     default: {
19 |       return children
20 |     }
21 |   }
22 | }
23 | 


--------------------------------------------------------------------------------
/services/WalletClassification.ts:
--------------------------------------------------------------------------------
 1 | import { defaultWalletWeiAmount, privilegedWalletWeiAmount } from "../consts/env"
 2 | import { normalizeAddress } from "../utils/ethAddressUtils"
 3 | 
 4 | export class WalletClassification {
 5 |   constructor(private readonly addresses: string[] = []) {}
 6 | 
 7 |   isPrivileged(address: string | undefined) {
 8 |     const normalizedAddress = normalizeAddress(address || "")
 9 |     return this.addresses.includes(normalizedAddress)
10 |   }
11 | 
12 |   retrieveAmount(address: string | undefined) {
13 |     if (this.isPrivileged(address)) {
14 |       return privilegedWalletWeiAmount
15 |     }
16 | 
17 |     return defaultWalletWeiAmount
18 |   }
19 | }
20 | 


--------------------------------------------------------------------------------
/components/ClaimButton/_GoogleReCaptchaClaimButton.tsx:
--------------------------------------------------------------------------------
 1 | import { useGoogleReCaptcha } from "react-google-recaptcha-v3"
 2 | import { BaseClaimButton } from "./_BaseClaimButton"
 3 | 
 4 | type GoogleReCaptchaClaimButtonProps = {
 5 |   onSuccess: () => void
 6 |   onError: (message: string) => void
 7 | }
 8 | 
 9 | export const GoogleReCaptchaClaimButton = (props: GoogleReCaptchaClaimButtonProps) => {
10 |   const { executeRecaptcha } = useGoogleReCaptcha()
11 | 
12 |   const retrieveCaptcha = async () => {
13 |     if (!executeRecaptcha) {
14 |       throw new Error("Couldn’t generate captcha")
15 |     }
16 | 
17 |     return await executeRecaptcha("claim")
18 |   }
19 | 
20 |   return <BaseClaimButton {...props} retrieveCaptcha={retrieveCaptcha} />
21 | }
22 | 


--------------------------------------------------------------------------------
/components/ClaimButton/ClaimButton.tsx:
--------------------------------------------------------------------------------
 1 | import { BaseClaimButton } from "./_BaseClaimButton"
 2 | import { GoogleReCaptchaClaimButton } from "./_GoogleReCaptchaClaimButton"
 3 | 
 4 | type ClaimButtonProps = {
 5 |   onSuccess: () => void
 6 |   onError: (message: string) => void
 7 | }
 8 | 
 9 | export const ClaimButton = (props: ClaimButtonProps) => {
10 |   switch (process.env.NEXT_PUBLIC_ENABLE_CAPTCHA) {
11 |     case "recaptcha_v3": {
12 |       return <GoogleReCaptchaClaimButton {...props} />
13 |     }
14 |     default: {
15 |       const retrieveCaptcha = async (): Promise<string> => {
16 |         return new Promise((resolve) => resolve(""))
17 |       }
18 | 
19 |       return <BaseClaimButton {...props} retrieveCaptcha={retrieveCaptcha} />
20 |     }
21 |   }
22 | }
23 | 


--------------------------------------------------------------------------------
/consts/env.ts:
--------------------------------------------------------------------------------
 1 | export const defaultWalletEthAmount =
 2 |   process.env.NEXT_PUBLIC_DEFAULT_WALLET_ETH_AMOUNT !== undefined
 3 |     ? parseFloat(process.env.NEXT_PUBLIC_DEFAULT_WALLET_ETH_AMOUNT)
 4 |     : 0.25
 5 | 
 6 | export const privilegedWalletEthAmount =
 7 |   process.env.NEXT_PUBLIC_PRIVILEGED_WALLET_ETH_AMOUNT !== undefined
 8 |     ? parseFloat(process.env.NEXT_PUBLIC_PRIVILEGED_WALLET_ETH_AMOUNT)
 9 |     : 1
10 | 
11 | export const defaultWalletWeiAmount = BigInt(defaultWalletEthAmount * 10 ** 18)
12 | 
13 | export const privilegedWalletWeiAmount = BigInt(privilegedWalletEthAmount * 10 ** 18)
14 | 
15 | export const pollingInterval = 20_000
16 | 
17 | export const defaultMillisecondsLayover = 86400000 // 24h
18 | 
19 | export const defaultBlockLayover = 5400 // ~24h, 16s per block on Görli
20 | 


--------------------------------------------------------------------------------
/services/TimestampNonce.ts:
--------------------------------------------------------------------------------
 1 | import { Nonce } from "../interfaces/Nonce"
 2 | 
 3 | const timeTolerance = 600 // 10 minutes
 4 | 
 5 | export class TimestampNonce implements Nonce {
 6 |   constructor() {}
 7 | 
 8 |   async verify(input: string) {
 9 |     return new Promise<boolean>((resolve, reject) => {
10 |       const userTimestamp = parseInt(input)
11 |       const currentTimestamp = Math.floor(new Date().getTime() / 1000)
12 | 
13 |       if (currentTimestamp <= userTimestamp + timeTolerance) {
14 |         return resolve(true)
15 |       }
16 | 
17 |       return reject(false)
18 |     })
19 |   }
20 | 
21 |   async generate() {
22 |     return new Promise<string>((resolve) => {
23 |       const timestamp = Math.floor(new Date().getTime() / 1000)
24 |       resolve(`${timestamp}`)
25 |     })
26 |   }
27 | }
28 | 


--------------------------------------------------------------------------------
/components/Footer.tsx:
--------------------------------------------------------------------------------
 1 | import { Link as MuiLink, styled } from "@mui/material"
 2 | import Link from "next/link"
 3 | 
 4 | const FooterDiv = styled("footer")(({ theme }) => ({
 5 |   margin: `${theme.spacing(1)} auto`,
 6 |   padding: theme.spacing(4),
 7 |   minWidth: theme.spacing(40),
 8 |   maxWidth: theme.spacing(70),
 9 |   width: "100%",
10 |   textAlign: "center",
11 |   color: theme.palette.text.secondary,
12 |   ...theme.typography.body2
13 | }))
14 | 
15 | export const Footer = () => {
16 |   return (
17 |     <FooterDiv>
18 |       Made with ❤️ by{" "}
19 |       <Link href="https://www.youtube.com/channel/UCJV16_5c4A0amyBZSI4yP6A" passHref>
20 |         <MuiLink target="_blank" rel="noopener referrer">
21 |           Matt Sokola
22 |         </MuiLink>
23 |       </Link>
24 |     </FooterDiv>
25 |   )
26 | }
27 | 


--------------------------------------------------------------------------------
/components/Header.tsx:
--------------------------------------------------------------------------------
 1 | import { styled, Typography } from "@mui/material"
 2 | 
 3 | const HeaderDiv = styled("div")(({ theme }) => ({
 4 |   margin: `0 auto`,
 5 |   padding: `${theme.spacing(3)} ${theme.spacing(2)}`,
 6 |   minWidth: theme.spacing(40),
 7 |   maxWidth: theme.spacing(70),
 8 |   width: "100%",
 9 |   "& > h1": {
10 |     ...theme.typography.h4,
11 |     marginBottom: theme.spacing(2),
12 |     fontWeight: theme.typography.fontWeightMedium
13 |   }
14 | }))
15 | 
16 | export const Header = () => {
17 |   return (
18 |     <HeaderDiv>
19 |       <Typography variant="h1">Claim Görli ETH</Typography>
20 |       <Typography variant="body2">
21 |         <b>Görli ETH has no monetary value.</b> It means you can’t sell or exchange it for any goods or services. The
22 |         only utility it has is testing your decentralized application (DApp).
23 |       </Typography>
24 |     </HeaderDiv>
25 |   )
26 | }
27 | 


--------------------------------------------------------------------------------
/services/IpTransactionHistory.ts:
--------------------------------------------------------------------------------
 1 | import Redis from "ioredis"
 2 | import { defaultMillisecondsLayover } from "../consts/env"
 3 | import { TransactionHistory } from "../interfaces/TransactionHistory"
 4 | 
 5 | export class IpTransactionHistory implements TransactionHistory {
 6 |   constructor(private readonly redis: Redis) {}
 7 | 
 8 |   async hasReceivedTokens(address: string, minLayover: number = defaultMillisecondsLayover): Promise<boolean> {
 9 |     const timeString = await this.redis.get(address)
10 | 
11 |     if (timeString === null) {
12 |       return false
13 |     }
14 | 
15 |     const lastTransactionTime = new Date(timeString).getTime()
16 |     const nowTime = new Date().getTime()
17 | 
18 |     return nowTime - lastTransactionTime < minLayover
19 |   }
20 | 
21 |   async recordTransaction(address: string) {
22 |     const nowTime = new Date().toISOString()
23 | 
24 |     await this.redis.set(address, nowTime)
25 |   }
26 | }
27 | 


--------------------------------------------------------------------------------
/services/EtherscanTransactionHistory.ts:
--------------------------------------------------------------------------------
 1 | import { ethers } from "ethers"
 2 | import { defaultBlockLayover } from "../consts/env"
 3 | import { TransactionHistory } from "../interfaces/TransactionHistory"
 4 | 
 5 | export class EtherscanTransactionHistory implements TransactionHistory {
 6 |   constructor(private readonly provider: ethers.providers.EtherscanProvider) {}
 7 | 
 8 |   async hasReceivedTokens(address: string, blockSpan: number = defaultBlockLayover): Promise<boolean> {
 9 |     const endBlock = await this.provider.getBlockNumber()
10 |     const startBlock = endBlock - blockSpan
11 | 
12 |     const transactions = await this.provider.getHistory(address, startBlock, endBlock)
13 | 
14 |     for (const transaction of transactions) {
15 |       if (transaction.from.toLocaleLowerCase() === process.env.WALLET_ADDRESS?.toLocaleLowerCase()) {
16 |         return true
17 |       }
18 |     }
19 | 
20 |     return false
21 |   }
22 | 
23 |   async recordTransaction(_: string) {
24 |     // do nothing
25 |   }
26 | }
27 | 


--------------------------------------------------------------------------------
/services/RedisTransactionHistory.ts:
--------------------------------------------------------------------------------
 1 | import Redis from "ioredis"
 2 | import { defaultMillisecondsLayover } from "../consts/env"
 3 | import { TransactionHistory } from "../interfaces/TransactionHistory"
 4 | import { normalizeAddress } from "../utils/ethAddressUtils"
 5 | 
 6 | export class RedisTransactionHistory implements TransactionHistory {
 7 |   constructor(private readonly redis: Redis) {}
 8 | 
 9 |   async hasReceivedTokens(address: string, minLayover: number = defaultMillisecondsLayover): Promise<boolean> {
10 |     const normalizedAddress = normalizeAddress(address)
11 |     const timeString = await this.redis.get(normalizedAddress)
12 | 
13 |     if (timeString === null) {
14 |       return false
15 |     }
16 | 
17 |     const lastTransactionTime = new Date(timeString).getTime()
18 |     const nowTime = new Date().getTime()
19 | 
20 |     return nowTime - lastTransactionTime < minLayover
21 |   }
22 | 
23 |   async recordTransaction(address: string) {
24 |     const normalizedAddress = normalizeAddress(address)
25 |     const nowTime = new Date().toISOString()
26 | 
27 |     await this.redis.set(normalizedAddress, nowTime)
28 |   }
29 | }
30 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2022 Mateusz Sokola
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/utils/bootstrapEthereum.ts:
--------------------------------------------------------------------------------
 1 | import { Goerli } from "@usedapp/core"
 2 | import { ethers } from "ethers"
 3 | import { privilegedWallets } from "../consts/wallets"
 4 | import { Ethereum } from "../services/Ethereum"
 5 | import { TimestampNonce } from "../services/TimestampNonce"
 6 | import { WalletClassification } from "../services/WalletClassification"
 7 | import { bootstrapTransactionHistory, TransactionHistoryType } from "./bootstrapTransactionHistory"
 8 | 
 9 | export const bootstrapEthereum = (chainId: number = Goerli.chainId) => {
10 |   // Wallet Classification Service
11 |   const classificationService = new WalletClassification(privilegedWallets)
12 | 
13 |   // Transaction History Service
14 |   const enabledTransactionChecks = process.env.ENABLE_TRANSACTION_CHECKS as TransactionHistoryType
15 |   const transactionHistoryService = bootstrapTransactionHistory(enabledTransactionChecks, { chainId })
16 | 
17 |   // Nonce Service
18 |   const nonceService = new TimestampNonce()
19 | 
20 |   // Blockchain Service
21 |   const provider = new ethers.providers.JsonRpcProvider(process.env.NEXT_PUBLIC_ETH_API_URL || "", chainId)
22 |   const wallet = new ethers.Wallet(process.env.WALLET_PRIVATE_KEY || "", provider)
23 |   const ethereum = new Ethereum(wallet, nonceService, classificationService, transactionHistoryService)
24 | 
25 |   return ethereum
26 | }
27 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "eth-faucet",
 3 |   "version": "0.1.1",
 4 |   "license": "MIT",
 5 |   "scripts": {
 6 |     "create-wallet": "ts-node ./_scripts/createWallet.ts",
 7 |     "dev": "next dev",
 8 |     "build": "next build",
 9 |     "start": "next start",
10 |     "lint": "next lint"
11 |   },
12 |   "dependencies": {
13 |     "@emotion/react": "latest",
14 |     "@emotion/styled": "latest",
15 |     "@metamask/eth-sig-util": "latest",
16 |     "@mui/icons-material": "latest",
17 |     "@mui/lab": "latest",
18 |     "@mui/material": "latest",
19 |     "@usedapp/core": "latest",
20 |     "axios": "latest",
21 |     "ethers": "latest",
22 |     "ioredis": "latest",
23 |     "lodash": "latest",
24 |     "next": "12.1.6",
25 |     "react": "18.1.0",
26 |     "react-dom": "18.1.0",
27 |     "react-google-recaptcha-v3": "1.10.0",
28 |     "request-ip": "latest"
29 |   },
30 |   "devDependencies": {
31 |     "@types/lodash": "latest",
32 |     "@types/node": "17.0.35",
33 |     "@types/react": "18.0.9",
34 |     "@types/react-dom": "18.0.4",
35 |     "@types/request-ip": "latest",
36 |     "eslint": "8.16.0",
37 |     "eslint-config-next": "12.1.6",
38 |     "prettier": "latest",
39 |     "ts-node": "10.9.1",
40 |     "typescript": "4.6.4"
41 |   },
42 |   "engines": {
43 |     "node": "16.x.x",
44 |     "yarn": "3.x.x",
45 |     "npm": "please-use-yarn"
46 |   },
47 |   "packageManager": "yarn@3.2.2"
48 | }
49 | 


--------------------------------------------------------------------------------
/utils/bootstrapTransactionHistory.ts:
--------------------------------------------------------------------------------
 1 | import { ethers } from "ethers"
 2 | import Redis from "ioredis"
 3 | import { TransactionHistory } from "../interfaces/TransactionHistory"
 4 | import { EtherscanTransactionHistory } from "../services/EtherscanTransactionHistory"
 5 | import { IpTransactionHistory } from "../services/IpTransactionHistory"
 6 | import { RedisTransactionHistory } from "../services/RedisTransactionHistory"
 7 | 
 8 | export type TransactionHistoryType = "etherscan" | "redis" | "ip"
 9 | 
10 | export const bootstrapTransactionHistory = (
11 |   type: TransactionHistoryType,
12 |   options?: any
13 | ): TransactionHistory | undefined => {
14 |   switch (type) {
15 |     case "etherscan": {
16 |       const { chainId } = options as { chainId: number }
17 |       const etherscan = new ethers.providers.EtherscanProvider(chainId, process.env.ETHERSCAN_API_KEY)
18 |       const etherscanService = new EtherscanTransactionHistory(etherscan)
19 | 
20 |       return etherscanService
21 |     }
22 |     case "redis": {
23 |       const redis = new Redis(process.env.REDIS_URL as string)
24 |       const redisService = new RedisTransactionHistory(redis)
25 | 
26 |       return redisService
27 |     }
28 |     case "ip": {
29 |       const redis = new Redis(process.env.REDIS_URL as string)
30 |       const ipService = new IpTransactionHistory(redis)
31 | 
32 |       return ipService
33 |     }
34 |     default: {
35 |       return undefined
36 |     }
37 |   }
38 | }
39 | 


--------------------------------------------------------------------------------
/pages/_app.tsx:
--------------------------------------------------------------------------------
 1 | import type { AppProps } from "next/app"
 2 | import { createTheme, CssBaseline, ThemeProvider } from "@mui/material"
 3 | import { Goerli, DAppProvider, Config } from "@usedapp/core"
 4 | import Head from "next/head"
 5 | import { OpenSourceMemo } from "../components/OpenSourceMemo"
 6 | import { Header } from "../components/Header"
 7 | import { Footer } from "../components/Footer"
 8 | import { Layout } from "../components/Layout"
 9 | import { Content } from "../components/Content"
10 | import { pollingInterval } from "../consts/env"
11 | import { CaptchaProvider } from "../components/CaptchaProvider"
12 | 
13 | const config: Config = {
14 |   readOnlyChainId: Goerli.chainId,
15 |   readOnlyUrls: {
16 |     [Goerli.chainId]: process.env.NEXT_PUBLIC_ETH_API_URL as string
17 |   },
18 |   pollingInterval
19 | }
20 | const theme = createTheme()
21 | 
22 | const EthereumFaucet = ({ Component, pageProps }: AppProps) => (
23 |   <>
24 |     <Head>
25 |       <title>Claim Görli ETH</title>
26 |     </Head>
27 |     <CaptchaProvider>
28 |       <DAppProvider config={config}>
29 |         <ThemeProvider theme={theme}>
30 |           <CssBaseline />
31 |           <Layout>
32 |             <Content>
33 |               <Header />
34 |               <Component {...pageProps} />
35 |               <OpenSourceMemo />
36 |             </Content>
37 |             <Footer />
38 |           </Layout>
39 |         </ThemeProvider>
40 |       </DAppProvider>
41 |     </CaptchaProvider>
42 |   </>
43 | )
44 | 
45 | export default EthereumFaucet
46 | 


--------------------------------------------------------------------------------
/components/ClaimButton/_BaseClaimButton.tsx:
--------------------------------------------------------------------------------
 1 | import { Button } from "@mui/material"
 2 | import LoadingButton from "@mui/lab/LoadingButton"
 3 | import { Goerli, useEthers } from "@usedapp/core"
 4 | import { isNil } from "lodash"
 5 | import Link from "next/link"
 6 | import { hasMetamask } from "../../hooks/hasMetamask"
 7 | import { claimTokens, retrieveNonce } from "../../services/HttpClient"
 8 | import { messageTemplate } from "../../utils/textMessage"
 9 | 
10 | type BaseClaimButtonProps = {
11 |   onSuccess: () => void
12 |   onError: (message: string) => void
13 |   retrieveCaptcha: () => Promise<string>
14 | }
15 | 
16 | export const BaseClaimButton = ({ onSuccess, onError, retrieveCaptcha }: BaseClaimButtonProps) => {
17 |   const { account, library, isLoading: loading, activateBrowserWallet, switchNetwork, chainId } = useEthers()
18 |   const installed = hasMetamask()
19 | 
20 |   const claimGorliEth = async () => {
21 |     try {
22 |       if (isNil(library) || isNil(account)) {
23 |         throw new Error("Wallet is not connected")
24 |       }
25 | 
26 |       const captchaToken = await retrieveCaptcha()
27 | 
28 |       const nonce = await retrieveNonce()
29 |       const message = messageTemplate(nonce)
30 | 
31 |       const signer = library.getSigner()
32 |       const signature = await signer.signMessage(message)
33 | 
34 |       await claimTokens(account as string, message, signature, captchaToken)
35 |       onSuccess()
36 |     } catch (e: any) {
37 |       if (e.name === "AxiosError" && e.response.data.message) {
38 |         onError(e.response.data.message)
39 |         return
40 |       }
41 | 
42 |       onError(e?.message || "Something went wrong")
43 |     }
44 |   }
45 | 
46 |   if (!installed) {
47 |     return (
48 |       <Link href="https://metamask.io/download/" passHref>
49 |         <Button variant="contained" fullWidth>
50 |           Install MetaMask
51 |         </Button>
52 |       </Link>
53 |     )
54 |   }
55 | 
56 |   if (loading) {
57 |     return <LoadingButton variant="contained" loading fullWidth />
58 |   }
59 | 
60 |   if (!account) {
61 |     return (
62 |       <Button variant="contained" onClick={() => activateBrowserWallet()} fullWidth>
63 |         Connect wallet
64 |       </Button>
65 |     )
66 |   }
67 | 
68 |   if (chainId !== Goerli.chainId) {
69 |     return (
70 |       <Button variant="contained" onClick={() => switchNetwork(Goerli.chainId)} fullWidth>
71 |         Switch to Görli network
72 |       </Button>
73 |     )
74 |   }
75 | 
76 |   return (
77 |     <Button variant="contained" onClick={claimGorliEth} fullWidth>
78 |       Claim Görli ETH
79 |     </Button>
80 |   )
81 | }
82 | 


--------------------------------------------------------------------------------
/pages/index.tsx:
--------------------------------------------------------------------------------
 1 | import type { NextPage } from "next"
 2 | import { formatEther } from "@ethersproject/units"
 3 | import { useEtherBalance, useEthers } from "@usedapp/core"
 4 | import { useCallback, useReducer } from "react"
 5 | import { Alert } from "../components/Alert"
 6 | import { ClaimButton } from "../components/ClaimButton"
 7 | import { Item } from "../components/Item"
 8 | import { RoundedBox } from "../components/RoundedBox"
 9 | import { useWalletClassification } from "../hooks/useWalletClassification"
10 | 
11 | type Action =
12 |   | {
13 |       type: "success"
14 |     }
15 |   | {
16 |       type: "default"
17 |     }
18 |   | {
19 |       type: "error"
20 |       error: string
21 |     }
22 | 
23 | type State =
24 |   | {
25 |       status: "success"
26 |     }
27 |   | {
28 |       status: "default"
29 |     }
30 |   | {
31 |       status: "error"
32 |       error: string
33 |     }
34 | 
35 | const initialState: State = {
36 |   status: "default"
37 | }
38 | 
39 | const reducer = (_: State, action: Action): State => {
40 |   switch (action.type) {
41 |     case "error":
42 |       return { status: "error", error: action.error }
43 |     case "success":
44 |       return { status: "success" }
45 |     default:
46 |       return { status: "default" }
47 |   }
48 | }
49 | 
50 | const Home: NextPage = () => {
51 |   const { account } = useEthers()
52 |   const [state, dispatch] = useReducer(reducer, initialState)
53 |   const balance = useEtherBalance(account, { refresh: "everyBlock" })
54 |   const [retrieveAmount] = useWalletClassification()
55 | 
56 |   const handleSuccess = () => dispatch({ type: "success" })
57 | 
58 |   const handleError = (error: string) => dispatch({ type: "error", error })
59 | 
60 |   const renderAlert = useCallback(() => {
61 |     switch (state.status) {
62 |       case "success":
63 |         return (
64 |           <Alert severity="success">
65 |             Görli ETH has been dispatched to your wallet. You should receive it within 3 minutes.
66 |           </Alert>
67 |         )
68 |       case "error":
69 |         return <Alert severity="error">{state.error}</Alert>
70 |       default:
71 |         return null
72 |     }
73 |   }, [state.status])
74 | 
75 |   return (
76 |     <RoundedBox>
77 |       <Item>
78 |         <span>Wallet balance</span>
79 |         <span>{balance ? formatEther(balance) : <>&ndash;</>} ETH (testnet)</span>
80 |       </Item>
81 |       <Item>
82 |         <span>Claimable Görli ETH</span>
83 |         <span>{formatEther(retrieveAmount(account))} ETH (testnet)</span>
84 |       </Item>
85 |       <ClaimButton onSuccess={handleSuccess} onError={handleError} />
86 |       {renderAlert()}
87 |     </RoundedBox>
88 |   )
89 | }
90 | 
91 | export default Home
92 | 


--------------------------------------------------------------------------------
/pages/api/claim.ts:
--------------------------------------------------------------------------------
 1 | import requestIp from "request-ip"
 2 | import type { NextApiRequest, NextApiResponse } from "next"
 3 | import { InsufficientFundsError } from "../../errors/InsufficientFundsError"
 4 | import { InvalidCaptcha } from "../../errors/InvalidCaptcha"
 5 | import { IpLimitExceeded } from "../../errors/IpLimitExceeded"
 6 | import { NonceExpiredError } from "../../errors/NonceExpiredError"
 7 | import { NonEmptyWalletError } from "../../errors/NonEmptyWalletError"
 8 | import { SignatureMismatchError } from "../../errors/SignatureMismatchError"
 9 | import { WalletAlreadyFunded } from "../../errors/WalletAlreadyFunded"
10 | import { TransactionHistory } from "../../interfaces/TransactionHistory"
11 | import { DefaultResponse } from "../../interfaces/Response"
12 | import { bootstrapCaptcha } from "../../utils/bootstrapCaptcha"
13 | import { bootstrapEthereum } from "../../utils/bootstrapEthereum"
14 | import { bootstrapTransactionHistory } from "../../utils/bootstrapTransactionHistory"
15 | 
16 | type ClaimParams = {
17 |   address: string
18 |   message: string
19 |   signature: string
20 |   captcha: string
21 | }
22 | 
23 | const handler = async (req: NextApiRequest, res: NextApiResponse<DefaultResponse>) => {
24 |   try {
25 |     const ethereum = bootstrapEthereum()
26 |     const captcha = bootstrapCaptcha()
27 | 
28 |     const { address, message, signature, captcha: captchaToken }: ClaimParams = req.body
29 | 
30 |     // TODO(mateusz): Refactor bootstrapTransactionHistory. The current implementation is hairy
31 |     // Start of IP detection
32 |     const ipDetection = bootstrapTransactionHistory("ip") as TransactionHistory
33 |     const ipAddress = requestIp.getClientIp(req)
34 |     if (ipAddress) {
35 |       const hasReceivedTokens = await ipDetection.hasReceivedTokens(ipAddress)
36 |       if (hasReceivedTokens) {
37 |         throw new IpLimitExceeded()
38 |       }
39 |     }
40 |     // End of IP detection
41 | 
42 |     if (captcha) {
43 |       await captcha.verifyCaptcha(captchaToken)
44 |     }
45 |     await ethereum.verifyMessage(address, message, signature)
46 |     await ethereum.isEligible(address)
47 |     await ethereum.fundWallet(address)
48 |     // IP Detection
49 |     if (ipAddress) {
50 |       await ipDetection.recordTransaction(ipAddress)
51 |     }
52 | 
53 |     return res.status(200).json({ status: "ok" })
54 |   } catch (e) {
55 |     if (
56 |       e instanceof InvalidCaptcha ||
57 |       e instanceof IpLimitExceeded ||
58 |       e instanceof NonceExpiredError ||
59 |       e instanceof SignatureMismatchError ||
60 |       e instanceof InsufficientFundsError ||
61 |       e instanceof NonEmptyWalletError ||
62 |       e instanceof WalletAlreadyFunded
63 |     ) {
64 |       return res.status(e.code).json({ status: "error", message: e.message })
65 |     }
66 | 
67 |     console.error(e)
68 |     return res.status(500).json({ status: "error", message: "Something went wrong" })
69 |   }
70 | }
71 | 
72 | export default handler
73 | 


--------------------------------------------------------------------------------
/services/Ethereum.ts:
--------------------------------------------------------------------------------
 1 | import { recoverPersonalSignature } from "@metamask/eth-sig-util"
 2 | import { ethers } from "ethers"
 3 | import { defaultWalletWeiAmount } from "../consts/env"
 4 | import { InsufficientFundsError } from "../errors/InsufficientFundsError"
 5 | import { NonceExpiredError } from "../errors/NonceExpiredError"
 6 | import { NonEmptyWalletError } from "../errors/NonEmptyWalletError"
 7 | import { SignatureMismatchError } from "../errors/SignatureMismatchError"
 8 | import { WalletAlreadyFunded } from "../errors/WalletAlreadyFunded"
 9 | import { Blockchain } from "../interfaces/Blockchain"
10 | import { Nonce } from "../interfaces/Nonce"
11 | import { TransactionHistory } from "../interfaces/TransactionHistory"
12 | import { extractNonceFromMessage } from "../utils/textMessage"
13 | import { WalletClassification } from "./WalletClassification"
14 | 
15 | export class Ethereum implements Blockchain {
16 |   constructor(
17 |     private readonly wallet: ethers.Wallet,
18 |     private readonly nonceService: Nonce,
19 |     private readonly classificationService: WalletClassification,
20 |     private readonly transactionHistoryService: TransactionHistory | undefined = undefined
21 |   ) {}
22 | 
23 |   async fundWallet(address: string): Promise<void> {
24 |     try {
25 |       const amount = this.classificationService.retrieveAmount(address)
26 |       const value = ethers.BigNumber.from(amount.toString())
27 | 
28 |       const transaction = {
29 |         to: address,
30 |         value
31 |       }
32 |       await this.wallet.sendTransaction(transaction)
33 | 
34 |       // Added after the video was released to prevent user from draining system's wallet
35 |       if (this.transactionHistoryService === undefined) {
36 |         return
37 |       }
38 | 
39 |       await this.transactionHistoryService.recordTransaction(address)
40 |     } catch (e: any) {
41 |       if (e?.code === "INSUFFICIENT_FUNDS") {
42 |         throw new InsufficientFundsError()
43 |       }
44 | 
45 |       throw e
46 |     }
47 |   }
48 | 
49 |   async verifyMessage(address: string, message: string, signature: string): Promise<boolean> {
50 |     const nonce = extractNonceFromMessage(message)
51 |     const isValid = await this.nonceService.verify(nonce)
52 | 
53 |     if (!isValid) {
54 |       throw new NonceExpiredError()
55 |     }
56 | 
57 |     const recoveredAddress = recoverPersonalSignature({
58 |       data: message,
59 |       signature
60 |     })
61 | 
62 |     if (address.toLowerCase() !== recoveredAddress.toLowerCase()) {
63 |       throw new SignatureMismatchError()
64 |     }
65 | 
66 |     return true
67 |   }
68 | 
69 |   async isEligible(address: string): Promise<void> {
70 |     // Privileged wallets aren’t checked for eligibility
71 |     if (this.classificationService.isPrivileged(address)) {
72 |       return
73 |     }
74 | 
75 |     const balance = await this.wallet.provider.getBalance(address)
76 | 
77 |     if (balance.gt(defaultWalletWeiAmount)) {
78 |       throw new NonEmptyWalletError()
79 |     }
80 | 
81 |     // Added after the video was released to prevent user from draining system's wallet
82 |     if (this.transactionHistoryService === undefined) {
83 |       return
84 |     }
85 | 
86 |     const hasReceivedTokens = await this.transactionHistoryService.hasReceivedTokens(address)
87 | 
88 |     if (hasReceivedTokens) {
89 |       throw new WalletAlreadyFunded()
90 |     }
91 |   }
92 | }
93 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | The `eth-faucet` is a developer tool to get testnet Ether (ETH) in order to test and troubleshoot your decentralized application (DApp) before going live on Ethereum mainnet, where you must use real ETH.
  2 | 
  3 | ![Screenshot](./screenshot.png)
  4 | 
  5 | Live version: **[eth-faucet-alpha.vercel.app](https://eth-faucet-alpha.vercel.app)**
  6 | 
  7 | ## Getting Started
  8 | 
  9 | 1. First, create a new Ethereum wallet:
 10 | 
 11 | ```bash
 12 | yarn create-wallet
 13 | ```
 14 | 
 15 | You should receive wallet credentials printed to your console:
 16 | 
 17 | ```
 18 | export WALLET_ADDRESS=0x0000000000000000000000000000000000000000
 19 | export WALLET_MNEMONIC_PHRASE=fluffy kitten hates cats although it is a cat
 20 | export WALLET_PRIVATE_KEY=0x0000000000000000000000000000000000000000000000000000000000000000
 21 | ```
 22 | 
 23 | **Write those credentials down**, you will need it!
 24 | 
 25 | 2. Now, you need to find the Ethereum API for Görli network. I’m using Infura and you can use it as well. Just [create a free account](https://infura.io) and generate API keys for Görli network.
 26 | 
 27 | 3. Once you have your API keys, create a `.env.local` file, and specify the following variables:
 28 | 
 29 | ```
 30 | WALLET_PRIVATE_KEY=0x0000000000000000000000000000000000000000000000000000000000000000
 31 | NEXT_PUBLIC_ETH_API_URL=https://goerli.infura.io/v3/00000000000000000000000000000000
 32 | NEXT_PUBLIC_DEFAULT_WALLET_ETH_AMOUNT=0.25 # Optional
 33 | NEXT_PUBLIC_PRIVILEGED_WALLET_ETH_AMOUNT=1 # Optional
 34 | ```
 35 | 
 36 | 4. Finally, we can run our app:
 37 | 
 38 | ```bash
 39 | yarn dev
 40 | ```
 41 | 
 42 | Open [http://localhost:3000](http://localhost:3000) with your browser to see it.
 43 | 
 44 | ## How to top up the wallet with Görli ETH?
 45 | 
 46 | You can use [this faucet](https://goerli-faucet.mudit.blog/) to request some testnet Ethereum.
 47 | 
 48 | ## How to change amount of distributed Görli ETH?
 49 | 
 50 | Set the `NEXT_PUBLIC_DEFAULT_WALLET_ETH_AMOUNT` variable in your `.env` file. For example:
 51 | 
 52 | ```
 53 | NEXT_PUBLIC_DEFAULT_WALLET_ETH_AMOUNT=5 # 5 ETH per claim
 54 | ```
 55 | 
 56 | ## Use captcha
 57 | 
 58 | If you want to prevent bots from draining your wallet, you should use some captcha verification system. You can do it by setting `NEXT_PUBLIC_ENABLE_CAPTCHA` in your `.env` file. At the moment we support only Google ReCaptcha v3.
 59 | 
 60 | | Parameter                    | Type                             | Description                  |
 61 | | :--------------------------- | :------------------------------- | :--------------------------- |
 62 | | `NEXT_PUBLIC_ENABLE_CAPTCHA` | `none` (default), `recaptcha_v3` | Enables captcha verification |
 63 | 
 64 | ### Google ReCaptcha v3
 65 | 
 66 | If you want to use Google ReCaptcha v3 to verify captchas. Just set `NEXT_PUBLIC_ENABLE_CAPTCHA` to `recaptcha_v3`, than add `NEXT_PUBLIC_RECAPTCHA_SITE_KEY` and `RECAPTCHA_SECRET_KEY` in your `.env` file.
 67 | 
 68 | | Parameter                        | Type     | Description                     |
 69 | | :------------------------------- | :------- | :------------------------------ |
 70 | | `NEXT_PUBLIC_RECAPTCHA_SITE_KEY` | `string` | **Required**. Front-end API key |
 71 | | `RECAPTCHA_SECRET_KEY`           | `string` | **Required**. Back-end API key  |
 72 | 
 73 | ```
 74 | NEXT_PUBLIC_ENABLE_CAPTCHA=recaptcha_v3
 75 | NEXT_PUBLIC_RECAPTCHA_SITE_KEY=0000000000000000000000000000000000000000
 76 | RECAPTCHA_SECRET_KEY=0000000000000000000000000000000000000000
 77 | ```
 78 | 
 79 | You can [create a new API Key here](https://www.google.com/recaptcha/intro/v3.html). It’s free of charge (there are some limits though).
 80 | 
 81 | ## Restricting users to claim Görli ETH once per day
 82 | 
 83 | If you want to restrict users from draining your wallet, you should enable transaction checks. You can do it by setting `ENABLE_TRANSACTION_CHECKS` in your `.env` file. The supported transaction history scanners you can find here:
 84 | 
 85 | | Parameter                   | Type                                   | Description                                                           |
 86 | | :-------------------------- | :------------------------------------- | :-------------------------------------------------------------------- |
 87 | | `ENABLE_TRANSACTION_CHECKS` | `none` (default), `etherscan`, `redis` | Enables transaction checks to prevent users from draining your wallet |
 88 | 
 89 | ### Etherscan
 90 | 
 91 | To scan blockchain history for transactions you should use Etherscan History API. Just set `ENABLE_TRANSACTION_CHECKS` to `etherscan` and add `ETHERSCAN_API_KEY` in your `.env` file.
 92 | 
 93 | | Parameter           | Type     | Description                                       |
 94 | | :------------------ | :------- | :------------------------------------------------ |
 95 | | `ETHERSCAN_API_KEY` | `string` | **Required**. Etherscan API key for Görli testnet |
 96 | 
 97 | ```
 98 | ENABLE_TRANSACTION_CHECKS=etherscan
 99 | ETHERSCAN_API_KEY=00000000000000000000000000000000
100 | ```
101 | 
102 | You can [create a new API Key on Etherscan](https://docs.etherscan.io/getting-started/viewing-api-usage-statistics). It’s free of charge.
103 | 
104 | ### Redis
105 | 
106 | If you want to record transaction history in database I recommend to use Redis. Just set `ENABLE_TRANSACTION_CHECKS` to `redis` and add `REDIS_URL` in your `.env` file.
107 | 
108 | | Parameter   | Type     | Description                           |
109 | | :---------- | :------- | :------------------------------------ |
110 | | `REDIS_URL` | `string` | **Required**. Redis connection string |
111 | 
112 | ```
113 | ENABLE_TRANSACTION_CHECKS=redis
114 | REDIS_URL=rediss://user:password@redis:6379
115 | ```
116 | 
117 | You can [create a Redis database on Upstash.com](https://upstash.com/). It’s free for the first 10.000 requests per month.
118 | 
119 | ## Privileged wallets
120 | 
121 | From now on, the faucet supports priviledged wallets. The riviledged wallet can receive higher amounts of tokens per request and the limits are not apply to them.
122 | 
123 | ### How to define amount of distributed Görli ETH to privileged wallets?
124 | 
125 | Set the `NEXT_PUBLIC_PRIVILEGED_WALLET_ETH_AMOUNT` variable in your `.env` file. For example:
126 | 
127 | ```
128 | NEXT_PUBLIC_PRIVILEGED_WALLET_ETH_AMOUNT=64 # 64 ETH per claim
129 | ```
130 | 
131 | ### How to define privileged wallets?
132 | 
133 | At the current moment, you will need to fork this repository and add wallet addresses into [consts/wallets.ts](consts/wallets.ts) file.
134 | 
135 | ```
136 | # Example
137 | export const privilegedWallets = [
138 |   "0x0000000000000000000000000000000000000000000000000000000000000001",
139 |   "0x0000000000000000000000000000000000000000000000000000000000000002",
140 |   "0x0000000000000000000000000000000000000000000000000000000000000003",
141 |   ...,
142 |   "0x0000000000000000000000000000000000000000000000000000000000009999"
143 | ]
144 | ```
145 | 


--------------------------------------------------------------------------------