example-js-sdk 0.0.1

package/lib/util/legacyEIP712.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyConstructEIP712Tx = legacyConstructEIP712Tx;
+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 {
+        ...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 => (0, 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: { ...eip712_1.DEFAULT_CARBON_DOMAIN_FIELDS, chainId: (0, ethermint_1.parseChainId)(doc.chain_id) },
+        message: doc,
+    };
+    return eip712Tx;
+}

package/lib/util/message.d.ts

@@ -0,0 +1,2 @@
+import { StdSignDoc } from "@cosmjs/amino";
+export declare const constructAdr36SignDoc: (address: string, message: string) => StdSignDoc;

package/lib/util/message.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constructAdr36SignDoc = void 0;
+const constructAdr36SignDoc = (address, message) => {
+    const msgSignData = constructMsgSignData(address, message);
+    const msgs = [{ type: 'sign/MsgSignData', value: msgSignData }];
+    const fee = {
+        gas: '0',
+        amount: [],
+    };
+    const signDoc = {
+        chain_id: '',
+        account_number: '0',
+        sequence: '0',
+        fee,
+        msgs,
+        memo: '',
+    };
+    return signDoc;
+};
+exports.constructAdr36SignDoc = constructAdr36SignDoc;
+const constructMsgSignData = (address, message) => {
+    return { signer: address, data: Buffer.from(message).toString('base64') };
+};

package/lib/util/network.d.ts

@@ -0,0 +1,9 @@
+import { Network } from "../constant";
+/**
+ *
+ * @param network
+ * @param defaultNetwork
+ * @returns
+ */
+export declare const parseNetwork: (network: string, defaultNetwork?: Network | null) => Network | null;
+export declare const carbonNetworkFromChainId: (parsedEvmChainId: string) => Network;

package/lib/util/network.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.carbonNetworkFromChainId = exports.parseNetwork = void 0;
+const constant_1 = require("../constant");
+const index_1 = require("../index");
+const ethermint_1 = require("./ethermint");
+/**
+ *
+ * @param network
+ * @param defaultNetwork
+ * @returns
+ */
+const parseNetwork = (network, defaultNetwork = constant_1.DEFAULT_NETWORK) => {
+    switch (network?.toLowerCase?.()) {
+        case "main":
+        case "mainnet":
+            return constant_1.Network.MainNet;
+        case "test":
+        case "testnet":
+            return constant_1.Network.TestNet;
+        case "dev":
+        case "devnet":
+            return constant_1.Network.DevNet;
+        case "local":
+        case "localhost":
+            return constant_1.Network.LocalHost;
+    }
+    return defaultNetwork;
+};
+exports.parseNetwork = parseNetwork;
+const carbonNetworkFromChainId = (parsedEvmChainId) => {
+    switch (parsedEvmChainId) {
+        case (0, ethermint_1.parseChainId)(constant_1.CarbonEvmChainIDs[index_1.CarbonSDK.Network.LocalHost]): return index_1.CarbonSDK.Network.LocalHost;
+        case (0, ethermint_1.parseChainId)(constant_1.CarbonEvmChainIDs[index_1.CarbonSDK.Network.DevNet]): return index_1.CarbonSDK.Network.DevNet;
+        case (0, ethermint_1.parseChainId)(constant_1.CarbonEvmChainIDs[index_1.CarbonSDK.Network.TestNet]): return index_1.CarbonSDK.Network.TestNet;
+        default: return index_1.CarbonSDK.Network.MainNet;
+    }
+};
+exports.carbonNetworkFromChainId = carbonNetworkFromChainId;

package/lib/util/number.d.ts

@@ -0,0 +1,9 @@
+import BigNumber from "bignumber.js";
+export declare const BN_ONE: BigNumber;
+export declare const BN_ZERO: BigNumber;
+export declare const BN_10000: BigNumber;
+export declare const parseBN: (input?: string | BigNumber | number | null, defaultValue?: BigNumber) => BigNumber | undefined;
+export declare const bnOrZero: (input?: string | BigNumber | number | null, defaultValue?: BigNumber) => BigNumber;
+export declare const toHuman: (value?: null | BigNumber | string | number, decimals?: null | BigNumber | string | number) => BigNumber | undefined;
+export declare const toUnitless: (value?: null | BigNumber | string | number, decimals?: null | BigNumber | string | number) => BigNumber | undefined;
+export declare const generateNonce: () => number;

package/lib/util/number.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateNonce = exports.toUnitless = exports.toHuman = exports.bnOrZero = exports.parseBN = exports.BN_10000 = exports.BN_ZERO = exports.BN_ONE = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+exports.BN_ONE = new bignumber_js_1.default(1);
+exports.BN_ZERO = new bignumber_js_1.default(0);
+exports.BN_10000 = new bignumber_js_1.default(10000);
+const parseBN = (input, defaultValue) => {
+    if (!input && input !== 0)
+        return defaultValue;
+    const result = bignumber_js_1.default.isBigNumber(input) ? input : new bignumber_js_1.default(input);
+    if (!result.isFinite() || result.isNaN())
+        return defaultValue;
+    return result;
+};
+exports.parseBN = parseBN;
+const bnOrZero = (input, defaultValue = exports.BN_ZERO) => {
+    return (0, exports.parseBN)(input, defaultValue);
+};
+exports.bnOrZero = bnOrZero;
+const toHuman = (value, decimals) => {
+    if (value === undefined || value === null)
+        return undefined;
+    const valueBN = (0, exports.bnOrZero)(value);
+    if (!decimals)
+        return valueBN; // decimals = 0 or nullish
+    const decimalsBN = (0, exports.bnOrZero)(decimals);
+    return valueBN.shiftedBy(decimalsBN.negated().toNumber());
+};
+exports.toHuman = toHuman;
+const toUnitless = (value, decimals) => {
+    if (value === undefined || value === null)
+        return undefined;
+    const valueBN = (0, exports.bnOrZero)(value);
+    if (!decimals)
+        return valueBN; // decimals = 0 or nullish
+    const decimalsBN = (0, exports.bnOrZero)(decimals);
+    return valueBN.shiftedBy(decimalsBN.toNumber());
+};
+exports.toUnitless = toUnitless;
+const generateNonce = () => {
+    return Math.floor(Math.random() * 1000000);
+};
+exports.generateNonce = generateNonce;

package/lib/util/order.d.ts

@@ -0,0 +1,3 @@
+import { OrderModule } from "../modules/order";
+export declare const getDefaultTimeInForce: (isMarketOrder: boolean) => OrderModule.TimeInForce.Gtc | OrderModule.TimeInForce.Ioc;
+export declare function isMarket(type: OrderModule.OrderType | string): boolean;

package/lib/util/order.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultTimeInForce = void 0;
+exports.isMarket = isMarket;
+const order_1 = require("../modules/order");
+const getDefaultTimeInForce = (isMarketOrder) => {
+    return isMarketOrder ? order_1.OrderModule.TimeInForce.Ioc : order_1.OrderModule.TimeInForce.Gtc;
+};
+exports.getDefaultTimeInForce = getDefaultTimeInForce;
+function isMarket(type) {
+    const newType = type;
+    return newType === order_1.OrderModule.OrderType.Market || newType === order_1.OrderModule.OrderType.StopMarket || newType === order_1.OrderModule.OrderType.TakeProfitMarket;
+}

package/lib/util/provider.d.ts

@@ -0,0 +1 @@
+export declare function signTransactionWrapper(signTxTask: () => Promise<any>): Promise<any>;

package/lib/util/provider.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signTransactionWrapper = signTransactionWrapper;
+const tx_1 = require("./tx");
+async function signTransactionWrapper(signTxTask) {
+    try {
+        return await signTxTask();
+    }
+    catch (err) {
+        throw new tx_1.CarbonCustomError(err.message, tx_1.ErrorType.SIGNATURE_REJECTION);
+    }
+}

package/lib/util/token.d.ts

@@ -0,0 +1,16 @@
+import { SimpleMap } from "./type";
+export declare const FuturesDenomOverride: SimpleMap<string>;
+export declare enum MainNetDefaultTokens {
+    WBTC = "wbtc.1.2.786598",
+    ETH = "eth.1.2.942d87",
+    USDC = "usdc.1.2.343151",
+    BUSDC = "busd.1.6.754a80",
+    ATOM = "ibc/A4DB47A9D3CF9A068D454513891B526702455D3EF08FB9EB558C561F9DC2B701",
+    STATOM = "ibc/B7864B03E1B9FD4F049243E92ABD691586F682137037A9F3FCA5222815620B3C",
+    USC = "usc",
+    OSMO = "ibc/ED07A3391A112B175915CD8FAF43A2DA8E4790EDE12566649D0C2F97716B8518",
+    STOSMO = "ibc/75249A18DEFBEFE55F83B1C70CAD234DF164F174C6BC51682EE92C2C81C18C93",
+    SWTH = "swth",
+    ZIL = "zil.1.18.1a4a06",
+    BNB = "bnb.1.6.773edb"
+}

package/lib/util/token.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MainNetDefaultTokens = exports.FuturesDenomOverride = void 0;
+exports.FuturesDenomOverride = {
+    WBTC: "BTC",
+    USDC: "USD",
+    iusd: "USD",
+};
+var MainNetDefaultTokens;
+(function (MainNetDefaultTokens) {
+    MainNetDefaultTokens["WBTC"] = "wbtc.1.2.786598";
+    MainNetDefaultTokens["ETH"] = "eth.1.2.942d87";
+    MainNetDefaultTokens["USDC"] = "usdc.1.2.343151";
+    MainNetDefaultTokens["BUSDC"] = "busd.1.6.754a80";
+    MainNetDefaultTokens["ATOM"] = "ibc/A4DB47A9D3CF9A068D454513891B526702455D3EF08FB9EB558C561F9DC2B701";
+    MainNetDefaultTokens["STATOM"] = "ibc/B7864B03E1B9FD4F049243E92ABD691586F682137037A9F3FCA5222815620B3C";
+    MainNetDefaultTokens["USC"] = "usc";
+    MainNetDefaultTokens["OSMO"] = "ibc/ED07A3391A112B175915CD8FAF43A2DA8E4790EDE12566649D0C2F97716B8518";
+    MainNetDefaultTokens["STOSMO"] = "ibc/75249A18DEFBEFE55F83B1C70CAD234DF164F174C6BC51682EE92C2C81C18C93";
+    MainNetDefaultTokens["SWTH"] = "swth";
+    MainNetDefaultTokens["ZIL"] = "zil.1.18.1a4a06";
+    MainNetDefaultTokens["BNB"] = "bnb.1.6.773edb";
+})(MainNetDefaultTokens || (exports.MainNetDefaultTokens = MainNetDefaultTokens = {}));

package/lib/util/transferfees.d.ts

@@ -0,0 +1,18 @@
+export interface FeeAmount {
+    fee: string;
+}
+export interface FeeInfoDetails {
+    [index: string]: FeeAmount;
+}
+export interface FeeResult {
+    prev_update_time: number;
+    details: FeeInfoDetails;
+}
+export declare enum FeeResultType {
+    CreateWallet = "createWallet",
+    Deposit = "deposit",
+    Withdrawal = "withdrawal"
+}
+export interface FeeInfo extends FeeResult {
+    denom: string;
+}

package/lib/util/transferfees.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeeResultType = void 0;
+var FeeResultType;
+(function (FeeResultType) {
+    FeeResultType["CreateWallet"] = "createWallet";
+    FeeResultType["Deposit"] = "deposit";
+    FeeResultType["Withdrawal"] = "withdrawal";
+})(FeeResultType || (exports.FeeResultType = FeeResultType = {}));