viem 3.0.0-next.10 → 3.0.0-next.13

package/src/tempo/actions/earn/deployment.ts

@@ -1,8 +1,9 @@
-import { AbiEvent, Address, Hex } from 'ox'
 import type { Errors } from 'ox'
+import { AbiEvent, Address, Hex } from 'ox'
+import type { TransactionReceipt } from '../../chainConfig.js'
 
 import * as Account from '../../../core/Account.js'
-import type * as Chain from '../../../core/Chain.js'
+import * as Chain from '../../../core/Chain.js'
 import type * as Client from '../../../core/Client.js'
 import { BaseError } from '../../../core/Errors.js'
 import { getCode } from '../../../core/actions/address/getCode.js'
@@ -24,13 +25,38 @@ import {
   pickWriteParameters,
   pickWriteSyncParameters,
 } from '../../internal/utils.js'
-import type { TransactionReceipt } from '../../chainConfig.js'
 
 const maxUint64 = 2n ** 64n - 1n
 const maxUint256 = 2n ** 256n - 1n
 const zeroAddress =
   '0x0000000000000000000000000000000000000000' as const satisfies Address.Address
 
+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. */
@@ -147,7 +173,7 @@ export namespace createErc4626Engine {
     venue: Address.Address
   }
 
-  export type Parameters = WriteParameters &
+  export type Parameters = Omit<WriteParameters, 'owner'> &
     Omit<Args, 'owner'> & {
       /** Final engine owner. @default `account.address` */
       owner?: Account.Account | Address.Address | undefined
@@ -333,6 +359,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 }
 }
@@ -406,7 +434,7 @@ export namespace createStack {
     transferPolicyId?: bigint | undefined
   }
 
-  export type Parameters = WriteParameters &
+  export type Parameters = Omit<WriteParameters, 'owner'> &
     Omit<Args, 'owner'> & {
       /** Final stack owner and operator. @default `account.address` */
       owner?: Account.Account | Address.Address | undefined
@@ -593,6 +621,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 }
 }
@@ -610,7 +640,7 @@ export namespace createStackSync {
 }
 
 /**
- * Permanently binds an ERC-4626 engine to its EarnVault.
+ * Permanently binds an engine to its EarnVault.
  *
  * @experimental
  *
@@ -625,8 +655,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...',
  * })
  * ```
@@ -635,20 +666,22 @@ export namespace createStackSync {
  * @param parameters - Parameters.
  * @returns The transaction hash.
  */
-export async function bindErc4626Engine<
+export async function bindEngine<
   chain extends Chain.Chain | undefined,
   account extends Account.Account | undefined,
 >(
   client: Client.Client<chain, account>,
-  parameters: bindErc4626Engine.Parameters,
-): Promise<bindErc4626Engine.ReturnValue> {
-  return bindErc4626Engine.inner(write, client, parameters)
+  parameters: bindEngine.Parameters,
+): Promise<bindEngine.ReturnValue> {
+  return bindEngine.inner(write, client, parameters)
 }
 
-export namespace bindErc4626Engine {
+export namespace bindEngine {
   export type Args = {
     /** ERC-4626 engine address. */
     engine: Address.Address
+    /** Address that will own the initialized engine. Omit to retain its current owner. */
+    finalOwner?: Address.Address | undefined
     /** Factory-created EarnVault address. */
     vault: Address.Address
   }
@@ -667,10 +700,10 @@ export namespace bindErc4626Engine {
     client: Client.Client<chain, account>,
     parameters: Parameters,
   ): 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
   }
 
@@ -690,7 +723,7 @@ export namespace bindErc4626Engine {
    *
    * const client = Client.create({ chain: tempoModerato, transport: http() })
    * await client.transaction.send({
-   *   calls: [Actions.earn.bindErc4626Engine.call({
+   *   calls: [Actions.earn.bindEngine.call({
    *     engine: '0x...',
    *     vault: '0x...',
    *   })],
@@ -701,11 +734,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],
     })
   }
 
@@ -722,7 +763,7 @@ export namespace bindErc4626Engine {
     })[],
   >(logs: logs, parameters: { engine: Address.Address }) {
     const [log] = AbiEvent.extractLogs(
-      Abis.erc4626Engine,
+      engineBindingAbi,
       logs.filter((log): log is logs[number] =>
         Address.isEqual(log.address, parameters.engine),
       ),
@@ -737,7 +778,7 @@ export namespace bindErc4626Engine {
 }
 
 /**
- * Binds an ERC-4626 engine and waits for confirmation.
+ * Binds an engine and waits for confirmation.
  *
  * @experimental
  *
@@ -752,8 +793,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...',
  * })
  * ```
@@ -762,25 +804,28 @@ export namespace bindErc4626Engine {
  * @param parameters - Parameters.
  * @returns The receipt and bound addresses.
  */
-export async function bindErc4626EngineSync<
+export async function bindEngineSync<
   chain extends Chain.Chain | undefined,
   account extends Account.Account | undefined,
 >(
   client: Client.Client<chain, account>,
-  parameters: bindErc4626EngineSync.Parameters,
-): Promise<bindErc4626EngineSync.ReturnValue> {
+  parameters: bindEngineSync.Parameters,
+): Promise<bindEngineSync.ReturnValue> {
   const { engine, throwOnReceiptRevert = true } = parameters
-  const receipt = await bindErc4626Engine.inner(writeSync, client, {
+  const receipt = await bindEngine.inner(writeSync, client, {
     ...parameters,
     throwOnReceiptRevert,
   } as never)
-  const { args } = bindErc4626Engine.extractEvent(receipt.logs, { engine })
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as bindEngineSync.ReturnValue
+
+  const { args } = bindEngine.extractEvent(receipt.logs, { engine })
   return { engine, vault: args.earnVault, receipt }
 }
 
-export namespace bindErc4626EngineSync {
-  export type Args = bindErc4626Engine.Args
-  export type Parameters = bindErc4626Engine.Parameters & WriteSyncParameters
+export namespace bindEngineSync {
+  export type Args = bindEngine.Args
+  export type Parameters = bindEngine.Parameters & WriteSyncParameters
   export type ReturnValue = {
     /** ERC-4626 engine address. */
     engine: Address.Address
@@ -844,7 +889,6 @@ export class DeployErc4626StackError extends BaseError<Error> {
  * })
  * const result = await Actions.earn.deployErc4626StackSync(client, {
  *   deploymentId: '0x...',
- *   factories: { earn: '0x...', erc4626Engine: '0x...' },
  *   venue: '0x...',
  * })
  * ```
@@ -877,6 +921,20 @@ export async function deployErc4626StackSync<
   )
     throw new Error('`bindingAccount` must match `owner`.')
 
+  const factories = (() => {
+    if (parameters.factories) return parameters.factories
+    if (!client.chain) throw new Chain.NotFoundError()
+    return {
+      earn: Chain.getContractAddress({
+        chain: client.chain,
+        contract: 'earnFactory',
+      }),
+      erc4626Engine: Chain.getContractAddress({
+        chain: client.chain,
+        contract: 'erc4626EngineFactory',
+      }),
+    }
+  })()
   validateDeploymentId(parameters.deploymentId)
   if (
     parameters.resume &&
@@ -885,7 +943,7 @@ export async function deployErc4626StackSync<
   )
     throw new Error('The resumed deployment ID does not match `deploymentId`.')
   await validateContracts(client, {
-    factories: parameters.factories,
+    factories,
     venue: parameters.venue,
   })
 
@@ -893,6 +951,7 @@ export async function deployErc4626StackSync<
     gas: _,
     keyAuthorization: __,
     nonce: ___,
+    owner: ____,
     ...sharedWriteParameters
   } = pickWriteParameters(parameters as never)
   const writeParameters = {
@@ -903,7 +962,7 @@ export async function deployErc4626StackSync<
   }
   const engineArgs = {
     deploymentId: parameters.deploymentId,
-    factory: parameters.factories.erc4626Engine,
+    factory: factories.erc4626Engine,
     name: parameters.name,
     owner,
     symbol: parameters.symbol,
@@ -952,7 +1011,7 @@ export async function deployErc4626StackSync<
       } as never)
       receipts.engine = receipt
       createErc4626Engine.extractEvent(receipt.logs, {
-        factory: parameters.factories.erc4626Engine,
+        factory: factories.erc4626Engine,
       })
     }
     await verifyEngine(client, engineArgs, predictedEngine)
@@ -965,7 +1024,7 @@ export async function deployErc4626StackSync<
     deploymentId: parameters.deploymentId,
     distributor: parameters.distributor,
     engine: predictedEngine,
-    factory: parameters.factories.earn,
+    factory: factories.earn,
     fees: parameters.fees,
     owner,
     transferPolicyId: parameters.transferPolicyId,
@@ -1005,8 +1064,10 @@ 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,
+        factory: factories.earn,
       })
       state.vault = args.earnVault
       if (
@@ -1025,7 +1086,7 @@ export async function deployErc4626StackSync<
       if (!state.vault) {
         const event = await findStackDeployment(client, {
           earnShare: predicted.earnShare,
-          factory: parameters.factories.earn,
+          factory: factories.earn,
           fromBlock: parameters.fromBlock,
         })
         state.vault = event.args.earnVault
@@ -1063,20 +1124,25 @@ export async function deployErc4626StackSync<
         ...writeParameters,
         account: bindingAccount,
         engine: predictedEngine,
+        finalOwner: owner,
         vault,
       }
       await simulate(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(
         writeSync,
         client,
         bindingParameters as never,
       )
       receipts.binding = receipt
-      bindErc4626Engine.extractEvent(receipt.logs, { engine: predictedEngine })
+      bindEngine.extractEvent(receipt.logs, { engine: predictedEngine })
     } else if (!Address.isEqual(boundVault, vault)) {
       throw new Error(`Engine is already bound to ${boundVault}.`)
     }
@@ -1104,7 +1170,7 @@ export async function deployErc4626StackSync<
 export namespace deployErc4626StackSync {
   export type Parameters = Omit<
     WriteParameters,
-    'gas' | 'keyAuthorization' | 'nonce' | 'throwOnReceiptRevert'
+    'gas' | 'keyAuthorization' | 'nonce' | 'owner' | 'throwOnReceiptRevert'
   > &
     WriteSyncParameters & {
       /** Account used only for the final owner binding. */
@@ -1115,8 +1181,8 @@ export namespace deployErc4626StackSync {
       deploymentId: Hex.Hex
       /** Optional protected fee distributor. */
       distributor?: EarnDistributorConfiguration | undefined
-      /** Reviewed factory pair from one Earn release. */
-      factories: EarnFactoryAddresses
+      /** Reviewed factory pair from one Earn release. @default `client.chain.contracts` */
+      factories?: EarnFactoryAddresses | undefined
       /** Initial fee configuration. Omit for fee-free deployment. */
       fees?: EarnFeeConfiguration | undefined
       /** First block to search for a prior factory deployment event. */

package/src/tempo/actions/earn.ts

@@ -1,6 +1,7 @@
-import { AbiEvent, AbiParameters, Address, Hex } from 'ox'
 import type { Errors } from 'ox'
+import { AbiEvent, AbiParameters, Address, Hex } from 'ox'
 import { EarnShares } from 'ox/tempo'
+import type { TransactionReceipt } from '../chainConfig.js'
 
 import * as Account from '../../core/Account.js'
 import type * as Chain from '../../core/Chain.js'
@@ -17,8 +18,8 @@ import { sendSync } from '../../core/actions/transaction/sendSync.js'
 import { type ObserveErrorType, observe } from '../../core/internal/observe.js'
 import { type PollErrorType, poll } from '../../core/internal/poll.js'
 import { withResolvers } from '../../core/internal/promise.js'
-import type { Compute, OneOf } from '../../core/internal/types.js'
 import { stringify } from '../../core/internal/stringify.js'
+import type { Compute, OneOf } from '../../core/internal/types.js'
 import * as Abis from '../Abis.js'
 import * as Addresses from '../Addresses.js'
 import {
@@ -43,7 +44,6 @@ import {
   resolveTokenWithDecimals,
   simulateWrite,
 } from '../internal/utils.js'
-import { getPortalAddress } from '../zones/zone.js'
 import * as policyActions from './policy/index.js'
 import * as tokenActions from './token/index.js'
 import * as zoneActions from './zone/index.js'
@@ -595,6 +595,9 @@ export async function depositSync<
     ...options,
     throwOnReceiptRevert,
   })
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as depositSync.ReturnType
+
   const { args } = deposit.extractEvent(receipt.logs, { vault })
   return {
     assetAmount: args.assets,
@@ -891,6 +894,9 @@ export async function depositSharesSync<
     ...options,
     throwOnReceiptRevert,
   })
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as depositSharesSync.ReturnType
+
   const { args } = depositShares.extractEvent(receipt.logs, { vault })
   return {
     caller: args.caller,
@@ -934,7 +940,7 @@ export namespace depositSharesSync {
  *   assetToken: '0x…',
  *   gateway: '0x…',
  *   recipient: '0x…',
- *   recoveryRecipient: '0x…',
+ *   tempoRefundRecipient: '0x…',
  *   shareAmountMin: 99_500_000n,
  *   vault: '0x...',
  *   vaultAssetAmountMin: 99_000_000n,
@@ -984,17 +990,17 @@ export namespace privateDeposit {
       actionId = Hex.random(32),
       assetAmount,
       callbackGas = zoneGatewayCallbackGas,
-      fallbackRecipient = options.recoveryRecipient,
+      fallbackRecipient = options.tempoRefundRecipient,
       gateway,
       portalAddress: portalAddress_,
       recipient,
-      recoveryRecipient,
+      tempoRefundRecipient,
       returnMemo,
       vault,
       withdrawalMemo,
       zoneId,
     } = options
-    const portalAddress = portalAddress_ ?? getPortalAddress(chainId, zoneId)
+    const portalAddress = portalAddress_ ?? Addresses.zonePortal(zoneId)
     const readParameters = pickReadParameters(options)
     const [fromBlock, config] = await Promise.all([
       getNumber(client, { cacheTime: 0 }),
@@ -1027,7 +1033,11 @@ export namespace privateDeposit {
         minEarnShares: shareAmountMin,
         minOutputAmount: 0n,
         minVaultAssets: options.vaultAssetAmountMin ?? assetAmount,
-        zoneReturn: { encrypted, keyIndex, refundRecipient: recoveryRecipient },
+        zoneReturn: {
+          encrypted,
+          keyIndex,
+          refundRecipient: tempoRefundRecipient,
+        },
       },
     ])
     return {
@@ -2254,6 +2264,9 @@ export async function redeemSync<
     ...options,
     throwOnReceiptRevert,
   })
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as redeemSync.ReturnType
+
   const { args } = redeem.extractEvent(receipt.logs, { vault })
   return {
     assetAmount: args.assets,
@@ -2292,7 +2305,7 @@ export namespace redeemSync {
  * const prepared = await Actions.earn.privateRedeem.prepare(parentClient, {
  *   gateway: '0x…',
  *   recipient: '0x…',
- *   recoveryRecipient: '0x…',
+ *   tempoRefundRecipient: '0x…',
  *   shareAmount: 100_000_000n,
  *   slippageBps: 50,
  *   vault: '0x...',
@@ -2341,18 +2354,18 @@ export namespace privateRedeem {
     const {
       actionId = Hex.random(32),
       callbackGas = zoneGatewayCallbackGas,
-      fallbackRecipient = options.recoveryRecipient,
+      fallbackRecipient = options.tempoRefundRecipient,
       gateway,
       portalAddress: portalAddress_,
       recipient,
-      recoveryRecipient,
+      tempoRefundRecipient,
       returnMemo,
       shareAmount,
       vault,
       withdrawalMemo,
       zoneId,
     } = options
-    const portalAddress = portalAddress_ ?? getPortalAddress(chainId, zoneId)
+    const portalAddress = portalAddress_ ?? Addresses.zonePortal(zoneId)
     const readParameters = pickReadParameters(options)
     const [fromBlock, config] = await Promise.all([
       getNumber(client, { cacheTime: 0 }),
@@ -2401,7 +2414,11 @@ export namespace privateRedeem {
         minEarnShares: 0n,
         minOutputAmount: assetAmountMin,
         minVaultAssets: assetAmountMin,
-        zoneReturn: { encrypted, keyIndex, refundRecipient: recoveryRecipient },
+        zoneReturn: {
+          encrypted,
+          keyIndex,
+          refundRecipient: tempoRefundRecipient,
+        },
       },
     ])
     return {
@@ -2899,6 +2916,9 @@ export async function withdrawExactSync<
     ...options,
     throwOnReceiptRevert,
   })
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as withdrawExactSync.ReturnType
+
   const { args } = withdrawExact.extractEvent(receipt.logs, { vault })
   return {
     assetAmount: args.assets,
@@ -2946,7 +2966,7 @@ type PrivatePreparationParameters = {
   actionId?: Hex.Hex | undefined
   /** Gas reserved for the parent-chain callback. @default `10_000_000n` */
   callbackGas?: bigint | undefined
-  /** Public recipient if the parent-chain callback fails. @default `recoveryRecipient` */
+  /** Public recipient if the parent-chain callback fails. @default `tempoRefundRecipient` */
   fallbackRecipient?: Address.Address | undefined
   /** Zone gateway address. */
   gateway: Address.Address
@@ -2955,7 +2975,7 @@ type PrivatePreparationParameters = {
   /** Encrypted recipient for the returned tokens. */
   recipient: Address.Address
   /** Public recipient if the encrypted return fails. */
-  recoveryRecipient: Address.Address
+  tempoRefundRecipient: Address.Address
   /** Optional memo encrypted with the returned Zone deposit. */
   returnMemo?: Hex.Hex | undefined
   /** Vault address. */

package/src/tempo/actions/fee/setUserTokenSync.ts

@@ -1,4 +1,5 @@
 import type { Address, Errors } from 'ox'
+import type { TransactionReceipt } from '../../chainConfig.js'
 
 import type * as Account from '../../../core/Account.js'
 import type * as Chain from '../../../core/Chain.js'
@@ -41,6 +42,9 @@ export async function setUserTokenSync<
     ...options,
     throwOnReceiptRevert,
   })
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as setUserTokenSync.ReturnType
+
   const { args } = setUserToken.extractEvent(receipt.logs)
   return {
     ...args,

package/src/tempo/actions/fee/setValidatorTokenSync.ts

@@ -1,4 +1,5 @@
 import type { Address, Errors } from 'ox'
+import type { TransactionReceipt } from '../../chainConfig.js'
 
 import type * as Account from '../../../core/Account.js'
 import type * as Chain from '../../../core/Chain.js'
@@ -42,6 +43,9 @@ export async function setValidatorTokenSync<
     ...options,
     throwOnReceiptRevert,
   })
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as setValidatorTokenSync.ReturnType
+
   const { args } = setValidatorToken.extractEvent(receipt.logs)
   return {
     ...args,

package/src/tempo/actions/index.ts

@@ -8,9 +8,13 @@ export * as faucet from './faucet/index.js'
 export * as fee from './fee/index.js'
 export * as nonce from './nonce/index.js'
 export * as policy from './policy/index.js'
+export * as propAmm from './propAmm.js'
 export * as receivePolicy from './receivePolicy/index.js'
 export * as token from './token/index.js'
 export * as validator from './validator/index.js'
 export * as virtualAddress from './virtualAddress/index.js'
 export * as wallet from './wallet/index.js'
 export * as zone from './zone/index.js'
+
+/** Native multisig configuration and approval actions. */
+export * as multisig from './multisig/index.js'

package/src/tempo/actions/multisig/getConfig.ts

@@ -0,0 +1,46 @@
+import type { Address, Errors } from 'ox'
+import { MultisigConfig } from 'ox/tempo'
+import type * as Client from '../../../core/Client.js'
+
+/**
+ * Gets the current cached config for a multisig account.
+ *
+ * The coordinator reads the account's current onchain commitment and returns
+ * the matching config from its store. It returns `null` when the config is not
+ * cached.
+ *
+ * @example
+ * ```ts
+ * const config = await client.multisig.getConfig({
+ *   address: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The config, or `null` when it is unknown.
+ */
+export async function getConfig(
+  client: Client.Client,
+  parameters: getConfig.Options,
+): Promise<getConfig.ReturnType> {
+  const config = await client.request({
+    method: 'multisig_getConfig',
+    params: [{ address: parameters.address }],
+  })
+  return config ? MultisigConfig.fromRpc(config as MultisigConfig.Rpc) : null
+}
+
+export declare namespace getConfig {
+  /** Parameters for {@link getConfig}. */
+  export type Options = {
+    /** Multisig account address. */
+    address: Address.Address
+  }
+
+  /** Return value for {@link getConfig}. */
+  export type ReturnType = MultisigConfig.Config | null
+
+  /** Error type for {@link getConfig}. */
+  export type ErrorType = Errors.GlobalErrorType
+}