@teneo-protocol/sdk 1.0.0 → 2.0.0

package/src/utils/circuit-breaker.ts

@@ -31,7 +31,10 @@ export interface CircuitBreakerOptions {
  * Error thrown when circuit is open
  */
 export class CircuitBreakerError extends Error {
-  constructor(message: string, public readonly state: CircuitState) {
+  constructor(
+    message: string,
+    public readonly state: CircuitState
+  ) {
     super(message);
     this.name = "CircuitBreakerError";
 

package/src/utils/deduplication-cache.test.ts

@@ -25,15 +25,11 @@ describe("DeduplicationCache", () => {
     });
 
     it("should throw error if TTL is less than 1000ms", () => {
-      expect(() => new DeduplicationCache(999)).toThrow(
-        "TTL must be at least 1000ms"
-      );
+      expect(() => new DeduplicationCache(999)).toThrow("TTL must be at least 1000ms");
     });
 
     it("should throw error if maxSize is less than 1", () => {
-      expect(() => new DeduplicationCache(5000, 0)).toThrow(
-        "maxSize must be at least 1"
-      );
+      expect(() => new DeduplicationCache(5000, 0)).toThrow("maxSize must be at least 1");
     });
   });
 

package/src/utils/event-waiter.test.ts

@@ -376,6 +376,9 @@ describe("waitForAllEvents", () => {
     emitter.emit("data", { id: 1, value: "first" });
 
     const results = await promise;
-    expect(results).toEqual([{ id: 1, value: "first" }, { id: 2, value: "second" }]);
+    expect(results).toEqual([
+      { id: 1, value: "first" },
+      { id: 2, value: "second" }
+    ]);
   });
 });

package/src/utils/event-waiter.ts

@@ -102,7 +102,9 @@ export async function waitForEvent<T = any>(
     // Timeout handler - rejects after timeout
     timeoutHandle = setTimeout(() => {
       cleanup();
-      const message = options.timeoutMessage || `Timeout waiting for event '${eventName}' after ${options.timeout}ms`;
+      const message =
+        options.timeoutMessage ||
+        `Timeout waiting for event '${eventName}' after ${options.timeout}ms`;
       reject(new Error(message));
     }, options.timeout);
 
@@ -135,9 +137,7 @@ export async function waitForAnyEvent<T = any>(
   }>
 ): Promise<T> {
   return Promise.race(
-    waiters.map(({ emitter, eventName, options }) =>
-      waitForEvent<T>(emitter, eventName, options)
-    )
+    waiters.map(({ emitter, eventName, options }) => waitForEvent<T>(emitter, eventName, options))
   );
 }
 
@@ -165,8 +165,6 @@ export async function waitForAllEvents<T = any>(
   }>
 ): Promise<T[]> {
   return Promise.all(
-    waiters.map(({ emitter, eventName, options }) =>
-      waitForEvent<T>(emitter, eventName, options)
-    )
+    waiters.map(({ emitter, eventName, options }) => waitForEvent<T>(emitter, eventName, options))
   );
 }

package/src/utils/rate-limiter.test.ts

@@ -17,21 +17,15 @@ describe("TokenBucketRateLimiter", () => {
     });
 
     it("should throw error if tokensPerSecond is less than 1", () => {
-      expect(() => new TokenBucketRateLimiter(0, 10)).toThrow(
-        "tokensPerSecond must be at least 1"
-      );
+      expect(() => new TokenBucketRateLimiter(0, 10)).toThrow("tokensPerSecond must be at least 1");
       expect(() => new TokenBucketRateLimiter(-1, 10)).toThrow(
         "tokensPerSecond must be at least 1"
       );
     });
 
     it("should throw error if maxBurst is less than 1", () => {
-      expect(() => new TokenBucketRateLimiter(10, 0)).toThrow(
-        "maxBurst must be at least 1"
-      );
-      expect(() => new TokenBucketRateLimiter(10, -1)).toThrow(
-        "maxBurst must be at least 1"
-      );
+      expect(() => new TokenBucketRateLimiter(10, 0)).toThrow("maxBurst must be at least 1");
+      expect(() => new TokenBucketRateLimiter(10, -1)).toThrow("maxBurst must be at least 1");
     });
   });
 
@@ -159,9 +153,7 @@ describe("TokenBucketRateLimiter", () => {
       // Reset and try again to verify error message
       limiter.reset();
       limiter.tryConsume();
-      await expect(limiter.consume(10)).rejects.toThrow(
-        /Rate limit timeout/
-      );
+      await expect(limiter.consume(10)).rejects.toThrow(/Rate limit timeout/);
     });
 
     it("should succeed within timeout if token becomes available", async () => {
@@ -309,11 +301,7 @@ describe("TokenBucketRateLimiter", () => {
       limiter.tryConsume();
 
       // Start multiple blocking consume calls
-      const promises = [
-        limiter.consume(1000),
-        limiter.consume(1000),
-        limiter.consume(1000)
-      ];
+      const promises = [limiter.consume(1000), limiter.consume(1000), limiter.consume(1000)];
 
       // All should eventually succeed as tokens refill
       await expect(Promise.all(promises)).resolves.toBeDefined();

package/src/utils/rate-limiter.ts

@@ -13,7 +13,7 @@
 export class RateLimitError extends Error {
   constructor(message: string) {
     super(message);
-    this.name = 'RateLimitError';
+    this.name = "RateLimitError";
 
     if (Error.captureStackTrace) {
       Error.captureStackTrace(this, RateLimitError);
@@ -64,10 +64,10 @@ export class TokenBucketRateLimiter {
     private readonly maxBurst: number
   ) {
     if (tokensPerSecond < 1) {
-      throw new Error('TokenBucketRateLimiter tokensPerSecond must be at least 1');
+      throw new Error("TokenBucketRateLimiter tokensPerSecond must be at least 1");
     }
     if (maxBurst < 1) {
-      throw new Error('TokenBucketRateLimiter maxBurst must be at least 1');
+      throw new Error("TokenBucketRateLimiter maxBurst must be at least 1");
     }
 
     this.tokens = maxBurst; // Start with full bucket
@@ -131,17 +131,14 @@ export class TokenBucketRateLimiter {
       // Check timeout
       const elapsed = Date.now() - startTime;
       if (timeout !== undefined && elapsed >= timeout) {
-        throw new RateLimitError(
-          `Rate limit timeout: no token available after ${timeout}ms`
-        );
+        throw new RateLimitError(`Rate limit timeout: no token available after ${timeout}ms`);
       }
 
       // Calculate wait time until next token
       // If timeout is specified, don't wait longer than remaining timeout
       const baseWaitTime = Math.min(this.refillInterval, 100);
-      const waitTime = timeout !== undefined
-        ? Math.min(baseWaitTime, timeout - elapsed)
-        : baseWaitTime;
+      const waitTime =
+        timeout !== undefined ? Math.min(baseWaitTime, timeout - elapsed) : baseWaitTime;
 
       // If waitTime is very small or negative, check timeout immediately
       if (waitTime <= 0) {

package/src/utils/secure-private-key.test.ts

@@ -3,65 +3,72 @@
  * Verifies secure encryption, decryption, memory cleanup, and integration with viem
  */
 
-import { SecurePrivateKey } from './secure-private-key';
-import { privateKeyToAccount } from 'viem/accounts';
+import { SecurePrivateKey } from "./secure-private-key";
+import { privateKeyToAccount } from "viem/accounts";
 
-describe('SecurePrivateKey', () => {
+describe("SecurePrivateKey", () => {
   // Test private key (do NOT use in production)
-  const testPrivateKey = '0x1234567890123456789012345678901234567890123456789012345678901234';
+  const testPrivateKey = "0x1234567890123456789012345678901234567890123456789012345678901234";
 
-  describe('constructor', () => {
-    it('should create instance with valid private key', () => {
+  describe("constructor", () => {
+    it("should create instance with valid private key", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
       expect(secureKey).toBeInstanceOf(SecurePrivateKey);
       expect(secureKey.isDestroyed()).toBe(false);
       secureKey.destroy();
     });
 
-    it('should throw error with empty private key', () => {
-      expect(() => new SecurePrivateKey('')).toThrow('Private key must be a non-empty string');
+    it("should throw error with empty private key", () => {
+      expect(() => new SecurePrivateKey("")).toThrow("Private key must be a non-empty string");
     });
 
-    it('should throw error with null private key', () => {
-      expect(() => new SecurePrivateKey(null as any)).toThrow('Private key must be a non-empty string');
+    it("should throw error with null private key", () => {
+      expect(() => new SecurePrivateKey(null as any)).toThrow(
+        "Private key must be a non-empty string"
+      );
     });
 
-    it('should throw error with undefined private key', () => {
+    it("should throw error with undefined private key", () => {
       expect(() => new SecurePrivateKey(undefined as any)).toThrow(
-        'Private key must be a non-empty string'
+        "Private key must be a non-empty string"
       );
     });
 
-    it('should throw error with non-string private key', () => {
-      expect(() => new SecurePrivateKey(123 as any)).toThrow('Private key must be a non-empty string');
+    it("should throw error with non-string private key", () => {
+      expect(() => new SecurePrivateKey(123 as any)).toThrow(
+        "Private key must be a non-empty string"
+      );
     });
   });
 
-  describe('use()', () => {
-    it('should decrypt and pass key to callback', () => {
+  describe("use()", () => {
+    it("should decrypt and pass key to callback", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
 
       const result = secureKey.use((key) => {
         expect(key).toBe(testPrivateKey);
-        return 'success';
+        return "success";
       });
 
-      expect(result).toBe('success');
+      expect(result).toBe("success");
       secureKey.destroy();
     });
 
-    it('should return callback result', () => {
+    it("should return callback result", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
 
       const result = secureKey.use((key) => {
         return { key: key.substring(0, 10), length: key.length };
       });
 
-      expect(result).toEqual({ key: testPrivateKey.substring(0, 10), length: testPrivateKey.length });
+      expect(result).toEqual({
+        key: testPrivateKey.substring(0, 10),
+        length: testPrivateKey.length
+      });
       secureKey.destroy();
     });
 
-    it('should work with async callbacks', async () => {
+    it("should work with async callbacks", async () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
 
       const result = await secureKey.use(async (key) => {
@@ -73,7 +80,7 @@ describe('SecurePrivateKey', () => {
       secureKey.destroy();
     });
 
-    it('should allow multiple uses', () => {
+    it("should allow multiple uses", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
 
       const result1 = secureKey.use((key) => key.length);
@@ -87,33 +94,33 @@ describe('SecurePrivateKey', () => {
       secureKey.destroy();
     });
 
-    it('should throw if key has been destroyed', () => {
+    it("should throw if key has been destroyed", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
       secureKey.destroy();
 
       expect(() => {
         secureKey.use((key) => key);
-      }).toThrow('SecurePrivateKey has been destroyed and can no longer be used');
+      }).toThrow("SecurePrivateKey has been destroyed and can no longer be used");
     });
 
-    it('should propagate errors from callback', () => {
+    it("should propagate errors from callback", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
 
       expect(() => {
         secureKey.use((key) => {
-          throw new Error('Test error');
+          throw new Error("Test error");
         });
-      }).toThrow('Test error');
+      }).toThrow("Test error");
 
       secureKey.destroy();
     });
 
-    it('should clean up even if callback throws', () => {
+    it("should clean up even if callback throws", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
 
       try {
         secureKey.use((key) => {
-          throw new Error('Test error');
+          throw new Error("Test error");
         });
       } catch (error) {
         // Expected
@@ -127,8 +134,8 @@ describe('SecurePrivateKey', () => {
     });
   });
 
-  describe('destroy()', () => {
-    it('should mark instance as destroyed', () => {
+  describe("destroy()", () => {
+    it("should mark instance as destroyed", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
       expect(secureKey.isDestroyed()).toBe(false);
 
@@ -136,7 +143,7 @@ describe('SecurePrivateKey', () => {
       expect(secureKey.isDestroyed()).toBe(true);
     });
 
-    it('should be idempotent (safe to call multiple times)', () => {
+    it("should be idempotent (safe to call multiple times)", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
 
       secureKey.destroy();
@@ -146,32 +153,32 @@ describe('SecurePrivateKey', () => {
       expect(secureKey.isDestroyed()).toBe(true);
     });
 
-    it('should prevent further use after destruction', () => {
+    it("should prevent further use after destruction", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
       secureKey.destroy();
 
       expect(() => {
         secureKey.use((key) => key);
-      }).toThrow('SecurePrivateKey has been destroyed');
+      }).toThrow("SecurePrivateKey has been destroyed");
     });
   });
 
-  describe('isDestroyed()', () => {
-    it('should return false for new instance', () => {
+  describe("isDestroyed()", () => {
+    it("should return false for new instance", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
       expect(secureKey.isDestroyed()).toBe(false);
       secureKey.destroy();
     });
 
-    it('should return true after destruction', () => {
+    it("should return true after destruction", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
       secureKey.destroy();
       expect(secureKey.isDestroyed()).toBe(true);
     });
   });
 
-  describe('encryption/decryption', () => {
-    it('should correctly encrypt and decrypt private key', () => {
+  describe("encryption/decryption", () => {
+    it("should correctly encrypt and decrypt private key", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
 
       const decrypted = secureKey.use((key) => key);
@@ -180,8 +187,8 @@ describe('SecurePrivateKey', () => {
       secureKey.destroy();
     });
 
-    it('should handle keys with special characters', () => {
-      const specialKey = '0xABCDEF123456!@#$%^&*()_+-=[]{}|;:,.<>?';
+    it("should handle keys with special characters", () => {
+      const specialKey = "0xABCDEF123456!@#$%^&*()_+-=[]{}|;:,.<>?";
       const secureKey = new SecurePrivateKey(specialKey);
 
       const decrypted = secureKey.use((key) => key);
@@ -190,8 +197,8 @@ describe('SecurePrivateKey', () => {
       secureKey.destroy();
     });
 
-    it('should handle very long keys', () => {
-      const longKey = '0x' + 'a'.repeat(1000);
+    it("should handle very long keys", () => {
+      const longKey = "0x" + "a".repeat(1000);
       const secureKey = new SecurePrivateKey(longKey);
 
       const decrypted = secureKey.use((key) => key);
@@ -200,7 +207,7 @@ describe('SecurePrivateKey', () => {
       secureKey.destroy();
     });
 
-    it('should produce different encrypted data for same key (random IV)', () => {
+    it("should produce different encrypted data for same key (random IV)", () => {
       const secureKey1 = new SecurePrivateKey(testPrivateKey);
       const secureKey2 = new SecurePrivateKey(testPrivateKey);
 
@@ -223,8 +230,8 @@ describe('SecurePrivateKey', () => {
     });
   });
 
-  describe('integration with viem', () => {
-    it('should work with privateKeyToAccount', () => {
+  describe("integration with viem", () => {
+    it("should work with privateKeyToAccount", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
 
       const account = secureKey.use((key) => {
@@ -238,14 +245,14 @@ describe('SecurePrivateKey', () => {
       secureKey.destroy();
     });
 
-    it('should allow signing messages with account created from secure key', async () => {
+    it("should allow signing messages with account created from secure key", async () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
 
       const account = secureKey.use((key) => {
         return privateKeyToAccount(key as `0x${string}`);
       });
 
-      const message = 'Hello, Teneo!';
+      const message = "Hello, Teneo!";
       const signature = await account.signMessage({ message });
 
       expect(signature).toBeDefined();
@@ -255,7 +262,7 @@ describe('SecurePrivateKey', () => {
       secureKey.destroy();
     });
 
-    it('should create consistent account address across multiple uses', () => {
+    it("should create consistent account address across multiple uses", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
 
       const address1 = secureKey.use((key) => {
@@ -272,8 +279,8 @@ describe('SecurePrivateKey', () => {
     });
   });
 
-  describe('security properties', () => {
-    it('should not expose private key in toString()', () => {
+  describe("security properties", () => {
+    it("should not expose private key in toString()", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
 
       const stringified = String(secureKey);
@@ -283,7 +290,7 @@ describe('SecurePrivateKey', () => {
       secureKey.destroy();
     });
 
-    it('should not expose private key in JSON.stringify()', () => {
+    it("should not expose private key in JSON.stringify()", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
 
       const jsonString = JSON.stringify(secureKey);
@@ -293,7 +300,7 @@ describe('SecurePrivateKey', () => {
       secureKey.destroy();
     });
 
-    it('should not expose private key when inspecting object', () => {
+    it("should not expose private key when inspecting object", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
 
       // Try to access private properties (they're still accessible via 'any' but not exposed)
@@ -307,23 +314,23 @@ describe('SecurePrivateKey', () => {
       secureKey.destroy();
     });
 
-    it('should store key encrypted in memory', () => {
+    it("should store key encrypted in memory", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
 
       // Access encrypted buffer via any
       const encrypted = (secureKey as any).encrypted as Buffer;
 
       // Encrypted data should not contain the plaintext key
-      const encryptedString = encrypted.toString('utf8');
+      const encryptedString = encrypted.toString("utf8");
       expect(encryptedString).not.toContain(testPrivateKey);
-      expect(encryptedString).not.toContain('1234567890');
+      expect(encryptedString).not.toContain("1234567890");
 
       secureKey.destroy();
     });
   });
 
-  describe('memory cleanup', () => {
-    it('should zero out encryption key on destroy', () => {
+  describe("memory cleanup", () => {
+    it("should zero out encryption key on destroy", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
 
       // Get reference to encryption key before destroy
@@ -338,7 +345,7 @@ describe('SecurePrivateKey', () => {
       expect(encryptionKey.every((byte) => byte === 0)).toBe(true);
     });
 
-    it('should zero out encrypted buffer on destroy', () => {
+    it("should zero out encrypted buffer on destroy", () => {
       const secureKey = new SecurePrivateKey(testPrivateKey);
 
       // Get reference to encrypted buffer before destroy

package/src/utils/secure-private-key.ts

@@ -19,7 +19,7 @@
  * ```
  */
 
-import crypto from 'crypto';
+import crypto from "crypto";
 
 /**
  * Securely stores and manages an encrypted private key in memory.
@@ -42,8 +42,8 @@ export class SecurePrivateKey {
    * @throws {Error} If private key is empty or invalid
    */
   constructor(privateKey: string) {
-    if (!privateKey || typeof privateKey !== 'string') {
-      throw new Error('Private key must be a non-empty string');
+    if (!privateKey || typeof privateKey !== "string") {
+      throw new Error("Private key must be a non-empty string");
     }
 
     // Generate a random encryption key for AES-256
@@ -136,13 +136,10 @@ export class SecurePrivateKey {
     const iv = crypto.randomBytes(16);
 
     // Create cipher
-    const cipher = crypto.createCipheriv('aes-256-gcm', this.encryptionKey, iv);
+    const cipher = crypto.createCipheriv("aes-256-gcm", this.encryptionKey, iv);
 
     // Encrypt the data
-    const encrypted = Buffer.concat([
-      cipher.update(data, 'utf8'),
-      cipher.final()
-    ]);
+    const encrypted = Buffer.concat([cipher.update(data, "utf8"), cipher.final()]);
 
     // Get authentication tag for integrity verification
     const authTag = cipher.getAuthTag();
@@ -164,16 +161,13 @@ export class SecurePrivateKey {
     const ciphertext = this.encrypted.subarray(32);
 
     // Create decipher
-    const decipher = crypto.createDecipheriv('aes-256-gcm', this.encryptionKey, iv);
+    const decipher = crypto.createDecipheriv("aes-256-gcm", this.encryptionKey, iv);
     decipher.setAuthTag(authTag);
 
     // Decrypt the data
-    const decrypted = Buffer.concat([
-      decipher.update(ciphertext),
-      decipher.final()
-    ]);
+    const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
 
-    return decrypted.toString('utf8');
+    return decrypted.toString("utf8");
   }
 
   /**
@@ -185,7 +179,7 @@ export class SecurePrivateKey {
    */
   private zeroOutString(str: string): void {
     // Convert to buffer and zero it out
-    const buffer = Buffer.from(str, 'utf8');
+    const buffer = Buffer.from(str, "utf8");
     buffer.fill(0);
 
     // Note: The original string object may still exist in memory
@@ -199,7 +193,7 @@ export class SecurePrivateKey {
    */
   private checkNotDestroyed(): void {
     if (this.destroyed) {
-      throw new Error('SecurePrivateKey has been destroyed and can no longer be used');
+      throw new Error("SecurePrivateKey has been destroyed and can no longer be used");
     }
   }
 }