@gitopia/gitopiajs 0.0.2

package/dist/esm/cosmos/bank/v1beta1/query.lcd.js

@@ -0,0 +1,169 @@
+//@ts-nocheck
+import { setPaginationParams } from "../../../helpers";
+export class LCDQueryClient {
+    req;
+    constructor({ requestClient }) {
+        this.req = requestClient;
+        this.balance = this.balance.bind(this);
+        this.allBalances = this.allBalances.bind(this);
+        this.spendableBalances = this.spendableBalances.bind(this);
+        this.spendableBalanceByDenom = this.spendableBalanceByDenom.bind(this);
+        this.totalSupply = this.totalSupply.bind(this);
+        this.supplyOf = this.supplyOf.bind(this);
+        this.params = this.params.bind(this);
+        this.denomMetadata = this.denomMetadata.bind(this);
+        this.denomsMetadata = this.denomsMetadata.bind(this);
+        this.denomOwners = this.denomOwners.bind(this);
+        this.sendEnabled = this.sendEnabled.bind(this);
+    }
+    /* Balance queries the balance of a single coin for a single account. */
+    async balance(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.denom !== "undefined") {
+            options.params.denom = params.denom;
+        }
+        const endpoint = `cosmos/bank/v1beta1/balances/${params.address}/by_denom`;
+        return await this.req.get(endpoint, options);
+    }
+    /* AllBalances queries the balance of all coins for a single account.
+    
+     When called from another module, this query might consume a high amount of
+     gas if the pagination field is incorrectly set. */
+    async allBalances(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `cosmos/bank/v1beta1/balances/${params.address}`;
+        return await this.req.get(endpoint, options);
+    }
+    /* SpendableBalances queries the spendable balance of all coins for a single
+     account.
+    
+     When called from another module, this query might consume a high amount of
+     gas if the pagination field is incorrectly set.
+    
+     Since: cosmos-sdk 0.46 */
+    async spendableBalances(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `cosmos/bank/v1beta1/spendable_balances/${params.address}`;
+        return await this.req.get(endpoint, options);
+    }
+    /* SpendableBalanceByDenom queries the spendable balance of a single denom for
+     a single account.
+    
+     When called from another module, this query might consume a high amount of
+     gas if the pagination field is incorrectly set.
+    
+     Since: cosmos-sdk 0.47 */
+    async spendableBalanceByDenom(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.denom !== "undefined") {
+            options.params.denom = params.denom;
+        }
+        const endpoint = `cosmos/bank/v1beta1/spendable_balances/${params.address}/by_denom`;
+        return await this.req.get(endpoint, options);
+    }
+    /* TotalSupply queries the total supply of all coins.
+    
+     When called from another module, this query might consume a high amount of
+     gas if the pagination field is incorrectly set. */
+    async totalSupply(params = {
+        pagination: undefined
+    }) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `cosmos/bank/v1beta1/supply`;
+        return await this.req.get(endpoint, options);
+    }
+    /* SupplyOf queries the supply of a single coin.
+    
+     When called from another module, this query might consume a high amount of
+     gas if the pagination field is incorrectly set. */
+    async supplyOf(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.denom !== "undefined") {
+            options.params.denom = params.denom;
+        }
+        const endpoint = `cosmos/bank/v1beta1/supply/by_denom`;
+        return await this.req.get(endpoint, options);
+    }
+    /* Params queries the parameters of x/bank module. */
+    async params(_params = {}) {
+        const endpoint = `cosmos/bank/v1beta1/params`;
+        return await this.req.get(endpoint);
+    }
+    /* DenomsMetadata queries the client metadata of a given coin denomination. */
+    async denomMetadata(params) {
+        const endpoint = `cosmos/bank/v1beta1/denoms_metadata/${params.denom}`;
+        return await this.req.get(endpoint);
+    }
+    /* DenomsMetadata queries the client metadata for all registered coin
+     denominations. */
+    async denomsMetadata(params = {
+        pagination: undefined
+    }) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `cosmos/bank/v1beta1/denoms_metadata`;
+        return await this.req.get(endpoint, options);
+    }
+    /* DenomOwners queries for all account addresses that own a particular token
+     denomination.
+    
+     When called from another module, this query might consume a high amount of
+     gas if the pagination field is incorrectly set.
+    
+     Since: cosmos-sdk 0.46 */
+    async denomOwners(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `cosmos/bank/v1beta1/denom_owners/${params.denom}`;
+        return await this.req.get(endpoint, options);
+    }
+    /* SendEnabled queries for SendEnabled entries.
+    
+     This query only returns denominations that have specific SendEnabled settings.
+     Any denomination that does not have a specific setting will use the default
+     params.default_send_enabled, and will not be returned by this query.
+    
+     Since: cosmos-sdk 0.47 */
+    async sendEnabled(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.denoms !== "undefined") {
+            options.params.denoms = params.denoms;
+        }
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `cosmos/bank/v1beta1/send_enabled`;
+        return await this.req.get(endpoint, options);
+    }
+}

package/dist/esm/cosmos/bank/v1beta1/query.rpc.Query.js

@@ -0,0 +1,118 @@
+import { BinaryReader } from "../../../binary";
+import { createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryBalanceRequest, QueryBalanceResponse, QueryAllBalancesRequest, QueryAllBalancesResponse, QuerySpendableBalancesRequest, QuerySpendableBalancesResponse, QuerySpendableBalanceByDenomRequest, QuerySpendableBalanceByDenomResponse, QueryTotalSupplyRequest, QueryTotalSupplyResponse, QuerySupplyOfRequest, QuerySupplyOfResponse, QueryParamsRequest, QueryParamsResponse, QueryDenomMetadataRequest, QueryDenomMetadataResponse, QueryDenomsMetadataRequest, QueryDenomsMetadataResponse, QueryDenomOwnersRequest, QueryDenomOwnersResponse, QuerySendEnabledRequest, QuerySendEnabledResponse } from "./query";
+export class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+        this.balance = this.balance.bind(this);
+        this.allBalances = this.allBalances.bind(this);
+        this.spendableBalances = this.spendableBalances.bind(this);
+        this.spendableBalanceByDenom = this.spendableBalanceByDenom.bind(this);
+        this.totalSupply = this.totalSupply.bind(this);
+        this.supplyOf = this.supplyOf.bind(this);
+        this.params = this.params.bind(this);
+        this.denomMetadata = this.denomMetadata.bind(this);
+        this.denomsMetadata = this.denomsMetadata.bind(this);
+        this.denomOwners = this.denomOwners.bind(this);
+        this.sendEnabled = this.sendEnabled.bind(this);
+    }
+    balance(request) {
+        const data = QueryBalanceRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "Balance", data);
+        return promise.then(data => QueryBalanceResponse.decode(new BinaryReader(data)));
+    }
+    allBalances(request) {
+        const data = QueryAllBalancesRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "AllBalances", data);
+        return promise.then(data => QueryAllBalancesResponse.decode(new BinaryReader(data)));
+    }
+    spendableBalances(request) {
+        const data = QuerySpendableBalancesRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "SpendableBalances", data);
+        return promise.then(data => QuerySpendableBalancesResponse.decode(new BinaryReader(data)));
+    }
+    spendableBalanceByDenom(request) {
+        const data = QuerySpendableBalanceByDenomRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "SpendableBalanceByDenom", data);
+        return promise.then(data => QuerySpendableBalanceByDenomResponse.decode(new BinaryReader(data)));
+    }
+    totalSupply(request = {
+        pagination: undefined
+    }) {
+        const data = QueryTotalSupplyRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "TotalSupply", data);
+        return promise.then(data => QueryTotalSupplyResponse.decode(new BinaryReader(data)));
+    }
+    supplyOf(request) {
+        const data = QuerySupplyOfRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "SupplyOf", data);
+        return promise.then(data => QuerySupplyOfResponse.decode(new BinaryReader(data)));
+    }
+    params(request = {}) {
+        const data = QueryParamsRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "Params", data);
+        return promise.then(data => QueryParamsResponse.decode(new BinaryReader(data)));
+    }
+    denomMetadata(request) {
+        const data = QueryDenomMetadataRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "DenomMetadata", data);
+        return promise.then(data => QueryDenomMetadataResponse.decode(new BinaryReader(data)));
+    }
+    denomsMetadata(request = {
+        pagination: undefined
+    }) {
+        const data = QueryDenomsMetadataRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "DenomsMetadata", data);
+        return promise.then(data => QueryDenomsMetadataResponse.decode(new BinaryReader(data)));
+    }
+    denomOwners(request) {
+        const data = QueryDenomOwnersRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "DenomOwners", data);
+        return promise.then(data => QueryDenomOwnersResponse.decode(new BinaryReader(data)));
+    }
+    sendEnabled(request) {
+        const data = QuerySendEnabledRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "SendEnabled", data);
+        return promise.then(data => QuerySendEnabledResponse.decode(new BinaryReader(data)));
+    }
+}
+export const createRpcQueryExtension = (base) => {
+    const rpc = createProtobufRpcClient(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        balance(request) {
+            return queryService.balance(request);
+        },
+        allBalances(request) {
+            return queryService.allBalances(request);
+        },
+        spendableBalances(request) {
+            return queryService.spendableBalances(request);
+        },
+        spendableBalanceByDenom(request) {
+            return queryService.spendableBalanceByDenom(request);
+        },
+        totalSupply(request) {
+            return queryService.totalSupply(request);
+        },
+        supplyOf(request) {
+            return queryService.supplyOf(request);
+        },
+        params(request) {
+            return queryService.params(request);
+        },
+        denomMetadata(request) {
+            return queryService.denomMetadata(request);
+        },
+        denomsMetadata(request) {
+            return queryService.denomsMetadata(request);
+        },
+        denomOwners(request) {
+            return queryService.denomOwners(request);
+        },
+        sendEnabled(request) {
+            return queryService.sendEnabled(request);
+        }
+    };
+};

package/dist/esm/cosmos/base/query/v1beta1/pagination.js

@@ -0,0 +1,201 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
+function createBasePageRequest() {
+    return {
+        key: new Uint8Array(),
+        offset: BigInt(0),
+        limit: BigInt(0),
+        countTotal: false,
+        reverse: false
+    };
+}
+export const PageRequest = {
+    typeUrl: "/cosmos.base.query.v1beta1.PageRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        if (message.offset !== BigInt(0)) {
+            writer.uint32(16).uint64(message.offset);
+        }
+        if (message.limit !== BigInt(0)) {
+            writer.uint32(24).uint64(message.limit);
+        }
+        if (message.countTotal === true) {
+            writer.uint32(32).bool(message.countTotal);
+        }
+        if (message.reverse === true) {
+            writer.uint32(40).bool(message.reverse);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePageRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.bytes();
+                    break;
+                case 2:
+                    message.offset = reader.uint64();
+                    break;
+                case 3:
+                    message.limit = reader.uint64();
+                    break;
+                case 4:
+                    message.countTotal = reader.bool();
+                    break;
+                case 5:
+                    message.reverse = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePageRequest();
+        message.key = object.key ?? new Uint8Array();
+        message.offset = object.offset !== undefined && object.offset !== null ? BigInt(object.offset.toString()) : BigInt(0);
+        message.limit = object.limit !== undefined && object.limit !== null ? BigInt(object.limit.toString()) : BigInt(0);
+        message.countTotal = object.countTotal ?? false;
+        message.reverse = object.reverse ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePageRequest();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = bytesFromBase64(object.key);
+        }
+        if (object.offset !== undefined && object.offset !== null) {
+            message.offset = BigInt(object.offset);
+        }
+        if (object.limit !== undefined && object.limit !== null) {
+            message.limit = BigInt(object.limit);
+        }
+        if (object.count_total !== undefined && object.count_total !== null) {
+            message.countTotal = object.count_total;
+        }
+        if (object.reverse !== undefined && object.reverse !== null) {
+            message.reverse = object.reverse;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key ? base64FromBytes(message.key) : undefined;
+        obj.offset = message.offset !== BigInt(0) ? message.offset?.toString() : undefined;
+        obj.limit = message.limit !== BigInt(0) ? message.limit?.toString() : undefined;
+        obj.count_total = message.countTotal === false ? undefined : message.countTotal;
+        obj.reverse = message.reverse === false ? undefined : message.reverse;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return PageRequest.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/PageRequest",
+            value: PageRequest.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return PageRequest.decode(message.value);
+    },
+    toProto(message) {
+        return PageRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.base.query.v1beta1.PageRequest",
+            value: PageRequest.encode(message).finish()
+        };
+    }
+};
+function createBasePageResponse() {
+    return {
+        nextKey: new Uint8Array(),
+        total: BigInt(0)
+    };
+}
+export const PageResponse = {
+    typeUrl: "/cosmos.base.query.v1beta1.PageResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.nextKey.length !== 0) {
+            writer.uint32(10).bytes(message.nextKey);
+        }
+        if (message.total !== BigInt(0)) {
+            writer.uint32(16).uint64(message.total);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePageResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.nextKey = reader.bytes();
+                    break;
+                case 2:
+                    message.total = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePageResponse();
+        message.nextKey = object.nextKey ?? new Uint8Array();
+        message.total = object.total !== undefined && object.total !== null ? BigInt(object.total.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePageResponse();
+        if (object.next_key !== undefined && object.next_key !== null) {
+            message.nextKey = bytesFromBase64(object.next_key);
+        }
+        if (object.total !== undefined && object.total !== null) {
+            message.total = BigInt(object.total);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.next_key = message.nextKey ? base64FromBytes(message.nextKey) : undefined;
+        obj.total = message.total !== BigInt(0) ? message.total?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return PageResponse.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/PageResponse",
+            value: PageResponse.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return PageResponse.decode(message.value);
+    },
+    toProto(message) {
+        return PageResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.base.query.v1beta1.PageResponse",
+            value: PageResponse.encode(message).finish()
+        };
+    }
+};