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

package/src/keyring-cosmos/service.ts

@@ -1,5 +1,5 @@
 import { ChainsService } from "../chains";
-import { DEFAULT_BIP44_PURPOSE, KeyRingService } from "../keyring";
+import { KeyRingService, DEFAULT_BIP44_PURPOSE } from "../keyring";
 import {
   AminoSignResponse,
   ChainInfo,
@@ -15,7 +15,6 @@ import {
   Bech32Address,
   ChainIdHelper,
   checkAndValidateADR36AminoSignDoc,
-  encodePubKey,
   encodeSecp256k1Pubkey,
   encodeSecp256k1Signature,
   EthermintChainIdHelper,
@@ -109,25 +108,29 @@ export class KeyRingCosmosService {
 
     const pubKey = await this.keyRingService.getPubKey(chainId, vaultId);
 
+    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
+    const evmInfo = ChainsService.getEVMInfo(chainInfo);
+    const forceEVMLedger = chainInfo.features?.includes(
+      "force-enable-evm-ledger"
+    );
+
     const keyInfo = this.keyRingService.getKeyInfo(vaultId);
     if (!keyInfo) {
       throw new Error("Null key info");
     }
 
-    const isEthermintLike = pubKey.coinType === 60;
-
-    if (isEthermintLike && keyInfo.type === "ledger") {
+    if (isEthermintLike && keyInfo.type === "ledger" && !forceEVMLedger) {
       KeyRingCosmosService.throwErrorIfEthermintWithLedgerButNotSupported(
         chainId
       );
     }
 
     const address = (() => {
-      if (isEthermintLike) {
-        return pubKey.pubKey.getEthAddress();
+      if (isEthermintLike || evmInfo !== undefined) {
+        return pubKey.getEthAddress();
       }
 
-      return pubKey.pubKey.getCosmosAddress();
+      return pubKey.getCosmosAddress();
     })();
 
     const bech32Address = new Bech32Address(address);
@@ -135,7 +138,7 @@ export class KeyRingCosmosService {
     return {
       name: this.keyRingService.getKeyRingName(vaultId),
       algo: isEthermintLike ? "ethsecp256k1" : "secp256k1",
-      pubKey: pubKey.pubKey.toBytes(),
+      pubKey: pubKey.toBytes(),
       address,
       bech32Address: bech32Address.toBech32(
         chainInfo.bech32Config?.bech32PrefixAccAddr ?? ""
@@ -162,13 +165,15 @@ export class KeyRingCosmosService {
       coinTypes.push(...chainInfo.alternativeBIP44s.map((alt) => alt.coinType));
     }
 
+    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
+
     const res: {
       coinType: number;
       bech32Address: string;
     }[] = [];
 
     for (const coinType of coinTypes) {
-      let pubKey: { pubKey: PubKeySecp256k1; coinType: number | undefined };
+      let pubKey: PubKeySecp256k1;
       try {
         pubKey = await this.keyRingService.getPubKeyWithNotFinalizedCoinType(
           chainId,
@@ -176,21 +181,17 @@ export class KeyRingCosmosService {
           DEFAULT_BIP44_PURPOSE,
           coinType
         );
-        // coin type이 명시되지 않는다면 coin type을 처리할 수 없는 keyring이라고 가정하고 처리하지 않는다.
-        if (pubKey.coinType == null) {
-          return [];
-        }
       } catch (e) {
         console.log(e);
         continue;
       }
 
       const address = (() => {
-        if (pubKey.coinType === 60) {
-          return pubKey.pubKey.getEthAddress();
+        if (isEthermintLike) {
+          return pubKey.getEthAddress();
         }
 
-        return pubKey.pubKey.getCosmosAddress();
+        return pubKey.getCosmosAddress();
       })();
 
       const bech32Address = new Bech32Address(address);
@@ -238,8 +239,7 @@ export class KeyRingCosmosService {
     if (chainInfo.hideInUI) {
       throw new Error("Can't sign for hidden chain");
     }
-    const key = await this.getKey(vaultId, chainId);
-    const isEthermintLike = key.algo === "ethsecp256k1";
+    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
     const forceEVMLedger = chainInfo.features?.includes(
       "force-enable-evm-ledger"
     );
@@ -263,6 +263,7 @@ export class KeyRingCosmosService {
     signDoc = trimAminoSignDoc(signDoc);
     signDoc = sortObjectByKey(signDoc);
 
+    const key = await this.getKey(vaultId, chainId);
     const bech32Prefix =
       this.chainsService.getChainInfoOrThrow(chainId).bech32Config
         ?.bech32PrefixAccAddr ?? "";
@@ -306,7 +307,6 @@ export class KeyRingCosmosService {
         signOptions,
         keyType: keyInfo.type,
         keyInsensitive: keyInfo.insensitive,
-        isEthermintLike,
       },
       async (res: { newSignDoc: StdSignDoc; signature?: Uint8Array }) => {
         let newSignDoc = res.newSignDoc;
@@ -385,8 +385,7 @@ export class KeyRingCosmosService {
 
     const vaultId = this.keyRingService.selectedVaultId;
 
-    const key = await this.getKey(vaultId, chainId);
-    const isEthermintLike = key.algo === "ethsecp256k1";
+    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
     const forceEVMLedger = chainInfo.features?.includes(
       "force-enable-evm-ledger"
     );
@@ -410,6 +409,7 @@ export class KeyRingCosmosService {
     signDoc = trimAminoSignDoc(signDoc);
     signDoc = sortObjectByKey(signDoc);
 
+    const key = await this.getKey(vaultId, chainId);
     const bech32Prefix =
       this.chainsService.getChainInfoOrThrow(chainId).bech32Config
         ?.bech32PrefixAccAddr ?? "";
@@ -488,8 +488,7 @@ export class KeyRingCosmosService {
 
     const vaultId = this.keyRingService.selectedVaultId;
 
-    const key = await this.getKey(vaultId, chainId);
-    const isEthermintLike = key.algo === "ethsecp256k1";
+    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
     const forceEVMLedger = chainInfo.features?.includes(
       "force-enable-evm-ledger"
     );
@@ -513,6 +512,7 @@ export class KeyRingCosmosService {
     signDoc = trimAminoSignDoc(signDoc);
     signDoc = sortObjectByKey(signDoc);
 
+    const key = await this.getKey(vaultId, chainId);
     const bech32Prefix =
       this.chainsService.getChainInfoOrThrow(chainId).bech32Config
         ?.bech32PrefixAccAddr ?? "";
@@ -625,8 +625,7 @@ export class KeyRingCosmosService {
 
     const vaultId = this.keyRingService.selectedVaultId;
 
-    const key = await this.getKey(vaultId, chainId);
-    const isEthermintLike = key.algo === "ethsecp256k1";
+    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
     const forceEVMLedger = chainInfo.features?.includes(
       "force-enable-evm-ledger"
     );
@@ -650,6 +649,7 @@ export class KeyRingCosmosService {
     signDoc = trimAminoSignDoc(signDoc);
     signDoc = sortObjectByKey(signDoc);
 
+    const key = await this.getKey(vaultId, chainId);
     const bech32Prefix =
       this.chainsService.getChainInfoOrThrow(chainId).bech32Config
         ?.bech32PrefixAccAddr ?? "";
@@ -747,8 +747,7 @@ export class KeyRingCosmosService {
     if (chainInfo.hideInUI) {
       throw new Error("Can't sign for hidden chain");
     }
-    const key = await this.getKey(vaultId, chainId);
-    const isEthermintLike = key.algo === "ethsecp256k1";
+    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
     const forceEVMLedger = chainInfo.features?.includes(
       "force-enable-evm-ledger"
     );
@@ -764,6 +763,7 @@ export class KeyRingCosmosService {
       );
     }
 
+    const key = await this.getKey(vaultId, chainId);
     const bech32Prefix =
       this.chainsService.getChainInfoOrThrow(chainId).bech32Config
         ?.bech32PrefixAccAddr ?? "";
@@ -787,7 +787,6 @@ export class KeyRingCosmosService {
         signOptions,
         keyType: keyInfo.type,
         keyInsensitive: keyInfo.insensitive,
-        isEthermintLike,
       },
       async (res: { newSignDoc: StdSignDoc; signature?: Uint8Array }) => {
         const newSignDoc = res.newSignDoc;
@@ -847,8 +846,7 @@ export class KeyRingCosmosService {
     if (chainInfo.hideInUI) {
       throw new Error("Can't sign for hidden chain");
     }
-    const key = await this.getKey(vaultId, chainId);
-    const isEthermintLike = key.algo === "ethsecp256k1";
+    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
     const forceEVMLedger = chainInfo.features?.includes(
       "force-enable-evm-ledger"
     );
@@ -864,24 +862,7 @@ export class KeyRingCosmosService {
       );
     }
 
-    if (!env.isInternalMsg && key.algo === "ethsecp256k1") {
-      const authInfo = AuthInfo.decode(signDoc.authInfoBytes);
-      if (
-        authInfo.signerInfos.length === 1 &&
-        authInfo.signerInfos[0].publicKey?.typeUrl ===
-          "/cosmos.crypto.secp256k1.PubKey"
-      ) {
-        signDoc.authInfoBytes = AuthInfo.encode({
-          ...authInfo,
-          signerInfos: [
-            {
-              ...authInfo.signerInfos[0],
-              publicKey: encodePubKey(chainInfo, true, key.pubKey),
-            },
-          ],
-        }).finish();
-      }
-    }
+    const key = await this.getKey(vaultId, chainId);
     const bech32Prefix =
       this.chainsService.getChainInfoOrThrow(chainId).bech32Config
         ?.bech32PrefixAccAddr ?? "";
@@ -904,7 +885,6 @@ export class KeyRingCosmosService {
         signOptions,
         keyType: keyInfo.type,
         keyInsensitive: keyInfo.insensitive,
-        isEthermintLike,
       },
       async (res: { newSignDocBytes: Uint8Array; signature?: Uint8Array }) => {
         const newSignDocBytes = res.newSignDocBytes;
@@ -1006,8 +986,7 @@ export class KeyRingCosmosService {
     if (chainInfo.hideInUI) {
       throw new Error("Can't sign for hidden chain");
     }
-    const key = await this.getKey(vaultId, chainId);
-    const isEthermintLike = key.algo === "ethsecp256k1";
+    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
     const forceEVMLedger = chainInfo.features?.includes(
       "force-enable-evm-ledger"
     );
@@ -1023,6 +1002,7 @@ export class KeyRingCosmosService {
       );
     }
 
+    const key = await this.getKey(vaultId, chainId);
     const bech32Prefix =
       this.chainsService.getChainInfoOrThrow(chainId).bech32Config
         ?.bech32PrefixAccAddr ?? "";
@@ -1144,9 +1124,9 @@ export class KeyRingCosmosService {
     signature: StdSignature
   ): Promise<boolean> {
     const chainInfo = this.chainsService.getChainInfoOrThrow(chainId);
-    const key = await this.getKey(vaultId, chainId);
-    const isEthermintLike = key.algo === "ethsecp256k1";
+    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
 
+    const key = await this.getKey(vaultId, chainId);
     const bech32Prefix = chainInfo.bech32Config?.bech32PrefixAccAddr ?? "";
     const bech32Address = new Bech32Address(key.address).toBech32(bech32Prefix);
     if (signer !== bech32Address) {
@@ -1215,8 +1195,7 @@ export class KeyRingCosmosService {
     if (chainInfo.hideInUI) {
       throw new Error("Can't sign for hidden chain");
     }
-    const key = await this.getKey(vaultId, chainId);
-    const isEthermintLike = key.algo === "ethsecp256k1";
+    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
     const forceEVMLedger = chainInfo.features?.includes(
       "force-enable-evm-ledger"
     );
@@ -1268,6 +1247,7 @@ export class KeyRingCosmosService {
     signDoc = trimAminoSignDoc(signDoc);
     signDoc = sortObjectByKey(signDoc);
 
+    const key = await this.getKey(vaultId, chainId);
     const bech32Prefix =
       this.chainsService.getChainInfoOrThrow(chainId).bech32Config
         ?.bech32PrefixAccAddr ?? "";
@@ -1456,8 +1436,9 @@ export class KeyRingCosmosService {
 
         const ownerBech32 = Bech32Address.fromBech32(owner);
         for (const accountInfo of interactionInfo.accountInfos) {
-          const key = await this.getKey(vaultId, chainId);
-          const isEthermintLike = key.algo === "ethsecp256k1";
+          const isEthermintLike = KeyRingService.isEthermintLike(
+            this.chainsService.getChainInfoOrThrow(accountInfo.chainId)
+          );
 
           if (
             ownerBech32.toHex(false) !==

package/src/keyring-ethereum/service.ts

@@ -87,8 +87,7 @@ export class KeyRingEthereumService {
     if (chainInfo.hideInUI) {
       throw new Error("Can't sign for hidden chain");
     }
-    const key = await this.keyRingCosmosService.getKey(vaultId, chainId);
-    const isEthermintLike = key.algo === "ethsecp256k1";
+    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
     const evmInfo = ChainsService.getEVMInfo(chainInfo);
     const forceEVMLedger = chainInfo.features?.includes(
       "force-enable-evm-ledger"
@@ -125,6 +124,7 @@ export class KeyRingEthereumService {
       ).toLowerCase();
     }
 
+    const key = await this.keyRingCosmosService.getKey(vaultId, chainId);
     if (
       signer !== key.bech32Address &&
       signer !== key.ethereumHexAddress.toLowerCase()
@@ -348,13 +348,8 @@ export class KeyRingEthereumService {
             const pubkey = await this.keyRingService.getPubKeySelected(
               currentChainId
             );
-            if (pubkey.coinType !== 60) {
-              throw new Error(
-                "Can't use ethereum json rpc if coin type is not 60"
-              );
-            }
             const selectedAddress = `0x${Buffer.from(
-              pubkey.pubKey.getEthAddress()
+              pubkey.getEthAddress()
             ).toString("hex")}`;
 
             return {
@@ -373,13 +368,8 @@ export class KeyRingEthereumService {
             const pubkey = await this.keyRingService.getPubKeySelected(
               currentChainId
             );
-            if (pubkey.coinType !== 60) {
-              throw new Error(
-                "Can't use ethereum json rpc if coin type is not 60"
-              );
-            }
             const selectedAddress = `0x${Buffer.from(
-              pubkey.pubKey.getEthAddress()
+              pubkey.getEthAddress()
             ).toString("hex")}`;
 
             return {
@@ -412,13 +402,8 @@ export class KeyRingEthereumService {
           const pubkey = await this.keyRingService.getPubKeySelected(
             currentChainId
           );
-          if (pubkey.coinType !== 60) {
-            throw new Error(
-              "Can't use ethereum json rpc if coin type is not 60"
-            );
-          }
           const selectedAddress = `0x${Buffer.from(
-            pubkey.pubKey.getEthAddress()
+            pubkey.getEthAddress()
           ).toString("hex")}`;
 
           return [selectedAddress];
@@ -428,13 +413,8 @@ export class KeyRingEthereumService {
           const pubkey = await this.keyRingService.getPubKeySelected(
             currentChainId
           );
-          if (pubkey.coinType !== 60) {
-            throw new Error(
-              "Can't use ethereum json rpc if coin type is not 60"
-            );
-          }
           const selectedAddress = `0x${Buffer.from(
-            pubkey.pubKey.getEthAddress()
+            pubkey.getEthAddress()
           ).toString("hex")}`;
 
           return [selectedAddress];
@@ -497,13 +477,8 @@ export class KeyRingEthereumService {
           const pubkey = await this.keyRingService.getPubKeySelected(
             currentChainId
           );
-          if (pubkey.coinType !== 60) {
-            throw new Error(
-              "Can't use ethereum json rpc if coin type is not 60"
-            );
-          }
           const selectedAddress = `0x${Buffer.from(
-            pubkey.pubKey.getEthAddress()
+            pubkey.getEthAddress()
           ).toString("hex")}`;
 
           const transactionCount = await this.request(
@@ -623,13 +598,8 @@ export class KeyRingEthereumService {
           const pubkey = await this.keyRingService.getPubKeySelected(
             currentChainId
           );
-          if (pubkey.coinType !== 60) {
-            throw new Error(
-              "Can't use ethereum json rpc if coin type is not 60"
-            );
-          }
           const selectedAddress = `0x${Buffer.from(
-            pubkey.pubKey.getEthAddress()
+            pubkey.getEthAddress()
           ).toString("hex")}`;
 
           const transactionCount = await this.request(

package/src/keyring-keystone/service.ts

@@ -38,14 +38,7 @@ export class KeyRingKeystoneService {
     });
   }
 
-  getPubKey(
-    vault: Vault,
-    purpose: number,
-    coinType: number
-  ): {
-    pubKey: PubKeySecp256k1;
-    coinType: number;
-  } {
+  getPubKey(vault: Vault, purpose: number, coinType: number): PubKeySecp256k1 {
     let bytes;
     if (vault.insensitive["keys"]) {
       const path = Object.keys(vault.insensitive["keys"]).find((path) => {
@@ -66,10 +59,7 @@ export class KeyRingKeystoneService {
     } else {
       throw new Error(`Keystone is not initialized.`);
     }
-    return {
-      pubKey: new PubKeySecp256k1(bytes),
-      coinType,
-    };
+    return new PubKeySecp256k1(bytes);
   }
 
   sign(): {

package/src/keyring-ledger/service.ts

@@ -3,10 +3,10 @@ import { Buffer } from "buffer/";
 import { PubKeySecp256k1, PubKeyStarknet } from "@keplr-wallet/crypto";
 import { KeplrError } from "@keplr-wallet/router";
 import { ModularChainInfo } from "@keplr-wallet/types";
+import { KeyRingService } from "../keyring";
 import { Network as BitcoinNetwork } from "bitcoinjs-lib";
 import { PubKeyBitcoinCompatible } from "@keplr-wallet/crypto";
 import { Descriptor } from "../keyring-bitcoin";
-import { App, AppCoinType } from "@keplr-wallet/ledger-cosmos";
 
 export class KeyRingLedgerService {
   async init(): Promise<void> {
@@ -43,12 +43,9 @@ export class KeyRingLedgerService {
   getPubKey(
     vault: Vault,
     _purpose: number,
-    coinType: number,
+    _coinType: number,
     modularChainInfo: ModularChainInfo
-  ): {
-    pubKey: PubKeySecp256k1;
-    coinType: number;
-  } {
+  ): PubKeySecp256k1 {
     if ("starknet" in modularChainInfo) {
       throw new Error(
         "'getPubKeyStarknet' should be called for Starknet chain"
@@ -61,7 +58,10 @@ export class KeyRingLedgerService {
 
     let app = "Cosmos";
 
-    if (coinType === 60) {
+    const isEthermintLike = KeyRingService.isEthermintLike(
+      modularChainInfo.cosmos
+    );
+    if (isEthermintLike) {
       app = "Ethereum";
       if (!vault.insensitive[app]) {
         throw new KeplrError(
@@ -83,12 +83,6 @@ export class KeyRingLedgerService {
       if (vault.insensitive["THORChain"]) {
         app = "THORChain";
       }
-
-      const appCoinType = AppCoinType[app as App];
-      if (appCoinType == null) {
-        throw new Error(`CoinType is null: ${app}`);
-      }
-      coinType = appCoinType;
     }
 
     if (!vault.insensitive[app]) {
@@ -99,10 +93,7 @@ export class KeyRingLedgerService {
       (vault.insensitive[app] as any)["pubKey"] as string,
       "hex"
     );
-    return {
-      pubKey: new PubKeySecp256k1(bytes),
-      coinType,
-    };
+    return new PubKeySecp256k1(bytes);
   }
 
   getPubKeyStarknet(

package/src/keyring-mnemonic/service.ts

@@ -65,21 +65,14 @@ export class KeyRingMnemonicService {
     });
   }
 
-  getPubKey(
-    vault: Vault,
-    purpose: number,
-    coinType: number
-  ): { pubKey: PubKeySecp256k1; coinType: number } {
+  getPubKey(vault: Vault, purpose: number, coinType: number): PubKeySecp256k1 {
     const bip44Path = this.getBIP44PathFromVault(vault);
 
     const tag = `pubKey-m/${purpose}'/${coinType}'/${bip44Path.account}'/${bip44Path.change}/${bip44Path.addressIndex}`;
 
     if (vault.insensitive[tag]) {
       const pubKey = Buffer.from(vault.insensitive[tag] as string, "hex");
-      return {
-        coinType,
-        pubKey: new PubKeySecp256k1(pubKey),
-      };
+      return new PubKeySecp256k1(pubKey);
     }
 
     const privKey = this.getPrivKey(vault, purpose, coinType);
@@ -91,10 +84,7 @@ export class KeyRingMnemonicService {
       [tag]: pubKeyText,
     });
 
-    return {
-      coinType,
-      pubKey,
-    };
+    return pubKey;
   }
 
   getPubKeyBitcoin(

package/src/keyring-private-key/service.ts

@@ -44,16 +44,13 @@ export class KeyRingPrivateKeyService {
     });
   }
 
-  getPubKey(vault: Vault): { pubKey: PubKeySecp256k1; coinType: undefined } {
+  getPubKey(vault: Vault): PubKeySecp256k1 {
     const publicKeyBytes = Buffer.from(
       vault.insensitive["publicKey"] as string,
       "hex"
     );
 
-    return {
-      pubKey: new PubKeySecp256k1(publicKeyBytes),
-      coinType: undefined,
-    };
+    return new PubKeySecp256k1(publicKeyBytes);
   }
 
   sign(

package/src/keyring-starknet/service.ts

@@ -197,8 +197,7 @@ export class KeyRingStarknetService {
         );
 
         return {
-          pubKey: (await this.keyRingService.getPubKey(chainId, vaultId))
-            .pubKey,
+          pubKey: await this.keyRingService.getPubKey(chainId, vaultId),
           salt: Hash.sha256(Buffer.concat([sig.r, sig.s])).slice(0, 24),
           classHash: Buffer.from(EthAccountUpgradeableClassHash, "hex"),
         };

package/src/token-scan/service.ts

@@ -325,11 +325,8 @@ export class TokenScanService {
       if (this.chainsService.isEvmOnlyChain(chainId)) {
         const evmInfo = this.chainsService.getEVMInfoOrThrow(chainId);
         const pubkey = await this.keyRingService.getPubKey(chainId, vaultId);
-        if (pubkey.coinType !== 60) {
-          return;
-        }
         const ethereumHexAddress = `0x${Buffer.from(
-          pubkey.pubKey.getEthAddress()
+          pubkey.getEthAddress()
         ).toString("hex")}`;
 
         const res = await simpleFetch<{