viem 1.6.5 → 1.6.7

package/src/utils/formatters/block.ts

@@ -1,13 +1,14 @@
 import type { Block, BlockTag } from '../../types/block.js'
-import type { Hash } from '../../types/misc.js'
-import type { RpcBlock } from '../../types/rpc.js'
-import type { Prettify } from '../../types/utils.js'
-import type { Chain } from '@viem/chains'
+import type { Chain } from '../../types/chain.js'
 import type {
   ExtractChainFormatterExclude,
   ExtractChainFormatterReturnType,
-} from '@viem/chains'
+} 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 { defineFormatter } from './formatter.js'
 import { type FormattedTransaction, formatTransaction } from './transaction.js'
 
 type BlockPendingDependencies = 'hash' | 'logsBloom' | 'nonce' | 'number'
@@ -61,3 +62,5 @@ export function formatBlock(block: Partial<RpcBlock>) {
       : null,
   } as Block
 }
+
+export const defineBlock = /*#__PURE__*/ defineFormatter('block', formatBlock)

package/src/utils/formatters/extract.ts

@@ -1,4 +1,4 @@
-import type { ChainFormatter } from '@viem/chains'
+import type { ChainFormatter } from '../../types/chain.js'
 
 /**
  * @description Picks out the keys from `value` that exist in the formatter.

package/src/utils/formatters/formatter.ts

@@ -0,0 +1,37 @@
+import type { Assign, Prettify } from '../../types/utils.js'
+
+export function defineFormatter<TType extends string, TParameters, TReturnType>(
+  type: TType,
+  format: (_: TParameters) => TReturnType,
+) {
+  return <
+    TOverrideParameters,
+    TOverrideReturnType,
+    TExclude extends (keyof TParameters)[] = [],
+  >({
+    exclude,
+    format: overrides,
+  }: {
+    exclude?: TExclude
+    format: (_: TOverrideParameters) => TOverrideReturnType
+  }) => {
+    return {
+      exclude,
+      format: (args: Assign<TParameters, TOverrideParameters>) => {
+        const formatted = format(args as any)
+        if (exclude) {
+          for (const key of exclude) {
+            delete (formatted as any)[key]
+          }
+        }
+        return {
+          ...formatted,
+          ...overrides(args),
+        } as Prettify<Assign<TReturnType, TOverrideReturnType>> & {
+          [K in TExclude[number]]: never
+        }
+      },
+      type,
+    }
+  }
+}

package/src/utils/formatters/transaction.ts

@@ -1,13 +1,14 @@
 import type { BlockTag } from '../../types/block.js'
+import type { Chain } from '../../types/chain.js'
+import type {
+  ExtractChainFormatterExclude,
+  ExtractChainFormatterReturnType,
+} from '../../types/chain.js'
 import type { RpcTransaction } from '../../types/rpc.js'
 import type { Transaction } from '../../types/transaction.js'
 import type { UnionOmit } from '../../types/utils.js'
 import { hexToNumber } from '../encoding/fromHex.js'
-import type { Chain } from '@viem/chains'
-import type {
-  ExtractChainFormatterExclude,
-  ExtractChainFormatterReturnType,
-} from '@viem/chains'
+import { defineFormatter } from './formatter.js'
 
 type TransactionPendingDependencies =
   | 'blockHash'
@@ -77,3 +78,8 @@ export function formatTransaction(transaction: Partial<RpcTransaction>) {
   }
   return transaction_ as Transaction
 }
+
+export const defineTransaction = /*#__PURE__*/ defineFormatter(
+  'transaction',
+  formatTransaction,
+)

package/src/utils/formatters/transactionReceipt.ts

@@ -1,8 +1,12 @@
+import type {
+  Chain,
+  ExtractChainFormatterReturnType,
+} from '../../types/chain.js'
 import type { RpcTransactionReceipt } from '../../types/rpc.js'
 import type { TransactionReceipt } from '../../types/transaction.js'
 import { hexToNumber } from '../encoding/fromHex.js'
-import type { Chain, ExtractChainFormatterReturnType } from '@viem/chains'
 
+import { defineFormatter } from './formatter.js'
 import { formatLog } from './log.js'
 import { transactionType } from './transaction.js'
 
@@ -56,3 +60,8 @@ export function formatTransactionReceipt(
       : null,
   } as TransactionReceipt
 }
+
+export const defineTransactionReceipt = /*#__PURE__*/ defineFormatter(
+  'transactionReceipt',
+  formatTransactionReceipt,
+)

package/src/utils/formatters/transactionRequest.ts

@@ -1,7 +1,11 @@
+import type {
+  Chain,
+  ExtractChainFormatterParameters,
+} from '../../types/chain.js'
 import type { RpcTransactionRequest } from '../../types/rpc.js'
 import type { TransactionRequest } from '../../types/transaction.js'
 import { numberToHex } from '../encoding/toHex.js'
-import type { Chain, ExtractChainFormatterParameters } from '@viem/chains'
+import { defineFormatter } from './formatter.js'
 
 export type FormattedTransactionRequest<
   TChain extends Chain | undefined = Chain | undefined,
@@ -42,3 +46,8 @@ export function formatTransactionRequest(
         : undefined,
   } as RpcTransactionRequest
 }
+
+export const defineTransactionRequest = /*#__PURE__*/ defineFormatter(
+  'transactionRequest',
+  formatTransactionRequest,
+)

package/src/utils/index.ts

@@ -119,17 +119,23 @@ export { slice, sliceBytes, sliceHex } from './data/slice.js'
 export { trim } from './data/trim.js'
 export {
   type FormattedBlock,
+  defineBlock,
   formatBlock,
 } from './formatters/block.js'
 export {
   type FormattedTransaction,
+  defineTransaction,
   formatTransaction,
   transactionType,
 } from './formatters/transaction.js'
 export { formatLog } from './formatters/log.js'
-export { type FormattedTransactionReceipt } from './formatters/transactionReceipt.js'
+export {
+  type FormattedTransactionReceipt,
+  defineTransactionReceipt,
+} from './formatters/transactionReceipt.js'
 export {
   type FormattedTransactionRequest,
+  defineTransactionRequest,
   formatTransactionRequest,
 } from './formatters/transactionRequest.js'
 export { extract } from './formatters/extract.js'
@@ -168,6 +174,7 @@ export { getCallError } from './errors/getCallError.js'
 export { getContractError } from './errors/getContractError.js'
 export { getEstimateGasError } from './errors/getEstimateGasError.js'
 export { getTransactionError } from './errors/getTransactionError.js'
+export { defineFormatter } from './formatters/formatter.js'
 export { getEventSelector } from './hash/getEventSelector.js'
 export { getFunctionSelector } from './hash/getFunctionSelector.js'
 export { isHash } from './hash/isHash.js'

package/src/utils/transaction/assertRequest.ts

@@ -3,8 +3,8 @@ import type { SendTransactionParameters } from '../../actions/wallet/sendTransac
 import { InvalidAddressError } from '../../errors/address.js'
 import { FeeCapTooHighError, TipAboveFeeCapError } from '../../errors/node.js'
 import { FeeConflictError } from '../../errors/transaction.js'
+import type { Chain } from '../../types/chain.js'
 import { isAddress } from '../address/isAddress.js'
-import type { Chain } from '@viem/chains'
 
 export type AssertRequestParameters = Partial<SendTransactionParameters<Chain>>
 

package/src/utils/transaction/prepareRequest.ts

@@ -2,27 +2,23 @@ import type { Address } from 'abitype'
 
 import type { Account } from '../../accounts/types.js'
 import { parseAccount } from '../../accounts/utils/parseAccount.js'
-import { internal_estimateFeesPerGas } from '../../actions/public/estimateFeesPerGas.js'
 import {
   type EstimateGasParameters,
   estimateGas,
 } from '../../actions/public/estimateGas.js'
 import { getBlock } from '../../actions/public/getBlock.js'
+import { getGasPrice } from '../../actions/public/getGasPrice.js'
 import { getTransactionCount } from '../../actions/public/getTransactionCount.js'
 import type { SendTransactionParameters } from '../../actions/wallet/sendTransaction.js'
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import { AccountNotFoundError } from '../../errors/account.js'
-import {
-  Eip1559FeesNotSupportedError,
-  MaxFeePerGasTooLowError,
-} from '../../errors/fee.js'
+import { BaseError } from '../../errors/base.js'
 import type { GetAccountParameter } from '../../types/account.js'
-import type { GetChain } from '../../types/chain.js'
+import type { Chain, GetChain } from '../../types/chain.js'
 import type { UnionOmit } from '../../types/utils.js'
-import { type FormattedTransactionRequest } from '../index.js'
+import type { FormattedTransactionRequest } from '../index.js'
 import { type AssertRequestParameters, assertRequest } from './assertRequest.js'
-import type { Chain } from '@viem/chains'
 
 export type PrepareRequestParameters<
   TChain extends Chain | undefined = Chain | undefined,
@@ -64,7 +60,15 @@ export async function prepareRequest<
   client: Client<Transport, TChain, TAccount>,
   args: TArgs,
 ): Promise<PrepareRequestReturnType<TChain, TAccount, TChainOverride, TArgs>> {
-  const { account: account_, chain, gas, gasPrice, nonce } = args
+  const {
+    account: account_,
+    chain = client.chain,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+  } = args
   if (!account_) throw new AccountNotFoundError()
   const account = parseAccount(account_)
 
@@ -82,40 +86,44 @@ export async function prepareRequest<
     typeof block.baseFeePerGas === 'bigint' &&
     typeof gasPrice === 'undefined'
   ) {
-    // EIP-1559 fees
-    const { maxFeePerGas, maxPriorityFeePerGas } =
-      await internal_estimateFeesPerGas(client, {
-        block,
-        chain,
-        request: request as PrepareRequestParameters,
-      })
+    let defaultPriorityFee = 1_500_000_000n // 1.5 gwei
+    if (typeof chain?.fees?.defaultPriorityFee !== 'undefined') {
+      defaultPriorityFee =
+        typeof chain.fees.defaultPriorityFee === 'bigint'
+          ? chain.fees.defaultPriorityFee
+          : await chain.fees.defaultPriorityFee({
+              block,
+              request: request as PrepareRequestParameters,
+            })
+    }
 
-    if (
-      typeof args.maxPriorityFeePerGas === 'undefined' &&
-      args.maxFeePerGas &&
-      args.maxFeePerGas < maxPriorityFeePerGas
-    )
-      throw new MaxFeePerGasTooLowError({
-        maxPriorityFeePerGas,
-      })
-
-    request.maxPriorityFeePerGas = maxPriorityFeePerGas
-    request.maxFeePerGas = args.maxFeePerGas ?? maxFeePerGas
+    // EIP-1559 fees
+    if (typeof maxFeePerGas === 'undefined') {
+      // Set a buffer of 1.2x on top of the base fee to account for fluctuations.
+      request.maxPriorityFeePerGas = maxPriorityFeePerGas ?? defaultPriorityFee
+      request.maxFeePerGas =
+        (block.baseFeePerGas * 120n) / 100n + request.maxPriorityFeePerGas
+    } else {
+      if (
+        typeof maxPriorityFeePerGas === 'undefined' &&
+        maxFeePerGas < defaultPriorityFee
+      )
+        throw new BaseError(
+          '`maxFeePerGas` cannot be less than the default `maxPriorityFeePerGas` (1.5 gwei).',
+        )
+      request.maxFeePerGas = maxFeePerGas
+      request.maxPriorityFeePerGas = maxPriorityFeePerGas ?? defaultPriorityFee
+    }
   } else if (typeof gasPrice === 'undefined') {
     // Legacy fees
     if (
-      typeof args.maxFeePerGas !== 'undefined' ||
-      typeof args.maxPriorityFeePerGas !== 'undefined'
+      typeof maxFeePerGas !== 'undefined' ||
+      typeof maxPriorityFeePerGas !== 'undefined'
     )
-      throw new Eip1559FeesNotSupportedError()
+      throw new BaseError('Chain does not support EIP-1559 fees.')
 
-    const { gasPrice: gasPrice_ } = await internal_estimateFeesPerGas(client, {
-      block,
-      chain,
-      request: request as PrepareRequestParameters,
-      type: 'legacy',
-    })
-    request.gasPrice = gasPrice_
+    // Set a buffer of 1.2x on top of the base fee to account for fluctuations.
+    request.gasPrice = ((await getGasPrice(client)) * 120n) / 100n
   }
 
   if (typeof gas === 'undefined')

package/chains/src/celo/formatters.test-d.ts

@@ -1,314 +0,0 @@
-import {
-  type Hash,
-  type RpcBlock,
-  type RpcTransaction,
-  type RpcTransactionReceipt,
-  type TransactionRequest,
-  createPublicClient,
-  createWalletClient,
-  http,
-} from 'viem'
-import {
-  getBlock,
-  getTransaction,
-  getTransactionReceipt,
-  sendTransaction,
-} from 'viem/actions'
-import { describe, expectTypeOf, test } from 'vitest'
-
-import { celo } from '../index.js'
-import { formattersCelo } from './formatters.js'
-
-describe('block', () => {
-  expectTypeOf(formattersCelo.block.format).parameter(0).toEqualTypeOf<
-    Partial<RpcBlock> & {
-      randomness: { committed: `0x${string}`; revealed: `0x${string}` }
-      transactions:
-        | `0x${string}`[]
-        | (RpcTransaction & {
-            feeCurrency: `0x${string}` | null
-            gatewayFee: `0x${string}` | null
-            gatewayFeeRecipient: `0x${string}` | null
-          })[]
-    }
-  >()
-  expectTypeOf<
-    ReturnType<typeof formattersCelo.block.format>['difficulty']
-  >().toEqualTypeOf<never>()
-  expectTypeOf<
-    ReturnType<typeof formattersCelo.block.format>['gasLimit']
-  >().toEqualTypeOf<never>()
-  expectTypeOf<
-    ReturnType<typeof formattersCelo.block.format>['mixHash']
-  >().toEqualTypeOf<never>()
-  expectTypeOf<
-    ReturnType<typeof formattersCelo.block.format>['nonce']
-  >().toEqualTypeOf<never>()
-  expectTypeOf<
-    ReturnType<typeof formattersCelo.block.format>['uncles']
-  >().toEqualTypeOf<never>()
-  expectTypeOf<
-    ReturnType<typeof formattersCelo.block.format>['randomness']
-  >().toEqualTypeOf<{
-    committed: `0x${string}`
-    revealed: `0x${string}`
-  }>()
-})
-
-describe('transaction', () => {
-  expectTypeOf(formattersCelo.transaction.format).parameter(0).toEqualTypeOf<
-    Partial<RpcTransaction> & {
-      feeCurrency: `0x${string}` | null
-      gatewayFee: `0x${string}` | null
-      gatewayFeeRecipient: `0x${string}` | null
-    }
-  >()
-  expectTypeOf<
-    ReturnType<typeof formattersCelo.transaction.format>['feeCurrency']
-  >().toEqualTypeOf<`0x${string}` | null>()
-  expectTypeOf<
-    ReturnType<typeof formattersCelo.transaction.format>['gatewayFee']
-  >().toEqualTypeOf<bigint | null>()
-  expectTypeOf<
-    ReturnType<typeof formattersCelo.transaction.format>['gatewayFeeRecipient']
-  >().toEqualTypeOf<`0x${string}` | null>()
-})
-
-describe('transactionReceipt', () => {
-  expectTypeOf(formattersCelo.transactionReceipt.format)
-    .parameter(0)
-    .toEqualTypeOf<
-      Partial<RpcTransactionReceipt> & {
-        feeCurrency: `0x${string}` | null
-        gatewayFee: `0x${string}` | null
-        gatewayFeeRecipient: `0x${string}` | null
-      }
-    >()
-  expectTypeOf<
-    ReturnType<typeof formattersCelo.transactionReceipt.format>['feeCurrency']
-  >().toEqualTypeOf<`0x${string}` | null>()
-  expectTypeOf<
-    ReturnType<typeof formattersCelo.transactionReceipt.format>['gatewayFee']
-  >().toEqualTypeOf<bigint | null>()
-  expectTypeOf<
-    ReturnType<
-      typeof formattersCelo.transactionReceipt.format
-    >['gatewayFeeRecipient']
-  >().toEqualTypeOf<`0x${string}` | null>()
-})
-
-describe('transactionRequest', () => {
-  expectTypeOf(formattersCelo.transactionRequest.format)
-    .parameter(0)
-    .toEqualTypeOf<
-      Partial<TransactionRequest> & {
-        feeCurrency?: `0x${string}` | undefined
-        gatewayFee?: bigint | undefined
-        gatewayFeeRecipient?: `0x${string}` | undefined
-      }
-    >()
-  expectTypeOf<
-    ReturnType<typeof formattersCelo.transactionRequest.format>['feeCurrency']
-  >().toEqualTypeOf<`0x${string}` | undefined>()
-  expectTypeOf<
-    ReturnType<typeof formattersCelo.transactionRequest.format>['gatewayFee']
-  >().toEqualTypeOf<`0x${string}` | undefined>()
-  expectTypeOf<
-    ReturnType<
-      typeof formattersCelo.transactionRequest.format
-    >['gatewayFeeRecipient']
-  >().toEqualTypeOf<`0x${string}` | undefined>()
-})
-
-describe('smoke', () => {
-  test('block', async () => {
-    const client = createPublicClient({
-      chain: celo,
-      transport: http(),
-    })
-    const block = await getBlock(client, {
-      blockNumber: 16645775n,
-    })
-
-    expectTypeOf(block.difficulty).toEqualTypeOf<never>()
-    expectTypeOf(block.gasLimit).toEqualTypeOf<never>()
-    expectTypeOf(block.mixHash).toEqualTypeOf<never>()
-    expectTypeOf(block.nonce).toEqualTypeOf<never>()
-    expectTypeOf(block.uncles).toEqualTypeOf<never>()
-    expectTypeOf(block.randomness).toEqualTypeOf<{
-      committed: `0x${string}`
-      revealed: `0x${string}`
-    }>()
-    expectTypeOf(block.transactions).toEqualTypeOf<Hash[]>()
-
-    const block_includeTransactions = await getBlock(client, {
-      blockNumber: 16645775n,
-      includeTransactions: true,
-    })
-    expectTypeOf(
-      block_includeTransactions.transactions[0].feeCurrency,
-    ).toEqualTypeOf<`0x${string}` | null>()
-    expectTypeOf(
-      block_includeTransactions.transactions[0].gatewayFee,
-    ).toEqualTypeOf<bigint | null>()
-    expectTypeOf(
-      block_includeTransactions.transactions[0].gatewayFeeRecipient,
-    ).toEqualTypeOf<`0x${string}` | null>()
-
-    const block_pending = await getBlock(client, {
-      blockTag: 'pending',
-      includeTransactions: true,
-    })
-    expectTypeOf(block_pending.hash).toEqualTypeOf<null>()
-    expectTypeOf(block_pending.logsBloom).toEqualTypeOf<null>()
-    expectTypeOf(block_pending.number).toEqualTypeOf<null>()
-    expectTypeOf(block_pending.transactions[0].blockHash).toEqualTypeOf<null>()
-    expectTypeOf(
-      block_pending.transactions[0].blockNumber,
-    ).toEqualTypeOf<null>()
-    expectTypeOf(
-      block_pending.transactions[0].transactionIndex,
-    ).toEqualTypeOf<null>()
-  })
-
-  test('transaction', async () => {
-    const client = createPublicClient({
-      chain: celo,
-      transport: http(),
-    })
-
-    const transaction = await getTransaction(client, {
-      blockNumber: 16628100n,
-      index: 0,
-    })
-
-    expectTypeOf(transaction.feeCurrency).toEqualTypeOf<`0x${string}` | null>()
-    expectTypeOf(transaction.gatewayFee).toEqualTypeOf<bigint | null>()
-    expectTypeOf(transaction.gatewayFeeRecipient).toEqualTypeOf<
-      `0x${string}` | null
-    >()
-  })
-
-  test('transactionReceipt', async () => {
-    const client = createPublicClient({
-      chain: celo,
-      transport: http(),
-    })
-
-    const transaction = await getTransactionReceipt(client, {
-      hash: '0x',
-    })
-
-    expectTypeOf(transaction.feeCurrency).toEqualTypeOf<`0x${string}` | null>()
-    expectTypeOf(transaction.gatewayFee).toEqualTypeOf<bigint | null>()
-    expectTypeOf(transaction.gatewayFeeRecipient).toEqualTypeOf<
-      `0x${string}` | null
-    >()
-  })
-
-  test('transactionRequest', async () => {
-    const client = createWalletClient({
-      account: '0x',
-      chain: celo,
-      transport: http(),
-    })
-
-    sendTransaction(client, {
-      feeCurrency: '0x',
-      gatewayFee: 0n,
-      gatewayFeeRecipient: '0x',
-    })
-
-    // @ts-expect-error `gasPrice` is not defined
-    sendTransaction(client, {
-      feeCurrency: '0x',
-      gatewayFee: 0n,
-      gatewayFeeRecipient: '0x',
-      gasPrice: 0n,
-      maxFeePerGas: 0n,
-      maxPriorityFeePerGas: 0n,
-    })
-
-    // @ts-expect-error `gasPrice` is not defined
-    sendTransaction(client, {
-      feeCurrency: '0x',
-      gatewayFee: 0n,
-      gatewayFeeRecipient: '0x',
-      gasPrice: 0n,
-      type: 'eip1559',
-    })
-
-    // @ts-expect-error `type` cannot be "legacy"
-    sendTransaction(client, {
-      feeCurrency: '0x',
-      gatewayFee: 0n,
-      gatewayFeeRecipient: '0x',
-      maxFeePerGas: 0n,
-      type: 'legacy',
-    })
-
-    // @ts-expect-error `type` cannot be "eip2930"
-    sendTransaction(client, {
-      feeCurrency: '0x',
-      gatewayFee: 0n,
-      gatewayFeeRecipient: '0x',
-      maxFeePerGas: 0n,
-      type: 'eip2930',
-    })
-  })
-
-  test('transactionRequest (chain on action)', async () => {
-    const client = createWalletClient({
-      account: '0x',
-      transport: http(),
-    })
-
-    sendTransaction(client, {
-      chain: celo,
-      feeCurrency: '0x',
-      gatewayFee: 0n,
-      gatewayFeeRecipient: '0x',
-    })
-
-    // @ts-expect-error `gasPrice` is not defined
-    sendTransaction(client, {
-      chain: celo,
-      feeCurrency: '0x',
-      gatewayFee: 0n,
-      gatewayFeeRecipient: '0x',
-      gasPrice: 0n,
-      maxFeePerGas: 0n,
-      maxPriorityFeePerGas: 0n,
-    })
-
-    // @ts-expect-error `gasPrice` is not defined
-    sendTransaction(client, {
-      chain: celo,
-      feeCurrency: '0x',
-      gatewayFee: 0n,
-      gatewayFeeRecipient: '0x',
-      gasPrice: 0n,
-      type: 'eip1559',
-    })
-
-    // @ts-expect-error `type` cannot be "legacy"
-    sendTransaction(client, {
-      chain: celo,
-      feeCurrency: '0x',
-      gatewayFee: 0n,
-      gatewayFeeRecipient: '0x',
-      maxFeePerGas: 0n,
-      type: 'legacy',
-    })
-
-    // @ts-expect-error `type` cannot be "eip2930"
-    sendTransaction(client, {
-      chain: celo,
-      feeCurrency: '0x',
-      gatewayFee: 0n,
-      gatewayFeeRecipient: '0x',
-      maxFeePerGas: 0n,
-      type: 'eip2930',
-    })
-  })
-})