juno-network 0.11.0 → 0.14.0

package/src/codegen/juno/feeshare/v1/feeshare.ts

@@ -0,0 +1,101 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/**
+ * FeeShare defines an instance that organizes fee distribution conditions for
+ * the owner of a given smart contract
+ */
+
+export interface FeeShare {
+  /**
+   * contract_address is the bech32 address of a registered contract in string
+   * form
+   */
+  contractAddress: string;
+  /**
+   * deployer_address is the bech32 address of message sender. It must be the
+   * same as the contracts admin address.
+   */
+
+  deployerAddress: string;
+  /**
+   * withdrawer_address is the bech32 address of account receiving the
+   * transaction fees.
+   */
+
+  withdrawerAddress: string;
+}
+/**
+ * FeeShare defines an instance that organizes fee distribution conditions for
+ * the owner of a given smart contract
+ */
+
+export interface FeeShareSDKType {
+  contract_address: string;
+  deployer_address: string;
+  withdrawer_address: string;
+}
+
+function createBaseFeeShare(): FeeShare {
+  return {
+    contractAddress: "",
+    deployerAddress: "",
+    withdrawerAddress: ""
+  };
+}
+
+export const FeeShare = {
+  encode(message: FeeShare, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.contractAddress !== "") {
+      writer.uint32(10).string(message.contractAddress);
+    }
+
+    if (message.deployerAddress !== "") {
+      writer.uint32(18).string(message.deployerAddress);
+    }
+
+    if (message.withdrawerAddress !== "") {
+      writer.uint32(26).string(message.withdrawerAddress);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): FeeShare {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFeeShare();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.contractAddress = reader.string();
+          break;
+
+        case 2:
+          message.deployerAddress = reader.string();
+          break;
+
+        case 3:
+          message.withdrawerAddress = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<FeeShare>): FeeShare {
+    const message = createBaseFeeShare();
+    message.contractAddress = object.contractAddress ?? "";
+    message.deployerAddress = object.deployerAddress ?? "";
+    message.withdrawerAddress = object.withdrawerAddress ?? "";
+    return message;
+  }
+
+};

package/src/codegen/juno/feeshare/v1/genesis.ts

@@ -0,0 +1,165 @@
+import { FeeShare, FeeShareSDKType } from "./feeshare";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/** GenesisState defines the module's genesis state. */
+
+export interface GenesisState {
+  /** params are the feeshare module parameters */
+  params?: Params;
+  /** FeeShare is a slice of active registered contracts for fee distribution */
+
+  feeShare: FeeShare[];
+}
+/** GenesisState defines the module's genesis state. */
+
+export interface GenesisStateSDKType {
+  params?: ParamsSDKType;
+  fee_share: FeeShareSDKType[];
+}
+/** Params defines the feeshare module params */
+
+export interface Params {
+  /** enable_feeshare defines a parameter to enable the feeshare module */
+  enableFeeShare: boolean;
+  /**
+   * developer_shares defines the proportion of the transaction fees to be
+   * distributed to the registered contract owner
+   */
+
+  developerShares: string;
+  /**
+   * allowed_denoms defines the list of denoms that are allowed to be paid to
+   * the contract withdraw addresses. If said denom is not in the list, the fees
+   * will ONLY be sent to the community pool.
+   * If this list is empty, all denoms are allowed.
+   */
+
+  allowedDenoms: string[];
+}
+/** Params defines the feeshare module params */
+
+export interface ParamsSDKType {
+  enable_fee_share: boolean;
+  developer_shares: string;
+  allowed_denoms: string[];
+}
+
+function createBaseGenesisState(): GenesisState {
+  return {
+    params: undefined,
+    feeShare: []
+  };
+}
+
+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.feeShare) {
+      FeeShare.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.feeShare.push(FeeShare.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    message.feeShare = object.feeShare?.map(e => FeeShare.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseParams(): Params {
+  return {
+    enableFeeShare: false,
+    developerShares: "",
+    allowedDenoms: []
+  };
+}
+
+export const Params = {
+  encode(message: Params, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.enableFeeShare === true) {
+      writer.uint32(8).bool(message.enableFeeShare);
+    }
+
+    if (message.developerShares !== "") {
+      writer.uint32(18).string(message.developerShares);
+    }
+
+    for (const v of message.allowedDenoms) {
+      writer.uint32(26).string(v!);
+    }
+
+    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.enableFeeShare = reader.bool();
+          break;
+
+        case 2:
+          message.developerShares = reader.string();
+          break;
+
+        case 3:
+          message.allowedDenoms.push(reader.string());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<Params>): Params {
+    const message = createBaseParams();
+    message.enableFeeShare = object.enableFeeShare ?? false;
+    message.developerShares = object.developerShares ?? "";
+    message.allowedDenoms = object.allowedDenoms?.map(e => e) || [];
+    return message;
+  }
+
+};

package/src/codegen/juno/feeshare/v1/query.lcd.ts

@@ -0,0 +1,83 @@
+import { setPaginationParams } from "../../../helpers";
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryFeeSharesRequest, QueryFeeSharesResponseSDKType, QueryFeeShareRequest, QueryFeeShareResponseSDKType, QueryParamsRequest, QueryParamsResponseSDKType, QueryDeployerFeeSharesRequest, QueryDeployerFeeSharesResponseSDKType, QueryWithdrawerFeeSharesRequest, QueryWithdrawerFeeSharesResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.feeShares = this.feeShares.bind(this);
+    this.feeShare = this.feeShare.bind(this);
+    this.params = this.params.bind(this);
+    this.deployerFeeShares = this.deployerFeeShares.bind(this);
+    this.withdrawerFeeShares = this.withdrawerFeeShares.bind(this);
+  }
+  /* FeeShares retrieves all registered FeeShares */
+
+
+  async feeShares(params: QueryFeeSharesRequest = {
+    pagination: undefined
+  }): Promise<QueryFeeSharesResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `juno/feeshare/v1/fee_shares`;
+    return await this.req.get<QueryFeeSharesResponseSDKType>(endpoint, options);
+  }
+  /* FeeShare retrieves a registered FeeShare for a given contract address */
+
+
+  async feeShare(params: QueryFeeShareRequest): Promise<QueryFeeShareResponseSDKType> {
+    const endpoint = `juno/feeshare/v1/fee_shares/${params.contractAddress}`;
+    return await this.req.get<QueryFeeShareResponseSDKType>(endpoint);
+  }
+  /* Params retrieves the FeeShare module params */
+
+
+  async params(_params: QueryParamsRequest = {}): Promise<QueryParamsResponseSDKType> {
+    const endpoint = `juno/feeshare/v1/params`;
+    return await this.req.get<QueryParamsResponseSDKType>(endpoint);
+  }
+  /* DeployerFeeShares retrieves all FeeShares that a given deployer has
+   registered */
+
+
+  async deployerFeeShares(params: QueryDeployerFeeSharesRequest): Promise<QueryDeployerFeeSharesResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `juno/feeshare/v1/fee_shares/${params.deployerAddress}`;
+    return await this.req.get<QueryDeployerFeeSharesResponseSDKType>(endpoint, options);
+  }
+  /* WithdrawerFeeShares retrieves all FeeShares with a given withdrawer
+   address */
+
+
+  async withdrawerFeeShares(params: QueryWithdrawerFeeSharesRequest): Promise<QueryWithdrawerFeeSharesResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `juno/feeshare/v1/fee_shares/${params.withdrawerAddress}`;
+    return await this.req.get<QueryWithdrawerFeeSharesResponseSDKType>(endpoint, options);
+  }
+
+}

package/src/codegen/juno/feeshare/v1/query.rpc.Query.ts

@@ -0,0 +1,99 @@
+import { Rpc } from "../../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryFeeSharesRequest, QueryFeeSharesResponse, QueryFeeShareRequest, QueryFeeShareResponse, QueryParamsRequest, QueryParamsResponse, QueryDeployerFeeSharesRequest, QueryDeployerFeeSharesResponse, QueryWithdrawerFeeSharesRequest, QueryWithdrawerFeeSharesResponse } from "./query";
+/** Query defines the gRPC querier service. */
+
+export interface Query {
+  /** FeeShares retrieves all registered FeeShares */
+  feeShares(request?: QueryFeeSharesRequest): Promise<QueryFeeSharesResponse>;
+  /** FeeShare retrieves a registered FeeShare for a given contract address */
+
+  feeShare(request: QueryFeeShareRequest): Promise<QueryFeeShareResponse>;
+  /** Params retrieves the FeeShare module params */
+
+  params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+  /**
+   * DeployerFeeShares retrieves all FeeShares that a given deployer has
+   * registered
+   */
+
+  deployerFeeShares(request: QueryDeployerFeeSharesRequest): Promise<QueryDeployerFeeSharesResponse>;
+  /**
+   * WithdrawerFeeShares retrieves all FeeShares with a given withdrawer
+   * address
+   */
+
+  withdrawerFeeShares(request: QueryWithdrawerFeeSharesRequest): Promise<QueryWithdrawerFeeSharesResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.feeShares = this.feeShares.bind(this);
+    this.feeShare = this.feeShare.bind(this);
+    this.params = this.params.bind(this);
+    this.deployerFeeShares = this.deployerFeeShares.bind(this);
+    this.withdrawerFeeShares = this.withdrawerFeeShares.bind(this);
+  }
+
+  feeShares(request: QueryFeeSharesRequest = {
+    pagination: undefined
+  }): Promise<QueryFeeSharesResponse> {
+    const data = QueryFeeSharesRequest.encode(request).finish();
+    const promise = this.rpc.request("juno.feeshare.v1.Query", "FeeShares", data);
+    return promise.then(data => QueryFeeSharesResponse.decode(new _m0.Reader(data)));
+  }
+
+  feeShare(request: QueryFeeShareRequest): Promise<QueryFeeShareResponse> {
+    const data = QueryFeeShareRequest.encode(request).finish();
+    const promise = this.rpc.request("juno.feeshare.v1.Query", "FeeShare", data);
+    return promise.then(data => QueryFeeShareResponse.decode(new _m0.Reader(data)));
+  }
+
+  params(request: QueryParamsRequest = {}): Promise<QueryParamsResponse> {
+    const data = QueryParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("juno.feeshare.v1.Query", "Params", data);
+    return promise.then(data => QueryParamsResponse.decode(new _m0.Reader(data)));
+  }
+
+  deployerFeeShares(request: QueryDeployerFeeSharesRequest): Promise<QueryDeployerFeeSharesResponse> {
+    const data = QueryDeployerFeeSharesRequest.encode(request).finish();
+    const promise = this.rpc.request("juno.feeshare.v1.Query", "DeployerFeeShares", data);
+    return promise.then(data => QueryDeployerFeeSharesResponse.decode(new _m0.Reader(data)));
+  }
+
+  withdrawerFeeShares(request: QueryWithdrawerFeeSharesRequest): Promise<QueryWithdrawerFeeSharesResponse> {
+    const data = QueryWithdrawerFeeSharesRequest.encode(request).finish();
+    const promise = this.rpc.request("juno.feeshare.v1.Query", "WithdrawerFeeShares", data);
+    return promise.then(data => QueryWithdrawerFeeSharesResponse.decode(new _m0.Reader(data)));
+  }
+
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    feeShares(request?: QueryFeeSharesRequest): Promise<QueryFeeSharesResponse> {
+      return queryService.feeShares(request);
+    },
+
+    feeShare(request: QueryFeeShareRequest): Promise<QueryFeeShareResponse> {
+      return queryService.feeShare(request);
+    },
+
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse> {
+      return queryService.params(request);
+    },
+
+    deployerFeeShares(request: QueryDeployerFeeSharesRequest): Promise<QueryDeployerFeeSharesResponse> {
+      return queryService.deployerFeeShares(request);
+    },
+
+    withdrawerFeeShares(request: QueryWithdrawerFeeSharesRequest): Promise<QueryWithdrawerFeeSharesResponse> {
+      return queryService.withdrawerFeeShares(request);
+    }
+
+  };
+};