juno-network 0.5.3 → 0.6.0

package/src/codegen/tendermint/types/validator.ts

@@ -0,0 +1,228 @@
+import { PublicKey, PublicKeySDKType } from "../crypto/keys";
+import * as _m0 from "protobufjs/minimal";
+import { Long, DeepPartial } from "@osmonauts/helpers";
+export interface ValidatorSet {
+  validators: Validator[];
+  proposer: Validator;
+  totalVotingPower: Long;
+}
+export interface ValidatorSetSDKType {
+  validators: ValidatorSDKType[];
+  proposer: ValidatorSDKType;
+  total_voting_power: Long;
+}
+export interface Validator {
+  address: Uint8Array;
+  pubKey: PublicKey;
+  votingPower: Long;
+  proposerPriority: Long;
+}
+export interface ValidatorSDKType {
+  address: Uint8Array;
+  pub_key: PublicKeySDKType;
+  voting_power: Long;
+  proposer_priority: Long;
+}
+export interface SimpleValidator {
+  pubKey: PublicKey;
+  votingPower: Long;
+}
+export interface SimpleValidatorSDKType {
+  pub_key: PublicKeySDKType;
+  voting_power: Long;
+}
+
+function createBaseValidatorSet(): ValidatorSet {
+  return {
+    validators: [],
+    proposer: undefined,
+    totalVotingPower: Long.ZERO
+  };
+}
+
+export const ValidatorSet = {
+  encode(message: ValidatorSet, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.validators) {
+      Validator.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.proposer !== undefined) {
+      Validator.encode(message.proposer, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (!message.totalVotingPower.isZero()) {
+      writer.uint32(24).int64(message.totalVotingPower);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ValidatorSet {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseValidatorSet();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.validators.push(Validator.decode(reader, reader.uint32()));
+          break;
+
+        case 2:
+          message.proposer = Validator.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.totalVotingPower = (reader.int64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ValidatorSet>): ValidatorSet {
+    const message = createBaseValidatorSet();
+    message.validators = object.validators?.map(e => Validator.fromPartial(e)) || [];
+    message.proposer = object.proposer !== undefined && object.proposer !== null ? Validator.fromPartial(object.proposer) : undefined;
+    message.totalVotingPower = object.totalVotingPower !== undefined && object.totalVotingPower !== null ? Long.fromValue(object.totalVotingPower) : Long.ZERO;
+    return message;
+  }
+
+};
+
+function createBaseValidator(): Validator {
+  return {
+    address: new Uint8Array(),
+    pubKey: undefined,
+    votingPower: Long.ZERO,
+    proposerPriority: Long.ZERO
+  };
+}
+
+export const Validator = {
+  encode(message: Validator, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.address.length !== 0) {
+      writer.uint32(10).bytes(message.address);
+    }
+
+    if (message.pubKey !== undefined) {
+      PublicKey.encode(message.pubKey, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (!message.votingPower.isZero()) {
+      writer.uint32(24).int64(message.votingPower);
+    }
+
+    if (!message.proposerPriority.isZero()) {
+      writer.uint32(32).int64(message.proposerPriority);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Validator {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseValidator();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.bytes();
+          break;
+
+        case 2:
+          message.pubKey = PublicKey.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.votingPower = (reader.int64() as Long);
+          break;
+
+        case 4:
+          message.proposerPriority = (reader.int64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<Validator>): Validator {
+    const message = createBaseValidator();
+    message.address = object.address ?? new Uint8Array();
+    message.pubKey = object.pubKey !== undefined && object.pubKey !== null ? PublicKey.fromPartial(object.pubKey) : undefined;
+    message.votingPower = object.votingPower !== undefined && object.votingPower !== null ? Long.fromValue(object.votingPower) : Long.ZERO;
+    message.proposerPriority = object.proposerPriority !== undefined && object.proposerPriority !== null ? Long.fromValue(object.proposerPriority) : Long.ZERO;
+    return message;
+  }
+
+};
+
+function createBaseSimpleValidator(): SimpleValidator {
+  return {
+    pubKey: undefined,
+    votingPower: Long.ZERO
+  };
+}
+
+export const SimpleValidator = {
+  encode(message: SimpleValidator, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.pubKey !== undefined) {
+      PublicKey.encode(message.pubKey, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (!message.votingPower.isZero()) {
+      writer.uint32(16).int64(message.votingPower);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SimpleValidator {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSimpleValidator();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.pubKey = PublicKey.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.votingPower = (reader.int64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<SimpleValidator>): SimpleValidator {
+    const message = createBaseSimpleValidator();
+    message.pubKey = object.pubKey !== undefined && object.pubKey !== null ? PublicKey.fromPartial(object.pubKey) : undefined;
+    message.votingPower = object.votingPower !== undefined && object.votingPower !== null ? Long.fromValue(object.votingPower) : Long.ZERO;
+    return message;
+  }
+
+};

package/src/codegen/tendermint/version/types.ts

@@ -0,0 +1,152 @@
+import * as _m0 from "protobufjs/minimal";
+import { Long, DeepPartial } from "@osmonauts/helpers";
+/**
+ * App includes the protocol and software version for the application.
+ * This information is included in ResponseInfo. The App.Protocol can be
+ * updated in ResponseEndBlock.
+ */
+
+export interface App {
+  protocol: Long;
+  software: string;
+}
+/**
+ * App includes the protocol and software version for the application.
+ * This information is included in ResponseInfo. The App.Protocol can be
+ * updated in ResponseEndBlock.
+ */
+
+export interface AppSDKType {
+  protocol: Long;
+  software: string;
+}
+/**
+ * Consensus captures the consensus rules for processing a block in the blockchain,
+ * including all blockchain data structures and the rules of the application's
+ * state transition machine.
+ */
+
+export interface Consensus {
+  block: Long;
+  app: Long;
+}
+/**
+ * Consensus captures the consensus rules for processing a block in the blockchain,
+ * including all blockchain data structures and the rules of the application's
+ * state transition machine.
+ */
+
+export interface ConsensusSDKType {
+  block: Long;
+  app: Long;
+}
+
+function createBaseApp(): App {
+  return {
+    protocol: Long.UZERO,
+    software: ""
+  };
+}
+
+export const App = {
+  encode(message: App, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (!message.protocol.isZero()) {
+      writer.uint32(8).uint64(message.protocol);
+    }
+
+    if (message.software !== "") {
+      writer.uint32(18).string(message.software);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): App {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseApp();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.protocol = (reader.uint64() as Long);
+          break;
+
+        case 2:
+          message.software = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<App>): App {
+    const message = createBaseApp();
+    message.protocol = object.protocol !== undefined && object.protocol !== null ? Long.fromValue(object.protocol) : Long.UZERO;
+    message.software = object.software ?? "";
+    return message;
+  }
+
+};
+
+function createBaseConsensus(): Consensus {
+  return {
+    block: Long.UZERO,
+    app: Long.UZERO
+  };
+}
+
+export const Consensus = {
+  encode(message: Consensus, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (!message.block.isZero()) {
+      writer.uint32(8).uint64(message.block);
+    }
+
+    if (!message.app.isZero()) {
+      writer.uint32(16).uint64(message.app);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Consensus {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseConsensus();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.block = (reader.uint64() as Long);
+          break;
+
+        case 2:
+          message.app = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<Consensus>): Consensus {
+    const message = createBaseConsensus();
+    message.block = object.block !== undefined && object.block !== null ? Long.fromValue(object.block) : Long.UZERO;
+    message.app = object.app !== undefined && object.app !== null ? Long.fromValue(object.app) : Long.UZERO;
+    return message;
+  }
+
+};

package/src/index.ts

@@ -0,0 +1 @@
+export * from './codegen';

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

@@ -5,7 +5,7 @@
 */
 import { CosmWasmClient, SigningCosmWasmClient, ExecuteResult } from "@cosmjs/cosmwasm-stargate";
 import { Coin, StdFee } from "@cosmjs/amino";
-import { Uint128, BalanceResponse, Expiration, TokenSelect, Addr, InfoResponse, Token1ForToken2PriceResponse, Token2ForToken1PriceResponse } from "./JunoSwap.types";
+import { Uint128, BalanceResponse, Expiration, TokenSelect, Decimal, InfoResponse, Token1ForToken2PriceResponse, Token2ForToken1PriceResponse } from "./JunoSwap.types";
 export interface JunoSwapReadOnlyInterface {
     contractAddress: string;
     balance: ({ address }: {
@@ -49,30 +49,31 @@ export interface JunoSwapInterface extends JunoSwapReadOnlyInterface {
         minToken1: Uint128;
         minToken2: Uint128;
     }, fee?: number | StdFee | "auto", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
-    swapToken1ForToken2: ({ expiration, minToken2, token1Amount }: {
+    swap: ({ expiration, inputAmount, inputToken, minOutput }: {
         expiration?: Expiration;
-        minToken2: Uint128;
-        token1Amount: Uint128;
-    }, fee?: number | StdFee | "auto", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
-    swapToken2ForToken1: ({ expiration, minToken1, token2Amount }: {
-        expiration?: Expiration;
-        minToken1: Uint128;
-        token2Amount: Uint128;
+        inputAmount: Uint128;
+        inputToken: TokenSelect;
+        minOutput: Uint128;
     }, fee?: number | StdFee | "auto", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
-    multiContractSwap: ({ expiration, inputToken, inputTokenAmount, outputAmmAddress, outputMinToken, outputToken }: {
+    passThroughSwap: ({ expiration, inputToken, inputTokenAmount, outputAmmAddress, outputMinToken }: {
         expiration?: Expiration;
         inputToken: TokenSelect;
         inputTokenAmount: Uint128;
-        outputAmmAddress: Addr;
+        outputAmmAddress: string;
         outputMinToken: Uint128;
-        outputToken: TokenSelect;
     }, fee?: number | StdFee | "auto", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
-    swapTo: ({ expiration, inputAmount, inputToken, minToken, recipient }: {
+    swapAndSendTo: ({ expiration, inputAmount, inputToken, minToken, recipient }: {
         expiration?: Expiration;
         inputAmount: Uint128;
         inputToken: TokenSelect;
         minToken: Uint128;
-        recipient: Addr;
+        recipient: string;
+    }, fee?: number | StdFee | "auto", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
+    updateConfig: ({ lpFeePercent, owner, protocolFeePercent, protocolFeeRecipient }: {
+        lpFeePercent: Decimal;
+        owner?: string;
+        protocolFeePercent: Decimal;
+        protocolFeeRecipient: string;
     }, fee?: number | StdFee | "auto", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
 }
 export declare class JunoSwapClient extends JunoSwapQueryClient implements JunoSwapInterface {
@@ -92,29 +93,30 @@ export declare class JunoSwapClient extends JunoSwapQueryClient implements JunoS
         minToken1: Uint128;
         minToken2: Uint128;
     }, fee?: number | StdFee | "auto", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
-    swapToken1ForToken2: ({ expiration, minToken2, token1Amount }: {
+    swap: ({ expiration, inputAmount, inputToken, minOutput }: {
         expiration?: Expiration;
-        minToken2: Uint128;
-        token1Amount: Uint128;
-    }, fee?: number | StdFee | "auto", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
-    swapToken2ForToken1: ({ expiration, minToken1, token2Amount }: {
-        expiration?: Expiration;
-        minToken1: Uint128;
-        token2Amount: Uint128;
+        inputAmount: Uint128;
+        inputToken: TokenSelect;
+        minOutput: Uint128;
     }, fee?: number | StdFee | "auto", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
-    multiContractSwap: ({ expiration, inputToken, inputTokenAmount, outputAmmAddress, outputMinToken, outputToken }: {
+    passThroughSwap: ({ expiration, inputToken, inputTokenAmount, outputAmmAddress, outputMinToken }: {
         expiration?: Expiration;
         inputToken: TokenSelect;
         inputTokenAmount: Uint128;
-        outputAmmAddress: Addr;
+        outputAmmAddress: string;
         outputMinToken: Uint128;
-        outputToken: TokenSelect;
     }, fee?: number | StdFee | "auto", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
-    swapTo: ({ expiration, inputAmount, inputToken, minToken, recipient }: {
+    swapAndSendTo: ({ expiration, inputAmount, inputToken, minToken, recipient }: {
         expiration?: Expiration;
         inputAmount: Uint128;
         inputToken: TokenSelect;
         minToken: Uint128;
-        recipient: Addr;
+        recipient: string;
+    }, fee?: number | StdFee | "auto", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
+    updateConfig: ({ lpFeePercent, owner, protocolFeePercent, protocolFeeRecipient }: {
+        lpFeePercent: Decimal;
+        owner?: string;
+        protocolFeePercent: Decimal;
+        protocolFeeRecipient: string;
     }, fee?: number | StdFee | "auto", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
 }

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

@@ -25,36 +25,37 @@ export declare type ExecuteMsg = {
         [k: string]: unknown;
     };
 } | {
-    swap_token1_for_token2: {
+    swap: {
         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;
+        input_amount: Uint128;
+        input_token: TokenSelect;
+        min_output: Uint128;
         [k: string]: unknown;
     };
 } | {
-    multi_contract_swap: {
+    pass_through_swap: {
         expiration?: Expiration | null;
         input_token: TokenSelect;
         input_token_amount: Uint128;
-        output_amm_address: Addr;
+        output_amm_address: string;
         output_min_token: Uint128;
-        output_token: TokenSelect;
         [k: string]: unknown;
     };
 } | {
-    swap_to: {
+    swap_and_send_to: {
         expiration?: Expiration | null;
         input_amount: Uint128;
         input_token: TokenSelect;
         min_token: Uint128;
-        recipient: Addr;
+        recipient: string;
+        [k: string]: unknown;
+    };
+} | {
+    update_config: {
+        lp_fee_percent: Decimal;
+        owner?: string | null;
+        protocol_fee_percent: Decimal;
+        protocol_fee_recipient: string;
         [k: string]: unknown;
     };
 };
@@ -70,22 +71,40 @@ export declare type Expiration = {
 export declare type Timestamp = Uint64;
 export declare type Uint64 = string;
 export declare type TokenSelect = "Token1" | "Token2";
+export declare type Decimal = string;
+export declare type Denom = {
+    native: string;
+} | {
+    cw20: Addr;
+};
 export declare type Addr = string;
 export interface InfoResponse {
+    lp_fee_percent: Decimal;
+    lp_token_address: string;
     lp_token_supply: Uint128;
-    token1_address?: string | null;
-    token1_denom: string;
+    owner?: string | null;
+    protocol_fee_percent: Decimal;
+    protocol_fee_recipient: string;
+    token1_denom: Denom;
     token1_reserve: Uint128;
-    token2_address?: string | null;
-    token2_denom: string;
+    token2_denom: Denom;
     token2_reserve: Uint128;
     [k: string]: unknown;
 }
 export interface InstantiateMsg {
-    token1_address?: Addr | null;
-    token1_denom: string;
-    token2_address?: Addr | null;
-    token2_denom: string;
+    lp_fee_percent: Decimal;
+    lp_token_code_id: number;
+    owner?: string | null;
+    protocol_fee_percent: Decimal;
+    protocol_fee_recipient: string;
+    token1_denom: Denom;
+    token2_denom: Denom;
+    [k: string]: unknown;
+}
+export interface MigrateMsg {
+    lp_fee_percent: Decimal;
+    protocol_fee_percent: Decimal;
+    protocol_fee_recipient: string;
     [k: string]: unknown;
 }
 export declare type QueryMsg = {
@@ -109,8 +128,7 @@ export declare type QueryMsg = {
     };
 };
 export interface Token {
-    address?: Addr | null;
-    denom: string;
+    denom: Denom;
     reserve: Uint128;
     [k: string]: unknown;
 }