viem 2.53.1 → 2.54.0

package/tokens/definitions/stcusd.ts

@@ -0,0 +1,13 @@
+// Generated with `pnpm gen:tokenlist`. Do not modify manually.
+
+import { defineToken } from '../defineToken.js'
+
+export const stcusd = /*#__PURE__*/ defineToken({
+  addresses: {
+    4217: '0x20c0000000000000000000008ee4fcff88888888', // tempo
+  },
+  currency: 'stcUSD',
+  decimals: 6,
+  name: 'Staked Cap USD',
+  symbol: 'stcUSD',
+})

package/tokens/definitions/susde.ts

@@ -0,0 +1,13 @@
+// Generated with `pnpm gen:tokenlist`. Do not modify manually.
+
+import { defineToken } from '../defineToken.js'
+
+export const susde = /*#__PURE__*/ defineToken({
+  addresses: {
+    4217: '0x20c000000000000000000000bd95bfb69fbe6ce3', // tempo
+  },
+  currency: 'sUSDe',
+  decimals: 6,
+  name: 'Staked USDe',
+  symbol: 'sUSDe',
+})

package/tokens/definitions/syrupusdc.ts

@@ -0,0 +1,13 @@
+// Generated with `pnpm gen:tokenlist`. Do not modify manually.
+
+import { defineToken } from '../defineToken.js'
+
+export const syrupusdc = /*#__PURE__*/ defineToken({
+  addresses: {
+    4217: '0x20c0000000000000000000008191667423f70e67', // tempo
+  },
+  currency: 'syrupUSDC',
+  decimals: 6,
+  name: 'Syrup USDC',
+  symbol: 'syrupUSDC',
+})

package/tokens/definitions/thetausd.ts

@@ -0,0 +1,13 @@
+// Generated with `pnpm gen:tokenlist`. Do not modify manually.
+
+import { defineToken } from '../defineToken.js'
+
+export const thetausd = /*#__PURE__*/ defineToken({
+  addresses: {
+    42431: '0x20c0000000000000000000000000000000000003', // tempoModerato
+  },
+  currency: 'USD',
+  decimals: 6,
+  name: 'ThetaUSD',
+  symbol: 'thetaUSD',
+})

package/tokens/definitions/usd1.ts

@@ -0,0 +1,13 @@
+// Generated with `pnpm gen:tokenlist`. Do not modify manually.
+
+import { defineToken } from '../defineToken.js'
+
+export const usd1 = /*#__PURE__*/ defineToken({
+  addresses: {
+    4217: '0x20c000000000000000000000111111111e910f0f', // tempo
+  },
+  currency: 'USD',
+  decimals: 6,
+  name: 'USD1',
+  symbol: 'USD1',
+})

package/tokens/definitions/usdb.ts

@@ -0,0 +1,13 @@
+// Generated with `pnpm gen:tokenlist`. Do not modify manually.
+
+import { defineToken } from '../defineToken.js'
+
+export const usdb = /*#__PURE__*/ defineToken({
+  addresses: {
+    4217: '0x20c0000000000000000000003158081efd85bfc2', // tempo
+  },
+  currency: 'USD',
+  decimals: 6,
+  name: 'USDBridge',
+  symbol: 'USDB',
+})

package/tokens/definitions/usdc.ts

@@ -0,0 +1,67 @@
+import { defineToken } from '../defineToken.js'
+
+/**
+ * [USDC](https://www.circle.com/usdc) token, with canonical contract addresses
+ * across supported chains.
+ *
+ * Pass to a Client's `tokens` array, call with a chain id to produce a
+ * [token config](/docs/chains/tokens), or read the metadata and `addresses`
+ * map directly.
+ *
+ * @example
+ * ```ts
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { usdc } from 'viem/tokens'
+ *
+ * const client = createPublicClient({
+ *   chain: mainnet,
+ *   tokens: [usdc],
+ *   transport: http(),
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { usdc } from 'viem/tokens'
+ *
+ * usdc.addresses[1]
+ * // '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'
+ * ```
+ */
+export const usdc = /*#__PURE__*/ defineToken({
+  addresses: {
+    1: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // mainnet
+    10: '0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85', // optimism
+    130: '0x078D782b760474a361dDA0AF3839290b0EF57AD6', // unichain
+    137: '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359', // polygon
+    146: '0x29219dd400f2Bf60E5a23d13Be72B486D4038894', // sonic
+    480: '0x79A02482A880bCE3F13e09Da970dC34db4CD24d1', // worldchain
+    1301: '0x31d0220469e10c4E71834a79b1f276d740d3768F', // unichainSepolia
+    1328: '0x4fCF1784B31630811181f670Aea7A7bEF803eaED', // seiTestnet
+    1329: '0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392', // sei
+    4801: '0x66145f38cBAC35Ca6F1Dfb4914dF98F1614aeA88', // worldchainSepolia
+    8453: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // base
+    42161: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831', // arbitrum
+    43113: '0x5425890298aed601595a70AB815c96711a31Bc65', // avalancheFuji
+    43114: '0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E', // avalanche
+    57054: '0xA4879Fed32Ecbef99399e5cbC247E533421C4eC6', // sonicBlazeTestnet
+    57073: '0x2D270e6886d130D724215A266106e6832161EAEd', // ink
+    59141: '0xFEce4462D57bD51A6A552365A011b95f0E16d9B7', // lineaSepolia
+    59144: '0x176211869cA2b568f2A7D4EE941E073a821EE1ff', // linea
+    80002: '0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582', // polygonAmoy
+    81224: '0xd996633a415985DBd7D6D12f4A4343E31f5037cf', // codex
+    84532: '0x036CbD53842c5426634e7929541eC2318f3dCF7e', // baseSepolia
+    421614: '0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d', // arbitrumSepolia
+    763373: '0xFabab97dCE620294D2B0b0e46C68964e326300Ac', // inkSepolia
+    812242: '0x6d7f141b6819C2c9CC2f818e6ad549E7Ca090F8f', // codexTestnet
+    5042002: '0x3600000000000000000000000000000000000000', // arcTestnet
+    11155111: '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238', // sepolia
+    11155420: '0x5fd84259d66Cd46123540766Be93DFE6D43130D7', // optimismSepolia
+  },
+  currency: 'USD',
+  decimals: 6,
+  name: 'USD Coin',
+  popular: true,
+  symbol: 'USDC',
+})

package/tokens/definitions/usdce.ts

@@ -0,0 +1,14 @@
+// Generated with `pnpm gen:tokenlist`. Do not modify manually.
+
+import { defineToken } from '../defineToken.js'
+
+export const usdce = /*#__PURE__*/ defineToken({
+  addresses: {
+    4217: '0x20c000000000000000000000b9537d11c60e8b50', // tempo
+    42431: '0x20c0000000000000000000009e8d7eb59b783726', // tempoModerato
+  },
+  currency: 'USD',
+  decimals: 6,
+  name: 'Bridged USDC (Stargate)',
+  symbol: 'USDC.e',
+})

package/tokens/definitions/usde.ts

@@ -0,0 +1,13 @@
+// Generated with `pnpm gen:tokenlist`. Do not modify manually.
+
+import { defineToken } from '../defineToken.js'
+
+export const usde = /*#__PURE__*/ defineToken({
+  addresses: {
+    4217: '0x20c0000000000000000000002f52d5cc21a3207b', // tempo
+  },
+  currency: 'USD',
+  decimals: 6,
+  name: 'USDe',
+  symbol: 'USDe',
+})

package/tokens/definitions/usdt0.ts

@@ -0,0 +1,13 @@
+// Generated with `pnpm gen:tokenlist`. Do not modify manually.
+
+import { defineToken } from '../defineToken.js'
+
+export const usdt0 = /*#__PURE__*/ defineToken({
+  addresses: {
+    4217: '0x20c00000000000000000000014f22ca97301eb73', // tempo
+  },
+  currency: 'USD',
+  decimals: 6,
+  name: 'USDT0',
+  symbol: 'USDT0',
+})

package/tokens/definitions/wsrusd.ts

@@ -0,0 +1,13 @@
+// Generated with `pnpm gen:tokenlist`. Do not modify manually.
+
+import { defineToken } from '../defineToken.js'
+
+export const wsrusd = /*#__PURE__*/ defineToken({
+  addresses: {
+    4217: '0x20c000000000000000000000aeed2ec36a54d0e5', // tempo
+  },
+  currency: 'wsrUSD',
+  decimals: 6,
+  name: 'Wrapped Savings rUSD',
+  symbol: 'wsrUSD',
+})

package/tokens/index.ts

@@ -0,0 +1,31 @@
+// biome-ignore lint/performance/noBarrelFile: entrypoint module
+export { defineToken, type Token, type Tokens } from './defineToken.js'
+export { alphausd } from './definitions/alphausd.js'
+export { betausd } from './definitions/betausd.js'
+export { brla } from './definitions/brla.js'
+export { cbbtc } from './definitions/cbbtc.js'
+export { chfau } from './definitions/chfau.js'
+export { cusd } from './definitions/cusd.js'
+export { dlusd } from './definitions/dlusd.js'
+export { eurau } from './definitions/eurau.js'
+export { eurce } from './definitions/eurce.js'
+export { frxusd } from './definitions/frxusd.js'
+export { gbpa } from './definitions/gbpa.js'
+export { gusd } from './definitions/gusd.js'
+export { iusd } from './definitions/iusd.js'
+export { pathusd } from './definitions/pathusd.js'
+export { reusd } from './definitions/reusd.js'
+export { rusd } from './definitions/rusd.js'
+export { sbc } from './definitions/sbc.js'
+export { siusd } from './definitions/siusd.js'
+export { stcusd } from './definitions/stcusd.js'
+export { susde } from './definitions/susde.js'
+export { syrupusdc } from './definitions/syrupusdc.js'
+export { thetausd } from './definitions/thetausd.js'
+export { usd1 } from './definitions/usd1.js'
+export { usdb } from './definitions/usdb.js'
+export { usdc } from './definitions/usdc.js'
+export { usdce } from './definitions/usdce.js'
+export { usde } from './definitions/usde.js'
+export { usdt0 } from './definitions/usdt0.js'
+export { wsrusd } from './definitions/wsrusd.js'

package/tokens/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/tokens/index.d.ts",
+  "module": "../_esm/tokens/index.js",
+  "main": "../_cjs/tokens/index.js"
+}

package/utils/encoding/fromRlp.ts

@@ -2,6 +2,8 @@ import { BaseError, type BaseErrorType } from '../../errors/base.js'
 import {
   InvalidHexValueError,
   type InvalidHexValueErrorType,
+  RlpDepthLimitExceededError,
+  type RlpDepthLimitExceededErrorType,
 } from '../../errors/encoding.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
@@ -17,6 +19,8 @@ import type { RecursiveArray } from './toRlp.js'
 
 type To = 'hex' | 'bytes'
 
+const rlpDepthLimit = 1_024
+
 export type FromRlpReturnType<to extends To> =
   | (to extends 'bytes' ? RecursiveArray<ByteArray> : never)
   | (to extends 'hex' ? RecursiveArray<Hex> : never)
@@ -26,6 +30,7 @@ export type FromRlpErrorType =
   | FromRlpCursorErrorType
   | HexToBytesErrorType
   | InvalidHexValueErrorType
+  | RlpDepthLimitExceededErrorType
   | ErrorType
 
 export function fromRlp<to extends To = 'hex'>(
@@ -58,7 +63,11 @@ type FromRlpCursorErrorType =
 function fromRlpCursor<to extends To = 'hex'>(
   cursor: Cursor,
   to: to | To | undefined = 'hex',
+  recursiveDepth = 0,
 ): FromRlpReturnType<to> {
+  if (recursiveDepth >= rlpDepthLimit)
+    throw new RlpDepthLimitExceededError({ limit: rlpDepthLimit })
+
   if (cursor.bytes.length === 0)
     return (
       to === 'hex' ? bytesToHex(cursor.bytes) : cursor.bytes
@@ -76,7 +85,12 @@ function fromRlpCursor<to extends To = 'hex'>(
 
   // list
   const length = readLength(cursor, prefix, 0xc0)
-  return readList(cursor, length, to) as {} as FromRlpReturnType<to>
+  return readList(
+    cursor,
+    length,
+    to,
+    recursiveDepth + 1,
+  ) as {} as FromRlpReturnType<to>
 }
 
 type ReadLengthErrorType = BaseErrorType | ErrorType
@@ -93,10 +107,15 @@ function readLength(cursor: Cursor, prefix: number, offset: number) {
 
 type ReadListErrorType = ErrorType
 
-function readList<to extends To>(cursor: Cursor, length: number, to: to | To) {
+function readList<to extends To>(
+  cursor: Cursor,
+  length: number,
+  to: to | To,
+  recursiveDepth: number,
+) {
   const position = cursor.position
   const value: FromRlpReturnType<to>[] = []
   while (cursor.position - position < length)
-    value.push(fromRlpCursor(cursor, to))
+    value.push(fromRlpCursor(cursor, to, recursiveDepth))
   return value
 }

package/utils/rpc/http.ts

@@ -1,6 +1,8 @@
 import {
   HttpRequestError,
   type HttpRequestErrorType as HttpRequestErrorType_,
+  ResponseBodyTooLargeError,
+  type ResponseBodyTooLargeErrorType,
   TimeoutError,
   type TimeoutErrorType,
 } from '../../errors/request.js'
@@ -25,6 +27,8 @@ export type HttpRpcClientOptions = {
     | undefined
   /** Request configuration to pass to `fetch`. */
   fetchOptions?: Omit<RequestInit, 'body'> | undefined
+  /** Maximum response body size in bytes. Set to `false` to disable. @default 10_485_760 */
+  maxResponseBodySize?: number | false | undefined
   /** A callback to handle the request. */
   onRequest?:
     | ((
@@ -49,6 +53,8 @@ export type HttpRequestParameters<
   fetchFn?: HttpRpcClientOptions['fetchFn'] | undefined
   /** Request configuration to pass to `fetch`. */
   fetchOptions?: HttpRpcClientOptions['fetchOptions'] | undefined
+  /** Maximum response body size in bytes. Set to `false` to disable. */
+  maxResponseBodySize?: HttpRpcClientOptions['maxResponseBodySize'] | undefined
   /** A callback to handle the response. */
   onRequest?:
     | ((
@@ -70,10 +76,13 @@ export type HttpRequestReturnType<
 
 export type HttpRequestErrorType =
   | HttpRequestErrorType_
+  | ResponseBodyTooLargeErrorType
   | TimeoutErrorType
   | WithTimeoutErrorType
   | ErrorType
 
+const defaultMaxResponseBodySize = 10_485_760
+
 export type HttpRpcClient = {
   request<body extends RpcRequest | RpcRequest[]>(
     params: HttpRequestParameters<body>,
@@ -91,6 +100,8 @@ export function getHttpRpcClient(
       const {
         body,
         fetchFn = options.fetchFn ?? fetch,
+        maxResponseBodySize = options.maxResponseBodySize ??
+          defaultMaxResponseBodySize,
         onRequest = options.onRequest,
         onResponse = options.onResponse,
         timeout = options.timeout ?? 10_000,
@@ -144,12 +155,15 @@ export function getHttpRpcClient(
         if (onResponse) await onResponse(response)
 
         let data: any
+        const responseBody = await readResponseBody(response, {
+          maxResponseBodySize,
+        })
         if (
           response.headers.get('Content-Type')?.startsWith('application/json')
         )
-          data = await response.json()
+          data = JSON.parse(responseBody)
         else {
-          data = await response.text()
+          data = responseBody
           try {
             data = JSON.parse(data || '{}')
           } catch (err) {
@@ -181,6 +195,7 @@ export function getHttpRpcClient(
         if (signal_?.aborted) throw getAbortError(signal_)
         if (isAbortError(err)) throw err
         if (err instanceof HttpRequestError) throw err
+        if (err instanceof ResponseBodyTooLargeError) throw err
         if (err instanceof TimeoutError) throw err
         throw new HttpRequestError({
           body,
@@ -192,6 +207,59 @@ export function getHttpRpcClient(
   }
 }
 
+async function readResponseBody(
+  response: Response,
+  { maxResponseBodySize }: { maxResponseBodySize: number | false },
+): Promise<string> {
+  if (maxResponseBodySize === false) return response.text()
+
+  const contentLength = response.headers.get('Content-Length')
+  if (contentLength) {
+    const size = Number(contentLength)
+    if (size > maxResponseBodySize)
+      throw new ResponseBodyTooLargeError({
+        maxSize: maxResponseBodySize,
+        size,
+      })
+  }
+
+  if (!response.body) {
+    const body = await response.text()
+    const size = new TextEncoder().encode(body).length
+    if (size > maxResponseBodySize)
+      throw new ResponseBodyTooLargeError({
+        maxSize: maxResponseBodySize,
+        size,
+      })
+    return body
+  }
+
+  const reader = response.body.getReader()
+  const decoder = new TextDecoder()
+  let body = ''
+  let size = 0
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      size += value.byteLength
+      if (size > maxResponseBodySize) {
+        await reader.cancel()
+        throw new ResponseBodyTooLargeError({
+          maxSize: maxResponseBodySize,
+          size,
+        })
+      }
+      body += decoder.decode(value, { stream: true })
+    }
+    body += decoder.decode()
+    return body
+  } finally {
+    reader.releaseLock()
+  }
+}
+
 /** @internal */
 export function parseUrl(url_: string) {
   try {

package/utils/transaction/parseTransaction.ts

@@ -7,6 +7,8 @@ import {
   type InvalidLegacyVErrorType,
   InvalidSerializedTransactionError,
   type InvalidSerializedTransactionErrorType,
+  InvalidYParityError,
+  type InvalidYParityErrorType,
 } from '../../errors/transaction.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type {
@@ -593,6 +595,7 @@ function parseAuthorizationList(
 
 type ParseEIP155SignatureErrorType =
   | HexToBigIntErrorType
+  | InvalidYParityErrorType
   | PadHexErrorType
   | ErrorType
 
@@ -600,8 +603,10 @@ function parseEIP155Signature(
   transactionArray: RecursiveArray<Hex>,
 ): Signature & { yParity: number } {
   const signature = transactionArray.slice(-3)
-  const v =
-    signature[0] === '0x' || hexToBigInt(signature[0] as Hex) === 0n ? 27n : 28n
+  const yParity = signature[0] === '0x' ? 0n : hexToBigInt(signature[0] as Hex)
+  if (yParity !== 0n && yParity !== 1n)
+    throw new InvalidYParityError({ yParity })
+  const v = yParity === 0n ? 27n : 28n
   return {
     r: padHex(signature[1] as Hex, { size: 32 }),
     s: padHex(signature[2] as Hex, { size: 32 }),