@keplr-wallet/stores 0.13.38 → 0.13.39

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

@@ -1,5 +1,9 @@
 import { Coin } from "@keplr-wallet/types";
-import { CoinPrimitive } from "../../../common";
+import {
+  CoinPrimitive,
+  isSuspectedResponseDataWithInvalidValue,
+} from "../../../common";
+import Joi from "joi";
 
 export type Rewards = {
   rewards?: DelegatorReward[] | null;
@@ -37,8 +41,7 @@ export type InitiaDelegation = {
   delegation: {
     delegator_address: string;
     validator_address: string;
-    // Dec
-    shares: string;
+    shares: Coin[];
   };
   balance: {
     denom: string;
@@ -72,11 +75,214 @@ export type InitiaUnbondingDelegation = {
   entries: {
     creation_height: string;
     completion_time: string;
-    initial_balance: string;
+    initial_balance: Coin[];
     balance: Coin[];
   }[];
 };
 
+const validationOptions: Joi.ValidationOptions = {
+  convert: false,
+};
+
+const IntegerStringSchema = Joi.string()
+  .pattern(/^[0-9]+$/)
+  .required();
+const DecimalStringSchema = Joi.string()
+  .pattern(/^[0-9]+(\.[0-9]+)?$/)
+  .required();
+
+const CoinPrimitiveSchema = Joi.object<CoinPrimitive>({
+  denom: Joi.string().required(),
+  amount: IntegerStringSchema,
+}).unknown(true);
+
+const RewardCoinSchema = Joi.object<CoinPrimitive>({
+  denom: Joi.string().required(),
+  amount: DecimalStringSchema,
+}).unknown(true);
+
+const DelegationSchema = Joi.object<Delegation>({
+  delegation: Joi.object({
+    delegator_address: Joi.string().required(),
+    validator_address: Joi.string().required(),
+    shares: Joi.string().required(),
+  })
+    .unknown(true)
+    .required(),
+  balance: Joi.object({
+    denom: Joi.string().required(),
+    amount: IntegerStringSchema,
+  })
+    .unknown(true)
+    .required(),
+}).unknown(true);
+
+const InitiaDelegationSchema = Joi.object<InitiaDelegation>({
+  delegation: Joi.object({
+    delegator_address: Joi.string().required(),
+    validator_address: Joi.string().required(),
+    shares: Joi.array().items(RewardCoinSchema).required(),
+  })
+    .unknown(true)
+    .required(),
+  balance: Joi.array().items(CoinPrimitiveSchema).required(),
+}).unknown(true);
+
+const UnbondingEntrySchema = Joi.object<UnbondingDelegation["entries"][number]>(
+  {
+    creation_height: Joi.string().required(),
+    completion_time: Joi.string().required(),
+    initial_balance: IntegerStringSchema,
+    balance: IntegerStringSchema,
+  }
+).unknown(true);
+
+const UnbondingDelegationSchema = Joi.object<UnbondingDelegation>({
+  delegator_address: Joi.string().required(),
+  validator_address: Joi.string().required(),
+  entries: Joi.array().items(UnbondingEntrySchema).required(),
+}).unknown(true);
+
+const InitiaUnbondingEntrySchema = Joi.object<
+  InitiaUnbondingDelegation["entries"][number]
+>({
+  creation_height: Joi.string().required(),
+  completion_time: Joi.string().required(),
+  initial_balance: Joi.array().items(CoinPrimitiveSchema).required(),
+  balance: Joi.array().items(CoinPrimitiveSchema).required(),
+}).unknown(true);
+
+const InitiaUnbondingDelegationSchema = Joi.object<InitiaUnbondingDelegation>({
+  delegator_address: Joi.string().required(),
+  validator_address: Joi.string().required(),
+  entries: Joi.array().items(InitiaUnbondingEntrySchema).required(),
+}).unknown(true);
+
+const DelegatorRewardSchema = Joi.object<DelegatorReward>({
+  validator_address: Joi.string().required(),
+  reward: Joi.array().items(RewardCoinSchema).allow(null).optional(),
+}).unknown(true);
+
+const DelegationsResponseSchema = Joi.object<Delegations>({
+  delegation_responses: Joi.array().items(DelegationSchema).required(),
+}).unknown(true);
+
+const InitiaDelegationsResponseSchema = Joi.object<InitiaDelegations>({
+  delegation_responses: Joi.array().items(InitiaDelegationSchema).required(),
+}).unknown(true);
+
+const UnbondingDelegationsResponseSchema = Joi.object<UnbondingDelegations>({
+  unbonding_responses: Joi.array().items(UnbondingDelegationSchema).required(),
+}).unknown(true);
+
+const InitiaUnbondingDelegationsResponseSchema =
+  Joi.object<InitiaUnbondingDelegations>({
+    unbonding_responses: Joi.array()
+      .items(InitiaUnbondingDelegationSchema)
+      .required(),
+  }).unknown(true);
+
+const RewardsResponseSchema = Joi.object<Rewards>({
+  rewards: Joi.array().items(DelegatorRewardSchema).allow(null).optional(),
+  total: Joi.array().items(RewardCoinSchema).optional(),
+})
+  .or("rewards", "total")
+  .unknown(true);
+
+function getValidatedResponse<T>(
+  schema: Joi.ObjectSchema<T>,
+  data: unknown
+): T | undefined {
+  const validated = schema.validate(data, validationOptions);
+  if (validated.error) {
+    return;
+  }
+
+  return validated.value;
+}
+
+export function assertStakingResponseData(
+  headers: any,
+  data: unknown,
+  assertResponse: (data: unknown) => void
+): void {
+  if (isSuspectedResponseDataWithInvalidValue(headers, data)) {
+    return;
+  }
+
+  assertResponse(data);
+}
+
+export function getDelegationResponses(
+  data: unknown
+): Delegation[] | undefined {
+  return getValidatedResponse(DelegationsResponseSchema, data)
+    ?.delegation_responses;
+}
+
+export function assertDelegationsResponse(
+  data: unknown
+): asserts data is Delegations {
+  if (!getDelegationResponses(data)) {
+    throw new Error("Invalid Cosmos staking delegations response");
+  }
+}
+
+export function getInitiaDelegationResponses(
+  data: unknown
+): InitiaDelegation[] | undefined {
+  return getValidatedResponse(InitiaDelegationsResponseSchema, data)
+    ?.delegation_responses;
+}
+
+export function assertInitiaDelegationsResponse(
+  data: unknown
+): asserts data is InitiaDelegations {
+  if (!getInitiaDelegationResponses(data)) {
+    throw new Error("Invalid Initia staking delegations response");
+  }
+}
+
+export function getUnbondingResponses(
+  data: unknown
+): UnbondingDelegation[] | undefined {
+  return getValidatedResponse(UnbondingDelegationsResponseSchema, data)
+    ?.unbonding_responses;
+}
+
+export function assertUnbondingDelegationsResponse(
+  data: unknown
+): asserts data is UnbondingDelegations {
+  if (!getUnbondingResponses(data)) {
+    throw new Error("Invalid Cosmos staking unbonding delegations response");
+  }
+}
+
+export function getInitiaUnbondingResponses(
+  data: unknown
+): InitiaUnbondingDelegation[] | undefined {
+  return getValidatedResponse(InitiaUnbondingDelegationsResponseSchema, data)
+    ?.unbonding_responses;
+}
+
+export function assertInitiaUnbondingDelegationsResponse(
+  data: unknown
+): asserts data is InitiaUnbondingDelegations {
+  if (!getInitiaUnbondingResponses(data)) {
+    throw new Error("Invalid Initia staking unbonding delegations response");
+  }
+}
+
+export function getRewardsResponse(data: unknown): Rewards | undefined {
+  return getValidatedResponse(RewardsResponseSchema, data);
+}
+
+export function assertRewardsResponse(data: unknown): asserts data is Rewards {
+  if (!getRewardsResponse(data)) {
+    throw new Error("Invalid Cosmos distribution rewards response");
+  }
+}
+
 export type Validator = {
   operator_address: string;
   consensus_pubkey: {

package/src/query/cosmos/staking/unbonding-delegations.ts

@@ -2,7 +2,13 @@ import {
   ObservableChainQuery,
   ObservableChainQueryMap,
 } from "../../chain-query";
-import { UnbondingDelegation, UnbondingDelegations } from "./types";
+import {
+  assertStakingResponseData,
+  assertUnbondingDelegationsResponse,
+  getUnbondingResponses,
+  UnbondingDelegation,
+  UnbondingDelegations,
+} from "./types";
 import { ChainGetter, requireCosmosInfo } from "../../../chain";
 import { CoinPretty, Int, Dec } from "@keplr-wallet/unit";
 import { computed, makeObservable } from "mobx";
@@ -39,6 +45,16 @@ export class ObservableQueryUnbondingDelegationsInner extends ObservableChainQue
     return this.bech32Address.length > 0;
   }
 
+  protected override async fetchResponse(abortController: AbortController) {
+    const response = await super.fetchResponse(abortController);
+    assertStakingResponseData(
+      response.headers,
+      response.data,
+      assertUnbondingDelegationsResponse
+    );
+    return response;
+  }
+
   @computed
   get total(): CoinPretty | undefined {
     const cosmosInfo = requireCosmosInfo(
@@ -54,8 +70,13 @@ export class ObservableQueryUnbondingDelegationsInner extends ObservableChainQue
       return new CoinPretty(stakeCurrency, new Int(0)).ready(false);
     }
 
+    const unbondingResponses = getUnbondingResponses(this.response.data);
+    if (!unbondingResponses) {
+      return new CoinPretty(stakeCurrency, new Int(0)).ready(false);
+    }
+
     let totalBalance = new Int(0);
-    for (const unbondingDelegation of this.response.data.unbonding_responses) {
+    for (const unbondingDelegation of unbondingResponses) {
       for (const entry of unbondingDelegation.entries) {
         const amount = new Int(entry.balance);
         if (amount.gt(new Int(0))) {
@@ -120,7 +141,12 @@ export class ObservableQueryUnbondingDelegationsInner extends ObservableChainQue
 
     const res: UnbondingDelegation[] = [];
 
-    for (const unbonding of this.response.data.unbonding_responses) {
+    const unbondingResponses = getUnbondingResponses(this.response.data);
+    if (!unbondingResponses) {
+      return [];
+    }
+
+    for (const unbonding of unbondingResponses) {
       const u = {
         ...unbonding,
       };