mppx 0.5.13 → 0.5.16

package/src/tempo/session/ChannelStore.ts

@@ -109,6 +109,18 @@ export type ChannelStore = {
 
 export type DeductResult = { ok: true; channel: State } | { ok: false; channel: State }
 
+export function normalizeChannelId(channelId: Hex): Hex {
+  return channelId.toLowerCase() as Hex
+}
+
+function normalizeState(channelId: Hex, state: State): State {
+  return state.channelId === channelId ? state : { ...state, channelId }
+}
+
+function normalizeMaybeState(channelId: Hex, state: State | null): State | null {
+  return state ? normalizeState(channelId, state) : null
+}
+
 /**
  * Atomically deduct `amount` from a channel's available balance.
  *
@@ -208,54 +220,75 @@ export function fromStore(store: Store.Store | Store.AtomicStore): ChannelStore
     channelId: Hex,
     fn: (current: State | null) => Store.Change<State, result>,
   ): Promise<result> {
+    const normalizedChannelId = normalizeChannelId(channelId)
     let change: Store.Change<State, result> | undefined
 
     if (atomicUpdate) {
-      const result = await atomicUpdate(channelId, (current) => {
-        change = fn((current as State | null) ?? null)
+      const result = await atomicUpdate(normalizedChannelId, (current) => {
+        change = fn(normalizeMaybeState(normalizedChannelId, (current as State | null) ?? null))
+        if (change.op === 'set') {
+          change = {
+            ...change,
+            value: normalizeState(normalizedChannelId, change.value),
+          }
+        }
         if (change.op !== 'set') return change
         return { ...change, value: change.value as never }
       })
-      if (change?.op !== 'noop') notify(channelId)
+      if (change?.op !== 'noop') notify(normalizedChannelId)
       return result
     }
 
-    while (locks.has(channelId)) await locks.get(channelId)
+    while (locks.has(normalizedChannelId)) await locks.get(normalizedChannelId)
 
     let release!: () => void
     locks.set(
-      channelId,
+      normalizedChannelId,
       new Promise<void>((r) => {
         release = r
       }),
     )
 
     try {
-      const current = (await store.get(channelId)) as State | null
+      const current = normalizeMaybeState(
+        normalizedChannelId,
+        (await store.get(normalizedChannelId)) as State | null,
+      )
       change = fn(current)
-      if (change.op === 'set') await store.put(channelId, change.value as never)
-      if (change.op === 'delete') await store.delete(channelId)
-      if (change.op !== 'noop') notify(channelId)
+      if (change.op === 'set') {
+        change = {
+          ...change,
+          value: normalizeState(normalizedChannelId, change.value),
+        }
+        await store.put(normalizedChannelId, change.value as never)
+      }
+      if (change.op === 'delete') await store.delete(normalizedChannelId)
+      if (change.op !== 'noop') notify(normalizedChannelId)
       return change.result
     } finally {
-      locks.delete(channelId)
+      locks.delete(normalizedChannelId)
       release()
     }
   }
 
   const cs: ChannelStore = {
     async getChannel(channelId) {
-      return (await store.get(channelId)) as State | null
+      const normalizedChannelId = normalizeChannelId(channelId)
+      return normalizeMaybeState(
+        normalizedChannelId,
+        (await store.get(normalizedChannelId)) as State | null,
+      )
     },
     async updateChannel(channelId, fn) {
       return update(channelId, fn)
     },
     waitForUpdate(channelId) {
       return new Promise<void>((resolve) => {
-        let set = waiters.get(channelId)
+        const normalizedChannelId = normalizeChannelId(channelId)
+        let set = waiters.get(normalizedChannelId)
         if (!set) {
           set = new Set()
-          waiters.set(channelId, set)
+          waiters.set(normalizedChannelId, set)
         }
         set.add(resolve)
       })

package/src/viem/Client.test.ts

@@ -2,7 +2,7 @@ import { createClient, custom, defineChain, type Hex } from 'viem'
 import { privateKeyToAccount } from 'viem/accounts'
 import { signTransaction } from 'viem/actions'
 import { tempoLocalnet } from 'viem/chains'
-import { Transaction } from 'viem/tempo'
+import { Account as TempoAccount, Transaction } from 'viem/tempo'
 import { describe, expect, test } from 'vp/test'
 
 import * as Client from './Client.js'
@@ -168,6 +168,57 @@ describe('feePayer transaction serialization', () => {
     } as never)
     expect(serverSigned).toMatch(/^0x7[68]/)
   })
+
+  test('behavior: deserialized + re-signed tx preserves keyAuthorization', async () => {
+    const rootAccount = TempoAccount.fromSecp256k1(
+      '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+    )
+    const accessKey = TempoAccount.fromSecp256k1(
+      '0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d',
+      { access: rootAccount },
+    )
+    const feePayerAccount = privateKeyToAccount(
+      '0x5de4111afa1a4b94908f83103f52c5de640f0e4f465f975fa6d6640d3c5e3b48',
+    )
+    const accessKeyClient = createClient({
+      account: accessKey,
+      chain: tempoLocalnet,
+      transport: mockTransport,
+    })
+
+    const keyAuthorization = await rootAccount.signKeyAuthorization(
+      {
+        accessKeyAddress: accessKey.accessKeyAddress,
+        keyType: accessKey.keyType,
+      },
+      {
+        chainId: BigInt(tempoLocalnet.id),
+      },
+    )
+
+    const clientSigned = await signTransaction(accessKeyClient, {
+      account: accessKey,
+      ...feePayer_prepared,
+      keyAuthorization,
+    } as never)
+    const deserialized = Transaction.deserialize(
+      clientSigned as Transaction.TransactionSerializedTempo,
+    )
+
+    expect(deserialized.keyAuthorization).toEqual(keyAuthorization)
+
+    const serverSigned = await signTransaction(tempoClient, {
+      ...deserialized,
+      account: feePayerAccount,
+      feePayer: feePayerAccount,
+      feeToken: '0x20c0000000000000000000000000000000000001' as const,
+    } as never)
+    const serverDeserialized = Transaction.deserialize(
+      serverSigned as Transaction.TransactionSerializedTempo,
+    )
+
+    expect(serverDeserialized.keyAuthorization).toEqual(keyAuthorization)
+  })
 })
 
 describe('getResolver serializer injection', () => {