juno-network 0.0.2

package/types/codegen/JunoSwap.react-query.d.ts

@@ -0,0 +1,128 @@
+/**
+* This file was automatically generated by @cosmwasm/ts-codegen@0.10.0.
+* DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+* and run the @cosmwasm/ts-codegen generate command to regenerate this file.
+*/
+import { UseQueryOptions, UseMutationOptions } from "@tanstack/react-query";
+import { ExecuteResult } from "@cosmjs/cosmwasm-stargate";
+import { StdFee, Coin } from "@cosmjs/amino";
+import { Uint128, BalanceResponse, Expiration, TokenSelect, Addr, InfoResponse, Token1ForToken2PriceResponse, Token2ForToken1PriceResponse } from "./JunoSwap.types";
+import { JunoSwapQueryClient, JunoSwapClient } from "./JunoSwap.client";
+export interface JunoSwapReactQuery<TResponse> {
+    client: JunoSwapQueryClient | undefined;
+    options?: Omit<UseQueryOptions<TResponse, Error, TResponse, (string | undefined)[]>, "'queryKey' | 'queryFn' | 'initialData'"> & {
+        initialData?: undefined;
+    };
+}
+export interface JunoSwapToken2ForToken1PriceQuery extends JunoSwapReactQuery<Token2ForToken1PriceResponse> {
+    args: {
+        token2Amount: Uint128;
+    };
+}
+export declare function useJunoSwapToken2ForToken1PriceQuery({ client, args, options }: JunoSwapToken2ForToken1PriceQuery): any;
+export interface JunoSwapToken1ForToken2PriceQuery extends JunoSwapReactQuery<Token1ForToken2PriceResponse> {
+    args: {
+        token1Amount: Uint128;
+    };
+}
+export declare function useJunoSwapToken1ForToken2PriceQuery({ client, args, options }: JunoSwapToken1ForToken2PriceQuery): any;
+export interface JunoSwapInfoQuery extends JunoSwapReactQuery<InfoResponse> {
+}
+export declare function useJunoSwapInfoQuery({ client, options }: JunoSwapInfoQuery): any;
+export interface JunoSwapBalanceQuery extends JunoSwapReactQuery<BalanceResponse> {
+    args: {
+        address: string;
+    };
+}
+export declare function useJunoSwapBalanceQuery({ client, args, options }: JunoSwapBalanceQuery): any;
+export interface JunoSwapSwapToMutation {
+    client: JunoSwapClient;
+    msg: {
+        expiration?: Expiration;
+        inputAmount: Uint128;
+        inputToken: TokenSelect;
+        minToken: Uint128;
+        recipient: Addr;
+    };
+    args?: {
+        fee?: number | StdFee | "auto";
+        memo?: string;
+        funds?: Coin[];
+    };
+}
+export declare function useJunoSwapSwapToMutation(options?: Omit<UseMutationOptions<ExecuteResult, Error, JunoSwapSwapToMutation>, "mutationFn">): any;
+export interface JunoSwapMultiContractSwapMutation {
+    client: JunoSwapClient;
+    msg: {
+        expiration?: Expiration;
+        inputToken: TokenSelect;
+        inputTokenAmount: Uint128;
+        outputAmmAddress: Addr;
+        outputMinToken: Uint128;
+        outputToken: TokenSelect;
+    };
+    args?: {
+        fee?: number | StdFee | "auto";
+        memo?: string;
+        funds?: Coin[];
+    };
+}
+export declare function useJunoSwapMultiContractSwapMutation(options?: Omit<UseMutationOptions<ExecuteResult, Error, JunoSwapMultiContractSwapMutation>, "mutationFn">): any;
+export interface JunoSwapSwapToken2ForToken1Mutation {
+    client: JunoSwapClient;
+    msg: {
+        expiration?: Expiration;
+        minToken1: Uint128;
+        token2Amount: Uint128;
+    };
+    args?: {
+        fee?: number | StdFee | "auto";
+        memo?: string;
+        funds?: Coin[];
+    };
+}
+export declare function useJunoSwapSwapToken2ForToken1Mutation(options?: Omit<UseMutationOptions<ExecuteResult, Error, JunoSwapSwapToken2ForToken1Mutation>, "mutationFn">): any;
+export interface JunoSwapSwapToken1ForToken2Mutation {
+    client: JunoSwapClient;
+    msg: {
+        expiration?: Expiration;
+        minToken2: Uint128;
+        token1Amount: Uint128;
+    };
+    args?: {
+        fee?: number | StdFee | "auto";
+        memo?: string;
+        funds?: Coin[];
+    };
+}
+export declare function useJunoSwapSwapToken1ForToken2Mutation(options?: Omit<UseMutationOptions<ExecuteResult, Error, JunoSwapSwapToken1ForToken2Mutation>, "mutationFn">): any;
+export interface JunoSwapRemoveLiquidityMutation {
+    client: JunoSwapClient;
+    msg: {
+        amount: Uint128;
+        expiration?: Expiration;
+        minToken1: Uint128;
+        minToken2: Uint128;
+    };
+    args?: {
+        fee?: number | StdFee | "auto";
+        memo?: string;
+        funds?: Coin[];
+    };
+}
+export declare function useJunoSwapRemoveLiquidityMutation(options?: Omit<UseMutationOptions<ExecuteResult, Error, JunoSwapRemoveLiquidityMutation>, "mutationFn">): any;
+export interface JunoSwapAddLiquidityMutation {
+    client: JunoSwapClient;
+    msg: {
+        expiration?: Expiration;
+        maxToken2: Uint128;
+        minLiquidity: Uint128;
+        token1Amount: Uint128;
+    };
+    args?: {
+        fee?: number | StdFee | "auto";
+        memo?: string;
+        funds?: Coin[];
+    };
+}
+export declare function useJunoSwapAddLiquidityMutation(options?: Omit<UseMutationOptions<ExecuteResult, Error, JunoSwapAddLiquidityMutation>, "mutationFn">): any;

package/types/codegen/JunoSwap.types.d.ts

@@ -0,0 +1,124 @@
+/**
+* This file was automatically generated by @cosmwasm/ts-codegen@0.10.0.
+* DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+* and run the @cosmwasm/ts-codegen generate command to regenerate this file.
+*/
+export declare type Uint128 = string;
+export interface BalanceResponse {
+    balance: Uint128;
+    [k: string]: unknown;
+}
+export declare type ExecuteMsg = {
+    add_liquidity: {
+        expiration?: Expiration | null;
+        max_token2: Uint128;
+        min_liquidity: Uint128;
+        token1_amount: Uint128;
+        [k: string]: unknown;
+    };
+} | {
+    remove_liquidity: {
+        amount: Uint128;
+        expiration?: Expiration | null;
+        min_token1: Uint128;
+        min_token2: Uint128;
+        [k: string]: unknown;
+    };
+} | {
+    swap_token1_for_token2: {
+        expiration?: Expiration | null;
+        min_token2: Uint128;
+        token1_amount: Uint128;
+        [k: string]: unknown;
+    };
+} | {
+    swap_token2_for_token1: {
+        expiration?: Expiration | null;
+        min_token1: Uint128;
+        token2_amount: Uint128;
+        [k: string]: unknown;
+    };
+} | {
+    multi_contract_swap: {
+        expiration?: Expiration | null;
+        input_token: TokenSelect;
+        input_token_amount: Uint128;
+        output_amm_address: Addr;
+        output_min_token: Uint128;
+        output_token: TokenSelect;
+        [k: string]: unknown;
+    };
+} | {
+    swap_to: {
+        expiration?: Expiration | null;
+        input_amount: Uint128;
+        input_token: TokenSelect;
+        min_token: Uint128;
+        recipient: Addr;
+        [k: string]: unknown;
+    };
+};
+export declare type Expiration = {
+    at_height: number;
+} | {
+    at_time: Timestamp;
+} | {
+    never: {
+        [k: string]: unknown;
+    };
+};
+export declare type Timestamp = Uint64;
+export declare type Uint64 = string;
+export declare type TokenSelect = "Token1" | "Token2";
+export declare type Addr = string;
+export interface InfoResponse {
+    lp_token_supply: Uint128;
+    token1_address?: string | null;
+    token1_denom: string;
+    token1_reserve: Uint128;
+    token2_address?: string | null;
+    token2_denom: string;
+    token2_reserve: Uint128;
+    [k: string]: unknown;
+}
+export interface InstantiateMsg {
+    token1_address?: Addr | null;
+    token1_denom: string;
+    token2_address?: Addr | null;
+    token2_denom: string;
+    [k: string]: unknown;
+}
+export declare type QueryMsg = {
+    balance: {
+        address: string;
+        [k: string]: unknown;
+    };
+} | {
+    info: {
+        [k: string]: unknown;
+    };
+} | {
+    token1_for_token2_price: {
+        token1_amount: Uint128;
+        [k: string]: unknown;
+    };
+} | {
+    token2_for_token1_price: {
+        token2_amount: Uint128;
+        [k: string]: unknown;
+    };
+};
+export interface Token {
+    address?: Addr | null;
+    denom: string;
+    reserve: Uint128;
+    [k: string]: unknown;
+}
+export interface Token1ForToken2PriceResponse {
+    token2_amount: Uint128;
+    [k: string]: unknown;
+}
+export interface Token2ForToken1PriceResponse {
+    token1_amount: Uint128;
+    [k: string]: unknown;
+}

package/types/codegen/confio/proofs.d.ts

@@ -0,0 +1,309 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+export declare enum HashOp {
+    /** NO_HASH - NO_HASH is the default if no data passed. Note this is an illegal argument some places. */
+    NO_HASH = 0,
+    SHA256 = 1,
+    SHA512 = 2,
+    KECCAK = 3,
+    RIPEMD160 = 4,
+    /** BITCOIN - ripemd160(sha256(x)) */
+    BITCOIN = 5,
+    UNRECOGNIZED = -1
+}
+export declare function hashOpFromJSON(object: any): HashOp;
+export declare function hashOpToJSON(object: HashOp): string;
+/**
+ * LengthOp defines how to process the key and value of the LeafOp
+ * to include length information. After encoding the length with the given
+ * algorithm, the length will be prepended to the key and value bytes.
+ * (Each one with it's own encoded length)
+ */
+export declare enum LengthOp {
+    /** NO_PREFIX - NO_PREFIX don't include any length info */
+    NO_PREFIX = 0,
+    /** VAR_PROTO - VAR_PROTO uses protobuf (and go-amino) varint encoding of the length */
+    VAR_PROTO = 1,
+    /** VAR_RLP - VAR_RLP uses rlp int encoding of the length */
+    VAR_RLP = 2,
+    /** FIXED32_BIG - FIXED32_BIG uses big-endian encoding of the length as a 32 bit integer */
+    FIXED32_BIG = 3,
+    /** FIXED32_LITTLE - FIXED32_LITTLE uses little-endian encoding of the length as a 32 bit integer */
+    FIXED32_LITTLE = 4,
+    /** FIXED64_BIG - FIXED64_BIG uses big-endian encoding of the length as a 64 bit integer */
+    FIXED64_BIG = 5,
+    /** FIXED64_LITTLE - FIXED64_LITTLE uses little-endian encoding of the length as a 64 bit integer */
+    FIXED64_LITTLE = 6,
+    /** REQUIRE_32_BYTES - REQUIRE_32_BYTES is like NONE, but will fail if the input is not exactly 32 bytes (sha256 output) */
+    REQUIRE_32_BYTES = 7,
+    /** REQUIRE_64_BYTES - REQUIRE_64_BYTES is like NONE, but will fail if the input is not exactly 64 bytes (sha512 output) */
+    REQUIRE_64_BYTES = 8,
+    UNRECOGNIZED = -1
+}
+export declare function lengthOpFromJSON(object: any): LengthOp;
+export declare function lengthOpToJSON(object: LengthOp): string;
+/**
+ * ExistenceProof takes a key and a value and a set of steps to perform on it.
+ * The result of peforming all these steps will provide a "root hash", which can
+ * be compared to the value in a header.
+ *
+ * Since it is computationally infeasible to produce a hash collission for any of the used
+ * cryptographic hash functions, if someone can provide a series of operations to transform
+ * a given key and value into a root hash that matches some trusted root, these key and values
+ * must be in the referenced merkle tree.
+ *
+ * The only possible issue is maliablity in LeafOp, such as providing extra prefix data,
+ * which should be controlled by a spec. Eg. with lengthOp as NONE,
+ * prefix = FOO, key = BAR, value = CHOICE
+ * and
+ * prefix = F, key = OOBAR, value = CHOICE
+ * would produce the same value.
+ *
+ * With LengthOp this is tricker but not impossible. Which is why the "leafPrefixEqual" field
+ * in the ProofSpec is valuable to prevent this mutability. And why all trees should
+ * length-prefix the data before hashing it.
+ */
+export interface ExistenceProof {
+    key: Uint8Array;
+    value: Uint8Array;
+    leaf: LeafOp;
+    path: InnerOp[];
+}
+/**
+ * NonExistenceProof takes a proof of two neighbors, one left of the desired key,
+ * one right of the desired key. If both proofs are valid AND they are neighbors,
+ * then there is no valid proof for the given key.
+ */
+export interface NonExistenceProof {
+    /** TODO: remove this as unnecessary??? we prove a range */
+    key: Uint8Array;
+    left: ExistenceProof;
+    right: ExistenceProof;
+}
+/** CommitmentProof is either an ExistenceProof or a NonExistenceProof, or a Batch of such messages */
+export interface CommitmentProof {
+    exist?: ExistenceProof;
+    nonexist?: NonExistenceProof;
+    batch?: BatchProof;
+    compressed?: CompressedBatchProof;
+}
+/**
+ * LeafOp represents the raw key-value data we wish to prove, and
+ * must be flexible to represent the internal transformation from
+ * the original key-value pairs into the basis hash, for many existing
+ * merkle trees.
+ *
+ * key and value are passed in. So that the signature of this operation is:
+ * leafOp(key, value) -> output
+ *
+ * To process this, first prehash the keys and values if needed (ANY means no hash in this case):
+ * hkey = prehashKey(key)
+ * hvalue = prehashValue(value)
+ *
+ * Then combine the bytes, and hash it
+ * output = hash(prefix || length(hkey) || hkey || length(hvalue) || hvalue)
+ */
+export interface LeafOp {
+    hash: HashOp;
+    prehashKey: HashOp;
+    prehashValue: HashOp;
+    length: LengthOp;
+    /**
+     * prefix is a fixed bytes that may optionally be included at the beginning to differentiate
+     * a leaf node from an inner node.
+     */
+    prefix: Uint8Array;
+}
+/**
+ * InnerOp represents a merkle-proof step that is not a leaf.
+ * It represents concatenating two children and hashing them to provide the next result.
+ *
+ * The result of the previous step is passed in, so the signature of this op is:
+ * innerOp(child) -> output
+ *
+ * The result of applying InnerOp should be:
+ * output = op.hash(op.prefix || child || op.suffix)
+ *
+ * where the || operator is concatenation of binary data,
+ * and child is the result of hashing all the tree below this step.
+ *
+ * Any special data, like prepending child with the length, or prepending the entire operation with
+ * some value to differentiate from leaf nodes, should be included in prefix and suffix.
+ * If either of prefix or suffix is empty, we just treat it as an empty string
+ */
+export interface InnerOp {
+    hash: HashOp;
+    prefix: Uint8Array;
+    suffix: Uint8Array;
+}
+/**
+ * ProofSpec defines what the expected parameters are for a given proof type.
+ * This can be stored in the client and used to validate any incoming proofs.
+ *
+ * verify(ProofSpec, Proof) -> Proof | Error
+ *
+ * As demonstrated in tests, if we don't fix the algorithm used to calculate the
+ * LeafHash for a given tree, there are many possible key-value pairs that can
+ * generate a given hash (by interpretting the preimage differently).
+ * We need this for proper security, requires client knows a priori what
+ * tree format server uses. But not in code, rather a configuration object.
+ */
+export interface ProofSpec {
+    /**
+     * any field in the ExistenceProof must be the same as in this spec.
+     * except Prefix, which is just the first bytes of prefix (spec can be longer)
+     */
+    leafSpec: LeafOp;
+    innerSpec: InnerSpec;
+    /** max_depth (if > 0) is the maximum number of InnerOps allowed (mainly for fixed-depth tries) */
+    maxDepth: number;
+    /** min_depth (if > 0) is the minimum number of InnerOps allowed (mainly for fixed-depth tries) */
+    minDepth: number;
+}
+/**
+ * InnerSpec contains all store-specific structure info to determine if two proofs from a
+ * given store are neighbors.
+ *
+ * This enables:
+ *
+ * isLeftMost(spec: InnerSpec, op: InnerOp)
+ * isRightMost(spec: InnerSpec, op: InnerOp)
+ * isLeftNeighbor(spec: InnerSpec, left: InnerOp, right: InnerOp)
+ */
+export interface InnerSpec {
+    /**
+     * Child order is the ordering of the children node, must count from 0
+     * iavl tree is [0, 1] (left then right)
+     * merk is [0, 2, 1] (left, right, here)
+     */
+    childOrder: number[];
+    childSize: number;
+    minPrefixLength: number;
+    maxPrefixLength: number;
+    /** empty child is the prehash image that is used when one child is nil (eg. 20 bytes of 0) */
+    emptyChild: Uint8Array;
+    /** hash is the algorithm that must be used for each InnerOp */
+    hash: HashOp;
+}
+/** BatchProof is a group of multiple proof types than can be compressed */
+export interface BatchProof {
+    entries: BatchEntry[];
+}
+/** Use BatchEntry not CommitmentProof, to avoid recursion */
+export interface BatchEntry {
+    exist?: ExistenceProof;
+    nonexist?: NonExistenceProof;
+}
+export interface CompressedBatchProof {
+    entries: CompressedBatchEntry[];
+    lookupInners: InnerOp[];
+}
+/** Use BatchEntry not CommitmentProof, to avoid recursion */
+export interface CompressedBatchEntry {
+    exist?: CompressedExistenceProof;
+    nonexist?: CompressedNonExistenceProof;
+}
+export interface CompressedExistenceProof {
+    key: Uint8Array;
+    value: Uint8Array;
+    leaf: LeafOp;
+    /** these are indexes into the lookup_inners table in CompressedBatchProof */
+    path: number[];
+}
+export interface CompressedNonExistenceProof {
+    /** TODO: remove this as unnecessary??? we prove a range */
+    key: Uint8Array;
+    left: CompressedExistenceProof;
+    right: CompressedExistenceProof;
+}
+export declare const ExistenceProof: {
+    encode(message: ExistenceProof, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ExistenceProof;
+    fromJSON(object: any): ExistenceProof;
+    toJSON(message: ExistenceProof): unknown;
+    fromPartial(object: DeepPartial<ExistenceProof>): ExistenceProof;
+};
+export declare const NonExistenceProof: {
+    encode(message: NonExistenceProof, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): NonExistenceProof;
+    fromJSON(object: any): NonExistenceProof;
+    toJSON(message: NonExistenceProof): unknown;
+    fromPartial(object: DeepPartial<NonExistenceProof>): NonExistenceProof;
+};
+export declare const CommitmentProof: {
+    encode(message: CommitmentProof, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): CommitmentProof;
+    fromJSON(object: any): CommitmentProof;
+    toJSON(message: CommitmentProof): unknown;
+    fromPartial(object: DeepPartial<CommitmentProof>): CommitmentProof;
+};
+export declare const LeafOp: {
+    encode(message: LeafOp, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): LeafOp;
+    fromJSON(object: any): LeafOp;
+    toJSON(message: LeafOp): unknown;
+    fromPartial(object: DeepPartial<LeafOp>): LeafOp;
+};
+export declare const InnerOp: {
+    encode(message: InnerOp, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): InnerOp;
+    fromJSON(object: any): InnerOp;
+    toJSON(message: InnerOp): unknown;
+    fromPartial(object: DeepPartial<InnerOp>): InnerOp;
+};
+export declare const ProofSpec: {
+    encode(message: ProofSpec, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ProofSpec;
+    fromJSON(object: any): ProofSpec;
+    toJSON(message: ProofSpec): unknown;
+    fromPartial(object: DeepPartial<ProofSpec>): ProofSpec;
+};
+export declare const InnerSpec: {
+    encode(message: InnerSpec, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): InnerSpec;
+    fromJSON(object: any): InnerSpec;
+    toJSON(message: InnerSpec): unknown;
+    fromPartial(object: DeepPartial<InnerSpec>): InnerSpec;
+};
+export declare const BatchProof: {
+    encode(message: BatchProof, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): BatchProof;
+    fromJSON(object: any): BatchProof;
+    toJSON(message: BatchProof): unknown;
+    fromPartial(object: DeepPartial<BatchProof>): BatchProof;
+};
+export declare const BatchEntry: {
+    encode(message: BatchEntry, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): BatchEntry;
+    fromJSON(object: any): BatchEntry;
+    toJSON(message: BatchEntry): unknown;
+    fromPartial(object: DeepPartial<BatchEntry>): BatchEntry;
+};
+export declare const CompressedBatchProof: {
+    encode(message: CompressedBatchProof, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): CompressedBatchProof;
+    fromJSON(object: any): CompressedBatchProof;
+    toJSON(message: CompressedBatchProof): unknown;
+    fromPartial(object: DeepPartial<CompressedBatchProof>): CompressedBatchProof;
+};
+export declare const CompressedBatchEntry: {
+    encode(message: CompressedBatchEntry, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): CompressedBatchEntry;
+    fromJSON(object: any): CompressedBatchEntry;
+    toJSON(message: CompressedBatchEntry): unknown;
+    fromPartial(object: DeepPartial<CompressedBatchEntry>): CompressedBatchEntry;
+};
+export declare const CompressedExistenceProof: {
+    encode(message: CompressedExistenceProof, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): CompressedExistenceProof;
+    fromJSON(object: any): CompressedExistenceProof;
+    toJSON(message: CompressedExistenceProof): unknown;
+    fromPartial(object: DeepPartial<CompressedExistenceProof>): CompressedExistenceProof;
+};
+export declare const CompressedNonExistenceProof: {
+    encode(message: CompressedNonExistenceProof, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): CompressedNonExistenceProof;
+    fromJSON(object: any): CompressedNonExistenceProof;
+    toJSON(message: CompressedNonExistenceProof): unknown;
+    fromPartial(object: DeepPartial<CompressedNonExistenceProof>): CompressedNonExistenceProof;
+};

package/types/codegen/contracts.d.ts

@@ -0,0 +1,23 @@
+/**
+* This file was automatically generated by @cosmwasm/ts-codegen@0.10.0.
+* DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+* and run the @cosmwasm/ts-codegen generate command to regenerate this file.
+*/
+import * as _1 from "./JunoSwap.client";
+import * as _2 from "./JunoSwap.react-query";
+export declare namespace contracts {
+    const JunoSwap: {
+        useJunoSwapToken2ForToken1PriceQuery({ client, args, options }: _2.JunoSwapToken2ForToken1PriceQuery): any;
+        useJunoSwapToken1ForToken2PriceQuery({ client, args, options }: _2.JunoSwapToken1ForToken2PriceQuery): any;
+        useJunoSwapInfoQuery({ client, options }: _2.JunoSwapInfoQuery): any;
+        useJunoSwapBalanceQuery({ client, args, options }: _2.JunoSwapBalanceQuery): any;
+        useJunoSwapSwapToMutation(options?: Omit<UseMutationOptions<ExecuteResult, Error, _2.JunoSwapSwapToMutation>, "mutationFn">): any;
+        useJunoSwapMultiContractSwapMutation(options?: Omit<UseMutationOptions<ExecuteResult, Error, _2.JunoSwapMultiContractSwapMutation>, "mutationFn">): any;
+        useJunoSwapSwapToken2ForToken1Mutation(options?: Omit<UseMutationOptions<ExecuteResult, Error, _2.JunoSwapSwapToken2ForToken1Mutation>, "mutationFn">): any;
+        useJunoSwapSwapToken1ForToken2Mutation(options?: Omit<UseMutationOptions<ExecuteResult, Error, _2.JunoSwapSwapToken1ForToken2Mutation>, "mutationFn">): any;
+        useJunoSwapRemoveLiquidityMutation(options?: Omit<UseMutationOptions<ExecuteResult, Error, _2.JunoSwapRemoveLiquidityMutation>, "mutationFn">): any;
+        useJunoSwapAddLiquidityMutation(options?: Omit<UseMutationOptions<ExecuteResult, Error, _2.JunoSwapAddLiquidityMutation>, "mutationFn">): any;
+        JunoSwapQueryClient: typeof _1.JunoSwapQueryClient;
+        JunoSwapClient: typeof _1.JunoSwapClient;
+    };
+}

package/types/codegen/cosmos/app/v1alpha1/config.d.ts

@@ -0,0 +1,51 @@
+import { Any } from "../../../google/protobuf/any";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/**
+ * Config represents the configuration for a Cosmos SDK ABCI app.
+ * It is intended that all state machine logic including the version of
+ * baseapp and tx handlers (and possibly even Tendermint) that an app needs
+ * can be described in a config object. For compatibility, the framework should
+ * allow a mixture of declarative and imperative app wiring, however, apps
+ * that strive for the maximum ease of maintainability should be able to describe
+ * their state machine with a config object alone.
+ */
+export interface Config {
+    /** modules are the module configurations for the app. */
+    modules: ModuleConfig[];
+}
+/** ModuleConfig is a module configuration for an app. */
+export interface ModuleConfig {
+    /**
+     * name is the unique name of the module within the app. It should be a name
+     * that persists between different versions of a module so that modules
+     * can be smoothly upgraded to new versions.
+     *
+     * For example, for the module cosmos.bank.module.v1.Module, we may chose
+     * to simply name the module "bank" in the app. When we upgrade to
+     * cosmos.bank.module.v2.Module, the app-specific name "bank" stays the same
+     * and the framework knows that the v2 module should receive all the same state
+     * that the v1 module had. Note: modules should provide info on which versions
+     * they can migrate from in the ModuleDescriptor.can_migration_from field.
+     */
+    name: string;
+    /**
+     * config is the config object for the module. Module config messages should
+     * define a ModuleDescriptor using the cosmos.app.v1alpha1.is_module extension.
+     */
+    config: Any;
+}
+export declare const Config: {
+    encode(message: Config, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Config;
+    fromJSON(object: any): Config;
+    toJSON(message: Config): unknown;
+    fromPartial(object: DeepPartial<Config>): Config;
+};
+export declare const ModuleConfig: {
+    encode(message: ModuleConfig, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ModuleConfig;
+    fromJSON(object: any): ModuleConfig;
+    toJSON(message: ModuleConfig): unknown;
+    fromPartial(object: DeepPartial<ModuleConfig>): ModuleConfig;
+};