ox 1.8.12 → 1.8.13

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

package/src/tempo/KeyAuthorization.test.ts

@@ -97,8 +97,8 @@ const signature_keychain = {
 
 describe('configurable account binding', () => {
   test('behavior: accepts unbound configurable grants', () => {
-    // The node binds a root-signed grant to its signer, so only admin-signed
-    // grants need `account` (TIP-1049).
+    // The node binds a grant to its signer, so `account` is optional. From T14
+    // only the root key or owner quorum may sign a grant (TIP-1137).
     const signed = KeyAuthorization.from(
       { address, chainId: 1n, type: 'configurable' },
       { signature: signature_secp256k1 },
@@ -2673,7 +2673,9 @@ describe('witness (TIP-1053)', () => {
   })
 })
 
-describe('admin keys (TIP-1049)', () => {
+// TIP-1137 removes admin keys at T14, but the wire fields are unchanged, so
+// pre-T14 history (T6 to T13) must still encode, decode, and hash.
+describe('historical admin keys (TIP-1049)', () => {
   const account = '0x1111111111111111111111111111111111111111' as const
 
   test('from: preserves isAdmin and account', () => {
@@ -2858,7 +2860,7 @@ describe('admin keys (TIP-1049)', () => {
   })
 
   describe('configurable admin keys', () => {
-    test('behavior: a configurable account may sign or be granted an admin key', () => {
+    test('behavior: round-trips a pre-T14 configurable admin grant', () => {
       const signed = KeyAuthorization.from(
         {
           account: signature_configurable.account,

package/src/tempo/KeyAuthorization.ts

@@ -38,7 +38,10 @@ export type KeyAuthorization<
   bigintType = bigint,
   numberType = number,
 > = {
-  /** Account address this authorization is bound to. Required when an admin access key signs the grant (TIP-1049). */
+  /**
+   * Account address this authorization is bound to. When present, the Tempo node
+   * requires it to equal the transaction sender.
+   */
   account?: Address.Address | undefined
   /** Address derived from the public key of the key type. */
   address: Address.Address
@@ -46,7 +49,14 @@ export type KeyAuthorization<
   chainId: bigintType
   /** Unix timestamp when key expires (undefined = never expires). */
   expiry?: numberType | null | undefined
-  /** Whether this authorization provisions an admin access key. */
+  /**
+   * Whether this authorization provisions an admin access key (TIP-1049).
+   *
+   * @deprecated Admin access keys are removed at T14 by
+   * [TIP-1137](https://docs.tempo.xyz/protocol/tips/tip-1137). From T14 the Tempo
+   * node rejects any key authorization with `isAdmin: true`. The field is still
+   * encoded and decoded so pre-T14 history round-trips.
+   */
   isAdmin?: boolean | undefined
   /**
    * TIP20 spending limits for this key.
@@ -104,7 +114,7 @@ export type Input = KeyAuthorization<false, bigint, number>
 
 /** RPC representation matching the node's wire format. */
 export type Rpc = {
-  /** Optional account address binding (TIP-1049). */
+  /** Optional account address binding. When present, must equal the transaction sender. */
   account?: Address.Address | null | undefined
   /** Allowed call scopes (node field: `allowedCalls`). */
   allowedCalls?: readonly RpcCallScope[] | null | undefined
@@ -112,7 +122,12 @@ export type Rpc = {
   chainId: Hex.Hex
   /** Expiry timestamp (hex quantity or null). */
   expiry: Hex.Hex | null | undefined
-  /** Whether this authorization provisions an admin access key (TIP-1049). */
+  /**
+   * Whether this authorization provisions an admin access key (TIP-1049).
+   *
+   * @deprecated Rejected from T14 by [TIP-1137](https://docs.tempo.xyz/protocol/tips/tip-1137).
+   * Still decoded for pre-T14 history.
+   */
   isAdmin?: boolean | null | undefined
   /** Key identifier. */
   keyId: Address.Address
@@ -712,7 +727,9 @@ export function fromTuple<const tuple extends Tuple>(
   const isAdmin = (() => {
     if (isAbsent(rawIsAdmin)) return undefined
     // TIP-1049: the admin marker is strictly `0x01`. Any other value is a
-    // protocol-level decode error on the node, so reject it here too.
+    // protocol-level decode error on the node, so reject it here too. T14
+    // (TIP-1137) rejects admin authorizations at validation, not decoding,
+    // so pre-T14 history still decodes.
     if (rawIsAdmin !== '0x01')
       throw new InvalidAdminMarkerError(rawIsAdmin as Hex.Hex)
     return true
@@ -1140,8 +1157,9 @@ export function toTuple<const authorization extends KeyAuthorization>(
     { value: witness, placeholder: '0x' },
     // TIP-1049: admin marker. Present = `0x01` (RLP integer 1); absent
     // skipped or omitted. Any other value is a hard decode error on the node.
+    // TIP-1137 keeps this encoding but rejects `0x01` from T14.
     { value: isAdmin ? '0x01' : undefined, placeholder: '0x' },
-    // TIP-1049: optional account binding. Last field — never a placeholder.
+    // Optional account binding. Last field — never a placeholder.
     { value: account, placeholder: '0x' },
   ]
   let lastPresent = -1
@@ -1245,8 +1263,8 @@ export class InvalidSignatureTypeError extends Error {
 /**
  * Thrown when a configurable account key grant omits its parent account binding.
  *
- * @deprecated No longer thrown. The Tempo node only requires `account` on grants
- * signed by an admin access key, which it checks against the transaction sender.
+ * @deprecated No longer thrown. The Tempo node does not require `account`; when
+ * present, it must equal the transaction sender.
  */
 export class MissingAccountError extends Error {
   override readonly name = 'KeyAuthorization.MissingAccountError'

package/src/tempo/TxEnvelopeTempo.test.ts

@@ -106,6 +106,19 @@ describe('assert', () => {
     )
   })
 
+  test('tip above zero fee cap', () => {
+    expect(() =>
+      TxEnvelopeTempo.assert({
+        calls: [{ to: '0x0000000000000000000000000000000000000000' }],
+        chainId: 1,
+        maxFeePerGas: 0n,
+        maxPriorityFeePerGas: 1n,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[TransactionEnvelope.TipAboveFeeCapError: The provided tip (\`maxPriorityFeePerGas\` = 0.000000001 gwei) cannot be higher than the fee cap (\`maxFeePerGas\` = 0 gwei).]`,
+    )
+  })
+
   test('invalid chain id', () => {
     expect(() =>
       TxEnvelopeTempo.assert({
@@ -138,6 +151,19 @@ describe('deserialize', () => {
     expect(deserialized).toEqual(transaction)
   })
 
+  test('tip above empty fee cap', () => {
+    const serialized = TxEnvelopeTempo.serialize({
+      calls: [{ to: '0x0000000000000000000000000000000000000000' }],
+      chainId: 1,
+      maxPriorityFeePerGas: 1n,
+    })
+    expect(() =>
+      TxEnvelopeTempo.deserialize(serialized),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[TransactionEnvelope.TipAboveFeeCapError: The provided tip (\`maxPriorityFeePerGas\` = 0.000000001 gwei) cannot be higher than the fee cap (\`maxFeePerGas\` = 0 gwei).]`,
+    )
+  })
+
   test('fee payer', () => {
     const serialized = TxEnvelopeTempo.serialize(transaction, {
       format: 'feePayer',

package/src/tempo/TxEnvelopeTempo.ts

@@ -214,8 +214,8 @@ export function assert(envelope: PartialBy<TxEnvelopeTempo, 'type'>) {
     })
 
   if (
-    maxPriorityFeePerGas &&
-    maxFeePerGas &&
+    typeof maxPriorityFeePerGas === 'bigint' &&
+    typeof maxFeePerGas === 'bigint' &&
     maxPriorityFeePerGas > maxFeePerGas
   )
     throw new TransactionEnvelope.TipAboveFeeCapError({
@@ -335,6 +335,12 @@ export function deserialize(serialized: Serialized): Compute<TxEnvelopeTempo> {
     transaction.maxFeePerGas = BigInt(maxFeePerGas)
   if (Hex.validate(maxPriorityFeePerGas) && maxPriorityFeePerGas !== '0x')
     transaction.maxPriorityFeePerGas = BigInt(maxPriorityFeePerGas)
+  // An empty `maxFeePerGas` encodes zero, so a tip above it is rejected.
+  if (
+    transaction.maxPriorityFeePerGas &&
+    typeof transaction.maxFeePerGas === 'undefined'
+  )
+    transaction.maxFeePerGas = 0n
   if (Hex.validate(nonceKey))
     transaction.nonceKey = nonceKey === '0x' ? 0n : BigInt(nonceKey)
   if (Hex.validate(validBefore) && validBefore !== '0x')