viem 2.57.8 → 2.57.10

package/tempo/Abis.ts

@@ -1,5 +1,5 @@
 // Generated with `pnpm gen:tempo-abis`. Do not modify manually.
-// Source: tempoxyz/tempo@6ef1f812c9ddcbe90a88ada73944012520942d26
+// Source: tempoxyz/tempo@e539a1dac2921670585a08215e516d8b98aa527a
 
 export const accountKeychain = [
   {
@@ -444,7 +444,7 @@ export const addressRegistry = [
   { name: 'VirtualAddressUnregistered', type: 'error', inputs: [] },
 ] as const
 
-export const nativeMultisig = [
+export const configurableAccount = [
   {
     name: 'deriveAccount',
     type: 'function',
@@ -505,7 +505,24 @@ export const nativeMultisig = [
     outputs: [],
   },
   {
-    name: 'MultisigConfigUpdated',
+    name: 'upgradeAccount',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { type: 'uint8', name: 'threshold' },
+      {
+        type: 'tuple[]',
+        name: 'owners',
+        components: [
+          { type: 'address', name: 'owner' },
+          { type: 'uint8', name: 'weight' },
+        ],
+      },
+    ],
+    outputs: [{ type: 'bytes32', name: 'commitment' }],
+  },
+  {
+    name: 'ConfigurableAccountConfigUpdated',
     type: 'event',
     inputs: [
       { type: 'address', name: 'account', indexed: true },
@@ -522,15 +539,37 @@ export const nativeMultisig = [
       },
     ],
   },
+  {
+    name: 'AccountUpgraded',
+    type: 'event',
+    inputs: [
+      { type: 'address', name: 'account', indexed: true },
+      { type: 'bytes32', name: 'commitment', indexed: true },
+      { type: 'bytes32', name: 'salt' },
+      { type: 'uint8', name: 'threshold' },
+      {
+        type: 'tuple[]',
+        name: 'owners',
+        components: [
+          { type: 'address', name: 'owner' },
+          { type: 'uint8', name: 'weight' },
+        ],
+      },
+    ],
+  },
   { name: 'InvalidAccount', type: 'error', inputs: [] },
   { name: 'InvalidConfig', type: 'error', inputs: [] },
   { name: 'InvalidThreshold', type: 'error', inputs: [] },
-  { name: 'InvalidMultisigOwner', type: 'error', inputs: [] },
+  { name: 'InvalidConfigurableAccountOwner', type: 'error', inputs: [] },
   { name: 'InvalidWeight', type: 'error', inputs: [] },
   { name: 'TooManyOwners', type: 'error', inputs: [] },
   { name: 'DuplicateOwner', type: 'error', inputs: [] },
   { name: 'InvalidOwnerOrder', type: 'error', inputs: [] },
-  { name: 'UnauthorizedMultisigCaller', type: 'error', inputs: [] },
+  { name: 'UnauthorizedConfigurableAccountCaller', type: 'error', inputs: [] },
+  { name: 'PrimitiveRootRequired', type: 'error', inputs: [] },
+  { name: 'UpgradeMustBeOnlyCall', type: 'error', inputs: [] },
+  { name: 'AccountAlreadyConfigurable', type: 'error', inputs: [] },
+  { name: 'AccountHasCode', type: 'error', inputs: [] },
 ] as const
 
 export const currentCommittee = [
@@ -705,6 +744,17 @@ export const signatureVerifier = [
     ],
     outputs: [{ type: 'bool' }],
   },
+  {
+    name: 'verifyConfigurableAccount',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [
+      { type: 'address', name: 'account' },
+      { type: 'bytes32', name: 'hash' },
+      { type: 'bytes', name: 'signature' },
+    ],
+    outputs: [{ type: 'bool' }],
+  },
   { name: 'InvalidFormat', type: 'error', inputs: [] },
   { name: 'InvalidSignature', type: 'error', inputs: [] },
 ] as const
@@ -1710,6 +1760,11 @@ export const tip20ChannelReserve = [
   { name: 'CaptureAmountInvalid', type: 'error', inputs: [] },
   { name: 'CloseNotReady', type: 'error', inputs: [] },
   { name: 'DepositOverflow', type: 'error', inputs: [] },
+  {
+    name: 'RootKeyRetired',
+    type: 'error',
+    inputs: [{ type: 'address', name: 'account' }],
+  },
 ] as const
 
 export const tip20Factory = [
@@ -2314,6 +2369,11 @@ export const tip20 = [
   { name: 'InvalidSignature', type: 'error', inputs: [] },
   { name: 'LogoURITooLong', type: 'error', inputs: [] },
   { name: 'InvalidLogoURI', type: 'error', inputs: [] },
+  {
+    name: 'RootKeyRetired',
+    type: 'error',
+    inputs: [{ type: 'address', name: 'account' }],
+  },
   {
     name: 'hasRole',
     type: 'function',
@@ -9861,10 +9921,10 @@ export const directPropAmm = [
 export const core = [
   ...accountKeychain,
   ...addressRegistry,
+  ...configurableAccount,
   ...currentCommittee,
   ...feeAmm,
   ...feeManager,
-  ...nativeMultisig,
   ...nonce,
   ...receivePolicyGuard,
   ...signatureVerifier,
@@ -9946,6 +10006,19 @@ export const coreErrors = [
   { name: 'InvalidMasterAddress', type: 'error', inputs: [] },
   { name: 'ProofOfWorkFailed', type: 'error', inputs: [] },
   { name: 'VirtualAddressUnregistered', type: 'error', inputs: [] },
+  { name: 'InvalidAccount', type: 'error', inputs: [] },
+  { name: 'InvalidConfig', type: 'error', inputs: [] },
+  { name: 'InvalidThreshold', type: 'error', inputs: [] },
+  { name: 'InvalidConfigurableAccountOwner', type: 'error', inputs: [] },
+  { name: 'InvalidWeight', type: 'error', inputs: [] },
+  { name: 'TooManyOwners', type: 'error', inputs: [] },
+  { name: 'DuplicateOwner', type: 'error', inputs: [] },
+  { name: 'InvalidOwnerOrder', type: 'error', inputs: [] },
+  { name: 'UnauthorizedConfigurableAccountCaller', type: 'error', inputs: [] },
+  { name: 'PrimitiveRootRequired', type: 'error', inputs: [] },
+  { name: 'UpgradeMustBeOnlyCall', type: 'error', inputs: [] },
+  { name: 'AccountAlreadyConfigurable', type: 'error', inputs: [] },
+  { name: 'AccountHasCode', type: 'error', inputs: [] },
   { name: 'Unauthorized', type: 'error', inputs: [] },
   { name: 'IdenticalAddresses', type: 'error', inputs: [] },
   { name: 'InvalidToken', type: 'error', inputs: [] },
@@ -9956,15 +10029,6 @@ export const coreErrors = [
   { name: 'InvalidSwapCalculation', type: 'error', inputs: [] },
   { name: 'InsufficientFeeTokenBalance', type: 'error', inputs: [] },
   { name: 'CannotChangeWithinBlock', type: 'error', inputs: [] },
-  { name: 'InvalidAccount', type: 'error', inputs: [] },
-  { name: 'InvalidConfig', type: 'error', inputs: [] },
-  { name: 'InvalidThreshold', type: 'error', inputs: [] },
-  { name: 'InvalidMultisigOwner', type: 'error', inputs: [] },
-  { name: 'InvalidWeight', type: 'error', inputs: [] },
-  { name: 'TooManyOwners', type: 'error', inputs: [] },
-  { name: 'DuplicateOwner', type: 'error', inputs: [] },
-  { name: 'InvalidOwnerOrder', type: 'error', inputs: [] },
-  { name: 'UnauthorizedMultisigCaller', type: 'error', inputs: [] },
   { name: 'ProtocolNonceNotSupported', type: 'error', inputs: [] },
   { name: 'InvalidNonceKey', type: 'error', inputs: [] },
   { name: 'NonceOverflow', type: 'error', inputs: [] },
@@ -10026,6 +10090,11 @@ export const coreErrors = [
   { name: 'PermitExpired', type: 'error', inputs: [] },
   { name: 'LogoURITooLong', type: 'error', inputs: [] },
   { name: 'InvalidLogoURI', type: 'error', inputs: [] },
+  {
+    name: 'RootKeyRetired',
+    type: 'error',
+    inputs: [{ type: 'address', name: 'account' }],
+  },
   { name: 'ChannelAlreadyExists', type: 'error', inputs: [] },
   { name: 'ChannelNotFound', type: 'error', inputs: [] },
   { name: 'NotPayer', type: 'error', inputs: [] },

package/tempo/Account.ts

@@ -24,7 +24,7 @@ import { keccak256 } from '../utils/hash/keccak256.js'
 import { hashMessage } from '../utils/signature/hashMessage.js'
 import { hashTypedData } from '../utils/signature/hashTypedData.js'
 import type { SerializeTransactionFn } from '../utils/transaction/serializeTransaction.js'
-import { nativeMultisigFactory } from './Addresses.js'
+import { configurableAccountRecoveryFactory } from './Addresses.js'
 import { parseApproval } from './accounts/Signature.js'
 import type { KeyAuthorizationManager } from './KeyAuthorizationManager.js'
 import * as Transaction from './Transaction.js'
@@ -281,8 +281,10 @@ export declare namespace fromSecp256k1 {
  *
  * The returned account does not hold a key itself. Omit `address` or set it to
  * `infer` to derive an account address from its initial config. For a current
- * config, set `address` to the stable account address. Pass the address directly
- * for an address-only account.
+ * config, set `address` to the stable account address. For an account
+ * upgraded in place with `Actions.accounts.upgrade`, set `address` to the
+ * upgraded account and pass the installed owners and threshold as `upgrade`.
+ * Pass the address directly for an address-only account.
  *
  * Owners can be accounts or addresses directly, or weighted `{ owner, weight }`
  * entries. Direct owners default to weight `1`, and `threshold` defaults to `1`.
@@ -309,7 +311,7 @@ export declare namespace fromSecp256k1 {
  * const transaction = await client.signTransaction(request)
  * ```
  *
- * @param value Initial config, current config, or account address.
+ * @param value Initial config, current config, upgrade config, or account address.
  * @returns Configurable account.
  */
 export function fromConfig(
@@ -318,6 +320,9 @@ export function fromConfig(
 export function fromConfig(
   value: fromConfig.CurrentConfig,
 ): ConfigurableAccount<AccountConfig.Config>
+export function fromConfig(
+  value: fromConfig.UpgradeConfig,
+): ConfigurableAccount<AccountConfig.Config>
 export function fromConfig(
   address: Address.Address,
 ): ConfigurableAccount<undefined>
@@ -325,7 +330,12 @@ export function fromConfig(value: fromConfig.Parameters): ConfigurableAccount
 export function fromConfig(value: fromConfig.Parameters): ConfigurableAccount {
   const configInput = (() => {
     if (typeof value === 'string') return undefined
-    const { address: _, ...config } = value
+    if ('upgrade' in value) return value.upgrade
+    const {
+      address: _,
+      factory: __,
+      ...config
+    } = value as fromConfig.InitialConfig
     return config
   })()
   const config = (() => {
@@ -335,16 +345,16 @@ export function fromConfig(value: fromConfig.Parameters): ConfigurableAccount {
         ? { owner: value, weight: 1 }
         : value,
     )
-    return AccountConfig.from({
-      ...configInput,
-      owners: ownerEntries.map(({ owner, weight }) => ({
-        owner: typeof owner === 'string' ? owner : owner.address,
-        weight,
-      })),
-      threshold: configInput.threshold ?? 1,
-    })
+    const owners = ownerEntries.map(({ owner, weight }) => ({
+      owner: typeof owner === 'string' ? owner : owner.address,
+      weight,
+    }))
+    const threshold = configInput.threshold ?? 1
+    if (typeof value !== 'string' && 'upgrade' in value)
+      return AccountConfig.fromUpgrade(value.address, { owners, threshold })
+    return AccountConfig.from({ ...configInput, owners, threshold })
   })()
-  if (typeof value !== 'string') {
+  if (typeof value !== 'string' && !('upgrade' in value)) {
     if (
       (value.address === undefined || value.address === 'infer') &&
       config!.version !== 0n
@@ -362,7 +372,7 @@ export function fromConfig(value: fromConfig.Parameters): ConfigurableAccount {
       if (typeof value === 'string') return value
       if (value.address === undefined || value.address === 'infer')
         return AccountConfig.getAddress(config!, {
-          factory: nativeMultisigFactory,
+          factory: value.factory ?? configurableAccountRecoveryFactory,
         })
       return value.address
     })(),
@@ -484,6 +494,11 @@ export declare namespace fromConfig {
   export type InitialConfig = {
     /** Derives the stable account address from this initial config. */
     address?: 'infer' | undefined
+    /**
+     * Recovery factory used to derive the address.
+     * @default `Addresses.configurableAccountRecoveryFactory`
+     */
+    factory?: Address.Address | undefined
     /** Weighted owners. */
     owners: readonly Owner[]
     /** Caller-chosen 32-byte salt. */
@@ -505,7 +520,24 @@ export declare namespace fromConfig {
       })
 
   /** Parameters for {@link fromConfig}. */
-  export type Parameters = Address.Address | CurrentConfig | InitialConfig
+  export type Parameters =
+    | Address.Address
+    | CurrentConfig
+    | InitialConfig
+    | UpgradeConfig
+
+  /** Account upgraded in place and the owners and threshold it installed. */
+  export type UpgradeConfig = {
+    /** Upgraded account address. */
+    address: Address.Address
+    /** Owners and threshold installed by the upgrade. */
+    upgrade: {
+      /** Weighted owners. */
+      owners: readonly Owner[]
+      /** Minimum owner weight required for authorization. */
+      threshold?: number | undefined
+    }
+  }
 }
 
 export type ConfigurableAccount<
@@ -1110,6 +1142,10 @@ declare namespace fromAccessKey {
   export type ReturnValue = AccessKeyAccount
 }
 
+// TODO: support configurable accounts as access keys (TIP-1111): authorize a
+// configurable account with key type `configurable`, sign as it with a keychain
+// envelope wrapping its configurable signature, and accept those envelopes in the
+// relay fee payer.
 /** @internal */
 export function resolveAccessKey(
   accessKey: resolveAccessKey.Parameters,

package/tempo/Addresses.ts

@@ -12,13 +12,13 @@ export const accountImplementation =
 export const accountKeychain = '0xaAAAaaAA00000000000000000000000000000000'
 export const accountRegistrar = '0x7702ac0000000000000000000000000000000000'
 export const addressRegistry = '0xfdc0000000000000000000000000000000000000'
+export const configurableAccount = '0xAACC000000000000000000000000000000000000'
+/** Default configurable account recovery factory. Temporary until the production address is finalized. */
+export const configurableAccountRecoveryFactory =
+  '0x7171717171717171717171717171717171717171'
 /** Current consensus committee precompile address, used with `Abis.currentCommittee` to read committee members. */
 export const currentCommittee = '0xC077e00000000000000000000000000000000000'
 export const feeManager = '0xfeec000000000000000000000000000000000000'
-export const nativeMultisig = '0xAACC000000000000000000000000000000000000'
-/** Temporary recovery factory until the production address is finalized. */
-export const nativeMultisigFactory =
-  '0x7171717171717171717171717171717171717171'
 export const nonceManager = '0x4e4F4E4345000000000000000000000000000000'
 export const ousd = '0x20c0000000000000000000006a37DA5C996874BE'
 export const pathUsd = '0x20c0000000000000000000000000000000000000'

package/tempo/Decorator.ts

@@ -503,6 +503,34 @@ type DecoratorBase<
     ) => ReturnType<typeof accessKeyActions.watchWitnessBurned>
   }
   accounts: {
+    /**
+     * Derives a configurable account address from an initial config with the
+     * configurable account precompile.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { Account, tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({
+     *   account: Account.fromSecp256k1('0x...'),
+     *   chain: tempo,
+     *   transport: http(),
+     * }).extend(tempoActions())
+     *
+     * const address = await client.accounts.deriveAccount({
+     *   owners: [{ owner: '0x...', weight: 1 }],
+     *   threshold: 1,
+     * })
+     * ```
+     *
+     * @param parameters - Owners, threshold, and optional salt.
+     * @returns The configurable account address.
+     */
+    deriveAccount: (
+      parameters: accountsActions.deriveAccount.Parameters,
+    ) => Promise<accountsActions.deriveAccount.ReturnValue>
     /**
      * Gets the current cached config for a configurable account.
      *
@@ -543,6 +571,90 @@ type DecoratorBase<
     updateConfigSync: (
       parameters: accountsActions.updateConfigSync.Parameters<chain, account>,
     ) => Promise<accountsActions.updateConfigSync.ReturnValue>
+    /**
+     * Upgrades an existing account to a configurable account in place.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { Account, tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({
+     *   account: Account.fromSecp256k1('0x...'),
+     *   chain: tempo,
+     *   transport: http(),
+     * }).extend(tempoActions())
+     *
+     * const hash = await client.accounts.upgrade({
+     *   owners: [{ owner: '0x...', weight: 1 }],
+     *   threshold: 1,
+     * })
+     * ```
+     *
+     * @param parameters - Owners, threshold, and transaction parameters.
+     * @returns The transaction hash.
+     */
+    upgrade: (
+      parameters: accountsActions.upgrade.Parameters<chain, account>,
+    ) => Promise<accountsActions.upgrade.ReturnValue>
+    /**
+     * Upgrades an existing account to a configurable account in place and
+     * waits for confirmation.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { Account, tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({
+     *   account: Account.fromSecp256k1('0x...'),
+     *   chain: tempo,
+     *   transport: http(),
+     * }).extend(tempoActions())
+     *
+     * const { config } = await client.accounts.upgradeSync({
+     *   owners: [{ owner: '0x...', weight: 1 }],
+     *   threshold: 1,
+     * })
+     * ```
+     *
+     * @param parameters - Owners, threshold, and transaction parameters.
+     * @returns The installed configuration, its commitment, and the transaction receipt.
+     */
+    upgradeSync: (
+      parameters: accountsActions.upgradeSync.Parameters<chain, account>,
+    ) => Promise<accountsActions.upgradeSync.ReturnValue>
+    /**
+     * Verifies a configurable account signature against the account's
+     * current configuration.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { Account, tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({
+     *   account: Account.fromSecp256k1('0x...'),
+     *   chain: tempo,
+     *   transport: http(),
+     * }).extend(tempoActions())
+     *
+     * const valid = await client.accounts.verifyHash({
+     *   account: '0x...',
+     *   hash: '0x...',
+     *   signature: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Account, hash, and signature.
+     * @returns Whether the signature is valid for the account.
+     */
+    verifyHash: (
+      parameters: accountsActions.verifyHash.Parameters,
+    ) => Promise<accountsActions.verifyHash.ReturnValue>
   }
   amm: {
     /**
@@ -6206,11 +6318,15 @@ export function decorator() {
         'watchWitnessBurned',
       ]),
       accounts: bindActions(client, accountsActions, [
+        'deriveAccount',
         'getConfig',
         'getConfigCommitment',
         'getOperation',
         'updateConfig',
         'updateConfigSync',
+        'upgrade',
+        'upgradeSync',
+        'verifyHash',
       ]),
       amm: bindActions(client, ammActions, [
         'getPool',

package/tempo/ExecutionError.ts

@@ -34,6 +34,9 @@ export type Rpc =
 export const messages: Record<`${AbiErrorName}(${string})`, string> = {
   'AbdicationAlreadyScheduled(uint8)':
     'Abdication is already scheduled for capability {0}.',
+  'AccountAlreadyConfigurable()':
+    'The account is already a configurable account.',
+  'AccountHasCode()': 'Accounts with code cannot be upgraded.',
   'AccountNotAllowed(address)': 'Account {0} is not allowed.',
   'ActiveLeaderRemoved()': 'The active leader cannot be removed.',
   'AddressAlreadyHasValidator()': 'This address already has a validator.',
@@ -100,6 +103,7 @@ export const messages: Record<`${AbiErrorName}(${string})`, string> = {
   'InvalidClaimAddress()': 'Invalid claim address.',
   'InvalidClosedLoopConfig()': 'Invalid closed-loop configuration.',
   'InvalidConfig()': 'Invalid configuration.',
+  'InvalidConfigurableAccountOwner()': 'Invalid owner.',
   'InvalidCurrency()': 'Invalid currency.',
   'InvalidDepositTransition()': 'Invalid deposit transition.',
   'InvalidEncryptionKeyIndex(uint256)': 'Invalid encryption key index ({0}).',
@@ -114,7 +118,6 @@ export const messages: Record<`${AbiErrorName}(${string})`, string> = {
   'InvalidMasterAddress()': 'Invalid master address.',
   'InvalidMigrationIndex()': 'Invalid migration index.',
   'InvalidMode()': 'Invalid mode.',
-  'InvalidMultisigOwner()': 'Invalid owner.',
   'InvalidNonceKey()': 'Invalid nonce key.',
   'InvalidOwner()': 'Invalid owner.',
   'InvalidOwnerOrder()': 'Invalid owner order.',
@@ -191,11 +194,13 @@ export const messages: Record<`${AbiErrorName}(${string})`, string> = {
   'PolicyNotFound()': 'Policy not found.',
   'PolicyNotSimple()': 'Policy is not a simple policy.',
   'PortalIsPaused()': 'The portal is paused.',
+  'PrimitiveRootRequired()': 'The root key must sign the upgrade transaction.',
   'ProofOfWorkFailed()': 'Proof of work failed.',
   'ProtectedAddress()': 'Address is protected.',
   'ProtocolNonceNotSupported()': 'Protocol nonce is not supported.',
   'PublicKeyAlreadyExists()': 'Public key already exists.',
   'ReentrantWithdrawal()': 'Reentrant withdrawals are not allowed.',
+  'RootKeyRetired(address)': 'The root key of {0} is retired.',
   'SequencerConfigurationUnchanged()':
     'The sequencer configuration is unchanged.',
   'SignatureTypeMismatch(uint8,uint8)':
@@ -219,8 +224,11 @@ export const messages: Record<`${AbiErrorName}(${string})`, string> = {
   'Unauthorized()': 'Unauthorized.',
   'UnauthorizedCaller()': 'Unauthorized caller.',
   'UnauthorizedClaimer()': 'Unauthorized claimer.',
-  'UnauthorizedMultisigCaller()': 'Unauthorized multisig caller.',
+  'UnauthorizedConfigurableAccountCaller()':
+    'Unauthorized configurable account caller.',
   'Uninitialized()': 'Uninitialized.',
+  'UpgradeMustBeOnlyCall()':
+    'The upgrade must be the only call in the transaction.',
   'ValidatorAlreadyDeactivated()': 'Validator is already deactivated.',
   'ValidatorAlreadyExists()': 'Validator already exists.',
   'ValidatorNotFound()': 'Validator not found.',
@@ -310,6 +318,24 @@ export const hints: Partial<Record<keyof typeof messages, readonly string[]>> =
     'SupplyCapExceeded()': ['Mint a smaller amount, or raise the supply cap.'],
     'TickOutOfBounds(int16)': ['Use a tick within the allowed range.'],
     'Unauthorized()': ['The account lacks the permission this call requires.'],
+    'AccountAlreadyConfigurable()': [
+      'The account is already configurable. Rotate its owners with `updateConfig` instead.',
+    ],
+    'AccountHasCode()': [
+      'Only accounts without code or delegation can be upgraded in place.',
+    ],
+    'PrimitiveRootRequired()': [
+      "Send the upgrade from the account's root key, not an access key or another account.",
+    ],
+    'RootKeyRetired(address)': [
+      'The account was upgraded to a configurable account. Sign with its owners instead of the retired root key.',
+    ],
+    'UnauthorizedConfigurableAccountCaller()': [
+      'Only the configurable account can update its own configuration.',
+    ],
+    'UpgradeMustBeOnlyCall()': [
+      'Send `upgradeAccount` as the only call, without a key authorization or authorization list.',
+    ],
   }
 
 /** Interpolate `{0}`, `{1}`, … placeholders with args. */

package/tempo/Hardfork.ts

@@ -10,11 +10,25 @@ export const hardforks = [
   't4',
   't5',
   't6',
+  't7',
+  't8',
+  't9',
+  't10',
+  't11',
+  't12',
+  't13',
+  't14',
 ] as const
 
 export type Hardfork = (typeof hardforks)[number]
 
-/** Returns `true` if `current` is before `target`. */
+/**
+ * Returns `true` if `current` is before `target`.
+ *
+ * Unknown `current` hardforks are treated as newer than every known hardfork.
+ */
 export function lt(current: string, target: Hardfork): boolean {
-  return hardforks.indexOf(current as Hardfork) < hardforks.indexOf(target)
+  const index = hardforks.indexOf(current as Hardfork)
+  if (index === -1) return false
+  return index < hardforks.indexOf(target)
 }

package/tempo/Selectors.ts

@@ -49,11 +49,12 @@ export const addressRegistry = {
   resolveVirtualAddress: '0xe2fc56ef',
 } as const satisfies FunctionSelectors<typeof Abis.addressRegistry>
 
-export const nativeMultisig = {
+export const configurableAccount = {
   deriveAccount: '0xce8e071c',
   getConfigCommitment: '0x5bd93359',
   updateConfig: '0x64203645',
-} as const satisfies FunctionSelectors<typeof Abis.nativeMultisig>
+  upgradeAccount: '0x5f5fdc31',
+} as const satisfies FunctionSelectors<typeof Abis.configurableAccount>
 
 export const currentCommittee = {
   getCommitteeMembers: '0xb2a275f9',
@@ -73,6 +74,7 @@ export const receivePolicyGuard = {
 export const signatureVerifier = {
   recover: '0x19045a25',
   verify: '0x1a86b550',
+  verifyConfigurableAccount: '0x8a4c1645',
   verifyKeychain: '0x6c0c731e',
   verifyKeychainAdmin: '0x5f6fc5b7',
 } as const satisfies FunctionSelectors<typeof Abis.signatureVerifier>

package/tempo/Transaction.ts

@@ -103,8 +103,8 @@ export type TransactionRequestRpc = OneOf<
       TransactionRequestTempo<Hex.Hex, Hex.Hex, '0x76'>,
       'accountSimulation'
     > & {
-      /** Account simulation spec, named `multisigSimulation` by the node. */
-      multisigSimulation?: AccountSimulation.Rpc | undefined
+      /** Account simulation spec, named `configurableAccountSimulation` by the node. */
+      configurableAccountSimulation?: AccountSimulation.Rpc | undefined
     })
 >
 

package/tempo/accounts/Config.ts

@@ -4,7 +4,7 @@ import type * as Hex from 'ox/Hex'
 import * as Json from 'ox/Json'
 import { AccountConfig } from 'ox/tempo'
 import { BaseError } from '../../errors/base.js'
-import { nativeMultisigFactory } from '../Addresses.js'
+import { configurableAccountRecoveryFactory } from '../Addresses.js'
 import type * as Store from '../Store.js'
 
 /** A valid 48-owner config is much smaller; 64 KiB bounds hostile store parsing work. */
@@ -78,7 +78,9 @@ function assertKey(options: {
   if (config.version === 0n) {
     if (
       !Address.isEqual(
-        AccountConfig.getAddress(config, { factory: nativeMultisigFactory }),
+        AccountConfig.getAddress(config, {
+          factory: configurableAccountRecoveryFactory,
+        }),
         address,
       )
     )
@@ -106,7 +108,7 @@ function deserialize(value: string): AccountConfig.Config {
 /** Returns the store key for an account and config commitment. */
 function key(options: { address: Address.Address; commitment: Hex.Hex }) {
   const { address, commitment } = options
-  return `multisig:config:${address.toLowerCase()}:${commitment.toLowerCase()}`
+  return `configurableAccount:config:${address.toLowerCase()}:${commitment.toLowerCase()}`
 }
 
 /** Serializes an account config for storage. */

package/tempo/accounts/Operation.ts

@@ -173,12 +173,12 @@ function assertHash(operation: AccountOperation.Operation) {
 
 /** Returns the store key for an operation hash. */
 function operationKey(hash: Hex.Hex) {
-  return `multisig:operation:${hash.toLowerCase()}`
+  return `configurableAccount:operation:${hash.toLowerCase()}`
 }
 
 /** Returns the store key for a submission attempt. */
 function submissionKey(hash: Hex.Hex, submissionId: Hex.Hex) {
-  return `multisig:submission:${hash.toLowerCase()}:${submissionId.toLowerCase()}`
+  return `configurableAccount:submission:${hash.toLowerCase()}:${submissionId.toLowerCase()}`
 }
 
 /** Thrown when a stored account operation is malformed or unsupported. */