viem 2.0.0-beta.1 → 2.0.0-beta.10

package/chains/opStack/actions/estimateContractTotalGas.ts

@@ -0,0 +1,144 @@
+import type { Abi } from 'abitype'
+
+import type { Account } from '../../../accounts/types.js'
+import {
+  type ParseAccountErrorType,
+  parseAccount,
+} from '../../../accounts/utils/parseAccount.js'
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import type { BaseError } from '../../../errors/base.js'
+import type { Chain } from '../../../types/chain.js'
+import type {
+  ContractFunctionArgs,
+  ContractFunctionName,
+  ContractFunctionParameters,
+  GetValue,
+} from '../../../types/contract.js'
+import type { UnionOmit } from '../../../types/utils.js'
+import {
+  type EncodeFunctionDataErrorType,
+  type EncodeFunctionDataParameters,
+  encodeFunctionData,
+} from '../../../utils/abi/encodeFunctionData.js'
+import {
+  type GetContractErrorReturnType,
+  getContractError,
+} from '../../../utils/errors/getContractError.js'
+import {
+  type EstimateTotalGasErrorType,
+  type EstimateTotalGasParameters,
+  estimateTotalGas,
+} from './estimateTotalGas.js'
+
+export type EstimateContractTotalGasParameters<
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends ContractFunctionName<
+    abi,
+    'nonpayable' | 'payable'
+  > = ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  > = ContractFunctionArgs<abi, 'nonpayable' | 'payable', functionName>,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+> = ContractFunctionParameters<
+  abi,
+  'nonpayable' | 'payable',
+  functionName,
+  args
+> &
+  UnionOmit<
+    EstimateTotalGasParameters<chain, account, chainOverride>,
+    'data' | 'to' | 'value'
+  > &
+  GetValue<
+    abi,
+    functionName,
+    EstimateTotalGasParameters<
+      chain,
+      account,
+      chainOverride
+    > extends EstimateTotalGasParameters
+      ? EstimateTotalGasParameters<chain, account, chainOverride>['value']
+      : EstimateTotalGasParameters['value']
+  >
+
+export type EstimateContractTotalGasReturnType = bigint
+
+export type EstimateContractTotalGasErrorType = GetContractErrorReturnType<
+  | EncodeFunctionDataErrorType
+  | EstimateTotalGasErrorType
+  | ParseAccountErrorType
+>
+
+/**
+ * Estimates the L1 data gas + L2 gas required to successfully execute a contract write function call.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link EstimateContractTotalGasParameters}
+ * @returns The gas estimate (in wei). {@link EstimateContractTotalGasReturnType}
+ *
+ * @example
+ * import { createPublicClient, http, parseAbi } from 'viem'
+ * import { optimism } from 'viem/chains'
+ * import { estimateContractTotalGas } from 'viem/op-stack'
+ *
+ * const client = createPublicClient({
+ *   chain: optimism,
+ *   transport: http(),
+ * })
+ * const totalGas = await estimateContractTotalGas(client, {
+ *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+ *   abi: parseAbi(['function mint() public']),
+ *   functionName: 'mint',
+ *   account: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+ * })
+ */
+export async function estimateContractTotalGas<
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+  chain extends Chain | undefined,
+  account extends Account | undefined = undefined,
+  chainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: EstimateContractTotalGasParameters<
+    abi,
+    functionName,
+    args,
+    chain,
+    account,
+    chainOverride
+  >,
+): Promise<EstimateContractTotalGasReturnType> {
+  const { abi, address, args, functionName, ...request } =
+    parameters as EstimateContractTotalGasParameters
+  const data = encodeFunctionData({
+    abi,
+    args,
+    functionName,
+  } as EncodeFunctionDataParameters)
+  try {
+    const gas = await estimateTotalGas(client, {
+      data,
+      to: address,
+      ...request,
+    } as unknown as EstimateTotalGasParameters)
+    return gas
+  } catch (error) {
+    const account = request.account ? parseAccount(request.account) : undefined
+    throw getContractError(error as BaseError, {
+      abi,
+      address,
+      args,
+      docsPath: '/docs/chains/op-stack/estimateTotalGas',
+      functionName,
+      sender: account?.address,
+    })
+  }
+}

package/chains/opStack/actions/estimateL1Fee.ts

@@ -0,0 +1,138 @@
+import type { Address } from 'abitype'
+
+import { getChainId } from '../../../actions/public/getChainId.js'
+import {
+  type ReadContractErrorType,
+  readContract,
+} from '../../../actions/public/readContract.js'
+import {
+  type PrepareTransactionRequestErrorType,
+  type PrepareTransactionRequestParameters,
+  prepareTransactionRequest,
+} from '../../../actions/wallet/prepareTransactionRequest.js'
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import { maxInt256 } from '../../../constants/number.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Account, GetAccountParameter } from '../../../types/account.js'
+import { type Chain, type GetChainParameter } from '../../../types/chain.js'
+import type { Signature } from '../../../types/misc.js'
+import type { TransactionRequestEIP1559 } from '../../../types/transaction.js'
+import type { RequestErrorType } from '../../../utils/buildRequest.js'
+import { getChainContractAddress } from '../../../utils/chain/getChainContractAddress.js'
+import { type HexToNumberErrorType } from '../../../utils/encoding/fromHex.js'
+import { numberToHex } from '../../../utils/encoding/toHex.js'
+import {
+  type AssertRequestErrorType,
+  assertRequest,
+} from '../../../utils/transaction/assertRequest.js'
+import {
+  type SerializeTransactionErrorType,
+  serializeTransaction,
+} from '../../../utils/transaction/serializeTransaction.js'
+import { gasPriceOracleAbi } from '../abis.js'
+import { contracts } from '../contracts.js'
+
+export type EstimateL1FeeParameters<
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends Account | undefined = Account | undefined,
+  TChainOverride extends Chain | undefined = undefined,
+> = Omit<TransactionRequestEIP1559, 'from'> &
+  GetAccountParameter<TAccount> &
+  GetChainParameter<TChain, TChainOverride> & {
+    /** Gas price oracle address. */
+    gasPriceOracleAddress?: Address
+  }
+
+export type EstimateL1FeeReturnType = bigint
+
+export type EstimateL1FeeErrorType =
+  | RequestErrorType
+  | PrepareTransactionRequestErrorType
+  | AssertRequestErrorType
+  | SerializeTransactionErrorType
+  | HexToNumberErrorType
+  | ReadContractErrorType
+  | ErrorType
+
+const stubSignature = {
+  r: numberToHex(maxInt256),
+  s: numberToHex(maxInt256),
+  v: 28n,
+} as const satisfies Signature
+
+/**
+ * Estimates the L1 data fee required to execute an L2 transaction.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link EstimateL1FeeParameters}
+ * @returns The fee (in wei). {@link EstimateL1FeeReturnType}
+ *
+ * @example
+ * import { createPublicClient, http, parseEther } from 'viem'
+ * import { optimism } from 'viem/chains'
+ * import { estimateL1Fee } from 'viem/chains/optimism'
+ *
+ * const client = createPublicClient({
+ *   chain: optimism,
+ *   transport: http(),
+ * })
+ * const l1Fee = await estimateL1Fee(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: parseEther('1'),
+ * })
+ */
+export async function estimateL1Fee<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+  TChainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, TChain, TAccount>,
+  args: EstimateL1FeeParameters<TChain, TAccount, TChainOverride>,
+): Promise<EstimateL1FeeReturnType> {
+  const {
+    chain = client.chain,
+    gasPriceOracleAddress: gasPriceOracleAddress_,
+  } = args
+
+  const gasPriceOracleAddress = (() => {
+    if (gasPriceOracleAddress_) return gasPriceOracleAddress_
+    if (chain)
+      return getChainContractAddress({
+        chain,
+        contract: 'gasPriceOracle',
+      })
+    return contracts.gasPriceOracle.address
+  })()
+
+  // Populate transaction with required fields to accurately estimate gas.
+  const [request, chainId] = await Promise.all([
+    prepareTransactionRequest(
+      client,
+      args as PrepareTransactionRequestParameters,
+    ),
+    (async () => {
+      if (chain) return chain.id
+      return getChainId(client)
+    })(),
+  ])
+
+  assertRequest(request)
+
+  const transaction = serializeTransaction(
+    {
+      ...request,
+      chainId,
+      type: 'eip1559',
+    },
+    stubSignature,
+  )
+
+  return readContract(client, {
+    abi: gasPriceOracleAbi,
+    address: gasPriceOracleAddress,
+    functionName: 'getL1Fee',
+    args: [transaction],
+  })
+}

package/chains/opStack/actions/estimateL1Gas.ts

@@ -0,0 +1,138 @@
+import type { Address } from 'abitype'
+
+import { getChainId } from '../../../actions/public/getChainId.js'
+import {
+  type ReadContractErrorType,
+  readContract,
+} from '../../../actions/public/readContract.js'
+import {
+  type PrepareTransactionRequestErrorType,
+  type PrepareTransactionRequestParameters,
+  prepareTransactionRequest,
+} from '../../../actions/wallet/prepareTransactionRequest.js'
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import { maxInt256 } from '../../../constants/number.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Account, GetAccountParameter } from '../../../types/account.js'
+import { type Chain, type GetChainParameter } from '../../../types/chain.js'
+import type { Signature } from '../../../types/misc.js'
+import type { TransactionRequestEIP1559 } from '../../../types/transaction.js'
+import type { RequestErrorType } from '../../../utils/buildRequest.js'
+import { getChainContractAddress } from '../../../utils/chain/getChainContractAddress.js'
+import { type HexToNumberErrorType } from '../../../utils/encoding/fromHex.js'
+import { numberToHex } from '../../../utils/encoding/toHex.js'
+import {
+  type AssertRequestErrorType,
+  assertRequest,
+} from '../../../utils/transaction/assertRequest.js'
+import {
+  type SerializeTransactionErrorType,
+  serializeTransaction,
+} from '../../../utils/transaction/serializeTransaction.js'
+import { gasPriceOracleAbi } from '../abis.js'
+import { contracts } from '../contracts.js'
+
+export type EstimateL1GasParameters<
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends Account | undefined = Account | undefined,
+  TChainOverride extends Chain | undefined = Chain | undefined,
+> = Omit<TransactionRequestEIP1559, 'from'> &
+  GetAccountParameter<TAccount> &
+  GetChainParameter<TChain, TChainOverride> & {
+    /** Gas price oracle address. */
+    gasPriceOracleAddress?: Address
+  }
+
+export type EstimateL1GasReturnType = bigint
+
+export type EstimateL1GasErrorType =
+  | RequestErrorType
+  | PrepareTransactionRequestErrorType
+  | AssertRequestErrorType
+  | SerializeTransactionErrorType
+  | HexToNumberErrorType
+  | ReadContractErrorType
+  | ErrorType
+
+const stubSignature = {
+  r: numberToHex(maxInt256),
+  s: numberToHex(maxInt256),
+  v: 28n,
+} as const satisfies Signature
+
+/**
+ * Estimates the L1 data gas required to execute an L2 transaction.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link EstimateL1GasParameters}
+ * @returns The gas estimate. {@link EstimateL1GasReturnType}
+ *
+ * @example
+ * import { createPublicClient, http, parseEther } from 'viem'
+ * import { optimism } from 'viem/chains'
+ * import { estimateL1Gas } from 'viem/chains/optimism'
+ *
+ * const client = createPublicClient({
+ *   chain: optimism,
+ *   transport: http(),
+ * })
+ * const l1Gas = await estimateL1Gas(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: parseEther('1'),
+ * })
+ */
+export async function estimateL1Gas<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+  TChainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, TChain, TAccount>,
+  args: EstimateL1GasParameters<TChain, TAccount, TChainOverride>,
+): Promise<EstimateL1GasReturnType> {
+  const {
+    chain = client.chain,
+    gasPriceOracleAddress: gasPriceOracleAddress_,
+  } = args
+
+  const gasPriceOracleAddress = (() => {
+    if (gasPriceOracleAddress_) return gasPriceOracleAddress_
+    if (chain)
+      return getChainContractAddress({
+        chain,
+        contract: 'gasPriceOracle',
+      })
+    return contracts.gasPriceOracle.address
+  })()
+
+  // Populate transaction with required fields to accurately estimate gas.
+  const [request, chainId] = await Promise.all([
+    prepareTransactionRequest(
+      client,
+      args as PrepareTransactionRequestParameters,
+    ),
+    (async () => {
+      if (chain) return chain.id
+      return getChainId(client)
+    })(),
+  ])
+
+  assertRequest(request)
+
+  const transaction = serializeTransaction(
+    {
+      ...request,
+      chainId,
+      type: 'eip1559',
+    },
+    stubSignature,
+  )
+
+  return readContract(client, {
+    abi: gasPriceOracleAbi,
+    address: gasPriceOracleAddress,
+    functionName: 'getL1GasUsed',
+    args: [transaction],
+  })
+}

package/chains/opStack/actions/estimateTotalFee.ts

@@ -0,0 +1,86 @@
+import {
+  type EstimateGasErrorType,
+  type EstimateGasParameters,
+  estimateGas,
+} from '../../../actions/public/estimateGas.js'
+import {
+  type GetGasPriceErrorType,
+  getGasPrice,
+} from '../../../actions/public/getGasPrice.js'
+import {
+  type PrepareTransactionRequestErrorType,
+  type PrepareTransactionRequestParameters,
+  prepareTransactionRequest,
+} from '../../../actions/wallet/prepareTransactionRequest.js'
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Account } from '../../../types/account.js'
+import { type Chain } from '../../../types/chain.js'
+import type { RequestErrorType } from '../../../utils/buildRequest.js'
+import {
+  type EstimateL1FeeErrorType,
+  type EstimateL1FeeParameters,
+  estimateL1Fee,
+} from './estimateL1Fee.js'
+
+export type EstimateTotalFeeParameters<
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends Account | undefined = Account | undefined,
+  TChainOverride extends Chain | undefined = Chain | undefined,
+> = EstimateL1FeeParameters<TChain, TAccount, TChainOverride>
+
+export type EstimateTotalFeeReturnType = bigint
+
+export type EstimateTotalFeeErrorType =
+  | RequestErrorType
+  | PrepareTransactionRequestErrorType
+  | EstimateL1FeeErrorType
+  | EstimateGasErrorType
+  | GetGasPriceErrorType
+  | ErrorType
+
+/**
+ * Estimates the L1 data fee + L2 fee to execute an L2 transaction.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link EstimateTotalFeeParameters}
+ * @returns The fee (in wei). {@link EstimateTotalFeeReturnType}
+ *
+ * @example
+ * import { createPublicClient, http, parseEther } from 'viem'
+ * import { optimism } from 'viem/chains'
+ * import { estimateTotalFee } from 'viem/chains/optimism'
+ *
+ * const client = createPublicClient({
+ *   chain: optimism,
+ *   transport: http(),
+ * })
+ * const totalGas = await estimateTotalFee(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: parseEther('1'),
+ * })
+ */
+export async function estimateTotalFee<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+  TChainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, TChain, TAccount>,
+  args: EstimateTotalFeeParameters<TChain, TAccount, TChainOverride>,
+): Promise<EstimateTotalFeeReturnType> {
+  // Populate transaction with required fields to accurately estimate gas.
+  const request = await prepareTransactionRequest(
+    client,
+    args as PrepareTransactionRequestParameters,
+  )
+
+  const [l1Fee, l2Gas, l2GasPrice] = await Promise.all([
+    estimateL1Fee(client, request as EstimateL1FeeParameters),
+    estimateGas(client, request as EstimateGasParameters),
+    getGasPrice(client),
+  ])
+
+  return l1Fee + l2Gas * l2GasPrice
+}

package/chains/opStack/actions/estimateTotalGas.ts

@@ -0,0 +1,80 @@
+import {
+  type EstimateGasErrorType,
+  type EstimateGasParameters,
+  estimateGas,
+} from '../../../actions/public/estimateGas.js'
+import {
+  type PrepareTransactionRequestErrorType,
+  type PrepareTransactionRequestParameters,
+  prepareTransactionRequest,
+} from '../../../actions/wallet/prepareTransactionRequest.js'
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Account } from '../../../types/account.js'
+import { type Chain } from '../../../types/chain.js'
+import type { RequestErrorType } from '../../../utils/buildRequest.js'
+import {
+  type EstimateL1GasErrorType,
+  type EstimateL1GasParameters,
+  estimateL1Gas,
+} from './estimateL1Gas.js'
+
+export type EstimateTotalGasParameters<
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends Account | undefined = Account | undefined,
+  TChainOverride extends Chain | undefined = Chain | undefined,
+> = EstimateL1GasParameters<TChain, TAccount, TChainOverride>
+
+export type EstimateTotalGasReturnType = bigint
+
+export type EstimateTotalGasErrorType =
+  | RequestErrorType
+  | PrepareTransactionRequestErrorType
+  | EstimateL1GasErrorType
+  | EstimateGasErrorType
+  | ErrorType
+
+/**
+ * Estimates the amount of L1 data gas + L2 gas required to execute an L2 transaction.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link EstimateTotalGasParameters}
+ * @returns The gas estimate. {@link EstimateTotalGasReturnType}
+ *
+ * @example
+ * import { createPublicClient, http, parseEther } from 'viem'
+ * import { optimism } from 'viem/chains'
+ * import { estimateTotalGas } from 'viem/chains/optimism'
+ *
+ * const client = createPublicClient({
+ *   chain: optimism,
+ *   transport: http(),
+ * })
+ * const totalGas = await estimateTotalGas(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: parseEther('1'),
+ * })
+ */
+export async function estimateTotalGas<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+  TChainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, TChain, TAccount>,
+  args: EstimateTotalGasParameters<TChain, TAccount, TChainOverride>,
+): Promise<EstimateTotalGasReturnType> {
+  // Populate transaction with required fields to accurately estimate gas.
+  const request = await prepareTransactionRequest(
+    client,
+    args as PrepareTransactionRequestParameters,
+  )
+
+  const [l1Gas, l2Gas] = await Promise.all([
+    estimateL1Gas(client, request as EstimateL1GasParameters),
+    estimateGas(client, request as EstimateGasParameters),
+  ])
+
+  return l1Gas + l2Gas
+}

package/chains/opStack/chainConfig.ts

@@ -0,0 +1,9 @@
+import { contracts } from './contracts.js'
+import { formatters } from './formatters.js'
+import { serializers } from './serializers.js'
+
+export const chainConfig = {
+  contracts,
+  formatters,
+  serializers,
+} as const

package/chains/opStack/chains.ts

@@ -0,0 +1,9 @@
+export { base } from '../definitions/base.js'
+export { baseGoerli } from '../definitions/baseGoerli.js'
+export { baseSepolia } from '../definitions/baseSepolia.js'
+export { optimism } from '../definitions/optimism.js'
+export { optimismGoerli } from '../definitions/optimismGoerli.js'
+export { optimismSepolia } from '../definitions/optimismSepolia.js'
+export { zora } from '../definitions/zora.js'
+export { zoraSepolia } from '../definitions/zoraSepolia.js'
+export { zoraTestnet } from '../definitions/zoraTestnet.js'

package/chains/opStack/contracts.ts

@@ -0,0 +1,14 @@
+import type { Chain } from '../../types/chain.js'
+
+export const contracts = {
+  gasPriceOracle: { address: '0x420000000000000000000000000000000000000F' },
+  l1Block: { address: '0x4200000000000000000000000000000000000015' },
+  l2CrossDomainMessenger: {
+    address: '0x4200000000000000000000000000000000000007',
+  },
+  l2Erc721Bridge: { address: '0x4200000000000000000000000000000000000014' },
+  l2StandardBridge: { address: '0x4200000000000000000000000000000000000010' },
+  l2ToL1MessagePasser: {
+    address: '0x4200000000000000000000000000000000000016',
+  },
+} as const satisfies Chain['contracts']