juno-network 0.11.0 → 0.14.0

package/src/codegen/osmosis/tokenfactory/v1beta1/tx.rpc.msg.ts

@@ -0,0 +1,55 @@
+import { Rpc } from "../../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { MsgCreateDenom, MsgCreateDenomResponse, MsgMint, MsgMintResponse, MsgBurn, MsgBurnResponse, MsgChangeAdmin, MsgChangeAdminResponse, MsgSetDenomMetadata, MsgSetDenomMetadataResponse } from "./tx";
+/** Msg defines the tokefactory module's gRPC message service. */
+
+export interface Msg {
+  createDenom(request: MsgCreateDenom): Promise<MsgCreateDenomResponse>;
+  mint(request: MsgMint): Promise<MsgMintResponse>;
+  burn(request: MsgBurn): Promise<MsgBurnResponse>;
+  changeAdmin(request: MsgChangeAdmin): Promise<MsgChangeAdminResponse>;
+  setDenomMetadata(request: MsgSetDenomMetadata): Promise<MsgSetDenomMetadataResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.createDenom = this.createDenom.bind(this);
+    this.mint = this.mint.bind(this);
+    this.burn = this.burn.bind(this);
+    this.changeAdmin = this.changeAdmin.bind(this);
+    this.setDenomMetadata = this.setDenomMetadata.bind(this);
+  }
+
+  createDenom(request: MsgCreateDenom): Promise<MsgCreateDenomResponse> {
+    const data = MsgCreateDenom.encode(request).finish();
+    const promise = this.rpc.request("osmosis.tokenfactory.v1beta1.Msg", "CreateDenom", data);
+    return promise.then(data => MsgCreateDenomResponse.decode(new _m0.Reader(data)));
+  }
+
+  mint(request: MsgMint): Promise<MsgMintResponse> {
+    const data = MsgMint.encode(request).finish();
+    const promise = this.rpc.request("osmosis.tokenfactory.v1beta1.Msg", "Mint", data);
+    return promise.then(data => MsgMintResponse.decode(new _m0.Reader(data)));
+  }
+
+  burn(request: MsgBurn): Promise<MsgBurnResponse> {
+    const data = MsgBurn.encode(request).finish();
+    const promise = this.rpc.request("osmosis.tokenfactory.v1beta1.Msg", "Burn", data);
+    return promise.then(data => MsgBurnResponse.decode(new _m0.Reader(data)));
+  }
+
+  changeAdmin(request: MsgChangeAdmin): Promise<MsgChangeAdminResponse> {
+    const data = MsgChangeAdmin.encode(request).finish();
+    const promise = this.rpc.request("osmosis.tokenfactory.v1beta1.Msg", "ChangeAdmin", data);
+    return promise.then(data => MsgChangeAdminResponse.decode(new _m0.Reader(data)));
+  }
+
+  setDenomMetadata(request: MsgSetDenomMetadata): Promise<MsgSetDenomMetadataResponse> {
+    const data = MsgSetDenomMetadata.encode(request).finish();
+    const promise = this.rpc.request("osmosis.tokenfactory.v1beta1.Msg", "SetDenomMetadata", data);
+    return promise.then(data => MsgSetDenomMetadataResponse.decode(new _m0.Reader(data)));
+  }
+
+}

package/src/codegen/osmosis/tokenfactory/v1beta1/tx.ts

@@ -0,0 +1,622 @@
+import { Coin, CoinSDKType } from "../../../cosmos/base/v1beta1/coin";
+import { Metadata, MetadataSDKType } from "../../../cosmos/bank/v1beta1/bank";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/**
+ * MsgCreateDenom defines the message structure for the CreateDenom gRPC service
+ * method. It allows an account to create a new denom. It requires a sender
+ * address and a sub denomination. The (sender_address, sub_denomination) tuple
+ * must be unique and cannot be re-used.
+ * 
+ * The resulting denom created is defined as
+ * <factory/{creatorAddress}/{subdenom}>. The resulting denom's admin is
+ * originally set to be the creator, but this can be changed later. The token
+ * denom does not indicate the current admin.
+ */
+
+export interface MsgCreateDenom {
+  sender: string;
+  /** subdenom can be up to 44 "alphanumeric" characters long. */
+
+  subdenom: string;
+}
+/**
+ * MsgCreateDenom defines the message structure for the CreateDenom gRPC service
+ * method. It allows an account to create a new denom. It requires a sender
+ * address and a sub denomination. The (sender_address, sub_denomination) tuple
+ * must be unique and cannot be re-used.
+ * 
+ * The resulting denom created is defined as
+ * <factory/{creatorAddress}/{subdenom}>. The resulting denom's admin is
+ * originally set to be the creator, but this can be changed later. The token
+ * denom does not indicate the current admin.
+ */
+
+export interface MsgCreateDenomSDKType {
+  sender: string;
+  subdenom: string;
+}
+/**
+ * MsgCreateDenomResponse is the return value of MsgCreateDenom
+ * It returns the full string of the newly created denom
+ */
+
+export interface MsgCreateDenomResponse {
+  newTokenDenom: string;
+}
+/**
+ * MsgCreateDenomResponse is the return value of MsgCreateDenom
+ * It returns the full string of the newly created denom
+ */
+
+export interface MsgCreateDenomResponseSDKType {
+  new_token_denom: string;
+}
+/**
+ * MsgMint is the sdk.Msg type for allowing an admin account to mint
+ * more of a token.  For now, we only support minting to the sender account
+ */
+
+export interface MsgMint {
+  sender: string;
+  amount?: Coin;
+}
+/**
+ * MsgMint is the sdk.Msg type for allowing an admin account to mint
+ * more of a token.  For now, we only support minting to the sender account
+ */
+
+export interface MsgMintSDKType {
+  sender: string;
+  amount?: CoinSDKType;
+}
+export interface MsgMintResponse {}
+export interface MsgMintResponseSDKType {}
+/**
+ * MsgBurn is the sdk.Msg type for allowing an admin account to burn
+ * a token.  For now, we only support burning from the sender account.
+ */
+
+export interface MsgBurn {
+  sender: string;
+  amount?: Coin;
+}
+/**
+ * MsgBurn is the sdk.Msg type for allowing an admin account to burn
+ * a token.  For now, we only support burning from the sender account.
+ */
+
+export interface MsgBurnSDKType {
+  sender: string;
+  amount?: CoinSDKType;
+}
+export interface MsgBurnResponse {}
+export interface MsgBurnResponseSDKType {}
+/**
+ * MsgChangeAdmin is the sdk.Msg type for allowing an admin account to reassign
+ * adminship of a denom to a new account
+ */
+
+export interface MsgChangeAdmin {
+  sender: string;
+  denom: string;
+  newAdmin: string;
+}
+/**
+ * MsgChangeAdmin is the sdk.Msg type for allowing an admin account to reassign
+ * adminship of a denom to a new account
+ */
+
+export interface MsgChangeAdminSDKType {
+  sender: string;
+  denom: string;
+  new_admin: string;
+}
+/**
+ * MsgChangeAdminResponse defines the response structure for an executed
+ * MsgChangeAdmin message.
+ */
+
+export interface MsgChangeAdminResponse {}
+/**
+ * MsgChangeAdminResponse defines the response structure for an executed
+ * MsgChangeAdmin message.
+ */
+
+export interface MsgChangeAdminResponseSDKType {}
+/**
+ * MsgSetDenomMetadata is the sdk.Msg type for allowing an admin account to set
+ * the denom's bank metadata
+ */
+
+export interface MsgSetDenomMetadata {
+  sender: string;
+  metadata?: Metadata;
+}
+/**
+ * MsgSetDenomMetadata is the sdk.Msg type for allowing an admin account to set
+ * the denom's bank metadata
+ */
+
+export interface MsgSetDenomMetadataSDKType {
+  sender: string;
+  metadata?: MetadataSDKType;
+}
+/**
+ * MsgSetDenomMetadataResponse defines the response structure for an executed
+ * MsgSetDenomMetadata message.
+ */
+
+export interface MsgSetDenomMetadataResponse {}
+/**
+ * MsgSetDenomMetadataResponse defines the response structure for an executed
+ * MsgSetDenomMetadata message.
+ */
+
+export interface MsgSetDenomMetadataResponseSDKType {}
+
+function createBaseMsgCreateDenom(): MsgCreateDenom {
+  return {
+    sender: "",
+    subdenom: ""
+  };
+}
+
+export const MsgCreateDenom = {
+  encode(message: MsgCreateDenom, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.sender !== "") {
+      writer.uint32(10).string(message.sender);
+    }
+
+    if (message.subdenom !== "") {
+      writer.uint32(18).string(message.subdenom);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreateDenom {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgCreateDenom();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.sender = reader.string();
+          break;
+
+        case 2:
+          message.subdenom = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgCreateDenom>): MsgCreateDenom {
+    const message = createBaseMsgCreateDenom();
+    message.sender = object.sender ?? "";
+    message.subdenom = object.subdenom ?? "";
+    return message;
+  }
+
+};
+
+function createBaseMsgCreateDenomResponse(): MsgCreateDenomResponse {
+  return {
+    newTokenDenom: ""
+  };
+}
+
+export const MsgCreateDenomResponse = {
+  encode(message: MsgCreateDenomResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.newTokenDenom !== "") {
+      writer.uint32(10).string(message.newTokenDenom);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreateDenomResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgCreateDenomResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.newTokenDenom = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgCreateDenomResponse>): MsgCreateDenomResponse {
+    const message = createBaseMsgCreateDenomResponse();
+    message.newTokenDenom = object.newTokenDenom ?? "";
+    return message;
+  }
+
+};
+
+function createBaseMsgMint(): MsgMint {
+  return {
+    sender: "",
+    amount: undefined
+  };
+}
+
+export const MsgMint = {
+  encode(message: MsgMint, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.sender !== "") {
+      writer.uint32(10).string(message.sender);
+    }
+
+    if (message.amount !== undefined) {
+      Coin.encode(message.amount, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgMint {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgMint();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.sender = reader.string();
+          break;
+
+        case 2:
+          message.amount = Coin.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgMint>): MsgMint {
+    const message = createBaseMsgMint();
+    message.sender = object.sender ?? "";
+    message.amount = object.amount !== undefined && object.amount !== null ? Coin.fromPartial(object.amount) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseMsgMintResponse(): MsgMintResponse {
+  return {};
+}
+
+export const MsgMintResponse = {
+  encode(_: MsgMintResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgMintResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgMintResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgMintResponse>): MsgMintResponse {
+    const message = createBaseMsgMintResponse();
+    return message;
+  }
+
+};
+
+function createBaseMsgBurn(): MsgBurn {
+  return {
+    sender: "",
+    amount: undefined
+  };
+}
+
+export const MsgBurn = {
+  encode(message: MsgBurn, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.sender !== "") {
+      writer.uint32(10).string(message.sender);
+    }
+
+    if (message.amount !== undefined) {
+      Coin.encode(message.amount, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgBurn {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgBurn();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.sender = reader.string();
+          break;
+
+        case 2:
+          message.amount = Coin.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgBurn>): MsgBurn {
+    const message = createBaseMsgBurn();
+    message.sender = object.sender ?? "";
+    message.amount = object.amount !== undefined && object.amount !== null ? Coin.fromPartial(object.amount) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseMsgBurnResponse(): MsgBurnResponse {
+  return {};
+}
+
+export const MsgBurnResponse = {
+  encode(_: MsgBurnResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgBurnResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgBurnResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgBurnResponse>): MsgBurnResponse {
+    const message = createBaseMsgBurnResponse();
+    return message;
+  }
+
+};
+
+function createBaseMsgChangeAdmin(): MsgChangeAdmin {
+  return {
+    sender: "",
+    denom: "",
+    newAdmin: ""
+  };
+}
+
+export const MsgChangeAdmin = {
+  encode(message: MsgChangeAdmin, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.sender !== "") {
+      writer.uint32(10).string(message.sender);
+    }
+
+    if (message.denom !== "") {
+      writer.uint32(18).string(message.denom);
+    }
+
+    if (message.newAdmin !== "") {
+      writer.uint32(26).string(message.newAdmin);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgChangeAdmin {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgChangeAdmin();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.sender = reader.string();
+          break;
+
+        case 2:
+          message.denom = reader.string();
+          break;
+
+        case 3:
+          message.newAdmin = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgChangeAdmin>): MsgChangeAdmin {
+    const message = createBaseMsgChangeAdmin();
+    message.sender = object.sender ?? "";
+    message.denom = object.denom ?? "";
+    message.newAdmin = object.newAdmin ?? "";
+    return message;
+  }
+
+};
+
+function createBaseMsgChangeAdminResponse(): MsgChangeAdminResponse {
+  return {};
+}
+
+export const MsgChangeAdminResponse = {
+  encode(_: MsgChangeAdminResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgChangeAdminResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgChangeAdminResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgChangeAdminResponse>): MsgChangeAdminResponse {
+    const message = createBaseMsgChangeAdminResponse();
+    return message;
+  }
+
+};
+
+function createBaseMsgSetDenomMetadata(): MsgSetDenomMetadata {
+  return {
+    sender: "",
+    metadata: undefined
+  };
+}
+
+export const MsgSetDenomMetadata = {
+  encode(message: MsgSetDenomMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.sender !== "") {
+      writer.uint32(10).string(message.sender);
+    }
+
+    if (message.metadata !== undefined) {
+      Metadata.encode(message.metadata, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgSetDenomMetadata {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSetDenomMetadata();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.sender = reader.string();
+          break;
+
+        case 2:
+          message.metadata = Metadata.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgSetDenomMetadata>): MsgSetDenomMetadata {
+    const message = createBaseMsgSetDenomMetadata();
+    message.sender = object.sender ?? "";
+    message.metadata = object.metadata !== undefined && object.metadata !== null ? Metadata.fromPartial(object.metadata) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseMsgSetDenomMetadataResponse(): MsgSetDenomMetadataResponse {
+  return {};
+}
+
+export const MsgSetDenomMetadataResponse = {
+  encode(_: MsgSetDenomMetadataResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgSetDenomMetadataResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSetDenomMetadataResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgSetDenomMetadataResponse>): MsgSetDenomMetadataResponse {
+    const message = createBaseMsgSetDenomMetadataResponse();
+    return message;
+  }
+
+};

package/src/codegen/router/bundle.ts

@@ -0,0 +1,16 @@
+import * as _92 from "./v1/genesis";
+import * as _93 from "./v1/query";
+import * as _177 from "./v1/query.lcd";
+import * as _178 from "./v1/query.rpc.Query";
+import * as _194 from "./lcd";
+import * as _195 from "./rpc.query";
+export namespace router {
+  export const v1 = { ..._92,
+    ..._93,
+    ..._177,
+    ..._178
+  };
+  export const ClientFactory = { ..._194,
+    ..._195
+  };
+}