add ObservableQueryIbcPfmTransferV2 to swap queries

Author: piatoss3612

apps/extension/src/pages/main/token-detail/modal.tsx

@@ -86,7 +86,7 @@ export const TokenDetailModal: FunctionComponent<{
     bitcoinQueriesStore,
     priceStore,
     price24HChangesStore,
-    skipQueriesStore,
+    swapQueriesStore,
     uiConfigStore,
   } = useStore();
 
@@ -300,9 +300,9 @@ export const TokenDetailModal: FunctionComponent<{
           }&outCoinMinimalDenom=uusdc&entryPoint=token_detail`
         );
       },
-      disabled: !skipQueriesStore.queryIBCSwap.isSwappableCurrency(
+      disabled: !swapQueriesStore.querySwappable.isSwappableToken(
         chainId,
-        currency
+        currency.coinMinimalDenom
       ),
     },
     {

apps/extension/src/stores/root.tsx

@@ -406,7 +406,7 @@ export class RootStore {
     this.swapQueriesStore = new SwapQueries(
       this.queriesStore.sharedContext,
       this.chainStore,
-      "https://keplr-api-dev.keplr.app"
+      "https://keplr-api-dev.keplr.app" // TODO: change to production URL
     );
     this.starknetQueriesStore = new StarknetQueriesStore(
       this.queriesStore.sharedContext,

apps/hooks-internal/src/ibc-swap/amount.ts

@@ -54,7 +54,7 @@ export class IBCSwapAmountConfig extends AmountConfig {
       [CosmosAccount, CosmwasmAccount]
     >,
     public readonly ethereumAccountStore: EthereumAccountStore,
-    protected readonly skipQueries: SkipQueries,
+    protected readonly skipQueries: SkipQueries, // TODO: replace with swap queries
     initialChainId: string,
     senderConfig: ISenderConfig,
     initialOutChainId: string,

apps/stores-internal/src/swap/chains.ts

@@ -0,0 +1,153 @@
+import {
+  IChainInfoImpl,
+  ObservableQuery,
+  QuerySharedContext,
+} from "@keplr-wallet/stores";
+import { ChainsResponseV2 } from "./types";
+import { computed, makeObservable } from "mobx";
+import { ChainIdHelper } from "@keplr-wallet/cosmos";
+import { computedFn } from "mobx-utils";
+import Joi from "joi";
+import { InternalChainStore } from "../internal";
+import { simpleFetch } from "@keplr-wallet/simple-fetch";
+
+const Schema = Joi.object<ChainsResponseV2>({
+  chains: Joi.array().items(
+    Joi.object({
+      chain_id: Joi.string(),
+      pfm_enabled: Joi.boolean(),
+      supports_memo: Joi.boolean(),
+      chain_type: Joi.string(),
+    }).unknown(true)
+  ),
+}).unknown(true);
+
+export class ObservableQueryChainsV2 extends ObservableQuery<ChainsResponseV2> {
+  constructor(
+    sharedContext: QuerySharedContext,
+    protected readonly chainStore: InternalChainStore,
+    protected readonly skipURL: string
+  ) {
+    super(sharedContext, skipURL, "/v1/swap/chains");
+
+    makeObservable(this);
+  }
+
+  protected override async fetchResponse(
+    abortController: AbortController
+  ): Promise<{ headers: any; data: ChainsResponseV2 }> {
+    const _result = await simpleFetch(this.baseURL, this.url, {
+      signal: abortController.signal,
+      headers: {
+        ...(() => {
+          const res: { authorization?: string } = {};
+          if (process.env["SKIP_API_KEY"]) {
+            res.authorization = process.env["SKIP_API_KEY"];
+          }
+
+          return res;
+        })(),
+      },
+    });
+    const result = {
+      headers: _result.headers,
+      data: _result.data,
+    };
+
+    const validated = Schema.validate(result.data);
+    if (validated.error) {
+      console.log("Failed to validate chains response", validated.error);
+      throw validated.error;
+    }
+
+    return {
+      headers: result.headers,
+      data: validated.value,
+    };
+  }
+
+  @computed
+  get chains(): {
+    chainInfo: IChainInfoImpl;
+    pfmEnabled: boolean;
+    supportsMemo: boolean;
+    chainType: string;
+  }[] {
+    if (!this.response) {
+      return [];
+    }
+
+    return this.response.data.chains
+      .filter((chain) => {
+        const isEVMChain = chain.chain_type === "evm";
+        const chainId = isEVMChain
+          ? `eip155:${chain.chain_id}`
+          : chain.chain_id;
+
+        return this.chainStore.hasChain(chainId);
+      })
+      .filter((chain) => {
+        const isEVMChain = chain.chain_type === "evm";
+        const chainId = isEVMChain
+          ? `eip155:${chain.chain_id}`
+          : chain.chain_id;
+
+        return this.chainStore.isInChainInfosInListUI(chainId);
+      })
+      .map((chain) => {
+        const isEVMChain = chain.chain_type === "evm";
+        const chainId = isEVMChain
+          ? `eip155:${chain.chain_id}`
+          : chain.chain_id;
+
+        return {
+          chainInfo: this.chainStore.getChain(chainId),
+          pfmEnabled: chain.pfm_enabled,
+          supportsMemo: chain.supports_memo ?? false,
+          chainType: chain.chain_type,
+        };
+      });
+  }
+
+  isPFMEnabled = computedFn((chainId: string): boolean => {
+    const chain = this.chains.find((chain) => {
+      return (
+        chain.chainInfo.chainIdentifier ===
+        ChainIdHelper.parse(chainId).identifier
+      );
+    });
+    if (!chain) {
+      return false;
+    }
+
+    return chain.pfmEnabled;
+  });
+
+  isSupportsMemo = computedFn((chainId: string): boolean => {
+    const chain = this.chains.find((chain) => {
+      return (
+        chain.chainInfo.chainIdentifier ===
+        ChainIdHelper.parse(chainId).identifier
+      );
+    });
+    if (!chain) {
+      return false;
+    }
+
+    return chain.supportsMemo;
+  });
+
+  isChainTypeEVM = computedFn((chainId: string): boolean => {
+    const chain = this.chains.find((chain) => {
+      return (
+        chain.chainInfo.chainIdentifier ===
+        ChainIdHelper.parse(chainId).identifier
+      );
+    });
+    if (!chain) {
+      return false;
+    }
+
+    return chain.chainType === "evm";
+  });
+}