Multisig - Rhinestone

A multisig account requires signatures from multiple owners to authorize a transaction. It distributes control so no single party can act unilaterally — useful for treasuries and shared accounts — and can also improve UX (e.g. a passkey per device, so a user can sign from any of them). Both the ECDSA signer (Ownable Validator) and the passkey signer (WebAuthn Validator) support multisig. The validator verifies each signature against the stored owner set, and the account enforces the threshold (e.g. 2-of-3).

Setup

Create a multisig by passing multiple owners and a threshold — the number of signatures required to authorize a transaction.

ECDSA
Passkeys

const account = await rhinestone.createAccount({
  owners: {
    type: 'ecdsa',
    accounts: [signerA, signerB, signerC],
    threshold: 2, // 2-of-3
  },
})

const account = await rhinestone.createAccount({
  owners: {
    type: 'passkey',
    accounts: [passkeyAccountA, passkeyAccountB],
    threshold: 2, // 2-of-2
  },
})

By default, threshold is 1 (any single owner can sign). Managing owners after creation — adding or removing signers, changing the threshold, reading the current set — is covered on the signer pages: ECDSA and passkeys.

To combine different signer types (e.g. require both an EOA and a passkey), use multi-factor authentication instead.

1-of-n: sign from any owner

With a 1-of-n threshold, any single owner can authorize a transaction on their own. Pick which owner signs with signers. A common use is a passkey per device, so the user can sign from any device without migrating keys.

import { RhinestoneSDK } from '@rhinestone/sdk'
import { toWebAuthnAccount } from 'viem/account-abstraction'
import { base, arbitrum } from 'viem/chains'
import { encodeFunctionData, erc20Abi, parseUnits } from 'viem'

// One passkey per device, each registered via WebAuthn on that device
const passkeyAccountA = toWebAuthnAccount({ credential: credentialFromDeviceA })
const passkeyAccountB = toWebAuthnAccount({ credential: credentialFromDeviceB })

const rhinestone = new RhinestoneSDK({
  apiKey: process.env.RHINESTONE_API_KEY as string,
})

// Any single registered device can sign
const account = await rhinestone.createAccount({
  owners: {
    type: 'passkey',
    accounts: [passkeyAccountA, passkeyAccountB],
    threshold: 1,
  },
})

const usdcAmount = parseUnits('0.1', 6)
const prepared = await account.prepareTransaction({
  sourceChains: [base],
  targetChain: arbitrum,
  calls: [
    {
      to: 'USDC',
      value: 0n,
      data: encodeFunctionData({
        abi: erc20Abi,
        functionName: 'transfer',
        args: ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', usdcAmount],
      }),
    },
  ],
  tokenRequests: [{ address: 'USDC', amount: usdcAmount }],
  // Sign from a single device
  signers: {
    type: 'owner',
    kind: 'passkey',
    accounts: [passkeyAccountA],
  },
})

const signed = await account.signTransaction(prepared)
const transaction = await account.submitTransaction(signed)
const result = await account.waitForExecution(transaction)

ECDSA works the same way — set threshold: 1 and pass a single account under signers.

m-of-n: collect multiple signatures

When the threshold is greater than one, you need signatures from several owners. There are two ways to collect them.

Co-located signing

If every key is available in the same environment, sign with a subset of owners in a single call. List the signing owners under signers and call signTransaction once — the SDK requests a signature from each account in the list in parallel and packs them into the account’s multisig signature. Every listed key must be reachable in this environment; if the owners sign from separate devices, use independent signing instead.

const prepared = await account.prepareTransaction({
  sourceChains: [base],
  targetChain: arbitrum,
  calls: [
    // …
  ],
  tokenRequests: [{ address: 'USDC', amount: usdcAmount }],
  // Two of the three owners sign to meet the 2-of-3 threshold
  signers: {
    type: 'owner',
    kind: 'ecdsa',
    accounts: [signerA, signerB],
  },
})

const signed = await account.signTransaction(prepared)
const transaction = await account.submitTransaction(signed)

Independent signing

When owners are separate parties on different devices, each signs the same prepared transaction independently, and a coordinator merges the results. Prepare the transaction once and share it with each owner:

// Coordinator: prepare once, then share `prepared` with each owner
const prepared = await account.prepareTransaction({
  sourceChains: [base],
  targetChain: arbitrum,
  calls: [
    // …
  ],
  tokenRequests: [{ address: 'USDC', amount: usdcAmount }],
})

// Each owner signs in their own environment
const signatureA = await account.signTransaction(prepared, { owner: signerA })
const signatureB = await account.signTransaction(prepared, { owner: signerB })

// Coordinator: assemble the collected signatures and submit
const signed = await account.assembleTransaction(prepared, [signatureA, signatureB])
const transaction = await account.submitTransaction(signed)
const result = await account.waitForExecution(transaction)

Passkey owners follow the same flow — pass the passkey account as owner. The signature returned by signTransaction({ owner }) is JSON-serializable, so each owner can return it over the wire:

// On the owner's side
const payload = JSON.stringify(await account.signTransaction(prepared, { owner: signerA }))

// On the coordinator's side
const signatureA = JSON.parse(payload)

Signatures can be collected in any order — assembleTransaction deduplicates them and orders them to match the account’s owner set. Provide enough to meet the threshold, or assembly throws InsufficientOwnerSignaturesError. Every owner must sign the same prepared transaction, otherwise assembly throws MismatchedOwnerSignaturesError.

Independent signing is supported for ECDSA, passkey, and multi-factor owners. For multi-factor accounts, also pass the validatorId of the factor the owner belongs to: signTransaction(prepared, { owner, validatorId }).

​Setup

​1-of-n: sign from any owner

​m-of-n: collect multiple signatures

​Co-located signing

​Independent signing

Setup

1-of-n: sign from any owner

m-of-n: collect multiple signatures

Co-located signing

Independent signing