@keplr-wallet/background 0.13.13 → 0.13.15-rc.0

package/src/token-cw20/service.ts

@@ -1,7 +1,6 @@
 import { Env, KeplrError } from "@keplr-wallet/router";
 import {
   AppCurrency,
-  ChainInfo,
   CW20Currency,
   Secret20Currency,
 } from "@keplr-wallet/types";
@@ -125,8 +124,8 @@ export class TokenCW20Service {
     this.chainsService.addChainRemovedHandler(this.onChainRemoved);
   }
 
-  protected readonly onChainRemoved = (chainInfo: ChainInfo) => {
-    const chainIdentifier = ChainIdHelper.parse(chainInfo.chainId).identifier;
+  protected readonly onChainRemoved = (chainId: string) => {
+    const chainIdentifier = ChainIdHelper.parse(chainId).identifier;
     runInAction(() => {
       this.tokenMap.delete(chainIdentifier);
     });
@@ -194,14 +193,8 @@ export class TokenCW20Service {
     }
   }
 
-  protected validateChainInfoFeatures(chainInfo: ChainInfo) {
-    if (
-      !chainInfo.features ||
-      !(
-        chainInfo.features.includes("cosmwasm") ||
-        chainInfo.features.includes("secretwasm")
-      )
-    ) {
+  protected validateCosmosFeatures(features: string[] | undefined) {
+    if (!features?.includes("cosmwasm") && !features?.includes("secretwasm")) {
       throw new Error("The chain doesn't support cosmwasm");
     }
   }
@@ -215,8 +208,16 @@ export class TokenCW20Service {
     viewingKey?: string
   ) {
     this.validateAssociatedAccountAddress(associatedAccountAddress);
-    const chainInfo = this.chainsService.getChainInfoOrThrow(chainId);
-    this.validateChainInfoFeatures(chainInfo);
+    const modularChainInfo =
+      this.chainsService.getModularChainInfoOrThrow(chainId);
+    if (
+      modularChainInfo.type !== "cosmos" &&
+      modularChainInfo.type !== "ethermint"
+    ) {
+      throw new Error("The chain doesn't support cosmwasm");
+    }
+    const cosmosInfo = modularChainInfo.cosmos;
+    this.validateCosmosFeatures(cosmosInfo.features);
 
     const existing = this.getToken(
       chainId,
@@ -251,7 +252,7 @@ export class TokenCW20Service {
     // Validate the contract address.
     Bech32Address.validate(
       contractAddress,
-      chainInfo.bech32Config?.bech32PrefixAccAddr
+      cosmosInfo.bech32Config?.bech32PrefixAccAddr
     );
 
     const params = {
@@ -305,8 +306,16 @@ export class TokenCW20Service {
     associatedAccountAddress: string
   ): Promise<void> {
     this.validateAssociatedAccountAddress(associatedAccountAddress);
-    const chainInfo = this.chainsService.getChainInfoOrThrow(chainId);
-    this.validateChainInfoFeatures(chainInfo);
+    const modularChainInfo =
+      this.chainsService.getModularChainInfoOrThrow(chainId);
+    if (
+      modularChainInfo.type !== "cosmos" &&
+      modularChainInfo.type !== "ethermint"
+    ) {
+      throw new Error("The chain doesn't support cosmwasm");
+    }
+    const cosmosInfo = modularChainInfo.cosmos;
+    this.validateCosmosFeatures(cosmosInfo.features);
     const chainIdentifier = ChainIdHelper.parse(chainId).identifier;
 
     if (!this.tokenMap.has(chainIdentifier)) {
@@ -317,7 +326,10 @@ export class TokenCW20Service {
 
     const tokens = this.tokenMap.get(chainIdentifier)!;
 
-    currency = await TokenCW20Service.validateCurrency(chainInfo, currency);
+    currency = await TokenCW20Service.validateCurrency(
+      cosmosInfo.bech32Config?.bech32PrefixAccAddr,
+      currency
+    );
 
     if (
       !("type" in currency) ||
@@ -422,7 +434,7 @@ export class TokenCW20Service {
   }
 
   static async validateCurrency(
-    chainInfo: ChainInfo,
+    bech32Prefix: string | undefined,
     currency: AppCurrency
   ): Promise<AppCurrency> {
     // Validate the schema.
@@ -430,13 +442,13 @@ export class TokenCW20Service {
       switch (currency.type) {
         case "cw20":
           currency = await TokenCW20Service.validateCW20Currency(
-            chainInfo,
+            bech32Prefix,
             currency
           );
           break;
         case "secret20":
           currency = await TokenCW20Service.validateSecret20Currency(
-            chainInfo,
+            bech32Prefix,
             currency
           );
           break;
@@ -451,33 +463,27 @@ export class TokenCW20Service {
   }
 
   static async validateCW20Currency(
-    chainInfo: ChainInfo,
+    bech32Prefix: string | undefined,
     currency: CW20Currency
   ): Promise<CW20Currency> {
     // Validate the schema.
     currency = await CW20CurrencySchema.validateAsync(currency);
 
     // Validate the contract address.
-    Bech32Address.validate(
-      currency.contractAddress,
-      chainInfo.bech32Config?.bech32PrefixAccAddr
-    );
+    Bech32Address.validate(currency.contractAddress, bech32Prefix);
 
     return currency;
   }
 
   static async validateSecret20Currency(
-    chainInfo: ChainInfo,
+    bech32Prefix: string | undefined,
     currency: Secret20Currency
   ): Promise<Secret20Currency> {
     // Validate the schema.
     currency = await Secret20CurrencySchema.validateAsync(currency);
 
     // Validate the contract address.
-    Bech32Address.validate(
-      currency.contractAddress,
-      chainInfo.bech32Config?.bech32PrefixAccAddr
-    );
+    Bech32Address.validate(currency.contractAddress, bech32Prefix);
 
     return currency;
   }

package/src/token-erc20/service.ts

@@ -1,5 +1,5 @@
 import { Env, KeplrError } from "@keplr-wallet/router";
-import { AppCurrency, ChainInfo, ERC20Currency } from "@keplr-wallet/types";
+import { AppCurrency, ERC20Currency } from "@keplr-wallet/types";
 import { ERC20CurrencySchema } from "@keplr-wallet/chain-validator";
 import { ChainIdHelper } from "@keplr-wallet/cosmos";
 import { ChainsService } from "../chains";
@@ -50,8 +50,8 @@ export class TokenERC20Service {
     this.chainsService.addChainRemovedHandler(this.onChainRemoved);
   }
 
-  protected readonly onChainRemoved = (chainInfo: ChainInfo) => {
-    const chainIdentifier = ChainIdHelper.parse(chainInfo.chainId).identifier;
+  protected readonly onChainRemoved = (chainId: string) => {
+    const chainIdentifier = ChainIdHelper.parse(chainId).identifier;
     runInAction(() => {
       this.tokenMap.delete(chainIdentifier);
     });
@@ -64,20 +64,15 @@ export class TokenERC20Service {
     }
   );
 
-  protected validateChainInfo(chainInfo: ChainInfo) {
-    if (chainInfo.evm === undefined) {
-      throw new Error("The chain doesn't support evm");
-    }
-  }
-
   async suggestERC20Token(env: Env, chainId: string, contractAddress: string) {
     const modularChainInfo =
       this.chainsService.getModularChainInfoOrThrow(chainId);
-    if ("cosmos" in modularChainInfo) {
-      const chainInfo = this.chainsService.getChainInfoOrThrow(chainId);
-
-      this.validateChainInfo(chainInfo);
-    } else if ("starknet" in modularChainInfo) {
+    if (
+      modularChainInfo.type === "ethermint" ||
+      modularChainInfo.type === "evm"
+    ) {
+      // EVM supported — ok
+    } else if (modularChainInfo.type === "starknet") {
       if (modularChainInfo.starknet == null) {
         throw new Error("Starknet chain info is not defined");
       }
@@ -137,10 +132,12 @@ export class TokenERC20Service {
   async setERC20Token(chainId: string, currency: AppCurrency): Promise<void> {
     const modularChainInfo =
       this.chainsService.getModularChainInfoOrThrow(chainId);
-    if ("cosmos" in modularChainInfo) {
-      const chainInfo = this.chainsService.getChainInfoOrThrow(chainId);
-      this.validateChainInfo(chainInfo);
-    } else if ("starknet" in modularChainInfo) {
+    if (
+      modularChainInfo.type === "ethermint" ||
+      modularChainInfo.type === "evm"
+    ) {
+      // EVM supported — ok
+    } else if (modularChainInfo.type === "starknet") {
       if (modularChainInfo.starknet == null) {
         throw new Error("Starknet chain info is not defined");
       }

package/src/token-scan/service.ts

@@ -149,12 +149,12 @@ export class TokenScanService {
       }
     );
 
-    this.chainsService.addChainRemovedHandler((chainInfo) => {
+    this.chainsService.addChainRemovedHandler((chainId) => {
       runInAction(() => {
         for (const [vaultId, tokenScans] of this.vaultToMap.entries()) {
           let prevTokenScans = tokenScans;
           prevTokenScans = prevTokenScans.filter((scan) => {
-            return scan.chainId !== chainInfo.chainId;
+            return scan.chainId !== chainId;
           });
 
           this.vaultToMap.set(vaultId, prevTokenScans);
@@ -202,8 +202,9 @@ export class TokenScanService {
       return;
     }
 
-    const chainInfo = this.chainsService.getChainInfoOrThrow(chainId);
-    if (chainInfo.hideInUI) {
+    const modularChainInfo =
+      this.chainsService.getModularChainInfoOrThrow(chainId);
+    if (modularChainInfo.hideInUI) {
       return;
     }
 
@@ -239,8 +240,9 @@ export class TokenScanService {
       return;
     }
 
-    const chainInfo = this.chainsService.getChainInfoOrThrow(chainId);
-    if (chainInfo.hideInUI) {
+    const modularChainInfo =
+      this.chainsService.getModularChainInfoOrThrow(chainId);
+    if (modularChainInfo.hideInUI) {
       return;
     }
 
@@ -299,7 +301,7 @@ export class TokenScanService {
     const logChains: string[] = [];
 
     for (const modularChainInfo of modularChainInfos) {
-      if ("linkedChainKey" in modularChainInfo) {
+      if (modularChainInfo.linkedChainKey != null) {
         if (processedLinkedChainKeys.has(modularChainInfo.linkedChainKey)) {
           continue;
         }
@@ -386,17 +388,23 @@ export class TokenScanService {
       return;
     }
 
-    if ("linkedChainKey" in modularChainInfo) {
+    if (modularChainInfo.linkedChainKey != null) {
       tokenScan.linkedChainKey = modularChainInfo.linkedChainKey;
     }
 
-    if ("cosmos" in modularChainInfo) {
-      const chainInfo = this.chainsService.getChainInfoOrThrow(chainId);
-      if (chainInfo.hideInUI) {
+    if (
+      modularChainInfo.type === "cosmos" ||
+      modularChainInfo.type === "ethermint" ||
+      modularChainInfo.type === "evm"
+    ) {
+      if (modularChainInfo.hideInUI) {
         return;
       }
 
-      if (this.chainsService.isEvmOnlyChain(chainId)) {
+      if (
+        this.chainsService.isEvmOnlyChain(chainId) &&
+        modularChainInfo.type === "evm"
+      ) {
         const evmInfo = this.chainsService.getEVMInfoOrThrow(chainId);
         const pubkey = await this.keyRingService.getPubKey(chainId, vaultId);
         const ethereumHexAddress = `0x${Buffer.from(
@@ -433,7 +441,7 @@ export class TokenScanService {
           BigInt(res.data.result).toString(10) !== "0"
         ) {
           assets.push({
-            currency: chainInfo.stakeCurrency ?? chainInfo.currencies[0],
+            currency: modularChainInfo.evm.nativeCurrency,
             amount: BigInt(res.data.result).toString(10),
           });
         }
@@ -507,7 +515,11 @@ export class TokenScanService {
             assets,
           });
         }
-      } else {
+      } else if (
+        modularChainInfo.type === "cosmos" ||
+        modularChainInfo.type === "ethermint"
+      ) {
+        const cosmosInfo = modularChainInfo.cosmos;
         const bech32Addresses: {
           value: string;
           coinType?: number;
@@ -539,7 +551,7 @@ export class TokenScanService {
           const res = await simpleFetch<{
             balances: { denom: string; amount: string }[];
           }>(
-            chainInfo.rest,
+            cosmosInfo.rest,
             `/cosmos/bank/v1beta1/balances/${bech32Address.value}?pagination.limit=1000`
           );
 
@@ -548,8 +560,9 @@ export class TokenScanService {
 
             const balances = res.data?.balances ?? [];
             for (const bal of balances) {
-              const currency = chainInfo.currencies.find(
-                (cur) => cur.coinMinimalDenom === bal.denom
+              const currency = cosmosInfo.currencies.find(
+                (cur: { coinMinimalDenom: string }) =>
+                  cur.coinMinimalDenom === bal.denom
               );
 
               // validate
@@ -577,7 +590,7 @@ export class TokenScanService {
           }
         }
       }
-    } else if ("starknet" in modularChainInfo) {
+    } else if (modularChainInfo.type === "starknet") {
       const { hexAddress: starknetHexAddress } =
         await this.keyRingStarknetService.getStarknetKey(vaultId, chainId);
 
@@ -651,7 +664,7 @@ export class TokenScanService {
           }
         })
       );
-    } else if ("bitcoin" in modularChainInfo) {
+    } else if (modularChainInfo.type === "bitcoin") {
       const getBitcoinScanInfo = async (
         vaultId: string,
         chainId: string,
@@ -706,12 +719,12 @@ export class TokenScanService {
       };
 
       // TODO: 향후 여러 주소체계를 지원하는 체인이 추가되면 linkedChainKey와 관련된 로직은 별도의 함수로 분리가 필요할 것
-      if ("linkedChainKey" in modularChainInfo) {
+      if (modularChainInfo.linkedChainKey != null) {
         const linkedBitcoinChains = this.chainsService
           .getModularChainInfos()
           .filter((chainInfo) => {
             return (
-              "bitcoin" in chainInfo &&
+              chainInfo.type === "bitcoin" &&
               chainInfo.linkedChainKey === modularChainInfo.linkedChainKey
             );
           });

package/src/tx/service.ts

@@ -40,7 +40,15 @@ export class BackgroundTxService {
       onFulfill?: (tx: any) => void;
     }
   ): Promise<Uint8Array> {
-    const chainInfo = this.chainsService.getChainInfoOrThrow(chainId);
+    const modularChainInfo =
+      this.chainsService.getModularChainInfoOrThrow(chainId);
+    if (
+      modularChainInfo.type !== "cosmos" &&
+      modularChainInfo.type !== "ethermint"
+    ) {
+      throw new Error(`Not a cosmos chain: ${chainId}`);
+    }
+    const cosmosInfo = modularChainInfo.cosmos;
 
     if (!options.silent) {
       this.notification.create({
@@ -75,7 +83,7 @@ export class BackgroundTxService {
 
     try {
       const result = await simpleFetch<any>(
-        chainInfo.rest,
+        cosmosInfo.rest,
         isProtoTx ? "/cosmos/tx/v1beta1/txs" : "/txs",
         {
           method: "POST",
@@ -103,7 +111,7 @@ export class BackgroundTxService {
           () => {
             return new Promise<void>((resolve, reject) => {
               const txTracer = new TendermintTxTracer(
-                chainInfo.rpc,
+                cosmosInfo.rpc,
                 "/websocket"
               );
               txTracer.addEventListener("close", () => {
@@ -166,13 +174,23 @@ export class BackgroundTxService {
   }
 
   async traceTx(chainId: string, txHash: string): Promise<any> {
-    const chainInfo = this.chainsService.getChainInfoOrThrow(chainId);
+    const modularChainInfo =
+      this.chainsService.getModularChainInfoOrThrow(chainId);
+    if (
+      modularChainInfo.type !== "cosmos" &&
+      modularChainInfo.type !== "ethermint"
+    ) {
+      throw new Error(`Not a cosmos chain: ${chainId}`);
+    }
     const txHashBuffer = Buffer.from(txHash, "hex");
 
     return await retry(
       () => {
         return new Promise<any>((resolve, reject) => {
-          const txTracer = new TendermintTxTracer(chainInfo.rpc, "/websocket");
+          const txTracer = new TendermintTxTracer(
+            modularChainInfo.cosmos.rpc,
+            "/websocket"
+          );
           txTracer.addEventListener("close", () => {
             // reject if ws closed before fulfilled
             // 하지만 로직상 fulfill 되기 전에 ws가 닫히는게 되기 때문에
@@ -243,12 +261,11 @@ export class BackgroundTxService {
     let message = e.message;
 
     // Tendermint rpc error.
-    const regResult = /code:\s*(-?\d+),\s*message:\s*(.+),\sdata:\s(.+)/g.exec(
-      e.message
-    );
-    if (regResult && regResult.length === 4) {
+    const tendermintRpcErrorMessage =
+      BackgroundTxService.parseTendermintRpcErrorMessage(e.message);
+    if (tendermintRpcErrorMessage) {
       // If error is from tendermint
-      message = regResult[3];
+      message = tendermintRpcErrorMessage;
     }
 
     try {
@@ -286,6 +303,37 @@ export class BackgroundTxService {
     });
   }
 
+  // Keep the Tendermint RPC parsing best-effort only and avoid regex backtracking
+  // on raw error strings from external nodes/libraries.
+  private static parseTendermintRpcErrorMessage(
+    message: string
+  ): string | undefined {
+    if (!message.startsWith("code:")) {
+      return undefined;
+    }
+
+    const messageIndex = message.indexOf("message:");
+    const dataIndex = message.indexOf("data:");
+
+    if (messageIndex < 0 || dataIndex < 0 || messageIndex > dataIndex) {
+      return undefined;
+    }
+
+    const messageBody = message.slice(messageIndex + "message:".length);
+    const dataDelimiter =
+      messageBody.indexOf(", data:") >= 0 ? ", data:" : ",data:";
+    const dataDelimiterIndex = messageBody.indexOf(dataDelimiter);
+
+    if (dataDelimiterIndex < 0) {
+      return undefined;
+    }
+
+    const dataMessage = messageBody
+      .slice(dataDelimiterIndex + dataDelimiter.length)
+      .trim();
+    return dataMessage.length > 0 ? dataMessage : undefined;
+  }
+
   async waitStarknetTransaction(
     chainId: string,
     txHash: string
@@ -294,7 +342,7 @@ export class BackgroundTxService {
     if (!modularChainInfo) {
       throw new Error("Invalid chain id");
     }
-    if (!("starknet" in modularChainInfo)) {
+    if (modularChainInfo.type !== "starknet") {
       throw new Error("Chain is not for starknet");
     }
     const starknet = modularChainInfo.starknet;
@@ -340,7 +388,7 @@ export class BackgroundTxService {
       throw new Error("Invalid chain id");
     }
 
-    if (!("bitcoin" in modularChainInfo)) {
+    if (modularChainInfo.type !== "bitcoin") {
       throw new Error("Chain is not for bitcoin");
     }
 

package/src/tx-ethereum/service.ts

@@ -33,11 +33,7 @@ export class BackgroundTxEthereumService {
     }
 
     try {
-      const chainInfo = this.chainsService.getChainInfoOrThrow(chainId);
-      const evmInfo = ChainsService.getEVMInfo(chainInfo);
-      if (!evmInfo) {
-        throw new Error("No EVM info provided");
-      }
+      const evmInfo = this.chainsService.getEVMInfoOrThrow(chainId);
 
       const sendRawTransactionResponse = await simpleFetch<{
         result?: string;
@@ -131,11 +127,15 @@ export class BackgroundTxEthereumService {
     chainId: string,
     txHash: string
   ): Promise<EthTxReceipt | null> {
-    const chainInfo = this.chainsService.getChainInfoOrThrow(chainId);
-    const evmInfo = ChainsService.getEVMInfo(chainInfo);
-    if (!evmInfo) {
+    const modularChainInfo =
+      this.chainsService.getModularChainInfoOrThrow(chainId);
+    if (
+      modularChainInfo.type !== "evm" &&
+      modularChainInfo.type !== "ethermint"
+    ) {
       return null;
     }
+    const evmInfo = modularChainInfo.evm;
 
     return await retry(
       () => {

package/src/tx-executor/service.ts

@@ -586,18 +586,16 @@ export class BackgroundTxExecutorService {
       typeof browser !== "undefined"
         ? new URL(browser.runtime.getURL("/")).origin
         : "extension";
-    const chainInfo = this.chainsService.getChainInfoOrThrow(tx.chainId);
-    const evmInfo = ChainsService.getEVMInfo(chainInfo);
-    if (!evmInfo) {
-      throw new KeplrError("direct-tx-executor", 142, "Not EVM chain");
-    }
+    const evmInfo = this.chainsService.getEVMInfoOrThrow(tx.chainId);
 
     const unsignedTx = await fillUnsignedEVMTx(
       origin,
       evmInfo,
       signer,
       tx.txData,
-      tx.feeType ?? "average"
+      tx.feeType ?? "average",
+      tx.customPriorityFee,
+      tx.customGasPrice
     );
 
     const result = await this.keyRingEthereumService.signEthereumPreAuthorized(

package/src/tx-executor/types.ts

@@ -42,9 +42,17 @@ interface BackgroundTxBase {
   error?: string;
 }
 
-export interface EVMBackgroundTx extends BackgroundTxBase {
+export type EVMBackgroundTxFeeType = BackgroundTxFeeType | "custom";
+
+interface EVMBackgroundTxBase extends Omit<BackgroundTxBase, "feeType"> {
+  feeType?: EVMBackgroundTxFeeType;
+}
+
+export interface EVMBackgroundTx extends EVMBackgroundTxBase {
   readonly type: BackgroundTxType.EVM;
   txData: UnsignedTransaction;
+  customPriorityFee?: string;
+  customGasPrice?: string;
 }
 
 export interface CosmosBackgroundTx extends BackgroundTxBase {