@keplr-wallet/background 0.12.273-alpha.2 → 0.12.273

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keplr-wallet/background",
-  "version": "0.12.273-alpha.2",
+  "version": "0.12.273",
   "main": "build/index.js",
   "author": "chainapsis",
   "license": "Apache-2.0",
@@ -28,17 +28,17 @@
     "@ethersproject/hash": "^5.7.0",
     "@ethersproject/transactions": "^5.7.0",
     "@ethersproject/wallet": "^5.7.0",
-    "@keplr-wallet/chain-validator": "0.12.273-alpha.2",
-    "@keplr-wallet/common": "0.12.273-alpha.2",
-    "@keplr-wallet/cosmos": "0.12.273-alpha.2",
-    "@keplr-wallet/crypto": "0.12.273-alpha.2",
-    "@keplr-wallet/ledger-cosmos": "0.12.273-alpha.2",
-    "@keplr-wallet/popup": "0.12.273-alpha.2",
-    "@keplr-wallet/proto-types": "0.12.273-alpha.2",
-    "@keplr-wallet/router": "0.12.273-alpha.2",
-    "@keplr-wallet/simple-fetch": "0.12.273-alpha.2",
-    "@keplr-wallet/types": "0.12.273-alpha.2",
-    "@keplr-wallet/unit": "0.12.273-alpha.2",
+    "@keplr-wallet/chain-validator": "0.12.273",
+    "@keplr-wallet/common": "0.12.273",
+    "@keplr-wallet/cosmos": "0.12.273",
+    "@keplr-wallet/crypto": "0.12.273",
+    "@keplr-wallet/ledger-cosmos": "0.12.273",
+    "@keplr-wallet/popup": "0.12.273",
+    "@keplr-wallet/proto-types": "0.12.273",
+    "@keplr-wallet/router": "0.12.273",
+    "@keplr-wallet/simple-fetch": "0.12.273",
+    "@keplr-wallet/types": "0.12.273",
+    "@keplr-wallet/unit": "0.12.273",
     "@ledgerhq/hw-app-eth": "^6.40.3",
     "@ledgerhq/hw-app-starknet": "^2.5.2",
     "@ledgerhq/hw-transport": "^6.31.4",
@@ -65,5 +65,5 @@
     "mobx-utils": "^6",
     "starknet": "^7"
   },
-  "gitHead": "c965bae914526b008c8a495ac186227e357fb12a"
+  "gitHead": "6b9b19d8c4cc163b7cf8877247a0221dfd032d29"
 }

package/src/chains/service.ts

@@ -1063,7 +1063,6 @@ export class ChainsService {
         };
       }
 
-      // TODO
       // Reduce the confusion from different coin type on ecosystem.
       // Unite coin type for all chain to 118 with allowing alternatives.
       // (If coin type is 60, it is probably to be compatible with metamask. So, in this case, do nothing.)
@@ -1095,25 +1094,6 @@ export class ChainsService {
 
       newChainInfo = {
         ...newChainInfo,
-        ...(() => {
-          if (
-            newChainInfo.chainId === "mantra-1" ||
-            newChainInfo.chainId === "mantra-dukong-1"
-          ) {
-            return {
-              bip44: {
-                coinType: 60,
-              },
-              alternativeBIP44s: [
-                {
-                  coinType: 118,
-                },
-              ],
-            };
-          }
-
-          return {};
-        })(),
         currencies: newChainInfo.currencies.map((currency) => {
           // Normalize coinMinimalDenom for all currencies.
           const coinMinimalDenom = DenomHelper.normalizeDenom(

package/src/keyring/handler.ts

@@ -431,7 +431,7 @@ const handleExportKeyRingVaultsMsg: (
 const handleSearchKeyRingsMsg: (
   service: KeyRingService
 ) => InternalHandler<SearchKeyRingsMsg> = (service) => {
-  return async (_, msg) => {
-    return await service.searchKeyRings(msg.searchText);
+  return (_, msg) => {
+    return service.searchKeyRings(msg.searchText);
   };
 };

package/src/keyring/service.ts

@@ -469,12 +469,7 @@ export class KeyRingService {
                   continue;
                 }
 
-                if (
-                  chainInfo.bip44.coinType === 60 ||
-                  !!chainInfo.features?.includes("eth-address-gen") ||
-                  (!!chainInfo.features?.includes("eth-key-sign") &&
-                    !hasEthereum)
-                ) {
+                if (KeyRingService.isEthermintLike(chainInfo) && !hasEthereum) {
                   continue;
                 }
 
@@ -514,11 +509,7 @@ export class KeyRingService {
                 continue;
               }
 
-              if (
-                chainInfo.bip44.coinType === 60 ||
-                !!chainInfo.features?.includes("eth-address-gen") ||
-                !!chainInfo.features?.includes("eth-key-sign")
-              ) {
+              if (KeyRingService.isEthermintLike(chainInfo)) {
                 continue;
               }
 
@@ -1005,9 +996,7 @@ export class KeyRingService {
       },
     });
   }
-  getPubKeySelected(
-    chainId: string
-  ): Promise<{ pubKey: PubKeySecp256k1; coinType: number | undefined }> {
+  getPubKeySelected(chainId: string): Promise<PubKeySecp256k1> {
     return this.getPubKey(chainId, this.selectedVaultId);
   }
 
@@ -1133,10 +1122,7 @@ export class KeyRingService {
     return this.sign(chainId, this.selectedVaultId, data, digestMethod);
   }
 
-  getPubKey(
-    chainId: string,
-    vaultId: string
-  ): Promise<{ pubKey: PubKeySecp256k1; coinType: number | undefined }> {
+  getPubKey(chainId: string, vaultId: string): Promise<PubKeySecp256k1> {
     if (this.vaultService.isLocked) {
       throw new Error("KeyRing is locked");
     }
@@ -1259,7 +1245,7 @@ export class KeyRingService {
     vaultId: string,
     purpose: number,
     coinType: number
-  ): Promise<{ pubKey: PubKeySecp256k1; coinType: number | undefined }> {
+  ): Promise<PubKeySecp256k1> {
     if (this.vaultService.isLocked) {
       throw new Error("KeyRing is locked");
     }
@@ -1504,7 +1490,7 @@ export class KeyRingService {
     purpose: number,
     coinType: number,
     modularChainInfo: ModularChainInfo
-  ): Promise<{ pubKey: PubKeySecp256k1; coinType: number | undefined }> {
+  ): Promise<PubKeySecp256k1> {
     if (this.vaultService.isLocked) {
       throw new Error("KeyRing is locked");
     }
@@ -1534,7 +1520,7 @@ export class KeyRingService {
         (async () =>
           (
             await keyRing.getPubKey(vault, purpose, coinType, modularChainInfo)
-          ).pubKey.toBitcoinPubKey(network))()
+          ).toBitcoinPubKey(network))()
       );
     }
 
@@ -1813,10 +1799,10 @@ export class KeyRingService {
     throw new Error(`Unsupported keyRing ${type}`);
   }
 
-  async searchKeyRings(
+  searchKeyRings(
     searchText: string,
     ignoreChainEnabled: boolean = false
-  ): Promise<KeyInfo[]> {
+  ): KeyInfo[] {
     searchText = searchText.trim();
 
     const keyInfos = this.getKeyInfos();
@@ -1845,62 +1831,53 @@ export class KeyRingService {
       })();
 
       if (isHex) {
-        const asyncFilter = await Promise.all(
-          keyInfos.map(async (keyInfo) => {
-            const modularChainInfos =
-              this.chainsUIService.enabledModularChainInfosForVault(keyInfo.id);
-            // TODO: 다른 체인도 지원하기
-            const chainInfos = modularChainInfos
-              .filter((c) => "cosmos" in c)
-              .map((c) => {
-                if (!("cosmos" in c)) {
-                  throw new Error("Unsupported chain");
-                }
-                return c.cosmos;
-              });
-
-            let evmEnabled = false;
-            for (const chainInfo of chainInfos) {
-              const pubKey = await this.getPubKey(
-                chainInfo.chainId,
-                keyInfo.id
-              );
-              if (pubKey.coinType === 60) {
-                evmEnabled = true;
+        hexAddressSearchKeyInfos = keyInfos.filter((keyInfo) => {
+          const modularChainInfos =
+            this.chainsUIService.enabledModularChainInfosForVault(keyInfo.id);
+          // TODO: 다른 체인도 지원하기
+          const chainInfos = modularChainInfos
+            .filter((c) => "cosmos" in c)
+            .map((c) => {
+              if (!("cosmos" in c)) {
+                throw new Error("Unsupported chain");
               }
+              return c.cosmos;
+            });
+
+          let evmEnabled = false;
+          for (const chainInfo of chainInfos) {
+            if (KeyRingService.isEthermintLike(chainInfo)) {
+              evmEnabled = true;
             }
-            if (!evmEnabled && !ignoreChainEnabled) {
-              return false;
-            }
+          }
+          if (!evmEnabled && !ignoreChainEnabled) {
+            return false;
+          }
 
-            for (const [key, value] of Object.entries(keyInfo.insensitive)) {
-              for (const chainInfo of chainInfos) {
-                try {
-                  const hexAddress =
-                    KeyRingService.getAddressHexStringFromKeyInfo(
-                      chainInfo,
-                      keyInfo,
-                      key,
-                      value,
-                      true
-                    );
+          for (const [key, value] of Object.entries(keyInfo.insensitive)) {
+            for (const chainInfo of chainInfos) {
+              try {
+                const hexAddress =
+                  KeyRingService.getAddressHexStringFromKeyInfo(
+                    chainInfo,
+                    keyInfo,
+                    key,
+                    value,
+                    true
+                  );
 
-                  if (
-                    hexAddress.includes(
-                      searchText.replace("0x", "").toLowerCase()
-                    )
-                  ) {
-                    return true;
-                  }
-                } catch {
-                  // noop
+                if (
+                  hexAddress.includes(
+                    searchText.replace("0x", "").toLowerCase()
+                  )
+                ) {
+                  return true;
                 }
+              } catch {
+                // noop
               }
             }
-          })
-        );
-        hexAddressSearchKeyInfos = keyInfos.filter((_, i) => {
-          return asyncFilter[i];
+          }
         });
       }
     }
@@ -1934,78 +1911,69 @@ export class KeyRingService {
           return result;
         })();
 
-        const asyncFilter = await Promise.all(
-          keyInfos.map(async (keyInfo) => {
-            if (!ignoreChainEnabled) {
-              targetChainInfos = targetChainInfos.filter((chainInfo) => {
-                return this.chainsUIService.isEnabled(
-                  keyInfo.id,
-                  chainInfo.chainId
-                );
-              });
-            }
-
-            const chainInfos = (() => {
-              if (ignoreChainEnabled) {
-                return this.chainsService.getChainInfos();
-              }
-              return targetChainInfos.length > 0
-                ? targetChainInfos
-                : (() => {
-                    const modularChainInfos =
-                      this.chainsUIService.enabledModularChainInfosForVault(
-                        keyInfo.id
-                      );
-                    // TODO: 다른 체인도 지원하기
-                    return modularChainInfos
-                      .filter((c) => "cosmos" in c)
-                      .map((c) => {
-                        if (!("cosmos" in c)) {
-                          throw new Error("Unsupported chain");
-                        }
-                        return c.cosmos;
-                      });
-                  })();
-            })();
+        bech32AddressSearchKeyInfos = keyInfos.filter((keyInfo) => {
+          if (!ignoreChainEnabled) {
+            targetChainInfos = targetChainInfos.filter((chainInfo) => {
+              return this.chainsUIService.isEnabled(
+                keyInfo.id,
+                chainInfo.chainId
+              );
+            });
+          }
 
-            for (const chainInfo of chainInfos) {
-              for (const [key, value] of Object.entries(keyInfo.insensitive)) {
-                try {
-                  const pubKey = await this.getPubKey(
-                    chainInfo.chainId,
-                    keyInfo.id
-                  );
-                  const isEVM = pubKey.coinType === 60;
-
-                  const hexAddress =
-                    KeyRingService.getAddressHexStringFromKeyInfo(
-                      chainInfo,
-                      keyInfo,
-                      key,
-                      value,
-                      isEVM
+          const chainInfos = (() => {
+            if (ignoreChainEnabled) {
+              return this.chainsService.getChainInfos();
+            }
+            return targetChainInfos.length > 0
+              ? targetChainInfos
+              : (() => {
+                  const modularChainInfos =
+                    this.chainsUIService.enabledModularChainInfosForVault(
+                      keyInfo.id
                     );
+                  // TODO: 다른 체인도 지원하기
+                  return modularChainInfos
+                    .filter((c) => "cosmos" in c)
+                    .map((c) => {
+                      if (!("cosmos" in c)) {
+                        throw new Error("Unsupported chain");
+                      }
+                      return c.cosmos;
+                    });
+                })();
+          })();
+
+          for (const chainInfo of chainInfos) {
+            for (const [key, value] of Object.entries(keyInfo.insensitive)) {
+              try {
+                const isEVM = KeyRingService.isEthermintLike(chainInfo);
+
+                const hexAddress =
+                  KeyRingService.getAddressHexStringFromKeyInfo(
+                    chainInfo,
+                    keyInfo,
+                    key,
+                    value,
+                    isEVM
+                  );
 
-                  if (chainInfo.bech32Config == null) {
-                    return false;
-                  }
+                if (chainInfo.bech32Config == null) {
+                  return false;
+                }
 
-                  const bech32Address = this.getKeySearchBech32FromHex(
-                    chainInfo.bech32Config.bech32PrefixAccAddr,
-                    hexAddress
-                  );
-                  if (bech32Address.includes(searchText.toLowerCase())) {
-                    return true;
-                  }
-                } catch {
-                  // noop
+                const bech32Address = this.getKeySearchBech32FromHex(
+                  chainInfo.bech32Config.bech32PrefixAccAddr,
+                  hexAddress
+                );
+                if (bech32Address.includes(searchText.toLowerCase())) {
+                  return true;
                 }
+              } catch {
+                // noop
               }
             }
-          })
-        );
-        bech32AddressSearchKeyInfos = keyInfos.filter((_, i) => {
-          return asyncFilter[i];
+          }
         });
       }
     }
@@ -2141,4 +2109,12 @@ export class KeyRingService {
       throw new Error("Invalid address index in hd path");
     }
   }
+
+  static isEthermintLike(chainInfo: ChainInfo): boolean {
+    return (
+      chainInfo.bip44.coinType === 60 ||
+      !!chainInfo.features?.includes("eth-address-gen") ||
+      !!chainInfo.features?.includes("eth-key-sign")
+    );
+  }
 }

package/src/keyring/types.ts

@@ -41,9 +41,7 @@ export interface KeyRing {
     purpose: number,
     coinType: number,
     modularChainInfo: ModularChainInfo
-  ):
-    | { pubKey: PubKeySecp256k1; coinType: number | undefined }
-    | Promise<{ pubKey: PubKeySecp256k1; coinType: number | undefined }>;
+  ): PubKeySecp256k1 | Promise<PubKeySecp256k1>;
   // This method should only be implemented for Ledger keyring.
   getPubKeyStarknet?(
     vault: Vault,

package/src/keyring-cosmos/handler.ts

@@ -358,7 +358,7 @@ const handleGetCosmosKeysForEachVaultWithSearchSettledMsg: (
   service
 ) => {
   return async (_, msg) => {
-    const searched = await service.keyRingService.searchKeyRings(
+    const searched = service.keyRingService.searchKeyRings(
       msg.searchText,
       true
     );