juno-network 0.5.3 → 0.6.0

package/module/codegen/tendermint/types/validator.js

@@ -0,0 +1,202 @@
+import { PublicKey } from "../crypto/keys";
+import * as _m0 from "protobufjs/minimal";
+import { Long } from "@osmonauts/helpers";
+
+function createBaseValidatorSet() {
+  return {
+    validators: [],
+    proposer: undefined,
+    totalVotingPower: Long.ZERO
+  };
+}
+
+export const ValidatorSet = {
+  encode(message, writer = _m0.Writer.create()) {
+    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, length) {
+    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();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object) {
+    var _object$validators;
+
+    const message = createBaseValidatorSet();
+    message.validators = ((_object$validators = object.validators) === null || _object$validators === void 0 ? void 0 : _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() {
+  return {
+    address: new Uint8Array(),
+    pubKey: undefined,
+    votingPower: Long.ZERO,
+    proposerPriority: Long.ZERO
+  };
+}
+
+export const Validator = {
+  encode(message, writer = _m0.Writer.create()) {
+    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, length) {
+    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();
+          break;
+
+        case 4:
+          message.proposerPriority = reader.int64();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object) {
+    var _object$address;
+
+    const message = createBaseValidator();
+    message.address = (_object$address = object.address) !== null && _object$address !== void 0 ? _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() {
+  return {
+    pubKey: undefined,
+    votingPower: Long.ZERO
+  };
+}
+
+export const SimpleValidator = {
+  encode(message, writer = _m0.Writer.create()) {
+    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, length) {
+    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();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object) {
+    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/module/codegen/tendermint/version/types.js

@@ -0,0 +1,119 @@
+import * as _m0 from "protobufjs/minimal";
+import { Long } 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.
+ */
+
+function createBaseApp() {
+  return {
+    protocol: Long.UZERO,
+    software: ""
+  };
+}
+
+export const App = {
+  encode(message, writer = _m0.Writer.create()) {
+    if (!message.protocol.isZero()) {
+      writer.uint32(8).uint64(message.protocol);
+    }
+
+    if (message.software !== "") {
+      writer.uint32(18).string(message.software);
+    }
+
+    return writer;
+  },
+
+  decode(input, length) {
+    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();
+          break;
+
+        case 2:
+          message.software = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object) {
+    var _object$software;
+
+    const message = createBaseApp();
+    message.protocol = object.protocol !== undefined && object.protocol !== null ? Long.fromValue(object.protocol) : Long.UZERO;
+    message.software = (_object$software = object.software) !== null && _object$software !== void 0 ? _object$software : "";
+    return message;
+  }
+
+};
+
+function createBaseConsensus() {
+  return {
+    block: Long.UZERO,
+    app: Long.UZERO
+  };
+}
+
+export const Consensus = {
+  encode(message, writer = _m0.Writer.create()) {
+    if (!message.block.isZero()) {
+      writer.uint32(8).uint64(message.block);
+    }
+
+    if (!message.app.isZero()) {
+      writer.uint32(16).uint64(message.app);
+    }
+
+    return writer;
+  },
+
+  decode(input, length) {
+    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();
+          break;
+
+        case 2:
+          message.app = reader.uint64();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object) {
+    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/module/index.js

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

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "juno-network",
-  "version": "0.5.3",
+  "version": "0.6.0",
   "description": "juno",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "homepage": "https://github.com/CosmosContracts/typescript#readme",
   "license": "SEE LICENSE IN LICENSE",
   "main": "main/index.js",
+  "module": "module/index.js",
   "typings": "types/index.d.ts",
   "directories": {
     "lib": "src",
@@ -13,11 +14,15 @@
   },
   "files": [
     "types",
+    "module",
+    "src",
     "main"
   ],
   "scripts": {
-    "build": "cross-env BABEL_ENV=production babel src --out-dir main --delete-dir-on-start --extensions \".tsx,.ts,.js\"",
+    "build:main": "cross-env BABEL_ENV=production babel src --out-dir main --delete-dir-on-start --extensions \".tsx,.ts,.js\"",
+    "build:module": "cross-env MODULE=true babel src --out-dir module --delete-dir-on-start  --extensions \".tsx,.ts,.js\"",
     "build:ts": "tsc --project ./tsconfig.json",
+    "build": "npm run build:module && npm run build:main",
     "buidl": "npm run build && npm run build:ts",
     "codegen": "cross-env NODE_ENV=development babel-node scripts/codegen.js",
     "prepare": "npm run build",
@@ -86,5 +91,5 @@
     "@osmonauts/lcd": "0.6.0",
     "protobufjs": "^6.11.2"
   },
-  "gitHead": "6cda1181da55359dceb211b734c91207548da992"
+  "gitHead": "b48c5381ae5cdf85fd8c469ab5a740cf9231cc06"
 }

package/src/codegen/JunoSwap.client.ts

@@ -0,0 +1,299 @@
+/**
+* This file was automatically generated by @cosmwasm/ts-codegen@0.16.1.
+* 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 { CosmWasmClient, SigningCosmWasmClient, ExecuteResult } from "@cosmjs/cosmwasm-stargate";
+import { Coin, StdFee } from "@cosmjs/amino";
+import { Uint128, BalanceResponse, ExecuteMsg, Expiration, Timestamp, Uint64, TokenSelect, Decimal, Denom, Addr, InfoResponse, InstantiateMsg, MigrateMsg, QueryMsg, Token, Token1ForToken2PriceResponse, Token2ForToken1PriceResponse } from "./JunoSwap.types";
+export interface JunoSwapReadOnlyInterface {
+  contractAddress: string;
+  balance: ({
+    address
+  }: {
+    address: string;
+  }) => Promise<BalanceResponse>;
+  info: () => Promise<InfoResponse>;
+  token1ForToken2Price: ({
+    token1Amount
+  }: {
+    token1Amount: Uint128;
+  }) => Promise<Token1ForToken2PriceResponse>;
+  token2ForToken1Price: ({
+    token2Amount
+  }: {
+    token2Amount: Uint128;
+  }) => Promise<Token2ForToken1PriceResponse>;
+}
+export class JunoSwapQueryClient implements JunoSwapReadOnlyInterface {
+  client: CosmWasmClient;
+  contractAddress: string;
+
+  constructor(client: CosmWasmClient, contractAddress: string) {
+    this.client = client;
+    this.contractAddress = contractAddress;
+    this.balance = this.balance.bind(this);
+    this.info = this.info.bind(this);
+    this.token1ForToken2Price = this.token1ForToken2Price.bind(this);
+    this.token2ForToken1Price = this.token2ForToken1Price.bind(this);
+  }
+
+  balance = async ({
+    address
+  }: {
+    address: string;
+  }): Promise<BalanceResponse> => {
+    return this.client.queryContractSmart(this.contractAddress, {
+      balance: {
+        address
+      }
+    });
+  };
+  info = async (): Promise<InfoResponse> => {
+    return this.client.queryContractSmart(this.contractAddress, {
+      info: {}
+    });
+  };
+  token1ForToken2Price = async ({
+    token1Amount
+  }: {
+    token1Amount: Uint128;
+  }): Promise<Token1ForToken2PriceResponse> => {
+    return this.client.queryContractSmart(this.contractAddress, {
+      token1_for_token2_price: {
+        token1_amount: token1Amount
+      }
+    });
+  };
+  token2ForToken1Price = async ({
+    token2Amount
+  }: {
+    token2Amount: Uint128;
+  }): Promise<Token2ForToken1PriceResponse> => {
+    return this.client.queryContractSmart(this.contractAddress, {
+      token2_for_token1_price: {
+        token2_amount: token2Amount
+      }
+    });
+  };
+}
+export interface JunoSwapInterface extends JunoSwapReadOnlyInterface {
+  contractAddress: string;
+  sender: string;
+  addLiquidity: ({
+    expiration,
+    maxToken2,
+    minLiquidity,
+    token1Amount
+  }: {
+    expiration?: Expiration;
+    maxToken2: Uint128;
+    minLiquidity: Uint128;
+    token1Amount: Uint128;
+  }, fee?: number | StdFee | "auto", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
+  removeLiquidity: ({
+    amount,
+    expiration,
+    minToken1,
+    minToken2
+  }: {
+    amount: Uint128;
+    expiration?: Expiration;
+    minToken1: Uint128;
+    minToken2: Uint128;
+  }, fee?: number | StdFee | "auto", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
+  swap: ({
+    expiration,
+    inputAmount,
+    inputToken,
+    minOutput
+  }: {
+    expiration?: Expiration;
+    inputAmount: Uint128;
+    inputToken: TokenSelect;
+    minOutput: Uint128;
+  }, fee?: number | StdFee | "auto", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
+  passThroughSwap: ({
+    expiration,
+    inputToken,
+    inputTokenAmount,
+    outputAmmAddress,
+    outputMinToken
+  }: {
+    expiration?: Expiration;
+    inputToken: TokenSelect;
+    inputTokenAmount: Uint128;
+    outputAmmAddress: string;
+    outputMinToken: Uint128;
+  }, fee?: number | StdFee | "auto", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
+  swapAndSendTo: ({
+    expiration,
+    inputAmount,
+    inputToken,
+    minToken,
+    recipient
+  }: {
+    expiration?: Expiration;
+    inputAmount: Uint128;
+    inputToken: TokenSelect;
+    minToken: Uint128;
+    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 class JunoSwapClient extends JunoSwapQueryClient implements JunoSwapInterface {
+  client: SigningCosmWasmClient;
+  sender: string;
+  contractAddress: string;
+
+  constructor(client: SigningCosmWasmClient, sender: string, contractAddress: string) {
+    super(client, contractAddress);
+    this.client = client;
+    this.sender = sender;
+    this.contractAddress = contractAddress;
+    this.addLiquidity = this.addLiquidity.bind(this);
+    this.removeLiquidity = this.removeLiquidity.bind(this);
+    this.swap = this.swap.bind(this);
+    this.passThroughSwap = this.passThroughSwap.bind(this);
+    this.swapAndSendTo = this.swapAndSendTo.bind(this);
+    this.updateConfig = this.updateConfig.bind(this);
+  }
+
+  addLiquidity = async ({
+    expiration,
+    maxToken2,
+    minLiquidity,
+    token1Amount
+  }: {
+    expiration?: Expiration;
+    maxToken2: Uint128;
+    minLiquidity: Uint128;
+    token1Amount: Uint128;
+  }, fee: number | StdFee | "auto" = "auto", memo?: string, funds?: Coin[]): Promise<ExecuteResult> => {
+    return await this.client.execute(this.sender, this.contractAddress, {
+      add_liquidity: {
+        expiration,
+        max_token2: maxToken2,
+        min_liquidity: minLiquidity,
+        token1_amount: token1Amount
+      }
+    }, fee, memo, funds);
+  };
+  removeLiquidity = async ({
+    amount,
+    expiration,
+    minToken1,
+    minToken2
+  }: {
+    amount: Uint128;
+    expiration?: Expiration;
+    minToken1: Uint128;
+    minToken2: Uint128;
+  }, fee: number | StdFee | "auto" = "auto", memo?: string, funds?: Coin[]): Promise<ExecuteResult> => {
+    return await this.client.execute(this.sender, this.contractAddress, {
+      remove_liquidity: {
+        amount,
+        expiration,
+        min_token1: minToken1,
+        min_token2: minToken2
+      }
+    }, fee, memo, funds);
+  };
+  swap = async ({
+    expiration,
+    inputAmount,
+    inputToken,
+    minOutput
+  }: {
+    expiration?: Expiration;
+    inputAmount: Uint128;
+    inputToken: TokenSelect;
+    minOutput: Uint128;
+  }, fee: number | StdFee | "auto" = "auto", memo?: string, funds?: Coin[]): Promise<ExecuteResult> => {
+    return await this.client.execute(this.sender, this.contractAddress, {
+      swap: {
+        expiration,
+        input_amount: inputAmount,
+        input_token: inputToken,
+        min_output: minOutput
+      }
+    }, fee, memo, funds);
+  };
+  passThroughSwap = async ({
+    expiration,
+    inputToken,
+    inputTokenAmount,
+    outputAmmAddress,
+    outputMinToken
+  }: {
+    expiration?: Expiration;
+    inputToken: TokenSelect;
+    inputTokenAmount: Uint128;
+    outputAmmAddress: string;
+    outputMinToken: Uint128;
+  }, fee: number | StdFee | "auto" = "auto", memo?: string, funds?: Coin[]): Promise<ExecuteResult> => {
+    return await this.client.execute(this.sender, this.contractAddress, {
+      pass_through_swap: {
+        expiration,
+        input_token: inputToken,
+        input_token_amount: inputTokenAmount,
+        output_amm_address: outputAmmAddress,
+        output_min_token: outputMinToken
+      }
+    }, fee, memo, funds);
+  };
+  swapAndSendTo = async ({
+    expiration,
+    inputAmount,
+    inputToken,
+    minToken,
+    recipient
+  }: {
+    expiration?: Expiration;
+    inputAmount: Uint128;
+    inputToken: TokenSelect;
+    minToken: Uint128;
+    recipient: string;
+  }, fee: number | StdFee | "auto" = "auto", memo?: string, funds?: Coin[]): Promise<ExecuteResult> => {
+    return await this.client.execute(this.sender, this.contractAddress, {
+      swap_and_send_to: {
+        expiration,
+        input_amount: inputAmount,
+        input_token: inputToken,
+        min_token: minToken,
+        recipient
+      }
+    }, fee, memo, funds);
+  };
+  updateConfig = async ({
+    lpFeePercent,
+    owner,
+    protocolFeePercent,
+    protocolFeeRecipient
+  }: {
+    lpFeePercent: Decimal;
+    owner?: string;
+    protocolFeePercent: Decimal;
+    protocolFeeRecipient: string;
+  }, fee: number | StdFee | "auto" = "auto", memo?: string, funds?: Coin[]): Promise<ExecuteResult> => {
+    return await this.client.execute(this.sender, this.contractAddress, {
+      update_config: {
+        lp_fee_percent: lpFeePercent,
+        owner,
+        protocol_fee_percent: protocolFeePercent,
+        protocol_fee_recipient: protocolFeeRecipient
+      }
+    }, fee, memo, funds);
+  };
+}