@keplr-wallet/stores 0.13.38 → 0.13.39

package/src/query/cosmos/staking/response-guards.spec.ts

@@ -0,0 +1,414 @@
+import { MemoryKVStore } from "@keplr-wallet/common";
+import { QuerySharedContext, QueryResponse } from "../../../common";
+import { ChainGetter } from "../../../chain";
+import { ObservableQueryDelegationsInner } from "./delegations";
+import { ObservableQueryInitiaDelegationsInner } from "./initia-delegations";
+import { ObservableQueryInitiaUnbondingDelegationsInner } from "./initia-unbonding-delegations";
+import {
+  assertDelegationsResponse,
+  assertRewardsResponse,
+  assertStakingResponseData,
+  assertUnbondingDelegationsResponse,
+  getDelegationResponses,
+  getInitiaDelegationResponses,
+  getInitiaUnbondingResponses,
+  getRewardsResponse,
+  getUnbondingResponses,
+} from "./types";
+
+const stakeCurrency = {
+  coinDenom: "ATOM",
+  coinMinimalDenom: "uatom",
+  coinDecimals: 6,
+};
+
+const chainGetter: ChainGetter = {
+  getModularChain: () =>
+    ({
+      chainId: "cosmoshub-4",
+      type: "cosmos",
+      unwrapped: {
+        type: "cosmos",
+        cosmos: {
+          stakeCurrency,
+        },
+      },
+    } as any),
+  hasModularChain: () => true,
+};
+
+const initiaStakeCurrency = {
+  coinDenom: "INIT",
+  coinMinimalDenom: "uinit",
+  coinDecimals: 6,
+};
+
+const initiaChainGetter: ChainGetter = {
+  getModularChain: () =>
+    ({
+      chainId: "interwoven-1",
+      type: "cosmos",
+      unwrapped: {
+        type: "cosmos",
+        cosmos: {
+          stakeCurrency: initiaStakeCurrency,
+        },
+      },
+    } as any),
+  hasModularChain: () => true,
+};
+
+const initiaDelegationResponse = {
+  delegation_responses: [
+    {
+      delegation: {
+        delegator_address: "init10alvsy3f0a6vsr7ghjh3rtygrhygavsk3tscgz",
+        validator_address: "initvaloper1validator",
+        shares: [
+          {
+            denom: "uinit",
+            amount: "990000.000000000000000000",
+          },
+        ],
+      },
+      balance: [
+        {
+          denom: "uinit",
+          amount: "990000",
+        },
+      ],
+    },
+    {
+      delegation: {
+        delegator_address: "init10alvsy3f0a6vsr7ghjh3rtygrhygavsk3tscgz",
+        validator_address: "initvaloper1validator2",
+        shares: [
+          {
+            denom: "uinit",
+            amount: "200000.000000000000000000",
+          },
+        ],
+      },
+      balance: [
+        {
+          denom: "uinit",
+          amount: "200000",
+        },
+      ],
+    },
+  ],
+};
+
+const initiaUnbondingDelegationResponse = {
+  unbonding_responses: [
+    {
+      delegator_address: "init10alvsy3f0a6vsr7ghjh3rtygrhygavsk3tscgz",
+      validator_address: "initvaloper1validator",
+      entries: [
+        {
+          creation_height: "123",
+          completion_time: "2026-01-01T00:00:00Z",
+          initial_balance: [
+            {
+              denom: "uinit",
+              amount: "300000",
+            },
+          ],
+          balance: [
+            {
+              denom: "uinit",
+              amount: "200000",
+            },
+          ],
+        },
+      ],
+    },
+  ],
+};
+
+class TestDelegationsQuery extends ObservableQueryDelegationsInner {
+  setTestResponse(data: unknown) {
+    this.setResponse({
+      data,
+      staled: false,
+      local: true,
+      timestamp: Date.now(),
+    } as QueryResponse<any>);
+  }
+}
+
+class TestInitiaDelegationsQuery extends ObservableQueryInitiaDelegationsInner {
+  setTestResponse(data: unknown) {
+    this.setResponse({
+      data,
+      staled: false,
+      local: true,
+      timestamp: Date.now(),
+    } as QueryResponse<any>);
+  }
+}
+
+class TestInitiaUnbondingDelegationsQuery extends ObservableQueryInitiaUnbondingDelegationsInner {
+  setTestResponse(data: unknown) {
+    this.setResponse({
+      data,
+      staled: false,
+      local: true,
+      timestamp: Date.now(),
+    } as QueryResponse<any>);
+  }
+}
+
+describe("staking response guards", () => {
+  test("rejects malformed delegation responses", () => {
+    expect(getDelegationResponses("")).toBeUndefined();
+    expect(getDelegationResponses({})).toBeUndefined();
+    expect(
+      getDelegationResponses({
+        delegation_responses: [
+          {
+            delegation: {
+              delegator_address: "cosmos1delegator",
+              validator_address: "cosmosvaloper1validator",
+              shares: "1.0",
+            },
+            balance: {
+              denom: "uatom",
+              amount: "123",
+            },
+          },
+        ],
+      })
+    ).toHaveLength(1);
+
+    expect(() => assertDelegationsResponse("")).toThrow(
+      "Invalid Cosmos staking delegations response"
+    );
+  });
+
+  test("lets known malformed text responses reach the base retry path", () => {
+    const assertResponse = jest.fn(() => {
+      throw new Error("should not validate retryable string responses");
+    });
+
+    expect(() =>
+      assertStakingResponseData(
+        {},
+        "The network connection was lost.",
+        assertResponse
+      )
+    ).not.toThrow();
+    expect(assertResponse).not.toHaveBeenCalled();
+
+    expect(() =>
+      assertStakingResponseData(
+        {
+          get: (key: string) =>
+            key === "content-type" ? "application/json" : "",
+        },
+        '{"delegation_responses":[',
+        assertResponse
+      )
+    ).not.toThrow();
+    expect(assertResponse).not.toHaveBeenCalled();
+  });
+
+  test("still rejects unknown malformed text responses", () => {
+    expect(() =>
+      assertStakingResponseData({}, "<html>bad gateway</html>", (data) =>
+        assertDelegationsResponse(data)
+      )
+    ).toThrow("Invalid Cosmos staking delegations response");
+  });
+
+  test("rejects malformed unbonding delegation responses", () => {
+    expect(getUnbondingResponses("")).toBeUndefined();
+    expect(getUnbondingResponses({})).toBeUndefined();
+    expect(
+      getUnbondingResponses({
+        unbonding_responses: [
+          {
+            delegator_address: "cosmos1delegator",
+            validator_address: "cosmosvaloper1validator",
+            entries: [
+              {
+                creation_height: "1",
+                completion_time: "2026-01-01T00:00:00Z",
+                initial_balance: "123",
+                balance: "123",
+              },
+            ],
+          },
+        ],
+      })
+    ).toHaveLength(1);
+
+    expect(() => assertUnbondingDelegationsResponse("")).toThrow(
+      "Invalid Cosmos staking unbonding delegations response"
+    );
+  });
+
+  test("accepts Initia delegation responses with coin-array shares", () => {
+    expect(getInitiaDelegationResponses(initiaDelegationResponse)).toHaveLength(
+      2
+    );
+
+    expect(
+      getInitiaDelegationResponses({
+        delegation_responses: [
+          {
+            delegation: {
+              delegator_address: "init10alvsy3f0a6vsr7ghjh3rtygrhygavsk3tscgz",
+              validator_address: "initvaloper1validator",
+              shares: [
+                {
+                  denom: "uinit",
+                  amount: 990000,
+                },
+              ],
+            },
+            balance: [
+              {
+                denom: "uinit",
+                amount: "990000",
+              },
+            ],
+          },
+        ],
+      })
+    ).toBeUndefined();
+  });
+
+  test("Initia delegation getters total coin-array balances", () => {
+    const query = new TestInitiaDelegationsQuery(
+      new QuerySharedContext(new MemoryKVStore("test"), {
+        responseDebounceMs: 10,
+      }),
+      "interwoven-1",
+      initiaChainGetter,
+      "init10alvsy3f0a6vsr7ghjh3rtygrhygavsk3tscgz"
+    );
+
+    query.setTestResponse(initiaDelegationResponse);
+
+    expect(query.total?.toCoin()).toEqual({
+      denom: "uinit",
+      amount: "1190000",
+    });
+    expect(query.delegationBalances).toHaveLength(2);
+    expect(query.delegations[0].delegation.shares).toBe(
+      "990000.000000000000000000"
+    );
+  });
+
+  test("accepts Initia unbonding responses with coin-array balances", () => {
+    expect(
+      getInitiaUnbondingResponses(initiaUnbondingDelegationResponse)
+    ).toHaveLength(1);
+
+    expect(
+      getInitiaUnbondingResponses({
+        unbonding_responses: [
+          {
+            delegator_address: "init10alvsy3f0a6vsr7ghjh3rtygrhygavsk3tscgz",
+            validator_address: "initvaloper1validator",
+            entries: [
+              {
+                creation_height: "123",
+                completion_time: "2026-01-01T00:00:00Z",
+                initial_balance: "300000",
+                balance: [
+                  {
+                    denom: "uinit",
+                    amount: "200000",
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      })
+    ).toBeUndefined();
+  });
+
+  test("Initia unbonding getters total and normalize coin-array balances", () => {
+    const query = new TestInitiaUnbondingDelegationsQuery(
+      new QuerySharedContext(new MemoryKVStore("test"), {
+        responseDebounceMs: 10,
+      }),
+      "interwoven-1",
+      initiaChainGetter,
+      "init10alvsy3f0a6vsr7ghjh3rtygrhygavsk3tscgz"
+    );
+
+    query.setTestResponse(initiaUnbondingDelegationResponse);
+
+    expect(query.total?.toCoin()).toEqual({
+      denom: "uinit",
+      amount: "200000",
+    });
+    expect(query.unbondings[0].entries[0].initial_balance).toBe("300000");
+    expect(query.unbondings[0].entries[0].balance).toBe("200000");
+  });
+
+  test("rejects malformed reward responses without coercing values", () => {
+    expect(getRewardsResponse("")).toBeUndefined();
+    expect(
+      getRewardsResponse({
+        rewards: [
+          {
+            validator_address: "cosmosvaloper1validator",
+            reward: [
+              {
+                denom: "uatom",
+                amount: "1.5",
+              },
+            ],
+          },
+        ],
+        total: [
+          {
+            denom: "uatom",
+            amount: "1.5",
+          },
+        ],
+      })
+    ).toBeDefined();
+    expect(
+      getRewardsResponse({
+        rewards: [
+          {
+            validator_address: "cosmosvaloper1validator",
+            reward: [
+              {
+                denom: "uatom",
+                amount: 1.5,
+              },
+            ],
+          },
+        ],
+      })
+    ).toBeUndefined();
+
+    expect(() => assertRewardsResponse("")).toThrow(
+      "Invalid Cosmos distribution rewards response"
+    );
+  });
+
+  test("delegation getters tolerate malformed cached responses", () => {
+    const query = new TestDelegationsQuery(
+      new QuerySharedContext(new MemoryKVStore("test"), {
+        responseDebounceMs: 10,
+      }),
+      "cosmoshub-4",
+      chainGetter,
+      "cosmos1delegator"
+    );
+
+    query.setTestResponse("");
+
+    expect(() => query.total).not.toThrow();
+    expect(query.delegationBalances).toEqual([]);
+    expect(query.delegations).toEqual([]);
+  });
+});

package/src/query/cosmos/staking/rewards.ts

@@ -1,4 +1,9 @@
-import { Rewards } from "./types";
+import {
+  assertRewardsResponse,
+  assertStakingResponseData,
+  getRewardsResponse,
+  Rewards,
+} from "./types";
 import {
   ObservableChainQuery,
   ObservableChainQueryMap,
@@ -45,16 +50,29 @@ export class ObservableQueryRewardsInner extends ObservableChainQuery<Rewards> {
     return this.bech32Address.length > 0;
   }
 
+  protected override async fetchResponse(abortController: AbortController) {
+    const response = await super.fetchResponse(abortController);
+    assertStakingResponseData(
+      response.headers,
+      response.data,
+      assertRewardsResponse
+    );
+    return response;
+  }
+
   @computed
   get rewards(): CoinPretty[] {
     const mcInfo2 = this.chainGetter.getModularChain(this.chainId);
 
-    if (!this.response || !this.response.data.rewards) {
+    const response = this.response
+      ? getRewardsResponse(this.response.data)
+      : undefined;
+    if (!response?.rewards) {
       return [];
     }
 
     const map = new Map<string, CoinPrimitive>();
-    for (const valRewards of this.response.data.rewards) {
+    for (const valRewards of response.rewards) {
       for (const coin of valRewards.reward ?? []) {
         const amount = new Dec(coin.amount).truncate();
         if (!amount.gt(new Int(0))) {
@@ -80,7 +98,10 @@ export class ObservableQueryRewardsInner extends ObservableChainQuery<Rewards> {
     (validatorAddress: string): CoinPretty[] => {
       const mcInfo2 = this.chainGetter.getModularChain(this.chainId);
 
-      const rewards = this.response?.data.rewards?.find((r) => {
+      const response = this.response
+        ? getRewardsResponse(this.response.data)
+        : undefined;
+      const rewards = response?.rewards?.find((r) => {
         return r.validator_address === validatorAddress;
       });
 
@@ -186,7 +207,12 @@ export class ObservableQueryRewardsInner extends ObservableChainQuery<Rewards> {
 
     const result: string[] = [];
 
-    for (const reward of this.response.data.rewards ?? []) {
+    const response = getRewardsResponse(this.response.data);
+    if (!response) {
+      return [];
+    }
+
+    for (const reward of response.rewards ?? []) {
       if (reward.reward) {
         for (const r of reward.reward) {
           const dec = new Dec(r.amount);
@@ -219,7 +245,12 @@ export class ObservableQueryRewardsInner extends ObservableChainQuery<Rewards> {
         return [];
       }
 
-      const rewards = this.response.data.rewards?.slice() ?? [];
+      const response = getRewardsResponse(this.response.data);
+      if (!response) {
+        return [];
+      }
+
+      const rewards = response.rewards?.slice() ?? [];
       rewards.sort((reward1, reward2) => {
         const amount1 = StoreUtils.getBalanceFromCurrency(
           cosmosInfo.stakeCurrency!,
@@ -263,13 +294,17 @@ export class ObservableQueryRewardsInner extends ObservableChainQuery<Rewards> {
 
     const denoms: Set<string> = new Set();
     const mcInfo2 = this.chainGetter.getModularChain(this.chainId);
-    if (response.data.total) {
-      response.data.total.forEach((coin) => {
+    const rewardsResponse = getRewardsResponse(response.data);
+    if (!rewardsResponse) {
+      return;
+    }
+    if (rewardsResponse.total) {
+      rewardsResponse.total.forEach((coin) => {
         denoms.add(coin.denom);
       });
     }
-    if (response.data.rewards) {
-      response.data.rewards.forEach((reward) => {
+    if (rewardsResponse.rewards) {
+      rewardsResponse.rewards.forEach((reward) => {
         if (reward.reward) {
           reward.reward.forEach((r) => {
             denoms.add(r.denom);