viem 2.9.1 → 2.9.3

package/chains/opStack/decorators/walletL2.ts

@@ -1,101 +0,0 @@
-import type { Client } from '../../../clients/createClient.js'
-import type { Transport } from '../../../clients/transports/createTransport.js'
-import type { Account } from '../../../types/account.js'
-import type { Chain } from '../../../types/chain.js'
-import {
-  type InitiateWithdrawalParameters,
-  type InitiateWithdrawalReturnType,
-  initiateWithdrawal,
-} from '../actions/initiateWithdrawal.js'
-
-export type WalletActionsL2<
-  chain extends Chain | undefined = Chain | undefined,
-  account extends Account | undefined = Account | undefined,
-> = {
-  /**
-   * Initiates a [withdrawal](https://community.optimism.io/docs/protocol/withdrawal-flow/#withdrawal-initiating-transaction) on an L2 to the L1.
-   *
-   * Internally performs a contract write to the [`initiateWithdrawal` function](https://github.com/ethereum-optimism/optimism/blob/283f0aa2e3358ced30ff7cbd4028c0c0c3faa140/packages/contracts-bedrock/src/L2/L2ToL1MessagePasser.sol#L73)
-   * on the [Optimism L2ToL1MessagePasser predeploy contract](https://github.com/ethereum-optimism/optimism/blob/283f0aa2e3358ced30ff7cbd4028c0c0c3faa140/packages/contracts-bedrock/src/L2/L2ToL1MessagePasser.sol).
-   *
-   * - Docs: https://viem.sh/op-stack/actions/initiateWithdrawal
-   *
-   * @param client - Client to use
-   * @param parameters - {@link InitiateWithdrawalParameters}
-   * @returns The L2 transaction hash. {@link InitiateWithdrawalReturnType}
-   *
-   * @example
-   * import { createWalletClient, custom, parseEther } from 'viem'
-   * import { base, mainnet } from 'viem/chains'
-   * import { walletActionsL2 } from 'viem/op-stack'
-   *
-   * const client = createWalletClient({
-   *   chain: mainnet,
-   *   transport: custom(window.ethereum),
-   * }).extend(walletActionsL2())
-   *
-   * const hash = await client.initiateWithdrawal({
-   *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
-   *   args: {
-   *     gas: 21_000n,
-   *     to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
-   *     value: parseEther('1'),
-   *   },
-   * })
-   *
-   * @example
-   * // Account Hoisting
-   * import { createWalletClient, http } from 'viem'
-   * import { privateKeyToAccount } from 'viem/accounts'
-   * import { base, mainnet } from 'viem/chains'
-   * import { walletActionsL2 } from 'viem/op-stack'
-   *
-   * const client = createWalletClient({
-   *   account: privateKeyToAccount('0x…'),
-   *   chain: mainnet,
-   *   transport: http(),
-   * }).extend(walletActionsL2())
-   *
-   * const hash = await client.initiateWithdrawal({
-   *   args: {
-   *     gas: 21_000n,
-   *     to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
-   *     value: parseEther('1'),
-   *   },
-   * })
-   */
-  initiateWithdrawal: <chainOverride extends Chain | undefined = undefined>(
-    parameters: InitiateWithdrawalParameters<chain, account, chainOverride>,
-  ) => Promise<InitiateWithdrawalReturnType>
-}
-
-/**
- * A suite of Wallet Actions for suited for development with Layer 2 (OP Stack) chains.
- *
- * - Docs: https://viem.sh/op-stack/client
- *
- * @example
- * import { createPublicClient, createWalletClient, http } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { walletActionsL1 } from 'viem/op-stack'
- *
- * const walletClient = createWalletClient({
- *   chain: mainnet,
- *   transport: http(),
- * }).extend(walletActionsL1())
- *
- * const hash = await walletClient.depositTransaction({...})
- */
-export function walletActionsL2() {
-  return <
-    TTransport extends Transport,
-    TChain extends Chain | undefined = Chain | undefined,
-    TAccount extends Account | undefined = Account | undefined,
-  >(
-    client: Client<TTransport, TChain, TAccount>,
-  ): WalletActionsL2<TChain, TAccount> => {
-    return {
-      initiateWithdrawal: (args) => initiateWithdrawal(client, args),
-    }
-  }
-}

package/chains/opStack/errors/withdrawal.ts

@@ -1,25 +0,0 @@
-import { BaseError } from '../../../errors/base.js'
-import type { Hex } from '../../../types/misc.js'
-
-export type GameNotFoundErrorType = GameNotFoundError & {
-  name: 'GameNotFoundError'
-}
-export class GameNotFoundError extends BaseError {
-  override name = 'GameNotFoundError'
-  constructor() {
-    super('Dispute game not found.')
-  }
-}
-
-export type ReceiptContainsNoWithdrawalsErrorType =
-  ReceiptContainsNoWithdrawalsError & {
-    name: 'ReceiptContainsNoWithdrawalsError'
-  }
-export class ReceiptContainsNoWithdrawalsError extends BaseError {
-  override name = 'ReceiptContainsNoWithdrawalsError'
-  constructor({ hash }: { hash: Hex }) {
-    super(
-      `The provided transaction receipt with hash "${hash}" contains no withdrawals.`,
-    )
-  }
-}

package/chains/opStack/formatters.ts

@@ -1,76 +0,0 @@
-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 {
-  OpStackBlockOverrides,
-  OpStackRpcBlockOverrides,
-} from './types/block.js'
-import type {
-  OpStackRpcTransaction,
-  OpStackRpcTransactionReceiptOverrides,
-  OpStackTransaction,
-  OpStackTransactionReceiptOverrides,
-} from './types/transaction.js'
-
-export const formatters = {
-  block: /*#__PURE__*/ defineBlock({
-    format(
-      args: OpStackRpcBlockOverrides & {
-        transactions: Hash[] | OpStackRpcTransaction[]
-      },
-    ): OpStackBlockOverrides & {
-      transactions: Hash[] | OpStackTransaction[]
-    } {
-      const transactions = args.transactions?.map((transaction) => {
-        if (typeof transaction === 'string') return transaction
-        const formatted = formatTransaction(
-          transaction as RpcTransaction,
-        ) as OpStackTransaction
-        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[] | OpStackTransaction[]
-      return {
-        transactions,
-        stateRoot: args.stateRoot,
-      }
-    },
-  }),
-  transaction: /*#__PURE__*/ defineTransaction({
-    format(args: OpStackRpcTransaction): OpStackTransaction {
-      const transaction = {} as OpStackTransaction
-      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: OpStackRpcTransactionReceiptOverrides,
-    ): OpStackTransactionReceiptOverrides {
-      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/chains/opStack/index.ts

@@ -1,269 +0,0 @@
-export {
-  buildDepositTransaction,
-  type BuildDepositTransactionErrorType,
-  type BuildDepositTransactionParameters,
-  type BuildDepositTransactionReturnType,
-} from './actions/buildDepositTransaction.js'
-export {
-  buildInitiateWithdrawal,
-  type BuildInitiateWithdrawalErrorType,
-  type BuildInitiateWithdrawalParameters,
-  type BuildInitiateWithdrawalReturnType,
-} from './actions/buildInitiateWithdrawal.js'
-export {
-  buildProveWithdrawal,
-  type BuildProveWithdrawalErrorType,
-  type BuildProveWithdrawalParameters,
-  type BuildProveWithdrawalReturnType,
-} from './actions/buildProveWithdrawal.js'
-export {
-  depositTransaction,
-  type DepositTransactionErrorType,
-  type DepositTransactionParameters,
-  type DepositTransactionReturnType,
-} from './actions/depositTransaction.js'
-export {
-  estimateContractL1Fee,
-  type EstimateContractL1FeeErrorType,
-  type EstimateContractL1FeeParameters,
-  type EstimateContractL1FeeReturnType,
-} from './actions/estimateContractL1Fee.js'
-export {
-  estimateContractL1Gas,
-  type EstimateContractL1GasErrorType,
-  type EstimateContractL1GasParameters,
-  type EstimateContractL1GasReturnType,
-} from './actions/estimateContractL1Gas.js'
-export {
-  estimateContractTotalFee,
-  type EstimateContractTotalFeeErrorType,
-  type EstimateContractTotalFeeParameters,
-  type EstimateContractTotalFeeReturnType,
-} from './actions/estimateContractTotalFee.js'
-export {
-  estimateContractTotalGas,
-  type EstimateContractTotalGasErrorType,
-  type EstimateContractTotalGasParameters,
-  type EstimateContractTotalGasReturnType,
-} from './actions/estimateContractTotalGas.js'
-export {
-  estimateL1Fee,
-  type EstimateL1FeeErrorType,
-  type EstimateL1FeeParameters,
-  type EstimateL1FeeReturnType,
-} from './actions/estimateL1Fee.js'
-export {
-  getGame,
-  type GetGameErrorType,
-  type GetGameParameters,
-  type GetGameReturnType,
-} from './actions/getGame.js'
-export {
-  getGames,
-  type GetGamesErrorType,
-  type GetGamesParameters,
-  type GetGamesReturnType,
-} from './actions/getGames.js'
-export {
-  getL1BaseFee,
-  type GetL1BaseFeeErrorType,
-  type GetL1BaseFeeParameters,
-  type GetL1BaseFeeReturnType,
-} from './actions/getL1BaseFee.js'
-export {
-  estimateL1Gas,
-  type EstimateL1GasErrorType,
-  type EstimateL1GasParameters,
-  type EstimateL1GasReturnType,
-} from './actions/estimateL1Gas.js'
-export {
-  estimateTotalFee,
-  type EstimateTotalFeeErrorType,
-  type EstimateTotalFeeParameters,
-  type EstimateTotalFeeReturnType,
-} from './actions/estimateTotalFee.js'
-export {
-  estimateTotalGas,
-  type EstimateTotalGasErrorType,
-  type EstimateTotalGasParameters,
-  type EstimateTotalGasReturnType,
-} from './actions/estimateTotalGas.js'
-export {
-  finalizeWithdrawal,
-  type FinalizeWithdrawalErrorType,
-  type FinalizeWithdrawalParameters,
-  type FinalizeWithdrawalReturnType,
-} from './actions/finalizeWithdrawal.js'
-export {
-  getL2Output,
-  type GetL2OutputErrorType,
-  type GetL2OutputParameters,
-  type GetL2OutputReturnType,
-} from './actions/getL2Output.js'
-export {
-  getPortalVersion,
-  type GetPortalVersionErrorType,
-  type GetPortalVersionParameters,
-  type GetPortalVersionReturnType,
-} from './actions/getPortalVersion.js'
-export {
-  getTimeToNextGame,
-  type GetTimeToNextGameErrorType,
-  type GetTimeToNextGameParameters,
-  type GetTimeToNextGameReturnType,
-} from './actions/getTimeToNextGame.js'
-export {
-  getTimeToFinalize,
-  type GetTimeToFinalizeErrorType,
-  type GetTimeToFinalizeParameters,
-  type GetTimeToFinalizeReturnType,
-} from './actions/getTimeToFinalize.js'
-export {
-  getTimeToNextL2Output,
-  type GetTimeToNextL2OutputErrorType,
-  type GetTimeToNextL2OutputParameters,
-  type GetTimeToNextL2OutputReturnType,
-} from './actions/getTimeToNextL2Output.js'
-export {
-  getTimeToProve,
-  type GetTimeToProveErrorType,
-  type GetTimeToProveParameters,
-  type GetTimeToProveReturnType,
-} from './actions/getTimeToProve.js'
-export {
-  getWithdrawalStatus,
-  type GetWithdrawalStatusErrorType,
-  type GetWithdrawalStatusParameters,
-  type GetWithdrawalStatusReturnType,
-} from './actions/getWithdrawalStatus.js'
-export {
-  initiateWithdrawal,
-  type InitiateWithdrawalErrorType,
-  type InitiateWithdrawalParameters,
-  type InitiateWithdrawalReturnType,
-} from './actions/initiateWithdrawal.js'
-export {
-  proveWithdrawal,
-  type ProveWithdrawalErrorType,
-  type ProveWithdrawalParameters,
-  type ProveWithdrawalReturnType,
-} from './actions/proveWithdrawal.js'
-export {
-  waitForNextGame,
-  type WaitForNextGameErrorType,
-  type WaitForNextGameParameters,
-  type WaitForNextGameReturnType,
-} from './actions/waitForNextGame.js'
-export {
-  waitForNextL2Output,
-  type WaitForNextL2OutputErrorType,
-  type WaitForNextL2OutputParameters,
-  type WaitForNextL2OutputReturnType,
-} from './actions/waitForNextL2Output.js'
-export {
-  waitToFinalize,
-  type WaitToFinalizeErrorType,
-  type WaitToFinalizeParameters,
-  type WaitToFinalizeReturnType,
-} from './actions/waitToFinalize.js'
-export {
-  waitToProve,
-  type WaitToProveErrorType,
-  type WaitToProveParameters,
-  type WaitToProveReturnType,
-} from './actions/waitToProve.js'
-
-export { chainConfig } from './chainConfig.js'
-
-export * from './chains.js'
-
-export { publicActionsL1, type PublicActionsL1 } from './decorators/publicL1.js'
-export { publicActionsL2, type PublicActionsL2 } from './decorators/publicL2.js'
-export { walletActionsL1, type WalletActionsL1 } from './decorators/walletL1.js'
-export { walletActionsL2, type WalletActionsL2 } from './decorators/walletL2.js'
-
-export {
-  parseTransaction,
-  type ParseTransactionErrorType,
-  type ParseTransactionReturnType,
-} from './parsers.js'
-
-export {
-  serializeTransaction,
-  serializers,
-  type SerializeTransactionErrorType,
-  type SerializeTransactionReturnType,
-} from './serializers.js'
-
-export type {
-  OpStackBlock,
-  OpStackBlockOverrides,
-  OpStackRpcBlock,
-  OpStackRpcBlockOverrides,
-} from './types/block.js'
-export type {
-  OpStackDepositTransaction,
-  OpStackRpcDepositTransaction,
-  OpStackRpcTransaction,
-  OpStackRpcTransactionReceipt,
-  OpStackRpcTransactionReceiptOverrides,
-  OpStackTransaction,
-  OpStackTransactionReceipt,
-  OpStackTransactionReceiptOverrides,
-} from './types/transaction.js'
-
-export {
-  extractWithdrawalMessageLogs,
-  type ExtractWithdrawalMessageLogsErrorType,
-  type ExtractWithdrawalMessageLogsParameters,
-  type ExtractWithdrawalMessageLogsReturnType,
-} from './utils/extractWithdrawalMessageLogs.js'
-
-export {
-  extractTransactionDepositedLogs,
-  type ExtractTransactionDepositedLogsErrorType,
-  type ExtractTransactionDepositedLogsParameters,
-  type ExtractTransactionDepositedLogsReturnType,
-} from './utils/extractTransactionDepositedLogs.js'
-
-export {
-  opaqueDataToDepositData,
-  type OpaqueDataToDepositDataErrorType,
-  type OpaqueDataToDepositDataParameters,
-  type OpaqueDataToDepositDataReturnType,
-} from './utils/opaqueDataToDepositData.js'
-
-export {
-  getL2TransactionHash,
-  type GetL2TransactionHashErrorType,
-  type GetL2TransactionHashParameters,
-  type GetL2TransactionHashReturnType,
-} from './utils/getL2TransactionHash.js'
-
-export {
-  getL2TransactionHashes,
-  type GetL2TransactionHashesErrorType,
-  type GetL2TransactionHashesParameters,
-  type GetL2TransactionHashesReturnType,
-} from './utils/getL2TransactionHashes.js'
-
-export {
-  getSourceHash,
-  type GetSourceHashErrorType,
-  type GetSourceHashParameters,
-  type GetSourceHashReturnType,
-} from './utils/getSourceHash.js'
-
-export {
-  getWithdrawalHashStorageSlot,
-  type GetWithdrawalHashStorageSlotErrorType,
-  type GetWithdrawalHashStorageSlotParameters,
-  type GetWithdrawalHashStorageSlotReturnType,
-} from './utils/getWithdrawalHashStorageSlot.js'
-
-export {
-  getWithdrawals,
-  type GetWithdrawalsErrorType,
-  type GetWithdrawalsParameters,
-  type GetWithdrawalsReturnType,
-} from './utils/getWithdrawals.js'

package/chains/opStack/parsers.ts

@@ -1,88 +0,0 @@
-import { InvalidSerializedTransactionError } from '../../errors/transaction.js'
-import type { ErrorType } from '../../errors/utils.js'
-import { isHex } from '../../utils/data/isHex.js'
-import { sliceHex } from '../../utils/data/slice.js'
-import { hexToBigInt, hexToBool } from '../../utils/encoding/fromHex.js'
-import type { GetSerializedTransactionType } from '../../utils/transaction/getSerializedTransactionType.js'
-import {
-  type ParseTransactionErrorType as ParseTransactionErrorType_,
-  type ParseTransactionReturnType as ParseTransactionReturnType_,
-  parseTransaction as parseTransaction_,
-  toTransactionArray,
-} from '../../utils/transaction/parseTransaction.js'
-import { assertTransactionDeposit } from './serializers.js'
-import type {
-  OpStackTransactionSerialized,
-  OpStackTransactionType,
-  TransactionSerializableDeposit,
-  TransactionSerializedDeposit,
-} from './types/transaction.js'
-
-export type ParseTransactionReturnType<
-  TSerialized extends
-    OpStackTransactionSerialized = OpStackTransactionSerialized,
-  TType extends
-    OpStackTransactionType = GetSerializedTransactionType<TSerialized>,
-> = TSerialized extends TransactionSerializedDeposit
-  ? TransactionSerializableDeposit
-  : ParseTransactionReturnType_<TSerialized, TType>
-
-export type ParseTransactionErrorType = ParseTransactionErrorType_ | ErrorType
-
-export function parseTransaction<
-  TSerialized extends OpStackTransactionSerialized,
->(serializedTransaction: TSerialized): ParseTransactionReturnType<TSerialized> {
-  const serializedType = sliceHex(serializedTransaction, 0, 1)
-
-  if (serializedType === '0x7e')
-    return parseTransactionDeposit(
-      serializedTransaction as TransactionSerializedDeposit,
-    ) as ParseTransactionReturnType<TSerialized>
-
-  return parseTransaction_(
-    serializedTransaction,
-  ) as ParseTransactionReturnType<TSerialized>
-}
-
-function parseTransactionDeposit(
-  serializedTransaction: TransactionSerializedDeposit,
-): ParseTransactionReturnType<TransactionSerializedDeposit> {
-  const transactionArray = toTransactionArray(serializedTransaction)
-
-  const [sourceHash, from, to, mint, value, gas, isSystemTx, data] =
-    transactionArray
-
-  if (transactionArray.length !== 8 || !isHex(sourceHash) || !isHex(from))
-    throw new InvalidSerializedTransactionError({
-      attributes: {
-        sourceHash,
-        from,
-        gas,
-        to,
-        mint,
-        value,
-        isSystemTx,
-        data,
-      },
-      serializedTransaction,
-      type: 'deposit',
-    })
-
-  const transaction: TransactionSerializableDeposit = {
-    sourceHash,
-    from,
-    type: 'deposit',
-  }
-
-  if (isHex(gas) && gas !== '0x') transaction.gas = hexToBigInt(gas)
-  if (isHex(to) && to !== '0x') transaction.to = to
-  if (isHex(mint) && mint !== '0x') transaction.mint = hexToBigInt(mint)
-  if (isHex(value) && value !== '0x') transaction.value = hexToBigInt(value)
-  if (isHex(isSystemTx) && isSystemTx !== '0x')
-    transaction.isSystemTx = hexToBool(isSystemTx)
-  if (isHex(data) && data !== '0x') transaction.data = data
-
-  assertTransactionDeposit(transaction)
-
-  return transaction
-}

package/chains/opStack/serializers.ts

@@ -1,88 +0,0 @@
-import { InvalidAddressError } from '../../errors/address.js'
-import type { ErrorType } from '../../errors/utils.js'
-import type { ChainSerializers } from '../../types/chain.js'
-import type { Hex, Signature } from '../../types/misc.js'
-import type { TransactionSerializable } from '../../types/transaction.js'
-import type { RequiredBy } from '../../types/utils.js'
-import { isAddress } from '../../utils/address/isAddress.js'
-import { concatHex } from '../../utils/data/concat.js'
-import { toHex } from '../../utils/encoding/toHex.js'
-import { toRlp } from '../../utils/encoding/toRlp.js'
-import {
-  type SerializeTransactionErrorType as SerializeTransactionErrorType_,
-  serializeTransaction as serializeTransaction_,
-} from '../../utils/transaction/serializeTransaction.js'
-import type {
-  OpStackTransactionSerializable,
-  TransactionSerializableDeposit,
-  TransactionSerializedDeposit,
-} from './types/transaction.js'
-
-export type SerializeTransactionReturnType = ReturnType<
-  typeof serializeTransaction
->
-
-export type SerializeTransactionErrorType =
-  | SerializeTransactionErrorType_
-  | ErrorType
-
-export function serializeTransaction(
-  transaction: OpStackTransactionSerializable,
-  signature?: Signature,
-) {
-  if (isDeposit(transaction)) return serializeTransactionDeposit(transaction)
-  return serializeTransaction_(
-    transaction as TransactionSerializable,
-    signature,
-  )
-}
-
-export const serializers = {
-  transaction: serializeTransaction,
-} as const satisfies ChainSerializers
-
-//////////////////////////////////////////////////////////////////////////////
-// Serializers
-
-export type SerializeTransactionDepositReturnType = TransactionSerializedDeposit
-
-function serializeTransactionDeposit(
-  transaction: TransactionSerializableDeposit,
-): SerializeTransactionDepositReturnType {
-  assertTransactionDeposit(transaction)
-
-  const { sourceHash, data, from, gas, isSystemTx, mint, to, value } =
-    transaction
-
-  const serializedTransaction: Hex[] = [
-    sourceHash,
-    from,
-    to ?? '0x',
-    mint ? toHex(mint) : '0x',
-    value ? toHex(value) : '0x',
-    gas ? toHex(gas) : '0x',
-    isSystemTx ? '0x1' : '0x',
-    data ?? '0x',
-  ]
-
-  return concatHex([
-    '0x7e',
-    toRlp(serializedTransaction),
-  ]) as SerializeTransactionDepositReturnType
-}
-
-function isDeposit(
-  transaction: OpStackTransactionSerializable,
-): transaction is RequiredBy<TransactionSerializableDeposit, 'type'> {
-  if (transaction.type === 'deposit') return true
-  if (typeof transaction.sourceHash !== 'undefined') return true
-  return false
-}
-
-export function assertTransactionDeposit(
-  transaction: TransactionSerializableDeposit,
-) {
-  const { from, to } = transaction
-  if (from && !isAddress(from)) throw new InvalidAddressError({ address: from })
-  if (to && !isAddress(to)) throw new InvalidAddressError({ address: to })
-}

package/chains/opStack/types/block.ts

@@ -1,34 +0,0 @@
-import type { Block, BlockTag } from '../../../types/block.js'
-import type { Hash } from '../../../types/misc.js'
-import type { RpcBlock } from '../../../types/rpc.js'
-import type {
-  OpStackRpcTransaction,
-  OpStackTransaction,
-} from './transaction.js'
-
-export type OpStackBlockOverrides = {
-  stateRoot: Hash
-}
-export type OpStackBlock<
-  TIncludeTransactions extends boolean = boolean,
-  TBlockTag extends BlockTag = BlockTag,
-> = Block<
-  bigint,
-  TIncludeTransactions,
-  TBlockTag,
-  OpStackTransaction<TBlockTag extends 'pending' ? true : false>
-> &
-  OpStackBlockOverrides
-
-export type OpStackRpcBlockOverrides = {
-  stateRoot: Hash
-}
-export type OpStackRpcBlock<
-  TBlockTag extends BlockTag = BlockTag,
-  TIncludeTransactions extends boolean = boolean,
-> = RpcBlock<
-  TBlockTag,
-  TIncludeTransactions,
-  OpStackRpcTransaction<TBlockTag extends 'pending' ? true : false>
-> &
-  OpStackRpcBlockOverrides

package/chains/opStack/types/chain.ts

@@ -1,10 +0,0 @@
-import type { Chain, ChainContract } from '../../../types/chain.js'
-
-export type TargetChain<
-  chain extends Chain = Chain,
-  contractName extends string = string,
-> = {
-  contracts: {
-    [_ in contractName]: { [_ in chain['id']]: ChainContract }
-  }
-}