viem 2.17.3 → 2.17.5

package/utils/encoding/fromHex.ts

@@ -28,25 +28,25 @@ export function assertSize(
 }
 
 export type FromHexParameters<
-  TTo extends 'string' | 'bigint' | 'number' | 'bytes' | 'boolean',
+  to extends 'string' | 'bigint' | 'number' | 'bytes' | 'boolean',
 > =
-  | TTo
+  | to
   | {
       /** Size (in bytes) of the hex value. */
       size?: number | undefined
       /** Type to convert to. */
-      to: TTo
+      to: to
     }
 
-export type FromHexReturnType<TTo> = TTo extends 'string'
+export type FromHexReturnType<to> = to extends 'string'
   ? string
-  : TTo extends 'bigint'
+  : to extends 'bigint'
     ? bigint
-    : TTo extends 'number'
+    : to extends 'number'
       ? number
-      : TTo extends 'bytes'
+      : to extends 'bytes'
         ? ByteArray
-        : TTo extends 'boolean'
+        : to extends 'boolean'
           ? boolean
           : never
 
@@ -87,16 +87,16 @@ export type FromHexErrorType =
  * // 'Hello world'
  */
 export function fromHex<
-  TTo extends 'string' | 'bigint' | 'number' | 'bytes' | 'boolean',
->(hex: Hex, toOrOpts: FromHexParameters<TTo>): FromHexReturnType<TTo> {
+  to extends 'string' | 'bigint' | 'number' | 'bytes' | 'boolean',
+>(hex: Hex, toOrOpts: FromHexParameters<to>): FromHexReturnType<to> {
   const opts = typeof toOrOpts === 'string' ? { to: toOrOpts } : toOrOpts
   const to = opts.to
 
-  if (to === 'number') return hexToNumber(hex, opts) as FromHexReturnType<TTo>
-  if (to === 'bigint') return hexToBigInt(hex, opts) as FromHexReturnType<TTo>
-  if (to === 'string') return hexToString(hex, opts) as FromHexReturnType<TTo>
-  if (to === 'boolean') return hexToBool(hex, opts) as FromHexReturnType<TTo>
-  return hexToBytes(hex, opts) as FromHexReturnType<TTo>
+  if (to === 'number') return hexToNumber(hex, opts) as FromHexReturnType<to>
+  if (to === 'bigint') return hexToBigInt(hex, opts) as FromHexReturnType<to>
+  if (to === 'string') return hexToString(hex, opts) as FromHexReturnType<to>
+  if (to === 'boolean') return hexToBool(hex, opts) as FromHexReturnType<to>
+  return hexToBytes(hex, opts) as FromHexReturnType<to>
 }
 
 export type HexToBigIntOpts = {

package/utils/ens/avatar/parseAvatarRecord.ts

@@ -34,8 +34,8 @@ export type ParseAvatarRecordErrorType =
  * @see https://docs.ens.domains/web/avatars
  *
  */
-export async function parseAvatarRecord<TChain extends Chain | undefined>(
-  client: Client<Transport, TChain>,
+export async function parseAvatarRecord<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
   {
     gatewayUrls,
     record,
@@ -58,8 +58,8 @@ type ParseNftAvatarUriErrorType =
   | GetMetadataAvatarUriErrorType
   | ErrorType
 
-async function parseNftAvatarUri<TChain extends Chain | undefined>(
-  client: Client<Transport, TChain>,
+async function parseNftAvatarUri<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
   {
     gatewayUrls,
     record,

package/utils/ens/avatar/utils.ts

@@ -258,8 +258,8 @@ export type GetNftTokenUriErrorType =
   | EnsAvatarUnsupportedNamespaceErrorType
   | ErrorType
 
-export async function getNftTokenUri<TChain extends Chain | undefined>(
-  client: Client<Transport, TChain>,
+export async function getNftTokenUri<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
   { nft }: { nft: ParsedNft },
 ) {
   if (nft.namespace === 'erc721') {

package/utils/filters/createFilterRequestScope.ts

@@ -28,8 +28,8 @@ type CreateFilterRequestScopeReturnType = (
  * listen for responses and scope the child transport `request` function
  * to the successful filter ID.
  */
-export function createFilterRequestScope<TChain extends Chain | undefined>(
-  client: Client<Transport, TChain>,
+export function createFilterRequestScope<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
   { method }: CreateFilterRequestScopeParameters,
 ): CreateFilterRequestScopeReturnType {
   const requestMap: Record<Hex, EIP1193RequestFn> = {}

package/utils/formatters/block.ts

@@ -15,24 +15,24 @@ import { type FormattedTransaction, formatTransaction } from './transaction.js'
 type BlockPendingDependencies = 'hash' | 'logsBloom' | 'nonce' | 'number'
 
 export type FormattedBlock<
-  TChain extends Chain | undefined = undefined,
-  TIncludeTransactions extends boolean = boolean,
-  TBlockTag extends BlockTag = BlockTag,
+  chain extends Chain | undefined = undefined,
+  includeTransactions extends boolean = boolean,
+  blockTag extends BlockTag = BlockTag,
   _FormatterReturnType = ExtractChainFormatterReturnType<
-    TChain,
+    chain,
     'block',
-    Block<bigint, TIncludeTransactions>
+    Block<bigint, includeTransactions>
   >,
   _ExcludedPendingDependencies extends string = BlockPendingDependencies &
-    ExtractChainFormatterExclude<TChain, 'block'>,
+    ExtractChainFormatterExclude<chain, 'block'>,
   _Formatted = Omit<_FormatterReturnType, BlockPendingDependencies> & {
     [_key in _ExcludedPendingDependencies]: never
   } & Pick<
-      Block<bigint, TIncludeTransactions, TBlockTag>,
+      Block<bigint, includeTransactions, blockTag>,
       BlockPendingDependencies
     >,
-  _Transactions = TIncludeTransactions extends true
-    ? Prettify<FormattedTransaction<TChain, TBlockTag>>[]
+  _Transactions = includeTransactions extends true
+    ? Prettify<FormattedTransaction<chain, blockTag>>[]
     : Hash[],
 > = Omit<_Formatted, 'transactions'> & {
   transactions: _Transactions

package/utils/formatters/formatter.ts

@@ -3,24 +3,24 @@ import type { Prettify } from '../../types/utils.js'
 
 export type DefineFormatterErrorType = ErrorType
 
-export function defineFormatter<TType extends string, TParameters, TReturnType>(
-  type: TType,
-  format: (_: TParameters) => TReturnType,
+export function defineFormatter<type extends string, parameters, returnType>(
+  type: type,
+  format: (_: parameters) => returnType,
 ) {
   return <
-    TOverrideParameters,
-    TOverrideReturnType,
-    TExclude extends (keyof TParameters | keyof TOverrideParameters)[] = [],
+    parametersOverride,
+    returnTypeOverride,
+    exclude extends (keyof parameters | keyof parametersOverride)[] = [],
   >({
     exclude,
     format: overrides,
   }: {
-    exclude?: TExclude | undefined
-    format: (_: TOverrideParameters) => TOverrideReturnType
+    exclude?: exclude | undefined
+    format: (_: parametersOverride) => returnTypeOverride
   }) => {
     return {
       exclude,
-      format: (args: TOverrideParameters) => {
+      format: (args: parametersOverride) => {
         const formatted = format(args as any)
         if (exclude) {
           for (const key of exclude) {
@@ -30,8 +30,8 @@ export function defineFormatter<TType extends string, TParameters, TReturnType>(
         return {
           ...formatted,
           ...overrides(args),
-        } as Prettify<TOverrideReturnType> & {
-          [_key in TExclude[number]]: never
+        } as Prettify<returnTypeOverride> & {
+          [_key in exclude[number]]: never
         }
       },
       type,

package/utils/formatters/transaction.ts

@@ -18,19 +18,19 @@ type TransactionPendingDependencies =
   | 'transactionIndex'
 
 export type FormattedTransaction<
-  TChain extends Chain | undefined = undefined,
-  TBlockTag extends BlockTag = BlockTag,
+  chain extends Chain | undefined = undefined,
+  blockTag extends BlockTag = BlockTag,
   _FormatterReturnType = ExtractChainFormatterReturnType<
-    TChain,
+    chain,
     'transaction',
     Transaction
   >,
   _ExcludedPendingDependencies extends string = TransactionPendingDependencies &
-    ExtractChainFormatterExclude<TChain, 'transaction'>,
+    ExtractChainFormatterExclude<chain, 'transaction'>,
 > = UnionLooseOmit<_FormatterReturnType, TransactionPendingDependencies> & {
   [_K in _ExcludedPendingDependencies]: never
 } & Pick<
-    Transaction<bigint, number, TBlockTag extends 'pending' ? true : false>,
+    Transaction<bigint, number, blockTag extends 'pending' ? true : false>,
     TransactionPendingDependencies
   >
 

package/utils/formatters/transactionReceipt.ts

@@ -13,9 +13,9 @@ import { formatLog } from './log.js'
 import { transactionType } from './transaction.js'
 
 export type FormattedTransactionReceipt<
-  TChain extends Chain | undefined = undefined,
+  chain extends Chain | undefined = undefined,
 > = ExtractChainFormatterReturnType<
-  TChain,
+  chain,
   'transactionReceipt',
   TransactionReceipt
 >

package/utils/formatters/transactionRequest.ts

@@ -11,9 +11,9 @@ import { bytesToHex, numberToHex } from '../encoding/toHex.js'
 import { type DefineFormatterErrorType, defineFormatter } from './formatter.js'
 
 export type FormattedTransactionRequest<
-  TChain extends Chain | undefined = Chain | undefined,
+  chain extends Chain | undefined = Chain | undefined,
 > = ExtractChainFormatterParameters<
-  TChain,
+  chain,
   'transactionRequest',
   TransactionRequest
 >

package/utils/hash/keccak256.ts

@@ -8,9 +8,9 @@ import { type ToHexErrorType, toHex } from '../encoding/toHex.js'
 
 type To = 'hex' | 'bytes'
 
-export type Keccak256Hash<TTo extends To> =
-  | (TTo extends 'bytes' ? ByteArray : never)
-  | (TTo extends 'hex' ? Hex : never)
+export type Keccak256Hash<to extends To> =
+  | (to extends 'bytes' ? ByteArray : never)
+  | (to extends 'hex' ? Hex : never)
 
 export type Keccak256ErrorType =
   | IsHexErrorType
@@ -18,14 +18,14 @@ export type Keccak256ErrorType =
   | ToHexErrorType
   | ErrorType
 
-export function keccak256<TTo extends To = 'hex'>(
+export function keccak256<to extends To = 'hex'>(
   value: Hex | ByteArray,
-  to_?: TTo | undefined,
-): Keccak256Hash<TTo> {
+  to_?: to | undefined,
+): Keccak256Hash<to> {
   const to = to_ || 'hex'
   const bytes = keccak_256(
     isHex(value, { strict: false }) ? toBytes(value) : value,
   )
-  if (to === 'bytes') return bytes as Keccak256Hash<TTo>
-  return toHex(bytes) as Keccak256Hash<TTo>
+  if (to === 'bytes') return bytes as Keccak256Hash<to>
+  return toHex(bytes) as Keccak256Hash<to>
 }

package/utils/hash/ripemd160.ts

@@ -8,9 +8,9 @@ import { type ToHexErrorType, toHex } from '../encoding/toHex.js'
 
 type To = 'hex' | 'bytes'
 
-export type Ripemd160Hash<TTo extends To> =
-  | (TTo extends 'bytes' ? ByteArray : never)
-  | (TTo extends 'hex' ? Hex : never)
+export type Ripemd160Hash<to extends To> =
+  | (to extends 'bytes' ? ByteArray : never)
+  | (to extends 'hex' ? Hex : never)
 
 export type Ripemd160ErrorType =
   | IsHexErrorType
@@ -18,14 +18,14 @@ export type Ripemd160ErrorType =
   | ToHexErrorType
   | ErrorType
 
-export function ripemd160<TTo extends To = 'hex'>(
+export function ripemd160<to extends To = 'hex'>(
   value: Hex | ByteArray,
-  to_?: TTo | undefined,
-): Ripemd160Hash<TTo> {
+  to_?: to | undefined,
+): Ripemd160Hash<to> {
   const to = to_ || 'hex'
   const bytes = noble_ripemd160(
     isHex(value, { strict: false }) ? toBytes(value) : value,
   )
-  if (to === 'bytes') return bytes as Ripemd160Hash<TTo>
-  return toHex(bytes) as Ripemd160Hash<TTo>
+  if (to === 'bytes') return bytes as Ripemd160Hash<to>
+  return toHex(bytes) as Ripemd160Hash<to>
 }

package/utils/hash/sha256.ts

@@ -8,9 +8,9 @@ import { type ToHexErrorType, toHex } from '../encoding/toHex.js'
 
 type To = 'hex' | 'bytes'
 
-export type Sha256Hash<TTo extends To> =
-  | (TTo extends 'bytes' ? ByteArray : never)
-  | (TTo extends 'hex' ? Hex : never)
+export type Sha256Hash<to extends To> =
+  | (to extends 'bytes' ? ByteArray : never)
+  | (to extends 'hex' ? Hex : never)
 
 export type Sha256ErrorType =
   | IsHexErrorType
@@ -18,14 +18,14 @@ export type Sha256ErrorType =
   | ToHexErrorType
   | ErrorType
 
-export function sha256<TTo extends To = 'hex'>(
+export function sha256<to extends To = 'hex'>(
   value: Hex | ByteArray,
-  to_?: TTo | undefined,
-): Sha256Hash<TTo> {
+  to_?: to | undefined,
+): Sha256Hash<to> {
   const to = to_ || 'hex'
   const bytes = noble_sha256(
     isHex(value, { strict: false }) ? toBytes(value) : value,
   )
-  if (to === 'bytes') return bytes as Sha256Hash<TTo>
-  return toHex(bytes) as Sha256Hash<TTo>
+  if (to === 'bytes') return bytes as Sha256Hash<to>
+  return toHex(bytes) as Sha256Hash<to>
 }

package/utils/observe.ts

@@ -14,8 +14,8 @@ export const listenersCache = /*#__PURE__*/ new Map<
 /** @internal */
 export const cleanupCache = /*#__PURE__*/ new Map<string, () => void>()
 
-type EmitFunction<TCallbacks extends Callbacks> = (
-  emit: TCallbacks,
+type EmitFunction<callbacks extends Callbacks> = (
+  emit: callbacks,
 ) => MaybePromise<void | (() => void)>
 
 let callbackCount = 0
@@ -25,10 +25,10 @@ let callbackCount = 0
  * is set up under the same observer id, the function will only be called once
  * for both instances of the observer.
  */
-export function observe<TCallbacks extends Callbacks>(
+export function observe<callbacks extends Callbacks>(
   observerId: string,
-  callbacks: TCallbacks,
-  fn: EmitFunction<TCallbacks>,
+  callbacks: callbacks,
+  fn: EmitFunction<callbacks>,
 ) {
   const callbackId = ++callbackCount
 
@@ -56,15 +56,15 @@ export function observe<TCallbacks extends Callbacks>(
 
   if (listeners && listeners.length > 0) return unwatch
 
-  const emit: TCallbacks = {} as TCallbacks
+  const emit: callbacks = {} as callbacks
   for (const key in callbacks) {
     emit[key] = ((
-      ...args: Parameters<NonNullable<TCallbacks[keyof TCallbacks]>>
+      ...args: Parameters<NonNullable<callbacks[keyof callbacks]>>
     ) => {
       const listeners = getListeners()
       if (listeners.length === 0) return
       for (const listener of listeners) listener.fns[key]?.(...args)
-    }) as TCallbacks[Extract<keyof TCallbacks, string>]
+    }) as callbacks[Extract<keyof callbacks, string>]
   }
 
   const cleanup = fn(emit)

package/utils/poll.ts

@@ -1,11 +1,11 @@
 import type { ErrorType } from '../errors/utils.js'
 import { wait } from './wait.js'
 
-type PollOptions<TData> = {
+type PollOptions<data> = {
   // Whether or not to emit when the polling starts.
   emitOnBegin?: boolean | undefined
   // The initial wait time (in ms) before polling.
-  initialWaitTime?: ((data: TData | void) => Promise<number>) | undefined
+  initialWaitTime?: ((data: data | void) => Promise<number>) | undefined
   // The interval (in ms).
   interval: number
 }
@@ -15,16 +15,16 @@ export type PollErrorType = ErrorType
 /**
  * @description Polls a function at a specified interval.
  */
-export function poll<TData>(
-  fn: ({ unpoll }: { unpoll: () => void }) => Promise<TData | void>,
-  { emitOnBegin, initialWaitTime, interval }: PollOptions<TData>,
+export function poll<data>(
+  fn: ({ unpoll }: { unpoll: () => void }) => Promise<data | void>,
+  { emitOnBegin, initialWaitTime, interval }: PollOptions<data>,
 ) {
   let active = true
 
   const unwatch = () => (active = false)
 
   const watch = async () => {
-    let data: TData | void = undefined
+    let data: data | void = undefined
     if (emitOnBegin) data = await fn({ unpoll: unwatch })
 
     const initialWait = (await initialWaitTime?.(data)) ?? interval

package/utils/promise/createBatchScheduler.ts

@@ -1,41 +1,38 @@
 import type { ErrorType } from '../../errors/utils.js'
 
-type Resolved<TReturnType extends readonly unknown[] = any> = [
-  result: TReturnType[number],
-  results: TReturnType,
+type Resolved<returnType extends readonly unknown[] = any> = [
+  result: returnType[number],
+  results: returnType,
 ]
 
-type PendingPromise<TReturnType extends readonly unknown[] = any> = {
-  resolve?: ((data: Resolved<TReturnType>) => void) | undefined
+type PendingPromise<returnType extends readonly unknown[] = any> = {
+  resolve?: ((data: Resolved<returnType>) => void) | undefined
   reject?: ((reason?: unknown) => void) | undefined
 }
 
 type SchedulerItem = { args: unknown; pendingPromise: PendingPromise }
 
-type BatchResultsCompareFn<TResult = unknown> = (
-  a: TResult,
-  b: TResult,
-) => number
+type BatchResultsCompareFn<result = unknown> = (a: result, b: result) => number
 
 type CreateBatchSchedulerArguments<
-  TParameters = unknown,
-  TReturnType extends readonly unknown[] = readonly unknown[],
+  parameters = unknown,
+  returnType extends readonly unknown[] = readonly unknown[],
 > = {
-  fn: (args: TParameters[]) => Promise<TReturnType>
+  fn: (args: parameters[]) => Promise<returnType>
   id: number | string
-  shouldSplitBatch?: ((args: TParameters[]) => boolean) | undefined
+  shouldSplitBatch?: ((args: parameters[]) => boolean) | undefined
   wait?: number | undefined
-  sort?: BatchResultsCompareFn<TReturnType[number]> | undefined
+  sort?: BatchResultsCompareFn<returnType[number]> | undefined
 }
 
 type CreateBatchSchedulerReturnType<
-  TParameters = unknown,
-  TReturnType extends readonly unknown[] = readonly unknown[],
+  parameters = unknown,
+  returnType extends readonly unknown[] = readonly unknown[],
 > = {
   flush: () => void
-  schedule: TParameters extends undefined
-    ? (args?: TParameters | undefined) => Promise<Resolved<TReturnType>>
-    : (args: TParameters) => Promise<Resolved<TReturnType>>
+  schedule: parameters extends undefined
+    ? (args?: parameters | undefined) => Promise<Resolved<returnType>>
+    : (args: parameters) => Promise<Resolved<returnType>>
 }
 
 export type CreateBatchSchedulerErrorType = ErrorType
@@ -44,8 +41,8 @@ const schedulerCache = /*#__PURE__*/ new Map<number | string, SchedulerItem[]>()
 
 /** @internal */
 export function createBatchScheduler<
-  TParameters,
-  TReturnType extends readonly unknown[],
+  parameters,
+  returnType extends readonly unknown[],
 >({
   fn,
   id,
@@ -53,9 +50,9 @@ export function createBatchScheduler<
   wait = 0,
   sort,
 }: CreateBatchSchedulerArguments<
-  TParameters,
-  TReturnType
->): CreateBatchSchedulerReturnType<TParameters, TReturnType> {
+  parameters,
+  returnType
+>): CreateBatchSchedulerReturnType<parameters, returnType> {
   const exec = async () => {
     const scheduler = getScheduler()
     flush()
@@ -64,7 +61,7 @@ export function createBatchScheduler<
 
     if (args.length === 0) return
 
-    fn(args as TParameters[])
+    fn(args as parameters[])
       .then((data) => {
         if (sort && Array.isArray(data)) data.sort(sort)
         for (let i = 0; i < scheduler.length; i++) {
@@ -83,7 +80,7 @@ export function createBatchScheduler<
   const flush = () => schedulerCache.delete(id)
 
   const getBatchedArgs = () =>
-    getScheduler().map(({ args }) => args) as TParameters[]
+    getScheduler().map(({ args }) => args) as parameters[]
 
   const getScheduler = () => schedulerCache.get(id) || []
 
@@ -92,9 +89,9 @@ export function createBatchScheduler<
 
   return {
     flush,
-    async schedule(args: TParameters) {
-      const pendingPromise: PendingPromise<TReturnType> = {}
-      const promise = new Promise<Resolved<TReturnType>>((resolve, reject) => {
+    async schedule(args: parameters) {
+      const pendingPromise: PendingPromise<returnType> = {}
+      const promise = new Promise<Resolved<returnType>>((resolve, reject) => {
         pendingPromise.resolve = resolve
         pendingPromise.reject = reject
       })
@@ -113,5 +110,5 @@ export function createBatchScheduler<
       setTimeout(exec, wait)
       return promise
     },
-  } as unknown as CreateBatchSchedulerReturnType<TParameters, TReturnType>
+  } as unknown as CreateBatchSchedulerReturnType<parameters, returnType>
 }

package/utils/promise/withCache.ts

@@ -7,15 +7,15 @@ export const responseCache = /*#__PURE__*/ new Map()
 
 export type GetCacheErrorType = ErrorType
 
-export function getCache<TData>(cacheKey: string) {
-  const buildCache = <TData>(cacheKey: string, cache: Map<string, TData>) => ({
+export function getCache<data>(cacheKey: string) {
+  const buildCache = <data>(cacheKey: string, cache: Map<string, data>) => ({
     clear: () => cache.delete(cacheKey),
     get: () => cache.get(cacheKey),
-    set: (data: TData) => cache.set(cacheKey, data),
+    set: (data: data) => cache.set(cacheKey, data),
   })
 
-  const promise = buildCache<Promise<TData>>(cacheKey, promiseCache)
-  const response = buildCache<{ created: Date; data: TData }>(
+  const promise = buildCache<Promise<data>>(cacheKey, promiseCache)
+  const response = buildCache<{ created: Date; data: data }>(
     cacheKey,
     responseCache,
   )
@@ -41,11 +41,11 @@ type WithCacheParameters = {
  * @description Returns the result of a given promise, and caches the result for
  * subsequent invocations against a provided cache key.
  */
-export async function withCache<TData>(
-  fn: () => Promise<TData>,
+export async function withCache<data>(
+  fn: () => Promise<data>,
   { cacheKey, cacheTime = Number.POSITIVE_INFINITY }: WithCacheParameters,
 ) {
-  const cache = getCache<TData>(cacheKey)
+  const cache = getCache<data>(cacheKey)
 
   // If a response exists in the cache, and it's not expired, return it
   // and do not invoke the promise.

package/utils/promise/withRetry.ts

@@ -23,15 +23,15 @@ export type WithRetryParameters = {
 
 export type WithRetryErrorType = ErrorType
 
-export function withRetry<TData>(
-  fn: () => Promise<TData>,
+export function withRetry<data>(
+  fn: () => Promise<data>,
   {
     delay: delay_ = 100,
     retryCount = 2,
     shouldRetry = () => true,
   }: WithRetryParameters = {},
 ) {
-  return new Promise<TData>((resolve, reject) => {
+  return new Promise<data>((resolve, reject) => {
     const attemptRetry = async ({ count = 0 } = {}) => {
       const retry = async ({ error }: { error: Error }) => {
         const delay =

package/utils/promise/withTimeout.ts

@@ -2,10 +2,10 @@ import type { ErrorType } from '../../errors/utils.js'
 
 export type WithTimeoutErrorType = ErrorType
 
-export function withTimeout<TData>(
+export function withTimeout<data>(
   fn: ({
     signal,
-  }: { signal: AbortController['signal'] | null }) => Promise<TData>,
+  }: { signal: AbortController['signal'] | null }) => Promise<data>,
   {
     errorInstance = new Error('timed out'),
     timeout,
@@ -18,7 +18,7 @@ export function withTimeout<TData>(
     // Whether or not the timeout should use an abort signal.
     signal?: boolean | undefined
   },
-): Promise<TData> {
+): Promise<data> {
   return new Promise((resolve, reject) => {
     ;(async () => {
       let timeoutId!: NodeJS.Timeout

package/utils/rpc/http.ts

@@ -25,10 +25,10 @@ export type HttpRpcClientOptions = {
 }
 
 export type HttpRequestParameters<
-  TBody extends RpcRequest | RpcRequest[] = RpcRequest,
+  body extends RpcRequest | RpcRequest[] = RpcRequest,
 > = {
   /** The RPC request body. */
-  body: TBody
+  body: body
   /** Request configuration to pass to `fetch`. */
   fetchOptions?: HttpRpcClientOptions['fetchOptions'] | undefined
   /** A callback to handle the response. */
@@ -40,8 +40,8 @@ export type HttpRequestParameters<
 }
 
 export type HttpRequestReturnType<
-  TBody extends RpcRequest | RpcRequest[] = RpcRequest,
-> = TBody extends RpcRequest[] ? RpcResponse[] : RpcResponse
+  body extends RpcRequest | RpcRequest[] = RpcRequest,
+> = body extends RpcRequest[] ? RpcResponse[] : RpcResponse
 
 export type HttpRequestErrorType =
   | HttpRequestErrorType_
@@ -50,9 +50,9 @@ export type HttpRequestErrorType =
   | ErrorType
 
 export type HttpRpcClient = {
-  request<TBody extends RpcRequest | RpcRequest[]>(
-    params: HttpRequestParameters<TBody>,
-  ): Promise<HttpRequestReturnType<TBody>>
+  request<body extends RpcRequest | RpcRequest[]>(
+    params: HttpRequestParameters<body>,
+  ): Promise<HttpRequestReturnType<body>>
 }
 
 export function getHttpRpcClient(