@injectivelabs/sdk-ts 1.15.0 → 1.15.2

package/dist/esm/utils/address.js

@@ -0,0 +1,79 @@
+import { bech32 } from 'bech32';
+import { Address } from 'ethereumjs-util';
+import keccak256 from 'keccak256';
+/**
+ * Get injective address from Ethereum hex address
+ *
+ * @param ethAddress string
+ * @returns string
+ */
+export const getInjectiveAddress = (ethAddress) => {
+    const addressBuffer = Address.fromString(ethAddress.toString()).toBuffer();
+    return bech32.encode('inj', bech32.toWords(addressBuffer));
+};
+/**
+ * Get ethereum address from injective bech32 address
+ *
+ * @param injectiveAddress string
+ * @returns string
+ */
+export const getEthereumAddress = (injectiveAddress) => {
+    if (injectiveAddress.startsWith('0x')) {
+        return injectiveAddress;
+    }
+    return `0x${Buffer.from(bech32.fromWords(bech32.decode(injectiveAddress).words)).toString('hex')}`;
+};
+/**
+ * Get ethereum address from injective bech32 address
+ *
+ * @param injectiveAddress string
+ * @returns string
+ */
+export const getInjectiveAddressFromSubaccountId = (subaccountId) => {
+    const ethAddress = subaccountId.slice(0, 42);
+    return getInjectiveAddress(ethAddress);
+};
+/**
+ * Get default subaccount id from injective bech32 address
+ *
+ * @param injectiveAddress string
+ * @returns string
+ */
+export const getDefaultSubaccountId = (injectiveAddress) => {
+    return `0x${Buffer.from(bech32.fromWords(bech32.decode(injectiveAddress).words)).toString('hex')}${'0'.repeat(24)}`;
+};
+/**
+ * Get subaccount id from injective bech32 address and an index (defaults to 0)
+ * @param injectiveAddress string
+ * @param nonce number
+ * @returns string
+ */
+export const getSubaccountId = (injectiveAddress, nonce = 0) => {
+    return `0x${Buffer.from(bech32.fromWords(bech32.decode(injectiveAddress).words)).toString('hex')}${'0'.repeat(23)}${nonce}`;
+};
+/** @deprecated - use getEthereumAddress */
+export const getAddressFromInjectiveAddress = (address) => {
+    if (address.startsWith('0x')) {
+        return address;
+    }
+    return `0x${Buffer.from(bech32.fromWords(bech32.decode(address).words)).toString('hex')}`;
+};
+export const getChecksumAddress = (ethAddress) => {
+    const lowercasedAddress = ethAddress.toLowerCase().replace('0x', '');
+    const addressHash = keccak256(lowercasedAddress)
+        .toString('hex')
+        .replace('0x', '');
+    let checksumAddress = '0x';
+    for (let i = 0; i < lowercasedAddress.length; i++) {
+        if (parseInt(addressHash[i], 16) > 7) {
+            checksumAddress += lowercasedAddress[i].toUpperCase();
+        }
+        else {
+            checksumAddress += lowercasedAddress[i];
+        }
+    }
+    return checksumAddress;
+};
+export const isCw20ContractAddress = (address) => address.length === 42 && address.startsWith('inj');
+export const addHexPrefix = (hex) => hex.startsWith('0x') ? hex : `0x${hex}`;
+export const removeHexPrefix = (hex) => hex.startsWith('0x') ? hex.slice(2) : hex;

package/dist/esm/utils/buff.d.ts

@@ -0,0 +1,2 @@
+export declare const hexToBuff: (hex: string) => Buffer<ArrayBuffer>;
+export declare const hexToBase64: (hex: string) => string;

package/dist/esm/utils/buff.js

@@ -0,0 +1,6 @@
+export const hexToBuff = (hex) => {
+    return Buffer.from(hex.startsWith('0x') ? hex.slice(2) : hex, 'hex');
+};
+export const hexToBase64 = (hex) => {
+    return Buffer.from(hex.startsWith('0x') ? hex.slice(2) : hex, 'hex').toString('base64');
+};

package/dist/esm/utils/constants.d.ts

@@ -0,0 +1,9 @@
+import { DEFAULT_STD_FEE, DEFAULT_STD_FEE_BY_DENOM } from '@injectivelabs/utils';
+export declare const BECH32_PUBKEY_ACC_PREFIX = "injpub";
+export declare const BECH32_PUBKEY_VAL_PREFIX = "injvaloperpub";
+export declare const BECH32_PUBKEY_CONS_PREFIX = "injvalconspub";
+export declare const BECH32_ADDR_ACC_PREFIX = "inj";
+export declare const BECH32_ADDR_VAL_PREFIX = "injvaloper";
+export declare const BECH32_ADDR_CONS_PREFIX = "injvalcons";
+export declare const DEFAULT_DERIVATION_PATH = "m/44'/60'/0'/0/0";
+export { DEFAULT_STD_FEE, DEFAULT_STD_FEE_BY_DENOM };

package/dist/esm/utils/constants.js

@@ -0,0 +1,9 @@
+import { DEFAULT_STD_FEE, DEFAULT_STD_FEE_BY_DENOM } from '@injectivelabs/utils';
+export const BECH32_PUBKEY_ACC_PREFIX = 'injpub';
+export const BECH32_PUBKEY_VAL_PREFIX = 'injvaloperpub';
+export const BECH32_PUBKEY_CONS_PREFIX = 'injvalconspub';
+export const BECH32_ADDR_ACC_PREFIX = 'inj';
+export const BECH32_ADDR_VAL_PREFIX = 'injvaloper';
+export const BECH32_ADDR_CONS_PREFIX = 'injvalcons';
+export const DEFAULT_DERIVATION_PATH = "m/44'/60'/0'/0/0";
+export { DEFAULT_STD_FEE, DEFAULT_STD_FEE_BY_DENOM };

package/dist/esm/utils/crypto.d.ts

@@ -0,0 +1,19 @@
+import { TypedMessage, MessageTypes, SignTypedDataVersion } from '@metamask/eth-sig-util';
+export declare const hashToHex: (data: string) => string;
+export declare const sha256: (data: Uint8Array) => Uint8Array;
+export declare const ripemd160: (data: Uint8Array) => Uint8Array;
+export declare const privateKeyToPublicKey: (privateKey: Uint8Array) => Uint8Array;
+export declare const privateKeyHashToPublicKey: (privateKeyHash: string) => Uint8Array;
+export declare const privateKeyToPublicKeyBase64: (privateKey: Uint8Array) => string;
+export declare const privateKeyHashToPublicKeyBase64: (privateKeyHash: string) => string;
+export declare const domainHash: (message: any) => Buffer<ArrayBufferLike>;
+export declare const messageHash: (message: any) => Buffer<ArrayBufferLike>;
+export declare function uint8ArrayToHex(arr: Uint8Array): string;
+export declare function hexToUnit8Array(str: string): Uint8Array<ArrayBuffer>;
+export declare function decompressPubKey(startsWith02Or03: string): string;
+export declare const publicKeyToAddress: (pubKey: Uint8Array, sanitize?: boolean) => Uint8Array;
+export declare const sanitizeTypedData: <T extends object | any[] | bigint | string | number | boolean | null | undefined>(data: T) => T;
+export declare const TypedDataUtilsSanitizeData: <T extends MessageTypes>(data: TypedMessage<T>) => TypedMessage<T>;
+export declare const TypedDataUtilsHashStruct: (primaryType: string, data: Record<string, unknown>, types: Record<string, import("@metamask/eth-sig-util").MessageTypeProperty[]>, version: SignTypedDataVersion.V3 | SignTypedDataVersion.V4) => Buffer;
+export declare const SignTypedDataVersionV4 = SignTypedDataVersion.V4;
+export type TypedMessageV4 = TypedMessage<MessageTypes>;

package/dist/esm/utils/crypto.js

@@ -0,0 +1,84 @@
+// import CryptoEs from 'crypto-es'
+import CryptoEs from 'crypto-js';
+import { secp256k1 } from '@noble/curves/secp256k1';
+import keccak256 from 'keccak256';
+import { TypedDataUtils, SignTypedDataVersion, } from '@metamask/eth-sig-util';
+export const hashToHex = (data) => {
+    return CryptoEs.SHA256(CryptoEs.enc.Base64.parse(data))
+        .toString()
+        .toUpperCase();
+};
+export const sha256 = (data) => {
+    const wordArray = CryptoEs.lib.WordArray.create(data);
+    const hash = CryptoEs.SHA256(wordArray);
+    return Uint8Array.from(Buffer.from(hash.toString(), 'hex'));
+};
+export const ripemd160 = (data) => {
+    const wordArray = CryptoEs.lib.WordArray.create(data);
+    const hash = CryptoEs.RIPEMD160(wordArray);
+    return Uint8Array.from(Buffer.from(hash.toString(), 'hex'));
+};
+export const privateKeyToPublicKey = (privateKey) => {
+    return secp256k1.getPublicKey(privateKey, true);
+};
+export const privateKeyHashToPublicKey = (privateKeyHash) => {
+    const privateKey = privateKeyHash.startsWith('0x')
+        ? privateKeyHash.slice(2)
+        : privateKeyHash;
+    return secp256k1.getPublicKey(Buffer.from(privateKey, 'hex'), true);
+};
+export const privateKeyToPublicKeyBase64 = (privateKey) => {
+    return Buffer.from(privateKeyToPublicKey(privateKey)).toString('base64');
+};
+export const privateKeyHashToPublicKeyBase64 = (privateKeyHash) => {
+    return Buffer.from(privateKeyHashToPublicKey(privateKeyHash)).toString('base64');
+};
+export const domainHash = (message) => TypedDataUtils.hashStruct('EIP712Domain', message.domain, message.types, SignTypedDataVersion.V4);
+export const messageHash = (message) => TypedDataUtils.hashStruct(message.primaryType, message.message, message.types, SignTypedDataVersion.V4);
+export function uint8ArrayToHex(arr) {
+    return Buffer.from(arr).toString('hex');
+}
+export function hexToUnit8Array(str) {
+    return new Uint8Array(Buffer.from(str, 'hex'));
+}
+export function decompressPubKey(startsWith02Or03) {
+    const testBuffer = Buffer.from(startsWith02Or03, 'hex');
+    if (testBuffer.length === 64)
+        startsWith02Or03 = '04' + startsWith02Or03;
+    const point = secp256k1.ProjectivePoint.fromHex(Buffer.from(testBuffer).toString('hex'));
+    const decompressed = point.toHex(false);
+    if (!decompressed.startsWith('04'))
+        return decompressed;
+    return decompressed.slice(2);
+}
+export const publicKeyToAddress = function (pubKey, sanitize = false) {
+    if (sanitize && pubKey.length !== 64) {
+        pubKey = secp256k1.ProjectivePoint.fromHex(pubKey)
+            .toRawBytes(false)
+            .slice(1);
+    }
+    if (pubKey.length !== 64) {
+        throw new Error('Expected pubKey to be of length 64');
+    }
+    return keccak256(Buffer.from(pubKey)).subarray(-20);
+};
+export const sanitizeTypedData = (data) => {
+    switch (Object.prototype.toString.call(data)) {
+        case '[object Object]': {
+            const entries = Object.keys(data).map((k) => [
+                k,
+                sanitizeTypedData(data[k]),
+            ]);
+            return Object.fromEntries(entries);
+        }
+        case '[object Array]':
+            return data.map((v) => sanitizeTypedData(v));
+        case '[object BigInt]':
+            return data.toString();
+        default:
+            return data;
+    }
+};
+export const TypedDataUtilsSanitizeData = TypedDataUtils.sanitizeData;
+export const TypedDataUtilsHashStruct = TypedDataUtils.hashStruct;
+export const SignTypedDataVersionV4 = SignTypedDataVersion.V4;

package/dist/esm/utils/grpc.d.ts

@@ -0,0 +1,4 @@
+import * as grpcPkg from '@injectivelabs/grpc-web';
+declare const grpc: typeof grpcPkg.grpc;
+export declare const getGrpcTransport: () => import("@injectivelabs/grpc-web").grpc.TransportFactory;
+export { grpc, grpcPkg };

package/dist/esm/utils/grpc.js

@@ -0,0 +1,18 @@
+import * as grpcPkg from '@injectivelabs/grpc-web';
+import { NodeHttpTransport } from '@injectivelabs/grpc-web-node-http-transport';
+import { ReactNativeTransport } from '@injectivelabs/grpc-web-react-native-transport';
+import { isNode, isReactNative } from './helpers.js';
+const grpc = grpcPkg.grpc ??
+    grpcPkg.default
+        .grpc ??
+    grpcPkg;
+export const getGrpcTransport = () => {
+    if (isReactNative()) {
+        return ReactNativeTransport({ withCredentials: true });
+    }
+    if (isNode()) {
+        return NodeHttpTransport();
+    }
+    return grpc.CrossBrowserHttpTransport({ withCredentials: false });
+};
+export { grpc, grpcPkg };

package/dist/esm/utils/helpers.d.ts

@@ -0,0 +1,24 @@
+import { CosmosBaseV1Beta1Coin } from '@injectivelabs/core-proto-ts';
+import { Coin } from '@injectivelabs/ts-types';
+export declare const isServerSide: () => boolean;
+export declare const isReactNative: () => boolean;
+export declare const isNode: () => boolean;
+export declare const isBrowser: () => boolean;
+export declare const objectToJson: (object: Record<string, any>, params?: {
+    replacer?: any;
+    indentation?: number;
+} | undefined) => string;
+export declare const protoObjectToJson: (object: any, params?: {
+    replacer?: any;
+    indentation?: number;
+} | undefined) => string;
+export declare const grpcCoinToUiCoin: (coin: CosmosBaseV1Beta1Coin.Coin) => Coin;
+export declare const uint8ArrayToString: (string: string | Uint8Array | null | undefined) => string;
+export declare const sortObjectByKeysWithReduce: <T>(obj: T) => T;
+export declare const sortObjectByKeys: <T>(obj: T) => T;
+export declare const getErrorMessage: (error: any, endpoint: string) => string;
+/**
+ * Converts value to it's number representation
+ */
+export declare const hexToNumber: (value: string) => number;
+export declare function isJsonString<T>(str: T): boolean;

package/dist/esm/utils/helpers.js

@@ -0,0 +1,111 @@
+export const isServerSide = () => typeof window === 'undefined';
+export const isReactNative = () => {
+    return (typeof document === 'undefined' &&
+        typeof navigator !== 'undefined' &&
+        navigator.product === 'ReactNative');
+};
+export const isNode = () => {
+    if (typeof window === 'undefined') {
+        return true;
+    }
+    return (typeof process !== 'undefined' &&
+        typeof process.versions !== 'undefined' &&
+        typeof process.versions.node !== 'undefined');
+};
+export const isBrowser = () => {
+    if (isReactNative()) {
+        return false;
+    }
+    if (isNode()) {
+        return false;
+    }
+    return typeof window !== 'undefined';
+};
+export const objectToJson = (object, params) => {
+    const { replacer, indentation } = params || { replacer: null, indentation: 2 };
+    return JSON.stringify(object, replacer, indentation);
+};
+export const protoObjectToJson = (object, params) => {
+    const { replacer, indentation } = params || { replacer: null, indentation: 2 };
+    if (object.toObject !== undefined) {
+        return JSON.stringify(object.toObject(), replacer, indentation);
+    }
+    return objectToJson(object, { replacer, indentation });
+};
+export const grpcCoinToUiCoin = (coin) => ({
+    amount: coin.amount,
+    denom: coin.denom,
+});
+export const uint8ArrayToString = (string) => {
+    if (!string) {
+        return '';
+    }
+    if (string.constructor !== Uint8Array) {
+        return string;
+    }
+    return new TextDecoder().decode(string);
+};
+export const sortObjectByKeysWithReduce = (obj) => {
+    if (typeof obj !== 'object' || obj === null)
+        return obj;
+    if (Array.isArray(obj)) {
+        return obj.map((e) => sortObjectByKeysWithReduce(e)).sort();
+    }
+    return Object.keys(obj)
+        .sort()
+        .reduce((sorted, k) => {
+        const key = k;
+        sorted[key] = sortObjectByKeysWithReduce(obj[key]);
+        return sorted;
+    }, {});
+};
+export const sortObjectByKeys = (obj) => {
+    if (typeof obj !== 'object' || obj === null) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(sortObjectByKeys);
+    }
+    const sortedKeys = Object.keys(obj).sort();
+    const result = {};
+    sortedKeys.forEach((key) => {
+        result[key] = sortObjectByKeys(obj[key]);
+    });
+    return result;
+};
+export const getErrorMessage = (error, endpoint) => {
+    if (!error.response) {
+        return `The request to ${endpoint} has failed.`;
+    }
+    return error.response.data
+        ? error.response.data.message || error.response.data
+        : error.response.statusText;
+};
+/**
+ * Converts value to it's number representation
+ */
+export const hexToNumber = (value) => {
+    const [negative, hexValue] = value.startsWith('-')
+        ? [true, value.slice(1)]
+        : [false, value];
+    const num = BigInt(hexValue);
+    if (num > Number.MAX_SAFE_INTEGER) {
+        return Number(negative ? -num : num);
+    }
+    if (num < Number.MIN_SAFE_INTEGER) {
+        return Number(num);
+    }
+    return negative ? -1 * Number(num) : Number(num);
+};
+export function isJsonString(str) {
+    if (typeof str !== 'string') {
+        return false;
+    }
+    try {
+        JSON.parse(str);
+    }
+    catch (e) {
+        return false;
+    }
+    return true;
+}

package/dist/esm/utils/index.d.ts

@@ -0,0 +1,13 @@
+export * from './utf8.js';
+export * from './buff.js';
+export * from './time.js';
+export * from './msgs.js';
+export * from './grpc.js';
+export * from './crypto.js';
+export * from './helpers.js';
+export * from './numbers.js';
+export * from './markets.js';
+export * from './address.js';
+export * from './constants.js';
+export * from './pagination.js';
+export * from './transaction.js';

package/dist/esm/utils/index.js

@@ -0,0 +1,13 @@
+export * from './utf8.js';
+export * from './buff.js';
+export * from './time.js';
+export * from './msgs.js';
+export * from './grpc.js';
+export * from './crypto.js';
+export * from './helpers.js';
+export * from './numbers.js';
+export * from './markets.js';
+export * from './address.js';
+export * from './constants.js';
+export * from './pagination.js';
+export * from './transaction.js';

package/dist/esm/utils/markets.d.ts

@@ -0,0 +1,34 @@
+export declare const getDerivativeMarketTensMultiplier: ({ quoteDecimals, minPriceTickSize, minQuantityTickSize, }: {
+    minPriceTickSize: number | string;
+    minQuantityTickSize: number | string;
+    quoteDecimals: number;
+}) => {
+    quantityTensMultiplier: number;
+    priceTensMultiplier: number;
+};
+export declare const getSpotMarketTensMultiplier: ({ baseDecimals, quoteDecimals, minPriceTickSize, minQuantityTickSize, }: {
+    minPriceTickSize: number | string;
+    minQuantityTickSize: number | string;
+    baseDecimals: number;
+    quoteDecimals: number;
+}) => {
+    priceTensMultiplier: number;
+    quantityTensMultiplier: number;
+};
+export declare const getDerivativeMarketDecimals: ({ minPriceTickSize, minQuantityTickSize, quoteDecimals, }: {
+    minPriceTickSize: number | string;
+    minQuantityTickSize: number | string;
+    quoteDecimals: number;
+}) => {
+    quantityDecimals: number;
+    priceDecimals: number;
+};
+export declare const getSpotMarketDecimals: ({ minPriceTickSize, minQuantityTickSize, baseDecimals, quoteDecimals, }: {
+    minPriceTickSize: number | string;
+    minQuantityTickSize: number | string;
+    baseDecimals: number;
+    quoteDecimals: number;
+}) => {
+    priceDecimals: number;
+    quantityDecimals: number;
+};

package/dist/esm/utils/markets.js

@@ -0,0 +1,30 @@
+import { BigNumber } from '@injectivelabs/utils';
+import { getExactDecimalsFromNumber, getTensMultiplier } from './numbers.js';
+export const getDerivativeMarketTensMultiplier = ({ quoteDecimals, minPriceTickSize, minQuantityTickSize, }) => {
+    return {
+        quantityTensMultiplier: getTensMultiplier(minQuantityTickSize),
+        priceTensMultiplier: getTensMultiplier(new BigNumber(minPriceTickSize).shiftedBy(-quoteDecimals).toFixed()),
+    };
+};
+export const getSpotMarketTensMultiplier = ({ baseDecimals, quoteDecimals, minPriceTickSize, minQuantityTickSize, }) => {
+    return {
+        priceTensMultiplier: getTensMultiplier(new BigNumber(minPriceTickSize)
+            .shiftedBy(baseDecimals - quoteDecimals)
+            .toFixed()),
+        quantityTensMultiplier: getTensMultiplier(new BigNumber(minQuantityTickSize).shiftedBy(-baseDecimals).toFixed()),
+    };
+};
+export const getDerivativeMarketDecimals = ({ minPriceTickSize, minQuantityTickSize, quoteDecimals, }) => {
+    return {
+        quantityDecimals: getExactDecimalsFromNumber(minQuantityTickSize),
+        priceDecimals: getExactDecimalsFromNumber(new BigNumber(minPriceTickSize).shiftedBy(-quoteDecimals).toFixed()),
+    };
+};
+export const getSpotMarketDecimals = ({ minPriceTickSize, minQuantityTickSize, baseDecimals, quoteDecimals, }) => {
+    return {
+        priceDecimals: getExactDecimalsFromNumber(new BigNumber(minPriceTickSize)
+            .shiftedBy(baseDecimals - quoteDecimals)
+            .toFixed()),
+        quantityDecimals: getExactDecimalsFromNumber(new BigNumber(minQuantityTickSize).shiftedBy(-baseDecimals).toFixed()),
+    };
+};

package/dist/esm/utils/msgs.d.ts

@@ -0,0 +1,2 @@
+import { Msgs } from '../core/modules/msgs.js';
+export declare const getGasPriceBasedOnMessage: (msgs: Msgs[]) => number;

package/dist/esm/utils/msgs.js

@@ -0,0 +1,55 @@
+import { BigNumberInBase, DEFAULT_GAS_LIMIT, DEFAULT_IBC_GAS_LIMIT, DEFAULT_EXCHANGE_LIMIT, } from '@injectivelabs/utils';
+export const getGasPriceBasedOnMessage = (msgs) => {
+    const messages = Array.isArray(msgs) ? msgs : [msgs];
+    const messageType = messages[0].toDirectSign().type;
+    if (messageType.includes('MsgPrivilegedExecuteContract')) {
+        return new BigNumberInBase(DEFAULT_GAS_LIMIT)
+            .times(6)
+            .times(messages.length)
+            .decimalPlaces(0)
+            .toNumber();
+    }
+    if (messageType.includes('MsgExecuteContract')) {
+        return new BigNumberInBase(DEFAULT_GAS_LIMIT)
+            .times(3)
+            .times(messages.length)
+            .decimalPlaces(0)
+            .toNumber();
+    }
+    if (messageType.includes('wasm')) {
+        return new BigNumberInBase(DEFAULT_GAS_LIMIT)
+            .times(1.5)
+            .times(messages.length)
+            .decimalPlaces(0)
+            .toNumber();
+    }
+    if (messageType.includes('exchange')) {
+        return new BigNumberInBase(DEFAULT_EXCHANGE_LIMIT)
+            .times(messages.length)
+            .decimalPlaces(0)
+            .toNumber();
+    }
+    if (messageType.includes('authz')) {
+        return new BigNumberInBase(DEFAULT_EXCHANGE_LIMIT)
+            .times(messages.length)
+            .decimalPlaces(0)
+            .toNumber();
+    }
+    if (messageType.includes('gov') &&
+        (messageType.includes('MsgDeposit') ||
+            messageType.includes('MsgSubmitProposal'))) {
+        return new BigNumberInBase(DEFAULT_GAS_LIMIT)
+            .times(15)
+            .times(messages.length)
+            .decimalPlaces(0)
+            .toNumber();
+    }
+    if (messageType.includes('MsgTransfer')) {
+        return new BigNumberInBase(DEFAULT_IBC_GAS_LIMIT)
+            .times(messages.length)
+            .toNumber();
+    }
+    return new BigNumberInBase(DEFAULT_GAS_LIMIT)
+        .times(messages.length)
+        .toNumber();
+};