example-js-sdk 0.0.1

package/lib/util/eip712.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constructEIP712Tx = constructEIP712Tx;
+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 = { ...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 = { ...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 = { ...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]) { // eslint-disable-line
+        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 }) => {
+            const fieldValue = Array.isArray(msgValue) && msgValue.length > 0 ? msgValue[0][name] : msgValue[name];
+            //Assumption: Take first value in array to determine which fields are populated
+            if (isNonZeroField(fieldValue)) {
+                if (Array.isArray(fieldValue) && fieldValue.length === 0) {
+                    msgTypeDefinitions[typeName] = [...msgTypeDefinitions[typeName], { name, type: 'string[]' }];
+                    return;
+                }
+                //For nested structs
+                if (packageName) {
+                    const isArray = type.includes('[]') ? true : false;
+                    // TypeValue0 --> Value
+                    const objectName = typeName.split('Type')[1].split(/\d+/)[0];
+                    const nestedTypeName = `Type${objectName ? objectName : ''}${name.split('_').map((subName) => (0, 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(/\d+/)[0] : nestedType.split(/\d+/)[0];
+                        const nestedMsgTypeIndex = getLatestMsgTypeIndex(`${nestedAnyTypeName}Value`, types);
+                        const nestedAnyValueType = `${nestedAnyTypeName}Value${nestedMsgTypeIndex}`;
+                        msgTypeDefinitions[`${nestedAnyTypeName}${nestedMsgTypeIndex}`] = [{ name: "type", type: "string" }, { name: "value", type: nestedAnyValueType }];
+                        const anyObjectTypeNameSplit = nestedAnyTypeName.split('Type')[1].split(/\d+/)[0];
+                        const field = isArray ? fieldValue[0] : fieldValue;
+                        const messageTypeUrl = AminoTypesMap_1.default.fromAmino(field).typeUrl;
+                        getMsgValueType(messageTypeUrl, field.value, "value", nestedMsgTypeIndex, types, anyObjectTypeNameSplit, true, msgTypeDefinitions);
+                    }
+                    else {
+                        const typeStructName = type.includes('[]') ? type.split('[]')[0].split(/\d+/)[0] : type.split(/\d+/)[0];
+                        const messageTypeUrl = `${packageName}.${typeStructName}`;
+                        getMsgValueType(messageTypeUrl, fieldValue, name, nestedMsgTypeIndex, types, objectName, true, msgTypeDefinitions);
+                    }
+                }
+                else {
+                    const primitiveType = getGjsonPrimitiveType(fieldValue);
+                    msgTypeDefinitions[typeName] = [...msgTypeDefinitions[typeName], { name, type: primitiveType }];
+                }
+            }
+        });
+    }
+    return msgTypeDefinitions;
+}
+function getGjsonPrimitiveType(value) {
+    if (typeof value === 'number') {
+        return 'int64';
+    }
+    if (typeof value === 'boolean') {
+        return 'bool';
+    }
+    if (Array.isArray(value) && value.length && value.every(item => typeof item === 'string')) {
+        return 'string[]';
+    }
+    return 'string';
+}
+function getTypeName(name, index, objectName, nestedType = false, isArray = false) {
+    if (nestedType) {
+        return `Type${objectName ? objectName : ''}${name.split('_').map(subName => (0, lodash_1.capitalize)(subName)).join('')}${index}${isArray ? '[]' : ''}`;
+    }
+    return name;
+}
+function isGoogleProtobufAnyPackage(packageName, type) {
+    return packageName === '/google.protobuf' && (type === 'Any' || 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 true;
+    }
+    // empty objects are considered truthy
+    if (fieldValue && typeof fieldValue === 'object' && Object.keys(fieldValue).length === 0) {
+        return true;
+    }
+    return fieldValue;
+}
+function constructEIP712Tx(doc, chainId) {
+    const { account_number, chain_id, fee, memo, sequence } = doc;
+    const eip712Tx = {
+        types: getTypes(doc.msgs),
+        primaryType: "Tx",
+        domain: { ...eip712_1.DEFAULT_CARBON_DOMAIN_FIELDS, chainId: (0, ethermint_1.parseChainId)(chainId || chain_id) },
+        message: { account_number, chain_id, fee, memo, sequence, ...convertMsgs(doc.msgs) },
+    };
+    return eip712Tx;
+}
+function convertMsgs(msgs) {
+    const convertedMsgs = {};
+    msgs.forEach((msg, index) => {
+        convertedMsgs[`msg${index}`] = msg;
+    });
+    return convertedMsgs;
+}

package/lib/util/ethermint.d.ts

@@ -0,0 +1,9 @@
+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>;
+export declare function populateUnsignedEvmTranscation(api: CarbonSDK, req: ethers.providers.TransactionRequest): Promise<ethers.utils.UnsignedTransaction>;

package/lib/util/ethermint.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PUBLIC_KEY_SIGNING_TEXT = exports.ETH_SECP256K1_TYPE = void 0;
+exports.encodeAnyEthSecp256k1PubKey = encodeAnyEthSecp256k1PubKey;
+exports.parseChainId = parseChainId;
+exports.populateEvmTransactionDetails = populateEvmTransactionDetails;
+exports.populateUnsignedEvmTranscation = populateUnsignedEvmTranscation;
+const codec_1 = require("../codec");
+const keys_1 = require("../codec/ethermint/crypto/v1/ethsecp256k1/keys");
+const constant_1 = require("../constant");
+const ethers_1 = require("ethers");
+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(),
+    });
+}
+function parseChainId(evmChainId) {
+    // eslint check if workaround is sound
+    if (!evmChainId) {
+        throw new Error("chain-id is undefined");
+    }
+    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];
+}
+async function populateEvmTransactionDetails(api, req) {
+    const provider = new ethers_1.ethers.providers.JsonRpcProvider(constant_1.NetworkConfigs[api.network].evmJsonRpcUrl);
+    const evmHexAddress = api.wallet?.evmHexAddress ?? '';
+    const request = {
+        to: req.to ?? '',
+        from: req.from ?? api.wallet?.evmHexAddress,
+        nonce: req.nonce ?? (await provider.getTransactionCount(evmHexAddress)),
+        data: req.data,
+        value: req.value ? `0x${Number(req.value).toString(16)}` : undefined,
+        chainId: req.chainId ?? Number(parseChainId(await api.wallet?.getEvmChainId() ?? '')),
+        // type = 0, 1 or 2 where 0 = legacyTx, 1 = AccessListTx, 2 = DynamicTx. Defaults to DynamicTx 
+        type: req.type ?? 2,
+        accessList: req.accessList,
+    };
+    const gasLimit = (await provider.estimateGas(request)).toHexString();
+    const gasFee = await provider.getFeeData();
+    if (!req.gasPrice) {
+        // Dynamic Tx
+        return {
+            ...request,
+            maxPriorityFeePerGas: req.maxPriorityFeePerGas ?? gasFee.maxPriorityFeePerGas?.toHexString(),
+            maxFeePerGas: req.maxFeePerGas ?? gasFee.maxFeePerGas?.toHexString(),
+            gasLimit,
+            type: 2,
+        };
+    }
+    if (req.accessList) {
+        // AccessList Tx 
+        return {
+            ...request,
+            gasLimit,
+            type: 1,
+        };
+    }
+    // LegacyTx
+    return {
+        ...request,
+        gasLimit,
+        type: 0,
+    };
+}
+async function populateUnsignedEvmTranscation(api, req) {
+    const provider = new ethers_1.ethers.providers.JsonRpcProvider(constant_1.NetworkConfigs[api.network].evmJsonRpcUrl);
+    const evmHexAddress = api.wallet?.evmHexAddress ?? '';
+    const nonce = req.nonce ?? (await provider.getTransactionCount(evmHexAddress));
+    const chainId = req.chainId ?? Number(parseChainId(await api.wallet?.getEvmChainId() ?? ''));
+    const value = req.value ? `0x${Number(req.value).toString(16)}` : undefined;
+    const baseTx = {
+        to: req.to ?? '',
+        from: req.from ?? api.wallet?.evmHexAddress,
+        nonce,
+        data: req.data,
+        value,
+        chainId,
+        // type = 0, 1 or 2 where 0 = legacyTx, 1 = AccessListTx, 2 = DynamicTx. Defaults to DynamicTx 
+        type: req.type ?? 2,
+        accessList: req.accessList,
+    };
+    const gasLimit = (await provider.estimateGas(baseTx)).toHexString();
+    const gasFee = await provider.getFeeData();
+    const unsignedTx = {
+        to: req.to ?? '',
+        nonce: parseInt(nonce.toString()),
+        data: req.data,
+        value,
+        chainId,
+        // type = 0, 1 or 2 where 0 = legacyTx, 1 = AccessListTx, 2 = DynamicTx. Defaults to DynamicTx 
+        type: req.type ?? 2,
+        accessList: req.accessList,
+    };
+    if (!req.gasPrice) {
+        // Dynamic Tx
+        return {
+            ...unsignedTx,
+            maxPriorityFeePerGas: req.maxPriorityFeePerGas ?? gasFee.maxPriorityFeePerGas?.toHexString(),
+            maxFeePerGas: req.maxFeePerGas ?? gasFee.maxFeePerGas?.toHexString(),
+            gasLimit,
+            type: 2,
+        };
+    }
+    if (req.accessList) {
+        // AccessList Tx 
+        return {
+            ...unsignedTx,
+            gasLimit,
+            type: 1,
+        };
+    }
+    // LegacyTx
+    return {
+        ...unsignedTx,
+        gasLimit,
+        type: 0,
+    };
+}

package/lib/util/evm.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_PUBLIC_KEY_MESSAGE = "Testing on Orbix chain";
+export declare const recoverPublicKey: (message: string, signature: string) => string;

package/lib/util/evm.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recoverPublicKey = exports.DEFAULT_PUBLIC_KEY_MESSAGE = void 0;
+const ethers_1 = require("ethers");
+exports.DEFAULT_PUBLIC_KEY_MESSAGE = `Testing on Orbix chain`;
+const recoverPublicKey = (message, signature) => {
+    const uncompressedPublicKey = ethers_1.ethers.utils.recoverPublicKey(ethers_1.ethers.utils.hashMessage(message), signature);
+    return ethers_1.ethers.utils.computePublicKey(uncompressedPublicKey, true).split('0x')[1];
+};
+exports.recoverPublicKey = recoverPublicKey;

package/lib/util/external.d.ts

@@ -0,0 +1,11 @@
+import { Carbon } from "../CarbonSDK";
+export interface TokensWithExternalBalance extends Carbon.Coin.Token {
+    externalBalance: string;
+}
+export interface TokenInitInfo {
+    address: string;
+    decimals: number;
+    symbol: string;
+    name: string;
+}
+export declare function iOS(): boolean;

package/lib/util/external.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iOS = iOS;
+// Detect device type
+function iOS() {
+    return /iPad|iPhone|iPod/.test(navigator.platform) || (navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1);
+}

package/lib/util/fetch.d.ts

@@ -0,0 +1 @@
+export declare function fetch(url: string, init?: RequestInit): Promise<Response>;

package/lib/util/fetch.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetch = fetch;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+function fetch(url, init) {
+    if (typeof window !== "undefined" && window.fetch) {
+        return window.fetch(url, { ...init });
+    }
+    else {
+        return (0, node_fetch_1.default)(url, init);
+    }
+}

package/lib/util/generic.d.ts

@@ -0,0 +1,40 @@
+import { Tendermint37Client } from "@cosmjs/tendermint-rpc";
+export declare const overrideConfig: <T = unknown>(defaults: T, override?: Partial<T>) => T;
+export declare const sortObject: (input: any) => unknown;
+export declare const stripHexPrefix: (input: string) => string;
+export declare const appendHexPrefix: (input: string) => string;
+export declare const computeTxHash: (bytes?: Uint8Array | Buffer) => string | undefined;
+export declare const toTxHash: (bytes?: Uint8Array | Buffer) => string | undefined;
+/**
+ * Make tendermint client send RPC requests with the same request
+ * ID instead of using a random id that is unread in the client.
+ *
+ * Motivation: enhanced cache-ability on API providers.
+ *
+ * Broadcast methods are untouched to ensure retries don't hit cache.
+ */
+export declare const modifyTmClient: (tmClient: Tendermint37Client) => Tendermint37Client;
+export declare const callIgnoreError: <T = any>(runnable: () => T) => T;
+export declare class QueueManager<T = void, V = void> {
+    private readonly processor;
+    triggerDelay: number;
+    maxDelayThreshold: number;
+    currTriggerThreshold: number;
+    currQueueTrigger: NodeJS.Timeout | null;
+    isProcessingQueue: boolean;
+    private queue;
+    constructor(processor: (input: T) => V, options?: QueueManager.Options);
+    enqueue(task: T, skipTrigger?: boolean): void;
+    trigger(): void;
+    private process;
+}
+export declare namespace QueueManager {
+    interface Options {
+        triggerDelay?: number;
+        maxDelayThreshold?: number;
+    }
+}
+export declare const getBestRpcTmClient: (rpcUrls: string[]) => Promise<{
+    client: Tendermint37Client;
+    rpcUrl: string;
+}>;

package/lib/util/generic.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBestRpcTmClient = exports.QueueManager = exports.callIgnoreError = exports.modifyTmClient = exports.toTxHash = exports.computeTxHash = exports.appendHexPrefix = exports.stripHexPrefix = exports.sortObject = exports.overrideConfig = void 0;
+const crypto_1 = require("@cosmjs/crypto");
+const tendermint_rpc_1 = require("@cosmjs/tendermint-rpc");
+const bytes_1 = require("../util/bytes");
+const overrideConfig = (defaults, override) => {
+    const result = { ...defaults };
+    if (!override)
+        return result;
+    for (const key of Object.keys(override)) {
+        const member = override[key];
+        if (typeof member === "undefined")
+            continue;
+        if (typeof member === "object") {
+            result[key] = (0, exports.overrideConfig)(result[key], member);
+        }
+        else {
+            result[key] = member;
+        }
+    }
+    return result;
+};
+exports.overrideConfig = overrideConfig;
+const sortObject = (input) => {
+    if (typeof input !== "object" || input === null)
+        return input;
+    if (Array.isArray(input))
+        return input.map(exports.sortObject);
+    const output = {};
+    Object.keys(input)
+        .sort()
+        .forEach((key) => (output[key] = (0, exports.sortObject)(input[key])));
+    return output;
+};
+exports.sortObject = sortObject;
+const stripHexPrefix = (input) => {
+    return input?.slice(0, 2) === "0x" ? input.slice(2) : input;
+};
+exports.stripHexPrefix = stripHexPrefix;
+const appendHexPrefix = (input) => {
+    return input?.slice(0, 2) === "0x" ? input : `0x${input}`;
+};
+exports.appendHexPrefix = appendHexPrefix;
+const computeTxHash = (bytes) => {
+    if (!bytes)
+        return bytes;
+    return (0, exports.toTxHash)((0, crypto_1.sha256)((0, bytes_1.toUint8Array)(bytes)));
+};
+exports.computeTxHash = computeTxHash;
+const toTxHash = (bytes) => {
+    if (!bytes)
+        return bytes;
+    return Buffer.from((0, bytes_1.toUint8Array)(bytes)).toString("hex").toUpperCase();
+};
+exports.toTxHash = toTxHash;
+/**
+ * Make tendermint client send RPC requests with the same request
+ * ID instead of using a random id that is unread in the client.
+ *
+ * Motivation: enhanced cache-ability on API providers.
+ *
+ * Broadcast methods are untouched to ensure retries don't hit cache.
+ */
+const modifyTmClient = (tmClient) => {
+    try {
+        const p = tmClient.p;
+        const newEncoder = { ...p };
+        for (const method of Object.getOwnPropertyNames(p)) {
+            if (method === "encodeBroadcastTx" || typeof p[method] !== "function")
+                continue;
+            const ogHandler = p[method];
+            newEncoder[method] = (req) => {
+                const result = ogHandler(req);
+                if (req.method === "abci_query" && req.params.path === "/cosmos.auth.v1beta1.Query/Account") {
+                    return result;
+                }
+                return {
+                    ...result,
+                    id: 42,
+                };
+            };
+        }
+        tmClient.p = newEncoder;
+    }
+    catch (error) {
+        console.error("failed to modify tm client");
+        console.error(error);
+    }
+    return tmClient;
+};
+exports.modifyTmClient = modifyTmClient;
+const callIgnoreError = (runnable) => {
+    return runnable();
+};
+exports.callIgnoreError = callIgnoreError;
+class QueueManager {
+    constructor(processor, options = {}) {
+        this.processor = processor;
+        this.currTriggerThreshold = 0;
+        this.currQueueTrigger = null;
+        this.isProcessingQueue = false;
+        this.queue = [];
+        this.triggerDelay = options.triggerDelay ?? 300;
+        this.maxDelayThreshold = options.maxDelayThreshold ?? 1000;
+    }
+    enqueue(task, skipTrigger = false) {
+        this.queue.unshift(task);
+        if (!skipTrigger)
+            this.trigger();
+    }
+    trigger() {
+        const currentTimeMillis = new Date().getTime();
+        // do not shift delay later if next schedule
+        if (this.currTriggerThreshold && currentTimeMillis + this.triggerDelay > this.currTriggerThreshold) {
+            return;
+        }
+        if (!this.currTriggerThreshold && this.maxDelayThreshold > 0) {
+            this.currTriggerThreshold = currentTimeMillis + this.maxDelayThreshold; // max wait for 1s before dispatching queue
+        }
+        clearTimeout(this.currQueueTrigger);
+        this.currQueueTrigger = setTimeout(this.process.bind(this), this.triggerDelay);
+    }
+    async process() {
+        if (this.isProcessingQueue)
+            return;
+        this.isProcessingQueue = true; // activate sync lock
+        this.currTriggerThreshold = 0; // reset to 0
+        try {
+            while (this.queue.length) {
+                const item = this.queue.pop();
+                try {
+                    await this.processor(item);
+                }
+                catch (error) {
+                    console.error("queue manager process item failed");
+                    console.error(error);
+                }
+            }
+        }
+        finally {
+            this.isProcessingQueue = false;
+        }
+    }
+}
+exports.QueueManager = QueueManager;
+const getBestRpcTmClient = async (rpcUrls) => {
+    for (const rpcUrl of rpcUrls) {
+        try {
+            return {
+                client: await tendermint_rpc_1.Tendermint37Client.connect(rpcUrl),
+                rpcUrl,
+            };
+        }
+        catch (error) {
+            console.debug("failed to connect RPC:" + rpcUrl);
+            console.debug(error);
+            continue;
+        }
+    }
+    throw new Error("Could not get available RPC service");
+};
+exports.getBestRpcTmClient = getBestRpcTmClient;

package/lib/util/gov.d.ts

@@ -0,0 +1,47 @@
+import { Any } from "../codec/google/protobuf/any";
+export declare enum ProposalTypes {
+    ParameterChange = "/cosmos.params.v1beta1.ParameterChangeProposal",
+    SoftwareUpgrade = "/cosmos.upgrade.v1beta1.SoftwareUpgradeProposal",
+    CancelSoftwareUpgrade = "/cosmos.upgrade.v1beta1.CancelSoftwareUpgradeProposal",
+    CommunityPoolSpend = "/cosmos.distribution.v1beta1.CommunityPoolSpendProposal",
+    Text = "/cosmos.gov.v1beta1.TextProposal",
+    CommunityPoolSpendV2 = "/cosmos.distribution.v1beta1.MsgCommunityPoolSpend",
+    SoftwareUpgradeV2 = "/cosmos.upgrade.v1beta1.MsgSoftwareUpgrade",
+    CancelSoftwareUpgradeV2 = "/cosmos.upgrade.v1beta1.MsgCancelUpgrade",
+    CreateAlliance = "/alliance.alliance.MsgCreateAllianceProposal",
+    UpdateAlliance = "/alliance.alliance.MsgUpdateAllianceProposal",
+    DeleteAlliance = "/alliance.alliance.MsgDeleteAllianceProposal",
+    CreateAllianceV2 = "/alliance.alliance.MsgCreateAlliance",
+    UpdateAllianceV2 = "/alliance.alliance.MsgUpdateAlliance",
+    DeleteAllianceV2 = "/alliance.alliance.MsgDeleteAlliance",
+    ClientUpdateProposal = "/ibc.core.client.v1.ClientUpdateProposal",
+    UpdateMarket = "/mememax.orbix.market.UpdateMarketProposal",
+    UpdateMarketV2 = "/mememax.orbix.market.MsgUpdateMarket",
+    SetMsgGasCost = "/mememax.orbix.fee.SetMsgGasCostProposal",
+    SetMinGasPrice = "/mememax.orbix.fee.SetMinGasPriceProposal",
+    RemoveMsgGasCost = "/mememax.orbix.fee.RemoveMsgGasCostProposal",
+    RemoveMinGasPrice = "/mememax.orbix.fee.RemoveMinGasPriceProposal",
+    SetMsgGasCostV2 = "/mememax.orbix.fee.MsgSetGasCost",
+    SetMinGasPriceV2 = "/mememax.orbix.fee.MsgSetMinGasPrice",
+    RemoveMsgGasCostV2 = "/mememax.orbix.fee.MsgRemoveGasCost",
+    RemoveMinGasPriceV2 = "/mememax.orbix.fee.MsgRemoveMinGasPrice",
+    SettlementPriceV2 = "/mememax.orbix.pricing.MsgUpdateSettlementPrice",
+    CreateOracleV2 = "/mememax.orbix.oracle.MsgCreateOracle",
+    CreateToken = "/mememax.orbix.coin.CreateTokenProposal",
+    CreateGroup = "/mememax.orbix.coin.CreateGroupProposal",
+    UpdateGroup = "/mememax.orbix.coin.UpdateGroupProposal",
+    RegisterToGroup = "/mememax.orbix.coin.RegisterToGroupProposal",
+    DeregisterFromGroup = "/mememax.orbix.coin.DeregisterFromGroupProposal",
+    DepositToGroup = "/mememax.orbix.coin.DepositToGroupProposal",
+    WithdrawFromGroup = "/mememax.orbix.coin.WithdrawFromGroupProposal",
+    UpdateGroupTokenConfig = "/mememax.orbix.coin.UpdateGroupTokenConfigProposal"
+}
+export interface PropDecoded {
+    typeUrl: string;
+    value: any;
+}
+export declare const emptyProposal: {
+    typeUrl: string;
+    value: {};
+};
+export declare const decodeContent: (content?: Any) => PropDecoded;