viem 2.13.6 → 2.13.8

package/utils/abi/decodeAbiParameters.ts

@@ -13,7 +13,11 @@ import {
   type ChecksumAddressErrorType,
   checksumAddress,
 } from '../address/getAddress.js'
-import { type Cursor, createCursor } from '../cursor.js'
+import {
+  type CreateCursorErrorType,
+  type Cursor,
+  createCursor,
+} from '../cursor.js'
 import { type SizeErrorType, size } from '../data/size.js'
 import { type SliceBytesErrorType, sliceBytes } from '../data/slice.js'
 import { type TrimErrorType, trim } from '../data/trim.js'
@@ -42,6 +46,7 @@ export type DecodeAbiParametersErrorType =
   | BytesToHexErrorType
   | DecodeParameterErrorType
   | SizeErrorType
+  | CreateCursorErrorType
   | ErrorType
 
 export function decodeAbiParameters<

package/utils/abi/encodeAbiParameters.ts

@@ -110,7 +110,7 @@ type PreparedParam = { dynamic: boolean; encoded: Hex }
 type TupleAbiParameter = AbiParameter & { components: readonly AbiParameter[] }
 type Tuple = AbiParameterToPrimitiveType<TupleAbiParameter>
 
-export type PrepareParamsErrorType = ErrorType
+type PrepareParamsErrorType = PrepareParamErrorType | ErrorType
 
 function prepareParams<const TParams extends readonly AbiParameter[]>({
   params,
@@ -126,7 +126,14 @@ function prepareParams<const TParams extends readonly AbiParameter[]>({
   return preparedParams
 }
 
-export type PrepareParamErrorType =
+type PrepareParamErrorType =
+  | EncodeAddressErrorType
+  | EncodeArrayErrorType
+  | EncodeBytesErrorType
+  | EncodeBoolErrorType
+  | EncodeNumberErrorType
+  | EncodeStringErrorType
+  | EncodeTupleErrorType
   | GetArrayComponentsErrorType
   | InvalidAbiEncodingTypeErrorType
   | ErrorType
@@ -171,10 +178,7 @@ function prepareParam<const TParam extends AbiParameter>({
 
 /////////////////////////////////////////////////////////////////
 
-export type EncodeParamsErrorType =
-  | NumberToHexErrorType
-  | SizeErrorType
-  | ErrorType
+type EncodeParamsErrorType = NumberToHexErrorType | SizeErrorType | ErrorType
 
 function encodeParams(preparedParams: PreparedParam[]): Hex {
   // 1. Compute the size of the static part of the parameters.
@@ -206,7 +210,7 @@ function encodeParams(preparedParams: PreparedParam[]): Hex {
 
 /////////////////////////////////////////////////////////////////
 
-export type EncodeAddressErrorType =
+type EncodeAddressErrorType =
   | InvalidAddressErrorType
   | IsAddressErrorType
   | ErrorType
@@ -216,13 +220,14 @@ function encodeAddress(value: Hex): PreparedParam {
   return { dynamic: false, encoded: padHex(value.toLowerCase() as Hex) }
 }
 
-export type EncodeArrayErrorType =
+type EncodeArrayErrorType =
   | AbiEncodingArrayLengthMismatchErrorType
   | ConcatErrorType
   | EncodeParamsErrorType
   | InvalidArrayErrorType
   | NumberToHexErrorType
-  | PrepareParamErrorType
+  // TODO: Add back once circular type reference is resolved
+  // | PrepareParamErrorType
   | ErrorType
 
 function encodeArray<const TParam extends AbiParameter>(
@@ -270,7 +275,7 @@ function encodeArray<const TParam extends AbiParameter>(
   }
 }
 
-export type EncodeBytesErrorType =
+type EncodeBytesErrorType =
   | AbiEncodingBytesSizeMismatchErrorType
   | ConcatErrorType
   | PadHexErrorType
@@ -306,10 +311,7 @@ function encodeBytes<const TParam extends AbiParameter>(
   return { dynamic: false, encoded: padHex(value, { dir: 'right' }) }
 }
 
-export type EncodeBoolErrorType =
-  | PadHexErrorType
-  | BoolToHexErrorType
-  | ErrorType
+type EncodeBoolErrorType = PadHexErrorType | BoolToHexErrorType | ErrorType
 
 function encodeBool(value: boolean): PreparedParam {
   if (typeof value !== 'boolean')
@@ -319,7 +321,7 @@ function encodeBool(value: boolean): PreparedParam {
   return { dynamic: false, encoded: padHex(boolToHex(value)) }
 }
 
-export type EncodeNumberErrorType = NumberToHexErrorType | ErrorType
+type EncodeNumberErrorType = NumberToHexErrorType | ErrorType
 
 function encodeNumber(
   value: number,
@@ -334,7 +336,7 @@ function encodeNumber(
   }
 }
 
-export type EncodeStringErrorType =
+type EncodeStringErrorType =
   | ConcatErrorType
   | NumberToHexErrorType
   | PadHexErrorType
@@ -363,10 +365,11 @@ function encodeString(value: string): PreparedParam {
   }
 }
 
-export type EncodeTupleErrorType =
+type EncodeTupleErrorType =
   | ConcatErrorType
   | EncodeParamsErrorType
-  | PrepareParamErrorType
+  // TODO: Add back once circular type reference is resolved
+  // | PrepareParamErrorType
   | ErrorType
 
 function encodeTuple<
@@ -395,7 +398,7 @@ function encodeTuple<
   }
 }
 
-export type GetArrayComponentsErrorType = ErrorType
+type GetArrayComponentsErrorType = ErrorType
 
 export function getArrayComponents(
   type: string,

package/utils/abi/getAbiItem.ts

@@ -1,6 +1,9 @@
 import type { Abi, AbiParameter, Address } from 'abitype'
 
-import { AbiItemAmbiguityError } from '../../errors/abi.js'
+import {
+  AbiItemAmbiguityError,
+  type AbiItemAmbiguityErrorType,
+} from '../../errors/abi.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type {
   AbiItem,
@@ -57,6 +60,7 @@ export type GetAbiItemErrorType =
   | IsArgOfTypeErrorType
   | IsHexErrorType
   | ToFunctionSelectorErrorType
+  | AbiItemAmbiguityErrorType
   | ErrorType
 
 export type GetAbiItemReturnType<
@@ -148,8 +152,9 @@ export function getAbiItem<
   return abiItems[0] as GetAbiItemReturnType<abi, name, args>
 }
 
-export type IsArgOfTypeErrorType = IsAddressErrorType | ErrorType
+type IsArgOfTypeErrorType = IsAddressErrorType | ErrorType
 
+/** @internal */
 export function isArgOfType(arg: unknown, abiParameter: AbiParameter): boolean {
   const argType = typeof arg
   const abiParameterType = abiParameter.type
@@ -207,6 +212,7 @@ export function isArgOfType(arg: unknown, abiParameter: AbiParameter): boolean {
   }
 }
 
+/** @internal */
 export function getAmbiguousTypes(
   sourceParameters: readonly AbiParameter[],
   targetParameters: readonly AbiParameter[],

package/utils/address/getAddress.ts

@@ -10,7 +10,7 @@ import { type Keccak256ErrorType, keccak256 } from '../hash/keccak256.js'
 import { LruMap } from '../lru.js'
 import { type IsAddressErrorType, isAddress } from './isAddress.js'
 
-export const checksumAddressCache = /*#__PURE__*/ new LruMap<Address>(8192)
+const checksumAddressCache = /*#__PURE__*/ new LruMap<Address>(8192)
 
 export type ChecksumAddressErrorType =
   | Keccak256ErrorType

package/utils/address/isAddress.ts

@@ -5,6 +5,7 @@ import { checksumAddress } from './getAddress.js'
 
 const addressRegex = /^0x[a-fA-F0-9]{40}$/
 
+/** @internal */
 export const isAddressCache = /*#__PURE__*/ new LruMap<boolean>(8192)
 
 export type IsAddressOptions = {

package/utils/blob/toBlobs.ts

@@ -12,7 +12,7 @@ import {
 } from '../../errors/blob.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
-import { createCursor } from '../cursor.js'
+import { type CreateCursorErrorType, createCursor } from '../cursor.js'
 import { type SizeErrorType, size } from '../data/size.js'
 import { type HexToBytesErrorType, hexToBytes } from '../encoding/toBytes.js'
 import { type BytesToHexErrorType, bytesToHex } from '../encoding/toHex.js'
@@ -36,6 +36,7 @@ export type ToBlobsReturnType<to extends To> =
 export type ToBlobsErrorType =
   | BlobSizeTooLargeErrorType
   | BytesToHexErrorType
+  | CreateCursorErrorType
   | EmptyBlobErrorType
   | HexToBytesErrorType
   | SizeErrorType

package/utils/buildRequest.ts

@@ -190,6 +190,7 @@ export function buildRequest<request extends (args: any) => Promise<any>>(
   }
 }
 
+/** @internal */
 export function shouldRetry(error: Error) {
   if ('code' in error && typeof error.code === 'number') {
     if (error.code === -1) return true // Unknown error

package/utils/ccip.ts

@@ -5,10 +5,15 @@ import type { Transport } from '../clients/transports/createTransport.js'
 import type { BaseError } from '../errors/base.js'
 import {
   OffchainLookupError,
+  type OffchainLookupErrorType as OffchainLookupErrorType_,
   OffchainLookupResponseMalformedError,
+  type OffchainLookupResponseMalformedErrorType,
   OffchainLookupSenderMismatchError,
 } from '../errors/ccip.js'
-import { HttpRequestError } from '../errors/request.js'
+import {
+  HttpRequestError,
+  type HttpRequestErrorType,
+} from '../errors/request.js'
 import type { Chain } from '../types/chain.js'
 import type { Hex } from '../types/misc.js'
 
@@ -49,7 +54,7 @@ export const offchainLookupAbiItem = {
   ],
 } as const satisfies Abi[number]
 
-export type OffchainLookupErrorType = ErrorType
+export type OffchainLookupErrorType = OffchainLookupErrorType_ | ErrorType
 
 export async function offchainLookup<TChain extends Chain | undefined>(
   client: Client<Transport, TChain>,
@@ -115,7 +120,10 @@ export type CcipRequestParameters = {
 
 export type CcipRequestReturnType = Hex
 
-export type CcipRequestErrorType = ErrorType
+export type CcipRequestErrorType =
+  | HttpRequestErrorType
+  | OffchainLookupResponseMalformedErrorType
+  | ErrorType
 
 export async function ccipRequest({
   data,

package/utils/chain/extractChain.ts

@@ -1,5 +1,5 @@
 import type { ErrorType } from '../../errors/utils.js'
-import type { Chain, ExtractChain } from '../../types/chain.js'
+import type { Chain } from '../../types/chain.js'
 
 export type ExtractChainParameters<
   chains extends readonly Chain[],
@@ -12,7 +12,7 @@ export type ExtractChainParameters<
 export type ExtractChainReturnType<
   chains extends readonly Chain[],
   chainId extends chains[number]['id'],
-> = ExtractChain<chains, chainId>
+> = Extract<chains[number], { id: chainId }>
 
 export type ExtractChainErrorType = ErrorType
 

package/utils/cursor.ts

@@ -1,7 +1,10 @@
 import {
   NegativeOffsetError,
+  type NegativeOffsetErrorType,
   PositionOutOfBoundsError,
+  type PositionOutOfBoundsErrorType,
   RecursiveReadLimitExceededError,
+  type RecursiveReadLimitExceededErrorType,
 } from '../errors/cursor.js'
 import type { ErrorType } from '../errors/utils.js'
 import type { ByteArray } from '../types/misc.js'
@@ -41,19 +44,21 @@ export type Cursor = {
   _touch(): void
 }
 
-export type CreateCursorErrorType = ErrorType
-
-export type CursorErrorType =
+type CursorErrorType =
   | CursorAssertPositionErrorType
   | CursorDecrementPositionErrorType
   | CursorIncrementPositionErrorType
   | ErrorType
 
-export type CursorAssertPositionErrorType = PositionOutOfBoundsError | ErrorType
+type CursorAssertPositionErrorType = PositionOutOfBoundsErrorType | ErrorType
+
+type CursorDecrementPositionErrorType = NegativeOffsetError | ErrorType
 
-export type CursorDecrementPositionErrorType = NegativeOffsetError | ErrorType
+type CursorIncrementPositionErrorType = NegativeOffsetError | ErrorType
 
-export type CursorIncrementPositionErrorType = NegativeOffsetError | ErrorType
+type StaticCursorErrorType =
+  | NegativeOffsetErrorType
+  | RecursiveReadLimitExceededErrorType
 
 const staticCursor: Cursor = {
   bytes: new Uint8Array(),
@@ -216,6 +221,11 @@ const staticCursor: Cursor = {
 
 type CursorConfig = { recursiveReadLimit?: number | undefined }
 
+export type CreateCursorErrorType =
+  | CursorErrorType
+  | StaticCursorErrorType
+  | ErrorType
+
 export function createCursor(
   bytes: ByteArray,
   { recursiveReadLimit = 8_192 }: CursorConfig = {},

package/utils/encoding/fromRlp.ts

@@ -49,25 +49,7 @@ export function fromRlp<to extends To = 'hex'>(
   return result as FromRlpReturnType<to>
 }
 
-export type RlpToBytesErrorType = FromRlpErrorType | ErrorType
-
-export function rlpToBytes<to extends To = 'bytes'>(
-  bytes: ByteArray,
-  to: to | To | undefined = 'bytes',
-): FromRlpReturnType<to> {
-  return fromRlp(bytes, to)
-}
-
-export type RlpToHexErrorType = FromRlpErrorType | ErrorType
-
-export function rlpToHex<to extends To = 'hex'>(
-  hex: Hex,
-  to: to | To | undefined = 'hex',
-): FromRlpReturnType<to> {
-  return fromRlp(hex, to)
-}
-
-export type FromRlpCursorErrorType =
+type FromRlpCursorErrorType =
   | BytesToHexErrorType
   | ReadLengthErrorType
   | ReadListErrorType
@@ -97,7 +79,7 @@ function fromRlpCursor<to extends To = 'hex'>(
   return readList(cursor, length, to) as {} as FromRlpReturnType<to>
 }
 
-export type ReadLengthErrorType = BaseErrorType | ErrorType
+type ReadLengthErrorType = BaseErrorType | ErrorType
 
 function readLength(cursor: Cursor, prefix: number, offset: number) {
   if (offset === 0x80 && prefix < 0x80) return 1
@@ -109,7 +91,7 @@ function readLength(cursor: Cursor, prefix: number, offset: number) {
   throw new BaseError('Invalid RLP prefix')
 }
 
-export type ReadListErrorType = ErrorType
+type ReadListErrorType = ErrorType
 
 function readList<to extends To>(cursor: Cursor, length: number, to: to | To) {
   const position = cursor.position

package/utils/ens/avatar/parseAvatarRecord.ts

@@ -49,7 +49,7 @@ export async function parseAvatarRecord<TChain extends Chain | undefined>(
   return parseAvatarUri({ uri: record, gatewayUrls })
 }
 
-export type ParseNftAvatarUriErrorType =
+type ParseNftAvatarUriErrorType =
   | ParseNftUriErrorType
   | GetNftTokenUriErrorType
   | ResolveAvatarUriErrorType

package/utils/ens/avatar/utils.ts

@@ -33,8 +33,9 @@ const ipfsHashRegex =
 const base64Regex = /^data:([a-zA-Z\-/+]*);base64,([^"].*)/
 const dataURIRegex = /^data:([a-zA-Z\-/+]*)?(;[a-zA-Z0-9].*?)?(,)/
 
-export type IsImageUriErrorType = ErrorType
+type IsImageUriErrorType = ErrorType
 
+/** @internal */
 export async function isImageUri(uri: string) {
   try {
     const res = await fetch(uri, { method: 'HEAD' })
@@ -66,8 +67,9 @@ export async function isImageUri(uri: string) {
   }
 }
 
-export type GetGatewayErrorType = ErrorType
+type GetGatewayErrorType = ErrorType
 
+/** @internal */
 export function getGateway(custom: string | undefined, defaultGateway: string) {
   if (!custom) return defaultGateway
   if (custom.endsWith('/')) return custom.slice(0, -1)

package/utils/ens/errors.ts

@@ -3,6 +3,7 @@ import { BaseError } from '../../errors/base.js'
 import { ContractFunctionRevertedError } from '../../errors/contract.js'
 import type { ErrorType } from '../../errors/utils.js'
 
+/** @internal */
 export type IsNullUniversalResolverErrorErrorType = ErrorType
 
 /*

package/utils/hash/normalizeSignature.ts

@@ -1,8 +1,8 @@
 import { BaseError } from '../../errors/base.js'
 import type { ErrorType } from '../../errors/utils.js'
 
-export type NormalizeSignatureParameters = string
-export type NormalizeSignatureReturnType = string
+type NormalizeSignatureParameters = string
+type NormalizeSignatureReturnType = string
 export type NormalizeSignatureErrorType = ErrorType
 
 export function normalizeSignature(

package/utils/index.ts

@@ -64,6 +64,9 @@ export { getWebSocketRpcClient } from './rpc/webSocket.js'
 export { type StringifyErrorType, stringify } from './stringify.js'
 export {
   type DomainSeparatorErrorType,
+  type SerializeTypedDataErrorType,
+  type ValidateTypedDataErrorType,
+  serializeTypedData,
   validateTypedData,
 } from './typedData.js'
 export {

package/utils/observe.ts

@@ -6,10 +6,12 @@ type Callbacks = Record<string, Callback>
 
 export type ObserveErrorType = ErrorType
 
+/** @internal */
 export const listenersCache = /*#__PURE__*/ new Map<
   string,
   { id: number; fns: Callbacks }[]
 >()
+/** @internal */
 export const cleanupCache = /*#__PURE__*/ new Map<string, () => void>()
 
 type EmitFunction<TCallbacks extends Callbacks> = (

package/utils/promise/createBatchScheduler.ts

@@ -17,7 +17,7 @@ type BatchResultsCompareFn<TResult = unknown> = (
   b: TResult,
 ) => number
 
-export type CreateBatchSchedulerArguments<
+type CreateBatchSchedulerArguments<
   TParameters = unknown,
   TReturnType extends readonly unknown[] = readonly unknown[],
 > = {
@@ -28,7 +28,7 @@ export type CreateBatchSchedulerArguments<
   sort?: BatchResultsCompareFn<TReturnType[number]> | undefined
 }
 
-export type CreateBatchSchedulerReturnType<
+type CreateBatchSchedulerReturnType<
   TParameters = unknown,
   TReturnType extends readonly unknown[] = readonly unknown[],
 > = {
@@ -42,6 +42,7 @@ export type CreateBatchSchedulerErrorType = ErrorType
 
 const schedulerCache = /*#__PURE__*/ new Map<number | string, SchedulerItem[]>()
 
+/** @internal */
 export function createBatchScheduler<
   TParameters,
   TReturnType extends readonly unknown[],

package/utils/promise/withCache.ts

@@ -1,6 +1,8 @@
 import type { ErrorType } from '../../errors/utils.js'
 
+/** @internal */
 export const promiseCache = /*#__PURE__*/ new Map()
+/** @internal */
 export const responseCache = /*#__PURE__*/ new Map()
 
 export type GetCacheErrorType = ErrorType
@@ -28,7 +30,7 @@ export function getCache<TData>(cacheKey: string) {
   }
 }
 
-export type WithCacheParameters = {
+type WithCacheParameters = {
   /** The key to cache the data against. */
   cacheKey: string
   /** The time that cached data will remain in memory. Default: Infinity (no expiry) */

package/utils/promise/withTimeout.ts

@@ -21,7 +21,7 @@ export function withTimeout<TData>(
 ): Promise<TData> {
   return new Promise((resolve, reject) => {
     ;(async () => {
-      let timeoutId!: Timer
+      let timeoutId!: NodeJS.Timeout
       try {
         const controller = new AbortController()
         if (timeout > 0) {
@@ -31,7 +31,7 @@ export function withTimeout<TData>(
             } else {
               reject(errorInstance)
             }
-          }, timeout)
+          }, timeout) as NodeJS.Timeout // need to cast because bun globals.d.ts overrides @types/node
         }
         resolve(await fn({ signal: controller?.signal || null }))
       } catch (err) {

package/utils/rpc/id.ts

@@ -1,4 +1,4 @@
-export function createIdStore() {
+function createIdStore() {
   return {
     current: 0,
     take() {

package/utils/rpc/ipc.ts

@@ -15,6 +15,7 @@ export type GetIpcRpcClientOptions = Pick<
 const openingBrace = '{'.charCodeAt(0)
 const closingBrace = '}'.charCodeAt(0)
 
+/** @internal */
 export function extractMessages(buffer: Buffer): [Buffer[], Buffer] {
   const messages: Buffer[] = []
 

package/utils/stateOverride.ts

@@ -21,10 +21,11 @@ import type { StateMapping, StateOverride } from '../types/stateOverride.js'
 import { isAddress } from './address/isAddress.js'
 import { type NumberToHexErrorType, numberToHex } from './encoding/toHex.js'
 
-export type SerializeStateMappingParameters = StateMapping | undefined
+type SerializeStateMappingParameters = StateMapping | undefined
 
-export type SerializeStateMappingErrorType = InvalidBytesLengthErrorType
+type SerializeStateMappingErrorType = InvalidBytesLengthErrorType
 
+/** @internal */
 export function serializeStateMapping(
   stateMapping: SerializeStateMappingParameters,
 ): RpcStateMapping | undefined {
@@ -47,16 +48,17 @@ export function serializeStateMapping(
   }, {} as RpcStateMapping)
 }
 
-export type SerializeAccountStateOverrideParameters = Omit<
+type SerializeAccountStateOverrideParameters = Omit<
   StateOverride[number],
   'address'
 >
 
-export type SerializeAccountStateOverrideErrorType =
+type SerializeAccountStateOverrideErrorType =
   | NumberToHexErrorType
   | StateAssignmentConflictErrorType
   | SerializeStateMappingErrorType
 
+/** @internal */
 export function serializeAccountStateOverride(
   parameters: SerializeAccountStateOverrideParameters,
 ): RpcAccountStateOverride {
@@ -75,13 +77,14 @@ export function serializeAccountStateOverride(
   return rpcAccountStateOverride
 }
 
-export type SerializeStateOverrideParameters = StateOverride | undefined
+type SerializeStateOverrideParameters = StateOverride | undefined
 
 export type SerializeStateOverrideErrorType =
   | InvalidAddressErrorType
   | AccountStateConflictErrorType
   | SerializeAccountStateOverrideErrorType
 
+/** @internal */
 export function serializeStateOverride(
   parameters?: SerializeStateOverrideParameters,
 ): RpcStateOverride | undefined {

package/utils/transaction/parseTransaction.ts

@@ -26,7 +26,7 @@ import type {
   TransactionSerializedGeneric,
   TransactionType,
 } from '../../types/transaction.js'
-import type { IsNarrowable } from '../../types/utils.js'
+import type { IsNarrowable, Mutable } from '../../types/utils.js'
 import { type IsAddressErrorType, isAddress } from '../address/isAddress.js'
 import { toBlobSidecars } from '../blob/toBlobSidecars.js'
 import { type IsHexErrorType, isHex } from '../data/isHex.js'
@@ -102,6 +102,7 @@ export function parseTransaction<
 }
 
 type ParseTransactionEIP4844ErrorType =
+  | ToTransactionArrayErrorType
   | AssertTransactionEIP4844ErrorType
   | ToTransactionArrayErrorType
   | HexToBigIntErrorType
@@ -204,6 +205,7 @@ function parseTransactionEIP4844(
 }
 
 type ParseTransactionEIP1559ErrorType =
+  | ToTransactionArrayErrorType
   | AssertTransactionEIP1559ErrorType
   | ToTransactionArrayErrorType
   | HexToBigIntErrorType
@@ -212,6 +214,7 @@ type ParseTransactionEIP1559ErrorType =
   | InvalidSerializedTransactionErrorType
   | IsHexErrorType
   | ParseEIP155SignatureErrorType
+  | ParseAccessListErrorType
   | ErrorType
 
 function parseTransactionEIP1559(
@@ -285,6 +288,7 @@ function parseTransactionEIP1559(
 }
 
 type ParseTransactionEIP2930ErrorType =
+  | ToTransactionArrayErrorType
   | AssertTransactionEIP2930ErrorType
   | ToTransactionArrayErrorType
   | HexToBigIntErrorType
@@ -293,6 +297,7 @@ type ParseTransactionEIP2930ErrorType =
   | InvalidSerializedTransactionErrorType
   | IsHexErrorType
   | ParseEIP155SignatureErrorType
+  | ParseAccessListErrorType
   | ErrorType
 
 function parseTransactionEIP2930(
@@ -430,19 +435,19 @@ function parseTransactionLegacy(
   return transaction
 }
 
-export type ToTransactionArrayErrorType = FromRlpErrorType | ErrorType
+type ToTransactionArrayErrorType = FromRlpErrorType | ErrorType
 
 export function toTransactionArray(serializedTransaction: string) {
   return fromRlp(`0x${serializedTransaction.slice(4)}` as Hex, 'hex')
 }
 
-export type ParseAccessListErrorType =
+type ParseAccessListErrorType =
   | InvalidAddressErrorType
   | IsAddressErrorType
   | ErrorType
 
 export function parseAccessList(accessList_: RecursiveArray<Hex>): AccessList {
-  const accessList: AccessList = []
+  const accessList: Mutable<AccessList> = []
   for (let i = 0; i < accessList_.length; i++) {
     const [address, storageKeys] = accessList_[i] as [Hex, Hex[]]
 

package/utils/unit/parseUnits.ts

@@ -19,7 +19,7 @@ export function parseUnits(value: string, decimals: number) {
   const negative = integer.startsWith('-')
   if (negative) integer = integer.slice(1)
 
-  // trim leading zeros.
+  // trim trailing zeros.
   fraction = fraction.replace(/(0+)$/, '')
 
   // round off if the fraction is larger than the number of decimals.