example-js-sdk 0.0.1

package/lib/provider/metamask/MetaMask.js

@@ -0,0 +1,665 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetaMask = void 0;
+const codec_1 = require("../../codec");
+const tx_1 = require("../../codec/cosmos/tx/v1beta1/tx");
+const constant_1 = require("../../constant");
+const eth_1 = require("../../eth");
+const index_1 = require("../../index");
+const util_1 = require("../../util");
+const address_1 = require("../../util/address");
+const blockchain_1 = require("../../util/blockchain");
+const eip712_1 = require("../../util/eip712");
+const ethermint_1 = require("../../util/ethermint");
+const evm_1 = require("../../util/evm");
+const generic_1 = require("../../util/generic");
+const legacyEIP712_1 = require("../../util/legacyEIP712");
+const network_1 = require("../../util/network");
+const provider_1 = require("../../util/provider");
+const wallet_1 = require("../../wallet");
+const build_1 = require("@cosmjs/amino/build");
+const proto_signing_1 = require("@cosmjs/proto-signing");
+const tx_2 = require("cosmjs-types/cosmos/tx/v1beta1/tx");
+const ethSignUtils = __importStar(require("eth-sig-util"));
+const ethers_1 = require("ethers");
+const constant_2 = require("../../constant");
+const eip6963Provider_1 = require("../eip6963Provider");
+const error_1 = require("./error");
+const legacy_accounts_1 = require("./legacy-accounts");
+const CONTRACT_HASH = {
+    Ethereum: {
+        // use same rinkeby contract for all non-mainnet uses
+        [constant_1.Network.TestNet]: "0x086e1b5f67c0f7ca8eb202d35553e27e964899e2",
+        [constant_1.Network.DevNet]: "0x086e1b5f67c0f7ca8eb202d35553e27e964899e2",
+        [constant_1.Network.LocalHost]: "0x086e1b5f67c0f7ca8eb202d35553e27e964899e2",
+        [constant_1.Network.MainNet]: "0xf4552877A40c1527D38970F170993660084D4541",
+    },
+    ['Binance Smart Chain']: {
+        // use same testnet contract for all non-mainnet uses
+        [constant_1.Network.TestNet]: "0x06E949ec2d6737ff57859CdcE426C5b5CA2Fc085",
+        [constant_1.Network.DevNet]: "0x06E949ec2d6737ff57859CdcE426C5b5CA2Fc085",
+        [constant_1.Network.LocalHost]: "0x06E949ec2d6737ff57859CdcE426C5b5CA2Fc085",
+        [constant_1.Network.MainNet]: "0x3786d94AC6B15FE2eaC72c3CA78cB82578Fc66f4",
+    },
+    Arbitrum: {
+        // use same testnet contract for all non-mainnet uses
+        [constant_1.Network.TestNet]: "",
+        [constant_1.Network.DevNet]: "",
+        [constant_1.Network.LocalHost]: "",
+        [constant_1.Network.MainNet]: "0x43138036d1283413035b8eca403559737e8f7980",
+    },
+    Polygon: {
+        // use same testnet contract for all non-mainnet uses
+        [constant_1.Network.TestNet]: "",
+        [constant_1.Network.DevNet]: "",
+        [constant_1.Network.LocalHost]: "",
+        [constant_1.Network.MainNet]: "0x61B9503Fe023E1F1Dd0ab7417923cB0A41DD9E0c",
+    },
+    OKC: {
+        // use same testnet contract for all non-mainnet uses
+        [constant_1.Network.TestNet]: "",
+        [constant_1.Network.DevNet]: "",
+        [constant_1.Network.LocalHost]: "",
+        [constant_1.Network.MainNet]: "0x7e8D8c98a016877Cb3103e837Fc71D41b155aF70",
+    },
+    Mantle: {
+        // use same testnet contract for all non-mainnet uses
+        [constant_1.Network.TestNet]: "",
+        [constant_1.Network.DevNet]: "",
+        [constant_1.Network.LocalHost]: "",
+        [constant_1.Network.MainNet]: "",
+    },
+    Optimism: {
+        // use same testnet contract for all non-mainnet uses
+        [constant_1.Network.TestNet]: "",
+        [constant_1.Network.DevNet]: "",
+        [constant_1.Network.LocalHost]: "",
+        [constant_1.Network.MainNet]: "",
+    },
+    Avalanche: {
+        // use same testnet contract for all non-mainnet uses
+        [constant_1.Network.TestNet]: "",
+        [constant_1.Network.DevNet]: "",
+        [constant_1.Network.LocalHost]: "",
+        [constant_1.Network.MainNet]: "",
+    },
+    Base: {
+        // use same testnet contract for all non-mainnet uses
+        [constant_1.Network.TestNet]: "",
+        [constant_1.Network.DevNet]: "",
+        [constant_1.Network.LocalHost]: "",
+        [constant_1.Network.MainNet]: "",
+    },
+    Monad: {
+        // use same testnet contract for all non-mainnet uses
+        [constant_1.Network.TestNet]: "",
+        [constant_1.Network.DevNet]: "",
+        [constant_1.Network.LocalHost]: "",
+        [constant_1.Network.MainNet]: "",
+    },
+    Carbon: {
+        //Carbon does not support Metamask legacy mnemonic sign in
+        [constant_1.Network.TestNet]: "",
+        [constant_1.Network.DevNet]: "",
+        [constant_1.Network.LocalHost]: "",
+        [constant_1.Network.MainNet]: "",
+    },
+};
+const REGISTRY_CONTRACT_ABI = eth_1.ABIs.keyStorage;
+const ENCRYPTION_VERSION = "x25519-xsalsa20-poly1305";
+const MNEMONIC_MATCH_REGEX = /-----BEGIN MNEMONIC PHRASE-----([a-z\s]*)-----END MNEMONIC PHRASE-----/im;
+const MNEMONIC_MATCH_REGEX_LEGACY = /^[a-z\s]*$/i;
+const getEncryptMessage = (input) => {
+    return `
+  !!! Attention !!! Please make sure you are connecting to https://app.dem.exchange, do not confirm decrypt if you're connecting to untrusted sites.
+  -----BEGIN MNEMONIC PHRASE-----
+  ${input}
+  -----END MNEMONIC PHRASE-----
+  `
+        .trim()
+        .replace(/^\s+/gm, "");
+};
+/**
+ * TODO: Add docs
+ */
+class MetaMask extends eip6963Provider_1.Eip6963Provider {
+    static createMetamaskSigner(metamask, evmChainId, pubKeyBase64, addressOptions) {
+        const evmHexAddress = util_1.AddressUtils.ETHAddress.publicKeyToAddress(Buffer.from(pubKeyBase64, "base64"), addressOptions);
+        const signDirect = async (_, doc) => {
+            const txBody = tx_2.TxBody.decode(doc.bodyBytes);
+            const authInfo = tx_1.AuthInfo.decode(doc.authInfoBytes);
+            const msgs = txBody.messages.map(message => {
+                const msg = codec_1.registry.decode({ ...message });
+                return {
+                    typeUrl: message.typeUrl,
+                    value: msg,
+                };
+            });
+            const fee = {
+                amount: authInfo.fee?.amount ?? [],
+                gas: authInfo.fee?.gasLimit.toString() ?? "0",
+            };
+            const aminoMsgs = msgs.map(msg => index_1.AminoTypesMap.toAmino(msg));
+            const { sig, signedDoc } = await metamask.signEip712(evmHexAddress, doc.accountNumber.toString(), evmChainId, aminoMsgs, fee, txBody.memo, authInfo.signerInfos[0].sequence.toString());
+            const signedTxBody = {
+                messages: msgs,
+                memo: signedDoc.memo,
+            };
+            const signedTxBodyEncodeObject = {
+                typeUrl: "/cosmos.tx.v1beta1.TxBody",
+                value: signedTxBody,
+            };
+            const signedTxBodyBytes = codec_1.registry.encode(signedTxBodyEncodeObject);
+            const signDoc = (0, proto_signing_1.makeSignDoc)(signedTxBodyBytes, doc.authInfoBytes, signedDoc.chain_id, parseInt(signedDoc.account_number));
+            const sigBz = Uint8Array.from(Buffer.from(sig, 'hex'));
+            return {
+                signed: signDoc,
+                signature: {
+                    pub_key: {
+                        type: ethermint_1.ETH_SECP256K1_TYPE,
+                        value: pubKeyBase64,
+                    },
+                    // Remove recovery `v` from signature
+                    signature: Buffer.from(sigBz.slice(0, -1)).toString('base64'),
+                },
+            };
+        };
+        const signAmino = async (_, doc) => {
+            const { account_number, msgs, fee, memo, sequence } = doc;
+            const { sig, signedDoc } = await metamask.signEip712(evmHexAddress, account_number, evmChainId, msgs, fee, memo, sequence);
+            const sigBz = Uint8Array.from(Buffer.from(sig, 'hex'));
+            return {
+                signed: signedDoc,
+                signature: {
+                    pub_key: {
+                        type: ethermint_1.ETH_SECP256K1_TYPE,
+                        value: pubKeyBase64,
+                    },
+                    // Remove recovery `v` from signature
+                    signature: Buffer.from(sigBz.slice(0, -1)).toString('base64'),
+                },
+            };
+        };
+        const getAccounts = async () => {
+            const address = await metamask.defaultAccount();
+            return [
+                {
+                    algo: "secp256k1",
+                    address,
+                    pubkey: Uint8Array.from(Buffer.from(pubKeyBase64, 'base64')),
+                },
+            ];
+        };
+        const signLegacyEip712 = async (signerAddress, doc) => {
+            const { account_number, chain_id, msgs, fee, memo, sequence } = doc;
+            // Only MsgMergeAccount will have an Eth address signer, other generic transaction will be cosmos address signer
+            // FeePayer here is only used for legacy EIP-712
+            const feePayer = index_1.AminoTypesMap.fromAmino(msgs[0]).typeUrl === codec_1.TxTypes.MsgMergeAccount ? util_1.AddressUtils.ETHAddress.publicKeyToBech32Address(Buffer.from(pubKeyBase64, "base64"), addressOptions) : signerAddress;
+            const { sig, signedDoc } = await metamask.signEip712(evmHexAddress, account_number, chain_id, msgs, fee, memo, sequence, feePayer);
+            return {
+                signed: signedDoc,
+                signature: {
+                    pub_key: {
+                        type: ethermint_1.ETH_SECP256K1_TYPE,
+                        value: pubKeyBase64,
+                    },
+                    signature: Buffer.from(sig, 'hex').toString('base64'),
+                },
+                feePayer,
+            };
+        };
+        const sendEvmTransaction = async (api, req) => {
+            try {
+                const request = await (0, ethermint_1.populateEvmTransactionDetails)(api, req);
+                const response = await metamask.sendEvmTransaction(request);
+                return response;
+            }
+            catch (error) {
+                console.error(error);
+                throw ((0, error_1.parseEvmError)(error, index_1.ProviderAgent.MetamaskExtension));
+            }
+        };
+        const signMessage = async (address, message) => {
+            return metamask.personalSign(address, message);
+        };
+        return {
+            type: wallet_1.CarbonSignerTypes.BrowserInjected,
+            legacyEip712SignMode: metamask.legacyEip712SignMode,
+            signDirect,
+            signAmino,
+            getAccounts,
+            signLegacyEip712,
+            sendEvmTransaction,
+            signMessage,
+        };
+    }
+    static async signAndRecoverPubKey(provider, enableJwtAuth, customMsg = evm_1.DEFAULT_PUBLIC_KEY_MESSAGE) {
+        const address = await provider.defaultAccount();
+        const signMessage = enableJwtAuth ? index_1.AuthUtils.getAuthMessage(customMsg) : customMsg;
+        const signature = await provider.personalSign(address, signMessage);
+        const publicKeyHex = index_1.EvmUtils.recoverPublicKey(signMessage, signature);
+        return {
+            publicKey: Buffer.from(publicKeyHex, 'hex').toString('base64'),
+            signature,
+            message: signMessage,
+        };
+    }
+    static getNetworkParams(network, blockchain = 'Ethereum') {
+        if (blockchain === 'Carbon') {
+            return MetaMask.getCarbonEvmNetworkParams(network);
+        }
+        const isMainnet = network === constant_1.Network.MainNet;
+        // metamask should come with Ethereum configs
+        return isMainnet ? constant_2.ETH_MAINNET : constant_2.ETH_TESTNET;
+    }
+    static getCarbonEvmNetworkParams(network) {
+        switch (network) {
+            case constant_1.Network.LocalHost:
+                return constant_2.CARBON_EVM_LOCALHOST;
+            case constant_1.Network.DevNet:
+                return constant_2.CARBON_EVM_DEVNET;
+            case constant_1.Network.TestNet:
+                return constant_2.CARBON_EVM_TESTNET;
+            default:
+                return constant_2.CARBON_EVM_MAINNET;
+        }
+    }
+    static getRequiredChainId(network, blockchain = 'Ethereum') {
+        if (blockchain === "Carbon") {
+            return Number((0, ethermint_1.parseChainId)(constant_1.CarbonEvmChainIDs[network]));
+        }
+        const isMainnet = network === constant_1.Network.MainNet;
+        // Fallback to Ethereum chain ID
+        const chainId = isMainnet ? constant_2.ETH_MAINNET.chainId : constant_2.ETH_TESTNET.chainId;
+        return Number(chainId);
+    }
+    constructor(network, legacyEip712SignMode = false) {
+        super();
+        this.network = network;
+        this.legacyEip712SignMode = legacyEip712SignMode;
+        this.blockchain = 'Ethereum';
+        this.connectedAccount = '';
+    }
+    checkProvider(blockchain = this.blockchain) {
+        const config = constant_1.NetworkConfigs[this.network];
+        if (!config[blockchain_1.BLOCKCHAIN_V2_TO_V1_MAPPING[blockchain]]) {
+            throw new Error(`MetaMask login not supported for this network ${this.network}`);
+        }
+        const ethNetworkConfig = config[blockchain_1.BLOCKCHAIN_V2_TO_V1_MAPPING[blockchain]];
+        const provider = new ethers_1.ethers.providers.JsonRpcProvider(ethNetworkConfig.rpcURL);
+        return provider;
+    }
+    getBlockchain() {
+        return this.blockchain;
+    }
+    async syncConnectedAccount() {
+        this.connectedAccount = await this.defaultAccount();
+        return this.connectedAccount;
+    }
+    async syncBlockchain() {
+        const metamaskAPI = await this.getConnectedAPI();
+        const chainIdHex = (await metamaskAPI?.request({ method: "eth_chainId" }));
+        const chainId = chainIdHex ? parseInt(chainIdHex, 16) : undefined;
+        const blockchain = (0, blockchain_1.getBlockchainFromChainV2)(chainId);
+        this.blockchain = blockchain;
+        return { chainId, blockchain };
+    }
+    async getSigner() {
+        const ethereum = await this.getConnectedAPI();
+        return new ethers_1.ethers.providers.Web3Provider(ethereum).getSigner();
+    }
+    getDefaultMetamaskProvider() {
+        const metamaskProvider = super.getProvider(index_1.SupportedEip6963Provider.MetaMask);
+        return metamaskProvider?.provider;
+    }
+    async getConnectedAPI() {
+        const metamaskProvider = this.getDefaultMetamaskProvider();
+        if (!metamaskProvider) {
+            throw new Error("MetaMask not connected, please check that your extension is enabled");
+        }
+        return metamaskProvider;
+    }
+    async connect() {
+        return this.getConnectedAPI();
+    }
+    async defaultAccount() {
+        const metamaskAPI = await this.getConnectedAPI();
+        const accounts = (await metamaskAPI.request({ method: "eth_requestAccounts" }));
+        const [defaultAccount] = accounts;
+        if (!defaultAccount) {
+            throw new Error("No default account on MetaMask, please create one first");
+        }
+        return defaultAccount;
+    }
+    async getEncryptedLegacyAccounts(network = constant_1.Network.MainNet) {
+        const defaultAccount = await this.defaultAccount();
+        const legacyAccounts = network === constant_1.Network.MainNet ? legacy_accounts_1.LEGACY_ACCOUNTS_MAINNET : legacy_accounts_1.LEGACY_ACCOUNTS_TESTNET;
+        const legacyAccBlockchains = [];
+        for (const [blockchain] of Object.entries(legacyAccounts)) {
+            for (const address of legacyAccounts[blockchain]) {
+                if (address.toLowerCase() === defaultAccount.toLowerCase()) {
+                    legacyAccBlockchains.push(blockchain);
+                    break;
+                }
+            }
+        }
+        if (legacyAccBlockchains.length > 0) {
+            const legacyMnemonicCiphers = legacyAccBlockchains.map(async (blockchain) => (this.getMnemonicInfo(blockchain)));
+            const results = await Promise.all(legacyMnemonicCiphers);
+            return results.filter((result) => result !== undefined);
+        }
+        return undefined;
+    }
+    async changeNetworkIfRequired(blockchain, network) {
+        const required = await this.isChangeNetworkRequired(blockchain, network);
+        if (!required)
+            return;
+        const metamaskApi = await this.getConnectedAPI();
+        const requiredChainId = `0x${MetaMask.getRequiredChainId(network, blockchain).toString(16)}`;
+        try {
+            await metamaskApi.request({ method: 'wallet_switchEthereumChain', params: [{ chainId: requiredChainId }] });
+            await this.syncBlockchain();
+        }
+        catch (err) {
+            // This error code indicates that the chain has not been added to MetaMask.
+            try {
+                await metamaskApi.request({
+                    method: 'wallet_addEthereumChain',
+                    params: [MetaMask.getNetworkParams(network, blockchain)],
+                });
+                await this.syncBlockchain();
+            }
+            catch (err) {
+                throw new Error(`Please switch to ${blockchain} network on Metamask.`);
+            }
+        }
+    }
+    async isChangeNetworkRequired(blockchain, network) {
+        const metamaskNetwork = await this.syncBlockchain();
+        const requiredChainId = MetaMask.getRequiredChainId(network, blockchain);
+        return metamaskNetwork.chainId !== requiredChainId;
+    }
+    async verifyNetworkAndConnectedAccount(evmHexAddress, evmChainId) {
+        await this.verifyNetwork(evmChainId);
+        await this.verifyConnectedAccount(evmHexAddress);
+    }
+    async verifyNetwork(evmChainId) {
+        const network = (0, network_1.carbonNetworkFromChainId)(evmChainId);
+        await this.changeNetworkIfRequired("Carbon", network);
+    }
+    async verifyConnectedAccount(address) {
+        const metamaskAPI = await this.getConnectedAPI();
+        const accounts = (await metamaskAPI.request({ method: "eth_requestAccounts" }));
+        if (!accounts.find(acc => acc.toLowerCase() === address?.toLowerCase()))
+            throw new Error(`${address} not connected on Metamask`);
+    }
+    async getMnemonicInfo(connectedBlockchain) {
+        const defaultAccount = await this.defaultAccount();
+        let result;
+        if (connectedBlockchain && connectedBlockchain !== 'Carbon' && CONTRACT_HASH[connectedBlockchain][this.network]) {
+            const mnemonicCipher = await this.getStoredMnemonicCipher(defaultAccount, connectedBlockchain).catch(err => {
+                console.error(err);
+                throw new Error(`Unable to retrieve stored mnemonic cipher from ${connectedBlockchain}`);
+            });
+            if (mnemonicCipher) {
+                const mnemonic = await this.decryptCipher(mnemonicCipher) ?? '';
+                const privateKey = `0x${address_1.SWTHAddress.mnemonicToPrivateKey(mnemonic).toString('hex').toLowerCase()}`;
+                const bech32Address = address_1.SWTHAddress.privateKeyToAddress(address_1.SWTHAddress.mnemonicToPrivateKey(mnemonic), { network: this.network });
+                const evmHexAddress = address_1.ETHAddress.privateKeyToAddress(address_1.SWTHAddress.mnemonicToPrivateKey(mnemonic));
+                result = {
+                    mnemonic,
+                    chain: connectedBlockchain,
+                    privateKey,
+                    bech32Address,
+                    evmHexAddress,
+                };
+            }
+        }
+        return result;
+    }
+    async getStoredMnemonicCipher(account, blockchain) {
+        const contractHash = this.getContractHash(blockchain);
+        const provider = this.checkProvider(blockchain);
+        const contract = new ethers_1.ethers.Contract(contractHash, REGISTRY_CONTRACT_ABI, provider);
+        const cipherTextHex = await contract.map(account);
+        if (!cipherTextHex?.length || cipherTextHex === "0x") {
+            // value would be '0x' if not initialized
+            return undefined;
+        }
+        return cipherTextHex;
+    }
+    async encryptMnemonic(mnemonic) {
+        const defaultAccount = await this.defaultAccount();
+        const publicKey = await this.getEncryptionPublicKey(defaultAccount);
+        const messageToEncrypt = getEncryptMessage(mnemonic);
+        const cipher = ethSignUtils.encrypt(publicKey, {
+            data: messageToEncrypt,
+        }, ENCRYPTION_VERSION);
+        const { version, nonce, ephemPublicKey, ciphertext } = cipher;
+        const encryptedMnemonic = ethers_1.ethers.utils.toUtf8Bytes([version, nonce, ephemPublicKey, ciphertext].join("."));
+        return Buffer.from(encryptedMnemonic).toString("hex");
+    }
+    // create signed public key for merging of cosmos and ethereum accounts (Metamask V2)
+    async signPublicKeyMergeAccount(publicKey, address) {
+        const message = `${ethermint_1.PUBLIC_KEY_SIGNING_TEXT}${publicKey}`;
+        return (await this.personalSign(address, message)).split("0x")[1];
+    }
+    async personalSign(address, message) {
+        const api = await this.getConnectedAPI();
+        const ethAddress = ethers_1.ethers.utils.getAddress(address);
+        return (await api.request({
+            method: "personal_sign",
+            params: [(0, generic_1.appendHexPrefix)(Buffer.from(message, "utf-8").toString("hex")), ethAddress],
+        }));
+    }
+    async getEncryptionPublicKey(address) {
+        const api = await this.getConnectedAPI();
+        const publicKey = (await api.request({
+            method: "eth_getEncryptionPublicKey",
+            params: [address],
+        }));
+        return publicKey;
+    }
+    async signEip712(evmHexAddress, accountNumber, evmChainId, msgs, fee, memo, sequence, feePayer = '') {
+        const metamaskNetwork = await this.syncBlockchain();
+        const metamaskChainId = metamaskNetwork.chainId ? `orbix_${metamaskNetwork.chainId.toString()}-1` : '';
+        const metamaskAPI = await this.getConnectedAPI();
+        if (metamaskChainId !== evmChainId) {
+            memo += "|CROSSCHAIN-SIGNING|signed-chain-id:" + metamaskChainId + ";" + "orbix-chain-id:" + evmChainId;
+        }
+        const stdSignDoc = (0, build_1.makeSignDoc)(msgs, fee, evmChainId, memo, accountNumber, sequence);
+        const eip712Tx = this.legacyEip712SignMode ? (0, legacyEIP712_1.legacyConstructEIP712Tx)({ ...stdSignDoc, fee: { ...fee, feePayer } }) : (0, eip712_1.constructEIP712Tx)(stdSignDoc, metamaskChainId);
+        const sig = await (0, provider_1.signTransactionWrapper)(async () => {
+            const signature = (await metamaskAPI.request({
+                method: 'eth_signTypedData_v4',
+                params: [
+                    evmHexAddress,
+                    JSON.stringify(eip712Tx),
+                ],
+            }));
+            return signature.split('0x')[1];
+        });
+        return { sig, signedDoc: stdSignDoc };
+    }
+    async sendEvmTransaction(req) {
+        await this.verifyNetworkAndConnectedAccount(req.from, req.chainId.toString());
+        const api = await this.getConnectedAPI();
+        const tx = {
+            from: req.from,
+            to: req.to,
+            value: req.value,
+            gasPrice: req.gasPrice,
+            gas: req.gasLimit,
+            data: req.data,
+            // type can only be 0 or 1 or 2
+            type: `0x${req.type}`,
+            chainId: req.chainId,
+        };
+        const txHash = (await api.request({
+            method: "eth_sendTransaction",
+            params: [tx],
+        }));
+        return txHash;
+    }
+    async storeMnemonic(encryptedMnemonic, blockchain) {
+        const metamaskAPI = await this.getConnectedAPI();
+        const defaultAccount = await this.defaultAccount();
+        const storedMnemonicCipher = await this.getStoredMnemonicCipher(defaultAccount, blockchain);
+        if (storedMnemonicCipher) {
+            throw new Error("Cannot store key on registry - key already exists for ETH account");
+        }
+        const contractHash = this.getContractHash(blockchain);
+        const provider = this.checkProvider(blockchain);
+        const contract = new ethers_1.ethers.Contract(contractHash, REGISTRY_CONTRACT_ABI, provider);
+        const dataBytes = Buffer.from(encryptedMnemonic, "hex");
+        const unsignedTx = await contract.populateTransaction.Store(dataBytes);
+        const txHash = (await metamaskAPI.request({
+            method: "eth_sendTransaction",
+            params: [
+                {
+                    ...unsignedTx,
+                    from: defaultAccount,
+                },
+            ],
+        }));
+        return txHash;
+    }
+    async login(blockchain) {
+        if (blockchain === 'Carbon') {
+            throw new Error('Carbon EVM does not support Metamask Legacy');
+        }
+        const metamaskAPI = await this.getConnectedAPI();
+        const defaultAccount = await this.defaultAccount();
+        const cipherTextHex = await this.getStoredMnemonicCipher(defaultAccount, blockchain);
+        const chainIdHex = (await metamaskAPI.request({ method: "eth_chainId" }));
+        const chainId = parseInt(chainIdHex, 16);
+        const requiredChainId = this.getRequiredChain(this.network, chainId);
+        if (chainId !== requiredChainId) {
+            const requiredNetworkName = blockchain_1.ChainNames[requiredChainId] ?? blockchain_1.ChainNames[3];
+            throw new Error(`MetaMask not connected to correct network, please use ${requiredNetworkName} (Chain ID: ${requiredChainId})`);
+        }
+        const mnemonic = this.decryptCipher(cipherTextHex);
+        return mnemonic;
+    }
+    async decryptCipher(cipherTextHex) {
+        const metamaskAPI = await this.getConnectedAPI();
+        const defaultAccount = await this.defaultAccount();
+        if (!cipherTextHex || !cipherTextHex.length) {
+            return null;
+        }
+        const cipherText = ethers_1.ethers.utils.toUtf8String(cipherTextHex);
+        const [version, nonce, ephemPublicKey, ciphertext] = cipherText.split(".");
+        const cipher = {
+            version,
+            nonce,
+            ephemPublicKey,
+            ciphertext,
+        };
+        const decryptedCipherText = (await metamaskAPI.request({
+            method: "eth_decrypt",
+            params: [Buffer.from(JSON.stringify(cipher)).toString('hex'), defaultAccount],
+        }))?.trim();
+        // legacy encrypted mnemonic doesnt include warning message.
+        if (decryptedCipherText.match(MNEMONIC_MATCH_REGEX_LEGACY)) {
+            return decryptedCipherText;
+        }
+        // match line with prefix 'mnemonic: '
+        const match = decryptedCipherText.match(MNEMONIC_MATCH_REGEX);
+        // invalid cipher
+        if (!match) {
+            console.error("invalid account info retrieved from contract");
+            console.error(decryptedCipherText);
+            throw new Error("Retrieved invalid account on blockchain, please check console for more information.");
+        }
+        return match[1]?.trim();
+    }
+    getRequiredChain(network, currentChainId) {
+        const isMainnet = network === constant_1.Network.MainNet;
+        if (!isMainnet && currentChainId === 10143) {
+            this.blockchain = 'Monad';
+            return 10143;
+        }
+        switch (currentChainId) {
+            case 1: // Ethereum Mainnet
+            case 5: // Ethereum Goerli Testnet
+                this.blockchain = 'Ethereum';
+                return isMainnet ? 1 : 5;
+            case 56: // Binance Smart Chain Mainnet
+            case 97: // Binance Smart Chain Testnet
+                this.blockchain = 'Binance Smart Chain';
+                return isMainnet ? 56 : 97;
+            case 42161: // Arbitrum Mainnet
+            case 421611: // Arbitrum Testnet
+                this.blockchain = 'Arbitrum';
+                return isMainnet ? 42161 : 421611;
+            case 137: // Polygon Mainnet
+            case 80001: // Polygon Testnet
+                this.blockchain = 'Polygon';
+                return isMainnet ? 137 : 80001;
+            case 66: // OKC Mainnet
+            case 65: // OKC Testnet
+                this.blockchain = 'OKC';
+                return isMainnet ? 66 : 65;
+            case 5000: // Mantle Mainnet
+            case 5003: // Mantle Testnet
+                this.blockchain = 'Mantle';
+                return isMainnet ? 5000 : 5003;
+            case 10: // OP Mainnet
+            case 11155420: // OP Sepolia Testnet
+                this.blockchain = 'Optimism';
+                return isMainnet ? 10 : 11155420;
+            case 43114: // Avalanche Mainnet
+            case 43113: // Avalanche Fuji Testnet
+                this.blockchain = 'Avalanche';
+                return isMainnet ? 43114 : 43113;
+            case 8453:
+            case 84532:
+                this.blockchain = 'Base';
+                return isMainnet ? 8453 : 84532;
+            default:
+                // Default fallback for Ethereum if no specific match found
+                return isMainnet ? 1 : 5;
+        }
+    }
+    getContractHash(blockchain = this.blockchain) {
+        const contractHash = CONTRACT_HASH[blockchain][this.network];
+        if (!contractHash) {
+            throw new Error(`MetaMask login is not supported on ${this.network} on ${blockchain}`);
+        }
+        return contractHash;
+    }
+}
+exports.MetaMask = MetaMask;

package/lib/provider/metamask/error.d.ts

@@ -0,0 +1,2 @@
+import { ProviderAgent } from "../../constant";
+export declare const parseEvmError: (error: Error, providerAgent?: ProviderAgent) => Error;

package/lib/provider/metamask/error.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEvmError = void 0;
+const constant_1 = require("../../constant");
+const isNonceMismatchError = (error) => {
+    return error.message.includes('invalid nonce');
+};
+const isContractExecutionReverted = (error) => {
+    return error.message.includes('execution reverted');
+};
+const parseEvmError = (error, providerAgent) => {
+    if (providerAgent === constant_1.ProviderAgent.MetamaskExtension && isNonceMismatchError(error))
+        return new Error('Please clear the activity data in your wallet. On your MetaMask Settings > Advanced > Clear activity tab data.');
+    if (isContractExecutionReverted(error))
+        return new Error('Contract execution reverted. Refer to the console for details.');
+    return error;
+};
+exports.parseEvmError = parseEvmError;