@sparkdreamnft/sparkdreamjs 0.0.7 → 0.0.8

package/sparkdream/session/v1/query.lcd.d.ts

@@ -0,0 +1,13 @@
+import { LCDClient } from "@cosmology/lcd";
+import { QueryParamsRequest, QueryParamsResponse, QuerySessionRequest, QuerySessionResponse, QuerySessionsByGranterRequest, QuerySessionsByGranterResponse, QuerySessionsByGranteeRequest, QuerySessionsByGranteeResponse, QueryAllowedMsgTypesRequest, QueryAllowedMsgTypesResponse } from "./query";
+export declare class LCDQueryClient {
+    req: LCDClient;
+    constructor({ requestClient }: {
+        requestClient: LCDClient;
+    });
+    params: (_params?: QueryParamsRequest) => Promise<QueryParamsResponse>;
+    session: (params: QuerySessionRequest) => Promise<QuerySessionResponse>;
+    sessionsByGranter: (params: QuerySessionsByGranterRequest) => Promise<QuerySessionsByGranterResponse>;
+    sessionsByGrantee: (params: QuerySessionsByGranteeRequest) => Promise<QuerySessionsByGranteeResponse>;
+    allowedMsgTypes: (_params?: QueryAllowedMsgTypesRequest) => Promise<QueryAllowedMsgTypesResponse>;
+}

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LCDQueryClient = void 0;
+//@ts-nocheck
+const helpers_1 = require("../../../helpers");
+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") {
+            (0, helpers_1.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") {
+            (0, helpers_1.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);
+    };
+}
+exports.LCDQueryClient = LCDQueryClient;

package/sparkdream/session/v1/query.rpc.Query.d.ts

@@ -0,0 +1,32 @@
+import { TxRpc } from "../../../types";
+import { QueryClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QuerySessionRequest, QuerySessionResponse, QuerySessionsByGranterRequest, QuerySessionsByGranterResponse, QuerySessionsByGranteeRequest, QuerySessionsByGranteeResponse, QueryAllowedMsgTypesRequest, QueryAllowedMsgTypesResponse } from "./query";
+/** Query defines the gRPC querier service. */
+export interface Query {
+    /** Params queries the parameters of the module. */
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    /** Session queries a single session by (granter, grantee). */
+    session(request: QuerySessionRequest): Promise<QuerySessionResponse>;
+    /** SessionsByGranter queries all active sessions for a granter. */
+    sessionsByGranter(request: QuerySessionsByGranterRequest): Promise<QuerySessionsByGranterResponse>;
+    /** SessionsByGrantee queries all active sessions for a grantee. */
+    sessionsByGrantee(request: QuerySessionsByGranteeRequest): Promise<QuerySessionsByGranteeResponse>;
+    /** AllowedMsgTypes queries the ceiling and currently active message types. */
+    allowedMsgTypes(request?: QueryAllowedMsgTypesRequest): Promise<QueryAllowedMsgTypesResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: TxRpc);
+    params: (request?: QueryParamsRequest) => Promise<QueryParamsResponse>;
+    session: (request: QuerySessionRequest) => Promise<QuerySessionResponse>;
+    sessionsByGranter: (request: QuerySessionsByGranterRequest) => Promise<QuerySessionsByGranterResponse>;
+    sessionsByGrantee: (request: QuerySessionsByGranteeRequest) => Promise<QuerySessionsByGranteeResponse>;
+    allowedMsgTypes: (request?: QueryAllowedMsgTypesRequest) => Promise<QueryAllowedMsgTypesResponse>;
+}
+export declare const createRpcQueryExtension: (base: QueryClient) => {
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    session(request: QuerySessionRequest): Promise<QuerySessionResponse>;
+    sessionsByGranter(request: QuerySessionsByGranterRequest): Promise<QuerySessionsByGranterResponse>;
+    sessionsByGrantee(request: QuerySessionsByGranteeRequest): Promise<QuerySessionsByGranteeResponse>;
+    allowedMsgTypes(request?: QueryAllowedMsgTypesRequest): Promise<QueryAllowedMsgTypesResponse>;
+};

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRpcQueryExtension = exports.QueryClientImpl = void 0;
+const binary_1 = require("../../../binary");
+const stargate_1 = require("@cosmjs/stargate");
+const query_1 = require("./query");
+class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* Params queries the parameters of the module. */
+    params = async (request = {}) => {
+        const data = query_1.QueryParamsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.session.v1.Query", "Params", data);
+        return promise.then(data => query_1.QueryParamsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Session queries a single session by (granter, grantee). */
+    session = async (request) => {
+        const data = query_1.QuerySessionRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.session.v1.Query", "Session", data);
+        return promise.then(data => query_1.QuerySessionResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* SessionsByGranter queries all active sessions for a granter. */
+    sessionsByGranter = async (request) => {
+        const data = query_1.QuerySessionsByGranterRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.session.v1.Query", "SessionsByGranter", data);
+        return promise.then(data => query_1.QuerySessionsByGranterResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* SessionsByGrantee queries all active sessions for a grantee. */
+    sessionsByGrantee = async (request) => {
+        const data = query_1.QuerySessionsByGranteeRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.session.v1.Query", "SessionsByGrantee", data);
+        return promise.then(data => query_1.QuerySessionsByGranteeResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* AllowedMsgTypes queries the ceiling and currently active message types. */
+    allowedMsgTypes = async (request = {}) => {
+        const data = query_1.QueryAllowedMsgTypesRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.session.v1.Query", "AllowedMsgTypes", data);
+        return promise.then(data => query_1.QueryAllowedMsgTypesResponse.decode(new binary_1.BinaryReader(data)));
+    };
+}
+exports.QueryClientImpl = QueryClientImpl;
+const createRpcQueryExtension = (base) => {
+    const rpc = (0, stargate_1.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);
+        }
+    };
+};
+exports.createRpcQueryExtension = createRpcQueryExtension;

package/sparkdream/session/v1/session.d.ts

@@ -0,0 +1,125 @@
+import { Coin, CoinAmino } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * 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 interface Session {
+    /**
+     * Main wallet address (pays fees, "owns" the session).
+     */
+    granter: string;
+    /**
+     * Ephemeral session key address.
+     */
+    grantee: string;
+    /**
+     * Scoped message type URLs (subset of active allowlist).
+     */
+    allowedMsgTypes: string[];
+    /**
+     * Max gas budget (zero amount = no fee delegation).
+     */
+    spendLimit: Coin;
+    /**
+     * Gas consumed so far.
+     */
+    spent: Coin;
+    /**
+     * Auto-invalidation time.
+     */
+    expiration: Date;
+    /**
+     * When the session was created.
+     */
+    createdAt: Date;
+    /**
+     * Last successful MsgExecSession.
+     */
+    lastUsedAt: Date;
+    /**
+     * Total successful executions.
+     */
+    execCount: bigint;
+    /**
+     * Execution cap (0 = unlimited).
+     */
+    maxExecCount: bigint;
+}
+export interface SessionProtoMsg {
+    typeUrl: "/sparkdream.session.v1.Session";
+    value: Uint8Array;
+}
+/**
+ * Session represents an active session key delegation from granter to grantee.
+ * @name SessionAmino
+ * @package sparkdream.session.v1
+ * @see proto type: sparkdream.session.v1.Session
+ */
+export interface SessionAmino {
+    /**
+     * Main wallet address (pays fees, "owns" the session).
+     */
+    granter?: string;
+    /**
+     * Ephemeral session key address.
+     */
+    grantee?: string;
+    /**
+     * Scoped message type URLs (subset of active allowlist).
+     */
+    allowed_msg_types?: string[];
+    /**
+     * Max gas budget (zero amount = no fee delegation).
+     */
+    spend_limit?: CoinAmino;
+    /**
+     * Gas consumed so far.
+     */
+    spent?: CoinAmino;
+    /**
+     * Auto-invalidation time.
+     */
+    expiration?: string;
+    /**
+     * When the session was created.
+     */
+    created_at?: string;
+    /**
+     * Last successful MsgExecSession.
+     */
+    last_used_at?: string;
+    /**
+     * Total successful executions.
+     */
+    exec_count?: string;
+    /**
+     * Execution cap (0 = unlimited).
+     */
+    max_exec_count?: string;
+}
+export interface SessionAminoMsg {
+    type: "/sparkdream.session.v1.Session";
+    value: SessionAmino;
+}
+/**
+ * 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 declare const Session: {
+    typeUrl: string;
+    encode(message: Session, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Session;
+    fromPartial(object: DeepPartial<Session>): Session;
+    fromAmino(object: SessionAmino): Session;
+    toAmino(message: Session): SessionAmino;
+    fromAminoMsg(object: SessionAminoMsg): Session;
+    fromProtoMsg(message: SessionProtoMsg): Session;
+    toProto(message: Session): Uint8Array;
+    toProtoMsg(message: Session): SessionProtoMsg;
+};

package/sparkdream/session/v1/session.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Session = void 0;
+//@ts-nocheck
+const coin_1 = require("../../../cosmos/base/v1beta1/coin");
+const timestamp_1 = require("../../../google/protobuf/timestamp");
+const binary_1 = require("../../../binary");
+const helpers_1 = require("../../../helpers");
+function createBaseSession() {
+    return {
+        granter: "",
+        grantee: "",
+        allowedMsgTypes: [],
+        spendLimit: coin_1.Coin.fromPartial({}),
+        spent: coin_1.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
+ */
+exports.Session = {
+    typeUrl: "/sparkdream.session.v1.Session",
+    encode(message, writer = binary_1.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_1.Coin.encode(message.spendLimit, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.spent !== undefined) {
+            coin_1.Coin.encode(message.spent, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.expiration !== undefined) {
+            timestamp_1.Timestamp.encode((0, helpers_1.toTimestamp)(message.expiration), writer.uint32(50).fork()).ldelim();
+        }
+        if (message.createdAt !== undefined) {
+            timestamp_1.Timestamp.encode((0, helpers_1.toTimestamp)(message.createdAt), writer.uint32(58).fork()).ldelim();
+        }
+        if (message.lastUsedAt !== undefined) {
+            timestamp_1.Timestamp.encode((0, helpers_1.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 binary_1.BinaryReader ? input : new binary_1.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_1.Coin.decode(reader, reader.uint32());
+                    break;
+                case 5:
+                    message.spent = coin_1.Coin.decode(reader, reader.uint32());
+                    break;
+                case 6:
+                    message.expiration = (0, helpers_1.fromTimestamp)(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    break;
+                case 7:
+                    message.createdAt = (0, helpers_1.fromTimestamp)(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    break;
+                case 8:
+                    message.lastUsedAt = (0, helpers_1.fromTimestamp)(timestamp_1.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_1.Coin.fromPartial(object.spendLimit) : undefined;
+        message.spent = object.spent !== undefined && object.spent !== null ? coin_1.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_1.Coin.fromAmino(object.spend_limit);
+        }
+        if (object.spent !== undefined && object.spent !== null) {
+            message.spent = coin_1.Coin.fromAmino(object.spent);
+        }
+        if (object.expiration !== undefined && object.expiration !== null) {
+            message.expiration = (0, helpers_1.fromTimestamp)(timestamp_1.Timestamp.fromAmino(object.expiration));
+        }
+        if (object.created_at !== undefined && object.created_at !== null) {
+            message.createdAt = (0, helpers_1.fromTimestamp)(timestamp_1.Timestamp.fromAmino(object.created_at));
+        }
+        if (object.last_used_at !== undefined && object.last_used_at !== null) {
+            message.lastUsedAt = (0, helpers_1.fromTimestamp)(timestamp_1.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_1.Coin.toAmino(message.spendLimit) : undefined;
+        obj.spent = message.spent ? coin_1.Coin.toAmino(message.spent) : undefined;
+        obj.expiration = message.expiration ? timestamp_1.Timestamp.toAmino((0, helpers_1.toTimestamp)(message.expiration)) : undefined;
+        obj.created_at = message.createdAt ? timestamp_1.Timestamp.toAmino((0, helpers_1.toTimestamp)(message.createdAt)) : undefined;
+        obj.last_used_at = message.lastUsedAt ? timestamp_1.Timestamp.toAmino((0, helpers_1.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 exports.Session.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.Session.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Session.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.session.v1.Session",
+            value: exports.Session.encode(message).finish()
+        };
+    }
+};

package/sparkdream/session/v1/tx.amino.d.ts

@@ -0,0 +1,28 @@
+import { MsgUpdateParams, MsgUpdateOperationalParams, MsgCreateSession, MsgRevokeSession, MsgExecSession } from "./tx";
+export declare const AminoConverter: {
+    "/sparkdream.session.v1.MsgUpdateParams": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateParams) => import("./tx").MsgUpdateParamsAmino;
+        fromAmino: (object: import("./tx").MsgUpdateParamsAmino) => MsgUpdateParams;
+    };
+    "/sparkdream.session.v1.MsgUpdateOperationalParams": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateOperationalParams) => import("./tx").MsgUpdateOperationalParamsAmino;
+        fromAmino: (object: import("./tx").MsgUpdateOperationalParamsAmino) => MsgUpdateOperationalParams;
+    };
+    "/sparkdream.session.v1.MsgCreateSession": {
+        aminoType: string;
+        toAmino: (message: MsgCreateSession) => import("./tx").MsgCreateSessionAmino;
+        fromAmino: (object: import("./tx").MsgCreateSessionAmino) => MsgCreateSession;
+    };
+    "/sparkdream.session.v1.MsgRevokeSession": {
+        aminoType: string;
+        toAmino: (message: MsgRevokeSession) => import("./tx").MsgRevokeSessionAmino;
+        fromAmino: (object: import("./tx").MsgRevokeSessionAmino) => MsgRevokeSession;
+    };
+    "/sparkdream.session.v1.MsgExecSession": {
+        aminoType: string;
+        toAmino: (message: MsgExecSession) => import("./tx").MsgExecSessionAmino;
+        fromAmino: (object: import("./tx").MsgExecSessionAmino) => MsgExecSession;
+    };
+};

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AminoConverter = void 0;
+//@ts-nocheck
+const tx_1 = require("./tx");
+exports.AminoConverter = {
+    "/sparkdream.session.v1.MsgUpdateParams": {
+        aminoType: "sparkdream/x/session/MsgUpdateParams",
+        toAmino: tx_1.MsgUpdateParams.toAmino,
+        fromAmino: tx_1.MsgUpdateParams.fromAmino
+    },
+    "/sparkdream.session.v1.MsgUpdateOperationalParams": {
+        aminoType: "sparkdream/x/session/MsgUpdateOperationalParams",
+        toAmino: tx_1.MsgUpdateOperationalParams.toAmino,
+        fromAmino: tx_1.MsgUpdateOperationalParams.fromAmino
+    },
+    "/sparkdream.session.v1.MsgCreateSession": {
+        aminoType: "/sparkdream.session.v1.MsgCreateSession",
+        toAmino: tx_1.MsgCreateSession.toAmino,
+        fromAmino: tx_1.MsgCreateSession.fromAmino
+    },
+    "/sparkdream.session.v1.MsgRevokeSession": {
+        aminoType: "/sparkdream.session.v1.MsgRevokeSession",
+        toAmino: tx_1.MsgRevokeSession.toAmino,
+        fromAmino: tx_1.MsgRevokeSession.fromAmino
+    },
+    "/sparkdream.session.v1.MsgExecSession": {
+        aminoType: "/sparkdream.session.v1.MsgExecSession",
+        toAmino: tx_1.MsgExecSession.toAmino,
+        fromAmino: tx_1.MsgExecSession.fromAmino
+    }
+};