ox 0.14.56 → 0.14.58

package/core/RpcTransport.ts

@@ -95,8 +95,14 @@ export function fromHttp<
             ? await fetchOptions_(body_)
             : fetchOptions_
 
-        const response = await promise.withTimeout(
-          ({ signal }) => {
+        const { data, response } = await promise.withTimeout(
+          async ({ signal }) => {
+            // Abort on whichever signal fires first, so that a caller's
+            // `signal` does not disable the timeout.
+            const signals = [
+              fetchOptions?.signal,
+              timeout > 0 ? signal : null,
+            ].filter((s): s is AbortSignal => Boolean(s))
             const init: RequestInit = {
               ...fetchOptions,
               body,
@@ -105,10 +111,40 @@ export function fromHttp<
                 ...fetchOptions?.headers,
               },
               method: fetchOptions?.method ?? 'POST',
-              signal: fetchOptions?.signal ?? (timeout > 0 ? signal : null),
+              signal: (() => {
+                if (signals.length < 2) return signals[0] ?? null
+                // Runtimes without `AbortSignal.any` (e.g. Node < 18.17) keep
+                // only the caller's signal, as before.
+                if (typeof AbortSignal.any !== 'function') return signals[0]!
+                return AbortSignal.any(signals)
+              })(),
             }
             const request = new Request(url, init)
-            return fetchFn(request)
+            const response = await fetchFn(request)
+
+            // Read the body within the timeout too, so a response that stalls
+            // after its headers cannot hang the request.
+            const data = await (async () => {
+              if (
+                response.headers
+                  .get('Content-Type')
+                  ?.startsWith('application/json')
+              )
+                return response.json()
+              return response.text().then((data) => {
+                try {
+                  return JSON.parse(data || '{}')
+                } catch (_err) {
+                  if (response.ok)
+                    throw new MalformedResponseError({
+                      response: data,
+                    })
+                  return { error: data }
+                }
+              })
+            })()
+
+            return { data, response }
           },
           {
             timeout,
@@ -116,24 +152,6 @@ export function fromHttp<
           },
         )
 
-        const data = await (async () => {
-          if (
-            response.headers.get('Content-Type')?.startsWith('application/json')
-          )
-            return response.json()
-          return response.text().then((data) => {
-            try {
-              return JSON.parse(data || '{}')
-            } catch (_err) {
-              if (response.ok)
-                throw new MalformedResponseError({
-                  response: data,
-                })
-              return { error: data }
-            }
-          })
-        })()
-
         if (!response.ok)
           throw new HttpError({
             body,

package/core/TypedData.ts

@@ -393,7 +393,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/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,
@@ -466,8 +467,9 @@ export function normalizeSignature(signature: string): string {
 
     // Ignore spaces
     if (char === ' ') {
-      // If the previous character is a separator, and the current section isn't empty, we want to deactivate.
-      if (signature[i - 1] !== ',' && current !== ',' && current !== ',(') {
+      // A space directly after a `(` or `,` separator is leading whitespace.
+      // Otherwise, it ends the type, so we want to deactivate.
+      if (!current.endsWith(',') && !current.endsWith('(')) {
         current = ''
         active = false
       }
@@ -508,9 +510,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,
+              )
             )
           },
         )
@@ -530,15 +535,16 @@ export function isArgOfType(
         return argType === 'string' || arg instanceof Uint8Array
 
       // fixed-length (`<type>[M]`) and dynamic (`<type>[]`) arrays
-      // https://regexr.com/6va6i
-      if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
+      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(/(\[[0-9]{0,}\])$/, ''),
+              type,
             } as AbiParameters.Parameter),
           )
         )
@@ -557,32 +563,65 @@ export function getAmbiguousTypes(
 ): AbiParameters.Parameter['type'][] | undefined {
   for (const parameterIndex in sourceParameters) {
     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 types = [sourceParameter.type, targetParameter.type]
 
+    const value = args[parameterIndex]
+
     const ambiguous = (() => {
       if (types.includes('address') && types.includes('bytes20')) return true
-      if (types.includes('address') && types.includes('string'))
-        return Address.validate(args[parameterIndex] as Address.Address, {
-          strict: false,
-        })
-      if (types.includes('address') && types.includes('bytes'))
-        return Address.validate(args[parameterIndex] as Address.Address, {
-          strict: false,
-        })
+      // An `undefined` value comes from an empty array, which matches both types.
+      if (
+        types.includes('address') &&
+        (types.includes('string') || types.includes('bytes'))
+      )
+        return (
+          value === undefined ||
+          Address.validate(value as Address.Address, { strict: false })
+        )
       return false
     })()
 
@@ -591,3 +630,13 @@ export function getAmbiguousTypes(
 
   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!]
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ox",
   "description": "Ethereum Standard Library",
-  "version": "0.14.56",
+  "version": "0.14.58",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",

package/tempo/AccountConfig.test-d.ts

@@ -22,6 +22,16 @@ test('from returns a complete configuration', () => {
   expectTypeOf(zero.version).toEqualTypeOf<0n>()
 })
 
+test('fromUpgrade returns a version-one configuration', () => {
+  const config = AccountConfig.fromUpgrade(
+    '0x3333333333333333333333333333333333333333',
+    input,
+  )
+
+  expectTypeOf(config).toMatchTypeOf<AccountConfig.Config>()
+  expectTypeOf(config.version).toEqualTypeOf<1n>()
+})
+
 test('update returns the next complete configuration', () => {
   const config = AccountConfig.update(AccountConfig.from(input), {
     owners: input.owners,

package/tempo/AccountConfig.test.ts

@@ -12,6 +12,13 @@ const config = AccountConfig.from({
 })
 const account = AccountConfig.getAddress(config, { factory })
 
+// Vectors from Tempo `crates/primitives/tests/configurable_account.rs`
+// (`configurable_account_hashes_follow_vectors_and_documented_layout`).
+const tempo = {
+  account: '0x91847576f406d0842ad7c1a0c97c22a122e64278',
+  factory: '0x9999999999999999999999999999999999999999',
+} as const
+
 describe('from', () => {
   test('behavior: normalizes an initial configuration', () => {
     expect(
@@ -99,10 +106,103 @@ describe('fromRpc/toRpc', () => {
   })
 })
 
+describe('fromUpgrade', () => {
+  const root = '0x3333333333333333333333333333333333333333'
+
+  test('example: derives the migrated config', () => {
+    // The root key may also be listed as an owner.
+    const config = AccountConfig.fromUpgrade(root, {
+      owners: [
+        { owner: root, weight: 1 },
+        { owner: owner_1, weight: 1 },
+      ],
+      threshold: 2,
+    })
+    expect({
+      commitment: AccountConfig.getCommitment(config),
+      config,
+    }).toMatchInlineSnapshot(`
+      {
+        "commitment": "0xabca6d8f3a14b99ecaef378042e6a2ffa4f231125517e073cfbd3bcd69ac6ea1",
+        "config": {
+          "owners": [
+            {
+              "owner": "0x1111111111111111111111111111111111111111",
+              "weight": 1,
+            },
+            {
+              "owner": "0x3333333333333333333333333333333333333333",
+              "weight": 1,
+            },
+          ],
+          "salt": "0x42b3dad8fa6c40b50e6dbbbdaaace72d6c04250c16c1e263a52355983a30eb56",
+          "threshold": 2,
+          "version": 1n,
+        },
+      }
+    `)
+  })
+
+  test('behavior: binds the salt to the account', () => {
+    const options = {
+      owners: [{ owner: owner_1, weight: 1 }],
+      threshold: 1,
+    } as const
+    expect(AccountConfig.fromUpgrade(root, options).salt).not.toBe(
+      AccountConfig.fromUpgrade(owner_2, options).salt,
+    )
+  })
+
+  test('error: rejects an invalid account', () => {
+    expect(() =>
+      AccountConfig.fromUpgrade('0x1234', {
+        owners: [{ owner: owner_1, weight: 1 }],
+        threshold: 1,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      [Address.InvalidAddressError: Address "0x1234" is invalid.
+
+      Details: Address is not a 20 byte (40 hexadecimal character) value.]
+    `)
+  })
+
+  test('error: rejects an invalid config', () => {
+    expect(() =>
+      AccountConfig.fromUpgrade(root, {
+        owners: [{ owner: owner_1, weight: 1 }],
+        threshold: 2,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[AccountConfig.InvalidConfigError: Invalid account config: threshold exceeds total owner weight.]`,
+    )
+  })
+})
+
 describe('getAddress', () => {
+  test('example: matches the Tempo vectors', () => {
+    expect({
+      maxOwners: AccountConfig.getAddress(
+        {
+          owners: Array.from({ length: AccountConfig.maxOwners }, (_, i) => ({
+            owner: Hex.padLeft(Hex.fromNumber(i + 1), 20),
+            weight: 1,
+          })),
+          threshold: 8,
+        },
+        { factory: tempo.factory },
+      ),
+      single: AccountConfig.getAddress(config, { factory: tempo.factory }),
+    }).toMatchInlineSnapshot(`
+      {
+        "maxOwners": "0x7a4279bb3f1b8b54d703484317f64eae6814e827",
+        "single": "0x87c346a9029d675f296db533b12e146439cf20d5",
+      }
+    `)
+  })
+
   test('example: matches the frozen CREATE2 vector', () => {
     expect(account).toMatchInlineSnapshot(
-      `"0x90ba71cb7534da990a1182cf28c9bf415055e03d"`,
+      `"0x2318ebe50d1d476ec10854bfd949f96ea7737b68"`,
     )
     expect(account).not.toBe('0x8820d1497eeaf4f68e00b2cfc00a2f3b1dbb00da')
   })
@@ -120,7 +220,7 @@ describe('getAddress', () => {
         },
         { factory },
       ),
-    ).toMatchInlineSnapshot(`"0x7898a7d1dd96946d2a968de1540ca884a244320c"`)
+    ).toMatchInlineSnapshot(`"0x1baa996a4f142d99999aa22f1cb1eb97eed2a24a"`)
   })
 
   test('behavior: is stable and binds the salt', () => {
@@ -135,8 +235,8 @@ describe('getAddress', () => {
       ),
     }).toMatchInlineSnapshot(`
       {
-        "repeated": "0x90ba71cb7534da990a1182cf28c9bf415055e03d",
-        "salted": "0xa1a8472f4a01772db729d8ebc73fe46120750b83",
+        "repeated": "0x2318ebe50d1d476ec10854bfd949f96ea7737b68",
+        "salted": "0x70d2e44032514493b68641ce5182cc878baa51f0",
       }
     `)
   })
@@ -157,6 +257,18 @@ describe('getAddress', () => {
 })
 
 describe('getCommitment', () => {
+  test('example: matches the Tempo vectors', () => {
+    expect({
+      current: AccountConfig.getCommitment({ ...config, version: 1n }),
+      initial: AccountConfig.getCommitment(config),
+    }).toMatchInlineSnapshot(`
+      {
+        "current": "0xee570a0f26f17b41cdf0952a04ee01ea23495b0c0a59f9c904b0d60cb76453c3",
+        "initial": "0x79cc3a5fcbe18cb8cbbd2b41393750ccf3bbc20533a846755767fa10068ae01d",
+      }
+    `)
+  })
+
   test('example: matches the frozen initial and current vectors', () => {
     expect({
       current: AccountConfig.getCommitment({ ...config, version: 1n }),
@@ -164,20 +276,40 @@ describe('getCommitment', () => {
       initial: AccountConfig.getCommitment(config),
     }).toMatchInlineSnapshot(`
       {
-        "current": "0x6237ca5930f2265d4fb70a0305dd6ceea4df227053b4a62c304489ede946a2f8",
-        "currentNumber": "0x6237ca5930f2265d4fb70a0305dd6ceea4df227053b4a62c304489ede946a2f8",
-        "initial": "0xa9e7d1e2ad25e227a4de5f38f3bba31d854ffc8efec46aaa8649097a516bb4ee",
+        "current": "0xee570a0f26f17b41cdf0952a04ee01ea23495b0c0a59f9c904b0d60cb76453c3",
+        "currentNumber": "0xee570a0f26f17b41cdf0952a04ee01ea23495b0c0a59f9c904b0d60cb76453c3",
+        "initial": "0x79cc3a5fcbe18cb8cbbd2b41393750ccf3bbc20533a846755767fa10068ae01d",
       }
     `)
   })
 })
 
 describe('getSignPayload', () => {
+  test('example: matches the Tempo vectors', () => {
+    expect({
+      current: AccountConfig.getSignPayload({
+        account: tempo.account,
+        config: { version: 1n },
+        payload,
+      }),
+      initial: AccountConfig.getSignPayload({
+        account: tempo.account,
+        config,
+        payload,
+      }),
+    }).toMatchInlineSnapshot(`
+      {
+        "current": "0x285c850cb2803beb10f2f212dac73784a1a03b3991ba79081b24bfa91beb9182",
+        "initial": "0xe6fa513b5ab32da6f116443f13191096bce77b4850f4d51f3aa436fa7650c964",
+      }
+    `)
+  })
+
   test('example: matches the frozen version-0 vector', () => {
     expect(
       AccountConfig.getSignPayload({ account, config, payload }),
     ).toMatchInlineSnapshot(
-      `"0x728efe90611b01c91c2be0da56e7eb8e0d2c274c84f97182e274187dde0b8a20"`,
+      `"0x32144254ec42f7a37b97e3a843667b527479f933320be553265e6594dc44ea87"`,
     )
   })
 
@@ -325,8 +457,8 @@ describe('assert/validate', () => {
       valid: AccountConfig.validate(boundary),
     }).toMatchInlineSnapshot(`
       {
-        "account": "0x6acb25715a2b0cf05c098f753a87d9b38471e99f",
-        "commitment": "0x0dc47a7ab45ffa21a01bfd115427e26617b5a57d7ccbea57db2fd4537ba96f56",
+        "account": "0x8400988285be93cba9391d445e473601633e5d62",
+        "commitment": "0xa9282ca5b73ac63b7e27f49cafa6ab13bd2aa79fc45267cf27342db73150cd46",
         "rlpHash": "0xbaf0d030add91caaa10815d2e99c942f1e39b0d199216973781adb4fc1af6955",
         "rlpLength": 1145,
         "valid": true,
@@ -496,6 +628,7 @@ test('exports', () => {
       "from",
       "fromRpc",
       "fromTuple",
+      "fromUpgrade",
       "getAddress",
       "getCommitment",
       "getSignPayload",

package/tempo/AccountConfig.ts

@@ -33,17 +33,25 @@ export const signatureTypeByte = '0x05' as const
 export const zeroSalt = `0x${'00'.repeat(32)}` as const
 
 /** Domain prefix for the configurable account address derivation. */
-const accountDomain = 'tempo:multisig:account'
+const accountDomain = 'tempo:configurable-account:account'
 
 /** Domain prefix for account configuration commitments. */
-const configDomain = 'tempo:multisig:config'
+const configDomain = 'tempo:configurable-account:config'
 
-/** Keccak-256 of the canonical recovery wallet creation code. */
-const recoveryWalletInitCodeHash =
+/**
+ * Keccak-256 of the account proxy creation code.
+ *
+ * Placeholder until [TIP-1110](https://tips.sh/1110) fixes the canonical
+ * account proxy, which will change every derived address.
+ */
+const accountProxyInitCodeHash =
   '0x583cc63a2e37f645b43eac911b1a6d6de08b83abdc308c61364edda8cfc3bd37'
 
 /** Domain prefix for configurable account owner approvals. */
-const signatureDomain = 'tempo:multisig:signature'
+const signatureDomain = 'tempo:configurable-account:signature'
+
+/** Domain prefix for the salt of an account migrated in place. */
+const upgradeDomain = 'tempo:configurable-account:upgrade'
 
 /**
  * Complete account configuration witness.
@@ -335,12 +343,75 @@ export function fromTuple(tuple: Tuple): Config {
   return config
 }
 
+/**
+ * Derives the configuration an existing account installs when it migrates in
+ * place with the `upgradeAccount` precompile call
+ * ([TIP-1113](https://tips.sh/1113)).
+ *
+ * The account keeps its address. Its salt is
+ * `keccak256("tempo:configurable-account:upgrade" || account)` and its version
+ * is `1n`. Owners are sorted into canonical order and the config is validated.
+ * The account itself may be listed as an owner.
+ *
+ * @example
+ * ```ts twoslash
+ * import { AccountConfig } from 'ox/tempo'
+ *
+ * const config = AccountConfig.fromUpgrade(
+ *   '0x3333333333333333333333333333333333333333',
+ *   {
+ *     owners: [
+ *       {
+ *         owner: '0x1111111111111111111111111111111111111111',
+ *         weight: 1
+ *       }
+ *     ],
+ *     threshold: 1
+ *   }
+ * )
+ * // config.version === 1n
+ * ```
+ *
+ * @param account - The account migrating in place.
+ * @param options - The owners and threshold to install.
+ * @returns The installed account config.
+ */
+export function fromUpgrade<numberType = number>(
+  account: Address.Address,
+  options: fromUpgrade.Options<numberType>,
+): Config<1n, numberType> {
+  Address.assert(account)
+  return from({
+    owners: options.owners,
+    salt: Hash.keccak256(Hex.concat(Hex.fromString(upgradeDomain), account)),
+    threshold: options.threshold,
+    version: 1n,
+  })
+}
+
+export declare namespace fromUpgrade {
+  type Options<numberType = number> = {
+    /** Weighted owners to install. Sorted into canonical order. */
+    owners: readonly Owner<numberType>[]
+    /** Minimum total owner weight required for authorization. */
+    threshold: numberType
+  }
+
+  type ErrorType =
+    | Address.assert.ErrorType
+    | assert.ErrorType
+    | Hash.keccak256.ErrorType
+    | Hex.concat.ErrorType
+    | Hex.fromString.ErrorType
+    | Errors.GlobalErrorType
+}
+
 /**
  * Derives the stable configurable account address.
  *
  * The initial config is hashed into a CREATE2 salt using fixed-width
  * big-endian fields, not RLP. The account uses the chain-configured recovery
- * factory and wallet init-code hash.
+ * factory and account proxy init-code hash.
  *
  * The address is derived once from the initial version-0 config. Config
  * updates do not change it.
@@ -388,7 +459,7 @@ export function getAddress(
     ),
   )
   const account = ContractAddress.fromCreate2({
-    bytecodeHash: recoveryWalletInitCodeHash,
+    bytecodeHash: accountProxyInitCodeHash,
     from: options.factory,
     salt: accountSalt,
   })
@@ -421,7 +492,7 @@ export declare namespace getAddress {
  * Computes the commitment for an account configuration.
  *
  * The commitment uses raw fixed-width fields, not RLP or ABI encoding:
- * `keccak256("tempo:multisig:config" || salt || uint64be(version) || uint8(threshold) || uint8(owners.length) || owners)`.
+ * `keccak256("tempo:configurable-account:config" || salt || uint64be(version) || uint8(threshold) || uint8(owners.length) || owners)`.
  *
  * @example
  * ```ts twoslash
@@ -469,7 +540,7 @@ export declare namespace getCommitment {
 /**
  * Computes the digest a configurable account owner approves (signs).
  *
- * `keccak256("tempo:multisig:signature" || inner_digest || account || uint64be(version))`,
+ * `keccak256("tempo:configurable-account:signature" || inner_digest || account || uint64be(version))`,
  * where `inner_digest` is the transaction sign payload
  * ({@link ox#TxEnvelopeTempo.(getSignPayload:function)}).
  *