@notabene/verify-proof 1.2.0-next.1 → 1.3.0-next.1

package/src/tests/xrpl.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect } from "vitest";
+import { verifyPersonalSignXRPL } from "../xrpl";
+import { Wallet } from "xrpl";
+import { sign } from "ripple-keypairs";
+import {
+  type SignatureProof,
+  ProofStatus,
+  ProofTypes,
+} from "@notabene/javascript-sdk";
+
+describe("verifyPersonalSignXRPL", async () => {
+  // Create test wallets using seed
+  const ed25519 = Wallet.fromSeed("snoPBrXtMeMyMHUVTgbuqAfg1SUTb");
+  const message = "Ripple signature test";
+
+  function createXRPLProof(wallet: Wallet): SignatureProof {
+    const messageHex = Buffer.from(message).toString("hex");
+    const signature = sign(messageHex, wallet.privateKey);
+
+    return {
+      type: ProofTypes.ED25519,
+      address: `xrpl:1:${wallet.address}`,
+      did: `did:pkh:xrpl:1:${wallet.address}`,
+      attestation: message,
+      proof: signature,
+      status: ProofStatus.PENDING,
+      wallet_provider: "XRPL",
+    };
+  }
+
+   function existingXRPLProof(): SignatureProof {
+    return {
+      type: ProofTypes.ED25519,
+      proof: 'B080C34BCD2F1392420A5CB46C14772AC54841181CB3387A0793025C480A6A52292A869FB2B86B89EA33E096285F8CC45F5D35D4E29750BA8E127076CADF7906',
+      address: `xrpl:1:rGWNp4P9DJpDNhPc7t9GeHoQb8SCKWBfYV`,
+      did: `did:pkh:xrpl:1:rGWNp4P9DJpDNhPc7t9GeHoQb8SCKWBfYV`,
+      status: ProofStatus.PENDING,
+      wallet_provider: "XRPL",
+      attestation: "I certify that\n\nxrpl:1 account rGWNp4P9DJpDNhPc7t9GeHoQb8SCKWBfYV\n\nbelonged to did:key:z6Mkq3vnQfZFLVe2UXBUTgonfEhzYr9QF7xvkSSpdt9LXeY6\n\non Thu, 06 Mar 2025 10:34:43 GMT"
+    }
+  }
+
+  it("returns verified proof when valid existing XRPL proof", async () => {
+    const proof = existingXRPLProof();
+    const result = await verifyPersonalSignXRPL(proof, undefined, true);
+    expect(result.status).toBe(ProofStatus.VERIFIED);
+  });
+
+  it("returns verified proof when valid secp256k1 signature", async () => {
+    const proof = createXRPLProof(ed25519);
+    const result = await verifyPersonalSignXRPL(
+      proof,
+      ed25519.publicKey
+    );
+    expect(result.status).toBe(ProofStatus.VERIFIED);
+  });
+
+  it("returns failed proof when invalid message", async () => {
+    const proof = {
+      ...createXRPLProof(ed25519),
+      attestation: "evil text",
+    };
+    const result = await verifyPersonalSignXRPL(
+      proof,
+      ed25519.publicKey
+    );
+    expect(result.status).toBe(ProofStatus.FAILED);
+  });
+
+  it("returns failed proof for non-XRPL address", async () => {
+    const proof: SignatureProof = {
+      type: ProofTypes.ED25519,
+      did: `did:pkh:eip155:1:0x123`,
+      wallet_provider: "XRPL",
+      address: "eip155:1:0x123",
+      attestation: "test message",
+      proof: "signature",
+      status: ProofStatus.PENDING,
+    };
+
+    const result = await verifyPersonalSignXRPL(
+      proof,
+      ed25519.publicKey
+    );
+    expect(result.status).toBe(ProofStatus.FAILED);
+  });
+});

package/src/xrpl.ts

@@ -0,0 +1,94 @@
+import { ProofStatus, SignatureProof } from "@notabene/javascript-sdk";
+import { AccountTxTransaction, Client } from "xrpl";
+import { verify } from "ripple-keypairs";
+
+export function verifyXRPL(
+  message: string,
+  publicKey: string,
+  proof: string
+): boolean {
+  return verify(Buffer.from(message).toString("hex"), proof, publicKey);
+}
+
+export const xrplTestnetWs = [
+  "wss://s.altnet.rippletest.net:51233",
+  "wss://testnet.xrpl-labs.com/",
+];
+
+export const xrplMainnetWs = [
+  "wss://s1.ripple.com",
+  "wss://xrplcluster.com/", // full node
+  "wss://s2.ripple.com/",
+];
+
+// If the public key is not provided, we need to get it directly
+async function getPublicKey(
+  address: string,
+  isTest?: boolean
+): Promise<string | undefined> {
+  const servers = isTest ? xrplTestnetWs : xrplMainnetWs;
+
+  for (const server of servers) {
+    try {
+      const client = new Client(server);
+      await client.connect();
+
+      const response = await client.request({
+        command: "account_tx",
+        account: address,
+        binary: false,
+        limit: 2,
+        forward: false,
+      });
+
+      await client.disconnect();
+      return getSigningPubkeyFromLatestTx(response.result?.transactions);
+    } catch (error) {
+      let errorMessage = "Connection to XRPL server failed";
+      if (error instanceof Error) {
+        errorMessage += `: ${error.message}`;
+      }
+      console.error(errorMessage);
+      // Continue to next server
+    }
+  }
+
+  throw new Error("Failed to connect to any XRPL server");
+}
+
+function getSigningPubkeyFromLatestTx(
+  latestTx: AccountTxTransaction[]
+): string {
+  for (let i = 0; i < latestTx.length; i++) {
+    // Check if the Account in the .tx is the address derived from the pubkey
+    const signingPubKey = latestTx[i]?.tx_json?.SigningPubKey ?? "0x";
+    // TODO: https://github.com/Cypher-Laboratory/xrpl-publickey-getter/blob/main/src/pubKeyGetter.ts#L98
+    // Check the public key matches the address properly
+    return signingPubKey;
+  }
+  throw new Error("No valid pubkey found in the latest transactions");
+}
+
+export async function verifyPersonalSignXRPL(
+  proof: SignatureProof,
+  publicKey?: string,
+  isTest?: boolean
+): Promise<SignatureProof> {
+  const [ns, , address] = proof.address.split(/:/);
+  if (ns !== "xrpl") return { ...proof, status: ProofStatus.FAILED };
+
+  if (!publicKey) {
+    publicKey = await getPublicKey(address, isTest);
+  }
+
+  if (!publicKey) {
+    return { ...proof, status: ProofStatus.FAILED };
+  }
+
+  const verified = verifyXRPL(proof.attestation, publicKey, proof.proof);
+
+  return {
+    ...proof,
+    status: verified ? ProofStatus.VERIFIED : ProofStatus.FAILED,
+  };
+}