viem 2.56.1 → 2.56.3

package/tempo/actions/accessKey.ts

@@ -1,8 +1,11 @@
 import type { Address } from 'abitype'
+import type * as RpcSchema from 'ox/RpcSchema'
 import {
-  type KeyAuthorization,
+  KeyAuthorization,
   MultisigConfig,
-  type SignatureEnvelope,
+  MultisigOperation,
+  type RpcSchemaTempo,
+  SignatureEnvelope,
 } from 'ox/tempo'
 import type { Account } from '../../accounts/types.js'
 import { parseAccount } from '../../accounts/utils/parseAccount.js'
@@ -22,24 +25,23 @@ import type { Chain } from '../../types/chain.js'
 import type { ExtractAbiItem, GetEventArgs } from '../../types/contract.js'
 import type { Log, Log as viem_Log } from '../../types/log.js'
 import type { Hex } from '../../types/misc.js'
-import type { Compute, UnionOmit } from '../../types/utils.js'
+import type { Compute, OneOf, UnionOmit } from '../../types/utils.js'
 import { parseEventLogs } from '../../utils/abi/parseEventLogs.js'
+import { isAddressEqual } from '../../utils/address/isAddressEqual.js'
 import * as Abis from '../Abis.js'
 import type {
   AccessKeyAccount,
   MultisigAccount,
-  resolveAccessKey,
+  RootAccount,
 } from '../Account.js'
 import {
+  fromMultisig,
   getKeyAuthorizationSignPayload,
+  resolveAccessKey,
   signKeyAuthorization,
 } from '../Account.js'
 import * as Addresses from '../Addresses.js'
 import * as Hardfork from '../Hardfork.js'
-import {
-  createMultisigStateResolver,
-  getMultisigOwnerStates,
-} from '../internal/multisig.js'
 import type {
   GetAccountParameter,
   ReadParameters,
@@ -47,7 +49,7 @@ import type {
 } from '../internal/types.js'
 import { defineCall } from '../internal/utils.js'
 import type { TransactionReceipt } from '../Transaction.js'
-import * as multisig from './multisig.js'
+import { getConfig } from './multisig.js'
 
 /** @internal */
 const signatureTypes = {
@@ -242,6 +244,8 @@ export async function authorizeSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = authorize.extractEvent(receipt.logs)
   return {
     ...args,
@@ -436,6 +440,8 @@ export async function burnWitnessSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = burnWitness.extractEvent(receipt.logs)
   return {
     ...args,
@@ -989,6 +995,8 @@ export async function revokeSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = revoke.extractEvent(receipt.logs)
   return {
     ...args,
@@ -1053,12 +1061,11 @@ export async function prepareAuthorization<
     if ('multisig' in parameters) return parameters.multisig
     if (parsed.source !== 'multisig') return undefined
     const account = parsed as MultisigAccount
-    const getState = createMultisigStateResolver((account) =>
-      multisig.getConfig(client, { account }),
-    )
-    const states = await getMultisigOwnerStates(account, getState)
-    const state = states[0]!
-    return { init: !state.initialized, states, version: state.version }
+    if (!account.config)
+      throw new Error(
+        'A multisig config is required to prepare a key authorization.',
+      )
+    return { config: account.config }
   })()
   const authorizationSignPayload = getKeyAuthorizationSignPayload(
     parsed as never,
@@ -1072,8 +1079,8 @@ export async function prepareAuthorization<
     parsed.source === 'multisig' && multisigState
       ? MultisigConfig.getSignPayload({
           account: parsed.address,
+          config: multisigState.config,
           payload: authorizationSignPayload,
-          version: multisigState.version,
         })
       : authorizationSignPayload
   return {
@@ -1142,20 +1149,154 @@ export namespace prepareAuthorization {
  * transient user activation.
  *
  * @param client - Client.
- * @param parameters - Parameters or the prepared result.
- * @returns The signed key authorization.
+ * @param parameters - Authorization fields, or a stored operation hash.
+ * @returns A signed key authorization with multisig operation metadata when coordinated.
  */
+export function signAuthorization<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: signAuthorization.CoordinatedParameters,
+): Promise<signAuthorization.CoordinatedReturnValue>
+export function signAuthorization<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: signAuthorization.LocalParameters<account>,
+): Promise<signAuthorization.ReturnValue>
 export async function signAuthorization<
   chain extends Chain | undefined,
   account extends Account | undefined,
 >(
   client: Client<Transport, chain, account>,
   parameters: signAuthorization.Parameters<account>,
-): Promise<signAuthorization.ReturnValue> {
+): Promise<
+  signAuthorization.CoordinatedReturnValue | signAuthorization.ReturnValue
+> {
+  const coordinated =
+    ('hash' in parameters && parameters.hash) ||
+    ('owner' in parameters && parameters.owner)
+
+  if (coordinated) {
+    const parameters_ = parameters as signAuthorization.CoordinatedParameters
+    const owner_ = parameters_.owner
+    if (!owner_ || typeof owner_ === 'string')
+      throw new Error(
+        'A local owner account is required to approve a multisig key authorization.',
+      )
+    const owner = parseAccount(owner_)
+    const sign = owner.sign
+    if (!sign)
+      throw new Error(
+        'A local owner account is required to approve a multisig key authorization.',
+      )
+
+    const request = await (async () => {
+      if ('hash' in parameters_ && parameters_.hash) {
+        const signature = SignatureEnvelope.serialize(
+          SignatureEnvelope.from(await sign({ hash: parameters_.hash })),
+        )
+        return { hash: parameters_.hash, signature }
+      }
+
+      const {
+        account: account_,
+        owner: _,
+        ...authorization
+      } = parameters_ as signAuthorization.CoordinatedInitialParameters
+      const address = typeof account_ === 'string' ? account_ : account_.address
+      const config = await (async () => {
+        if (typeof account_ !== 'string' && account_.config)
+          return account_.config
+        const config = await getConfig(client, { address })
+        if (config) return config
+        throw new Error(
+          `No current multisig config is cached for account ${address}. Provide the current config.`,
+        )
+      })()
+      const account = (() => {
+        if (config.version !== 0n) return fromMultisig({ address, ...config })
+        const { version: _, ...initialConfig } = config
+        return fromMultisig({ address: 'infer', ...initialConfig })
+      })()
+      if (!isAddressEqual(account.address, address))
+        throw new Error('Initial multisig config does not match the account.')
+      const prepared = await prepareAuthorization(client, {
+        ...authorization,
+        account,
+      } as never)
+      const signature = SignatureEnvelope.serialize(
+        SignatureEnvelope.from(await sign({ hash: prepared.signPayload })),
+      )
+      const { accessKey, admin, chainId, expiry, limits, scopes, witness } =
+        prepared
+      const { accessKeyAddress, keyType: type } = resolveAccessKey(accessKey)
+      const keyAuthorization = KeyAuthorization.from({
+        account: account.address,
+        address: accessKeyAddress,
+        chainId: BigInt(chainId),
+        signature: SignatureEnvelope.from({
+          account: account.address,
+          config,
+          signatures: [SignatureEnvelope.from(signature)],
+        }),
+        type,
+        ...(witness ? { witness } : {}),
+        ...(admin ? { isAdmin: true } : { expiry, limits, scopes }),
+      } as never)
+      return { keyAuthorization: KeyAuthorization.toRpc(keyAuthorization) }
+    })()
+
+    type multisig_approveKeyAuthorization = Extract<
+      RpcSchema.ToViem<RpcSchemaTempo.Multisig>[number],
+      { Method: 'multisig_approveKeyAuthorization' }
+    >
+    const operation = await client.request<multisig_approveKeyAuthorization>({
+      method: 'multisig_approveKeyAuthorization',
+      params: [request],
+    })
+    const multisig = MultisigOperation.fromRpc(operation)
+    const keyAuthorization = KeyAuthorization.deserialize(
+      await (async () => {
+        if (multisig.status === 'success') return multisig.keyAuthorization
+        const approvals = await MultisigOperation.selectApprovals({
+          account: multisig.account,
+          approvals: multisig.approvals,
+          config: multisig.config,
+          hash: multisig.hash,
+        })
+        return MultisigOperation.serializeKeyAuthorization(
+          multisig.keyAuthorization,
+          {
+            account: multisig.account,
+            approvals:
+              approvals.selectedApprovals.length > 0
+                ? approvals.selectedApprovals
+                : approvals.approvals.slice(0, 1),
+            config: multisig.config,
+          },
+        )
+      })(),
+    )
+    if (!keyAuthorization.signature)
+      throw new Error('Expected a signed multisig key authorization.')
+    return {
+      ...keyAuthorization,
+      hash: multisig.hash,
+      multisig,
+      status: multisig.status,
+    } as never
+  }
+
   const prepared = (
-    'multisig' in parameters
+    'signPayload' in parameters
       ? parameters
-      : await prepareAuthorization(client, parameters)
+      : await prepareAuthorization(
+          client,
+          parameters as signAuthorization.LocalParameters<account>,
+        )
   ) as prepareAuthorization.ReturnValue
   const {
     accessKey,
@@ -1170,18 +1311,62 @@ export async function signAuthorization<
     key: accessKey,
     multisig: multisigState,
     ...rest,
-  })
+  }) as never
 }
 
 export namespace signAuthorization {
-  export type Parameters<
+  /** Initial coordinated key authorization parameters. */
+  export type CoordinatedInitialParameters = Omit<
+    prepareAuthorization.Parameters<Account>,
+    'account' | 'multisig'
+  > & {
+    /** Multisig account being authorized. */
+    account: Address | MultisigAccount
+    /** Local owner that approves the authorization. */
+    owner: RootAccount | MultisigAccount
+  }
+
+  /** Coordinated key authorization parameters. */
+  export type CoordinatedParameters = OneOf<
+    | CoordinatedInitialParameters
+    | {
+        /** Stored multisig operation hash. */
+        hash: Hex
+        /** Local owner that approves the authorization. */
+        owner: RootAccount | MultisigAccount
+      }
+  >
+
+  /** Locally signed key authorization parameters. */
+  export type LocalParameters<
     account extends Account | undefined = Account | undefined,
   > = prepareAuthorization.Parameters<account> & {
     /** Serialized approvals from external multisig owners. */
     signatures?: readonly SignatureEnvelope.Serialized[] | undefined
   }
 
+  /** Parameters for {@link signAuthorization}. */
+  export type Parameters<
+    account extends Account | undefined = Account | undefined,
+  > = CoordinatedParameters | LocalParameters<account>
+
+  /** Local return value for {@link signAuthorization}. */
   export type ReturnValue = Awaited<ReturnType<typeof signKeyAuthorization>>
+
+  /** Coordinated return value for {@link signAuthorization}. */
+  export type CoordinatedReturnValue = Compute<
+    ReturnValue & {
+      /** Deterministic multisig operation hash. */
+      hash: Hex
+      /** Current multisig operation. */
+      multisig: MultisigOperation.KeyAuthorizationOperation
+      /** Current multisig operation status. */
+      status: MultisigOperation.KeyAuthorizationOperation['status']
+    }
+  >
+
+  /** Error type for {@link signAuthorization}. */
+  export type ErrorType = BaseErrorType
 }
 
 /**
@@ -1353,6 +1538,8 @@ export async function updateLimitSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = updateLimit.extractEvent(receipt.logs)
   return {
     account: args.account,

package/tempo/actions/amm.ts

@@ -23,6 +23,7 @@ import * as Abis from '../Abis.js'
 import * as Addresses from '../Addresses.js'
 import type { ReadParameters, WriteParameters } from '../internal/types.js'
 import { defineCall } from '../internal/utils.js'
+import type { TransactionReceipt as TempoTransactionReceipt } from '../Transaction.js'
 
 /**
  * Gets the reserves for a liquidity pool.
@@ -405,6 +406,8 @@ export async function rebalanceSwapSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TempoTransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = rebalanceSwap.extractEvent(receipt.logs)
   return {
     ...args,
@@ -636,6 +639,8 @@ export async function mintSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TempoTransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = mint.extractEvent(receipt.logs)
   return {
     ...args,
@@ -851,6 +856,8 @@ export async function burnSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TempoTransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = burn.extractEvent(receipt.logs)
   return {
     ...args,

package/tempo/actions/channel.ts

@@ -171,6 +171,8 @@ export async function closeSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = close.extractEvent(receipt.logs)
   return { ...args, receipt } as never
 }
@@ -511,6 +513,8 @@ export async function openSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = open.extractEvent(receipt.logs)
   return { ...args, receipt } as never
 }
@@ -656,6 +660,8 @@ export async function requestCloseSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = requestClose.extractEvent(receipt.logs)
   return { ...args, receipt } as never
 }
@@ -811,6 +817,8 @@ export async function settleSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = settle.extractEvent(receipt.logs)
   return { ...args, receipt } as never
 }
@@ -1026,6 +1034,8 @@ export async function topUpSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = topUp.extractEvent(receipt.logs)
   return { ...args, receipt } as never
 }
@@ -1172,6 +1182,8 @@ export async function withdrawSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = withdraw.extractEvent(receipt.logs)
   return { ...args, receipt } as never
 }

package/tempo/actions/dex.ts

@@ -387,6 +387,8 @@ export async function cancelSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = cancel.extractEvent(receipt.logs)
   return {
     ...args,
@@ -588,6 +590,8 @@ export async function cancelStaleSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = cancelStale.extractEvent(receipt.logs)
   return {
     ...args,
@@ -783,6 +787,8 @@ export async function createPairSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = createPair.extractEvent(receipt.logs)
   return {
     ...args,
@@ -1567,6 +1573,8 @@ export async function placeFlipSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = placeFlip.extractEvent(receipt.logs)
   return {
     ...args,
@@ -1637,6 +1645,8 @@ export async function placeSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = place.extractEvent(receipt.logs)
   return {
     ...args,

package/tempo/actions/earn/deployment.ts

@@ -184,7 +184,7 @@ export namespace createErc4626Engine {
   export type Parameters<
     chain extends Chain | undefined = Chain | undefined,
     account extends Account | undefined = Account | undefined,
-  > = WriteParameters<chain, account> &
+  > = Omit<WriteParameters<chain, account>, 'owner'> &
     Omit<Args, 'owner'> & {
       /** Final engine owner. @default `account.address` */
       owner?: Account | Address | undefined
@@ -366,6 +366,8 @@ export async function createErc4626EngineSync<
     ...parameters,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = createErc4626Engine.extractEvent(receipt.logs, { factory })
   return { ...args, receipt }
 }
@@ -449,7 +451,7 @@ export namespace createStack {
   export type Parameters<
     chain extends Chain | undefined = Chain | undefined,
     account extends Account | undefined = Account | undefined,
-  > = WriteParameters<chain, account> &
+  > = Omit<WriteParameters<chain, account>, 'owner'> &
     Omit<Args, 'owner'> & {
       /** Final stack owner and operator. @default `account.address` */
       owner?: Account | Address | undefined
@@ -632,6 +634,8 @@ export async function createStackSync<
     ...parameters,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = createStack.extractEvent(receipt.logs, { factory })
   return { ...args, receipt }
 }
@@ -832,6 +836,8 @@ export async function bindEngineSync<
     ...parameters,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = bindEngine.extractEvent(receipt.logs, { engine })
   return { engine, vault: args.earnVault, receipt }
 }
@@ -956,6 +962,7 @@ export async function deployErc4626StackSync<
     gas: _,
     keyAuthorization: __,
     nonce: ___,
+    owner: ____,
     ...sharedWriteParameters
   } = pickWriteParameters(parameters as never)
   const writeParameters = {
@@ -1018,6 +1025,8 @@ export async function deployErc4626StackSync<
         } as never,
       )
       receipts.engine = receipt
+      if ((receipt as TransactionReceipt).status === 'pending')
+        return { receipt } as never
       createErc4626Engine.extractEvent(receipt.logs, {
         factory: parameters.factories.erc4626Engine,
       })
@@ -1072,6 +1081,8 @@ export async function deployErc4626StackSync<
         ...stackArgs,
       } as never)
       receipts.stack = receipt
+      if ((receipt as TransactionReceipt).status === 'pending')
+        return { receipt } as never
       const { args } = createStack.extractEvent(receipt.logs, {
         factory: parameters.factories.earn,
       })
@@ -1148,6 +1159,8 @@ export async function deployErc4626StackSync<
         bindingParameters as never,
       )
       receipts.binding = receipt
+      if ((receipt as TransactionReceipt).status === 'pending')
+        return { receipt } as never
       bindEngine.extractEvent(receipt.logs, { engine: predictedEngine })
     } else if (!isAddressEqual(boundVault, vault)) {
       throw new Error(`Engine is already bound to ${boundVault}.`)
@@ -1179,7 +1192,7 @@ export namespace deployErc4626StackSync {
     account extends Account | undefined = Account | undefined,
   > = Omit<
     WriteParameters<chain, account>,
-    'gas' | 'keyAuthorization' | 'nonce' | 'throwOnReceiptRevert'
+    'gas' | 'keyAuthorization' | 'nonce' | 'owner' | 'throwOnReceiptRevert'
   > &
     WriteSyncParameters<chain, account> & {
       /** Account used only for the final owner binding. */

package/tempo/actions/earn.ts

@@ -152,6 +152,8 @@ export async function configureExitSafePolicy<
     chain: client.chain,
     type: 'whitelist',
   } as never)
+  if ((eligibility.receipt as TransactionReceipt).status === 'pending')
+    return { receipt: eligibility.receipt } as never
   const compoundPolicy = await writeContractSync(client, {
     account,
     abi: Abis.tip403Registry,
@@ -161,6 +163,8 @@ export async function configureExitSafePolicy<
     functionName: 'createCompoundPolicy',
     throwOnReceiptRevert: true,
   } as never)
+  if ((compoundPolicy as TransactionReceipt).status === 'pending')
+    return { receipt: compoundPolicy } as never
   const [compoundEvent] = parseEventLogs({
     abi: Abis.tip403Registry,
     eventName: 'CompoundPolicyCreated',
@@ -176,6 +180,8 @@ export async function configureExitSafePolicy<
     policyId: compoundEvent.args.policyId,
     token: parameters.shareToken,
   } as never)
+  if ((tokenPolicy.receipt as TransactionReceipt).status === 'pending')
+    return { receipt: tokenPolicy.receipt } as never
   const policyAdmin = isAddressEqual(
     parameters.accessAdministrator,
     account.address,
@@ -187,6 +193,11 @@ export async function configureExitSafePolicy<
         chain: client.chain,
         policyId: eligibility.policyId,
       } as never)
+  if (
+    policyAdmin &&
+    (policyAdmin.receipt as TransactionReceipt).status === 'pending'
+  )
+    return { receipt: policyAdmin.receipt } as never
 
   return {
     policy: {
@@ -617,6 +628,8 @@ export async function depositSync<
     ...parameters,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = deposit.extractEvent(receipt.logs, { vault })
   return {
     assetAmount: args.assets,
@@ -920,6 +933,8 @@ export async function depositSharesSync<
     ...parameters,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = depositShares.extractEvent(receipt.logs, { vault })
   return {
     caller: args.caller,
@@ -2308,6 +2323,8 @@ export async function redeemSync<
     ...parameters,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = redeem.extractEvent(receipt.logs, { vault })
   return {
     assetAmount: args.assets,
@@ -2972,6 +2989,8 @@ export async function withdrawExactSync<
     ...parameters,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = withdrawExact.extractEvent(receipt.logs, { vault })
   return {
     assetAmount: args.assets,

package/tempo/actions/fee.ts

@@ -383,6 +383,8 @@ export async function setUserTokenSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = setUserToken.extractEvent(receipt.logs)
   return {
     ...args,
@@ -715,6 +717,8 @@ export async function setValidatorTokenSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = setValidatorToken.extractEvent(receipt.logs)
   return {
     ...args,