ox 1.8.8 → 1.8.10

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/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!]
+}

package/src/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/src/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(
@@ -98,10 +105,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')
   })
@@ -119,7 +219,7 @@ describe('getAddress', () => {
         },
         { factory },
       ),
-    ).toMatchInlineSnapshot(`"0x7898a7d1dd96946d2a968de1540ca884a244320c"`)
+    ).toMatchInlineSnapshot(`"0x1baa996a4f142d99999aa22f1cb1eb97eed2a24a"`)
   })
 
   test('behavior: is stable and binds the salt', () => {
@@ -134,8 +234,8 @@ describe('getAddress', () => {
       ),
     }).toMatchInlineSnapshot(`
       {
-        "repeated": "0x90ba71cb7534da990a1182cf28c9bf415055e03d",
-        "salted": "0xa1a8472f4a01772db729d8ebc73fe46120750b83",
+        "repeated": "0x2318ebe50d1d476ec10854bfd949f96ea7737b68",
+        "salted": "0x70d2e44032514493b68641ce5182cc878baa51f0",
       }
     `)
   })
@@ -156,6 +256,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 }),
@@ -163,20 +275,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"`,
     )
   })
 
@@ -324,8 +456,8 @@ describe('assert/validate', () => {
       valid: AccountConfig.validate(boundary),
     }).toMatchInlineSnapshot(`
       {
-        "account": "0x6acb25715a2b0cf05c098f753a87d9b38471e99f",
-        "commitment": "0x0dc47a7ab45ffa21a01bfd115427e26617b5a57d7ccbea57db2fd4537ba96f56",
+        "account": "0x8400988285be93cba9391d445e473601633e5d62",
+        "commitment": "0xa9282ca5b73ac63b7e27f49cafa6ab13bd2aa79fc45267cf27342db73150cd46",
         "rlpHash": "0xbaf0d030add91caaa10815d2e99c942f1e39b0d199216973781adb4fc1af6955",
         "rlpLength": 1145,
         "valid": true,
@@ -495,6 +627,7 @@ test('exports', () => {
       "from",
       "fromRpc",
       "fromTuple",
+      "fromUpgrade",
       "getAddress",
       "getCommitment",
       "getSignPayload",

package/src/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.
@@ -347,12 +355,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.
@@ -403,7 +474,7 @@ export function getAddress(
     ),
   )
   const account = ContractAddress.fromCreate2({
-    bytecodeHash: recoveryWalletInitCodeHash,
+    bytecodeHash: accountProxyInitCodeHash,
     from: options.factory,
     salt: accountSalt,
   })
@@ -436,7 +507,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
@@ -487,7 +558,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)}).
  *