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

package/src/keyring-cosmos/service.ts

@@ -1,5 +1,5 @@
 import { ChainsService } from "../chains";
-import { KeyRingService, DEFAULT_BIP44_PURPOSE } from "../keyring";
+import { DEFAULT_BIP44_PURPOSE, KeyRingService } from "../keyring";
 import {
   AminoSignResponse,
   ChainInfo,
@@ -15,6 +15,7 @@ import {
   Bech32Address,
   ChainIdHelper,
   checkAndValidateADR36AminoSignDoc,
+  encodePubKey,
   encodeSecp256k1Pubkey,
   encodeSecp256k1Signature,
   EthermintChainIdHelper,
@@ -108,29 +109,25 @@ 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");
     }
 
-    if (isEthermintLike && keyInfo.type === "ledger" && !forceEVMLedger) {
+    const isEthermintLike = pubKey.coinType === 60;
+
+    if (isEthermintLike && keyInfo.type === "ledger") {
       KeyRingCosmosService.throwErrorIfEthermintWithLedgerButNotSupported(
         chainId
       );
     }
 
     const address = (() => {
-      if (isEthermintLike || evmInfo !== undefined) {
-        return pubKey.getEthAddress();
+      if (isEthermintLike) {
+        return pubKey.pubKey.getEthAddress();
       }
 
-      return pubKey.getCosmosAddress();
+      return pubKey.pubKey.getCosmosAddress();
     })();
 
     const bech32Address = new Bech32Address(address);
@@ -138,7 +135,7 @@ export class KeyRingCosmosService {
     return {
       name: this.keyRingService.getKeyRingName(vaultId),
       algo: isEthermintLike ? "ethsecp256k1" : "secp256k1",
-      pubKey: pubKey.toBytes(),
+      pubKey: pubKey.pubKey.toBytes(),
       address,
       bech32Address: bech32Address.toBech32(
         chainInfo.bech32Config?.bech32PrefixAccAddr ?? ""
@@ -165,15 +162,13 @@ 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: PubKeySecp256k1;
+      let pubKey: { pubKey: PubKeySecp256k1; coinType: number | undefined };
       try {
         pubKey = await this.keyRingService.getPubKeyWithNotFinalizedCoinType(
           chainId,
@@ -181,17 +176,21 @@ 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 (isEthermintLike) {
-          return pubKey.getEthAddress();
+        if (pubKey.coinType === 60) {
+          return pubKey.pubKey.getEthAddress();
         }
 
-        return pubKey.getCosmosAddress();
+        return pubKey.pubKey.getCosmosAddress();
       })();
 
       const bech32Address = new Bech32Address(address);
@@ -239,7 +238,8 @@ export class KeyRingCosmosService {
     if (chainInfo.hideInUI) {
       throw new Error("Can't sign for hidden chain");
     }
-    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
+    const key = await this.getKey(vaultId, chainId);
+    const isEthermintLike = key.algo === "ethsecp256k1";
     const forceEVMLedger = chainInfo.features?.includes(
       "force-enable-evm-ledger"
     );
@@ -263,7 +263,6 @@ export class KeyRingCosmosService {
     signDoc = trimAminoSignDoc(signDoc);
     signDoc = sortObjectByKey(signDoc);
 
-    const key = await this.getKey(vaultId, chainId);
     const bech32Prefix =
       this.chainsService.getChainInfoOrThrow(chainId).bech32Config
         ?.bech32PrefixAccAddr ?? "";
@@ -307,6 +306,7 @@ export class KeyRingCosmosService {
         signOptions,
         keyType: keyInfo.type,
         keyInsensitive: keyInfo.insensitive,
+        isEthermintLike,
       },
       async (res: { newSignDoc: StdSignDoc; signature?: Uint8Array }) => {
         let newSignDoc = res.newSignDoc;
@@ -385,7 +385,8 @@ export class KeyRingCosmosService {
 
     const vaultId = this.keyRingService.selectedVaultId;
 
-    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
+    const key = await this.getKey(vaultId, chainId);
+    const isEthermintLike = key.algo === "ethsecp256k1";
     const forceEVMLedger = chainInfo.features?.includes(
       "force-enable-evm-ledger"
     );
@@ -409,7 +410,6 @@ 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,7 +488,8 @@ export class KeyRingCosmosService {
 
     const vaultId = this.keyRingService.selectedVaultId;
 
-    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
+    const key = await this.getKey(vaultId, chainId);
+    const isEthermintLike = key.algo === "ethsecp256k1";
     const forceEVMLedger = chainInfo.features?.includes(
       "force-enable-evm-ledger"
     );
@@ -512,7 +513,6 @@ 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,7 +625,8 @@ export class KeyRingCosmosService {
 
     const vaultId = this.keyRingService.selectedVaultId;
 
-    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
+    const key = await this.getKey(vaultId, chainId);
+    const isEthermintLike = key.algo === "ethsecp256k1";
     const forceEVMLedger = chainInfo.features?.includes(
       "force-enable-evm-ledger"
     );
@@ -649,7 +650,6 @@ 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,7 +747,8 @@ export class KeyRingCosmosService {
     if (chainInfo.hideInUI) {
       throw new Error("Can't sign for hidden chain");
     }
-    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
+    const key = await this.getKey(vaultId, chainId);
+    const isEthermintLike = key.algo === "ethsecp256k1";
     const forceEVMLedger = chainInfo.features?.includes(
       "force-enable-evm-ledger"
     );
@@ -763,7 +764,6 @@ export class KeyRingCosmosService {
       );
     }
 
-    const key = await this.getKey(vaultId, chainId);
     const bech32Prefix =
       this.chainsService.getChainInfoOrThrow(chainId).bech32Config
         ?.bech32PrefixAccAddr ?? "";
@@ -787,6 +787,7 @@ export class KeyRingCosmosService {
         signOptions,
         keyType: keyInfo.type,
         keyInsensitive: keyInfo.insensitive,
+        isEthermintLike,
       },
       async (res: { newSignDoc: StdSignDoc; signature?: Uint8Array }) => {
         const newSignDoc = res.newSignDoc;
@@ -846,7 +847,8 @@ export class KeyRingCosmosService {
     if (chainInfo.hideInUI) {
       throw new Error("Can't sign for hidden chain");
     }
-    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
+    const key = await this.getKey(vaultId, chainId);
+    const isEthermintLike = key.algo === "ethsecp256k1";
     const forceEVMLedger = chainInfo.features?.includes(
       "force-enable-evm-ledger"
     );
@@ -862,7 +864,24 @@ export class KeyRingCosmosService {
       );
     }
 
-    const key = await this.getKey(vaultId, chainId);
+    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 bech32Prefix =
       this.chainsService.getChainInfoOrThrow(chainId).bech32Config
         ?.bech32PrefixAccAddr ?? "";
@@ -885,6 +904,7 @@ export class KeyRingCosmosService {
         signOptions,
         keyType: keyInfo.type,
         keyInsensitive: keyInfo.insensitive,
+        isEthermintLike,
       },
       async (res: { newSignDocBytes: Uint8Array; signature?: Uint8Array }) => {
         const newSignDocBytes = res.newSignDocBytes;
@@ -986,7 +1006,8 @@ export class KeyRingCosmosService {
     if (chainInfo.hideInUI) {
       throw new Error("Can't sign for hidden chain");
     }
-    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
+    const key = await this.getKey(vaultId, chainId);
+    const isEthermintLike = key.algo === "ethsecp256k1";
     const forceEVMLedger = chainInfo.features?.includes(
       "force-enable-evm-ledger"
     );
@@ -1002,7 +1023,6 @@ export class KeyRingCosmosService {
       );
     }
 
-    const key = await this.getKey(vaultId, chainId);
     const bech32Prefix =
       this.chainsService.getChainInfoOrThrow(chainId).bech32Config
         ?.bech32PrefixAccAddr ?? "";
@@ -1124,9 +1144,9 @@ export class KeyRingCosmosService {
     signature: StdSignature
   ): Promise<boolean> {
     const chainInfo = this.chainsService.getChainInfoOrThrow(chainId);
-    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
-
     const key = await this.getKey(vaultId, chainId);
+    const isEthermintLike = key.algo === "ethsecp256k1";
+
     const bech32Prefix = chainInfo.bech32Config?.bech32PrefixAccAddr ?? "";
     const bech32Address = new Bech32Address(key.address).toBech32(bech32Prefix);
     if (signer !== bech32Address) {
@@ -1195,7 +1215,8 @@ export class KeyRingCosmosService {
     if (chainInfo.hideInUI) {
       throw new Error("Can't sign for hidden chain");
     }
-    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
+    const key = await this.getKey(vaultId, chainId);
+    const isEthermintLike = key.algo === "ethsecp256k1";
     const forceEVMLedger = chainInfo.features?.includes(
       "force-enable-evm-ledger"
     );
@@ -1247,7 +1268,6 @@ export class KeyRingCosmosService {
     signDoc = trimAminoSignDoc(signDoc);
     signDoc = sortObjectByKey(signDoc);
 
-    const key = await this.getKey(vaultId, chainId);
     const bech32Prefix =
       this.chainsService.getChainInfoOrThrow(chainId).bech32Config
         ?.bech32PrefixAccAddr ?? "";
@@ -1436,9 +1456,8 @@ export class KeyRingCosmosService {
 
         const ownerBech32 = Bech32Address.fromBech32(owner);
         for (const accountInfo of interactionInfo.accountInfos) {
-          const isEthermintLike = KeyRingService.isEthermintLike(
-            this.chainsService.getChainInfoOrThrow(accountInfo.chainId)
-          );
+          const key = await this.getKey(vaultId, chainId);
+          const isEthermintLike = key.algo === "ethsecp256k1";
 
           if (
             ownerBech32.toHex(false) !==

package/src/keyring-ethereum/service.ts

@@ -87,7 +87,8 @@ export class KeyRingEthereumService {
     if (chainInfo.hideInUI) {
       throw new Error("Can't sign for hidden chain");
     }
-    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
+    const key = await this.keyRingCosmosService.getKey(vaultId, chainId);
+    const isEthermintLike = key.algo === "ethsecp256k1";
     const evmInfo = ChainsService.getEVMInfo(chainInfo);
     const forceEVMLedger = chainInfo.features?.includes(
       "force-enable-evm-ledger"
@@ -124,7 +125,6 @@ export class KeyRingEthereumService {
       ).toLowerCase();
     }
 
-    const key = await this.keyRingCosmosService.getKey(vaultId, chainId);
     if (
       signer !== key.bech32Address &&
       signer !== key.ethereumHexAddress.toLowerCase()
@@ -348,8 +348,13 @@ 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.getEthAddress()
+              pubkey.pubKey.getEthAddress()
             ).toString("hex")}`;
 
             return {
@@ -368,8 +373,13 @@ 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.getEthAddress()
+              pubkey.pubKey.getEthAddress()
             ).toString("hex")}`;
 
             return {
@@ -402,8 +412,13 @@ 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.getEthAddress()
+            pubkey.pubKey.getEthAddress()
           ).toString("hex")}`;
 
           return [selectedAddress];
@@ -413,8 +428,13 @@ 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.getEthAddress()
+            pubkey.pubKey.getEthAddress()
           ).toString("hex")}`;
 
           return [selectedAddress];
@@ -477,8 +497,13 @@ 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.getEthAddress()
+            pubkey.pubKey.getEthAddress()
           ).toString("hex")}`;
 
           const transactionCount = await this.request(
@@ -598,8 +623,13 @@ 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.getEthAddress()
+            pubkey.pubKey.getEthAddress()
           ).toString("hex")}`;
 
           const transactionCount = await this.request(

package/src/keyring-keystone/service.ts

@@ -38,7 +38,14 @@ export class KeyRingKeystoneService {
     });
   }
 
-  getPubKey(vault: Vault, purpose: number, coinType: number): PubKeySecp256k1 {
+  getPubKey(
+    vault: Vault,
+    purpose: number,
+    coinType: number
+  ): {
+    pubKey: PubKeySecp256k1;
+    coinType: number;
+  } {
     let bytes;
     if (vault.insensitive["keys"]) {
       const path = Object.keys(vault.insensitive["keys"]).find((path) => {
@@ -59,7 +66,10 @@ export class KeyRingKeystoneService {
     } else {
       throw new Error(`Keystone is not initialized.`);
     }
-    return new PubKeySecp256k1(bytes);
+    return {
+      pubKey: new PubKeySecp256k1(bytes),
+      coinType,
+    };
   }
 
   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,9 +43,12 @@ export class KeyRingLedgerService {
   getPubKey(
     vault: Vault,
     _purpose: number,
-    _coinType: number,
+    coinType: number,
     modularChainInfo: ModularChainInfo
-  ): PubKeySecp256k1 {
+  ): {
+    pubKey: PubKeySecp256k1;
+    coinType: number;
+  } {
     if ("starknet" in modularChainInfo) {
       throw new Error(
         "'getPubKeyStarknet' should be called for Starknet chain"
@@ -58,10 +61,7 @@ export class KeyRingLedgerService {
 
     let app = "Cosmos";
 
-    const isEthermintLike = KeyRingService.isEthermintLike(
-      modularChainInfo.cosmos
-    );
-    if (isEthermintLike) {
+    if (coinType === 60) {
       app = "Ethereum";
       if (!vault.insensitive[app]) {
         throw new KeplrError(
@@ -83,6 +83,12 @@ 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]) {
@@ -93,7 +99,10 @@ export class KeyRingLedgerService {
       (vault.insensitive[app] as any)["pubKey"] as string,
       "hex"
     );
-    return new PubKeySecp256k1(bytes);
+    return {
+      pubKey: new PubKeySecp256k1(bytes),
+      coinType,
+    };
   }
 
   getPubKeyStarknet(

package/src/keyring-mnemonic/service.ts

@@ -65,14 +65,21 @@ export class KeyRingMnemonicService {
     });
   }
 
-  getPubKey(vault: Vault, purpose: number, coinType: number): PubKeySecp256k1 {
+  getPubKey(
+    vault: Vault,
+    purpose: number,
+    coinType: number
+  ): { pubKey: PubKeySecp256k1; coinType: number } {
     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 new PubKeySecp256k1(pubKey);
+      return {
+        coinType,
+        pubKey: new PubKeySecp256k1(pubKey),
+      };
     }
 
     const privKey = this.getPrivKey(vault, purpose, coinType);
@@ -84,7 +91,10 @@ export class KeyRingMnemonicService {
       [tag]: pubKeyText,
     });
 
-    return pubKey;
+    return {
+      coinType,
+      pubKey,
+    };
   }
 
   getPubKeyBitcoin(

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

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

package/src/keyring-starknet/service.ts

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

package/src/token-scan/service.ts

@@ -325,8 +325,11 @@ 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.getEthAddress()
+          pubkey.pubKey.getEthAddress()
         ).toString("hex")}`;
 
         const res = await simpleFetch<{