viem 2.55.18 → 2.56.0

package/tempo/actions/earn/deployment.ts

@@ -38,6 +38,32 @@ import {
 } from '../../internal/utils.js'
 import type { TransactionReceipt } from '../../Transaction.js'
 
+const engineBindingAbi = [
+  {
+    type: 'function',
+    name: 'initializeEarnVault',
+    inputs: [
+      { name: 'earnVault_', type: 'address' },
+      { name: 'finalOwner_', type: 'address' },
+    ],
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
+  {
+    type: 'function',
+    name: 'initializeEarnVault',
+    inputs: [{ name: 'earnVault_', type: 'address' }],
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
+  {
+    type: 'event',
+    name: 'EarnVaultInitialized',
+    inputs: [{ name: 'earnVault', type: 'address', indexed: true }],
+    anonymous: false,
+  },
+] as const
+
 /** @experimental Factory addresses for one reviewed Tempo Earn release. */
 export type EarnFactoryAddresses = {
   /** `ERC4626EngineFactory` address. */
@@ -629,7 +655,7 @@ export namespace createStackSync {
 }
 
 /**
- * Permanently binds an ERC-4626 engine to its EarnVault.
+ * Permanently binds an engine to its EarnVault.
  *
  * @experimental
  *
@@ -645,8 +671,9 @@ export namespace createStackSync {
  *   chain: tempoModerato,
  *   transport: http(),
  * })
- * const hash = await Actions.earn.bindErc4626Engine(client, {
+ * const hash = await Actions.earn.bindEngine(client, {
  *   engine: '0x...',
+ *   finalOwner: '0x...',
  *   vault: '0x...',
  * })
  * ```
@@ -655,20 +682,22 @@ export namespace createStackSync {
  * @param parameters - Parameters.
  * @returns The transaction hash.
  */
-export async function bindErc4626Engine<
+export async function bindEngine<
   chain extends Chain | undefined,
   account extends Account | undefined,
 >(
   client: Client<Transport, chain, account>,
-  parameters: bindErc4626Engine.Parameters<chain, account>,
-): Promise<bindErc4626Engine.ReturnValue> {
-  return bindErc4626Engine.inner(writeContract, client, parameters)
+  parameters: bindEngine.Parameters<chain, account>,
+): Promise<bindEngine.ReturnValue> {
+  return bindEngine.inner(writeContract, client, parameters)
 }
 
-export namespace bindErc4626Engine {
+export namespace bindEngine {
   export type Args = {
-    /** ERC-4626 engine address. */
+    /** Engine address. */
     engine: Address
+    /** Address that will own the initialized engine. Omit to retain the current owner. */
+    finalOwner?: Address | undefined
     /** Factory-created EarnVault address. */
     vault: Address
   }
@@ -690,15 +719,15 @@ export namespace bindErc4626Engine {
     client: Client<Transport, chain, account>,
     parameters: Parameters<chain, account>,
   ): Promise<ReturnType<action>> {
-    const { engine, vault, ...rest } = parameters
+    const { engine, finalOwner, vault, ...rest } = parameters
     return (await action(client, {
       ...rest,
-      ...bindErc4626Engine.call({ engine, vault }),
+      ...bindEngine.call({ engine, finalOwner, vault }),
     } as never)) as never
   }
 
   /**
-   * Defines a call to `ERC4626Engine.initializeEarnVault`.
+   * Defines a call to `initializeEarnVault` on an Earn engine.
    *
    * Can be passed as a parameter to:
    * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
@@ -714,8 +743,9 @@ export namespace bindErc4626Engine {
    * const client = createClient({ chain: tempoModerato, transport: http() })
    *   .extend(walletActions)
    * await client.sendTransaction({
-   *   calls: [Actions.earn.bindErc4626Engine.call({
+   *   calls: [Actions.earn.bindEngine.call({
    *     engine: '0x...',
+   *     finalOwner: '0x...',
    *     vault: '0x...',
    *   })],
    * })
@@ -725,11 +755,19 @@ export namespace bindErc4626Engine {
    * @returns The call.
    */
   export function call(args: Args) {
+    const { engine, finalOwner, vault } = args
+    if (finalOwner)
+      return defineCall({
+        address: engine,
+        abi: engineBindingAbi,
+        functionName: 'initializeEarnVault',
+        args: [vault, finalOwner],
+      })
     return defineCall({
-      address: args.engine,
-      abi: Abis.erc4626Engine,
+      address: engine,
+      abi: engineBindingAbi,
       functionName: 'initializeEarnVault',
-      args: [args.vault],
+      args: [vault],
     })
   }
 
@@ -742,7 +780,7 @@ export namespace bindErc4626Engine {
    */
   export function extractEvent(logs: Log[], parameters: { engine: Address }) {
     const [log] = parseEventLogs({
-      abi: Abis.erc4626Engine,
+      abi: engineBindingAbi,
       eventName: 'EarnVaultInitialized',
       logs: logs.filter((log) =>
         isAddressEqual(log.address, parameters.engine),
@@ -755,7 +793,7 @@ export namespace bindErc4626Engine {
 }
 
 /**
- * Binds an ERC-4626 engine and waits for confirmation.
+ * Binds an engine and waits for confirmation.
  *
  * @experimental
  *
@@ -771,8 +809,9 @@ export namespace bindErc4626Engine {
  *   chain: tempoModerato,
  *   transport: http(),
  * })
- * const result = await Actions.earn.bindErc4626EngineSync(client, {
+ * const result = await Actions.earn.bindEngineSync(client, {
  *   engine: '0x...',
+ *   finalOwner: '0x...',
  *   vault: '0x...',
  * })
  * ```
@@ -781,31 +820,31 @@ export namespace bindErc4626Engine {
  * @param parameters - Parameters.
  * @returns The receipt and bound addresses.
  */
-export async function bindErc4626EngineSync<
+export async function bindEngineSync<
   chain extends Chain | undefined,
   account extends Account | undefined,
 >(
   client: Client<Transport, chain, account>,
-  parameters: bindErc4626EngineSync.Parameters<chain, account>,
-): Promise<bindErc4626EngineSync.ReturnValue> {
+  parameters: bindEngineSync.Parameters<chain, account>,
+): Promise<bindEngineSync.ReturnValue> {
   const { engine, throwOnReceiptRevert = true } = parameters
-  const receipt = await bindErc4626Engine.inner(writeContractSync, client, {
+  const receipt = await bindEngine.inner(writeContractSync, client, {
     ...parameters,
     throwOnReceiptRevert,
   } as never)
-  const { args } = bindErc4626Engine.extractEvent(receipt.logs, { engine })
+  const { args } = bindEngine.extractEvent(receipt.logs, { engine })
   return { engine, vault: args.earnVault, receipt }
 }
 
-export namespace bindErc4626EngineSync {
-  export type Args = bindErc4626Engine.Args
+export namespace bindEngineSync {
+  export type Args = bindEngine.Args
   export type Parameters<
     chain extends Chain | undefined = Chain | undefined,
     account extends Account | undefined = Account | undefined,
-  > = bindErc4626Engine.Parameters<chain, account> &
+  > = bindEngine.Parameters<chain, account> &
     WriteSyncParameters<chain, account>
   export type ReturnValue = {
-    /** ERC-4626 engine address. */
+    /** Engine address. */
     engine: Address
     /** Transaction receipt. */
     receipt: TransactionReceipt
@@ -1091,20 +1130,25 @@ export async function deployErc4626StackSync<
         ...writeParameters,
         account: bindingAccount,
         engine: predictedEngine,
+        finalOwner: owner,
         vault,
       }
       await simulateContract(client, {
         ...sharedWriteParameters,
         account: bindingAccount,
-        ...bindErc4626Engine.call({ engine: predictedEngine, vault }),
+        ...bindEngine.call({
+          engine: predictedEngine,
+          finalOwner: owner,
+          vault,
+        }),
       } as never)
-      const receipt = await bindErc4626Engine.inner(
+      const receipt = await bindEngine.inner(
         writeContractSync,
         client,
         bindingParameters as never,
       )
       receipts.binding = receipt
-      bindErc4626Engine.extractEvent(receipt.logs, { engine: predictedEngine })
+      bindEngine.extractEvent(receipt.logs, { engine: predictedEngine })
     } else if (!isAddressEqual(boundVault, vault)) {
       throw new Error(`Engine is already bound to ${boundVault}.`)
     }

package/tempo/actions/earn.ts

@@ -62,7 +62,6 @@ import {
   resolveTokenWithDecimals,
 } from '../internal/utils.js'
 import type { TransactionReceipt } from '../Transaction.js'
-import { getPortalAddress } from '../zones/zone.js'
 import * as policyActions from './policy.js'
 import * as tokenActions from './token.js'
 import * as zoneActions from './zone.js'
@@ -1029,7 +1028,7 @@ export namespace privateDeposit {
       withdrawalMemo,
       zoneId,
     } = parameters
-    const portalAddress = portalAddress_ ?? getPortalAddress(chainId, zoneId)
+    const portalAddress = portalAddress_ ?? Addresses.zonePortal(zoneId)
     const readParameters = pickReadParameters(parameters)
     const [fromBlock, config] = await Promise.all([
       getBlockNumber(client, { cacheTime: 0 }),
@@ -2411,7 +2410,7 @@ export namespace privateRedeem {
       withdrawalMemo,
       zoneId,
     } = parameters
-    const portalAddress = portalAddress_ ?? getPortalAddress(chainId, zoneId)
+    const portalAddress = portalAddress_ ?? Addresses.zonePortal(zoneId)
     const readParameters = pickReadParameters(parameters)
     const [fromBlock, config] = await Promise.all([
       getBlockNumber(client, { cacheTime: 0 }),

package/tempo/actions/index.ts

@@ -6,6 +6,7 @@ export * as dex from './dex.js'
 export * as earn from './earn.js'
 export * as faucet from './faucet.js'
 export * as fee from './fee.js'
+export * as multisig from './multisig.js'
 export * as nonce from './nonce.js'
 export * as policy from './policy.js'
 export * as receivePolicy from './receivePolicy.js'

package/tempo/actions/multisig.ts

@@ -0,0 +1,356 @@
+import type { Address } from 'abitype'
+import { MultisigConfig } from 'ox/tempo'
+import type { Account } from '../../accounts/types.js'
+import type { ReadContractReturnType } from '../../actions/public/readContract.js'
+import { readContract } from '../../actions/public/readContract.js'
+import type { WriteContractReturnType } from '../../actions/wallet/writeContract.js'
+import { writeContract } from '../../actions/wallet/writeContract.js'
+import { writeContractSync } from '../../actions/wallet/writeContractSync.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { BaseErrorType } from '../../errors/base.js'
+import type { Chain } from '../../types/chain.js'
+import type { GetEventArgs } from '../../types/contract.js'
+import type { Log } from '../../types/log.js'
+import type { Compute } from '../../types/utils.js'
+import { parseEventLogs } from '../../utils/abi/parseEventLogs.js'
+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 } from '../Transaction.js'
+
+/**
+ * Checks whether an address is an initialized native multisig account.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   chain: tempo,
+ *   transport: http(),
+ * })
+ *
+ * const initialized = await Actions.multisig.isInitialized(client, {
+ *   account: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns Whether the account is an initialized native multisig account.
+ */
+export async function isInitialized<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: isInitialized.Parameters,
+): Promise<isInitialized.ReturnValue> {
+  const { account, ...rest } = parameters
+  return readContract(client, {
+    ...rest,
+    ...isInitialized.call({ account }),
+  })
+}
+
+export namespace isInitialized {
+  export type Parameters = ReadParameters & Args
+
+  export type Args = {
+    /** Account address. */
+    account: Address
+  }
+
+  export type ReturnValue = ReadContractReturnType<
+    typeof Abis.nativeMultisig,
+    'isMultisigAccount',
+    never
+  >
+
+  /**
+   * Defines a call to the precompile's `isMultisigAccount` function.
+   *
+   * Can be passed to [`multicall`](https://viem.sh/docs/contract/multicall).
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    return defineCall({
+      address: Addresses.nativeMultisig,
+      abi: Abis.nativeMultisig,
+      args: [args.account],
+      functionName: 'isMultisigAccount',
+    })
+  }
+}
+
+/**
+ * Gets the current configuration for an initialized native multisig account.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   chain: tempo,
+ *   transport: http(),
+ * })
+ *
+ * const config = await Actions.multisig.getConfig(client, {
+ *   account: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The current version, threshold, and owners.
+ */
+export async function getConfig<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: getConfig.Parameters,
+): Promise<getConfig.ReturnValue> {
+  const { account, ...rest } = parameters
+  return readContract(client, {
+    ...rest,
+    ...getConfig.call({ account }),
+  })
+}
+
+export namespace getConfig {
+  export type Parameters = ReadParameters & Args
+
+  export type Args = {
+    /** Initialized multisig account address. */
+    account: Address
+  }
+
+  export type ReturnValue = ReadContractReturnType<
+    typeof Abis.nativeMultisig,
+    'getConfig',
+    never
+  >
+
+  /**
+   * Defines a call to the `getConfig` function.
+   *
+   * Can be passed to [`multicall`](https://viem.sh/docs/contract/multicall).
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    return defineCall({
+      address: Addresses.nativeMultisig,
+      abi: Abis.nativeMultisig,
+      args: [args.account],
+      functionName: 'getConfig',
+    })
+  }
+}
+
+/**
+ * Replaces the current configuration for a native multisig account.
+ *
+ * The transaction must be authorized directly by the account's current owner
+ * quorum. Local owner-signing flows can include {@link updateConfig.call} in a
+ * prepared transaction before collecting approvals.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { sendTransactionSync } from 'viem/actions'
+ * import { tempoLocalnet } from 'viem/chains'
+ * import { Account, Actions } from 'viem/tempo'
+ *
+ * const owner = Account.fromSecp256k1(
+ *   '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+ * )
+ * const account = Account.fromMultisig({ owners: [owner] })
+ * const client = createClient({
+ *   chain: tempoLocalnet,
+ *   transport: http(),
+ * })
+ *
+ * await sendTransactionSync(client, {
+ *   account,
+ *   to: account.address,
+ * })
+ *
+ * const hash = await Actions.multisig.updateConfig(client, {
+ *   account,
+ *   threshold: 1,
+ *   owners: [{ owner: owner.address, weight: 1 }],
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The transaction hash.
+ */
+export async function updateConfig<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: updateConfig.Parameters<chain, account>,
+): Promise<updateConfig.ReturnValue> {
+  return updateConfig.inner(writeContract, client, parameters)
+}
+
+export namespace updateConfig {
+  export type Parameters<
+    chain extends Chain | undefined = Chain | undefined,
+    account extends Account | undefined = Account | undefined,
+  > = WriteParameters<chain, account> & Args
+
+  export type Args = {
+    /** New multisig owners and their weights. */
+    owners: MultisigConfig.Config['owners']
+    /** New signature weight required to authorize the account. */
+    threshold: MultisigConfig.Config['threshold']
+  }
+
+  export type ReturnValue = WriteContractReturnType
+
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
+
+  /** @internal */
+  export async function inner<
+    action extends typeof writeContract | typeof writeContractSync,
+    chain extends Chain | undefined,
+    account extends Account | undefined,
+  >(
+    action: action,
+    client: Client<Transport, chain, account>,
+    parameters: Parameters<chain, account>,
+  ): Promise<ReturnType<action>> {
+    const { owners, threshold, ...rest } = parameters
+    return (await action(client, {
+      ...rest,
+      ...updateConfig.call({ owners, threshold }),
+    } as never)) as never
+  }
+
+  /**
+   * Defines a call to the `updateConfig` function.
+   *
+   * Can be passed as a parameter to:
+   * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate gas
+   * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the update
+   * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): include the update in a call batch
+   *
+   * @example
+   * ```ts
+   * import { Actions } from 'viem/tempo'
+   *
+   * const call = Actions.multisig.updateConfig.call({
+   *   threshold: 1,
+   *   owners: [{ owner: '0x...', weight: 1 }],
+   * })
+   * ```
+   *
+   * @param args - New multisig configuration.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const config = MultisigConfig.from(args)
+    return defineCall({
+      address: Addresses.nativeMultisig,
+      abi: Abis.nativeMultisig,
+      args: [config.threshold, config.owners],
+      functionName: 'updateConfig',
+    })
+  }
+
+  /**
+   * Extracts the `MultisigConfigUpdated` event from logs.
+   *
+   * @param logs - Transaction logs.
+   * @returns The configuration update event.
+   */
+  export function extractEvent(logs: Log[]) {
+    const [log] = parseEventLogs({
+      abi: Abis.nativeMultisig,
+      logs,
+      eventName: 'MultisigConfigUpdated',
+      strict: true,
+    })
+    if (!log) throw new Error('`MultisigConfigUpdated` event not found.')
+    return log
+  }
+}
+
+/**
+ * Replaces a native multisig configuration and waits for confirmation.
+ *
+ * @example
+ * ```ts
+ * import { createWalletClient, custom, type EIP1193Provider } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * declare const provider: EIP1193Provider
+ *
+ * const client = createWalletClient({
+ *   account: '0x...',
+ *   chain: tempo,
+ *   transport: custom(provider),
+ * })
+ *
+ * const { receipt } = await Actions.multisig.updateConfigSync(client, {
+ *   threshold: 1,
+ *   owners: [{ owner: '0x...', weight: 1 }],
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The updated configuration event and transaction receipt.
+ */
+export async function updateConfigSync<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: updateConfigSync.Parameters<chain, account>,
+): Promise<updateConfigSync.ReturnValue> {
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await updateConfig.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
+  const { args } = updateConfig.extractEvent(receipt.logs)
+  return { ...args, receipt } as never
+}
+
+export namespace updateConfigSync {
+  export type Parameters<
+    chain extends Chain | undefined = Chain | undefined,
+    account extends Account | undefined = Account | undefined,
+  > = updateConfig.Parameters<chain, account>
+
+  export type Args = updateConfig.Args
+
+  export type ReturnValue = Compute<
+    GetEventArgs<
+      typeof Abis.nativeMultisig,
+      'MultisigConfigUpdated',
+      { IndexedOnly: false; Required: true }
+    > & {
+      receipt: TransactionReceipt
+    }
+  >
+
+  export type ErrorType = updateConfig.ErrorType
+}