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

package/build/chain/base.js

@@ -455,27 +455,76 @@ __decorate([
 ], ChainInfoImpl.prototype, "setEmbeddedChainInfo", null);
 exports.ChainInfoImpl = ChainInfoImpl;
 class ModularChainInfoImpl {
+    get unknownDenomMap() {
+        return new Map();
+    }
     constructor(embedded, currencyRegistry) {
         this.currencyRegistry = currencyRegistry;
         this.registeredCosmosCurrencies = [];
         this.registeredStarkentCurrencies = [];
         this.registeredBitcoinCurrencies = [];
+        this.registeredEvmCurrencies = [];
+        this.registeredCurrenciesNoReaction = [];
+        this.registrationInProgressCurrencyMap = new Map();
         this._embedded = embedded;
+        this.availableModules = this.detectAvailableModules();
         (0, mobx_1.makeObservable)(this);
         (0, mobx_utils_1.keepAlive)(this, "cosmosCurrencyMap");
         (0, mobx_utils_1.keepAlive)(this, "starknetCurrencyMap");
         (0, mobx_utils_1.keepAlive)(this, "bitcoinCurrencyMap");
+        (0, mobx_utils_1.keepAlive)(this, "evmCurrencyMap");
+    }
+    detectAvailableModules() {
+        const modules = [];
+        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() {
         return this._embedded;
     }
     setEmbeddedModularChainInfo(embedded) {
         this._embedded = embedded;
+        this.availableModules = this.detectAvailableModules();
     }
     get chainId() {
         return this._embedded.chainId;
     }
-    getCurrencies(module) {
+    get stakeCurrency() {
+        return "cosmos" in this._embedded
+            ? this._embedded.cosmos.stakeCurrency
+            : undefined;
+    }
+    get feeCurrencies() {
+        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() {
+        return this.availableModules
+            .map((module) => this.getCurrenciesByModule(module))
+            .flat();
+    }
+    getCurrenciesByModule(module) {
         switch (module) {
             case "cosmos":
                 if (!("cosmos" in this._embedded)) {
@@ -492,6 +541,407 @@ class ModularChainInfoImpl {
                     throw new Error(`No bitcoin module for this chain: ${this.chainId}`);
                 }
                 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) {
+        const normalizedDenom = common_1.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) {
+        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) {
+        const normalizedCoinMinimalDenom = common_1.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) {
+        const normalizedCoinMinimalDenom = common_1.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) {
+        const normalizedCoinMinimalDenom = common_1.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;
+        return new Promise((resolve) => {
+            disposal = (0, mobx_1.autorun)(() => {
+                const registration = this.registrationInProgressCurrencyMap.get(normalizedCoinMinimalDenom);
+                if (!registration) {
+                    const result = this.findCurrencyByModule(normalizedCoinMinimalDenom);
+                    resolve(result);
+                }
+            });
+        }).finally(() => {
+            if (disposal) {
+                disposal();
+            }
+        });
+    }
+    forceFindCurrencyWithoutReaction(coinMinimalDenom) {
+        const normalizedCoinMinimalDenom = common_1.DenomHelper.normalizeDenom(coinMinimalDenom);
+        const currency = this.findCurrencyWithoutReaction(normalizedCoinMinimalDenom);
+        if (currency) {
+            return currency;
+        }
+        return this.getRawCurrency(normalizedCoinMinimalDenom);
+    }
+    /**
+     * raw currency를 반환한다. ref을 유지하기 위해서 cache를 사용한다.
+     */
+    getRawCurrency(denom) {
+        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, }) {
+        this.addUnknownDenomsImpl({
+            module,
+            coinMinimalDenoms,
+            reaction: true,
+        });
+    }
+    addUnknownDenomsWithoutReaction({ module, coinMinimalDenoms, }) {
+        this.addUnknownDenomsImpl({
+            module,
+            coinMinimalDenoms,
+            reaction: false,
+        });
+    }
+    /**
+     * 해당되는 denom의 currency를 모를 때 이 메소드를 사용해서 등록을 요청할 수 있다.
+     *
+     * - balance 쿼리 결과 등에서 모르는 denom이 나타날 때
+     * - IBC denom을 동적으로 등록해야 할 때
+     * ---
+     * - action 데코레이터가 사용되지 않은 이유: action 내부에서 autorun을 생성하면, autorun의 첫 실행이 action이 끝날 때까지 지연된다.
+     *   autorun을 사용하는 startCurrencyRegistration 내부에서 불필요한 지연이 발생할 수 있어 action 없이 구현하여 autorun을 즉시 실행한다.
+     *   하지만 이 메소드를 action 안에서 호출하게 되는 경우가 있다면 여전히 즉시 실행되지 않으므로 고려가 필요하다.
+     */
+    addUnknownDenomsImpl({ module, coinMinimalDenoms, reaction, }) {
+        for (const coinMinimalDenom of coinMinimalDenoms) {
+            const normalizedDenom = common_1.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 제공
+    getCurrencyMapByModule(module) {
+        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 업데이트
+     */
+    shouldSkipUnknownDenom(normalizedDenom, reaction) {
+        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
+     */
+    addToUnknownDenomMapAndReturnIsNew(denom, reaction) {
+        const prior = this.unknownDenomMap.get(denom);
+        if (prior) {
+            return false; // 이미 존재하면 새로 추가하지 않음
+        }
+        (0, mobx_1.runInAction)(() => {
+            this.unknownDenomMap.set(denom, {
+                denom: denom,
+                reaction,
+            });
+            this.registrationInProgressCurrencyMap.set(denom, true);
+        });
+        return true;
+    }
+    startCurrencyRegistration(module, denom) {
+        let i = 0;
+        let disposed = false;
+        const disposer = (0, mobx_1.autorun)(() => {
+            i++;
+            // autorun의 첫 실행에서 즉시 dispose하면 disposer가 아직 undefined이므로
+            // setTimeout으로 다음 회차로 안전하게 연기
+            const dispose = () => {
+                disposed = true;
+                if (i === 1) {
+                    // 첫 실행: 다음 회차에 dispose
+                    setTimeout(() => {
+                        disposer === null || disposer === void 0 ? void 0 : disposer();
+                    }, 1);
+                }
+                else {
+                    // 두번째 이후: 즉시 dispose
+                    disposer === null || disposer === void 0 ? void 0 : 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)) {
+                    (0, mobx_1.runInAction)(() => {
+                        this.registrationInProgressCurrencyMap.delete(denom);
+                    });
+                }
+                dispose();
+            }
+        });
+    }
+    /**
+     * currency 등록 진행
+     */
+    handleCurrencyRegistration(args) {
+        const { module, denom, generator, dispose } = args;
+        const currency = generator.value;
+        (0, mobx_1.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)
+     */
+    findAndRemoveUnknownDenom(denom, shouldRemove) {
+        const unknownDenom = this.unknownDenomMap.get(denom);
+        if (!unknownDenom) {
+            return undefined;
+        }
+        if (shouldRemove) {
+            this.unknownDenomMap.delete(denom);
+        }
+        return unknownDenom;
+    }
+    addOrReplaceCurrency(module, currency) {
+        const currencyMap = this.getCurrencyMapByModule(module);
+        const normalizedCoinMinimalDenom = common_1.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
+                (0, common_1.sortedJsonByKeyStringify)(prev) !== (0, common_1.sortedJsonByKeyStringify)(currency)) {
+                    newRegisteredCurrencies.splice(index, 1, currency);
+                    this.replaceRegisteredCurrencies(module, newRegisteredCurrencies);
+                }
+            }
+        }
+        else {
+            newRegisteredCurrencies.push(currency);
+            this.replaceRegisteredCurrencies(module, newRegisteredCurrencies);
+        }
+    }
+    addOrReplaceCurrencyNoReaction(module, currency) {
+        if (module !== "cosmos" && module !== "evm") {
+            return;
+        }
+        const normalizedCoinMinimalDenom = common_1.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
+                (0, common_1.sortedJsonByKeyStringify)(prev) !== (0, common_1.sortedJsonByKeyStringify)(currency)) {
+                    newRegisteredCurrencies.splice(index, 1, currency);
+                    this.registeredCurrenciesNoReaction = newRegisteredCurrencies;
+                }
+            }
+        }
+        else {
+            newRegisteredCurrencies.push(currency);
+            this.registeredCurrenciesNoReaction = newRegisteredCurrencies;
+        }
+    }
+    getRegisteredCurrencies(module) {
+        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}`);
+        }
+    }
+    replaceRegisteredCurrencies(module, currencies) {
+        switch (module) {
+            case "cosmos":
+                this.registeredCosmosCurrencies = currencies;
+                break;
+            case "starknet":
+                this.registeredStarkentCurrencies = currencies;
+                break;
+            case "bitcoin":
+                this.registeredBitcoinCurrencies = currencies;
+                break;
+            case "evm":
+                this.registeredEvmCurrencies = currencies;
+                break;
             default:
                 throw new Error(`Unknown module: ${module}`);
         }
@@ -536,6 +986,17 @@ class ModularChainInfoImpl {
                     }
                 }
                 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 = common_1.DenomHelper.normalizeDenom(currency.coinMinimalDenom);
+                    if (!this.evmCurrencyMap.has(normalizedCoinMinimalDenom)) {
+                        this.registeredEvmCurrencies.push(currency);
+                    }
+                }
+                break;
             default:
                 throw new Error(`Unknown module: ${module}`);
         }
@@ -570,6 +1031,12 @@ class ModularChainInfoImpl {
                 this.registeredBitcoinCurrencies =
                     this.registeredBitcoinCurrencies.filter((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}`);
         }
@@ -581,6 +1048,16 @@ class ModularChainInfoImpl {
                 result.set(currency.coinMinimalDenom, currency);
             }
         }
+        for (const currency of this.registeredCosmosCurrencies) {
+            result.set(common_1.DenomHelper.normalizeDenom(currency.coinMinimalDenom), currency);
+        }
+        return result;
+    }
+    get currencyMapNoReaction() {
+        const result = new Map();
+        for (const currency of this.registeredCurrenciesNoReaction) {
+            result.set(currency.coinMinimalDenom, currency);
+        }
         return result;
     }
     get starknetCurrencyMap() {
@@ -590,6 +1067,9 @@ class ModularChainInfoImpl {
                 result.set(currency.coinMinimalDenom, currency);
             }
         }
+        for (const currency of this.registeredStarkentCurrencies) {
+            result.set(common_1.DenomHelper.normalizeDenom(currency.coinMinimalDenom), currency);
+        }
         return result;
     }
     get bitcoinCurrencyMap() {
@@ -599,8 +1079,51 @@ class ModularChainInfoImpl {
                 result.set(currency.coinMinimalDenom, currency);
             }
         }
+        for (const currency of this.registeredBitcoinCurrencies) {
+            result.set(common_1.DenomHelper.normalizeDenom(currency.coinMinimalDenom), currency);
+        }
         return result;
     }
+    get evmCurrencyMap() {
+        const result = new Map();
+        if ("evm" in this._embedded) {
+            for (const currency of this._embedded.evm.currencies) {
+                result.set(common_1.DenomHelper.normalizeDenom(currency.coinMinimalDenom), currency);
+            }
+        }
+        for (const currency of this.registeredEvmCurrencies) {
+            result.set(common_1.DenomHelper.normalizeDenom(currency.coinMinimalDenom), currency);
+        }
+        return result;
+    }
+    hasFeature(feature) {
+        var _a, _b;
+        if ("evm" in this._embedded) {
+            return !!("features" in this._embedded.evm &&
+                ((_a = this._embedded.evm.features) === null || _a === void 0 ? void 0 : _a.includes(feature)));
+        }
+        if ("cosmos" in this._embedded) {
+            return !!("features" in this._embedded.cosmos &&
+                ((_b = this._embedded.cosmos.features) === null || _b === void 0 ? void 0 : _b.includes(feature)));
+        }
+        return false;
+    }
+    isCurrencyRegistrationInProgress(coinMinimalDenom) {
+        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, }) {
+        var _a, _b;
+        return (((_a = or === null || or === void 0 ? void 0 : or.some((module) => this.matchModule(module))) !== null && _a !== void 0 ? _a : true) &&
+            ((_b = and === null || and === void 0 ? void 0 : and.every((module) => this.matchModule(module))) !== null && _b !== void 0 ? _b : true));
+    }
+    matchModule(module) {
+        return this.availableModules.includes(module);
+    }
 }
 __decorate([
     mobx_1.observable.ref
@@ -614,9 +1137,30 @@ __decorate([
 __decorate([
     mobx_1.observable.shallow
 ], ModularChainInfoImpl.prototype, "registeredBitcoinCurrencies", void 0);
+__decorate([
+    mobx_1.observable.shallow
+], ModularChainInfoImpl.prototype, "registeredEvmCurrencies", void 0);
+__decorate([
+    mobx_1.observable.shallow
+], ModularChainInfoImpl.prototype, "registeredCurrenciesNoReaction", void 0);
+__decorate([
+    mobx_1.computed
+], ModularChainInfoImpl.prototype, "unknownDenomMap", null);
+__decorate([
+    mobx_1.observable.shallow
+], ModularChainInfoImpl.prototype, "registrationInProgressCurrencyMap", void 0);
+__decorate([
+    mobx_1.observable.shallow
+], ModularChainInfoImpl.prototype, "availableModules", void 0);
 __decorate([
     mobx_1.action
 ], ModularChainInfoImpl.prototype, "setEmbeddedModularChainInfo", null);
+__decorate([
+    mobx_1.action
+], ModularChainInfoImpl.prototype, "addOrReplaceCurrency", null);
+__decorate([
+    mobx_1.action
+], ModularChainInfoImpl.prototype, "addOrReplaceCurrencyNoReaction", null);
 __decorate([
     mobx_1.action
 ], ModularChainInfoImpl.prototype, "addCurrencies", null);
@@ -626,12 +1170,18 @@ __decorate([
 __decorate([
     mobx_1.computed
 ], ModularChainInfoImpl.prototype, "cosmosCurrencyMap", null);
+__decorate([
+    mobx_1.computed
+], ModularChainInfoImpl.prototype, "currencyMapNoReaction", null);
 __decorate([
     mobx_1.computed
 ], ModularChainInfoImpl.prototype, "starknetCurrencyMap", null);
 __decorate([
     mobx_1.computed
 ], ModularChainInfoImpl.prototype, "bitcoinCurrencyMap", null);
+__decorate([
+    mobx_1.computed
+], ModularChainInfoImpl.prototype, "evmCurrencyMap", null);
 exports.ModularChainInfoImpl = ModularChainInfoImpl;
 class ChainStore {
     constructor(embedChainInfos) {
@@ -644,6 +1194,9 @@ class ChainStore {
         (0, mobx_utils_1.keepAlive)(this, "chainInfoMap");
         (0, mobx_utils_1.keepAlive)(this, "modularChainInfoMap");
     }
+    /**
+     * @deprecated Use `modularChainInfos` instead
+     */
     get chainInfos() {
         return this._chainInfos;
     }
@@ -660,6 +1213,9 @@ class ChainStore {
         }
         return result;
     }
+    /**
+     * @deprecated Use `getmodularChain` or `getModularChainInfoImpl` instead
+     */
     getChain(chainId) {
         const chainIdentifier = cosmos_1.ChainIdHelper.parse(chainId);
         const chainInfo = this.chainInfoMap.get(chainIdentifier.identifier);
@@ -668,6 +1224,9 @@ class ChainStore {
         }
         return chainInfo;
     }
+    /**
+     * @deprecated Use `hasModularChain` instead
+     */
     hasChain(chainId) {
         const chainIdentifier = cosmos_1.ChainIdHelper.parse(chainId);
         return this.chainInfoMap.has(chainIdentifier.identifier);
@@ -726,25 +1285,31 @@ class ChainStore {
             return new ChainInfoImpl(chainInfo, this);
         });
         this._modularChainInfos = chainInfos.map((chainInfo) => {
-            if ("currencies" in 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,
-                    cosmos: chainInfo,
+                    isTestnet: chainInfo.isTestnet,
+                    isNative: true,
+                    evm: Object.assign(Object.assign({}, chainInfo.evm), { currencies: chainInfo.currencies, feeCurrencies: chainInfo.feeCurrencies, bip44: chainInfo.bip44, features: chainInfo.features }),
                 };
             }
-            return chainInfo;
+            if ("currencies" in chainInfo) {
+                return Object.assign({ chainId: chainInfo.chainId, chainName: chainInfo.chainName, chainSymbolImageUrl: chainInfo.chainSymbolImageUrl, isNative: true, cosmos: chainInfo }, (chainInfo.evm && {
+                    evm: Object.assign(Object.assign({}, chainInfo.evm), { currencies: chainInfo.currencies, bip44: chainInfo.bip44 }),
+                }));
+            }
+            return Object.assign(Object.assign({}, chainInfo), { isNative: true });
         });
         this._modularChainInfoImpls = chainInfos.map((chainInfo) => {
-            const modularChainInfo = "currencies" in chainInfo
-                ? {
-                    chainId: chainInfo.chainId,
-                    chainName: chainInfo.chainName,
-                    chainSymbolImageUrl: chainInfo.chainSymbolImageUrl,
-                    cosmos: chainInfo,
-                }
-                : 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(cosmos_1.ChainIdHelper.parse(chainInfo.chainId).identifier);
             if (prev) {
                 prev.setEmbeddedModularChainInfo(modularChainInfo);
@@ -768,31 +1333,17 @@ class ChainStore {
                 if (!cosmos) {
                     throw new Error("Can't find cosmos chain info");
                 }
-                return {
-                    chainId: cosmos.chainId,
-                    chainName: cosmos.chainName,
-                    chainSymbolImageUrl: cosmos.chainSymbolImageUrl,
-                    cosmos,
-                };
+                return Object.assign({ chainId: cosmos.chainId, chainName: cosmos.chainName, chainSymbolImageUrl: cosmos.chainSymbolImageUrl, isNative: chainInfo.isNative || !cosmos.beta, cosmos }, (cosmos.evm && {
+                    evm: Object.assign(Object.assign({}, 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");
-                    }
-                    return {
-                        chainId: cosmos.chainId,
-                        chainName: cosmos.chainName,
-                        chainSymbolImageUrl: cosmos.chainSymbolImageUrl,
-                        cosmos,
-                    };
-                }
-                return 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(cosmos_1.ChainIdHelper.parse(chainInfo.chainId).identifier);
             if (prev) {
                 prev.setEmbeddedModularChainInfo(modularChainInfo);
@@ -815,8 +1366,8 @@ class ChainStore {
         this.currencyRegistrars.push(registrar);
     }
     isEvmChain(chainId) {
-        const chainInfo = this.getChain(chainId);
-        return chainInfo.evm != null;
+        const chainInfo = this.getModularChain(chainId);
+        return "evm" in chainInfo && chainInfo.evm != null;
     }
     isEvmOnlyChain(chainId) {
         const chainIdLikeCAIP2 = chainId.split(":");
@@ -824,16 +1375,26 @@ class ChainStore {
             chainIdLikeCAIP2.length === 2 &&
             chainIdLikeCAIP2[0] === "eip155");
     }
+    // 초기화 시 isEvmOnlyChain 확인하면 _modularChainInfos 할당 전이라 오류가 발생할 수 밖에 없어서 별도 추가
+    isEvmOnlyChainForInit(chainId) {
+        const chainIdLikeCAIP2 = chainId.split(":");
+        return chainIdLikeCAIP2.length === 2 && chainIdLikeCAIP2[0] === "eip155";
+    }
     isEvmOrEthermintLikeChain(chainId) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         const b = this.isEvmChain(chainId);
         if (b) {
             return true;
         }
-        const chainInfo = this.getChain(chainId);
-        const isEthermintLike = chainInfo.bip44.coinType === 60 ||
-            !!((_a = chainInfo.features) === null || _a === void 0 ? void 0 : _a.includes("eth-address-gen")) ||
-            !!((_b = chainInfo.features) === null || _b === void 0 ? void 0 : _b.includes("eth-key-sign"));
+        const chainInfo = this.getModularChain(chainId);
+        const isEthermintLike = ("cosmos" in chainInfo &&
+            (chainInfo.cosmos.bip44.coinType === 60 ||
+                !!((_a = chainInfo.cosmos.features) === null || _a === void 0 ? void 0 : _a.includes("eth-address-gen")) ||
+                !!((_b = chainInfo.cosmos.features) === null || _b === void 0 ? void 0 : _b.includes("eth-key-sign")))) ||
+            ("evm" in chainInfo &&
+                (chainInfo.evm.bip44.coinType === 60 ||
+                    !!((_c = chainInfo.evm.features) === null || _c === void 0 ? void 0 : _c.includes("eth-address-gen")) ||
+                    !!((_d = chainInfo.evm.features) === null || _d === void 0 ? void 0 : _d.includes("eth-key-sign"))));
         return isEthermintLike;
     }
 }