ox 1.8.9 → 1.8.12

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

@@ -151,6 +151,43 @@ describe('fromRpc', () => {
       }
     `)
   })
+
+  test('behavior: yParity above 1', () => {
+    expect(
+      Authorization.fromRpc({
+        address: '0xc498cea4bfedbb8de856491bdd9967e677775f4f',
+        chainId: '0x0',
+        nonce: '0x6',
+        r: '0x44754b7f217808e21f1935cfa450380e17a3ab8f2c6996c0190d678f0c14a512',
+        s: '0x27a6b869798cbbbd8d538dbc95b9bb28783bf08f8ef88ad6bb82552d0b47b191',
+        yParity: '0x1c',
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "address": "0xc498cea4bfedbb8de856491bdd9967e677775f4f",
+        "chainId": 0,
+        "nonce": 6n,
+        "r": "0x44754b7f217808e21f1935cfa450380e17a3ab8f2c6996c0190d678f0c14a512",
+        "s": "0x27a6b869798cbbbd8d538dbc95b9bb28783bf08f8ef88ad6bb82552d0b47b191",
+        "yParity": 28,
+      }
+    `)
+  })
+
+  test('error: yParity above 2**8 - 1', () => {
+    expect(() =>
+      Authorization.fromRpc({
+        address: '0xc498cea4bfedbb8de856491bdd9967e677775f4f',
+        chainId: '0x0',
+        nonce: '0x6',
+        r: '0x44754b7f217808e21f1935cfa450380e17a3ab8f2c6996c0190d678f0c14a512',
+        s: '0x27a6b869798cbbbd8d538dbc95b9bb28783bf08f8ef88ad6bb82552d0b47b191',
+        yParity: '0x100',
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Hex.IntegerOutOfRangeError: Number \`256\` is not in safe 8-bit unsigned integer range (\`0\` to \`255\`)]`,
+    )
+  })
 })
 
 describe('fromRpcList', () => {
@@ -251,6 +288,44 @@ describe('fromTuple', () => {
       }
     `)
   })
+
+  test('behavior: yParity above 1', () => {
+    const tuple = [
+      '0x',
+      '0xc498cea4bfedbb8de856491bdd9967e677775f4f',
+      '0x06',
+      '0x1c',
+      '0x44754b7f217808e21f1935cfa450380e17a3ab8f2c6996c0190d678f0c14a512',
+      '0x27a6b869798cbbbd8d538dbc95b9bb28783bf08f8ef88ad6bb82552d0b47b191',
+    ] as const satisfies Authorization.Tuple
+    const authorization = Authorization.fromTuple(tuple)
+    expect(authorization).toMatchInlineSnapshot(`
+      {
+        "address": "0xc498cea4bfedbb8de856491bdd9967e677775f4f",
+        "chainId": 0,
+        "nonce": 6n,
+        "r": "0x44754b7f217808e21f1935cfa450380e17a3ab8f2c6996c0190d678f0c14a512",
+        "s": "0x27a6b869798cbbbd8d538dbc95b9bb28783bf08f8ef88ad6bb82552d0b47b191",
+        "yParity": 28,
+      }
+    `)
+  })
+
+  test('error: yParity above 2**8 - 1', () => {
+    const tuple = [
+      '0x',
+      '0xc498cea4bfedbb8de856491bdd9967e677775f4f',
+      '0x06',
+      '0x0100',
+      '0x44754b7f217808e21f1935cfa450380e17a3ab8f2c6996c0190d678f0c14a512',
+      '0x27a6b869798cbbbd8d538dbc95b9bb28783bf08f8ef88ad6bb82552d0b47b191',
+    ] as const satisfies Authorization.Tuple
+    expect(() =>
+      Authorization.fromTuple(tuple),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Hex.IntegerOutOfRangeError: Number \`256\` is not in safe 8-bit unsigned integer range (\`0\` to \`255\`)]`,
+    )
+  })
 })
 
 describe('fromTupleList', () => {
@@ -454,6 +529,43 @@ describe('toRpc', () => {
     expect(fromBigint).toEqual(fromNumber)
     expect(fromBigint).toEqual(fromHex)
   })
+
+  test('behavior: yParity above 1', () => {
+    expect(
+      Authorization.toRpc({
+        address: '0xc498cea4bfedbb8de856491bdd9967e677775f4f',
+        chainId: 0,
+        nonce: 6n,
+        r: '0x44754b7f217808e21f1935cfa450380e17a3ab8f2c6996c0190d678f0c14a512',
+        s: '0x27a6b869798cbbbd8d538dbc95b9bb28783bf08f8ef88ad6bb82552d0b47b191',
+        yParity: 28,
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "address": "0xc498cea4bfedbb8de856491bdd9967e677775f4f",
+        "chainId": "0x0",
+        "nonce": "0x6",
+        "r": "0x44754b7f217808e21f1935cfa450380e17a3ab8f2c6996c0190d678f0c14a512",
+        "s": "0x27a6b869798cbbbd8d538dbc95b9bb28783bf08f8ef88ad6bb82552d0b47b191",
+        "yParity": "0x1c",
+      }
+    `)
+  })
+
+  test('error: yParity above 2**8 - 1', () => {
+    expect(() =>
+      Authorization.toRpc({
+        address: '0xc498cea4bfedbb8de856491bdd9967e677775f4f',
+        chainId: 0,
+        nonce: 6n,
+        r: '0x44754b7f217808e21f1935cfa450380e17a3ab8f2c6996c0190d678f0c14a512',
+        s: '0x27a6b869798cbbbd8d538dbc95b9bb28783bf08f8ef88ad6bb82552d0b47b191',
+        yParity: 256,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Hex.IntegerOutOfRangeError: Number \`256\` is not in safe 8-bit unsigned integer range (\`0\` to \`255\`)]`,
+    )
+  })
 })
 
 describe('toRpcList', () => {
@@ -540,6 +652,60 @@ describe('toTuple', () => {
     `)
     }
   })
+
+  test('behavior: yParity above 1', () => {
+    const authorization = Authorization.from({
+      address: '0xc498cea4bfedbb8de856491bdd9967e677775f4f',
+      chainId: 0,
+      nonce: 6n,
+      r: '0x44754b7f217808e21f1935cfa450380e17a3ab8f2c6996c0190d678f0c14a512',
+      s: '0x27a6b869798cbbbd8d538dbc95b9bb28783bf08f8ef88ad6bb82552d0b47b191',
+      yParity: 28,
+    })
+    const tuple = Authorization.toTuple(authorization)
+    expect(tuple).toMatchInlineSnapshot(`
+      [
+        "0x",
+        "0xc498cea4bfedbb8de856491bdd9967e677775f4f",
+        "0x6",
+        "0x1c",
+        "0x44754b7f217808e21f1935cfa450380e17a3ab8f2c6996c0190d678f0c14a512",
+        "0x27a6b869798cbbbd8d538dbc95b9bb28783bf08f8ef88ad6bb82552d0b47b191",
+      ]
+    `)
+  })
+
+  test('error: yParity above 2**8 - 1', () => {
+    const authorization = Authorization.from({
+      address: '0xc498cea4bfedbb8de856491bdd9967e677775f4f',
+      chainId: 0,
+      nonce: 6n,
+      r: '0x44754b7f217808e21f1935cfa450380e17a3ab8f2c6996c0190d678f0c14a512',
+      s: '0x27a6b869798cbbbd8d538dbc95b9bb28783bf08f8ef88ad6bb82552d0b47b191',
+      yParity: 256,
+    })
+    expect(() =>
+      Authorization.toTuple(authorization),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Hex.IntegerOutOfRangeError: Number \`256\` is not in safe 8-bit unsigned integer range (\`0\` to \`255\`)]`,
+    )
+  })
+
+  test('error: yParity not an integer', () => {
+    const authorization = Authorization.from({
+      address: '0xc498cea4bfedbb8de856491bdd9967e677775f4f',
+      chainId: 0,
+      nonce: 6n,
+      r: '0x44754b7f217808e21f1935cfa450380e17a3ab8f2c6996c0190d678f0c14a512',
+      s: '0x27a6b869798cbbbd8d538dbc95b9bb28783bf08f8ef88ad6bb82552d0b47b191',
+      yParity: Number.NaN,
+    })
+    expect(() =>
+      Authorization.toTuple(authorization),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Hex.IntegerOutOfRangeError: Number \`NaN\` is not in safe 8-bit unsigned integer range (\`0\` to \`255\`)]`,
+    )
+  })
 })
 
 describe('toTupleList', () => {

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

@@ -26,6 +26,23 @@ describe('assert', () => {
   Hex values must start with \`"0x"\` and contain only hexadecimal characters (0-9, a-f, A-F).]
 `)
   })
+
+  test('options: even', () => {
+    expect(() => Hex.assert('0x0', { even: true }))
+      .toThrowErrorMatchingInlineSnapshot(`
+      [Hex.InvalidLengthError: Hex value \`"0x0"\` is an odd length (1 nibbles).
+
+      It must be an even length.]
+    `)
+    expect(() => Hex.assert('0x400', { even: true }))
+      .toThrowErrorMatchingInlineSnapshot(`
+      [Hex.InvalidLengthError: Hex value \`"0x400"\` is an odd length (3 nibbles).
+
+      It must be an even length.]
+    `)
+    expect(() => Hex.assert('0x00', { even: true })).not.toThrow()
+    expect(() => Hex.assert('0x0', { even: false })).not.toThrow()
+  })
 })
 
 describe('concat', () => {
@@ -750,6 +767,20 @@ describe('validate', () => {
     expect(Hex.validate({ foo: 'bar' })).toBeFalsy()
     expect(Hex.validate(undefined)).toBeFalsy()
   })
+
+  test('options: even', () => {
+    expect(Hex.validate('0x', { even: true })).toMatchInlineSnapshot(`true`)
+    expect(Hex.validate('0x00', { even: true })).toMatchInlineSnapshot(`true`)
+    expect(Hex.validate('0x0400', { even: true })).toMatchInlineSnapshot(`true`)
+    expect(Hex.validate('0x0', { even: true })).toMatchInlineSnapshot(`false`)
+    expect(Hex.validate('0x400', { even: true })).toMatchInlineSnapshot(`false`)
+    expect(Hex.validate('0x0g', { even: true })).toMatchInlineSnapshot(`true`)
+    expect(
+      Hex.validate('0x0g', { even: true, strict: true }),
+    ).toMatchInlineSnapshot(`false`)
+    expect(Hex.validate('0xg', { even: true })).toMatchInlineSnapshot(`false`)
+    expect(Hex.validate('0x0', { even: false })).toMatchInlineSnapshot(`true`)
+  })
 })
 
 test('exports', () => {

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

@@ -242,6 +242,54 @@ describe('fromHttp', () => {
 
     await server.close()
   })
+
+  test('behavior: caller signal without `AbortSignal.any`', async () => {
+    const server = await createHttpServer((_, res) => {
+      res.end(JSON.stringify({ id: 0, jsonrpc: '2.0', result: 'wagmi' }))
+    })
+
+    const transport = RpcTransport.fromHttp(server.url, {
+      timeout: 50,
+      fetchOptions: {
+        signal: new AbortController().signal,
+      },
+    })
+
+    const descriptor = Object.getOwnPropertyDescriptor(AbortSignal, 'any')!
+    Object.defineProperty(AbortSignal, 'any', {
+      configurable: true,
+      value: undefined,
+    })
+    try {
+      await expect(
+        transport.request({ method: 'eth_accounts' }),
+      ).resolves.toMatchInlineSnapshot(`"wagmi"`)
+    } finally {
+      Object.defineProperty(AbortSignal, 'any', descriptor)
+      await server.close()
+    }
+  })
+
+  test('behavior: timeout covers a response body that stalls after its headers', async () => {
+    const server = await createHttpServer(async (_, res) => {
+      res.writeHead(200, { 'Content-Type': 'application/json' })
+      res.write('{"id":0,"jsonrpc":"2.0",')
+      await setTimeout(200)
+      res.end('"result":"wagmi"}')
+    })
+
+    const transport = RpcTransport.fromHttp(server.url, {
+      timeout: 50,
+    })
+
+    await expect(() =>
+      transport.request({ method: 'eth_accounts' }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Promise.TimeoutError: Operation timed out.]`,
+    )
+
+    await server.close()
+  })
 })
 
 test('exports', () => {

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

@@ -1,4 +1,11 @@
-import { Bytes, Hex, Signature, Solidity, TxEnvelopeEip1559 } from 'ox'
+import {
+  Bytes,
+  Hex,
+  Secp256k1,
+  Signature,
+  Solidity,
+  TxEnvelopeEip1559,
+} from 'ox'
 import { describe, expect, test } from 'vp/test'
 
 describe('assert', () => {
@@ -488,6 +495,40 @@ describe('serialize', () => {
       `"0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db8"`,
     )
   })
+
+  test('behavior: `r` and `s` shorter than 32 bytes', () => {
+    const signature = Signature.toHex({
+      r: '0x1cdb3cbf94c7059e0e16d2ba046daef144d77384995a66f379194b638fc07e',
+      s: '0xc3d1ccd2c334876b9f8ef0ba3725c30dd5e1def225df36efa406d881ed610b',
+      yParity: 1,
+    })
+    expect(signature).toMatchInlineSnapshot(
+      `"0x001cdb3cbf94c7059e0e16d2ba046daef144d77384995a66f379194b638fc07e00c3d1ccd2c334876b9f8ef0ba3725c30dd5e1def225df36efa406d881ed610b1c"`,
+    )
+    expect(Hex.size(signature)).toMatchInlineSnapshot(`65`)
+  })
+
+  test('behavior: short `s` round-trips through recovery', () => {
+    const payload =
+      '0x44caf484852acee09d52b2802dba26d3c8ab3d28c7abcc1398b87898115633ec'
+    const signature = Signature.fromHex(
+      Signature.toHex({
+        r: '0xdf1cdb3cbf94c7059e0e16d2ba046daef144d77384995a66f379194b638fc07e',
+        s: '0xc3d1ccd2c334876b9f8ef0ba3725c30dd5e1def225df36efa406d881ed610b',
+        yParity: 1,
+      }),
+    )
+    expect(signature).toMatchInlineSnapshot(`
+      {
+        "r": "0xdf1cdb3cbf94c7059e0e16d2ba046daef144d77384995a66f379194b638fc07e",
+        "s": "0x00c3d1ccd2c334876b9f8ef0ba3725c30dd5e1def225df36efa406d881ed610b",
+        "yParity": 1,
+      }
+    `)
+    expect(
+      Secp256k1.recoverAddress({ payload, signature }),
+    ).toMatchInlineSnapshot(`"0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266"`)
+  })
 })
 
 describe('toBytes', () => {

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

@@ -61,6 +61,40 @@ describe('createMessage', () => {
     0xA0Cf798816D4b9b9866b5330EEa46a18382f251e
 
 
+    URI: https://example.com/path
+    Version: 1
+    Chain ID: 1
+    Nonce: foobarbaz
+    Issued At: 2023-02-01T00:00:00.000Z"
+  `)
+
+    expect(
+      Siwe.createMessage({
+        ...message,
+        domain: 'example.xn--p1ai',
+      }),
+    ).toMatchInlineSnapshot(`
+    "example.xn--p1ai wants you to sign in with your Ethereum account:
+    0xA0Cf798816D4b9b9866b5330EEa46a18382f251e
+
+
+    URI: https://example.com/path
+    Version: 1
+    Chain ID: 1
+    Nonce: foobarbaz
+    Issued At: 2023-02-01T00:00:00.000Z"
+  `)
+
+    expect(
+      Siwe.createMessage({
+        ...message,
+        domain: 'example.XN--P1AI',
+      }),
+    ).toMatchInlineSnapshot(`
+    "example.XN--P1AI wants you to sign in with your Ethereum account:
+    0xA0Cf798816D4b9b9866b5330EEa46a18382f251e
+
+
     URI: https://example.com/path
     Version: 1
     Chain ID: 1
@@ -431,6 +465,12 @@ describe('createMessage', () => {
     'example.com:3000',
     'localhost:3000',
     '127.0.0.1:3000',
+    'example.xN--p1ai',
+    'example.xn--p1ai:443',
+    'example.xn--vermgensberater-ctb',
+    // 63 octets: "xn--" plus 59 LDH characters.
+    `example.xn--${'a'.repeat(59)}`,
+    `example.${'a'.repeat(63)}`,
   ])('valid domain `%s`', (domain) => {
     expect(
       Siwe.createMessage({
@@ -449,6 +489,13 @@ describe('createMessage', () => {
     'http://127.0.0.1:3000',
     'foobarbaz',
     '-example.com',
+    'example.xn--',
+    'example.xn--p1ai-',
+    'example.xx--p1ai',
+    'xn--p1ai',
+    // 64 octets: one past the maximum label length.
+    `example.xn--${'a'.repeat(60)}`,
+    `example.${'a'.repeat(64)}`,
   ])('invalid domain `%s`', (domain) => {
     expect(() =>
       Siwe.createMessage({
@@ -459,6 +506,12 @@ describe('createMessage', () => {
   })
 })
 
+describe('domainRegex', () => {
+  test('behavior: captures the port in group 3', () => {
+    expect(Siwe.domainRegex.exec('example.xn--p1ai:443')?.[3]).toBe(':443')
+  })
+})
+
 describe('generateNonce', () => {
   test('default', () => {
     const nonce = Siwe.generateNonce()

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

@@ -181,6 +181,40 @@ describe('deserialize', () => {
     })
   })
 
+  test('behavior: authorization yParity above 1', () => {
+    // Mainnet transaction 0xaec8420968abd74e70ef5b3099d6ba7baa3f069c4f718d7c4d729d591cffcb09,
+    // whose authorization holds a `y_parity` of 28.
+    const serialized =
+      '0x04f8c90102843b9aca0084408206be830186a094db35624115a810cf541988294a57766cd02acc828080c0f85cf85a8094c498cea4bfedbb8de856491bdd9967e677775f4f061ca044754b7f217808e21f1935cfa450380e17a3ab8f2c6996c0190d678f0c14a512a027a6b869798cbbbd8d538dbc95b9bb28783bf08f8ef88ad6bb82552d0b47b19180a0287d894b2ebb8a178a55810b242af186c73de663382358363d58b42628bbded3a0678f589cd41571248f24df7e60912d05f14c76471b859f4abd956c612bf175ee'
+
+    const envelope = TxEnvelopeEip7702.deserialize(serialized)
+    expect(envelope).toMatchInlineSnapshot(`
+      {
+        "authorizationList": [
+          {
+            "address": "0xc498cea4bfedbb8de856491bdd9967e677775f4f",
+            "chainId": 0,
+            "nonce": 6n,
+            "r": "0x44754b7f217808e21f1935cfa450380e17a3ab8f2c6996c0190d678f0c14a512",
+            "s": "0x27a6b869798cbbbd8d538dbc95b9bb28783bf08f8ef88ad6bb82552d0b47b191",
+            "yParity": 28,
+          },
+        ],
+        "chainId": 1,
+        "gas": 100000n,
+        "maxFeePerGas": 1082263230n,
+        "maxPriorityFeePerGas": 1000000000n,
+        "nonce": 2n,
+        "r": "0x287d894b2ebb8a178a55810b242af186c73de663382358363d58b42628bbded3",
+        "s": "0x678f589cd41571248f24df7e60912d05f14c76471b859f4abd956c612bf175ee",
+        "to": "0xdb35624115a810cf541988294a57766cd02acc82",
+        "type": "eip7702",
+        "yParity": 0,
+      }
+    `)
+    expect(TxEnvelopeEip7702.serialize(envelope)).toBe(serialized)
+  })
+
   describe('raw', () => {
     test('default', () => {
       const serialized = `0x04${Rlp.fromHex([
@@ -529,6 +563,38 @@ describe('hash', () => {
       `"0xa5ccd813e459b9154917af19270091cf3312bd759af08e0e18cd2560ef586cf4"`,
     )
   })
+
+  test('behavior: authorization yParity above 1', () => {
+    // Mainnet transaction 0xaec8420968abd74e70ef5b3099d6ba7baa3f069c4f718d7c4d729d591cffcb09,
+    // whose authorization holds a `y_parity` of 28.
+    const envelope = TxEnvelopeEip7702.from({
+      authorizationList: [
+        {
+          address: '0xc498cea4bfedbb8de856491bdd9967e677775f4f',
+          chainId: 0,
+          nonce: 6n,
+          r: '0x44754b7f217808e21f1935cfa450380e17a3ab8f2c6996c0190d678f0c14a512',
+          s: '0x27a6b869798cbbbd8d538dbc95b9bb28783bf08f8ef88ad6bb82552d0b47b191',
+          yParity: 28,
+        },
+      ],
+      chainId: 1,
+      gas: 100000n,
+      maxFeePerGas: 1082263230n,
+      maxPriorityFeePerGas: 1000000000n,
+      nonce: 2n,
+      r: '0x287d894b2ebb8a178a55810b242af186c73de663382358363d58b42628bbded3',
+      s: '0x678f589cd41571248f24df7e60912d05f14c76471b859f4abd956c612bf175ee',
+      to: '0xdb35624115a810cf541988294a57766cd02acc82',
+      value: 0n,
+      yParity: 0,
+    })
+
+    const hash = TxEnvelopeEip7702.hash(envelope)
+    expect(hash).toMatchInlineSnapshot(
+      `"0xaec8420968abd74e70ef5b3099d6ba7baa3f069c4f718d7c4d729d591cffcb09"`,
+    )
+  })
 })
 
 describe('serialize', () => {

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

@@ -791,6 +791,23 @@ describe('extractEip712DomainTypes', () => {
   test('empty', () => {
     expect(TypedData.extractEip712DomainTypes({})).toMatchInlineSnapshot('[]')
   })
+
+  test('empty version', () => {
+    expect(
+      TypedData.extractEip712DomainTypes({ name: 'Ether Mail', version: '' }),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "name": "name",
+          "type": "string",
+        },
+        {
+          "name": "version",
+          "type": "string",
+        },
+      ]
+    `)
+  })
 })
 
 describe('getSignPayload', () => {
@@ -849,6 +866,18 @@ describe('getSignPayload', () => {
     )
   })
 
+  test('domain: empty version', () => {
+    expect(
+      TypedData.getSignPayload({
+        ...typedData.complex,
+        domain: { name: 'Ether Mail', version: '' },
+        primaryType: 'Mail',
+      }),
+    ).toMatchInlineSnapshot(
+      `"0xa437e12ee2fd4391429d9714be617951b7e69fb61dc520ad6fb8230d03b7508c"`,
+    )
+  })
+
   test('domain: bigint chainId produces same hash as number chainId', () => {
     const typedDataWithNumberChainId = {
       domain: {

package/src/core/internal/abiItem.ts

@@ -4,6 +4,7 @@ import type * as AbiItem from '../AbiItem.js'
 import type * as AbiParameters from '../AbiParameters.js'
 import * as Address from '../Address.js'
 import * as Errors from '../Errors.js'
+import { getArrayComponents } from './abiParameters.js'
 import type {
   Compute,
   IsNever,
@@ -570,20 +571,6 @@ const integerTypeRegex =
  */
 const fixedBytesTypeRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/
 
-/**
- * Fixed-length (`<type>[M]`) / dynamic (`<type>[]`) array regex.
- *
- * @internal
- */
-const arrayTypeRegex = /[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/
-
-/**
- * Strips a single trailing `[...]` array suffix from a type.
- *
- * @internal
- */
-const arraySuffixStripRegex = /(\[[0-9]{0,}\])$/
-
 /** @internal */
 export function isArgOfType(
   arg: unknown,
@@ -604,9 +591,12 @@ export function isArgOfType(
       if (abiParameterType === 'tuple' && 'components' in abiParameter)
         return Object.values(abiParameter.components).every(
           (component, index) => {
-            return isArgOfType(
-              Object.values(arg as unknown[] | Record<string, unknown>)[index],
-              component as AbiParameters.Parameter,
+            return (
+              argType === 'object' &&
+              isArgOfType(
+                getComponentValue(arg, component, index),
+                component as AbiParameters.Parameter,
+              )
             )
           },
         )
@@ -617,14 +607,17 @@ export function isArgOfType(
       if (fixedBytesTypeRegex.test(abiParameterType))
         return argType === 'string' || arg instanceof Uint8Array
 
-      if (arrayTypeRegex.test(abiParameterType)) {
+      // Fixed-length (`<type>[M]`) and dynamic (`<type>[]`) arrays.
+      const arrayComponents = getArrayComponents(abiParameterType)
+      if (arrayComponents) {
+        const [length, type] = arrayComponents
         return (
           Array.isArray(arg) &&
+          (length === null || arg.length === length) &&
           arg.every((x: unknown) =>
             isArgOfType(x, {
               ...abiParameter,
-              // Pop off `[]` or `[M]` from end of type
-              type: abiParameterType.replace(arraySuffixStripRegex, ''),
+              type,
             } as AbiParameters.Parameter),
           )
         )
@@ -649,19 +642,49 @@ export function getAmbiguousTypes(
     parameterIndex++
   ) {
     const sourceParameter = sourceParameters[parameterIndex]!
-    const targetParameter = targetParameters[parameterIndex]!
+    const targetParameter = targetParameters[parameterIndex]
+    if (!targetParameter) continue
 
     if (
       sourceParameter.type === 'tuple' &&
       targetParameter.type === 'tuple' &&
       'components' in sourceParameter &&
       'components' in targetParameter
-    )
-      return getAmbiguousTypes(
+    ) {
+      const value = args[parameterIndex]
+      const types = getAmbiguousTypes(
         sourceParameter.components,
         targetParameter.components,
-        (args as any)[parameterIndex],
+        sourceParameter.components.map((component, index) =>
+          getComponentValue(value, component, index),
+        ),
+      )
+      if (types) return types
+      continue
+    }
+
+    const sourceArray = getArrayComponents(sourceParameter.type)
+    const targetArray = getArrayComponents(targetParameter.type)
+    if (sourceArray && targetArray) {
+      // Every item matches both element types, so the first item (or `undefined` for an empty array) decides.
+      const types = getAmbiguousTypes(
+        [
+          {
+            ...sourceParameter,
+            type: sourceArray[1],
+          } as AbiParameters.Parameter,
+        ],
+        [
+          {
+            ...targetParameter,
+            type: targetArray[1],
+          } as AbiParameters.Parameter,
+        ],
+        [(args[parameterIndex] as readonly unknown[] | undefined)?.[0]],
       )
+      if (types) return types
+      continue
+    }
 
     const sourceType = sourceParameter.type
     const targetType = targetParameter.type
@@ -679,10 +702,21 @@ export function getAmbiguousTypes(
       (sourceType === 'address' && targetType === 'bytes') ||
       (sourceType === 'bytes' && targetType === 'address')
     )
-      ambiguous = Address.validate(arg, { strict: false })
+      // An `undefined` value comes from an empty array, which matches both types.
+      ambiguous = arg === undefined || Address.validate(arg, { strict: false })
 
     if (ambiguous) return [sourceType, targetType]
   }
 
   return
 }
+
+// Reads a tuple component's value by index from arrays and by name from objects, like `AbiParameters.encode`.
+function getComponentValue(
+  arg: unknown,
+  component: AbiParameters.Parameter,
+  index: number,
+): unknown {
+  if (Array.isArray(arg)) return arg[index]
+  return (arg as Record<string, unknown> | undefined)?.[component.name!]
+}