carbon-js-sdk 0.4.16 → 0.4.17

package/lib/clients/TokenClient.js

@@ -644,15 +644,16 @@ class TokenClient {
             const geckoIdToUsdPriceMap = yield this.getUSDValuesFromCoinGecko(geckoIds);
             const carbonTokenPrices = yield this.getUSDValuesFromPricingModule();
             const uscStablecoin = this.getNativeStablecoin();
+            // add carbon token prices first
+            Object.entries(carbonTokenPrices).forEach(([key, value]) => {
+                this.usdValues[key] = value;
+            });
             //store price based on denoms
             for (const denom of denoms) {
-                const carbonTokenPrice = carbonTokenPrices[denom];
                 // if token price in pricing module exists for denom, return that as usd price first
                 // else check coingecko
-                if (carbonTokenPrice) {
-                    this.usdValues[denom] = carbonTokenPrice;
+                if (this.usdValues[denom])
                     continue;
-                }
                 const coinId = (_a = this.geckoTokenNames[denom]) !== null && _a !== void 0 ? _a : denom;
                 const price = util_1.NumberUtils.bnOrZero((_b = geckoIdToUsdPriceMap === null || geckoIdToUsdPriceMap === void 0 ? void 0 : geckoIdToUsdPriceMap[coinId]) === null || _b === void 0 ? void 0 : _b.usd);
                 if (price.gt(0)) {

package/lib/constant/eip712.d.ts

@@ -1,4 +1,4 @@
-export declare const DEFAULT_EIP712_TYPES: {
+export declare const LEGACY_DEFAULT_EIP712_TYPES: {
     EIP712Domain: {
         name: string;
         type: string;
@@ -20,6 +20,24 @@ export declare const DEFAULT_EIP712_TYPES: {
         type: string;
     }[];
 };
+export declare const DEFAULT_EIP712_TYPES: {
+    Coin: {
+        name: string;
+        type: string;
+    }[];
+    EIP712Domain: {
+        name: string;
+        type: string;
+    }[];
+    Fee: {
+        name: string;
+        type: string;
+    }[];
+    Tx: {
+        name: string;
+        type: string;
+    }[];
+};
 export declare const DEFAULT_CARBON_DOMAIN_FIELDS: {
     name: string;
     version: string;

package/lib/constant/eip712.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_CARBON_DOMAIN_FIELDS = exports.DEFAULT_EIP712_TYPES = void 0;
-exports.DEFAULT_EIP712_TYPES = {
+exports.DEFAULT_CARBON_DOMAIN_FIELDS = exports.DEFAULT_EIP712_TYPES = exports.LEGACY_DEFAULT_EIP712_TYPES = void 0;
+exports.LEGACY_DEFAULT_EIP712_TYPES = {
     EIP712Domain: [
         { name: 'name', type: 'string' },
         { name: 'version', type: 'string' },
@@ -31,10 +31,76 @@ exports.DEFAULT_EIP712_TYPES = {
         { name: 'value', type: 'MsgValue' },
     ],
 };
+exports.DEFAULT_EIP712_TYPES = {
+    Coin: [
+        {
+            name: 'denom',
+            type: 'string'
+        },
+        {
+            name: 'amount',
+            type: 'string'
+        }
+    ],
+    EIP712Domain: [
+        {
+            name: 'name',
+            type: 'string'
+        },
+        {
+            name: 'version',
+            type: 'string'
+        },
+        {
+            name: 'chainId',
+            type: 'uint256'
+        },
+        {
+            name: 'verifyingContract',
+            type: 'string'
+        },
+        {
+            name: 'salt',
+            type: 'string'
+        }
+    ],
+    Fee: [
+        {
+            name: 'amount',
+            type: 'Coin[]'
+        },
+        {
+            name: 'gas',
+            type: 'string'
+        }
+    ],
+    Tx: [
+        {
+            name: 'account_number',
+            type: 'string'
+        },
+        {
+            name: 'chain_id',
+            type: 'string'
+        },
+        {
+            name: 'fee',
+            type: 'Fee'
+        },
+        {
+            name: 'memo',
+            type: 'string'
+        },
+        {
+            name: 'sequence',
+            type: 'string'
+        },
+    ]
+};
 // Note that the chainId field is delibrately omitted because it is dynamic
 exports.DEFAULT_CARBON_DOMAIN_FIELDS = {
-    name: "Carbon",
-    version: "1.0.0",
-    verifyingContract: "cosmos",
-    salt: "1",
+    name: 'Carbon',
+    version: '1.0.0',
+    verifyingContract: 'cosmos',
+    salt: '1',
 };

package/lib/modules/evm.js

@@ -68,7 +68,7 @@ class EvmModule extends base_1.default {
                 })
             });
             return yield wallet.sendTx({
-                typeUrl: util_1.CarbonTx.Types.MsgUpdateParams,
+                typeUrl: util_1.CarbonTx.Types.MsgEvmUpdateParams,
                 value,
             }, opts);
         });

package/lib/provider/amino/types/evm.d.ts

@@ -0,0 +1,4 @@
+import { TypeUtils } from "../../../util";
+import { AminoConverter } from "@cosmjs/stargate";
+declare const EvmAmino: TypeUtils.SimpleMap<AminoConverter>;
+export default EvmAmino;

package/lib/provider/amino/types/evm.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const CarbonTx = __importStar(require("../../../util/tx"));
+const utils_1 = require("../utils");
+const TxTypes = {
+    UpdateParams: "ethermint/MsgUpdateParams",
+    EthereumTx: "evm/v1/MsgEthereumTx"
+};
+const MsgEthereumTx = {
+    aminoType: TxTypes.EthereumTx,
+    valueMap: {},
+};
+const MsgUpdateParams = {
+    aminoType: TxTypes.UpdateParams,
+    valueMap: {},
+};
+const EvmAmino = {
+    [CarbonTx.Types.MsgEthereumTx]: utils_1.generateAminoType(MsgEthereumTx),
+    [CarbonTx.Types.MsgEvmUpdateParams]: utils_1.generateAminoType(MsgUpdateParams),
+};
+exports.default = EvmAmino;

package/lib/provider/amino/types/evmmerge.d.ts

@@ -0,0 +1,4 @@
+import { TypeUtils } from "../../../util";
+import { AminoConverter } from "@cosmjs/stargate";
+declare const EvmMergeAmino: TypeUtils.SimpleMap<AminoConverter>;
+export default EvmMergeAmino;

package/lib/provider/amino/types/evmmerge.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const CarbonTx = __importStar(require("../../../util/tx"));
+const utils_1 = require("../utils");
+const TxTypes = {
+    MergeAccount: "evmmerge/MsgMergeAccount",
+};
+const MsgMergeAccount = {
+    aminoType: TxTypes.MergeAccount,
+    valueMap: {},
+};
+const EvmMergeAmino = {
+    [CarbonTx.Types.MsgMergeAccount]: utils_1.generateAminoType(MsgMergeAccount),
+};
+exports.default = EvmMergeAmino;

package/lib/provider/amino/types/feemarket.d.ts

@@ -0,0 +1,4 @@
+import { TypeUtils } from "../../../util";
+import { AminoConverter } from "@cosmjs/stargate";
+declare const FeeMarketAmino: TypeUtils.SimpleMap<AminoConverter>;
+export default FeeMarketAmino;

package/lib/provider/amino/types/feemarket.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const CarbonTx = __importStar(require("../../../util/tx"));
+const utils_1 = require("../utils");
+const TxTypes = {
+    UpdateParams: "ethermint/feemarket/MsgUpdateParams",
+};
+const MsgUpdateParams = {
+    aminoType: TxTypes.UpdateParams,
+    valueMap: {},
+};
+const FeeMarketAmino = {
+    [CarbonTx.Types.MsgUpdateParams]: utils_1.generateAminoType(MsgUpdateParams),
+};
+exports.default = FeeMarketAmino;

package/lib/util/eip712.d.ts

@@ -1,10 +1,10 @@
-import { StdSignDoc } from "@cosmjs/amino/build";
 import { TypedDataDomain, TypedDataField } from "@ethersproject/abstract-signer";
 import { TypeUtils } from ".";
+import { CarbonTx } from "../util";
 export interface EIP712Tx {
-    readonly types: TypeUtils.SimpleMap<Array<TypedDataField>>;
+    readonly types: TypeUtils.SimpleMap<TypedDataField[]>;
     readonly primaryType: string;
     readonly domain: TypedDataDomain;
-    readonly message: StdSignDoc;
+    readonly message: any;
 }
-export declare function constructEIP712Tx(doc: StdSignDoc): EIP712Tx;
+export declare function constructEIP712Tx(doc: CarbonTx.StdSignDoc): EIP712Tx;

package/lib/util/eip712.js

@@ -8,39 +8,188 @@ const eip712_1 = require("../constant/eip712");
 const ethermint_1 = require("../util/ethermint");
 const codec_1 = require("../codec");
 const AminoTypesMap_1 = __importDefault(require("../provider/amino/AminoTypesMap"));
-function getTypes(msgTypeUrl, aminoMsgValue) {
-    return Object.assign(Object.assign({}, eip712_1.DEFAULT_EIP712_TYPES), getMsgValueType(msgTypeUrl, aminoMsgValue, "MsgValue"));
+const lodash_1 = require("lodash");
+function getTypes(msgs) {
+    let types = Object.assign({}, eip712_1.DEFAULT_EIP712_TYPES);
+    const includedTypes = [];
+    let valueIndex = 0;
+    msgs.forEach((msg, index) => {
+        const typeUrl = AminoTypesMap_1.default.fromAmino(msg).typeUrl;
+        const msgType = msg.type.split('/')[1];
+        const msgTypeIndex = getLatestMsgTypeIndex(`Type${msgType}`, types);
+        //cosmos-sdk/MsgSend => TypeMsgSend1
+        const typeKey = `Type${msgType}${msgTypeIndex}`;
+        if (!includedTypes.includes(msg.type)) {
+            types['Tx'] = [...types['Tx'], { name: `msg${index}`, type: typeKey }];
+            types[typeKey] = [{ name: 'value', type: `TypeValue${valueIndex}` }, { name: 'type', type: 'string' }];
+            //cosmos-sdk/MsgSend => Msg_Send
+            types = Object.assign(Object.assign({}, types), sortByNameDescending(getMsgValueType(typeUrl, msg.value, `TypeValue${valueIndex}`, valueIndex, types)));
+            includedTypes.push(msg.type);
+            valueIndex++;
+            return;
+        }
+        const typeFound = matchingType(msg, types);
+        if (typeFound) {
+            types['Tx'] = [...types['Tx'], { name: `msg${index}`, type: typeFound }];
+            return;
+        }
+        //same type, but different fields populated, so new type defnition is required
+        types['Tx'] = [...types['Tx'], { name: `msg${index}`, type: typeKey }];
+        types[typeKey] = [{ name: 'value', type: `TypeValue${valueIndex}` }, { name: 'type', type: 'string' }];
+        types = Object.assign(Object.assign({}, types), sortByNameDescending(getMsgValueType(typeUrl, msg.value, `TypeValue${valueIndex}`, valueIndex, types)));
+        valueIndex++;
+    });
+    return types;
 }
-function getMsgValueType(msgTypeUrl, aminoMsgValue, msgTypeName, msgTypeDefinitions = {}) {
-    const packageName = msgTypeUrl.split(".").splice(-1).join();
+function getLatestMsgTypeIndex(typeName, types) {
+    let index = 0;
+    Object.entries(types).forEach(([key, _]) => {
+        if (key.includes(typeName)) {
+            index++;
+        }
+    });
+    return index;
+}
+function sortByNameDescending(types) {
+    Object.entries(types).forEach(([key, _]) => {
+        types[key].sort((a, b) => b.name.localeCompare(a.name));
+    });
+    return types;
+}
+// Checks if there is a need to create new type for the same message type because of different populated fields 
+function matchingType(msg, eipTypes) {
+    const msgType = msg.type.split('/')[1];
+    let match = false;
+    for (const key in eipTypes) {
+        if (key.includes(msgType)) {
+            match = compareValues(msg, key, eipTypes);
+        }
+        if (match) {
+            return key;
+        }
+    }
+    return '';
+}
+function compareValues(msg, key, eipTypes) {
+    let match = true;
+    for (let { name, type } of eipTypes[key]) {
+        if (Object.keys(msg).length > eipTypes[key].length) {
+            return false;
+        }
+        let value = msg[name];
+        if (!isNonZeroField(value)) {
+            return false;
+        }
+        const typeIsArray = type.includes('[]');
+        if (typeIsArray) {
+            type = type.split('[]')[0];
+            //Assumption: Take first value in array to determine which fields are populated
+            value = value[0];
+        }
+        if (eipTypes[type]) {
+            match = compareValues(value, type, eipTypes);
+        }
+    }
+    return match;
+}
+function getMsgValueType(msgTypeUrl, msgValue, msgTypeName, msgTypeIndex, types, objectName, nestedType = false, msgTypeDefinitions = {}) {
+    const packageName = msgTypeUrl.split(".").slice(0, -1).join(".");
     const msgFieldType = msgTypeUrl.split(".").pop();
+    const typeName = getTypeName(msgTypeName, msgTypeIndex, objectName, nestedType, false);
     const fieldsDefinition = codec_1.EIP712Types[packageName][msgFieldType];
-    const nonZeroFieldsDefinition = [];
-    fieldsDefinition.forEach(({ packageName, name, type }) => {
-        const fieldValue = aminoMsgValue[name];
-        if (fieldValue && fieldValue.length) {
-            nonZeroFieldsDefinition.push({ name, type });
-            msgTypeDefinitions[msgTypeName] = Object.assign(Object.assign({}, msgTypeDefinitions[msgTypeName]), nonZeroFieldsDefinition);
-            if (packageName) {
-                const typeUrl = `${packageName}.${type}`;
-                const nestedAminoMsgValue = isMessage(typeUrl) ? aminoMsgValue[name]["value"] : aminoMsgValue[name];
-                getMsgValueType(typeUrl, nestedAminoMsgValue, type, msgTypeDefinitions);
-            }
+    if (isNonZeroField(msgValue)) {
+        if (!msgTypeDefinitions[typeName]) {
+            msgTypeDefinitions[typeName] = [];
         }
-    });
+        fieldsDefinition.forEach(({ packageName, name, type }) => {
+            if (Array.isArray(msgValue) && msgValue.length === 0) {
+                msgTypeDefinitions[typeName] = [...msgTypeDefinitions[typeName], { name, type: 'string[]' }];
+                return;
+            }
+            //Assumption: Take first value in array to determine which fields are populated
+            const fieldValue = Array.isArray(msgValue) && msgValue.length > 0 ? msgValue[0][name] : msgValue[name];
+            if (isNonZeroField(fieldValue)) {
+                //For nested structs
+                if (packageName) {
+                    const isArray = type.includes('[]') ? true : false;
+                    // TypeValue0 --> Value
+                    const objectName = typeName.split('Type')[1].split(`${msgTypeIndex}`)[0];
+                    const nestedTypeName = `Type${objectName ? objectName : ''}${name.split('_').map((subName) => lodash_1.capitalize(subName)).join('')}`;
+                    const nestedMsgTypeIndex = getLatestMsgTypeIndex(nestedTypeName, types);
+                    const nestedType = getTypeName(name, nestedMsgTypeIndex, objectName, true, isArray);
+                    msgTypeDefinitions[typeName] = [...msgTypeDefinitions[typeName], { name, type: nestedType }];
+                    //Special logic if nested struct is google protobuf's Any type
+                    if (isGoogleProtobufAnyPackage(packageName, type)) {
+                        const nestedAnyTypeName = isArray ? nestedType.split('[]')[0].split(`${msgTypeIndex}`)[0] : nestedType.split(`${msgTypeIndex}`)[0];
+                        const nestedMsgTypeIndex = getLatestMsgTypeIndex(`${nestedAnyTypeName}Value`, types);
+                        const nestedAnyValueType = `${nestedAnyTypeName}Value${nestedMsgTypeIndex}`;
+                        msgTypeDefinitions[`${nestedAnyTypeName}${msgTypeIndex}`] = [{ name: "type", type: "string" }, { name: "value", type: nestedAnyValueType }];
+                        const anyObjectTypeNameSplit = nestedAnyTypeName.split('Type')[1].split(`${msgTypeIndex}`)[0];
+                        const messageTypeUrl = AminoTypesMap_1.default.fromAmino(fieldValue).typeUrl;
+                        getMsgValueType(messageTypeUrl, fieldValue.value, "value", nestedMsgTypeIndex, types, anyObjectTypeNameSplit, true, msgTypeDefinitions);
+                    }
+                    else {
+                        const typeStructName = type.includes('[]') ? type.split('[]')[0].split(`${nestedMsgTypeIndex}`)[0] : type.split(`${nestedMsgTypeIndex}`)[0];
+                        const messageTypeUrl = `${packageName}.${typeStructName}`;
+                        getMsgValueType(messageTypeUrl, fieldValue, name, nestedMsgTypeIndex, types, objectName, true, msgTypeDefinitions);
+                    }
+                }
+                else {
+                    msgTypeDefinitions[typeName] = [...msgTypeDefinitions[typeName], { name, type: getGjsonPrimitiveType(fieldValue) }];
+                }
+            }
+        });
+    }
     return msgTypeDefinitions;
 }
-function isMessage(msgTypeUrl) {
-    return codec_1.registry.lookupType(msgTypeUrl) !== undefined;
+function getGjsonPrimitiveType(value) {
+    if (typeof value === 'number') {
+        return 'number';
+    }
+    if (typeof value === 'boolean') {
+        return 'boolean';
+    }
+    return 'string';
+}
+function getTypeName(name, index, objectName, nestedType = false, isArray = false) {
+    if (nestedType) {
+        return `Type${objectName ? objectName : ''}${name.split('_').map(subName => lodash_1.capitalize(subName)).join('')}${index}${isArray ? '[]' : ''}`;
+    }
+    return name;
+}
+function isGoogleProtobufAnyPackage(packageName, type) {
+    return packageName === '/google.protobuf' && type == 'Any';
+}
+function isNonZeroField(fieldValue) {
+    // zero fields are considered falsey
+    if (fieldValue == "0") {
+        return false;
+    }
+    // empty arrays are considered truthy
+    if (Array.isArray(fieldValue)) {
+        return fieldValue.length !== 0;
+    }
+    // empty objects are considered truthy
+    if (fieldValue && typeof fieldValue === 'object' && Object.keys(fieldValue).length === 0) {
+        return false;
+    }
+    return fieldValue;
 }
 function constructEIP712Tx(doc) {
-    // EIP-712 can only accept batch msgs of the same type
-    const msg = doc.msgs[0];
-    return {
-        types: getTypes(AminoTypesMap_1.default.fromAmino(msg).typeUrl, msg.value),
+    const { account_number, chain_id, fee, memo, sequence } = doc;
+    const eip712Tx = {
+        types: getTypes(doc.msgs),
         primaryType: "Tx",
         domain: Object.assign(Object.assign({}, eip712_1.DEFAULT_CARBON_DOMAIN_FIELDS), { chainId: ethermint_1.parseChainId(doc.chain_id) }),
-        message: doc
+        message: Object.assign({ account_number, chain_id, fee, memo, sequence }, convertMsgs(doc.msgs))
     };
+    return eip712Tx;
 }
 exports.constructEIP712Tx = constructEIP712Tx;
+function convertMsgs(msgs) {
+    const convertedMsgs = {};
+    msgs.forEach((msg, index) => {
+        convertedMsgs[`msg${index}`] = msg;
+    });
+    return convertedMsgs;
+}

package/lib/util/ethermint.d.ts

@@ -1,4 +1,8 @@
+import CarbonSDK from "../CarbonSDK";
 import { Any } from "../codec";
+import { ethers } from "ethers";
 export declare const ETH_SECP256K1_TYPE = "/ethermint.crypto.v1.ethsecp256k1.PubKey";
+export declare const PUBLIC_KEY_SIGNING_TEXT = "Sign your public key to merge your Carbon account: ";
 export declare function encodeAnyEthSecp256k1PubKey(pubkey: Uint8Array): Any;
 export declare function parseChainId(evmChainId: string): string;
+export declare function populateEvmTransactionDetails(api: CarbonSDK, req: ethers.providers.TransactionRequest): Promise<ethers.providers.TransactionRequest>;

package/lib/util/ethermint.js

@@ -1,15 +1,26 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseChainId = exports.encodeAnyEthSecp256k1PubKey = exports.ETH_SECP256K1_TYPE = void 0;
+exports.populateEvmTransactionDetails = exports.parseChainId = exports.encodeAnyEthSecp256k1PubKey = exports.PUBLIC_KEY_SIGNING_TEXT = exports.ETH_SECP256K1_TYPE = void 0;
 const codec_1 = require("../codec");
 const keys_1 = require("../codec/ethermint/crypto/v1/ethsecp256k1/keys");
 exports.ETH_SECP256K1_TYPE = '/ethermint.crypto.v1.ethsecp256k1.PubKey';
+exports.PUBLIC_KEY_SIGNING_TEXT = 'Sign your public key to merge your Carbon account: ';
 function encodeAnyEthSecp256k1PubKey(pubkey) {
-    return codec_1.registry.encodeAsAny({
+    const ethPubKey = keys_1.PubKey.fromPartial({
+        key: pubkey,
+    });
+    return codec_1.Any.fromPartial({
         typeUrl: exports.ETH_SECP256K1_TYPE,
-        value: keys_1.PubKey.fromPartial({
-            key: pubkey,
-        }),
+        value: keys_1.PubKey.encode(ethPubKey).finish(),
     });
 }
 exports.encodeAnyEthSecp256k1PubKey = encodeAnyEthSecp256k1PubKey;
@@ -18,9 +29,40 @@ function parseChainId(evmChainId) {
     if (chainId.length > 48) {
         throw new Error(`chain-id '${chainId}' cannot exceed 48 chars`);
     }
-    if (!chainId.match(/^[0-9a-f]+$/i)) {
+    if (!chainId.match(/^[a-z]+_\d+-\d+$/)) {
         throw new Error(`chain-id '${chainId}' does not conform to the required format`);
     }
     return chainId.split("_")[1].split("-")[0];
 }
 exports.parseChainId = parseChainId;
+function populateEvmTransactionDetails(api, req) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+    return __awaiter(this, void 0, void 0, function* () {
+        const provider = api.evmJsonRpc;
+        const evmHexAddress = (_b = (_a = api.wallet) === null || _a === void 0 ? void 0 : _a.evmHexAddress) !== null && _b !== void 0 ? _b : '';
+        let request = {
+            to: (_c = req.to) !== null && _c !== void 0 ? _c : '',
+            from: (_d = req.from) !== null && _d !== void 0 ? _d : (_e = api.wallet) === null || _e === void 0 ? void 0 : _e.evmHexAddress,
+            nonce: (_f = req.nonce) !== null && _f !== void 0 ? _f : (yield provider.getTransactionCount(evmHexAddress)),
+            data: req.data,
+            value: `0x${Number(req.value).toString(16)}`,
+            chainId: (_g = req.chainId) !== null && _g !== void 0 ? _g : Number(parseChainId(yield ((_h = api.wallet) === null || _h === void 0 ? void 0 : _h.getEvmChainId()))),
+            // type = 0, 1 or 2 where 0 = legacyTx, 1 = AccessListTx, 2 = DynamicTx. Defaults to DynamicTx 
+            type: (_j = req.type) !== null && _j !== void 0 ? _j : 2,
+            accessList: req.accessList,
+        };
+        const gasLimit = (yield provider.estimateGas(request)).toHexString();
+        const gasFee = yield provider.getFeeData();
+        if (!req.gasPrice) {
+            // Dynamic Tx
+            return Object.assign(Object.assign({}, request), { maxPriorityFeePerGas: (_k = req.maxPriorityFeePerGas) !== null && _k !== void 0 ? _k : (_l = gasFee.maxPriorityFeePerGas) === null || _l === void 0 ? void 0 : _l.toHexString(), maxFeePerGas: (_m = req.maxFeePerGas) !== null && _m !== void 0 ? _m : (_o = gasFee.maxFeePerGas) === null || _o === void 0 ? void 0 : _o.toHexString(), gasLimit, type: 2 });
+        }
+        if (req.accessList) {
+            // AccessList Tx 
+            return Object.assign(Object.assign({}, request), { gasLimit, type: 1 });
+        }
+        // LegacyTx
+        return Object.assign(Object.assign({}, request), { gasLimit, type: 0 });
+    });
+}
+exports.populateEvmTransactionDetails = populateEvmTransactionDetails;

package/lib/util/legacyEIP712.d.ts

@@ -0,0 +1,20 @@
+import { StdSignDoc } from "@cosmjs/amino/build";
+import { TypedDataDomain, TypedDataField } from "@ethersproject/abstract-signer";
+import { TypeUtils } from ".";
+import { Coin } from "@cosmjs/proto-signing";
+export interface LegacyEIP712Tx {
+    readonly types: TypeUtils.SimpleMap<TypedDataField[]>;
+    readonly primaryType: string;
+    readonly domain: TypedDataDomain;
+    readonly message: LegacyEIP712StdSignDoc;
+}
+export declare type EIP712Fee = {
+    readonly amount: readonly Coin[];
+    readonly gas: string;
+    readonly feePayer: string;
+};
+declare type LegacyEIP712StdSignDoc = StdSignDoc & {
+    fee: EIP712Fee;
+};
+export declare function legacyConstructEIP712Tx(doc: LegacyEIP712StdSignDoc): LegacyEIP712Tx;
+export {};

package/lib/util/legacyEIP712.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyConstructEIP712Tx = void 0;
+const eip712_1 = require("../constant/eip712");
+const ethermint_1 = require("../util/ethermint");
+const codec_1 = require("../codec");
+const AminoTypesMap_1 = __importDefault(require("../provider/amino/AminoTypesMap"));
+const lodash_1 = require("lodash");
+function getTypes(msgTypeUrl, aminoMsgValue) {
+    return Object.assign(Object.assign({}, eip712_1.LEGACY_DEFAULT_EIP712_TYPES), getMsgValueType(msgTypeUrl, aminoMsgValue, "MsgValue"));
+}
+function getMsgValueType(msgTypeUrl, msgValue, msgTypeName, objectName, nestedType = false, msgTypeDefinitions = {}) {
+    const packageName = msgTypeUrl.split(".").slice(0, -1).join(".");
+    const msgFieldType = msgTypeUrl.split(".").pop();
+    const typeName = getTypeName(msgTypeName, objectName, nestedType, false);
+    const fieldsDefinition = codec_1.EIP712Types[packageName][msgFieldType];
+    if (isNonZeroField(msgValue)) {
+        if (!msgTypeDefinitions[typeName]) {
+            msgTypeDefinitions[typeName] = [];
+        }
+        fieldsDefinition.forEach(({ packageName, name, type }) => {
+            let fieldValue;
+            if (Array.isArray(msgValue)) {
+                //Assumption: Take first value in array to determine which fields are populated
+                fieldValue = msgValue.length > 0 ? msgValue[0][name] : [];
+            }
+            else {
+                fieldValue = msgValue[name];
+            }
+            if (isNonZeroField(fieldValue)) {
+                //For nested structs
+                if (packageName) {
+                    const isArray = type.includes('[]') ? true : false;
+                    const objectName = typeName === 'MsgValue' ? 'MsgValue' : typeName.split('Type')[1];
+                    const nestedType = getTypeName(name, objectName, true, isArray);
+                    msgTypeDefinitions[typeName] = [...msgTypeDefinitions[typeName], { name, type: nestedType }];
+                    //Special logic if nested struct is google protobuf's Any type
+                    if (isGoogleProtobufAnyPackage(packageName, type)) {
+                        const nestedAnyTypeName = isArray ? nestedType.split('[]')[0] : nestedType;
+                        const nestedAnyValueType = `${nestedAnyTypeName}Value`;
+                        msgTypeDefinitions[nestedAnyTypeName] = [{ name: "type", type: "string" }, { name: "value", type: nestedAnyValueType }];
+                        const anyObjectTypeNameSplit = nestedAnyTypeName.split('Type')[1];
+                        const messageTypeUrl = AminoTypesMap_1.default.fromAmino(fieldValue).typeUrl;
+                        getMsgValueType(messageTypeUrl, fieldValue.value, "value", anyObjectTypeNameSplit, true, msgTypeDefinitions);
+                    }
+                    else {
+                        const typeStructName = type.includes('[]') ? type.split('[]')[0] : type;
+                        const messageTypeUrl = `${packageName}.${typeStructName}`;
+                        getMsgValueType(messageTypeUrl, fieldValue, name, objectName, true, msgTypeDefinitions);
+                    }
+                }
+                else {
+                    msgTypeDefinitions[typeName] = [...msgTypeDefinitions[typeName], { name, type }];
+                }
+            }
+        });
+    }
+    return msgTypeDefinitions;
+}
+function getTypeName(name, objectName, nestedType = false, isArray = false) {
+    if (nestedType) {
+        return `Type${objectName === 'MsgValue' ? '' : objectName}${name.split('_').map(subName => lodash_1.capitalize(subName)).join('')}${isArray ? '[]' : ''}`;
+    }
+    return name;
+}
+function isGoogleProtobufAnyPackage(packageName, type) {
+    return packageName === '/google.protobuf' && type == 'Any';
+}
+function isNonZeroField(fieldValue) {
+    // zero fields are considered falsey
+    if (fieldValue == "0") {
+        return false;
+    }
+    // empty arrays are considered truthy
+    if (Array.isArray(fieldValue)) {
+        return fieldValue.length !== 0;
+    }
+    // empty objects are considered truthy
+    if (fieldValue && typeof fieldValue === 'object' && Object.keys(fieldValue).length === 0) {
+        return false;
+    }
+    return fieldValue;
+}
+function legacyConstructEIP712Tx(doc) {
+    // Legacy EIP-712 can only accept batch msgs of the same type
+    const msg = doc.msgs[0];
+    const eip712Tx = {
+        types: getTypes(AminoTypesMap_1.default.fromAmino(msg).typeUrl, msg.value),
+        primaryType: "Tx",
+        domain: Object.assign(Object.assign({}, eip712_1.DEFAULT_CARBON_DOMAIN_FIELDS), { chainId: ethermint_1.parseChainId(doc.chain_id) }),
+        message: doc
+    };
+    return eip712Tx;
+}
+exports.legacyConstructEIP712Tx = legacyConstructEIP712Tx;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "carbon-js-sdk",
-  "version": "0.4.16",
+  "version": "0.4.17",
   "description": "TypeScript SDK for Carbon blockchain",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",