@notabene/verify-proof 1.0.0-preview.7 → 1.0.0

package/dist/solana.d.ts

@@ -1,2 +1,2 @@
-import { SignatureProof } from "@notabene/javascript-sdk/src/types";
+import { SignatureProof } from "@notabene/javascript-sdk";
 export declare function verifySolanaSignature(proof: SignatureProof): Promise<SignatureProof>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@notabene/verify-proof",
-  "version": "1.0.0-preview.7",
+  "version": "1.0.0",
   "description": "Verify ownership proofs",
   "source": "src/index.ts",
   "type": "module",
@@ -23,19 +23,12 @@
     "test": "vitest"
   },
   "devDependencies": {
-    "@types/bitcoinjs-lib": "3.4.0",
-    "@types/node": "^22.9.0",
-    "bitcoinjs-lib": "^3.2.0",
-    "buffer": "^6.0.3",
-    "ecpair": "^3.0.0-rc.0",
     "eslint": "^9.9.0",
     "microbundle": "^0.15.1",
-    "tiny-secp256k1": "^2.2.3",
+    "ox": "^0.2.2",
     "typescript": "^5.5.4",
     "vite": "^5.4.11",
-    "vitest": "^2.0.5",
-    "bitcoinjs-message": "^2.2.0",
-    "ox": "^0.1.4"
+    "vitest": "^2.0.5"
   },
   "dependencies": {
     "@bitauth/libauth": "^3.0.0",
@@ -45,7 +38,6 @@
     "bigi": "^1.4.2",
     "bs58": "^6.0.0",
     "tweetnacl": "^1.0.3",
-    "varuint-bitcoin": "^2.0.0",
-    "viem": "^2.21.44"
+    "varuint-bitcoin": "^2.0.0"
   }
 }

package/src/bitcoin.ts

@@ -1,7 +1,4 @@
-import {
-  ProofStatus,
-  SignatureProof,
-} from "@notabene/javascript-sdk/src/types";
+import { ProofStatus, SignatureProof } from "@notabene/javascript-sdk";
 import { bech32 } from "bech32";
 
 import {
@@ -21,7 +18,7 @@ enum SEGWIT_TYPES {
 
 const messagePrefix = "\u0018Bitcoin Signed Message:\n";
 
-export enum DerivationMode {
+enum DerivationMode {
   LEGACY = "Legacy",
   NATIVE = "Native SegWit",
   SEGWIT = "SegWit",
@@ -77,6 +74,7 @@ type DecodedSignature = {
   recovery: RecoveryId;
   signature: Uint8Array;
 };
+
 function decodeSignature(proof: string): DecodedSignature {
   const signature = decodeBase64(proof);
   if (signature.length !== 65) throw new Error("Invalid signature length");
@@ -146,7 +144,7 @@ function verify(
   return actual === address;
 }
 
-export function magicHash(attestation: string) {
+function magicHash(attestation: string) {
   const prefix = new TextEncoder().encode(messagePrefix);
   const message = new TextEncoder().encode(attestation);
   const length = encodeLength(message.length).buffer;

package/src/eth.ts

@@ -1,8 +1,22 @@
-import {
-  ProofStatus,
-  SignatureProof,
-} from "@notabene/javascript-sdk/src/types";
-import { verifyMessage } from "viem";
+import { ProofStatus, SignatureProof } from "@notabene/javascript-sdk";
+
+import { Secp256k1, Hex, PersonalMessage, Signature, Address } from "ox";
+
+export function verifyEIP191(
+  address: Hex.Hex,
+  message: string,
+  proof: Hex.Hex,
+): boolean {
+  try {
+    const payload = PersonalMessage.getSignPayload(Hex.fromString(message));
+    const signature = Signature.fromHex(proof);
+    const publicKey = Secp256k1.recoverPublicKey({ payload, signature });
+    const recovered = Address.fromPublicKey(publicKey);
+    return recovered.toString() === address.toString();
+  } catch (error) {
+    return false;
+  }
+}
 
 export async function verifyPersonalSignEIP191(
   proof: SignatureProof,
@@ -10,11 +24,11 @@ export async function verifyPersonalSignEIP191(
   const [ns, _, address] = proof.address.split(/:/);
   if (ns !== "eip155") return { ...proof, status: ProofStatus.FAILED };
 
-  const verified = await verifyMessage({
-    address: address as `0x${string}`,
-    message: proof.attestation,
-    signature: proof.proof as `0x${string}`,
-  });
+  const verified = verifyEIP191(
+    address as Hex.Hex,
+    proof.attestation,
+    proof.proof as Hex.Hex,
+  );
   return {
     ...proof,
     status: verified ? ProofStatus.VERIFIED : ProofStatus.FAILED,

package/src/index.ts

@@ -5,7 +5,7 @@ import {
   ScreenshotProof,
   ProofTypes,
   ProofStatus,
-} from "@notabene/javascript-sdk/src/types";
+} from "@notabene/javascript-sdk";
 import { verifyBTCSignature } from "./bitcoin";
 import { verifyPersonalSignEIP191 } from "./eth";
 import { verifySolanaSignature } from "./solana";

package/src/solana.ts

@@ -1,10 +1,8 @@
 import nacl from "tweetnacl";
-import {
-  ProofStatus,
-  SignatureProof,
-} from "@notabene/javascript-sdk/src/types";
+import { ProofStatus, SignatureProof } from "@notabene/javascript-sdk";
 import { decode as decodeBase64 } from "@stablelib/base64";
 import bs58 from "bs58";
+
 export async function verifySolanaSignature(
   proof: SignatureProof,
 ): Promise<SignatureProof> {

package/src/tests/bitcoin.test.ts

@@ -1,99 +1,61 @@
 import { describe, it, expect } from "vitest";
-import * as bitcoin from "bitcoinjs-lib";
-import * as bitcoinMessage from "bitcoinjs-message";
-import { Buffer } from "node:buffer";
 
 import { verifyBTCSignature } from "../bitcoin";
 import {
   type SignatureProof,
   ProofStatus,
   ProofTypes,
-} from "@notabene/javascript-sdk/src/types";
-
-function rng() {
-  return Buffer.from("zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz");
-}
-
-function signMessage(
-  toAddress: (kp: bitcoin.ECPair) => string,
-): SignatureProof {
-  const keyPair = bitcoin.ECPair.makeRandom({ rng: rng });
-  const address = toAddress(keyPair);
-  const sigOptions: bitcoinMessage.SignatureOptions | undefined =
-    address.startsWith("bc1") ? { segwitType: "p2wpkh" } : undefined;
-  const privateKey = keyPair.d.toBuffer(32);
-  var attestation = "This is an example of a signed message.";
-
-  var proof = bitcoinMessage
-    .sign(attestation, privateKey, keyPair.compressed, sigOptions)
-    .toString("base64");
-  // console.log("signMessage", { proof, address });
-  return {
-    type: ProofTypes.BIP137,
-    address: `bip122:000000000019d6689c085ae165831e93:${address}`,
-    did: `did:pkh:bip122:000000000019d6689c085ae165831e93:${address}`,
-    attestation,
-    proof,
-    status: ProofStatus.PENDING,
-    wallet_provider: "MetaMask",
-  };
-}
-
-function signP2PKHMessage(): SignatureProof {
-  return signMessage((kp) => kp.getAddress());
-}
-
-function signSegWitMessage(): SignatureProof {
-  return signMessage((kp) =>
-    bitcoin.address.toBech32(
-      bitcoin.crypto.hash160(kp.getPublicKeyBuffer()),
-      0,
-      kp.network.bech32 || "bc",
-    ),
-  );
-}
+} from "@notabene/javascript-sdk";
+
+const segwitProof: SignatureProof = {
+  type: ProofTypes.BIP137,
+  address:
+    "bip122:000000000019d6689c085ae165831e93:bc1qnf4kpa62dwhpwm0stsas5yv0skatt3v9s040p8",
+  did: "did:pkh:bip122:000000000019d6689c085ae165831e93:bc1qnf4kpa62dwhpwm0stsas5yv0skatt3v9s040p8",
+  attestation: "This is an example of a signed message.",
+  proof:
+    "J796FDv8f8w3syiaMSGoL6SAwPLRf6t13S+fYNjYA9EnJy3T0jZOY1eHBaGTBufOuW78FVFSwXKyUnrEjYOT9EU=",
+  status: ProofStatus.PENDING,
+  wallet_provider: "BitMask",
+};
+
+const legacyProof: SignatureProof = {
+  type: ProofTypes.BIP137,
+  address:
+    "bip122:000000000019d6689c085ae165831e93:1F5VhMHukdnUES9kfXqzPzMeF1GPHKiF64",
+  did: "did:pkh:bip122:000000000019d6689c085ae165831e93:1F5VhMHukdnUES9kfXqzPzMeF1GPHKiF64",
+  attestation: "This is an example of a signed message.",
+  proof:
+    "H796FDv8f8w3syiaMSGoL6SAwPLRf6t13S+fYNjYA9EnJy3T0jZOY1eHBaGTBufOuW78FVFSwXKyUnrEjYOT9EU=",
+  status: ProofStatus.PENDING,
+  wallet_provider: "BitMask",
+};
 
 describe("verifyBTCSignature", () => {
   it("handles native segwit addresses", async () => {
-    const proof: SignatureProof = signSegWitMessage();
-    const result = await verifyBTCSignature(proof);
-    expect(result.status).toBe(ProofStatus.VERIFIED);
+    const result = await verifyBTCSignature(segwitProof);
+    expect(result).toEqual({ ...segwitProof, status: ProofStatus.VERIFIED });
   });
 
   it("verifies legacy bitcoin address signature", async () => {
-    const proof: SignatureProof = signP2PKHMessage();
-    const result = await verifyBTCSignature(proof);
-    expect(result.status).toBe(ProofStatus.VERIFIED);
+    const result = await verifyBTCSignature(legacyProof);
+    expect(result).toEqual({ ...legacyProof, status: ProofStatus.VERIFIED });
   });
 
   it("fails for invalid bitcoin signature", async () => {
-    const proof: SignatureProof = {
-      type: ProofTypes.BIP137,
-      did: "did:pkh:bip122:000000000019d6689c085ae165831e93:1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
-      wallet_provider: "ledger",
-      address:
-        "bip122:000000000019d6689c085ae165831e93:1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
-      attestation: "test message",
-      proof: "invalid_signature",
-      status: ProofStatus.PENDING,
-    };
+    const proof: SignatureProof = { ...legacyProof, proof: "invalitd" };
 
     const result = await verifyBTCSignature(proof);
-    expect(result.status).toBe(ProofStatus.FAILED);
+    expect(result).toEqual({ ...proof, status: ProofStatus.FAILED });
   });
 
   it("returns failed proof for non-BIP122 address", async () => {
     const proof: SignatureProof = {
-      type: ProofTypes.EIP191,
-      status: ProofStatus.PENDING,
-      did: "did:example:123",
+      ...legacyProof,
       address: "eip155:1:0x1234567890123456789012345678901234567890",
-      proof: "0x1234567890",
-      attestation: "I own this address",
-      wallet_provider: "MetaMask",
     };
 
     const result = await verifyBTCSignature(proof);
-    expect(result.status).toBe(ProofStatus.FAILED);
+    expect(result).toEqual({ ...proof, status: ProofStatus.FAILED });
   });
 });

package/src/tests/eth.test.ts

@@ -4,7 +4,7 @@ import {
   type SignatureProof,
   ProofStatus,
   ProofTypes,
-} from "@notabene/javascript-sdk/src/types";
+} from "@notabene/javascript-sdk";
 
 import { Hex, Address, PersonalMessage, Secp256k1, Signature } from "ox";
 

package/src/tests/index.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi } from "vitest";
+import { describe, it, expect } from "vitest";
 import { verifyProof } from "../index";
 import {
   type DeclarationProof,
@@ -6,13 +6,7 @@ import {
   type SignatureProof,
   ProofStatus,
   ProofTypes,
-} from "@notabene/javascript-sdk/src/types";
-import { verifyMessage } from "viem";
-
-// Mock viem's verifyMessage function
-vi.mock("viem", () => ({
-  verifyMessage: vi.fn(),
-}));
+} from "@notabene/javascript-sdk";
 
 describe("verifyProof", () => {
   it("should verify a confirmed checkbox proof", async () => {
@@ -87,68 +81,86 @@ describe("verifyProof", () => {
     expect(result).toEqual(proof);
   });
 
-  it("should verify a valid PersonalSignEIP191 proof", async () => {
+  describe("eip191", () => {
     const proof: SignatureProof = {
       type: ProofTypes.EIP191,
+      address: "eip155:1:0x772f226b9cc93a2953dc5868864de72f90441caf",
+      did: "did:pkh:eip155:1:0x772f226b9cc93a2953dc5868864de72f90441caf",
+      attestation: "I agree",
+      proof:
+        "0xddd74ca17084728a167b6f99326b50a0ce4a1ce4f80a56da4a60b23b69637c624e6dfb2270de56caece9182200fe38791339cbf097586a4e06a9ef4bd298cc1800",
       status: ProofStatus.PENDING,
-      did: "did:example:123",
-      address: "eip155:1:0x1234567890123456789012345678901234567890",
-      proof: "0x1234567890",
-      attestation: "I own this address",
       wallet_provider: "MetaMask",
     };
 
-    // Mock successful verification
-    (verifyMessage as jest.Mock).mockResolvedValue(true);
+    it("should verify proof", async () => {
+      const result = await verifyProof(proof);
+      expect(result.status).toBe(ProofStatus.VERIFIED);
+    });
 
-    const result = await verifyProof(proof);
+    it("should fail if not invalid proof", async () => {
+      const result = await verifyProof({
+        ...proof,
+        proof: "0x",
+      } as SignatureProof);
 
-    expect(result.status).toBe(ProofStatus.VERIFIED);
-    expect(verifyMessage).toHaveBeenCalledWith({
-      address: "0x1234567890123456789012345678901234567890",
-      message: proof.attestation,
-      signature: proof.proof,
+      expect(result.status).toBe(ProofStatus.FAILED);
     });
   });
 
-  it("should fail an invalid PersonalSignEIP191 proof", async () => {
+  describe("solana", () => {
     const proof: SignatureProof = {
-      type: ProofTypes.EIP191,
+      type: ProofTypes.ED25519,
       status: ProofStatus.PENDING,
-      did: "did:example:123",
-      address: "eip155:1:0x1234567890123456789012345678901234567890",
-      proof: "0x1234567890",
-      attestation: "I own this address",
-      wallet_provider: "MetaMask",
+      did: "did:pkh:solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:3GgW39JvdBVCAdiK1mafeBcBKXJq8mee5woVoDARRnPq",
+      address:
+        "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:3GgW39JvdBVCAdiK1mafeBcBKXJq8mee5woVoDARRnPq",
+      attestation: "Test message",
+      proof:
+        "8dkeX3S+qisPkadV5QkmLWu2gbom/ljqlEwDAVuEV33HWZbSbPol+KV/zET4NLn8JBvSpu6JROJRg45WAIMPAQ==",
+      wallet_provider: "Phantom",
     };
 
-    // Mock failed verification
-    (verifyMessage as jest.Mock).mockResolvedValue(false);
+    it("should verify proof", async () => {
+      const result = await verifyProof(proof);
+      expect(result.status).toBe(ProofStatus.VERIFIED);
+    });
 
-    const result = await verifyProof(proof);
+    it("should fail if not invalid proof", async () => {
+      const result = await verifyProof({
+        ...proof,
+        proof: "0x",
+      } as SignatureProof);
 
-    expect(result.status).toBe(ProofStatus.FAILED);
-    expect(verifyMessage).toHaveBeenCalledWith({
-      address: "0x1234567890123456789012345678901234567890",
-      message: proof.attestation,
-      signature: proof.proof,
+      expect(result.status).toBe(ProofStatus.FAILED);
     });
   });
 
-  it("should fail if not eip155 proof", async () => {
+  describe("bitcoin", () => {
     const proof: SignatureProof = {
-      type: ProofTypes.EIP191,
+      type: ProofTypes.BIP137,
       status: ProofStatus.PENDING,
-      did: "did:example:123",
       address:
-        "bip122:000000000019d6689c085ae165831e93:128Lkh3S7CkDTBZ8W7BbpsN3YYizJMp8p6",
-      proof: "0x1234567890",
-      attestation: "I own this address",
-      wallet_provider: "MetaMask",
+        "bip122:000000000019d6689c085ae165831e93:bc1qnf4kpa62dwhpwm0stsas5yv0skatt3v9s040p8",
+      did: "did:pkh:bip122:000000000019d6689c085ae165831e93:bc1qnf4kpa62dwhpwm0stsas5yv0skatt3v9s040p8",
+      attestation: "This is an example of a signed message.",
+      proof:
+        "J796FDv8f8w3syiaMSGoL6SAwPLRf6t13S+fYNjYA9EnJy3T0jZOY1eHBaGTBufOuW78FVFSwXKyUnrEjYOT9EU=",
+      wallet_provider: "Phantom",
     };
 
-    const result = await verifyProof(proof);
+    it("should verify proof", async () => {
+      const result = await verifyProof(proof);
+      expect(result.status).toBe(ProofStatus.VERIFIED);
+    });
 
-    expect(result.status).toBe(ProofStatus.FAILED);
+    it("should fail if not invalid proof", async () => {
+      const result = await verifyProof({
+        ...proof,
+        proof: "0x",
+      } as SignatureProof);
+
+      expect(result.status).toBe(ProofStatus.FAILED);
+    });
   });
 });

package/src/tests/solana.test.ts

@@ -5,7 +5,7 @@ import {
   ProofStatus,
   ProofTypes,
   SignatureProof,
-} from "@notabene/javascript-sdk/src/types";
+} from "@notabene/javascript-sdk";
 import { verifySolanaSignature } from "../solana";
 
 describe("verifySolanaSignature", () => {
@@ -25,6 +25,7 @@ describe("verifySolanaSignature", () => {
       proof: Buffer.from(signature).toString("base64"),
       wallet_provider: "Phantom",
     };
+
     const result = await verifySolanaSignature(proof);
     expect(result.status).toBe(ProofStatus.VERIFIED);
   });