@keplr-wallet/background 0.12.272 → 0.12.273-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keplr-wallet/background",
-  "version": "0.12.272",
+  "version": "0.12.273-alpha.1",
   "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.272",
-    "@keplr-wallet/common": "0.12.272",
-    "@keplr-wallet/cosmos": "0.12.272",
-    "@keplr-wallet/crypto": "0.12.272",
-    "@keplr-wallet/ledger-cosmos": "0.12.272",
-    "@keplr-wallet/popup": "0.12.272",
-    "@keplr-wallet/proto-types": "0.12.272",
-    "@keplr-wallet/router": "0.12.272",
-    "@keplr-wallet/simple-fetch": "0.12.272",
-    "@keplr-wallet/types": "0.12.272",
-    "@keplr-wallet/unit": "0.12.272",
+    "@keplr-wallet/chain-validator": "0.12.273-alpha.1",
+    "@keplr-wallet/common": "0.12.273-alpha.1",
+    "@keplr-wallet/cosmos": "0.12.273-alpha.1",
+    "@keplr-wallet/crypto": "0.12.273-alpha.1",
+    "@keplr-wallet/ledger-cosmos": "0.12.273-alpha.1",
+    "@keplr-wallet/popup": "0.12.273-alpha.1",
+    "@keplr-wallet/proto-types": "0.12.273-alpha.1",
+    "@keplr-wallet/router": "0.12.273-alpha.1",
+    "@keplr-wallet/simple-fetch": "0.12.273-alpha.1",
+    "@keplr-wallet/types": "0.12.273-alpha.1",
+    "@keplr-wallet/unit": "0.12.273-alpha.1",
     "@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": "6e41576f45372d14806724238d5d45f9a7d3f1ff"
+  "gitHead": "1eb0b05baebffae0d009daf99dee7cd4e70783ea"
 }

package/src/chains/service.ts

@@ -1063,6 +1063,7 @@ 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.)
@@ -1086,8 +1087,33 @@ export class ChainsService {
         };
       }
 
+      let features = [...(newChainInfo.features ?? [])];
+      if (features.includes("evm-feemarket")) {
+        // evm-feemarket and feemarket is incompatible.
+        features = features.filter((f) => f !== "feemarket");
+      }
+
       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(
@@ -1128,6 +1154,7 @@ export class ChainsService {
             coinMinimalDenom,
           };
         }),
+        features,
       };
       return newChainInfo;
     });

package/src/keyring/handler.ts

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

package/src/keyring/service.ts

@@ -469,7 +469,12 @@ export class KeyRingService {
                   continue;
                 }
 
-                if (KeyRingService.isEthermintLike(chainInfo) && !hasEthereum) {
+                if (
+                  chainInfo.bip44.coinType === 60 ||
+                  !!chainInfo.features?.includes("eth-address-gen") ||
+                  (!!chainInfo.features?.includes("eth-key-sign") &&
+                    !hasEthereum)
+                ) {
                   continue;
                 }
 
@@ -509,7 +514,11 @@ export class KeyRingService {
                 continue;
               }
 
-              if (KeyRingService.isEthermintLike(chainInfo)) {
+              if (
+                chainInfo.bip44.coinType === 60 ||
+                !!chainInfo.features?.includes("eth-address-gen") ||
+                !!chainInfo.features?.includes("eth-key-sign")
+              ) {
                 continue;
               }
 
@@ -996,7 +1005,9 @@ export class KeyRingService {
       },
     });
   }
-  getPubKeySelected(chainId: string): Promise<PubKeySecp256k1> {
+  getPubKeySelected(
+    chainId: string
+  ): Promise<{ pubKey: PubKeySecp256k1; coinType: number | undefined }> {
     return this.getPubKey(chainId, this.selectedVaultId);
   }
 
@@ -1122,7 +1133,10 @@ export class KeyRingService {
     return this.sign(chainId, this.selectedVaultId, data, digestMethod);
   }
 
-  getPubKey(chainId: string, vaultId: string): Promise<PubKeySecp256k1> {
+  getPubKey(
+    chainId: string,
+    vaultId: string
+  ): Promise<{ pubKey: PubKeySecp256k1; coinType: number | undefined }> {
     if (this.vaultService.isLocked) {
       throw new Error("KeyRing is locked");
     }
@@ -1245,7 +1259,7 @@ export class KeyRingService {
     vaultId: string,
     purpose: number,
     coinType: number
-  ): Promise<PubKeySecp256k1> {
+  ): Promise<{ pubKey: PubKeySecp256k1; coinType: number | undefined }> {
     if (this.vaultService.isLocked) {
       throw new Error("KeyRing is locked");
     }
@@ -1490,7 +1504,7 @@ export class KeyRingService {
     purpose: number,
     coinType: number,
     modularChainInfo: ModularChainInfo
-  ): Promise<PubKeySecp256k1> {
+  ): Promise<{ pubKey: PubKeySecp256k1; coinType: number | undefined }> {
     if (this.vaultService.isLocked) {
       throw new Error("KeyRing is locked");
     }
@@ -1520,7 +1534,7 @@ export class KeyRingService {
         (async () =>
           (
             await keyRing.getPubKey(vault, purpose, coinType, modularChainInfo)
-          ).toBitcoinPubKey(network))()
+          ).pubKey.toBitcoinPubKey(network))()
       );
     }
 
@@ -1799,10 +1813,10 @@ export class KeyRingService {
     throw new Error(`Unsupported keyRing ${type}`);
   }
 
-  searchKeyRings(
+  async searchKeyRings(
     searchText: string,
     ignoreChainEnabled: boolean = false
-  ): KeyInfo[] {
+  ): Promise<KeyInfo[]> {
     searchText = searchText.trim();
 
     const keyInfos = this.getKeyInfos();
@@ -1831,53 +1845,62 @@ export class KeyRingService {
       })();
 
       if (isHex) {
-        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;
-            });
+        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) {
-            if (KeyRingService.isEthermintLike(chainInfo)) {
-              evmEnabled = true;
+            let evmEnabled = false;
+            for (const chainInfo of chainInfos) {
+              const pubKey = await this.getPubKey(
+                chainInfo.chainId,
+                keyInfo.id
+              );
+              if (pubKey.coinType === 60) {
+                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;
+                  if (
+                    hexAddress.includes(
+                      searchText.replace("0x", "").toLowerCase()
+                    )
+                  ) {
+                    return true;
+                  }
+                } catch {
+                  // noop
                 }
-              } catch {
-                // noop
               }
             }
-          }
+          })
+        );
+        hexAddressSearchKeyInfos = keyInfos.filter((_, i) => {
+          return asyncFilter[i];
         });
       }
     }
@@ -1911,69 +1934,78 @@ export class KeyRingService {
           return result;
         })();
 
-        bech32AddressSearchKeyInfos = keyInfos.filter((keyInfo) => {
-          if (!ignoreChainEnabled) {
-            targetChainInfos = targetChainInfos.filter((chainInfo) => {
-              return this.chainsUIService.isEnabled(
-                keyInfo.id,
-                chainInfo.chainId
-              );
-            });
-          }
-
-          const chainInfos = (() => {
-            if (ignoreChainEnabled) {
-              return this.chainsService.getChainInfos();
+        const asyncFilter = await Promise.all(
+          keyInfos.map(async (keyInfo) => {
+            if (!ignoreChainEnabled) {
+              targetChainInfos = targetChainInfos.filter((chainInfo) => {
+                return this.chainsUIService.isEnabled(
+                  keyInfo.id,
+                  chainInfo.chainId
+                );
+              });
             }
-            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
+
+            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 pubKey = await this.getPubKey(
+                    chainInfo.chainId,
+                    keyInfo.id
                   );
+                  const isEVM = pubKey.coinType === 60;
+
+                  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;
+                  const bech32Address = this.getKeySearchBech32FromHex(
+                    chainInfo.bech32Config.bech32PrefixAccAddr,
+                    hexAddress
+                  );
+                  if (bech32Address.includes(searchText.toLowerCase())) {
+                    return true;
+                  }
+                } catch {
+                  // noop
                 }
-              } catch {
-                // noop
               }
             }
-          }
+          })
+        );
+        bech32AddressSearchKeyInfos = keyInfos.filter((_, i) => {
+          return asyncFilter[i];
         });
       }
     }
@@ -2109,12 +2141,4 @@ 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,7 +41,9 @@ export interface KeyRing {
     purpose: number,
     coinType: number,
     modularChainInfo: ModularChainInfo
-  ): PubKeySecp256k1 | Promise<PubKeySecp256k1>;
+  ):
+    | { pubKey: PubKeySecp256k1; coinType: number | undefined }
+    | Promise<{ pubKey: PubKeySecp256k1; coinType: number | undefined }>;
   // 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 = service.keyRingService.searchKeyRings(
+    const searched = await service.keyRingService.searchKeyRings(
       msg.searchText,
       true
     );