mppx 0.4.7 → 0.4.9

package/src/tempo/server/Session.ts

@@ -18,6 +18,7 @@ import {
   type Client as viem_Client,
 } from 'viem'
 import { tempo as tempo_chain } from 'viem/chains'
+
 import {
   AmountExceedsDepositError,
   BadRequestError,
@@ -85,7 +86,7 @@ export function session<const parameters extends session.Parameters>(p?: paramet
   const parameters = p as parameters
   const {
     amount,
-    channelStateTtl = 60_000,
+    channelStateTtl = 5_000,
     currency = defaults.resolveCurrency(parameters),
     decimals = defaults.decimals,
     store: rawStore = Store.memory(),
@@ -284,7 +285,7 @@ export declare namespace session {
   >
 
   type Parameters = {
-    /** TTL in milliseconds for cached on-chain channel state. After this duration, the server re-queries on-chain state during voucher handling to detect forced close requests. @default 60_000 */
+    /** TTL in milliseconds for cached on-chain channel state. After this duration, the server re-queries on-chain state during voucher handling to detect forced close requests. @default 5_000 */
     channelStateTtl?: number | undefined
     /** Minimum voucher delta to accept (numeric string, default: "0"). */
     minVoucherDelta?: string | undefined
@@ -451,7 +452,7 @@ async function verifyAndAcceptVoucher(parameters: {
     throw new ChannelClosedError({ reason: 'channel has a pending close request' })
   }
 
-  if (voucher.cumulativeAmount < onChain.settled) {
+  if (voucher.cumulativeAmount <= onChain.settled) {
     throw new VerificationFailedError({
       reason: 'voucher cumulativeAmount is below on-chain settled amount',
     })
@@ -462,12 +463,8 @@ async function verifyAndAcceptVoucher(parameters: {
   }
 
   if (voucher.cumulativeAmount <= channel.highestVoucherAmount) {
-    return createSessionReceipt({
-      challengeId: challenge.id,
-      channelId,
-      acceptedCumulative: channel.highestVoucherAmount,
-      spent: channel.spent,
-      units: channel.units,
+    throw new VerificationFailedError({
+      reason: 'voucher cumulativeAmount must be strictly greater than highest accepted voucher',
     })
   }
 
@@ -561,7 +558,7 @@ async function handleOpen(
     throw new AmountExceedsDepositError({ reason: 'voucher amount exceeds on-chain deposit' })
   }
 
-  if (voucher.cumulativeAmount < onChain.settled) {
+  if (voucher.cumulativeAmount <= onChain.settled) {
     throw new VerificationFailedError({
       reason: 'voucher cumulativeAmount is below on-chain settled amount',
     })
@@ -580,16 +577,22 @@ async function handleOpen(
 
   const updated = await store.updateChannel(payload.channelId, (existing) => {
     if (existing) {
-      if (voucher.cumulativeAmount < existing.settledOnChain) {
+      if (voucher.cumulativeAmount <= existing.settledOnChain) {
         throw new VerificationFailedError({
           reason: 'voucher amount is below settled on-chain amount',
         })
       }
 
+      const settledOnChain =
+        onChain.settled > existing.settledOnChain ? onChain.settled : existing.settledOnChain
+      const spent = settledOnChain > existing.spent ? settledOnChain : existing.spent
+
       if (voucher.cumulativeAmount > existing.highestVoucherAmount) {
         return {
           ...existing,
           deposit: onChain.deposit,
+          settledOnChain,
+          spent,
           highestVoucherAmount: voucher.cumulativeAmount,
           highestVoucher: voucher,
           authorizedSigner,
@@ -598,6 +601,8 @@ async function handleOpen(
       return {
         ...existing,
         deposit: onChain.deposit,
+        settledOnChain,
+        spent,
         authorizedSigner,
       }
     }
@@ -605,15 +610,16 @@ async function handleOpen(
       channelId: payload.channelId,
       chainId: methodDetails.chainId,
       escrowContract: methodDetails.escrowContract,
+      closeRequestedAt: onChain.closeRequestedAt,
       payer: onChain.payer,
       payee: onChain.payee,
       token: onChain.token,
       authorizedSigner,
       deposit: onChain.deposit,
-      settledOnChain: 0n,
+      settledOnChain: onChain.settled,
       highestVoucherAmount: voucher.cumulativeAmount,
       highestVoucher: voucher,
-      spent: 0n,
+      spent: onChain.settled,
       units: 0,
       finalized: false,
       createdAt: new Date().toISOString(),
@@ -715,18 +721,30 @@ async function handleVoucher(
   //
   // To guard against the payer initiating a forced close while vouchers
   // are still being accepted, re-query on-chain state when the cache
-  // exceeds the configured staleness TTL.
+  // exceeds the configured staleness TTL (default: 5s).
   const lastVerified = lastOnChainVerified.get(payload.channelId) ?? 0
   const isStale = Date.now() - lastVerified > channelStateTtl
 
-  let cachedOnChain: OnChainChannel
-  if (isStale) {
-    cachedOnChain = await getOnChainChannel(client, methodDetails.escrowContract, payload.channelId)
-    lastOnChainVerified.set(payload.channelId, Date.now())
-  } else {
-    cachedOnChain = {
+  const onChain = await (async () => {
+    if (isStale) {
+      const onChainChannel = await getOnChainChannel(
+        client,
+        methodDetails.escrowContract,
+        payload.channelId,
+      )
+      lastOnChainVerified.set(payload.channelId, Date.now())
+      // Persist closeRequestedAt so the cached path detects force-close
+      // between re-queries.
+      if (onChainChannel.closeRequestedAt !== 0n) {
+        await store.updateChannel(payload.channelId, (current) =>
+          current ? { ...current, closeRequestedAt: onChainChannel.closeRequestedAt } : current,
+        )
+      }
+      return onChainChannel
+    }
+    return {
       finalized: channel.finalized,
-      closeRequestedAt: 0n,
+      closeRequestedAt: channel.closeRequestedAt,
       payer: channel.payer,
       payee: channel.payee,
       token: channel.token,
@@ -734,7 +752,7 @@ async function handleVoucher(
       deposit: channel.deposit,
       settled: channel.settledOnChain,
     }
-  }
+  })()
 
   return verifyAndAcceptVoucher({
     store,
@@ -743,7 +761,7 @@ async function handleVoucher(
     channel,
     channelId: payload.channelId,
     voucher,
-    onChain: cachedOnChain,
+    onChain,
     methodDetails,
   })
 }

package/src/tempo/server/Sse.test.ts

@@ -1,5 +1,6 @@
 import type { Address, Hex } from 'viem'
 import { describe, expect, test } from 'vitest'
+
 import { chainId, escrowContract as escrowContractDefaults } from '../internal/defaults.js'
 import type * as ChannelStore from '../session/ChannelStore.js'
 import { serve, toResponse } from '../session/Sse.js'
@@ -41,6 +42,7 @@ function seedChannel(
     highestVoucher: null,
     spent: 0n,
     units: 0,
+    closeRequestedAt: 0n,
     finalized: false,
     createdAt: new Date().toISOString(),
   }))

package/src/tempo/server/internal/transport.test.ts

@@ -1,6 +1,7 @@
 import { Challenge, Credential } from 'mppx'
 import type { Address, Hex } from 'viem'
 import { describe, expect, test } from 'vitest'
+
 import * as Store from '../../../Store.js'
 import { chainId, escrowContract as escrowContractDefaults } from '../../internal/defaults.js'
 import * as ChannelStore from '../../session/ChannelStore.js'
@@ -31,6 +32,7 @@ function seedChannel(
     highestVoucher: null,
     spent: 0n,
     units: 0,
+    closeRequestedAt: 0n,
     finalized: false,
     createdAt: new Date().toISOString(),
   }))
@@ -262,6 +264,34 @@ describe('sse transport', () => {
     ).toThrow('No SSE context available')
   })
 
+  test('respondReceipt with non-SSE upstream Response still deducts from channel', async () => {
+    const store = memoryStore()
+    await seedChannel(store, 10000000n)
+    const transport = sse({ store })
+
+    transport.getCredential(makeAuthorizedRequest())
+
+    const plainResponse = new Response(JSON.stringify({ content: 'hello' }), {
+      headers: { 'Content-Type': 'application/json' },
+    })
+
+    const response = transport.respondReceipt({
+      receipt: makeReceipt(),
+      response: plainResponse,
+      challengeId,
+    })
+
+    const body = await response.text()
+
+    const channel = await store.getChannel(channelId)
+    expect(channel!.spent).toBe(1000000n)
+    expect(channel!.units).toBe(1)
+
+    expect(JSON.parse(body)).toEqual({ content: 'hello' })
+    expect(response.headers.get('Content-Type')).toBe('application/json')
+    expect(response.headers.get('Payment-Receipt')).toBeTruthy()
+  })
+
   test('poll: true strips waitForUpdate from store', async () => {
     const store = memoryStore()
     ;(store as any).waitForUpdate = async () => {}

package/src/tempo/server/internal/transport.ts

@@ -6,7 +6,7 @@
  * @internal
  */
 import * as Transport from '../../../server/Transport.js'
-import type * as ChannelStore from '../../session/ChannelStore.js'
+import * as ChannelStore from '../../session/ChannelStore.js'
 import * as Sse_core from '../../session/Sse.js'
 
 /** SSE transport with Tempo session controller. */
@@ -89,7 +89,46 @@ export function sse(options: sse.Options & { store: ChannelStore.ChannelStore })
         return Sse_core.toResponse(stream)
       }
 
-      return base.respondReceipt({ receipt, response: response as Response, challengeId })
+      const baseResponse = base.respondReceipt({
+        receipt,
+        response: response as Response,
+        challengeId,
+      })
+
+      // Non-SSE response (e.g. upstream returned JSON instead of event-stream).
+      // Need to deduct tickCost so request isn't free.
+      const ctx = contextMap.get(challengeId)
+      if (ctx) {
+        contextMap.delete(challengeId)
+        const stream = new ReadableStream<Uint8Array>({
+          async start(controller) {
+            // deduction completes before consumer reads
+            await ChannelStore.deductFromChannel(store, ctx.channelId, ctx.tickCost)
+            if (!baseResponse.body) {
+              controller.close()
+              return
+            }
+            const reader = baseResponse.body.getReader()
+            try {
+              while (true) {
+                const { done, value } = await reader.read()
+                if (done) break
+                controller.enqueue(value)
+              }
+            } finally {
+              reader.releaseLock()
+              controller.close()
+            }
+          },
+        })
+        return new Response(stream, {
+          status: baseResponse.status,
+          statusText: baseResponse.statusText,
+          headers: baseResponse.headers,
+        })
+      }
+
+      return baseResponse
     },
   })
 }

package/src/tempo/session/Chain.test.ts

@@ -11,6 +11,7 @@ import {
   topUpChannel,
 } from '~test/tempo/session.js'
 import { accounts, asset, chain, client, fundAccount } from '~test/tempo/viem.js'
+
 import {
   broadcastOpenTransaction,
   broadcastTopUpTransaction,
@@ -242,6 +243,33 @@ describe('on-chain', () => {
       ).rejects.toThrow('open transaction token does not match server currency')
     })
 
+    test('rejects when transaction channelId does not match claimed channelId', async () => {
+      const salt = nextSalt()
+
+      const { serializedTransaction } = await signOpenChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit: 5_000_000n,
+        salt,
+      })
+
+      const fakeChannelId =
+        '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex
+
+      await expect(
+        broadcastOpenTransaction({
+          client,
+          serializedTransaction,
+          escrowContract,
+          channelId: fakeChannelId,
+          recipient,
+          currency,
+        }),
+      ).rejects.toThrow('open transaction does not match claimed channelId')
+    })
+
     test('successful broadcast returns txHash and onChain state', async () => {
       const salt = nextSalt()
       const deposit = 10_000_000n
@@ -313,6 +341,59 @@ describe('on-chain', () => {
       ).rejects.toThrow('fee-sponsored open transaction contains an unauthorized call')
     })
 
+    test('fee-payer: rejects unsigned transaction', async () => {
+      const salt = nextSalt()
+      const deposit = 5_000_000n
+
+      const { channelId, serializedTransaction } = await signOpenChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit,
+        salt,
+      })
+
+      // Strip the sender signature to simulate the POC attack
+      const deserialized = Transaction.deserialize(
+        serializedTransaction as Transaction.TransactionSerializedTempo,
+      )
+      const unsigned = await Transaction.serialize({
+        ...deserialized,
+        signature: undefined,
+        from: undefined,
+      })
+
+      await expect(
+        broadcastOpenTransaction({
+          client,
+          serializedTransaction: unsigned,
+          escrowContract,
+          channelId,
+          recipient,
+          currency,
+          feePayer: accounts[0],
+        }),
+      ).rejects.toThrow('Transaction must be signed by the sender before fee payer co-signing')
+    })
+
+    test('fee-payer: rejects non-Tempo transaction', async () => {
+      const fakeEip1559 =
+        '0x02f8650182a5bf843b9aca00843b9aca008252089400000000000000000000000000000000000000008080c001a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000' as Hex
+
+      await expect(
+        broadcastOpenTransaction({
+          client,
+          serializedTransaction: fakeEip1559,
+          escrowContract,
+          channelId: '0x0000000000000000000000000000000000000000000000000000000000000000' as Hex,
+          recipient,
+          currency,
+          feePayer: accounts[0],
+        }),
+      ).rejects.toThrow('Only Tempo (0x76/0x78) transactions are supported')
+    })
+
     test('duplicate broadcast returns fallback with txHash undefined', async () => {
       const salt = nextSalt()
       const deposit = 5_000_000n
@@ -544,6 +625,70 @@ describe('on-chain', () => {
         }),
       ).rejects.toThrow('fee-sponsored topUp transaction contains an unauthorized call')
     })
+
+    test('fee-payer: rejects unsigned transaction', async () => {
+      const salt = nextSalt()
+      const deposit = 5_000_000n
+      const topUpAmount = 3_000_000n
+
+      const { channelId } = await openChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit,
+        salt,
+      })
+
+      const { serializedTransaction } = await signTopUpChannel({
+        escrow: escrowContract,
+        payer,
+        channelId,
+        token: currency,
+        amount: topUpAmount,
+      })
+
+      // Strip the sender signature to simulate the POC attack
+      const deserialized = Transaction.deserialize(
+        serializedTransaction as Transaction.TransactionSerializedTempo,
+      )
+      const unsigned = await Transaction.serialize({
+        ...deserialized,
+        signature: undefined,
+        from: undefined,
+      })
+
+      await expect(
+        broadcastTopUpTransaction({
+          client,
+          serializedTransaction: unsigned,
+          escrowContract,
+          channelId,
+          currency: asset,
+          declaredDeposit: topUpAmount,
+          previousDeposit: deposit,
+          feePayer: accounts[0],
+        }),
+      ).rejects.toThrow('Transaction must be signed by the sender before fee payer co-signing')
+    })
+
+    test('fee-payer: rejects non-Tempo transaction', async () => {
+      const fakeEip1559 =
+        '0x02f8650182a5bf843b9aca00843b9aca008252089400000000000000000000000000000000000000008080c001a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000' as Hex
+
+      await expect(
+        broadcastTopUpTransaction({
+          client,
+          serializedTransaction: fakeEip1559,
+          escrowContract,
+          channelId: '0x0000000000000000000000000000000000000000000000000000000000000000' as Hex,
+          currency: asset,
+          declaredDeposit: 1_000_000n,
+          previousDeposit: 0n,
+          feePayer: accounts[0],
+        }),
+      ).rejects.toThrow('Only Tempo (0x76/0x78) transactions are supported')
+    })
   })
 
   describe('settleOnChain', () => {

package/src/tempo/session/Chain.ts

@@ -6,7 +6,6 @@ import {
   encodeFunctionData,
   getAbiItem,
   type Hex,
-  isAddressEqual,
   type ReadContractReturnType,
   toFunctionSelector,
 } from 'viem'
@@ -20,13 +19,29 @@ import {
   writeContract,
 } from 'viem/actions'
 import { Transaction } from 'viem/tempo'
+
 import { BadRequestError, ChannelClosedError, VerificationFailedError } from '../../Errors.js'
+import * as TempoAddress from '../internal/address.js'
 import * as defaults from '../internal/defaults.js'
+import { isTempoTransaction } from '../internal/fee-payer.js'
+import * as Channel from './Channel.js'
 import { escrowAbi } from './escrow.abi.js'
 import type { SignedVoucher } from './Types.js'
 
 export { escrowAbi }
 
+/**
+ * Asserts that a deserialized transaction has an existing sender signature —
+ * required before fee payer co-signing to prevent the fee payer from becoming
+ * the sender.
+ */
+function assertSenderSigned(transaction: any): void {
+  if (!transaction.signature || !transaction.from)
+    throw new BadRequestError({
+      reason: 'Transaction must be signed by the sender before fee payer co-signing',
+    })
+}
+
 const UINT128_MAX = 2n ** 128n - 1n
 
 /**
@@ -221,13 +236,21 @@ export async function broadcastOpenTransaction(parameters: {
     waitForConfirmation = true,
   } = parameters
 
+  if (feePayer && !isTempoTransaction(serializedTransaction))
+    throw new BadRequestError({
+      reason: 'Only Tempo (0x76/0x78) transactions are supported',
+    })
+
   const transaction = Transaction.deserialize(
     serializedTransaction as Transaction.TransactionSerializedTempo,
   )
+
+  if (feePayer) assertSenderSigned(transaction)
+
   const calls = transaction.calls ?? []
 
   const openCall = calls.find((call) => {
-    if (!call.to || !isAddressEqual(call.to, escrowContract)) return false
+    if (!call.to || !TempoAddress.isEqual(call.to, escrowContract)) return false
     if (!call.data) return false
     return call.data.slice(0, 10) === escrowOpenSelector
   })
@@ -246,8 +269,9 @@ export async function broadcastOpenTransaction(parameters: {
       }
       const selector = call.data.slice(0, 10)
       const isEscrowOpen =
-        isAddressEqual(call.to, escrowContract) && selector === escrowOpenSelector
-      const isTokenApprove = isAddressEqual(call.to, currency) && selector === erc20ApproveSelector
+        TempoAddress.isEqual(call.to, escrowContract) && selector === escrowOpenSelector
+      const isTokenApprove =
+        TempoAddress.isEqual(call.to, currency) && selector === erc20ApproveSelector
       if (!isEscrowOpen && !isTokenApprove) {
         throw new BadRequestError({
           reason: 'fee-sponsored open transaction contains an unauthorized call',
@@ -257,7 +281,7 @@ export async function broadcastOpenTransaction(parameters: {
   }
 
   const { args: openArgs } = decodeFunctionData({ abi: escrowAbi, data: openCall.data! })
-  const [payee, token, deposit, , authorizedSigner] = openArgs as readonly [
+  const [payee, token, deposit, salt, authorizedSigner] = openArgs as readonly [
     Address,
     Address,
     bigint,
@@ -265,17 +289,33 @@ export async function broadcastOpenTransaction(parameters: {
     Address,
   ]
 
-  if (!isAddressEqual(payee, recipient)) {
+  if (!TempoAddress.isEqual(payee, recipient)) {
     throw new VerificationFailedError({
       reason: 'open transaction payee does not match server recipient',
     })
   }
-  if (!isAddressEqual(token, currency)) {
+  if (!TempoAddress.isEqual(token, currency)) {
     throw new VerificationFailedError({
       reason: 'open transaction token does not match server currency',
     })
   }
 
+  if (!transaction.from) throw new BadRequestError({ reason: 'open transaction has no sender' })
+
+  const derivedChannelId = Channel.computeId({
+    payer: transaction.from as `0x${string}`,
+    payee,
+    token,
+    salt,
+    authorizedSigner,
+    escrowContract,
+    chainId: client.chain!.id,
+  })
+  if (derivedChannelId.toLowerCase() !== channelId.toLowerCase())
+    throw new VerificationFailedError({
+      reason: 'open transaction does not match claimed channelId',
+    })
+
   const resolvedFeeToken =
     transaction.feeToken ?? defaults.currency[client.chain?.id as keyof typeof defaults.currency]
 
@@ -364,13 +404,21 @@ export async function broadcastTopUpTransaction(parameters: {
     feePayer,
   } = parameters
 
+  if (feePayer && !isTempoTransaction(serializedTransaction))
+    throw new BadRequestError({
+      reason: 'Only Tempo (0x76/0x78) transactions are supported',
+    })
+
   const transaction = Transaction.deserialize(
     serializedTransaction as Transaction.TransactionSerializedTempo,
   )
+
+  if (feePayer) assertSenderSigned(transaction)
+
   const calls = transaction.calls ?? []
 
   const topUpCall = calls.find((call) => {
-    if (!call.to || !isAddressEqual(call.to, escrowContract)) return false
+    if (!call.to || !TempoAddress.isEqual(call.to, escrowContract)) return false
     if (!call.data) return false
     return call.data.slice(0, 10) === escrowTopUpSelector
   })
@@ -389,8 +437,9 @@ export async function broadcastTopUpTransaction(parameters: {
       }
       const selector = call.data.slice(0, 10)
       const isEscrowTopUp =
-        isAddressEqual(call.to, escrowContract) && selector === escrowTopUpSelector
-      const isTokenApprove = isAddressEqual(call.to, currency) && selector === erc20ApproveSelector
+        TempoAddress.isEqual(call.to, escrowContract) && selector === escrowTopUpSelector
+      const isTokenApprove =
+        TempoAddress.isEqual(call.to, currency) && selector === erc20ApproveSelector
       if (!isEscrowTopUp && !isTokenApprove) {
         throw new BadRequestError({
           reason: 'fee-sponsored topUp transaction contains an unauthorized call',

package/src/tempo/session/Channel.test.ts

@@ -1,5 +1,6 @@
 import { AbiParameters, Hash } from 'ox'
 import { describe, expect, test } from 'vitest'
+
 import * as Channel from './Channel.js'
 
 describe('computeId', () => {

package/src/tempo/session/ChannelStore.test.ts

@@ -1,5 +1,6 @@
 import type { Address, Hex } from 'viem'
 import { describe, expect, test } from 'vitest'
+
 import * as Store from '../../Store.js'
 import { chainId, escrowContract as escrowContractDefaults } from '../internal/defaults.js'
 import * as ChannelStore from './ChannelStore.js'
@@ -22,6 +23,7 @@ function makeChannel(overrides?: Partial<ChannelStore.State>): ChannelStore.Stat
     highestVoucher: null,
     spent: 0n,
     units: 0,
+    closeRequestedAt: 0n,
     finalized: false,
     createdAt: '2025-01-01T00:00:00.000Z',
     ...overrides,
@@ -239,6 +241,15 @@ describe('ChannelStore.deductFromChannel', () => {
     )
   })
 
+  test('rejects deduction when channel is finalized', async () => {
+    const cs = ChannelStore.fromStore(Store.memory())
+    await seedChannel(cs, { highestVoucherAmount: 10_000_000n, spent: 0n, finalized: true })
+
+    const result = await ChannelStore.deductFromChannel(cs, channelId, 1_000_000n)
+    expect(result.ok).toBe(false)
+    expect(result.channel.spent).toBe(0n)
+  })
+
   test('exact balance succeeds', async () => {
     const cs = ChannelStore.fromStore(Store.memory())
     await seedChannel(cs, { highestVoucherAmount: 1_000_000n, spent: 0n })

package/src/tempo/session/ChannelStore.ts

@@ -1,4 +1,5 @@
 import type { Address, Hex } from 'viem'
+
 import type * as Store from '../../Store.js'
 import type { SignedVoucher } from './Types.js'
 
@@ -27,6 +28,8 @@ export interface State {
   escrowContract: Address
   /** Unique identifier for this payment channel. */
   channelId: Hex
+  /** On-chain timestamp when a force-close was requested (0n if not requested). */
+  closeRequestedAt: bigint
   /** ISO 8601 timestamp when the channel was created. */
   createdAt: string
   /** Current on-chain deposit in the escrow contract. */
@@ -107,6 +110,7 @@ export async function deductFromChannel(
   const channel = await store.updateChannel(channelId, (current) => {
     deducted = false
     if (!current) return null
+    if (current.finalized) return current
     if (current.highestVoucherAmount - current.spent >= amount) {
       deducted = true
       return { ...current, spent: current.spent + amount, units: current.units + 1 }
@@ -165,9 +169,9 @@ export function fromStore(store: Store.Store): ChannelStore {
     )
 
     try {
-      const current = await store.get<State | null>(channelId)
+      const current = (await store.get(channelId)) as State | null
       const next = fn(current)
-      if (next) await store.put(channelId, next)
+      if (next) await store.put(channelId, next as never)
       else await store.delete(channelId)
       return next
     } finally {
@@ -178,7 +182,7 @@ export function fromStore(store: Store.Store): ChannelStore {
 
   const cs: ChannelStore = {
     async getChannel(channelId) {
-      return store.get<State | null>(channelId)
+      return (await store.get(channelId)) as State | null
     },
     async updateChannel(channelId, fn) {
       const result = await update(channelId, fn)