injectivejs 1.4.0 → 1.6.0

package/esm/injective/tokenfactory/v1beta1/tx.rpc.func.js

@@ -0,0 +1,39 @@
+import { buildTx } from "../../../helper-func-types";
+import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
+import { MsgCreateDenom, MsgMint, MsgBurn, MsgChangeAdmin, MsgSetDenomMetadata, MsgUpdateParams } from "./tx";
+export const createCreateDenom = (clientResolver) => buildTx({
+    clientResolver,
+    typeUrl: MsgCreateDenom.typeUrl,
+    encoders: toEncoders(MsgCreateDenom),
+    converters: toConverters(MsgCreateDenom)
+});
+export const createMint = (clientResolver) => buildTx({
+    clientResolver,
+    typeUrl: MsgMint.typeUrl,
+    encoders: toEncoders(MsgMint),
+    converters: toConverters(MsgMint)
+});
+export const createBurn = (clientResolver) => buildTx({
+    clientResolver,
+    typeUrl: MsgBurn.typeUrl,
+    encoders: toEncoders(MsgBurn),
+    converters: toConverters(MsgBurn)
+});
+export const createChangeAdmin = (clientResolver) => buildTx({
+    clientResolver,
+    typeUrl: MsgChangeAdmin.typeUrl,
+    encoders: toEncoders(MsgChangeAdmin),
+    converters: toConverters(MsgChangeAdmin)
+});
+export const createSetDenomMetadata = (clientResolver) => buildTx({
+    clientResolver,
+    typeUrl: MsgSetDenomMetadata.typeUrl,
+    encoders: toEncoders(MsgSetDenomMetadata),
+    converters: toConverters(MsgSetDenomMetadata)
+});
+export const createUpdateParams = (clientResolver) => buildTx({
+    clientResolver,
+    typeUrl: MsgUpdateParams.typeUrl,
+    encoders: toEncoders(MsgUpdateParams),
+    converters: toConverters(MsgUpdateParams)
+});

package/esm/injective/types/v1beta1/account.js

@@ -0,0 +1,86 @@
+import { BaseAccount } from "../../../cosmos/auth/v1beta1/auth";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+function createBaseEthAccount() {
+    return {
+        baseAccount: undefined,
+        codeHash: new Uint8Array()
+    };
+}
+export const EthAccount = {
+    typeUrl: "/injective.types.v1beta1.EthAccount",
+    is(o) {
+        return o && (o.$typeUrl === EthAccount.typeUrl || o.codeHash instanceof Uint8Array || typeof o.codeHash === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === EthAccount.typeUrl || o.code_hash instanceof Uint8Array || typeof o.code_hash === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.baseAccount !== undefined) {
+            BaseAccount.encode(message.baseAccount, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.codeHash.length !== 0) {
+            writer.uint32(18).bytes(message.codeHash);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseEthAccount();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.baseAccount = BaseAccount.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.codeHash = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseEthAccount();
+        message.baseAccount = object.baseAccount !== undefined && object.baseAccount !== null ? BaseAccount.fromPartial(object.baseAccount) : undefined;
+        message.codeHash = object.codeHash ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseEthAccount();
+        if (object.base_account !== undefined && object.base_account !== null) {
+            message.baseAccount = BaseAccount.fromAmino(object.base_account);
+        }
+        if (object.code_hash !== undefined && object.code_hash !== null) {
+            message.codeHash = bytesFromBase64(object.code_hash);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.base_account = message.baseAccount ? BaseAccount.toAmino(message.baseAccount) : undefined;
+        obj.code_hash = message.codeHash ? base64FromBytes(message.codeHash) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return EthAccount.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return EthAccount.decode(message.value);
+    },
+    toProto(message) {
+        return EthAccount.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.types.v1beta1.EthAccount",
+            value: EthAccount.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(EthAccount.typeUrl, EthAccount);

package/esm/injective/types/v1beta1/tx_ext.js

@@ -0,0 +1,97 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+function createBaseExtensionOptionsWeb3Tx() {
+    return {
+        typedDataChainID: BigInt(0),
+        feePayer: "",
+        feePayerSig: new Uint8Array()
+    };
+}
+export const ExtensionOptionsWeb3Tx = {
+    typeUrl: "/injective.types.v1beta1.ExtensionOptionsWeb3Tx",
+    is(o) {
+        return o && (o.$typeUrl === ExtensionOptionsWeb3Tx.typeUrl || typeof o.typedDataChainID === "bigint" && typeof o.feePayer === "string" && (o.feePayerSig instanceof Uint8Array || typeof o.feePayerSig === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === ExtensionOptionsWeb3Tx.typeUrl || typeof o.typedDataChainID === "bigint" && typeof o.feePayer === "string" && (o.feePayerSig instanceof Uint8Array || typeof o.feePayerSig === "string"));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.typedDataChainID !== BigInt(0)) {
+            writer.uint32(8).uint64(message.typedDataChainID);
+        }
+        if (message.feePayer !== "") {
+            writer.uint32(18).string(message.feePayer);
+        }
+        if (message.feePayerSig.length !== 0) {
+            writer.uint32(26).bytes(message.feePayerSig);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseExtensionOptionsWeb3Tx();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.typedDataChainID = reader.uint64();
+                    break;
+                case 2:
+                    message.feePayer = reader.string();
+                    break;
+                case 3:
+                    message.feePayerSig = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseExtensionOptionsWeb3Tx();
+        message.typedDataChainID = object.typedDataChainID !== undefined && object.typedDataChainID !== null ? BigInt(object.typedDataChainID.toString()) : BigInt(0);
+        message.feePayer = object.feePayer ?? "";
+        message.feePayerSig = object.feePayerSig ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseExtensionOptionsWeb3Tx();
+        if (object.typedDataChainID !== undefined && object.typedDataChainID !== null) {
+            message.typedDataChainID = BigInt(object.typedDataChainID);
+        }
+        if (object.feePayer !== undefined && object.feePayer !== null) {
+            message.feePayer = object.feePayer;
+        }
+        if (object.feePayerSig !== undefined && object.feePayerSig !== null) {
+            message.feePayerSig = bytesFromBase64(object.feePayerSig);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.typedDataChainID = message.typedDataChainID !== BigInt(0) ? message.typedDataChainID?.toString() : undefined;
+        obj.feePayer = message.feePayer === "" ? undefined : message.feePayer;
+        obj.feePayerSig = message.feePayerSig ? base64FromBytes(message.feePayerSig) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ExtensionOptionsWeb3Tx.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ExtensionOptionsWeb3Tx.decode(message.value);
+    },
+    toProto(message) {
+        return ExtensionOptionsWeb3Tx.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.types.v1beta1.ExtensionOptionsWeb3Tx",
+            value: ExtensionOptionsWeb3Tx.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(ExtensionOptionsWeb3Tx.typeUrl, ExtensionOptionsWeb3Tx);

package/esm/injective/types/v1beta1/tx_response.js

@@ -0,0 +1,158 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+function createBaseTxResponseGenericMessage() {
+    return {
+        header: "",
+        data: new Uint8Array()
+    };
+}
+export const TxResponseGenericMessage = {
+    typeUrl: "/injective.types.v1beta1.TxResponseGenericMessage",
+    is(o) {
+        return o && (o.$typeUrl === TxResponseGenericMessage.typeUrl || typeof o.header === "string" && (o.data instanceof Uint8Array || typeof o.data === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === TxResponseGenericMessage.typeUrl || typeof o.header === "string" && (o.data instanceof Uint8Array || typeof o.data === "string"));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.header !== "") {
+            writer.uint32(10).string(message.header);
+        }
+        if (message.data.length !== 0) {
+            writer.uint32(18).bytes(message.data);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTxResponseGenericMessage();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.header = reader.string();
+                    break;
+                case 2:
+                    message.data = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseTxResponseGenericMessage();
+        message.header = object.header ?? "";
+        message.data = object.data ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseTxResponseGenericMessage();
+        if (object.header !== undefined && object.header !== null) {
+            message.header = object.header;
+        }
+        if (object.data !== undefined && object.data !== null) {
+            message.data = bytesFromBase64(object.data);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.header = message.header === "" ? undefined : message.header;
+        obj.data = message.data ? base64FromBytes(message.data) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return TxResponseGenericMessage.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return TxResponseGenericMessage.decode(message.value);
+    },
+    toProto(message) {
+        return TxResponseGenericMessage.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.types.v1beta1.TxResponseGenericMessage",
+            value: TxResponseGenericMessage.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(TxResponseGenericMessage.typeUrl, TxResponseGenericMessage);
+function createBaseTxResponseData() {
+    return {
+        messages: []
+    };
+}
+export const TxResponseData = {
+    typeUrl: "/injective.types.v1beta1.TxResponseData",
+    is(o) {
+        return o && (o.$typeUrl === TxResponseData.typeUrl || Array.isArray(o.messages) && (!o.messages.length || TxResponseGenericMessage.is(o.messages[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === TxResponseData.typeUrl || Array.isArray(o.messages) && (!o.messages.length || TxResponseGenericMessage.isAmino(o.messages[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.messages) {
+            TxResponseGenericMessage.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTxResponseData();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.messages.push(TxResponseGenericMessage.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseTxResponseData();
+        message.messages = object.messages?.map(e => TxResponseGenericMessage.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseTxResponseData();
+        message.messages = object.messages?.map(e => TxResponseGenericMessage.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.messages) {
+            obj.messages = message.messages.map(e => e ? TxResponseGenericMessage.toAmino(e) : undefined);
+        }
+        else {
+            obj.messages = message.messages;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return TxResponseData.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return TxResponseData.decode(message.value);
+    },
+    toProto(message) {
+        return TxResponseData.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.types.v1beta1.TxResponseData",
+            value: TxResponseData.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(TxResponseData.typeUrl, TxResponseData);