ox 1.8.9 → 1.8.12

package/src/core/Signature.ts

@@ -704,8 +704,9 @@ export declare namespace fromRecoveredBytes {
 export function toHex(signature: Signature<boolean>): Hex.Hex {
   assert(signature)
 
-  const r = signature.r
-  const s = signature.s
+  // `r` and `s` are big-endian integers, so short values (e.g. from RPC or `toTuple`) are left-padded.
+  const r = Hex.padLeft(signature.r, 32)
+  const s = Hex.padLeft(signature.s, 32)
 
   const signature_ = Hex.concat(
     r,
@@ -721,8 +722,10 @@ export function toHex(signature: Signature<boolean>): Hex.Hex {
 
 export declare namespace toHex {
   type ErrorType =
+    | assert.ErrorType
     | Hex.concat.ErrorType
     | Hex.fromNumber.ErrorType
+    | Hex.padLeft.ErrorType
     | Errors.GlobalErrorType
 }
 

package/src/core/Siwe.ts

@@ -4,7 +4,7 @@ import * as Hex from './Hex.js'
 import type { ExactPartial } from './internal/types.js'
 
 export const domainRegex =
-  /^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}(:[0-9]{1,5})?$/
+  /^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+(?:[a-zA-Z]{2,63}|[xX][nN]--[a-zA-Z0-9-]{0,58}[a-zA-Z0-9])(:[0-9]{1,5})?$/
 
 export const ipRegex =
   /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(:[0-9]{1,5})?$/

package/src/core/TypedData.ts

@@ -429,7 +429,7 @@ export function extractEip712DomainTypes(
 ): Parameter[] {
   return [
     typeof domain?.name === 'string' && { name: 'name', type: 'string' },
-    domain?.version && { name: 'version', type: 'string' },
+    typeof domain?.version === 'string' && { name: 'version', type: 'string' },
     (typeof domain?.chainId === 'number' ||
       typeof domain?.chainId === 'bigint') && {
       name: 'chainId',

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

@@ -1,10 +1,60 @@
-import { Abi, AbiEvent, Hex } from 'ox'
+import { Abi, AbiEvent, AbiParameters, Hash, Hex } from 'ox'
 import { describe, expect, test } from 'vp/test'
 import { wagmiContractConfig } from '../../../test/constants/abis.js'
 import { address } from '../../../test/constants/addresses.js'
 import { anvilMainnet } from '../../../test/prool.js'
 
 describe('assertArgs', () => {
+  test('behavior: non-indexed `string` and `bytes`', () => {
+    const abiEvent = AbiEvent.from(
+      'event Message(string indexed topic, string text, bytes data, bytes32 key)',
+    )
+    const args = AbiEvent.decode(abiEvent, {
+      data: AbiParameters.encode(AbiParameters.from('string, bytes, bytes32'), [
+        'hello',
+        '0xabcd',
+        `0x${'ab'.repeat(32)}`,
+      ]),
+      topics: [
+        AbiEvent.getSelector(abiEvent),
+        Hash.keccak256(Hex.fromString('greeting')),
+      ],
+    })
+
+    AbiEvent.assertArgs(abiEvent, args, {
+      data: '0xABCD',
+      key: `0x${'AB'.repeat(32)}`,
+      text: 'hello',
+      topic: 'greeting',
+    })
+    expect(() => AbiEvent.assertArgs(abiEvent, args, { text: 'goodbye' }))
+      .toThrowErrorMatchingInlineSnapshot(`
+      [AbiEvent.ArgsMismatchError: Given arguments do not match the expected arguments.
+
+      Event: event Message(string indexed topic, string text, bytes data, bytes32 key)
+      Expected Arguments: 
+        topic:  0xb6b19d010a6e0901db334da92e3eed820e0244fba35be613232ddf8d2ee39391
+        text:   hello
+        data:   0xabcd
+        key:    0xabababababababababababababababababababababababababababababababab
+      Given Arguments: 
+        text:  goodbye]
+    `)
+    expect(() => AbiEvent.assertArgs(abiEvent, args, { data: '0xab' }))
+      .toThrowErrorMatchingInlineSnapshot(`
+      [AbiEvent.ArgsMismatchError: Given arguments do not match the expected arguments.
+
+      Event: event Message(string indexed topic, string text, bytes data, bytes32 key)
+      Expected Arguments: 
+        topic:  0xb6b19d010a6e0901db334da92e3eed820e0244fba35be613232ddf8d2ee39391
+        text:   hello
+        data:   0xabcd
+        key:    0xabababababababababababababababababababababababababababababababab
+      Given Arguments: 
+        data:  0xab]
+    `)
+  })
+
   test('default', () => {
     const abiEvent = AbiEvent.from(
       'event Transfer(address indexed from, address indexed to, uint256 value)',
@@ -934,6 +984,187 @@ describe('extractLogs', () => {
     `)
   })
 
+  test('behavior: filters by non-indexed `string` arguments', () => {
+    const message = AbiEvent.from(
+      'event Message(address indexed from, string text)',
+    )
+    const log = {
+      data: AbiParameters.encode(AbiParameters.from('string'), ['hello']),
+      topics: [
+        AbiEvent.getSelector(message),
+        '0x0000000000000000000000000000000000000000000000000000000000000001',
+      ],
+    } as const
+
+    expect(
+      AbiEvent.extractLogs([message], [log], { args: { text: 'goodbye' } }),
+    ).toMatchInlineSnapshot(`[]`)
+    expect(AbiEvent.extractLogs([message], [log], { args: { text: 'hello' } }))
+      .toMatchInlineSnapshot(`
+      [
+        {
+          "args": {
+            "from": "0x0000000000000000000000000000000000000001",
+            "text": "hello",
+          },
+          "data": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000568656c6c6f000000000000000000000000000000000000000000000000000000",
+          "eventName": "Message",
+          "topics": [
+            "0x811f7cff0a3374ff67cccc3726035d34ba70410e0256818a891e4d6acc01d88e",
+            "0x0000000000000000000000000000000000000000000000000000000000000001",
+          ],
+        },
+      ]
+    `)
+  })
+
+  test('behavior: filters by unnamed non-indexed `string` arguments', () => {
+    const message = AbiEvent.from('event Message(address indexed, string)')
+    const log = {
+      data: AbiParameters.encode(AbiParameters.from('string'), ['hello']),
+      topics: [
+        AbiEvent.getSelector(message),
+        '0x0000000000000000000000000000000000000000000000000000000000000001',
+      ],
+    } as const
+
+    expect(
+      AbiEvent.extractLogs([message], [log], { args: [null, 'goodbye'] }),
+    ).toMatchInlineSnapshot(`[]`)
+    expect(
+      AbiEvent.extractLogs([message], [log], {
+        args: ['0x0000000000000000000000000000000000000001', 'hello'],
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "args": [
+            "0x0000000000000000000000000000000000000001",
+            "hello",
+          ],
+          "data": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000568656c6c6f000000000000000000000000000000000000000000000000000000",
+          "eventName": "Message",
+          "topics": [
+            "0x811f7cff0a3374ff67cccc3726035d34ba70410e0256818a891e4d6acc01d88e",
+            "0x0000000000000000000000000000000000000000000000000000000000000001",
+          ],
+        },
+      ]
+    `)
+  })
+
+  test('behavior: filters by non-indexed `bytes` and `bytes32` arguments in either case', () => {
+    const payload = AbiEvent.from('event Payload(bytes data, bytes32 key)')
+    const log = {
+      data: AbiParameters.encode(AbiParameters.from('bytes, bytes32'), [
+        '0xabcd',
+        `0x${'ab'.repeat(32)}`,
+      ]),
+      topics: [AbiEvent.getSelector(payload)],
+    } as const
+
+    expect(
+      AbiEvent.extractLogs([payload], [log], { args: { data: '0xab' } }),
+    ).toMatchInlineSnapshot(`[]`)
+    expect(
+      AbiEvent.extractLogs([payload], [log], {
+        args: { key: `0x${'cd'.repeat(32)}` },
+      }),
+    ).toMatchInlineSnapshot(`[]`)
+    expect(
+      AbiEvent.extractLogs([payload], [log], {
+        args: { data: '0xABCD', key: `0x${'AB'.repeat(32)}` },
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "args": {
+            "data": "0xabcd",
+            "key": "0xabababababababababababababababababababababababababababababababab",
+          },
+          "data": "0x0000000000000000000000000000000000000000000000000000000000000040abababababababababababababababababababababababababababababababab0000000000000000000000000000000000000000000000000000000000000002abcd000000000000000000000000000000000000000000000000000000000000",
+          "eventName": "Payload",
+          "topics": [
+            "0x1d7847897c7e3bd365111aaf33b5ea1cc653db465de055620fb4cde96c75147f",
+          ],
+        },
+      ]
+    `)
+  })
+
+  test('behavior: filters by indexed `bytes` and `bytes32` arguments', () => {
+    const payload = AbiEvent.from(
+      'event Payload(bytes indexed data, bytes32 indexed key)',
+    )
+    const log = {
+      data: '0x',
+      topics: [
+        AbiEvent.getSelector(payload),
+        Hash.keccak256('0x1234'),
+        `0x${'ab'.repeat(32)}`,
+      ],
+    } as const
+
+    expect(
+      AbiEvent.extractLogs([payload], [log], { args: { data: '0x5678' } }),
+    ).toMatchInlineSnapshot(`[]`)
+    expect(
+      AbiEvent.extractLogs([payload], [log], {
+        args: { data: '0x1234', key: `0x${'AB'.repeat(32)}` },
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "args": {
+            "data": "0x56570de287d73cd1cb6092bb8fdee6173974955fdef345ae579ee9f475ea7432",
+            "key": "0xabababababababababababababababababababababababababababababababab",
+          },
+          "data": "0x",
+          "eventName": "Payload",
+          "topics": [
+            "0x1d7847897c7e3bd365111aaf33b5ea1cc653db465de055620fb4cde96c75147f",
+            "0x56570de287d73cd1cb6092bb8fdee6173974955fdef345ae579ee9f475ea7432",
+            "0xabababababababababababababababababababababababababababababababab",
+          ],
+        },
+      ]
+    `)
+  })
+
+  test('behavior: non-strict mode filters indexed `string` arguments decoded from data', () => {
+    const message = AbiEvent.from('event Message(string indexed text)')
+    const log = {
+      data: AbiParameters.encode(AbiParameters.from('string'), ['hello']),
+      topics: [AbiEvent.getSelector(message)],
+    } as const
+
+    expect(
+      AbiEvent.extractLogs([message], [log], {
+        args: { text: 'goodbye' },
+        strict: false,
+      }),
+    ).toMatchInlineSnapshot(`[]`)
+    expect(
+      AbiEvent.extractLogs([message], [log], {
+        args: { text: 'hello' },
+        strict: false,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "args": {
+            "text": "hello",
+          },
+          "data": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000568656c6c6f000000000000000000000000000000000000000000000000000000",
+          "eventName": "Message",
+          "topics": [
+            "0x51a7f65c6325882f237d4aeb43228179cfad48b868511d508e24b4437a819137",
+          ],
+        },
+      ]
+    `)
+  })
+
   test('behavior: formats RPC logs', () => {
     const transfer = AbiEvent.from(
       'event Transfer(address indexed from, address indexed to, uint256 value)',

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

@@ -566,6 +566,123 @@ describe('fromAbi', () => {
     `)
   })
 
+  test('behavior: overloads: array of sized type with a zero digit', () => {
+    const abi = Abi.from(['function foo(bool x)', 'function foo(uint160[] x)'])
+    const item = AbiItem.fromAbi(abi, 'foo', {
+      args: [[1n, 2n]],
+    })
+    expect(item).toMatchInlineSnapshot(`
+      {
+        "hash": "0x7bde9aac82d6d2ebf4a41781f2948136bf4f6c8ebf8f4e48fef38fa1e84c8956",
+        "inputs": [
+          {
+            "name": "x",
+            "type": "uint160[]",
+          },
+        ],
+        "name": "foo",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function",
+      }
+    `)
+  })
+
+  test('behavior: overloads: fixed-length arrays', () => {
+    const abi = Abi.from([
+      'function foo(uint256[3] x)',
+      'function foo(uint256[2] x)',
+    ])
+    const item = AbiItem.fromAbi(abi, 'foo', {
+      args: [[1n, 2n, 3n]],
+    })
+    expect(item).toMatchInlineSnapshot(`
+      {
+        "hash": "0x692ce76c55b41cf69172ef1ac912f391f409c4752ccbc07a9223c555ab216e8a",
+        "inputs": [
+          {
+            "name": "x",
+            "type": "uint256[3]",
+          },
+        ],
+        "name": "foo",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function",
+      }
+    `)
+  })
+
+  test('behavior: overloads: tuple object with array component', () => {
+    const abi = Abi.from([
+      'function foo((uint256[] a) x)',
+      'function foo((uint256[] a, uint256 b) x)',
+    ])
+    const item = AbiItem.fromAbi(abi, 'foo', {
+      args: [{ a: [1n], b: 2n }],
+    })
+    expect(item).toMatchInlineSnapshot(`
+      {
+        "hash": "0x61457dec1afc1333188255223fb1db69745528cabbb7e205dbd87802866b7d4b",
+        "inputs": [
+          {
+            "components": [
+              {
+                "name": "a",
+                "type": "uint256[]",
+              },
+              {
+                "name": "b",
+                "type": "uint256",
+              },
+            ],
+            "name": "x",
+            "type": "tuple",
+          },
+        ],
+        "name": "foo",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function",
+      }
+    `)
+  })
+
+  test('behavior: overloads: tuple object keys in a different order', () => {
+    const abi = Abi.from([
+      'function foo((address a, string b) x)',
+      'function foo((string a, string b) x)',
+    ])
+    const item = AbiItem.fromAbi(abi, 'foo', {
+      args: [{ b: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e', a: 'hello' }],
+    })
+    expect(item).toMatchInlineSnapshot(`
+      {
+        "hash": "0xdd0b43b6d117718cd57f3e320a76cfbe273b4896ff11ecfa3da506a2d372773b",
+        "inputs": [
+          {
+            "components": [
+              {
+                "name": "a",
+                "type": "string",
+              },
+              {
+                "name": "b",
+                "type": "string",
+              },
+            ],
+            "name": "x",
+            "type": "tuple",
+          },
+        ],
+        "name": "foo",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function",
+      }
+    `)
+  })
+
   test('behavior: overloads: tuple', () => {
     const abi = Abi.from([
       'function foo(uint256 foo, (string a, string b, uint256 c) bar)',
@@ -783,6 +900,125 @@ describe('fromAbi', () => {
       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(address[])', 'function foo(bytes20[])']),
+        'foo',
+        {
+          args: [['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e']],
+        },
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      [AbiItem.AmbiguityError: Found ambiguous types in overloaded ABI Items.
+
+      \`bytes20\` in \`foo(bytes20[])\`, and
+      \`address\` in \`foo(address[])\`
+
+      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(address[])', 'function foo(bytes20[])']),
+        'foo',
+        {
+          args: [[]],
+        },
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      [AbiItem.AmbiguityError: Found ambiguous types in overloaded ABI Items.
+
+      \`bytes20\` in \`foo(bytes20[])\`, and
+      \`address\` in \`foo(address[])\`
+
+      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(address[])', 'function foo(string[])']),
+        'foo',
+        {
+          args: [[]],
+        },
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      [AbiItem.AmbiguityError: Found ambiguous types in overloaded ABI Items.
+
+      \`string\` in \`foo(string[])\`, and
+      \`address\` in \`foo(address[])\`
+
+      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(address[2])', 'function foo(bytes20[])']),
+        'foo',
+        {
+          args: [
+            [
+              '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+              '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+            ],
+          ],
+        },
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      [AbiItem.AmbiguityError: Found ambiguous types in overloaded ABI Items.
+
+      \`bytes20\` in \`foo(bytes20[])\`, and
+      \`address\` in \`foo(address[2])\`
+
+      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((address[] a))',
+          'function foo((bytes20[] a))',
+        ]),
+        'foo',
+        {
+          args: [{ a: ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'] }],
+        },
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      [AbiItem.AmbiguityError: Found ambiguous types in overloaded ABI Items.
+
+      \`bytes20\` in \`foo((bytes20[]))\`, and
+      \`address\` in \`foo((address[]))\`
+
+      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), address[])',
+          'function foo((uint256), bytes20[])',
+        ]),
+        'foo',
+        {
+          args: [[1n], ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e']],
+        },
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      [AbiItem.AmbiguityError: Found ambiguous types in overloaded ABI Items.
+
+      \`bytes20\` in \`foo((uint256),bytes20[])\`, and
+      \`address\` in \`foo((uint256),address[])\`
+
+      These types encode differently and cannot be distinguished at runtime.
+      Remove one of the ambiguous items in the ABI.]
+    `)
   })
 
   describe('getAmbiguousTypes', () => {
@@ -970,6 +1206,99 @@ describe('fromAbi', () => {
         ]
       `)
     })
+
+    test('arrays', () => {
+      expect(
+        getAmbiguousTypes(
+          AbiParameters.from('address[]'),
+          AbiParameters.from('bytes20[]'),
+          [['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e']],
+        ),
+      ).toMatchInlineSnapshot(`
+        [
+          "address",
+          "bytes20",
+        ]
+      `)
+
+      expect(
+        getAmbiguousTypes(
+          AbiParameters.from('address[]'),
+          AbiParameters.from('bytes20[]'),
+          [[]],
+        ),
+      ).toMatchInlineSnapshot(`
+        [
+          "address",
+          "bytes20",
+        ]
+      `)
+
+      expect(
+        getAmbiguousTypes(
+          AbiParameters.from('string[2]'),
+          AbiParameters.from('address[]'),
+          [
+            [
+              '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+              '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+            ],
+          ],
+        ),
+      ).toMatchInlineSnapshot(`
+        [
+          "string",
+          "address",
+        ]
+      `)
+
+      expect(
+        getAmbiguousTypes(
+          AbiParameters.from('(address[] a)'),
+          AbiParameters.from('(bytes20[] a)'),
+          [{ a: ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'] }],
+        ),
+      ).toMatchInlineSnapshot(`
+        [
+          "address",
+          "bytes20",
+        ]
+      `)
+
+      expect(
+        getAmbiguousTypes(
+          AbiParameters.from('string[]'),
+          AbiParameters.from('address[]'),
+          [['foo', 'bar']],
+        ),
+      ).toBeUndefined()
+
+      expect(
+        getAmbiguousTypes(
+          AbiParameters.from('string[]'),
+          AbiParameters.from('address[]'),
+          [[]],
+        ),
+      ).toMatchInlineSnapshot(`
+        [
+          "string",
+          "address",
+        ]
+      `)
+
+      expect(
+        getAmbiguousTypes(
+          AbiParameters.from('address[][]'),
+          AbiParameters.from('bytes20[][]'),
+          [[['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e']]],
+        ),
+      ).toMatchInlineSnapshot(`
+        [
+          "address",
+          "bytes20",
+        ]
+      `)
+    })
   })
 
   describe.each([
@@ -983,6 +1312,19 @@ describe('fromAbi', () => {
       abiParameter: { type: 'uint256[]' },
       expected: true,
     },
+    { arg: [1n], abiParameter: { type: 'uint160[]' }, expected: true },
+    { arg: [1, 2], abiParameter: { type: 'int40[2]' }, expected: true },
+    {
+      arg: [1n, 2n, 3n],
+      abiParameter: { type: 'uint256[2]' },
+      expected: false,
+    },
+    { arg: [[1n]], abiParameter: { type: 'uint120[][]' }, expected: true },
+    {
+      arg: ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'],
+      abiParameter: { type: 'bytes20[]' },
+      expected: true,
+    },
     {
       arg: [{ foo: 1n, bar: [{ baz: 1n }] }],
       abiParameter: {