injectivejs 0.1.0 → 0.3.0

package/types/codegen/ics23/bundle.d.ts

@@ -0,0 +1,545 @@
+import * as _0 from "../confio/proofs";
+export declare const ics23: {
+    hashOpFromJSON(object: any): _0.HashOp;
+    hashOpToJSON(object: _0.HashOp): string;
+    lengthOpFromJSON(object: any): _0.LengthOp;
+    lengthOpToJSON(object: _0.LengthOp): string;
+    HashOp: typeof _0.HashOp;
+    HashOpSDKType: typeof _0.HashOpSDKType;
+    LengthOp: typeof _0.LengthOp;
+    LengthOpSDKType: typeof _0.LengthOpSDKType;
+    ExistenceProof: {
+        encode(message: _0.ExistenceProof, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+        decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _0.ExistenceProof;
+        fromPartial(object: {
+            key?: Uint8Array;
+            value?: Uint8Array;
+            leaf?: {
+                hash?: _0.HashOp;
+                prehashKey?: _0.HashOp;
+                prehashValue?: _0.HashOp;
+                length?: _0.LengthOp;
+                prefix?: Uint8Array;
+            };
+            path?: {
+                hash?: _0.HashOp;
+                prefix?: Uint8Array;
+                suffix?: Uint8Array;
+            }[];
+        }): _0.ExistenceProof;
+    };
+    NonExistenceProof: {
+        encode(message: _0.NonExistenceProof, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+        decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _0.NonExistenceProof;
+        fromPartial(object: {
+            key?: Uint8Array;
+            left?: {
+                key?: Uint8Array;
+                value?: Uint8Array;
+                leaf?: {
+                    hash?: _0.HashOp;
+                    prehashKey?: _0.HashOp;
+                    prehashValue?: _0.HashOp;
+                    length?: _0.LengthOp;
+                    prefix?: Uint8Array;
+                };
+                path?: {
+                    hash?: _0.HashOp;
+                    prefix?: Uint8Array;
+                    suffix?: Uint8Array;
+                }[];
+            };
+            right?: {
+                key?: Uint8Array;
+                value?: Uint8Array;
+                leaf?: {
+                    hash?: _0.HashOp;
+                    prehashKey?: _0.HashOp;
+                    prehashValue?: _0.HashOp;
+                    length?: _0.LengthOp;
+                    prefix?: Uint8Array;
+                };
+                path?: {
+                    hash?: _0.HashOp;
+                    prefix?: Uint8Array;
+                    suffix?: Uint8Array;
+                }[];
+            };
+        }): _0.NonExistenceProof;
+    };
+    CommitmentProof: {
+        encode(message: _0.CommitmentProof, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+        decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _0.CommitmentProof;
+        fromPartial(object: {
+            exist?: {
+                key?: Uint8Array;
+                value?: Uint8Array;
+                leaf?: {
+                    hash?: _0.HashOp;
+                    prehashKey?: _0.HashOp;
+                    prehashValue?: _0.HashOp;
+                    length?: _0.LengthOp;
+                    prefix?: Uint8Array;
+                };
+                path?: {
+                    hash?: _0.HashOp;
+                    prefix?: Uint8Array;
+                    suffix?: Uint8Array;
+                }[];
+            };
+            nonexist?: {
+                key?: Uint8Array;
+                left?: {
+                    key?: Uint8Array;
+                    value?: Uint8Array;
+                    leaf?: {
+                        hash?: _0.HashOp;
+                        prehashKey?: _0.HashOp;
+                        prehashValue?: _0.HashOp;
+                        length?: _0.LengthOp;
+                        prefix?: Uint8Array;
+                    };
+                    path?: {
+                        hash?: _0.HashOp;
+                        prefix?: Uint8Array;
+                        suffix?: Uint8Array;
+                    }[];
+                };
+                right?: {
+                    key?: Uint8Array;
+                    value?: Uint8Array;
+                    leaf?: {
+                        hash?: _0.HashOp;
+                        prehashKey?: _0.HashOp;
+                        prehashValue?: _0.HashOp;
+                        length?: _0.LengthOp;
+                        prefix?: Uint8Array;
+                    };
+                    path?: {
+                        hash?: _0.HashOp;
+                        prefix?: Uint8Array;
+                        suffix?: Uint8Array;
+                    }[];
+                };
+            };
+            batch?: {
+                entries?: {
+                    exist?: {
+                        key?: Uint8Array;
+                        value?: Uint8Array;
+                        leaf?: {
+                            hash?: _0.HashOp;
+                            prehashKey?: _0.HashOp;
+                            prehashValue?: _0.HashOp;
+                            length?: _0.LengthOp;
+                            prefix?: Uint8Array;
+                        };
+                        path?: {
+                            hash?: _0.HashOp;
+                            prefix?: Uint8Array;
+                            suffix?: Uint8Array;
+                        }[];
+                    };
+                    nonexist?: {
+                        key?: Uint8Array;
+                        left?: {
+                            key?: Uint8Array;
+                            value?: Uint8Array;
+                            leaf?: {
+                                hash?: _0.HashOp;
+                                prehashKey?: _0.HashOp;
+                                prehashValue?: _0.HashOp;
+                                length?: _0.LengthOp;
+                                prefix?: Uint8Array;
+                            };
+                            path?: {
+                                hash?: _0.HashOp;
+                                prefix?: Uint8Array;
+                                suffix?: Uint8Array;
+                            }[];
+                        };
+                        right?: {
+                            key?: Uint8Array;
+                            value?: Uint8Array;
+                            leaf?: {
+                                hash?: _0.HashOp;
+                                prehashKey?: _0.HashOp;
+                                prehashValue?: _0.HashOp;
+                                length?: _0.LengthOp;
+                                prefix?: Uint8Array;
+                            };
+                            path?: {
+                                hash?: _0.HashOp;
+                                prefix?: Uint8Array;
+                                suffix?: Uint8Array;
+                            }[];
+                        };
+                    };
+                }[];
+            };
+            compressed?: {
+                entries?: {
+                    exist?: {
+                        key?: Uint8Array;
+                        value?: Uint8Array;
+                        leaf?: {
+                            hash?: _0.HashOp;
+                            prehashKey?: _0.HashOp;
+                            prehashValue?: _0.HashOp;
+                            length?: _0.LengthOp;
+                            prefix?: Uint8Array;
+                        };
+                        path?: number[];
+                    };
+                    nonexist?: {
+                        key?: Uint8Array;
+                        left?: {
+                            key?: Uint8Array;
+                            value?: Uint8Array;
+                            leaf?: {
+                                hash?: _0.HashOp;
+                                prehashKey?: _0.HashOp;
+                                prehashValue?: _0.HashOp;
+                                length?: _0.LengthOp;
+                                prefix?: Uint8Array;
+                            };
+                            path?: number[];
+                        };
+                        right?: {
+                            key?: Uint8Array;
+                            value?: Uint8Array;
+                            leaf?: {
+                                hash?: _0.HashOp;
+                                prehashKey?: _0.HashOp;
+                                prehashValue?: _0.HashOp;
+                                length?: _0.LengthOp;
+                                prefix?: Uint8Array;
+                            };
+                            path?: number[];
+                        };
+                    };
+                }[];
+                lookupInners?: {
+                    hash?: _0.HashOp;
+                    prefix?: Uint8Array;
+                    suffix?: Uint8Array;
+                }[];
+            };
+        }): _0.CommitmentProof;
+    };
+    LeafOp: {
+        encode(message: _0.LeafOp, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+        decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _0.LeafOp;
+        fromPartial(object: {
+            hash?: _0.HashOp;
+            prehashKey?: _0.HashOp;
+            prehashValue?: _0.HashOp;
+            length?: _0.LengthOp;
+            prefix?: Uint8Array;
+        }): _0.LeafOp;
+    };
+    InnerOp: {
+        encode(message: _0.InnerOp, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+        decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _0.InnerOp;
+        fromPartial(object: {
+            hash?: _0.HashOp;
+            prefix?: Uint8Array;
+            suffix?: Uint8Array;
+        }): _0.InnerOp;
+    };
+    ProofSpec: {
+        encode(message: _0.ProofSpec, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+        decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _0.ProofSpec;
+        fromPartial(object: {
+            leafSpec?: {
+                hash?: _0.HashOp;
+                prehashKey?: _0.HashOp;
+                prehashValue?: _0.HashOp;
+                length?: _0.LengthOp;
+                prefix?: Uint8Array;
+            };
+            innerSpec?: {
+                childOrder?: number[];
+                childSize?: number;
+                minPrefixLength?: number;
+                maxPrefixLength?: number;
+                emptyChild?: Uint8Array;
+                hash?: _0.HashOp;
+            };
+            maxDepth?: number;
+            minDepth?: number;
+        }): _0.ProofSpec;
+    };
+    InnerSpec: {
+        encode(message: _0.InnerSpec, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+        decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _0.InnerSpec;
+        fromPartial(object: {
+            childOrder?: number[];
+            childSize?: number;
+            minPrefixLength?: number;
+            maxPrefixLength?: number;
+            emptyChild?: Uint8Array;
+            hash?: _0.HashOp;
+        }): _0.InnerSpec;
+    };
+    BatchProof: {
+        encode(message: _0.BatchProof, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+        decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _0.BatchProof;
+        fromPartial(object: {
+            entries?: {
+                exist?: {
+                    key?: Uint8Array;
+                    value?: Uint8Array;
+                    leaf?: {
+                        hash?: _0.HashOp;
+                        prehashKey?: _0.HashOp;
+                        prehashValue?: _0.HashOp;
+                        length?: _0.LengthOp;
+                        prefix?: Uint8Array;
+                    };
+                    path?: {
+                        hash?: _0.HashOp;
+                        prefix?: Uint8Array;
+                        suffix?: Uint8Array;
+                    }[];
+                };
+                nonexist?: {
+                    key?: Uint8Array;
+                    left?: {
+                        key?: Uint8Array;
+                        value?: Uint8Array;
+                        leaf?: {
+                            hash?: _0.HashOp;
+                            prehashKey?: _0.HashOp;
+                            prehashValue?: _0.HashOp;
+                            length?: _0.LengthOp;
+                            prefix?: Uint8Array;
+                        };
+                        path?: {
+                            hash?: _0.HashOp;
+                            prefix?: Uint8Array;
+                            suffix?: Uint8Array;
+                        }[];
+                    };
+                    right?: {
+                        key?: Uint8Array;
+                        value?: Uint8Array;
+                        leaf?: {
+                            hash?: _0.HashOp;
+                            prehashKey?: _0.HashOp;
+                            prehashValue?: _0.HashOp;
+                            length?: _0.LengthOp;
+                            prefix?: Uint8Array;
+                        };
+                        path?: {
+                            hash?: _0.HashOp;
+                            prefix?: Uint8Array;
+                            suffix?: Uint8Array;
+                        }[];
+                    };
+                };
+            }[];
+        }): _0.BatchProof;
+    };
+    BatchEntry: {
+        encode(message: _0.BatchEntry, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+        decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _0.BatchEntry;
+        fromPartial(object: {
+            exist?: {
+                key?: Uint8Array;
+                value?: Uint8Array;
+                leaf?: {
+                    hash?: _0.HashOp;
+                    prehashKey?: _0.HashOp;
+                    prehashValue?: _0.HashOp;
+                    length?: _0.LengthOp;
+                    prefix?: Uint8Array;
+                };
+                path?: {
+                    hash?: _0.HashOp;
+                    prefix?: Uint8Array;
+                    suffix?: Uint8Array;
+                }[];
+            };
+            nonexist?: {
+                key?: Uint8Array;
+                left?: {
+                    key?: Uint8Array;
+                    value?: Uint8Array;
+                    leaf?: {
+                        hash?: _0.HashOp;
+                        prehashKey?: _0.HashOp;
+                        prehashValue?: _0.HashOp;
+                        length?: _0.LengthOp;
+                        prefix?: Uint8Array;
+                    };
+                    path?: {
+                        hash?: _0.HashOp;
+                        prefix?: Uint8Array;
+                        suffix?: Uint8Array;
+                    }[];
+                };
+                right?: {
+                    key?: Uint8Array;
+                    value?: Uint8Array;
+                    leaf?: {
+                        hash?: _0.HashOp;
+                        prehashKey?: _0.HashOp;
+                        prehashValue?: _0.HashOp;
+                        length?: _0.LengthOp;
+                        prefix?: Uint8Array;
+                    };
+                    path?: {
+                        hash?: _0.HashOp;
+                        prefix?: Uint8Array;
+                        suffix?: Uint8Array;
+                    }[];
+                };
+            };
+        }): _0.BatchEntry;
+    };
+    CompressedBatchProof: {
+        encode(message: _0.CompressedBatchProof, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+        decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _0.CompressedBatchProof;
+        fromPartial(object: {
+            entries?: {
+                exist?: {
+                    key?: Uint8Array;
+                    value?: Uint8Array;
+                    leaf?: {
+                        hash?: _0.HashOp;
+                        prehashKey?: _0.HashOp;
+                        prehashValue?: _0.HashOp;
+                        length?: _0.LengthOp;
+                        prefix?: Uint8Array;
+                    };
+                    path?: number[];
+                };
+                nonexist?: {
+                    key?: Uint8Array;
+                    left?: {
+                        key?: Uint8Array;
+                        value?: Uint8Array;
+                        leaf?: {
+                            hash?: _0.HashOp;
+                            prehashKey?: _0.HashOp;
+                            prehashValue?: _0.HashOp;
+                            length?: _0.LengthOp;
+                            prefix?: Uint8Array;
+                        };
+                        path?: number[];
+                    };
+                    right?: {
+                        key?: Uint8Array;
+                        value?: Uint8Array;
+                        leaf?: {
+                            hash?: _0.HashOp;
+                            prehashKey?: _0.HashOp;
+                            prehashValue?: _0.HashOp;
+                            length?: _0.LengthOp;
+                            prefix?: Uint8Array;
+                        };
+                        path?: number[];
+                    };
+                };
+            }[];
+            lookupInners?: {
+                hash?: _0.HashOp;
+                prefix?: Uint8Array;
+                suffix?: Uint8Array;
+            }[];
+        }): _0.CompressedBatchProof;
+    };
+    CompressedBatchEntry: {
+        encode(message: _0.CompressedBatchEntry, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+        decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _0.CompressedBatchEntry;
+        fromPartial(object: {
+            exist?: {
+                key?: Uint8Array;
+                value?: Uint8Array;
+                leaf?: {
+                    hash?: _0.HashOp;
+                    prehashKey?: _0.HashOp;
+                    prehashValue?: _0.HashOp;
+                    length?: _0.LengthOp;
+                    prefix?: Uint8Array;
+                };
+                path?: number[];
+            };
+            nonexist?: {
+                key?: Uint8Array;
+                left?: {
+                    key?: Uint8Array;
+                    value?: Uint8Array;
+                    leaf?: {
+                        hash?: _0.HashOp;
+                        prehashKey?: _0.HashOp;
+                        prehashValue?: _0.HashOp;
+                        length?: _0.LengthOp;
+                        prefix?: Uint8Array;
+                    };
+                    path?: number[];
+                };
+                right?: {
+                    key?: Uint8Array;
+                    value?: Uint8Array;
+                    leaf?: {
+                        hash?: _0.HashOp;
+                        prehashKey?: _0.HashOp;
+                        prehashValue?: _0.HashOp;
+                        length?: _0.LengthOp;
+                        prefix?: Uint8Array;
+                    };
+                    path?: number[];
+                };
+            };
+        }): _0.CompressedBatchEntry;
+    };
+    CompressedExistenceProof: {
+        encode(message: _0.CompressedExistenceProof, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+        decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _0.CompressedExistenceProof;
+        fromPartial(object: {
+            key?: Uint8Array;
+            value?: Uint8Array;
+            leaf?: {
+                hash?: _0.HashOp;
+                prehashKey?: _0.HashOp;
+                prehashValue?: _0.HashOp;
+                length?: _0.LengthOp;
+                prefix?: Uint8Array;
+            };
+            path?: number[];
+        }): _0.CompressedExistenceProof;
+    };
+    CompressedNonExistenceProof: {
+        encode(message: _0.CompressedNonExistenceProof, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+        decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _0.CompressedNonExistenceProof;
+        fromPartial(object: {
+            key?: Uint8Array;
+            left?: {
+                key?: Uint8Array;
+                value?: Uint8Array;
+                leaf?: {
+                    hash?: _0.HashOp;
+                    prehashKey?: _0.HashOp;
+                    prehashValue?: _0.HashOp;
+                    length?: _0.LengthOp;
+                    prefix?: Uint8Array;
+                };
+                path?: number[];
+            };
+            right?: {
+                key?: Uint8Array;
+                value?: Uint8Array;
+                leaf?: {
+                    hash?: _0.HashOp;
+                    prehashKey?: _0.HashOp;
+                    prehashValue?: _0.HashOp;
+                    length?: _0.LengthOp;
+                    prefix?: Uint8Array;
+                };
+                path?: number[];
+            };
+        }): _0.CompressedNonExistenceProof;
+    };
+};

package/types/codegen/index.d.ts

@@ -0,0 +1,19 @@
+/**
+  * This file and any referenced files were automatically generated by @osmonauts/telescope@0.35.0
+  * DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+  * and run the transpile command or yarn proto command to regenerate this bundle.
+  */
+export * from "./ics23/bundle";
+export * from "./cosmos_proto/bundle";
+export * from "./cosmos/bundle";
+export * from "./cosmos/client";
+export * from "./cosmwasm/bundle";
+export * from "./cosmwasm/client";
+export * from "./gogoproto/bundle";
+export * from "./google/bundle";
+export * from "./ibc/bundle";
+export * from "./ibc/client";
+export * from "./injective/bundle";
+export * from "./injective/client";
+export * from "./tendermint/bundle";
+export * from "./contracts";

package/types/codegen/injective/auction/v1beta1/auction.d.ts

@@ -0,0 +1,96 @@
+import { Coin, CoinSDKType } from "../../../cosmos/base/v1beta1/coin";
+import * as _m0 from "protobufjs/minimal";
+import { Long, DeepPartial } from "@osmonauts/helpers";
+export interface Params {
+    /** auction_period_duration defines the auction period duration */
+    auctionPeriod: Long;
+    /** min_next_bid_increment_rate defines the minimum increment rate for new bids */
+    minNextBidIncrementRate: string;
+}
+export interface ParamsSDKType {
+    /** auction_period_duration defines the auction period duration */
+    auction_period: Long;
+    /** min_next_bid_increment_rate defines the minimum increment rate for new bids */
+    min_next_bid_increment_rate: string;
+}
+export interface Bid {
+    bidder: string;
+    amount: string;
+}
+export interface BidSDKType {
+    bidder: string;
+    amount: string;
+}
+export interface EventBid {
+    /** bidder describes the address of bidder */
+    bidder: string;
+    /** amount describes the amount the bidder put on the auction */
+    amount: string;
+    /** round defines the round number of auction */
+    round: Long;
+}
+export interface EventBidSDKType {
+    /** bidder describes the address of bidder */
+    bidder: string;
+    /** amount describes the amount the bidder put on the auction */
+    amount: string;
+    /** round defines the round number of auction */
+    round: Long;
+}
+export interface EventAuctionResult {
+    /** winner describes the address of the winner */
+    winner: string;
+    /** amount describes the amount the winner get from the auction */
+    amount: string;
+    /** round defines the round number of auction */
+    round: Long;
+}
+export interface EventAuctionResultSDKType {
+    /** winner describes the address of the winner */
+    winner: string;
+    /** amount describes the amount the winner get from the auction */
+    amount: string;
+    /** round defines the round number of auction */
+    round: Long;
+}
+export interface EventAuctionStart {
+    /** round defines the round number of auction */
+    round: Long;
+    /** ending_timestamp describes auction end time */
+    endingTimestamp: Long;
+    /** new_basket describes auction module balance at the time of new auction start */
+    newBasket: Coin[];
+}
+export interface EventAuctionStartSDKType {
+    /** round defines the round number of auction */
+    round: Long;
+    /** ending_timestamp describes auction end time */
+    ending_timestamp: Long;
+    /** new_basket describes auction module balance at the time of new auction start */
+    new_basket: CoinSDKType[];
+}
+export declare const Params: {
+    encode(message: Params, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Params;
+    fromPartial(object: DeepPartial<Params>): Params;
+};
+export declare const Bid: {
+    encode(message: Bid, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Bid;
+    fromPartial(object: DeepPartial<Bid>): Bid;
+};
+export declare const EventBid: {
+    encode(message: EventBid, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): EventBid;
+    fromPartial(object: DeepPartial<EventBid>): EventBid;
+};
+export declare const EventAuctionResult: {
+    encode(message: EventAuctionResult, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): EventAuctionResult;
+    fromPartial(object: DeepPartial<EventAuctionResult>): EventAuctionResult;
+};
+export declare const EventAuctionStart: {
+    encode(message: EventAuctionStart, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): EventAuctionStart;
+    fromPartial(object: DeepPartial<EventAuctionStart>): EventAuctionStart;
+};

package/types/codegen/injective/auction/v1beta1/genesis.d.ts

@@ -0,0 +1,30 @@
+import { Params, ParamsSDKType, Bid, BidSDKType } from "./auction";
+import * as _m0 from "protobufjs/minimal";
+import { Long, DeepPartial } from "@osmonauts/helpers";
+/** GenesisState defines the auction module's genesis state. */
+export interface GenesisState {
+    /** params defines all the parameters of related to auction. */
+    params: Params;
+    /** current auction round */
+    auctionRound: Long;
+    /** current highest bid */
+    highestBid: Bid;
+    /** auction ending timestamp */
+    auctionEndingTimestamp: Long;
+}
+/** GenesisState defines the auction module's genesis state. */
+export interface GenesisStateSDKType {
+    /** params defines all the parameters of related to auction. */
+    params: ParamsSDKType;
+    /** current auction round */
+    auction_round: Long;
+    /** current highest bid */
+    highest_bid: BidSDKType;
+    /** auction ending timestamp */
+    auction_ending_timestamp: Long;
+}
+export declare const GenesisState: {
+    encode(message: GenesisState, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+};