feat: add TransactionRequest.fromRpc

Author: jxom

.changeset/eleven-humans-applaud.md

@@ -0,0 +1,5 @@
+---
+"ox": patch
+---
+
+Added `TransactionRequest.fromRpc`

src/core/TransactionRequest.ts

@@ -53,6 +53,62 @@ export type TransactionRequest<
 /** RPC representation of a {@link ox#TransactionRequest.TransactionRequest}. */
 export type Rpc = TransactionRequest<Hex.Hex, Hex.Hex, string>
 
+/**
+ * Converts a {@link ox#TransactionRequest.Rpc} to a {@link ox#TransactionRequest.TransactionRequest}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { TransactionRequest } from 'ox'
+ *
+ * const request = TransactionRequest.fromRpc({
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: '0x2386f26fc10000',
+ * })
+ * ```
+ *
+ * @param request - The RPC request to convert.
+ * @returns A transaction request.
+ */
+export function fromRpc(request: Rpc): TransactionRequest {
+  const request_ = request as TransactionRequest
+
+  if (typeof request.authorizationList !== 'undefined')
+    request_.authorizationList = Authorization.fromRpcList(
+      request.authorizationList,
+    )
+  if (typeof request.chainId !== 'undefined')
+    request_.chainId = Hex.toNumber(request.chainId)
+  if (typeof request.gas !== 'undefined')
+    request_.gas = Hex.toBigInt(request.gas)
+  if (typeof request.gasPrice !== 'undefined')
+    request_.gasPrice = Hex.toBigInt(request.gasPrice)
+  if (typeof request.maxFeePerBlobGas !== 'undefined')
+    request_.maxFeePerBlobGas = Hex.toBigInt(request.maxFeePerBlobGas)
+  if (typeof request.maxFeePerGas !== 'undefined')
+    request_.maxFeePerGas = Hex.toBigInt(request.maxFeePerGas)
+  if (typeof request.maxPriorityFeePerGas !== 'undefined')
+    request_.maxPriorityFeePerGas = Hex.toBigInt(request.maxPriorityFeePerGas)
+  if (typeof request.nonce !== 'undefined')
+    request_.nonce = Hex.toBigInt(request.nonce)
+  if (typeof request.type !== 'undefined')
+    request_.type =
+      Transaction.fromRpcType[
+        request.type as keyof typeof Transaction.fromRpcType
+      ] || request.type
+  if (typeof request.value !== 'undefined')
+    request_.value = Hex.toBigInt(request.value)
+
+  return request_
+}
+
+export declare namespace fromRpc {
+  export type ErrorType =
+    | Authorization.fromRpcList.ErrorType
+    | Hex.toNumber.ErrorType
+    | Hex.toBigInt.ErrorType
+    | Errors.GlobalErrorType
+}
+
 /**
  * Converts a {@link ox#TransactionRequest.TransactionRequest} to a {@link ox#TransactionRequest.Rpc}.
  *

src/core/_test/TransactionRequest.test.ts

@@ -94,9 +94,114 @@ describe('toRpc', () => {
   })
 })
 
+describe('fromRpc', () => {
+  test('default', () => {
+    const request = TransactionRequest.fromRpc({
+      to: '0x0000000000000000000000000000000000000000',
+      value: '0x2386f26fc10000',
+    })
+    expect(request).toMatchInlineSnapshot(`
+      {
+        "to": "0x0000000000000000000000000000000000000000",
+        "value": 10000000000000000n,
+      }
+    `)
+  })
+
+  test('behavior: all', () => {
+    const request = TransactionRequest.fromRpc({
+      accessList: [],
+      authorizationList: [],
+      blobs: ['0xdeadbeef'],
+      blobVersionedHashes: ['0xdeadbeef'],
+      chainId: '0x1',
+      data: '0xdeadbeef',
+      from: '0x0000000000000000000000000000000000000000',
+      gas: '0xf4240',
+      gasPrice: '0x3b9aca00',
+      maxFeePerBlobGas: '0x3b9aca00',
+      maxFeePerGas: '0x3b9aca00',
+      maxPriorityFeePerGas: '0x3b9aca00',
+      nonce: '0x1',
+      to: '0x0000000000000000000000000000000000000000',
+      type: '0x2',
+      value: '0x3b9aca00',
+    })
+    expect(request).toMatchInlineSnapshot(`
+      {
+        "accessList": [],
+        "authorizationList": [],
+        "blobVersionedHashes": [
+          "0xdeadbeef",
+        ],
+        "blobs": [
+          "0xdeadbeef",
+        ],
+        "chainId": 1,
+        "data": "0xdeadbeef",
+        "from": "0x0000000000000000000000000000000000000000",
+        "gas": 1000000n,
+        "gasPrice": 1000000000n,
+        "maxFeePerBlobGas": 1000000000n,
+        "maxFeePerGas": 1000000000n,
+        "maxPriorityFeePerGas": 1000000000n,
+        "nonce": 1n,
+        "to": "0x0000000000000000000000000000000000000000",
+        "type": "eip1559",
+        "value": 1000000000n,
+      }
+    `)
+  })
+
+  test('behavior: input', () => {
+    const request = TransactionRequest.fromRpc({
+      input: '0xdeadbeef',
+    })
+    expect(request).toMatchInlineSnapshot(`
+      {
+        "input": "0xdeadbeef",
+      }
+    `)
+  })
+
+  test('behavior: empty', () => {
+    const request = TransactionRequest.fromRpc({})
+    expect(request).toMatchInlineSnapshot('{}')
+  })
+
+  test('behavior: roundtrip', () => {
+    const original: TransactionRequest.TransactionRequest = {
+      accessList: [],
+      authorizationList: [],
+      blobs: ['0xdeadbeef'],
+      blobVersionedHashes: ['0xdeadbeef'],
+      chainId: 1,
+      data: '0xdeadbeef',
+      from: '0x0000000000000000000000000000000000000000',
+      gas: 1000000n,
+      gasPrice: 1000000000n,
+      maxFeePerBlobGas: 1000000000n,
+      maxFeePerGas: 1000000000n,
+      maxPriorityFeePerGas: 1000000000n,
+      nonce: 1n,
+      to: '0x0000000000000000000000000000000000000000',
+      type: 'eip1559',
+      value: 1000000000n,
+    }
+    const rpc = TransactionRequest.toRpc(original)
+    const converted = TransactionRequest.fromRpc(rpc)
+
+    expect(converted).toEqual({
+      ...original,
+      input: '0xdeadbeef',
+    })
+  })
+})
+
 test('exports', () => {
   expect(Object.keys(TransactionRequest)).toMatchInlineSnapshot(`
     [
+      "fromRpc",
       "toRpc",
     ]
   `)