tapimo 0.19.0 → 0.20.0

package/src/handlers/internal/{multisig.store.test.ts → accounts.store.test.ts}

@@ -5,19 +5,19 @@ import { tempoLocalnet } from 'viem/tempo/chains'
 import * as Handler from '../../Handler.js'
 import * as Log from '../../internal/Log.js'
 import * as StateStore from '../../internal/Store.js'
-import * as Multisig from './multisig.js'
+import * as Accounts from './accounts.js'
 
 describe('fromStore', () => {
   test('requires atomic state', () => {
     const { swap: _, ...state } = StateStore.memory()
-    expect(() => Multisig.fromStore(state)).toThrowErrorMatchingInlineSnapshot(
-      `[Error: Multisig coordination requires an atomic state store.]`,
+    expect(() => Accounts.fromStore(state)).toThrowErrorMatchingInlineSnapshot(
+      `[Error: Configurable account coordination requires an atomic state store.]`,
     )
   })
 
   test('preserves concurrent compare-and-set', async () => {
     const state = StateStore.memory()
-    const a = Multisig.fromStore(state)
+    const a = Accounts.fromStore(state)
     const results = await Promise.all([
       a.compareAndSet('operation', null, 'a'),
       a.compareAndSet('operation', null, 'b'),
@@ -35,7 +35,7 @@ describe('fromStore', () => {
   test('honors absolute expiration', async () => {
     vi.useFakeTimers()
     try {
-      const store = Multisig.fromStore(StateStore.memory())
+      const store = Accounts.fromStore(StateStore.memory())
       await store.compareAndSet('lease', null, 'a', { expiresAt: Date.now() + 100 })
       await vi.advanceTimersByTimeAsync(101)
       expect(await store.getItem('lease')).toBeNull()
@@ -52,7 +52,7 @@ describe('relay', () => {
   test('serves unknown operations without forwarding them to the node', async () => {
     const handler = Handler.relay({
       getClient: () => client,
-      multisig: { store: StateStore.memory() },
+      accounts: { store: StateStore.memory() },
     })
     const response = await handler.fetch(
       new Request('http://relay/', {
@@ -60,7 +60,7 @@ describe('relay', () => {
         body: JSON.stringify({
           id: 42,
           jsonrpc: '2.0',
-          method: 'multisig_getOperation',
+          method: 'account_getOperation',
           params: [Hex.random(32)],
         }),
       }),
@@ -77,14 +77,14 @@ describe('relay', () => {
   test('rejects invalid parameters across the five methods', async () => {
     const handler = Handler.relay({
       getClient: () => client,
-      multisig: { store: StateStore.memory() },
+      accounts: { store: StateStore.memory() },
     })
     for (const method of [
-      'multisig_approveRawTransaction',
-      'multisig_approveRawTransactionSync',
-      'multisig_approveKeyAuthorization',
-      'multisig_getConfig',
-      'multisig_getOperation',
+      'account_approveRawTransaction',
+      'account_approveRawTransactionSync',
+      'account_approveKeyAuthorization',
+      'account_getConfig',
+      'account_getOperation',
     ]) {
       const response = await handler.fetch(
         new Request('http://relay/', {
@@ -100,15 +100,15 @@ describe('relay', () => {
     const state = StateStore.memory()
     const hash = Hex.random(32)
     // Operation lookup keys are part of the persisted Viem coordinator format.
-    await state.put(`multisig:v2:multisig:operation:${hash}`, 'invalid')
-    const handler = Handler.relay({ getClient: () => client, multisig: { store: state } })
+    await state.put(`accounts:v1:configurableAccount:operation:${hash}`, 'invalid')
+    const handler = Handler.relay({ getClient: () => client, accounts: { store: state } })
     const response = await handler.fetch(
       new Request('http://relay/', {
         method: 'POST',
         body: JSON.stringify({
           id: 1,
           jsonrpc: '2.0',
-          method: 'multisig_getOperation',
+          method: 'account_getOperation',
           params: [hash],
         }),
       }),

package/src/handlers/internal/{multisig.test.ts → accounts.test.ts}

@@ -1,8 +1,8 @@
 import { Hex, Rlp } from 'ox'
 import {
+  AccountConfig,
+  AccountOperation,
   KeyAuthorization,
-  MultisigConfig,
-  MultisigOperation,
   SignatureEnvelope,
   TxEnvelopeTempo,
 } from 'ox/tempo'
@@ -20,7 +20,7 @@ import * as StateStore from '../../internal/Store.js'
 
 const owners = Accounts.create(inject('tempoTestMnemonic'))
 const chain = defineChain({ ...tempoLocalnet, id: 1337 })
-const client = createClient({ chain, transport: http(inject('tempoMultisigRpcUrl')) })
+const client = createClient({ chain, transport: http(inject('tempoAccountsRpcUrl')) })
 const feeToken = '0x20c0000000000000000000000000000000000000'
 
 beforeAll(async () => {
@@ -30,18 +30,18 @@ beforeAll(async () => {
 describe('relay', () => {
   test('serves all five TIP-1101 methods and keeps submitted hashes distinct', async () => {
     const relay = fixture()
-    const account = multisig()
+    const account = configurable()
     const config = {
-      ...MultisigConfig.toRpc(account.config!),
+      ...AccountConfig.toRpc(account.config!),
       owners: account.config!.owners.map(({ owner, weight }) => ({
         owner: owner.toLowerCase(),
         weight,
       })),
     }
-    expect(await relay.rpc('multisig_getConfig', [{ address: account.address }])).toBeNull()
-    expect(await relay.rpc('multisig_getOperation', [Hex.random(32)])).toBeNull()
+    expect(await relay.rpc('account_getConfig', [{ address: account.address }])).toBeNull()
+    expect(await relay.rpc('account_getOperation', [Hex.random(32)])).toBeNull()
     const first = await approval(account, [owners[1]])
-    const hash = (await relay.rpc('multisig_approveRawTransaction', [first])) as Hex.Hex
+    const hash = (await relay.rpc('account_approveRawTransaction', [first])) as Hex.Hex
     const pending = await relay.operation(hash)
     expect(pending).toMatchObject({
       hash,
@@ -52,13 +52,13 @@ describe('relay', () => {
       threshold: 2,
     })
     expect(pending.config.version).toBe('0x0')
-    expect(await relay.rpc('multisig_getConfig', [{ address: account.address }])).toEqual(config)
+    expect(await relay.rpc('account_getConfig', [{ address: account.address }])).toEqual(config)
     expect(await relay.rpc('eth_getTransactionReceipt', [hash])).toBeNull()
     const second = await approval(account, [owners[2]])
-    const complete = (await relay.rpc('multisig_approveRawTransactionSync', [
+    const complete = (await relay.rpc('account_approveRawTransactionSync', [
       second,
       1000,
-    ])) as MultisigOperation.TransactionRpc
+    ])) as AccountOperation.TransactionRpc
     expect(complete).toMatchObject({ hash, status: 'success', signatureCount: 2, weight: 2 })
     expect(complete.transactionHash).not.toBe(hash)
     const receipt = await getTransactionReceipt(client, { hash: complete.transactionHash! })
@@ -67,13 +67,13 @@ describe('relay', () => {
       status: 'success',
       feePayer: owners[0].address.toLowerCase(),
     })
-    expect(await relay.rpc('multisig_approveRawTransaction', [first])).toBe(hash)
+    expect(await relay.rpc('account_approveRawTransaction', [first])).toBe(hash)
     expect(await relay.operation(hash)).toEqual(complete)
     expect(await relay.rpc('eth_getTransactionReceipt', [hash])).toMatchObject({
       transactionHash: complete.transactionHash,
-      multisig: { hash },
+      operation: { hash },
     })
-    expect(await relay.rpc('multisig_getConfig', [{ address: account.address }])).toEqual(config)
+    expect(await relay.rpc('account_getConfig', [{ address: account.address }])).toEqual(config)
 
     const key = KeyAuthorization.from({
       account: account.address,
@@ -81,13 +81,13 @@ describe('relay', () => {
       chainId: BigInt(chain.id),
       type: 'secp256k1',
     })
-    const keyHash = MultisigConfig.getSignPayload({
+    const keyHash = AccountConfig.getSignPayload({
       account: account.address,
       config: account.config!,
       payload: KeyAuthorization.getSignPayload(key),
     })
     const signed = KeyAuthorization.from(key, {
-      signature: SignatureEnvelope.from<SignatureEnvelope.Multisig>({
+      signature: SignatureEnvelope.from<SignatureEnvelope.Configurable>({
         account: account.address,
         config: account.config!,
         signatures: [
@@ -97,20 +97,20 @@ describe('relay', () => {
         ],
       }),
     })
-    const keyPending = (await relay.rpc('multisig_approveKeyAuthorization', [
+    const keyPending = (await relay.rpc('account_approveKeyAuthorization', [
       { keyAuthorization: KeyAuthorization.toRpc(signed) },
-    ])) as MultisigOperation.KeyAuthorizationRpc
+    ])) as AccountOperation.KeyAuthorizationRpc
     expect(keyPending).toMatchObject({ hash: keyHash, status: 'pending', type: 'keyAuthorization' })
     const nonce = await client.request({
       method: 'eth_getTransactionCount',
       params: [account.address, 'latest'],
     })
-    const keySuccess = (await relay.rpc('multisig_approveKeyAuthorization', [
+    const keySuccess = (await relay.rpc('account_approveKeyAuthorization', [
       { hash: keyHash, signature: await owners[2].sign({ hash: keyHash }) },
-    ])) as MultisigOperation.KeyAuthorizationRpc
+    ])) as AccountOperation.KeyAuthorizationRpc
     expect(keySuccess).toMatchObject({ hash: keyHash, status: 'success', signatureCount: 2 })
     expect(KeyAuthorization.deserialize(keySuccess.keyAuthorization).signature?.type).toBe(
-      'multisig',
+      'configurable',
     )
     expect(await relay.operation(keyHash)).toEqual(keySuccess)
     expect(
@@ -126,11 +126,11 @@ describe('relay', () => {
     const wallet = createClient({
       chain,
       transport: withRelay(
-        http(inject('tempoMultisigRpcUrl')),
+        http(inject('tempoAccountsRpcUrl')),
         custom({ request: ({ method, params }) => relay.rpc(method, params ?? []) }),
       ),
     })
-    const account = multisig()
+    const account = configurable()
     const pending = await sendTransactionSync(wallet, {
       account,
       calls: [{ to: account.address, value: 0n }],
@@ -150,13 +150,13 @@ describe('relay', () => {
     const store = StateStore.memory()
     const a = fixture({ store })
     const b = fixture({ store })
-    const account = multisig(3)
+    const account = configurable(3)
     const first = await approval(account, [owners[1]])
     const second = await approval(account, [owners[2]])
     const hashes = await Promise.all([
-      a.rpc('multisig_approveRawTransaction', [first]),
-      b.rpc('multisig_approveRawTransaction', [second]),
-      a.rpc('multisig_approveRawTransaction', [first]),
+      a.rpc('account_approveRawTransaction', [first]),
+      b.rpc('account_approveRawTransaction', [second]),
+      a.rpc('account_approveRawTransaction', [first]),
     ])
     expect(new Set(hashes).size).toBe(1)
     expect(await a.operation(hashes[0] as Hex.Hex)).toMatchObject({
@@ -166,11 +166,11 @@ describe('relay', () => {
     })
   })
 
-  test.each(['multisig_approveRawTransaction', 'eth_sendRawTransaction'])(
+  test.each(['account_approveRawTransaction', 'eth_sendRawTransaction'])(
     'selects a weighted quorum and submits asynchronously via %s',
     async (method) => {
       const relay = fixture()
-      const account = Account.fromMultisig({
+      const account = Account.fromConfig({
         owners: [
           { owner: owners[1].address, weight: 2 },
           { owner: owners[2].address, weight: 1 },
@@ -192,29 +192,29 @@ describe('relay', () => {
 
   test('rejects positive-version configs for an unregistered account', async () => {
     const relay = fixture()
-    const initial = multisig()
-    const account = Account.fromMultisig({
+    const initial = configurable()
+    const account = Account.fromConfig({
       ...initial.config!,
       address: initial.address,
       version: 1n,
     })
     await expect(
-      relay.rpc('multisig_approveRawTransaction', [await approval(account, [owners[1]])]),
+      relay.rpc('account_approveRawTransaction', [await approval(account, [owners[1]])]),
     ).rejects.toMatchObject({ code: -32602 })
     expect((await relay.store.list()).keys).toEqual([])
   })
 
   test('validates cached configurations before returning them', async () => {
     const relay = fixture()
-    const account = multisig()
-    await relay.rpc('multisig_approveRawTransaction', [await approval(account, [owners[1]])])
+    const account = configurable()
+    await relay.rpc('account_approveRawTransaction', [await approval(account, [owners[1]])])
     const { keys } = await relay.store.list()
     const key = keys.find(
       ({ name }) => name.includes(':config:') && name.endsWith(`0x${'00'.repeat(32)}`),
     )!
     await relay.store.put(key.name, '{}')
     await expect(
-      relay.rpc('multisig_getConfig', [{ address: account.address }]),
+      relay.rpc('account_getConfig', [{ address: account.address }]),
     ).rejects.toMatchObject({ code: -32603 })
   })
 
@@ -222,15 +222,15 @@ describe('relay', () => {
     const store = StateStore.memory()
     const rejected = fixture({ store, validate: async () => false })
     const accepted = fixture({ store })
-    const account = multisig()
+    const account = configurable()
     const first = await approval(account, [owners[1]])
     const second = await approval(account, [owners[2]])
-    const hash = (await rejected.rpc('multisig_approveRawTransaction', [first])) as Hex.Hex
-    await expect(
-      rejected.rpc('multisig_approveRawTransactionSync', [second]),
-    ).rejects.toMatchObject({ code: -32602, message: 'Sponsorship rejected.' })
+    const hash = (await rejected.rpc('account_approveRawTransaction', [first])) as Hex.Hex
+    await expect(rejected.rpc('account_approveRawTransactionSync', [second])).rejects.toMatchObject(
+      { code: -32602, message: 'Sponsorship rejected.' },
+    )
     expect(await accepted.operation(hash)).toMatchObject({ status: 'pending', signatureCount: 2 })
-    expect(await accepted.rpc('multisig_approveRawTransactionSync', [second])).toMatchObject({
+    expect(await accepted.rpc('account_approveRawTransactionSync', [second])).toMatchObject({
       status: 'success',
     })
   })
@@ -238,15 +238,15 @@ describe('relay', () => {
   test('rejects malformed requests and non-owner approvals', async () => {
     const relay = fixture()
     for (const [method, params] of [
-      ['multisig_approveRawTransaction', ['0x76']],
-      ['multisig_approveRawTransactionSync', ['0x']],
-      ['multisig_approveKeyAuthorization', [{ hash: Hex.random(32), signature: '0x' }]],
-      ['multisig_getConfig', [{ address: 'invalid' }]],
-      ['multisig_getOperation', ['0x']],
+      ['account_approveRawTransaction', ['0x76']],
+      ['account_approveRawTransactionSync', ['0x']],
+      ['account_approveKeyAuthorization', [{ hash: Hex.random(32), signature: '0x' }]],
+      ['account_getConfig', [{ address: 'invalid' }]],
+      ['account_getOperation', ['0x']],
     ] as const)
       await expect(relay.rpc(method, params)).rejects.toMatchObject({ code: -32602 })
     await expect(
-      relay.rpc('multisig_approveRawTransaction', [await approval(multisig(), [owners[4]])]),
+      relay.rpc('account_approveRawTransaction', [await approval(configurable(), [owners[4]])]),
     ).rejects.toMatchObject({ code: -32602 })
   })
 
@@ -254,7 +254,7 @@ describe('relay', () => {
     'retains partial approvals without broadcasting via %s',
     async (method) => {
       const relay = fixture()
-      const account = multisig()
+      const account = configurable()
       const partial = await approval(account, [owners[1]])
       const result = (await relay.rpc(method, [partial])) as
         | Hex.Hex
@@ -281,31 +281,31 @@ describe('relay', () => {
   test('rejects chain mismatches before collecting approvals', async () => {
     const relay = fixture()
     await expect(
-      relay.rpc('multisig_approveRawTransaction', [await approval(multisig(), [owners[1]])], 1),
+      relay.rpc('account_approveRawTransaction', [await approval(configurable(), [owners[1]])], 1),
     ).rejects.toMatchObject({ code: -32602, message: 'Conflicting chain ids.' })
     expect((await relay.store.list()).keys).toEqual([])
   })
 
   test('reports corrupt stored state as an observable server error', async () => {
     const relay = fixture()
-    const hash = (await relay.rpc('multisig_approveRawTransaction', [
-      await approval(multisig(), [owners[1]]),
+    const hash = (await relay.rpc('account_approveRawTransaction', [
+      await approval(configurable(), [owners[1]]),
     ])) as Hex.Hex
     const { keys } = await relay.store.list()
     const key = keys.find(({ name }) => name.endsWith(hash.toLowerCase()))!
     await relay.store.put(key.name, 'invalid')
-    const response = await relay.response('multisig_getOperation', [hash])
+    const response = await relay.response('account_getOperation', [hash])
     expect(response).toMatchObject({ error: { code: -32603 } })
     expect(Log.rpcErrors(response)).toMatchObject({ serverErrors: 1 })
   })
 })
 
 describe('raw sponsorship', () => {
-  test('sponsors a multisig fee-payer handoff its owners approved', async () => {
-    const account = multisig(1)
+  test('sponsors a configurable account fee-payer handoff its owners approved', async () => {
+    const account = configurable(1)
     const relay = fixture()
     const serialized = await handoff({ account, signers: [owners[1]] })
-    // Fee-payer serialization writes the `0x00` marker instead of a sender for multisig signatures.
+    // Fee-payer serialization writes the `0x00` marker instead of a sender for configurable account signatures.
     expect((Rlp.toHex(Hex.slice(serialized, 1)) as readonly Hex.Hex[])[11]).toBe('0x00')
 
     const result = (await relay.rpc('eth_signRawTransaction', [serialized])) as `0x76${string}`
@@ -316,23 +316,23 @@ describe('raw sponsorship', () => {
   test.each([
     {
       name: 'approvals below quorum',
-      account: () => multisig(2),
-      message: 'Multisig account approvals do not reach quorum.',
+      account: () => configurable(2),
+      message: 'Configurable account approvals do not reach quorum.',
       signers: () => [owners[1]],
     },
     {
       name: 'a non-owner approval',
-      account: () => multisig(1),
-      message: 'Invalid multisig approval: signature is from non-owner <address>.',
+      account: () => configurable(1),
+      message: 'Invalid operation approval: signature is from non-owner <address>.',
       signers: () => [owners[4]],
     },
     {
       name: 'a config that does not derive its account',
-      account: () => ({ ...multisig(1), address: `0x${'ab'.repeat(20)}` as const }),
-      message: 'Initial account config does not match the multisig account.',
+      account: () => ({ ...configurable(1), address: `0x${'ab'.repeat(20)}` as const }),
+      message: 'Initial account config does not match the configurable account.',
       signers: () => [owners[1]],
     },
-  ])('rejects a multisig handoff with $name', async ({ account, message, signers }) => {
+  ])('rejects a configurable account handoff with $name', async ({ account, message, signers }) => {
     const relay = fixture()
 
     const { error } = await relay.response('eth_signRawTransaction', [
@@ -342,8 +342,8 @@ describe('raw sponsorship', () => {
     expect(error?.message.replace(/0x[0-9a-f]{40}/i, '<address>')).toBe(message)
   })
 
-  test('sponsors an access key a multisig account authorized in the same transaction', async () => {
-    const account = multisig(1)
+  test('sponsors an access key a configurable account authorized in the same transaction', async () => {
+    const account = configurable(1)
     const relay = fixture()
 
     const result = (await relay.rpc('eth_signRawTransaction', [
@@ -353,8 +353,8 @@ describe('raw sponsorship', () => {
     expect(TxEnvelopeTempo.deserialize(result as never).from).toBe(account.address.toLowerCase())
   })
 
-  test('rejects an access key a non-owner authorized for a multisig account', async () => {
-    const account = multisig(1)
+  test('rejects an access key a non-owner authorized for a configurable account', async () => {
+    const account = configurable(1)
     const relay = fixture()
 
     const { error } = await relay.response('eth_signRawTransaction', [
@@ -362,20 +362,23 @@ describe('raw sponsorship', () => {
     ])
 
     expect(error?.message.replace(/0x[0-9a-f]{40}/i, '<address>')).toMatchInlineSnapshot(
-      `"Invalid multisig approval: signature is from non-owner <address>."`,
+      `"Invalid operation approval: signature is from non-owner <address>."`,
     )
   })
 })
 
-function multisig(threshold = 2) {
-  return Account.fromMultisig({
+function configurable(threshold = 2) {
+  return Account.fromConfig({
     owners: [owners[1].address, owners[2].address, owners[3].address],
     salt: Hex.random(32),
     threshold,
   })
 }
 
-async function approval(account: Account.MultisigAccount, signers: readonly Accounts.Account[]) {
+async function approval(
+  account: Account.ConfigurableAccount,
+  signers: readonly Accounts.Account[],
+) {
   const transaction = TxEnvelopeTempo.from({
     calls: [{ to: account.address, value: 0n }],
     chainId: chain.id,
@@ -386,7 +389,7 @@ async function approval(account: Account.MultisigAccount, signers: readonly Acco
     maxPriorityFeePerGas: 0n,
     nonce: 0n,
   })
-  const hash = MultisigConfig.getSignPayload({
+  const hash = AccountConfig.getSignPayload({
     account: account.address,
     config: account.config!,
     payload: TxEnvelopeTempo.getSignPayload(transaction),
@@ -396,7 +399,7 @@ async function approval(account: Account.MultisigAccount, signers: readonly Acco
       .sort((a, b) => a.address.toLowerCase().localeCompare(b.address.toLowerCase()))
       .map(async (owner) => {
         const signature = SignatureEnvelope.from(await owner.sign({ hash }))
-        if (signature.type === 'multisig' || signature.type === 'keychain')
+        if (signature.type === 'configurable' || signature.type === 'keychain')
           throw new Error('Expected a primitive owner.')
         return signature
       }),
@@ -418,7 +421,7 @@ function fixture(options: fixture.Options = {}) {
       ...(options.validate ? { validate: options.validate } : {}),
     },
     getClient: () => client,
-    multisig: { store },
+    accounts: { store },
   })
   async function response(method: string, params: readonly unknown[], chainId: number = chain.id) {
     return (await (
@@ -438,7 +441,7 @@ function fixture(options: fixture.Options = {}) {
   }
   return {
     operation: (hash: Hex.Hex) =>
-      rpc('multisig_getOperation', [hash]) as Promise<MultisigOperation.Rpc>,
+      rpc('account_getOperation', [hash]) as Promise<AccountOperation.Rpc>,
     response,
     rpc,
     store,
@@ -479,9 +482,9 @@ async function handoff(options: handoff.Options) {
 
 declare namespace handoff {
   type Options = {
-    /** Multisig account the handoff is sent from. */
-    account: Account.MultisigAccount
-    /** Owners whose approvals the multisig signature carries. */
+    /** Configurable account the handoff is sent from. */
+    account: Account.ConfigurableAccount
+    /** Owners whose approvals the configurable signature carries. */
     signers: readonly Accounts.Account[]
   }
 }
@@ -535,10 +538,10 @@ async function keyHandoff(options: handoff.Options) {
   })
 }
 
-/** Returns a multisig signature carrying `signers`' approvals of `payload` for `account`. */
+/** Returns a configurable signature carrying `signers`' approvals of `payload` for `account`. */
 async function approve(options: approve.Options) {
   const { account, payload, signers } = options
-  const hash = MultisigConfig.getSignPayload({
+  const hash = AccountConfig.getSignPayload({
     account: account.address,
     config: account.config!,
     payload,
@@ -548,7 +551,7 @@ async function approve(options: approve.Options) {
       .sort((a, b) => a.address.toLowerCase().localeCompare(b.address.toLowerCase()))
       .map(async (owner) => {
         const signature = SignatureEnvelope.from(await owner.sign({ hash }))
-        if (signature.type === 'multisig' || signature.type === 'keychain')
+        if (signature.type === 'configurable' || signature.type === 'keychain')
           throw new Error('Expected a primitive owner.')
         return signature
       }),
@@ -562,8 +565,8 @@ async function approve(options: approve.Options) {
 
 declare namespace approve {
   type Options = {
-    /** Multisig account whose owners approve `payload`. */
-    account: Account.MultisigAccount
+    /** Configurable account whose owners approve `payload`. */
+    account: Account.ConfigurableAccount
     /** Sign payload the owners approve. */
     payload: Hex.Hex
     /** Owners whose approvals the signature carries. */

package/src/handlers/internal/{multisig.ts → accounts.ts}

@@ -2,23 +2,23 @@ import { Store } from 'viem/tempo'
 
 import type * as core_Store from '../../internal/Store.js'
 
-/** Methods the relay answers through stored multisig coordination when a multisig store is configured. */
+/** Methods the relay answers through stored configurable account coordination when an account store is configured. */
 export const methods = new Set([
   'eth_getTransactionByHash',
   'eth_getTransactionReceipt',
   'eth_sendRawTransaction',
   'eth_sendRawTransactionSync',
-  'multisig_approveKeyAuthorization',
-  'multisig_approveRawTransaction',
-  'multisig_approveRawTransactionSync',
-  'multisig_getConfig',
-  'multisig_getOperation',
+  'account_approveKeyAuthorization',
+  'account_approveRawTransaction',
+  'account_approveRawTransactionSync',
+  'account_getConfig',
+  'account_getOperation',
 ])
 
-/** Adapts Tempo API state to Viem's atomic multisig store. */
+/** Adapts Tempo API state to Viem's atomic configurable account store. */
 export function fromStore(store: core_Store.State): Store.Atomic {
   const swap = store.swap?.bind(store)
-  if (!swap) throw new Error('Multisig coordination requires an atomic state store.')
+  if (!swap) throw new Error('Configurable account coordination requires an atomic state store.')
 
   return Store.from(
     {
@@ -31,6 +31,6 @@ export function fromStore(store: core_Store.State): Store.Atomic {
       removeItem: (key) => store.delete(key),
       setItem: (key, value) => store.put(key, value),
     },
-    { key: 'multisig:v2' },
+    { key: 'accounts:v1' },
   )
 }