wip: send tx sync

Author: jxom

src/actions/index.test.ts

@@ -76,6 +76,7 @@ test('exports actions', () => {
       "revert": [Function],
       "sendCalls": [Function],
       "sendRawTransaction": [Function],
+      "sendRawTransactionSync": [Function],
       "sendTransaction": [Function],
       "sendUnsignedTransaction": [Function],
       "setAutomine": [Function],

src/actions/index.ts

@@ -525,6 +525,12 @@ export {
   type SendRawTransactionReturnType,
   sendRawTransaction,
 } from './wallet/sendRawTransaction.js'
+export {
+  type SendRawTransactionSyncErrorType,
+  type SendRawTransactionSyncParameters,
+  type SendRawTransactionSyncReturnType,
+  sendRawTransactionSync,
+} from './wallet/sendRawTransactionSync.js'
 export {
   type SendTransactionErrorType,
   type SendTransactionParameters,

src/actions/wallet/sendRawTransactionSync.test.ts

@@ -0,0 +1,30 @@
+import { expect, test } from 'vitest'
+import { accounts } from '~test/src/constants.js'
+import { anvilMainnet } from '../../../test/src/anvil.js'
+import { privateKeyToAccount } from '../../accounts/privateKeyToAccount.js'
+import { wait } from '../../utils/wait.js'
+import { mine } from '../index.js'
+import { prepareTransactionRequest } from './prepareTransactionRequest.js'
+import { sendRawTransactionSync } from './sendRawTransactionSync.js'
+import { signTransaction } from './signTransaction.js'
+
+const client = anvilMainnet.getClient()
+
+test('default', async () => {
+  const request = await prepareTransactionRequest(client, {
+    account: privateKeyToAccount(accounts[0].privateKey),
+    to: accounts[1].address,
+    value: 1n,
+  })
+  const serializedTransaction = await signTransaction(client, request)
+  const [receipt] = await Promise.all([
+    sendRawTransactionSync(client, {
+      serializedTransaction,
+    }),
+    (async () => {
+      await wait(100)
+      await mine(client, { blocks: 1 })
+    })(),
+  ])
+  expect(receipt).toBeDefined()
+})

src/actions/wallet/sendRawTransactionSync.ts

@@ -0,0 +1,68 @@
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { Chain } from '../../types/chain.js'
+import type { TransactionSerializedGeneric } from '../../types/transaction.js'
+import type { RequestErrorType } from '../../utils/buildRequest.js'
+import { formatTransactionReceipt } from '../../utils/formatters/transactionReceipt.js'
+import {
+  type FormattedTransactionReceipt,
+  numberToHex,
+} from '../../utils/index.js'
+
+export type SendRawTransactionSyncParameters = {
+  /** The signed serialized transaction. */
+  serializedTransaction: TransactionSerializedGeneric
+  /** The timeout for the transaction. */
+  timeout?: number | undefined
+}
+
+export type SendRawTransactionSyncReturnType<
+  chain extends Chain | undefined = undefined,
+> = FormattedTransactionReceipt<chain>
+
+export type SendRawTransactionSyncErrorType = RequestErrorType | ErrorType
+
+/**
+ * Sends a **signed** transaction to the network synchronously,
+ * and waits for the transaction to be included in a block.
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/sendRawTransactionSync
+ * - JSON-RPC Method: [`eth_sendRawTransactionSync`](https://eips.ethereum.org/EIPS/eip-7966)
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SendRawTransactionParameters}
+ * @returns The transaction receipt. {@link SendRawTransactionSyncReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { sendRawTransactionSync } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ *
+ * const receipt = await sendRawTransactionSync(client, {
+ *   serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
+ * })
+ */
+export async function sendRawTransactionSync<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
+  { serializedTransaction, timeout }: SendRawTransactionSyncParameters,
+): Promise<SendRawTransactionSyncReturnType<chain>> {
+  const receipt = await client.request(
+    {
+      method: 'eth_sendRawTransactionSync',
+      params: timeout
+        ? [serializedTransaction, numberToHex(timeout)]
+        : [serializedTransaction],
+    },
+    { retryCount: 0 },
+  )
+  const format =
+    client.chain?.formatters?.transactionReceipt?.format ||
+    formatTransactionReceipt
+  return format(receipt) as SendRawTransactionSyncReturnType<chain>
+}

src/clients/decorators/public.test.ts

@@ -73,6 +73,7 @@ test('default', async () => {
       "prepareTransactionRequest": [Function],
       "readContract": [Function],
       "sendRawTransaction": [Function],
+      "sendRawTransactionSync": [Function],
       "simulate": [Function],
       "simulateBlocks": [Function],
       "simulateCalls": [Function],
@@ -463,6 +464,25 @@ describe('smoke test', () => {
     ).toBeDefined()
   })
 
+  test('sendRawTransactionSync', async () => {
+    const request = await client.prepareTransactionRequest({
+      account: privateKeyToAccount(accounts[0].privateKey),
+      to: accounts[1].address,
+      value: parseEther('1'),
+    })
+    const serializedTransaction = await signTransaction(client, request)
+    const [receipt] = await Promise.all([
+      client.sendRawTransactionSync({
+        serializedTransaction,
+      }),
+      (async () => {
+        await wait(100)
+        await mine(client, { blocks: 1 })
+      })(),
+    ])
+    expect(receipt).toBeDefined()
+  })
+
   test('readContract', async () => {
     expect(
       await client.readContract({

src/clients/decorators/public.ts

@@ -261,6 +261,11 @@ import {
   type SendRawTransactionReturnType,
   sendRawTransaction,
 } from '../../actions/wallet/sendRawTransaction.js'
+import {
+  type SendRawTransactionSyncParameters,
+  type SendRawTransactionSyncReturnType,
+  sendRawTransactionSync,
+} from '../../actions/wallet/sendRawTransactionSync.js'
 import type { Account } from '../../types/account.js'
 import type { BlockNumber, BlockTag } from '../../types/block.js'
 import type { Chain } from '../../types/chain.js'
@@ -1535,6 +1540,33 @@ export type PublicActions<
   sendRawTransaction: (
     args: SendRawTransactionParameters,
   ) => Promise<SendRawTransactionReturnType>
+  /**
+   * Sends a **signed** transaction to the network
+   *
+   * - Docs: https://viem.sh/docs/actions/wallet/sendRawTransactionSync
+   * - JSON-RPC Method: [`eth_sendRawTransactionSync`](https://eips.ethereum.org/EIPS/eip-7966)
+   *
+   * @param client - Client to use
+   * @param parameters - {@link SendRawTransactionSyncParameters}
+   * @returns The transaction receipt. {@link SendRawTransactionSyncReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   * import { sendRawTransactionSync } from 'viem/wallet'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   *
+   * const receipt = await client.sendRawTransactionSync({
+   *   serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
+   * })
+   */
+  sendRawTransactionSync: (
+    args: SendRawTransactionSyncParameters,
+  ) => Promise<SendRawTransactionSyncReturnType<chain>>
   /**
    * @deprecated Use `simulateBlocks` instead.
    */
@@ -2018,6 +2050,7 @@ export function publicActions<
       prepareTransactionRequest(client as any, args as any) as any,
     readContract: (args) => readContract(client, args),
     sendRawTransaction: (args) => sendRawTransaction(client, args),
+    sendRawTransactionSync: (args) => sendRawTransactionSync(client, args),
     simulate: (args) => simulateBlocks(client, args),
     simulateBlocks: (args) => simulateBlocks(client, args),
     simulateCalls: (args) => simulateCalls(client, args),

src/clients/decorators/wallet.test.ts

@@ -8,6 +8,8 @@ import { avalanche } from '../../chains/index.js'
 import { parseEther } from '../../utils/unit/parseEther.js'
 
 import { walletActions } from './wallet.js'
+import { wait } from '../../utils/wait.js'
+import { mine } from '../../actions/test/mine.js'
 
 const walletClient = anvilMainnet.getClient().extend(walletActions)
 const walletClientWithAccount = anvilMainnet
@@ -30,6 +32,7 @@ test('default', async () => {
       "requestPermissions": [Function],
       "sendCalls": [Function],
       "sendRawTransaction": [Function],
+      "sendRawTransactionSync": [Function],
       "sendTransaction": [Function],
       "showCallsStatus": [Function],
       "signAuthorization": [Function],
@@ -119,6 +122,25 @@ describe('smoke test', () => {
     ).toBeDefined()
   })
 
+  test('sendRawTransactionSync', async () => {
+    const request = await walletClient.prepareTransactionRequest({
+      account: privateKeyToAccount(accounts[0].privateKey),
+      to: accounts[1].address,
+      value: parseEther('1'),
+    })
+    const serializedTransaction = await walletClient.signTransaction(request)
+    const [receipt] = await Promise.all([
+      walletClient.sendRawTransactionSync({
+        serializedTransaction,
+      }),
+      (async () => {
+        await wait(100)
+        await mine(walletClient, { blocks: 1 })
+      })(),
+    ])
+    expect(receipt).toBeDefined()
+  })
+
   test('sendTransaction', async () => {
     expect(
       await walletClient.sendTransaction({

src/clients/decorators/wallet.ts

@@ -62,6 +62,11 @@ import {
   type SendRawTransactionReturnType,
   sendRawTransaction,
 } from '../../actions/wallet/sendRawTransaction.js'
+import {
+  type SendRawTransactionSyncParameters,
+  type SendRawTransactionSyncReturnType,
+  sendRawTransactionSync,
+} from '../../actions/wallet/sendRawTransactionSync.js'
 import {
   type SendTransactionParameters,
   type SendTransactionRequest,
@@ -498,6 +503,34 @@ export type WalletActions<
   sendRawTransaction: (
     args: SendRawTransactionParameters,
   ) => Promise<SendRawTransactionReturnType>
+  /**
+   * Sends a **signed** transaction to the network synchronously,
+   * and waits for the transaction to be included in a block.
+   *
+   * - Docs: https://viem.sh/docs/actions/wallet/sendRawTransactionSync
+   * - JSON-RPC Method: [`eth_sendRawTransactionSync`](https://eips.ethereum.org/EIPS/eip-7966)
+   *
+   * @param client - Client to use
+   * @param parameters - {@link SendRawTransactionSyncParameters}
+   * @returns The transaction receipt. {@link SendRawTransactionSyncReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   * import { sendRawTransactionSync } from 'viem/wallet'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   *
+   * const receipt = await client.sendRawTransactionSync({
+   *   serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
+   * })
+   */
+  sendRawTransactionSync: (
+    args: SendRawTransactionSyncParameters,
+  ) => Promise<SendRawTransactionSyncReturnType<chain>>
   /**
    * Creates, signs, and sends a new transaction to the network.
    *
@@ -973,6 +1006,7 @@ export function walletActions<
     requestPermissions: (args) => requestPermissions(client, args),
     sendCalls: (args) => sendCalls(client, args),
     sendRawTransaction: (args) => sendRawTransaction(client, args),
+    sendRawTransactionSync: (args) => sendRawTransactionSync(client, args),
     sendTransaction: (args) => sendTransaction(client, args),
     showCallsStatus: (args) => showCallsStatus(client, args),
     signAuthorization: (args) => signAuthorization(client, args),

src/index.ts

@@ -485,6 +485,11 @@ export type {
   SendRawTransactionParameters,
   SendRawTransactionReturnType,
 } from './actions/wallet/sendRawTransaction.js'
+export type {
+  SendRawTransactionSyncErrorType,
+  SendRawTransactionSyncParameters,
+  SendRawTransactionSyncReturnType,
+} from './actions/wallet/sendRawTransactionSync.js'
 export type {
   SendTransactionErrorType,
   SendTransactionParameters,

src/types/eip1193.ts

@@ -1168,6 +1168,20 @@ export type PublicRpcSchema = [
     Parameters: [signedTransaction: Hex]
     ReturnType: Hash
   },
+  /**
+   * @description Sends a **signed** transaction to the network synchronously
+   * @link https://eips.ethereum.org/EIPS/eip-7966
+   * @example
+   * provider.request({ method: 'eth_sendRawTransactionSync', params: ['0x...'] })
+   * // => '0x...'
+   */
+  {
+    Method: 'eth_sendRawTransactionSync'
+    Parameters:
+      | [signedTransaction: Hex]
+      | [signedTransaction: Hex, timeout: Hex]
+    ReturnType: TransactionReceipt
+  },
   /**
    * @description Simulates execution of a set of calls with optional block and state overrides.
    * @example
@@ -1711,6 +1725,20 @@ export type WalletRpcSchema = [
     Parameters: [signedTransaction: Hex]
     ReturnType: Hash
   },
+  /**
+   * @description Sends and already-signed transaction to the network synchronously
+   * @link https://eips.ethereum.org/EIPS/eip-7966
+   * @example
+   * provider.request({ method: 'eth_sendRawTransactionSync', params: ['0x...'] })
+   * // => '0x...'
+   */
+  {
+    Method: 'eth_sendRawTransactionSync'
+    Parameters:
+      | [signedTransaction: Hex]
+      | [signedTransaction: Hex, timeout: Hex]
+    ReturnType: TransactionReceipt
+  },
   /**
    * @description Calculates an Ethereum-specific signature in the form of `keccak256("\x19Ethereum Signed Message:\n" + len(message) + message))`
    * @link https://eips.ethereum.org/EIPS/eip-1474