viem 2.0.0-beta.9 → 2.0.0-rc.0

package/chains/opStack/actions/proveWithdrawal.ts

@@ -0,0 +1,151 @@
+import type { Address } from 'abitype'
+import {
+  type WriteContractErrorType,
+  writeContract,
+} from '../../../actions/wallet/writeContract.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, GetAccountParameter } from '../../../types/account.js'
+import type {
+  Chain,
+  DeriveChain,
+  GetChainParameter,
+} from '../../../types/chain.js'
+import type { Hash, Hex } from '../../../types/misc.js'
+import type { UnionEvaluate, UnionOmit } from '../../../types/utils.js'
+import type { FormattedTransactionRequest } from '../../../utils/formatters/transactionRequest.js'
+import { portalAbi } from '../abis.js'
+import type { GetContractAddressParameter } from '../types/contract.js'
+import {
+  type EstimateProveWithdrawalGasErrorType,
+  type EstimateProveWithdrawalGasParameters,
+  estimateProveWithdrawalGas,
+} from './estimateProveWithdrawalGas.js'
+
+export type ProveWithdrawalParameters<
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+  _derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
+> = UnionEvaluate<
+  UnionOmit<
+    FormattedTransactionRequest<_derivedChain>,
+    | 'accessList'
+    | 'data'
+    | 'from'
+    | 'gas'
+    | 'gasPrice'
+    | 'to'
+    | 'type'
+    | 'value'
+  >
+> &
+  GetAccountParameter<account, Account | Address> &
+  GetChainParameter<chain, chainOverride> &
+  GetContractAddressParameter<_derivedChain, 'portal'> & {
+    /**
+     * Gas limit for transaction execution on the L1.
+     * `null` to skip gas estimation & defer calculation to signer.
+     */
+    gas?: bigint | null
+    l2OutputIndex: bigint
+    outputRootProof: {
+      version: Hex
+      stateRoot: Hex
+      messagePasserStorageRoot: Hex
+      latestBlockhash: Hex
+    }
+    withdrawalProof: readonly Hex[]
+    withdrawal: {
+      data: Hex
+      gasLimit: bigint
+      nonce: bigint
+      sender: Address
+      target: Address
+      value: bigint
+    }
+  }
+export type ProveWithdrawalReturnType = Hash
+export type ProveWithdrawalErrorType =
+  | EstimateProveWithdrawalGasErrorType
+  | WriteContractErrorType
+  | ErrorType
+
+/**
+ * Proves a withdrawal that occurred on an L2. Used in the Withdrawal flow.
+ *
+ * - Docs: https://viem.sh/op-stack/actions/proveWithdrawal.html
+ *
+ * @param client - Client to use
+ * @param parameters - {@link ProveWithdrawalParameters}
+ * @returns The prove transaction hash. {@link ProveWithdrawalReturnType}
+ *
+ * @example
+ * import { createWalletClient, http } from 'viem'
+ * import { mainnet, optimism } from 'viem/chains'
+ * import { proveWithdrawal } from 'viem/op-stack'
+ *
+ * const walletClientL1 = createWalletClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const request = await proveWithdrawal(walletClientL1, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   l2OutputIndex: 4529n,
+ *   outputRootProof: { ... },
+ *   targetChain: optimism,
+ *   withdrawalProof: [ ... ],
+ *   withdrawal: { ... },
+ * })
+ */
+export async function proveWithdrawal<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  chainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: ProveWithdrawalParameters<chain, account, chainOverride>,
+): Promise<ProveWithdrawalReturnType> {
+  const {
+    account,
+    chain = client.chain,
+    gas,
+    l2OutputIndex,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    outputRootProof,
+    targetChain,
+    withdrawalProof,
+    withdrawal,
+  } = parameters
+
+  const portalAddress = (() => {
+    if (parameters.portalAddress) return parameters.portalAddress
+    if (chain) return targetChain!.contracts.portal[chain.id].address
+    return Object.values(targetChain!.contracts.portal)[0].address
+  })()
+
+  const gas_ =
+    typeof gas !== 'number' && gas !== null
+      ? await estimateProveWithdrawalGas(
+          client,
+          parameters as EstimateProveWithdrawalGasParameters,
+        )
+      : undefined
+
+  return writeContract(client, {
+    account,
+    abi: portalAbi,
+    address: portalAddress,
+    chain,
+    functionName: 'proveWithdrawalTransaction',
+    args: [withdrawal, l2OutputIndex, outputRootProof, withdrawalProof],
+    gas: gas_,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+  })
+}

package/chains/opStack/actions/waitForNextL2Output.ts

@@ -0,0 +1,111 @@
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import { ContractFunctionRevertedError } from '../../../errors/contract.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Account } from '../../../types/account.js'
+import type {
+  Chain,
+  DeriveChain,
+  GetChainParameter,
+} from '../../../types/chain.js'
+import { poll } from '../../../utils/poll.js'
+import type { GetContractAddressParameter } from '../types/contract.js'
+import {
+  type GetL2OutputErrorType,
+  type GetL2OutputReturnType,
+  getL2Output,
+} from './getL2Output.js'
+import {
+  type GetTimeToNextL2OutputErrorType,
+  type GetTimeToNextL2OutputParameters,
+  getTimeToNextL2Output,
+} from './getTimeToNextL2Output.js'
+
+export type WaitForNextL2OutputParameters<
+  chain extends Chain | undefined = Chain | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+  _derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
+> = GetChainParameter<chain, chainOverride> &
+  GetContractAddressParameter<_derivedChain, 'l2OutputOracle'> & {
+    /**
+     * The buffer to account for discrepencies between non-deterministic time intervals.
+     * @default 1.1
+     */
+    intervalBuffer?: GetTimeToNextL2OutputParameters['intervalBuffer']
+    l2BlockNumber: bigint
+    /**
+     * Polling frequency (in ms). Defaults to Client's pollingInterval config.
+     * @default client.pollingInterval
+     */
+    pollingInterval?: number
+  }
+export type WaitForNextL2OutputReturnType = GetL2OutputReturnType
+export type WaitForNextL2OutputErrorType =
+  | GetL2OutputErrorType
+  | GetTimeToNextL2OutputErrorType
+  | ErrorType
+
+/**
+ * Waits for the next L2 output (after the provided block number) to be submitted.
+ *
+ * - Docs: https://viem.sh/op-stack/actions/waitForNextL2Output.html
+ *
+ * @param client - Client to use
+ * @param parameters - {@link WaitForNextL2OutputParameters}
+ * @returns The L2 transaction hash. {@link WaitForNextL2OutputReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { getBlockNumber } from 'viem/actions'
+ * import { mainnet, optimism } from 'viem/chains'
+ * import { waitForNextL2Output } from 'viem/op-stack'
+ *
+ * const publicClientL1 = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const publicClientL2 = createPublicClient({
+ *   chain: optimism,
+ *   transport: http(),
+ * })
+ *
+ * const l2BlockNumber = await getBlockNumber(publicClientL2)
+ * await waitForNextL2Output(publicClientL1, {
+ *   l2BlockNumber,
+ *   targetChain: optimism
+ * })
+ */
+export async function waitForNextL2Output<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  chainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: WaitForNextL2OutputParameters<chain, chainOverride>,
+): Promise<WaitForNextL2OutputReturnType> {
+  const { pollingInterval = client.pollingInterval } = parameters
+
+  const { seconds } = await getTimeToNextL2Output(client, parameters)
+
+  return new Promise((resolve, reject) => {
+    poll(
+      async ({ unpoll }) => {
+        try {
+          const output = await getL2Output(client, parameters)
+          unpoll()
+          resolve(output)
+        } catch (e) {
+          const error = e as GetL2OutputErrorType
+          if (!(error.cause instanceof ContractFunctionRevertedError)) {
+            unpoll()
+            reject(e)
+          }
+        }
+      },
+      {
+        interval: pollingInterval,
+        initialWaitTime: async () => seconds * 1000,
+      },
+    )
+  })
+}

package/chains/opStack/actions/waitToFinalize.ts

@@ -0,0 +1,64 @@
+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 { wait } from '../../../utils/wait.js'
+import {
+  type GetTimeToFinalizeErrorType,
+  type GetTimeToFinalizeParameters,
+  getTimeToFinalize,
+} from './getTimeToFinalize.js'
+
+export type WaitToFinalizeParameters<
+  chain extends Chain | undefined = Chain | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+> = GetTimeToFinalizeParameters<chain, chainOverride>
+export type WaitToFinalizeReturnType = void
+export type WaitToFinalizeErrorType = GetTimeToFinalizeErrorType | ErrorType
+
+/**
+ * Waits until the withdrawal transaction can be finalized. Used for the [Withdrawal](/op-stack/guides/withdrawals.html) flow.
+ *
+ * - Docs: https://viem.sh/op-stack/actions/waitToFinalize.html
+ *
+ * @param client - Client to use
+ * @param parameters - {@link WaitToFinalizeParameters}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { getBlockNumber } from 'viem/actions'
+ * import { mainnet, optimism } from 'viem/chains'
+ * import { waitToFinalize } from 'viem/op-stack'
+ *
+ * const publicClientL1 = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const publicClientL2 = createPublicClient({
+ *   chain: optimism,
+ *   transport: http(),
+ * })
+ *
+ * const receipt = await getTransactionReceipt(publicClientL2, {
+ *   hash: '0x9a2f4283636ddeb9ac32382961b22c177c9e86dd3b283735c154f897b1a7ff4a',
+ * })
+ *
+ * const [withdrawal] = getWithdrawals(receipt)
+ *
+ * await waitToFinalize(publicClientL1, {
+ *   withdrawalHash: withdrawal.withdrawalHash,
+ *   targetChain: optimism
+ * })
+ */
+export async function waitToFinalize<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  chainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: WaitToFinalizeParameters<chain, chainOverride>,
+): Promise<WaitToFinalizeReturnType> {
+  const { seconds } = await getTimeToFinalize(client, parameters)
+  await wait(seconds * 1000)
+}

package/chains/opStack/actions/waitToProve.ts

@@ -0,0 +1,99 @@
+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,
+  DeriveChain,
+  GetChainParameter,
+} from '../../../types/chain.js'
+import type { TransactionReceipt } from '../../../types/transaction.js'
+import { ReceiptContainsNoWithdrawalsError } from '../errors/withdrawal.js'
+import type { GetContractAddressParameter } from '../types/contract.js'
+import type { Withdrawal } from '../types/withdrawal.js'
+import {
+  type GetWithdrawalsErrorType,
+  getWithdrawals,
+} from '../utils/getWithdrawals.js'
+import {
+  type WaitForNextL2OutputErrorType,
+  type WaitForNextL2OutputReturnType,
+  waitForNextL2Output,
+} from './waitForNextL2Output.js'
+
+export type WaitToProveParameters<
+  chain extends Chain | undefined = Chain | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+  _derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
+> = GetChainParameter<chain, chainOverride> &
+  GetContractAddressParameter<_derivedChain, 'l2OutputOracle'> & {
+    receipt: TransactionReceipt
+    /**
+     * Polling frequency (in ms). Defaults to Client's pollingInterval config.
+     * @default client.pollingInterval
+     */
+    pollingInterval?: number
+  }
+export type WaitToProveReturnType = {
+  withdrawal: Withdrawal
+  output: WaitForNextL2OutputReturnType
+}
+export type WaitToProveErrorType =
+  | GetWithdrawalsErrorType
+  | WaitForNextL2OutputErrorType
+  | ErrorType
+
+/**
+ * Waits until the L2 withdrawal transaction is ready to be proved. Used for the [Withdrawal](/op-stack/guides/withdrawals.html) flow.
+ *
+ * - Docs: https://viem.sh/op-stack/actions/waitToProve.html
+ *
+ * @param client - Client to use
+ * @param parameters - {@link WaitToProveParameters}
+ * @returns The L2 output and withdrawal message. {@link WaitToProveReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { getBlockNumber } from 'viem/actions'
+ * import { mainnet, optimism } from 'viem/chains'
+ * import { waitToProve } from 'viem/op-stack'
+ *
+ * const publicClientL1 = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const publicClientL2 = createPublicClient({
+ *   chain: optimism,
+ *   transport: http(),
+ * })
+ *
+ * const receipt = await getTransactionReceipt(publicClientL2, { hash: '0x...' })
+ * await waitToProve(publicClientL1, {
+ *   receipt,
+ *   targetChain: optimism
+ * })
+ */
+export async function waitToProve<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  chainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: WaitToProveParameters<chain, chainOverride>,
+): Promise<WaitToProveReturnType> {
+  const { receipt } = parameters
+
+  const [withdrawal] = getWithdrawals(receipt)
+
+  if (!withdrawal)
+    throw new ReceiptContainsNoWithdrawalsError({
+      hash: receipt.transactionHash,
+    })
+
+  const output = await waitForNextL2Output(client, {
+    ...parameters,
+    l2BlockNumber: receipt.blockNumber,
+  })
+
+  return { output, withdrawal }
+}

package/chains/opStack/chains.ts

@@ -4,6 +4,8 @@ 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 { pgn } from '../definitions/pgn.js'
+export { pgnTestnet } from '../definitions/pgnTestnet.js'
 export { zora } from '../definitions/zora.js'
 export { zoraSepolia } from '../definitions/zoraSepolia.js'
 export { zoraTestnet } from '../definitions/zoraTestnet.js'