Magic

// register-oidc-provider.ts
const res = await fetch(
  "https://tee.express.magiclabs.com/v1/identity/provider",
  {
    method: "POST",
    headers: {
      "X-Magic-Secret-Key": process.env.MAGIC_SECRET_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      issuer: "https://your-app.com", // Your backend URL
      audience: "magic-express",
      jwks_uri: "https://your-app.com/.well-known/jwks.json",
    }),
  }
)

const { id } = await res.json()
// Save this as MAGIC_OIDC_PROVIDER_ID

const MAGIC_EXPRESS_API = "https://tee.express.magiclabs.com"

function magicHeaders(jwt: string) {
  return {
    Authorization: `Bearer ${jwt}`,
    "X-Magic-API-Key": process.env.MAGIC_API_KEY!,
    "X-OIDC-Provider-ID": process.env.MAGIC_OIDC_PROVIDER_ID!,
    "X-Magic-Chain": "ETH",
    "Content-Type": "application/json",
  }
}

export async function getOrCreateWallet(jwt: string) {
  const res = await fetch(`${MAGIC_EXPRESS_API}/v1/wallet`, {
    method: "POST",
    headers: magicHeaders(jwt),
  })
  return res.json() as Promise<{ public_address: string }>
}

export async function signHash(jwt: string, hash: string) {
  const res = await fetch(`${MAGIC_EXPRESS_API}/v1/wallet/sign/data`, {
    method: "POST",
    headers: magicHeaders(jwt),
    body: JSON.stringify({ raw_data_hash: hash }),
  })
  return res.json() as Promise<{ signature: string }>
}

// GET /api/wallet
app.get("/api/wallet", async (c) => {
  const user = getAuthenticatedUser(c) // Your auth middleware
  if (!user) return c.json({ error: "Unauthorized" }, 401)

  const jwt = await issueJwt(user.id) // Sign JWT with your RS256 private key
  const data = await getOrCreateWallet(jwt)
  return c.json(data)
})

// POST /api/sign
app.post("/api/sign", async (c) => {
  const user = getAuthenticatedUser(c)
  if (!user) return c.json({ error: "Unauthorized" }, 401)

  const { hash } = await c.req.json()
  const jwt = await issueJwt(user.id)
  const data = await signHash(jwt, hash)
  return c.json(data)
})

import { RhinestoneSDK } from "@rhinestone/sdk"
import { toAccount } from "viem/accounts"
import { hashTypedData, hashMessage } from "viem"
import type { SignableMessage, TypedDataDefinition, Hex } from "viem"

// 1. Get wallet address from your backend
const walletRes = await fetch("/api/wallet", {
  credentials: "include",
})
const { public_address } = await walletRes.json()

// 2. Create a viem account that signs via your backend
const account = toAccount({
  address: public_address as Hex,
  async signMessage({ message }: { message: SignableMessage }) {
    const hash = hashMessage(message)
    const res = await fetch("/api/sign", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      credentials: "include",
      body: JSON.stringify({ hash }),
    })
    if (!res.ok) throw new Error((await res.json()).error)
    return (await res.json()).signature as Hex
  },
  async signTransaction() {
    throw new Error("signTransaction not supported")
  },
  async signTypedData(typedData: TypedDataDefinition) {
    const hash = hashTypedData(typedData)
    const res = await fetch("/api/sign", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      credentials: "include",
      body: JSON.stringify({ hash }),
    })
    if (!res.ok) throw new Error((await res.json()).error)
    return (await res.json()).signature as Hex
  },
})

// 3. Create the Rhinestone account
const rhinestone = new RhinestoneSDK({
  apiKey: process.env.NEXT_PUBLIC_RHINESTONE_API_KEY!,
})
const rhinestoneAccount = await rhinestone.createAccount({
  owners: { type: "ecdsa", accounts: [account] },
})