@gibs/common 1.10.1 → 1.12.0

package/src/serialize.test.ts

@@ -0,0 +1,128 @@
+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,31 +1,30 @@
-
-const BIGINT_TYPE = 'bigint' as const
+const BIGINT_TYPE = 'bigint' as const;
 type SerializedBigInt = {
-  __type__: typeof BIGINT_TYPE
-  value: string
-}
+  __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
-}
+  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 BigInt(value.value);
   }
-  return value
-}
+  return value;
+};

package/src/types.ts

@@ -1,13 +1,13 @@
-import type { Abi, Hex } from "viem"
+import type { Abi, Hex } from 'viem';
 
 /** The inputs for a multicall read */
 export type Call = {
-  allowFailure?: boolean
-  functionName: string
-  target?: Hex
-  abi?: Abi
-  args?: (bigint | Hex | Hex[] | bigint[] | string | string[])[]
-}
+  allowFailure?: boolean;
+  functionName: string;
+  target?: Hex;
+  abi?: Abi;
+  args?: (bigint | Hex | Hex[] | bigint[] | string | string[])[];
+};
 
 /** The erc20 metadata */
-export type Erc20Metadata = [string, string, number]
+export type Erc20Metadata = [string, string, number];

package/tsconfig.json

@@ -12,5 +12,6 @@
     "moduleDetection": "force",
     "moduleResolution": "nodenext"
   },
-  "include": ["src/**/*.ts", "src/**/*.js"]
+  "include": ["src/**/*.ts", "src/**/*.js"],
+  "exclude": ["src/**/*.test.ts", "src/**/*.spec.ts"]
 }

package/vitest.config.ts

@@ -0,0 +1,13 @@
+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'],
+    },
+  },
+});

package/dist/src/cache.d.ts

@@ -1,14 +0,0 @@
-/**
- * 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 declare const maxMemoize: <A extends unknown[], B>(fn: (...a: A) => B, max?: number) => (...a: A) => B | undefined;
-/**
- * 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 declare const ttlMemoizeSingle: <A extends unknown[], B>(fn: (...a: A) => B, ttl?: number) => (...a: A) => B;

package/dist/src/cache.js

@@ -1,44 +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 = (fn, max = 1024) => {
-    const cache = new Map();
-    return (...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 = (fn, ttl = hour1) => {
-    let cache = null;
-    return (...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/dist/src/client.d.ts

@@ -1,30 +0,0 @@
-import { type Chain, type PublicClient } from "viem";
-/** The default batch config for the client */
-export declare const defaultBatchConfig: {
-    batch: {
-        wait: number;
-        batchSize: number;
-    };
-};
-/**
- * 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 declare const chainKey: (chainId: number, urls: string[]) => string;
-/** The client cache for the given chain id */
-export declare const clientCache: 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 declare const clientFromChain: ({ chain, urls, }: {
-    chain: Chain;
-    urls: string[];
-}) => PublicClient;

package/dist/src/client.js

@@ -1,55 +0,0 @@
-import { createPublicClient, fallback, http, 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, urls) => {
-    return `${chainId},${urls.join(',')}`.toLowerCase();
-};
-/** The client cache for the given chain id */
-export const clientCache = new Map();
-/**
- * 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, }) => {
-    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/dist/src/erc20.d.ts

@@ -1,13 +0,0 @@
-import { type Chain, type PublicClient, type Hex } from 'viem';
-import _ from 'lodash';
-import type { Erc20Metadata } from './types.js';
-/** The erc20 metadata calls */
-export declare const erc20MetadataCalls: {
-    functionName: string;
-}[];
-/** The multicall for the erc20 metadata */
-export declare const multicallErc20: (({ client, target, chain }: {
-    client: PublicClient;
-    target: Hex;
-    chain: Chain;
-}) => Promise<Erc20Metadata>) & _.MemoizedFunction;

package/dist/src/erc20.js

@@ -1,30 +0,0 @@
-import { erc20Abi, erc20Abi_bytes32, getAddress, } from 'viem';
-import _ from 'lodash';
-import { multicallRead } from './multicall.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 }) => {
-    const options = {
-        chain: chain,
-        client: client,
-        abi: erc20Abi,
-        target,
-        calls: erc20MetadataCalls,
-    };
-    try {
-        return await multicallRead(options);
-    }
-    catch {
-        return await multicallRead({
-            ...options,
-            abi: erc20Abi_bytes32,
-        });
-    }
-}, ({ target, chain }) => {
-    return !target ? chain.id : getAddress(target, chain.id);
-});

package/dist/src/index.d.ts

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

package/dist/src/index.js

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

package/dist/src/multicall.d.ts

@@ -1,10 +0,0 @@
-import { type Chain, type PublicClient, type Hex, type Abi } from 'viem';
-import type { Call } from './types.js';
-/** The multicall for the given chain, client, abi, calls, and target */
-export declare const multicallRead: <T>({ chain, client, abi, calls, target, }: {
-    chain: Chain;
-    client: PublicClient;
-    abi: Abi;
-    calls: Call[];
-    target?: Hex;
-}) => Promise<T>;

package/dist/src/multicall.js

@@ -1,44 +0,0 @@
-import { getContract, encodeFunctionData, decodeFunctionResult, multicall3Abi, } from 'viem';
-/** The multicall for the given chain, client, abi, calls, and target */
-export const multicallRead = async ({ chain, client, abi, calls, target, }) => {
-    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,
-    });
-    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 || []),
-        }),
-        allowFailure: call.allowFailure || false,
-        target: (call.target || target),
-    }));
-    let reads = null;
-    try {
-        reads = await multicall.read.aggregate3([arg]);
-        if (!reads)
-            throw reads;
-        const r = reads;
-        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,
-            }));
-    }
-    catch (err) {
-        console.error(client.chain?.id, target, calls, reads);
-        throw err;
-    }
-};

package/dist/src/serialize.d.ts

@@ -1,12 +0,0 @@
-declare const BIGINT_TYPE: "bigint";
-type SerializedBigInt = {
-    __type__: typeof BIGINT_TYPE;
-    value: string;
-};
-/** The json any stringify for the given key and value */
-export declare const jsonAnyStringify: (key: string, value: unknown) => unknown;
-/** The is serialized big int for the given value */
-export declare const isSerializedBigInt: (value: unknown) => value is SerializedBigInt;
-/** The json any parse for the given key and value */
-export declare const jsonAnyParse: (_key: string, value: unknown) => unknown;
-export {};

package/dist/src/serialize.js

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

package/dist/src/types.d.ts

@@ -1,11 +0,0 @@
-import type { Abi, Hex } from "viem";
-/** The inputs for a multicall read */
-export type Call = {
-    allowFailure?: boolean;
-    functionName: string;
-    target?: Hex;
-    abi?: Abi;
-    args?: (bigint | Hex | Hex[] | bigint[] | string | string[])[];
-};
-/** The erc20 metadata */
-export type Erc20Metadata = [string, string, number];

package/dist/src/types.js

@@ -1 +0,0 @@
-export {};