Support for External Multisig Networks without Local Wallet Dependency

[theref]

Summary

We're integrating TACo (Threshold Access Control) network's distributed signing with MetaMask Smart Accounts. Currently, toMetaMaskSmartAccount requires a local wallet as a signatory even when using external multisig signers. This creates an unnecessary dependency for applications using distributed signing networks.

Current Implementation

// Current setup requires a local wallet even though signing happens via TACo network
const smartAccount = await toMetaMaskSmartAccount({
  client: publicClient,
  implementation: Implementation.MultiSig,
  deployParams: [signers, BigInt(threshold)], // TACo network signers
  deploySalt: '0x' as `0x${string}`,
  signatory: [{ account: localAccount }], // ← Still requires local wallet
});

Problem

When using distributed signing networks like TACo:

• The actual signing is performed by the network (2-of-3 threshold signatures from Ursula nodes)
• The local wallet in signatory is just a placeholder and doesn't perform the actual signing
• This creates confusion and unnecessary key management requirements
• AI agents and autonomous systems must manage private keys they don't actually use for signing

Use Case

TACo provides distributed threshold signatures where:

• Multiple Ursula nodes collectively sign transactions
• No single entity holds the complete signing capability
• The signing happens through the TACo SDK's signUserOp() function
• We retrieve signatures via the network, not from a local key

Example of how we currently sign:

const signature = await signUserOp(
  provider,
  TACO_DOMAIN,
  COHORT_ID,
  SEPOLIA_CHAIN_ID,
  tacoUserOp,
  AA_VERSION,
  signingContext
);

Desired Behavior

We'd like to wrap or integrate external signing networks (like TACo) with toMetaMaskSmartAccount without requiring a dummy local wallet. We understand Viem has capabilities for custom account implementations and wrapping external signers, but we're unsure of the best pattern to apply here.

Questions

1. Is there an existing pattern in Viem/Delegation Toolkit for wrapping external signing networks?
2. Can the signatory field support custom implementations that delegate to external networks?
3. What's the recommended approach for integrating distributed signing systems?

Benefits of Supporting This

• Enhanced Security: No unnecessary local key management
• AI Agent Compatibility: Enables autonomous agents without key custody
• Cleaner Integration: Direct integration with distributed signing networks
• Broader Adoption: Opens up new use cases for decentralized applications

Additional Context

• We're building demos for TACo adopters showing Account Abstraction integration
• The current workaround uses a dummy local wallet which is confusing in examples
• This pattern would benefit any application using external signing infrastructure (MPC, threshold signatures, HSMs, etc.)

Would love guidance on the best way to achieve this with the current toolkit or if this requires an enhancement.

[jeffsmale90]

Hi @theref terribly sorry for the late reply on this! We have been heads down building.

I think this is a valid concern, and I think it would make sense for the signers parameter to be optional on a multisig instance. Would that solve the problem that you have?

We have made steps towards improving the developer experience for aggregating signatures for multisigs (we call the PartialSignatures) using the aggregateSignature function - see the docs here https://docs.metamask.io/delegation-toolkit/development/guides/smart-accounts/generate-multisig-signature

[theref]

No problem, we snuck around the issue by wrapping the multisig in a custom Viem wrapper and using that, but it's not idea because signing isn't actually implemented properly.

Nice to see that progress is being made! Happy to talk to you through our use case if that helps with dev decisions - we'd definitely like the multisig implementation to be a bit more flexible, but I think many of those changes can only come with an upgrade to Entry Point 0.8.0

[jeffsmale90]

I've raised #163 proposing that we make the signer parameter optional. This allows the MetaMaskSmartAccount abstraction to be created without having any signer locally. (note: signer is the new name for signatory).

The existing aggregateSignature function https://docs.metamask.io/smart-accounts-kit/development/reference/smart-account/#aggregatesignature can be used to form the final signature from the distributed signer's partial signatures.