viem 2.22.6 → 2.22.8

package/zksync/constants/number.ts

@@ -2,3 +2,4 @@ import { maxUint16 } from '../../constants/number.js'
 
 export const gasPerPubdataDefault = 50000n
 export const maxBytecodeSize = maxUint16 * 32n
+export const requiredL1ToL2GasPerPubdataLimit = 800n

package/zksync/decorators/walletL1.ts

@@ -0,0 +1,71 @@
+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 RequestExecuteParameters,
+  type RequestExecuteReturnType,
+  requestExecute,
+} from '../actions/requestExecute.js'
+import type { ChainEIP712 } from '../types/chain.js'
+
+export type WalletActionsL1<
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+> = {
+  /**
+   * Requests execution of a L2 transaction from L1.
+   *
+   * @param parameters - {@link RequestExecuteParameters}
+   * @returns hash - The [Transaction](https://viem.sh/docs/glossary/terms#transaction) hash. {@link RequestExecuteReturnType}
+   *
+   * @example
+   * import { createPublicClient, createWalletClient, http } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { zksync, mainnet } from 'viem/chains'
+   * import { walletActionsL1, publicActionsL2 } from 'viem/zksync'
+   *
+   * const walletClient = createWalletClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   *   account: privateKeyToAccount('0x…'),
+   * }).extend(walletActionsL1())
+   *
+   * const clientL2 = createPublicClient({
+   *   chain: zksync,
+   *   transport: http(),
+   * }).extend(publicActionsL2())
+   *
+   * const hash = await walletClient.requestExecute({
+   *     client: clientL2,
+   *     contractAddress: '0x43020e6e11cef7dce8e37baa09d9a996ac722057'
+   *     calldata: '0x',
+   *     l2Value: 1_000_000_000_000_000_000n,
+   * })
+   */
+  requestExecute: <
+    chainOverride extends Chain | undefined = undefined,
+    chainL2 extends ChainEIP712 | undefined = ChainEIP712 | undefined,
+    accountL2 extends Account | undefined = Account | undefined,
+  >(
+    parameters: RequestExecuteParameters<
+      chain,
+      account,
+      chainOverride,
+      chainL2,
+      accountL2
+    >,
+  ) => Promise<RequestExecuteReturnType>
+}
+
+export function walletActionsL1() {
+  return <
+    transport extends Transport,
+    chain extends Chain | undefined = Chain | undefined,
+    account extends Account | undefined = Account | undefined,
+  >(
+    client: Client<transport, chain, account>,
+  ): WalletActionsL1<chain, account> => ({
+    requestExecute: (args) => requestExecute(client, args),
+  })
+}

package/zksync/errors/bridge.ts

@@ -0,0 +1,29 @@
+import { BaseError } from '../../errors/base.js'
+
+export type BaseFeeHigherThanValueErrorType = BaseFeeHigherThanValueError & {
+  name: 'BaseFeeHigherThanValueError'
+}
+export class BaseFeeHigherThanValueError extends BaseError {
+  constructor(baseCost: bigint, value: bigint) {
+    super(
+      [
+        'The base cost of performing the priority operation is higher than the provided transaction value parameter.',
+        '',
+        `Base cost: ${baseCost}.`,
+        `Provided value: ${value}.`,
+      ].join('\n'),
+      { name: 'BaseFeeHigherThanValueError' },
+    )
+  }
+}
+
+export type TxHashNotFoundInLogsErrorType = BaseFeeHigherThanValueError & {
+  name: 'TxHashNotFoundInLogsError'
+}
+export class TxHashNotFoundInLogsError extends BaseError {
+  constructor() {
+    super('The transaction hash not found in event logs.', {
+      name: 'TxHashNotFoundInLogsError',
+    })
+  }
+}

package/zksync/index.ts

@@ -95,6 +95,12 @@ export {
   type GetTransactionDetailsReturnType,
   getTransactionDetails,
 } from './actions/getTransactionDetails.js'
+export {
+  type RequestExecuteErrorType,
+  type RequestExecuteReturnType,
+  type RequestExecuteParameters,
+  requestExecute,
+} from './actions/requestExecute.js'
 export {
   type SendTransactionErrorType,
   type SendTransactionParameters,
@@ -165,6 +171,11 @@ export {
   type PublicActionsL2,
 } from './decorators/publicL2.js'
 
+export {
+  walletActionsL1,
+  type WalletActionsL1,
+} from './decorators/walletL1.js'
+
 export { serializeTransaction } from './serializers.js'
 
 export type { ZksyncSmartAccount } from './types/account.js'
@@ -284,6 +295,10 @@ export type {
   ZksyncTransactionDetails,
 } from './types/transaction.js'
 
+export {
+  type GetL2HashFromPriorityOpErrorType,
+  getL2HashFromPriorityOp,
+} from './utils/bridge/getL2HashFromPriorityOp.js'
 export {
   type GetApprovalBasedPaymasterInputParameters,
   type GetApprovalBasedPaymasterInputReturnType,

package/zksync/utils/bridge/getL2HashFromPriorityOp.ts

@@ -0,0 +1,63 @@
+import type { Address } from 'abitype'
+import type { Hash } from '../../../types/misc.js'
+import type { TransactionReceipt } from '../../../types/transaction.js'
+import { decodeEventLog, isAddressEqual } from '../../../utils/index.js'
+import { zksyncAbi } from '../../constants/abis.js'
+import {
+  TxHashNotFoundInLogsError,
+  type TxHashNotFoundInLogsErrorType,
+} from '../../errors/bridge.js'
+
+export type GetL2HashFromPriorityOpErrorType = TxHashNotFoundInLogsErrorType
+
+/**
+ * Returns the hash of the L2 priority operation from a given L1 transaction receipt.
+ *
+ * @param receipt - The L1 transaction receipt.
+ * @param zksync - The address of the ZKsync Era main contract.
+ * @returns hash - The hash of the L2 priority operation.
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { zksync, mainnet } from 'viem/chains'
+ * import { publicActionsL2, getL2HashFromPriorityOp } from 'viem/zksync'
+ *
+ * const client = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const zksyncClient = const client = createPublicClient({
+ *   chain: zksync,
+ *   transport: http(),
+ * })
+ *
+ * const receipt = await client.waitForTransactionReceipt({hash: '0x...'})
+ * const l2Hash = getL2HashFromPriorityOp(
+ *   receipt,
+ *   await zksyncClient.getMainContractAddress()
+ * )
+ */
+export function getL2HashFromPriorityOp(
+  receipt: TransactionReceipt,
+  zksync: Address,
+): Address {
+  let hash: Hash | null = null
+  for (const log of receipt.logs) {
+    if (!isAddressEqual(log.address, zksync)) continue
+    try {
+      const priorityQueueLog = decodeEventLog({
+        abi: zksyncAbi,
+        data: log.data,
+        topics: log.topics,
+      })
+      if (priorityQueueLog && (priorityQueueLog.args as any).txHash !== null)
+        hash = (priorityQueueLog.args as any).txHash
+    } catch (_e) {}
+  }
+
+  if (!hash) {
+    throw new TxHashNotFoundInLogsError()
+  }
+  return hash
+}