@gibs/common 1.6.27

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@gibs/common",
+  "version": "1.6.27",
+  "main": "index.js",
+  "access": "public",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./erc20": "./src/erc20.ts",
+    "./cache": "./src/cache.ts",
+    "./serialize": "./src/serialize.ts",
+    "./types": "./src/types.ts",
+    "./multicall": "./src/multicall.ts",
+    "./client": "./src/client.ts"
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "viem": "^2.31.0"
+  }
+}

package/src/cache.ts

@@ -0,0 +1,48 @@
+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.ts

@@ -0,0 +1,59 @@
+import { type Chain, type PublicClient, createPublicClient, fallback, http, webSocket } from "viem"
+
+export const defaultBatchConfig = {
+  batch: {
+    wait: 10,
+    batchSize: 32,
+  },
+}
+
+export const chainKey = (chainId: number, urls: string[]) => {
+  return `${chainId},${urls.join(',')}`.toLowerCase()
+}
+
+export const clientCache = new Map<number, {
+  key: string
+  client: PublicClient
+}>()
+
+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.ts

@@ -0,0 +1,41 @@
+import {
+  type Chain,
+  type PublicClient,
+  type Hex,
+  type Abi,
+  erc20Abi,
+  erc20Abi_bytes32,
+  getAddress,
+} from 'viem'
+import _ from 'lodash'
+import type { Erc20Metadata } from './types.js'
+import { multicallRead } from './multicall.js'
+
+export const erc20MetadataCalls = [
+  { functionName: 'name' },
+  { functionName: 'symbol' },
+  { functionName: 'decimals' },
+]
+
+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)
+  },
+)

package/src/index.ts

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

package/src/multicall.ts

@@ -0,0 +1,67 @@
+import {
+  type Chain,
+  type PublicClient,
+  type Hex,
+  type Abi,
+  getContract,
+  encodeFunctionData,
+  decodeFunctionResult,
+  multicall3Abi,
+} from 'viem'
+import _ from 'lodash'
+import type { Call } from './types.js'
+
+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])
+    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,
+        }),
+    ) as T
+  } catch (err) {
+    console.error(client.chain?.id, target, calls, reads)
+    throw err
+  }
+}

package/src/serialize.ts

@@ -0,0 +1,28 @@
+
+const BIGINT_TYPE = 'bigint' as const
+type SerializedBigInt = {
+  __type__: typeof BIGINT_TYPE
+  value: string
+}
+export const jsonAnyStringify = (key: string, value: unknown) => {
+  if (typeof value === BIGINT_TYPE) {
+    return {
+      __type__: BIGINT_TYPE,
+      value: (value as bigint).toString(),
+    }
+  }
+  return value
+}
+
+export const isSerializedBigInt = (value: unknown): value is SerializedBigInt => {
+  return (
+    !!value && typeof value === 'object' && (value as SerializedBigInt).__type__ === BIGINT_TYPE
+  )
+}
+
+export const jsonAnyParse = (_key: string, value: unknown) => {
+  if (isSerializedBigInt(value)) {
+    return BigInt(value.value)
+  }
+  return value
+}

package/src/types.ts

@@ -0,0 +1,11 @@
+import type { Abi, Hex } from "viem"
+
+export type Call = {
+  allowFailure?: boolean
+  functionName: string
+  target?: Hex
+  abi?: Abi
+  args?: (bigint | Hex | Hex[] | bigint[] | string | string[])[]
+}
+export type Erc20Metadata = [string, string, number]
+

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "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"]
+}