ox 1.8.10 → 1.8.13

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/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

@@ -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([
@@ -277,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(
@@ -529,6 +576,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

@@ -425,7 +425,7 @@ describe('assert', () => {
     ).toThrowErrorMatchingInlineSnapshot(`
       [TypedData.InvalidStructTypeError: Struct type "address" is invalid.
 
-      Struct type must not be a Solidity type.]
+      Struct type must contain only letters, digits, "_" and "$", and must not be a Solidity type.]
     `)
   })
 
@@ -498,6 +498,161 @@ describe('assert', () => {
       [Hex.IntegerOutOfRangeError: Number \`256n\` is not in safe 8-bit unsigned integer range (\`0n\` to \`255n\`)]
     `)
   })
+  test.each([
+    '1Order',
+    '_Order',
+    'bytesInfo',
+    'Foo$Bar',
+    'intent',
+    'interval',
+    'uintPair',
+  ])('struct type: %s', (type) => {
+    TypedData.assert({
+      types: {
+        Order: [{ name: 'inner', type }],
+        [type]: [{ name: 'amount', type: 'uint256' }],
+      },
+      primaryType: 'Order',
+      message: { inner: { amount: 1n } },
+    } as any)
+  })
+
+  test.each([
+    'address',
+    'bool',
+    'bytes',
+    'bytes32',
+    'bytes32[]',
+    'bytes33',
+    'Foo.Bar',
+    'int',
+    'int8',
+    'int8[2]',
+    'string',
+    'uint',
+    'uint256',
+    'uint256 ',
+    'uint256[]',
+    'uint7',
+  ])('invalid struct type: %s', (type) => {
+    expect(() =>
+      TypedData.assert({
+        types: {
+          Order: [{ name: 'inner', type }],
+          [type]: [{ name: 'amount', type: 'uint256' }],
+        },
+        primaryType: 'Order',
+        message: { inner: { amount: 1n } },
+      } as any),
+    ).toThrowError(`Struct type "${type}" is invalid.`)
+  })
+
+  test('invalid struct type: array element', () => {
+    expect(() =>
+      TypedData.assert({
+        types: {
+          Message: [{ name: 'contents', type: 'bytes32[]' }],
+          bytes32: [],
+        },
+        primaryType: 'Message',
+        message: { contents: [Hex.padLeft('0x11', 32)] },
+      } as any),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      [TypedData.InvalidStructTypeError: Struct type "bytes32" is invalid.
+
+      Struct type must contain only letters, digits, "_" and "$", and must not be a Solidity type.]
+    `)
+  })
+
+  test.each([
+    'bytes0',
+    'bytes33',
+    'int0',
+    'int7',
+    'uint08',
+    'uint7',
+    'uint7[]',
+    'uint264',
+    'uint264[2]',
+  ])('invalid type: %s', (type) => {
+    expect(() =>
+      TypedData.assert({
+        types: {
+          Message: [{ name: 'amount', type }],
+        },
+        primaryType: 'Message',
+        message: {
+          amount: type.includes('[')
+            ? [1n, 2n]
+            : type.startsWith('bytes')
+              ? '0x'
+              : 1n,
+        },
+      } as any),
+    ).toThrowError(`Type "${type}" is not a valid EIP-712 type.`)
+  })
+
+  test('invalid type: alias', () => {
+    expect(() =>
+      TypedData.assert({
+        types: {
+          Message: [{ name: 'amount', type: 'uint' }],
+        },
+        primaryType: 'Message',
+        message: { amount: 1n },
+      } as any),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      [TypedData.InvalidTypeError: Type "uint" is not a valid EIP-712 type.
+
+      Use "uint256" instead.]
+    `)
+  })
+
+  test('invalid type: undefined struct', () => {
+    expect(() =>
+      TypedData.assert({
+        types: {
+          Mail: [{ name: 'from', type: 'Person' }],
+        },
+        primaryType: 'Mail',
+        message: { from: { name: 'Cow' } },
+      } as any),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[TypedData.InvalidTypeError: Type "Person" is not a valid EIP-712 type.]`,
+    )
+  })
+
+  test.each(['bytes0', 'Foo', 'uint', 'uint7', 'uint7[]'])(
+    'invalid type in array element struct: %s',
+    (type) => {
+      for (const to of ['Person[]', 'Person[][]', 'Person[2]'])
+        expect(() =>
+          TypedData.assert({
+            types: {
+              Mail: [{ name: 'to', type: to }],
+              Person: [{ name: 'x', type }],
+            },
+            primaryType: 'Mail',
+            message: { to: [] },
+          } as any),
+        ).toThrowError(`Type "${type}" is not a valid EIP-712 type.`)
+    },
+  )
+
+  test.each(['__proto__', 'constructor', 'hasOwnProperty', 'toString'])(
+    'invalid type: %s',
+    (type) => {
+      expect(() =>
+        TypedData.assert({
+          types: {
+            Message: [{ name: 'value', type }],
+          },
+          primaryType: 'Message',
+          message: { value: {} },
+        } as any),
+      ).toThrowError(`Type "${type}" is not a valid EIP-712 type.`)
+    },
+  )
 })
 
 describe('domainSeparator', () => {
@@ -1054,6 +1209,37 @@ describe('getSignPayload', () => {
       `"0xd2669f23b7849020ad41bcbff5b51372793f91320e0f901641945568ed7322be"`,
     )
   })
+  test('struct type: prefixed by a Solidity type', () => {
+    expect(
+      TypedData.getSignPayload({
+        domain: { name: 'Domain' },
+        types: {
+          Message: [{ name: 'intent', type: 'intent' }],
+          intent: [{ name: 'amount', type: 'uint256' }],
+        },
+        primaryType: 'Message',
+        message: { intent: { amount: 1n } },
+      }),
+    ).toMatchInlineSnapshot(
+      `"0xcbeb995e95e87817f47e51736d0e5825644055cbcad196c2b26449ad78fd87ee"`,
+    )
+  })
+
+  test('struct type: with $', () => {
+    expect(
+      TypedData.getSignPayload({
+        domain: { name: 'Domain' },
+        types: {
+          Message: [{ name: 'order', type: 'Order$1' }],
+          Order$1: [{ name: 'amount', type: 'uint256' }],
+        },
+        primaryType: 'Message',
+        message: { order: { amount: 1n } },
+      }),
+    ).toMatchInlineSnapshot(
+      `"0x97a137d1f96a18c6a214fd8e7b991ed7309ff25f223b68aa63a4670f9838a94a"`,
+    )
+  })
 })
 
 describe('hashDomain', () => {
@@ -1613,6 +1799,7 @@ test('exports', () => {
       "InvalidDomainError",
       "InvalidPrimaryTypeError",
       "InvalidStructTypeError",
+      "InvalidTypeError",
       "InvalidArrayError",
       "InvalidArrayLengthError",
       "encodeData",

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 * as Hex from '../Hex.js'
 import { getArrayComponents } from './abiParameters.js'
 import type {
   Compute,
@@ -601,11 +602,32 @@ export function isArgOfType(
           },
         )
 
-      if (integerTypeRegex.test(abiParameterType))
-        return argType === 'number' || argType === 'bigint'
+      if (integerTypeRegex.test(abiParameterType)) {
+        if (typeof arg !== 'bigint' && typeof arg !== 'number') return false
+        if (typeof arg === 'number' && !Number.isInteger(arg)) return false
 
-      if (fixedBytesTypeRegex.test(abiParameterType))
-        return argType === 'string' || arg instanceof Uint8Array
+        // An overload whose integer range excludes the value does not match.
+        const signed = abiParameterType.startsWith('int')
+        const bits = Number.parseInt(
+          abiParameterType.replace(/^u?int/, '') || '256',
+          10,
+        )
+        const max = 2n ** (BigInt(bits) - (signed ? 1n : 0n)) - 1n
+        const min = signed ? -max - 1n : 0n
+        return arg >= min && arg <= max
+      }
+
+      if (fixedBytesTypeRegex.test(abiParameterType)) {
+        if (typeof arg !== 'string' && !(arg instanceof Uint8Array))
+          return false
+        // An overload whose fixed size differs from the value does not match.
+        const bytes = abiParameterType.slice(5)
+        if (!bytes) return true
+        if (arg instanceof Uint8Array)
+          return arg.length === Number.parseInt(bytes, 10)
+        if (!Hex.validate(arg)) return false
+        return Hex.size(arg as Hex.Hex) === Number.parseInt(bytes, 10)
+      }
 
       // Fixed-length (`<type>[M]`) and dynamic (`<type>[]`) arrays.
       const arrayComponents = getArrayComponents(abiParameterType)
@@ -683,6 +705,15 @@ export function getAmbiguousTypes(
         [(args[parameterIndex] as readonly unknown[] | undefined)?.[0]],
       )
       if (types) return types
+      // Same element type, different array shape: `uint256[]` and `uint256[2]`
+      // both accept `[1n, 1n]`, but one is dynamic and the other is static.
+      // Skip this when the element types differ. `string[]` vs `address[]`
+      // stays unambiguous for a non-address string.
+      if (
+        sourceArray[1] === targetArray[1] &&
+        sourceParameter.type !== targetParameter.type
+      )
+        return [sourceParameter.type, targetParameter.type]
       continue
     }
 
@@ -690,20 +721,20 @@ export function getAmbiguousTypes(
     const targetType = targetParameter.type
     const arg = args[parameterIndex] as Address.Address
 
-    let ambiguous = false
-    if (
-      (sourceType === 'address' && targetType === 'bytes20') ||
-      (sourceType === 'bytes20' && targetType === 'address')
-    )
-      ambiguous = true
-    else if (
-      (sourceType === 'address' && targetType === 'string') ||
-      (sourceType === 'string' && targetType === 'address') ||
-      (sourceType === 'address' && targetType === 'bytes') ||
-      (sourceType === 'bytes' && targetType === 'address')
-    )
+    const ambiguous = (() => {
       // An `undefined` value comes from an empty array, which matches both types.
-      ambiguous = arg === undefined || Address.validate(arg, { strict: false })
+      // This stays above the catch-all: a non-address string is not ambiguous.
+      if (
+        (sourceType === 'address' && targetType === 'string') ||
+        (sourceType === 'string' && targetType === 'address') ||
+        (sourceType === 'address' && targetType === 'bytes') ||
+        (sourceType === 'bytes' && targetType === 'address')
+      )
+        return arg === undefined || Address.validate(arg, { strict: false })
+      // Distinct types that both matched cannot be distinguished at runtime
+      // (e.g. `bytes` vs `bytes32`, `uint256` vs `int256`, `address` vs `bytes20`).
+      return sourceType !== targetType
+    })()
 
     if (ambiguous) return [sourceType, targetType]
   }

package/src/core/internal/abiParameters.ts

@@ -178,6 +178,14 @@ export function decodeAddress(
 ) {
   const { checksum = false } = options
   const value = cursor.readBytes(32)
+  // An address occupies the low 20 bytes of the word; the high 12 bytes
+  // must be zero padding.
+  for (let i = 0; i < 12; i++)
+    if (value[i] !== 0)
+      throw new Address.InvalidAddressError({
+        address: Hex.fromBytes(value),
+        cause: new Address.InvalidInputError(),
+      })
   const wrap = (address: Hex.Hex) =>
     checksum ? Address.checksum(address) : address
   return [wrap(Hex.fromBytes(Bytes.slice(value, -20))), 32]
@@ -185,6 +193,7 @@ export function decodeAddress(
 
 export declare namespace decodeAddress {
   type ErrorType =
+    | Address.InvalidAddressError
     | Hex.fromBytes.ErrorType
     | Bytes.slice.ErrorType
     | Errors.GlobalErrorType
@@ -356,19 +365,28 @@ export function decodeNumber(
 ) {
   const signed = param.type.startsWith('int')
   const size = Number.parseInt(param.type.split('int')[1] || '256', 10)
-  const value = cursor.readBytes(32)
-  return [
-    size > 48
-      ? Bytes.toBigInt(value, { signed })
-      : Bytes.toNumber(value, { signed }),
-    32,
-  ]
+  const value = Bytes.toBigInt(cursor.readBytes(32), { signed })
+  // The word must hold a value that fits the declared size (zero-padded for
+  // unsigned, sign-extended for signed types).
+  if (size < 256) {
+    const max = (1n << BigInt(signed ? size - 1 : size)) - 1n
+    const min = signed ? -max - 1n : 0n
+    if (value > max || value < min)
+      throw new Hex.IntegerOutOfRangeError({
+        max: max.toString(),
+        min: min.toString(),
+        signed,
+        size: size / 8,
+        value: value.toString(),
+      })
+  }
+  return [size > 48 ? value : Number(value), 32]
 }
 
 export declare namespace decodeNumber {
   type ErrorType =
-    | Bytes.toNumber.ErrorType
     | Bytes.toBigInt.ErrorType
+    | Hex.IntegerOutOfRangeError
     | Errors.GlobalErrorType
 }
 

package/src/core/internal/rpcSchemas/eth.ts

@@ -13,6 +13,7 @@ import type * as Transaction from '../../Transaction.js'
 import type * as TransactionReceipt from '../../TransactionReceipt.js'
 import type * as TransactionRequest from '../../TransactionRequest.js'
 import type * as TxEnvelope from '../../TxEnvelope.js'
+import type { OneOf, UnionCompute } from '../types.js'
 
 /**
  * Union of all JSON-RPC Methods for the `eth_` namespace.
@@ -237,7 +238,7 @@ export type Eth = RpcSchema.From<
       ReturnType: {
         capabilities?: Record<string, unknown> | undefined
         raw?: Hex.Hex | undefined
-        tx: TxEnvelope.Rpc & { from: Address.Address }
+        tx: UnionCompute<OneOf<TxEnvelope.Rpc> & { from: Address.Address }>
       }
     }
   /**