viem 2.0.0-beta.5 → 2.0.0-beta.8

package/chains/opStack/serializers.ts

@@ -0,0 +1,88 @@
+import { InvalidAddressError } from '../../errors/address.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { ChainSerializers } from '../../types/chain.js'
+import type { Hex } 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_,
+  type SerializeTransactionFn,
+  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 const serializeTransaction: SerializeTransactionFn<
+  OpStackTransactionSerializable
+> = (transaction, 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

@@ -0,0 +1,34 @@
+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

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

package/chains/opStack/types/contract.ts

@@ -0,0 +1,17 @@
+import type { Address } from 'abitype'
+
+import type { Chain } from '../../../types/chain.js'
+import type { TargetChain } from './chain.js'
+
+export type GetContractAddressParameter<
+  chain extends Chain | undefined,
+  contractName extends string,
+> =
+  | (chain extends Chain
+      ? {
+          [_key in `${contractName}Address`]?: undefined
+        } & { targetChain: TargetChain<chain, contractName> }
+      : never)
+  | ({
+      [_key in `${contractName}Address`]: Address
+    } & { targetChain?: undefined })

package/chains/opStack/{types.ts → types/transaction.ts}

@@ -1,45 +1,21 @@
-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 { FeeValuesEIP1559 } from '../../../types/fee.js'
+import type { Hex } from '../../../types/misc.js'
 import type {
   Index,
   Quantity,
-  RpcBlock,
   RpcTransaction as RpcTransaction_,
   RpcTransactionReceipt,
-} from '../../types/rpc.js'
+} from '../../../types/rpc.js'
 import type {
   Transaction as Transaction_,
   TransactionBase,
   TransactionReceipt,
-} from '../../types/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
+  TransactionSerializable,
+  TransactionSerializableBase,
+  TransactionSerialized,
+  TransactionType,
+} from '../../../types/transaction.js'
+import type { RequiredBy } from '../../../types/utils.js'
 
 type RpcTransaction<TPending extends boolean = boolean> =
   RpcTransaction_<TPending> & {
@@ -100,3 +76,33 @@ export type OpStackTransactionReceiptOverrides = {
 }
 export type OpStackTransactionReceipt = TransactionReceipt &
   OpStackTransactionReceiptOverrides
+
+export type OpStackTransactionSerializable =
+  | RequiredBy<TransactionSerializableDeposit, 'type'>
+  | (TransactionSerializable & {
+      isSystemTx?: undefined
+      mint?: undefined
+      sourceHash?: undefined
+    })
+
+export type OpStackTransactionSerialized<
+  TType extends OpStackTransactionType = 'legacy',
+> = TransactionSerialized<TType> | TransactionSerializedDeposit
+
+export type OpStackTransactionType = TransactionType | 'deposit'
+
+export type TransactionSerializableDeposit<
+  TQuantity = bigint,
+  TIndex = number,
+> = Omit<
+  TransactionSerializableBase<TQuantity, TIndex>,
+  'nonce' | 'r' | 's' | 'v'
+> & {
+  from: Hex
+  isSystemTx?: boolean
+  mint?: bigint
+  sourceHash: Hex
+  type?: 'deposit'
+}
+
+export type TransactionSerializedDeposit = `0x7e${string}`

package/chains/opStack/utils/extractTransactionDepositedLogs.ts

@@ -0,0 +1,36 @@
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Log } from '../../../types/log.js'
+import {
+  type ParseEventLogsErrorType,
+  parseEventLogs,
+} from '../../../utils/abi/parseEventLogs.js'
+import { portalAbi } from '../abis.js'
+
+export type ExtractTransactionDepositedLogsParameters = {
+  /** An opaque array of logs. */
+  logs: Log[]
+}
+
+export type ExtractTransactionDepositedLogsReturnType = Log<
+  bigint,
+  number,
+  false,
+  undefined,
+  true,
+  typeof portalAbi,
+  'TransactionDeposited'
+>[]
+
+export type ExtractTransactionDepositedLogsErrorType =
+  | ParseEventLogsErrorType
+  | ErrorType
+
+export function extractTransactionDepositedLogs({
+  logs,
+}: ExtractTransactionDepositedLogsParameters) {
+  return parseEventLogs({
+    abi: portalAbi,
+    eventName: 'TransactionDeposited',
+    logs,
+  })
+}

package/chains/opStack/utils/fromOpaqueData.ts

@@ -0,0 +1,40 @@
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Hex } from '../../../types/misc.js'
+import { type SizeErrorType, size } from '../../../utils/data/size.js'
+import { type SliceErrorType, slice } from '../../../utils/data/slice.js'
+import { hexToBigInt } from '../../../utils/encoding/fromHex.js'
+
+export type FromOpaqueDataParameters = Hex
+
+export type FromOpaqueDataReturnType = {
+  mint: bigint
+  value: bigint
+  gas: bigint
+  isCreation: boolean
+  data: Hex
+}
+
+export type FromOpaqueDataErrorType = SliceErrorType | SizeErrorType | ErrorType
+
+export function fromOpaqueData(opaqueData: Hex): FromOpaqueDataReturnType {
+  let offset = 0
+  const mint = slice(opaqueData, offset, offset + 32)
+  offset += 32
+  const value = slice(opaqueData, offset, offset + 32)
+  offset += 32
+  const gas = slice(opaqueData, offset, offset + 8)
+  offset += 8
+  const isCreation = BigInt(slice(opaqueData, offset, offset + 1)) === 1n
+  offset += 1
+  const data =
+    offset > size(opaqueData) - 1
+      ? '0x'
+      : slice(opaqueData, offset, opaqueData.length)
+  return {
+    mint: hexToBigInt(mint),
+    value: hexToBigInt(value),
+    gas: hexToBigInt(gas),
+    isCreation,
+    data,
+  }
+}

package/chains/opStack/utils/getL2TransactionHash.ts

@@ -0,0 +1,52 @@
+// Adapted from https://github.com/ethereum-optimism/optimism/blob/develop/packages/core-utils/src/optimism/deposit-transaction.ts#L117
+
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Log } from '../../../types/log.js'
+import type { Hex } from '../../../types/misc.js'
+import { keccak256 } from '../../../utils/hash/keccak256.js'
+import type { portalAbi } from '../abis.js'
+import { serializeTransaction } from '../serializers.js'
+import { fromOpaqueData } from './fromOpaqueData.js'
+import { getSourceHash } from './getSourceHash.js'
+
+export type GetL2TransactionHashParameters = {
+  /** The "TransactionDeposited" log to compute the L2 hash from. */
+  log: Log<
+    bigint,
+    number,
+    false,
+    undefined,
+    true,
+    typeof portalAbi,
+    'TransactionDeposited'
+  >
+}
+
+export type GetL2TransactionHashReturnType = Hex
+
+export type GetL2TransactionHashErrorType = ErrorType
+
+export function getL2TransactionHash({ log }: GetL2TransactionHashParameters) {
+  const sourceHash = getSourceHash({
+    domain: 'userDeposit',
+    l1BlockHash: log.blockHash,
+    l1LogIndex: log.logIndex,
+  })
+  const { data, gas, isCreation, mint, value } = fromOpaqueData(
+    log.args.opaqueData,
+  )
+
+  return keccak256(
+    serializeTransaction({
+      from: log.args.from,
+      to: isCreation ? undefined : log.args.to,
+      sourceHash,
+      data,
+      gas,
+      isSystemTx: false,
+      mint,
+      type: 'deposit',
+      value,
+    }),
+  )
+}

package/chains/opStack/utils/getL2TransactionHashes.ts

@@ -0,0 +1,21 @@
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Log } from '../../../types/log.js'
+import type { Hex } from '../../../types/misc.js'
+import { extractTransactionDepositedLogs } from './extractTransactionDepositedLogs.js'
+import { getL2TransactionHash } from './getL2TransactionHash.js'
+
+export type GetL2TransactionHashesParameters = {
+  /** The L1 transaction receipt logs. */
+  logs: Log[]
+}
+
+export type GetL2TransactionHashesReturnType = Hex[]
+
+export type GetL2TransactionHashesErrorType = ErrorType
+
+export function getL2TransactionHashes({
+  logs,
+}: GetL2TransactionHashesParameters): GetL2TransactionHashesReturnType {
+  const extractedLogs = extractTransactionDepositedLogs({ logs })
+  return extractedLogs.map((log) => getL2TransactionHash({ log }))
+}

package/chains/opStack/utils/getSourceHash.ts

@@ -0,0 +1,61 @@
+// Adapted from https://github.com/ethereum-optimism/optimism/blob/develop/packages/core-utils/src/optimism/deposit-transaction.ts#L117
+
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Hex } from '../../../types/misc.js'
+import { type ConcatErrorType, concat } from '../../../utils/data/concat.js'
+import { type PadErrorType, pad } from '../../../utils/data/pad.js'
+import { type ToHexErrorType, toHex } from '../../../utils/encoding/toHex.js'
+import {
+  type Keccak256ErrorType,
+  keccak256,
+} from '../../../utils/hash/keccak256.js'
+
+export type GetSourceHashParameters = {
+  /** The L1 block hash. */
+  l1BlockHash: Hex
+} & (
+  | {
+      /** Domain of source hash. */
+      domain: 'userDeposit'
+      /** The index of the log on the L1. */
+      l1LogIndex: number
+      /** The sequence number. */
+      sequenceNumber?: undefined
+    }
+  | {
+      /** Domain of source hash. */
+      domain: 'l1InfoDeposit'
+      /** The index of the log on the L1. */
+      l1LogIndex?: undefined
+      /** The sequence number. */
+      sequenceNumber: number
+    }
+)
+
+export type GetSourceHashReturnType = Hex
+
+export type GetSourceHashErrorType =
+  | ConcatErrorType
+  | Keccak256ErrorType
+  | PadErrorType
+  | ToHexErrorType
+  | ErrorType
+
+const sourceHashDomainMap = {
+  userDeposit: 0,
+  l1InfoDeposit: 1,
+} as const
+
+export function getSourceHash({
+  domain,
+  l1LogIndex,
+  l1BlockHash,
+  sequenceNumber,
+}: GetSourceHashParameters) {
+  const marker = toHex(l1LogIndex! || sequenceNumber!)
+  const input = concat([l1BlockHash, pad(marker, { size: 32 })])
+  const depositIdHash = keccak256(input)
+  const domainHex = toHex(sourceHashDomainMap[domain])
+  const domainInput = concat([pad(domainHex, { size: 32 }), depositIdHash])
+  return keccak256(domainInput)
+}

package/clients/createClient.ts

@@ -147,7 +147,7 @@ type Client_Base<
 
 type Extended = Prettify<
   // disallow redefining base properties
-  { [K in keyof Client_Base]?: undefined } & {
+  { [_ in keyof Client_Base]?: undefined } & {
     [key: string]: unknown
   }
 >

package/clients/createWalletClient.ts

@@ -103,7 +103,7 @@ export function createWalletClient(
     ...parameters,
     key,
     name,
-    transport: (opts) => transport({ ...opts, retryCount: 0 }),
+    transport,
     type: 'walletClient',
   })
   return client.extend(walletActions)