@gibs/common 1.12.0 → 1.13.1

package/src/multicall.test.ts

@@ -1,263 +0,0 @@
-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,68 +0,0 @@
-import _ from 'lodash';
-import {
-  type Abi,
-  type Chain,
-  decodeFunctionResult,
-  encodeFunctionData,
-  getContract,
-  type Hex,
-  multicall3Abi,
-  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>({
-  chain,
-  client,
-  abi,
-  calls,
-  target,
-}: {
-  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;
-  const arg = calls.map((call) => ({
-    callData: encodeFunctionData({
-      abi: call.abi || abi,
-      functionName: call.functionName,
-      // this seems like a bug in viem, it should be able to infer the type of the args
-      args: (call.args || []) as any,
-    }),
-    allowFailure: call.allowFailure || false,
-    target: (call.target || target) as Hex,
-  }));
-  let reads: null | Awaited<ReturnType<typeof multicall.read.aggregate3>> = null;
-  try {
-    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,
-          }),
-    ) as T;
-  } catch (err) {
-    console.error(client.chain?.id, target, calls, reads);
-    throw err;
-  }
-};

package/src/serialize.test.ts

@@ -1,128 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { isSerializedBigInt, jsonAnyParse, jsonAnyStringify } from './serialize';
-
-describe('serialize', () => {
-  describe('jsonAnyStringify', () => {
-    it('should serialize bigint values', () => {
-      const result = jsonAnyStringify('test', 12345n);
-      expect(result).toEqual({
-        __type__: 'bigint',
-        value: '12345',
-      });
-    });
-
-    it('should serialize large bigint values', () => {
-      const largeBigInt = BigInt('999999999999999999999999999999');
-      const result = jsonAnyStringify('test', largeBigInt);
-      expect(result).toEqual({
-        __type__: 'bigint',
-        value: '999999999999999999999999999999',
-      });
-    });
-
-    it('should pass through non-bigint values unchanged', () => {
-      expect(jsonAnyStringify('test', 'string')).toBe('string');
-      expect(jsonAnyStringify('test', 123)).toBe(123);
-      expect(jsonAnyStringify('test', true)).toBe(true);
-      expect(jsonAnyStringify('test', null)).toBe(null);
-      expect(jsonAnyStringify('test', undefined)).toBe(undefined);
-    });
-
-    it('should handle objects', () => {
-      const obj = { foo: 'bar' };
-      expect(jsonAnyStringify('test', obj)).toBe(obj);
-    });
-
-    it('should handle arrays', () => {
-      const arr = [1, 2, 3];
-      expect(jsonAnyStringify('test', arr)).toBe(arr);
-    });
-  });
-
-  describe('isSerializedBigInt', () => {
-    it('should identify serialized bigint objects', () => {
-      const serialized = {
-        __type__: 'bigint',
-        value: '12345',
-      };
-      expect(isSerializedBigInt(serialized)).toBe(true);
-    });
-
-    it('should reject non-serialized bigint objects', () => {
-      expect(isSerializedBigInt({})).toBe(false);
-      expect(isSerializedBigInt({ __type__: 'string' })).toBe(false);
-      expect(isSerializedBigInt({ value: '123' })).toBe(false);
-      expect(isSerializedBigInt('string')).toBe(false);
-      expect(isSerializedBigInt(123)).toBe(false);
-      expect(isSerializedBigInt(null)).toBe(false);
-      expect(isSerializedBigInt(undefined)).toBe(false);
-    });
-  });
-
-  describe('jsonAnyParse', () => {
-    it('should deserialize bigint values', () => {
-      const serialized = {
-        __type__: 'bigint',
-        value: '12345',
-      };
-      const result = jsonAnyParse('test', serialized);
-      expect(result).toBe(12345n);
-      expect(typeof result).toBe('bigint');
-    });
-
-    it('should deserialize large bigint values', () => {
-      const serialized = {
-        __type__: 'bigint',
-        value: '999999999999999999999999999999',
-      };
-      const result = jsonAnyParse('test', serialized);
-      expect(result).toBe(BigInt('999999999999999999999999999999'));
-    });
-
-    it('should pass through non-serialized-bigint values unchanged', () => {
-      expect(jsonAnyParse('test', 'string')).toBe('string');
-      expect(jsonAnyParse('test', 123)).toBe(123);
-      expect(jsonAnyParse('test', true)).toBe(true);
-      expect(jsonAnyParse('test', null)).toBe(null);
-      expect(jsonAnyParse('test', undefined)).toBe(undefined);
-    });
-  });
-
-  describe('round-trip serialization', () => {
-    it('should correctly round-trip bigint values through JSON', () => {
-      const original = { amount: 12345n, balance: 999999999999999999n };
-      const serialized = JSON.stringify(original, jsonAnyStringify);
-      const deserialized = JSON.parse(serialized, jsonAnyParse);
-
-      expect(deserialized.amount).toBe(12345n);
-      expect(deserialized.balance).toBe(999999999999999999n);
-    });
-
-    it('should handle nested objects with bigints', () => {
-      const original = {
-        user: {
-          address: '0x123',
-          balance: 1000000000000000000n,
-        },
-        transaction: {
-          value: 5000000000000000n,
-          gasLimit: 21000n,
-        },
-      };
-      const serialized = JSON.stringify(original, jsonAnyStringify);
-      const deserialized = JSON.parse(serialized, jsonAnyParse);
-
-      expect(deserialized.user.balance).toBe(1000000000000000000n);
-      expect(deserialized.transaction.value).toBe(5000000000000000n);
-      expect(deserialized.transaction.gasLimit).toBe(21000n);
-    });
-
-    it('should handle arrays with bigints', () => {
-      const original = [1n, 2n, 3n, 999999999999999999n];
-      const serialized = JSON.stringify(original, jsonAnyStringify);
-      const deserialized = JSON.parse(serialized, jsonAnyParse);
-
-      expect(deserialized).toEqual([1n, 2n, 3n, 999999999999999999n]);
-    });
-  });
-});

package/src/serialize.ts

@@ -1,30 +0,0 @@
-const BIGINT_TYPE = 'bigint' as const;
-type SerializedBigInt = {
-  __type__: typeof BIGINT_TYPE;
-  value: string;
-};
-/** The json any stringify for the given key and value */
-export const jsonAnyStringify = (key: string, value: unknown) => {
-  if (typeof value === BIGINT_TYPE) {
-    return {
-      __type__: BIGINT_TYPE,
-      value: (value as bigint).toString(),
-    };
-  }
-  return value;
-};
-
-/** The is serialized big int for the given value */
-export const isSerializedBigInt = (value: unknown): value is SerializedBigInt => {
-  return (
-    !!value && typeof value === 'object' && (value as SerializedBigInt).__type__ === BIGINT_TYPE
-  );
-};
-
-/** The json any parse for the given key and value */
-export const jsonAnyParse = (_key: string, value: unknown) => {
-  if (isSerializedBigInt(value)) {
-    return BigInt(value.value);
-  }
-  return value;
-};

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ESNext",
-    "useDefineForClassFields": true,
-    "module": "NodeNext",
-    "composite": true,
-    "allowJs": true,
-    "outDir": "./dist",
-    "strict": true,
-    "isolatedModules": true,
-    "skipLibCheck": true,
-    "moduleDetection": "force",
-    "moduleResolution": "nodenext"
-  },
-  "include": ["src/**/*.ts", "src/**/*.js"],
-  "exclude": ["src/**/*.test.ts", "src/**/*.spec.ts"]
-}

package/vitest.config.ts

@@ -1,13 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    coverage: {
-      provider: 'v8',
-      reporter: ['text', 'json', 'html'],
-      exclude: ['node_modules/**', 'dist/**', '**/*.config.ts', '**/*.d.ts'],
-    },
-  },
-});