@sparkdreamnft/sparkdreamjs 0.0.7 → 0.0.8

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

@@ -0,0 +1,105 @@
+import { MsgUpdateParams, MsgUpdateOperationalParams, MsgCreateSession, MsgRevokeSession, MsgExecSession } from "./tx";
+export const registry = [["/sparkdream.session.v1.MsgUpdateParams", MsgUpdateParams], ["/sparkdream.session.v1.MsgUpdateOperationalParams", MsgUpdateOperationalParams], ["/sparkdream.session.v1.MsgCreateSession", MsgCreateSession], ["/sparkdream.session.v1.MsgRevokeSession", MsgRevokeSession], ["/sparkdream.session.v1.MsgExecSession", MsgExecSession]];
+export const load = (protoRegistry) => {
+    registry.forEach(([typeUrl, mod]) => {
+        protoRegistry.register(typeUrl, mod);
+    });
+};
+export const MessageComposer = {
+    encoded: {
+        updateParams(value) {
+            return {
+                typeUrl: "/sparkdream.session.v1.MsgUpdateParams",
+                value: MsgUpdateParams.encode(value).finish()
+            };
+        },
+        updateOperationalParams(value) {
+            return {
+                typeUrl: "/sparkdream.session.v1.MsgUpdateOperationalParams",
+                value: MsgUpdateOperationalParams.encode(value).finish()
+            };
+        },
+        createSession(value) {
+            return {
+                typeUrl: "/sparkdream.session.v1.MsgCreateSession",
+                value: MsgCreateSession.encode(value).finish()
+            };
+        },
+        revokeSession(value) {
+            return {
+                typeUrl: "/sparkdream.session.v1.MsgRevokeSession",
+                value: MsgRevokeSession.encode(value).finish()
+            };
+        },
+        execSession(value) {
+            return {
+                typeUrl: "/sparkdream.session.v1.MsgExecSession",
+                value: MsgExecSession.encode(value).finish()
+            };
+        }
+    },
+    withTypeUrl: {
+        updateParams(value) {
+            return {
+                typeUrl: "/sparkdream.session.v1.MsgUpdateParams",
+                value
+            };
+        },
+        updateOperationalParams(value) {
+            return {
+                typeUrl: "/sparkdream.session.v1.MsgUpdateOperationalParams",
+                value
+            };
+        },
+        createSession(value) {
+            return {
+                typeUrl: "/sparkdream.session.v1.MsgCreateSession",
+                value
+            };
+        },
+        revokeSession(value) {
+            return {
+                typeUrl: "/sparkdream.session.v1.MsgRevokeSession",
+                value
+            };
+        },
+        execSession(value) {
+            return {
+                typeUrl: "/sparkdream.session.v1.MsgExecSession",
+                value
+            };
+        }
+    },
+    fromPartial: {
+        updateParams(value) {
+            return {
+                typeUrl: "/sparkdream.session.v1.MsgUpdateParams",
+                value: MsgUpdateParams.fromPartial(value)
+            };
+        },
+        updateOperationalParams(value) {
+            return {
+                typeUrl: "/sparkdream.session.v1.MsgUpdateOperationalParams",
+                value: MsgUpdateOperationalParams.fromPartial(value)
+            };
+        },
+        createSession(value) {
+            return {
+                typeUrl: "/sparkdream.session.v1.MsgCreateSession",
+                value: MsgCreateSession.fromPartial(value)
+            };
+        },
+        revokeSession(value) {
+            return {
+                typeUrl: "/sparkdream.session.v1.MsgRevokeSession",
+                value: MsgRevokeSession.fromPartial(value)
+            };
+        },
+        execSession(value) {
+            return {
+                typeUrl: "/sparkdream.session.v1.MsgExecSession",
+                value: MsgExecSession.fromPartial(value)
+            };
+        }
+    }
+};

package/esm/sparkdream/session/v1/tx.rpc.msg.js

@@ -0,0 +1,43 @@
+import { BinaryReader } from "../../../binary";
+import { MsgUpdateParams, MsgUpdateParamsResponse, MsgUpdateOperationalParams, MsgUpdateOperationalParamsResponse, MsgCreateSession, MsgCreateSessionResponse, MsgRevokeSession, MsgRevokeSessionResponse, MsgExecSession, MsgExecSessionResponse } from "./tx";
+export class MsgClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* UpdateParams defines a (governance) operation for updating the module
+     parameters. The authority defaults to the x/gov module account. */
+    updateParams = async (request) => {
+        const data = MsgUpdateParams.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.session.v1.Msg", "UpdateParams", data);
+        return promise.then(data => MsgUpdateParamsResponse.decode(new BinaryReader(data)));
+    };
+    /* UpdateOperationalParams defines an operation for updating the module's
+     operational parameters. Authorized for Commons Council Operations Committee. */
+    updateOperationalParams = async (request) => {
+        const data = MsgUpdateOperationalParams.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.session.v1.Msg", "UpdateOperationalParams", data);
+        return promise.then(data => MsgUpdateOperationalParamsResponse.decode(new BinaryReader(data)));
+    };
+    /* CreateSession creates a new session key delegation. */
+    createSession = async (request) => {
+        const data = MsgCreateSession.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.session.v1.Msg", "CreateSession", data);
+        return promise.then(data => MsgCreateSessionResponse.decode(new BinaryReader(data)));
+    };
+    /* RevokeSession revokes an active session. */
+    revokeSession = async (request) => {
+        const data = MsgRevokeSession.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.session.v1.Msg", "RevokeSession", data);
+        return promise.then(data => MsgRevokeSessionResponse.decode(new BinaryReader(data)));
+    };
+    /* ExecSession executes messages using a session key. */
+    execSession = async (request) => {
+        const data = MsgExecSession.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.session.v1.Msg", "ExecSession", data);
+        return promise.then(data => MsgExecSessionResponse.decode(new BinaryReader(data)));
+    };
+}
+export const createClientImpl = (rpc) => {
+    return new MsgClientImpl(rpc);
+};

package/esm/sparkdream/shield/module/v1/module.js

@@ -0,0 +1,71 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+function createBaseModule() {
+    return {
+        authority: ""
+    };
+}
+/**
+ * Module is the config object for the module.
+ * @name Module
+ * @package sparkdream.shield.module.v1
+ * @see proto type: sparkdream.shield.module.v1.Module
+ */
+export const Module = {
+    typeUrl: "/sparkdream.shield.module.v1.Module",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        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 = createBaseModule();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseModule();
+        message.authority = object.authority ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseModule();
+        if (object.authority !== undefined && object.authority !== null) {
+            message.authority = object.authority;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.authority = message.authority === "" ? undefined : message.authority;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Module.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Module.decode(message.value);
+    },
+    toProto(message) {
+        return Module.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.module.v1.Module",
+            value: Module.encode(message).finish()
+        };
+    }
+};

package/esm/sparkdream/shield/v1/genesis.js

@@ -0,0 +1,301 @@
+//@ts-nocheck
+import { Params } from "./params";
+import { ShieldedOpRegistration, UsedNullifier, DayFunding, VerificationKey, TLEKeySet, PendingShieldedOp, ShieldEpochState, ShieldEpochDecryptionKey, IdentityRateLimitEntry, ShieldDecryptionShare, TLEMissCounterEntry, DKGState, DKGContributionEntry } from "./types";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseGenesisState() {
+    return {
+        params: Params.fromPartial({}),
+        registeredOps: [],
+        usedNullifiers: [],
+        dayFundings: [],
+        verificationKeys: [],
+        tleKeySet: TLEKeySet.fromPartial({}),
+        pendingOps: [],
+        shieldEpochState: ShieldEpochState.fromPartial({}),
+        decryptionKeys: [],
+        nextPendingOpId: BigInt(0),
+        identityRateLimits: [],
+        pendingNullifiers: [],
+        decryptionShares: [],
+        tleMissCounters: [],
+        dkgState: DKGState.fromPartial({}),
+        dkgContributions: [],
+        dkgRegistrations: []
+    };
+}
+/**
+ * GenesisState defines the shield module's genesis state.
+ * @name GenesisState
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.GenesisState
+ */
+export const GenesisState = {
+    typeUrl: "/sparkdream.shield.v1.GenesisState",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.registeredOps) {
+            ShieldedOpRegistration.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.usedNullifiers) {
+            UsedNullifier.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        for (const v of message.dayFundings) {
+            DayFunding.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        for (const v of message.verificationKeys) {
+            VerificationKey.encode(v, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.tleKeySet !== undefined) {
+            TLEKeySet.encode(message.tleKeySet, writer.uint32(50).fork()).ldelim();
+        }
+        for (const v of message.pendingOps) {
+            PendingShieldedOp.encode(v, writer.uint32(58).fork()).ldelim();
+        }
+        if (message.shieldEpochState !== undefined) {
+            ShieldEpochState.encode(message.shieldEpochState, writer.uint32(66).fork()).ldelim();
+        }
+        for (const v of message.decryptionKeys) {
+            ShieldEpochDecryptionKey.encode(v, writer.uint32(74).fork()).ldelim();
+        }
+        if (message.nextPendingOpId !== BigInt(0)) {
+            writer.uint32(80).uint64(message.nextPendingOpId);
+        }
+        for (const v of message.identityRateLimits) {
+            IdentityRateLimitEntry.encode(v, writer.uint32(90).fork()).ldelim();
+        }
+        for (const v of message.pendingNullifiers) {
+            writer.uint32(98).string(v);
+        }
+        for (const v of message.decryptionShares) {
+            ShieldDecryptionShare.encode(v, writer.uint32(106).fork()).ldelim();
+        }
+        for (const v of message.tleMissCounters) {
+            TLEMissCounterEntry.encode(v, writer.uint32(114).fork()).ldelim();
+        }
+        if (message.dkgState !== undefined) {
+            DKGState.encode(message.dkgState, writer.uint32(122).fork()).ldelim();
+        }
+        for (const v of message.dkgContributions) {
+            DKGContributionEntry.encode(v, writer.uint32(130).fork()).ldelim();
+        }
+        for (const v of message.dkgRegistrations) {
+            DKGContributionEntry.encode(v, writer.uint32(138).fork()).ldelim();
+        }
+        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 = 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.registeredOps.push(ShieldedOpRegistration.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.usedNullifiers.push(UsedNullifier.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.dayFundings.push(DayFunding.decode(reader, reader.uint32()));
+                    break;
+                case 5:
+                    message.verificationKeys.push(VerificationKey.decode(reader, reader.uint32()));
+                    break;
+                case 6:
+                    message.tleKeySet = TLEKeySet.decode(reader, reader.uint32());
+                    break;
+                case 7:
+                    message.pendingOps.push(PendingShieldedOp.decode(reader, reader.uint32()));
+                    break;
+                case 8:
+                    message.shieldEpochState = ShieldEpochState.decode(reader, reader.uint32());
+                    break;
+                case 9:
+                    message.decryptionKeys.push(ShieldEpochDecryptionKey.decode(reader, reader.uint32()));
+                    break;
+                case 10:
+                    message.nextPendingOpId = reader.uint64();
+                    break;
+                case 11:
+                    message.identityRateLimits.push(IdentityRateLimitEntry.decode(reader, reader.uint32()));
+                    break;
+                case 12:
+                    message.pendingNullifiers.push(reader.string());
+                    break;
+                case 13:
+                    message.decryptionShares.push(ShieldDecryptionShare.decode(reader, reader.uint32()));
+                    break;
+                case 14:
+                    message.tleMissCounters.push(TLEMissCounterEntry.decode(reader, reader.uint32()));
+                    break;
+                case 15:
+                    message.dkgState = DKGState.decode(reader, reader.uint32());
+                    break;
+                case 16:
+                    message.dkgContributions.push(DKGContributionEntry.decode(reader, reader.uint32()));
+                    break;
+                case 17:
+                    message.dkgRegistrations.push(DKGContributionEntry.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisState();
+        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+        message.registeredOps = object.registeredOps?.map(e => ShieldedOpRegistration.fromPartial(e)) || [];
+        message.usedNullifiers = object.usedNullifiers?.map(e => UsedNullifier.fromPartial(e)) || [];
+        message.dayFundings = object.dayFundings?.map(e => DayFunding.fromPartial(e)) || [];
+        message.verificationKeys = object.verificationKeys?.map(e => VerificationKey.fromPartial(e)) || [];
+        message.tleKeySet = object.tleKeySet !== undefined && object.tleKeySet !== null ? TLEKeySet.fromPartial(object.tleKeySet) : undefined;
+        message.pendingOps = object.pendingOps?.map(e => PendingShieldedOp.fromPartial(e)) || [];
+        message.shieldEpochState = object.shieldEpochState !== undefined && object.shieldEpochState !== null ? ShieldEpochState.fromPartial(object.shieldEpochState) : undefined;
+        message.decryptionKeys = object.decryptionKeys?.map(e => ShieldEpochDecryptionKey.fromPartial(e)) || [];
+        message.nextPendingOpId = object.nextPendingOpId !== undefined && object.nextPendingOpId !== null ? BigInt(object.nextPendingOpId.toString()) : BigInt(0);
+        message.identityRateLimits = object.identityRateLimits?.map(e => IdentityRateLimitEntry.fromPartial(e)) || [];
+        message.pendingNullifiers = object.pendingNullifiers?.map(e => e) || [];
+        message.decryptionShares = object.decryptionShares?.map(e => ShieldDecryptionShare.fromPartial(e)) || [];
+        message.tleMissCounters = object.tleMissCounters?.map(e => TLEMissCounterEntry.fromPartial(e)) || [];
+        message.dkgState = object.dkgState !== undefined && object.dkgState !== null ? DKGState.fromPartial(object.dkgState) : undefined;
+        message.dkgContributions = object.dkgContributions?.map(e => DKGContributionEntry.fromPartial(e)) || [];
+        message.dkgRegistrations = object.dkgRegistrations?.map(e => DKGContributionEntry.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
+        }
+        message.registeredOps = object.registered_ops?.map(e => ShieldedOpRegistration.fromAmino(e)) || [];
+        message.usedNullifiers = object.used_nullifiers?.map(e => UsedNullifier.fromAmino(e)) || [];
+        message.dayFundings = object.day_fundings?.map(e => DayFunding.fromAmino(e)) || [];
+        message.verificationKeys = object.verification_keys?.map(e => VerificationKey.fromAmino(e)) || [];
+        if (object.tle_key_set !== undefined && object.tle_key_set !== null) {
+            message.tleKeySet = TLEKeySet.fromAmino(object.tle_key_set);
+        }
+        message.pendingOps = object.pending_ops?.map(e => PendingShieldedOp.fromAmino(e)) || [];
+        if (object.shield_epoch_state !== undefined && object.shield_epoch_state !== null) {
+            message.shieldEpochState = ShieldEpochState.fromAmino(object.shield_epoch_state);
+        }
+        message.decryptionKeys = object.decryption_keys?.map(e => ShieldEpochDecryptionKey.fromAmino(e)) || [];
+        if (object.next_pending_op_id !== undefined && object.next_pending_op_id !== null) {
+            message.nextPendingOpId = BigInt(object.next_pending_op_id);
+        }
+        message.identityRateLimits = object.identity_rate_limits?.map(e => IdentityRateLimitEntry.fromAmino(e)) || [];
+        message.pendingNullifiers = object.pending_nullifiers?.map(e => e) || [];
+        message.decryptionShares = object.decryption_shares?.map(e => ShieldDecryptionShare.fromAmino(e)) || [];
+        message.tleMissCounters = object.tle_miss_counters?.map(e => TLEMissCounterEntry.fromAmino(e)) || [];
+        if (object.dkg_state !== undefined && object.dkg_state !== null) {
+            message.dkgState = DKGState.fromAmino(object.dkg_state);
+        }
+        message.dkgContributions = object.dkg_contributions?.map(e => DKGContributionEntry.fromAmino(e)) || [];
+        message.dkgRegistrations = object.dkg_registrations?.map(e => DKGContributionEntry.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
+        if (message.registeredOps) {
+            obj.registered_ops = message.registeredOps.map(e => e ? ShieldedOpRegistration.toAmino(e) : undefined);
+        }
+        else {
+            obj.registered_ops = message.registeredOps;
+        }
+        if (message.usedNullifiers) {
+            obj.used_nullifiers = message.usedNullifiers.map(e => e ? UsedNullifier.toAmino(e) : undefined);
+        }
+        else {
+            obj.used_nullifiers = message.usedNullifiers;
+        }
+        if (message.dayFundings) {
+            obj.day_fundings = message.dayFundings.map(e => e ? DayFunding.toAmino(e) : undefined);
+        }
+        else {
+            obj.day_fundings = message.dayFundings;
+        }
+        if (message.verificationKeys) {
+            obj.verification_keys = message.verificationKeys.map(e => e ? VerificationKey.toAmino(e) : undefined);
+        }
+        else {
+            obj.verification_keys = message.verificationKeys;
+        }
+        obj.tle_key_set = message.tleKeySet ? TLEKeySet.toAmino(message.tleKeySet) : undefined;
+        if (message.pendingOps) {
+            obj.pending_ops = message.pendingOps.map(e => e ? PendingShieldedOp.toAmino(e) : undefined);
+        }
+        else {
+            obj.pending_ops = message.pendingOps;
+        }
+        obj.shield_epoch_state = message.shieldEpochState ? ShieldEpochState.toAmino(message.shieldEpochState) : undefined;
+        if (message.decryptionKeys) {
+            obj.decryption_keys = message.decryptionKeys.map(e => e ? ShieldEpochDecryptionKey.toAmino(e) : undefined);
+        }
+        else {
+            obj.decryption_keys = message.decryptionKeys;
+        }
+        obj.next_pending_op_id = message.nextPendingOpId !== BigInt(0) ? message.nextPendingOpId?.toString() : undefined;
+        if (message.identityRateLimits) {
+            obj.identity_rate_limits = message.identityRateLimits.map(e => e ? IdentityRateLimitEntry.toAmino(e) : undefined);
+        }
+        else {
+            obj.identity_rate_limits = message.identityRateLimits;
+        }
+        if (message.pendingNullifiers) {
+            obj.pending_nullifiers = message.pendingNullifiers.map(e => e);
+        }
+        else {
+            obj.pending_nullifiers = message.pendingNullifiers;
+        }
+        if (message.decryptionShares) {
+            obj.decryption_shares = message.decryptionShares.map(e => e ? ShieldDecryptionShare.toAmino(e) : undefined);
+        }
+        else {
+            obj.decryption_shares = message.decryptionShares;
+        }
+        if (message.tleMissCounters) {
+            obj.tle_miss_counters = message.tleMissCounters.map(e => e ? TLEMissCounterEntry.toAmino(e) : undefined);
+        }
+        else {
+            obj.tle_miss_counters = message.tleMissCounters;
+        }
+        obj.dkg_state = message.dkgState ? DKGState.toAmino(message.dkgState) : undefined;
+        if (message.dkgContributions) {
+            obj.dkg_contributions = message.dkgContributions.map(e => e ? DKGContributionEntry.toAmino(e) : undefined);
+        }
+        else {
+            obj.dkg_contributions = message.dkgContributions;
+        }
+        if (message.dkgRegistrations) {
+            obj.dkg_registrations = message.dkgRegistrations.map(e => e ? DKGContributionEntry.toAmino(e) : undefined);
+        }
+        else {
+            obj.dkg_registrations = message.dkgRegistrations;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return GenesisState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.GenesisState",
+            value: GenesisState.encode(message).finish()
+        };
+    }
+};