test(compound_v2): cover constructor defaultVtoken fallback chain

compound_v2.ts branches went 45.45% → 69.56%. The CompoundV2Adapter
constructor picks defaultVtoken from contracts via the `??` chain:

  vusdt → vusdc → vbnb → comptroller

Previously only the vusdt rung was hit (every fixture set it). This
commit adds 4 tests reaching into the private `defaultVtoken` field
to assert each rung:

  - vusdc selected when vusdt absent
  - vbnb selected when vusdt + vusdc absent
  - comptroller as last-resort defaultVtoken when no v* entries
    (deliberate so brand-new Venus forks can stand up the adapter
    before fixture data lands; resolveVtoken still fails without a
    cache but the constructor must not)
  - empty contracts {} → constructor throws
    "Missing vToken or comptroller"

Field access is via `(adapter as { defaultVtoken: Address })` rather
than routing through buildSupply, which would otherwise hit
resolveVtoken's RPC fallback and need its own readContract mock for
each test.

Author: Hiksang

ts/packages/defi-protocols/src/lending/compound_v2.test.ts

@@ -391,3 +391,59 @@ describe("CompoundV2Adapter — v1.0.6 utilization unit conversion", () => {
     expect(rates.total_supply).toBe(1_000_000n);
   });
 });
+
+describe("CompoundV2Adapter — constructor defaultVtoken fallback chain", () => {
+  // The constructor picks defaultVtoken from contracts via a `??` chain:
+  //   vusdt → vusdc → vbnb → comptroller
+  // We assert the picked address by reaching into the private field — the
+  // only way to observe each rung without routing through resolveVtoken's
+  // RPC fallback (which would need its own readContract mock).
+  function pickedDefault(adapter: object): Address {
+    return (adapter as { defaultVtoken: Address }).defaultVtoken;
+  }
+
+  it("picks vusdc when vusdt is absent", async () => {
+    const { CompoundV2Adapter } = await import("./compound_v2.js");
+    const entry: ProtocolEntry = {
+      ...makeEntry(),
+      contracts: { vusdc: VUSDC, comptroller: COMPTROLLER },
+    };
+    const adapter = new CompoundV2Adapter(entry, "https://example/bnb");
+    expect(pickedDefault(adapter).toLowerCase()).toBe(VUSDC.toLowerCase());
+  });
+
+  it("picks vbnb when vusdt + vusdc are absent", async () => {
+    const { CompoundV2Adapter } = await import("./compound_v2.js");
+    const entry: ProtocolEntry = {
+      ...makeEntry(),
+      contracts: { vbnb: VBNB, comptroller: COMPTROLLER },
+    };
+    const adapter = new CompoundV2Adapter(entry, "https://example/bnb");
+    expect(pickedDefault(adapter).toLowerCase()).toBe(VBNB.toLowerCase());
+  });
+
+  it("falls back to comptroller as a last-resort defaultVtoken when no v* entries exist", async () => {
+    const { CompoundV2Adapter } = await import("./compound_v2.js");
+    const entry: ProtocolEntry = {
+      ...makeEntry(),
+      // No v* keys at all. The `??` chain settles on comptroller — that's
+      // wonky-but-deliberate so integrators wiring a brand-new Venus fork
+      // can stand the adapter up before fixture data lands. resolveVtoken
+      // will still fail without the cache, but the constructor must not.
+      contracts: { comptroller: COMPTROLLER },
+    };
+    const adapter = new CompoundV2Adapter(entry, "https://example/bnb");
+    expect(pickedDefault(adapter).toLowerCase()).toBe(COMPTROLLER.toLowerCase());
+  });
+
+  it("throws when neither v* nor comptroller is configured", async () => {
+    const { CompoundV2Adapter } = await import("./compound_v2.js");
+    const entry: ProtocolEntry = {
+      ...makeEntry(),
+      contracts: {}, // empty → !vtoken → throws
+    };
+    expect(() => new CompoundV2Adapter(entry, "https://example/bnb")).toThrow(
+      /Missing vToken or comptroller/,
+    );
+  });
+});