viem 2.54.2 → 2.54.4

package/actions/index.ts

@@ -200,6 +200,12 @@ export {
   type GetProofReturnType,
   getProof,
 } from './public/getProof.js'
+export {
+  type GetRawTransactionErrorType,
+  type GetRawTransactionParameters,
+  type GetRawTransactionReturnType,
+  getRawTransaction,
+} from './public/getRawTransaction.js'
 export {
   type GetStorageAtErrorType,
   type GetStorageAtParameters,

package/actions/public/getRawTransaction.ts

@@ -0,0 +1,60 @@
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import {
+  TransactionNotFoundError,
+  type TransactionNotFoundErrorType,
+} from '../../errors/transaction.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { Chain } from '../../types/chain.js'
+import type { Hash, Hex } from '../../types/misc.js'
+import type { RequestErrorType } from '../../utils/buildRequest.js'
+
+export type GetRawTransactionParameters = {
+  /** The hash of the transaction. */
+  hash: Hash
+}
+
+export type GetRawTransactionReturnType = Hex
+
+export type GetRawTransactionErrorType =
+  | TransactionNotFoundErrorType
+  | RequestErrorType
+  | ErrorType
+
+/**
+ * Returns the raw, serialized [Transaction](https://viem.sh/docs/glossary/terms#transaction) given a hash.
+ *
+ * - Docs: https://viem.sh/docs/actions/public/getRawTransaction
+ * - JSON-RPC Methods: `eth_getRawTransactionByHash`
+ *
+ * @param client - Client to use
+ * @param parameters - {@link GetRawTransactionParameters}
+ * @returns The raw, serialized transaction. {@link GetRawTransactionReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { getRawTransaction } from 'viem/public'
+ *
+ * const client = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const rawTransaction = await getRawTransaction(client, {
+ *   hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',
+ * })
+ */
+export async function getRawTransaction<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
+  { hash }: GetRawTransactionParameters,
+): Promise<GetRawTransactionReturnType> {
+  const rawTransaction = await client.request(
+    {
+      method: 'eth_getRawTransactionByHash',
+      params: [hash],
+    },
+    { dedupe: true },
+  )
+  if (!rawTransaction) throw new TransactionNotFoundError({ hash })
+  return rawTransaction
+}

package/clients/decorators/public.ts

@@ -160,6 +160,11 @@ import {
   type GetProofReturnType,
   getProof,
 } from '../../actions/public/getProof.js'
+import {
+  type GetRawTransactionParameters,
+  type GetRawTransactionReturnType,
+  getRawTransaction,
+} from '../../actions/public/getRawTransaction.js'
 import {
   type GetStorageAtParameters,
   type GetStorageAtReturnType,
@@ -1352,6 +1357,30 @@ export type PublicActions<
       | EstimateMaxPriorityFeePerGasParameters<chain, chainOverride>
       | undefined,
   ) => Promise<EstimateMaxPriorityFeePerGasReturnType>
+  /**
+   * Returns the raw, serialized [Transaction](https://viem.sh/docs/glossary/terms#transaction) given a hash.
+   *
+   * - Docs: https://viem.sh/docs/actions/public/getRawTransaction
+   * - JSON-RPC Methods: `eth_getRawTransactionByHash`
+   *
+   * @param args - {@link GetRawTransactionParameters}
+   * @returns The raw, serialized transaction. {@link GetRawTransactionReturnType}
+   *
+   * @example
+   * import { createPublicClient, http } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createPublicClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   * })
+   * const rawTransaction = await client.getRawTransaction({
+   *   hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',
+   * })
+   */
+  getRawTransaction: (
+    args: GetRawTransactionParameters,
+  ) => Promise<GetRawTransactionReturnType>
   /**
    * Returns the value from a storage slot at a given address.
    *
@@ -2284,6 +2313,7 @@ export function publicActions<
     estimateMaxPriorityFeePerGas: (args) =>
       estimateMaxPriorityFeePerGas(client, args),
     fillTransaction: (args) => fillTransaction(client, args),
+    getRawTransaction: (args) => getRawTransaction(client, args),
     getStorageAt: (args) => getStorageAt(client, args),
     getTransaction: (args) => getTransaction(client, args),
     getTransactionConfirmations: (args) =>

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.54.2'
+export const version = '2.54.4'

package/index.ts

@@ -237,6 +237,11 @@ export type {
   GetProofParameters,
   GetProofReturnType,
 } from './actions/public/getProof.js'
+export type {
+  GetRawTransactionErrorType,
+  GetRawTransactionParameters,
+  GetRawTransactionReturnType,
+} from './actions/public/getRawTransaction.js'
 export type {
   GetStorageAtErrorType,
   GetStorageAtParameters,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.54.2",
+  "version": "2.54.4",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -234,7 +234,7 @@
     "@scure/bip39": "1.6.0",
     "abitype": "1.2.3",
     "isows": "1.0.7",
-    "ox": "0.14.29",
+    "ox": "0.14.30",
     "ws": "8.21.0"
   },
   "license": "MIT",

package/tempo/Formatters.ts

@@ -121,8 +121,12 @@ export function formatTransactionRequest(
   // `multisig` / `signatures` are client-side only (TIP-1061). They drive
   // sender derivation, owner signing, and final envelope assembly, but are
   // never sent as raw RPC fields — the wire payload is the serialized tx.
+  // `multisigInit` / `multisigSignatureCount` are wire fields: the node
+  // prices multisig gas from them during simulation.
   const {
     multisig: _multisig,
+    multisigInit,
+    multisigSignatureCount,
     signatures: _signatures,
     ...rpcRequest
   } = request
@@ -164,6 +168,10 @@ export function formatTransactionRequest(
 
   return {
     ...rpc,
+    ...(multisigInit ? { multisigInit } : {}),
+    ...(typeof multisigSignatureCount !== 'undefined'
+      ? { multisigSignatureCount }
+      : {}),
     ...(request.capabilities ? { capabilities: request.capabilities } : {}),
     ...(keyData ? { keyData } : {}),
     ...(keyId ? { keyId } : {}),

package/tempo/Transaction.ts

@@ -126,6 +126,16 @@ export type TransactionRequestTempo<
     feeToken?: TempoAddress.Address | bigint | undefined
     keyAuthorization?: KeyAuthorization.Signed<quantity, index> | undefined
     multisig?: MultisigConfig.Config<index> | undefined
+    /** Bootstrap multisig config hint for node-side gas modeling (TIP-1061). Attached automatically when `multisig` is present; the node ignores it for registered senders. */
+    multisigInit?:
+      | {
+          salt: Hex.Hex
+          threshold: number
+          owners: readonly { owner: Address; weight: number }[]
+        }
+      | undefined
+    /** Modeled owner approval count for node-side gas modeling (TIP-1061). */
+    multisigSignatureCount?: number | undefined
     nonceKey?: 'expiring' | quantity | undefined
     signatures?: readonly SignatureEnvelope.Serialized[] | undefined
     validBefore?: index | undefined

package/tempo/chainConfig.ts

@@ -83,8 +83,17 @@ export const chainConfig = {
           ? (request.account as MultisigAccount).config
           : undefined)
       if (multisig) {
-        request.multisig = multisig
-        request.from = MultisigConfig.getAddress(multisig)
+        const config = MultisigConfig.from(multisig)
+        request.multisig = config
+        request.from = MultisigConfig.getAddress(config)
+        request.multisigInit = {
+          salt: config.salt ?? MultisigConfig.zeroSalt,
+          threshold: Number(config.threshold),
+          owners: config.owners.map((owner) => ({
+            owner: owner.owner,
+            weight: Number(owner.weight),
+          })),
+        }
         // A non-multisig `account` (e.g. the client's default) isn't the sender,
         // so drop it: core then fills nonce/gas/fees for the multisig sender via
         // `request.from`. A multisig account *is* the sender — keep it so the

package/types/eip1193.ts

@@ -991,6 +991,17 @@ export type PublicRpcSchema = [
     ]
     ReturnType: Proof
   },
+  /**
+   * @description Returns the raw, serialized transaction specified by hash
+   * @example
+   * provider.request({ method: 'eth_getRawTransactionByHash', params: ['0x...'] })
+   * // => '0x...'
+   */
+  {
+    Method: 'eth_getRawTransactionByHash'
+    Parameters: [hash: Hash]
+    ReturnType: Hex | null
+  },
   /**
    * @description Returns the value from a storage position at an address
    * @link https://eips.ethereum.org/EIPS/eip-1474

package/utils/abi/decodeAbiParameters.ts

@@ -75,7 +75,9 @@ export function decodeAbiParameters<
   const values = []
   for (let i = 0; i < params.length; ++i) {
     const param = params[i]
-    cursor.setPosition(consumed)
+    // Zero-width types (e.g. `uint256[0]`, empty tuples) at the end of the
+    // data consume no bytes, so the cursor may already be exhausted.
+    if (consumed < bytes.length) cursor.setPosition(consumed)
     const [data, consumed_] = decodeParameter(cursor, param, {
       staticPosition: 0,
     })
@@ -146,7 +148,8 @@ function decodeArray(
 ) {
   // If the length of the array is not known in advance (dynamic array),
   // this means we will need to wonder off to the pointer and decode.
-  if (!length) {
+  // Note: zero-length fixed arrays (`T[0]`) are not dynamic.
+  if (length === null) {
     // Dealing with a dynamic type, so get the offset of the array data.
     const offset = bytesToNumber(cursor.readBytes(sizeOfOffset))
 
@@ -172,6 +175,12 @@ function decodeArray(
       })
       consumed += consumed_
       value.push(data)
+      // Charge zero-width elements against the read limit to bound work
+      // on huge lengths of zero-width types (e.g. `uint256[0][]`).
+      if (consumed_ === 0) {
+        cursor.assertReadLimit()
+        cursor._touch()
+      }
     }
 
     // As we have gone wondering, restore to the original position + next slot.
@@ -214,6 +223,12 @@ function decodeArray(
     })
     consumed += consumed_
     value.push(data)
+    // Charge zero-width elements against the read limit to bound work
+    // on huge lengths of zero-width types (e.g. `uint256[0][4294967295]`).
+    if (consumed_ === 0) {
+      cursor.assertReadLimit()
+      cursor._touch()
+    }
   }
   return [value, consumed]
 }

package/utils/abi/encodeAbiParameters.ts

@@ -26,7 +26,7 @@ import { IntegerOutOfRangeError } from '../../errors/encoding.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type { Hex } from '../../types/misc.js'
 import { type IsAddressErrorType, isAddress } from '../address/isAddress.js'
-import { type ConcatErrorType, concat } from '../data/concat.js'
+import { type ConcatHexErrorType, concatHex } from '../data/concat.js'
 import { type PadHexErrorType, padHex } from '../data/pad.js'
 import { type SizeErrorType, size } from '../data/size.js'
 import { type SliceErrorType, slice } from '../data/slice.js'
@@ -101,9 +101,7 @@ export function encodeAbiParameters<
     params: params as readonly AbiParameter[],
     values: values as any,
   })
-  const data = encodeParams(preparedParams)
-  if (data.length === 0) return '0x'
-  return data
+  return encodeParams(preparedParams)
 }
 
 /////////////////////////////////////////////////////////////////
@@ -212,7 +210,8 @@ function encodeParams(preparedParams: PreparedParam[]): Hex {
   }
 
   // 3. Concatenate static and dynamic parts.
-  return concat([...staticParams, ...dynamicParams])
+  // `concatHex` returns `'0x'` for empty input (zero-width parameters).
+  return concatHex([...staticParams, ...dynamicParams])
 }
 
 /////////////////////////////////////////////////////////////////
@@ -229,7 +228,7 @@ function encodeAddress(value: Hex): PreparedParam {
 
 type EncodeArrayErrorType =
   | AbiEncodingArrayLengthMismatchErrorType
-  | ConcatErrorType
+  | ConcatHexErrorType
   | EncodeParamsErrorType
   | InvalidArrayErrorType
   | NumberToHexErrorType
@@ -257,7 +256,9 @@ function encodeArray<const param extends AbiParameter>(
       type: `${param.type}[${length}]`,
     })
 
-  let dynamicChild = false
+  // Zero-length fixed arrays of dynamic types (e.g. `string[0]`) are dynamic
+  // per the ABI spec, even though they have no elements to inspect.
+  let dynamicChild = value.length === 0 && isDynamicType(param)
   const preparedParams: PreparedParam[] = []
   for (let i = 0; i < value.length; i++) {
     const preparedParam = prepareParam({ param, value: value[i] })
@@ -271,20 +272,20 @@ function encodeArray<const param extends AbiParameter>(
       const length = numberToHex(preparedParams.length, { size: 32 })
       return {
         dynamic: true,
-        encoded: preparedParams.length > 0 ? concat([length, data]) : length,
+        encoded: concatHex([length, data]),
       }
     }
     if (dynamicChild) return { dynamic: true, encoded: data }
   }
   return {
     dynamic: false,
-    encoded: concat(preparedParams.map(({ encoded }) => encoded)),
+    encoded: concatHex(preparedParams.map(({ encoded }) => encoded)),
   }
 }
 
 type EncodeBytesErrorType =
   | AbiEncodingBytesSizeMismatchErrorType
-  | ConcatErrorType
+  | ConcatHexErrorType
   | PadHexErrorType
   | NumberToHexErrorType
   | SizeErrorType
@@ -307,7 +308,10 @@ function encodeBytes<const param extends AbiParameter>(
       })
     return {
       dynamic: true,
-      encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_]),
+      encoded: concatHex([
+        padHex(numberToHex(bytesSize, { size: 32 })),
+        value_,
+      ]),
     }
   }
   if (bytesSize !== Number.parseInt(paramSize, 10))
@@ -356,7 +360,7 @@ function encodeNumber(
 }
 
 type EncodeStringErrorType =
-  | ConcatErrorType
+  | ConcatHexErrorType
   | NumberToHexErrorType
   | PadHexErrorType
   | SizeErrorType
@@ -377,7 +381,7 @@ function encodeString(value: string): PreparedParam {
   }
   return {
     dynamic: true,
-    encoded: concat([
+    encoded: concatHex([
       padHex(numberToHex(size(hexValue), { size: 32 })),
       ...parts,
     ]),
@@ -385,7 +389,7 @@ function encodeString(value: string): PreparedParam {
 }
 
 type EncodeTupleErrorType =
-  | ConcatErrorType
+  | ConcatHexErrorType
   | EncodeParamsErrorType
   // TODO: Add back once circular type reference is resolved
   // | PrepareParamErrorType
@@ -413,7 +417,7 @@ function encodeTuple<
     dynamic,
     encoded: dynamic
       ? encodeParams(preparedParams)
-      : concat(preparedParams.map(({ encoded }) => encoded)),
+      : concatHex(preparedParams.map(({ encoded }) => encoded)),
   }
 }
 
@@ -428,3 +432,16 @@ export function getArrayComponents(
       [matches[2] ? Number(matches[2]) : null, matches[1]]
     : undefined
 }
+
+function isDynamicType(param: AbiParameter): boolean {
+  const { type } = param
+  if (type === 'string') return true
+  if (type === 'bytes') return true
+  if (type.endsWith('[]')) return true
+  if (type === 'tuple')
+    return (param as TupleAbiParameter).components.some(isDynamicType)
+  const arrayComponents = getArrayComponents(type)
+  if (arrayComponents)
+    return isDynamicType({ ...param, type: arrayComponents[1] })
+  return false
+}