viem 2.57.8 → 2.57.11

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/Transport.ts

@@ -85,7 +85,9 @@ type RelayProxyParameters = {
   policy?: 'sign-only' | 'sign-and-broadcast' | undefined
 }
 
+/** Transport that {@link withFeePayer} returns. */
 export type FeePayer = Transport<typeof withFeePayer.type>
+/** Transport that {@link withRelay} returns for a remote relay. */
 export type Relay = Transport<typeof withRelay.type, { accounts: true }>
 
 /**

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

package/tempo/actions/accessKey.ts

@@ -72,6 +72,7 @@ const signatureTypes = {
   0: 'secp256k1',
   1: 'p256',
   2: 'webAuthn',
+  3: 'configurable',
 } as const satisfies Record<number, string>
 
 /** @internal */
@@ -558,8 +559,8 @@ export namespace getMetadata {
   export type ReturnValue = {
     /** The access key address. */
     address: Address
-    /** The key type. */
-    keyType: 'secp256k1' | 'p256' | 'webAuthn'
+    /** The key type. `configurable` for a configurable account access key. */
+    keyType: 'secp256k1' | 'p256' | 'webAuthn' | 'configurable'
     /** The expiry timestamp. */
     expiry: bigint
     /** The spending policy. */