viem 0.3.2 → 0.3.4

package/dist/types/utils/encoding/toHex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toHex.d.ts","sourceRoot":"","sources":["../../../../src/utils/encoding/toHex.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,sBAAsB,CAAA;AAO1D;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,GAAG,CAE7C;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,GAAG,CAMhD;AAED;;GAEG;AACH,wBAAgB,KAAK,CACnB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GACpD,GAAG,CAQL;AAED,MAAM,MAAM,eAAe,GACvB;IAEE,MAAM,CAAC,EAAE,OAAO,CAAA;IAEhB,IAAI,EAAE,MAAM,CAAA;CACb,GACD;IACE,MAAM,CAAC,EAAE,KAAK,CAAA;IACd,IAAI,CAAC,EAAE,KAAK,CAAA;CACb,CAAA;AAEL;;GAEG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,IAAI,GAAE,eAAoB,GACzB,GAAG,CAgCL;AAID;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAG/C"}
+{"version":3,"file":"toHex.d.ts","sourceRoot":"","sources":["../../../../src/utils/encoding/toHex.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,sBAAsB,CAAA;AAQ1D,MAAM,MAAM,eAAe,GAAG;IAC5B,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,KAAK,CACnB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,EACrD,IAAI,GAAE,eAAoB,GACzB,GAAG,CAQL;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,GAAE,aAAkB,GAAG,GAAG,CAOvE;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,GAAE,cAAmB,GAAG,GAAG,CAY3E;AAED,MAAM,MAAM,eAAe,GACvB;IACE,4DAA4D;IAC5D,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAA;CACb,GACD;IACE,MAAM,CAAC,EAAE,KAAK,CAAA;IACd,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAEL;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,IAAI,GAAE,eAAoB,GACzB,GAAG,CAgCL;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAID;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,GAAE,eAAoB,GAAG,GAAG,CAG3E"}

package/dist/types/utils/errors/getContractError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getContractError.d.ts","sourceRoot":"","sources":["../../../../src/utils/errors/getContractError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,SAAS,CAAA;AAClC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AACtD,OAAO,EAEL,8BAA8B,EAG/B,MAAM,uBAAuB,CAAA;AAM9B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AAInD,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,SAAS,EACd,EACE,GAAG,EACH,OAAO,EACP,IAAI,EACJ,QAAQ,EACR,YAAY,EACZ,MAAM,GACP,EAAE;IACD,GAAG,EAAE,GAAG,CAAA;IACR,IAAI,EAAE,GAAG,CAAA;IACT,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,kCA+BF"}
+{"version":3,"file":"getContractError.d.ts","sourceRoot":"","sources":["../../../../src/utils/errors/getContractError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,SAAS,CAAA;AAClC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AACtD,OAAO,EAEL,8BAA8B,EAG/B,MAAM,uBAAuB,CAAA;AAM9B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AAInD,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,SAAS,EACd,EACE,GAAG,EACH,OAAO,EACP,IAAI,EACJ,QAAQ,EACR,YAAY,EACZ,MAAM,GACP,EAAE;IACD,GAAG,EAAE,GAAG,CAAA;IACR,IAAI,EAAE,GAAG,CAAA;IACT,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,kCAmCF"}

package/dist/types/utils/promise/createBatchScheduler.d.ts

@@ -0,0 +1,15 @@
+type Resolved<TReturnType extends readonly unknown[] = any> = [
+    result: TReturnType[number],
+    results: TReturnType
+];
+export declare function createBatchScheduler<TParameters, TReturnType extends readonly unknown[]>({ fn, id, shouldSplitBatch, wait, }: {
+    fn: (args: TParameters[]) => Promise<TReturnType>;
+    id: number | string;
+    shouldSplitBatch?: (args: TParameters[]) => boolean;
+    wait?: number;
+}): {
+    flush: () => boolean;
+    schedule(args: TParameters): Promise<Resolved<TReturnType>>;
+};
+export {};
+//# sourceMappingURL=createBatchScheduler.d.ts.map

package/dist/types/utils/promise/createBatchScheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createBatchScheduler.d.ts","sourceRoot":"","sources":["../../../../src/utils/promise/createBatchScheduler.ts"],"names":[],"mappings":"AAAA,KAAK,QAAQ,CAAC,WAAW,SAAS,SAAS,OAAO,EAAE,GAAG,GAAG,IAAI;IAC5D,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC;IAC3B,OAAO,EAAE,WAAW;CACrB,CAAA;AAWD,wBAAgB,oBAAoB,CAClC,WAAW,EACX,WAAW,SAAS,SAAS,OAAO,EAAE,EACtC,EACA,EAAE,EACF,EAAE,EACF,gBAAgB,EAChB,IAAQ,GACT,EAAE;IACD,EAAE,EAAE,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,OAAO,CAAC,WAAW,CAAC,CAAA;IACjD,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;IACnB,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,OAAO,CAAA;IACnD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;;mBAgCwB,WAAW;EAsBnC"}

package/dist/types/utils/promise/index.d.ts

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

package/dist/types/utils/promise/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/promise/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/promise/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAChE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA"}

package/package.json

@@ -12,7 +12,7 @@
     "isomorphic-ws": "5.0.0",
     "ws": "8.12.0"
   },
-  "version": "0.3.2",
+  "version": "0.3.4",
   "files": [
     "dist",
     "!dist/**/*.tsbuildinfo",

package/src/actions/public/call.ts

@@ -1,5 +1,11 @@
 import type { PublicClient, Transport } from '../../clients/index.js'
+import { aggregate3Signature, multicall3Abi } from '../../constants/index.js'
 import type { BaseError } from '../../errors/index.js'
+import {
+  ChainDoesNotSupportContract,
+  ClientChainNotConfiguredError,
+  RawContractError,
+} from '../../errors/index.js'
 import type {
   Account,
   Address,
@@ -10,19 +16,23 @@ import type {
   MergeIntersectionProperties,
   TransactionRequest,
 } from '../../types/index.js'
+import type {
+  Formatted,
+  TransactionRequestFormatter,
+} from '../../utils/index.js'
 import {
   assertRequest,
+  decodeFunctionResult,
+  encodeFunctionData,
   extract,
   format,
   formatTransactionRequest,
   getCallError,
+  getChainContractAddress,
   numberToHex,
   parseAccount,
 } from '../../utils/index.js'
-import type {
-  Formatted,
-  TransactionRequestFormatter,
-} from '../../utils/index.js'
+import { createBatchScheduler } from '../../utils/promise/createBatchScheduler.js'
 
 export type FormattedCall<
   TFormatter extends Formatter | undefined = Formatter,
@@ -35,6 +45,7 @@ export type CallParameters<
   TChain extends Chain | undefined = Chain | undefined,
 > = FormattedCall<TransactionRequestFormatter<TChain>> & {
   account?: Account | Address
+  batch?: boolean
 } & (
     | {
         /** The balance of the account at a block number. */
@@ -84,6 +95,7 @@ export async function call<TChain extends Chain | undefined>(
 ): Promise<CallReturnType> {
   const {
     account: account_,
+    batch = Boolean(client.batch?.multicall),
     blockNumber,
     blockTag = 'latest',
     accessList,
@@ -104,7 +116,7 @@ export async function call<TChain extends Chain | undefined>(
 
     const blockNumberHex = blockNumber ? numberToHex(blockNumber) : undefined
     const formatter = client.chain?.formatters?.transactionRequest
-    const request_ = format(
+    const request = format(
       {
         from: account?.address,
         accessList,
@@ -122,11 +134,27 @@ export async function call<TChain extends Chain | undefined>(
       {
         formatter: formatter || formatTransactionRequest,
       },
-    )
+    ) as TransactionRequest
+
+    if (batch && shouldPerformMulticall({ request })) {
+      try {
+        return await scheduleMulticall(client, {
+          ...request,
+          blockNumber,
+          blockTag,
+        } as unknown as ScheduleMulticallParameters<TChain>)
+      } catch (err) {
+        if (
+          !(err instanceof ClientChainNotConfiguredError) &&
+          !(err instanceof ChainDoesNotSupportContract)
+        )
+          throw err
+      }
+    }
 
     const response = await client.request({
       method: 'eth_call',
-      params: [request_, blockNumberHex || blockTag],
+      params: [request as any, blockNumberHex || blockTag],
     })
     if (response === '0x') return { data: undefined }
     return { data: response }
@@ -138,3 +166,109 @@ export async function call<TChain extends Chain | undefined>(
     })
   }
 }
+
+// We only want to perform a scheduled multicall if:
+// - The request has calldata,
+// - The request has a target address,
+// - The target address is not already the aggregate3 signature,
+// - The request has no other properties (`nonce`, `gas`, etc cannot be sent with a multicall).
+function shouldPerformMulticall({ request }: { request: TransactionRequest }) {
+  const { data, to, ...request_ } = request
+  if (!data) return false
+  if (data.startsWith(aggregate3Signature)) return false
+  if (!to) return false
+  if (
+    Object.values(request_).filter((x) => typeof x !== 'undefined').length > 0
+  )
+    return false
+  return true
+}
+
+type ScheduleMulticallParameters<TChain extends Chain | undefined> = Pick<
+  CallParameters<TChain>,
+  'blockNumber' | 'blockTag'
+> & {
+  data: Hex
+  multicallAddress?: Address
+  to: Address
+}
+
+async function scheduleMulticall<TChain extends Chain | undefined>(
+  client: PublicClient<Transport, TChain>,
+  args: ScheduleMulticallParameters<TChain>,
+) {
+  const { batchSize = 1024, wait = 0 } =
+    typeof client.batch?.multicall === 'object' ? client.batch?.multicall : {}
+  const {
+    blockNumber,
+    blockTag = 'latest',
+    data,
+    multicallAddress: multicallAddress_,
+    to,
+  } = args
+
+  let multicallAddress = multicallAddress_
+  if (!multicallAddress) {
+    if (!client.chain) throw new ClientChainNotConfiguredError()
+
+    multicallAddress = getChainContractAddress({
+      blockNumber,
+      chain: client.chain,
+      contract: 'multicall3',
+    })
+  }
+
+  const blockNumberHex = blockNumber ? numberToHex(blockNumber) : undefined
+  const block = blockNumberHex || blockTag
+
+  const { schedule } = createBatchScheduler({
+    id: `${client.uid}.${block}`,
+    wait,
+    shouldSplitBatch(args) {
+      const size = args.reduce((size, { data }) => size + (data.length - 2), 0)
+      return size > batchSize * 2
+    },
+    fn: async (
+      requests: {
+        data: Hex
+        to: Address
+      }[],
+    ) => {
+      const calls = requests.map((request) => ({
+        allowFailure: true,
+        callData: request.data,
+        target: request.to,
+      }))
+
+      const calldata = encodeFunctionData({
+        abi: multicall3Abi,
+        args: [calls],
+        functionName: 'aggregate3',
+      })
+
+      const data = await client.request({
+        method: 'eth_call',
+        params: [
+          {
+            data: calldata,
+            to: multicallAddress,
+          },
+          block,
+        ],
+      })
+
+      return decodeFunctionResult({
+        abi: multicall3Abi,
+        args: [calls],
+        functionName: 'aggregate3',
+        data: data || '0x',
+      })
+    },
+  })
+
+  const [{ returnData, success }] = await schedule({ data, to })
+
+  if (!success) throw new RawContractError({ data: returnData })
+  if (returnData === '0x') return { data: undefined }
+  return { data: returnData }
+}

package/src/actions/public/simulateContract.ts

@@ -32,7 +32,7 @@ export type SimulateContractParameters<
 } & ContractFunctionConfig<TAbi, TFunctionName, 'payable' | 'nonpayable'> &
   Omit<
     CallParameters<TChainOverride extends Chain ? TChainOverride : TChain>,
-    'to' | 'data' | 'value'
+    'batch' | 'to' | 'data' | 'value'
   > &
   GetValue<TAbi, TFunctionName, CallParameters<TChain>['value']>
 
@@ -115,6 +115,7 @@ export async function simulateContract<
   } as unknown as EncodeFunctionDataParameters<TAbi, TFunctionName>)
   try {
     const { data } = await call(client, {
+      batch: false,
       data: calldata,
       to: address,
       ...callRequest,

package/src/clients/createPublicClient.ts

@@ -6,13 +6,26 @@ import { publicActions } from './decorators/index.js'
 import type { PublicActions } from './decorators/index.js'
 import type { Chain, Prettify } from '../types/index.js'
 
+export type MulticallBatchOptions = {
+  /** The maximum size (in bytes) for each calldata chunk. @default 1_024 */
+  batchSize?: number
+  /** The maximum number of milliseconds to wait before sending a batch. @default 16 */
+  wait?: number
+}
+
 export type PublicClientConfig<
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,
 > = Pick<
   ClientConfig<TTransport, TChain>,
   'chain' | 'key' | 'name' | 'pollingInterval' | 'transport'
->
+> & {
+  /** Flags for batch settings. */
+  batch?: {
+    /** Toggle to enable `eth_call` multicall aggregation. */
+    multicall?: boolean | MulticallBatchOptions
+  }
+}
 
 export type PublicClient<
   TTransport extends Transport = Transport,
@@ -20,6 +33,7 @@ export type PublicClient<
   TIncludeActions extends boolean = true,
 > = Prettify<
   Client<TTransport, PublicRequests, TChain> &
+    Pick<PublicClientConfig, 'batch'> &
     (TIncludeActions extends true ? PublicActions<TTransport, TChain> : unknown)
 >
 
@@ -46,6 +60,7 @@ export function createPublicClient<
   TTransport extends Transport,
   TChain extends Chain | undefined = undefined,
 >({
+  batch,
   chain,
   key = 'public',
   name = 'Public Client',
@@ -65,6 +80,7 @@ export function createPublicClient<
     type: 'publicClient',
   }) as PublicClient<TTransport, TChain>
   return {
+    batch,
     ...client,
     ...publicActions(client),
   }

package/src/clients/transports/fallback.ts

@@ -85,7 +85,7 @@ export function fallback(
   const {
     key = 'fallback',
     name = 'Fallback',
-    rank = true,
+    rank = false,
     retryCount,
     retryDelay,
   } = config

package/src/constants/contract.ts

@@ -0,0 +1 @@
+export const aggregate3Signature = '0x82ad56cb'

package/src/constants/index.ts

@@ -1,5 +1,7 @@
 export { multicall3Abi } from './abis.js'
 
+export { aggregate3Signature } from './contract.js'
+
 export { panicReasons, solidityError, solidityPanic } from './solidity.js'
 
 export { etherUnits, gweiUnits, weiUnits } from './unit.js'

package/src/errors/chain.ts

@@ -67,6 +67,14 @@ export class ChainNotFoundError extends BaseError {
   }
 }
 
+export class ClientChainNotConfiguredError extends BaseError {
+  override name = 'ClientChainNotConfiguredError'
+
+  constructor() {
+    super('No chain was provided to the Client.')
+  }
+}
+
 export class InvalidChainIdError extends BaseError {
   override name = 'InvalidChainIdError'
 

package/src/errors/contract.ts

@@ -194,7 +194,7 @@ export class ContractFunctionRevertedError extends BaseError {
     } else if (message) reason = message
 
     super(
-      reason
+      reason && reason !== 'execution reverted'
         ? [
             `The contract function "${functionName}" reverted with the following reason:`,
             reason,

package/src/errors/encoding.ts

@@ -81,3 +81,12 @@ export class OffsetOutOfBoundsError extends BaseError {
     )
   }
 }
+
+export class SizeOverflowError extends BaseError {
+  override name = 'SizeOverflowError'
+  constructor({ givenSize, maxSize }: { givenSize: number; maxSize: number }) {
+    super(
+      `Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`,
+    )
+  }
+}

package/src/errors/index.ts

@@ -37,6 +37,7 @@ export {
   ChainDoesNotSupportContract,
   ChainMismatchError,
   ChainNotFoundError,
+  ClientChainNotConfiguredError,
   InvalidChainIdError,
 } from './chain.js'
 
@@ -58,6 +59,7 @@ export {
   InvalidHexBooleanError,
   InvalidHexValueError,
   OffsetOutOfBoundsError,
+  SizeOverflowError,
 } from './encoding.js'
 
 export {

package/src/errors/version.ts

@@ -1 +1 @@
-export const version = '0.3.2'
+export const version = '0.3.4'

package/src/index.ts

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

package/src/types/eip1193.ts

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

package/src/utils/encoding/fromBytes.ts

@@ -1,8 +1,20 @@
 import { InvalidBytesBooleanError } from '../../errors/index.js'
 import type { ByteArray, Hex } from '../../types/index.js'
-import { hexToBigInt, hexToNumber } from './fromHex.js'
+import { trim } from '../data/trim.js'
+import { assertSize, hexToBigInt, hexToNumber } from './fromHex.js'
 import { bytesToHex } from './toHex.js'
 
+export type FromBytesParameters<
+  TTo extends 'string' | 'hex' | 'bigint' | 'number' | 'boolean',
+> =
+  | TTo
+  | {
+      /** Size of the bytes. */
+      size?: number
+      /** Type to convert to. */
+      to: TTo
+    }
+
 type FromBytesReturnType<TTo> = TTo extends 'string'
   ? string
   : TTo extends 'hex'
@@ -16,30 +28,106 @@ type FromBytesReturnType<TTo> = TTo extends 'string'
   : never
 
 /**
- * @description Decodes a byte array into a UTF-8 string, hex value, number, bigint or boolean.
+ * Decodes a byte array into a UTF-8 string, hex value, number, bigint or boolean.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromBytes.html
+ * - Example: https://viem.sh/docs/utilities/fromBytes.html#usage
+ *
+ * @param bytes Byte array to decode.
+ * @param toOrOpts Type to convert to or options.
+ * @returns Decoded value.
+ *
+ * @example
+ * import { fromBytes } from 'viem'
+ * const data = fromBytes(new Uint8Array([1, 164]), 'number')
+ * // 420
+ *
+ * @example
+ * import { fromBytes } from 'viem'
+ * const data = fromBytes(
+ *   new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+ *   'string'
+ * )
+ * // 'Hello world'
  */
 export function fromBytes<
   TTo extends 'string' | 'hex' | 'bigint' | 'number' | 'boolean',
->(bytes: ByteArray, to: TTo): FromBytesReturnType<TTo> {
-  if (to === 'number') return bytesToNumber(bytes) as FromBytesReturnType<TTo>
-  if (to === 'bigint') return bytesToBigint(bytes) as FromBytesReturnType<TTo>
-  if (to === 'boolean') return bytesToBool(bytes) as FromBytesReturnType<TTo>
-  if (to === 'string') return bytesToString(bytes) as FromBytesReturnType<TTo>
-  return bytesToHex(bytes) as FromBytesReturnType<TTo>
+>(
+  bytes: ByteArray,
+  toOrOpts: FromBytesParameters<TTo>,
+): FromBytesReturnType<TTo> {
+  const opts = typeof toOrOpts === 'string' ? { to: toOrOpts } : toOrOpts
+  const to = opts.to
+
+  if (to === 'number')
+    return bytesToNumber(bytes, opts) as FromBytesReturnType<TTo>
+  if (to === 'bigint')
+    return bytesToBigint(bytes, opts) as FromBytesReturnType<TTo>
+  if (to === 'boolean')
+    return bytesToBool(bytes, opts) as FromBytesReturnType<TTo>
+  if (to === 'string')
+    return bytesToString(bytes, opts) as FromBytesReturnType<TTo>
+  return bytesToHex(bytes, opts) as FromBytesReturnType<TTo>
+}
+
+export type BytesToBigIntOpts = {
+  /** Whether or not the number of a signed representation. */
+  signed?: boolean
+  /** Size of the bytes. */
+  size?: number
 }
 
 /**
- * @description Decodes a byte array into a bigint.
+ * Decodes a byte array into a bigint.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromBytes.html#bytestobigint
+ *
+ * @param bytes Byte array to decode.
+ * @param opts Options.
+ * @returns BigInt value.
+ *
+ * @example
+ * import { bytesToBigint } from 'viem'
+ * const data = bytesToBigint(new Uint8Array([1, 164]))
+ * // 420n
  */
-export function bytesToBigint(bytes: ByteArray): bigint {
-  const hex = bytesToHex(bytes)
+export function bytesToBigint(
+  bytes: ByteArray,
+  opts: BytesToBigIntOpts = {},
+): bigint {
+  if (typeof opts.size !== 'undefined') assertSize(bytes, { size: opts.size })
+  const hex = bytesToHex(bytes, opts)
   return hexToBigInt(hex)
 }
 
+export type BytesToBoolOpts = {
+  /** Size of the bytes. */
+  size?: number
+}
+
 /**
- * @description Decodes a byte array into a boolean.
+ * Decodes a byte array into a boolean.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromBytes.html#bytestobool
+ *
+ * @param bytes Byte array to decode.
+ * @param opts Options.
+ * @returns Boolean value.
+ *
+ * @example
+ * import { bytesToBool } from 'viem'
+ * const data = bytesToBool(new Uint8Array([1]))
+ * // true
  */
-export function bytesToBool(bytes: ByteArray): boolean {
+export function bytesToBool(
+  bytes_: ByteArray,
+  opts: BytesToBoolOpts = {},
+): boolean {
+  let bytes = bytes_
+  if (typeof opts.size !== 'undefined') {
+    assertSize(bytes, { size: opts.size })
+    bytes = trim(bytes)
+  }
   if (bytes.length > 1 || bytes[0] > 1)
     throw new InvalidBytesBooleanError(bytes)
   return Boolean(bytes[0])
@@ -47,17 +135,58 @@ export function bytesToBool(bytes: ByteArray): boolean {
 
 export { bytesToHex }
 
+export type BytesToNumberOpts = BytesToBigIntOpts
+
 /**
- * @description Decodes a byte array into a number.
+ * Decodes a byte array into a number.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromBytes.html#bytestonumber
+ *
+ * @param bytes Byte array to decode.
+ * @param opts Options.
+ * @returns Number value.
+ *
+ * @example
+ * import { bytesToNumber } from 'viem'
+ * const data = bytesToNumber(new Uint8Array([1, 164]))
+ * // 420
  */
-export function bytesToNumber(bytes: ByteArray): number {
-  const hex = bytesToHex(bytes)
+export function bytesToNumber(
+  bytes: ByteArray,
+  opts: BytesToNumberOpts = {},
+): number {
+  if (typeof opts.size !== 'undefined') assertSize(bytes, { size: opts.size })
+  const hex = bytesToHex(bytes, opts)
   return hexToNumber(hex)
 }
 
+export type BytesToStringOpts = {
+  /** Size of the bytes. */
+  size?: number
+}
+
 /**
- * @description Decodes a byte array into a UTF-8 string.
+ * Decodes a byte array into a UTF-8 string.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromBytes.html#bytestostring
+ *
+ * @param bytes Byte array to decode.
+ * @param opts Options.
+ * @returns String value.
+ *
+ * @example
+ * import { bytesToString } from 'viem'
+ * const data = bytesToString(new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]))
+ * // 'Hello world'
  */
-export function bytesToString(bytes: ByteArray): string {
+export function bytesToString(
+  bytes_: ByteArray,
+  opts: BytesToStringOpts = {},
+): string {
+  let bytes = bytes_
+  if (typeof opts.size !== 'undefined') {
+    assertSize(bytes, { size: opts.size })
+    bytes = trim(bytes, { dir: 'right' })
+  }
   return new TextDecoder().decode(bytes)
 }