viem 0.0.0-w-20230802141753 → 0.0.0-w-20230810183250

package/src/chains/celo/types.ts

@@ -0,0 +1,111 @@
+import type { Address } from 'abitype'
+
+import type { Block, BlockTag } from '../../types/block.js'
+import type { Hex } from '../../types/misc.js'
+import type {
+  RpcBlock,
+  RpcTransaction,
+  RpcTransactionReceipt,
+  RpcTransactionRequest,
+} from '../../types/rpc.js'
+import type {
+  Transaction,
+  TransactionReceipt,
+  TransactionRequest,
+} from '../../types/transaction.js'
+import type { NeverBy } from '../../types/utils.js'
+import type { OptimismRpcTransaction } from '../optimism/types.js'
+
+type CeloBlockExclude =
+  | 'difficulty'
+  | 'gasLimit'
+  | 'mixHash'
+  | 'nonce'
+  | 'uncles'
+
+export type CeloBlockOverrides = {
+  randomness: {
+    committed: Hex
+    revealed: Hex
+  }
+}
+export type CeloBlock<
+  TIncludeTransactions extends boolean = boolean,
+  TBlockTag extends BlockTag = BlockTag,
+> = NeverBy<
+  Block<
+    bigint,
+    TIncludeTransactions,
+    TBlockTag,
+    CeloTransaction<TBlockTag extends 'pending' ? true : false>
+  >,
+  CeloBlockExclude
+> &
+  CeloBlockOverrides
+
+export type CeloRpcBlockOverrides = {
+  randomness: {
+    committed: Hex
+    revealed: Hex
+  }
+}
+export type CeloRpcBlock<
+  TBlockTag extends BlockTag = BlockTag,
+  TIncludeTransactions extends boolean = boolean,
+> = NeverBy<
+  RpcBlock<
+    TBlockTag,
+    TIncludeTransactions,
+    OptimismRpcTransaction<TBlockTag extends 'pending' ? true : false>
+  >,
+  CeloBlockExclude
+> &
+  CeloRpcBlockOverrides
+
+export type CeloRpcTransactionOverrides = {
+  feeCurrency: Address | null
+  gatewayFee: Hex | null
+  gatewayFeeRecipient: Address | null
+}
+export type CeloRpcTransaction<TPending extends boolean = boolean> =
+  RpcTransaction<TPending> & CeloRpcTransactionOverrides
+
+export type CeloRpcTransactionReceiptOverrides = {
+  feeCurrency: Address | null
+  gatewayFee: Hex | null
+  gatewayFeeRecipient: Address | null
+}
+export type CeloRpcTransactionReceipt = RpcTransactionReceipt &
+  CeloRpcTransactionReceiptOverrides
+
+export type CeloRpcTransactionRequestOverrides = {
+  feeCurrency?: Address
+  gatewayFee?: Hex
+  gatewayFeeRecipient?: Address
+}
+export type CeloRpcTransactionRequest = RpcTransactionRequest &
+  CeloRpcTransactionRequestOverrides
+
+export type CeloTransactionOverrides = {
+  feeCurrency: Address | null
+  gatewayFee: bigint | null
+  gatewayFeeRecipient: Address | null
+}
+export type CeloTransaction<TPending extends boolean = boolean> =
+  Transaction<TPending> & CeloTransactionOverrides
+
+export type CeloTransactionReceiptOverrides = {
+  feeCurrency: Address | null
+  gatewayFee: bigint | null
+  gatewayFeeRecipient: Address | null
+}
+export type CeloTransactionReceipt = TransactionReceipt &
+  CeloTransactionReceiptOverrides
+
+export type CeloTransactionRequestOverrides = {
+  feeCurrency?: Address
+  gatewayFee?: bigint
+  gatewayFeeRecipient?: Address
+}
+export type CeloTransactionRequest = TransactionRequest &
+  CeloTransactionRequestOverrides

package/src/chains/index.ts

@@ -1,9 +1,10 @@
 import * as chains from '@wagmi/chains'
 
 import { defineChain } from '../utils/chain.js'
-import { formattersCelo } from './formatters/celo.js'
-import { formattersOptimism } from './formatters/optimism.js'
-import { serializersCelo } from './serializers/celo.js'
+import { formattersCelo } from './celo/formatters.js'
+import { serializersCelo } from './celo/serializers.js'
+import { feesOptimism } from './optimism/fees.js'
+import { formattersOptimism } from './optimism/formatters.js'
 
 export const arbitrum = /*#__PURE__*/ defineChain(chains.arbitrum)
 export const arbitrumGoerli = /*#__PURE__*/ defineChain(chains.arbitrumGoerli)
@@ -11,8 +12,14 @@ export const aurora = /*#__PURE__*/ defineChain(chains.aurora)
 export const auroraTestnet = /*#__PURE__*/ defineChain(chains.auroraTestnet)
 export const avalanche = /*#__PURE__*/ defineChain(chains.avalanche)
 export const avalancheFuji = /*#__PURE__*/ defineChain(chains.avalancheFuji)
-export const base = /*#__PURE__*/ defineChain(chains.base)
-export const baseGoerli = /*#__PURE__*/ defineChain(chains.baseGoerli)
+export const base = /*#__PURE__*/ defineChain(chains.base, {
+  fees: feesOptimism,
+  formatters: formattersOptimism,
+})
+export const baseGoerli = /*#__PURE__*/ defineChain(chains.baseGoerli, {
+  fees: feesOptimism,
+  formatters: formattersOptimism,
+})
 export const boba = /*#__PURE__*/ defineChain(chains.boba)
 export const bronos = /*#__PURE__*/ defineChain(chains.bronos)
 export const bronosTestnet = /*#__PURE__*/ defineChain(chains.bronosTestnet)
@@ -72,9 +79,11 @@ export const moonriver = /*#__PURE__*/ defineChain(chains.moonriver)
 export const nexi = /*#__PURE__*/ defineChain(chains.nexi)
 export const okc = /*#__PURE__*/ defineChain(chains.okc)
 export const optimism = /*#__PURE__*/ defineChain(chains.optimism, {
+  fees: feesOptimism,
   formatters: formattersOptimism,
 })
 export const optimismGoerli = /*#__PURE__*/ defineChain(chains.optimismGoerli, {
+  fees: feesOptimism,
   formatters: formattersOptimism,
 })
 export const polygon = /*#__PURE__*/ defineChain(chains.polygon)
@@ -136,7 +145,13 @@ export const xdcTestnet = /*#__PURE__*/ defineChain(chains.xdcTestnet)
 export const zhejiang = /*#__PURE__*/ defineChain(chains.zhejiang)
 export const zkSync = /*#__PURE__*/ defineChain(chains.zkSync)
 export const zkSyncTestnet = /*#__PURE__*/ defineChain(chains.zkSyncTestnet)
-export const zora = /*#__PURE__*/ defineChain(chains.zora)
-export const zoraTestnet = /*#__PURE__*/ defineChain(chains.zoraTestnet)
+export const zora = /*#__PURE__*/ defineChain(chains.zora, {
+  fees: feesOptimism,
+  formatters: formattersOptimism,
+})
+export const zoraTestnet = /*#__PURE__*/ defineChain(chains.zoraTestnet, {
+  fees: feesOptimism,
+  formatters: formattersOptimism,
+})
 
 export type { Chain } from '../types/chain.js'

package/src/chains/optimism/fees.ts

@@ -0,0 +1,5 @@
+import type { ChainFees } from '../../types/chain.js'
+
+export const feesOptimism = {
+  defaultPriorityFee: 1_000_000n, // 0.001 gwei
+} as const satisfies ChainFees

package/src/chains/optimism/formatters.ts

@@ -0,0 +1,74 @@
+import { type ChainFormatters } from '../../types/chain.js'
+import type { Hash } from '../../types/misc.js'
+import { type RpcTransaction } from '../../types/rpc.js'
+import { hexToBigInt } from '../../utils/encoding/fromHex.js'
+import { defineBlock } from '../../utils/formatters/block.js'
+import {
+  defineTransaction,
+  formatTransaction,
+} from '../../utils/formatters/transaction.js'
+import { defineTransactionReceipt } from '../../utils/formatters/transactionReceipt.js'
+import type {
+  OptimismBlockOverrides,
+  OptimismRpcBlockOverrides,
+  OptimismRpcTransaction,
+  OptimismRpcTransactionReceiptOverrides,
+  OptimismTransaction,
+  OptimismTransactionReceiptOverrides,
+} from './types.js'
+
+export const formattersOptimism = {
+  block: /*#__PURE__*/ defineBlock({
+    format(
+      args: OptimismRpcBlockOverrides & {
+        transactions: Hash[] | OptimismRpcTransaction[]
+      },
+    ): OptimismBlockOverrides & {
+      transactions: Hash[] | OptimismTransaction[]
+    } {
+      const transactions = args.transactions?.map((transaction) => {
+        if (typeof transaction === 'string') return transaction
+        const formatted = formatTransaction(
+          transaction as RpcTransaction,
+        ) as OptimismTransaction
+        if (formatted.typeHex === '0x7e') {
+          formatted.isSystemTx = transaction.isSystemTx
+          formatted.mint = transaction.mint
+            ? hexToBigInt(transaction.mint)
+            : undefined
+          formatted.sourceHash = transaction.sourceHash
+          formatted.type = 'deposit'
+        }
+        return formatted
+      }) as Hash[] | OptimismTransaction[]
+      return {
+        transactions,
+        stateRoot: args.stateRoot,
+      }
+    },
+  }),
+  transaction: /*#__PURE__*/ defineTransaction({
+    format(args: OptimismRpcTransaction): OptimismTransaction {
+      const transaction = {} as OptimismTransaction
+      if (args.type === '0x7e') {
+        transaction.isSystemTx = args.isSystemTx
+        transaction.mint = args.mint ? hexToBigInt(args.mint) : undefined
+        transaction.sourceHash = args.sourceHash
+        transaction.type = 'deposit'
+      }
+      return transaction
+    },
+  }),
+  transactionReceipt: /*#__PURE__*/ defineTransactionReceipt({
+    format(
+      args: OptimismRpcTransactionReceiptOverrides,
+    ): OptimismTransactionReceiptOverrides {
+      return {
+        l1GasPrice: args.l1GasPrice ? hexToBigInt(args.l1GasPrice) : null,
+        l1GasUsed: args.l1GasUsed ? hexToBigInt(args.l1GasUsed) : null,
+        l1Fee: args.l1Fee ? hexToBigInt(args.l1Fee) : null,
+        l1FeeScalar: args.l1FeeScalar ? Number(args.l1FeeScalar) : null,
+      }
+    },
+  }),
+} as const satisfies ChainFormatters

package/src/chains/optimism/types.ts

@@ -0,0 +1,102 @@
+import type { Block, BlockTag } from '../../types/block.js'
+import type { FeeValuesEIP1559 } from '../../types/fee.js'
+import type { Hash, Hex } from '../../types/misc.js'
+import type {
+  Index,
+  Quantity,
+  RpcBlock,
+  RpcTransaction as RpcTransaction_,
+  RpcTransactionReceipt,
+} from '../../types/rpc.js'
+import type {
+  Transaction as Transaction_,
+  TransactionBase,
+  TransactionReceipt,
+} from '../../types/transaction.js'
+
+export type OptimismBlockOverrides = {
+  stateRoot: Hash
+}
+export type OptimismBlock<
+  TIncludeTransactions extends boolean = boolean,
+  TBlockTag extends BlockTag = BlockTag,
+> = Block<
+  bigint,
+  TIncludeTransactions,
+  TBlockTag,
+  OptimismTransaction<TBlockTag extends 'pending' ? true : false>
+> &
+  OptimismBlockOverrides
+
+export type OptimismRpcBlockOverrides = {
+  stateRoot: Hash
+}
+export type OptimismRpcBlock<
+  TBlockTag extends BlockTag = BlockTag,
+  TIncludeTransactions extends boolean = boolean,
+> = RpcBlock<
+  TBlockTag,
+  TIncludeTransactions,
+  OptimismRpcTransaction<TBlockTag extends 'pending' ? true : false>
+> &
+  OptimismRpcBlockOverrides
+
+type RpcTransaction<TPending extends boolean = boolean> =
+  RpcTransaction_<TPending> & {
+    isSystemTx?: undefined
+    mint?: undefined
+    sourceHash?: undefined
+  }
+
+export type OptimismRpcDepositTransaction<TPending extends boolean = boolean> =
+  Omit<TransactionBase<Quantity, Index, TPending>, 'typeHex'> &
+    FeeValuesEIP1559<Quantity> & {
+      isSystemTx?: boolean
+      mint?: Hex
+      sourceHash: Hex
+      type: '0x7e'
+    }
+export type OptimismRpcTransaction<TPending extends boolean = boolean> =
+  | RpcTransaction<TPending>
+  | OptimismRpcDepositTransaction<TPending>
+
+export type OptimismRpcTransactionReceiptOverrides = {
+  l1GasPrice: Hex | null
+  l1GasUsed: Hex | null
+  l1Fee: Hex | null
+  l1FeeScalar: `${number}` | null
+}
+export type OptimismRpcTransactionReceipt = RpcTransactionReceipt &
+  OptimismRpcTransactionReceiptOverrides
+
+type Transaction<TPending extends boolean = boolean> = Transaction_<
+  bigint,
+  number,
+  TPending
+> & {
+  isSystemTx?: undefined
+  mint?: undefined
+  sourceHash?: undefined
+}
+
+export type OptimismDepositTransaction<TPending extends boolean = boolean> =
+  TransactionBase<bigint, number, TPending> &
+    FeeValuesEIP1559 & {
+      isSystemTx?: boolean
+      mint?: bigint
+      sourceHash: Hex
+      type: 'deposit'
+    }
+
+export type OptimismTransaction<TPending extends boolean = boolean> =
+  | Transaction<TPending>
+  | OptimismDepositTransaction<TPending>
+
+export type OptimismTransactionReceiptOverrides = {
+  l1GasPrice: bigint | null
+  l1GasUsed: bigint | null
+  l1Fee: bigint | null
+  l1FeeScalar: number | null
+}
+export type OptimismTransactionReceipt = TransactionReceipt &
+  OptimismTransactionReceiptOverrides

package/src/chains/utils.ts

@@ -0,0 +1,41 @@
+export { formattersCelo } from './celo/formatters.js'
+export {
+  type CeloTransactionSerializable,
+  type TransactionSerializableCIP42,
+  serializeTransactionCelo,
+  serializersCelo,
+} from './celo/serializers.js'
+export type {
+  CeloBlock,
+  CeloBlockOverrides,
+  CeloRpcBlock,
+  CeloRpcBlockOverrides,
+  CeloRpcTransaction,
+  CeloRpcTransactionOverrides,
+  CeloRpcTransactionReceipt,
+  CeloRpcTransactionReceiptOverrides,
+  CeloRpcTransactionRequest,
+  CeloRpcTransactionRequestOverrides,
+  CeloTransaction,
+  CeloTransactionOverrides,
+  CeloTransactionReceipt,
+  CeloTransactionReceiptOverrides,
+  CeloTransactionRequest,
+  CeloTransactionRequestOverrides,
+} from './celo/types.js'
+
+export { formattersOptimism } from './optimism/formatters.js'
+export type {
+  OptimismBlock,
+  OptimismBlockOverrides,
+  OptimismDepositTransaction,
+  OptimismRpcBlock,
+  OptimismRpcBlockOverrides,
+  OptimismRpcDepositTransaction,
+  OptimismRpcTransaction,
+  OptimismRpcTransactionReceipt,
+  OptimismRpcTransactionReceiptOverrides,
+  OptimismTransaction,
+  OptimismTransactionReceipt,
+  OptimismTransactionReceiptOverrides,
+} from './optimism/types.js'

package/src/clients/decorators/public.ts

@@ -1206,9 +1206,9 @@ export type PublicActions<
    * })
    */
   simulateContract: <
-    TAbi extends Abi | readonly unknown[] = Abi,
-    TFunctionName extends string = any,
-    TChainOverride extends Chain | undefined = undefined,
+    TAbi extends Abi | readonly unknown[],
+    TFunctionName extends string,
+    TChainOverride extends Chain | undefined,
   >(
     args: SimulateContractParameters<
       TAbi,

package/src/errors/node.ts

@@ -88,7 +88,8 @@ export class NonceTooHighError extends BaseError {
 }
 
 export class NonceTooLowError extends BaseError {
-  static nodeMessage = /nonce too low|transaction already imported/
+  static nodeMessage =
+    /nonce too low|transaction already imported|already known/
   override name = 'NonceTooLowError'
   constructor({ cause, nonce }: { cause?: BaseError; nonce?: number } = {}) {
     super(

package/src/errors/utils.ts

@@ -1,6 +1,6 @@
 import type { Address } from 'abitype'
 
-import { version } from './version.js'
+import { version } from '../version.js'
 
 export const getContractAddress = (address: Address) => address
 export const getUrl = (url: string) => url

package/src/index.ts

@@ -577,7 +577,30 @@ export type {
   Signature,
   SignableMessage,
 } from './types/misc.js'
-export type { Chain } from './types/chain.js'
+export type {
+  Chain,
+  ChainContract,
+  ChainFees,
+  ChainFormatter,
+  /** @deprecated use `ChainFormatter` instead. */
+  ChainFormatter as Formatter,
+  ChainFormatters,
+  /** @deprecated use `ChainFormatters` instead. */
+  ChainFormatters as Formatters,
+  ChainSerializers,
+  /** @deprecated use `ChainSerializers` instead. */
+  ChainSerializers as Serializers,
+  ExtractChainFormatterExclude,
+  /** @deprecated use `ExtractChainFormatterExclude` instead. */
+  ExtractChainFormatterExclude as ExtractFormatterExclude,
+  ExtractChainFormatterParameters,
+  /** @deprecated use `ExtractChainFormatterParameters` instead. */
+  ExtractChainFormatterParameters as ExtractFormatterParameters,
+  ExtractChainFormatterReturnType,
+  /** @deprecated use `ExtractChainFormatterReturnType` instead. */
+  ExtractChainFormatterReturnType as ExtractFormatterReturnType,
+  GetChain,
+} from './types/chain.js'
 export type {
   AddEthereumChainParameter,
   EIP1193Events,
@@ -605,13 +628,6 @@ export type {
   FeeValuesLegacy,
 } from './types/fee.js'
 export type { Filter } from './types/filter.js'
-export type {
-  Formatter,
-  Formatters,
-  ExtractFormatterParameters,
-  ExtractFormatterReturnType,
-} from './types/formatter.js'
-export type { Serializers } from './types/serializer.js'
 export type { TypedDataDefinition } from './types/typedData.js'
 export type { GetTransportConfig } from './types/transport.js'
 export type { HDKey } from '@scure/bip32'
@@ -841,3 +857,4 @@ export { slice, sliceBytes, sliceHex } from './utils/data/slice.js'
 export { stringify } from './utils/stringify.js'
 export { trim } from './utils/data/trim.js'
 export { validateTypedData } from './utils/typedData.js'
+export { version } from './version.js'

package/src/types/chain.ts

@@ -1,17 +1,24 @@
 import type { Address } from 'abitype'
 
-import type { Formatters } from './formatter.js'
-import type { Serializers } from './serializer.js'
-import type { IsUndefined } from './utils.js'
+import type { FormattedBlock } from '../utils/formatters/block.js'
+import type { PrepareRequestParameters } from '../utils/transaction/prepareRequest.js'
+import type { SerializeTransactionFn } from '../utils/transaction/serializeTransaction.js'
+import type {
+  TransactionSerializable,
+  TransactionSerializableGeneric,
+} from './transaction.js'
+import type { IsUndefined, Prettify } from './utils.js'
 
 export type Chain<
-  formatters extends Formatters | undefined = Formatters | undefined,
-  serializers extends Serializers<formatters> | undefined =
-    | Serializers<formatters>
-    | undefined,
-> = import('@wagmi/chains').Chain & {
+  formatters extends ChainFormatters | undefined = ChainFormatters | undefined,
+> = import('@wagmi/chains').Chain & ChainConfig<formatters>
+
+export type ChainConfig<
+  formatters extends ChainFormatters | undefined = ChainFormatters | undefined,
+> = {
   formatters?: formatters | undefined
-  serializers?: serializers | undefined
+  serializers?: ChainSerializers<formatters> | undefined
+  fees?: ChainFees<formatters> | undefined
 }
 
 export type ChainContract = {
@@ -19,9 +26,79 @@ export type ChainContract = {
   blockCreated?: number
 }
 
+export type ChainFees<
+  formatters extends ChainFormatters | undefined = ChainFormatters | undefined,
+> = {
+  defaultPriorityFee:
+    | bigint
+    | ((args: {
+        block: Prettify<FormattedBlock<{ formatters: formatters }>>
+        request: PrepareRequestParameters<
+          Omit<Chain, 'formatters'> & { formatters: formatters }
+        >
+      }) => Promise<bigint> | bigint)
+}
+
+export type ChainFormatters = {
+  block?: ChainFormatter<'block'>
+  transaction?: ChainFormatter<'transaction'>
+  transactionReceipt?: ChainFormatter<'transactionReceipt'>
+  transactionRequest?: ChainFormatter<'transactionRequest'>
+}
+
+export type ChainFormatter<type extends string = string> = {
+  format: (args: any) => any
+  type: type
+}
+
+export type ChainSerializers<
+  formatters extends ChainFormatters | undefined = undefined,
+> = {
+  transaction?: SerializeTransactionFn<
+    formatters extends ChainFormatters
+      ? formatters['transactionRequest'] extends ChainFormatter
+        ? TransactionSerializableGeneric &
+            Parameters<formatters['transactionRequest']['format']>[0]
+        : TransactionSerializable
+      : TransactionSerializable
+  >
+}
+
+/////////////////////////////////////////////////////////////////////
+// Utils
+
+export type ExtractChainFormatterExclude<
+  chain extends { formatters?: Chain['formatters'] } | undefined,
+  type extends keyof ChainFormatters,
+> = chain extends { formatters?: infer _Formatters extends ChainFormatters }
+  ? _Formatters[type] extends { exclude: infer Exclude }
+    ? Extract<Exclude, string[]>[number]
+    : ''
+  : ''
+
+export type ExtractChainFormatterParameters<
+  chain extends { formatters?: Chain['formatters'] } | undefined,
+  type extends keyof ChainFormatters,
+  fallback,
+> = chain extends { formatters?: infer _Formatters extends ChainFormatters }
+  ? _Formatters[type] extends ChainFormatter
+    ? Parameters<_Formatters[type]['format']>[0]
+    : fallback
+  : fallback
+
+export type ExtractChainFormatterReturnType<
+  chain extends { formatters?: Chain['formatters'] } | undefined,
+  type extends keyof ChainFormatters,
+  fallback,
+> = chain extends { formatters?: infer _Formatters extends ChainFormatters }
+  ? _Formatters[type] extends ChainFormatter
+    ? ReturnType<_Formatters[type]['format']>
+    : fallback
+  : fallback
+
 export type GetChain<
-  TChain extends Chain | undefined,
-  TChainOverride extends Chain | undefined = undefined,
-> = IsUndefined<TChain> extends true
-  ? { chain: TChainOverride | null }
-  : { chain?: TChainOverride | null }
+  chain extends Chain | undefined,
+  chainOverride extends Chain | undefined = undefined,
+> = IsUndefined<chain> extends true
+  ? { chain: chainOverride | null }
+  : { chain?: chainOverride | null }

package/src/types/rpc.ts

@@ -26,12 +26,8 @@ export type TransactionType = '0x0' | '0x1' | '0x2' | (string & {})
 export type RpcBlock<
   TBlockTag extends BlockTag = BlockTag,
   TIncludeTransactions extends boolean = boolean,
-> = Block<
-  Quantity,
-  TIncludeTransactions,
-  TBlockTag,
-  RpcTransaction<TBlockTag extends 'pending' ? true : false>
->
+  TTransaction = RpcTransaction<TBlockTag extends 'pending' ? true : false>,
+> = Block<Quantity, TIncludeTransactions, TBlockTag, TTransaction>
 export type RpcBlockNumber = BlockNumber<Quantity>
 export type RpcBlockIdentifier = BlockIdentifier<Quantity>
 export type RpcUncle = Uncle<Quantity>

package/src/types/utils.ts

@@ -155,6 +155,17 @@ export type OptionalNullable<T> = {
   [K in keyof T as T[K] extends NonNullable<unknown> ? never : K]?: T[K]
 }
 
+/**
+ * @description Make properties K of type T never.
+ *
+ * @example
+ * NeverBy<{ a: string, b: boolean, c: number }, 'a' | 'c'>
+ * => { a: never, b: boolean, c: never }
+ */
+export type NeverBy<T, K extends keyof T> = {
+  [U in keyof T]: U extends K ? never : T[U]
+}
+
 /**
  * @description Constructs a type by excluding `undefined` from `T`.
  *

package/src/utils/abi/encodeAbiParameters.ts

@@ -194,28 +194,25 @@ function encodeBytes<TParam extends AbiParameter>(
   value: Hex,
   { param }: { param: TParam },
 ): PreparedParam {
-  const [_, size_] = param.type.split('bytes')
-  if (!size_) {
-    const partsLength = Math.ceil(size(value) / 32)
-    const parts: Hex[] = []
-    for (let i = 0; i < partsLength; i++) {
-      parts.push(
-        padHex(slice(value, i * 32, (i + 1) * 32), {
-          dir: 'right',
-        }),
-      )
-    }
+  const [, paramSize] = param.type.split('bytes')
+  const bytesSize = size(value)
+  if (!paramSize) {
+    let value_ = value
+    // If the size is not divisible by 32 bytes, pad the end
+    // with empty bytes to the ceiling 32 bytes.
+    if (bytesSize % 32 !== 0)
+      value_ = padHex(value_, {
+        dir: 'right',
+        size: Math.ceil((value.length - 2) / 2 / 32) * 32,
+      })
     return {
       dynamic: true,
-      encoded: concat([
-        padHex(numberToHex(size(value), { size: 32 })),
-        ...parts,
-      ]),
+      encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_]),
     }
   }
-  if (size(value) !== parseInt(size_))
+  if (bytesSize !== parseInt(paramSize))
     throw new AbiEncodingBytesSizeMismatchError({
-      expectedSize: parseInt(size_),
+      expectedSize: parseInt(paramSize),
       value,
     })
   return { dynamic: false, encoded: padHex(value, { dir: 'right' }) }