carbon-js-sdk 0.4.19 → 0.4.21

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/provider/metamask/legacy-accounts.d.ts

@@ -0,0 +1,6 @@
+export declare const LEGACY_ACCOUNTS_TESTNET: {
+    Ethereum: string[];
+};
+export declare const LEGACY_ACCOUNTS_MAINNET: {
+    Ethereum: string[];
+};

package/lib/provider/metamask/legacy-accounts.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEGACY_ACCOUNTS_MAINNET = exports.LEGACY_ACCOUNTS_TESTNET = void 0;
+// As of 16 May 2023
+exports.LEGACY_ACCOUNTS_TESTNET = {
+    "Ethereum": [
+        "0x32c1069dcf38a7294ee9633fcb897c18cabd1668",
+        "0x6a8247bc77084acf32901f6a29369bc702d25769",
+        "0xe3f544b81a8e60087b25b1e6f0e71d579686c798",
+        "0xc6a53d96f92be41b9a7ccd9daa5d52cb7a8fdb92",
+        "0x8440a2e6e763ee99b29dcf663a72896817d6a6fd",
+        "0x04d40c9e02e0f793c25d2e4c993b853f6a1c7b6c",
+        "0x1e9eb8d2320a52dcd91a4016b1471947844ed903",
+        "0x7d831dd3a6f1553b9b995f499f4d31d4935b34f8",
+        "0xb88cb290efff1017a27db762fba8f15e754fdd67",
+        "0xc120adde16e45c1a36e65fb9bdb5bd8b1f620c19",
+        "0x0897fbc3eb27992cadbffa506e1403d180c94735",
+        "0x49367893FF5e5481312159D1EC7dfFd1bCD082B7",
+        "0x6fC1b1665BF2EC94d3d936EAb45ACa6b58eE2797",
+        "0x3619d35d2ca763d63387138Fff3a13A5fFE7c8Ce",
+        "0xEEe3c236312a81f3CC3CB78763968e24355b513F",
+        "0x184268C2eA4332234d6Ee5b0bA1C212E63fa55Cc",
+        "0x05a2F90551Dcba19C42c6E85FB00843C0859a427",
+        "0xad045ec15DbBe6FebE8e7D1EC85Eb7D496c4ebe1",
+        "0xcFa83a56f1479BB9CD5a25f36a0C3E44EE08D7DB",
+        "0x8e2C2E908195F87Bc6C14fAEC31F7726d094b3c6"
+    ]
+};
+// To be updated
+exports.LEGACY_ACCOUNTS_MAINNET = {
+    "Ethereum": [
+        "0x32c1069dcf38a7294ee9633fcb897c18cabd1668",
+        "0x6a8247bc77084acf32901f6a29369bc702d25769",
+        "0xe3f544b81a8e60087b25b1e6f0e71d579686c798",
+        "0xc6a53d96f92be41b9a7ccd9daa5d52cb7a8fdb92",
+        "0x8440a2e6e763ee99b29dcf663a72896817d6a6fd",
+        "0x04d40c9e02e0f793c25d2e4c993b853f6a1c7b6c",
+        "0x1e9eb8d2320a52dcd91a4016b1471947844ed903",
+        "0x7d831dd3a6f1553b9b995f499f4d31d4935b34f8",
+        "0xb88cb290efff1017a27db762fba8f15e754fdd67",
+        "0xc120adde16e45c1a36e65fb9bdb5bd8b1f620c19",
+        "0x0897fbc3eb27992cadbffa506e1403d180c94735"
+    ]
+};

package/lib/util/eip712.d.ts

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

package/lib/util/eip712.js

@@ -0,0 +1,195 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constructEIP712Tx = 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(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 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];
+    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 getGjsonPrimitiveType(value) {
+    if (typeof value === 'number') {
+        return 'int64';
+    }
+    if (typeof value === 'boolean') {
+        return 'bool';
+    }
+    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,except if it is string "0"
+    if (fieldValue == "0" && typeof fieldValue !== "string") {
+        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) {
+    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: 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

@@ -0,0 +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

@@ -0,0 +1,68 @@
+"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.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) {
+    const ethPubKey = keys_1.PubKey.fromPartial({
+        key: pubkey,
+    });
+    return codec_1.Any.fromPartial({
+        typeUrl: exports.ETH_SECP256K1_TYPE,
+        value: keys_1.PubKey.encode(ethPubKey).finish(),
+    });
+}
+exports.encodeAnyEthSecp256k1PubKey = encodeAnyEthSecp256k1PubKey;
+function parseChainId(evmChainId) {
+    const chainId = evmChainId.trim();
+    if (chainId.length > 48) {
+        throw new Error(`chain-id '${chainId}' cannot exceed 48 chars`);
+    }
+    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.19",
+  "version": "0.4.21",
   "description": "TypeScript SDK for Carbon blockchain",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/lib/clients/EvmIbcClient.d.ts

@@ -1,86 +0,0 @@
-import { Network } from "../constant";
-import { StdSignDoc } from "@cosmjs/amino";
-import { BlockchainUtils } from "../util";
-declare type SupportedBlockchains = BlockchainUtils.Blockchain.Canto | BlockchainUtils.Blockchain.Evmos;
-declare namespace EvmIbcClient {
-    interface TypedDomain {
-        name: string;
-        version: string;
-        chainId: number;
-        verifyingContract: string;
-        salt: string;
-    }
-    interface TypedDataV4 {
-        types: object;
-        primaryType: string;
-        message: StdSignDoc;
-        domain: TypedDomain;
-    }
-    const TYPED_DATA_REQUEST_METHOD = "eth_signTypedData_v4";
-    const DEFAULT_EIP712_TYPES: {
-        EIP712Domain: {
-            name: string;
-            type: string;
-        }[];
-        Tx: {
-            name: string;
-            type: string;
-        }[];
-        Fee: {
-            name: string;
-            type: string;
-        }[];
-        Coin: {
-            name: string;
-            type: string;
-        }[];
-        Msg: {
-            name: string;
-            type: string;
-        }[];
-    };
-    const getEvmChainId: (blockchain: SupportedBlockchains, network?: Network) => 7700 | 9001;
-    const getIbcTransferTypes: () => {
-        MsgValue: {
-            name: string;
-            type: string;
-        }[];
-        TypeToken: {
-            name: string;
-            type: string;
-        }[];
-        TypeTimeoutHeight: {
-            name: string;
-            type: string;
-        }[];
-        EIP712Domain: {
-            name: string;
-            type: string;
-        }[];
-        Tx: {
-            name: string;
-            type: string;
-        }[];
-        Fee: {
-            name: string;
-            type: string;
-        }[];
-        Coin: {
-            name: string;
-            type: string;
-        }[];
-        Msg: {
-            name: string;
-            type: string;
-        }[];
-    };
-    const getCosmosWeb3Domain: (blockchain: SupportedBlockchains) => {
-        name: string;
-        version: string;
-        chainId: number;
-        verifyingContract: string;
-        salt: string;
-    };
-    const getEIP712TypedData: (tx: StdSignDoc, blockchain: SupportedBlockchains, types?: object, domain?: EvmIbcClient.TypedDomain, primaryType?: string) => TypedDataV4;
-}
-export default EvmIbcClient;