@keplr-wallet/stores 0.12.238 → 0.12.239-rc.1

package/src/account/babylon.ts

@@ -0,0 +1,235 @@
+import { AccountSetBase, AccountSetBaseSuper } from "./base";
+import {
+  QueriesSetBase,
+  IQueriesStore,
+  CosmosQueries,
+  BabylonQueries,
+} from "../query";
+import { ChainGetter } from "../chain";
+import { DeepReadonly } from "utility-types";
+import { CosmosAccount } from "./cosmos";
+import { Dec, DecUtils } from "@keplr-wallet/unit";
+import {
+  MsgWrappedBeginRedelegate,
+  MsgWrappedDelegate,
+  MsgWrappedUndelegate,
+} from "@keplr-wallet/proto-types/babylon/epoching/v1/tx";
+import { Bech32Address } from "@keplr-wallet/cosmos";
+import {} from "../query";
+
+export interface BabylonAccount {
+  babylon: BabylonAccountImpl;
+}
+
+export const BabylonAccount = {
+  use(options: {
+    queriesStore: IQueriesStore<CosmosQueries & BabylonQueries>;
+  }): (
+    base: AccountSetBaseSuper & CosmosAccount,
+    chainGetter: ChainGetter,
+    chainId: string
+  ) => BabylonAccount {
+    return (base, chainGetter, chainId) => {
+      return {
+        babylon: new BabylonAccountImpl(
+          base,
+          chainGetter,
+          chainId,
+          options.queriesStore
+        ),
+      };
+    };
+  },
+};
+
+export class BabylonAccountImpl {
+  constructor(
+    protected readonly base: AccountSetBase & CosmosAccount,
+    protected readonly chainGetter: ChainGetter,
+    protected readonly chainId: string,
+    protected readonly queriesStore: IQueriesStore<
+      CosmosQueries & BabylonQueries
+    >
+  ) {}
+
+  makeDelegateTx(amount: string, validatorAddress: string) {
+    Bech32Address.validate(
+      validatorAddress,
+      this.chainGetter.getChain(this.chainId).bech32Config?.bech32PrefixValAddr
+    );
+
+    const currency = this.chainGetter.getChain(this.chainId).stakeCurrency;
+
+    if (!currency) {
+      throw new Error("Stake currency is null");
+    }
+
+    let dec = new Dec(amount);
+    dec = dec.mulTruncate(DecUtils.getPrecisionDec(currency.coinDecimals));
+
+    const msg = {
+      type: "/babylon.epoching.v1.MsgWrappedDelegate",
+      value: {
+        msg: {
+          delegator_address: this.base.bech32Address,
+          validator_address: validatorAddress,
+          amount: {
+            denom: currency.coinMinimalDenom,
+            amount: dec.truncate().toString(),
+          },
+        },
+      },
+    };
+
+    return this.base.cosmos.makeTx(
+      "delegate",
+      {
+        aminoMsgs: [msg],
+        protoMsgs: [
+          {
+            typeUrl: msg.type,
+            value: MsgWrappedDelegate.encode({
+              msg: {
+                delegatorAddress: msg.value.msg.delegator_address,
+                validatorAddress: msg.value.msg.validator_address,
+                amount: msg.value.msg.amount,
+              },
+            }).finish(),
+          },
+        ],
+      },
+      (tx) => {
+        if (tx.code == null || tx.code === 0) {
+          // After succeeding to delegate, refresh the last epoch message list
+          this.queries.babylon.queryLastEpochMsgs.getQuery().fetch();
+        }
+      }
+    );
+  }
+
+  makeUndelegateTx(amount: string, validatorAddress: string) {
+    Bech32Address.validate(
+      validatorAddress,
+      this.chainGetter.getChain(this.chainId).bech32Config?.bech32PrefixValAddr
+    );
+
+    const currency = this.chainGetter.getChain(this.chainId).stakeCurrency;
+
+    if (!currency) {
+      throw new Error("Stake currency is null");
+    }
+
+    let dec = new Dec(amount);
+    dec = dec.mulTruncate(DecUtils.getPrecisionDec(currency.coinDecimals));
+
+    const msg = {
+      type: "/babylon.epoching.v1.MsgWrappedUndelegate",
+      value: {
+        msg: {
+          delegator_address: this.base.bech32Address,
+          validator_address: validatorAddress,
+          amount: {
+            denom: currency.coinMinimalDenom,
+            amount: dec.truncate().toString(),
+          },
+        },
+      },
+    };
+
+    return this.base.cosmos.makeTx(
+      "undelegate",
+      {
+        aminoMsgs: [msg],
+        protoMsgs: [
+          {
+            typeUrl: msg.type,
+            value: MsgWrappedUndelegate.encode({
+              msg: {
+                delegatorAddress: msg.value.msg.delegator_address,
+                validatorAddress: msg.value.msg.validator_address,
+                amount: msg.value.msg.amount,
+              },
+            }).finish(),
+          },
+        ],
+      },
+      (tx) => {
+        if (tx.code == null || tx.code === 0) {
+          // After succeeding to undelegate, refresh the last epoch message list
+          this.queries.babylon.queryLastEpochMsgs.getQuery().fetch();
+        }
+      }
+    );
+  }
+
+  makeBeginRedelegateTx(
+    amount: string,
+    srcValidatorAddress: string,
+    dstValidatorAddress: string
+  ) {
+    Bech32Address.validate(
+      srcValidatorAddress,
+      this.chainGetter.getChain(this.chainId).bech32Config?.bech32PrefixValAddr
+    );
+    Bech32Address.validate(
+      dstValidatorAddress,
+      this.chainGetter.getChain(this.chainId).bech32Config?.bech32PrefixValAddr
+    );
+
+    const currency = this.chainGetter.getChain(this.chainId).stakeCurrency;
+
+    if (!currency) {
+      throw new Error("Stake currency is null");
+    }
+
+    let dec = new Dec(amount);
+    dec = dec.mulTruncate(DecUtils.getPrecisionDec(currency.coinDecimals));
+
+    const msg = {
+      type: "/babylon.epoching.v1.MsgWrappedBeginRedelegate",
+      value: {
+        msg: {
+          delegator_address: this.base.bech32Address,
+          validator_src_address: srcValidatorAddress,
+          validator_dst_address: dstValidatorAddress,
+          amount: {
+            denom: currency.coinMinimalDenom,
+            amount: dec.truncate().toString(),
+          },
+        },
+      },
+    };
+
+    return this.base.cosmos.makeTx(
+      "redelegate",
+      {
+        aminoMsgs: [msg],
+        protoMsgs: [
+          {
+            typeUrl: msg.type,
+            value: MsgWrappedBeginRedelegate.encode({
+              msg: {
+                delegatorAddress: msg.value.msg.delegator_address,
+                validatorSrcAddress: msg.value.msg.validator_src_address,
+                validatorDstAddress: msg.value.msg.validator_dst_address,
+                amount: msg.value.msg.amount,
+              },
+            }).finish(),
+          },
+        ],
+      },
+      (tx) => {
+        if (tx.code == null || tx.code === 0) {
+          // After succeeding to redelegate, refresh the last epoch message list
+          this.queries.babylon.queryLastEpochMsgs.getQuery().fetch();
+        }
+      }
+    );
+  }
+
+  protected get queries(): DeepReadonly<
+    QueriesSetBase & CosmosQueries & BabylonQueries
+  > {
+    return this.queriesStore.get(this.chainId);
+  }
+}

package/src/account/cosmos.ts

@@ -1602,14 +1602,23 @@ export class CosmosAccountImpl {
     dec = dec.mulTruncate(DecUtils.getPrecisionDec(currency.coinDecimals));
 
     const msg = {
-      type: this.msgOpts.delegate.type,
+      type: this.chainId.startsWith("interwoven-")
+        ? "mstaking/MsgDelegate"
+        : this.msgOpts.delegate.type,
       value: {
         delegator_address: this.base.bech32Address,
         validator_address: validatorAddress,
-        amount: {
-          denom: currency.coinMinimalDenom,
-          amount: dec.truncate().toString(),
-        },
+        amount: this.chainId.startsWith("interwoven-")
+          ? [
+              {
+                denom: currency.coinMinimalDenom,
+                amount: dec.truncate().toString(),
+              },
+            ]
+          : {
+              denom: currency.coinMinimalDenom,
+              amount: dec.truncate().toString(),
+            },
       },
     };
 
@@ -1619,11 +1628,15 @@ export class CosmosAccountImpl {
         aminoMsgs: [msg],
         protoMsgs: [
           {
-            typeUrl: "/cosmos.staking.v1beta1.MsgDelegate",
+            typeUrl: this.chainId.startsWith("interwoven-")
+              ? "/initia.mstaking.v1.MsgDelegate"
+              : "/cosmos.staking.v1beta1.MsgDelegate",
             value: MsgDelegate.encode({
               delegatorAddress: msg.value.delegator_address,
               validatorAddress: msg.value.validator_address,
-              amount: msg.value.amount,
+              amount: Array.isArray(msg.value.amount)
+                ? msg.value.amount[0]
+                : msg.value.amount,
             }).finish(),
           },
         ],
@@ -1642,12 +1655,21 @@ export class CosmosAccountImpl {
       (tx) => {
         if (tx.code == null || tx.code === 0) {
           // After succeeding to delegate, refresh the validators and delegations, rewards.
-          this.queries.cosmos.queryValidators
-            .getQueryStatus(BondStatus.Bonded)
-            .fetch();
-          this.queries.cosmos.queryDelegations
-            .getQueryBech32Address(this.base.bech32Address)
-            .fetch();
+          if (this.chainId.startsWith("interwoven-")) {
+            this.queries.cosmos.queryInitiaValidators
+              .getQueryStatus(BondStatus.Bonded)
+              .fetch();
+            this.queries.cosmos.queryInitiaDelegations
+              .getQueryBech32Address(this.base.bech32Address)
+              .fetch();
+          } else {
+            this.queries.cosmos.queryValidators
+              .getQueryStatus(BondStatus.Bonded)
+              .fetch();
+            this.queries.cosmos.queryDelegations
+              .getQueryBech32Address(this.base.bech32Address)
+              .fetch();
+          }
           this.queries.cosmos.queryRewards
             .getQueryBech32Address(this.base.bech32Address)
             .fetch();
@@ -1752,14 +1774,23 @@ export class CosmosAccountImpl {
     dec = dec.mulTruncate(DecUtils.getPrecisionDec(currency.coinDecimals));
 
     const msg = {
-      type: this.msgOpts.undelegate.type,
+      type: this.chainId.startsWith("interwoven-")
+        ? "mstaking/MsgUndelegate"
+        : this.msgOpts.undelegate.type,
       value: {
         delegator_address: this.base.bech32Address,
         validator_address: validatorAddress,
-        amount: {
-          denom: currency.coinMinimalDenom,
-          amount: dec.truncate().toString(),
-        },
+        amount: this.chainId.startsWith("interwoven-")
+          ? [
+              {
+                denom: currency.coinMinimalDenom,
+                amount: dec.truncate().toString(),
+              },
+            ]
+          : {
+              denom: currency.coinMinimalDenom,
+              amount: dec.truncate().toString(),
+            },
       },
     };
 
@@ -1769,11 +1800,15 @@ export class CosmosAccountImpl {
         aminoMsgs: [msg],
         protoMsgs: [
           {
-            typeUrl: "/cosmos.staking.v1beta1.MsgUndelegate",
+            typeUrl: this.chainId.startsWith("interwoven-")
+              ? "/initia.mstaking.v1.MsgUndelegate"
+              : "/cosmos.staking.v1beta1.MsgUndelegate",
             value: MsgUndelegate.encode({
               delegatorAddress: msg.value.delegator_address,
               validatorAddress: msg.value.validator_address,
-              amount: msg.value.amount,
+              amount: Array.isArray(msg.value.amount)
+                ? msg.value.amount[0]
+                : msg.value.amount,
             }).finish(),
           },
         ],
@@ -1792,15 +1827,27 @@ export class CosmosAccountImpl {
       (tx) => {
         if (tx.code == null || tx.code === 0) {
           // After succeeding to unbond, refresh the validators and delegations, unbonding delegations, rewards.
-          this.queries.cosmos.queryValidators
-            .getQueryStatus(BondStatus.Bonded)
-            .fetch();
-          this.queries.cosmos.queryDelegations
-            .getQueryBech32Address(this.base.bech32Address)
-            .fetch();
-          this.queries.cosmos.queryUnbondingDelegations
-            .getQueryBech32Address(this.base.bech32Address)
-            .fetch();
+          if (this.chainId.startsWith("interwoven-")) {
+            this.queries.cosmos.queryInitiaValidators
+              .getQueryStatus(BondStatus.Bonded)
+              .fetch();
+            this.queries.cosmos.queryInitiaDelegations
+              .getQueryBech32Address(this.base.bech32Address)
+              .fetch();
+            this.queries.cosmos.queryInitiaUnbondingDelegations
+              .getQueryBech32Address(this.base.bech32Address)
+              .fetch();
+          } else {
+            this.queries.cosmos.queryValidators
+              .getQueryStatus(BondStatus.Bonded)
+              .fetch();
+            this.queries.cosmos.queryDelegations
+              .getQueryBech32Address(this.base.bech32Address)
+              .fetch();
+            this.queries.cosmos.queryUnbondingDelegations
+              .getQueryBech32Address(this.base.bech32Address)
+              .fetch();
+          }
           this.queries.cosmos.queryRewards
             .getQueryBech32Address(this.base.bech32Address)
             .fetch();
@@ -1833,15 +1880,24 @@ export class CosmosAccountImpl {
     dec = dec.mulTruncate(DecUtils.getPrecisionDec(currency.coinDecimals));
 
     const msg = {
-      type: this.msgOpts.redelegate.type,
+      type: this.chainId.startsWith("interwoven-")
+        ? "mstaking/MsgBeginRedelegate"
+        : this.msgOpts.redelegate.type,
       value: {
         delegator_address: this.base.bech32Address,
         validator_src_address: srcValidatorAddress,
         validator_dst_address: dstValidatorAddress,
-        amount: {
-          denom: currency.coinMinimalDenom,
-          amount: dec.truncate().toString(),
-        },
+        amount: this.chainId.startsWith("interwoven-")
+          ? [
+              {
+                denom: currency.coinMinimalDenom,
+                amount: dec.truncate().toString(),
+              },
+            ]
+          : {
+              denom: currency.coinMinimalDenom,
+              amount: dec.truncate().toString(),
+            },
       },
     };
 
@@ -1851,12 +1907,16 @@ export class CosmosAccountImpl {
         aminoMsgs: [msg],
         protoMsgs: [
           {
-            typeUrl: "/cosmos.staking.v1beta1.MsgBeginRedelegate",
+            typeUrl: this.chainId.startsWith("interwoven-")
+              ? "/initia.mstaking.v1.MsgBeginRedelegate"
+              : "/cosmos.staking.v1beta1.MsgBeginRedelegate",
             value: MsgBeginRedelegate.encode({
               delegatorAddress: msg.value.delegator_address,
               validatorSrcAddress: msg.value.validator_src_address,
               validatorDstAddress: msg.value.validator_dst_address,
-              amount: msg.value.amount,
+              amount: Array.isArray(msg.value.amount)
+                ? msg.value.amount[0]
+                : msg.value.amount,
             }).finish(),
           },
         ],
@@ -1876,12 +1936,21 @@ export class CosmosAccountImpl {
       (tx) => {
         if (tx.code == null || tx.code === 0) {
           // After succeeding to redelegate, refresh the validators and delegations, rewards.
-          this.queries.cosmos.queryValidators
-            .getQueryStatus(BondStatus.Bonded)
-            .fetch();
-          this.queries.cosmos.queryDelegations
-            .getQueryBech32Address(this.base.bech32Address)
-            .fetch();
+          if (this.chainId.startsWith("interwoven-")) {
+            this.queries.cosmos.queryInitiaValidators
+              .getQueryStatus(BondStatus.Bonded)
+              .fetch();
+            this.queries.cosmos.queryInitiaDelegations
+              .getQueryBech32Address(this.base.bech32Address)
+              .fetch();
+          } else {
+            this.queries.cosmos.queryValidators
+              .getQueryStatus(BondStatus.Bonded)
+              .fetch();
+            this.queries.cosmos.queryDelegations
+              .getQueryBech32Address(this.base.bech32Address)
+              .fetch();
+          }
           this.queries.cosmos.queryRewards
             .getQueryBech32Address(this.base.bech32Address)
             .fetch();

package/src/account/index.ts

@@ -8,3 +8,4 @@ export * from "./cosmwasm";
 export * from "./utils";
 export * from "./context";
 export * from "./noble";
+export * from "./babylon";

package/src/query/babylon/epoching/index.ts

@@ -0,0 +1 @@
+export * from "./last-epoch-msgs";

package/src/query/babylon/epoching/last-epoch-msgs.ts

@@ -0,0 +1,55 @@
+import {
+  ObservableChainQuery,
+  ObservableChainQueryMap,
+} from "../../chain-query";
+import { ChainGetter } from "../../../chain";
+import { computed, makeObservable } from "mobx";
+import { QuerySharedContext } from "../../../common";
+import { EpochMessage, LatestEpochMessagesResponse } from "./types";
+
+export class ObservableQueryBabylonLastEpochMsgsInner extends ObservableChainQuery<LatestEpochMessagesResponse> {
+  constructor(
+    sharedContext: QuerySharedContext,
+    chainId: string,
+    chainGetter: ChainGetter
+  ) {
+    super(
+      sharedContext,
+      chainId,
+      chainGetter,
+      "/babylon/epoching/v1/epochs:latest/messages?epoch_count=1"
+    );
+
+    makeObservable(this);
+  }
+
+  @computed
+  get msgs(): EpochMessage[] {
+    if (!this.response || !this.response.data.latest_epoch_msgs) {
+      return [];
+    }
+    return this.response.data.latest_epoch_msgs[0].msgs;
+  }
+}
+
+export class ObservableQueryBabylonLastEpochMsgs extends ObservableChainQueryMap<LatestEpochMessagesResponse> {
+  constructor(
+    sharedContext: QuerySharedContext,
+    chainId: string,
+    chainGetter: ChainGetter
+  ) {
+    super(sharedContext, chainId, chainGetter, () => {
+      return new ObservableQueryBabylonLastEpochMsgsInner(
+        this.sharedContext,
+        this.chainId,
+        this.chainGetter
+      );
+    });
+  }
+
+  getQuery(): ObservableQueryBabylonLastEpochMsgsInner {
+    return this.get(
+      "babylon-last-epoch-msgs"
+    ) as ObservableQueryBabylonLastEpochMsgsInner;
+  }
+}

package/src/query/babylon/epoching/types.ts

@@ -0,0 +1,14 @@
+export interface EpochMessage {
+  tx_id: string;
+  msg_id: string;
+  block_height: string;
+  block_time: string;
+  msg: string;
+}
+
+export interface LatestEpochMessagesResponse {
+  latest_epoch_msgs: {
+    epoch_number: string;
+    msgs: EpochMessage[];
+  }[];
+}

package/src/query/babylon/index.ts

@@ -0,0 +1,2 @@
+export * from "./queries";
+export * from "./epoching";

package/src/query/babylon/queries.ts

@@ -0,0 +1,51 @@
+import { QueriesSetBase } from "../queries";
+import { ChainGetter } from "../../chain";
+import { DeepReadonly } from "utility-types";
+import { QuerySharedContext } from "../../common";
+import { ObservableQueryBabylonLastEpochMsgs } from "./epoching";
+
+export interface BabylonQueries {
+  babylon: BabylonQueriesImpl;
+}
+
+export const BabylonQueries = {
+  use(): (
+    queriesSetBase: QueriesSetBase,
+    sharedContext: QuerySharedContext,
+    chainId: string,
+    chainGetter: ChainGetter
+  ) => BabylonQueries {
+    return (
+      queriesSetBase: QueriesSetBase,
+      sharedContext: QuerySharedContext,
+      chainId: string,
+      chainGetter: ChainGetter
+    ) => {
+      return {
+        babylon: new BabylonQueriesImpl(
+          queriesSetBase,
+          sharedContext,
+          chainId,
+          chainGetter
+        ),
+      };
+    };
+  },
+};
+
+export class BabylonQueriesImpl {
+  public readonly queryLastEpochMsgs: DeepReadonly<ObservableQueryBabylonLastEpochMsgs>;
+
+  constructor(
+    _: QueriesSetBase,
+    sharedContext: QuerySharedContext,
+    chainId: string,
+    chainGetter: ChainGetter
+  ) {
+    this.queryLastEpochMsgs = new ObservableQueryBabylonLastEpochMsgs(
+      sharedContext,
+      chainId,
+      chainGetter
+    );
+  }
+}

package/src/query/cosmos/queries.ts

@@ -28,6 +28,7 @@ import { ObservableQueryFeeMarketGasPrices } from "./feemarket";
 import { ObservableQueryIBCClientStateV2 } from "./ibc/client-state-v2";
 import { ObservableQueryInitiaUnbondingDelegations } from "./staking/initia-unbonding-delegations";
 import { ObservableQueryInitiaDelegations } from "./staking/initia-delegations";
+import { ObservableQueryInitiaValidators } from "./staking/initia-validators";
 
 export interface CosmosQueries {
   cosmos: CosmosQueriesImpl;
@@ -73,6 +74,7 @@ export class CosmosQueriesImpl {
   public readonly queryInitiaUnbondingDelegations: DeepReadonly<ObservableQueryInitiaUnbondingDelegations>;
   public readonly queryValidators: DeepReadonly<ObservableQueryValidators>;
   public readonly queryBabylonBtcDelegationReward: DeepReadonly<ObservableQueryBabylonBtcDelegationReward>;
+  public readonly queryInitiaValidators: DeepReadonly<ObservableQueryInitiaValidators>;
 
   public readonly queryIBCClientState: DeepReadonly<ObservableQueryIBCClientState>;
   public readonly queryIBCClientStateV2: DeepReadonly<ObservableQueryIBCClientStateV2>;
@@ -164,6 +166,11 @@ export class CosmosQueriesImpl {
         chainGetter
       );
 
+    this.queryInitiaValidators = new ObservableQueryInitiaValidators(
+      sharedContext,
+      chainId,
+      chainGetter
+    );
     this.queryIBCClientState = new ObservableQueryIBCClientState(
       sharedContext,
       chainId,