mppx 0.6.31 → 0.8.0

package/src/tempo/session/{ChannelStore.test.ts → server/ChannelStore.test.ts}

@@ -1,8 +1,19 @@
 import type { Address, Hex } from 'viem'
-import { describe, expect, test } from 'vp/test'
-
-import * as Store from '../../Store.js'
-import { chainId, escrowContract as escrowContractDefaults } from '../internal/defaults.js'
+import { afterEach, describe, expect, test, vi } from 'vp/test'
+
+import * as Challenge from '../../../Challenge.js'
+import {
+  AmountExceedsDepositError,
+  ChannelNotFoundError,
+  DeltaTooSmallError,
+  VerificationFailedError,
+} from '../../../Errors.js'
+import * as Store from '../../../Store.js'
+import { chainId, escrowContract as escrowContractDefaults } from '../../internal/defaults.js'
+import * as PrecompileChannel from '../precompile/Channel.js'
+import type { SessionSignedVoucher } from '../precompile/Protocol.js'
+import type { SignedVoucher } from '../precompile/Protocol.js'
+import * as Voucher from '../precompile/Voucher.js'
 import * as ChannelStore from './ChannelStore.js'
 
 const channelId = '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex
@@ -12,7 +23,22 @@ const mixedCaseAliasChannelId = lowerCaseAliasChannelId.replace(/[a-f]/g, (chara
   index % 2 === 0 ? character.toUpperCase() : character,
 ) as Hex
 
-function makeChannel(overrides?: Partial<ChannelStore.State>): ChannelStore.State {
+const precompileDescriptor = {
+  payer: '0x0000000000000000000000000000000000000001' as Address,
+  payee: '0x0000000000000000000000000000000000000002' as Address,
+  operator: '0x0000000000000000000000000000000000000005' as Address,
+  token: '0x0000000000000000000000000000000000000003' as Address,
+  salt: `0x${'11'.repeat(32)}` as Hex,
+  authorizedSigner: '0x0000000000000000000000000000000000000004' as Address,
+  expiringNonceHash: `0x${'22'.repeat(32)}` as Hex,
+} satisfies PrecompileChannel.ChannelDescriptor
+
+type PrecompileChannelOverrides = Partial<ChannelStore.BaseState> &
+  ChannelStore.PrecompileBackendState
+
+type ChannelOverrides = Partial<ChannelStore.State> | PrecompileChannelOverrides
+
+function makeChannel(overrides?: ChannelOverrides): ChannelStore.State {
   return {
     channelId,
     payer: '0x0000000000000000000000000000000000000001' as Address,
@@ -30,15 +56,22 @@ function makeChannel(overrides?: Partial<ChannelStore.State>): ChannelStore.Stat
     closeRequestedAt: 0n,
     finalized: false,
     createdAt: '2025-01-01T00:00:00.000Z',
+    backend: 'precompile',
+    operator: precompileDescriptor.operator,
+    salt: precompileDescriptor.salt,
+    expiringNonceHash: precompileDescriptor.expiringNonceHash,
+    descriptor: precompileDescriptor,
     ...overrides,
-  }
+  } as ChannelStore.State
 }
 
 function seedChannel(
   store: ChannelStore.ChannelStore,
-  overrides?: Partial<ChannelStore.State>,
+  overrides?: ChannelOverrides,
 ): Promise<ChannelStore.State | null> {
-  return store.updateChannel(channelId, () => makeChannel(overrides))
+  return store.updateChannel(channelId, () => {
+    return makeChannel(overrides)
+  })
 }
 
 function stripUpdateMethod(store: Store.Store | Store.AtomicStore): Store.Store {
@@ -71,6 +104,10 @@ function sleep(ms: number): Promise<void> {
   return new Promise((r) => setTimeout(r, ms))
 }
 
+afterEach(() => {
+  vi.restoreAllMocks()
+})
+
 // ---------- Store.memory ----------
 
 describe('Store.memory', () => {
@@ -95,6 +132,463 @@ describe('Store.memory', () => {
   })
 })
 
+const stateUpdateChannelId = `0x${'01'.repeat(32)}` as Hex
+const stateUpdateSignature = `0x${'aa'.repeat(65)}` as Hex
+const stateUpdateToken = '0x20c0000000000000000000000000000000000001' as Address
+
+const stateUpdateDescriptor = {
+  payer: '0x0000000000000000000000000000000000000001' as Address,
+  payee: '0x0000000000000000000000000000000000000002' as Address,
+  operator: '0x0000000000000000000000000000000000000000' as Address,
+  token: stateUpdateToken,
+  salt: `0x${'02'.repeat(32)}` as Hex,
+  authorizedSigner: '0x0000000000000000000000000000000000000001' as Address,
+  expiringNonceHash: `0x${'03'.repeat(32)}` as Hex,
+}
+
+function stateUpdateVoucher(cumulativeAmount: bigint): SessionSignedVoucher {
+  return { channelId: stateUpdateChannelId, cumulativeAmount, signature: stateUpdateSignature }
+}
+
+function stateUpdateChannel(overrides: Partial<ChannelStore.State> = {}): ChannelStore.State {
+  return {
+    backend: 'precompile',
+    authorizedSigner: stateUpdateDescriptor.authorizedSigner,
+    chainId: 4217,
+    escrowContract: '0x4D50500000000000000000000000000000000000',
+    channelId: stateUpdateChannelId,
+    closeRequestedAt: 0n,
+    createdAt: '2026-01-01T00:00:00.000Z',
+    deposit: 100n,
+    finalized: false,
+    highestVoucher: stateUpdateVoucher(50n),
+    highestVoucherAmount: 50n,
+    payee: stateUpdateDescriptor.payee,
+    payer: stateUpdateDescriptor.payer,
+    settledOnChain: 10n,
+    spent: 20n,
+    token: stateUpdateToken,
+    units: 2,
+    descriptor: stateUpdateDescriptor,
+    expiringNonceHash: stateUpdateDescriptor.expiringNonceHash,
+    operator: stateUpdateDescriptor.operator,
+    salt: stateUpdateDescriptor.salt,
+    ...overrides,
+  }
+}
+
+describe('ChannelStore state updates', () => {
+  test('keeps the greater bigint value', () => {
+    expect(ChannelStore.keepGreater(10n, 5n)).toBe(10n)
+    expect(ChannelStore.keepGreater(10n, 15n)).toBe(15n)
+  })
+
+  test('keeps the greater close timestamp', () => {
+    expect(ChannelStore.keepGreaterTimestamp(10n, 5)).toBe(10n)
+    expect(ChannelStore.keepGreaterTimestamp(10n, 15)).toBe(15n)
+    expect(ChannelStore.keepGreaterTimestamp(10n, 15n)).toBe(15n)
+  })
+
+  test('merges active on-chain state without decreasing persisted fields', () => {
+    expect(
+      ChannelStore.mergeActiveOnChainState(
+        {
+          closeRequestedAt: 7n,
+          deposit: 100n,
+          settledOnChain: 20n,
+        },
+        {
+          closeRequestedAt: 5,
+          deposit: 90n,
+          settled: 25n,
+        },
+      ),
+    ).toEqual({
+      closeRequestedAt: 7n,
+      deposit: 100n,
+      settledOnChain: 25n,
+    })
+  })
+
+  test('stores a new voucher when it is higher than current state', () => {
+    expect(
+      ChannelStore.resolveHighestVoucher({
+        channelId: stateUpdateChannelId,
+        current: { highestVoucherAmount: 10n, highestVoucher: null },
+        cumulativeAmount: 20n,
+        signature: stateUpdateSignature,
+      }),
+    ).toEqual({
+      highestVoucherAmount: 20n,
+      highestVoucher: {
+        channelId: stateUpdateChannelId,
+        cumulativeAmount: 20n,
+        signature: stateUpdateSignature,
+      },
+    })
+  })
+
+  test('keeps an existing higher voucher', () => {
+    const currentVoucher = stateUpdateVoucher(30n)
+
+    expect(
+      ChannelStore.resolveHighestVoucher({
+        channelId: stateUpdateChannelId,
+        current: { highestVoucherAmount: 30n, highestVoucher: currentVoucher },
+        cumulativeAmount: 20n,
+        signature: stateUpdateSignature,
+      }),
+    ).toEqual({
+      highestVoucherAmount: 30n,
+      highestVoucher: currentVoucher,
+    })
+  })
+
+  test('resolvePrecompileChannelIdentity derives immutable descriptor identity fields', () => {
+    expect(
+      ChannelStore.resolvePrecompileChannelIdentity({
+        authorizedSigner: stateUpdateDescriptor.authorizedSigner,
+        chainId: 4217,
+        channelId: stateUpdateChannelId,
+        descriptor: stateUpdateDescriptor,
+        escrow: '0x4D50500000000000000000000000000000000000',
+        expiringNonceHash: stateUpdateDescriptor.expiringNonceHash,
+      }),
+    ).toEqual({
+      authorizedSigner: stateUpdateDescriptor.authorizedSigner,
+      backend: 'precompile',
+      chainId: 4217,
+      channelId: stateUpdateChannelId,
+      descriptor: stateUpdateDescriptor,
+      escrowContract: '0x4D50500000000000000000000000000000000000',
+      expiringNonceHash: stateUpdateDescriptor.expiringNonceHash,
+      operator: stateUpdateDescriptor.operator,
+      payee: stateUpdateDescriptor.payee,
+      payer: stateUpdateDescriptor.payer,
+      salt: stateUpdateDescriptor.salt,
+      token: stateUpdateToken,
+    })
+  })
+
+  test('openChannelState creates precompile state and preserves higher accepted voucher', () => {
+    const current = stateUpdateChannel({
+      highestVoucherAmount: 80n,
+      highestVoucher: stateUpdateVoucher(80n),
+      spent: 25n,
+    })
+    const next = ChannelStore.openChannelState({
+      authorizedSigner: stateUpdateDescriptor.authorizedSigner,
+      chainId: 4217,
+      channelId: stateUpdateChannelId,
+      current,
+      descriptor: stateUpdateDescriptor,
+      escrow: current.escrowContract,
+      expiringNonceHash: stateUpdateDescriptor.expiringNonceHash,
+      cumulativeAmount: 60n,
+      signature: stateUpdateSignature,
+      state: { deposit: 120n, settled: 15n, closeRequestedAt: 0 },
+    })
+
+    expect(next.backend).toBe('precompile')
+    expect(next.highestVoucherAmount).toBe(80n)
+    expect(next.highestVoucher).toEqual(stateUpdateVoucher(80n))
+    expect(next.deposit).toBe(120n)
+    expect(next.spent).toBe(25n)
+  })
+
+  test('topUpChannelState only increases deposit, settled, and close timestamp', () => {
+    const current = stateUpdateChannel({
+      deposit: 100n,
+      settledOnChain: 30n,
+      closeRequestedAt: 4n,
+    })
+
+    const next = ChannelStore.topUpChannelState({
+      current,
+      state: { deposit: 90n, settled: 20n, closeRequestedAt: 3 },
+    })
+
+    expect(next).toMatchObject({
+      deposit: 100n,
+      settledOnChain: 30n,
+      closeRequestedAt: 4n,
+    })
+  })
+
+  test('acceptVoucherStateUpdate stores newer voucher and reconciles on-chain state', () => {
+    const next = ChannelStore.acceptVoucherStateUpdate({
+      current: stateUpdateChannel(),
+      voucher: stateUpdateVoucher(70n),
+      channelState: { deposit: 120n, settled: 25n, closeRequestedAt: 0 },
+    })
+
+    expect(next.highestVoucherAmount).toBe(70n)
+    expect(next.deposit).toBe(120n)
+    expect(next.settledOnChain).toBe(25n)
+  })
+
+  test('markPendingClose returns max(spent, on-chain settled) as capture amount', () => {
+    const next = ChannelStore.markPendingClose({
+      closeRequestedAt: 11n,
+      cumulativeAmount: 50n,
+      current: stateUpdateChannel({ spent: 20n }),
+      onChainDeposit: 100n,
+      onChainSettled: 30n,
+    })
+
+    expect(next.captureAmount).toBe(30n)
+    expect(next.state?.closeRequestedAt).toBe(11n)
+  })
+
+  test('markPendingClose rejects close voucher below capture amount', () => {
+    expect(() =>
+      ChannelStore.markPendingClose({
+        closeRequestedAt: 11n,
+        cumulativeAmount: 25n,
+        current: stateUpdateChannel({ spent: 20n }),
+        onChainDeposit: 100n,
+        onChainSettled: 30n,
+      }),
+    ).toThrow(VerificationFailedError)
+  })
+
+  test('markPendingClose rejects capture above on-chain deposit', () => {
+    expect(() =>
+      ChannelStore.markPendingClose({
+        closeRequestedAt: 11n,
+        cumulativeAmount: 50n,
+        current: stateUpdateChannel({ spent: 40n }),
+        onChainDeposit: 30n,
+        onChainSettled: 0n,
+      }),
+    ).toThrow(AmountExceedsDepositError)
+  })
+
+  test('resolveCloseCaptureAmount captures max(local spent, on-chain settled)', () => {
+    expect(
+      ChannelStore.resolveCloseCaptureAmount({
+        cumulativeAmount: 50n,
+        onChainDeposit: 100n,
+        onChainSettled: 30n,
+        spent: 20n,
+      }),
+    ).toBe(30n)
+
+    expect(
+      ChannelStore.resolveCloseCaptureAmount({
+        cumulativeAmount: 50n,
+        onChainDeposit: 100n,
+        onChainSettled: 10n,
+        spent: 20n,
+      }),
+    ).toBe(20n)
+  })
+
+  test('resolveCloseCaptureAmount rejects invalid close boundaries', () => {
+    expect(() =>
+      ChannelStore.resolveCloseCaptureAmount({
+        cumulativeAmount: 19n,
+        onChainDeposit: 100n,
+        onChainSettled: 10n,
+        spent: 20n,
+      }),
+    ).toThrow(VerificationFailedError)
+
+    expect(() =>
+      ChannelStore.resolveCloseCaptureAmount({
+        cumulativeAmount: 25n,
+        onChainDeposit: 100n,
+        onChainSettled: 30n,
+        spent: 20n,
+      }),
+    ).toThrow(VerificationFailedError)
+
+    expect(() =>
+      ChannelStore.resolveCloseCaptureAmount({
+        cumulativeAmount: 50n,
+        onChainDeposit: 30n,
+        onChainSettled: 0n,
+        spent: 40n,
+      }),
+    ).toThrow(AmountExceedsDepositError)
+  })
+
+  test('finalizeClosedChannelState closes channel and records newer close voucher', () => {
+    const next = ChannelStore.finalizeClosedChannelState({
+      captureAmount: 60n,
+      channelId: stateUpdateChannelId,
+      cumulativeAmount: 70n,
+      current: stateUpdateChannel({ highestVoucherAmount: 50n, settledOnChain: 20n }),
+      signature: stateUpdateSignature,
+    })
+
+    expect(next).toMatchObject({
+      finalized: true,
+      closeRequestedAt: 0n,
+      deposit: 0n,
+      settledOnChain: 60n,
+      highestVoucherAmount: 70n,
+    })
+    expect(next?.highestVoucher).toEqual(stateUpdateVoucher(70n))
+  })
+})
+
+const voucherAcceptanceEscrow = '0x4D50500000000000000000000000000000000000' as Address
+
+const voucherAcceptanceChallenge = Challenge.from({
+  id: 'challenge-1',
+  realm: 'example.test',
+  method: 'tempo',
+  intent: 'session',
+  request: {
+    amount: '1',
+    currency: stateUpdateToken,
+    recipient: stateUpdateDescriptor.payee,
+    unitType: 'request',
+  },
+})
+
+function voucherAcceptanceVoucher(cumulativeAmount: bigint): SignedVoucher {
+  return {
+    channelId: stateUpdateChannelId,
+    cumulativeAmount,
+    signature: stateUpdateSignature,
+  }
+}
+
+function voucherAcceptanceChannel(overrides: Partial<ChannelStore.State> = {}): ChannelStore.State {
+  return stateUpdateChannel({
+    escrowContract: voucherAcceptanceEscrow,
+    highestVoucher: voucherAcceptanceVoucher(50n),
+    ...overrides,
+  })
+}
+
+function memoryChannelStore(initial: ChannelStore.State | null): ChannelStore.ChannelStore {
+  let state = initial
+  return {
+    async getChannel() {
+      return state
+    },
+    async updateChannel(_channelId, fn) {
+      state = fn(state)
+      return state
+    },
+  }
+}
+
+describe('ChannelStore voucher acceptance', () => {
+  test('loads persisted precompile channels', async () => {
+    const stored = voucherAcceptanceChannel()
+
+    await expect(
+      ChannelStore.loadPrecompileChannel({
+        channelId: stateUpdateChannelId,
+        chainId: 4217,
+        descriptor: stateUpdateDescriptor,
+        escrow: voucherAcceptanceEscrow,
+        store: memoryChannelStore(stored),
+      }),
+    ).resolves.toBe(stored)
+  })
+
+  test('rejects missing and non-precompile channels', async () => {
+    await expect(
+      ChannelStore.loadPrecompileChannel({
+        channelId: stateUpdateChannelId,
+        chainId: 4217,
+        descriptor: stateUpdateDescriptor,
+        escrow: voucherAcceptanceEscrow,
+        store: memoryChannelStore(null),
+      }),
+    ).rejects.toThrow(ChannelNotFoundError)
+
+    await expect(
+      ChannelStore.loadPrecompileChannel({
+        channelId: stateUpdateChannelId,
+        chainId: 4217,
+        descriptor: stateUpdateDescriptor,
+        escrow: voucherAcceptanceEscrow,
+        store: memoryChannelStore(voucherAcceptanceChannel({ backend: 'external' })),
+      }),
+    ).rejects.toThrow(VerificationFailedError)
+  })
+
+  test('accepts a valid voucher and reconciles store state', async () => {
+    vi.spyOn(Voucher, 'verifyVoucher').mockReturnValue(true)
+    const store = memoryChannelStore(
+      voucherAcceptanceChannel({ highestVoucherAmount: 50n, spent: 20n, units: 2 }),
+    )
+
+    const receipt = await ChannelStore.verifyAndAcceptVoucher({
+      challenge: voucherAcceptanceChallenge,
+      channel: (await store.getChannel(stateUpdateChannelId))!,
+      channelState: { deposit: 100n, settled: 10n, closeRequestedAt: 0 },
+      methodDetails: { chainId: 4217, escrowContract: voucherAcceptanceEscrow },
+      minVoucherDelta: 5n,
+      store,
+      voucher: voucherAcceptanceVoucher(70n),
+    })
+
+    expect(receipt).toMatchObject({
+      challengeId: voucherAcceptanceChallenge.id,
+      channelId: stateUpdateChannelId,
+      acceptedCumulative: '70',
+      spent: '20',
+      units: 2,
+    })
+    expect((await store.getChannel(stateUpdateChannelId))?.highestVoucherAmount).toBe(70n)
+  })
+
+  test('returns an idempotent receipt for an already accepted voucher', async () => {
+    vi.spyOn(Voucher, 'verifyVoucher').mockReturnValue(true)
+    const stored = voucherAcceptanceChannel({ highestVoucherAmount: 50n, spent: 30n, units: 4 })
+    const store = memoryChannelStore(stored)
+
+    const receipt = await ChannelStore.verifyAndAcceptVoucher({
+      challenge: voucherAcceptanceChallenge,
+      channel: stored,
+      channelState: { deposit: 100n, settled: 10n, closeRequestedAt: 0 },
+      methodDetails: { chainId: 4217, escrowContract: voucherAcceptanceEscrow },
+      minVoucherDelta: 5n,
+      store,
+      voucher: voucherAcceptanceVoucher(50n),
+    })
+
+    expect(receipt).toMatchObject({ acceptedCumulative: '50', spent: '30', units: 4 })
+    expect((await store.getChannel(stateUpdateChannelId))?.highestVoucherAmount).toBe(50n)
+  })
+
+  test('rejects vouchers beyond deposit or below minimum delta', async () => {
+    vi.spyOn(Voucher, 'verifyVoucher').mockReturnValue(true)
+    const stored = voucherAcceptanceChannel({ highestVoucherAmount: 50n })
+
+    await expect(
+      ChannelStore.verifyAndAcceptVoucher({
+        challenge: voucherAcceptanceChallenge,
+        channel: stored,
+        channelState: { deposit: 60n, settled: 10n, closeRequestedAt: 0 },
+        methodDetails: { chainId: 4217, escrowContract: voucherAcceptanceEscrow },
+        minVoucherDelta: 5n,
+        store: memoryChannelStore(stored),
+        voucher: voucherAcceptanceVoucher(70n),
+      }),
+    ).rejects.toThrow(AmountExceedsDepositError)
+
+    await expect(
+      ChannelStore.verifyAndAcceptVoucher({
+        challenge: voucherAcceptanceChallenge,
+        channel: stored,
+        channelState: { deposit: 100n, settled: 10n, closeRequestedAt: 0 },
+        methodDetails: { chainId: 4217, escrowContract: voucherAcceptanceEscrow },
+        minVoucherDelta: 5n,
+        store: memoryChannelStore(stored),
+        voucher: voucherAcceptanceVoucher(53n),
+      }),
+    ).rejects.toThrow(DeltaTooSmallError)
+  })
+})
+
 // ---------- channelStore ----------
 
 describe('channelStore', () => {
@@ -104,6 +598,15 @@ describe('channelStore', () => {
       expect(await cs.getChannel(channelId)).toBeNull()
     })
 
+    test('rejects malformed channel IDs before store access', async () => {
+      const cs = ChannelStore.fromStore(Store.memory())
+      await expect(cs.getChannel('0x1234' as Hex)).rejects.toThrow('Invalid session channel ID')
+      await expect(cs.updateChannel('not-a-channel-id' as Hex, () => null)).rejects.toThrow(
+        'Invalid session channel ID',
+      )
+      expect(() => ChannelStore.normalizeChannelId('0x1234')).toThrow('Invalid session channel ID')
+    })
+
     test('returns channel after update', async () => {
       const cs = ChannelStore.fromStore(Store.memory())
       const ch = makeChannel()
@@ -117,27 +620,6 @@ describe('channelStore', () => {
       expect(typeof loaded!.createdAt).toBe('string')
     })
 
-    test('prefixes backing store keys when configured', async () => {
-      const rawStore = Store.memory()
-      const cs = ChannelStore.fromStore(Store.from(rawStore, { keyPrefix: 'tenant:' }))
-      await cs.updateChannel(channelId, () => makeChannel())
-
-      expect(await rawStore.get(`tenant:${channelId}`)).not.toBeNull()
-      expect(await rawStore.get(channelId)).toBeNull()
-      expect((await cs.getChannel(channelId))?.channelId).toBe(channelId)
-    })
-
-    test('isolates prefixed store wrappers', async () => {
-      const rawStore = Store.memory()
-      const first = ChannelStore.fromStore(Store.from(rawStore, { keyPrefix: 'tenant-a:' }))
-      const second = ChannelStore.fromStore(Store.from(rawStore, { keyPrefix: 'tenant-b:' }))
-      await first.updateChannel(channelId, () => makeChannel())
-
-      expect(await second.getChannel(channelId)).toBeNull()
-      expect(await rawStore.get(`tenant-a:${channelId}`)).not.toBeNull()
-      expect(await rawStore.get(`tenant-b:${channelId}`)).toBeNull()
-    })
-
     test('treats case-variant channelIds as the same record', async () => {
       const cs = ChannelStore.fromStore(Store.memory())
       await cs.updateChannel(mixedCaseAliasChannelId, () =>
@@ -205,6 +687,31 @@ describe('channelStore', () => {
       expect(loaded!.highestVoucherAmount).toBe(888_888_888n)
       expect(loaded!.spent).toBe(42n)
     })
+
+    test('persists precompile descriptor fields without affecting accounting', async () => {
+      const cs = ChannelStore.fromStore(Store.memory())
+      await seedChannel(cs, {
+        backend: 'precompile',
+        operator: precompileDescriptor.operator,
+        salt: precompileDescriptor.salt,
+        expiringNonceHash: precompileDescriptor.expiringNonceHash,
+        descriptor: precompileDescriptor,
+      })
+
+      const deducted = await ChannelStore.deductFromChannel(cs, channelId, 1_000_000n)
+      expect(deducted.ok).toBe(true)
+
+      const loaded = await cs.getChannel(channelId)
+      expect(ChannelStore.isPrecompileState(loaded!)).toBe(true)
+      if (!ChannelStore.isPrecompileState(loaded!)) throw new Error('expected precompile channel')
+      expect(loaded!.backend).toBe('precompile')
+      expect(loaded!.operator).toBe(precompileDescriptor.operator)
+      expect(loaded!.salt).toBe(precompileDescriptor.salt)
+      expect(loaded!.expiringNonceHash).toBe(precompileDescriptor.expiringNonceHash)
+      expect(loaded!.descriptor).toEqual(precompileDescriptor)
+      expect(loaded!.spent).toBe(1_000_000n)
+      expect(loaded!.units).toBe(1)
+    })
   })
 
   describe('waitForUpdate', () => {