ox 1.8.1 → 1.8.4

package/src/zod/_test/FrameReceipt.test.ts

@@ -7,13 +7,15 @@ describe('FrameReceipt', () => {
     expect(
       z.safeDecode(z.FrameReceipt.FrameReceipt, {
         executionGasUsed: '0x',
+        gasUsed: '0x',
         logs: [],
         stateGasUsed: '0x0',
-        status: 1,
+        status: '0x1',
       }).success,
     ).toBe(false)
     expect(
       z.safeEncode(z.FrameReceipt.FrameReceipt, {
+        executionGasUsed: 0n,
         gasUsed: -1n,
         logs: [],
         stateGasUsed: 0n,
@@ -23,6 +25,7 @@ describe('FrameReceipt', () => {
     for (const gasUsed of [-1, Number.MAX_SAFE_INTEGER + 1, '0x'] as const)
       expect(
         z.safeEncode(z.FrameReceipt.FrameReceiptToRpc, {
+          executionGasUsed: 0n,
           gasUsed,
           logs: [],
           stateGasUsed: 0n,
@@ -34,9 +37,10 @@ describe('FrameReceipt', () => {
   test('roundtrip', () => {
     const rpc = {
       executionGasUsed: '0x20000000000001',
+      gasUsed: '0x20000000000001',
       logs: [],
       stateGasUsed: '0x0',
-      status: 2,
+      status: '0x2',
     } as const
     const receipt = FrameReceipt.fromRpc(rpc)
     expect(z.decode(z.FrameReceipt.FrameReceipt, rpc)).toEqual(receipt)
@@ -47,10 +51,11 @@ describe('FrameReceipt', () => {
     expect(
       z.safeDecode(z.FrameReceipt.FrameReceipt, {
         executionGasUsed: '0x0',
+        gasUsed: '0x0',
         logs: [],
         stateGasUsed: '0x0',
         // @ts-expect-error Invalid RPC status.
-        status: 3,
+        status: '0x3',
       }).success,
     ).toBe(false)
   })
@@ -60,6 +65,7 @@ describe('FrameReceiptToRpc', () => {
   test('numberish gas', () => {
     expect(
       z.encode(z.FrameReceipt.FrameReceiptToRpc, {
+        executionGasUsed: 21000,
         gasUsed: 21000,
         logs: [],
         stateGasUsed: '0x0',
@@ -67,9 +73,10 @@ describe('FrameReceiptToRpc', () => {
       }),
     ).toEqual({
       executionGasUsed: '0x5208',
+      gasUsed: '0x5208',
       logs: [],
       stateGasUsed: '0x0',
-      status: 1,
+      status: '0x1',
     })
   })
 })

package/src/zod/_test/FrameRequest.test-d.ts

@@ -0,0 +1,15 @@
+import type { FrameRequest } from 'ox'
+import { z } from 'ox/zod'
+import { expectTypeOf, test } from 'vp/test'
+
+test('public frame request codecs preserve input and output types', () => {
+  expectTypeOf<
+    z.input<typeof z.FrameRequest.FrameRequest>
+  >().toEqualTypeOf<FrameRequest.Rpc>()
+  expectTypeOf<
+    z.output<typeof z.FrameRequest.FrameRequest>
+  >().toEqualTypeOf<FrameRequest.FrameRequest>()
+  expectTypeOf<
+    z.output<typeof z.FrameRequest.FrameRequestToRpc>
+  >().toEqualTypeOf<FrameRequest.toRpc.Input>()
+})

package/src/zod/_test/FrameRequest.test.ts

@@ -0,0 +1,44 @@
+import { z } from 'ox/zod'
+import { describe, expect, test } from 'vp/test'
+
+describe('FrameRequest', () => {
+  test('round-trips omitted gas through the public codec', () => {
+    const frame = z.decode(z.FrameRequest.FrameRequest, {
+      mode: '0x2',
+      stateGas: '0x0',
+    })
+    expect(frame).toEqual({
+      mode: 2,
+      flags: 0,
+      stateGas: 0n,
+      value: 0n,
+      data: '0x',
+    })
+    expect(z.encode(z.FrameRequest.FrameRequest, frame)).toEqual({
+      mode: '0x2',
+      flags: '0x0',
+      stateGas: '0x0',
+      value: '0x0',
+      data: '0x',
+    })
+  })
+})
+
+describe('FrameRequestToRpc', () => {
+  test('encodes numberish values through the public codec', () => {
+    expect(
+      z.encode(z.FrameRequest.FrameRequestToRpc, {
+        mode: 'sender',
+        executionGas: 50000,
+        stateGas: '0x0',
+      }),
+    ).toEqual({
+      mode: '0x2',
+      flags: '0x0',
+      executionGas: '0xc350',
+      stateGas: '0x0',
+      value: '0x0',
+      data: '0x',
+    })
+  })
+})

package/src/zod/_test/FrameSignature.test.ts

@@ -1,4 +1,4 @@
-import { FrameSignature, P256, Secp256k1, Hash } from 'ox'
+import { FrameSignature, P256, Secp256k1, Hash, Signature } from 'ox'
 import { z } from 'ox/zod'
 import { describe, expect, test } from 'vp/test'
 import { accounts } from '../../../test/constants/accounts.js'
@@ -8,7 +8,7 @@ describe('FrameSignature', () => {
     expect(
       z.safeDecode(z.FrameSignature.FrameSignature, {
         msg: '0x',
-        scheme: 1,
+        scheme: '0x1',
         signature: '0x01',
       }).success,
     ).toBe(false)
@@ -20,27 +20,27 @@ describe('FrameSignature', () => {
         scheme: 'arbitrary',
         signature: '0xaabb',
       }),
-    ).toEqual({ msg: '0x', scheme: 0, signature: '0xaabb' })
+    ).toEqual({ msg: '0x', scheme: '0x0', signature: '0xaabb' })
     expect(
       z.encode(z.FrameSignature.FrameSignature, {
         scheme: 'secp256k1',
       }),
-    ).toEqual({ msg: '0x', scheme: 1, signature: '0x' })
+    ).toEqual({ msg: '0x', scheme: '0x1' })
     expect(
       z.encode(z.FrameSignature.FrameSignature, {
         scheme: 'p256',
       }),
-    ).toEqual({ msg: '0x', scheme: 2, signature: '0x' })
+    ).toEqual({ msg: '0x', scheme: '0x2' })
   })
 
   test('arbitrary bytes', () => {
     expect(
       z.encode(z.FrameSignature.FrameSignature, FrameSignature.from('0xaabb')),
-    ).toEqual({ msg: '0x', scheme: 0, signature: '0xaabb' })
+    ).toEqual({ msg: '0x', scheme: '0x0', signature: '0xaabb' })
     expect(
       z.decode(z.FrameSignature.FrameSignature, {
         msg: '0x',
-        scheme: 0,
+        scheme: '0x0',
         signature: '0xaabb',
       }),
     ).toEqual(FrameSignature.from('0xaabb'))
@@ -54,7 +54,7 @@ describe('FrameSignature', () => {
       }),
     })
     const rpc = z.encode(z.FrameSignature.FrameSignature, entry)
-    expect(rpc.scheme).toBe(1)
+    expect(rpc.scheme).toBe('0x1')
     expect(z.decode(z.FrameSignature.FrameSignature, rpc)).toEqual(entry)
   })
   test('P-256 signature', () => {
@@ -68,7 +68,7 @@ describe('FrameSignature', () => {
       }),
     })
     const rpc = z.encode(z.FrameSignature.FrameSignature, entry)
-    expect(rpc.scheme).toBe(2)
+    expect(rpc.scheme).toBe('0x2')
     expect(z.decode(z.FrameSignature.FrameSignature, rpc)).toEqual({
       ...entry,
       signature: { r: entry.signature.r, s: entry.signature.s },
@@ -92,3 +92,67 @@ describe('FrameSignature', () => {
     ).toBe(false)
   })
 })
+
+test('encodes protocol hex signatures', () => {
+  const payload = Hash.keccak256('0xdeadbeef')
+  const privateKey = accounts[0].privateKey
+  const secp = FrameSignature.from({
+    scheme: 'secp256k1',
+    signature: Secp256k1.sign({ payload, privateKey }),
+  })
+  const p256 = FrameSignature.from({
+    publicKey: P256.getPublicKey({ privateKey }),
+    scheme: 'p256',
+    signature: P256.sign({ payload, privateKey }),
+  })
+
+  expect(
+    z.encode(z.FrameSignature.FrameSignature, {
+      ...secp,
+      signature: Signature.toHex(secp.signature),
+    }),
+  ).toEqual(FrameSignature.toRpc(secp))
+  expect(
+    z.encode(z.FrameSignature.FrameSignature, {
+      ...p256,
+      signature: Signature.toHex(p256.signature),
+    }),
+  ).toEqual(FrameSignature.toRpc(p256))
+})
+
+describe('RPC signers', () => {
+  test.each(['0x0', '0x1', '0x2'] as const)(
+    'accepts an empty signer for scheme %s',
+    (scheme) => {
+      expect(
+        z.safeDecode(z.FrameSignature.FrameSignature, {
+          scheme,
+          signer: '0x',
+          msg: '0x',
+          ...(scheme === '0x0' ? { signature: '0x' } : {}),
+        }).success,
+      ).toBe(true)
+    },
+  )
+  test('rejects a null signer', () => {
+    expect(
+      z.safeParse(z.FrameSignature.FrameSignature, {
+        scheme: '0x1',
+        signer: null,
+      }).success,
+    ).toBe(false)
+  })
+})
+
+describe('unsigned placeholders', () => {
+  test.each([
+    { scheme: 'secp256k1', signature: '0x' },
+    { scheme: 'p256', signature: '0x' },
+  ] as const)('$scheme', (entry) => {
+    const { signature: _, ...unsigned } = entry
+    expect(z.safeParse(z.FrameSignature.Decoded, entry).success).toBe(true)
+    expect(z.encode(z.FrameSignature.FrameSignature, entry)).toEqual(
+      FrameSignature.toRpc(unsigned),
+    )
+  })
+})

package/src/zod/_test/RpcSchema.test.ts

@@ -423,3 +423,109 @@ describe('from', () => {
     expect(schema.abe_foo.method).toMatchInlineSnapshot(`"abe_foo"`)
   })
 })
+
+describe('frame simulation results', () => {
+  test('preserves payer, per-frame output, errors, and gas through the codec', () => {
+    const block = {
+      difficulty: '0x0',
+      extraData: '0x',
+      gasLimit: '0x100000',
+      gasUsed: '0x5208',
+      hash,
+      logsBloom: '0x',
+      miner: address,
+      mixHash: hash,
+      nonce: '0x0000000000000000',
+      number: '0x1',
+      parentHash: hash,
+      receiptsRoot: hash,
+      sha3Uncles: hash,
+      size: '0x1',
+      stateRoot: hash,
+      timestamp: '0x1',
+      transactions: [],
+      transactionsRoot: hash,
+      uncles: [],
+      calls: [
+        {
+          payer: address,
+          gasUsed: '0x5208',
+          returnData: '0xdead',
+          status: '0x0',
+          logs: [],
+          frameResults: [
+            {
+              status: '0x1',
+              gasUsed: '0x2',
+              executionGasUsed: '0x1',
+              stateGasUsed: '0x1',
+              logs: [],
+              returnData: '0xabcd',
+            },
+            {
+              status: '0x0',
+              gasUsed: '0x1',
+              executionGasUsed: '0x1',
+              stateGasUsed: '0x0',
+              logs: [],
+              returnData: '0xdead',
+              error: { code: 3, message: 'execution reverted' },
+            },
+            {
+              status: '0x2',
+              gasUsed: '0x0',
+              executionGasUsed: '0x0',
+              stateGasUsed: '0x0',
+              logs: [],
+              returnData: '0x',
+            },
+          ],
+        },
+      ],
+    } satisfies z.input<typeof z_RpcSchema.Eth.eth_simulateV1.returns>[number]
+    const decoded = z_RpcSchema.decodeReturns(
+      z_RpcSchema.Eth,
+      'eth_simulateV1',
+      [block],
+    )
+    expect(decoded[0]?.calls).toEqual([
+      {
+        payer: address,
+        gasUsed: '0x5208',
+        returnData: '0xdead',
+        status: '0x0',
+        logs: [],
+        frameResults: [
+          {
+            status: 'success',
+            gasUsed: 2n,
+            executionGasUsed: 1n,
+            stateGasUsed: 1n,
+            logs: [],
+            returnData: '0xabcd',
+          },
+          {
+            status: 'reverted',
+            gasUsed: 1n,
+            executionGasUsed: 1n,
+            stateGasUsed: 0n,
+            logs: [],
+            returnData: '0xdead',
+            error: { code: 3, message: 'execution reverted' },
+          },
+          {
+            status: 'skipped',
+            gasUsed: 0n,
+            executionGasUsed: 0n,
+            stateGasUsed: 0n,
+            logs: [],
+            returnData: '0x',
+          },
+        ],
+      },
+    ])
+    expect(
+      z_RpcSchema.encodeReturns(z_RpcSchema.Eth, 'eth_simulateV1', decoded),
+    ).toEqual([block])
+  })
+})

package/src/zod/_test/TransactionRequest.test.ts

@@ -220,3 +220,64 @@ describe('TransactionRequest', () => {
     ).toBe(false)
   })
 })
+
+describe('frame requests', () => {
+  test.each([
+    z_TransactionRequest.TransactionRequest,
+    z_TransactionRequest.TransactionRequestToRpc,
+  ])('preserves gas omission and zero through the request codec', (schema) => {
+    const decoded = z.decode(schema, {
+      type: '0x6',
+      frames: [{ mode: '0x2' }, { mode: '0x2', stateGas: '0x0' }],
+    })
+    expect(decoded).toEqual({
+      type: 'eip8141',
+      frames: [
+        { mode: 2, flags: 0, data: '0x', value: 0n },
+        { mode: 2, flags: 0, data: '0x', value: 0n, stateGas: 0n },
+      ],
+    })
+    expect(z.encode(schema, decoded)).toEqual({
+      type: '0x6',
+      frames: [
+        { mode: '0x2', flags: '0x0', data: '0x', value: '0x0' },
+        {
+          mode: '0x2',
+          flags: '0x0',
+          data: '0x',
+          value: '0x0',
+          stateGas: '0x0',
+        },
+      ],
+    })
+  })
+  test('encodes numberish frame limits', () => {
+    expect(
+      z.encode(z_TransactionRequest.TransactionRequestToRpc, {
+        frames: [{ mode: 'sender', executionGas: 50000, stateGas: '0x0' }],
+      }),
+    ).toEqual({
+      frames: [
+        {
+          mode: '0x2',
+          flags: '0x0',
+          data: '0x',
+          value: '0x0',
+          executionGas: '0xc350',
+          stateGas: '0x0',
+        },
+      ],
+    })
+  })
+  test.each([
+    { mode: '0x3' },
+    { mode: '0x2', executionGas: '0x00' },
+    { mode: '0x2', stateGas: null },
+    {},
+  ])('rejects malformed frame request %j', (frame) => {
+    expect(
+      z.safeParse(z_TransactionRequest.TransactionRequest, { frames: [frame] })
+        .success,
+    ).toBe(false)
+  })
+})

package/src/zod/_test/TxEnvelopeEip8141.nonce.test.ts

@@ -0,0 +1,174 @@
+import { TxEnvelopeEip8141 } from 'ox'
+import { z } from 'ox/zod'
+import { describe, expect, test } from 'vp/test'
+
+const envelope = TxEnvelopeEip8141.from({
+  chainId: 1,
+  frames: [{}],
+  sender: '0x1111111111111111111111111111111111111111',
+  nonceKeys: [1n, 2n ** 256n - 1n],
+  nonce: 2n ** 64n - 2n,
+})
+const rpc = TxEnvelopeEip8141.toRpc(envelope)
+
+describe('TxEnvelopeEip8141', () => {
+  test('retains keyed nonces through envelope codecs', () => {
+    const decoded = z.decode(z.TransactionEnvelope.TransactionEnvelope, rpc)
+    expect(decoded).toEqual(TxEnvelopeEip8141.fromRpc(rpc))
+    expect(
+      z.encode(z.TransactionEnvelope.TransactionEnvelope, envelope),
+    ).toEqual(rpc)
+    expect(
+      z.encode(z.TransactionEnvelope.TransactionEnvelopeToRpc, {
+        ...envelope,
+        nonceKeys: ['0x1', 2n ** 256n - 1n],
+        nonce: '0xfffffffffffffffe',
+      }),
+    ).toEqual(rpc)
+    const serialized = z.encode(z.TransactionEnvelope.serialized, envelope)
+    expect(z.decode(z.TransactionEnvelope.serialized, serialized)).toEqual(
+      decoded,
+    )
+    expect(z.encode(z.TransactionEnvelope.Signed, envelope)).toEqual(rpc)
+  })
+
+  test.each([
+    { nonceKeys: [] },
+    { nonceKeys: ['0x0', '0x1'] },
+    { nonceKeys: ['0x2', '0x1'] },
+    { nonceKeys: ['0x1', '0x1'] },
+    { nonceKeys: ['0x01'] },
+    { nonceKeys: ['0x0'], nonce: '0xffffffffffffffff' },
+    { nonce: '0x10000000000000000' },
+    { nonce: '0x00' },
+    { nonce: undefined },
+    { nonceKeys: null },
+  ])('rejects invalid keyed RPC envelope %#', (fields) => {
+    expect(
+      z.safeDecode(z.TxEnvelopeEip8141.TxEnvelopeEip8141, {
+        ...rpc,
+        ...fields,
+      } as never).success,
+    ).toBe(false)
+  })
+
+  test('rejects invalid decoded and numberish keys', () => {
+    for (const keys of [[], [0n, 1n], [2n, 1n], [1n, 1n], [2n ** 256n]]) {
+      expect(
+        z.safeEncode(z.TxEnvelopeEip8141.TxEnvelopeEip8141, {
+          ...envelope,
+          nonceKeys: keys,
+        }).success,
+      ).toBe(false)
+      expect(
+        z.safeEncode(z.TxEnvelopeEip8141.TxEnvelopeEip8141ToRpc, {
+          ...envelope,
+          nonceKeys: keys,
+        }).success,
+      ).toBe(false)
+    }
+  })
+})
+
+describe('TransactionRequest', () => {
+  test('retains keys while leaving sequence and frame limits unassigned', () => {
+    const input = {
+      type: '0x6',
+      nonceKeys: ['0x1', '0x2'],
+      frames: [{ mode: '0x2' }, { mode: '0x2', executionGas: '0x0' }],
+    } as const
+    const decoded = z.decode(z.TransactionRequest.TransactionRequest, input)
+    expect(decoded.nonceKeys).toMatchInlineSnapshot(`
+      [
+        1n,
+        2n,
+      ]
+    `)
+    expect(decoded.nonce).toBeUndefined()
+    expect(decoded.frames?.map((frame) => frame.executionGas)).toEqual([
+      undefined,
+      0n,
+    ])
+    const encoded = z.encode(z.TransactionRequest.TransactionRequest, decoded)
+    expect(encoded.nonceKeys).toEqual(input.nonceKeys)
+    expect(encoded.nonce).toBeUndefined()
+    expect(
+      z.encode(z.TransactionRequest.TransactionRequestToRpc, {
+        nonceKeys: [1, '0x2'],
+        nonce: 0,
+      }).nonceKeys,
+    ).toEqual(input.nonceKeys)
+  })
+  test.each([[], ['0x0', '0x1'], ['0x2', '0x1'], ['0x01'], ['0x1', '0x1']])(
+    'rejects invalid keys %#',
+    (...nonceKeys) => {
+      expect(
+        z.safeDecode(z.TransactionRequest.TransactionRequest, {
+          nonceKeys,
+        } as never).success,
+      ).toBe(false)
+    },
+  )
+  test('rejects an exhausted sequence', () => {
+    expect(
+      z.safeDecode(z.TransactionRequest.TransactionRequest, {
+        nonceKeys: ['0x1'],
+        nonce: '0xffffffffffffffff',
+      }).success,
+    ).toBe(false)
+    expect(
+      z.safeEncode(z.TransactionRequest.TransactionRequestToRpc, {
+        nonceKeys: [1],
+        nonce: '0xffffffffffffffff',
+      }).success,
+    ).toBe(false)
+  })
+})
+
+describe('Transaction', () => {
+  const pending = {
+    ...rpc,
+    blockHash: null,
+    blockNumber: null,
+    transactionIndex: null,
+    hash: `0x${'11'.repeat(32)}`,
+  } as const
+  const mined = {
+    ...pending,
+    blockHash: `0x${'22'.repeat(32)}`,
+    blockNumber: '0x1',
+    transactionIndex: '0x0',
+  } as const
+  test('preserves pending and mined keyed transaction results', () => {
+    const decoded = z.decode(z.Transaction.PendingEip8141, pending)
+    expect(decoded.nonceKeys).toEqual(envelope.nonceKeys)
+    expect(z.encode(z.Transaction.PendingEip8141, decoded)).toEqual(pending)
+    const result = z.decode(z.Transaction.Transaction, mined)
+    expect('nonceKeys' in result && result.nonceKeys).toEqual(
+      envelope.nonceKeys,
+    )
+    expect(z.encode(z.Transaction.Transaction, result)).toEqual(mined)
+    expect(z.encode(z.Transaction.TransactionToRpc, result)).toEqual(mined)
+  })
+  test('rejects invalid keyed transaction results', () => {
+    for (const fields of [
+      { nonceKeys: ['0x2', '0x1'] },
+      { nonceKeys: ['0x0', '0x1'] },
+      { nonce: '0xffffffffffffffff' },
+      { nonce: undefined },
+    ]) {
+      expect(
+        z.safeDecode(z.Transaction.Transaction, {
+          ...mined,
+          ...fields,
+        } as never).success,
+      ).toBe(false)
+      expect(
+        z.safeDecode(z.Transaction.PendingEip8141, {
+          ...pending,
+          ...fields,
+        } as never).success,
+      ).toBe(false)
+    }
+  })
+})

package/src/zod/_test/TxEnvelopeEip8141.test-d.ts

@@ -0,0 +1,29 @@
+import type { Transaction, TransactionRequest, TxEnvelopeEip8141 } from 'ox'
+import { z } from 'ox/zod'
+import { describe, expectTypeOf, test } from 'vp/test'
+
+describe('TxEnvelopeEip8141', () => {
+  test('nonce keys preserve decoded, RPC, and numberish types', () => {
+    expectTypeOf<
+      z.output<typeof z.TxEnvelopeEip8141.Decoded>
+    >().toEqualTypeOf<TxEnvelopeEip8141.TxEnvelopeEip8141>()
+    expectTypeOf<
+      z.input<typeof z.TxEnvelopeEip8141.TxEnvelopeEip8141>
+    >().toEqualTypeOf<TxEnvelopeEip8141.Rpc>()
+    expectTypeOf<
+      z.output<typeof z.TxEnvelopeEip8141.TxEnvelopeEip8141ToRpc>
+    >().toMatchTypeOf<TxEnvelopeEip8141.toRpc.Input>()
+    expectTypeOf<
+      z.output<typeof z.TransactionRequest.TransactionRequest>['nonceKeys']
+    >().toEqualTypeOf<TransactionRequest.TransactionRequest['nonceKeys']>()
+    expectTypeOf<
+      z.input<typeof z.TransactionRequest.TransactionRequest>['nonceKeys']
+    >().toEqualTypeOf<TransactionRequest.Rpc['nonceKeys']>()
+    expectTypeOf<
+      z.output<typeof z.Transaction.Eip8141>['nonceKeys']
+    >().toEqualTypeOf<Transaction.Eip8141['nonceKeys']>()
+    expectTypeOf<
+      z.input<typeof z.Transaction.Eip8141>['nonceKeys']
+    >().toEqualTypeOf<Transaction.Eip8141Rpc['nonceKeys']>()
+  })
+})

package/src/zod/_test/TxEnvelopeEip8141.test.ts

@@ -75,10 +75,10 @@ describe('TxEnvelopeEip8141', () => {
     expect(
       z.encode(z.TxEnvelopeEip8141.TxEnvelopeEip8141ToRpc, {
         chainId: '0x1',
-        frames: [{ gas: 50_000 }],
+        frames: [{ executionGas: 50_000 }],
         sender: accounts[0].address,
         type: 'eip8141',
-      }).frames[0]!.executionGasLimit,
+      }).frames[0]!.executionGas,
     ).toBe('0xc350')
   })
 })
@@ -107,7 +107,7 @@ describe('invalid envelopes', () => {
   test('rejects malformed nested RPC signatures without throwing', () => {
     const rpc = {
       ...TxEnvelopeEip8141.toRpc(envelope),
-      signatures: [{ msg: '0x', scheme: 1, signature: '0x01' }],
+      signatures: [{ msg: '0x', scheme: '0x1', signature: '0x01' }],
     } as const
     expect(
       z.safeDecode(z.TxEnvelopeEip8141.TxEnvelopeEip8141, rpc).success,