juno-network 0.5.3 → 0.6.0

package/src/codegen/cosmos/auth/v1beta1/auth.ts

@@ -0,0 +1,316 @@
+import { Any } from "../../../google/protobuf/any";
+import * as _m0 from "protobufjs/minimal";
+import { Long, isSet, DeepPartial } from "@osmonauts/helpers";
+
+/**
+ * BaseAccount defines a base account type. It contains all the necessary fields
+ * for basic account functionality. Any custom account type should extend this
+ * type for additional functionality (e.g. vesting).
+ */
+export interface BaseAccount {
+  address: string;
+  pub_key: Any;
+  account_number: Long;
+  sequence: Long;
+}
+
+/** ModuleAccount defines an account for modules that holds coins on a pool. */
+export interface ModuleAccount {
+  base_account: BaseAccount;
+  name: string;
+  permissions: string[];
+}
+
+/** Params defines the parameters for the auth module. */
+export interface Params {
+  max_memo_characters: Long;
+  tx_sig_limit: Long;
+  tx_size_cost_per_byte: Long;
+  sig_verify_cost_ed25519: Long;
+  sig_verify_cost_secp256k1: Long;
+}
+
+function createBaseBaseAccount(): BaseAccount {
+  return {
+    address: "",
+    pub_key: undefined,
+    account_number: Long.UZERO,
+    sequence: Long.UZERO
+  };
+}
+
+export const BaseAccount = {
+  encode(message: BaseAccount, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+
+    if (message.pub_key !== undefined) {
+      Any.encode(message.pub_key, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (!message.account_number.isZero()) {
+      writer.uint32(24).uint64(message.account_number);
+    }
+
+    if (!message.sequence.isZero()) {
+      writer.uint32(32).uint64(message.sequence);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): BaseAccount {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBaseAccount();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+
+        case 2:
+          message.pub_key = Any.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.account_number = (reader.uint64() as Long);
+          break;
+
+        case 4:
+          message.sequence = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): BaseAccount {
+    return {
+      address: isSet(object.address) ? String(object.address) : "",
+      pub_key: isSet(object.pub_key) ? Any.fromJSON(object.pub_key) : undefined,
+      account_number: isSet(object.account_number) ? Long.fromString(object.account_number) : Long.UZERO,
+      sequence: isSet(object.sequence) ? Long.fromString(object.sequence) : Long.UZERO
+    };
+  },
+
+  toJSON(message: BaseAccount): unknown {
+    const obj: any = {};
+    message.address !== undefined && (obj.address = message.address);
+    message.pub_key !== undefined && (obj.pub_key = message.pub_key ? Any.toJSON(message.pub_key) : undefined);
+    message.account_number !== undefined && (obj.account_number = (message.account_number || Long.UZERO).toString());
+    message.sequence !== undefined && (obj.sequence = (message.sequence || Long.UZERO).toString());
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<BaseAccount>): BaseAccount {
+    const message = createBaseBaseAccount();
+    message.address = object.address ?? "";
+    message.pub_key = object.pub_key !== undefined && object.pub_key !== null ? Any.fromPartial(object.pub_key) : undefined;
+    message.account_number = object.account_number !== undefined && object.account_number !== null ? Long.fromValue(object.account_number) : Long.UZERO;
+    message.sequence = object.sequence !== undefined && object.sequence !== null ? Long.fromValue(object.sequence) : Long.UZERO;
+    return message;
+  }
+
+};
+
+function createBaseModuleAccount(): ModuleAccount {
+  return {
+    base_account: undefined,
+    name: "",
+    permissions: []
+  };
+}
+
+export const ModuleAccount = {
+  encode(message: ModuleAccount, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.base_account !== undefined) {
+      BaseAccount.encode(message.base_account, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+
+    for (const v of message.permissions) {
+      writer.uint32(26).string(v!);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ModuleAccount {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseModuleAccount();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.base_account = BaseAccount.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.name = reader.string();
+          break;
+
+        case 3:
+          message.permissions.push(reader.string());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): ModuleAccount {
+    return {
+      base_account: isSet(object.base_account) ? BaseAccount.fromJSON(object.base_account) : undefined,
+      name: isSet(object.name) ? String(object.name) : "",
+      permissions: Array.isArray(object?.permissions) ? object.permissions.map((e: any) => String(e)) : []
+    };
+  },
+
+  toJSON(message: ModuleAccount): unknown {
+    const obj: any = {};
+    message.base_account !== undefined && (obj.base_account = message.base_account ? BaseAccount.toJSON(message.base_account) : undefined);
+    message.name !== undefined && (obj.name = message.name);
+
+    if (message.permissions) {
+      obj.permissions = message.permissions.map(e => e);
+    } else {
+      obj.permissions = [];
+    }
+
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<ModuleAccount>): ModuleAccount {
+    const message = createBaseModuleAccount();
+    message.base_account = object.base_account !== undefined && object.base_account !== null ? BaseAccount.fromPartial(object.base_account) : undefined;
+    message.name = object.name ?? "";
+    message.permissions = object.permissions?.map(e => e) || [];
+    return message;
+  }
+
+};
+
+function createBaseParams(): Params {
+  return {
+    max_memo_characters: Long.UZERO,
+    tx_sig_limit: Long.UZERO,
+    tx_size_cost_per_byte: Long.UZERO,
+    sig_verify_cost_ed25519: Long.UZERO,
+    sig_verify_cost_secp256k1: Long.UZERO
+  };
+}
+
+export const Params = {
+  encode(message: Params, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (!message.max_memo_characters.isZero()) {
+      writer.uint32(8).uint64(message.max_memo_characters);
+    }
+
+    if (!message.tx_sig_limit.isZero()) {
+      writer.uint32(16).uint64(message.tx_sig_limit);
+    }
+
+    if (!message.tx_size_cost_per_byte.isZero()) {
+      writer.uint32(24).uint64(message.tx_size_cost_per_byte);
+    }
+
+    if (!message.sig_verify_cost_ed25519.isZero()) {
+      writer.uint32(32).uint64(message.sig_verify_cost_ed25519);
+    }
+
+    if (!message.sig_verify_cost_secp256k1.isZero()) {
+      writer.uint32(40).uint64(message.sig_verify_cost_secp256k1);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Params {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseParams();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.max_memo_characters = (reader.uint64() as Long);
+          break;
+
+        case 2:
+          message.tx_sig_limit = (reader.uint64() as Long);
+          break;
+
+        case 3:
+          message.tx_size_cost_per_byte = (reader.uint64() as Long);
+          break;
+
+        case 4:
+          message.sig_verify_cost_ed25519 = (reader.uint64() as Long);
+          break;
+
+        case 5:
+          message.sig_verify_cost_secp256k1 = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): Params {
+    return {
+      max_memo_characters: isSet(object.max_memo_characters) ? Long.fromString(object.max_memo_characters) : Long.UZERO,
+      tx_sig_limit: isSet(object.tx_sig_limit) ? Long.fromString(object.tx_sig_limit) : Long.UZERO,
+      tx_size_cost_per_byte: isSet(object.tx_size_cost_per_byte) ? Long.fromString(object.tx_size_cost_per_byte) : Long.UZERO,
+      sig_verify_cost_ed25519: isSet(object.sig_verify_cost_ed25519) ? Long.fromString(object.sig_verify_cost_ed25519) : Long.UZERO,
+      sig_verify_cost_secp256k1: isSet(object.sig_verify_cost_secp256k1) ? Long.fromString(object.sig_verify_cost_secp256k1) : Long.UZERO
+    };
+  },
+
+  toJSON(message: Params): unknown {
+    const obj: any = {};
+    message.max_memo_characters !== undefined && (obj.max_memo_characters = (message.max_memo_characters || Long.UZERO).toString());
+    message.tx_sig_limit !== undefined && (obj.tx_sig_limit = (message.tx_sig_limit || Long.UZERO).toString());
+    message.tx_size_cost_per_byte !== undefined && (obj.tx_size_cost_per_byte = (message.tx_size_cost_per_byte || Long.UZERO).toString());
+    message.sig_verify_cost_ed25519 !== undefined && (obj.sig_verify_cost_ed25519 = (message.sig_verify_cost_ed25519 || Long.UZERO).toString());
+    message.sig_verify_cost_secp256k1 !== undefined && (obj.sig_verify_cost_secp256k1 = (message.sig_verify_cost_secp256k1 || Long.UZERO).toString());
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<Params>): Params {
+    const message = createBaseParams();
+    message.max_memo_characters = object.max_memo_characters !== undefined && object.max_memo_characters !== null ? Long.fromValue(object.max_memo_characters) : Long.UZERO;
+    message.tx_sig_limit = object.tx_sig_limit !== undefined && object.tx_sig_limit !== null ? Long.fromValue(object.tx_sig_limit) : Long.UZERO;
+    message.tx_size_cost_per_byte = object.tx_size_cost_per_byte !== undefined && object.tx_size_cost_per_byte !== null ? Long.fromValue(object.tx_size_cost_per_byte) : Long.UZERO;
+    message.sig_verify_cost_ed25519 = object.sig_verify_cost_ed25519 !== undefined && object.sig_verify_cost_ed25519 !== null ? Long.fromValue(object.sig_verify_cost_ed25519) : Long.UZERO;
+    message.sig_verify_cost_secp256k1 = object.sig_verify_cost_secp256k1 !== undefined && object.sig_verify_cost_secp256k1 !== null ? Long.fromValue(object.sig_verify_cost_secp256k1) : Long.UZERO;
+    return message;
+  }
+
+};

package/src/codegen/cosmos/auth/v1beta1/genesis.ts

@@ -0,0 +1,88 @@
+import { Params } from "./auth";
+import { Any } from "../../../google/protobuf/any";
+import * as _m0 from "protobufjs/minimal";
+import { isSet, DeepPartial } from "@osmonauts/helpers";
+
+/** GenesisState defines the auth module's genesis state. */
+export interface GenesisState {
+  /** params defines all the paramaters of the module. */
+  params: Params;
+
+  /** accounts are the accounts present at genesis. */
+  accounts: Any[];
+}
+
+function createBaseGenesisState(): GenesisState {
+  return {
+    params: undefined,
+    accounts: []
+  };
+}
+
+export const GenesisState = {
+  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+    }
+
+    for (const v of message.accounts) {
+      Any.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisState();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.params = Params.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.accounts.push(Any.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): GenesisState {
+    return {
+      params: isSet(object.params) ? Params.fromJSON(object.params) : undefined,
+      accounts: Array.isArray(object?.accounts) ? object.accounts.map((e: any) => Any.fromJSON(e)) : []
+    };
+  },
+
+  toJSON(message: GenesisState): unknown {
+    const obj: any = {};
+    message.params !== undefined && (obj.params = message.params ? Params.toJSON(message.params) : undefined);
+
+    if (message.accounts) {
+      obj.accounts = message.accounts.map(e => e ? Any.toJSON(e) : undefined);
+    } else {
+      obj.accounts = [];
+    }
+
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    message.accounts = object.accounts?.map(e => Any.fromPartial(e)) || [];
+    return message;
+  }
+
+};

package/src/codegen/cosmos/auth/v1beta1/query.lcd.ts

@@ -0,0 +1,72 @@
+import { PageRequest, PageResponse } from "../../base/query/v1beta1/pagination";
+import { Any } from "../../../google/protobuf/any";
+import { Params } from "./auth";
+import { setPaginationParams } from "@osmonauts/helpers";
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryAccountsRequest, QueryAccountsResponse, QueryAccountRequest, QueryAccountResponse, QueryParamsRequest, QueryParamsResponse, QueryModuleAccountsRequest, QueryModuleAccountsResponse, Bech32PrefixRequest, Bech32PrefixResponse, AddressBytesToStringRequest, AddressBytesToStringResponse, AddressStringToBytesRequest, AddressStringToBytesResponse } from "./query";
+export class LCDQueryClient extends LCDClient {
+  constructor({
+    restEndpoint
+  }: {
+    restEndpoint: string;
+  }) {
+    super({
+      restEndpoint
+    });
+  }
+
+  /* Accounts returns all the existing accounts
+  
+  Since: cosmos-sdk 0.43 */
+  async accounts(params: QueryAccountsRequest = {
+    pagination: undefined
+  }): Promise<QueryAccountsResponse> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `cosmos/auth/v1beta1/accounts`;
+    return await this.get<QueryAccountsResponse>(endpoint, options);
+  }
+
+  /* Account returns account details based on address. */
+  async account(params: QueryAccountRequest): Promise<QueryAccountResponse> {
+    const endpoint = `cosmos/auth/v1beta1/accounts/${params.address}`;
+    return await this.get<QueryAccountResponse>(endpoint);
+  }
+
+  /* Params queries all parameters. */
+  async params(_params: QueryParamsRequest = {}): Promise<QueryParamsResponse> {
+    const endpoint = `cosmos/auth/v1beta1/params`;
+    return await this.get<QueryParamsResponse>(endpoint);
+  }
+
+  /* ModuleAccounts returns all the existing module accounts. */
+  async moduleAccounts(_params: QueryModuleAccountsRequest = {}): Promise<QueryModuleAccountsResponse> {
+    const endpoint = `cosmos/auth/v1beta1/module_accounts`;
+    return await this.get<QueryModuleAccountsResponse>(endpoint);
+  }
+
+  /* Bech32 queries bech32Prefix */
+  async bech32Prefix(_params: Bech32PrefixRequest = {}): Promise<Bech32PrefixResponse> {
+    const endpoint = `cosmos/auth/v1beta1/bech32`;
+    return await this.get<Bech32PrefixResponse>(endpoint);
+  }
+
+  /* AddressBytesToString converts Account Address bytes to string */
+  async addressBytesToString(params: AddressBytesToStringRequest): Promise<AddressBytesToStringResponse> {
+    const endpoint = `cosmos/auth/v1beta1/bech32/${params.address_bytes}`;
+    return await this.get<AddressBytesToStringResponse>(endpoint);
+  }
+
+  /* AddressStringToBytes converts Address string to bytes */
+  async addressStringToBytes(params: AddressStringToBytesRequest): Promise<AddressStringToBytesResponse> {
+    const endpoint = `cosmos/auth/v1beta1/bech32/${params.address_string}`;
+    return await this.get<AddressStringToBytesResponse>(endpoint);
+  }
+
+}

package/src/codegen/cosmos/auth/v1beta1/query.rpc.query.ts

@@ -0,0 +1,90 @@
+import { PageRequest, PageResponse } from "../../base/query/v1beta1/pagination";
+import { Any } from "../../../google/protobuf/any";
+import { Params } from "./auth";
+import { Rpc } from "@osmonauts/helpers";
+import * as _m0 from "protobufjs/minimal";
+import { QueryAccountsRequest, QueryAccountsResponse, QueryAccountRequest, QueryAccountResponse, QueryParamsRequest, QueryParamsResponse, QueryModuleAccountsRequest, QueryModuleAccountsResponse, Bech32PrefixRequest, Bech32PrefixResponse, AddressBytesToStringRequest, AddressBytesToStringResponse, AddressStringToBytesRequest, AddressStringToBytesResponse } from "./query";
+
+/** Query defines the RPC service */
+export interface Query {
+  accounts(request: QueryAccountsRequest): Promise<QueryAccountsResponse>;
+  /*Accounts returns all the existing accounts
+  
+  Since: cosmos-sdk 0.43*/
+
+  account(request: QueryAccountRequest): Promise<QueryAccountResponse>;
+  /*Account returns account details based on address.*/
+
+  params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
+  /*Params queries all parameters.*/
+
+  moduleAccounts(request: QueryModuleAccountsRequest): Promise<QueryModuleAccountsResponse>;
+  /*ModuleAccounts returns all the existing module accounts.*/
+
+  bech32Prefix(request: Bech32PrefixRequest): Promise<Bech32PrefixResponse>;
+  /*Bech32 queries bech32Prefix*/
+
+  addressBytesToString(request: AddressBytesToStringRequest): Promise<AddressBytesToStringResponse>;
+  /*AddressBytesToString converts Account Address bytes to string*/
+
+  addressStringToBytes(request: AddressStringToBytesRequest): Promise<AddressStringToBytesResponse>;
+  /*AddressStringToBytes converts Address string to bytes*/
+
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.accounts = this.accounts.bind(this);
+    this.account = this.account.bind(this);
+    this.params = this.params.bind(this);
+    this.moduleAccounts = this.moduleAccounts.bind(this);
+    this.bech32Prefix = this.bech32Prefix.bind(this);
+    this.addressBytesToString = this.addressBytesToString.bind(this);
+    this.addressStringToBytes = this.addressStringToBytes.bind(this);
+  }
+
+  accounts(request: QueryAccountsRequest): Promise<QueryAccountsResponse> {
+    const data = QueryAccountsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.auth.v1beta1.Query", "Accounts", data);
+    return promise.then(data => QueryAccountsResponse.decode(new _m0.Reader(data)));
+  }
+
+  account(request: QueryAccountRequest): Promise<QueryAccountResponse> {
+    const data = QueryAccountRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.auth.v1beta1.Query", "Account", data);
+    return promise.then(data => QueryAccountResponse.decode(new _m0.Reader(data)));
+  }
+
+  params(request: QueryParamsRequest): Promise<QueryParamsResponse> {
+    const data = QueryParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.auth.v1beta1.Query", "Params", data);
+    return promise.then(data => QueryParamsResponse.decode(new _m0.Reader(data)));
+  }
+
+  moduleAccounts(request: QueryModuleAccountsRequest): Promise<QueryModuleAccountsResponse> {
+    const data = QueryModuleAccountsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.auth.v1beta1.Query", "ModuleAccounts", data);
+    return promise.then(data => QueryModuleAccountsResponse.decode(new _m0.Reader(data)));
+  }
+
+  bech32Prefix(request: Bech32PrefixRequest): Promise<Bech32PrefixResponse> {
+    const data = Bech32PrefixRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.auth.v1beta1.Query", "Bech32Prefix", data);
+    return promise.then(data => Bech32PrefixResponse.decode(new _m0.Reader(data)));
+  }
+
+  addressBytesToString(request: AddressBytesToStringRequest): Promise<AddressBytesToStringResponse> {
+    const data = AddressBytesToStringRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.auth.v1beta1.Query", "AddressBytesToString", data);
+    return promise.then(data => AddressBytesToStringResponse.decode(new _m0.Reader(data)));
+  }
+
+  addressStringToBytes(request: AddressStringToBytesRequest): Promise<AddressStringToBytesResponse> {
+    const data = AddressStringToBytesRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.auth.v1beta1.Query", "AddressStringToBytes", data);
+    return promise.then(data => AddressStringToBytesResponse.decode(new _m0.Reader(data)));
+  }
+
+}