@keplr-wallet/stores 0.12.299 → 0.12.300-rc.0

package/src/chain/base.ts

@@ -594,6 +594,25 @@ export class ModularChainInfoImpl<M extends ModularChainInfo = ModularChainInfo>
   protected registeredStarkentCurrencies: ERC20Currency[] = [];
   @observable.shallow
   protected registeredBitcoinCurrencies: AppCurrency[] = [];
+  @observable.shallow
+  protected registeredEvmCurrencies: AppCurrency[] = [];
+
+  @observable.shallow
+  protected registeredCurrenciesNoReaction: AppCurrency[] = [];
+
+  @computed
+  protected get unknownDenomMap(): Map<
+    string,
+    { denom: string; reaction: boolean }
+  > {
+    return new Map();
+  }
+
+  @observable.shallow
+  protected registrationInProgressCurrencyMap: Map<string, boolean> = new Map();
+
+  @observable.shallow
+  protected availableModules: ChainInfoModule[];
 
   constructor(
     embedded: M,
@@ -602,12 +621,23 @@ export class ModularChainInfoImpl<M extends ModularChainInfo = ModularChainInfo>
     }
   ) {
     this._embedded = embedded;
+    this.availableModules = this.detectAvailableModules();
 
     makeObservable(this);
 
     keepAlive(this, "cosmosCurrencyMap");
     keepAlive(this, "starknetCurrencyMap");
     keepAlive(this, "bitcoinCurrencyMap");
+    keepAlive(this, "evmCurrencyMap");
+  }
+
+  protected detectAvailableModules(): ChainInfoModule[] {
+    const modules: ChainInfoModule[] = [];
+    if ("bitcoin" in this._embedded) modules.push("bitcoin");
+    if ("starknet" in this._embedded) modules.push("starknet");
+    if ("evm" in this._embedded) modules.push("evm");
+    if ("cosmos" in this._embedded) modules.push("cosmos");
+    return modules;
   }
 
   get embedded(): M {
@@ -617,13 +647,47 @@ export class ModularChainInfoImpl<M extends ModularChainInfo = ModularChainInfo>
   @action
   setEmbeddedModularChainInfo(embedded: M) {
     this._embedded = embedded;
+    this.availableModules = this.detectAvailableModules();
   }
 
   get chainId(): string {
     return this._embedded.chainId;
   }
 
-  getCurrencies(module: ChainInfoModule): AppCurrency[] {
+  get stakeCurrency(): Currency | undefined {
+    return "cosmos" in this._embedded
+      ? this._embedded.cosmos.stakeCurrency
+      : undefined;
+  }
+
+  get feeCurrencies(): FeeCurrency[] | undefined {
+    if ("cosmos" in this._embedded) {
+      return this._embedded.cosmos.feeCurrencies;
+    }
+    if ("evm" in this._embedded) {
+      return this._embedded.evm.feeCurrencies;
+    }
+    if ("starknet" in this._embedded) {
+      const feeContractAddress = this._embedded.starknet.strkContractAddress;
+      const feeCurrency = this.getCurrenciesByModule("starknet").find(
+        (cur) => cur.coinMinimalDenom === `erc20:${feeContractAddress}`
+      );
+      if (feeCurrency) {
+        return [feeCurrency];
+      }
+    }
+    if ("bitcoin" in this._embedded) {
+      return [this._embedded.bitcoin.currencies[0]];
+    }
+  }
+
+  getCurrencies(): AppCurrency[] {
+    return this.availableModules
+      .map((module) => this.getCurrenciesByModule(module))
+      .flat();
+  }
+
+  getCurrenciesByModule(module: ChainInfoModule): AppCurrency[] {
     switch (module) {
       case "cosmos":
         if (!("cosmos" in this._embedded)) {
@@ -649,12 +713,569 @@ export class ModularChainInfoImpl<M extends ModularChainInfo = ModularChainInfo>
         return this._embedded.bitcoin.currencies.concat(
           this.registeredBitcoinCurrencies
         );
+      case "evm":
+        if (!("evm" in this._embedded)) {
+          throw new Error(
+            `No evm native module for this chain: ${this.chainId}`
+          );
+        }
+
+        return this._embedded.evm.currencies.concat(
+          this.registeredEvmCurrencies
+        );
 
       default:
         throw new Error(`Unknown module: ${module}`);
     }
   }
 
+  /**
+   * Currency를 반환한다.
+   * 만약 해당 Currency가 없다면 unknownDenomMap에 추가한다.
+   * @param coinMinimalDenom
+   */
+  findCurrency(coinMinimalDenom: string): AppCurrency | undefined {
+    const normalizedDenom = DenomHelper.normalizeDenom(coinMinimalDenom);
+
+    const currency = this.findCurrencyByModule(normalizedDenom);
+    if (currency) {
+      return currency;
+    }
+
+    this.availableModules.forEach((module) => {
+      // 동적으로 토큰을 발견하고 등록하는 절차는 cosmos, evm 모듈에서만 지원
+      if (module === "cosmos" || module === "evm") {
+        this.addUnknownDenomsImpl({
+          module,
+          coinMinimalDenoms: [normalizedDenom],
+          reaction: true,
+        });
+      }
+    });
+
+    // Unknown denom can be registered synchronously in some cases.
+    // For this case, re-try to get currency.
+    return this.findCurrencyByModule(normalizedDenom);
+  }
+
+  findCurrencyByModule(denom: string) {
+    for (const module of this.availableModules) {
+      const currency = this.getCurrencyMapByModule(module).get(denom);
+
+      if (currency) {
+        return currency;
+      }
+
+      if (module === "cosmos" || module === "evm") {
+        const noReactionCurrency = this.currencyMapNoReaction.get(denom);
+        if (noReactionCurrency) {
+          return noReactionCurrency;
+        }
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * findCurrency와 비슷하지만 해당하는 currency가 존재하지 않을 경우 raw currency를 반환한다.
+   * @param coinMinimalDenom
+   */
+  forceFindCurrency(coinMinimalDenom: string): AppCurrency {
+    const normalizedCoinMinimalDenom =
+      DenomHelper.normalizeDenom(coinMinimalDenom);
+
+    const currency = this.findCurrency(coinMinimalDenom);
+
+    if (currency) {
+      return currency;
+    }
+
+    return this.getRawCurrency(normalizedCoinMinimalDenom);
+  }
+
+  /**
+   * 최적화를 위해 reaction 없이 currency를 조회한다.
+   * 현재는 IBC asset에서만 사용되고 있어 Cosmos 모듈만 지원한다.
+   * @param coinMinimalDenom
+   */
+  findCurrencyWithoutReaction(
+    coinMinimalDenom: string
+  ): AppCurrency | undefined {
+    const normalizedCoinMinimalDenom =
+      DenomHelper.normalizeDenom(coinMinimalDenom);
+
+    const currency = this.findCurrencyByModule(normalizedCoinMinimalDenom);
+
+    if (currency) {
+      return currency;
+    }
+
+    this.availableModules.forEach((module) => {
+      if (module === "cosmos" || module === "evm") {
+        this.addUnknownDenomsImpl({
+          module,
+          coinMinimalDenoms: [normalizedCoinMinimalDenom],
+          reaction: false,
+        });
+      }
+    });
+
+    // Unknown denom can be registered synchronously in some cases.
+    // For this case, re-try to get currency.
+    return this.findCurrencyByModule(normalizedCoinMinimalDenom);
+  }
+
+  findCurrencyAsync(
+    coinMinimalDenom: string
+  ): Promise<AppCurrency | undefined> {
+    const normalizedCoinMinimalDenom =
+      DenomHelper.normalizeDenom(coinMinimalDenom);
+
+    const currency = this.findCurrencyByModule(normalizedCoinMinimalDenom);
+    if (currency) {
+      return Promise.resolve(currency);
+    }
+
+    this.availableModules.forEach((module) => {
+      if (module === "cosmos" || module === "evm") {
+        this.addUnknownDenomsImpl({
+          module,
+          coinMinimalDenoms: [normalizedCoinMinimalDenom],
+          reaction: true,
+        });
+      }
+    });
+
+    let disposal: IReactionDisposer | undefined;
+
+    return new Promise<AppCurrency | undefined>((resolve) => {
+      disposal = autorun(() => {
+        const registration = this.registrationInProgressCurrencyMap.get(
+          normalizedCoinMinimalDenom
+        );
+        if (!registration) {
+          const result = this.findCurrencyByModule(normalizedCoinMinimalDenom);
+          resolve(result);
+        }
+      });
+    }).finally(() => {
+      if (disposal) {
+        disposal();
+      }
+    });
+  }
+
+  forceFindCurrencyWithoutReaction(coinMinimalDenom: string): AppCurrency {
+    const normalizedCoinMinimalDenom =
+      DenomHelper.normalizeDenom(coinMinimalDenom);
+
+    const currency = this.findCurrencyWithoutReaction(
+      normalizedCoinMinimalDenom
+    );
+    if (currency) {
+      return currency;
+    }
+
+    return this.getRawCurrency(normalizedCoinMinimalDenom);
+  }
+
+  /**
+   * raw currency를 반환한다. ref을 유지하기 위해서 cache를 사용한다.
+   */
+  protected getRawCurrency(denom: string): AppCurrency {
+    if (forceFindCurrencyCache.has(denom)) {
+      return forceFindCurrencyCache.get(denom)!;
+    }
+
+    const currency = {
+      coinMinimalDenom: denom,
+      coinDenom: denom,
+      coinDecimals: 0,
+    };
+
+    forceFindCurrencyCache.set(denom, currency);
+
+    return currency;
+  }
+
+  addUnknownDenoms({
+    module,
+    coinMinimalDenoms,
+  }: {
+    module: ChainInfoModule;
+    coinMinimalDenoms: string[];
+  }) {
+    this.addUnknownDenomsImpl({
+      module,
+      coinMinimalDenoms,
+      reaction: true,
+    });
+  }
+
+  addUnknownDenomsWithoutReaction({
+    module,
+    coinMinimalDenoms,
+  }: {
+    module: ChainInfoModule;
+    coinMinimalDenoms: string[];
+  }) {
+    this.addUnknownDenomsImpl({
+      module,
+      coinMinimalDenoms,
+      reaction: false,
+    });
+  }
+
+  /**
+   * 해당되는 denom의 currency를 모를 때 이 메소드를 사용해서 등록을 요청할 수 있다.
+   *
+   * - balance 쿼리 결과 등에서 모르는 denom이 나타날 때
+   * - IBC denom을 동적으로 등록해야 할 때
+   * ---
+   * - action 데코레이터가 사용되지 않은 이유: action 내부에서 autorun을 생성하면, autorun의 첫 실행이 action이 끝날 때까지 지연된다.
+   *   autorun을 사용하는 startCurrencyRegistration 내부에서 불필요한 지연이 발생할 수 있어 action 없이 구현하여 autorun을 즉시 실행한다.
+   *   하지만 이 메소드를 action 안에서 호출하게 되는 경우가 있다면 여전히 즉시 실행되지 않으므로 고려가 필요하다.
+   */
+  protected addUnknownDenomsImpl({
+    module,
+    coinMinimalDenoms,
+    reaction,
+  }: {
+    module: ChainInfoModule;
+    coinMinimalDenoms: string[];
+    reaction: boolean;
+  }) {
+    for (const coinMinimalDenom of coinMinimalDenoms) {
+      const normalizedDenom = DenomHelper.normalizeDenom(coinMinimalDenom);
+
+      // 이미 등록 중인 경우 reaction 모드만 업데이트하고 스킵
+      if (this.shouldSkipUnknownDenom(normalizedDenom, reaction)) {
+        continue;
+      }
+
+      // 이미 currency가 존재하면 스킵
+      if (
+        reaction &&
+        this.getCurrencyMapByModule(module).has(normalizedDenom)
+      ) {
+        continue;
+      }
+
+      // noreaction 맵 확인
+      if (!reaction && this.currencyMapNoReaction.has(normalizedDenom)) {
+        continue;
+      }
+
+      // unknownDenomMap에 등록 및 등록진행중 상태로 변경
+      const isNewUnknownDenom = this.addToUnknownDenomMapAndReturnIsNew(
+        normalizedDenom,
+        reaction
+      );
+
+      // 새로운 unknown denom인 경우에만 autorun 시작
+      if (isNewUnknownDenom) {
+        this.startCurrencyRegistration(module, normalizedDenom);
+      }
+    }
+  }
+
+  // module별 currency map 제공
+  protected getCurrencyMapByModule(
+    module: ChainInfoModule
+  ): Map<string, AppCurrency> {
+    switch (module) {
+      case "cosmos":
+        return this.cosmosCurrencyMap;
+      case "starknet":
+        return this.starknetCurrencyMap;
+      case "bitcoin":
+        return this.bitcoinCurrencyMap;
+      case "evm":
+        return this.evmCurrencyMap;
+      default:
+        throw new Error(`Unknown module: ${module}`);
+    }
+  }
+
+  /**
+   * 이미 등록 중인 unknown denom인지 체크하고, reaction 업데이트
+   */
+  protected shouldSkipUnknownDenom(
+    normalizedDenom: string,
+    reaction: boolean
+  ): boolean {
+    const prior = this.unknownDenomMap.get(normalizedDenom);
+    if (!prior) {
+      return false;
+    }
+
+    // 같은 reaction 모드면 스킵
+    if (prior.reaction === reaction) {
+      return true;
+    }
+
+    // noReaction을 reaction으로 변경하는 경우
+    if (reaction) {
+      // 로직상 reaction은 reactive할 필요가 없기 때문에 직접 변경
+      prior.reaction = reaction;
+    }
+
+    return true;
+  }
+
+  /**
+   * unknownDenomMap에 등록 및 등록진행중 상태로 변경
+   * @returns 새로 추가된 경우 true, 이미 있던 경우 false
+   */
+  protected addToUnknownDenomMapAndReturnIsNew(
+    denom: string,
+    reaction: boolean
+  ): boolean {
+    const prior = this.unknownDenomMap.get(denom);
+    if (prior) {
+      return false; // 이미 존재하면 새로 추가하지 않음
+    }
+
+    runInAction(() => {
+      this.unknownDenomMap.set(denom, {
+        denom: denom,
+        reaction,
+      });
+      this.registrationInProgressCurrencyMap.set(denom, true);
+    });
+
+    return true;
+  }
+
+  protected startCurrencyRegistration(
+    module: ChainInfoModule,
+    denom: string
+  ): void {
+    let i = 0;
+    let disposed = false;
+
+    const disposer = autorun(() => {
+      i++;
+
+      // autorun의 첫 실행에서 즉시 dispose하면 disposer가 아직 undefined이므로
+      // setTimeout으로 다음 회차로 안전하게 연기
+      const dispose = () => {
+        disposed = true;
+
+        if (i === 1) {
+          // 첫 실행: 다음 회차에 dispose
+          setTimeout(() => {
+            disposer?.();
+          }, 1);
+        } else {
+          // 두번째 이후: 즉시 dispose
+          disposer?.();
+        }
+      };
+
+      // 이미 dispose된 경우 리턴
+      if (disposed) {
+        return;
+      }
+
+      const generator = this.currencyRegistry.getCurrencyRegistrar(
+        this.chainId,
+        denom
+      );
+
+      if (generator) {
+        this.handleCurrencyRegistration({
+          module,
+          denom,
+          generator,
+          dispose,
+        });
+      } else {
+        // registrar가 없으면 등록 불가능
+        if (this.registrationInProgressCurrencyMap.get(denom)) {
+          runInAction(() => {
+            this.registrationInProgressCurrencyMap.delete(denom);
+          });
+        }
+        dispose();
+      }
+    });
+  }
+
+  /**
+   * currency 등록 진행
+   */
+  protected handleCurrencyRegistration(args: {
+    module: ChainInfoModule;
+    denom: string;
+    generator: { value: AppCurrency | undefined; done: boolean };
+    dispose: () => void;
+  }): void {
+    const { module, denom, generator, dispose } = args;
+    const currency = generator.value;
+
+    runInAction(() => {
+      // 진행 중 상태 업데이트
+      if (!generator.done) {
+        this.registrationInProgressCurrencyMap.set(denom, true);
+      }
+
+      // currency가 있으면 등록
+      if (currency) {
+        const unknownDenom = this.findAndRemoveUnknownDenom(
+          denom,
+          generator.done
+        );
+
+        // reaction 모드에 따라 적절한 메서드로 추가
+        if (!unknownDenom || unknownDenom.reaction) {
+          this.addOrReplaceCurrency(module, currency);
+        } else {
+          this.addOrReplaceCurrencyNoReaction(module, currency);
+        }
+      }
+
+      // 완료되면 진행 중 상태 제거
+      if (generator.done) {
+        this.registrationInProgressCurrencyMap.delete(denom);
+      }
+    });
+
+    // 완료되면 dispose
+    if (generator.done) {
+      dispose();
+    }
+  }
+
+  /**
+   * unknownDenomMap에서 해당 denom 찾고, 완료되었으면 제거
+   * @returns 찾은 unknownDenom 정보 (없으면 undefined)
+   */
+  protected findAndRemoveUnknownDenom(
+    denom: string,
+    shouldRemove: boolean
+  ):
+    | {
+        denom: string;
+        reaction: boolean;
+      }
+    | undefined {
+    const unknownDenom = this.unknownDenomMap.get(denom);
+    if (!unknownDenom) {
+      return undefined;
+    }
+
+    if (shouldRemove) {
+      this.unknownDenomMap.delete(denom);
+    }
+    return unknownDenom;
+  }
+
+  @action
+  protected addOrReplaceCurrency(
+    module: ChainInfoModule,
+    currency: AppCurrency
+  ) {
+    const currencyMap = this.getCurrencyMapByModule(module);
+    const normalizedCoinMinimalDenom = DenomHelper.normalizeDenom(
+      currency.coinMinimalDenom
+    );
+
+    const newRegisteredCurrencies =
+      this.getRegisteredCurrencies(module).slice();
+
+    if (currencyMap.has(normalizedCoinMinimalDenom)) {
+      const index = newRegisteredCurrencies.findIndex(
+        (cur) => cur.coinMinimalDenom === normalizedCoinMinimalDenom
+      );
+      if (index >= 0) {
+        const prev = newRegisteredCurrencies[index];
+        if (
+          // If same, do nothing
+          sortedJsonByKeyStringify(prev) !== sortedJsonByKeyStringify(currency)
+        ) {
+          newRegisteredCurrencies.splice(index, 1, currency);
+          this.replaceRegisteredCurrencies(module, newRegisteredCurrencies);
+        }
+      }
+    } else {
+      newRegisteredCurrencies.push(currency);
+      this.replaceRegisteredCurrencies(module, newRegisteredCurrencies);
+    }
+  }
+
+  @action
+  protected addOrReplaceCurrencyNoReaction(
+    module: ChainInfoModule,
+    currency: AppCurrency
+  ) {
+    if (module !== "cosmos" && module !== "evm") {
+      return;
+    }
+
+    const normalizedCoinMinimalDenom = DenomHelper.normalizeDenom(
+      currency.coinMinimalDenom
+    );
+    const currencyMap = this.getCurrencyMapByModule(module);
+    const newRegisteredCurrencies = this.registeredCurrenciesNoReaction.slice();
+
+    if (currencyMap.has(normalizedCoinMinimalDenom)) {
+      const index = newRegisteredCurrencies.findIndex(
+        (cur) => cur.coinMinimalDenom === normalizedCoinMinimalDenom
+      );
+      if (index >= 0) {
+        const prev = newRegisteredCurrencies[index];
+        if (
+          // If same, do nothing
+          sortedJsonByKeyStringify(prev) !== sortedJsonByKeyStringify(currency)
+        ) {
+          newRegisteredCurrencies.splice(index, 1, currency);
+          this.registeredCurrenciesNoReaction = newRegisteredCurrencies;
+        }
+      }
+    } else {
+      newRegisteredCurrencies.push(currency);
+      this.registeredCurrenciesNoReaction = newRegisteredCurrencies;
+    }
+  }
+
+  protected getRegisteredCurrencies(module: ChainInfoModule): AppCurrency[] {
+    switch (module) {
+      case "cosmos":
+        return this.registeredCosmosCurrencies;
+      case "starknet":
+        return this.registeredStarkentCurrencies;
+      case "bitcoin":
+        return this.registeredBitcoinCurrencies;
+      case "evm":
+        return this.registeredEvmCurrencies;
+      default:
+        throw new Error(`Unknown module: ${module}`);
+    }
+  }
+  protected replaceRegisteredCurrencies(
+    module: ChainInfoModule,
+    currencies: AppCurrency[]
+  ) {
+    switch (module) {
+      case "cosmos":
+        this.registeredCosmosCurrencies = currencies;
+        break;
+      case "starknet":
+        this.registeredStarkentCurrencies = currencies as ERC20Currency[];
+        break;
+      case "bitcoin":
+        this.registeredBitcoinCurrencies = currencies;
+        break;
+      case "evm":
+        this.registeredEvmCurrencies = currencies;
+        break;
+      default:
+        throw new Error(`Unknown module: ${module}`);
+    }
+  }
+
   @action
   addCurrencies(module: ChainInfoModule, ...currencies: AppCurrency[]) {
     if (currencies.length === 0) {
@@ -708,6 +1329,20 @@ export class ModularChainInfoImpl<M extends ModularChainInfo = ModularChainInfo>
           }
         }
         break;
+      case "evm":
+        if (!("evm" in this._embedded)) {
+          throw new Error(`No evm module for this chain: ${this.chainId}`);
+        }
+
+        for (const currency of currencies) {
+          const normalizedCoinMinimalDenom = DenomHelper.normalizeDenom(
+            currency.coinMinimalDenom
+          );
+          if (!this.evmCurrencyMap.has(normalizedCoinMinimalDenom)) {
+            this.registeredEvmCurrencies.push(currency);
+          }
+        }
+        break;
       default:
         throw new Error(`Unknown module: ${module}`);
     }
@@ -755,6 +1390,15 @@ export class ModularChainInfoImpl<M extends ModularChainInfo = ModularChainInfo>
             (currency) => !map.get(currency.coinMinimalDenom)
           );
         break;
+      case "evm":
+        if (!("evm" in this._embedded)) {
+          throw new Error(`No evm module for this chain: ${this.chainId}`);
+        }
+
+        this.registeredEvmCurrencies = this.registeredEvmCurrencies.filter(
+          (currency) => !map.get(currency.coinMinimalDenom)
+        );
+        break;
       default:
         throw new Error(`Unknown module: ${module}`);
     }
@@ -768,7 +1412,21 @@ export class ModularChainInfoImpl<M extends ModularChainInfo = ModularChainInfo>
         result.set(currency.coinMinimalDenom, currency);
       }
     }
+    for (const currency of this.registeredCosmosCurrencies) {
+      result.set(
+        DenomHelper.normalizeDenom(currency.coinMinimalDenom),
+        currency
+      );
+    }
+    return result;
+  }
 
+  @computed
+  protected get currencyMapNoReaction(): Map<string, AppCurrency> {
+    const result: Map<string, AppCurrency> = new Map();
+    for (const currency of this.registeredCurrenciesNoReaction) {
+      result.set(currency.coinMinimalDenom, currency);
+    }
     return result;
   }
 
@@ -781,6 +1439,12 @@ export class ModularChainInfoImpl<M extends ModularChainInfo = ModularChainInfo>
       }
     }
 
+    for (const currency of this.registeredStarkentCurrencies) {
+      result.set(
+        DenomHelper.normalizeDenom(currency.coinMinimalDenom),
+        currency
+      );
+    }
     return result;
   }
 
@@ -793,8 +1457,79 @@ export class ModularChainInfoImpl<M extends ModularChainInfo = ModularChainInfo>
       }
     }
 
+    for (const currency of this.registeredBitcoinCurrencies) {
+      result.set(
+        DenomHelper.normalizeDenom(currency.coinMinimalDenom),
+        currency
+      );
+    }
+    return result;
+  }
+
+  @computed
+  protected get evmCurrencyMap(): Map<string, AppCurrency> {
+    const result: Map<string, AppCurrency> = new Map();
+    if ("evm" in this._embedded) {
+      for (const currency of this._embedded.evm.currencies) {
+        result.set(
+          DenomHelper.normalizeDenom(currency.coinMinimalDenom),
+          currency
+        );
+      }
+    }
+
+    for (const currency of this.registeredEvmCurrencies) {
+      result.set(
+        DenomHelper.normalizeDenom(currency.coinMinimalDenom),
+        currency
+      );
+    }
+
     return result;
   }
+
+  hasFeature(feature: string): boolean {
+    if ("evm" in this._embedded) {
+      return !!(
+        "features" in this._embedded.evm &&
+        this._embedded.evm.features?.includes(feature)
+      );
+    }
+    if ("cosmos" in this._embedded) {
+      return !!(
+        "features" in this._embedded.cosmos &&
+        this._embedded.cosmos.features?.includes(feature)
+      );
+    }
+    return false;
+  }
+
+  isCurrencyRegistrationInProgress(coinMinimalDenom: string): boolean {
+    return (
+      this.registrationInProgressCurrencyMap.get(coinMinimalDenom) || false
+    );
+  }
+
+  /**
+   * @description Check if the chain matches the given modules. Either `or` or `and` condition must be provided.
+   * @param or - If any of the modules in the array is available, return true.
+   * @param and - If all of the modules in the array are available, return true.
+   */
+  matchModules({
+    and,
+    or,
+  }:
+    | { or: ChainInfoModule[]; and?: undefined }
+    | { and: ChainInfoModule[]; or?: undefined }): boolean {
+    return (
+      (or?.some((module) => this.matchModule(module)) ?? true) &&
+      (and?.every((module) => this.matchModule(module)) ?? true)
+    );
+  }
+
+  matchModule(module: ChainInfoModule): boolean {
+    return this.availableModules.includes(module);
+  }
 }
 
 export class ChainStore<C extends ChainInfo = ChainInfo>
@@ -820,6 +1555,9 @@ export class ChainStore<C extends ChainInfo = ChainInfo>
     keepAlive(this, "modularChainInfoMap");
   }
 
+  /**
+   * @deprecated Use `modularChainInfos` instead
+   */
   get chainInfos(): IChainInfoImpl<C>[] {
     return this._chainInfos;
   }
@@ -841,6 +1579,9 @@ export class ChainStore<C extends ChainInfo = ChainInfo>
     return result;
   }
 
+  /**
+   * @deprecated Use `getmodularChain` or `getModularChainInfoImpl` instead
+   */
   getChain(chainId: string): IChainInfoImpl<C> {
     const chainIdentifier = ChainIdHelper.parse(chainId);
 
@@ -853,6 +1594,9 @@ export class ChainStore<C extends ChainInfo = ChainInfo>
     return chainInfo;
   }
 
+  /**
+   * @deprecated Use `hasModularChain` instead
+   */
   hasChain(chainId: string): boolean {
     const chainIdentifier = ChainIdHelper.parse(chainId);
 
@@ -941,27 +1685,56 @@ export class ChainStore<C extends ChainInfo = ChainInfo>
 
         return new ChainInfoImpl(chainInfo, this);
       });
+
     this._modularChainInfos = chainInfos.map((chainInfo) => {
+      if (
+        "evm" in chainInfo &&
+        chainInfo.evm &&
+        "currencies" in chainInfo && // clarify if it's ChainInfo type
+        this.isEvmOnlyChainForInit(chainInfo.chainId)
+      ) {
+        return {
+          chainId: chainInfo.chainId,
+          chainName: chainInfo.chainName,
+          chainSymbolImageUrl: chainInfo.chainSymbolImageUrl,
+          isTestnet: chainInfo.isTestnet,
+          isNative: true,
+          evm: {
+            ...chainInfo.evm,
+            currencies: chainInfo.currencies,
+            feeCurrencies: chainInfo.feeCurrencies,
+            bip44: chainInfo.bip44,
+            features: chainInfo.features,
+          },
+        };
+      }
       if ("currencies" in chainInfo) {
         return {
           chainId: chainInfo.chainId,
           chainName: chainInfo.chainName,
           chainSymbolImageUrl: chainInfo.chainSymbolImageUrl,
+          isNative: true,
           cosmos: chainInfo as C,
+          ...(chainInfo.evm && {
+            evm: {
+              ...chainInfo.evm,
+              currencies: chainInfo.currencies,
+              bip44: chainInfo.bip44,
+            },
+          }),
         };
       }
-      return chainInfo;
+      return { ...chainInfo, isNative: true };
     });
+
     this._modularChainInfoImpls = chainInfos.map((chainInfo) => {
-      const modularChainInfo =
-        "currencies" in chainInfo
-          ? {
-              chainId: chainInfo.chainId,
-              chainName: chainInfo.chainName,
-              chainSymbolImageUrl: chainInfo.chainSymbolImageUrl,
-              cosmos: chainInfo as C,
-            }
-          : chainInfo;
+      const modularChainInfo = this._modularChainInfos.find(
+        (c) => c.chainId === chainInfo.chainId
+      );
+
+      if (!modularChainInfo) {
+        throw new Error(`Unknown modular chain info: ${chainInfo.chainId}`);
+      }
 
       const prev = this.modularChainInfoImplMap.get(
         ChainIdHelper.parse(chainInfo.chainId).identifier
@@ -1004,30 +1777,28 @@ export class ChainStore<C extends ChainInfo = ChainInfo>
           chainId: cosmos.chainId,
           chainName: cosmos.chainName,
           chainSymbolImageUrl: cosmos.chainSymbolImageUrl,
+          isNative: chainInfo.isNative || !cosmos.beta,
           cosmos,
+          ...(cosmos.evm && {
+            evm: {
+              ...cosmos.evm,
+              currencies: cosmos.currencies,
+              bip44: cosmos.bip44,
+            },
+          }),
         };
       }
+
       return chainInfo;
     });
     this._modularChainInfoImpls = infos.modulrChainInfos.map((chainInfo) => {
-      const modularChainInfo = (() => {
-        if ("currencies" in chainInfo) {
-          const cosmos = infos.chainInfos.find(
-            (c) => c.chainId === chainInfo.chainId
-          );
-          if (!cosmos) {
-            throw new Error("Can't find cosmos chain info");
-          }
+      const modularChainInfo = this._modularChainInfos.find(
+        (c) => c.chainId === chainInfo.chainId
+      );
 
-          return {
-            chainId: cosmos.chainId,
-            chainName: cosmos.chainName,
-            chainSymbolImageUrl: cosmos.chainSymbolImageUrl,
-            cosmos,
-          };
-        }
-        return chainInfo;
-      })();
+      if (!modularChainInfo) {
+        throw new Error(`Unknown modular chain info: ${chainInfo.chainId}`);
+      }
 
       const prev = this.modularChainInfoImplMap.get(
         ChainIdHelper.parse(chainInfo.chainId).identifier
@@ -1066,8 +1837,8 @@ export class ChainStore<C extends ChainInfo = ChainInfo>
   }
 
   isEvmChain(chainId: string): boolean {
-    const chainInfo = this.getChain(chainId);
-    return chainInfo.evm != null;
+    const chainInfo = this.getModularChain(chainId);
+    return "evm" in chainInfo && chainInfo.evm != null;
   }
 
   isEvmOnlyChain(chainId: string): boolean {
@@ -1079,17 +1850,28 @@ export class ChainStore<C extends ChainInfo = ChainInfo>
     );
   }
 
+  // 초기화 시 isEvmOnlyChain 확인하면 _modularChainInfos 할당 전이라 오류가 발생할 수 밖에 없어서 별도 추가
+  isEvmOnlyChainForInit(chainId: string): boolean {
+    const chainIdLikeCAIP2 = chainId.split(":");
+    return chainIdLikeCAIP2.length === 2 && chainIdLikeCAIP2[0] === "eip155";
+  }
+
   isEvmOrEthermintLikeChain(chainId: string): boolean {
     const b = this.isEvmChain(chainId);
     if (b) {
       return true;
     }
-    const chainInfo = this.getChain(chainId);
+    const chainInfo = this.getModularChain(chainId);
 
     const isEthermintLike =
-      chainInfo.bip44.coinType === 60 ||
-      !!chainInfo.features?.includes("eth-address-gen") ||
-      !!chainInfo.features?.includes("eth-key-sign");
+      ("cosmos" in chainInfo &&
+        (chainInfo.cosmos.bip44.coinType === 60 ||
+          !!chainInfo.cosmos.features?.includes("eth-address-gen") ||
+          !!chainInfo.cosmos.features?.includes("eth-key-sign"))) ||
+      ("evm" in chainInfo &&
+        (chainInfo.evm.bip44.coinType === 60 ||
+          !!chainInfo.evm.features?.includes("eth-address-gen") ||
+          !!chainInfo.evm.features?.includes("eth-key-sign")));
 
     return isEthermintLike;
   }