@teneo-protocol/sdk 1.0.0 → 2.0.0

package/src/utils/signature-verifier.test.ts

@@ -9,8 +9,12 @@ import { BaseMessage, createUserMessage } from "../types";
 
 describe("SignatureVerifier", () => {
   // Test accounts
-  const testAccount1 = privateKeyToAccount('0x1234567890123456789012345678901234567890123456789012345678901234');
-  const testAccount2 = privateKeyToAccount('0xabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcd');
+  const testAccount1 = privateKeyToAccount(
+    "0x1234567890123456789012345678901234567890123456789012345678901234"
+  );
+  const testAccount2 = privateKeyToAccount(
+    "0xabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcd"
+  );
 
   describe("constructor", () => {
     it("should create verifier with default options", () => {
@@ -25,13 +29,13 @@ describe("SignatureVerifier", () => {
     it("should create verifier with custom options", () => {
       const verifier = new SignatureVerifier({
         trustedAddresses: [testAccount1.address],
-        requireSignaturesFor: ['task_response', 'agent_selected'],
+        requireSignaturesFor: ["task_response", "agent_selected"],
         strictMode: true
       });
 
       const options = verifier.getOptions();
       expect(options.trustedAddresses).toEqual([testAccount1.address]);
-      expect(options.requireSignaturesFor).toEqual(['task_response', 'agent_selected']);
+      expect(options.requireSignaturesFor).toEqual(["task_response", "agent_selected"]);
       expect(options.strictMode).toBe(true);
     });
   });
@@ -40,46 +44,46 @@ describe("SignatureVerifier", () => {
     it("should exclude signature and publicKey fields", () => {
       const verifier = new SignatureVerifier();
       const message: BaseMessage = {
-        type: 'message',
-        content: 'Hello',
-        from: 'agent1',
-        signature: '0xsignature',
-        publicKey: '0xpublickey',
-        timestamp: '2024-01-01T00:00:00Z'
+        type: "message",
+        content: "Hello",
+        from: "agent1",
+        signature: "0xsignature",
+        publicKey: "0xpublickey",
+        timestamp: "2024-01-01T00:00:00Z"
       };
 
       const signable = verifier.getSignableContent(message);
 
-      expect(signable).not.toHaveProperty('signature');
-      expect(signable).not.toHaveProperty('publicKey');
-      expect(signable).not.toHaveProperty('id');
-      expect(signable).toHaveProperty('type');
-      expect(signable).toHaveProperty('content');
-      expect(signable).toHaveProperty('from');
+      expect(signable).not.toHaveProperty("signature");
+      expect(signable).not.toHaveProperty("publicKey");
+      expect(signable).not.toHaveProperty("id");
+      expect(signable).toHaveProperty("type");
+      expect(signable).toHaveProperty("content");
+      expect(signable).toHaveProperty("from");
     });
 
     it("should exclude undefined fields", () => {
       const verifier = new SignatureVerifier();
       const message: BaseMessage = {
-        type: 'message',
-        content: 'Hello',
+        type: "message",
+        content: "Hello",
         from: undefined,
-        room: 'general'
+        room: "general"
       };
 
       const signable = verifier.getSignableContent(message);
 
-      expect(signable).not.toHaveProperty('from');
-      expect(signable).toHaveProperty('type');
-      expect(signable).toHaveProperty('content');
-      expect(signable).toHaveProperty('room');
+      expect(signable).not.toHaveProperty("from");
+      expect(signable).toHaveProperty("type");
+      expect(signable).toHaveProperty("content");
+      expect(signable).toHaveProperty("room");
     });
   });
 
   describe("createMessageHash", () => {
     it("should create consistent hashes for same content", () => {
       const verifier = new SignatureVerifier();
-      const content = { type: 'message', content: 'Hello' };
+      const content = { type: "message", content: "Hello" };
 
       const hash1 = verifier.createMessageHash(content);
       const hash2 = verifier.createMessageHash(content);
@@ -89,8 +93,8 @@ describe("SignatureVerifier", () => {
 
     it("should create different hashes for different content", () => {
       const verifier = new SignatureVerifier();
-      const content1 = { type: 'message', content: 'Hello' };
-      const content2 = { type: 'message', content: 'World' };
+      const content1 = { type: "message", content: "Hello" };
+      const content2 = { type: "message", content: "World" };
 
       const hash1 = verifier.createMessageHash(content1);
       const hash2 = verifier.createMessageHash(content2);
@@ -100,8 +104,8 @@ describe("SignatureVerifier", () => {
 
     it("should create same hash regardless of key order", () => {
       const verifier = new SignatureVerifier();
-      const content1 = { type: 'message', content: 'Hello', from: 'agent' };
-      const content2 = { from: 'agent', content: 'Hello', type: 'message' };
+      const content1 = { type: "message", content: "Hello", from: "agent" };
+      const content2 = { from: "agent", content: "Hello", type: "message" };
 
       const hash1 = verifier.createMessageHash(content1);
       const hash2 = verifier.createMessageHash(content2);
@@ -113,27 +117,27 @@ describe("SignatureVerifier", () => {
   describe("isSignatureRequired", () => {
     it("should return false when message type not in required list", () => {
       const verifier = new SignatureVerifier({
-        requireSignaturesFor: ['task_response']
+        requireSignaturesFor: ["task_response"]
       });
 
-      expect(verifier.isSignatureRequired('message')).toBe(false);
-      expect(verifier.isSignatureRequired('ping')).toBe(false);
+      expect(verifier.isSignatureRequired("message")).toBe(false);
+      expect(verifier.isSignatureRequired("ping")).toBe(false);
     });
 
     it("should return true when message type is in required list", () => {
       const verifier = new SignatureVerifier({
-        requireSignaturesFor: ['task_response', 'agent_selected']
+        requireSignaturesFor: ["task_response", "agent_selected"]
       });
 
-      expect(verifier.isSignatureRequired('task_response')).toBe(true);
-      expect(verifier.isSignatureRequired('agent_selected')).toBe(true);
+      expect(verifier.isSignatureRequired("task_response")).toBe(true);
+      expect(verifier.isSignatureRequired("agent_selected")).toBe(true);
     });
 
     it("should return false when no required types configured", () => {
       const verifier = new SignatureVerifier();
 
-      expect(verifier.isSignatureRequired('task_response')).toBe(false);
-      expect(verifier.isSignatureRequired('message')).toBe(false);
+      expect(verifier.isSignatureRequired("task_response")).toBe(false);
+      expect(verifier.isSignatureRequired("message")).toBe(false);
     });
   });
 
@@ -177,7 +181,7 @@ describe("SignatureVerifier", () => {
       });
 
       const message: BaseMessage = {
-        type: 'ping'
+        type: "ping"
       };
 
       const result = await verifier.verify(message);
@@ -188,19 +192,19 @@ describe("SignatureVerifier", () => {
 
     it("should fail when signature missing but required for message type", async () => {
       const verifier = new SignatureVerifier({
-        requireSignaturesFor: ['task_response']
+        requireSignaturesFor: ["task_response"]
       });
 
       const message: BaseMessage = {
-        type: 'task_response',
-        content: 'Result'
+        type: "task_response",
+        content: "Result"
       };
 
       const result = await verifier.verify(message);
 
       expect(result.valid).toBe(false);
       expect(result.signatureMissing).toBe(true);
-      expect(result.reason).toContain('required');
+      expect(result.reason).toContain("required");
     });
 
     it("should fail when signature missing and strictMode enabled", async () => {
@@ -209,8 +213,8 @@ describe("SignatureVerifier", () => {
       });
 
       const message: BaseMessage = {
-        type: 'message',
-        content: 'Hello'
+        type: "message",
+        content: "Hello"
       };
 
       const result = await verifier.verify(message);
@@ -225,10 +229,10 @@ describe("SignatureVerifier", () => {
       const verifier = new SignatureVerifier();
 
       const message: BaseMessage = {
-        type: 'message',
-        content: 'Hello',
-        from: 'agent1',
-        timestamp: '2024-01-01T00:00:00Z',
+        type: "message",
+        content: "Hello",
+        from: "agent1",
+        timestamp: "2024-01-01T00:00:00Z",
         publicKey: testAccount1.address
       };
 
@@ -252,25 +256,26 @@ describe("SignatureVerifier", () => {
       const verifier = new SignatureVerifier();
 
       const message: BaseMessage = {
-        type: 'message',
-        content: 'Hello',
+        type: "message",
+        content: "Hello",
         publicKey: testAccount1.address,
-        signature: '0xinvalidsignature1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012'
+        signature:
+          "0xinvalidsignature1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012"
       };
 
       const result = await verifier.verify(message);
 
       expect(result.valid).toBe(false);
       expect(result.signatureMissing).toBe(false);
-      expect(result.reason).toContain('error');
+      expect(result.reason).toContain("error");
     });
 
     it("should reject signature from wrong account", async () => {
       const verifier = new SignatureVerifier();
 
       const message: BaseMessage = {
-        type: 'message',
-        content: 'Hello',
+        type: "message",
+        content: "Hello",
         publicKey: testAccount1.address
       };
 
@@ -288,7 +293,7 @@ describe("SignatureVerifier", () => {
       const result = await verifier.verify(messageWithSignature);
 
       expect(result.valid).toBe(false);
-      expect(result.reason).toContain('does not match');
+      expect(result.reason).toContain("does not match");
     });
   });
 
@@ -299,8 +304,8 @@ describe("SignatureVerifier", () => {
       });
 
       const message: BaseMessage = {
-        type: 'message',
-        content: 'Hello',
+        type: "message",
+        content: "Hello",
         publicKey: testAccount1.address
       };
 
@@ -325,8 +330,8 @@ describe("SignatureVerifier", () => {
       });
 
       const message: BaseMessage = {
-        type: 'message',
-        content: 'Hello',
+        type: "message",
+        content: "Hello",
         publicKey: testAccount2.address
       };
 
@@ -343,7 +348,7 @@ describe("SignatureVerifier", () => {
 
       expect(result.valid).toBe(false);
       expect(result.isTrusted).toBe(false);
-      expect(result.reason).toContain('not in trusted whitelist');
+      expect(result.reason).toContain("not in trusted whitelist");
     });
   });
 
@@ -352,8 +357,8 @@ describe("SignatureVerifier", () => {
       const verifier = new SignatureVerifier();
 
       const message: BaseMessage = {
-        type: 'message',
-        content: 'Hello',
+        type: "message",
+        content: "Hello",
         publicKey: testAccount1.address
       };
 
@@ -376,8 +381,8 @@ describe("SignatureVerifier", () => {
       const verifier = new SignatureVerifier();
 
       const message: BaseMessage = {
-        type: 'message',
-        content: 'Hello',
+        type: "message",
+        content: "Hello",
         from: testAccount1.address
       };
 
@@ -400,16 +405,16 @@ describe("SignatureVerifier", () => {
       const verifier = new SignatureVerifier();
 
       const message: BaseMessage = {
-        type: 'message',
-        content: 'Hello',
-        from: 'agent-name-not-address',
-        signature: '0xsignature'
+        type: "message",
+        content: "Hello",
+        from: "agent-name-not-address",
+        signature: "0xsignature"
       };
 
       const result = await verifier.verify(message);
 
       expect(result.valid).toBe(false);
-      expect(result.reason).toContain('No address available');
+      expect(result.reason).toContain("No address available");
     });
   });
 
@@ -429,10 +434,10 @@ describe("SignatureVerifier", () => {
       const verifier = new SignatureVerifier();
 
       verifier.updateOptions({
-        requireSignaturesFor: ['task_response']
+        requireSignaturesFor: ["task_response"]
       });
 
-      expect(verifier.isSignatureRequired('task_response')).toBe(true);
+      expect(verifier.isSignatureRequired("task_response")).toBe(true);
     });
 
     it("should update strict mode", () => {

package/src/utils/signature-verifier.ts

@@ -3,8 +3,8 @@
  * Provides cryptographic verification of message signatures using Ethereum ECDSA
  */
 
-import { verifyMessage, hashMessage, type Address } from 'viem';
-import { BaseMessage, MessageType } from '../types';
+import { verifyMessage, hashMessage, type Address } from "viem";
+import { BaseMessage, MessageType } from "../types";
 
 /**
  * Options for signature verification
@@ -109,7 +109,7 @@ export class SignatureVerifier {
         signatureMissing: true,
         reason: isRequired
           ? `Signature required for message type '${message.type}'`
-          : 'Signature missing but not required'
+          : "Signature missing but not required"
       };
     }
 
@@ -127,7 +127,7 @@ export class SignatureVerifier {
         return {
           valid: false,
           signatureMissing: false,
-          reason: 'No address available for verification (missing publicKey and from fields)'
+          reason: "No address available for verification (missing publicKey and from fields)"
         };
       }
 
@@ -143,7 +143,7 @@ export class SignatureVerifier {
           valid: false,
           recoveredAddress: addressToVerify,
           signatureMissing: false,
-          reason: 'Signature verification failed - signature does not match message content'
+          reason: "Signature verification failed - signature does not match message content"
         };
       }
 
@@ -167,7 +167,6 @@ export class SignatureVerifier {
         signatureMissing: false,
         isTrusted
       };
-
     } catch (error) {
       return {
         valid: false,
@@ -234,7 +233,7 @@ export class SignatureVerifier {
     }
 
     return this.options.trustedAddresses.some(
-      trusted => trusted.toLowerCase() === address.toLowerCase()
+      (trusted) => trusted.toLowerCase() === address.toLowerCase()
     );
   }
 
@@ -255,7 +254,7 @@ export class SignatureVerifier {
     }
 
     // Fall back to 'from' field if it looks like an address
-    if (message.from && message.from.startsWith('0x') && message.from.length === 42) {
+    if (message.from && message.from.startsWith("0x") && message.from.length === 42) {
       return message.from as Address;
     }
 

package/src/utils/ssrf-validator.test.ts

@@ -236,9 +236,9 @@ describe("SSRF Validator", () => {
         });
 
         // Other k8s services should be blocked by isKubernetesService check
-        expect(() => validateWebhookUrl("http://redis.default.svc.cluster.local:6379", true)).toThrow(
-          /Kubernetes service/i
-        );
+        expect(() =>
+          validateWebhookUrl("http://redis.default.svc.cluster.local:6379", true)
+        ).toThrow(/Kubernetes service/i);
       });
     });