viem 2.56.5 → 2.56.7

package/tempo/Account.ts

@@ -24,7 +24,9 @@ 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 type { KeyAuthorizationManager } from './KeyAuthorizationManager.js'
+import { parseApproval } from './multisig/Signature.js'
 import * as Transaction from './Transaction.js'
 
 export type Account_base<source extends string = string> = RequiredBy<
@@ -284,7 +286,7 @@ export declare namespace fromSecp256k1 {
  *
  * Owners can be accounts or addresses directly, or weighted `{ owner, weight }`
  * entries. Direct owners default to weight `1`, and `threshold` defaults to `1`.
- * Local owner accounts are retained for signing, including nested multisigs.
+ * Local owner accounts are retained for signing, using primitive signatures.
  * Configs containing only owner addresses require external approvals through
  * `signatures`.
  *
@@ -359,11 +361,13 @@ export function fromMultisig(value: fromMultisig.Parameters): MultisigAccount {
     (() => {
       if (typeof value === 'string') return value
       if (value.address === undefined || value.address === 'infer')
-        return MultisigConfig.getAddress(config!)
+        return MultisigConfig.getAddress(config!, {
+          factory: nativeMultisigFactory,
+        })
       return value.address
     })(),
   )
-  const ownerAccounts = (() => {
+  const ownerAccounts: LocalAccount[] = (() => {
     if (!configInput) return []
     return configInput.owners.flatMap((value) => {
       const owner =
@@ -371,6 +375,12 @@ export function fromMultisig(value: fromMultisig.Parameters): MultisigAccount {
       return typeof owner === 'string' ? [] : [parseAccount(owner)]
     })
   })()
+  if (
+    ownerAccounts.some(
+      (owner) => owner.source === 'multisig' || isAccessKeyAccount(owner),
+    )
+  )
+    throw new Error('Multisig owners must use primitive signatures.')
   const owners =
     config?.owners.flatMap(({ owner }) => {
       const account = ownerAccounts.find((account) =>
@@ -403,7 +413,7 @@ export function fromMultisig(value: fromMultisig.Parameters): MultisigAccount {
           throw new Error(
             'A local owner account is required to approve a multisig transaction.',
           )
-        if (owner.source !== 'root' && owner.source !== 'multisig')
+        if (owner.source !== 'root')
           throw new Error(
             'A Tempo owner account is required to approve a multisig transaction.',
           )
@@ -422,29 +432,16 @@ export function fromMultisig(value: fromMultisig.Parameters): MultisigAccount {
       }
       const payload = keccak256(await serializer(presign as never))
       const simulation = request.multisigSimulation
-      const requestAccount = simulation?.account ?? address
-
-      if (!Address.isEqual(requestAccount, address)) {
-        if (!simulation)
-          throw new Error('A multisig config is required for local signing.')
-        const parentConfig = MultisigConfig.from(simulation.config)
-        const parentDigest = MultisigConfig.getSignPayload({
-          account: requestAccount,
-          config: parentConfig,
-          payload,
-        })
-        return SignatureEnvelope.serialize(
-          await signMultisig(account, {
-            payload: parentDigest,
-          }),
+      if (request.from && !Address.isEqual(request.from, address))
+        throw new Error(
+          'Multisig account does not match the transaction sender.',
         )
-      }
 
       const signature = await signMultisig(account, {
         config: simulation?.config,
         payload,
         signatures: request.signatures?.map((signature) =>
-          SignatureEnvelope.from(signature),
+          parseApproval(signature),
         ),
       })
       return (await serializer(
@@ -494,9 +491,11 @@ export declare namespace fromMultisig {
   /** Multisig owner account or address, optionally with an explicit weight. */
   export type Owner =
     | Address.Address
-    | LocalAccount
+    | (LocalAccount & { accessKeyAddress?: never; owners?: never })
     | (Omit<MultisigConfig.Owner, 'owner'> & {
-        owner: Address.Address | LocalAccount
+        owner:
+          | Address.Address
+          | (LocalAccount & { accessKeyAddress?: never; owners?: never })
       })
 
   /** Parameters for {@link fromMultisig}. */
@@ -523,7 +522,7 @@ async function signMultisig(
   parameters: {
     config?: MultisigConfig.Config | undefined
     payload: Hex.Hex
-    signatures?: readonly SignatureEnvelope.SignatureEnvelope[] | undefined
+    signatures?: readonly SignatureEnvelope.Primitive[] | undefined
   },
 ): Promise<SignatureEnvelope.Multisig> {
   const { config, payload, signatures: providedSignatures = [] } = parameters
@@ -558,6 +557,7 @@ async function signMultisig(
       a.owner.toLowerCase().localeCompare(b.owner.toLowerCase()),
   )
   for (const owner of owners) {
+    if (weight >= Number(currentConfig.threshold)) break
     const address = owner.owner.toLowerCase() as Address.Address
     if (signedOwners.has(address)) continue
     const ownerAccount = account.owners.find((account) =>
@@ -565,19 +565,9 @@ async function signMultisig(
     )
     if (!ownerAccount) continue
 
-    if (isMultisigAccount(ownerAccount)) {
-      signatures.push(
-        await signMultisig(ownerAccount, {
-          payload: digest,
-        }),
-      )
-    } else {
-      if (!ownerAccount.sign)
-        throw new Error('Multisig owner account cannot sign.')
-      signatures.push(
-        SignatureEnvelope.from(await ownerAccount.sign({ hash: digest })),
-      )
-    }
+    if (!ownerAccount.sign)
+      throw new Error('Multisig owner account cannot sign.')
+    signatures.push(parseApproval(await ownerAccount.sign({ hash: digest })))
 
     signedOwners.add(address)
     weight += Number(owner.weight)
@@ -856,9 +846,7 @@ export async function signKeyAuthorization(
         await signMultisig(account, {
           config: multisigState.config,
           payload: hash,
-          signatures: signatures?.map((signature) =>
-            SignatureEnvelope.from(signature),
-          ),
+          signatures: signatures?.map((signature) => parseApproval(signature)),
         }),
       )
     }
@@ -982,16 +970,17 @@ function fromBase(parameters: fromBase.Parameters): Account_base {
       // primitive signature over the multisig owner approval digest, instead of
       // a full serialized transaction. Approvals are combined later in
       // `sendTransaction({ signatures })`.
-      const { multisigSimulation } = transaction as {
+      const { multisigSimulation, from } = transaction as {
+        from?: Address.Address
         multisigSimulation?: {
-          account: Address.Address
           config: MultisigConfig.Config
         }
       }
       if (multisigSimulation) {
+        if (!from) throw new Error('A multisig sender is required for signing.')
         const config = MultisigConfig.from(multisigSimulation.config)
         const digest = MultisigConfig.getSignPayload({
-          account: multisigSimulation.account,
+          account: from,
           config,
           payload,
         })

package/tempo/Addresses.ts

@@ -14,6 +14,9 @@ export const accountRegistrar = '0x7702ac0000000000000000000000000000000000'
 export const addressRegistry = '0xfdc0000000000000000000000000000000000000'
 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 pathUsd = '0x20c0000000000000000000000000000000000000'
 export const receivePolicyGuard = '0xB10C000000000000000000000000000000000000'

package/tempo/Multisig.ts

@@ -140,13 +140,12 @@ export function handleRequest(
         }
       }
       if (operation.status === 'pending')
-        return await toTransaction(client, operation, parameters.store)
+        return await toTransaction(client, operation)
       const transactionHash = await getSubmittedTransactionHash(
         parameters.store,
         operation,
       )
-      if (!transactionHash)
-        return await toTransaction(client, operation, parameters.store)
+      if (!transactionHash) return await toTransaction(client, operation)
       const transaction = await next(
         {
           ...request,
@@ -155,7 +154,7 @@ export function handleRequest(
         requestOptions,
       )
       if (!transaction || typeof transaction !== 'object')
-        return await toTransaction(client, operation, parameters.store)
+        return await toTransaction(client, operation)
       const success =
         operation.status === 'submitting'
           ? await completeSubmission(
@@ -306,23 +305,16 @@ async function submit(options: submit.Options) {
       const existingApprovals = existing
         ? await selectApprovals({
             account: signature.account,
-            client: options.client,
             config,
-            discardInvalidNested: true,
             hash: operationHash,
             approvals: existing.approvals,
-            blockNumber,
-            store: options.store,
           })
         : undefined
       const approvals = await selectApprovals({
         account: signature.account,
-        client: options.client,
         config,
         hash: operationHash,
         approvals: [...(existingApprovals?.approvals ?? []), ...incoming],
-        blockNumber,
-        store: options.store,
       })
       return MultisigOperation.from({
         account: signature.account,
@@ -427,12 +419,9 @@ async function submit(options: submit.Options) {
         })
         const finalApprovals = await selectApprovals({
           account: claim.account,
-          blockNumber,
-          client: options.client,
           config: claim.config,
           hash: claim.hash,
           approvals: claim.approvals,
-          store: options.store,
         })
         const final = MultisigOperation.serializeTransaction(claim, {
           approvals: finalApprovals.selectedApprovals,
@@ -703,12 +692,8 @@ async function approveKeyAuthorization(
         ? await selectApprovals({
             account: approval.account,
             approvals: existing.approvals,
-            blockNumber,
-            client: options.client,
             config: approval.config,
-            discardInvalidNested: true,
             hash: approval.hash,
-            store: options.store,
           })
         : undefined
       const approvals = await selectApprovals({
@@ -717,11 +702,8 @@ async function approveKeyAuthorization(
           ...(existingApprovals?.approvals ?? []),
           ...approval.approvals,
         ],
-        blockNumber,
-        client: options.client,
         config: approval.config,
         hash: approval.hash,
-        store: options.store,
       })
       if (
         existing &&
@@ -804,16 +786,18 @@ function assertConfig(options: {
   const { account, commitment, config } = options
   if (
     config.version === 0n &&
-    MultisigConfig.getAddress(config).toLowerCase() !== account.toLowerCase()
+    MultisigConfig.getAddress(config, {
+      factory: Addresses.nativeMultisigFactory,
+    }).toLowerCase() !== account.toLowerCase()
   )
     throw new RpcResponse.InvalidParamsError({
       message: 'Initial multisig config does not match the multisig account.',
     })
-  const expected = (() => {
-    if (config.version === 0n) return Hex.fromNumber(0, { size: 32 })
-    return MultisigConfig.getCommitment(config)
-  })()
-  if (commitment.toLowerCase() !== expected.toLowerCase())
+  if (config.version === 0n && Hex.toBigInt(commitment) === 0n) return
+  if (
+    commitment.toLowerCase() !==
+    MultisigConfig.getCommitment(config).toLowerCase()
+  )
     throw new RpcResponse.InvalidParamsError({
       message: `Multisig config does not match account ${account}.`,
     })
@@ -904,82 +888,12 @@ declare namespace cacheNextConfigs {
   }
 }
 
-/** Selects approvals after validating every nested config. */
-// biome-ignore lint/correctness/noUnusedVariables: _
-async function selectApprovals(options: selectApprovals.Options) {
-  const validation = new Map<string, Promise<Hex.Hex>>()
-  let validationCount = 0
-  const select = async (approvals: readonly SignatureEnvelope.Serialized[]) => {
-    const result = await MultisigOperation.selectApprovals({
-      account: options.account,
-      approvals,
-      config: options.config,
-      hash: options.hash,
-    })
-    const configs = new Map<
-      string,
-      { account: Address; config: MultisigConfig.Config }
-    >()
-    const visit = (signature: SignatureEnvelope.SignatureEnvelope) => {
-      if (signature.type !== 'multisig') return
-      const config = MultisigConfig.from(signature.config)
-      const key = signature.account.toLowerCase()
-      configs.set(key, { account: signature.account, config })
-      for (const approval of signature.signatures) visit(approval)
-    }
-    for (const approval of result.approvals)
-      visit(SignatureEnvelope.from(approval))
-
-    for (const { account, config } of configs.values()) {
-      const key = `${account.toLowerCase()}:${MultisigConfig.getCommitment(config)}`
-      const pending = (() => {
-        const existing = validation.get(key)
-        if (existing) return existing
-        validationCount++
-        if (validationCount > MultisigConfig.maxOwners)
-          throw new RpcResponse.InvalidParamsError({
-            message: 'Multisig approval validation exceeds the owner limit.',
-          })
-        const pending = validateConfig({
-          account,
-          blockNumber: options.blockNumber,
-          client: options.client,
-          config,
-        })
-        validation.set(key, pending)
-        return pending
-      })()
-      const commitment = await pending
-      await ConfigStore.write(options.store, {
-        address: account,
-        commitment,
-        config,
-      })
-    }
-    return result
-  }
+/** Validates primitive approvals and translates invalid input into an RPC error. */
+async function selectApprovals(
+  options: MultisigOperation.selectApprovals.Options,
+) {
   try {
-    if (!options.discardInvalidNested) return await select(options.approvals)
-
-    const approvals: SignatureEnvelope.Serialized[] = []
-    for (const approval of options.approvals) {
-      if (SignatureEnvelope.from(approval).type !== 'multisig') {
-        approvals.push(approval)
-        continue
-      }
-      try {
-        const retained = (await select([approval])).approvals[0]
-        if (retained) approvals.push(retained)
-      } catch (error) {
-        if (
-          error instanceof MultisigOperation.InvalidApprovalError ||
-          error instanceof RpcResponse.InvalidParamsError
-        )
-          continue
-        throw error
-      }
-    }
-    return await select(approvals)
+    return await MultisigOperation.selectApprovals(options)
   } catch (error) {
     if (error instanceof MultisigOperation.InvalidApprovalError)
       throw new RpcResponse.InvalidParamsError({ message: error.shortMessage })
@@ -987,20 +901,6 @@ async function selectApprovals(options: selectApprovals.Options) {
   }
 }
 
-declare namespace selectApprovals {
-  /** Options for {@link selectApprovals}. */
-  export type Options = MultisigOperation.selectApprovals.Options & {
-    /** Block used to validate every config. */
-    blockNumber: bigint
-    /** Client used to validate nested multisig configurations. */
-    client: ReturnType<typeof createClient>
-    /** Discards stored nested approvals invalidated by a child configuration change. */
-    discardInvalidNested?: boolean | undefined
-    /** Shared multisig store. */
-    store: Store.Store
-  }
-}
-
 /** Returns an existing successful operation through the requested send method. */
 async function submittedResult(
   options: submit.Options,
@@ -1186,7 +1086,6 @@ function mergeTransaction(existing: Hex.Hex | undefined, incoming: Hex.Hex) {
 async function toTransaction(
   client: ReturnType<typeof createClient>,
   operation: MultisigOperation.TransactionOperation,
-  store: Store.Store,
 ) {
   const approvals = await (async () => {
     if (operation.status !== 'pending')
@@ -1206,12 +1105,8 @@ async function toTransaction(
     return await selectApprovals({
       account: operation.account,
       approvals: operation.approvals,
-      blockNumber,
-      client,
       config: operation.config,
-      discardInvalidNested: true,
       hash: operation.hash,
-      store,
     })
   })()
   const current =
@@ -1224,17 +1119,9 @@ async function toTransaction(
           weight: approvals.weight,
         })
       : operation
-  const serialized = MultisigOperation.serializeTransaction(
-    approvals.approvals.length > 0 ? current : operation,
-    {
-      // Keep one stored approval in the synthetic envelope when every nested
-      // approval became stale. The next submission replaces it before broadcast.
-      approvals:
-        approvals.selectedApprovals.length > 0
-          ? approvals.selectedApprovals
-          : operation.approvals.slice(0, 1),
-    },
-  )
+  const serialized = MultisigOperation.serializeTransaction(current, {
+    approvals: approvals.selectedApprovals,
+  })
   const transaction = deserialize(serialized)
   return {
     ...ox_Transaction.toRpc(

package/tempo/Transaction.ts

@@ -42,7 +42,8 @@ import {
   parseTransaction as viem_parseTransaction,
 } from '../utils/transaction/parseTransaction.js'
 import { serializeTransaction as viem_serializeTransaction } from '../utils/transaction/serializeTransaction.js'
-import type { MultisigAccount, RootAccount } from './Account.js'
+import type { RootAccount } from './Account.js'
+import { parseApproval } from './multisig/Signature.js'
 
 export type Transaction<
   bigintType = bigint,
@@ -135,7 +136,7 @@ export type TransactionRequestTempo<
     keyAuthorization?: KeyAuthorization.Signed<quantity, index> | undefined
     multisigSimulation?: MultisigSimulation.Spec | undefined
     nonceKey?: 'expiring' | quantity | undefined
-    owner?: MultisigAccount | RootAccount | undefined
+    owner?: RootAccount | undefined
     signatures?: readonly SignatureEnvelope.Serialized[] | undefined
     validBefore?: index | undefined
     validAfter?: index | undefined
@@ -155,17 +156,30 @@ export type TransactionSerializableTempo<
     chainId: number
     feeToken?: Address | bigint | undefined
     feePayerSignature?: viem_Signature | null | undefined
-    from?: Address | undefined
     keyAuthorization?: KeyAuthorization.Signed<quantity, index> | undefined
-    multisigSimulation?: MultisigSimulation.Spec | undefined
     nonceKey?: quantity | undefined
-    owner?: MultisigAccount | RootAccount | undefined
+    owner?: RootAccount | undefined
     signature?: SignatureEnvelope.SignatureEnvelope<quantity, index> | undefined
-    signatures?: readonly SignatureEnvelope.Serialized[] | undefined
     validBefore?: index | undefined
     validAfter?: index | undefined
     type?: 'tempo' | undefined
-  }
+  } & (
+    | {
+        from: Address
+        multisigSimulation?: MultisigSimulation.Spec | undefined
+        signatures?: readonly SignatureEnvelope.Serialized[] | undefined
+      }
+    | {
+        from?: Address | undefined
+        multisigSimulation?: undefined
+        signatures?: readonly SignatureEnvelope.Serialized[] | undefined
+      }
+    | {
+        from?: Address | undefined
+        multisigSimulation?: MultisigSimulation.Spec | undefined
+        signatures?: undefined
+      }
+  )
 
 export type TransactionSerialized<
   type extends TransactionType = TransactionType,
@@ -381,10 +395,11 @@ async function serializeTempo(
 
     const payload = TxTempo.getSignPayload(TxTempo.from(transaction_sender_ox))
     const signatures = transaction.signatures.map((approval) =>
-      SignatureEnvelope.from(approval),
+      parseApproval(approval),
     )
     const config = MultisigConfig.from(multisigSimulation.config)
-    const account = multisigSimulation.account
+    const account = transaction.from
+    if (!account) throw new Error('A multisig sender is required for signing.')
     const sorted = SignatureEnvelope.sortMultisigApprovals({
       account,
       config,

package/tempo/actions/accessKey.ts

@@ -48,6 +48,7 @@ import type {
   WriteParameters,
 } from '../internal/types.js'
 import { defineCall } from '../internal/utils.js'
+import { parseApproval } from '../multisig/Signature.js'
 import type { TransactionReceipt } from '../Transaction.js'
 import { getConfig } from './multisig.js'
 
@@ -1240,7 +1241,7 @@ export async function signAuthorization<
         signature: SignatureEnvelope.from({
           account: account.address,
           config,
-          signatures: [SignatureEnvelope.from(signature)],
+          signatures: [parseApproval(signature)],
         }),
         type,
         ...(witness ? { witness } : {}),
@@ -1323,7 +1324,7 @@ export namespace signAuthorization {
     /** Multisig account being authorized. */
     account: Address | MultisigAccount
     /** Local owner that approves the authorization. */
-    owner: RootAccount | MultisigAccount
+    owner: RootAccount
   }
 
   /** Coordinated key authorization parameters. */
@@ -1333,7 +1334,7 @@ export namespace signAuthorization {
         /** Stored multisig operation hash. */
         hash: Hex
         /** Local owner that approves the authorization. */
-        owner: RootAccount | MultisigAccount
+        owner: RootAccount
       }
   >
 

package/tempo/chainConfig.ts

@@ -85,10 +85,7 @@ export const chainConfig = {
           throw new Error(
             'A local owner account is required to approve a stored multisig transaction.',
           )
-        if (
-          request.owner.source !== 'root' &&
-          request.owner.source !== 'multisig'
-        )
+        if (request.owner.source !== 'root')
           throw new Error(
             'A Tempo owner account is required to approve a stored multisig transaction.',
           )
@@ -125,7 +122,6 @@ export const chainConfig = {
           account: request.account,
           from: operation.account,
           multisigSimulation: getMultisigSimulation({
-            account: operation.account,
             config: operation.config,
             local: request.account,
           }),
@@ -168,11 +164,7 @@ export const chainConfig = {
         throw new Error(
           'A local owner account is required to approve a multisig transaction.',
         )
-      if (
-        request.owner &&
-        request.owner.source !== 'root' &&
-        request.owner.source !== 'multisig'
-      )
+      if (request.owner && request.owner.source !== 'root')
         throw new Error(
           'A Tempo owner account is required to approve a multisig transaction.',
         )
@@ -206,7 +198,6 @@ export const chainConfig = {
           )
         request.from = account
         request.multisigSimulation = getMultisigSimulation({
-          account,
           config,
           local,
         })
@@ -409,48 +400,18 @@ export type ChainConfig = typeof chainConfig
 
 /** Builds a bounded multisig spec for gas simulation. */
 function getMultisigSimulation(options: {
-  account: Address
   config: MultisigConfig.Config
   local?: MultisigAccount | undefined
 }): MultisigSimulation.Spec {
-  const { account, config, local } = options
+  const { config, local } = options
   return {
-    account,
     approvals: selectOwners(config).map((owner) => {
       const localOwner = local?.owners.find((account) =>
         isAddressEqual(account.address, owner.owner),
       )
-      if (localOwner?.source === 'multisig') {
-        const nested = localOwner as MultisigAccount
-        if (!nested.config)
-          throw new Error(
-            'A nested multisig config is required for gas estimation.',
-          )
-        return {
-          type: 'multisig',
-          spec: {
-            account: nested.address,
-            approvals: selectOwners(nested.config).map((owner) => {
-              const nestedOwner = nested.owners.find((account) =>
-                isAddressEqual(account.address, owner.owner),
-              )
-              if (nestedOwner?.source === 'multisig')
-                throw new Error(
-                  'Multisig simulation nesting exceeds depth two.',
-                )
-              return {
-                ...getSimulationKey(nestedOwner),
-                owner: owner.owner,
-              }
-            }),
-            config: nested.config,
-          },
-        }
-      }
       return {
         ...getSimulationKey(localOwner),
         owner: owner.owner,
-        type: 'primitive',
       }
     }),
     config,

package/tempo/multisig/Config.ts

@@ -4,12 +4,13 @@ import type * as Hex from 'ox/Hex'
 import * as Json from 'ox/Json'
 import { MultisigConfig } from 'ox/tempo'
 import { BaseError } from '../../errors/base.js'
+import { nativeMultisigFactory } 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. */
 const maxStoredValueLength = 65_536
 
-/** Zero commitment used before an account records its first config update. */
+/** Zero commitment used before an account is initialized. */
 const zeroCommitment = `0x${'00'.repeat(32)}` as const
 
 /** Reads a cached multisig config. */
@@ -43,7 +44,14 @@ export async function write(
   const { address, commitment } = options
   const config = MultisigConfig.from(options.config)
   assertKey({ address, commitment, config })
-  await store.setItem(key({ address, commitment }), serialize(config))
+  const value = serialize(config)
+  await store.setItem(key({ address, commitment }), value)
+  // Initialization commits the version-zero config without changing its version.
+  if (commitment.toLowerCase() === zeroCommitment)
+    await store.setItem(
+      key({ address, commitment: MultisigConfig.getCommitment(config) }),
+      value,
+    )
 }
 
 export declare namespace write {
@@ -69,11 +77,13 @@ function assertKey(options: {
     throw new InvalidStoreValueError()
   if (config.version === 0n) {
     if (
-      commitment.toLowerCase() !== zeroCommitment ||
-      !Address.isEqual(MultisigConfig.getAddress(config), address)
+      !Address.isEqual(
+        MultisigConfig.getAddress(config, { factory: nativeMultisigFactory }),
+        address,
+      )
     )
       throw new InvalidStoreValueError()
-    return
+    if (commitment.toLowerCase() === zeroCommitment) return
   }
   if (
     MultisigConfig.getCommitment(config).toLowerCase() !==