tapimo 0.7.0 → 0.7.2

package/src/internal/EarnVaults.test.ts

@@ -0,0 +1,195 @@
+import { parseAbi } from 'viem'
+import { tempoTestnet } from 'viem/tempo/chains'
+
+import * as Runtime from '../../test/runtime.js'
+import * as TestViem from '../../test/Viem.js'
+import * as Zones from '../apps/Zones.js'
+import * as EarnVaults from './EarnVaults.js'
+import * as Viem from './Viem.js'
+
+const vaultAddress = '0xF4ae63687d6753A78e7f551d2EDA1D0d31A5ea3A'
+
+describe('schema.ResolveInput', () => {
+  test('normalizes the vault address', () => {
+    expect(
+      EarnVaults.schema.ResolveInput.parse({
+        chainId: tempoTestnet.id,
+        vaultAddress,
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "chainId": 42431,
+        "vaultAddress": "0xf4ae63687d6753a78e7f551d2eda1d0d31a5ea3a",
+      }
+    `)
+  })
+
+  test('rejects obsolete resolver fields', () => {
+    const result = EarnVaults.schema.ResolveInput.safeParse({
+      chainId: tempoTestnet.id,
+      vault: vaultAddress,
+      vaultAddress,
+    })
+    expect(result.error?.issues[0]).toMatchInlineSnapshot(`
+      {
+        "code": "unrecognized_keys",
+        "keys": [
+          "vault",
+        ],
+        "message": "Invalid input",
+        "path": [],
+      }
+    `)
+  })
+})
+
+describe('classifyEngineType', () => {
+  test('classifies supported capability fingerprints', () => {
+    expect([
+      EarnVaults.classifyEngineType({ asyncRedeem: false, inKindDeposit: true }),
+      EarnVaults.classifyEngineType({ asyncRedeem: true, inKindDeposit: false }),
+    ]).toMatchInlineSnapshot(`
+      [
+        "erc4626",
+        "veda",
+      ]
+    `)
+  })
+
+  test('leaves ambiguous capability fingerprints unknown', () => {
+    expect([
+      EarnVaults.classifyEngineType({ asyncRedeem: false, inKindDeposit: false }),
+      EarnVaults.classifyEngineType({ asyncRedeem: true, inKindDeposit: true }),
+    ]).toMatchInlineSnapshot(`
+      [
+        null,
+        null,
+      ]
+    `)
+  })
+})
+
+describe('resolve', () => {
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'reads the current Moderato Earn v1 vault',
+    async () => {
+      const getClient = Viem.createGetClient({
+        defaultChainId: tempoTestnet.id,
+        rpc: TestViem.rpc,
+        zones: [Zones.zoneE],
+      })
+      const { instantLiquidity, sharePrice, state, ...discovery } = await EarnVaults.resolve({
+        getClient,
+        input: {
+          chainId: tempoTestnet.id,
+          vaultAddress,
+        },
+        zones: [Zones.zoneE],
+      })
+      expect({
+        depositsPaused: state.depositsPaused,
+        feesActive: state.feesActive,
+        isAccountingAligned: state.isAccountingAligned,
+        openRedeemRequestCount: state.openRedeemRequestCount,
+        pricedPerShare: sharePrice !== null && BigInt(sharePrice) > 0n,
+      }).toMatchInlineSnapshot(`
+        {
+          "depositsPaused": false,
+          "feesActive": true,
+          "isAccountingAligned": true,
+          "openRedeemRequestCount": 0,
+          "pricedPerShare": true,
+        }
+      `)
+
+      expect(discovery).toMatchInlineSnapshot(`
+        {
+          "access": {
+            "status": "allowlisted",
+          },
+          "assetToken": {
+            "address": "0x20c000000000000000000000ff04042ee92fd449",
+            "currency": "USD",
+            "decimals": 6,
+            "name": "Bridge Test PATHUSD",
+            "symbol": "btPATHUSD",
+          },
+          "capabilities": {
+            "asyncRedeem": false,
+            "boundedRedeem": true,
+            "deposit": true,
+            "exactWithdraw": true,
+            "inKindDeposit": true,
+            "privateRouting": false,
+            "redeem": true,
+            "routerSwaps": false,
+          },
+          "chainId": 42431,
+          "engine": {
+            "address": "0xd85fc943333a6cd7c0e3391acd54fc4e572f0baf",
+            "type": "erc4626",
+            "venue": "0xa8b4f0e69cd4b0e56b676343f02acd8c3b355322",
+          },
+          "shareToken": {
+            "address": "0x20c0000000000000000000006d04bb298da7edb2",
+            "currency": "USD",
+            "decimals": 6,
+            "name": "Tempo Earn Live Vault (Earn)",
+            "symbol": "teLIVEE",
+          },
+          "vaultAddress": "0xf4ae63687d6753a78e7f551d2eda1d0d31a5ea3a",
+        }
+      `)
+
+      // Instant liquidity mirrors the venue's own withdrawal limit capped at the
+      // vault's backing, never a restatement of `state.totalAssets`. The pinned
+      // venue exposes no limit view, so the field stays null here.
+      const venue = discovery.engine.venue
+      expect(venue).not.toBeNull()
+      if (!venue) return
+      const withdrawable = await getClient(tempoTestnet.id)
+        .readContract({
+          abi: parseAbi(['function maxWithdraw(address owner) view returns (uint256)']),
+          address: venue,
+          args: [discovery.engine.address],
+          functionName: 'maxWithdraw',
+        })
+        .catch(() => undefined)
+      const backing = BigInt(state.totalAssets)
+      expect([withdrawable === undefined, instantLiquidity]).toStrictEqual([
+        true,
+        withdrawable === undefined
+          ? null
+          : (withdrawable < backing ? withdrawable : backing).toString(),
+      ])
+    },
+    60_000,
+  )
+
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'resolves the same vault without private routing',
+    async () => {
+      const discovery = await EarnVaults.resolve({
+        getClient: Viem.createGetClient({
+          defaultChainId: tempoTestnet.id,
+          rpc: TestViem.rpc,
+        }),
+        input: {
+          chainId: tempoTestnet.id,
+          vaultAddress,
+        },
+        zones: [],
+      })
+      expect({
+        privateRouting: discovery.capabilities.privateRouting,
+        routerSwaps: discovery.capabilities.routerSwaps,
+      }).toMatchInlineSnapshot(`
+        {
+          "privateRouting": false,
+          "routerSwaps": false,
+        }
+      `)
+    },
+    60_000,
+  )
+})