viem 0.4.0-main.20230419T202802 → 0.4.0-main.20230419T213620

package/src/errors/index.ts

@@ -37,6 +37,7 @@ export {
   ChainDoesNotSupportContract,
   ChainMismatchError,
   ChainNotFoundError,
+  ClientChainNotConfiguredError,
   InvalidChainIdError,
 } from './chain.js'
 

package/src/errors/version.ts

@@ -1 +1 @@
-export const version = '0.4.0-main.20230419T202802'
+export const version = '0.4.0-main.20230419T213620'

package/src/index.ts

@@ -182,6 +182,7 @@ export {
   CallExecutionError,
   ChainDisconnectedError,
   ChainDoesNotSupportContract,
+  ClientChainNotConfiguredError,
   ContractFunctionExecutionError,
   ContractFunctionRevertedError,
   ContractFunctionZeroDataError,

package/src/types/eip1193.ts

@@ -207,7 +207,7 @@ export type PublicRequests = {
      */
     method: 'eth_call'
     params: [
-      request: TransactionRequest,
+      request: Partial<TransactionRequest>,
       block: BlockNumber | BlockTag | BlockIdentifier,
     ]
   }): Promise<Hex>

package/src/utils/errors/getContractError.ts

@@ -33,11 +33,12 @@ export function getContractError(
     sender?: Address
   },
 ) {
-  const { code, data, message } = (
+  const { code, data, message, shortMessage } = (
     err instanceof RawContractError
       ? err
-      : err instanceof CallExecutionError ||
-        err instanceof EstimateGasExecutionError
+      : !(err.cause && 'data' in (err.cause as BaseError)) &&
+        (err instanceof CallExecutionError ||
+          err instanceof EstimateGasExecutionError)
       ? ((err.cause as BaseError)?.cause as BaseError)?.cause || {}
       : err.cause || {}
   ) as RawContractError
@@ -45,12 +46,15 @@ export function getContractError(
   let cause = err
   if (err instanceof AbiDecodingZeroDataError) {
     cause = new ContractFunctionZeroDataError({ functionName })
-  } else if (code === EXECUTION_REVERTED_ERROR_CODE && (data || message)) {
+  } else if (
+    code === EXECUTION_REVERTED_ERROR_CODE &&
+    (data || message || shortMessage)
+  ) {
     cause = new ContractFunctionRevertedError({
       abi,
       data,
       functionName,
-      message,
+      message: shortMessage ?? message,
     })
   }
 

package/src/utils/promise/createBatchScheduler.ts

@@ -0,0 +1,82 @@
+type Resolved<TReturnType extends readonly unknown[] = any> = [
+  result: TReturnType[number],
+  results: TReturnType,
+]
+
+type PendingPromise<TReturnType extends readonly unknown[] = any> = {
+  resolve?: (data: Resolved<TReturnType>) => void
+  reject?: (reason?: unknown) => void
+}
+
+type SchedulerItem = { args: unknown; pendingPromise: PendingPromise }
+
+const schedulerCache = new Map<number | string, SchedulerItem[]>()
+
+export function createBatchScheduler<
+  TParameters,
+  TReturnType extends readonly unknown[],
+>({
+  fn,
+  id,
+  shouldSplitBatch,
+  wait = 0,
+}: {
+  fn: (args: TParameters[]) => Promise<TReturnType>
+  id: number | string
+  shouldSplitBatch?: (args: TParameters[]) => boolean
+  wait?: number
+}) {
+  const exec = async () => {
+    const scheduler = getScheduler()
+    flush()
+
+    const args = scheduler.map(({ args }) => args)
+
+    if (args.length === 0) return
+
+    fn(args as TParameters[])
+      .then((data) => {
+        scheduler.forEach(({ pendingPromise }, i) =>
+          pendingPromise.resolve?.([data[i], data]),
+        )
+      })
+      .catch((err) => {
+        scheduler.forEach(({ pendingPromise }) => pendingPromise.reject?.(err))
+      })
+  }
+
+  const flush = () => schedulerCache.delete(id)
+
+  const getBatchedArgs = () =>
+    getScheduler().map(({ args }) => args) as TParameters[]
+
+  const getScheduler = () => schedulerCache.get(id) || []
+
+  const setScheduler = (item: SchedulerItem) =>
+    schedulerCache.set(id, [...getScheduler(), item])
+
+  return {
+    flush,
+    async schedule(args: TParameters) {
+      const pendingPromise: PendingPromise<TReturnType> = {}
+      const promise = new Promise<Resolved<TReturnType>>((resolve, reject) => {
+        pendingPromise.resolve = resolve
+        pendingPromise.reject = reject
+      })
+
+      const split = shouldSplitBatch?.([...getBatchedArgs(), args])
+
+      if (split) exec()
+
+      const hasActiveScheduler = getScheduler().length > 0
+      if (hasActiveScheduler) {
+        setScheduler({ args, pendingPromise })
+        return promise
+      }
+
+      setScheduler({ args, pendingPromise })
+      setTimeout(exec, wait)
+      return promise
+    },
+  }
+}

package/src/utils/promise/index.ts

@@ -1,3 +1,4 @@
+export { createBatchScheduler } from './createBatchScheduler.js'
 export { getCache, withCache } from './withCache.js'
 export { withRetry } from './withRetry.js'
 export { withTimeout } from './withTimeout.js'