@notabene/verify-proof 1.0.0-preview.6 → 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,10 +1,11 @@
 {
   "name": "@notabene/verify-proof",
-  "version": "1.0.0-preview.6",
+  "version": "1.0.0",
   "description": "Verify ownership proofs",
   "source": "src/index.ts",
   "type": "module",
   "module": "dist/index.js",
+  "types": "dist/index.d.ts",
   "main": "dist/index.cjs",
   "author": "Pelle Braendgaard",
   "license": "Apache-2.0",
@@ -22,25 +23,21 @@
     "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"
   },
   "dependencies": {
+    "@bitauth/libauth": "^3.0.0",
     "@notabene/javascript-sdk": "^2.0.2",
-    "@solana/web3.js": "^1.95.4",
     "@stablelib/base64": "^2.0.0",
+    "bech32": "^2.0.0",
     "bigi": "^1.4.2",
-    "bitcoinjs-message": "^2.2.0",
-    "ox": "^0.1.4",
+    "bs58": "^6.0.0",
     "tweetnacl": "^1.0.3",
-    "viem": "^2.21.44"
+    "varuint-bitcoin": "^2.0.0"
   }
 }

package/src/bitcoin.ts

@@ -1,10 +1,24 @@
+import { ProofStatus, SignatureProof } from "@notabene/javascript-sdk";
+import { bech32 } from "bech32";
+
 import {
-  ProofStatus,
-  SignatureProof,
-} from "@notabene/javascript-sdk/src/types";
-import * as bitcoinMessage from "bitcoinjs-message";
+  secp256k1,
+  hash160,
+  hash256,
+  RecoveryId,
+  encodeBase58AddressFormat,
+} from "@bitauth/libauth";
+import { encode as encodeLength } from "varuint-bitcoin";
+import { decode as decodeBase64 } from "@stablelib/base64";
+
+enum SEGWIT_TYPES {
+  P2WPKH = "p2wpkh",
+  P2SH_P2WPKH = "p2sh(p2wpkh)",
+}
+
+const messagePrefix = "\u0018Bitcoin Signed Message:\n";
 
-export enum DerivationMode {
+enum DerivationMode {
   LEGACY = "Legacy",
   NATIVE = "Native SegWit",
   SEGWIT = "SegWit",
@@ -25,13 +39,7 @@ export async function verifyBTCSignature(
     const segwit = [DerivationMode.SEGWIT, DerivationMode.NATIVE].includes(
       getDerivationMode(address),
     );
-    const verified = bitcoinMessage.verify(
-      proof.attestation,
-      address,
-      proof.proof,
-      undefined,
-      segwit,
-    );
+    const verified = verify(proof.attestation, address, proof.proof, segwit);
 
     return {
       ...proof,
@@ -59,3 +67,98 @@ function getDerivationMode(address: string) {
     );
   }
 }
+
+type DecodedSignature = {
+  compressed: boolean;
+  segwitType?: SEGWIT_TYPES;
+  recovery: RecoveryId;
+  signature: Uint8Array;
+};
+
+function decodeSignature(proof: string): DecodedSignature {
+  const signature = decodeBase64(proof);
+  if (signature.length !== 65) throw new Error("Invalid signature length");
+
+  const flagByte = signature[0] - 27;
+  if (flagByte > 15 || flagByte < 0) {
+    throw new Error("Invalid signature parameter");
+  }
+
+  return {
+    compressed: !!(flagByte & 12),
+    segwitType: !(flagByte & 8)
+      ? undefined
+      : !(flagByte & 4)
+        ? SEGWIT_TYPES.P2SH_P2WPKH
+        : SEGWIT_TYPES.P2WPKH,
+    recovery: (flagByte & 3) as RecoveryId,
+    signature: signature.slice(1),
+  };
+}
+
+function verify(
+  attestation: string,
+  address: string,
+  proof: string,
+  checkSegwitAlways: boolean,
+) {
+  const { compressed, segwitType, recovery, signature } =
+    decodeSignature(proof);
+  if (checkSegwitAlways && !compressed) {
+    throw new Error(
+      "checkSegwitAlways can only be used with a compressed pubkey signature flagbyte",
+    );
+  }
+
+  const hash = magicHash(attestation);
+  const publicKey: Uint8Array | string = compressed
+    ? secp256k1.recoverPublicKeyCompressed(signature, recovery, hash)
+    : secp256k1.recoverPublicKeyUncompressed(signature, recovery, hash);
+  if (typeof publicKey === "string") throw new Error(publicKey);
+  const publicKeyHash = hash160(publicKey);
+  let actual: string = "";
+
+  if (segwitType) {
+    if (segwitType === SEGWIT_TYPES.P2SH_P2WPKH) {
+      actual = encodeBech32Address(publicKeyHash);
+    } else {
+      // parsed.segwitType === SEGWIT_TYPES.P2WPKH
+      // must be true since we only return null, P2SH_P2WPKH, or P2WPKH
+      // from the decodeSignature function.
+      actual = encodeBech32Address(publicKeyHash);
+    }
+  } else {
+    if (checkSegwitAlways) {
+      try {
+        actual = encodeBech32Address(publicKeyHash);
+        // if address is bech32 it is not p2sh
+      } catch (e) {
+        actual = encodeBech32Address(publicKeyHash);
+        // base58 can be p2pkh or p2sh-p2wpkh
+      }
+    } else {
+      actual = encodeBase58AddressFormat(0, publicKeyHash);
+    }
+  }
+
+  return actual === address;
+}
+
+function magicHash(attestation: string) {
+  const prefix = new TextEncoder().encode(messagePrefix);
+  const message = new TextEncoder().encode(attestation);
+  const length = encodeLength(message.length).buffer;
+  const buffer = new Uint8Array(
+    prefix.length + length.byteLength + message.length,
+  );
+  buffer.set(prefix);
+  buffer.set(new Uint8Array(length), prefix.length);
+  buffer.set(message, prefix.length + length.byteLength);
+  return hash256(buffer);
+}
+
+function encodeBech32Address(publicKeyHash: Uint8Array): string {
+  const bwords = bech32.toWords(publicKeyHash);
+  bwords.unshift(0);
+  return bech32.encode("bc", bwords);
+}

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,7 @@
-import { PublicKey } from "@solana/web3.js";
 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,
@@ -12,13 +9,13 @@ export async function verifySolanaSignature(
   const [ns, _, address] = proof.address.split(/:/);
   if (ns !== "solana") return { ...proof, status: ProofStatus.FAILED };
   try {
-    const publicKey = new PublicKey(address);
+    const publicKey = bs58.decode(address);
     const messageBytes = new TextEncoder().encode(proof.attestation);
     const signatureBytes = decodeBase64(proof.proof);
     const verified = nacl.sign.detached.verify(
       messageBytes,
       signatureBytes,
-      publicKey.toBytes(),
+      publicKey,
     );
 
     return {

package/src/tests/bitcoin.test.ts

@@ -1,95 +1,61 @@
-import { describe, it, expect, vi } from "vitest";
-import * as bitcoin from "bitcoinjs-lib";
-import * as bitcoinMessage from "bitcoinjs-message";
-import { Buffer } from "node:buffer";
+import { describe, it, expect } from "vitest";
 
 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 privateKey = keyPair.d.toBuffer(32);
-  var attestation = "This is an example of a signed message.";
-  var proof = bitcoinMessage
-    .sign(attestation, privateKey, keyPair.compressed)
-    .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",
-      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

@@ -1,10 +1,10 @@
-import { describe, it, expect, vi } from "vitest";
+import { describe, it, expect } from "vitest";
 import { verifyPersonalSignEIP191 } from "../eth";
 import {
   type SignatureProof,
   ProofStatus,
   ProofTypes,
-} from "@notabene/javascript-sdk/src/types";
+} from "@notabene/javascript-sdk";
 
 import { Hex, Address, PersonalMessage, Secp256k1, Signature } from "ox";
 
@@ -45,6 +45,7 @@ describe("verifyPersonalSignEIP191", () => {
     const proof: SignatureProof = {
       type: ProofTypes.EIP191,
       did: `did:pkh:bip122:000000000019d6689c085ae165831e93:128Lkh3S7CkDTBZ8W7BbpsN3YYizJMp8p6`,
+      wallet_provider: "metamask",
       address:
         "bip122:000000000019d6689c085ae165831e93:128Lkh3S7CkDTBZ8W7BbpsN3YYizJMp8p6",
       attestation: "test message",

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

@@ -1,40 +1,41 @@
 import { describe, it, expect } from "vitest";
-import { Keypair } from "@solana/web3.js";
+import bs58 from "bs58";
 import nacl from "tweetnacl";
 import {
   ProofStatus,
   ProofTypes,
   SignatureProof,
-} from "@notabene/javascript-sdk/src/types";
+} from "@notabene/javascript-sdk";
 import { verifySolanaSignature } from "../solana";
 
 describe("verifySolanaSignature", () => {
+  const keypair = nacl.sign.keyPair();
+  const address = bs58.encode(keypair.publicKey);
   it("verifies valid Solana signature", async () => {
     // Generate a test keypair
-    const keypair = Keypair.generate();
     const message = "Test message";
     const messageBytes = new TextEncoder().encode(message);
     const signature = nacl.sign.detached(messageBytes, keypair.secretKey);
     const proof: SignatureProof = {
       type: ProofTypes.ED25519,
       status: ProofStatus.PENDING,
-      did: `did:pkh:solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:${keypair.publicKey.toString()}`,
-      address: `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:${keypair.publicKey.toString()}`,
+      did: `did:pkh:solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:${address}`,
+      address: `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:${address}`,
       attestation: message,
       proof: Buffer.from(signature).toString("base64"),
       wallet_provider: "Phantom",
     };
+
     const result = await verifySolanaSignature(proof);
     expect(result.status).toBe(ProofStatus.VERIFIED);
   });
 
   it("fails for invalid signature", async () => {
-    const keypair = Keypair.generate();
     const proof: SignatureProof = {
       type: ProofTypes.ED25519,
       status: ProofStatus.PENDING,
-      did: `did:pkh:solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:${keypair.publicKey.toString()}`,
-      address: `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:${keypair.publicKey.toString()}`,
+      did: `did:pkh:solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:${address}`,
+      address: `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:${address}`,
       attestation: "Test message",
       proof: "invalid_signature",
       wallet_provider: "Phantom",