@sparkdreamnft/sparkdreamjs 0.0.7 → 0.0.9

package/sparkdream/shield/v1/genesis.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenesisState = void 0;
+//@ts-nocheck
+const params_1 = require("./params");
+const types_1 = require("./types");
+const binary_1 = require("../../../binary");
+function createBaseGenesisState() {
+    return {
+        params: params_1.Params.fromPartial({}),
+        registeredOps: [],
+        usedNullifiers: [],
+        dayFundings: [],
+        verificationKeys: [],
+        tleKeySet: types_1.TLEKeySet.fromPartial({}),
+        pendingOps: [],
+        shieldEpochState: types_1.ShieldEpochState.fromPartial({}),
+        decryptionKeys: [],
+        nextPendingOpId: BigInt(0),
+        identityRateLimits: [],
+        pendingNullifiers: [],
+        decryptionShares: [],
+        tleMissCounters: [],
+        dkgState: types_1.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
+ */
+exports.GenesisState = {
+    typeUrl: "/sparkdream.shield.v1.GenesisState",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            params_1.Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.registeredOps) {
+            types_1.ShieldedOpRegistration.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.usedNullifiers) {
+            types_1.UsedNullifier.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        for (const v of message.dayFundings) {
+            types_1.DayFunding.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        for (const v of message.verificationKeys) {
+            types_1.VerificationKey.encode(v, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.tleKeySet !== undefined) {
+            types_1.TLEKeySet.encode(message.tleKeySet, writer.uint32(50).fork()).ldelim();
+        }
+        for (const v of message.pendingOps) {
+            types_1.PendingShieldedOp.encode(v, writer.uint32(58).fork()).ldelim();
+        }
+        if (message.shieldEpochState !== undefined) {
+            types_1.ShieldEpochState.encode(message.shieldEpochState, writer.uint32(66).fork()).ldelim();
+        }
+        for (const v of message.decryptionKeys) {
+            types_1.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) {
+            types_1.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) {
+            types_1.ShieldDecryptionShare.encode(v, writer.uint32(106).fork()).ldelim();
+        }
+        for (const v of message.tleMissCounters) {
+            types_1.TLEMissCounterEntry.encode(v, writer.uint32(114).fork()).ldelim();
+        }
+        if (message.dkgState !== undefined) {
+            types_1.DKGState.encode(message.dkgState, writer.uint32(122).fork()).ldelim();
+        }
+        for (const v of message.dkgContributions) {
+            types_1.DKGContributionEntry.encode(v, writer.uint32(130).fork()).ldelim();
+        }
+        for (const v of message.dkgRegistrations) {
+            types_1.DKGContributionEntry.encode(v, writer.uint32(138).fork()).ldelim();
+        }
+        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 = createBaseGenesisState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.params = params_1.Params.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.registeredOps.push(types_1.ShieldedOpRegistration.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.usedNullifiers.push(types_1.UsedNullifier.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.dayFundings.push(types_1.DayFunding.decode(reader, reader.uint32()));
+                    break;
+                case 5:
+                    message.verificationKeys.push(types_1.VerificationKey.decode(reader, reader.uint32()));
+                    break;
+                case 6:
+                    message.tleKeySet = types_1.TLEKeySet.decode(reader, reader.uint32());
+                    break;
+                case 7:
+                    message.pendingOps.push(types_1.PendingShieldedOp.decode(reader, reader.uint32()));
+                    break;
+                case 8:
+                    message.shieldEpochState = types_1.ShieldEpochState.decode(reader, reader.uint32());
+                    break;
+                case 9:
+                    message.decryptionKeys.push(types_1.ShieldEpochDecryptionKey.decode(reader, reader.uint32()));
+                    break;
+                case 10:
+                    message.nextPendingOpId = reader.uint64();
+                    break;
+                case 11:
+                    message.identityRateLimits.push(types_1.IdentityRateLimitEntry.decode(reader, reader.uint32()));
+                    break;
+                case 12:
+                    message.pendingNullifiers.push(reader.string());
+                    break;
+                case 13:
+                    message.decryptionShares.push(types_1.ShieldDecryptionShare.decode(reader, reader.uint32()));
+                    break;
+                case 14:
+                    message.tleMissCounters.push(types_1.TLEMissCounterEntry.decode(reader, reader.uint32()));
+                    break;
+                case 15:
+                    message.dkgState = types_1.DKGState.decode(reader, reader.uint32());
+                    break;
+                case 16:
+                    message.dkgContributions.push(types_1.DKGContributionEntry.decode(reader, reader.uint32()));
+                    break;
+                case 17:
+                    message.dkgRegistrations.push(types_1.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_1.Params.fromPartial(object.params) : undefined;
+        message.registeredOps = object.registeredOps?.map(e => types_1.ShieldedOpRegistration.fromPartial(e)) || [];
+        message.usedNullifiers = object.usedNullifiers?.map(e => types_1.UsedNullifier.fromPartial(e)) || [];
+        message.dayFundings = object.dayFundings?.map(e => types_1.DayFunding.fromPartial(e)) || [];
+        message.verificationKeys = object.verificationKeys?.map(e => types_1.VerificationKey.fromPartial(e)) || [];
+        message.tleKeySet = object.tleKeySet !== undefined && object.tleKeySet !== null ? types_1.TLEKeySet.fromPartial(object.tleKeySet) : undefined;
+        message.pendingOps = object.pendingOps?.map(e => types_1.PendingShieldedOp.fromPartial(e)) || [];
+        message.shieldEpochState = object.shieldEpochState !== undefined && object.shieldEpochState !== null ? types_1.ShieldEpochState.fromPartial(object.shieldEpochState) : undefined;
+        message.decryptionKeys = object.decryptionKeys?.map(e => types_1.ShieldEpochDecryptionKey.fromPartial(e)) || [];
+        message.nextPendingOpId = object.nextPendingOpId !== undefined && object.nextPendingOpId !== null ? BigInt(object.nextPendingOpId.toString()) : BigInt(0);
+        message.identityRateLimits = object.identityRateLimits?.map(e => types_1.IdentityRateLimitEntry.fromPartial(e)) || [];
+        message.pendingNullifiers = object.pendingNullifiers?.map(e => e) || [];
+        message.decryptionShares = object.decryptionShares?.map(e => types_1.ShieldDecryptionShare.fromPartial(e)) || [];
+        message.tleMissCounters = object.tleMissCounters?.map(e => types_1.TLEMissCounterEntry.fromPartial(e)) || [];
+        message.dkgState = object.dkgState !== undefined && object.dkgState !== null ? types_1.DKGState.fromPartial(object.dkgState) : undefined;
+        message.dkgContributions = object.dkgContributions?.map(e => types_1.DKGContributionEntry.fromPartial(e)) || [];
+        message.dkgRegistrations = object.dkgRegistrations?.map(e => types_1.DKGContributionEntry.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = params_1.Params.fromAmino(object.params);
+        }
+        message.registeredOps = object.registered_ops?.map(e => types_1.ShieldedOpRegistration.fromAmino(e)) || [];
+        message.usedNullifiers = object.used_nullifiers?.map(e => types_1.UsedNullifier.fromAmino(e)) || [];
+        message.dayFundings = object.day_fundings?.map(e => types_1.DayFunding.fromAmino(e)) || [];
+        message.verificationKeys = object.verification_keys?.map(e => types_1.VerificationKey.fromAmino(e)) || [];
+        if (object.tle_key_set !== undefined && object.tle_key_set !== null) {
+            message.tleKeySet = types_1.TLEKeySet.fromAmino(object.tle_key_set);
+        }
+        message.pendingOps = object.pending_ops?.map(e => types_1.PendingShieldedOp.fromAmino(e)) || [];
+        if (object.shield_epoch_state !== undefined && object.shield_epoch_state !== null) {
+            message.shieldEpochState = types_1.ShieldEpochState.fromAmino(object.shield_epoch_state);
+        }
+        message.decryptionKeys = object.decryption_keys?.map(e => types_1.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 => types_1.IdentityRateLimitEntry.fromAmino(e)) || [];
+        message.pendingNullifiers = object.pending_nullifiers?.map(e => e) || [];
+        message.decryptionShares = object.decryption_shares?.map(e => types_1.ShieldDecryptionShare.fromAmino(e)) || [];
+        message.tleMissCounters = object.tle_miss_counters?.map(e => types_1.TLEMissCounterEntry.fromAmino(e)) || [];
+        if (object.dkg_state !== undefined && object.dkg_state !== null) {
+            message.dkgState = types_1.DKGState.fromAmino(object.dkg_state);
+        }
+        message.dkgContributions = object.dkg_contributions?.map(e => types_1.DKGContributionEntry.fromAmino(e)) || [];
+        message.dkgRegistrations = object.dkg_registrations?.map(e => types_1.DKGContributionEntry.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? params_1.Params.toAmino(message.params) : params_1.Params.toAmino(params_1.Params.fromPartial({}));
+        if (message.registeredOps) {
+            obj.registered_ops = message.registeredOps.map(e => e ? types_1.ShieldedOpRegistration.toAmino(e) : undefined);
+        }
+        else {
+            obj.registered_ops = message.registeredOps;
+        }
+        if (message.usedNullifiers) {
+            obj.used_nullifiers = message.usedNullifiers.map(e => e ? types_1.UsedNullifier.toAmino(e) : undefined);
+        }
+        else {
+            obj.used_nullifiers = message.usedNullifiers;
+        }
+        if (message.dayFundings) {
+            obj.day_fundings = message.dayFundings.map(e => e ? types_1.DayFunding.toAmino(e) : undefined);
+        }
+        else {
+            obj.day_fundings = message.dayFundings;
+        }
+        if (message.verificationKeys) {
+            obj.verification_keys = message.verificationKeys.map(e => e ? types_1.VerificationKey.toAmino(e) : undefined);
+        }
+        else {
+            obj.verification_keys = message.verificationKeys;
+        }
+        obj.tle_key_set = message.tleKeySet ? types_1.TLEKeySet.toAmino(message.tleKeySet) : undefined;
+        if (message.pendingOps) {
+            obj.pending_ops = message.pendingOps.map(e => e ? types_1.PendingShieldedOp.toAmino(e) : undefined);
+        }
+        else {
+            obj.pending_ops = message.pendingOps;
+        }
+        obj.shield_epoch_state = message.shieldEpochState ? types_1.ShieldEpochState.toAmino(message.shieldEpochState) : undefined;
+        if (message.decryptionKeys) {
+            obj.decryption_keys = message.decryptionKeys.map(e => e ? types_1.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 ? types_1.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 ? types_1.ShieldDecryptionShare.toAmino(e) : undefined);
+        }
+        else {
+            obj.decryption_shares = message.decryptionShares;
+        }
+        if (message.tleMissCounters) {
+            obj.tle_miss_counters = message.tleMissCounters.map(e => e ? types_1.TLEMissCounterEntry.toAmino(e) : undefined);
+        }
+        else {
+            obj.tle_miss_counters = message.tleMissCounters;
+        }
+        obj.dkg_state = message.dkgState ? types_1.DKGState.toAmino(message.dkgState) : undefined;
+        if (message.dkgContributions) {
+            obj.dkg_contributions = message.dkgContributions.map(e => e ? types_1.DKGContributionEntry.toAmino(e) : undefined);
+        }
+        else {
+            obj.dkg_contributions = message.dkgContributions;
+        }
+        if (message.dkgRegistrations) {
+            obj.dkg_registrations = message.dkgRegistrations.map(e => e ? types_1.DKGContributionEntry.toAmino(e) : undefined);
+        }
+        else {
+            obj.dkg_registrations = message.dkgRegistrations;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GenesisState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.GenesisState",
+            value: exports.GenesisState.encode(message).finish()
+        };
+    }
+};

package/sparkdream/shield/v1/params.d.ts

@@ -0,0 +1,192 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * Params defines the parameters for the shield module.
+ * @name Params
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.Params
+ */
+export interface Params {
+    /**
+     * Whether shielded execution is enabled globally
+     */
+    enabled: boolean;
+    /**
+     * Maximum uspark to skim from community pool per day (14400 blocks at 6s/block)
+     */
+    maxFundingPerDay: string;
+    /**
+     * Target minimum balance for the shield module account
+     */
+    minGasReserve: string;
+    /**
+     * Maximum gas allowed per shielded execution
+     */
+    maxGasPerExec: bigint;
+    /**
+     * Per-identity rate limit: max shielded executions per epoch per nullifier-identity
+     */
+    maxExecsPerIdentityPerEpoch: bigint;
+    /**
+     * Whether encrypted batch mode is enabled (requires TLE DKG ceremony completed)
+     */
+    encryptedBatchEnabled: boolean;
+    /**
+     * Shield epoch interval in blocks
+     */
+    shieldEpochInterval: bigint;
+    /**
+     * Minimum number of operations in a batch before it executes
+     */
+    minBatchSize: number;
+    /**
+     * Maximum epochs an operation can remain pending before force-executing
+     */
+    maxPendingEpochs: number;
+    /**
+     * Maximum number of pending operations in the queue
+     */
+    maxPendingQueueSize: number;
+    /**
+     * Maximum size of encrypted_payload in bytes
+     */
+    maxEncryptedPayloadSize: number;
+    /**
+     * Maximum operations to execute in a single EndBlocker batch
+     */
+    maxOpsPerBatch: number;
+    /**
+     * Rolling window in shield epochs for tracking validator TLE misses
+     */
+    tleMissWindow: bigint;
+    /**
+     * Max misses within window before validator is jailed
+     */
+    tleMissTolerance: bigint;
+    /**
+     * Jail duration in seconds for TLE liveness violations
+     */
+    tleJailDuration: bigint;
+    /**
+     * Minimum bonded validators required to auto-open a DKG ceremony
+     */
+    minTleValidators: number;
+    /**
+     * Total DKG window in blocks (split: first half = key registration, second half = contributions)
+     */
+    dkgWindowBlocks: bigint;
+    /**
+     * Validator set drift percentage (0-100) that triggers automatic re-keying.
+     * e.g. 33 means re-key if >33% of DKG participants are no longer in the bonded set.
+     */
+    maxValidatorSetDrift: number;
+}
+export interface ParamsProtoMsg {
+    typeUrl: "/sparkdream.shield.v1.Params";
+    value: Uint8Array;
+}
+/**
+ * Params defines the parameters for the shield module.
+ * @name ParamsAmino
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.Params
+ */
+export interface ParamsAmino {
+    /**
+     * Whether shielded execution is enabled globally
+     */
+    enabled?: boolean;
+    /**
+     * Maximum uspark to skim from community pool per day (14400 blocks at 6s/block)
+     */
+    max_funding_per_day?: string;
+    /**
+     * Target minimum balance for the shield module account
+     */
+    min_gas_reserve?: string;
+    /**
+     * Maximum gas allowed per shielded execution
+     */
+    max_gas_per_exec?: string;
+    /**
+     * Per-identity rate limit: max shielded executions per epoch per nullifier-identity
+     */
+    max_execs_per_identity_per_epoch?: string;
+    /**
+     * Whether encrypted batch mode is enabled (requires TLE DKG ceremony completed)
+     */
+    encrypted_batch_enabled?: boolean;
+    /**
+     * Shield epoch interval in blocks
+     */
+    shield_epoch_interval?: string;
+    /**
+     * Minimum number of operations in a batch before it executes
+     */
+    min_batch_size?: number;
+    /**
+     * Maximum epochs an operation can remain pending before force-executing
+     */
+    max_pending_epochs?: number;
+    /**
+     * Maximum number of pending operations in the queue
+     */
+    max_pending_queue_size?: number;
+    /**
+     * Maximum size of encrypted_payload in bytes
+     */
+    max_encrypted_payload_size?: number;
+    /**
+     * Maximum operations to execute in a single EndBlocker batch
+     */
+    max_ops_per_batch?: number;
+    /**
+     * Rolling window in shield epochs for tracking validator TLE misses
+     */
+    tle_miss_window?: string;
+    /**
+     * Max misses within window before validator is jailed
+     */
+    tle_miss_tolerance?: string;
+    /**
+     * Jail duration in seconds for TLE liveness violations
+     */
+    tle_jail_duration?: string;
+    /**
+     * Minimum bonded validators required to auto-open a DKG ceremony
+     */
+    min_tle_validators?: number;
+    /**
+     * Total DKG window in blocks (split: first half = key registration, second half = contributions)
+     */
+    dkg_window_blocks?: string;
+    /**
+     * Validator set drift percentage (0-100) that triggers automatic re-keying.
+     * e.g. 33 means re-key if >33% of DKG participants are no longer in the bonded set.
+     */
+    max_validator_set_drift?: number;
+}
+export interface ParamsAminoMsg {
+    type: "sparkdream/x/shield/Params";
+    value: ParamsAmino;
+}
+/**
+ * Params defines the parameters for the shield module.
+ * @name Params
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.Params
+ */
+export declare const Params: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: Params, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Params;
+    fromPartial(object: DeepPartial<Params>): Params;
+    fromAmino(object: ParamsAmino): Params;
+    toAmino(message: Params): ParamsAmino;
+    fromAminoMsg(object: ParamsAminoMsg): Params;
+    toAminoMsg(message: Params): ParamsAminoMsg;
+    fromProtoMsg(message: ParamsProtoMsg): Params;
+    toProto(message: Params): Uint8Array;
+    toProtoMsg(message: Params): ParamsProtoMsg;
+};