injectivejs 1.4.0 → 1.6.0

package/injective/wasmx/v1/events.d.ts

@@ -0,0 +1,107 @@
+import { FundingMode } from "./proposal";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+export interface EventContractExecution {
+    contractAddress: string;
+    response: Uint8Array;
+    otherError: string;
+    executionError: string;
+}
+export interface EventContractExecutionProtoMsg {
+    typeUrl: "/injective.wasmx.v1.EventContractExecution";
+    value: Uint8Array;
+}
+export interface EventContractExecutionAmino {
+    contract_address: string;
+    response: string;
+    other_error: string;
+    execution_error: string;
+}
+export interface EventContractExecutionAminoMsg {
+    type: "/injective.wasmx.v1.EventContractExecution";
+    value: EventContractExecutionAmino;
+}
+export interface EventContractRegistered {
+    contractAddress: string;
+    gasPrice: bigint;
+    shouldPinContract: boolean;
+    isMigrationAllowed: boolean;
+    codeId: bigint;
+    adminAddress: string;
+    granterAddress: string;
+    fundingMode: FundingMode;
+}
+export interface EventContractRegisteredProtoMsg {
+    typeUrl: "/injective.wasmx.v1.EventContractRegistered";
+    value: Uint8Array;
+}
+export interface EventContractRegisteredAmino {
+    contract_address: string;
+    gas_price: string;
+    should_pin_contract: boolean;
+    is_migration_allowed: boolean;
+    code_id: string;
+    admin_address: string;
+    granter_address: string;
+    funding_mode: FundingMode;
+}
+export interface EventContractRegisteredAminoMsg {
+    type: "/injective.wasmx.v1.EventContractRegistered";
+    value: EventContractRegisteredAmino;
+}
+export interface EventContractDeregistered {
+    contractAddress: string;
+}
+export interface EventContractDeregisteredProtoMsg {
+    typeUrl: "/injective.wasmx.v1.EventContractDeregistered";
+    value: Uint8Array;
+}
+export interface EventContractDeregisteredAmino {
+    contract_address: string;
+}
+export interface EventContractDeregisteredAminoMsg {
+    type: "/injective.wasmx.v1.EventContractDeregistered";
+    value: EventContractDeregisteredAmino;
+}
+export declare const EventContractExecution: {
+    typeUrl: string;
+    is(o: any): o is EventContractExecution;
+    isAmino(o: any): o is EventContractExecutionAmino;
+    encode(message: EventContractExecution, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventContractExecution;
+    fromPartial(object: DeepPartial<EventContractExecution>): EventContractExecution;
+    fromAmino(object: EventContractExecutionAmino): EventContractExecution;
+    toAmino(message: EventContractExecution): EventContractExecutionAmino;
+    fromAminoMsg(object: EventContractExecutionAminoMsg): EventContractExecution;
+    fromProtoMsg(message: EventContractExecutionProtoMsg): EventContractExecution;
+    toProto(message: EventContractExecution): Uint8Array;
+    toProtoMsg(message: EventContractExecution): EventContractExecutionProtoMsg;
+};
+export declare const EventContractRegistered: {
+    typeUrl: string;
+    is(o: any): o is EventContractRegistered;
+    isAmino(o: any): o is EventContractRegisteredAmino;
+    encode(message: EventContractRegistered, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventContractRegistered;
+    fromPartial(object: DeepPartial<EventContractRegistered>): EventContractRegistered;
+    fromAmino(object: EventContractRegisteredAmino): EventContractRegistered;
+    toAmino(message: EventContractRegistered): EventContractRegisteredAmino;
+    fromAminoMsg(object: EventContractRegisteredAminoMsg): EventContractRegistered;
+    fromProtoMsg(message: EventContractRegisteredProtoMsg): EventContractRegistered;
+    toProto(message: EventContractRegistered): Uint8Array;
+    toProtoMsg(message: EventContractRegistered): EventContractRegisteredProtoMsg;
+};
+export declare const EventContractDeregistered: {
+    typeUrl: string;
+    is(o: any): o is EventContractDeregistered;
+    isAmino(o: any): o is EventContractDeregisteredAmino;
+    encode(message: EventContractDeregistered, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventContractDeregistered;
+    fromPartial(object: DeepPartial<EventContractDeregistered>): EventContractDeregistered;
+    fromAmino(object: EventContractDeregisteredAmino): EventContractDeregistered;
+    toAmino(message: EventContractDeregistered): EventContractDeregisteredAmino;
+    fromAminoMsg(object: EventContractDeregisteredAminoMsg): EventContractDeregistered;
+    fromProtoMsg(message: EventContractDeregisteredProtoMsg): EventContractDeregistered;
+    toProto(message: EventContractDeregistered): Uint8Array;
+    toProtoMsg(message: EventContractDeregistered): EventContractDeregisteredProtoMsg;
+};

package/injective/wasmx/v1/events.js

@@ -0,0 +1,336 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventContractDeregistered = exports.EventContractRegistered = exports.EventContractExecution = void 0;
+const binary_1 = require("../../../binary");
+const helpers_1 = require("../../../helpers");
+const registry_1 = require("../../../registry");
+function createBaseEventContractExecution() {
+    return {
+        contractAddress: "",
+        response: new Uint8Array(),
+        otherError: "",
+        executionError: ""
+    };
+}
+exports.EventContractExecution = {
+    typeUrl: "/injective.wasmx.v1.EventContractExecution",
+    is(o) {
+        return o && (o.$typeUrl === exports.EventContractExecution.typeUrl || typeof o.contractAddress === "string" && (o.response instanceof Uint8Array || typeof o.response === "string") && typeof o.otherError === "string" && typeof o.executionError === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.EventContractExecution.typeUrl || typeof o.contract_address === "string" && (o.response instanceof Uint8Array || typeof o.response === "string") && typeof o.other_error === "string" && typeof o.execution_error === "string");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.contractAddress !== "") {
+            writer.uint32(10).string(message.contractAddress);
+        }
+        if (message.response.length !== 0) {
+            writer.uint32(18).bytes(message.response);
+        }
+        if (message.otherError !== "") {
+            writer.uint32(26).string(message.otherError);
+        }
+        if (message.executionError !== "") {
+            writer.uint32(34).string(message.executionError);
+        }
+        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 = createBaseEventContractExecution();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.contractAddress = reader.string();
+                    break;
+                case 2:
+                    message.response = reader.bytes();
+                    break;
+                case 3:
+                    message.otherError = reader.string();
+                    break;
+                case 4:
+                    message.executionError = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseEventContractExecution();
+        message.contractAddress = object.contractAddress ?? "";
+        message.response = object.response ?? new Uint8Array();
+        message.otherError = object.otherError ?? "";
+        message.executionError = object.executionError ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseEventContractExecution();
+        if (object.contract_address !== undefined && object.contract_address !== null) {
+            message.contractAddress = object.contract_address;
+        }
+        if (object.response !== undefined && object.response !== null) {
+            message.response = (0, helpers_1.bytesFromBase64)(object.response);
+        }
+        if (object.other_error !== undefined && object.other_error !== null) {
+            message.otherError = object.other_error;
+        }
+        if (object.execution_error !== undefined && object.execution_error !== null) {
+            message.executionError = object.execution_error;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.contract_address = message.contractAddress === "" ? undefined : message.contractAddress;
+        obj.response = message.response ? (0, helpers_1.base64FromBytes)(message.response) : undefined;
+        obj.other_error = message.otherError === "" ? undefined : message.otherError;
+        obj.execution_error = message.executionError === "" ? undefined : message.executionError;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.EventContractExecution.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.EventContractExecution.decode(message.value);
+    },
+    toProto(message) {
+        return exports.EventContractExecution.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.wasmx.v1.EventContractExecution",
+            value: exports.EventContractExecution.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.EventContractExecution.typeUrl, exports.EventContractExecution);
+function createBaseEventContractRegistered() {
+    return {
+        contractAddress: "",
+        gasPrice: BigInt(0),
+        shouldPinContract: false,
+        isMigrationAllowed: false,
+        codeId: BigInt(0),
+        adminAddress: "",
+        granterAddress: "",
+        fundingMode: 0
+    };
+}
+exports.EventContractRegistered = {
+    typeUrl: "/injective.wasmx.v1.EventContractRegistered",
+    is(o) {
+        return o && (o.$typeUrl === exports.EventContractRegistered.typeUrl || typeof o.contractAddress === "string" && typeof o.gasPrice === "bigint" && typeof o.shouldPinContract === "boolean" && typeof o.isMigrationAllowed === "boolean" && typeof o.codeId === "bigint" && typeof o.adminAddress === "string" && typeof o.granterAddress === "string" && (0, helpers_1.isSet)(o.fundingMode));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.EventContractRegistered.typeUrl || typeof o.contract_address === "string" && typeof o.gas_price === "bigint" && typeof o.should_pin_contract === "boolean" && typeof o.is_migration_allowed === "boolean" && typeof o.code_id === "bigint" && typeof o.admin_address === "string" && typeof o.granter_address === "string" && (0, helpers_1.isSet)(o.funding_mode));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.contractAddress !== "") {
+            writer.uint32(10).string(message.contractAddress);
+        }
+        if (message.gasPrice !== BigInt(0)) {
+            writer.uint32(24).uint64(message.gasPrice);
+        }
+        if (message.shouldPinContract === true) {
+            writer.uint32(32).bool(message.shouldPinContract);
+        }
+        if (message.isMigrationAllowed === true) {
+            writer.uint32(40).bool(message.isMigrationAllowed);
+        }
+        if (message.codeId !== BigInt(0)) {
+            writer.uint32(48).uint64(message.codeId);
+        }
+        if (message.adminAddress !== "") {
+            writer.uint32(58).string(message.adminAddress);
+        }
+        if (message.granterAddress !== "") {
+            writer.uint32(66).string(message.granterAddress);
+        }
+        if (message.fundingMode !== 0) {
+            writer.uint32(72).int32(message.fundingMode);
+        }
+        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 = createBaseEventContractRegistered();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.contractAddress = reader.string();
+                    break;
+                case 3:
+                    message.gasPrice = reader.uint64();
+                    break;
+                case 4:
+                    message.shouldPinContract = reader.bool();
+                    break;
+                case 5:
+                    message.isMigrationAllowed = reader.bool();
+                    break;
+                case 6:
+                    message.codeId = reader.uint64();
+                    break;
+                case 7:
+                    message.adminAddress = reader.string();
+                    break;
+                case 8:
+                    message.granterAddress = reader.string();
+                    break;
+                case 9:
+                    message.fundingMode = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseEventContractRegistered();
+        message.contractAddress = object.contractAddress ?? "";
+        message.gasPrice = object.gasPrice !== undefined && object.gasPrice !== null ? BigInt(object.gasPrice.toString()) : BigInt(0);
+        message.shouldPinContract = object.shouldPinContract ?? false;
+        message.isMigrationAllowed = object.isMigrationAllowed ?? false;
+        message.codeId = object.codeId !== undefined && object.codeId !== null ? BigInt(object.codeId.toString()) : BigInt(0);
+        message.adminAddress = object.adminAddress ?? "";
+        message.granterAddress = object.granterAddress ?? "";
+        message.fundingMode = object.fundingMode ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseEventContractRegistered();
+        if (object.contract_address !== undefined && object.contract_address !== null) {
+            message.contractAddress = object.contract_address;
+        }
+        if (object.gas_price !== undefined && object.gas_price !== null) {
+            message.gasPrice = BigInt(object.gas_price);
+        }
+        if (object.should_pin_contract !== undefined && object.should_pin_contract !== null) {
+            message.shouldPinContract = object.should_pin_contract;
+        }
+        if (object.is_migration_allowed !== undefined && object.is_migration_allowed !== null) {
+            message.isMigrationAllowed = object.is_migration_allowed;
+        }
+        if (object.code_id !== undefined && object.code_id !== null) {
+            message.codeId = BigInt(object.code_id);
+        }
+        if (object.admin_address !== undefined && object.admin_address !== null) {
+            message.adminAddress = object.admin_address;
+        }
+        if (object.granter_address !== undefined && object.granter_address !== null) {
+            message.granterAddress = object.granter_address;
+        }
+        if (object.funding_mode !== undefined && object.funding_mode !== null) {
+            message.fundingMode = object.funding_mode;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.contract_address = message.contractAddress === "" ? undefined : message.contractAddress;
+        obj.gas_price = message.gasPrice !== BigInt(0) ? message.gasPrice?.toString() : undefined;
+        obj.should_pin_contract = message.shouldPinContract === false ? undefined : message.shouldPinContract;
+        obj.is_migration_allowed = message.isMigrationAllowed === false ? undefined : message.isMigrationAllowed;
+        obj.code_id = message.codeId !== BigInt(0) ? message.codeId?.toString() : undefined;
+        obj.admin_address = message.adminAddress === "" ? undefined : message.adminAddress;
+        obj.granter_address = message.granterAddress === "" ? undefined : message.granterAddress;
+        obj.funding_mode = message.fundingMode === 0 ? undefined : message.fundingMode;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.EventContractRegistered.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.EventContractRegistered.decode(message.value);
+    },
+    toProto(message) {
+        return exports.EventContractRegistered.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.wasmx.v1.EventContractRegistered",
+            value: exports.EventContractRegistered.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.EventContractRegistered.typeUrl, exports.EventContractRegistered);
+function createBaseEventContractDeregistered() {
+    return {
+        contractAddress: ""
+    };
+}
+exports.EventContractDeregistered = {
+    typeUrl: "/injective.wasmx.v1.EventContractDeregistered",
+    is(o) {
+        return o && (o.$typeUrl === exports.EventContractDeregistered.typeUrl || typeof o.contractAddress === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.EventContractDeregistered.typeUrl || typeof o.contract_address === "string");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.contractAddress !== "") {
+            writer.uint32(10).string(message.contractAddress);
+        }
+        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 = createBaseEventContractDeregistered();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.contractAddress = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseEventContractDeregistered();
+        message.contractAddress = object.contractAddress ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseEventContractDeregistered();
+        if (object.contract_address !== undefined && object.contract_address !== null) {
+            message.contractAddress = object.contract_address;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.contract_address = message.contractAddress === "" ? undefined : message.contractAddress;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.EventContractDeregistered.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.EventContractDeregistered.decode(message.value);
+    },
+    toProto(message) {
+        return exports.EventContractDeregistered.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.wasmx.v1.EventContractDeregistered",
+            value: exports.EventContractDeregistered.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.EventContractDeregistered.typeUrl, exports.EventContractDeregistered);

package/injective/wasmx/v1/genesis.d.ts

@@ -0,0 +1,75 @@
+import { RegisteredContract, RegisteredContractAmino, Params, ParamsAmino } from "./wasmx";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+export interface RegisteredContractWithAddress {
+    address: string;
+    registeredContract?: RegisteredContract;
+}
+export interface RegisteredContractWithAddressProtoMsg {
+    typeUrl: "/injective.wasmx.v1.RegisteredContractWithAddress";
+    value: Uint8Array;
+}
+export interface RegisteredContractWithAddressAmino {
+    address: string;
+    registered_contract?: RegisteredContractAmino;
+}
+export interface RegisteredContractWithAddressAminoMsg {
+    type: "/injective.wasmx.v1.RegisteredContractWithAddress";
+    value: RegisteredContractWithAddressAmino;
+}
+/** GenesisState defines the wasmx module's genesis state. */
+export interface GenesisState {
+    /** params defines all the parameters of related to wasmx. */
+    params: Params;
+    /**
+     * registered_contracts is an array containing the genesis registered
+     * contracts
+     */
+    registeredContracts: RegisteredContractWithAddress[];
+}
+export interface GenesisStateProtoMsg {
+    typeUrl: "/injective.wasmx.v1.GenesisState";
+    value: Uint8Array;
+}
+/** GenesisState defines the wasmx module's genesis state. */
+export interface GenesisStateAmino {
+    /** params defines all the parameters of related to wasmx. */
+    params: ParamsAmino;
+    /**
+     * registered_contracts is an array containing the genesis registered
+     * contracts
+     */
+    registered_contracts: RegisteredContractWithAddressAmino[];
+}
+export interface GenesisStateAminoMsg {
+    type: "/injective.wasmx.v1.GenesisState";
+    value: GenesisStateAmino;
+}
+export declare const RegisteredContractWithAddress: {
+    typeUrl: string;
+    is(o: any): o is RegisteredContractWithAddress;
+    isAmino(o: any): o is RegisteredContractWithAddressAmino;
+    encode(message: RegisteredContractWithAddress, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RegisteredContractWithAddress;
+    fromPartial(object: DeepPartial<RegisteredContractWithAddress>): RegisteredContractWithAddress;
+    fromAmino(object: RegisteredContractWithAddressAmino): RegisteredContractWithAddress;
+    toAmino(message: RegisteredContractWithAddress): RegisteredContractWithAddressAmino;
+    fromAminoMsg(object: RegisteredContractWithAddressAminoMsg): RegisteredContractWithAddress;
+    fromProtoMsg(message: RegisteredContractWithAddressProtoMsg): RegisteredContractWithAddress;
+    toProto(message: RegisteredContractWithAddress): Uint8Array;
+    toProtoMsg(message: RegisteredContractWithAddress): RegisteredContractWithAddressProtoMsg;
+};
+export declare const GenesisState: {
+    typeUrl: string;
+    is(o: any): o is GenesisState;
+    isAmino(o: any): o is GenesisStateAmino;
+    encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): GenesisState;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+    fromAmino(object: GenesisStateAmino): GenesisState;
+    toAmino(message: GenesisState): GenesisStateAmino;
+    fromAminoMsg(object: GenesisStateAminoMsg): GenesisState;
+    fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
+    toProto(message: GenesisState): Uint8Array;
+    toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
+};