const credentials = await request.json();
  const req: CtxOrReq = {
    req: {
      headers: {
        cookie: request.headers.get('cookie')
      }
    }
  }
  try {
    const message = new SiweMessage(JSON.parse(credentials.message || "{}"))
    // const nextAuthUrl = new URL(process.env.NEXTAUTH_URL)
    const nonce = await getCsrfToken(req);

    const fields =  await message.validate(credentials.signature)
    if (fields.nonce !== nonce) {
      return new NextResponse(JSON.stringify({ success: false, error: 'Nonce mismatch' }), { status: 400 });
    }

const data = await request.text();

    const json = JSON.parse(data);
    if (!('address' in json) || !('signature' in json) || !('message' in json)) {
      return NextResponse.json({ error: 'Malformed Request' }, { status: 400 })
    }
    const recoveredAddress = await recoverMessageAddress({
      message: json.message,
      signature: json.signature
    });
    if (recoveredAddress !== json.address) {
      return NextResponse.json({ error: 'Invalid Signature' }, { status: 400 })
    }

const UnlockableContent = () => {
  const { address, isConnected } = useAccount();
  const { chain } = useNetwork();
  const [codes, setCodes] = useState<{ tokenId: number, code: string }[]>([]);

  const handleSignedMessage = async (signature: string) => {
    const r = await fetch('/api/reveal', {
      method: 'POST',
      body: JSON.stringify({
        address,
        signature,
        message: `I verify that i own ${address} to reveal the discount codes`
      }),
    })
    if (r.ok) {
      const data = await r.json();
      if (data?.results?.length > 0) {
        setCodes(data.results)
      }
    }
  }

  const { signMessage } = useSignMessage({
    message: `I verify that i own ${address} to reveal the discount codes`,
    onSuccess: handleSignedMessage
  })

import NextAuth from "next-auth/next";
import CredentialsProvider from "next-auth/providers/credentials";
import { getCsrfToken } from "next-auth/react";


export const authOptions = {
    providers: [
        CredentialsProvider({
            id: "web3",
            name: "web3",
            credentials: {
                message: { label: "Message", type: "text" },
                signedMessage: { label: "Signed Message", type: "text" },
            },
            async authorize(credentials, req) {
                if (!credentials?.signedMessage || !credentials?.message) {
                    return null;
                }

                try {
                    const siwe = new SiweMessage(JSON.parse(credentials?.message));
                    const result = await siwe.verify({
                        signature: credentials.signedMessage,
                        nonce: await getCsrfToken({req})
                    });

                    if (!result.success) throw new Error("Invalid Signature");

                    if (result.data.statement !== process.env.NEXT_PUBLIC_SIGNIN_MESSAGE)
                        throw new Error("Statement Mismatch");

                    if (new Date(result.data.expirationTime) < new Date())
                      throw new Error("Signature Already expired");

                    return {
                        id: siwe.address,
                    };
                } catch (error) {
                    console.log(error);
                    return null;
                }
            },
        }),
    ],
    session: { strategy: "jwt" },

    debug: process.env.NODE_ENV !== "production",

    secret: process.env.NEXTAUTH_SECRET,

    callbacks: {
        async session({ session, token }) {
            session.user.address = token.sub;
            session.user.token = token;
            return session;
        },
    },
};

const handler = NextAuth(authOptions);

export { handler as GET, handler as POST };

const message = [`domain: ${window.location.host}`, `uri: ${window.location.origin}`, etc etc].join(`/n`)

const makeMessage = (address: Address, csrf: string) => typeof window === "undefined" ? "" : yourarrayjoinhere

const valid = await verifyMessage({ 
  address: credentials.address,
  message: makeMessage(credentials.address, "")
  signature: credentials.signedMessage,
})