@gibs/common 1.12.0 → 1.13.0

package/src/cache.test.ts

@@ -1,176 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { maxMemoize, ttlMemoizeSingle } from './cache';
-
-describe('cache', () => {
-  describe('maxMemoize', () => {
-    it('should cache function results', () => {
-      const fn = vi.fn((a: number, b: number) => a + b);
-      const memoized = maxMemoize(fn);
-
-      const result1 = memoized(1, 2);
-      const result2 = memoized(1, 2);
-
-      expect(result1).toBe(3);
-      expect(result2).toBe(3);
-      expect(fn).toHaveBeenCalledTimes(1);
-    });
-
-    it('should cache different argument combinations separately', () => {
-      const fn = vi.fn((a: number, b: number) => a + b);
-      const memoized = maxMemoize(fn);
-
-      expect(memoized(1, 2)).toBe(3);
-      expect(memoized(2, 3)).toBe(5);
-      expect(memoized(1, 2)).toBe(3);
-
-      expect(fn).toHaveBeenCalledTimes(2);
-    });
-
-    it('should handle bigint arguments correctly', () => {
-      const fn = vi.fn((a: bigint) => a * 2n);
-      const memoized = maxMemoize(fn);
-
-      const result1 = memoized(100n);
-      const result2 = memoized(100n);
-
-      expect(result1).toBe(200n);
-      expect(result2).toBe(200n);
-      expect(fn).toHaveBeenCalledTimes(1);
-    });
-
-    it('should respect max cache size', () => {
-      const fn = vi.fn((n: number) => n * 2);
-      const memoized = maxMemoize(fn, 3);
-
-      // Fill cache with 3 entries
-      memoized(1);
-      memoized(2);
-      memoized(3);
-
-      // Add 4th entry - should evict oldest
-      memoized(4);
-
-      // Call first entry again - should recompute
-      memoized(1);
-
-      // Total calls: 5 (1, 2, 3, 4, 1 again)
-      expect(fn).toHaveBeenCalledTimes(5);
-    });
-
-    it('should handle complex object arguments', () => {
-      const fn = vi.fn((obj: { a: number; b: string }) => `${obj.a}-${obj.b}`);
-      const memoized = maxMemoize(fn);
-
-      const result1 = memoized({ a: 1, b: 'test' });
-      const result2 = memoized({ a: 1, b: 'test' });
-
-      expect(result1).toBe('1-test');
-      expect(result2).toBe('1-test');
-      expect(fn).toHaveBeenCalledTimes(1);
-    });
-
-    it('should return undefined for cached undefined results', () => {
-      const fn = vi.fn(() => undefined);
-      const memoized = maxMemoize(fn);
-
-      const result1 = memoized();
-      const result2 = memoized();
-
-      expect(result1).toBe(undefined);
-      expect(result2).toBe(undefined);
-      expect(fn).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('ttlMemoizeSingle', () => {
-    beforeEach(() => {
-      vi.useFakeTimers();
-    });
-
-    afterEach(() => {
-      vi.useRealTimers();
-    });
-
-    it('should cache result within TTL', () => {
-      const fn = vi.fn(() => Math.random());
-      const memoized = ttlMemoizeSingle(fn, 1000);
-
-      const result1 = memoized();
-      vi.advanceTimersByTime(500);
-      const result2 = memoized();
-
-      expect(result1).toBe(result2);
-      expect(fn).toHaveBeenCalledTimes(1);
-    });
-
-    it('should recompute after TTL expires', () => {
-      const fn = vi.fn(() => Math.random());
-      const memoized = ttlMemoizeSingle(fn, 1000);
-
-      const result1 = memoized();
-      vi.advanceTimersByTime(1001);
-      const result2 = memoized();
-
-      expect(result1).not.toBe(result2);
-      expect(fn).toHaveBeenCalledTimes(2);
-    });
-
-    it('should use default TTL of 1 hour', () => {
-      const fn = vi.fn(() => 'test');
-      const memoized = ttlMemoizeSingle(fn);
-
-      memoized();
-      vi.advanceTimersByTime(1000 * 60 * 59); // 59 minutes
-      memoized();
-
-      expect(fn).toHaveBeenCalledTimes(1);
-
-      vi.advanceTimersByTime(1000 * 60 * 2); // 2 more minutes (total 61)
-      memoized();
-
-      expect(fn).toHaveBeenCalledTimes(2);
-    });
-
-    it('should ignore arguments and always return same cached result', () => {
-      const fn = vi.fn((n: number) => n * 2);
-      const memoized = ttlMemoizeSingle(fn, 1000);
-
-      const result1 = memoized(5);
-      const result2 = memoized(10);
-
-      // Second call should return cached result from first call
-      expect(result1).toBe(10);
-      expect(result2).toBe(10);
-      expect(fn).toHaveBeenCalledTimes(1);
-      expect(fn).toHaveBeenCalledWith(5);
-    });
-
-    it('should handle bigint results', () => {
-      const fn = vi.fn(() => 999999999999999999n);
-      const memoized = ttlMemoizeSingle(fn, 1000);
-
-      const result1 = memoized();
-      const result2 = memoized();
-
-      expect(result1).toBe(999999999999999999n);
-      expect(result2).toBe(999999999999999999n);
-      expect(fn).toHaveBeenCalledTimes(1);
-    });
-
-    it('should cache null and undefined results', () => {
-      const fnNull = vi.fn(() => null);
-      const memoizedNull = ttlMemoizeSingle(fnNull, 1000);
-
-      expect(memoizedNull()).toBe(null);
-      expect(memoizedNull()).toBe(null);
-      expect(fnNull).toHaveBeenCalledTimes(1);
-
-      const fnUndefined = vi.fn(() => undefined);
-      const memoizedUndefined = ttlMemoizeSingle(fnUndefined, 1000);
-
-      expect(memoizedUndefined()).toBe(undefined);
-      expect(memoizedUndefined()).toBe(undefined);
-      expect(fnUndefined).toHaveBeenCalledTimes(1);
-    });
-  });
-});

package/src/cache.ts

@@ -1,48 +0,0 @@
-import { jsonAnyStringify } from './serialize.js';
-
-/**
- * Memoize a function result and return a single value
- * @param fn the function to memoize
- * @param max the maximum number of values to cache
- * @returns the memoized function
- */
-export const maxMemoize = <A extends unknown[], B>(fn: (...a: A) => B, max = 1024) => {
-  const cache = new Map<string, B>();
-  return (...a: A) => {
-    const key = JSON.stringify(a, jsonAnyStringify);
-    const existing = cache.get(key);
-    if (cache.has(key)) {
-      return existing;
-    }
-    for (const k of cache.keys()) {
-      if (cache.size < max) break;
-      cache.delete(k);
-    }
-    const result = fn(...a);
-    cache.set(key, result);
-    return result;
-  };
-};
-
-const hour1 = 1000 * 60 * 60;
-/**
- * Memoize a function result and return a single value
- * @param fn the function to memoize
- * @param ttl the time to live for the cache
- * @returns the memoized function
- */
-export const ttlMemoizeSingle = <A extends unknown[], B>(fn: (...a: A) => B, ttl = hour1) => {
-  let cache: {
-    timestamp: number;
-    result: B;
-  } | null = null;
-  return (...a: A) => {
-    const now = Date.now();
-    if (cache && cache.timestamp + ttl > now) {
-      return cache.result;
-    }
-    const result = fn(...a);
-    cache = { timestamp: now, result };
-    return result;
-  };
-};

package/src/client.test.ts

@@ -1,205 +0,0 @@
-import type { Chain } from 'viem';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { chainKey, clientFromChain, defaultBatchConfig } from './client';
-
-// Mock viem functions
-vi.mock('viem', async () => {
-  const actual = await vi.importActual<typeof import('viem')>('viem');
-  return {
-    ...actual,
-    createPublicClient: vi.fn((config: any) => ({
-      ...config,
-      mockClient: true,
-    })),
-    http: vi.fn((url?: string, config?: any) => ({
-      type: 'http',
-      url,
-      config,
-    })),
-    webSocket: vi.fn((url: string, config?: any) => ({
-      type: 'webSocket',
-      url,
-      config,
-    })),
-    fallback: vi.fn((transports: any[], config?: any) => ({
-      type: 'fallback',
-      transports,
-      config,
-    })),
-  };
-});
-
-describe('client', () => {
-  describe('defaultBatchConfig', () => {
-    it('should have correct batch wait time', () => {
-      expect(defaultBatchConfig.batch.wait).toBe(10);
-    });
-
-    it('should have correct batch size', () => {
-      expect(defaultBatchConfig.batch.batchSize).toBe(32);
-    });
-
-    it('should have batch property', () => {
-      expect(defaultBatchConfig).toHaveProperty('batch');
-      expect(defaultBatchConfig.batch).toHaveProperty('wait');
-      expect(defaultBatchConfig.batch).toHaveProperty('batchSize');
-    });
-  });
-
-  describe('chainKey', () => {
-    it('should create key from chainId and single URL', () => {
-      const result = chainKey(1, ['https://eth.llamarpc.com']);
-      expect(result).toBe('1,https://eth.llamarpc.com');
-    });
-
-    it('should create key from chainId and multiple URLs', () => {
-      const result = chainKey(369, [
-        'https://rpc.pulsechain.com',
-        'https://rpc-pulsechain.g4mm4.io',
-      ]);
-      expect(result).toBe('369,https://rpc.pulsechain.com,https://rpc-pulsechain.g4mm4.io');
-    });
-
-    it('should lowercase the result', () => {
-      const result = chainKey(1, ['HTTPS://ETH.LLAMARPC.COM']);
-      expect(result).toBe('1,https://eth.llamarpc.com');
-    });
-
-    it('should handle empty URL array', () => {
-      const result = chainKey(1, []);
-      expect(result).toBe('1,');
-    });
-
-    it('should handle WebSocket URLs', () => {
-      const result = chainKey(1, ['wss://eth.llamarpc.com']);
-      expect(result).toBe('1,wss://eth.llamarpc.com');
-    });
-
-    it('should create unique keys for different chainIds', () => {
-      const key1 = chainKey(1, ['https://rpc.example.com']);
-      const key2 = chainKey(369, ['https://rpc.example.com']);
-      expect(key1).not.toBe(key2);
-    });
-
-    it('should create unique keys for different URL arrays', () => {
-      const key1 = chainKey(1, ['https://rpc1.example.com']);
-      const key2 = chainKey(1, ['https://rpc2.example.com']);
-      expect(key1).not.toBe(key2);
-    });
-
-    it('should create same key for same inputs', () => {
-      const key1 = chainKey(1, ['https://rpc.example.com', 'https://backup.example.com']);
-      const key2 = chainKey(1, ['https://rpc.example.com', 'https://backup.example.com']);
-      expect(key1).toBe(key2);
-    });
-
-    it('should handle URLs with query parameters', () => {
-      const result = chainKey(1, ['https://rpc.example.com?apiKey=123']);
-      expect(result).toBe('1,https://rpc.example.com?apikey=123');
-    });
-
-    it('should handle URLs with ports', () => {
-      const result = chainKey(1, ['https://localhost:8545']);
-      expect(result).toBe('1,https://localhost:8545');
-    });
-
-    it('should handle testnet chain IDs', () => {
-      const sepolia = chainKey(11155111, ['https://sepolia.infura.io']);
-      expect(sepolia).toBe('11155111,https://sepolia.infura.io');
-    });
-
-    it('should create different keys when URL order differs', () => {
-      const key1 = chainKey(1, ['https://rpc1.example.com', 'https://rpc2.example.com']);
-      const key2 = chainKey(1, ['https://rpc2.example.com', 'https://rpc1.example.com']);
-      expect(key1).not.toBe(key2);
-    });
-  });
-
-  describe('clientFromChain', () => {
-    let mockChain: Chain;
-
-    beforeEach(() => {
-      vi.clearAllMocks();
-      mockChain = {
-        id: 1,
-        name: 'Ethereum',
-        nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
-        rpcUrls: {
-          default: { http: ['https://eth.llamarpc.com'] },
-        },
-      } as Chain;
-    });
-
-    it('should create client with http transport when urls provided', () => {
-      const urls = ['https://eth.llamarpc.com'];
-      const client = clientFromChain({ chain: mockChain, urls });
-
-      expect(client).toBeDefined();
-      expect((client as any).mockClient).toBe(true);
-    });
-
-    it('should create client with multiple http urls using fallback', () => {
-      const urls = ['https://eth.llamarpc.com', 'https://rpc.ankr.com/eth'];
-      const client = clientFromChain({ chain: mockChain, urls });
-
-      expect(client).toBeDefined();
-    });
-
-    it('should create client with websocket transport', () => {
-      const urls = ['wss://eth.llamarpc.com'];
-      const client = clientFromChain({ chain: mockChain, urls });
-
-      expect(client).toBeDefined();
-    });
-
-    it('should create client with mixed http and websocket transports', () => {
-      const urls = ['https://eth.llamarpc.com', 'wss://eth.llamarpc.com'];
-      const client = clientFromChain({ chain: mockChain, urls });
-
-      expect(client).toBeDefined();
-    });
-
-    it('should create client with empty urls array', () => {
-      const urls: string[] = [];
-      const client = clientFromChain({ chain: mockChain, urls });
-
-      expect(client).toBeDefined();
-    });
-
-    it('should use cache for same chain and urls', () => {
-      const urls = ['https://eth.llamarpc.com'];
-
-      const client1 = clientFromChain({ chain: mockChain, urls });
-      const client2 = clientFromChain({ chain: mockChain, urls });
-
-      // Should return cached client
-      expect(client1).toBe(client2);
-    });
-
-    it('should create new client for different urls', () => {
-      const urls1 = ['https://eth.llamarpc.com'];
-      const urls2 = ['https://rpc.ankr.com/eth'];
-
-      const client1 = clientFromChain({ chain: mockChain, urls: urls1 });
-      const client2 = clientFromChain({ chain: mockChain, urls: urls2 });
-
-      // Should be different clients
-      expect(client1).not.toBe(client2);
-    });
-
-    it('should create new client for different chain', () => {
-      const urls = ['https://eth.llamarpc.com'];
-      const chain2: Chain = {
-        ...mockChain,
-        id: 369,
-        name: 'PulseChain',
-      };
-
-      const client1 = clientFromChain({ chain: mockChain, urls });
-      const client2 = clientFromChain({ chain: chain2, urls });
-
-      // Should be different clients
-      expect(client1).not.toBe(client2);
-    });
-  });
-});

package/src/client.ts

@@ -1,76 +0,0 @@
-import { type Chain, createPublicClient, fallback, http, type PublicClient, webSocket } from 'viem';
-
-/** The default batch config for the client */
-export const defaultBatchConfig = {
-  batch: {
-    wait: 10,
-    batchSize: 32,
-  },
-};
-
-/**
- * Returns the chain key for the given chain id and urls
- * @param chainId - the chain id
- * @param urls - the urls
- * @returns the chain key
- */
-export const chainKey = (chainId: number, urls: string[]) => {
-  return `${chainId},${urls.join(',')}`.toLowerCase();
-};
-
-/** The client cache for the given chain id */
-export const clientCache = new Map<
-  number,
-  {
-    key: string;
-    client: PublicClient;
-  }
->();
-
-/**
- * Returns the client for the given chain and urls
- * @param chain - the chain
- * @param urls - the urls
- * @returns the client
- */
-export const clientFromChain = ({
-  chain,
-  urls,
-}: {
-  chain: Chain;
-  urls: string[];
-}): PublicClient => {
-  const key = chainKey(chain.id, urls);
-  const existing = clientCache.get(chain.id);
-  if (existing && existing.key === key) {
-    return existing.client;
-  }
-  const transport = !urls?.length
-    ? http()
-    : fallback(
-        urls.map((rpc) =>
-          rpc.startsWith('http')
-            ? http(rpc, {
-                ...defaultBatchConfig,
-              })
-            : webSocket(rpc, {
-                keepAlive: true,
-                reconnect: true,
-                retryDelay: 250,
-                retryCount: 10,
-                timeout: 4_000,
-                ...defaultBatchConfig,
-              }),
-        ),
-        { rank: true },
-      );
-  const client = createPublicClient({
-    chain,
-    transport,
-  });
-  clientCache.set(chain.id, {
-    key,
-    client,
-  });
-  return client;
-};

package/src/erc20.test.ts

@@ -1,140 +0,0 @@
-import type { Chain, Hex, PublicClient } from 'viem';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { erc20MetadataCalls, multicallErc20 } from './erc20';
-
-// Mock the multicall module
-vi.mock('./multicall', () => ({
-  multicallRead: vi.fn(),
-}));
-
-describe('erc20', () => {
-  describe('erc20MetadataCalls', () => {
-    it('should have 3 metadata calls', () => {
-      expect(erc20MetadataCalls).toHaveLength(3);
-    });
-
-    it('should include name call', () => {
-      const nameCall = erc20MetadataCalls.find((c) => c.functionName === 'name');
-      expect(nameCall).toBeDefined();
-      expect(nameCall?.functionName).toBe('name');
-    });
-
-    it('should include symbol call', () => {
-      const symbolCall = erc20MetadataCalls.find((c) => c.functionName === 'symbol');
-      expect(symbolCall).toBeDefined();
-      expect(symbolCall?.functionName).toBe('symbol');
-    });
-
-    it('should include decimals call', () => {
-      const decimalsCall = erc20MetadataCalls.find((c) => c.functionName === 'decimals');
-      expect(decimalsCall).toBeDefined();
-      expect(decimalsCall?.functionName).toBe('decimals');
-    });
-
-    it('should have calls in correct order (name, symbol, decimals)', () => {
-      expect(erc20MetadataCalls[0].functionName).toBe('name');
-      expect(erc20MetadataCalls[1].functionName).toBe('symbol');
-      expect(erc20MetadataCalls[2].functionName).toBe('decimals');
-    });
-
-    it('should have only functionName property in each call', () => {
-      erc20MetadataCalls.forEach((call) => {
-        const keys = Object.keys(call);
-        expect(keys).toHaveLength(1);
-        expect(keys[0]).toBe('functionName');
-      });
-    });
-  });
-
-  describe('multicallErc20', () => {
-    let mockClient: PublicClient;
-    let mockChain: Chain;
-
-    beforeEach(() => {
-      vi.clearAllMocks();
-      // Clear memoization cache by deleting and recreating it
-      (multicallErc20 as any).cache = new Map();
-
-      mockChain = {
-        id: 1,
-        name: 'Ethereum',
-        nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
-        rpcUrls: {
-          default: { http: ['https://eth.llamarpc.com'] },
-        },
-      } as Chain;
-
-      mockClient = {
-        chain: mockChain,
-      } as PublicClient;
-    });
-
-    it('should successfully fetch erc20 metadata', async () => {
-      const { multicallRead } = await import('./multicall');
-      (multicallRead as any).mockResolvedValue(['Test Token', 'TST', 18]);
-
-      const result = await multicallErc20({
-        client: mockClient,
-        target: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48' as Hex,
-        chain: mockChain,
-      });
-
-      expect(result).toEqual(['Test Token', 'TST', 18]);
-      expect(multicallRead).toHaveBeenCalledWith({
-        chain: mockChain,
-        client: mockClient,
-        abi: expect.anything(),
-        target: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
-        calls: erc20MetadataCalls,
-      });
-    });
-
-    it('should fallback to bytes32 ABI on failure', async () => {
-      const { multicallRead } = await import('./multicall');
-      const mockError = new Error('Failed with standard ABI');
-      (multicallRead as any)
-        .mockRejectedValueOnce(mockError)
-        .mockResolvedValueOnce(['Test Token', 'TST', 18]);
-
-      const result = await multicallErc20({
-        client: mockClient,
-        target: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48' as Hex,
-        chain: mockChain,
-      });
-
-      expect(result).toEqual(['Test Token', 'TST', 18]);
-      expect(multicallRead).toHaveBeenCalledTimes(2);
-      // First call with standard ABI
-      expect((multicallRead as any).mock.calls[0][0].abi).toBeDefined();
-      // Second call with bytes32 ABI (fallback)
-      expect((multicallRead as any).mock.calls[1][0].abi).toBeDefined();
-    });
-
-    it('should use memoization with target address', async () => {
-      const { multicallRead } = await import('./multicall');
-      (multicallRead as any).mockResolvedValue(['Test Token', 'TST', 18]);
-
-      const target = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48' as Hex;
-
-      // First call
-      const result1 = await multicallErc20({ client: mockClient, target, chain: mockChain });
-      // Second call with same params - should use memoized result
-      const result2 = await multicallErc20({ client: mockClient, target, chain: mockChain });
-
-      expect(result1).toEqual(result2);
-      // Should only call multicallRead once due to memoization
-      expect(multicallRead).toHaveBeenCalledTimes(1);
-    });
-
-    it('should use chain id as memoization key when target is falsy', async () => {
-      const { multicallRead } = await import('./multicall');
-      (multicallRead as any).mockResolvedValue(['Test Token', 'TST', 18]);
-
-      // Call with null target (uses chain.id as key)
-      await multicallErc20({ client: mockClient, target: null as any, chain: mockChain });
-
-      // The memoization resolver should handle null target gracefully
-      expect(multicallRead).toHaveBeenCalled();
-    });
-  });
-});

package/src/erc20.ts

@@ -1,43 +0,0 @@
-import _ from 'lodash';
-import {
-  type Abi,
-  type Chain,
-  erc20Abi,
-  erc20Abi_bytes32,
-  getAddress,
-  type Hex,
-  type PublicClient,
-} from 'viem';
-import { multicallRead } from './multicall.js';
-import type { Erc20Metadata } from './types.js';
-
-/** The erc20 metadata calls */
-export const erc20MetadataCalls = [
-  { functionName: 'name' },
-  { functionName: 'symbol' },
-  { functionName: 'decimals' },
-];
-
-/** The multicall for the erc20 metadata */
-export const multicallErc20 = _.memoize(
-  async ({ client, target, chain }: { client: PublicClient; target: Hex; chain: Chain }) => {
-    const options = {
-      chain: chain,
-      client: client,
-      abi: erc20Abi,
-      target,
-      calls: erc20MetadataCalls,
-    };
-    try {
-      return await multicallRead<Erc20Metadata>(options);
-    } catch {
-      return await multicallRead<Erc20Metadata>({
-        ...options,
-        abi: erc20Abi_bytes32,
-      });
-    }
-  },
-  ({ target, chain }) => {
-    return !target ? chain.id : getAddress(target, chain.id);
-  },
-);