[APIS-313] Support ethermint ledger sign(cosmos)

package.json

@@ -82,6 +82,7 @@
     "js-yaml": "^4.1.0",
     "ledger-cosmos-js": "^2.1.8",
     "lodash": "^4.17.21",
+    "long": "^5.2.3",
     "notistack": "^2.0.4",
     "protobufjs": "^6.11.2",
     "qrcode.react": "^3.0.1",

src/Popup/Routes/index.tsx

@@ -44,6 +44,7 @@ import PopupCosmosAddNFTs from '~/Popup/pages/Popup/Cosmos/AddNFTs';
 import PopupCosmosAddTokens from '~/Popup/pages/Popup/Cosmos/AddTokens';
 import PopupCosmosSignAmino from '~/Popup/pages/Popup/Cosmos/Sign/Amino';
 import PopupCosmosSignDirect from '~/Popup/pages/Popup/Cosmos/Sign/Direct';
+import PopupCosmosSignEIP712 from '~/Popup/pages/Popup/Cosmos/Sign/EIP712';
 import PopupCosmosSignMessage from '~/Popup/pages/Popup/Cosmos/Sign/Message';
 import PopupEthereumAddNetwork from '~/Popup/pages/Popup/Ethereum/AddNetwork';
 import PopupEthereumAddTokens from '~/Popup/pages/Popup/Ethereum/AddTokens';
@@ -164,6 +165,7 @@ export default function Routes() {
           <Route path={PATH.POPUP__COSMOS__SIGN__AMINO} element={<PopupCosmosSignAmino />} />
           <Route path={PATH.POPUP__COSMOS__SIGN__DIRECT} element={<PopupCosmosSignDirect />} />
           <Route path={PATH.POPUP__COSMOS__SIGN__MESSAGE} element={<PopupCosmosSignMessage />} />
+          <Route path={PATH.POPUP__COSMOS__SIGN__EIP712} element={<PopupCosmosSignEIP712 />} />
 
           <Route path={PATH.POPUP__APTOS__TRANSACTION} element={<PopupAptosTransaction />} />
           <Route path={PATH.POPUP__APTOS__SIGN_MESSAGE} element={<PopupAptosSignMessage />} />

src/Popup/background/joiSchema.ts

@@ -6,6 +6,7 @@ import { ethereumAddressRegex, getCosmosAddressRegex } from '~/Popup/utils/regex
 import type { CosmosChain, GasRate } from '~/types/chain';
 import type { Fee, Msg, SignAminoDoc } from '~/types/cosmos/amino';
 import type { Amount } from '~/types/cosmos/common';
+import type { EIP712StructuredData } from '~/types/cosmos/ethermint';
 import type { SignDirectDoc } from '~/types/cosmos/proto';
 import type { AptosSignMessage, AptosSignTransaction } from '~/types/message/aptos';
 import type {
@@ -17,6 +18,7 @@ import type {
   CosSendTransaction,
   CosSignAmino,
   CosSignDirect,
+  CosSignEIP712,
   CosSignMessage,
   CosVerifyMessage,
 } from '~/types/message/cosmos';
@@ -102,6 +104,7 @@ export const cosSignAminoParamsSchema = (chainNames: string[], chainId: string)
         gas: Joi.string().required(),
         payer: Joi.string().optional(),
         granter: Joi.string().optional(),
+        feePayer: Joi.string().optional(),
       }),
       memo: Joi.string().allow(''),
       msgs: Joi.array().items(
@@ -137,6 +140,98 @@ export const cosSignMessageParamsSchema = (chainNames: string[]) =>
     .label('params')
     .required();
 
+export const cosSignEIP712ParamsSchema = (chainId: string) => {
+  const chainIdRegex = getChainIdRegex(chainId);
+
+  return Joi.object<CosSignEIP712['params']>({
+    chainId: Joi.string().trim().pattern(chainIdRegex).required(),
+    signer: Joi.string().required(),
+    eip712: Joi.object<EIP712StructuredData>({
+      types: Joi.object({
+        EIP712Domain: Joi.array()
+          .items(
+            Joi.object<{
+              name: string;
+              type: string;
+            }>({
+              name: Joi.string().valid('name').required(),
+              type: Joi.string().valid('string').required(),
+            }),
+            Joi.object<{
+              name: string;
+              type: string;
+            }>({
+              name: Joi.string().valid('version').required(),
+              type: Joi.string().valid('string').required(),
+            }),
+            Joi.object<{
+              name: string;
+              type: string;
+            }>({
+              name: Joi.string().valid('chainId').required(),
+              type: Joi.string().valid('uint256').required(),
+            }),
+            Joi.object<{
+              name: string;
+              type: string;
+            }>({
+              name: Joi.string().valid('verifyingContract').required(),
+              type: Joi.string().valid('address', 'string').required(),
+            }),
+            Joi.object<{
+              name: string;
+              type: string;
+            }>({
+              name: Joi.string().valid('salt').required(),
+              type: Joi.string().valid('bytes32', 'string').required(),
+            }),
+          )
+          .unique()
+          .min(1)
+          .custom((value) => {
+            const domainFieldNames: Array<string> = ['name', 'version', 'chainId', 'verifyingContract', 'salt'];
+
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
+            return value.sort((a: { name: string }, b: { name: string }) => domainFieldNames.indexOf(a.name) - domainFieldNames.indexOf(b.name));
+          })
+          .required(),
+      })
+        .unknown(true)
+        .required(),
+      domain: Joi.object().required(),
+      primaryType: Joi.string().required(),
+    })
+      .unknown(true)
+      .required(),
+    doc: Joi.object<SignAminoDoc>({
+      chain_id: Joi.string().trim().pattern(chainIdRegex).required(),
+      sequence: Joi.string().required(),
+      account_number: Joi.string().required(),
+      fee: Joi.object<Fee>({
+        amount: Joi.array()
+          .items(Joi.object<Amount>({ amount: Joi.string().required(), denom: Joi.string().required() }))
+          .optional(),
+        gas: Joi.string().required(),
+        payer: Joi.string().optional(),
+        feePayer: Joi.string().optional(),
+        granter: Joi.string().optional(),
+      }),
+      memo: Joi.string().allow(''),
+      msgs: Joi.array().items(
+        Joi.object<Msg>({
+          type: Joi.string().required(),
+          value: Joi.any(),
+        }),
+      ),
+      timeout_height: Joi.string().optional(),
+    }).required(),
+    isEditFee: Joi.boolean().default(true),
+    isEditMemo: Joi.boolean().default(false),
+    isCheckBalance: Joi.boolean().default(true),
+  })
+    .label('params')
+    .required();
+};
 export const cosVerifyMessageParamsSchema = (chainNames: string[]) =>
   Joi.object<CosVerifyMessage['params']>({
     chainName: Joi.string()

src/Popup/background/messageProcessor.ts

@@ -57,6 +57,7 @@ import type {
   CosSendTransactionResponse,
   CosSignAmino,
   CosSignDirect,
+  CosSignEIP712,
   CosSignMessage,
   CosSupportedChainIdsResponse,
   CosSupportedChainNamesResponse,
@@ -100,6 +101,7 @@ import {
   cosSendTransactionParamsSchema,
   cosSignAminoParamsSchema,
   cosSignDirectParamsSchema,
+  cosSignEIP712ParamsSchema,
   cosSignMessageParamsSchema,
   cosVerifyMessageParamsSchema,
   ethcAddNetworkParamsSchema,
@@ -238,7 +240,15 @@ export async function cstob(request: ContentScriptToBackgroundEventMessage<Reque
 
           const chain = getChain(chainName)!;
 
-          if (currentAccount.type === 'LEDGER' && chain.bip44.coinType !== LEDGER_SUPPORT_COIN_TYPE.COSMOS) {
+          if (
+            currentAccount.type === 'LEDGER' &&
+            ![
+              LEDGER_SUPPORT_COIN_TYPE.COSMOS,
+              LEDGER_SUPPORT_COIN_TYPE.ETHERMINT,
+              LEDGER_SUPPORT_COIN_TYPE.MEDIBLOC,
+              LEDGER_SUPPORT_COIN_TYPE.CRONOS_POS,
+            ].includes(chain.bip44.coinType)
+          ) {
             throw new CosmosRPCError(RPC_ERROR.LEDGER_UNSUPPORTED_CHAIN, COSMOS_RPC_ERROR_MESSAGE[RPC_ERROR.LEDGER_UNSUPPORTED_CHAIN]);
           }
 
@@ -331,7 +341,10 @@ export async function cstob(request: ContentScriptToBackgroundEventMessage<Reque
 
           const schema = cosSignAminoParamsSchema(allChainLowercaseNames, chain ? chain.chainId : '');
 
-          if (currentAccount.type === 'LEDGER' && chain?.bip44.coinType !== LEDGER_SUPPORT_COIN_TYPE.COSMOS) {
+          if (
+            currentAccount.type === 'LEDGER' &&
+            ![LEDGER_SUPPORT_COIN_TYPE.COSMOS, LEDGER_SUPPORT_COIN_TYPE.MEDIBLOC, LEDGER_SUPPORT_COIN_TYPE.CRONOS_POS].includes(chain?.bip44.coinType || '')
+          ) {
             throw new CosmosRPCError(RPC_ERROR.LEDGER_UNSUPPORTED_CHAIN, COSMOS_RPC_ERROR_MESSAGE[RPC_ERROR.LEDGER_UNSUPPORTED_CHAIN]);
           }
 
@@ -376,6 +389,33 @@ export async function cstob(request: ContentScriptToBackgroundEventMessage<Reque
           }
         }
 
+        if (method === 'cos_signEIP712') {
+          if (currentAccount.type !== 'LEDGER') {
+            throw new CosmosRPCError(RPC_ERROR.LEDGER_SUPPORTED_METHOD, COSMOS_RPC_ERROR_MESSAGE[RPC_ERROR.LEDGER_SUPPORTED_METHOD]);
+          }
+          const { params } = message;
+
+          const selectedChain = allChains.find((item) => item.chainId === params.chainId);
+
+          const schema = cosSignEIP712ParamsSchema(selectedChain ? selectedChain.chainId : '');
+
+          if (currentAccount.type === 'LEDGER' && selectedChain?.bip44.coinType !== LEDGER_SUPPORT_COIN_TYPE.ETHERMINT) {
+            throw new CosmosRPCError(RPC_ERROR.LEDGER_UNSUPPORTED_CHAIN, COSMOS_RPC_ERROR_MESSAGE[RPC_ERROR.LEDGER_UNSUPPORTED_CHAIN]);
+          }
+
+          try {
+            const validatedParams = (await schema.validateAsync({ ...params })) as CosSignEIP712['params'];
+
+            localQueues.push({
+              ...request,
+              message: { ...request.message, method, params: { ...validatedParams } as CosSignEIP712['params'] },
+            });
+            void setQueues();
+          } catch (err) {
+            throw new CosmosRPCError(RPC_ERROR.INVALID_PARAMS, `${err as string}`);
+          }
+        }
+
         if (method === 'cos_signMessage') {
           const { params } = message;
 
@@ -391,7 +431,10 @@ export async function cstob(request: ContentScriptToBackgroundEventMessage<Reque
 
           const schema = cosSignMessageParamsSchema(allChainLowercaseNames);
 
-          if (currentAccount.type === 'LEDGER' && chain?.bip44.coinType !== LEDGER_SUPPORT_COIN_TYPE.COSMOS) {
+          if (
+            currentAccount.type === 'LEDGER' &&
+            ![LEDGER_SUPPORT_COIN_TYPE.COSMOS, LEDGER_SUPPORT_COIN_TYPE.MEDIBLOC, LEDGER_SUPPORT_COIN_TYPE.CRONOS_POS].includes(chain.bip44.coinType)
+          ) {
             throw new CosmosRPCError(RPC_ERROR.LEDGER_UNSUPPORTED_CHAIN, COSMOS_RPC_ERROR_MESSAGE[RPC_ERROR.LEDGER_UNSUPPORTED_CHAIN]);
           }
 
@@ -614,7 +657,15 @@ export async function cstob(request: ContentScriptToBackgroundEventMessage<Reque
 
           const chain = getChain(chainName);
 
-          if (currentAccount.type === 'LEDGER' && chain?.bip44.coinType !== LEDGER_SUPPORT_COIN_TYPE.COSMOS) {
+          if (
+            currentAccount.type === 'LEDGER' &&
+            ![
+              LEDGER_SUPPORT_COIN_TYPE.COSMOS,
+              LEDGER_SUPPORT_COIN_TYPE.ETHERMINT,
+              LEDGER_SUPPORT_COIN_TYPE.MEDIBLOC,
+              LEDGER_SUPPORT_COIN_TYPE.CRONOS_POS,
+            ].includes(chain?.bip44.coinType || '')
+          ) {
             throw new CosmosRPCError(RPC_ERROR.LEDGER_UNSUPPORTED_CHAIN, COSMOS_RPC_ERROR_MESSAGE[RPC_ERROR.LEDGER_UNSUPPORTED_CHAIN]);
           }
 

src/Popup/components/Wrapper/Routes/index.tsx

@@ -56,6 +56,10 @@ export default function Routes({ children }: RoutesType) {
         navigate('/popup/cosmos/sign/message');
       }
 
+      if (extensionStorage.queues[0].message.method === 'cos_signEIP712') {
+        navigate('/popup/cosmos/sign/eip712');
+      }
+
       if (extensionStorage.queues[0].message.method === 'cos_addTokensCW20Internal') {
         navigate('/popup/cosmos/add-tokens');
       }

src/Popup/components/requests/LedgerPublicKeyRequest/index.tsx

@@ -1,5 +1,6 @@
 import { useMemo } from 'react';
 import { useSnackbar } from 'notistack';
+import TinySecp256k1 from 'tiny-secp256k1';
 import EthereumApp from '@ledgerhq/hw-app-eth';
 import { Typography } from '@mui/material';
 import Sui from '@mysten/ledgerjs-hw-app-sui';
@@ -92,22 +93,25 @@ export default function LedgerPublicKeyRequest({ children }: AccessRequestProps)
 
   if (currentAccount.type === 'LEDGER' && chain && currentQueue) {
     if (
-      ![LEDGER_SUPPORT_COIN_TYPE.COSMOS, LEDGER_SUPPORT_COIN_TYPE.MEDIBLOC, LEDGER_SUPPORT_COIN_TYPE.CRONOS_POS].includes(chain.bip44.coinType) &&
+      ![LEDGER_SUPPORT_COIN_TYPE.COSMOS, LEDGER_SUPPORT_COIN_TYPE.ETHERMINT, LEDGER_SUPPORT_COIN_TYPE.MEDIBLOC, LEDGER_SUPPORT_COIN_TYPE.CRONOS_POS].includes(
+        chain.bip44.coinType,
+      ) &&
       chain.line === 'COSMOS'
     ) {
       return null;
     }
 
     if (
       (!currentAccount.cosmosPublicKey && chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.COSMOS && chain.line === 'COSMOS') ||
+      (!currentAccount.ethermintPublicKey && chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.ETHERMINT && chain.line === 'COSMOS') ||
       (!currentAccount.mediblocPublicKey && chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.MEDIBLOC && chain.line === 'COSMOS') ||
       (!currentAccount.cryptoOrgPublicKey && chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.CRONOS_POS && chain.line === 'COSMOS') ||
       (!currentAccount.ethereumPublicKey && chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.ETHEREUM && chain.line === 'ETHEREUM') ||
       (!currentAccount.suiPublicKey && chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.SUI && chain.line === 'SUI')
     ) {
       const Step2 = (() => {
         if (chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.COSMOS) return Step2CosmosIcon;
-        if (chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.ETHEREUM) return Step2EthereumIcon;
+        if (chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.ETHEREUM || chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.ETHERMINT) return Step2EthereumIcon;
         if (chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.MEDIBLOC) return Step2Medibloc;
         if (chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.CRONOS_POS) return Step2CryptoOrg;
         if (chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.SUI) return Step2Sui;
@@ -116,7 +120,7 @@ export default function LedgerPublicKeyRequest({ children }: AccessRequestProps)
 
       const appName = (() => {
         if (chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.COSMOS) return 'Cosmos';
-        if (chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.ETHEREUM) return 'Ethereum';
+        if (chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.ETHEREUM || chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.ETHERMINT) return 'Ethereum';
         if (chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.MEDIBLOC) return 'Medibloc';
         if (chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.CRONOS_POS) return 'Cronos POS';
         if (chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.SUI) return 'Sui';
@@ -236,7 +240,10 @@ export default function LedgerPublicKeyRequest({ children }: AccessRequestProps)
                       }
                     }
 
-                    if (chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.ETHEREUM) {
+                    if (
+                      chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.ETHEREUM ||
+                      (chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.ETHERMINT && chain.line === 'COSMOS')
+                    ) {
                       const ethereumApp = new EthereumApp(transport);
 
                       const path = `${chain.bip44.purpose}/${chain.bip44.coinType}/${chain.bip44.account}/${chain.bip44.change}/${currentAccount.bip44.addressIndex}`;
@@ -245,8 +252,13 @@ export default function LedgerPublicKeyRequest({ children }: AccessRequestProps)
                       const { publicKey } = result;
 
                       if (accountIndex > -1) {
-                        newAccounts.splice(accountIndex, 1, { ...currentAccount, ethereumPublicKey: publicKey });
+                        if (chain.line === 'COSMOS') {
+                          const compressedPublicKey = Buffer.from(TinySecp256k1.pointCompress(Buffer.from(publicKey, 'hex'), true)).toString('hex');
 
+                          newAccounts.splice(accountIndex, 1, { ...currentAccount, ethermintPublicKey: compressedPublicKey });
+                        } else {
+                          newAccounts.splice(accountIndex, 1, { ...currentAccount, ethereumPublicKey: publicKey });
+                        }
                         await setExtensionStorage('accounts', newAccounts);
                       }
                     }

src/Popup/hooks/useEthermintLedgerSign.ts

@@ -0,0 +1,19 @@
+import { useMemo } from 'react';
+
+import { LEDGER_SUPPORT_COIN_TYPE } from '~/constants/ledger';
+import type { CosmosChain } from '~/types/chain';
+
+import { useCurrentAccount } from './useCurrent/useCurrentAccount';
+
+export function useEthermintLedgerSign(chain: CosmosChain) {
+  const { currentAccount } = useCurrentAccount();
+
+  const isLedgerAccount = useMemo(() => currentAccount.type === 'LEDGER', [currentAccount.type]);
+  const isEthermintChain = useMemo(() => chain.bip44.coinType === LEDGER_SUPPORT_COIN_TYPE.ETHERMINT, [chain.bip44.coinType]);
+
+  const isEthermintLedgerSign = useMemo(() => isLedgerAccount && isEthermintChain, [isEthermintChain, isLedgerAccount]);
+
+  const isInjectiveChain = useMemo(() => chain.id.startsWith('injective'), [chain.id]);
+
+  return { isEthermintLedgerSign, isInjectiveChain };
+}

src/Popup/i18n/en/translation.json

@@ -782,6 +782,7 @@
               "detailTab": "Details",
               "failedTransfer": "Failed to transfer",
               "insufficientFeeAmount": "Insufficient fee",
+              "notOpendEthApp": "Please open the Ethereum application on your Ledger device and try again.",
               "signButton": "Sign"
             }
           },
@@ -825,6 +826,15 @@
               "invalidAccountType": "Invalid account type (Ledger)"
             }
           },
+          "EIP712": {
+            "entry": {
+              "cancelButton": "Cancel",
+              "dataTab": "Data",
+              "detailTab": "Details",
+              "insufficientFeeAmount": "Insufficient fee",
+              "signButton": "Sign"
+            }
+          },
           "Message": {
             "entry": {
               "cancelButton": "Cancel",
@@ -1616,6 +1626,7 @@
           "invalidAmount": "Invalid amount",
           "invalidOutputAmount": "Invalid output amount",
           "invalidSwapTx": "Invalid tx data",
+          "ledgerNotSupported": "Not support signing with Ledger on Ethermint-like chains",
           "lessThanFeeWarningDescription1": "You do not have enough balance to cover the estimated gas costs for this transaction. Make sure you have more than",
           "lessThanFeeWarningDescription2": "before trying again.",
           "liquidityWarning": "The size of this trade is large compared to the available liquidity. Reduce the swap amount to get a better price.",