viem 2.17.3 → 2.17.4

package/types/log.ts

@@ -13,57 +13,57 @@ import type {
 import type { Hash, Hex } from './misc.js'
 
 export type Log<
-  TQuantity = bigint,
-  TIndex = number,
-  TPending extends boolean = boolean,
-  TAbiEvent extends AbiEvent | undefined = undefined,
-  TStrict extends boolean | undefined = undefined,
-  TAbi extends Abi | readonly unknown[] | undefined = TAbiEvent extends AbiEvent
-    ? [TAbiEvent]
+  quantity = bigint,
+  index = number,
+  pending extends boolean = boolean,
+  abiEvent extends AbiEvent | undefined = undefined,
+  strict extends boolean | undefined = undefined,
+  abi extends Abi | readonly unknown[] | undefined = abiEvent extends AbiEvent
+    ? [abiEvent]
     : undefined,
-  TEventName extends string | undefined = TAbiEvent extends AbiEvent
-    ? TAbiEvent['name']
+  eventName extends string | undefined = abiEvent extends AbiEvent
+    ? abiEvent['name']
     : undefined,
 > = {
   /** The address from which this log originated */
   address: Address
   /** Hash of block containing this log or `null` if pending */
-  blockHash: TPending extends true ? null : Hash
+  blockHash: pending extends true ? null : Hash
   /** Number of block containing this log or `null` if pending */
-  blockNumber: TPending extends true ? null : TQuantity
+  blockNumber: pending extends true ? null : quantity
   /** Contains the non-indexed arguments of the log */
   data: Hex
   /** Index of this log within its block or `null` if pending */
-  logIndex: TPending extends true ? null : TIndex
+  logIndex: pending extends true ? null : index
   /** Hash of the transaction that created this log or `null` if pending */
-  transactionHash: TPending extends true ? null : Hash
+  transactionHash: pending extends true ? null : Hash
   /** Index of the transaction that created this log or `null` if pending */
-  transactionIndex: TPending extends true ? null : TIndex
+  transactionIndex: pending extends true ? null : index
   /** `true` if this filter has been destroyed and is invalid */
   removed: boolean
-} & GetInferredLogValues<TAbiEvent, TAbi, TEventName, TStrict>
+} & GetInferredLogValues<abiEvent, abi, eventName, strict>
 
 type Topics<
-  THead extends AbiEvent['inputs'],
-  TBase = [Hex],
-> = THead extends readonly [
+  head extends AbiEvent['inputs'],
+  base = [Hex],
+> = head extends readonly [
   infer _Head,
   ...infer Tail extends AbiEvent['inputs'],
 ]
   ? _Head extends { indexed: true }
     ? [Hex, ...Topics<Tail>]
     : Topics<Tail>
-  : TBase
+  : base
 
 type GetTopics<
-  TAbiEvent extends AbiEvent | undefined = undefined,
-  TAbi extends Abi | readonly unknown[] = [TAbiEvent],
-  TEventName extends string | undefined = TAbiEvent extends AbiEvent
-    ? TAbiEvent['name']
+  abiEvent extends AbiEvent | undefined = undefined,
+  abi extends Abi | readonly unknown[] = [abiEvent],
+  eventName extends string | undefined = abiEvent extends AbiEvent
+    ? abiEvent['name']
     : undefined,
-  _AbiEvent extends AbiEvent | undefined = TAbi extends Abi
-    ? TEventName extends string
-      ? ExtractAbiEvent<TAbi, TEventName>
+  _AbiEvent extends AbiEvent | undefined = abi extends Abi
+    ? eventName extends string
+      ? ExtractAbiEvent<abi, eventName>
       : undefined
     : undefined,
   _Args = _AbiEvent extends AbiEvent
@@ -74,58 +74,58 @@ type GetTopics<
     | (readonly unknown[] extends _Args ? true : false),
 > = true extends _FailedToParseArgs
   ? [Hex, ...Hex[]] | []
-  : TAbiEvent extends AbiEvent
-    ? Topics<TAbiEvent['inputs']>
+  : abiEvent extends AbiEvent
+    ? Topics<abiEvent['inputs']>
     : _AbiEvent extends AbiEvent
       ? Topics<_AbiEvent['inputs']>
       : [Hex, ...Hex[]] | []
 
 type GetInferredLogValues<
-  TAbiEvent extends AbiEvent | undefined = undefined,
-  TAbi extends Abi | readonly unknown[] | undefined = TAbiEvent extends AbiEvent
-    ? [TAbiEvent]
+  abiEvent extends AbiEvent | undefined = undefined,
+  abi extends Abi | readonly unknown[] | undefined = abiEvent extends AbiEvent
+    ? [abiEvent]
     : undefined,
-  TEventName extends string | undefined = TAbiEvent extends AbiEvent
-    ? TAbiEvent['name']
+  eventName extends string | undefined = abiEvent extends AbiEvent
+    ? abiEvent['name']
     : undefined,
-  TStrict extends boolean | undefined = undefined,
-  _EventNames extends string = TAbi extends Abi
-    ? Abi extends TAbi
+  strict extends boolean | undefined = undefined,
+  _EventNames extends string = abi extends Abi
+    ? Abi extends abi
       ? string
-      : ExtractAbiEventNames<TAbi>
+      : ExtractAbiEventNames<abi>
     : string,
-> = TAbi extends Abi
-  ? TEventName extends string
+> = abi extends Abi
+  ? eventName extends string
     ? {
         args: GetEventArgs<
-          TAbi,
-          TEventName,
+          abi,
+          eventName,
           {
             EnableUnion: false
             IndexedOnly: false
-            Required: TStrict extends boolean ? TStrict : false
+            Required: strict extends boolean ? strict : false
           }
         >
         /** The event name decoded from `topics`. */
-        eventName: TEventName
+        eventName: eventName
         /** List of order-dependent topics */
-        topics: GetTopics<TAbiEvent, TAbi, TEventName>
+        topics: GetTopics<abiEvent, abi, eventName>
       }
     : {
-        [TName in _EventNames]: {
+        [name in _EventNames]: {
           args: GetEventArgs<
-            TAbi,
-            TName,
+            abi,
+            name,
             {
               EnableUnion: false
               IndexedOnly: false
-              Required: TStrict extends boolean ? TStrict : false
+              Required: strict extends boolean ? strict : false
             }
           >
           /** The event name decoded from `topics`. */
-          eventName: TName
+          eventName: name
           /** List of order-dependent topics */
-          topics: GetTopics<TAbiEvent, TAbi, TName>
+          topics: GetTopics<abiEvent, abi, name>
         }
       }[_EventNames]
   : {

package/types/proof.ts

@@ -3,18 +3,18 @@ import type { Hash } from './misc.js'
 
 type AccountProof = Hash
 
-type StorageProof<TQuantity = bigint> = {
+type StorageProof<quantity = bigint> = {
   key: Hash
   proof: Hash[]
-  value: TQuantity
+  value: quantity
 }
 
-export type Proof<TQuantity = bigint, TIndex = number> = {
+export type Proof<quantity = bigint, index = number> = {
   address: Address
-  balance: TQuantity
+  balance: quantity
   codeHash: Hash
-  nonce: TIndex
+  nonce: index
   storageHash: Hash
   accountProof: AccountProof[]
-  storageProof: StorageProof<TQuantity>[]
+  storageProof: StorageProof<quantity>[]
 }

package/types/rpc.ts

@@ -30,10 +30,10 @@ export type Status = '0x0' | '0x1'
 export type TransactionType = '0x0' | '0x1' | '0x2' | (string & {})
 
 export type RpcBlock<
-  TBlockTag extends BlockTag = BlockTag,
-  TIncludeTransactions extends boolean = boolean,
-  TTransaction = RpcTransaction<TBlockTag extends 'pending' ? true : false>,
-> = Block<Quantity, TIncludeTransactions, TBlockTag, TTransaction>
+  blockTag extends BlockTag = BlockTag,
+  includeTransactions extends boolean = boolean,
+  transaction = RpcTransaction<blockTag extends 'pending' ? true : false>,
+> = Block<Quantity, includeTransactions, blockTag, transaction>
 export type RpcBlockNumber = BlockNumber<Quantity>
 export type RpcBlockIdentifier = BlockIdentifier<Quantity>
 export type RpcUncle = Uncle<Quantity>
@@ -55,18 +55,18 @@ export type RpcTransactionRequest = OneOf<
 >
 // `yParity` is optional on the RPC type as some nodes do not return it
 // for 1559 & 2930 transactions (they should!).
-export type RpcTransaction<TPending extends boolean = boolean> = OneOf<
-  | Omit<TransactionLegacy<Quantity, Index, TPending, '0x0'>, 'typeHex'>
+export type RpcTransaction<pending extends boolean = boolean> = OneOf<
+  | Omit<TransactionLegacy<Quantity, Index, pending, '0x0'>, 'typeHex'>
   | PartialBy<
-      Omit<TransactionEIP2930<Quantity, Index, TPending, '0x1'>, 'typeHex'>,
+      Omit<TransactionEIP2930<Quantity, Index, pending, '0x1'>, 'typeHex'>,
       'yParity'
     >
   | PartialBy<
-      Omit<TransactionEIP1559<Quantity, Index, TPending, '0x2'>, 'typeHex'>,
+      Omit<TransactionEIP1559<Quantity, Index, pending, '0x2'>, 'typeHex'>,
       'yParity'
     >
   | PartialBy<
-      Omit<TransactionEIP4844<Quantity, Index, TPending, '0x3'>, 'typeHex'>,
+      Omit<TransactionEIP4844<Quantity, Index, pending, '0x3'>, 'typeHex'>,
       'yParity'
     >
 >

package/types/transport.ts

@@ -2,8 +2,8 @@ import type { Transport } from '../clients/transports/createTransport.js'
 import type { FallbackTransport } from '../clients/transports/fallback.js'
 import type { Some } from './utils.js'
 
-export type GetTransportConfig<TTransport extends Transport> =
-  ReturnType<TTransport>['config']
+export type GetTransportConfig<transport extends Transport> =
+  ReturnType<transport>['config']
 
 export type GetPollOptions<transport extends Transport> =
   | (HasTransportType<transport, 'webSocket'> extends true

package/types/utils.ts

@@ -110,7 +110,7 @@ export type IsUndefined<T> = [undefined] extends [T] ? true : false
 export type MaybePromise<T> = T | Promise<T>
 
 /**
- * @description Makes attributes on the type T required if TRequired is true.
+ * @description Makes attributes on the type T required if required is true.
  *
  * @example
  * MaybeRequired<{ a: string, b?: number }, true>
@@ -119,7 +119,7 @@ export type MaybePromise<T> = T | Promise<T>
  * MaybeRequired<{ a: string, b?: number }, false>
  * => { a: string, b?: number }
  */
-export type MaybeRequired<T, TRequired extends boolean> = TRequired extends true
+export type MaybeRequired<T, required extends boolean> = required extends true
   ? ExactRequired<T>
   : T
 

package/utils/abi/decodeAbiParameters.ts

@@ -36,9 +36,9 @@ import { type BytesToHexErrorType, bytesToHex } from '../encoding/toHex.js'
 import { getArrayComponents } from './encodeAbiParameters.js'
 
 export type DecodeAbiParametersReturnType<
-  TParams extends readonly AbiParameter[] = readonly AbiParameter[],
+  params extends readonly AbiParameter[] = readonly AbiParameter[],
 > = AbiParametersToPrimitiveTypes<
-  TParams extends readonly AbiParameter[] ? TParams : AbiParameter[]
+  params extends readonly AbiParameter[] ? params : AbiParameter[]
 >
 
 export type DecodeAbiParametersErrorType =
@@ -50,11 +50,11 @@ export type DecodeAbiParametersErrorType =
   | ErrorType
 
 export function decodeAbiParameters<
-  const TParams extends readonly AbiParameter[],
+  const params extends readonly AbiParameter[],
 >(
-  params: TParams,
+  params: params,
   data: ByteArray | Hex,
-): DecodeAbiParametersReturnType<TParams> {
+): DecodeAbiParametersReturnType<params> {
   const bytes = typeof data === 'string' ? hexToBytes(data) : data
   const cursor = createCursor(bytes)
 
@@ -78,7 +78,7 @@ export function decodeAbiParameters<
     consumed += consumed_
     values.push(data)
   }
-  return values as DecodeAbiParametersReturnType<TParams>
+  return values as DecodeAbiParametersReturnType<params>
 }
 
 type DecodeParameterErrorType =

package/utils/abi/decodeErrorResult.ts

@@ -62,9 +62,9 @@ export type DecodeErrorResultErrorType =
   | ToFunctionSelectorErrorType
   | ErrorType
 
-export function decodeErrorResult<const TAbi extends Abi | readonly unknown[]>(
-  parameters: DecodeErrorResultParameters<TAbi>,
-): DecodeErrorResultReturnType<TAbi> {
+export function decodeErrorResult<const abi extends Abi | readonly unknown[]>(
+  parameters: DecodeErrorResultParameters<abi>,
+): DecodeErrorResultReturnType<abi> {
   const { abi, data } = parameters as DecodeErrorResultParameters
 
   const signature = slice(data, 0, 4)
@@ -86,5 +86,5 @@ export function decodeErrorResult<const TAbi extends Abi | readonly unknown[]>(
         ? decodeAbiParameters(abiItem.inputs, slice(data, 4))
         : undefined,
     errorName: (abiItem as { name: string }).name,
-  } as DecodeErrorResultReturnType<TAbi>
+  } as DecodeErrorResultReturnType<abi>
 }

package/utils/abi/encodeAbiParameters.ts

@@ -81,11 +81,11 @@ export type EncodeAbiParametersErrorType =
  * ```
  */
 export function encodeAbiParameters<
-  const TParams extends readonly AbiParameter[] | readonly unknown[],
+  const params extends readonly AbiParameter[] | readonly unknown[],
 >(
-  params: TParams,
-  values: TParams extends readonly AbiParameter[]
-    ? AbiParametersToPrimitiveTypes<TParams>
+  params: params,
+  values: params extends readonly AbiParameter[]
+    ? AbiParametersToPrimitiveTypes<params>
     : never,
 ): EncodeAbiParametersReturnType {
   if (params.length !== values.length)
@@ -112,12 +112,12 @@ type Tuple = AbiParameterToPrimitiveType<TupleAbiParameter>
 
 type PrepareParamsErrorType = PrepareParamErrorType | ErrorType
 
-function prepareParams<const TParams extends readonly AbiParameter[]>({
+function prepareParams<const params extends readonly AbiParameter[]>({
   params,
   values,
 }: {
-  params: TParams
-  values: AbiParametersToPrimitiveTypes<TParams>
+  params: params
+  values: AbiParametersToPrimitiveTypes<params>
 }) {
   const preparedParams: PreparedParam[] = []
   for (let i = 0; i < params.length; i++) {
@@ -138,12 +138,12 @@ type PrepareParamErrorType =
   | InvalidAbiEncodingTypeErrorType
   | ErrorType
 
-function prepareParam<const TParam extends AbiParameter>({
+function prepareParam<const param extends AbiParameter>({
   param,
   value,
 }: {
-  param: TParam
-  value: AbiParameterToPrimitiveType<TParam>
+  param: param
+  value: AbiParameterToPrimitiveType<param>
 }): PreparedParam {
   const arrayComponents = getArrayComponents(param.type)
   if (arrayComponents) {
@@ -230,14 +230,14 @@ type EncodeArrayErrorType =
   // | PrepareParamErrorType
   | ErrorType
 
-function encodeArray<const TParam extends AbiParameter>(
-  value: AbiParameterToPrimitiveType<TParam>,
+function encodeArray<const param extends AbiParameter>(
+  value: AbiParameterToPrimitiveType<param>,
   {
     length,
     param,
   }: {
     length: number | null
-    param: TParam
+    param: param
   },
 ): PreparedParam {
   const dynamic = length === null
@@ -283,9 +283,9 @@ type EncodeBytesErrorType =
   | SizeErrorType
   | ErrorType
 
-function encodeBytes<const TParam extends AbiParameter>(
+function encodeBytes<const param extends AbiParameter>(
   value: Hex,
-  { param }: { param: TParam },
+  { param }: { param: param },
 ): PreparedParam {
   const [, paramSize] = param.type.split('bytes')
   const bytesSize = size(value)
@@ -373,10 +373,10 @@ type EncodeTupleErrorType =
   | ErrorType
 
 function encodeTuple<
-  const TParam extends AbiParameter & { components: readonly AbiParameter[] },
+  const param extends AbiParameter & { components: readonly AbiParameter[] },
 >(
-  value: AbiParameterToPrimitiveType<TParam>,
-  { param }: { param: TParam },
+  value: AbiParameterToPrimitiveType<param>,
+  { param }: { param: param },
 ): PreparedParam {
   let dynamic = false
   const preparedParams: PreparedParam[] = []

package/utils/abi/encodePacked.ts

@@ -45,10 +45,10 @@ type PackedAbiType =
   | SolidityArrayWithoutTuple
 
 type EncodePackedValues<
-  TPackedAbiTypes extends readonly PackedAbiType[] | readonly unknown[],
+  packedAbiTypes extends readonly PackedAbiType[] | readonly unknown[],
 > = {
-  [K in keyof TPackedAbiTypes]: TPackedAbiTypes[K] extends AbiType
-    ? AbiParameterToPrimitiveType<{ type: TPackedAbiTypes[K] }>
+  [K in keyof packedAbiTypes]: packedAbiTypes[K] extends AbiType
+    ? AbiParameterToPrimitiveType<{ type: packedAbiTypes[K] }>
     : unknown
 }
 
@@ -59,8 +59,8 @@ export type EncodePackedErrorType =
   | ErrorType
 
 export function encodePacked<
-  const TPackedAbiTypes extends readonly PackedAbiType[] | readonly unknown[],
->(types: TPackedAbiTypes, values: EncodePackedValues<TPackedAbiTypes>): Hex {
+  const packedAbiTypes extends readonly PackedAbiType[] | readonly unknown[],
+>(types: packedAbiTypes, values: EncodePackedValues<packedAbiTypes>): Hex {
   if (types.length !== values.length)
     throw new AbiEncodingLengthMismatchError({
       expectedLength: types.length as number,
@@ -87,9 +87,9 @@ type EncodeErrorType =
   | UnsupportedPackedAbiType
   | ErrorType
 
-function encode<const TPackedAbiType extends PackedAbiType | unknown>(
-  type: TPackedAbiType,
-  value: EncodePackedValues<[TPackedAbiType]>[0],
+function encode<const packedAbiType extends PackedAbiType | unknown>(
+  type: packedAbiType,
+  value: EncodePackedValues<[packedAbiType]>[0],
   isArray = false,
 ): Hex {
   if (type === 'address') {

package/utils/ccip.ts

@@ -56,8 +56,8 @@ export const offchainLookupAbiItem = {
 
 export type OffchainLookupErrorType = OffchainLookupErrorType_ | ErrorType
 
-export async function offchainLookup<TChain extends Chain | undefined>(
-  client: Client<Transport, TChain>,
+export async function offchainLookup<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
   {
     blockNumber,
     blockTag,

package/utils/data/concat.ts

@@ -1,20 +1,21 @@
 import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
 
-export type ConcatReturnType<TValue extends Hex | ByteArray> =
-  TValue extends Hex ? Hex : ByteArray
+export type ConcatReturnType<value extends Hex | ByteArray> = value extends Hex
+  ? Hex
+  : ByteArray
 
 export type ConcatErrorType =
   | ConcatBytesErrorType
   | ConcatHexErrorType
   | ErrorType
 
-export function concat<TValue extends Hex | ByteArray>(
-  values: readonly TValue[],
-): ConcatReturnType<TValue> {
+export function concat<value extends Hex | ByteArray>(
+  values: readonly value[],
+): ConcatReturnType<value> {
   if (typeof values[0] === 'string')
-    return concatHex(values as readonly Hex[]) as ConcatReturnType<TValue>
-  return concatBytes(values as readonly ByteArray[]) as ConcatReturnType<TValue>
+    return concatHex(values as readonly Hex[]) as ConcatReturnType<value>
+  return concatBytes(values as readonly ByteArray[]) as ConcatReturnType<value>
 }
 
 export type ConcatBytesErrorType = ErrorType

package/utils/data/pad.ts

@@ -9,19 +9,19 @@ type PadOptions = {
   dir?: 'left' | 'right' | undefined
   size?: number | null | undefined
 }
-export type PadReturnType<TValue extends ByteArray | Hex> = TValue extends Hex
+export type PadReturnType<value extends ByteArray | Hex> = value extends Hex
   ? Hex
   : ByteArray
 
 export type PadErrorType = PadHexErrorType | PadBytesErrorType | ErrorType
 
-export function pad<TValue extends ByteArray | Hex>(
-  hexOrBytes: TValue,
+export function pad<value extends ByteArray | Hex>(
+  hexOrBytes: value,
   { dir, size = 32 }: PadOptions = {},
-): PadReturnType<TValue> {
+): PadReturnType<value> {
   if (typeof hexOrBytes === 'string')
-    return padHex(hexOrBytes, { dir, size }) as PadReturnType<TValue>
-  return padBytes(hexOrBytes, { dir, size }) as PadReturnType<TValue>
+    return padHex(hexOrBytes, { dir, size }) as PadReturnType<value>
+  return padBytes(hexOrBytes, { dir, size }) as PadReturnType<value>
 }
 
 export type PadHexErrorType = SizeExceedsPaddingSizeErrorType | ErrorType

package/utils/data/slice.ts

@@ -8,7 +8,7 @@ import type { ByteArray, Hex } from '../../types/misc.js'
 import { type IsHexErrorType, isHex } from './isHex.js'
 import { type SizeErrorType, size } from './size.js'
 
-export type SliceReturnType<TValue extends ByteArray | Hex> = TValue extends Hex
+export type SliceReturnType<value extends ByteArray | Hex> = value extends Hex
   ? Hex
   : ByteArray
 
@@ -25,19 +25,19 @@ export type SliceErrorType =
  * @param start The start offset (in bytes).
  * @param end The end offset (in bytes).
  */
-export function slice<TValue extends ByteArray | Hex>(
-  value: TValue,
+export function slice<value extends ByteArray | Hex>(
+  value: value,
   start?: number | undefined,
   end?: number | undefined,
   { strict }: { strict?: boolean | undefined } = {},
-): SliceReturnType<TValue> {
+): SliceReturnType<value> {
   if (isHex(value, { strict: false }))
     return sliceHex(value as Hex, start, end, {
       strict,
-    }) as SliceReturnType<TValue>
+    }) as SliceReturnType<value>
   return sliceBytes(value as ByteArray, start, end, {
     strict,
-  }) as SliceReturnType<TValue>
+  }) as SliceReturnType<value>
 }
 
 export type AssertStartOffsetErrorType =

package/utils/data/trim.ts

@@ -4,16 +4,16 @@ import type { ByteArray, Hex } from '../../types/misc.js'
 type TrimOptions = {
   dir?: 'left' | 'right' | undefined
 }
-export type TrimReturnType<TValue extends ByteArray | Hex> = TValue extends Hex
+export type TrimReturnType<value extends ByteArray | Hex> = value extends Hex
   ? Hex
   : ByteArray
 
 export type TrimErrorType = ErrorType
 
-export function trim<TValue extends ByteArray | Hex>(
-  hexOrBytes: TValue,
+export function trim<value extends ByteArray | Hex>(
+  hexOrBytes: value,
   { dir = 'left' }: TrimOptions = {},
-): TrimReturnType<TValue> {
+): TrimReturnType<value> {
   let data: any =
     typeof hexOrBytes === 'string' ? hexOrBytes.replace('0x', '') : hexOrBytes
 
@@ -32,7 +32,7 @@ export function trim<TValue extends ByteArray | Hex>(
     if (data.length === 1 && dir === 'right') data = `${data}0`
     return `0x${
       data.length % 2 === 1 ? `0${data}` : data
-    }` as TrimReturnType<TValue>
+    }` as TrimReturnType<value>
   }
-  return data as TrimReturnType<TValue>
+  return data as TrimReturnType<value>
 }

package/utils/encoding/fromBytes.ts

@@ -14,25 +14,25 @@ import {
 import { type BytesToHexErrorType, bytesToHex } from './toHex.js'
 
 export type FromBytesParameters<
-  TTo extends 'string' | 'hex' | 'bigint' | 'number' | 'boolean',
+  to extends 'string' | 'hex' | 'bigint' | 'number' | 'boolean',
 > =
-  | TTo
+  | to
   | {
       /** Size of the bytes. */
       size?: number | undefined
       /** Type to convert to. */
-      to: TTo
+      to: to
     }
 
-export type FromBytesReturnType<TTo> = TTo extends 'string'
+export type FromBytesReturnType<to> = to extends 'string'
   ? string
-  : TTo extends 'hex'
+  : to extends 'hex'
     ? Hex
-    : TTo extends 'bigint'
+    : to extends 'bigint'
       ? bigint
-      : TTo extends 'number'
+      : to extends 'number'
         ? number
-        : TTo extends 'boolean'
+        : to extends 'boolean'
           ? boolean
           : never
 
@@ -68,23 +68,23 @@ export type FromBytesErrorType =
  * // 'Hello world'
  */
 export function fromBytes<
-  TTo extends 'string' | 'hex' | 'bigint' | 'number' | 'boolean',
+  to extends 'string' | 'hex' | 'bigint' | 'number' | 'boolean',
 >(
   bytes: ByteArray,
-  toOrOpts: FromBytesParameters<TTo>,
-): FromBytesReturnType<TTo> {
+  toOrOpts: FromBytesParameters<to>,
+): FromBytesReturnType<to> {
   const opts = typeof toOrOpts === 'string' ? { to: toOrOpts } : toOrOpts
   const to = opts.to
 
   if (to === 'number')
-    return bytesToNumber(bytes, opts) as FromBytesReturnType<TTo>
+    return bytesToNumber(bytes, opts) as FromBytesReturnType<to>
   if (to === 'bigint')
-    return bytesToBigInt(bytes, opts) as FromBytesReturnType<TTo>
+    return bytesToBigInt(bytes, opts) as FromBytesReturnType<to>
   if (to === 'boolean')
-    return bytesToBool(bytes, opts) as FromBytesReturnType<TTo>
+    return bytesToBool(bytes, opts) as FromBytesReturnType<to>
   if (to === 'string')
-    return bytesToString(bytes, opts) as FromBytesReturnType<TTo>
-  return bytesToHex(bytes, opts) as FromBytesReturnType<TTo>
+    return bytesToString(bytes, opts) as FromBytesReturnType<to>
+  return bytesToHex(bytes, opts) as FromBytesReturnType<to>
 }
 
 export type BytesToBigIntOpts = {