@notabene/verify-proof 1.3.3-next.1 → 1.4.0

package/dist/tests/xlm.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/xlm.d.ts

@@ -0,0 +1,2 @@
+import { SignatureProof } from "@notabene/javascript-sdk";
+export declare function verifyStellarSignature(proof: SignatureProof): SignatureProof;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@notabene/verify-proof",
-  "version": "1.3.3-next.1",
+  "version": "1.4.0",
   "description": "Verify ownership proofs",
   "source": "src/index.ts",
   "type": "module",
@@ -45,12 +45,13 @@
   "dependencies": {
     "@cardano-foundation/cardano-verify-datasignature": "^1.0.11",
     "@noble/curves": "^1.7.0",
-    "@notabene/javascript-sdk": "^2.8.0-next.3",
+    "@notabene/javascript-sdk": "2.9.0",
     "@scure/base": "^1.2.1",
+    "@stellar/stellar-sdk": "^13.1.0",
     "bip322-js": "^2.0.0",
     "ox": "^0.2.2",
     "tweetnacl": "^1.0.3",
     "varuint-bitcoin": "^2.0.0",
-    "xrpl": "^4.2.0"
+    "xrpl": "^4.2.5"
   }
 }

package/src/index.ts

@@ -12,6 +12,7 @@ import { verifySolanaSignature } from "./solana";
 import { verifyPersonalSignTIP191 } from "./tron";
 import { verifyCIP8Signature } from "./cardano";
 import { verifyPersonalSignXRPL } from "./xrpl";
+import { verifyStellarSignature } from "./xlm";
 
 export async function verifyProof(
   proof: OwnershipProof,
@@ -40,6 +41,8 @@ export async function verifyProof(
         return verifySolanaSignature(proof as SignatureProof);
     case ProofTypes.XRP_ED25519:
       return verifyPersonalSignXRPL(proof as SignatureProof, publicKey);
+    case ProofTypes.XLM_ED25519:
+      return verifyStellarSignature(proof as SignatureProof);
     case ProofTypes.EIP712:
     case ProofTypes.BIP137:
     case ProofTypes.BIP322:

package/src/tests/index.test.ts

@@ -248,4 +248,39 @@ describe("verifyProof", () => {
       expect(result.status).toBe(ProofStatus.FAILED);
     });
   });
+
+  describe("Stellar", () => {
+    const proof: SignatureProof = {
+      address: 'stellar:pubnet:GB4G3PJUA5NKFY5U4OJQGNZUL3QUPAJLMARNWXZNBKMGOUQJLPGXPOYG',
+      attestation: 'test message',
+      proof: 'Y8H4RDjxGsYSgDgLWsFN9i2vk/7cqc/nLejYK/MIElBcpeZxjn18qES92EuMMvkSIVnanRvTXSploOuHU9WCAQ==',
+      status: ProofStatus.PENDING,
+      type: ProofTypes.XLM_ED25519,
+      wallet_provider: 'STELLAR',
+      did: 'did:pkh:stellar:pubnet:GB4G3PJUA5NKFY5U4OJQGNZUL3QUPAJLMARNWXZNBKMGOUQJLPGXPOYG'
+    };
+
+    it("should verify proof", async () => {
+      const result = await verifyProof(proof);
+      expect(result.status).toBe(ProofStatus.VERIFIED);
+    });
+
+    it("should fail if invalid proof", async () => {
+      const result = await verifyProof({
+        ...proof,
+        proof: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+      } as SignatureProof);
+
+      expect(result.status).toBe(ProofStatus.FAILED);
+    });
+
+    it("should fail if invalid address format", async () => {
+      const result = await verifyProof({
+        ...proof,
+        address: "stellar:pubnet:not-a-valid-public-key"
+      } as SignatureProof);
+
+      expect(result.status).toBe(ProofStatus.FAILED);
+    });
+  });
 });

package/src/tests/xlm.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect } from "vitest";
+import { Keypair } from "@stellar/stellar-sdk";
+import { verifyStellarSignature } from "../xlm";
+import { ProofStatus, ProofTypes, SignatureProof } from "@notabene/javascript-sdk";
+
+describe("verifyStellarSignature", () => {
+  const createValidProof = (): SignatureProof => {
+    const keypair = Keypair.fromSecret("SBKMCWGXNN6C6QMCXOUZFQ4DSCACRE4FKIIFQMBFORXLOATUUM7SH4SV");
+    const message = "test message";
+    const messageBuffer = Buffer.from(message, "utf-8");
+    const signature = keypair.sign(messageBuffer);
+
+    return {
+      address: `stellar:pubnet:${keypair.publicKey().toString()}`,
+      attestation: message,
+      proof: signature.toString("base64"),
+      status: ProofStatus.PENDING,
+      type: ProofTypes.XLM_ED25519,
+      wallet_provider: "STELLAR",
+      did: `did:pkh:stellar:pubnet:${keypair.publicKey().toString()}`
+    };
+  };
+
+  it("should verify a valid Stellar signature", () => {
+    const proof = createValidProof();
+    const result = verifyStellarSignature(proof);
+    expect(result.status).toBe(ProofStatus.VERIFIED);
+  });
+
+  it("should fail for invalid signature", () => {
+    const keypair1 = Keypair.random();
+    const keypair2 = Keypair.random();
+    const message = "test message";
+    const messageBuffer = Buffer.from(message, "utf-8");
+    const signature = keypair1.sign(messageBuffer);
+    
+    const proof: SignatureProof = {
+      address: `stellar:pubnet:${keypair2.publicKey().toString()}`,
+      attestation: message,
+      proof: signature.toString("base64"),
+      status: ProofStatus.PENDING,
+      type: ProofTypes.XLM_ED25519,
+      wallet_provider: "STELLAR",
+      did: `did:pkh:stellar:pubnet:${keypair2.publicKey().toString()}`
+    };
+
+    const result = verifyStellarSignature(proof);
+    expect(result.status).toBe(ProofStatus.FAILED);
+  });
+
+  it("should fail for non-xlm namespace", () => {
+    const proof = {
+      ...createValidProof(),
+      address: "eip155:1:0x000000000000000000000000000000000000dead" // Different namespace
+    } as SignatureProof;
+
+    const result = verifyStellarSignature(proof);
+    expect(result.status).toBe(ProofStatus.FAILED);
+  });
+
+  it("should fail for malformed address", () => {
+    const proof = {
+      ...createValidProof(),
+      address: "stellar:pubnet"
+    } as unknown as SignatureProof;
+
+    const result = verifyStellarSignature(proof);
+    expect(result.status).toBe(ProofStatus.FAILED);
+  });
+
+  it("should fail for invalid public key format", () => {
+    const proof = {
+      ...createValidProof(),
+      address: "stellar:pubnet:not-a-valid-public-key"
+    } as SignatureProof;
+
+    const result = verifyStellarSignature(proof);
+    expect(result.status).toBe(ProofStatus.FAILED);
+  });
+});

package/src/xlm.ts

@@ -0,0 +1,25 @@
+import { ProofStatus, SignatureProof } from "@notabene/javascript-sdk";
+import { Keypair } from "@stellar/stellar-sdk";
+
+export function verifyStellarSignature(
+  proof: SignatureProof,
+): SignatureProof {
+  const [ns, , address] = proof.address.split(/:/);
+  if (ns !== "stellar") return { ...proof, status: ProofStatus.FAILED };
+
+  try {
+    const keypair = Keypair.fromPublicKey(address);
+    const messageBuffer = Buffer.from(proof.attestation, "utf-8");
+    const signatureBuffer = Buffer.from(proof.proof, "base64");
+
+    const verified = keypair.verify(messageBuffer, signatureBuffer);
+
+    return {
+      ...proof,
+      status: verified ? ProofStatus.VERIFIED : ProofStatus.FAILED,
+    };
+  } catch (error) {
+    console.error(error);
+    return { ...proof, status: ProofStatus.FAILED };
+  }
+}