injectivejs 1.4.0 → 1.6.0

package/injective/wasmx/v1/tx.rpc.func.d.ts

@@ -0,0 +1,8 @@
+import { SigningClientResolver } from "../../../helper-func-types";
+import { MsgUpdateContract, MsgActivateContract, MsgDeactivateContract, MsgExecuteContractCompat, MsgUpdateParams, MsgRegisterContract } from "./tx";
+export declare const createUpdateRegistryContractParams: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgUpdateContract, fee: import("../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../helper-func-types").DeliverTxResponse>;
+export declare const createActivateRegistryContract: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgActivateContract, fee: import("../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../helper-func-types").DeliverTxResponse>;
+export declare const createDeactivateRegistryContract: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgDeactivateContract, fee: import("../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../helper-func-types").DeliverTxResponse>;
+export declare const createExecuteContractCompat: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgExecuteContractCompat, 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>;
+export declare const createRegisterContract: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgRegisterContract, fee: import("../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../helper-func-types").DeliverTxResponse>;

package/injective/wasmx/v1/tx.rpc.func.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRegisterContract = exports.createUpdateParams = exports.createExecuteContractCompat = exports.createDeactivateRegistryContract = exports.createActivateRegistryContract = exports.createUpdateRegistryContractParams = void 0;
+const helper_func_types_1 = require("../../../helper-func-types");
+const utils_1 = require("@interchainjs/cosmos/utils");
+const tx_1 = require("./tx");
+const createUpdateRegistryContractParams = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgUpdateContract.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgUpdateContract),
+    converters: (0, utils_1.toConverters)(tx_1.MsgUpdateContract)
+});
+exports.createUpdateRegistryContractParams = createUpdateRegistryContractParams;
+const createActivateRegistryContract = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgActivateContract.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgActivateContract),
+    converters: (0, utils_1.toConverters)(tx_1.MsgActivateContract)
+});
+exports.createActivateRegistryContract = createActivateRegistryContract;
+const createDeactivateRegistryContract = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgDeactivateContract.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgDeactivateContract),
+    converters: (0, utils_1.toConverters)(tx_1.MsgDeactivateContract)
+});
+exports.createDeactivateRegistryContract = createDeactivateRegistryContract;
+const createExecuteContractCompat = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgExecuteContractCompat.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgExecuteContractCompat),
+    converters: (0, utils_1.toConverters)(tx_1.MsgExecuteContractCompat)
+});
+exports.createExecuteContractCompat = createExecuteContractCompat;
+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;
+const createRegisterContract = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgRegisterContract.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgRegisterContract),
+    converters: (0, utils_1.toConverters)(tx_1.MsgRegisterContract)
+});
+exports.createRegisterContract = createRegisterContract;

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

@@ -0,0 +1,140 @@
+import { AccessConfig, AccessConfigAmino } from "../../../cosmwasm/wasm/v1/types";
+import { FundingMode } from "./proposal";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+export interface Params {
+    /**
+     * Set the status to active to indicate that contracts can be executed in
+     * begin blocker.
+     */
+    isExecutionEnabled: boolean;
+    /**
+     * Maximum aggregate total gas to be used for the contract executions in the
+     * BeginBlocker.
+     */
+    maxBeginBlockTotalGas: bigint;
+    /**
+     * the maximum gas limit each individual contract can consume in the
+     * BeginBlocker.
+     */
+    maxContractGasLimit: bigint;
+    /**
+     * min_gas_price defines the minimum gas price the contracts must pay to be
+     * executed in the BeginBlocker.
+     */
+    minGasPrice: bigint;
+    registerContractAccess: AccessConfig;
+}
+export interface ParamsProtoMsg {
+    typeUrl: "/injective.wasmx.v1.Params";
+    value: Uint8Array;
+}
+export interface ParamsAmino {
+    /**
+     * Set the status to active to indicate that contracts can be executed in
+     * begin blocker.
+     */
+    is_execution_enabled: boolean;
+    /**
+     * Maximum aggregate total gas to be used for the contract executions in the
+     * BeginBlocker.
+     */
+    max_begin_block_total_gas: string;
+    /**
+     * the maximum gas limit each individual contract can consume in the
+     * BeginBlocker.
+     */
+    max_contract_gas_limit: string;
+    /**
+     * min_gas_price defines the minimum gas price the contracts must pay to be
+     * executed in the BeginBlocker.
+     */
+    min_gas_price: string;
+    register_contract_access: AccessConfigAmino;
+}
+export interface ParamsAminoMsg {
+    type: "wasmx/Params";
+    value: ParamsAmino;
+}
+export interface RegisteredContract {
+    /** limit of gas per BB execution */
+    gasLimit: bigint;
+    /** gas price that contract is willing to pay for execution in BeginBlocker */
+    gasPrice: bigint;
+    /** is contract currently active */
+    isExecutable: boolean;
+    /**
+     * code_id that is allowed to be executed (to prevent malicious updates) - if
+     * nil/0 any code_id can be executed
+     */
+    codeId?: bigint;
+    /** optional - admin addr that is allowed to update contract data */
+    adminAddress?: string;
+    /**
+     * Optional: address of the contract granting fee
+     * Must be set if fund_mode is GrantOnly
+     */
+    granterAddress?: string;
+    /** funding mode */
+    fundMode: FundingMode;
+}
+export interface RegisteredContractProtoMsg {
+    typeUrl: "/injective.wasmx.v1.RegisteredContract";
+    value: Uint8Array;
+}
+export interface RegisteredContractAmino {
+    /** limit of gas per BB execution */
+    gas_limit: string;
+    /** gas price that contract is willing to pay for execution in BeginBlocker */
+    gas_price: string;
+    /** is contract currently active */
+    is_executable: boolean;
+    /**
+     * code_id that is allowed to be executed (to prevent malicious updates) - if
+     * nil/0 any code_id can be executed
+     */
+    code_id?: string;
+    /** optional - admin addr that is allowed to update contract data */
+    admin_address?: string;
+    /**
+     * Optional: address of the contract granting fee
+     * Must be set if fund_mode is GrantOnly
+     */
+    granter_address?: string;
+    /** funding mode */
+    fund_mode: FundingMode;
+}
+export interface RegisteredContractAminoMsg {
+    type: "/injective.wasmx.v1.RegisteredContract";
+    value: RegisteredContractAmino;
+}
+export declare const Params: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is Params;
+    isAmino(o: any): o is ParamsAmino;
+    encode(message: Params, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Params;
+    fromPartial(object: DeepPartial<Params>): Params;
+    fromAmino(object: ParamsAmino): Params;
+    toAmino(message: Params): ParamsAmino;
+    fromAminoMsg(object: ParamsAminoMsg): Params;
+    toAminoMsg(message: Params): ParamsAminoMsg;
+    fromProtoMsg(message: ParamsProtoMsg): Params;
+    toProto(message: Params): Uint8Array;
+    toProtoMsg(message: Params): ParamsProtoMsg;
+};
+export declare const RegisteredContract: {
+    typeUrl: string;
+    is(o: any): o is RegisteredContract;
+    isAmino(o: any): o is RegisteredContractAmino;
+    encode(message: RegisteredContract, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RegisteredContract;
+    fromPartial(object: DeepPartial<RegisteredContract>): RegisteredContract;
+    fromAmino(object: RegisteredContractAmino): RegisteredContract;
+    toAmino(message: RegisteredContract): RegisteredContractAmino;
+    fromAminoMsg(object: RegisteredContractAminoMsg): RegisteredContract;
+    fromProtoMsg(message: RegisteredContractProtoMsg): RegisteredContract;
+    toProto(message: RegisteredContract): Uint8Array;
+    toProtoMsg(message: RegisteredContract): RegisteredContractProtoMsg;
+};

package/injective/wasmx/v1/wasmx.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegisteredContract = exports.Params = void 0;
+const types_1 = require("../../../cosmwasm/wasm/v1/types");
+const binary_1 = require("../../../binary");
+const helpers_1 = require("../../../helpers");
+const registry_1 = require("../../../registry");
+function createBaseParams() {
+    return {
+        isExecutionEnabled: false,
+        maxBeginBlockTotalGas: BigInt(0),
+        maxContractGasLimit: BigInt(0),
+        minGasPrice: BigInt(0),
+        registerContractAccess: types_1.AccessConfig.fromPartial({})
+    };
+}
+exports.Params = {
+    typeUrl: "/injective.wasmx.v1.Params",
+    aminoType: "wasmx/Params",
+    is(o) {
+        return o && (o.$typeUrl === exports.Params.typeUrl || typeof o.isExecutionEnabled === "boolean" && typeof o.maxBeginBlockTotalGas === "bigint" && typeof o.maxContractGasLimit === "bigint" && typeof o.minGasPrice === "bigint" && types_1.AccessConfig.is(o.registerContractAccess));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.Params.typeUrl || typeof o.is_execution_enabled === "boolean" && typeof o.max_begin_block_total_gas === "bigint" && typeof o.max_contract_gas_limit === "bigint" && typeof o.min_gas_price === "bigint" && types_1.AccessConfig.isAmino(o.register_contract_access));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.isExecutionEnabled === true) {
+            writer.uint32(8).bool(message.isExecutionEnabled);
+        }
+        if (message.maxBeginBlockTotalGas !== BigInt(0)) {
+            writer.uint32(16).uint64(message.maxBeginBlockTotalGas);
+        }
+        if (message.maxContractGasLimit !== BigInt(0)) {
+            writer.uint32(24).uint64(message.maxContractGasLimit);
+        }
+        if (message.minGasPrice !== BigInt(0)) {
+            writer.uint32(32).uint64(message.minGasPrice);
+        }
+        if (message.registerContractAccess !== undefined) {
+            types_1.AccessConfig.encode(message.registerContractAccess, writer.uint32(42).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 = createBaseParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.isExecutionEnabled = reader.bool();
+                    break;
+                case 2:
+                    message.maxBeginBlockTotalGas = reader.uint64();
+                    break;
+                case 3:
+                    message.maxContractGasLimit = reader.uint64();
+                    break;
+                case 4:
+                    message.minGasPrice = reader.uint64();
+                    break;
+                case 5:
+                    message.registerContractAccess = types_1.AccessConfig.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseParams();
+        message.isExecutionEnabled = object.isExecutionEnabled ?? false;
+        message.maxBeginBlockTotalGas = object.maxBeginBlockTotalGas !== undefined && object.maxBeginBlockTotalGas !== null ? BigInt(object.maxBeginBlockTotalGas.toString()) : BigInt(0);
+        message.maxContractGasLimit = object.maxContractGasLimit !== undefined && object.maxContractGasLimit !== null ? BigInt(object.maxContractGasLimit.toString()) : BigInt(0);
+        message.minGasPrice = object.minGasPrice !== undefined && object.minGasPrice !== null ? BigInt(object.minGasPrice.toString()) : BigInt(0);
+        message.registerContractAccess = object.registerContractAccess !== undefined && object.registerContractAccess !== null ? types_1.AccessConfig.fromPartial(object.registerContractAccess) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseParams();
+        if (object.is_execution_enabled !== undefined && object.is_execution_enabled !== null) {
+            message.isExecutionEnabled = object.is_execution_enabled;
+        }
+        if (object.max_begin_block_total_gas !== undefined && object.max_begin_block_total_gas !== null) {
+            message.maxBeginBlockTotalGas = BigInt(object.max_begin_block_total_gas);
+        }
+        if (object.max_contract_gas_limit !== undefined && object.max_contract_gas_limit !== null) {
+            message.maxContractGasLimit = BigInt(object.max_contract_gas_limit);
+        }
+        if (object.min_gas_price !== undefined && object.min_gas_price !== null) {
+            message.minGasPrice = BigInt(object.min_gas_price);
+        }
+        if (object.register_contract_access !== undefined && object.register_contract_access !== null) {
+            message.registerContractAccess = types_1.AccessConfig.fromAmino(object.register_contract_access);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.is_execution_enabled = message.isExecutionEnabled === false ? undefined : message.isExecutionEnabled;
+        obj.max_begin_block_total_gas = message.maxBeginBlockTotalGas !== BigInt(0) ? message.maxBeginBlockTotalGas?.toString() : undefined;
+        obj.max_contract_gas_limit = message.maxContractGasLimit !== BigInt(0) ? message.maxContractGasLimit?.toString() : undefined;
+        obj.min_gas_price = message.minGasPrice !== BigInt(0) ? message.minGasPrice?.toString() : undefined;
+        obj.register_contract_access = message.registerContractAccess ? types_1.AccessConfig.toAmino(message.registerContractAccess) : types_1.AccessConfig.toAmino(types_1.AccessConfig.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Params.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "wasmx/Params",
+            value: exports.Params.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.Params.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Params.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.wasmx.v1.Params",
+            value: exports.Params.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.Params.typeUrl, exports.Params);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.Params.aminoType, exports.Params.typeUrl);
+function createBaseRegisteredContract() {
+    return {
+        gasLimit: BigInt(0),
+        gasPrice: BigInt(0),
+        isExecutable: false,
+        codeId: undefined,
+        adminAddress: undefined,
+        granterAddress: undefined,
+        fundMode: 0
+    };
+}
+exports.RegisteredContract = {
+    typeUrl: "/injective.wasmx.v1.RegisteredContract",
+    is(o) {
+        return o && (o.$typeUrl === exports.RegisteredContract.typeUrl || typeof o.gasLimit === "bigint" && typeof o.gasPrice === "bigint" && typeof o.isExecutable === "boolean" && (0, helpers_1.isSet)(o.fundMode));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.RegisteredContract.typeUrl || typeof o.gas_limit === "bigint" && typeof o.gas_price === "bigint" && typeof o.is_executable === "boolean" && (0, helpers_1.isSet)(o.fund_mode));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.gasLimit !== BigInt(0)) {
+            writer.uint32(8).uint64(message.gasLimit);
+        }
+        if (message.gasPrice !== BigInt(0)) {
+            writer.uint32(16).uint64(message.gasPrice);
+        }
+        if (message.isExecutable === true) {
+            writer.uint32(24).bool(message.isExecutable);
+        }
+        if (message.codeId !== undefined) {
+            writer.uint32(32).uint64(message.codeId);
+        }
+        if (message.adminAddress !== undefined) {
+            writer.uint32(42).string(message.adminAddress);
+        }
+        if (message.granterAddress !== undefined) {
+            writer.uint32(50).string(message.granterAddress);
+        }
+        if (message.fundMode !== 0) {
+            writer.uint32(56).int32(message.fundMode);
+        }
+        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 = createBaseRegisteredContract();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.gasLimit = reader.uint64();
+                    break;
+                case 2:
+                    message.gasPrice = reader.uint64();
+                    break;
+                case 3:
+                    message.isExecutable = reader.bool();
+                    break;
+                case 4:
+                    message.codeId = reader.uint64();
+                    break;
+                case 5:
+                    message.adminAddress = reader.string();
+                    break;
+                case 6:
+                    message.granterAddress = reader.string();
+                    break;
+                case 7:
+                    message.fundMode = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseRegisteredContract();
+        message.gasLimit = object.gasLimit !== undefined && object.gasLimit !== null ? BigInt(object.gasLimit.toString()) : BigInt(0);
+        message.gasPrice = object.gasPrice !== undefined && object.gasPrice !== null ? BigInt(object.gasPrice.toString()) : BigInt(0);
+        message.isExecutable = object.isExecutable ?? false;
+        message.codeId = object.codeId !== undefined && object.codeId !== null ? BigInt(object.codeId.toString()) : undefined;
+        message.adminAddress = object.adminAddress ?? undefined;
+        message.granterAddress = object.granterAddress ?? undefined;
+        message.fundMode = object.fundMode ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseRegisteredContract();
+        if (object.gas_limit !== undefined && object.gas_limit !== null) {
+            message.gasLimit = BigInt(object.gas_limit);
+        }
+        if (object.gas_price !== undefined && object.gas_price !== null) {
+            message.gasPrice = BigInt(object.gas_price);
+        }
+        if (object.is_executable !== undefined && object.is_executable !== null) {
+            message.isExecutable = object.is_executable;
+        }
+        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.fund_mode !== undefined && object.fund_mode !== null) {
+            message.fundMode = object.fund_mode;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.gas_limit = message.gasLimit !== BigInt(0) ? message.gasLimit?.toString() : undefined;
+        obj.gas_price = message.gasPrice !== BigInt(0) ? message.gasPrice?.toString() : undefined;
+        obj.is_executable = message.isExecutable === false ? undefined : message.isExecutable;
+        obj.code_id = message.codeId !== BigInt(0) ? message.codeId?.toString() : undefined;
+        obj.admin_address = message.adminAddress === null ? undefined : message.adminAddress;
+        obj.granter_address = message.granterAddress === null ? undefined : message.granterAddress;
+        obj.fund_mode = message.fundMode === 0 ? undefined : message.fundMode;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.RegisteredContract.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.RegisteredContract.decode(message.value);
+    },
+    toProto(message) {
+        return exports.RegisteredContract.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.wasmx.v1.RegisteredContract",
+            value: exports.RegisteredContract.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.RegisteredContract.typeUrl, exports.RegisteredContract);

package/package.json

@@ -1,87 +1,49 @@
 {
   "name": "injectivejs",
-  "version": "1.4.0",
-  "description": "injective",
-  "author": "Dan Lynch <pyramation@gmail.com>",
-  "homepage": "https://github.com/cosmology-tech/injectivejs#readme",
-  "license": "SEE LICENSE IN LICENSE",
-  "main": "main/index.js",
-  "typings": "types/index.d.ts",
-  "directories": {
-    "lib": "src",
-    "test": "__tests__"
-  },
-  "files": [
-    "types",
-    "main"
-  ],
-  "scripts": {
-    "build": "cross-env BABEL_ENV=production babel src --out-dir main --delete-dir-on-start --extensions \".tsx,.ts,.js\"",
-    "build:ts": "tsc --project ./tsconfig.json",
-    "buidl": "npm run build && npm run build:ts",
-    "codegen": "cross-env NODE_ENV=development babel-node scripts/codegen.js",
-    "prepare": "npm run build",
-    "dev": "cross-env NODE_ENV=development babel-node src/index --extensions \".tsx,.ts,.js\"",
-    "watch": "cross-env NODE_ENV=development babel-watch src/index --extensions \".tsx,.ts,.js\"",
-    "lint": "eslint src --fix",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:debug": "node --inspect node_modules/.bin/jest --runInBand"
+  "version": "1.6.0",
+  "description": "Injectivejs is a JavaScript library for interacting with injective sdk.",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "author": "Cosmology <developers@cosmology.zone>",
+  "homepage": "https://github.com/cosmology-tech/interchainjs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cosmology-tech/interchainjs"
   },
+  "license": "MIT",
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "directory": "dist"
   },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/cosmology-tech/injectivejs"
+  "scripts": {
+    "copy": "copyfiles -f ../../LICENSE-MIT ../../LICENSE-Apache README.md package.json dist",
+    "clean": "rimraf dist/**",
+    "build": "npm run clean; tsc; tsc -p tsconfig.esm.json; npm run copy",
+    "build:dev": "npm run clean; tsc --declarationMap; tsc -p tsconfig.esm.json; npm run copy",
+    "lint": "eslint . --fix",
+    "prepare": "npm run build"
   },
-  "keywords": [],
-  "bugs": {
-    "url": "https://github.com/cosmology-tech/injectivejs/issues"
+  "dependencies": {
+    "@interchainjs/cosmos": "1.6.0",
+    "@interchainjs/cosmos-types": "1.6.0",
+    "@interchainjs/types": "1.6.0",
+    "@interchainjs/utils": "1.6.0",
+    "@noble/hashes": "^1.3.1",
+    "decimal.js": "^10.4.3"
   },
   "devDependencies": {
-    "@babel/cli": "7.18.10",
-    "@babel/core": "7.18.10",
-    "@babel/eslint-parser": "^7.18.9",
-    "@babel/node": "^7.18.10",
-    "@babel/plugin-proposal-class-properties": "7.18.6",
-    "@babel/plugin-proposal-export-default-from": "7.18.10",
-    "@babel/plugin-proposal-nullish-coalescing-operator": "7.18.6",
-    "@babel/plugin-proposal-numeric-separator": "7.18.6",
-    "@babel/plugin-proposal-object-rest-spread": "7.18.9",
-    "@babel/plugin-proposal-optional-chaining": "7.18.9",
-    "@babel/plugin-transform-runtime": "7.18.10",
-    "@babel/preset-env": "7.18.10",
-    "@babel/preset-typescript": "^7.18.6",
-    "@osmonauts/telescope": "^0.35.0",
-    "@protobufs/cosmos": "^0.0.11",
-    "@protobufs/cosmwasm": "^0.0.11",
-    "@protobufs/ibc": "^0.0.11",
-    "@types/jest": "^28.1.6",
-    "babel-core": "7.0.0-bridge.0",
-    "babel-jest": "28.1.3",
-    "babel-watch": "^7.0.0",
-    "cross-env": "^7.0.2",
-    "eslint": "8.21.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-prettier": "^4.2.1",
-    "jest": "^28.1.3",
-    "jest-in-case": "^1.0.2",
-    "long": "^5.2.0",
-    "prettier": "^2.7.1",
-    "regenerator-runtime": "^0.13.7",
-    "rimraf": "^3.0.2",
-    "ts-jest": "^28.0.7",
-    "typescript": "^4.7.4"
+    "@tanstack/react-query": "4.29.1"
   },
-  "dependencies": {
-    "@babel/runtime": "^7.18.9",
-    "@cosmjs/amino": "0.29.0",
-    "@cosmjs/proto-signing": "0.29.0",
-    "@cosmjs/stargate": "0.29.0",
-    "@cosmjs/tendermint-rpc": "^0.29.0",
-    "@osmonauts/helpers": "^0.6.0",
-    "@osmonauts/lcd": "^0.6.0",
-    "protobufjs": "^6.11.2"
-  }
+  "peerDependencies": {
+    "@tanstack/react-query": "4.29.1"
+  },
+  "keywords": [
+    "cosmos",
+    "blockchain",
+    "transaction",
+    "cosmjs",
+    "wallet"
+  ],
+  "gitHead": "d2d4a11d1c58cc82be572dd9a2103c3dc94f2cef"
 }

package/registry.d.ts

@@ -0,0 +1,33 @@
+/**
+* This file and any referenced files were automatically generated by @cosmology/telescope@1.10.11
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+import { BinaryReader } from "./binary";
+import { Any, AnyAmino } from "./google/protobuf/any";
+import { TelescopeGeneratedCodec } from "./types";
+export declare class GlobalDecoderRegistry {
+    static registry: {
+        [key: string]: TelescopeGeneratedCodec<any, any, any>;
+    };
+    static aminoProtoMapping: {
+        [key: string]: string;
+    };
+    static registerAminoProtoMapping(aminoType: string, typeUrl: string): void;
+    static register<T, SDK, Amino>(key: string, decoder: TelescopeGeneratedCodec<T, SDK, Amino>): void;
+    static getDecoder<T, SDK, Amino>(key: string): TelescopeGeneratedCodec<T, SDK, Amino>;
+    static getDecoderByInstance<T, SDK, Amino>(obj: unknown): TelescopeGeneratedCodec<T, SDK, Amino> | null;
+    static getDecoderByAminoType<T, SDK, Amino>(type: string): TelescopeGeneratedCodec<T, SDK, Amino> | null;
+    static wrapAny(obj: unknown): Any;
+    static unwrapAny<T, SDK, Amino>(input: BinaryReader | Uint8Array | Any): Any | T;
+    static fromJSON<T>(object: any): T;
+    static toJSON<T>(message: T): any;
+    static fromPartial<T>(object: unknown): T;
+    static fromSDK<T = unknown, SDK = unknown>(object: SDK): T;
+    static fromSDKJSON<SDK = unknown>(object: any): SDK;
+    static toSDK<T = unknown, SDK = unknown>(object: T): SDK;
+    static fromAmino<T = unknown, Amino = unknown>(object: Amino): T;
+    static fromAminoMsg<T = unknown, Amino = unknown>(object: AnyAmino): T;
+    static toAmino<T = unknown, Amino = unknown>(object: T): Amino;
+    static toAminoMsg<T = unknown, Amino = unknown>(object: T): AnyAmino;
+}