ox 1.0.0-beta.2 → 1.0.0-beta.20

package/src/core/_test/AbiParameter.test-d.ts

@@ -0,0 +1,41 @@
+import { AbiParameter } from 'ox'
+import { describe, expectTypeOf, test } from 'vp/test'
+
+describe('AbiParameter.format', () => {
+  test('infers parameter', () => {
+    const formatted = AbiParameter.format(value)
+    expectTypeOf(formatted).toEqualTypeOf<'address spender'>()
+  })
+
+  test('not narrowable', () => {
+    const formatted = AbiParameter.format({} as AbiParameter.AbiParameter)
+    expectTypeOf(formatted).toEqualTypeOf<string>()
+  })
+
+  const value = {
+    name: 'spender',
+    type: 'address',
+  } as const
+})
+
+describe('AbiParameter.from', () => {
+  test('infers parameter', () => {
+    const parameter = AbiParameter.from(value)
+    expectTypeOf(parameter).toEqualTypeOf(value)
+  })
+
+  test('from signature', () => {
+    const parameter = AbiParameter.from('address spender')
+    expectTypeOf(parameter).toEqualTypeOf(value)
+  })
+
+  test('not narrowable', () => {
+    const parameter = AbiParameter.from({} as AbiParameter.AbiParameter)
+    expectTypeOf(parameter).toEqualTypeOf<AbiParameter.AbiParameter>()
+  })
+
+  const value = {
+    name: 'spender',
+    type: 'address',
+  } as const
+})

package/src/core/_test/AbiParameter.test.ts

@@ -0,0 +1,84 @@
+import { AbiParameter } from 'ox'
+import { describe, expect, test } from 'vp/test'
+
+describe('from', () => {
+  test('json parameter', () => {
+    expect(AbiParameter.from({ name: 'spender', type: 'address' }))
+      .toMatchInlineSnapshot(`
+      {
+        "name": "spender",
+        "type": "address",
+      }
+    `)
+  })
+
+  test('human-readable parameter', () => {
+    expect(AbiParameter.from('address spender')).toMatchInlineSnapshot(`
+      {
+        "name": "spender",
+        "type": "address",
+      }
+    `)
+  })
+
+  test('human-readable parameter with structs', () => {
+    expect(
+      AbiParameter.from([
+        'struct Foo { address spender; uint256 amount; }',
+        'Foo foo',
+      ]),
+    ).toMatchInlineSnapshot(`
+      {
+        "components": [
+          {
+            "name": "spender",
+            "type": "address",
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+          },
+        ],
+        "name": "foo",
+        "type": "tuple",
+      }
+    `)
+  })
+})
+
+describe('format', () => {
+  test('parameter', () => {
+    expect(
+      AbiParameter.format({ name: 'spender', type: 'address' }),
+    ).toMatchInlineSnapshot(`"address spender"`)
+  })
+
+  test('tuple parameter', () => {
+    expect(
+      AbiParameter.format({
+        components: [
+          { name: 'spender', type: 'address' },
+          { name: 'amount', type: 'uint256' },
+        ],
+        name: 'foo',
+        type: 'tuple',
+      }),
+    ).toMatchInlineSnapshot(`"(address spender, uint256 amount) foo"`)
+  })
+})
+
+test('exports', () => {
+  expect(Object.keys(AbiParameter)).toMatchInlineSnapshot(`
+    [
+      "InvalidAbiParameterError",
+      "InvalidAbiTypeParameterError",
+      "InvalidFunctionModifierError",
+      "InvalidModifierError",
+      "InvalidParameterError",
+      "SolidityProtectedKeywordError",
+      "InvalidParenthesisError",
+      "format",
+      "from",
+    ]
+  `)
+})

package/src/core/_test/AbiParameters.decode.test.ts

@@ -1601,22 +1601,12 @@ test('zst', () => {
   expect(() =>
     AbiParameters.decode([{ type: 'uint256[0][4294967295]' }], payload),
   ).toThrowErrorMatchingInlineSnapshot(
-    `
-    [AbiParameters.DataSizeTooSmallError: Data size of 64 bytes is too small for given parameters.
-
-    Params: (uint256[0][4294967295])
-    Data:   0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000FFFFFFFF (64 bytes)]
-  `,
+    '[Cursor.RecursiveReadLimitExceededError: Recursive read limit of `8192` exceeded (recursive read count: `8193`).]',
   )
   expect(() =>
     AbiParameters.decode([{ type: 'uint32[0][4294967295]' }], payload),
   ).toThrowErrorMatchingInlineSnapshot(
-    `
-    [AbiParameters.DataSizeTooSmallError: Data size of 64 bytes is too small for given parameters.
-
-    Params: (uint32[0][4294967295])
-    Data:   0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000FFFFFFFF (64 bytes)]
-  `,
+    '[Cursor.RecursiveReadLimitExceededError: Recursive read limit of `8192` exceeded (recursive read count: `8193`).]',
   )
   expect(() =>
     AbiParameters.decode(
@@ -1798,3 +1788,89 @@ test('recursive 2', () => {
     '[Cursor.RecursiveReadLimitExceededError: Recursive read limit of `8192` exceeded (recursive read count: `8193`).]',
   )
 })
+
+describe('zero-width types', () => {
+  test('zero-length fixed array', () => {
+    expect(
+      AbiParameters.decode(
+        [{ type: 'uint256[0]' }, { type: 'uint256' }],
+        '0x0000000000000000000000000000000000000000000000000000000000000003',
+      ),
+    ).toEqual([[], 3n])
+  })
+
+  test('trailing empty tuple', () => {
+    expect(
+      AbiParameters.decode(
+        [{ type: 'uint256' }, { type: 'tuple', components: [] }],
+        '0x0000000000000000000000000000000000000000000000000000000000000005',
+      ),
+    ).toEqual([5n, []])
+  })
+
+  test('zero-length fixed array of dynamic type', () => {
+    expect(
+      AbiParameters.decode(
+        [{ type: 'string[0]' }, { type: 'uint256' }],
+        '0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000003',
+      ),
+    ).toEqual([[], 3n])
+  })
+
+  test('standalone zero-length fixed array of dynamic type', () => {
+    // The head is a single offset word pointing at an empty tail.
+    expect(
+      AbiParameters.decode(
+        [{ type: 'string[0]' }],
+        '0x0000000000000000000000000000000000000000000000000000000000000020',
+      ),
+    ).toEqual([[]])
+    expect(
+      AbiParameters.decode(
+        [{ type: 'bytes[0]' }],
+        '0x0000000000000000000000000000000000000000000000000000000000000020',
+      ),
+    ).toEqual([[]])
+  })
+
+  test('round-trip', () => {
+    const cases = [
+      {
+        parameters: [{ type: 'uint256[0]' }, { type: 'uint256' }],
+        values: [[], 3n],
+      },
+      {
+        parameters: [{ type: 'uint256' }, { type: 'tuple', components: [] }],
+        values: [5n, []],
+      },
+      {
+        parameters: [{ type: 'string[0]' }, { type: 'uint256' }],
+        values: [[], 3n],
+      },
+      {
+        parameters: [{ type: 'uint256[0]' }, { type: 'string' }],
+        values: [[], 'hello'],
+      },
+      {
+        parameters: [{ type: 'uint256[0][2]' }, { type: 'uint256' }],
+        values: [[[], []], 9n],
+      },
+      {
+        parameters: [{ type: 'string[0]' }],
+        values: [[]],
+      },
+      {
+        parameters: [{ type: 'tuple', components: [{ type: 'string[0]' }] }],
+        values: [[[]]],
+      },
+    ] as const
+    for (const { parameters, values } of cases) {
+      expect(
+        AbiParameters.decode(
+          parameters,
+          AbiParameters.encode(parameters, values as never),
+        ),
+      ).toEqual(values)
+    }
+  })
+})

package/src/core/_test/AbiParameters.encode.test.ts

@@ -1963,3 +1963,71 @@ test('https://github.com/wevm/viem/issues/1960', () => {
     `[BaseError: Invalid boolean value: "true" (type: string). Expected: \`true\` or \`false\`.]`,
   )
 })
+
+describe('zero-width types', () => {
+  // Per the ABI spec, `enc(T[0])` and `enc(())` are zero-length: a zero-length
+  // fixed array or empty tuple contributes no bytes. Expected values verified
+  // against ethers `AbiCoder.defaultAbiCoder()`.
+  test('zero-length fixed array', () => {
+    expect(
+      AbiParameters.encode(
+        [{ type: 'uint256[0]' }, { type: 'uint256' }],
+        [[], 3n],
+      ),
+    ).toBe('0x0000000000000000000000000000000000000000000000000000000000000003')
+  })
+
+  test('empty tuple', () => {
+    expect(
+      AbiParameters.encode(
+        [{ type: 'uint256' }, { type: 'tuple', components: [] }],
+        [5n, []],
+      ),
+    ).toBe('0x0000000000000000000000000000000000000000000000000000000000000005')
+  })
+
+  test('empty tuple only', () => {
+    expect(
+      AbiParameters.encode([{ type: 'tuple', components: [] }], [[]]),
+    ).toBe('0x')
+  })
+
+  test('nested zero-length fixed arrays', () => {
+    expect(
+      AbiParameters.encode(
+        [{ type: 'uint256[0][2]' }, { type: 'uint256' }],
+        [[[], []], 9n],
+      ),
+    ).toBe('0x0000000000000000000000000000000000000000000000000000000000000009')
+    expect(
+      AbiParameters.encode(
+        [{ type: 'uint256[2][0]' }, { type: 'uint256' }],
+        [[], 9n],
+      ),
+    ).toBe('0x0000000000000000000000000000000000000000000000000000000000000009')
+  })
+
+  test('offsets skip zero-width parameters', () => {
+    expect(
+      AbiParameters.encode(
+        [{ type: 'uint256[0]' }, { type: 'string' }],
+        [[], 'hello'],
+      ),
+    ).toBe(
+      '0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000568656c6c6f000000000000000000000000000000000000000000000000000000',
+    )
+  })
+
+  // `T[0]` of a dynamic `T` is dynamic per the ABI spec: 32-byte offset
+  // pointing at a zero-length tail.
+  test('zero-length fixed array of dynamic type', () => {
+    expect(
+      AbiParameters.encode(
+        [{ type: 'string[0]' }, { type: 'uint256' }],
+        [[], 3n],
+      ),
+    ).toBe(
+      '0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000003',
+    )
+  })
+})

package/src/core/_test/AbiParameters.test.ts

@@ -360,6 +360,13 @@ describe('format', () => {
 test('exports', () => {
   expect(Object.keys(AbiParameters)).toMatchInlineSnapshot(`
     [
+      "InvalidAbiParametersError",
+      "InvalidAbiTypeParameterError",
+      "InvalidFunctionModifierError",
+      "InvalidModifierError",
+      "InvalidParameterError",
+      "SolidityProtectedKeywordError",
+      "InvalidParenthesisError",
       "decode",
       "encode",
       "encodePacked",

package/src/core/_test/AccountProof.test.ts

@@ -90,6 +90,62 @@ describe('toRpc', () => {
     `)
   })
 
+  test('numberish inputs', () => {
+    const fromBigint = AccountProof.toRpc({
+      address: '0xb9CAB4F0E46F7F6b1024b5A7463734fa68E633f9',
+      balance: 1n,
+      codeHash:
+        '0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470',
+      nonce: 2,
+      storageHash:
+        '0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421',
+      accountProof: ['0xabcd', '0x1234'],
+      storageProof: [
+        {
+          key: '0x0000000000000000000000000000000000000000000000000000000000000000',
+          proof: ['0xdead'],
+          value: 3n,
+        },
+      ],
+    })
+    const fromNumber = AccountProof.toRpc({
+      address: '0xb9CAB4F0E46F7F6b1024b5A7463734fa68E633f9',
+      balance: 1,
+      codeHash:
+        '0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470',
+      nonce: 2,
+      storageHash:
+        '0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421',
+      accountProof: ['0xabcd', '0x1234'],
+      storageProof: [
+        {
+          key: '0x0000000000000000000000000000000000000000000000000000000000000000',
+          proof: ['0xdead'],
+          value: 3,
+        },
+      ],
+    })
+    const fromHex = AccountProof.toRpc({
+      address: '0xb9CAB4F0E46F7F6b1024b5A7463734fa68E633f9',
+      balance: '0x1',
+      codeHash:
+        '0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470',
+      nonce: '0x2',
+      storageHash:
+        '0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421',
+      accountProof: ['0xabcd', '0x1234'],
+      storageProof: [
+        {
+          key: '0x0000000000000000000000000000000000000000000000000000000000000000',
+          proof: ['0xdead'],
+          value: '0x3',
+        },
+      ],
+    })
+    expect(fromBigint).toEqual(fromNumber)
+    expect(fromBigint).toEqual(fromHex)
+  })
+
   test('round-trip', () => {
     const value = {
       address: '0xb9CAB4F0E46F7F6b1024b5A7463734fa68E633f9',

package/src/core/_test/Authorization.test.ts

@@ -425,6 +425,35 @@ describe('toRpc', () => {
       }
     `)
   })
+
+  test('numberish inputs', () => {
+    const fromBigint = Authorization.toRpc({
+      address: '0x0000000000000000000000000000000000000000',
+      chainId: 1,
+      nonce: 1n,
+      r: '0x635dc2033e60185bb36709c29c75d64ea51dfbd91c32ef4be198e4ceb169fb4d',
+      s: '0x50c2667ac4c771072746acfdcf1f1483336dcca8bd2df47cd83175dbe60f0540',
+      yParity: 0,
+    })
+    const fromNumber = Authorization.toRpc({
+      address: '0x0000000000000000000000000000000000000000',
+      chainId: 1,
+      nonce: 1,
+      r: '0x635dc2033e60185bb36709c29c75d64ea51dfbd91c32ef4be198e4ceb169fb4d',
+      s: '0x50c2667ac4c771072746acfdcf1f1483336dcca8bd2df47cd83175dbe60f0540',
+      yParity: 0,
+    })
+    const fromHex = Authorization.toRpc({
+      address: '0x0000000000000000000000000000000000000000',
+      chainId: '0x1',
+      nonce: '0x1',
+      r: '0x635dc2033e60185bb36709c29c75d64ea51dfbd91c32ef4be198e4ceb169fb4d',
+      s: '0x50c2667ac4c771072746acfdcf1f1483336dcca8bd2df47cd83175dbe60f0540',
+      yParity: 0,
+    })
+    expect(fromBigint).toEqual(fromNumber)
+    expect(fromBigint).toEqual(fromHex)
+  })
 })
 
 describe('toRpcList', () => {

package/src/core/_test/Block.test.ts

@@ -548,6 +548,104 @@ describe('toRpc', () => {
     `)
   })
 
+  test('numberish inputs', () => {
+    const input = {
+      extraData: '0x',
+      hash: '0xebc3644804e4040c0a74c5a5bbbc6b46a71a5d4010fe0c92ebb2fdf4a43ea5dd',
+      logsBloom:
+        '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      miner: '0x0000000000000000000000000000000000000000',
+      mixHash:
+        '0x0000000000000000000000000000000000000000000000000000000000000000',
+      nonce: '0x0000000000000000',
+      parentBeaconBlockRoot: undefined,
+      parentHash:
+        '0xe55516ad8029e53cd32087f14653d851401b05245abb1b2d6ed4ddcc597ac5a6',
+      receiptsRoot:
+        '0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421',
+      sealFields: [
+        '0x0000000000000000000000000000000000000000000000000000000000000000',
+        '0x0000000000000000',
+      ],
+      sha3Uncles:
+        '0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347',
+      stateRoot:
+        '0x0000000000000000000000000000000000000000000000000000000000000000',
+      transactions: [],
+      transactionsRoot:
+        '0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421',
+      uncles: [],
+      withdrawalsRoot:
+        '0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421',
+    } satisfies Partial<Parameters<typeof Block.toRpc>[0]>
+    const fromBigint = Block.toRpc({
+      ...input,
+      baseFeePerGas: 1n,
+      blobGasUsed: 2n,
+      difficulty: 3n,
+      excessBlobGas: 4n,
+      gasLimit: 5n,
+      gasUsed: 6n,
+      number: 7n,
+      size: 8n,
+      timestamp: 9n,
+      totalDifficulty: 10n,
+      withdrawals: [
+        {
+          address: '0xb9d7934878b5fb9610b3fe8a5e441e8fad7e293f',
+          amount: 11n,
+          index: 12,
+          validatorIndex: 13,
+        },
+      ],
+    })
+    const fromNumber = Block.toRpc({
+      ...input,
+      baseFeePerGas: 1,
+      blobGasUsed: 2,
+      difficulty: 3,
+      excessBlobGas: 4,
+      gasLimit: 5,
+      gasUsed: 6,
+      number: 7,
+      size: 8,
+      timestamp: 9,
+      totalDifficulty: 10,
+      withdrawals: [
+        {
+          address: '0xb9d7934878b5fb9610b3fe8a5e441e8fad7e293f',
+          amount: 11,
+          index: 12,
+          validatorIndex: 13,
+        },
+      ],
+    })
+    const fromHex = Block.toRpc({
+      ...input,
+      baseFeePerGas: '0x1',
+      blobGasUsed: '0x2',
+      difficulty: '0x3',
+      excessBlobGas: '0x4',
+      gasLimit: '0x5',
+      gasUsed: '0x6',
+      number: '0x7',
+      size: '0x8',
+      timestamp: '0x9',
+      totalDifficulty: '0xa',
+      withdrawals: [
+        {
+          address: '0xb9d7934878b5fb9610b3fe8a5e441e8fad7e293f',
+          amount: '0xb',
+          index: '0xc',
+          validatorIndex: '0xd',
+        },
+      ],
+    })
+
+    expect(fromBigint).toEqual(fromNumber)
+    expect(fromBigint).toEqual(fromHex)
+  })
+
   test('behavior: nullish values', () => {
     const block = Block.toRpc(
       {

package/src/core/_test/BlockOverrides.test.ts

@@ -107,4 +107,54 @@ describe('toRpc', () => {
       }
     `)
   })
+
+  test('numberish inputs', () => {
+    const input = {
+      feeRecipient: '0x0000000000000000000000000000000000000000',
+      withdrawals: [
+        {
+          address: '0x0000000000000000000000000000000000000000',
+          amount: 1n,
+          index: 0,
+          validatorIndex: 1,
+        },
+        {
+          address: '0x0000000000000000000000000000000000000000',
+          amount: 1n,
+          index: 0,
+          validatorIndex: 1,
+        },
+      ],
+    } satisfies Parameters<typeof BlockOverrides.toRpc>[0]
+    const fromBigint = BlockOverrides.toRpc({
+      ...input,
+      baseFeePerGas: 1n,
+      blobBaseFee: 2n,
+      gasLimit: 4n,
+      number: 5n,
+      prevRandao: 6n,
+      time: 78187493520n,
+    })
+    const fromNumber = BlockOverrides.toRpc({
+      ...input,
+      baseFeePerGas: 1,
+      blobBaseFee: 2,
+      gasLimit: 4,
+      number: 5,
+      prevRandao: 6,
+      time: 78187493520,
+    })
+    const fromHex = BlockOverrides.toRpc({
+      ...input,
+      baseFeePerGas: '0x1',
+      blobBaseFee: '0x2',
+      gasLimit: '0x4',
+      number: '0x5',
+      prevRandao: '0x6',
+      time: '0x1234567890',
+    })
+
+    expect(fromBigint).toEqual(fromNumber)
+    expect(fromBigint).toEqual(fromHex)
+  })
 })

package/src/core/_test/Filter.test.ts

@@ -122,6 +122,38 @@ describe('toRpc', () => {
     }
   })
 
+  test('numberish inputs', () => {
+    const fromBigint = Filter.toRpc({
+      fromBlock: 69420n,
+      toBlock: 69421n,
+      topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        null,
+        '0x0000000000000000000000000c04d9e9278ec5e4d424476d3ebec70cb5d648d1',
+      ],
+    })
+    const fromNumber = Filter.toRpc({
+      fromBlock: 69420,
+      toBlock: 69421,
+      topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        null,
+        '0x0000000000000000000000000c04d9e9278ec5e4d424476d3ebec70cb5d648d1',
+      ],
+    })
+    const fromHex = Filter.toRpc({
+      fromBlock: '0x10f2c',
+      toBlock: '0x10f2d',
+      topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        null,
+        '0x0000000000000000000000000c04d9e9278ec5e4d424476d3ebec70cb5d648d1',
+      ],
+    })
+    expect(fromBigint).toEqual(fromNumber)
+    expect(fromBigint).toEqual(fromHex)
+  })
+
   test('behavior: preserves explicit `address: null`', () => {
     const filter = Filter.toRpc({
       address: null,

package/src/core/_test/Log.test.ts

@@ -170,6 +170,48 @@ describe('toRpc', () => {
     `)
   })
 
+  test('numberish inputs', () => {
+    const input = {
+      address: '0xfba3912ca04dd458c843e2ee08967fc04f3579c2',
+      blockHash:
+        '0xabe69134e80a12f6a93d0aa18215b5b86c2fb338bae911790ca374a8716e01a4',
+      data: '0x',
+      removed: false,
+      topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        '0x0000000000000000000000000000000000000000000000000000000000000000',
+        '0x0000000000000000000000000c04d9e9278ec5e4d424476d3ebec70cb5d648d1',
+        '0x000000000000000000000000000000000000000000000000000000000000025b',
+      ],
+      transactionHash:
+        '0xcfa52db0bc2cb5bdcb2c5bd8816df7a2f018a0e3964ab1ef4d794cf327966e93',
+    } satisfies Partial<Parameters<typeof Log.toRpc>[0]>
+    const fromBigint = Log.toRpc({
+      ...input,
+      blockNumber: 19760236n,
+      blockTimestamp: 1714384847n,
+      logIndex: 271,
+      transactionIndex: 145,
+    })
+    const fromNumber = Log.toRpc({
+      ...input,
+      blockNumber: 19760236,
+      blockTimestamp: 1714384847,
+      logIndex: 271,
+      transactionIndex: 145,
+    })
+    const fromHex = Log.toRpc({
+      ...input,
+      blockNumber: '0x12d846c',
+      blockTimestamp: '0x662f6fcf',
+      logIndex: '0x10f',
+      transactionIndex: '0x91',
+    })
+
+    expect(fromBigint).toEqual(fromNumber)
+    expect(fromBigint).toEqual(fromHex)
+  })
+
   test('behavior: nullish values', () => {
     const log = Log.toRpc(
       {