---
id: TIP-1166
title: Configurable Account Voucher Signers for the Channel Reserve
description: Lets configurable accounts sign channel vouchers, checked against the owner configuration fixed in the channel salt when the channel opens.
authors: Tanishk Goyal (@legion2002)
status: Draft
related: TIP-1034, TIP-1020, TIP-1028, TIP-1107, TIP-1109, TIP-1112, TIP-1113
protocolVersion: T15
---

# TIP-1166: Configurable Account Voucher Signers for the Channel Reserve

## Abstract

This TIP lets configurable accounts ([TIP-1107](./tip-1107.md)) sign channel vouchers ([TIP-1034](./tip-1034.md)) with their owners. If the voucher signer has a nonzero configuration commitment at `open`, the channel MUST use that commitment as the descriptor's `salt`. The descriptor is fixed for the channel's lifetime, so subsequent configuration changes do not invalidate signatures the payee already holds.

## Motivation

Since T14, `open` rejects a signer with a nonzero configuration commitment. Configurable payers therefore need a separate signing key designated by `authorizedSigner` to use channels under the existing rules.

Checking `0x05` vouchers against the account's *current* commitment would let a payer cheat. Any `updateConfig` changes the commitment ([TIP-1109](./tip-1109.md)):

1. Alice opens a channel to Bob with 100 USDC.
2. Alice's owners sign a voucher for 60 USDC, and Bob serves her.
3. Alice rotates her owners, then calls `requestClose`.
4. Bob's voucher no longer matches Alice's config, so `close` fails.
5. After the 15-minute grace period, Alice withdraws all 100 USDC.

Bob can't defend against this, and owner rotation is a normal thing to do (for example, after losing a device). Fixing the commitment at open fixes the signer for the channel's lifetime, so Bob's voucher still works.

The descriptor's `salt` is payer-chosen entropy that already feeds `channelId`. Requiring it to equal the opening commitment puts that commitment in calldata that every channel method already takes, so the ABI, the `channelId` formula and the channel's single storage slot are unchanged.

Alternatives considered:

- **Store the commitment in a second slot per channel.** No change for integrations, but each configurable-account channel pays a second state-creation charge (250,000 gas, [TIP-1000](./tip-1000.md)) at open and a cold read on every voucher.
- **Add the commitment to `ChannelDescriptor`.** No extra storage, but it changes `channelId` and every channel method, breaking existing integrations.
- **Accept any past configuration.** Tempo doesn't store config history.
- **Block `updateConfig` while channels are open.** A user who loses a device couldn't remove it.

## Assumptions

- A commitment covers the whole configuration, including its version. Otherwise two owner sets could share one.
- A version-0 configuration can't be forged for an address it doesn't derive (CREATE2 preimage resistance).
- Payees check a `0x05` voucher's config against the opening commitment before accepting it.
- Payers rarely open several channels to the same payee, operator and token with the same configurable signer in one transaction (see [Open](#open)).

---

# Specification

## Overview

These rules apply from T15. The *signer* is `authorizedSigner` if nonzero, otherwise `payer`. The *opening commitment* is the signer's configuration commitment read by `open`, or zero if the signer has none. If the opening commitment is nonzero, `descriptor.salt` carries it; `salt` refers only to that descriptor field.

1. If the signer's commitment at `open` is nonzero, `open` MUST require `descriptor.salt` to equal that commitment; otherwise, `salt` remains payer-chosen.
2. `settle` and `close` MUST check vouchers against the opening commitment, never the signer's current configuration.
3. Changes to the signer's configuration after `open` MUST NOT change the channel's voucher-signature verification rules. A nonzero `topUp` MUST revert if the signer's current commitment differs from its opening commitment, so configurations no longer authorized by the account cannot gain control of additional funds.

## Open

- The T14 `RootKeyRetired` check on the signer is removed.
- After the duplicate-channel check and before moving tokens, `open` MUST read the signer's commitment from state as it is when the call executes. If it is nonzero and `salt` differs from it, `open` reverts with `SaltNotSignerCommitment(signer, commitment)`. Otherwise, if it is nonzero, `open` sets `hasOpeningCommitment` in the channel's packed state (see [Packed state](#packed-state)) and emits `OpeningCommitmentRecorded`. A zero commitment leaves `hasOpeningCommitment` zero and the salt payer-chosen, as before.
- No storage is added: the channel keeps one state slot, paid for as in TIP-1034.
- Because the salt can't vary, a payer can open only one channel per payee, operator, token and configurable signer in a transaction; a second reverts with `ChannelAlreadyExists`. Channels opened in different transactions differ by `expiringNonceHash`.

## Packed state

This TIP amends the TIP-1034 packed `ChannelState` slot; the full layout is under [Interfaces](#channel-state-layout).

- TIP-1034's requirement that the reserved high 32 bits remain zero is replaced: bits 224..239 hold the two flags in the layout, encoded as 0 or 1, and bits 240..255 MUST remain zero. Bits 224..231 have been in use since T12 without being recorded here.
- `hasOpeningCommitment` is 1 when the opening commitment is nonzero, and 0 otherwise. Channels opened before T15 read it as 0 and have a zero opening commitment.
- Only `open` sets it. `settle`, `close`, `topUp` and `requestClose` MUST preserve it when they rewrite the slot. Deleting the slot, when a channel closes or is withdrawn, clears it with the rest of the state.
- When `hasOpeningCommitment` is 1, the opening commitment is `descriptor.salt`; when it is 0, the opening commitment is zero.

## Voucher checks

| Opening commitment | Signature | Accepted when |
|---|---|---|
| Any | Keychain (`0x03`, `0x04`) | Never (unchanged) |
| Nonzero | `0x05` | Its account is the signer, its config hashes to the opening commitment, and its owner signatures reach the threshold |
| Nonzero | Primitive | Never: the signer's root key was retired at open ([TIP-1112](./tip-1112.md)) |
| Zero | `0x05` | Its account is the signer, its config is version 0 and derives the signer's address, and its owner signatures reach the threshold |
| Zero | Primitive | It recovers to the signer (unchanged) |

Owners sign the TIP-1034 voucher digest the same way they sign a `0x05` transaction. Gas follows the signature verifier's `verifyConfigurableAccount` schedule: the `0x05` signature's verification gas, plus the version-0 address-derivation gas when the opening commitment is zero. The opening commitment, not the signer's current commitment, decides whether the derivation charge applies. All gas is charged before verification. A failed check reverts with `InvalidSignature`.

## Top-up

A nonzero `topUp` reverts:

- with `SignerConfigChanged(signer)` if the opening commitment is nonzero and differs from the signer's current commitment;
- with `RootKeyRetired(signer)` if the opening commitment is zero and the signer now has a commitment (as at T14).

A zero `topUp` still works and cancels a close request. To add funds after a rotation, the payer closes the channel and opens a new one.

The second rule also blocks top-ups when an unregistered signer registers, even with the same version-0 owners. The precompile sees only the new commitment and can't tell registration from a rotation. The payer closes and reopens the channel in that case too.

## Voucher view

`verifyVoucher(descriptor, cumulativeAmount, signature)` returns whether `settle` and `close` would accept `signature` for the channel at `cumulativeAmount`, using the voucher checks above against the channel's opening commitment. It reverts with `ChannelNotFound` if the channel doesn't exist. It doesn't compare `cumulativeAmount` with the deposit or the settled amount, which `getChannel` returns. It charges the same gas as the voucher check in `settle`, and propagates out-of-gas rather than returning false. Payees can use it to check a voucher before serving, without reimplementing the configurable-account rules or knowing whether the channel has an opening commitment.

## Payment lane

`settle` and `close` with a well-formed `0x05` signature count as payment-lane transactions. The classifier checks encoding only and reads no state. The TIP-1045 limit of 2,048 bytes of calldata per payment call still applies. Larger vouchers, such as large owner sets or most WebAuthn approvals, are valid but go to the general lane.

## Interfaces

### Channel state layout

The packed `ChannelState` slot from T15. Bit 0 is the least significant bit.

```
bits   0..95   settled                         uint96
bits  96..191  deposit                         uint96
bits 192..223  closeRequestedAt                uint32
bits 224..231  usesLogicalReceivePolicySender  bool (T12, TIP-1028)
bits 232..239  hasOpeningCommitment            bool (T15, this TIP)
bits 240..255  reserved                        zero
```

### `ITIP20ChannelReserve`

Additions to `ITIP20ChannelReserve`. No existing method, event or the `channelId` formula changes.

```solidity
/// @notice Emitted by open when the signer has a nonzero configuration commitment.
/// @param channelId The channel that was opened.
/// @param signer The voucher signer: authorizedSigner if set, otherwise payer.
/// @param commitment The opening commitment: the signer's configuration commitment when open ran.
event OpeningCommitmentRecorded(bytes32 indexed channelId, address indexed signer, bytes32 commitment);

/// @notice Thrown by a nonzero topUp when the signer's configuration changed since open.
/// @param signer The voucher signer.
error SignerConfigChanged(address signer);

/// @notice Thrown by open when the signer has a configuration commitment and salt differs from it.
/// @param signer The voucher signer.
/// @param commitment The signer's current configuration commitment.
error SaltNotSignerCommitment(address signer, bytes32 commitment);

/// @notice Returns whether settle and close would accept a voucher signature for a channel.
/// @dev Reverts with ChannelNotFound if the channel doesn't exist. Doesn't check cumulativeAmount
///      against the channel's deposit or settled amount.
/// @param descriptor The channel's descriptor.
/// @param cumulativeAmount The voucher's cumulative amount.
/// @param signature The voucher signature.
/// @return valid True if the signature is valid for the channel's voucher signer and opening commitment.
function verifyVoucher(ChannelDescriptor calldata descriptor, uint96 cumulativeAmount, bytes calldata signature)
    external
    view
    returns (bool valid);
```

# Compatibility

Existing channels have a zero opening commitment and behave as before. The ABI change is additive: no existing method, event or the `channelId` formula changes. Integrations that open channels for configurable signers still have to change, because `salt` is no longer free for them.

| Integration | What changes |
|---|---|
| Configurable payers | Open with the signer's commitment as `salt`; sign vouchers with `0x05`, using the config from when the channel opened |
| Payees | When the signer had a commitment at open (`OpeningCommitmentRecorded`), check that the voucher's config hashes to `descriptor.salt`, which needs no state read, or call `verifyVoucher` |
| SDKs and wallets | Set `salt` to the signer's commitment instead of choosing it at random; keep each channel's opening config until it closes; on `SignerConfigChanged`, close and reopen |
| Indexers | Index `OpeningCommitmentRecorded` |

**Migrating to a configurable account.** Payers should close their open channels before becoming configurable, whether by upgrading an EOA ([TIP-1113](./tip-1113.md)) or by registering a configuration for an address that had none. A channel opened before the migration has a zero opening commitment: its vouchers can still be signed only by the original key or version-0 configuration, never by the account's current owners, and a nonzero `topUp` reverts with `RootKeyRetired`. Accepting the current owners' signatures on such channels would let a later rotation void vouchers the payee holds (the attack in [Motivation](#motivation)), so this TIP does not. Wallets should offer to close these channels as part of the migration and reopen them afterwards with the commitment as `salt`.

# Observability

`OpeningCommitmentRecorded` shows which owner set signs for a channel. Comparing it with the account's latest `ConfigurableAccountConfigUpdated` or `AccountUpgraded` event finds channels opened under an old config.

# Threat Model

This threat model covers who can sign vouchers for a channel whose signer is a configurable account, and what a payer can change after `open`. TIP-1034 still governs everything else in the channel: who can call `settle` and `close`, the close timer, and where funds can go.

The most consequential attack is a payer voiding the vouchers a payee already holds by rotating owners and then withdrawing the whole deposit (see [Motivation](#motivation)). The opening commitment stops it: `settle` and `close` check vouchers only against the commitment fixed in `descriptor.salt` at `open`, and nothing after `open` can change that.

Some risks are accepted by the design. Owners removed by a rotation keep voucher authority on channels opened before it, up to each channel's deposit and only toward its fixed payee, until the payer closes those channels. A signer that registers a configuration after `open` can no longer top up, even if it keeps the same owners, because the precompile can't tell registration from rotation.

| Actor | Capability and trust | Boundary check and failure consequence |
|---|---|---|
| Payer's or signer's current quorum | Opens channels, signs vouchers, and can change the account's configuration at any time. Trusted only to spend what it signs for. | Vouchers are checked against the opening commitment, never the current configuration, so a rotation can't void a held voucher. A nonzero `topUp` reverts once the configuration changed, so new funds need a new channel opened under the new owners. |
| Removed owners (old quorum) | Hold keys that met the threshold of the configuration in force at `open`. Not trusted after removal. | Can still sign vouchers on channels opened before the rotation, capped at each deposit and payable only to the channel's fixed payee. Can't sign on channels opened after the rotation, and can't gain control of new deposits. The payer cuts this off by closing those channels (`requestClose`, then `withdraw` after 15 minutes). |
| Payee or operator | Submits vouchers through `settle` and `close`, and chooses the configuration and signatures it presents. Not trusted to present an honest configuration. | The configuration must hash to the opening commitment, or, with a zero opening commitment, be version 0 and derive the signer's address. A forged configuration fails with `InvalidSignature`. A payee that doesn't check vouchers before serving, using the configuration or `verifyVoucher`, risks serving for vouchers that won't settle. |
| Original key of a migrated signer ([TIP-1113](./tip-1113.md)) | Signs primitive vouchers. Trusted only on channels opened before migration. | A nonzero opening commitment means the root key was retired at `open`, so primitive vouchers are always rejected. On channels opened before migration (zero opening commitment), the original key keeps voucher authority until the payer closes them; the account's new owners never gain it there. |
| Wallet or SDK | Picks `salt`, keeps the configuration from `open`, and shows owners what they sign. Trusted to keep the opening configuration until the channel closes. | A wrong `salt` makes `open` revert with `SaltNotSignerCommitment`. If the wallet loses the opening configuration, owners can't produce vouchers the payee can settle, and the payer has to close and reopen the channel. |
| Spammer | Submits large `0x05` vouchers or calls `verifyVoucher`. | Verification gas is charged up front under the signature verifier's `verifyConfigurableAccount` schedule, and `verifyVoucher` charges the same gas as `settle`. Calldata over 2,048 bytes leaves the payment lane ([Payment lane](#payment-lane)). |

Out of scope: config changes on zones before the zone processes the Tempo block carrying them ([TIP-1154](./tip-1154.md)). Keychain-wrapped voucher signatures (`0x03`, `0x04`) stay rejected as under TIP-1034. A payer that delegates to an access key sets the key's own address as `authorizedSigner`, and the key signs primitive vouchers, unchanged by this TIP.

# Invariants

1. A channel's opening commitment never changes while the channel exists.
2. While a channel exists, subsequent changes to the payer's or signer's account configuration MUST NOT change the signature-verification result for a fixed voucher and signature.
3. A channel with a nonzero opening commitment has it as its salt.
4. A nonzero `topUp` succeeds only if the signer's current commitment equals the opening commitment (or both are zero).
5. A channel with a nonzero opening commitment accepts only `0x05` vouchers.
6. A channel uses one state slot whatever its opening commitment (TIP-1034 invariant 7 is unchanged).
7. Bits 240..255 of the packed channel state are zero.
