injectivejs 1.4.0 → 1.6.0

package/injective/crypto/v1beta1/ethsecp256k1/keys.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivKey = exports.PubKey = void 0;
+const binary_1 = require("../../../../binary");
+const helpers_1 = require("../../../../helpers");
+const registry_1 = require("../../../../registry");
+function createBasePubKey() {
+    return {
+        key: new Uint8Array()
+    };
+}
+exports.PubKey = {
+    typeUrl: "/injective.crypto.v1beta1.ethsecp256k1.PubKey",
+    aminoType: "injective/PubKeyEthSecp256k1",
+    is(o) {
+        return o && (o.$typeUrl === exports.PubKey.typeUrl || o.key instanceof Uint8Array || typeof o.key === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.PubKey.typeUrl || o.key instanceof Uint8Array || typeof o.key === "string");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePubKey();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePubKey();
+        message.key = object.key ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePubKey();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = (0, helpers_1.bytesFromBase64)(object.key);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key ? (0, helpers_1.base64FromBytes)(message.key) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.PubKey.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "injective/PubKeyEthSecp256k1",
+            value: exports.PubKey.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.PubKey.decode(message.value);
+    },
+    toProto(message) {
+        return exports.PubKey.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.crypto.v1beta1.ethsecp256k1.PubKey",
+            value: exports.PubKey.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.PubKey.typeUrl, exports.PubKey);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.PubKey.aminoType, exports.PubKey.typeUrl);
+function createBasePrivKey() {
+    return {
+        key: new Uint8Array()
+    };
+}
+exports.PrivKey = {
+    typeUrl: "/injective.crypto.v1beta1.ethsecp256k1.PrivKey",
+    aminoType: "injective/PrivKeyEthSecp256k1",
+    is(o) {
+        return o && (o.$typeUrl === exports.PrivKey.typeUrl || o.key instanceof Uint8Array || typeof o.key === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.PrivKey.typeUrl || o.key instanceof Uint8Array || typeof o.key === "string");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePrivKey();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePrivKey();
+        message.key = object.key ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePrivKey();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = (0, helpers_1.bytesFromBase64)(object.key);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key ? (0, helpers_1.base64FromBytes)(message.key) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.PrivKey.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "injective/PrivKeyEthSecp256k1",
+            value: exports.PrivKey.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.PrivKey.decode(message.value);
+    },
+    toProto(message) {
+        return exports.PrivKey.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.crypto.v1beta1.ethsecp256k1.PrivKey",
+            value: exports.PrivKey.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.PrivKey.typeUrl, exports.PrivKey);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.PrivKey.aminoType, exports.PrivKey.typeUrl);

package/injective/exchange/v1beta1/authz.d.ts

@@ -0,0 +1,362 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/** spot authz messages */
+export interface CreateSpotLimitOrderAuthz {
+    subaccountId: string;
+    marketIds: string[];
+}
+export interface CreateSpotLimitOrderAuthzProtoMsg {
+    typeUrl: "/injective.exchange.v1beta1.CreateSpotLimitOrderAuthz";
+    value: Uint8Array;
+}
+/** spot authz messages */
+export interface CreateSpotLimitOrderAuthzAmino {
+    subaccount_id: string;
+    market_ids: string[];
+}
+export interface CreateSpotLimitOrderAuthzAminoMsg {
+    type: "exchange/CreateSpotLimitOrderAuthz";
+    value: CreateSpotLimitOrderAuthzAmino;
+}
+export interface CreateSpotMarketOrderAuthz {
+    subaccountId: string;
+    marketIds: string[];
+}
+export interface CreateSpotMarketOrderAuthzProtoMsg {
+    typeUrl: "/injective.exchange.v1beta1.CreateSpotMarketOrderAuthz";
+    value: Uint8Array;
+}
+export interface CreateSpotMarketOrderAuthzAmino {
+    subaccount_id: string;
+    market_ids: string[];
+}
+export interface CreateSpotMarketOrderAuthzAminoMsg {
+    type: "exchange/CreateSpotMarketOrderAuthz";
+    value: CreateSpotMarketOrderAuthzAmino;
+}
+export interface BatchCreateSpotLimitOrdersAuthz {
+    subaccountId: string;
+    marketIds: string[];
+}
+export interface BatchCreateSpotLimitOrdersAuthzProtoMsg {
+    typeUrl: "/injective.exchange.v1beta1.BatchCreateSpotLimitOrdersAuthz";
+    value: Uint8Array;
+}
+export interface BatchCreateSpotLimitOrdersAuthzAmino {
+    subaccount_id: string;
+    market_ids: string[];
+}
+export interface BatchCreateSpotLimitOrdersAuthzAminoMsg {
+    type: "exchange/BatchCreateSpotLimitOrdersAuthz";
+    value: BatchCreateSpotLimitOrdersAuthzAmino;
+}
+export interface CancelSpotOrderAuthz {
+    subaccountId: string;
+    marketIds: string[];
+}
+export interface CancelSpotOrderAuthzProtoMsg {
+    typeUrl: "/injective.exchange.v1beta1.CancelSpotOrderAuthz";
+    value: Uint8Array;
+}
+export interface CancelSpotOrderAuthzAmino {
+    subaccount_id: string;
+    market_ids: string[];
+}
+export interface CancelSpotOrderAuthzAminoMsg {
+    type: "exchange/CancelSpotOrderAuthz";
+    value: CancelSpotOrderAuthzAmino;
+}
+export interface BatchCancelSpotOrdersAuthz {
+    subaccountId: string;
+    marketIds: string[];
+}
+export interface BatchCancelSpotOrdersAuthzProtoMsg {
+    typeUrl: "/injective.exchange.v1beta1.BatchCancelSpotOrdersAuthz";
+    value: Uint8Array;
+}
+export interface BatchCancelSpotOrdersAuthzAmino {
+    subaccount_id: string;
+    market_ids: string[];
+}
+export interface BatchCancelSpotOrdersAuthzAminoMsg {
+    type: "exchange/BatchCancelSpotOrdersAuthz";
+    value: BatchCancelSpotOrdersAuthzAmino;
+}
+/** derivative authz messages */
+export interface CreateDerivativeLimitOrderAuthz {
+    subaccountId: string;
+    marketIds: string[];
+}
+export interface CreateDerivativeLimitOrderAuthzProtoMsg {
+    typeUrl: "/injective.exchange.v1beta1.CreateDerivativeLimitOrderAuthz";
+    value: Uint8Array;
+}
+/** derivative authz messages */
+export interface CreateDerivativeLimitOrderAuthzAmino {
+    subaccount_id: string;
+    market_ids: string[];
+}
+export interface CreateDerivativeLimitOrderAuthzAminoMsg {
+    type: "exchange/CreateDerivativeLimitOrderAuthz";
+    value: CreateDerivativeLimitOrderAuthzAmino;
+}
+export interface CreateDerivativeMarketOrderAuthz {
+    subaccountId: string;
+    marketIds: string[];
+}
+export interface CreateDerivativeMarketOrderAuthzProtoMsg {
+    typeUrl: "/injective.exchange.v1beta1.CreateDerivativeMarketOrderAuthz";
+    value: Uint8Array;
+}
+export interface CreateDerivativeMarketOrderAuthzAmino {
+    subaccount_id: string;
+    market_ids: string[];
+}
+export interface CreateDerivativeMarketOrderAuthzAminoMsg {
+    type: "exchange/CreateDerivativeMarketOrderAuthz";
+    value: CreateDerivativeMarketOrderAuthzAmino;
+}
+export interface BatchCreateDerivativeLimitOrdersAuthz {
+    subaccountId: string;
+    marketIds: string[];
+}
+export interface BatchCreateDerivativeLimitOrdersAuthzProtoMsg {
+    typeUrl: "/injective.exchange.v1beta1.BatchCreateDerivativeLimitOrdersAuthz";
+    value: Uint8Array;
+}
+export interface BatchCreateDerivativeLimitOrdersAuthzAmino {
+    subaccount_id: string;
+    market_ids: string[];
+}
+export interface BatchCreateDerivativeLimitOrdersAuthzAminoMsg {
+    type: "exchange/BatchCreateDerivativeLimitOrdersAuthz";
+    value: BatchCreateDerivativeLimitOrdersAuthzAmino;
+}
+export interface CancelDerivativeOrderAuthz {
+    subaccountId: string;
+    marketIds: string[];
+}
+export interface CancelDerivativeOrderAuthzProtoMsg {
+    typeUrl: "/injective.exchange.v1beta1.CancelDerivativeOrderAuthz";
+    value: Uint8Array;
+}
+export interface CancelDerivativeOrderAuthzAmino {
+    subaccount_id: string;
+    market_ids: string[];
+}
+export interface CancelDerivativeOrderAuthzAminoMsg {
+    type: "exchange/CancelDerivativeOrderAuthz";
+    value: CancelDerivativeOrderAuthzAmino;
+}
+export interface BatchCancelDerivativeOrdersAuthz {
+    subaccountId: string;
+    marketIds: string[];
+}
+export interface BatchCancelDerivativeOrdersAuthzProtoMsg {
+    typeUrl: "/injective.exchange.v1beta1.BatchCancelDerivativeOrdersAuthz";
+    value: Uint8Array;
+}
+export interface BatchCancelDerivativeOrdersAuthzAmino {
+    subaccount_id: string;
+    market_ids: string[];
+}
+export interface BatchCancelDerivativeOrdersAuthzAminoMsg {
+    type: "exchange/BatchCancelDerivativeOrdersAuthz";
+    value: BatchCancelDerivativeOrdersAuthzAmino;
+}
+/** common authz message used in both spot & derivative markets */
+export interface BatchUpdateOrdersAuthz {
+    subaccountId: string;
+    spotMarkets: string[];
+    derivativeMarkets: string[];
+}
+export interface BatchUpdateOrdersAuthzProtoMsg {
+    typeUrl: "/injective.exchange.v1beta1.BatchUpdateOrdersAuthz";
+    value: Uint8Array;
+}
+/** common authz message used in both spot & derivative markets */
+export interface BatchUpdateOrdersAuthzAmino {
+    subaccount_id: string;
+    spot_markets: string[];
+    derivative_markets: string[];
+}
+export interface BatchUpdateOrdersAuthzAminoMsg {
+    type: "exchange/BatchUpdateOrdersAuthz";
+    value: BatchUpdateOrdersAuthzAmino;
+}
+export declare const CreateSpotLimitOrderAuthz: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is CreateSpotLimitOrderAuthz;
+    isAmino(o: any): o is CreateSpotLimitOrderAuthzAmino;
+    encode(message: CreateSpotLimitOrderAuthz, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): CreateSpotLimitOrderAuthz;
+    fromPartial(object: DeepPartial<CreateSpotLimitOrderAuthz>): CreateSpotLimitOrderAuthz;
+    fromAmino(object: CreateSpotLimitOrderAuthzAmino): CreateSpotLimitOrderAuthz;
+    toAmino(message: CreateSpotLimitOrderAuthz): CreateSpotLimitOrderAuthzAmino;
+    fromAminoMsg(object: CreateSpotLimitOrderAuthzAminoMsg): CreateSpotLimitOrderAuthz;
+    toAminoMsg(message: CreateSpotLimitOrderAuthz): CreateSpotLimitOrderAuthzAminoMsg;
+    fromProtoMsg(message: CreateSpotLimitOrderAuthzProtoMsg): CreateSpotLimitOrderAuthz;
+    toProto(message: CreateSpotLimitOrderAuthz): Uint8Array;
+    toProtoMsg(message: CreateSpotLimitOrderAuthz): CreateSpotLimitOrderAuthzProtoMsg;
+};
+export declare const CreateSpotMarketOrderAuthz: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is CreateSpotMarketOrderAuthz;
+    isAmino(o: any): o is CreateSpotMarketOrderAuthzAmino;
+    encode(message: CreateSpotMarketOrderAuthz, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): CreateSpotMarketOrderAuthz;
+    fromPartial(object: DeepPartial<CreateSpotMarketOrderAuthz>): CreateSpotMarketOrderAuthz;
+    fromAmino(object: CreateSpotMarketOrderAuthzAmino): CreateSpotMarketOrderAuthz;
+    toAmino(message: CreateSpotMarketOrderAuthz): CreateSpotMarketOrderAuthzAmino;
+    fromAminoMsg(object: CreateSpotMarketOrderAuthzAminoMsg): CreateSpotMarketOrderAuthz;
+    toAminoMsg(message: CreateSpotMarketOrderAuthz): CreateSpotMarketOrderAuthzAminoMsg;
+    fromProtoMsg(message: CreateSpotMarketOrderAuthzProtoMsg): CreateSpotMarketOrderAuthz;
+    toProto(message: CreateSpotMarketOrderAuthz): Uint8Array;
+    toProtoMsg(message: CreateSpotMarketOrderAuthz): CreateSpotMarketOrderAuthzProtoMsg;
+};
+export declare const BatchCreateSpotLimitOrdersAuthz: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is BatchCreateSpotLimitOrdersAuthz;
+    isAmino(o: any): o is BatchCreateSpotLimitOrdersAuthzAmino;
+    encode(message: BatchCreateSpotLimitOrdersAuthz, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): BatchCreateSpotLimitOrdersAuthz;
+    fromPartial(object: DeepPartial<BatchCreateSpotLimitOrdersAuthz>): BatchCreateSpotLimitOrdersAuthz;
+    fromAmino(object: BatchCreateSpotLimitOrdersAuthzAmino): BatchCreateSpotLimitOrdersAuthz;
+    toAmino(message: BatchCreateSpotLimitOrdersAuthz): BatchCreateSpotLimitOrdersAuthzAmino;
+    fromAminoMsg(object: BatchCreateSpotLimitOrdersAuthzAminoMsg): BatchCreateSpotLimitOrdersAuthz;
+    toAminoMsg(message: BatchCreateSpotLimitOrdersAuthz): BatchCreateSpotLimitOrdersAuthzAminoMsg;
+    fromProtoMsg(message: BatchCreateSpotLimitOrdersAuthzProtoMsg): BatchCreateSpotLimitOrdersAuthz;
+    toProto(message: BatchCreateSpotLimitOrdersAuthz): Uint8Array;
+    toProtoMsg(message: BatchCreateSpotLimitOrdersAuthz): BatchCreateSpotLimitOrdersAuthzProtoMsg;
+};
+export declare const CancelSpotOrderAuthz: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is CancelSpotOrderAuthz;
+    isAmino(o: any): o is CancelSpotOrderAuthzAmino;
+    encode(message: CancelSpotOrderAuthz, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): CancelSpotOrderAuthz;
+    fromPartial(object: DeepPartial<CancelSpotOrderAuthz>): CancelSpotOrderAuthz;
+    fromAmino(object: CancelSpotOrderAuthzAmino): CancelSpotOrderAuthz;
+    toAmino(message: CancelSpotOrderAuthz): CancelSpotOrderAuthzAmino;
+    fromAminoMsg(object: CancelSpotOrderAuthzAminoMsg): CancelSpotOrderAuthz;
+    toAminoMsg(message: CancelSpotOrderAuthz): CancelSpotOrderAuthzAminoMsg;
+    fromProtoMsg(message: CancelSpotOrderAuthzProtoMsg): CancelSpotOrderAuthz;
+    toProto(message: CancelSpotOrderAuthz): Uint8Array;
+    toProtoMsg(message: CancelSpotOrderAuthz): CancelSpotOrderAuthzProtoMsg;
+};
+export declare const BatchCancelSpotOrdersAuthz: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is BatchCancelSpotOrdersAuthz;
+    isAmino(o: any): o is BatchCancelSpotOrdersAuthzAmino;
+    encode(message: BatchCancelSpotOrdersAuthz, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): BatchCancelSpotOrdersAuthz;
+    fromPartial(object: DeepPartial<BatchCancelSpotOrdersAuthz>): BatchCancelSpotOrdersAuthz;
+    fromAmino(object: BatchCancelSpotOrdersAuthzAmino): BatchCancelSpotOrdersAuthz;
+    toAmino(message: BatchCancelSpotOrdersAuthz): BatchCancelSpotOrdersAuthzAmino;
+    fromAminoMsg(object: BatchCancelSpotOrdersAuthzAminoMsg): BatchCancelSpotOrdersAuthz;
+    toAminoMsg(message: BatchCancelSpotOrdersAuthz): BatchCancelSpotOrdersAuthzAminoMsg;
+    fromProtoMsg(message: BatchCancelSpotOrdersAuthzProtoMsg): BatchCancelSpotOrdersAuthz;
+    toProto(message: BatchCancelSpotOrdersAuthz): Uint8Array;
+    toProtoMsg(message: BatchCancelSpotOrdersAuthz): BatchCancelSpotOrdersAuthzProtoMsg;
+};
+export declare const CreateDerivativeLimitOrderAuthz: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is CreateDerivativeLimitOrderAuthz;
+    isAmino(o: any): o is CreateDerivativeLimitOrderAuthzAmino;
+    encode(message: CreateDerivativeLimitOrderAuthz, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): CreateDerivativeLimitOrderAuthz;
+    fromPartial(object: DeepPartial<CreateDerivativeLimitOrderAuthz>): CreateDerivativeLimitOrderAuthz;
+    fromAmino(object: CreateDerivativeLimitOrderAuthzAmino): CreateDerivativeLimitOrderAuthz;
+    toAmino(message: CreateDerivativeLimitOrderAuthz): CreateDerivativeLimitOrderAuthzAmino;
+    fromAminoMsg(object: CreateDerivativeLimitOrderAuthzAminoMsg): CreateDerivativeLimitOrderAuthz;
+    toAminoMsg(message: CreateDerivativeLimitOrderAuthz): CreateDerivativeLimitOrderAuthzAminoMsg;
+    fromProtoMsg(message: CreateDerivativeLimitOrderAuthzProtoMsg): CreateDerivativeLimitOrderAuthz;
+    toProto(message: CreateDerivativeLimitOrderAuthz): Uint8Array;
+    toProtoMsg(message: CreateDerivativeLimitOrderAuthz): CreateDerivativeLimitOrderAuthzProtoMsg;
+};
+export declare const CreateDerivativeMarketOrderAuthz: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is CreateDerivativeMarketOrderAuthz;
+    isAmino(o: any): o is CreateDerivativeMarketOrderAuthzAmino;
+    encode(message: CreateDerivativeMarketOrderAuthz, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): CreateDerivativeMarketOrderAuthz;
+    fromPartial(object: DeepPartial<CreateDerivativeMarketOrderAuthz>): CreateDerivativeMarketOrderAuthz;
+    fromAmino(object: CreateDerivativeMarketOrderAuthzAmino): CreateDerivativeMarketOrderAuthz;
+    toAmino(message: CreateDerivativeMarketOrderAuthz): CreateDerivativeMarketOrderAuthzAmino;
+    fromAminoMsg(object: CreateDerivativeMarketOrderAuthzAminoMsg): CreateDerivativeMarketOrderAuthz;
+    toAminoMsg(message: CreateDerivativeMarketOrderAuthz): CreateDerivativeMarketOrderAuthzAminoMsg;
+    fromProtoMsg(message: CreateDerivativeMarketOrderAuthzProtoMsg): CreateDerivativeMarketOrderAuthz;
+    toProto(message: CreateDerivativeMarketOrderAuthz): Uint8Array;
+    toProtoMsg(message: CreateDerivativeMarketOrderAuthz): CreateDerivativeMarketOrderAuthzProtoMsg;
+};
+export declare const BatchCreateDerivativeLimitOrdersAuthz: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is BatchCreateDerivativeLimitOrdersAuthz;
+    isAmino(o: any): o is BatchCreateDerivativeLimitOrdersAuthzAmino;
+    encode(message: BatchCreateDerivativeLimitOrdersAuthz, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): BatchCreateDerivativeLimitOrdersAuthz;
+    fromPartial(object: DeepPartial<BatchCreateDerivativeLimitOrdersAuthz>): BatchCreateDerivativeLimitOrdersAuthz;
+    fromAmino(object: BatchCreateDerivativeLimitOrdersAuthzAmino): BatchCreateDerivativeLimitOrdersAuthz;
+    toAmino(message: BatchCreateDerivativeLimitOrdersAuthz): BatchCreateDerivativeLimitOrdersAuthzAmino;
+    fromAminoMsg(object: BatchCreateDerivativeLimitOrdersAuthzAminoMsg): BatchCreateDerivativeLimitOrdersAuthz;
+    toAminoMsg(message: BatchCreateDerivativeLimitOrdersAuthz): BatchCreateDerivativeLimitOrdersAuthzAminoMsg;
+    fromProtoMsg(message: BatchCreateDerivativeLimitOrdersAuthzProtoMsg): BatchCreateDerivativeLimitOrdersAuthz;
+    toProto(message: BatchCreateDerivativeLimitOrdersAuthz): Uint8Array;
+    toProtoMsg(message: BatchCreateDerivativeLimitOrdersAuthz): BatchCreateDerivativeLimitOrdersAuthzProtoMsg;
+};
+export declare const CancelDerivativeOrderAuthz: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is CancelDerivativeOrderAuthz;
+    isAmino(o: any): o is CancelDerivativeOrderAuthzAmino;
+    encode(message: CancelDerivativeOrderAuthz, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): CancelDerivativeOrderAuthz;
+    fromPartial(object: DeepPartial<CancelDerivativeOrderAuthz>): CancelDerivativeOrderAuthz;
+    fromAmino(object: CancelDerivativeOrderAuthzAmino): CancelDerivativeOrderAuthz;
+    toAmino(message: CancelDerivativeOrderAuthz): CancelDerivativeOrderAuthzAmino;
+    fromAminoMsg(object: CancelDerivativeOrderAuthzAminoMsg): CancelDerivativeOrderAuthz;
+    toAminoMsg(message: CancelDerivativeOrderAuthz): CancelDerivativeOrderAuthzAminoMsg;
+    fromProtoMsg(message: CancelDerivativeOrderAuthzProtoMsg): CancelDerivativeOrderAuthz;
+    toProto(message: CancelDerivativeOrderAuthz): Uint8Array;
+    toProtoMsg(message: CancelDerivativeOrderAuthz): CancelDerivativeOrderAuthzProtoMsg;
+};
+export declare const BatchCancelDerivativeOrdersAuthz: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is BatchCancelDerivativeOrdersAuthz;
+    isAmino(o: any): o is BatchCancelDerivativeOrdersAuthzAmino;
+    encode(message: BatchCancelDerivativeOrdersAuthz, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): BatchCancelDerivativeOrdersAuthz;
+    fromPartial(object: DeepPartial<BatchCancelDerivativeOrdersAuthz>): BatchCancelDerivativeOrdersAuthz;
+    fromAmino(object: BatchCancelDerivativeOrdersAuthzAmino): BatchCancelDerivativeOrdersAuthz;
+    toAmino(message: BatchCancelDerivativeOrdersAuthz): BatchCancelDerivativeOrdersAuthzAmino;
+    fromAminoMsg(object: BatchCancelDerivativeOrdersAuthzAminoMsg): BatchCancelDerivativeOrdersAuthz;
+    toAminoMsg(message: BatchCancelDerivativeOrdersAuthz): BatchCancelDerivativeOrdersAuthzAminoMsg;
+    fromProtoMsg(message: BatchCancelDerivativeOrdersAuthzProtoMsg): BatchCancelDerivativeOrdersAuthz;
+    toProto(message: BatchCancelDerivativeOrdersAuthz): Uint8Array;
+    toProtoMsg(message: BatchCancelDerivativeOrdersAuthz): BatchCancelDerivativeOrdersAuthzProtoMsg;
+};
+export declare const BatchUpdateOrdersAuthz: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is BatchUpdateOrdersAuthz;
+    isAmino(o: any): o is BatchUpdateOrdersAuthzAmino;
+    encode(message: BatchUpdateOrdersAuthz, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): BatchUpdateOrdersAuthz;
+    fromPartial(object: DeepPartial<BatchUpdateOrdersAuthz>): BatchUpdateOrdersAuthz;
+    fromAmino(object: BatchUpdateOrdersAuthzAmino): BatchUpdateOrdersAuthz;
+    toAmino(message: BatchUpdateOrdersAuthz): BatchUpdateOrdersAuthzAmino;
+    fromAminoMsg(object: BatchUpdateOrdersAuthzAminoMsg): BatchUpdateOrdersAuthz;
+    toAminoMsg(message: BatchUpdateOrdersAuthz): BatchUpdateOrdersAuthzAminoMsg;
+    fromProtoMsg(message: BatchUpdateOrdersAuthzProtoMsg): BatchUpdateOrdersAuthz;
+    toProto(message: BatchUpdateOrdersAuthz): Uint8Array;
+    toProtoMsg(message: BatchUpdateOrdersAuthz): BatchUpdateOrdersAuthzProtoMsg;
+};