@injectivelabs/sdk-ts 1.15.0 → 1.15.2

package/dist/esm/core/modules/exchange/utils/classes/OrderHashManager.js

@@ -0,0 +1,320 @@
+import { getNetworkEndpoints } from '@injectivelabs/networks';
+import { BigNumber } from '@injectivelabs/utils';
+import { GeneralException } from '@injectivelabs/exceptions';
+import { Address } from '../../../../accounts/Address.js';
+import { ChainGrpcExchangeApi } from '../../../../../client/chain/grpc/ChainGrpcExchangeApi.js';
+import { domainHash, messageHash } from '../../../../../utils/crypto.js';
+import { numberToCosmosSdkDecString } from '../../../../../utils/numbers.js';
+import keccak256 from 'keccak256';
+import { InjectiveExchangeV1Beta1Exchange } from '@injectivelabs/core-proto-ts';
+const spotOrderPrimaryType = 'SpotOrder';
+const derivativeOrderPrimaryType = 'DerivativeOrder';
+const EIP712DomainType = [
+    {
+        name: 'name',
+        type: 'string',
+    },
+    {
+        name: 'version',
+        type: 'string',
+    },
+    {
+        name: 'chainId',
+        type: 'uint256',
+    },
+    {
+        name: 'verifyingContract',
+        type: 'address',
+    },
+    {
+        name: 'salt',
+        type: 'bytes32',
+    },
+];
+const SpotOrderType = [
+    {
+        name: 'MarketId',
+        type: 'string',
+    },
+    {
+        name: 'OrderInfo',
+        type: 'OrderInfo',
+    },
+    {
+        name: 'Salt',
+        type: 'string',
+    },
+    {
+        name: 'OrderType',
+        type: 'string',
+    },
+    {
+        name: 'TriggerPrice',
+        type: 'string',
+    },
+];
+const DerivativeOrderType = [
+    {
+        name: 'MarketId',
+        type: 'string',
+    },
+    {
+        name: 'OrderInfo',
+        type: 'OrderInfo',
+    },
+    {
+        name: 'OrderType',
+        type: 'string',
+    },
+    {
+        name: 'Margin',
+        type: 'string',
+    },
+    {
+        name: 'TriggerPrice',
+        type: 'string',
+    },
+    {
+        name: 'Salt',
+        type: 'string',
+    },
+];
+const OrderInfoType = [
+    {
+        name: 'SubaccountId',
+        type: 'string',
+    },
+    {
+        name: 'FeeRecipient',
+        type: 'string',
+    },
+    {
+        name: 'Price',
+        type: 'string',
+    },
+    {
+        name: 'Quantity',
+        type: 'string',
+    },
+];
+const EIP712Domain = {
+    name: 'Injective Protocol',
+    version: '2.0.0',
+    chainId: `0x${new BigNumber(888).toString(16)}`,
+    verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
+    salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
+};
+const EIP712Types = {
+    EIP712Domain: EIP712DomainType,
+    [spotOrderPrimaryType]: SpotOrderType,
+    [derivativeOrderPrimaryType]: DerivativeOrderType,
+    OrderInfo: OrderInfoType,
+};
+const orderTypeToChainOrderType = (orderType) => {
+    switch (orderType) {
+        case InjectiveExchangeV1Beta1Exchange.OrderType.BUY:
+            return '\u0001';
+        case InjectiveExchangeV1Beta1Exchange.OrderType.SELL:
+            return '\u0002';
+        case InjectiveExchangeV1Beta1Exchange.OrderType.STOP_BUY:
+            return '\u0003';
+        case InjectiveExchangeV1Beta1Exchange.OrderType.STOP_SELL:
+            return '\u0004';
+        case InjectiveExchangeV1Beta1Exchange.OrderType.TAKE_BUY:
+            return '\u0005';
+        case InjectiveExchangeV1Beta1Exchange.OrderType.TAKE_SELL:
+            return '\u0006';
+        case InjectiveExchangeV1Beta1Exchange.OrderType.BUY_PO:
+            return '\u0007';
+        case InjectiveExchangeV1Beta1Exchange.OrderType.SELL_PO:
+            return '\u0008';
+        case InjectiveExchangeV1Beta1Exchange.OrderType.BUY_ATOMIC:
+            return '\u0009';
+        case InjectiveExchangeV1Beta1Exchange.OrderType.SELL_ATOMIC:
+            return '\u000A';
+        default:
+            return '\u0001';
+    }
+};
+const getEip712ForSpotOrder = (spotOrder, nonce) => {
+    return {
+        primaryType: spotOrderPrimaryType,
+        types: EIP712Types,
+        domain: EIP712Domain,
+        message: {
+            MarketId: spotOrder.marketId,
+            OrderInfo: {
+                SubaccountId: spotOrder.orderInfo.subaccountId,
+                FeeRecipient: spotOrder.orderInfo.feeRecipient,
+                Price: numberToCosmosSdkDecString(spotOrder.orderInfo.price),
+                Quantity: numberToCosmosSdkDecString(spotOrder.orderInfo.quantity),
+            },
+            Salt: nonce.toString(),
+            OrderType: orderTypeToChainOrderType(spotOrder.orderType),
+            TriggerPrice: spotOrder.triggerPrice
+                ? numberToCosmosSdkDecString(spotOrder.triggerPrice)
+                : '0.000000000000000000',
+        },
+    };
+};
+const getEip712ForDerivativeOrder = (derivativeOrder, nonce) => {
+    return {
+        primaryType: derivativeOrderPrimaryType,
+        types: EIP712Types,
+        domain: EIP712Domain,
+        message: {
+            MarketId: derivativeOrder.marketId,
+            OrderInfo: {
+                SubaccountId: derivativeOrder.orderInfo.subaccountId,
+                FeeRecipient: derivativeOrder.orderInfo.feeRecipient,
+                Price: numberToCosmosSdkDecString(derivativeOrder.orderInfo.price),
+                Quantity: numberToCosmosSdkDecString(derivativeOrder.orderInfo.quantity),
+            },
+            Margin: numberToCosmosSdkDecString(derivativeOrder.margin),
+            OrderType: orderTypeToChainOrderType(derivativeOrder.orderType),
+            TriggerPrice: derivativeOrder.triggerPrice
+                ? numberToCosmosSdkDecString(derivativeOrder.triggerPrice)
+                : '0.000000000000000000',
+            Salt: nonce.toString(),
+        },
+    };
+};
+export class OrderHashManager {
+    subaccountIndex;
+    address;
+    network;
+    nonce = 0;
+    constructor({ network, address, subaccountIndex = 0 /* default trading account */, }) {
+        this.network = network;
+        this.address = address;
+        this.subaccountIndex = subaccountIndex;
+    }
+    incrementNonce() {
+        this.nonce += 1;
+    }
+    setNonce(nonce) {
+        this.nonce = nonce;
+    }
+    /**
+     * Keep in mind that the order params have to be transformed
+     * in proper format that's supported on the chain
+     */
+    async getOrderHashes({ spotOrders = [], derivativeOrders = [], }) {
+        if (spotOrders.length === 0 && derivativeOrders.length === 0) {
+            throw new GeneralException(new Error('Please provide spot or derivative orders'));
+        }
+        await this.initSubaccountNonce();
+        const spotOrderHashes = spotOrders.map((order) => {
+            return this.incrementNonceAndReturn(this.hashTypedData(getEip712ForSpotOrder(order, this.nonce)));
+        });
+        const derivativeOrderHashes = derivativeOrders.map((order) => {
+            return this.incrementNonceAndReturn(this.hashTypedData(getEip712ForDerivativeOrder(order, this.nonce)));
+        });
+        return {
+            spotOrderHashes,
+            derivativeOrderHashes,
+        };
+    }
+    /**
+     * Keep in mind that the order params have to be transformed
+     * in proper format that's supported on the chain
+     */
+    async getDerivativeOrderHashes(orders) {
+        if (orders.length === 0) {
+            throw new GeneralException(new Error('Please provide orders'));
+        }
+        await this.initSubaccountNonce();
+        return orders.map((order) => {
+            return this.incrementNonceAndReturn(this.hashTypedData(getEip712ForDerivativeOrder(order, this.nonce)));
+        });
+    }
+    /**
+     * Keep in mind that the order params have to be transformed
+     * in proper format that's supported on the chain
+     */
+    async getSpotOrderHashes(orders) {
+        if (orders.length === 0) {
+            throw new GeneralException(new Error('Please provide orders'));
+        }
+        await this.initSubaccountNonce();
+        return orders.map((order) => {
+            return this.incrementNonceAndReturn(this.hashTypedData(getEip712ForSpotOrder(order, this.nonce)));
+        });
+    }
+    async getSpotOrderHashFromMsg(msg) {
+        await this.initSubaccountNonce();
+        const proto = msg.toAmino();
+        const order = proto.value.order;
+        if (!order) {
+            throw new GeneralException(new Error('The MsgCreateSpotLimitOrder is not complete'));
+        }
+        const orderInfo = order.order_info;
+        if (!orderInfo) {
+            throw new GeneralException(new Error('The MsgCreateSpotLimitOrder is not complete'));
+        }
+        return this.incrementNonceAndReturn(this.hashTypedData(getEip712ForSpotOrder({
+            marketId: order.market_id,
+            orderInfo: {
+                subaccountId: orderInfo.subaccount_id,
+                feeRecipient: orderInfo.fee_recipient,
+                price: orderInfo.price,
+                quantity: orderInfo.quantity,
+            },
+            orderType: order.order_type,
+            triggerPrice: order.trigger_price,
+        }, this.nonce)));
+    }
+    async getDerivativeOrderHashFromMsg(msg) {
+        await this.initSubaccountNonce();
+        const proto = msg.toAmino();
+        const order = proto.value.order;
+        if (!order) {
+            throw new GeneralException(new Error('The MsgCreateDerivativeLimitOrder is not complete'));
+        }
+        const orderInfo = order.order_info;
+        if (!orderInfo) {
+            throw new GeneralException(new Error('The MsgCreateDerivativeLimitOrder is not complete'));
+        }
+        return this.incrementNonceAndReturn(this.hashTypedData(getEip712ForDerivativeOrder({
+            marketId: order.market_id,
+            orderInfo: {
+                subaccountId: orderInfo.subaccount_id,
+                feeRecipient: orderInfo.fee_recipient,
+                price: orderInfo.price,
+                quantity: orderInfo.quantity,
+            },
+            margin: order.margin,
+            orderType: order.order_type,
+            triggerPrice: order.trigger_price,
+        }, this.nonce)));
+    }
+    async initSubaccountNonce() {
+        if (this.nonce) {
+            return this.incrementNonce();
+        }
+        const { network, subaccountIndex, address } = this;
+        const endpoints = getNetworkEndpoints(network);
+        const chainGrpcExchangeApi = new ChainGrpcExchangeApi(endpoints.grpc);
+        const subaccountId = Address.fromBech32(address).getSubaccountId(subaccountIndex);
+        const { nonce } = await chainGrpcExchangeApi.fetchSubaccountTradeNonce(subaccountId);
+        this.nonce = nonce + 1;
+    }
+    hashTypedData(eip712) {
+        const bytesToHash = Buffer.concat([
+            Buffer.from('19', 'hex'),
+            Buffer.from('01', 'hex'),
+            domainHash(eip712),
+            messageHash(eip712),
+        ]);
+        try {
+            return `0x${Buffer.from(keccak256(bytesToHash)).toString('hex')}`;
+        }
+        catch (e) {
+            return '';
+        }
+    }
+    incrementNonceAndReturn(result) {
+        this.incrementNonce();
+        return result;
+    }
+}

package/dist/esm/core/modules/exchange/utils/classes/index.d.ts

@@ -0,0 +1 @@
+export { OrderHashManager } from './OrderHashManager.js';

package/dist/esm/core/modules/exchange/utils/classes/index.js

@@ -0,0 +1 @@
+export { OrderHashManager } from './OrderHashManager.js';

package/dist/esm/core/modules/exchange/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './classes/index.js';

package/dist/esm/core/modules/exchange/utils/index.js

@@ -0,0 +1 @@
+export * from './classes/index.js';

package/dist/esm/core/modules/feegrant/index.d.ts

@@ -0,0 +1,3 @@
+import MsgGrantAllowance from './msgs/MsgGrantAllowance.js';
+import MsgRevokeAllowance from './msgs/MsgRevokeAllowance.js';
+export { MsgGrantAllowance, MsgRevokeAllowance };

package/dist/esm/core/modules/feegrant/index.js

@@ -0,0 +1,3 @@
+import MsgGrantAllowance from './msgs/MsgGrantAllowance.js';
+import MsgRevokeAllowance from './msgs/MsgRevokeAllowance.js';
+export { MsgGrantAllowance, MsgRevokeAllowance };

package/dist/esm/core/modules/feegrant/msgs/MsgGrantAllowance.d.ts

@@ -0,0 +1,66 @@
+import { MsgBase } from '../../MsgBase.js';
+import { GoogleProtobufAny, CosmosFeegrantV1Beta1Tx } from '@injectivelabs/core-proto-ts';
+import { Coin } from '@injectivelabs/ts-types';
+export declare namespace MsgGrantAllowance {
+    interface Params {
+        granter: string;
+        grantee: string;
+        allowance: {
+            spendLimit: Coin[];
+            expiration: number | undefined;
+        };
+    }
+    type Proto = CosmosFeegrantV1Beta1Tx.MsgGrantAllowance;
+    type Object = Omit<CosmosFeegrantV1Beta1Tx.MsgGrantAllowance, 'allowance'> & {
+        allowance: any;
+    };
+}
+/**
+ * @category Messages
+ */
+export default class MsgGrantAllowance extends MsgBase<MsgGrantAllowance.Params, MsgGrantAllowance.Proto> {
+    static fromJSON(params: MsgGrantAllowance.Params): MsgGrantAllowance;
+    toProto(): CosmosFeegrantV1Beta1Tx.MsgGrantAllowance;
+    toData(): {
+        granter: string;
+        grantee: string;
+        allowance: GoogleProtobufAny.Any | undefined;
+        '@type': string;
+    };
+    toAmino(): {
+        type: string;
+        value: MsgGrantAllowance.Object;
+    };
+    toDirectSign(): {
+        type: string;
+        message: CosmosFeegrantV1Beta1Tx.MsgGrantAllowance;
+    };
+    toWeb3Gw(): {
+        granter: string;
+        grantee: string;
+        allowance: {
+            '@type': string;
+            spendLimit: {
+                denom: string;
+                amount: string;
+            }[];
+            expiration: string;
+        };
+        '@type': string;
+    };
+    toEip712V2(): {
+        allowance: {
+            '@type': string;
+            spend_limit: {
+                denom: string;
+                amount: string;
+            }[];
+            expiration: string;
+        };
+        granter: string;
+        grantee: string;
+        '@type': string;
+    };
+    private getTimestamp;
+    toBinary(): Uint8Array;
+}

package/dist/esm/core/modules/feegrant/msgs/MsgGrantAllowance.js

@@ -0,0 +1,124 @@
+import snakecaseKeys from 'snakecase-keys';
+import { MsgBase } from '../../MsgBase.js';
+import { GoogleProtobufAny, CosmosBaseV1Beta1Coin, CosmosFeegrantV1Beta1Tx, GoogleProtobufTimestamp, CosmosFeegrantV1Beta1Feegrant, } from '@injectivelabs/core-proto-ts';
+const basicAllowanceType = '/cosmos.feegrant.v1beta1.BasicAllowance';
+/**
+ * @category Messages
+ */
+export default class MsgGrantAllowance extends MsgBase {
+    static fromJSON(params) {
+        return new MsgGrantAllowance(params);
+    }
+    toProto() {
+        const { params } = this;
+        const timestamp = this.getTimestamp();
+        const basicAllowance = CosmosFeegrantV1Beta1Feegrant.BasicAllowance.create();
+        basicAllowance.spendLimit = params.allowance.spendLimit.map(({ denom, amount }) => {
+            const coin = CosmosBaseV1Beta1Coin.Coin.create();
+            coin.denom = denom;
+            coin.amount = amount;
+            return coin;
+        });
+        basicAllowance.expiration = new Date(Number(timestamp.seconds) * 1000);
+        const allowance = GoogleProtobufAny.Any.create();
+        allowance.typeUrl = basicAllowanceType;
+        allowance.value = Buffer.from(CosmosFeegrantV1Beta1Feegrant.BasicAllowance.encode(basicAllowance).finish());
+        const message = CosmosFeegrantV1Beta1Tx.MsgGrantAllowance.create();
+        message.granter = params.granter;
+        message.grantee = params.grantee;
+        message.allowance = allowance;
+        return CosmosFeegrantV1Beta1Tx.MsgGrantAllowance.fromJSON(message);
+    }
+    toData() {
+        const proto = this.toProto();
+        return {
+            '@type': '/cosmos.feegrant.v1beta1.MsgGrantAllowance',
+            ...proto,
+        };
+    }
+    toAmino() {
+        const { params } = this;
+        const proto = this.toProto();
+        const timestamp = this.getTimestamp();
+        const message = proto;
+        const messageWithAllowance = snakecaseKeys({
+            ...message,
+            allowance: {
+                type: 'cosmos-sdk/BasicAllowance',
+                value: {
+                    spendLimit: params.allowance.spendLimit.map(({ denom, amount }) => ({
+                        denom,
+                        amount,
+                    })),
+                    expiration: new Date(Number(timestamp.seconds) * 1000)
+                        .toISOString()
+                        .replace('.000Z', 'Z'),
+                },
+            },
+        });
+        return {
+            type: 'cosmos-sdk/MsgGrantAllowance',
+            value: messageWithAllowance,
+        };
+    }
+    toDirectSign() {
+        const proto = this.toProto();
+        return {
+            type: '/cosmos.feegrant.v1beta1.MsgGrantAllowance',
+            message: proto,
+        };
+    }
+    toWeb3Gw() {
+        const { params } = this;
+        const amino = this.toAmino();
+        const timestamp = this.getTimestamp();
+        const messageWithAllowance = {
+            granter: amino.value.granter,
+            grantee: amino.value.grantee,
+            allowance: {
+                '@type': basicAllowanceType,
+                spendLimit: params.allowance.spendLimit.map(({ denom, amount }) => ({
+                    denom,
+                    amount,
+                })),
+                expiration: new Date(Number(timestamp.seconds) * 1000)
+                    .toISOString()
+                    .replace('.000Z', 'Z'),
+            },
+        };
+        return {
+            '@type': '/cosmos.feegrant.v1beta1.MsgGrantAllowance',
+            ...messageWithAllowance,
+        };
+    }
+    toEip712V2() {
+        const web3Gw = this.toWeb3Gw();
+        const messageAdjustedForEip712V2 = {
+            ...web3Gw,
+            allowance: {
+                '@type': web3Gw.allowance['@type'],
+                spend_limit: web3Gw.allowance.spendLimit,
+                expiration: web3Gw.allowance.expiration,
+            },
+        };
+        return messageAdjustedForEip712V2;
+    }
+    getTimestamp() {
+        const { params } = this;
+        if (params.allowance.expiration) {
+            const timestamp = GoogleProtobufTimestamp.Timestamp.create();
+            timestamp.seconds = params.allowance.expiration.toString();
+            return timestamp;
+        }
+        const defaultExpiryYears = 5;
+        const dateNow = new Date();
+        const expiration = new Date(dateNow.getFullYear() + defaultExpiryYears, dateNow.getMonth(), dateNow.getDate());
+        const timestamp = GoogleProtobufTimestamp.Timestamp.create();
+        const timestampInSeconds = (expiration.getTime() / 1000).toString();
+        timestamp.seconds = timestampInSeconds;
+        return timestamp;
+    }
+    toBinary() {
+        return CosmosFeegrantV1Beta1Tx.MsgGrantAllowance.encode(this.toProto()).finish();
+    }
+}

package/dist/esm/core/modules/feegrant/msgs/MsgRevokeAllowance.d.ts

@@ -0,0 +1,50 @@
+import { MsgBase } from '../../MsgBase.js';
+import { SnakeCaseKeys } from 'snakecase-keys';
+import { CosmosFeegrantV1Beta1Tx } from '@injectivelabs/core-proto-ts';
+export declare namespace MsgRevokeAllowance {
+    interface Params {
+        granter: string;
+        grantee: string;
+    }
+    type Proto = CosmosFeegrantV1Beta1Tx.MsgRevokeAllowance;
+}
+/**
+ * @category Messages
+ */
+export default class MsgRevokeAllowance extends MsgBase<MsgRevokeAllowance.Params, MsgRevokeAllowance.Proto> {
+    static fromJSON(params: MsgRevokeAllowance.Params): MsgRevokeAllowance;
+    toProto(): CosmosFeegrantV1Beta1Tx.MsgRevokeAllowance;
+    toData(): {
+        granter: string;
+        grantee: string;
+        '@type': string;
+    };
+    toAmino(): {
+        type: string;
+        value: SnakeCaseKeys<MsgRevokeAllowance>;
+    };
+    toWeb3Gw(): {
+        to_proto: {};
+        to_data: {};
+        to_amino: {};
+        to_web3_gw: {};
+        to_direct_sign: {};
+        to_binary: {};
+        params: {
+            granter: string;
+            grantee: string;
+        };
+        to_web3: {};
+        to_j_s_o_n: {};
+        to_eip712_types: {};
+        to_eip712: {};
+        to_eip712_v2: {};
+        to_direct_sign_j_s_o_n: {};
+        '@type': string;
+    };
+    toDirectSign(): {
+        type: string;
+        message: CosmosFeegrantV1Beta1Tx.MsgRevokeAllowance;
+    };
+    toBinary(): Uint8Array;
+}

package/dist/esm/core/modules/feegrant/msgs/MsgRevokeAllowance.js

@@ -0,0 +1,53 @@
+import { MsgBase } from '../../MsgBase.js';
+import snakecaseKeys from 'snakecase-keys';
+import { CosmosFeegrantV1Beta1Tx } from '@injectivelabs/core-proto-ts';
+/**
+ * @category Messages
+ */
+export default class MsgRevokeAllowance extends MsgBase {
+    static fromJSON(params) {
+        return new MsgRevokeAllowance(params);
+    }
+    toProto() {
+        const { params } = this;
+        const message = CosmosFeegrantV1Beta1Tx.MsgRevokeAllowance.create();
+        message.granter = params.granter;
+        message.grantee = params.grantee;
+        return CosmosFeegrantV1Beta1Tx.MsgRevokeAllowance.fromPartial(message);
+    }
+    toData() {
+        const proto = this.toProto();
+        return {
+            '@type': '/cosmos.feegrant.v1beta1.MsgRevokeAllowance',
+            ...proto,
+        };
+    }
+    toAmino() {
+        const proto = this.toProto();
+        const message = {
+            ...snakecaseKeys(proto),
+        };
+        return {
+            type: 'cosmos-sdk/MsgRevokeAllowance',
+            value: message,
+        };
+    }
+    toWeb3Gw() {
+        const amino = this.toAmino();
+        const { value } = amino;
+        return {
+            '@type': '/cosmos.feegrant.v1beta1.MsgRevokeAllowance',
+            ...value,
+        };
+    }
+    toDirectSign() {
+        const proto = this.toProto();
+        return {
+            type: '/cosmos.feegrant.v1beta1.MsgRevokeAllowance',
+            message: proto,
+        };
+    }
+    toBinary() {
+        return CosmosFeegrantV1Beta1Tx.MsgRevokeAllowance.encode(this.toProto()).finish();
+    }
+}

package/dist/esm/core/modules/feegrant/utils/allowance.d.ts

@@ -0,0 +1,11 @@
+import { GoogleProtobufAny, CosmosFeegrantV1Beta1Feegrant } from '@injectivelabs/core-proto-ts';
+export type AllowedMsgAllowance = Omit<CosmosFeegrantV1Beta1Feegrant.AllowedMsgAllowance, 'allowance'> & {
+    allowance: CosmosFeegrantV1Beta1Feegrant.BasicAllowance | CosmosFeegrantV1Beta1Feegrant.PeriodicAllowance;
+};
+export type Allowance = CosmosFeegrantV1Beta1Feegrant.BasicAllowance | CosmosFeegrantV1Beta1Feegrant.PeriodicAllowance | AllowedMsgAllowance | undefined;
+export declare enum AllowanceTypes {
+    BasicAllowance = "spendLimit",
+    PeriodicAllowance = "periodSpendLimit",
+    AllowedMsgAllowance = "allowedMessages"
+}
+export declare function encodeAllowance(allowance: Allowance): GoogleProtobufAny.Any | undefined;