tapimo 0.15.1 → 0.18.1

package/src/internal/EarnVaults.ts

@@ -12,10 +12,24 @@ import { Abis, Addresses } from 'viem/tempo'
 import * as z from 'zod/mini'
 
 import * as Schema from './Schema.js'
+import * as Store from './Store.js'
 import * as Viem from './Viem.js'
 
 /** Zod schemas owned by the Earn vault resolver. */
 export namespace schema {
+  /** Per-vault counterparties recognized by earnings accounting. */
+  export const Earnings = z.strictObject({
+    rewardDistributors: z
+      .array(Schema.Address)
+      .check(
+        z.maxLength(100),
+        z.describe(
+          'Additional dedicated reward distributors, combined with recorded campaign history. Incoming shares count as earnings; exclude spenders and refund handlers.',
+        ),
+        z.meta({ examples: [[]] }),
+      ),
+  })
+
   const access = z
     .strictObject({
       status: z
@@ -244,11 +258,28 @@ export namespace schema {
       ),
     })
     .check(z.describe('Live state resolved from an Earn vault.'))
+
+  /** Schema for cached vault facts reused by later discovery misses. */
+  export const Hint = z
+    .strictObject({
+      assetToken: metadata,
+      engine: Schema.Address.check(z.describe('Engine the facts were read from.')),
+      engineAsset: Schema.Address.check(z.describe('Asset the engine accounts in.')),
+      engineType,
+      shareToken: metadata,
+      syncRedeem: z.boolean().check(z.describe('Whether the engine redeems synchronously.')),
+      venue: z
+        .nullable(Schema.Address)
+        .check(z.describe('Yield venue bound to the engine, or null when it exposes none.')),
+    })
+    .check(z.describe('Cached Earn vault facts, valid while the vault keeps the same engine.'))
 }
 
 /** Live state resolved from an Earn vault. */
 export type Discovery = z.output<typeof schema.Discovery>
 
+type Hint = z.output<typeof schema.Hint>
+
 /** Onchain identity of an Earn vault. */
 export type ResolveInput = z.output<typeof schema.ResolveInput>
 
@@ -401,7 +432,12 @@ export async function resolve(
   const input = parseInput(options.input)
   const include = 'include' in options ? options.include : fullInclude
   const zones = options.zones.filter((zone) => zone.sourceId === input.chainId)
-  return resolveOnchain(options.getClient(input.chainId), { include, input, zones })
+  return resolveOnchain(options.getClient(input.chainId), {
+    hints: options.hints,
+    include,
+    input,
+    zones,
+  })
 }
 
 export declare namespace resolve {
@@ -420,6 +456,8 @@ export declare namespace resolve {
   type Options = {
     /** Resolves the onchain client used to read the vault. */
     getClient: Viem.GetClient
+    /** Cache for vault facts that cut discovery to two round trips; every use is checked against live reads. */
+    hints?: Store.Store | undefined
     /** Chain and vault identity to resolve. */
     input: unknown
     /** Private zones available to Earn routers. */
@@ -566,6 +604,66 @@ export declare namespace resolveZoneRoutes {
   }
 }
 
+/** Discovers a router's configured Zone and first code-bearing parent block. */
+export async function discoverZoneRoute(options: discoverZoneRoute.Options): Promise<ZoneRoute> {
+  const client = options.getClient(options.discovery.chainId)
+  const bindings = await readZoneRouteBindings(client, { earnRouter: options.earnRouter }).catch(
+    (error) => {
+      if (!isMissingOptionalFunctionError(error)) throw error
+      throw new InvalidRegistryError('Earn router does not expose the required bindings.')
+    },
+  )
+  const zone = options.zones.find(
+    (candidate) =>
+      candidate.sourceId === options.discovery.chainId &&
+      deriveZoneId(candidate.id) === bindings.allowedZoneId,
+  )
+  if (!zone) throw new InvalidRegistryError(`Zone ${bindings.allowedZoneId} is not configured.`)
+
+  const tip = await client.getBlockNumber()
+  const codeAt = async (blockNumber: bigint) => {
+    try {
+      return await client.getCode({ address: options.earnRouter, blockNumber })
+    } catch {
+      throw new InvalidRegistryError(
+        'Parent RPC cannot read historical code; configure an archive RPC to add this router.',
+      )
+    }
+  }
+  const tipCode = await codeAt(tip)
+  if (!tipCode || tipCode === '0x')
+    throw new InvalidRegistryError('Earn router has no code on the parent chain.')
+  let lower = 0n
+  let upper = tip
+  while (lower < upper) {
+    const middle = (lower + upper) / 2n
+    const code = await codeAt(middle)
+    if (code && code !== '0x') upper = middle
+    else lower = middle + 1n
+  }
+  if (lower > BigInt(Number.MAX_SAFE_INTEGER))
+    throw new InvalidRegistryError('Earn router deployment block exceeds the supported range.')
+  return {
+    chainId: zone.id,
+    deploymentBlock: Number(lower),
+    earnRouter: options.earnRouter,
+  }
+}
+
+export declare namespace discoverZoneRoute {
+  /** Inputs for discovering one parent-chain Earn router. */
+  type Options = {
+    /** Verified vault bound to the router. */
+    discovery: Discovery
+    /** Parent-chain client resolver. */
+    getClient: Viem.GetClient
+    /** Parent-chain router address. */
+    earnRouter: Address
+    /** Configured private Zones. */
+    zones: readonly Chain[]
+  }
+}
+
 /** Infers the supported engine type from its capability fingerprint. */
 export function classifyEngineType(
   options: classifyEngineType.Options,
@@ -589,9 +687,7 @@ export declare namespace classifyEngineType {
 }
 
 async function resolveOnchain(client: Client, options: resolveOnchain.Options): Promise<Discovery> {
-  const { include, input, zones } = options
-  const includeAccess = include.includes('access')
-  const includeCapabilities = include.includes('capabilities')
+  const { hints, include, input, zones } = options
   const actualChainId = await getChainId(client)
   if (actualChainId === undefined) throw new VerificationError(unavailable())
   if (actualChainId !== input.chainId)
@@ -607,6 +703,41 @@ async function resolveOnchain(client: Client, options: resolveOnchain.Options):
       status: 'unavailable',
     })
 
+  if (!hints) return (await resolveFully(client, { include, input, zones })).discovery
+
+  // The hint is memoized with the full read as its fetch, so request cache
+  // directives, timeouts, and background persistence apply to it.
+  const fresh: Discovery[] = []
+  const readHint = () =>
+    Store.memoize(
+      async () => {
+        const result = await resolveFully(client, { include, input, zones })
+        fresh.push(result.discovery)
+        return result.hint
+      },
+      { key: hintKey(input), store: hints, ttl: hintTtl },
+    )
+  const hint = schema.Hint.safeParse(await readHint())
+  if (fresh[0]) return fresh[0]
+  if (hint.success) {
+    const discovery = await resolveWithHint(client, { hint: hint.data, include, input, zones })
+    if (discovery) return discovery
+  }
+  // A stale or malformed hint is dropped and refilled by a full read.
+  await hints.delete(hintKey(input)).catch(() => {})
+  await readHint()
+  if (fresh[0]) return fresh[0]
+  return (await resolveFully(client, { include, input, zones })).discovery
+}
+
+/** Reads every field from the chain, returning the facts later misses may reuse. */
+async function resolveFully(
+  client: Client,
+  options: resolveFully.Options,
+): Promise<resolveFully.ReturnType> {
+  const { include, input, zones } = options
+  const includeAccess = include.includes('access')
+  const includeCapabilities = include.includes('capabilities')
   const vault = await readVaultBindings(client, input.vaultAddress).catch(async (error) => {
     if (isMissingContractError(error) && !(await client.getCode({ address: input.vaultAddress })))
       throw new NotFoundError(
@@ -642,6 +773,139 @@ async function resolveOnchain(client: Client, options: resolveOnchain.Options):
       readTokenMetadata(client, vault.shareToken),
     ])
   const { asset: engineAsset, venue } = bindings
+  return {
+    discovery: assemble({
+      access,
+      asset,
+      engineAsset,
+      engineType,
+      includeCapabilities,
+      input,
+      routerCapabilities,
+      shareQuote,
+      shareToken,
+      vault,
+      venue,
+      withdrawable,
+    }),
+    hint: {
+      assetToken: { address: vault.asset, ...asset },
+      engine: vault.engine,
+      engineAsset,
+      engineType,
+      shareToken: { address: vault.shareToken, ...shareToken },
+      syncRedeem: vault.capabilities.syncRedeem,
+      venue,
+    },
+  }
+}
+
+declare namespace resolveFully {
+  /** Vault identity, requested fields, and Zones, without a hint cache. */
+  type Options = Omit<resolveOnchain.Options, 'hints'>
+
+  /** A complete discovery and the facts later misses may reuse. */
+  type ReturnType = {
+    /** Discovery resolved entirely from the chain. */
+    discovery: Discovery
+    /** Vault facts to cache for later misses. */
+    hint: Hint
+  }
+}
+
+/** Resolves from a hint in two round trips, or returns `undefined` when the live vault no longer matches it. */
+async function resolveWithHint(
+  client: Client,
+  options: resolveWithHint.Options,
+): Promise<Discovery | undefined> {
+  const { hint, include, input, zones } = options
+  const includeCapabilities = include.includes('capabilities')
+  // Issued in one synchronous block so viem batches them into the vault read's first multicall.
+  const reads = {
+    access: include.includes('access')
+      ? readTransferPolicyId(client, hint.shareToken.address).then((transferPolicyId) =>
+          readAccess(client, transferPolicyId),
+        )
+      : Promise.resolve(undefined),
+    routerCapabilities: includeCapabilities
+      ? readRouterCapabilities(client, { chainId: input.chainId, zones })
+      : Promise.resolve({ deposit: false, redeem: false }),
+    shareQuote: readShareQuote(client, {
+      syncRedeem: hint.syncRedeem,
+      vaultAddress: input.vaultAddress,
+    }),
+    vault: readVaultBindings(client, input.vaultAddress),
+    withdrawable:
+      hint.engineType === 'erc4626' && hint.venue
+        ? readVenueLiquidity(client, { owner: hint.engine, venue: hint.venue })
+        : Promise.resolve(undefined),
+  }
+  // Mark every speculative read handled now; each is still awaited below when used.
+  for (const read of Object.values(reads)) read.catch(() => {})
+  const vault = await reads.vault.catch(() => undefined)
+  // The engine can be migrated; its asset and venue are immutable, so a matching engine proves them.
+  if (
+    !vault ||
+    !isAddressEqual(vault.engine, hint.engine) ||
+    !isAddressEqual(vault.asset, hint.assetToken.address) ||
+    !isAddressEqual(vault.shareToken, hint.shareToken.address) ||
+    vault.capabilities.syncRedeem !== hint.syncRedeem ||
+    classifyEngineType(vault.capabilities) !== hint.engineType
+  )
+    return undefined
+  const [access, routerCapabilities, shareQuote, withdrawable] = await Promise.all([
+    reads.access,
+    reads.routerCapabilities,
+    reads.shareQuote,
+    reads.withdrawable,
+  ])
+  return assemble({
+    access,
+    asset: hint.assetToken,
+    engineAsset: hint.engineAsset,
+    engineType: hint.engineType,
+    includeCapabilities,
+    input,
+    routerCapabilities,
+    shareQuote,
+    shareToken: hint.shareToken,
+    vault,
+    venue: hint.venue,
+    withdrawable,
+  })
+}
+
+declare namespace resolveWithHint {
+  /** Full-read options plus the cached facts to check. */
+  type Options = resolveFully.Options & {
+    /** Cached vault facts, checked against the live vault before use. */
+    hint: Hint
+  }
+}
+
+/** How long cached vault facts live; every use still checks them against the live vault. */
+const hintTtl = 24 * 60 * 60 * 1_000
+
+function hintKey(input: ResolveInput): string {
+  return `earn-vault:hint:v1:${input.chainId}:${input.vaultAddress.toLowerCase()}`
+}
+
+/** Builds and verifies a discovery from its onchain parts. */
+function assemble(options: assemble.Options): Discovery {
+  const {
+    access,
+    asset,
+    engineAsset,
+    engineType,
+    includeCapabilities,
+    input,
+    routerCapabilities,
+    shareQuote,
+    shareToken,
+    vault,
+    venue,
+    withdrawable,
+  } = options
   const assetToken = {
     address: vault.asset,
     currency: asset.currency,
@@ -724,8 +988,39 @@ async function resolveOnchain(client: Client, options: resolveOnchain.Options):
   })
 }
 
+declare namespace assemble {
+  /** Onchain parts of one discovery. */
+  type Options = {
+    /** Share-token access, when requested. */
+    access: Discovery['access'] | undefined
+    /** Asset token metadata. */
+    asset: TokenMetadata
+    /** Asset the engine accounts in, checked against the vault asset. */
+    engineAsset: Address
+    /** Engine type inferred from its capabilities. */
+    engineType: classifyEngineType.ReturnType
+    /** Whether to report vault capabilities. */
+    includeCapabilities: boolean
+    /** Vault identity. */
+    input: ResolveInput
+    /** Private-routing support of the configured Earn router. */
+    routerCapabilities: RouterCapabilities
+    /** Assets returned for the quoted share amount, when the engine can quote. */
+    shareQuote: bigint | undefined
+    /** Share token metadata. */
+    shareToken: TokenMetadata
+    /** Live vault bindings and state. */
+    vault: VaultBindings
+    /** Yield venue bound to the engine, when it exposes one. */
+    venue: Address | null
+    /** Assets the venue would release now, when it reports a limit. */
+    withdrawable: bigint | undefined
+  }
+}
+
 declare namespace resolveOnchain {
   type Options = {
+    hints: Store.Store | undefined
     include: readonly resolve.Include[]
     input: ResolveInput
     zones: readonly Chain[]

package/src/internal/EarnWithdrawals.test.ts

@@ -0,0 +1,315 @@
+import * as EarnWithdrawals from './EarnWithdrawals.js'
+import * as Tidx from './Tidx.js'
+import * as Viem from './Viem.js'
+
+describe('match', () => {
+  test('attributes assets, not shares, and preserves the wallet debit identity', () => {
+    expect(EarnWithdrawals.match(input())).toMatchInlineSnapshot(`
+      [
+        {
+          "assets": 1000000n,
+          "logIndex": 0,
+          "transactionHash": "0xe1089b1668337e65bd642dbe0f3e9d37f379d78243a3a766d9954629e8524d8c",
+        },
+      ]
+    `)
+    const options = input()
+    expect(EarnWithdrawals.match({ ...options, events: [...options.events].reverse() })).toEqual(
+      EarnWithdrawals.match(options),
+    )
+    expect(EarnWithdrawals.match({ ...options, account: options.events[2]!.receiver })).toEqual([])
+  })
+
+  test('rejects missing, mismatched, cross-transaction, or reordered legs', () => {
+    const options = input()
+    for (let index = 0; index < options.events.length; index++) {
+      expect(
+        EarnWithdrawals.match({
+          ...options,
+          events: options.events.filter((_, i) => i !== index),
+        }),
+      ).toEqual([])
+      expect(
+        EarnWithdrawals.match({
+          ...options,
+          events: options.events.map((event, i) =>
+            i === index ? { ...event, shares: event.shares + 1n } : event,
+          ),
+        }),
+      ).toEqual([])
+      expect(
+        EarnWithdrawals.match({
+          ...options,
+          events: options.events.map((event, i) =>
+            i === index ? { ...event, transactionHash: `0x${'bb'.repeat(32)}` as const } : event,
+          ),
+        }),
+      ).toEqual([])
+    }
+    expect(
+      EarnWithdrawals.match({
+        ...options,
+        events: options.events.map((event) => ({ ...event, logIndex: 10 - event.logIndex })),
+      }),
+    ).toEqual([])
+    expect(EarnWithdrawals.match({ ...options, vault: options.account })).toEqual([])
+  })
+
+  test('does not credit shared-funder, duplicate-exit, or refund batches', () => {
+    const options = input()
+    for (const extra of [
+      { ...options.events[0]!, sender: options.events[2]!.receiver, logIndex: 1 },
+      { ...options.events[1]!, receiver: options.account, logIndex: 9 },
+      { ...options.events[2]!, logIndex: 12 },
+    ])
+      expect(EarnWithdrawals.match({ ...options, events: [...options.events, extra] })).toEqual([])
+  })
+
+  test('ignores zero-value share movements without accepting nonzero extra funders', () => {
+    const options = input()
+    const extra = { ...options.events[0]!, logIndex: 1, sender: options.events[2]!.receiver }
+    expect(
+      EarnWithdrawals.match({ ...options, events: [...options.events, { ...extra, shares: 0n }] }),
+    ).toEqual([
+      { assets: 1_000_000n, logIndex: 0, transactionHash: options.events[0]!.transactionHash },
+    ])
+    expect(
+      EarnWithdrawals.match({ ...options, events: [...options.events, { ...extra, shares: 1n }] }),
+    ).toEqual([])
+  })
+})
+
+describe('classify', () => {
+  test('counts gifts to arbitrary recipients and ignores self and zero transfers', () => {
+    const options = input()
+    const transfer = options.events[0]!
+    const gift = { ...transfer, receiver: options.events[2]!.receiver }
+    expect(
+      EarnWithdrawals.classify({
+        ...options,
+        events: [
+          gift,
+          { ...transfer, logIndex: 1, receiver: options.account },
+          { ...transfer, logIndex: 2, shares: 0n },
+        ],
+      }),
+    ).toEqual([
+      {
+        assets: undefined,
+        blockNumber: 39_097_691,
+        logIndex: 0,
+        shares: 499_897n,
+        transactionHash: gift.transactionHash,
+      },
+    ])
+  })
+
+  test.each(['withdrawal', 'request'] as const)('excludes a direct %s exactly once', (kind) => {
+    const options = input()
+    const transfer = { ...options.events[0]!, receiver: options.vault }
+    const exit = { ...options.events[2]!, sender: options.account, kind }
+    expect(EarnWithdrawals.classify({ ...options, events: [transfer, exit] })).toEqual([])
+    const second = { ...transfer, logIndex: 1 }
+    expect(EarnWithdrawals.classify({ ...options, events: [transfer, second, exit] })).toEqual([
+      {
+        assets: undefined,
+        blockNumber: transfer.blockNumber,
+        logIndex: 0,
+        shares: transfer.shares,
+        transactionHash: transfer.transactionHash,
+      },
+    ])
+    expect(
+      EarnWithdrawals.classify({
+        ...options,
+        events: [transfer, second, exit, { ...exit, logIndex: 12 }],
+      }),
+    ).toEqual([])
+    const extra = { ...transfer, logIndex: 11 }
+    expect(EarnWithdrawals.classify({ ...options, events: [extra, exit, transfer] })).toEqual([
+      {
+        assets: undefined,
+        blockNumber: 39_097_691,
+        logIndex: 11,
+        shares: 499_897n,
+        transactionHash: transfer.transactionHash,
+      },
+    ])
+    for (const unmatched of [
+      { ...exit, logIndex: 0 },
+      { ...exit, shares: exit.shares + 1n },
+      { ...exit, transactionHash: `0x${'bb'.repeat(32)}` as const },
+    ])
+      expect(EarnWithdrawals.classify({ ...options, events: [transfer, unmatched] })).toHaveLength(
+        1,
+      )
+  })
+
+  test('values mediated async and ambiguous batches without crediting another funder’s proceeds', () => {
+    const options = input()
+    for (const events of [
+      options.events.map((event) =>
+        event.kind === 'withdrawal' ? { ...event, kind: 'request' as const } : event,
+      ),
+      [
+        ...options.events,
+        { ...options.events[0]!, sender: options.events[2]!.receiver, logIndex: 1 },
+      ],
+      [...options.events, { ...options.events[2]!, logIndex: 12 }],
+    ])
+      expect(EarnWithdrawals.classify({ ...options, events })).toEqual([
+        {
+          assets: undefined,
+          blockNumber: 39_097_691,
+          logIndex: 0,
+          shares: 499_897n,
+          transactionHash: options.events[0]!.transactionHash,
+        },
+      ])
+    expect(EarnWithdrawals.classify(options)[0]?.assets).toBe(1_000_000n)
+  })
+})
+
+describe('value', () => {
+  test('uses each transfer block’s quote and actual proceeds before quotes', async () => {
+    const client = Viem.getClient({ chainId: 4217 })
+    const options = input()
+    const withdrawal = EarnWithdrawals.classify(options)[0]!
+    // Fixed archive observations: 499,897 shares quote to 1,000,001 and 999,963 asset units at these blocks.
+    expect(
+      await EarnWithdrawals.value(client, {
+        vault: options.vault,
+        withdrawals: [
+          { ...withdrawal, assets: undefined },
+          { ...withdrawal, assets: undefined, blockNumber: 39_000_000 },
+          withdrawal,
+        ],
+      }),
+    ).toBe(2_999_964n)
+  })
+
+  test('does not turn an unavailable historical quote into a zero withdrawal', async () => {
+    const client = Viem.getClient({ chainId: 4217 })
+    const options = input()
+    const withdrawal = EarnWithdrawals.classify(options)[0]!
+    expect(
+      await EarnWithdrawals.value(client, {
+        vault: options.account,
+        withdrawals: [{ ...withdrawal, assets: undefined }],
+      }),
+    ).toBeUndefined()
+    expect(
+      await EarnWithdrawals.value(client, { vault: options.account, withdrawals: [withdrawal] }),
+    ).toBe(1_000_000n)
+  })
+})
+
+describe('read', () => {
+  test('reads and values a plain multi-recipient transfer batch without any vault exit', async () => {
+    const tidx = Tidx.getClient({
+      chainId: 4217,
+      tidx: {
+        auth: process.env.TIDX_AUTH,
+        baseUrl: Viem.resolveUrl(process.env.TIDX_URL, 4217) ?? Tidx.url[4217],
+      },
+    })
+    const vault = input().vault
+    const withdrawals = await EarnWithdrawals.read(tidx, {
+      account: '0xa65c6ed737b52543123817977d8d2c0e554bfc2d',
+      blockNumber: 37_539_309,
+      shareToken: '0x20c000000000000000000000baac91f6ca72f768',
+      startBlockNumber: 37_539_308,
+      vault,
+    })
+    expect(
+      withdrawals.map(({ assets, logIndex, shares }) => ({ assets, logIndex, shares })),
+    ).toEqual(
+      [91n, 92n, 181n, 1813n, 313n, 90n, 86n, 72n].map((shares, index) => ({
+        assets: undefined,
+        logIndex: 16 + index,
+        shares,
+      })),
+    )
+    expect(
+      await EarnWithdrawals.value(Viem.getClient({ chainId: 4217 }), { vault, withdrawals }),
+    ).toBe(5467n)
+  })
+
+  test('reads card withdrawals without configuration and respects the block window', async () => {
+    const tidx = Tidx.getClient({
+      chainId: 4217,
+      tidx: {
+        auth: process.env.TIDX_AUTH,
+        baseUrl: Viem.resolveUrl(process.env.TIDX_URL, 4217) ?? Tidx.url[4217],
+      },
+    })
+    const options = {
+      ...input(),
+      blockNumber: 39_097_691,
+      shareToken: '0x20c000000000000000000000baac91f6ca72f768' as const,
+      startBlockNumber: 39_097_690,
+    }
+    expect(await EarnWithdrawals.read(tidx, options)).toEqual([
+      {
+        assets: 1_000_000n,
+        blockNumber: 39_097_691,
+        logIndex: 0,
+        shares: 499_897n,
+        transactionHash: '0xe1089b1668337e65bd642dbe0f3e9d37f379d78243a3a766d9954629e8524d8c',
+      },
+    ])
+    expect(
+      (await EarnWithdrawals.read(tidx, { ...options, vault: options.account }))[0]?.assets,
+    ).toBeUndefined()
+    expect(
+      await EarnWithdrawals.read(tidx, { ...options, startBlockNumber: options.blockNumber }),
+    ).toEqual([])
+    expect(
+      await EarnWithdrawals.read(tidx, { ...options, blockNumber: options.startBlockNumber }),
+    ).toEqual([])
+  })
+})
+
+function input(): EarnWithdrawals.match.Options {
+  const account = '0x504a128461f2ee15b52a9d33812769e8cc31bc0d'
+  const spender = '0x3f58d4356cc5785de7962c274c48a748648fddf1'
+  const vault = '0xd730394f3bb85a4828e35fc5e361dcc9f894fa4f'
+  const transactionHash = '0xe1089b1668337e65bd642dbe0f3e9d37f379d78243a3a766d9954629e8524d8c'
+  // Captured receipt: 499,897 share units redeemed for 1,000,000 asset units, through a distinct receiver.
+  return {
+    account,
+    vault,
+    events: [
+      {
+        assets: 0n,
+        blockNumber: 39_097_691,
+        kind: 'transfer',
+        logIndex: 0,
+        receiver: spender,
+        sender: account,
+        shares: 499_897n,
+        transactionHash,
+      },
+      {
+        assets: 0n,
+        blockNumber: 39_097_691,
+        kind: 'transfer',
+        logIndex: 7,
+        receiver: vault,
+        sender: spender,
+        shares: 499_897n,
+        transactionHash,
+      },
+      {
+        assets: 1_000_000n,
+        blockNumber: 39_097_691,
+        kind: 'withdrawal',
+        logIndex: 10,
+        receiver: '0x39aaffa434a319393c45ba1571bff602086e7808',
+        sender: spender,
+        shares: 499_897n,
+        transactionHash,
+      },
+    ],
+  }
+}