@zerodev/permissions 5.3.2-alpha-0 → 5.3.2-alpha-1

package/signers/toWebAuthnKey.ts

@@ -1,163 +0,0 @@
-import { Buffer } from "buffer"
-import { type Hex, keccak256 } from "viem"
-import { b64ToBytes, uint8ArrayToHexString } from "./webAuthnUtils.js"
-
-export enum WebAuthnMode {
-    Register = "register",
-    Login = "login"
-}
-
-export type WebAuthnKey = {
-    pubX: bigint
-    pubY: bigint
-    authenticatorIdHash: Hex
-}
-
-export const toWebAuthnKey = async ({
-    passkeyName,
-    passkeyServerUrl,
-    webAuthnKey,
-    mode = WebAuthnMode.Login
-}: {
-    passkeyName: string
-    passkeyServerUrl: string
-    webAuthnKey?: WebAuthnKey
-    mode: WebAuthnMode
-}): Promise<WebAuthnKey> => {
-    if (webAuthnKey) {
-        return webAuthnKey
-    }
-    let pubKey: string | undefined
-    let authenticatorIdHash: Hex
-    if (mode === WebAuthnMode.Login) {
-        // Get login options
-        const loginOptionsResponse = await fetch(
-            `${passkeyServerUrl}/login/options`,
-            {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                credentials: "include"
-            }
-        )
-        const loginOptions = await loginOptionsResponse.json()
-
-        // Start authentication (login)
-        const { startAuthentication } = await import("@simplewebauthn/browser")
-        const loginCred = await startAuthentication(loginOptions)
-
-        // get authenticatorIdHash
-        authenticatorIdHash = keccak256(
-            uint8ArrayToHexString(b64ToBytes(loginCred.id))
-        )
-
-        // Verify authentication
-        const loginVerifyResponse = await fetch(
-            `${passkeyServerUrl}/login/verify`,
-            {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ cred: loginCred }),
-                credentials: "include"
-            }
-        )
-
-        const loginVerifyResult = await loginVerifyResponse.json()
-
-        if (window.sessionStorage === undefined) {
-            throw new Error("sessionStorage is not available")
-        }
-        sessionStorage.setItem("userId", loginVerifyResult.userId)
-
-        if (!loginVerifyResult.verification.verified) {
-            throw new Error("Login not verified")
-        }
-        // Import the key
-        pubKey = loginVerifyResult.pubkey // Uint8Array pubkey
-    } else {
-        if (!passkeyName) {
-            throw new Error("No passkey name provided")
-        }
-        // Get registration options
-        const registerOptionsResponse = await fetch(
-            `${passkeyServerUrl}/register/options`,
-            {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json"
-                },
-                body: JSON.stringify({ username: passkeyName }),
-                credentials: "include"
-            }
-        )
-        const registerOptions = await registerOptionsResponse.json()
-
-        // save userId to sessionStorage
-        if (window.sessionStorage === undefined) {
-            throw new Error("sessionStorage is not available")
-        }
-        sessionStorage.setItem("userId", registerOptions.userId)
-
-        // Start registration
-        const { startRegistration } = await import("@simplewebauthn/browser")
-        const registerCred = await startRegistration(registerOptions.options)
-
-        // get authenticatorIdHash
-        authenticatorIdHash = keccak256(
-            uint8ArrayToHexString(b64ToBytes(registerCred.id))
-        )
-
-        // Verify registration
-        const registerVerifyResponse = await fetch(
-            `${passkeyServerUrl}/register/verify`,
-            {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json"
-                },
-                body: JSON.stringify({
-                    userId: registerOptions.userId,
-                    username: passkeyName,
-                    cred: registerCred
-                }),
-                credentials: "include"
-            }
-        )
-
-        const registerVerifyResult = await registerVerifyResponse.json()
-        if (!registerVerifyResult.verified) {
-            throw new Error("Registration not verified")
-        }
-
-        // Import the key
-        pubKey = registerCred.response.publicKey
-    }
-    if (!pubKey) {
-        throw new Error("No public key returned from registration credential")
-    }
-
-    const spkiDer = Buffer.from(pubKey, "base64")
-    const key = await crypto.subtle.importKey(
-        "spki",
-        spkiDer,
-        {
-            name: "ECDSA",
-            namedCurve: "P-256"
-        },
-        true,
-        ["verify"]
-    )
-
-    // Export the key to the raw format
-    const rawKey = await crypto.subtle.exportKey("raw", key)
-    const rawKeyBuffer = Buffer.from(rawKey)
-
-    // The first byte is 0x04 (uncompressed), followed by x and y coordinates (32 bytes each for P-256)
-    const pubKeyX = rawKeyBuffer.subarray(1, 33).toString("hex")
-    const pubKeyY = rawKeyBuffer.subarray(33).toString("hex")
-
-    return {
-        pubX: BigInt(`0x${pubKeyX}`),
-        pubY: BigInt(`0x${pubKeyY}`),
-        authenticatorIdHash
-    }
-}

package/signers/webAuthnUtils.ts

@@ -1,54 +0,0 @@
-import { p256 } from "@noble/curves/p256"
-import { type Hex, bytesToBigInt, hexToBytes } from "viem"
-
-const RIP7212_SUPPORTED_NETWORKS = [80001]
-
-export const uint8ArrayToHexString = (array: Uint8Array): `0x${string}` => {
-    return `0x${Array.from(array, (byte) =>
-        byte.toString(16).padStart(2, "0")
-    ).join("")}` as `0x${string}`
-}
-
-export const b64ToBytes = (base64: string): Uint8Array => {
-    const paddedBase64 = base64
-        .replace(/-/g, "+")
-        .replace(/_/g, "/")
-        .padEnd(base64.length + ((4 - (base64.length % 4)) % 4), "=")
-    const binString = atob(paddedBase64)
-    return Uint8Array.from(binString, (m) => m.codePointAt(0) ?? 0)
-}
-
-export const findQuoteIndices = (
-    input: string
-): { beforeType: bigint; beforeChallenge: bigint } => {
-    const beforeTypeIndex = BigInt(input.lastIndexOf('"type":"webauthn.get"'))
-    const beforeChallengeIndex = BigInt(input.indexOf('"challenge'))
-    return {
-        beforeType: beforeTypeIndex,
-        beforeChallenge: beforeChallengeIndex
-    }
-}
-
-// Parse DER-encoded P256-SHA256 signature to contract-friendly signature
-// and normalize it so the signature is not malleable.
-export function parseAndNormalizeSig(derSig: Hex): { r: bigint; s: bigint } {
-    const parsedSignature = p256.Signature.fromDER(derSig.slice(2))
-    const bSig = hexToBytes(`0x${parsedSignature.toCompactHex()}`)
-    // assert(bSig.length === 64, "signature is not 64 bytes");
-    const bR = bSig.slice(0, 32)
-    const bS = bSig.slice(32)
-
-    // Avoid malleability. Ensure low S (<= N/2 where N is the curve order)
-    const r = bytesToBigInt(bR)
-    let s = bytesToBigInt(bS)
-    const n = BigInt(
-        "0xFFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551"
-    )
-    if (s > n / 2n) {
-        s = n - s
-    }
-    return { r, s }
-}
-
-export const isRIP7212SupportedNetwork = (chainId: number): boolean =>
-    RIP7212_SUPPORTED_NETWORKS.includes(chainId)