viem 0.0.0-main.20240316T233602 → 0.0.0-main.20240317T053608

package/utils/encoding/fromHex.ts

@@ -33,7 +33,7 @@ export type FromHexParameters<
   | TTo
   | {
       /** Size (in bytes) of the hex value. */
-      size?: number
+      size?: number | undefined
       /** Type to convert to. */
       to: TTo
     }
@@ -101,9 +101,9 @@ export function fromHex<
 
 export type HexToBigIntOpts = {
   /** Whether or not the number of a signed representation. */
-  signed?: boolean
+  signed?: boolean | undefined
   /** Size (in bytes) of the hex value. */
-  size?: number
+  size?: number | undefined
 }
 
 export type HexToBigIntErrorType = AssertSizeErrorType | ErrorType
@@ -144,7 +144,7 @@ export function hexToBigInt(hex: Hex, opts: HexToBigIntOpts = {}): bigint {
 
 export type HexToBoolOpts = {
   /** Size (in bytes) of the hex value. */
-  size?: number
+  size?: number | undefined
 }
 
 export type HexToBoolErrorType =
@@ -212,7 +212,7 @@ export function hexToNumber(hex: Hex, opts: HexToNumberOpts = {}): number {
 
 export type HexToStringOpts = {
   /** Size (in bytes) of the hex value. */
-  size?: number
+  size?: number | undefined
 }
 
 export type HexToStringErrorType =

package/utils/encoding/toBytes.ts

@@ -15,7 +15,7 @@ const encoder = /*#__PURE__*/ new TextEncoder()
 
 export type ToBytesParameters = {
   /** Size of the output bytes. */
-  size?: number
+  size?: number | undefined
 }
 
 export type ToBytesErrorType =
@@ -64,7 +64,7 @@ export function toBytes(
 
 export type BoolToBytesOpts = {
   /** Size of the output bytes. */
-  size?: number
+  size?: number | undefined
 }
 
 export type BoolToBytesErrorType =
@@ -123,7 +123,7 @@ function charCodeToBase16(char: number) {
 
 export type HexToBytesOpts = {
   /** Size of the output bytes. */
-  size?: number
+  size?: number | undefined
 }
 
 export type HexToBytesErrorType = AssertSizeErrorType | PadErrorType | ErrorType
@@ -198,14 +198,17 @@ export type NumberToBytesErrorType =
  * const data = numberToBytes(420, { size: 4 })
  * // Uint8Array([0, 0, 1, 164])
  */
-export function numberToBytes(value: bigint | number, opts?: NumberToHexOpts) {
+export function numberToBytes(
+  value: bigint | number,
+  opts?: NumberToHexOpts | undefined,
+) {
   const hex = numberToHex(value, opts)
   return hexToBytes(hex)
 }
 
 export type StringToBytesOpts = {
   /** Size of the output bytes. */
-  size?: number
+  size?: number | undefined
 }
 
 export type StringToBytesErrorType =

package/utils/encoding/toHex.ts

@@ -14,7 +14,7 @@ const hexes = /*#__PURE__*/ Array.from({ length: 256 }, (_v, i) =>
 
 export type ToHexParameters = {
   /** The size (in bytes) of the output hex value. */
-  size?: number
+  size?: number | undefined
 }
 
 export type ToHexErrorType =
@@ -64,7 +64,7 @@ export function toHex(
 
 export type BoolToHexOpts = {
   /** The size (in bytes) of the output hex value. */
-  size?: number
+  size?: number | undefined
 }
 
 export type BoolToHexErrorType = AssertSizeErrorType | PadErrorType | ErrorType
@@ -104,7 +104,7 @@ export function boolToHex(value: boolean, opts: BoolToHexOpts = {}): Hex {
 
 export type BytesToHexOpts = {
   /** The size (in bytes) of the output hex value. */
-  size?: number
+  size?: number | undefined
 }
 
 export type BytesToHexErrorType = AssertSizeErrorType | PadErrorType | ErrorType
@@ -145,14 +145,14 @@ export function bytesToHex(value: ByteArray, opts: BytesToHexOpts = {}): Hex {
 export type NumberToHexOpts =
   | {
       /** Whether or not the number of a signed representation. */
-      signed?: boolean
+      signed?: boolean | undefined
       /** The size (in bytes) of the output hex value. */
       size: number
     }
   | {
-      signed?: never
+      signed?: never | undefined
       /** The size (in bytes) of the output hex value. */
-      size?: number
+      size?: number | undefined
     }
 
 export type NumberToHexErrorType =
@@ -218,7 +218,7 @@ export function numberToHex(
 
 export type StringToHexOpts = {
   /** The size (in bytes) of the output hex value. */
-  size?: number
+  size?: number | undefined
 }
 
 export type StringToHexErrorType = BytesToHexErrorType | ErrorType

package/utils/ens/avatar/parseAvatarRecord.ts

@@ -30,7 +30,7 @@ export async function parseAvatarRecord<TChain extends Chain | undefined>(
     gatewayUrls,
     record,
   }: {
-    gatewayUrls?: AssetGatewayUrls
+    gatewayUrls?: AssetGatewayUrls | undefined
     record: string
   },
 ): Promise<string> {
@@ -54,7 +54,7 @@ async function parseNftAvatarUri<TChain extends Chain | undefined>(
     gatewayUrls,
     record,
   }: {
-    gatewayUrls?: AssetGatewayUrls
+    gatewayUrls?: AssetGatewayUrls | undefined
     record: string
   },
 ): Promise<string> {

package/utils/errors/getCallError.ts

@@ -27,8 +27,8 @@ export function getCallError<err extends ErrorType<string>>(
     docsPath,
     ...args
   }: CallParameters & {
-    chain?: Chain
-    docsPath?: string
+    chain?: Chain | undefined
+    docsPath?: string | undefined
   },
 ): GetCallErrorReturnType<err> {
   const cause = (() => {

package/utils/errors/getContractError.ts

@@ -38,10 +38,10 @@ export function getContractError<err extends ErrorType<string>>(
   }: {
     abi: Abi
     args: any
-    address?: Address
-    docsPath?: string
+    address?: Address | undefined
+    docsPath?: string | undefined
     functionName: string
-    sender?: Address
+    sender?: Address | undefined
   },
 ): GetContractErrorReturnType {
   const { code, data, message, shortMessage } = (

package/utils/errors/getEstimateGasError.ts

@@ -26,9 +26,9 @@ export function getEstimateGasError<err extends ErrorType<string>>(
     docsPath,
     ...args
   }: Omit<EstimateGasParameters, 'account'> & {
-    account?: Account
-    chain?: Chain
-    docsPath?: string
+    account?: Account | undefined
+    chain?: Chain | undefined
+    docsPath?: string | undefined
   },
 ): GetEstimateGasErrorReturnType<err> {
   const cause = (() => {

package/utils/errors/getNodeError.ts

@@ -31,6 +31,7 @@ import {
   InvalidInputRpcError,
   TransactionRejectedRpcError,
 } from '../../errors/rpc.js'
+import type { ExactPartial } from '../../types/utils.js'
 
 export function containsNodeError(err: BaseError) {
   return (
@@ -40,7 +41,9 @@ export function containsNodeError(err: BaseError) {
   )
 }
 
-export type GetNodeErrorParameters = Partial<SendTransactionParameters<any>>
+export type GetNodeErrorParameters = ExactPartial<
+  SendTransactionParameters<any>
+>
 
 export type GetNodeErrorReturnType =
   | ExecutionRevertedErrorType

package/utils/errors/getTransactionError.ts

@@ -20,8 +20,8 @@ export type GetTransactionErrorParameters = Omit<
   'account' | 'chain'
 > & {
   account: Account
-  chain?: Chain
-  docsPath?: string
+  chain?: Chain | undefined
+  docsPath?: string | undefined
 }
 
 export type GetTransactionErrorReturnType<cause = ErrorType> = Omit<

package/utils/formatters/block.ts

@@ -7,7 +7,7 @@ import type {
 } from '../../types/chain.js'
 import type { Hash } from '../../types/misc.js'
 import type { RpcBlock } from '../../types/rpc.js'
-import type { Prettify } from '../../types/utils.js'
+import type { ExactPartial, Prettify } from '../../types/utils.js'
 
 import { type DefineFormatterErrorType, defineFormatter } from './formatter.js'
 import { type FormattedTransaction, formatTransaction } from './transaction.js'
@@ -40,7 +40,7 @@ export type FormattedBlock<
 
 export type FormatBlockErrorType = ErrorType
 
-export function formatBlock(block: Partial<RpcBlock>) {
+export function formatBlock(block: ExactPartial<RpcBlock>) {
   const transactions = block.transactions?.map((transaction) => {
     if (typeof transaction === 'string') return transaction
     return formatTransaction(transaction)

package/utils/formatters/extract.ts

@@ -8,7 +8,7 @@ export type ExtractErrorType = ErrorType
  */
 export function extract(
   value_: Record<string, unknown>,
-  { format }: { format?: ChainFormatter['format'] },
+  { format }: { format?: ChainFormatter['format'] | undefined },
 ) {
   if (!format) return {}
 

package/utils/formatters/formatter.ts

@@ -15,7 +15,7 @@ export function defineFormatter<TType extends string, TParameters, TReturnType>(
     exclude,
     format: overrides,
   }: {
-    exclude?: TExclude
+    exclude?: TExclude | undefined
     format: (_: TOverrideParameters) => TOverrideReturnType
   }) => {
     return {

package/utils/formatters/log.ts

@@ -1,12 +1,16 @@
 import type { ErrorType } from '../../errors/utils.js'
 import type { Log } from '../../types/log.js'
 import type { RpcLog } from '../../types/rpc.js'
+import type { ExactPartial } from '../../types/utils.js'
 
 export type FormatLogErrorType = ErrorType
 
 export function formatLog(
-  log: Partial<RpcLog>,
-  { args, eventName }: { args?: unknown; eventName?: string } = {},
+  log: ExactPartial<RpcLog>,
+  {
+    args,
+    eventName,
+  }: { args?: unknown | undefined; eventName?: string | undefined } = {},
 ) {
   return {
     ...log,

package/utils/formatters/proof.ts

@@ -1,6 +1,7 @@
 import type { ErrorType } from '../../errors/utils.js'
 import type { Proof } from '../../types/proof.js'
 import type { RpcProof } from '../../types/rpc.js'
+import type { ExactPartial } from '../../types/utils.js'
 import { hexToNumber } from '../index.js'
 
 export type FormatProofErrorType = ErrorType
@@ -12,7 +13,7 @@ function formatStorageProof(storageProof: RpcProof['storageProof']) {
   }))
 }
 
-export function formatProof(proof: Partial<RpcProof>) {
+export function formatProof(proof: ExactPartial<RpcProof>) {
   return {
     ...proof,
     balance: proof.balance ? BigInt(proof.balance) : undefined,

package/utils/formatters/transaction.ts

@@ -8,7 +8,7 @@ import type {
 import type { Hex } from '../../types/misc.js'
 import type { RpcTransaction } from '../../types/rpc.js'
 import type { Transaction, TransactionType } from '../../types/transaction.js'
-import type { UnionLooseOmit } from '../../types/utils.js'
+import type { ExactPartial, UnionLooseOmit } from '../../types/utils.js'
 import { hexToNumber } from '../encoding/fromHex.js'
 import { type DefineFormatterErrorType, defineFormatter } from './formatter.js'
 
@@ -43,7 +43,7 @@ export const transactionType = {
 
 export type FormatTransactionErrorType = ErrorType
 
-export function formatTransaction(transaction: Partial<RpcTransaction>) {
+export function formatTransaction(transaction: ExactPartial<RpcTransaction>) {
   const transaction_ = {
     ...transaction,
     blockHash: transaction.blockHash ? transaction.blockHash : null,

package/utils/formatters/transactionReceipt.ts

@@ -5,6 +5,7 @@ import type {
 } from '../../types/chain.js'
 import type { RpcTransactionReceipt } from '../../types/rpc.js'
 import type { TransactionReceipt } from '../../types/transaction.js'
+import type { ExactPartial } from '../../types/utils.js'
 import { hexToNumber } from '../encoding/fromHex.js'
 
 import { type DefineFormatterErrorType, defineFormatter } from './formatter.js'
@@ -27,7 +28,7 @@ const statuses = {
 export type FormatTransactionReceiptErrorType = ErrorType
 
 export function formatTransactionReceipt(
-  transactionReceipt: Partial<RpcTransactionReceipt>,
+  transactionReceipt: ExactPartial<RpcTransactionReceipt>,
 ) {
   const receipt = {
     ...transactionReceipt,

package/utils/formatters/transactionRequest.ts

@@ -6,6 +6,7 @@ import type {
 import type { ByteArray } from '../../types/misc.js'
 import type { RpcTransactionRequest } from '../../types/rpc.js'
 import type { TransactionRequest } from '../../types/transaction.js'
+import type { ExactPartial } from '../../types/utils.js'
 import { bytesToHex, numberToHex } from '../encoding/toHex.js'
 import { type DefineFormatterErrorType, defineFormatter } from './formatter.js'
 
@@ -26,7 +27,9 @@ export const rpcTransactionType = {
 
 export type FormatTransactionRequestErrorType = ErrorType
 
-export function formatTransactionRequest(request: Partial<TransactionRequest>) {
+export function formatTransactionRequest(
+  request: ExactPartial<TransactionRequest>,
+) {
   const rpcRequest = { ...request } as RpcTransactionRequest
 
   if (

package/utils/hash/keccak256.ts

@@ -20,7 +20,7 @@ export type Keccak256ErrorType =
 
 export function keccak256<TTo extends To = 'hex'>(
   value: Hex | ByteArray,
-  to_?: TTo,
+  to_?: TTo | undefined,
 ): Keccak256Hash<TTo> {
   const to = to_ || 'hex'
   const bytes = keccak_256(

package/utils/hash/ripemd160.ts

@@ -20,7 +20,7 @@ export type Ripemd160ErrorType =
 
 export function ripemd160<TTo extends To = 'hex'>(
   value: Hex | ByteArray,
-  to_?: TTo,
+  to_?: TTo | undefined,
 ): Ripemd160Hash<TTo> {
   const to = to_ || 'hex'
   const bytes = noble_ripemd160(

package/utils/hash/sha256.ts

@@ -20,7 +20,7 @@ export type Sha256ErrorType =
 
 export function sha256<TTo extends To = 'hex'>(
   value: Hex | ByteArray,
-  to_?: TTo,
+  to_?: TTo | undefined,
 ): Sha256Hash<TTo> {
   const to = to_ || 'hex'
   const bytes = noble_sha256(

package/utils/poll.ts

@@ -3,9 +3,9 @@ import { wait } from './wait.js'
 
 type PollOptions<TData> = {
   // Whether or not to emit when the polling starts.
-  emitOnBegin?: boolean
+  emitOnBegin?: boolean | undefined
   // The initial wait time (in ms) before polling.
-  initialWaitTime?: (data: TData | void) => Promise<number>
+  initialWaitTime?: ((data: TData | void) => Promise<number>) | undefined
   // The interval (in ms).
   interval: number
 }

package/utils/promise/createBatchScheduler.ts

@@ -6,8 +6,8 @@ type Resolved<TReturnType extends readonly unknown[] = any> = [
 ]
 
 type PendingPromise<TReturnType extends readonly unknown[] = any> = {
-  resolve?: (data: Resolved<TReturnType>) => void
-  reject?: (reason?: unknown) => void
+  resolve?: ((data: Resolved<TReturnType>) => void) | undefined
+  reject?: ((reason?: unknown) => void) | undefined
 }
 
 type SchedulerItem = { args: unknown; pendingPromise: PendingPromise }
@@ -23,9 +23,9 @@ export type CreateBatchSchedulerArguments<
 > = {
   fn: (args: TParameters[]) => Promise<TReturnType>
   id: number | string
-  shouldSplitBatch?: (args: TParameters[]) => boolean
-  wait?: number
-  sort?: BatchResultsCompareFn<TReturnType[number]>
+  shouldSplitBatch?: ((args: TParameters[]) => boolean) | undefined
+  wait?: number | undefined
+  sort?: BatchResultsCompareFn<TReturnType[number]> | undefined
 }
 
 export type CreateBatchSchedulerReturnType<
@@ -34,7 +34,7 @@ export type CreateBatchSchedulerReturnType<
 > = {
   flush: () => void
   schedule: TParameters extends undefined
-    ? (args?: TParameters) => Promise<Resolved<TReturnType>>
+    ? (args?: TParameters | undefined) => Promise<Resolved<TReturnType>>
     : (args: TParameters) => Promise<Resolved<TReturnType>>
 }
 

package/utils/promise/withCache.ts

@@ -32,7 +32,7 @@ export type WithCacheParameters = {
   /** The key to cache the data against. */
   cacheKey: string
   /** The time that cached data will remain in memory. Default: Infinity (no expiry) */
-  cacheTime?: number
+  cacheTime?: number | undefined
 }
 
 /**

package/utils/promise/withRetry.ts

@@ -3,17 +3,22 @@ import { wait } from '../wait.js'
 
 export type WithRetryParameters = {
   // The delay (in ms) between retries.
-  delay?: ((config: { count: number; error: Error }) => number) | number
+  delay?:
+    | ((config: { count: number; error: Error }) => number)
+    | number
+    | undefined
   // The max number of times to retry.
-  retryCount?: number
+  retryCount?: number | undefined
   // Whether or not to retry when an error is thrown.
-  shouldRetry?: ({
-    count,
-    error,
-  }: {
-    count: number
-    error: Error
-  }) => Promise<boolean> | boolean
+  shouldRetry?:
+    | (({
+        count,
+        error,
+      }: {
+        count: number
+        error: Error
+      }) => Promise<boolean> | boolean)
+    | undefined
 }
 
 export type WithRetryErrorType = ErrorType

package/utils/promise/withTimeout.ts

@@ -3,18 +3,20 @@ import type { ErrorType } from '../../errors/utils.js'
 export type WithTimeoutErrorType = ErrorType
 
 export function withTimeout<TData>(
-  fn: ({ signal }: { signal?: AbortController['signal'] }) => Promise<TData>,
+  fn: ({
+    signal,
+  }: { signal: AbortController['signal'] | null }) => Promise<TData>,
   {
     errorInstance = new Error('timed out'),
     timeout,
     signal,
   }: {
     // The error instance to throw when the timeout is reached.
-    errorInstance?: Error
+    errorInstance?: Error | undefined
     // The timeout (in ms).
     timeout: number
     // Whether or not the timeout should use an abort signal.
-    signal?: boolean
+    signal?: boolean | undefined
   },
 ): Promise<TData> {
   return new Promise((resolve, reject) => {
@@ -31,7 +33,7 @@ export function withTimeout<TData>(
             }
           }, timeout)
         }
-        resolve(await fn({ signal: controller?.signal }))
+        resolve(await fn({ signal: controller?.signal || null }))
       } catch (err) {
         if ((err as Error).name === 'AbortError') reject(errorInstance)
         reject(err)

package/utils/rpc/http.ts

@@ -15,11 +15,11 @@ import { idCache } from './id.js'
 
 export type HttpRpcClientOptions = {
   // Request configuration to pass to `fetch`.
-  fetchOptions?: Omit<RequestInit, 'body'>
+  fetchOptions?: Omit<RequestInit, 'body'> | undefined
   // A callback to handle the response.
-  onResponse?: (response: Response) => Promise<void> | void
+  onResponse?: ((response: Response) => Promise<void> | void) | undefined
   // The timeout (in ms) for the request.
-  timeout?: number
+  timeout?: number | undefined
 }
 
 export type HttpRequestParameters<
@@ -28,11 +28,11 @@ export type HttpRequestParameters<
   // The RPC request body.
   body: TBody
   // Request configuration to pass to `fetch`.
-  fetchOptions?: HttpRpcClientOptions['fetchOptions']
+  fetchOptions?: HttpRpcClientOptions['fetchOptions'] | undefined
   // A callback to handle the response.
-  onResponse?: (response: Response) => Promise<void> | void
+  onResponse?: ((response: Response) => Promise<void> | void) | undefined
   // The timeout (in ms) for the request.
-  timeout?: HttpRpcClientOptions['timeout']
+  timeout?: HttpRpcClientOptions['timeout'] | undefined
 }
 
 export type HttpRequestReturnType<
@@ -92,7 +92,7 @@ export function getHttpRpcClient(
                 'Content-Type': 'application/json',
               },
               method: method || 'POST',
-              signal: signal_ || (timeout > 0 ? signal : undefined),
+              signal: signal_ || (timeout > 0 ? signal : null),
             })
             return response
           },

package/utils/rpc/socket.ts

@@ -28,12 +28,12 @@ export type SocketRpcClient<socket extends {}> = {
   socket: Socket<socket>
   request(params: {
     body: RpcRequest
-    onError?: (error: Error) => void
+    onError?: ((error: Error) => void) | undefined
     onResponse: (message: RpcResponse) => void
   }): void
   requestAsync(params: {
     body: RpcRequest
-    timeout?: number
+    timeout?: number | undefined
   }): Promise<RpcResponse>
   requests: CallbackMap
   subscriptions: CallbackMap

package/utils/signature/hashMessage.ts

@@ -25,7 +25,7 @@ export type HashMessageErrorType =
 
 export function hashMessage<TTo extends To = 'hex'>(
   message: SignableMessage,
-  to_?: TTo,
+  to_?: TTo | undefined,
 ): HashMessage<TTo> {
   const messageBytes = (() => {
     if (typeof message === 'string') return stringToBytes(message)

package/utils/transaction/assertRequest.ts

@@ -19,9 +19,12 @@ import {
 } from '../../errors/transaction.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
+import type { ExactPartial } from '../../types/utils.js'
 import { isAddress } from '../address/isAddress.js'
 
-export type AssertRequestParameters = Partial<SendTransactionParameters<Chain>>
+export type AssertRequestParameters = ExactPartial<
+  SendTransactionParameters<Chain>
+>
 
 export type AssertRequestErrorType =
   | InvalidAddressErrorType

package/utils/transaction/getTransactionType.ts

@@ -20,7 +20,13 @@ import type {
   TransactionSerializableGeneric,
   TransactionSerializableLegacy,
 } from '../../types/transaction.js'
-import type { Assign, IsNever, OneOf, Opaque } from '../../types/utils.js'
+import type {
+  Assign,
+  ExactPartial,
+  IsNever,
+  OneOf,
+  Opaque,
+} from '../../types/utils.js'
 
 type BaseProperties = {
   accessList?: undefined
@@ -45,18 +51,18 @@ type EIP1559Properties = Assign<
       },
     FeeValuesEIP1559
   > & {
-    accessList?: TransactionSerializableEIP2930['accessList']
+    accessList?: TransactionSerializableEIP2930['accessList'] | undefined
   }
 >
 type EIP2930Properties = Assign<
   BaseProperties,
-  Partial<FeeValuesLegacy> & {
+  ExactPartial<FeeValuesLegacy> & {
     accessList: TransactionSerializableEIP2930['accessList']
   }
 >
 type EIP4844Properties = Assign<
   BaseProperties,
-  Partial<FeeValuesEIP4844> &
+  ExactPartial<FeeValuesEIP4844> &
     OneOf<
       | {
           blobs: TransactionSerializableEIP4844['blobs']

package/utils/transaction/parseTransaction.ts

@@ -364,7 +364,7 @@ type ParseTransactionLegacyErrorType =
 function parseTransactionLegacy(
   serializedTransaction: Hex,
 ): Omit<TransactionRequestLegacy, 'from'> &
-  ({ chainId?: number } | ({ chainId: number } & Signature)) {
+  ({ chainId?: number | undefined } | ({ chainId: number } & Signature)) {
   const transactionArray = fromRlp(serializedTransaction, 'hex')
 
   const [nonce, gasPrice, gas, to, value, data, chainIdOrV_, r, s] =

package/utils/transaction/serializeAccessList.ts

@@ -28,7 +28,7 @@ export type SerializeAccessListErrorType =
  * @returns Array of hex strings
  */
 export function serializeAccessList(
-  accessList?: AccessList,
+  accessList?: AccessList | undefined,
 ): RecursiveArray<Hex> {
   if (!accessList || accessList.length === 0) return []