ox 1.8.12 → 1.8.13

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

@@ -1021,7 +1021,201 @@ describe('fromAbi', () => {
     `)
   })
 
+  test('behavior: overloads: bytes32 vs bytes', () => {
+    expect(() =>
+      AbiItem.fromAbi(
+        Abi.from([
+          'function isValidSignature(bytes32 hash, bytes signature)',
+          'function isValidSignature(bytes data, bytes signature)',
+        ]),
+        'isValidSignature',
+        {
+          args: [
+            '0x0000000000000000000000000000000000000000000000000000000000000001',
+            '0x1234',
+          ],
+        },
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      [AbiItem.AmbiguityError: Found ambiguous types in overloaded ABI Items.
+
+      \`bytes\` in \`isValidSignature(bytes,bytes)\`, and
+      \`bytes32\` in \`isValidSignature(bytes32,bytes)\`
+
+      These types encode differently and cannot be distinguished at runtime.
+      Remove one of the ambiguous items in the ABI.]
+    `)
+  })
+
+  test('behavior: overloads: uint256 vs int256', () => {
+    expect(() =>
+      AbiItem.fromAbi(
+        Abi.from(['function foo(uint256 x)', 'function foo(int256 x)']),
+        'foo',
+        { args: [1n] },
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      [AbiItem.AmbiguityError: Found ambiguous types in overloaded ABI Items.
+
+      \`int256\` in \`foo(int256)\`, and
+      \`uint256\` in \`foo(uint256)\`
+
+      These types encode differently and cannot be distinguished at runtime.
+      Remove one of the ambiguous items in the ABI.]
+    `)
+
+    expect(
+      AbiItem.fromAbi(
+        Abi.from(['function foo(uint256 x)', 'function foo(int256 x)']),
+        'foo',
+        { args: [-1n] },
+      ).inputs,
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "name": "x",
+          "type": "int256",
+        },
+      ]
+    `)
+  })
+
+  test('behavior: overloads: uint256[] vs uint256[2]', () => {
+    expect(() =>
+      AbiItem.fromAbi(
+        Abi.from(['function foo(uint256[] x)', 'function foo(uint256[2] x)']),
+        'foo',
+        { args: [[1n, 1n]] },
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      [AbiItem.AmbiguityError: Found ambiguous types in overloaded ABI Items.
+
+      \`uint256[2]\` in \`foo(uint256[2])\`, and
+      \`uint256[]\` in \`foo(uint256[])\`
+
+      These types encode differently and cannot be distinguished at runtime.
+      Remove one of the ambiguous items in the ABI.]
+    `)
+
+    expect(
+      AbiItem.fromAbi(
+        Abi.from(['function foo(uint256[] x)', 'function foo(uint256[2] x)']),
+        'foo',
+        { args: [[1n, 1n, 1n]] },
+      ).inputs,
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "name": "x",
+          "type": "uint256[]",
+        },
+      ]
+    `)
+  })
+
+  test('behavior: overloads: uint256[2][] vs uint256[][2]', () => {
+    expect(() =>
+      AbiItem.fromAbi(
+        Abi.from([
+          'function foo(uint256[2][] x)',
+          'function foo(uint256[][2] x)',
+        ]),
+        'foo',
+        {
+          args: [
+            [
+              [1n, 1n],
+              [1n, 1n],
+            ],
+          ],
+        },
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      [AbiItem.AmbiguityError: Found ambiguous types in overloaded ABI Items.
+
+      \`uint256[]\` in \`foo(uint256[][2])\`, and
+      \`uint256[2]\` in \`foo(uint256[2][])\`
+
+      These types encode differently and cannot be distinguished at runtime.
+      Remove one of the ambiguous items in the ABI.]
+    `)
+  })
+
+  test('behavior: overloads: selector chooses one of two matches', () => {
+    expect(
+      AbiItem.fromAbi(
+        Abi.from([
+          'function isValidSignature(bytes32 hash, bytes signature)',
+          'function isValidSignature(bytes data, bytes signature)',
+        ]),
+        '0x1626ba7e',
+        {
+          args: [
+            '0x0000000000000000000000000000000000000000000000000000000000000001',
+            '0x1234',
+          ],
+        },
+      ).inputs,
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "name": "hash",
+          "type": "bytes32",
+        },
+        {
+          "name": "signature",
+          "type": "bytes",
+        },
+      ]
+    `)
+  })
+
   describe('getAmbiguousTypes', () => {
+    test('bytes', () => {
+      expect(
+        getAmbiguousTypes(
+          AbiParameters.from('bytes32'),
+          AbiParameters.from('bytes'),
+          [
+            '0x0000000000000000000000000000000000000000000000000000000000000001',
+          ],
+        ),
+      ).toMatchInlineSnapshot(`
+        [
+          "bytes32",
+          "bytes",
+        ]
+      `)
+    })
+
+    test('integers', () => {
+      expect(
+        getAmbiguousTypes(
+          AbiParameters.from('uint256'),
+          AbiParameters.from('int256'),
+          [1n],
+        ),
+      ).toMatchInlineSnapshot(`
+        [
+          "uint256",
+          "int256",
+        ]
+      `)
+
+      expect(
+        getAmbiguousTypes(
+          AbiParameters.from('uint256'),
+          AbiParameters.from('uint128'),
+          [69420n],
+        ),
+      ).toMatchInlineSnapshot(`
+        [
+          "uint256",
+          "uint128",
+        ]
+      `)
+    })
+
     test('string/address', () => {
       expect(
         getAmbiguousTypes(
@@ -1163,7 +1357,7 @@ describe('fromAbi', () => {
       expect(
         getAmbiguousTypes(
           AbiParameters.from('uint256, (address)'),
-          AbiParameters.from('uint128, (bytes20)'),
+          AbiParameters.from('uint256, (bytes20)'),
           [69420n, ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e']],
         ),
       ).toMatchInlineSnapshot(`
@@ -1175,7 +1369,7 @@ describe('fromAbi', () => {
       expect(
         getAmbiguousTypes(
           AbiParameters.from('uint256, (string, (address))'),
-          AbiParameters.from('uint128, (string, (bytes20))'),
+          AbiParameters.from('uint256, (string, (bytes20))'),
           [69420n, ['foo', ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e']]],
         ),
       ).toMatchInlineSnapshot(`
@@ -1187,7 +1381,7 @@ describe('fromAbi', () => {
       expect(
         getAmbiguousTypes(
           AbiParameters.from('uint256, (string, (address, bytes))'),
-          AbiParameters.from('uint128, (string, (bytes20, address))'),
+          AbiParameters.from('uint256, (string, (bytes20, address))'),
           [
             123n,
             [
@@ -1360,7 +1554,19 @@ describe('fromAbi', () => {
     { arg: 'true', abiParameter: { type: 'bool' }, expected: false },
     // bytes
     { arg: 'foo', abiParameter: { type: 'bytes' }, expected: true },
-    { arg: 'foo', abiParameter: { type: 'bytes32' }, expected: true },
+    { arg: 'foo', abiParameter: { type: 'bytes32' }, expected: false },
+    { arg: '0x1234', abiParameter: { type: 'bytes2' }, expected: true },
+    { arg: '0x1234', abiParameter: { type: 'bytes4' }, expected: false },
+    {
+      arg: Bytes.fromString('foo'),
+      abiParameter: { type: 'bytes3' },
+      expected: true,
+    },
+    {
+      arg: Bytes.fromString('foo'),
+      abiParameter: { type: 'bytes4' },
+      expected: false,
+    },
     {
       arg: Bytes.fromString('foo'),
       abiParameter: { type: 'bytes' },
@@ -1381,6 +1587,34 @@ describe('fromAbi', () => {
     { arg: 1, abiParameter: { type: 'uint256' }, expected: true },
     { arg: 1, abiParameter: { type: 'int69' }, expected: false },
     { arg: 1, abiParameter: { type: 'uint69' }, expected: false },
+    { arg: -129, abiParameter: { type: 'int8' }, expected: false },
+    { arg: -128, abiParameter: { type: 'int8' }, expected: true },
+    { arg: 127, abiParameter: { type: 'int8' }, expected: true },
+    { arg: 128, abiParameter: { type: 'int8' }, expected: false },
+    { arg: -1n, abiParameter: { type: 'uint8' }, expected: false },
+    { arg: 0n, abiParameter: { type: 'uint8' }, expected: true },
+    { arg: 255n, abiParameter: { type: 'uint8' }, expected: true },
+    { arg: 256n, abiParameter: { type: 'uint8' }, expected: false },
+    { arg: 2n ** 256n - 1n, abiParameter: { type: 'uint256' }, expected: true },
+    { arg: 2n ** 256n, abiParameter: { type: 'uint256' }, expected: false },
+    { arg: -(2n ** 255n), abiParameter: { type: 'int256' }, expected: true },
+    {
+      arg: -(2n ** 255n) - 1n,
+      abiParameter: { type: 'int256' },
+      expected: false,
+    },
+    { arg: Number.NaN, abiParameter: { type: 'uint256' }, expected: false },
+    {
+      arg: Number.POSITIVE_INFINITY,
+      abiParameter: { type: 'uint256' },
+      expected: false,
+    },
+    { arg: 1.5, abiParameter: { type: 'uint256' }, expected: false },
+    {
+      arg: Number.MAX_SAFE_INTEGER + 1,
+      abiParameter: { type: 'uint256' },
+      expected: true,
+    },
     // string
     { arg: 'foo', abiParameter: { type: 'string' }, expected: true },
     { arg: 1, abiParameter: { type: 'string' }, expected: false },

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

@@ -1,4 +1,4 @@
-import { AbiItem, AbiParameters, type Address, Bytes, type Hex } from 'ox'
+import { AbiItem, AbiParameters, Address, Bytes, Hex } from 'ox'
 import { assertType, describe, expect, test } from 'vp/test'
 
 import {
@@ -1887,3 +1887,142 @@ describe('zero-width types', () => {
     }
   })
 })
+
+describe('integer range', () => {
+  test('uint8: max', () => {
+    expect(
+      AbiParameters.decode(
+        AbiParameters.from('uint8'),
+        '0x00000000000000000000000000000000000000000000000000000000000000ff',
+      ),
+    ).toEqual([255])
+  })
+
+  test('uint8: above max', () => {
+    expect(() =>
+      AbiParameters.decode(
+        AbiParameters.from('uint8'),
+        '0x0000000000000000000000000000000000000000000000000000000000000100',
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Hex.IntegerOutOfRangeError: Number \`256\` is not in safe 8-bit unsigned integer range (\`0\` to \`255\`)]`,
+    )
+  })
+
+  test('int8: -1', () => {
+    expect(
+      AbiParameters.decode(
+        AbiParameters.from('int8'),
+        '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
+      ),
+    ).toEqual([-1])
+  })
+
+  test('int8: missing sign extension', () => {
+    expect(() =>
+      AbiParameters.decode(
+        AbiParameters.from('int8'),
+        '0x0000000000000000000000000000000000000000000000000000000000000080',
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Hex.IntegerOutOfRangeError: Number \`128\` is not in safe 8-bit signed integer range (\`-128\` to \`127\`)]`,
+    )
+  })
+
+  test('int8: below min', () => {
+    expect(() =>
+      AbiParameters.decode(
+        AbiParameters.from('int8'),
+        '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f',
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Hex.IntegerOutOfRangeError: Number \`-129\` is not in safe 8-bit signed integer range (\`-128\` to \`127\`)]`,
+    )
+  })
+
+  test('uint8[]: element above max', () => {
+    expect(() =>
+      AbiParameters.decode(
+        AbiParameters.from('uint8[]'),
+        '0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000100',
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Hex.IntegerOutOfRangeError: Number \`256\` is not in safe 8-bit unsigned integer range (\`0\` to \`255\`)]`,
+    )
+  })
+
+  test('uint16: 2^64', () => {
+    expect(() =>
+      AbiParameters.decode(
+        AbiParameters.from('uint16'),
+        '0x0000000000000000000000000000000000000000000000010000000000000000',
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Hex.IntegerOutOfRangeError: Number \`18446744073709551616\` is not in safe 16-bit unsigned integer range (\`0\` to \`65535\`)]`,
+    )
+  })
+
+  test('every size: min and max round-trip, out of range throws', () => {
+    for (let size = 8; size <= 256; size += 8) {
+      for (const signed of [false, true]) {
+        const type = (signed ? 'int' : 'uint') + size
+        const parameters = AbiParameters.from(type)
+        const max = (1n << BigInt(signed ? size - 1 : size)) - 1n
+        const min = signed ? -max - 1n : 0n
+        const cast = (value: bigint) => (size > 48 ? value : Number(value))
+
+        for (const value of [min, max])
+          expect(
+            AbiParameters.decode(
+              parameters,
+              AbiParameters.encode(parameters, [cast(value)] as never),
+            ),
+          ).toEqual([cast(value)])
+
+        if (size === 256) continue
+        const word = (value: bigint) =>
+          Hex.fromNumber(BigInt.asUintN(256, value), { size: 32 })
+        expect(() => AbiParameters.decode(parameters, word(max + 1n))).toThrow(
+          Hex.IntegerOutOfRangeError,
+        )
+        if (signed)
+          expect(() =>
+            AbiParameters.decode(parameters, word(min - 1n)),
+          ).toThrow(Hex.IntegerOutOfRangeError)
+      }
+    }
+  })
+})
+
+describe('address padding', () => {
+  test('dirty high bytes', () => {
+    expect(() =>
+      AbiParameters.decode(
+        AbiParameters.from('address'),
+        '0x00000000000000000000000114dc79964da2c08b23698b3d3cc7ca32193d9955',
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      [Address.InvalidAddressError: Address "0x00000000000000000000000114dc79964da2c08b23698b3d3cc7ca32193d9955" is invalid.
+
+      Details: Address is not a 20 byte (40 hexadecimal character) value.]
+    `)
+  })
+
+  test('dirty first byte', () => {
+    expect(() =>
+      AbiParameters.decode(
+        AbiParameters.from('address'),
+        '0xff000000000000000000000014dc79964da2c08b23698b3d3cc7ca32193d9955',
+      ),
+    ).toThrow(Address.InvalidAddressError)
+  })
+
+  test('address[2]: second element dirty', () => {
+    expect(() =>
+      AbiParameters.decode(
+        AbiParameters.from('address[2]'),
+        '0x00000000000000000000000014dc79964da2c08b23698b3d3cc7ca32193d99550000000000000000000000ff14dc79964da2c08b23698b3d3cc7ca32193d9955',
+      ),
+    ).toThrow(Address.InvalidAddressError)
+  })
+})

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

@@ -1,4 +1,4 @@
-import { RpcSchema } from 'ox'
+import { type Frame, RpcSchema } from 'ox'
 import { z } from 'ox/zod'
 import { describe, expectTypeOf, test } from 'vp/test'
 
@@ -246,6 +246,28 @@ test('frame fill responses do not require raw bytes or lookup metadata', () => {
   expectTypeOf(filled).toExtend<Filled>()
 })
 
+test('fill responses expose fields not shared by every envelope as optional', () => {
+  type Tx = Extract<
+    RpcSchema.Eth,
+    { Request: { method: 'eth_fillTransaction' } }
+  >['ReturnType']['tx']
+  expectTypeOf<Tx['from']>().toEqualTypeOf<`0x${string}`>()
+  expectTypeOf<Tx['gas']>().toEqualTypeOf<`0x${string}` | undefined>()
+  expectTypeOf<Tx['frames']>().toEqualTypeOf<readonly Frame.Rpc[] | undefined>()
+
+  type Eip1559 = Extract<Tx, { type: '0x2' }>
+  expectTypeOf<Eip1559['gas']>().toEqualTypeOf<`0x${string}` | undefined>()
+  expectTypeOf<Eip1559['gasPrice']>().toEqualTypeOf<undefined>()
+  expectTypeOf<Eip1559['maxFeePerGas']>().toEqualTypeOf<
+    `0x${string}` | undefined
+  >()
+  expectTypeOf<Eip1559['frames']>().toEqualTypeOf<undefined>()
+
+  type Eip8141 = Extract<Tx, { type: '0x6' }>
+  expectTypeOf<Eip8141['frames']>().toEqualTypeOf<readonly Frame.Rpc[]>()
+  expectTypeOf<Eip8141['gas']>().toEqualTypeOf<undefined>()
+})
+
 test('frame simulation results expose payer and frame results', () => {
   type Result = Extract<
     RpcSchema.Eth,

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

@@ -27,6 +27,18 @@ describe('assert', () => {
     )
   })
 
+  test('tip higher than zero fee cap', () => {
+    expect(() =>
+      TxEnvelopeEip1559.assert({
+        maxFeePerGas: 0n,
+        maxPriorityFeePerGas: 1n,
+        chainId: 1,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      '[TransactionEnvelope.TipAboveFeeCapError: The provided tip (`maxPriorityFeePerGas` = 0.000000001 gwei) cannot be higher than the fee cap (`maxFeePerGas` = 0 gwei).]',
+    )
+  })
+
   test('invalid chainId', () => {
     expect(() =>
       TxEnvelopeEip1559.assert({ chainId: 0 }),
@@ -225,6 +237,18 @@ describe('deserialize', () => {
   })
 
   describe('errors', () => {
+    test('tip above empty fee cap', () => {
+      const serialized = TxEnvelopeEip1559.serialize({
+        chainId: 1,
+        maxPriorityFeePerGas: 1n,
+      })
+      expect(() =>
+        TxEnvelopeEip1559.deserialize(serialized),
+      ).toThrowErrorMatchingInlineSnapshot(
+        `[TransactionEnvelope.TipAboveFeeCapError: The provided tip (\`maxPriorityFeePerGas\` = 0.000000001 gwei) cannot be higher than the fee cap (\`maxFeePerGas\` = 0 gwei).]`,
+      )
+    })
+
     test('invalid access list (invalid address)', () => {
       expect(() =>
         TxEnvelopeEip1559.deserialize(

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

@@ -203,6 +203,19 @@ describe('deserialize', () => {
   })
 
   describe('errors', () => {
+    test('tip above empty fee cap', () => {
+      const serialized = TxEnvelopeEip4844.serialize({
+        blobVersionedHashes,
+        chainId: 1,
+        maxPriorityFeePerGas: 1n,
+      })
+      expect(() =>
+        TxEnvelopeEip4844.deserialize(serialized),
+      ).toThrowErrorMatchingInlineSnapshot(
+        `[TransactionEnvelope.TipAboveFeeCapError: The provided tip (\`maxPriorityFeePerGas\` = 0.000000001 gwei) cannot be higher than the fee cap (\`maxFeePerGas\` = 0 gwei).]`,
+      )
+    })
+
     test('invalid access list (invalid address)', () => {
       expect(() =>
         TxEnvelopeEip4844.deserialize(

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

@@ -311,6 +311,19 @@ describe('deserialize', () => {
   })
 
   describe('errors', () => {
+    test('tip above empty fee cap', () => {
+      const serialized = TxEnvelopeEip7702.serialize({
+        authorizationList: [],
+        chainId: 1,
+        maxPriorityFeePerGas: 1n,
+      })
+      expect(() =>
+        TxEnvelopeEip7702.deserialize(serialized),
+      ).toThrowErrorMatchingInlineSnapshot(
+        `[TransactionEnvelope.TipAboveFeeCapError: The provided tip (\`maxPriorityFeePerGas\` = 0.000000001 gwei) cannot be higher than the fee cap (\`maxFeePerGas\` = 0 gwei).]`,
+      )
+    })
+
     test('invalid access list (invalid address)', () => {
       expect(() =>
         TxEnvelopeEip7702.deserialize(