@sparkdreamnft/sparkdreamjs 0.0.7 → 0.0.9

package/esm/sparkdream/session/v1/query.lcd.js

@@ -0,0 +1,45 @@
+//@ts-nocheck
+import { setPaginationParams } from "../../../helpers";
+export class LCDQueryClient {
+    req;
+    constructor({ requestClient }) {
+        this.req = requestClient;
+    }
+    /* Params queries the parameters of the module. */
+    params = async (_params = {}) => {
+        const endpoint = `sparkdream/session/v1/params`;
+        return await this.req.get(endpoint);
+    };
+    /* Session queries a single session by (granter, grantee). */
+    session = async (params) => {
+        const endpoint = `sparkdream/session/v1/session/${params.granter}/${params.grantee}`;
+        return await this.req.get(endpoint);
+    };
+    /* SessionsByGranter queries all active sessions for a granter. */
+    sessionsByGranter = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/session/v1/sessions_by_granter/${params.granter}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* SessionsByGrantee queries all active sessions for a grantee. */
+    sessionsByGrantee = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/session/v1/sessions_by_grantee/${params.grantee}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* AllowedMsgTypes queries the ceiling and currently active message types. */
+    allowedMsgTypes = async (_params = {}) => {
+        const endpoint = `sparkdream/session/v1/allowed_msg_types`;
+        return await this.req.get(endpoint);
+    };
+}

package/esm/sparkdream/session/v1/query.rpc.Query.js

@@ -0,0 +1,60 @@
+import { BinaryReader } from "../../../binary";
+import { createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QuerySessionRequest, QuerySessionResponse, QuerySessionsByGranterRequest, QuerySessionsByGranterResponse, QuerySessionsByGranteeRequest, QuerySessionsByGranteeResponse, QueryAllowedMsgTypesRequest, QueryAllowedMsgTypesResponse } from "./query";
+export class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* Params queries the parameters of the module. */
+    params = async (request = {}) => {
+        const data = QueryParamsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.session.v1.Query", "Params", data);
+        return promise.then(data => QueryParamsResponse.decode(new BinaryReader(data)));
+    };
+    /* Session queries a single session by (granter, grantee). */
+    session = async (request) => {
+        const data = QuerySessionRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.session.v1.Query", "Session", data);
+        return promise.then(data => QuerySessionResponse.decode(new BinaryReader(data)));
+    };
+    /* SessionsByGranter queries all active sessions for a granter. */
+    sessionsByGranter = async (request) => {
+        const data = QuerySessionsByGranterRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.session.v1.Query", "SessionsByGranter", data);
+        return promise.then(data => QuerySessionsByGranterResponse.decode(new BinaryReader(data)));
+    };
+    /* SessionsByGrantee queries all active sessions for a grantee. */
+    sessionsByGrantee = async (request) => {
+        const data = QuerySessionsByGranteeRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.session.v1.Query", "SessionsByGrantee", data);
+        return promise.then(data => QuerySessionsByGranteeResponse.decode(new BinaryReader(data)));
+    };
+    /* AllowedMsgTypes queries the ceiling and currently active message types. */
+    allowedMsgTypes = async (request = {}) => {
+        const data = QueryAllowedMsgTypesRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.session.v1.Query", "AllowedMsgTypes", data);
+        return promise.then(data => QueryAllowedMsgTypesResponse.decode(new BinaryReader(data)));
+    };
+}
+export const createRpcQueryExtension = (base) => {
+    const rpc = createProtobufRpcClient(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        params(request) {
+            return queryService.params(request);
+        },
+        session(request) {
+            return queryService.session(request);
+        },
+        sessionsByGranter(request) {
+            return queryService.sessionsByGranter(request);
+        },
+        sessionsByGrantee(request) {
+            return queryService.sessionsByGrantee(request);
+        },
+        allowedMsgTypes(request) {
+            return queryService.allowedMsgTypes(request);
+        }
+    };
+};

package/esm/sparkdream/session/v1/session.js

@@ -0,0 +1,185 @@
+//@ts-nocheck
+import { Coin } from "../../../cosmos/base/v1beta1/coin";
+import { Timestamp } from "../../../google/protobuf/timestamp";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { toTimestamp, fromTimestamp } from "../../../helpers";
+function createBaseSession() {
+    return {
+        granter: "",
+        grantee: "",
+        allowedMsgTypes: [],
+        spendLimit: Coin.fromPartial({}),
+        spent: Coin.fromPartial({}),
+        expiration: new Date(),
+        createdAt: new Date(),
+        lastUsedAt: new Date(),
+        execCount: BigInt(0),
+        maxExecCount: BigInt(0)
+    };
+}
+/**
+ * Session represents an active session key delegation from granter to grantee.
+ * @name Session
+ * @package sparkdream.session.v1
+ * @see proto type: sparkdream.session.v1.Session
+ */
+export const Session = {
+    typeUrl: "/sparkdream.session.v1.Session",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.granter !== "") {
+            writer.uint32(10).string(message.granter);
+        }
+        if (message.grantee !== "") {
+            writer.uint32(18).string(message.grantee);
+        }
+        for (const v of message.allowedMsgTypes) {
+            writer.uint32(26).string(v);
+        }
+        if (message.spendLimit !== undefined) {
+            Coin.encode(message.spendLimit, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.spent !== undefined) {
+            Coin.encode(message.spent, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.expiration !== undefined) {
+            Timestamp.encode(toTimestamp(message.expiration), writer.uint32(50).fork()).ldelim();
+        }
+        if (message.createdAt !== undefined) {
+            Timestamp.encode(toTimestamp(message.createdAt), writer.uint32(58).fork()).ldelim();
+        }
+        if (message.lastUsedAt !== undefined) {
+            Timestamp.encode(toTimestamp(message.lastUsedAt), writer.uint32(66).fork()).ldelim();
+        }
+        if (message.execCount !== BigInt(0)) {
+            writer.uint32(72).uint64(message.execCount);
+        }
+        if (message.maxExecCount !== BigInt(0)) {
+            writer.uint32(80).uint64(message.maxExecCount);
+        }
+        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 = createBaseSession();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.granter = reader.string();
+                    break;
+                case 2:
+                    message.grantee = reader.string();
+                    break;
+                case 3:
+                    message.allowedMsgTypes.push(reader.string());
+                    break;
+                case 4:
+                    message.spendLimit = Coin.decode(reader, reader.uint32());
+                    break;
+                case 5:
+                    message.spent = Coin.decode(reader, reader.uint32());
+                    break;
+                case 6:
+                    message.expiration = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    break;
+                case 7:
+                    message.createdAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    break;
+                case 8:
+                    message.lastUsedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    break;
+                case 9:
+                    message.execCount = reader.uint64();
+                    break;
+                case 10:
+                    message.maxExecCount = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseSession();
+        message.granter = object.granter ?? "";
+        message.grantee = object.grantee ?? "";
+        message.allowedMsgTypes = object.allowedMsgTypes?.map(e => e) || [];
+        message.spendLimit = object.spendLimit !== undefined && object.spendLimit !== null ? Coin.fromPartial(object.spendLimit) : undefined;
+        message.spent = object.spent !== undefined && object.spent !== null ? Coin.fromPartial(object.spent) : undefined;
+        message.expiration = object.expiration ?? undefined;
+        message.createdAt = object.createdAt ?? undefined;
+        message.lastUsedAt = object.lastUsedAt ?? undefined;
+        message.execCount = object.execCount !== undefined && object.execCount !== null ? BigInt(object.execCount.toString()) : BigInt(0);
+        message.maxExecCount = object.maxExecCount !== undefined && object.maxExecCount !== null ? BigInt(object.maxExecCount.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseSession();
+        if (object.granter !== undefined && object.granter !== null) {
+            message.granter = object.granter;
+        }
+        if (object.grantee !== undefined && object.grantee !== null) {
+            message.grantee = object.grantee;
+        }
+        message.allowedMsgTypes = object.allowed_msg_types?.map(e => e) || [];
+        if (object.spend_limit !== undefined && object.spend_limit !== null) {
+            message.spendLimit = Coin.fromAmino(object.spend_limit);
+        }
+        if (object.spent !== undefined && object.spent !== null) {
+            message.spent = Coin.fromAmino(object.spent);
+        }
+        if (object.expiration !== undefined && object.expiration !== null) {
+            message.expiration = fromTimestamp(Timestamp.fromAmino(object.expiration));
+        }
+        if (object.created_at !== undefined && object.created_at !== null) {
+            message.createdAt = fromTimestamp(Timestamp.fromAmino(object.created_at));
+        }
+        if (object.last_used_at !== undefined && object.last_used_at !== null) {
+            message.lastUsedAt = fromTimestamp(Timestamp.fromAmino(object.last_used_at));
+        }
+        if (object.exec_count !== undefined && object.exec_count !== null) {
+            message.execCount = BigInt(object.exec_count);
+        }
+        if (object.max_exec_count !== undefined && object.max_exec_count !== null) {
+            message.maxExecCount = BigInt(object.max_exec_count);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.granter = message.granter === "" ? undefined : message.granter;
+        obj.grantee = message.grantee === "" ? undefined : message.grantee;
+        if (message.allowedMsgTypes) {
+            obj.allowed_msg_types = message.allowedMsgTypes.map(e => e);
+        }
+        else {
+            obj.allowed_msg_types = message.allowedMsgTypes;
+        }
+        obj.spend_limit = message.spendLimit ? Coin.toAmino(message.spendLimit) : undefined;
+        obj.spent = message.spent ? Coin.toAmino(message.spent) : undefined;
+        obj.expiration = message.expiration ? Timestamp.toAmino(toTimestamp(message.expiration)) : undefined;
+        obj.created_at = message.createdAt ? Timestamp.toAmino(toTimestamp(message.createdAt)) : undefined;
+        obj.last_used_at = message.lastUsedAt ? Timestamp.toAmino(toTimestamp(message.lastUsedAt)) : undefined;
+        obj.exec_count = message.execCount !== BigInt(0) ? message.execCount?.toString() : undefined;
+        obj.max_exec_count = message.maxExecCount !== BigInt(0) ? message.maxExecCount?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Session.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Session.decode(message.value);
+    },
+    toProto(message) {
+        return Session.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.session.v1.Session",
+            value: Session.encode(message).finish()
+        };
+    }
+};

package/esm/sparkdream/session/v1/tx.amino.js

@@ -0,0 +1,29 @@
+//@ts-nocheck
+import { MsgUpdateParams, MsgUpdateOperationalParams, MsgCreateSession, MsgRevokeSession, MsgExecSession } from "./tx";
+export const AminoConverter = {
+    "/sparkdream.session.v1.MsgUpdateParams": {
+        aminoType: "sparkdream/x/session/MsgUpdateParams",
+        toAmino: MsgUpdateParams.toAmino,
+        fromAmino: MsgUpdateParams.fromAmino
+    },
+    "/sparkdream.session.v1.MsgUpdateOperationalParams": {
+        aminoType: "sparkdream/x/session/MsgUpdateOperationalParams",
+        toAmino: MsgUpdateOperationalParams.toAmino,
+        fromAmino: MsgUpdateOperationalParams.fromAmino
+    },
+    "/sparkdream.session.v1.MsgCreateSession": {
+        aminoType: "/sparkdream.session.v1.MsgCreateSession",
+        toAmino: MsgCreateSession.toAmino,
+        fromAmino: MsgCreateSession.fromAmino
+    },
+    "/sparkdream.session.v1.MsgRevokeSession": {
+        aminoType: "/sparkdream.session.v1.MsgRevokeSession",
+        toAmino: MsgRevokeSession.toAmino,
+        fromAmino: MsgRevokeSession.fromAmino
+    },
+    "/sparkdream.session.v1.MsgExecSession": {
+        aminoType: "/sparkdream.session.v1.MsgExecSession",
+        toAmino: MsgExecSession.toAmino,
+        fromAmino: MsgExecSession.fromAmino
+    }
+};