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

package/build/chain/base.js

@@ -455,76 +455,27 @@ __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;
     }
-    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) {
+    getCurrencies(module) {
         switch (module) {
             case "cosmos":
                 if (!("cosmos" in this._embedded)) {
@@ -541,407 +492,6 @@ 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}`);
         }
@@ -986,17 +536,6 @@ 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}`);
         }
@@ -1031,12 +570,6 @@ 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}`);
         }
@@ -1048,16 +581,6 @@ 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() {
@@ -1067,9 +590,6 @@ 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() {
@@ -1079,51 +599,8 @@ 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
@@ -1137,30 +614,9 @@ __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);
@@ -1170,18 +626,12 @@ __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) {
@@ -1194,9 +644,6 @@ 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;
     }
@@ -1213,9 +660,6 @@ 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);
@@ -1224,9 +668,6 @@ class ChainStore {
         }
         return chainInfo;
     }
-    /**
-     * @deprecated Use `hasModularChain` instead
-     */
     hasChain(chainId) {
         const chainIdentifier = cosmos_1.ChainIdHelper.parse(chainId);
         return this.chainInfoMap.has(chainIdentifier.identifier);
@@ -1285,31 +726,25 @@ class ChainStore {
             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)) {
+            if ("currencies" in chainInfo) {
                 return {
                     chainId: chainInfo.chainId,
                     chainName: chainInfo.chainName,
                     chainSymbolImageUrl: chainInfo.chainSymbolImageUrl,
-                    isTestnet: chainInfo.isTestnet,
-                    isNative: true,
-                    evm: Object.assign(Object.assign({}, chainInfo.evm), { currencies: chainInfo.currencies, feeCurrencies: chainInfo.feeCurrencies, bip44: chainInfo.bip44, features: chainInfo.features }),
+                    cosmos: 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 });
+            return chainInfo;
         });
         this._modularChainInfoImpls = chainInfos.map((chainInfo) => {
-            const modularChainInfo = this._modularChainInfos.find((c) => c.chainId === chainInfo.chainId);
-            if (!modularChainInfo) {
-                throw new Error(`Unknown modular chain info: ${chainInfo.chainId}`);
-            }
+            const modularChainInfo = "currencies" in chainInfo
+                ? {
+                    chainId: chainInfo.chainId,
+                    chainName: chainInfo.chainName,
+                    chainSymbolImageUrl: chainInfo.chainSymbolImageUrl,
+                    cosmos: chainInfo,
+                }
+                : chainInfo;
             const prev = this.modularChainInfoImplMap.get(cosmos_1.ChainIdHelper.parse(chainInfo.chainId).identifier);
             if (prev) {
                 prev.setEmbeddedModularChainInfo(modularChainInfo);
@@ -1333,17 +768,31 @@ class ChainStore {
                 if (!cosmos) {
                     throw new Error("Can't find cosmos chain info");
                 }
-                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 {
+                    chainId: cosmos.chainId,
+                    chainName: cosmos.chainName,
+                    chainSymbolImageUrl: cosmos.chainSymbolImageUrl,
+                    cosmos,
+                };
             }
             return chainInfo;
         });
         this._modularChainInfoImpls = infos.modulrChainInfos.map((chainInfo) => {
-            const modularChainInfo = this._modularChainInfos.find((c) => c.chainId === chainInfo.chainId);
-            if (!modularChainInfo) {
-                throw new Error(`Unknown modular chain info: ${chainInfo.chainId}`);
-            }
+            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 prev = this.modularChainInfoImplMap.get(cosmos_1.ChainIdHelper.parse(chainInfo.chainId).identifier);
             if (prev) {
                 prev.setEmbeddedModularChainInfo(modularChainInfo);
@@ -1366,8 +815,8 @@ class ChainStore {
         this.currencyRegistrars.push(registrar);
     }
     isEvmChain(chainId) {
-        const chainInfo = this.getModularChain(chainId);
-        return "evm" in chainInfo && chainInfo.evm != null;
+        const chainInfo = this.getChain(chainId);
+        return chainInfo.evm != null;
     }
     isEvmOnlyChain(chainId) {
         const chainIdLikeCAIP2 = chainId.split(":");
@@ -1375,26 +824,16 @@ 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, _c, _d;
+        var _a, _b;
         const b = this.isEvmChain(chainId);
         if (b) {
             return true;
         }
-        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"))));
+        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"));
         return isEthermintLike;
     }
 }