injectivejs 1.4.0 → 1.6.0

package/injective/auction/v1beta1/tx.d.ts

@@ -0,0 +1,140 @@
+import { Coin, CoinAmino } from "../../../cosmos/base/v1beta1/coin";
+import { Params, ParamsAmino } from "./auction";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/** Bid defines a SDK message for placing a bid for an auction */
+export interface MsgBid {
+    sender: string;
+    /** amount of the bid in INJ tokens */
+    bidAmount: Coin;
+    /** the current auction round being bid on */
+    round: bigint;
+}
+export interface MsgBidProtoMsg {
+    typeUrl: "/injective.auction.v1beta1.MsgBid";
+    value: Uint8Array;
+}
+/** Bid defines a SDK message for placing a bid for an auction */
+export interface MsgBidAmino {
+    sender: string;
+    /** amount of the bid in INJ tokens */
+    bid_amount: CoinAmino;
+    /** the current auction round being bid on */
+    round: string;
+}
+export interface MsgBidAminoMsg {
+    type: "auction/MsgBid";
+    value: MsgBidAmino;
+}
+export interface MsgBidResponse {
+}
+export interface MsgBidResponseProtoMsg {
+    typeUrl: "/injective.auction.v1beta1.MsgBidResponse";
+    value: Uint8Array;
+}
+export interface MsgBidResponseAmino {
+}
+export interface MsgBidResponseAminoMsg {
+    type: "/injective.auction.v1beta1.MsgBidResponse";
+    value: MsgBidResponseAmino;
+}
+export interface MsgUpdateParams {
+    /** authority is the address of the governance account. */
+    authority: string;
+    /**
+     * params defines the ocr parameters to update.
+     *
+     * NOTE: All parameters must be supplied.
+     */
+    params: Params;
+}
+export interface MsgUpdateParamsProtoMsg {
+    typeUrl: "/injective.auction.v1beta1.MsgUpdateParams";
+    value: Uint8Array;
+}
+export interface MsgUpdateParamsAmino {
+    /** authority is the address of the governance account. */
+    authority: string;
+    /**
+     * params defines the ocr parameters to update.
+     *
+     * NOTE: All parameters must be supplied.
+     */
+    params: ParamsAmino;
+}
+export interface MsgUpdateParamsAminoMsg {
+    type: "auction/MsgUpdateParams";
+    value: MsgUpdateParamsAmino;
+}
+export interface MsgUpdateParamsResponse {
+}
+export interface MsgUpdateParamsResponseProtoMsg {
+    typeUrl: "/injective.auction.v1beta1.MsgUpdateParamsResponse";
+    value: Uint8Array;
+}
+export interface MsgUpdateParamsResponseAmino {
+}
+export interface MsgUpdateParamsResponseAminoMsg {
+    type: "/injective.auction.v1beta1.MsgUpdateParamsResponse";
+    value: MsgUpdateParamsResponseAmino;
+}
+export declare const MsgBid: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MsgBid;
+    isAmino(o: any): o is MsgBidAmino;
+    encode(message: MsgBid, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgBid;
+    fromPartial(object: DeepPartial<MsgBid>): MsgBid;
+    fromAmino(object: MsgBidAmino): MsgBid;
+    toAmino(message: MsgBid): MsgBidAmino;
+    fromAminoMsg(object: MsgBidAminoMsg): MsgBid;
+    toAminoMsg(message: MsgBid): MsgBidAminoMsg;
+    fromProtoMsg(message: MsgBidProtoMsg): MsgBid;
+    toProto(message: MsgBid): Uint8Array;
+    toProtoMsg(message: MsgBid): MsgBidProtoMsg;
+};
+export declare const MsgBidResponse: {
+    typeUrl: string;
+    is(o: any): o is MsgBidResponse;
+    isAmino(o: any): o is MsgBidResponseAmino;
+    encode(_: MsgBidResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgBidResponse;
+    fromPartial(_: DeepPartial<MsgBidResponse>): MsgBidResponse;
+    fromAmino(_: MsgBidResponseAmino): MsgBidResponse;
+    toAmino(_: MsgBidResponse): MsgBidResponseAmino;
+    fromAminoMsg(object: MsgBidResponseAminoMsg): MsgBidResponse;
+    fromProtoMsg(message: MsgBidResponseProtoMsg): MsgBidResponse;
+    toProto(message: MsgBidResponse): Uint8Array;
+    toProtoMsg(message: MsgBidResponse): MsgBidResponseProtoMsg;
+};
+export declare const MsgUpdateParams: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MsgUpdateParams;
+    isAmino(o: any): o is MsgUpdateParamsAmino;
+    encode(message: MsgUpdateParams, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateParams;
+    fromPartial(object: DeepPartial<MsgUpdateParams>): MsgUpdateParams;
+    fromAmino(object: MsgUpdateParamsAmino): MsgUpdateParams;
+    toAmino(message: MsgUpdateParams): MsgUpdateParamsAmino;
+    fromAminoMsg(object: MsgUpdateParamsAminoMsg): MsgUpdateParams;
+    toAminoMsg(message: MsgUpdateParams): MsgUpdateParamsAminoMsg;
+    fromProtoMsg(message: MsgUpdateParamsProtoMsg): MsgUpdateParams;
+    toProto(message: MsgUpdateParams): Uint8Array;
+    toProtoMsg(message: MsgUpdateParams): MsgUpdateParamsProtoMsg;
+};
+export declare const MsgUpdateParamsResponse: {
+    typeUrl: string;
+    is(o: any): o is MsgUpdateParamsResponse;
+    isAmino(o: any): o is MsgUpdateParamsResponseAmino;
+    encode(_: MsgUpdateParamsResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateParamsResponse;
+    fromPartial(_: DeepPartial<MsgUpdateParamsResponse>): MsgUpdateParamsResponse;
+    fromAmino(_: MsgUpdateParamsResponseAmino): MsgUpdateParamsResponse;
+    toAmino(_: MsgUpdateParamsResponse): MsgUpdateParamsResponseAmino;
+    fromAminoMsg(object: MsgUpdateParamsResponseAminoMsg): MsgUpdateParamsResponse;
+    fromProtoMsg(message: MsgUpdateParamsResponseProtoMsg): MsgUpdateParamsResponse;
+    toProto(message: MsgUpdateParamsResponse): Uint8Array;
+    toProtoMsg(message: MsgUpdateParamsResponse): MsgUpdateParamsResponseProtoMsg;
+};

package/injective/auction/v1beta1/tx.js

@@ -0,0 +1,313 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgUpdateParamsResponse = exports.MsgUpdateParams = exports.MsgBidResponse = exports.MsgBid = void 0;
+const coin_1 = require("../../../cosmos/base/v1beta1/coin");
+const auction_1 = require("./auction");
+const binary_1 = require("../../../binary");
+const registry_1 = require("../../../registry");
+function createBaseMsgBid() {
+    return {
+        sender: "",
+        bidAmount: coin_1.Coin.fromPartial({}),
+        round: BigInt(0)
+    };
+}
+exports.MsgBid = {
+    typeUrl: "/injective.auction.v1beta1.MsgBid",
+    aminoType: "auction/MsgBid",
+    is(o) {
+        return o && (o.$typeUrl === exports.MsgBid.typeUrl || typeof o.sender === "string" && coin_1.Coin.is(o.bidAmount) && typeof o.round === "bigint");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.MsgBid.typeUrl || typeof o.sender === "string" && coin_1.Coin.isAmino(o.bid_amount) && typeof o.round === "bigint");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.sender !== "") {
+            writer.uint32(10).string(message.sender);
+        }
+        if (message.bidAmount !== undefined) {
+            coin_1.Coin.encode(message.bidAmount, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.round !== BigInt(0)) {
+            writer.uint32(24).uint64(message.round);
+        }
+        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 = createBaseMsgBid();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = reader.string();
+                    break;
+                case 2:
+                    message.bidAmount = coin_1.Coin.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.round = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgBid();
+        message.sender = object.sender ?? "";
+        message.bidAmount = object.bidAmount !== undefined && object.bidAmount !== null ? coin_1.Coin.fromPartial(object.bidAmount) : undefined;
+        message.round = object.round !== undefined && object.round !== null ? BigInt(object.round.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgBid();
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        if (object.bid_amount !== undefined && object.bid_amount !== null) {
+            message.bidAmount = coin_1.Coin.fromAmino(object.bid_amount);
+        }
+        if (object.round !== undefined && object.round !== null) {
+            message.round = BigInt(object.round);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        obj.bid_amount = message.bidAmount ? coin_1.Coin.toAmino(message.bidAmount) : undefined;
+        obj.round = message.round !== BigInt(0) ? message.round?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MsgBid.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "auction/MsgBid",
+            value: exports.MsgBid.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.MsgBid.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgBid.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.auction.v1beta1.MsgBid",
+            value: exports.MsgBid.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.MsgBid.typeUrl, exports.MsgBid);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.MsgBid.aminoType, exports.MsgBid.typeUrl);
+function createBaseMsgBidResponse() {
+    return {};
+}
+exports.MsgBidResponse = {
+    typeUrl: "/injective.auction.v1beta1.MsgBidResponse",
+    is(o) {
+        return o && o.$typeUrl === exports.MsgBidResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.MsgBidResponse.typeUrl;
+    },
+    encode(_, writer = binary_1.BinaryWriter.create()) {
+        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 = createBaseMsgBidResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgBidResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgBidResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MsgBidResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.MsgBidResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgBidResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.auction.v1beta1.MsgBidResponse",
+            value: exports.MsgBidResponse.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.MsgBidResponse.typeUrl, exports.MsgBidResponse);
+function createBaseMsgUpdateParams() {
+    return {
+        authority: "",
+        params: auction_1.Params.fromPartial({})
+    };
+}
+exports.MsgUpdateParams = {
+    typeUrl: "/injective.auction.v1beta1.MsgUpdateParams",
+    aminoType: "auction/MsgUpdateParams",
+    is(o) {
+        return o && (o.$typeUrl === exports.MsgUpdateParams.typeUrl || typeof o.authority === "string" && auction_1.Params.is(o.params));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.MsgUpdateParams.typeUrl || typeof o.authority === "string" && auction_1.Params.isAmino(o.params));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        if (message.params !== undefined) {
+            auction_1.Params.encode(message.params, writer.uint32(18).fork()).ldelim();
+        }
+        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 = createBaseMsgUpdateParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                case 2:
+                    message.params = auction_1.Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUpdateParams();
+        message.authority = object.authority ?? "";
+        message.params = object.params !== undefined && object.params !== null ? auction_1.Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgUpdateParams();
+        if (object.authority !== undefined && object.authority !== null) {
+            message.authority = object.authority;
+        }
+        if (object.params !== undefined && object.params !== null) {
+            message.params = auction_1.Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.authority = message.authority === "" ? undefined : message.authority;
+        obj.params = message.params ? auction_1.Params.toAmino(message.params) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MsgUpdateParams.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "auction/MsgUpdateParams",
+            value: exports.MsgUpdateParams.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.MsgUpdateParams.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgUpdateParams.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.auction.v1beta1.MsgUpdateParams",
+            value: exports.MsgUpdateParams.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.MsgUpdateParams.typeUrl, exports.MsgUpdateParams);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.MsgUpdateParams.aminoType, exports.MsgUpdateParams.typeUrl);
+function createBaseMsgUpdateParamsResponse() {
+    return {};
+}
+exports.MsgUpdateParamsResponse = {
+    typeUrl: "/injective.auction.v1beta1.MsgUpdateParamsResponse",
+    is(o) {
+        return o && o.$typeUrl === exports.MsgUpdateParamsResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.MsgUpdateParamsResponse.typeUrl;
+    },
+    encode(_, writer = binary_1.BinaryWriter.create()) {
+        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 = createBaseMsgUpdateParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgUpdateParamsResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgUpdateParamsResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MsgUpdateParamsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.MsgUpdateParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgUpdateParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.auction.v1beta1.MsgUpdateParamsResponse",
+            value: exports.MsgUpdateParamsResponse.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.MsgUpdateParamsResponse.typeUrl, exports.MsgUpdateParamsResponse);

package/injective/auction/v1beta1/tx.rpc.func.d.ts

@@ -0,0 +1,4 @@
+import { SigningClientResolver } from "../../../helper-func-types";
+import { MsgBid, MsgUpdateParams } from "./tx";
+export declare const createBid: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgBid, fee: import("../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../helper-func-types").DeliverTxResponse>;
+export declare const createUpdateParams: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgUpdateParams, fee: import("../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../helper-func-types").DeliverTxResponse>;

package/injective/auction/v1beta1/tx.rpc.func.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUpdateParams = exports.createBid = void 0;
+const helper_func_types_1 = require("../../../helper-func-types");
+const utils_1 = require("@interchainjs/cosmos/utils");
+const tx_1 = require("./tx");
+const createBid = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgBid.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgBid),
+    converters: (0, utils_1.toConverters)(tx_1.MsgBid)
+});
+exports.createBid = createBid;
+const createUpdateParams = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgUpdateParams.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgUpdateParams),
+    converters: (0, utils_1.toConverters)(tx_1.MsgUpdateParams)
+});
+exports.createUpdateParams = createUpdateParams;

package/injective/crypto/v1beta1/ethsecp256k1/keys.d.ts

@@ -0,0 +1,80 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/**
+ * PubKey defines a type alias for an ecdsa.PublicKey that implements
+ * Tendermint's PubKey interface. It represents the 33-byte compressed public
+ * key format.
+ */
+export interface PubKey {
+    key: Uint8Array;
+}
+export interface PubKeyProtoMsg {
+    typeUrl: "/injective.crypto.v1beta1.ethsecp256k1.PubKey";
+    value: Uint8Array;
+}
+/**
+ * PubKey defines a type alias for an ecdsa.PublicKey that implements
+ * Tendermint's PubKey interface. It represents the 33-byte compressed public
+ * key format.
+ */
+export interface PubKeyAmino {
+    key: string;
+}
+export interface PubKeyAminoMsg {
+    type: "injective/PubKeyEthSecp256k1";
+    value: PubKeyAmino;
+}
+/**
+ * PrivKey defines a type alias for an ecdsa.PrivateKey that implements
+ * Tendermint's PrivateKey interface.
+ */
+export interface PrivKey {
+    key: Uint8Array;
+}
+export interface PrivKeyProtoMsg {
+    typeUrl: "/injective.crypto.v1beta1.ethsecp256k1.PrivKey";
+    value: Uint8Array;
+}
+/**
+ * PrivKey defines a type alias for an ecdsa.PrivateKey that implements
+ * Tendermint's PrivateKey interface.
+ */
+export interface PrivKeyAmino {
+    key: string;
+}
+export interface PrivKeyAminoMsg {
+    type: "injective/PrivKeyEthSecp256k1";
+    value: PrivKeyAmino;
+}
+export declare const PubKey: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is PubKey;
+    isAmino(o: any): o is PubKeyAmino;
+    encode(message: PubKey, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PubKey;
+    fromPartial(object: DeepPartial<PubKey>): PubKey;
+    fromAmino(object: PubKeyAmino): PubKey;
+    toAmino(message: PubKey): PubKeyAmino;
+    fromAminoMsg(object: PubKeyAminoMsg): PubKey;
+    toAminoMsg(message: PubKey): PubKeyAminoMsg;
+    fromProtoMsg(message: PubKeyProtoMsg): PubKey;
+    toProto(message: PubKey): Uint8Array;
+    toProtoMsg(message: PubKey): PubKeyProtoMsg;
+};
+export declare const PrivKey: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is PrivKey;
+    isAmino(o: any): o is PrivKeyAmino;
+    encode(message: PrivKey, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PrivKey;
+    fromPartial(object: DeepPartial<PrivKey>): PrivKey;
+    fromAmino(object: PrivKeyAmino): PrivKey;
+    toAmino(message: PrivKey): PrivKeyAmino;
+    fromAminoMsg(object: PrivKeyAminoMsg): PrivKey;
+    toAminoMsg(message: PrivKey): PrivKeyAminoMsg;
+    fromProtoMsg(message: PrivKeyProtoMsg): PrivKey;
+    toProto(message: PrivKey): Uint8Array;
+    toProtoMsg(message: PrivKey): PrivKeyProtoMsg;
+};