@gibs/common 1.9.1 → 1.12.0

package/src/client.ts

@@ -1,4 +1,4 @@
-import { type Chain, type PublicClient, createPublicClient, fallback, http, webSocket } from "viem"
+import { type Chain, createPublicClient, fallback, http, type PublicClient, webSocket } from 'viem';
 
 /** The default batch config for the client */
 export const defaultBatchConfig = {
@@ -6,7 +6,7 @@ export const defaultBatchConfig = {
     wait: 10,
     batchSize: 32,
   },
-}
+};
 
 /**
  * Returns the chain key for the given chain id and urls
@@ -15,14 +15,17 @@ export const defaultBatchConfig = {
  * @returns the chain key
  */
 export const chainKey = (chainId: number, urls: string[]) => {
-  return `${chainId},${urls.join(',')}`.toLowerCase()
-}
+  return `${chainId},${urls.join(',')}`.toLowerCase();
+};
 
 /** The client cache for the given chain id */
-export const clientCache = new Map<number, {
-  key: string
-  client: PublicClient
-}>()
+export const clientCache = new Map<
+  number,
+  {
+    key: string;
+    client: PublicClient;
+  }
+>();
 
 /**
  * Returns the client for the given chain and urls
@@ -34,40 +37,40 @@ export const clientFromChain = ({
   chain,
   urls,
 }: {
-  chain: Chain
-  urls: string[]
+  chain: Chain;
+  urls: string[];
 }): PublicClient => {
-  const key = chainKey(chain.id, urls)
-  const existing = clientCache.get(chain.id)
+  const key = chainKey(chain.id, urls);
+  const existing = clientCache.get(chain.id);
   if (existing && existing.key === key) {
-    return existing.client
+    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 },
-    )
+        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
-}
+  });
+  return client;
+};

package/src/erc20.test.ts

@@ -0,0 +1,140 @@
+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,22 +1,22 @@
+import _ from 'lodash';
 import {
-  type Chain,
-  type PublicClient,
-  type Hex,
   type Abi,
+  type Chain,
   erc20Abi,
   erc20Abi_bytes32,
   getAddress,
-} from 'viem'
-import _ from 'lodash'
-import type { Erc20Metadata } from './types.js'
-import { multicallRead } from './multicall.js'
+  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(
@@ -27,17 +27,17 @@ export const multicallErc20 = _.memoize(
       abi: erc20Abi,
       target,
       calls: erc20MetadataCalls,
-    }
+    };
     try {
-      return await multicallRead<Erc20Metadata>(options)
+      return await multicallRead<Erc20Metadata>(options);
     } catch {
       return await multicallRead<Erc20Metadata>({
         ...options,
         abi: erc20Abi_bytes32,
-      })
+      });
     }
   },
   ({ target, chain }) => {
-    return !target ? chain.id : getAddress(target, chain.id)
+    return !target ? chain.id : getAddress(target, chain.id);
   },
-)
+);

package/src/index.ts

@@ -1,6 +1,7 @@
-export * from './types.js'
-export * from './serialize.js'
-export * from './cache.js'
-export * from './multicall.js'
-export * from './erc20.js'
-export * from './client.js'
+export * from './assert.js';
+export * from './cache.js';
+export * from './client.js';
+export * from './erc20.js';
+export * from './multicall.js';
+export * from './serialize.js';
+export * from './types.js';

package/src/multicall.test.ts

@@ -0,0 +1,263 @@
+import type { Chain, Hex, PublicClient } from 'viem';
+import { erc20Abi } from 'viem';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { multicallRead } from './multicall';
+
+// Mock viem functions
+vi.mock('viem', async () => {
+  const actual = await vi.importActual<typeof import('viem')>('viem');
+  return {
+    ...actual,
+    getContract: vi.fn(() => ({
+      read: {
+        aggregate3: vi.fn(),
+      },
+    })),
+    encodeFunctionData: vi.fn(() => '0xENCODED_DATA' as Hex),
+    decodeFunctionResult: vi.fn((params: any) => {
+      // Return different mock data based on function name
+      if (params.functionName === 'name') return 'Test Token';
+      if (params.functionName === 'symbol') return 'TST';
+      if (params.functionName === 'decimals') return 18;
+      if (params.functionName === 'balanceOf') return 1000000000000000000n;
+      return 'MOCK_RESULT';
+    }),
+  };
+});
+
+describe('multicall', () => {
+  let mockClient: PublicClient;
+  let mockChain: Chain;
+
+  beforeEach(() => {
+    mockChain = {
+      id: 1,
+      name: 'Ethereum',
+      nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+      rpcUrls: {
+        default: { http: ['https://eth.llamarpc.com'] },
+      },
+      contracts: {
+        multicall3: {
+          address: '0xcA11bde05977b3631167028862bE2a173976CA11',
+        },
+      },
+    } as Chain;
+
+    mockClient = {
+      chain: mockChain,
+    } as PublicClient;
+  });
+
+  describe('multicallRead', () => {
+    it('should successfully read multiple calls', async () => {
+      const mockAggregate3 = vi.fn().mockResolvedValue([
+        { success: true, returnData: '0xRESULT1' as Hex },
+        { success: true, returnData: '0xRESULT2' as Hex },
+        { success: true, returnData: '0xRESULT3' as Hex },
+      ]);
+
+      const { getContract } = await import('viem');
+      (getContract as any).mockReturnValue({
+        read: {
+          aggregate3: mockAggregate3,
+        },
+      });
+
+      const result = await multicallRead({
+        chain: mockChain,
+        client: mockClient,
+        abi: erc20Abi,
+        target: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48' as Hex,
+        calls: [{ functionName: 'name' }, { functionName: 'symbol' }, { functionName: 'decimals' }],
+      });
+
+      expect(result).toBeDefined();
+      expect(Array.isArray(result)).toBe(true);
+      expect(result).toHaveLength(3);
+    });
+
+    it('should handle calls with arguments', async () => {
+      const mockAggregate3 = vi
+        .fn()
+        .mockResolvedValue([{ success: true, returnData: '0xRESULT1' as Hex }]);
+
+      const { getContract } = await import('viem');
+      (getContract as any).mockReturnValue({
+        read: {
+          aggregate3: mockAggregate3,
+        },
+      });
+
+      const result = await multicallRead({
+        chain: mockChain,
+        client: mockClient,
+        abi: erc20Abi,
+        target: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48' as Hex,
+        calls: [
+          {
+            functionName: 'balanceOf',
+            args: ['0x1111111111111111111111111111111111111111' as Hex],
+          },
+        ],
+      });
+
+      expect(result).toBeDefined();
+      expect(Array.isArray(result)).toBe(true);
+    });
+
+    it('should handle calls with allowFailure and failure', async () => {
+      const mockAggregate3 = vi.fn().mockResolvedValue([
+        { success: false, returnData: '0xERROR' as Hex },
+        { success: true, returnData: '0xRESULT2' as Hex },
+      ]);
+
+      const { getContract } = await import('viem');
+      (getContract as any).mockReturnValue({
+        read: {
+          aggregate3: mockAggregate3,
+        },
+      });
+
+      const result = await multicallRead({
+        chain: mockChain,
+        client: mockClient,
+        abi: erc20Abi,
+        target: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48' as Hex,
+        calls: [
+          { functionName: 'name', allowFailure: true },
+          { functionName: 'symbol', allowFailure: false },
+        ],
+      });
+
+      expect(result).toBeDefined();
+      expect(result[0]).toBe('0xERROR'); // Failed call returns returnData
+      expect(result[1]).toBe('TST'); // Successful call returns decoded result (symbol mock)
+    });
+
+    it('should handle calls with allowFailure and success', async () => {
+      const mockAggregate3 = vi.fn().mockResolvedValue([
+        { success: true, returnData: '0xRESULT1' as Hex },
+        { success: true, returnData: '0xRESULT2' as Hex },
+      ]);
+
+      const { getContract } = await import('viem');
+      (getContract as any).mockReturnValue({
+        read: {
+          aggregate3: mockAggregate3,
+        },
+      });
+
+      const result = await multicallRead({
+        chain: mockChain,
+        client: mockClient,
+        abi: erc20Abi,
+        target: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48' as Hex,
+        calls: [
+          { functionName: 'name', allowFailure: true }, // success=true, allowFailure=true -> decode
+          { functionName: 'symbol', allowFailure: false },
+        ],
+      });
+
+      expect(result).toBeDefined();
+      expect(result[0]).toBe('Test Token'); // Successful call with allowFailure=true returns decoded result
+      expect(result[1]).toBe('TST'); // Successful call returns decoded result
+    });
+
+    it('should handle calls with custom target addresses', async () => {
+      const mockAggregate3 = vi.fn().mockResolvedValue([
+        { success: true, returnData: '0xRESULT1' as Hex },
+        { success: true, returnData: '0xRESULT2' as Hex },
+      ]);
+
+      const { getContract } = await import('viem');
+      (getContract as any).mockReturnValue({
+        read: {
+          aggregate3: mockAggregate3,
+        },
+      });
+
+      const result = await multicallRead({
+        chain: mockChain,
+        client: mockClient,
+        abi: erc20Abi,
+        target: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48' as Hex,
+        calls: [
+          {
+            functionName: 'name',
+            target: '0x2222222222222222222222222222222222222222' as Hex,
+          },
+          { functionName: 'symbol' }, // Uses default target
+        ],
+      });
+
+      expect(result).toBeDefined();
+      expect(Array.isArray(result)).toBe(true);
+    });
+
+    it('should handle calls with custom ABIs', async () => {
+      const customAbi = [
+        {
+          name: 'customFunction',
+          type: 'function',
+          inputs: [],
+          outputs: [{ type: 'string' }],
+          stateMutability: 'view',
+        },
+      ] as const;
+
+      const mockAggregate3 = vi
+        .fn()
+        .mockResolvedValue([{ success: true, returnData: '0xRESULT1' as Hex }]);
+
+      const { getContract } = await import('viem');
+      (getContract as any).mockReturnValue({
+        read: {
+          aggregate3: mockAggregate3,
+        },
+      });
+
+      const result = await multicallRead({
+        chain: mockChain,
+        client: mockClient,
+        abi: erc20Abi,
+        target: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48' as Hex,
+        calls: [
+          {
+            functionName: 'customFunction',
+            abi: customAbi as any,
+          },
+        ],
+      });
+
+      expect(result).toBeDefined();
+    });
+
+    it('should throw error and log when aggregate3 fails', async () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const mockError = new Error('Multicall failed');
+
+      const mockAggregate3 = vi.fn().mockRejectedValue(mockError);
+
+      const { getContract } = await import('viem');
+      (getContract as any).mockReturnValue({
+        read: {
+          aggregate3: mockAggregate3,
+        },
+      });
+
+      await expect(
+        multicallRead({
+          chain: mockChain,
+          client: mockClient,
+          abi: erc20Abi,
+          target: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48' as Hex,
+          calls: [{ functionName: 'name' }],
+        }),
+      ).rejects.toThrow('Multicall failed');
+
+      expect(consoleErrorSpy).toHaveBeenCalled();
+      consoleErrorSpy.mockRestore();
+    });
+  });
+});

package/src/multicall.ts

@@ -1,15 +1,16 @@
+import _ from 'lodash';
 import {
-  type Chain,
-  type PublicClient,
-  type Hex,
   type Abi,
-  getContract,
-  encodeFunctionData,
+  type Chain,
   decodeFunctionResult,
+  encodeFunctionData,
+  getContract,
+  type Hex,
   multicall3Abi,
-} from 'viem'
-import _ from 'lodash'
-import type { Call } from './types.js'
+  type PublicClient,
+} from 'viem';
+import { ensureResult } from './assert.js';
+import type { Call } from './types.js';
 
 /** The multicall for the given chain, client, abi, calls, and target */
 export const multicallRead = async <T>({
@@ -19,18 +20,18 @@ export const multicallRead = async <T>({
   calls,
   target,
 }: {
-  chain: Chain
-  client: PublicClient
-  abi: Abi
-  calls: Call[]
-  target?: Hex
+  chain: Chain;
+  client: PublicClient;
+  abi: Abi;
+  calls: Call[];
+  target?: Hex;
 }) => {
   const multicall = getContract({
     abi: multicall3Abi,
     address: chain.contracts!.multicall3!.address!,
     // this seems like a bug in viem, it should be able to infer the type of the client
     client: client as any,
-  }) as any
+  }) as any;
   const arg = calls.map((call) => ({
     callData: encodeFunctionData({
       abi: call.abi || abi,
@@ -40,29 +41,28 @@ export const multicallRead = async <T>({
     }),
     allowFailure: call.allowFailure || false,
     target: (call.target || target) as Hex,
-  }))
-  let reads: null | Awaited<ReturnType<typeof multicall.read.aggregate3>> = null
+  }));
+  let reads: null | Awaited<ReturnType<typeof multicall.read.aggregate3>> = null;
   try {
-    reads = await multicall.read.aggregate3([arg])
-    if (!reads) throw reads
-    const r = reads
+    reads = await multicall.read.aggregate3([arg]);
+    const r = ensureResult(reads, 'Multicall aggregate3');
     return calls.map((call, i) =>
       call.allowFailure
         ? r[i].success
           ? decodeFunctionResult({
+              abi: call.abi || abi,
+              functionName: call.functionName,
+              data: r[i].returnData,
+            })
+          : r[i].returnData
+        : decodeFunctionResult({
             abi: call.abi || abi,
             functionName: call.functionName,
             data: r[i].returnData,
-          })
-          : r[i].returnData
-        : decodeFunctionResult({
-          abi: call.abi || abi,
-          functionName: call.functionName,
-          data: r[i].returnData,
-        }),
-    ) as T
+          }),
+    ) as T;
   } catch (err) {
-    console.error(client.chain?.id, target, calls, reads)
-    throw err
+    console.error(client.chain?.id, target, calls, reads);
+    throw err;
   }
-}
+};