@sparkdreamnft/sparkdreamjs 0.0.45 → 0.0.47

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

@@ -1122,7 +1122,9 @@ export const MsgClaimRecurringPull = {
 function createBaseMsgClaimRecurringPullResponse() {
     return {
         claimNumber: BigInt(0),
-        nextClaimTime: BigInt(0)
+        nextClaimTime: BigInt(0),
+        paused: false,
+        completed: false
     };
 }
 /**
@@ -1139,6 +1141,12 @@ export const MsgClaimRecurringPullResponse = {
         if (message.nextClaimTime !== BigInt(0)) {
             writer.uint32(16).int64(message.nextClaimTime);
         }
+        if (message.paused === true) {
+            writer.uint32(24).bool(message.paused);
+        }
+        if (message.completed === true) {
+            writer.uint32(32).bool(message.completed);
+        }
         return writer;
     },
     decode(input, length) {
@@ -1154,6 +1162,12 @@ export const MsgClaimRecurringPullResponse = {
                 case 2:
                     message.nextClaimTime = reader.int64();
                     break;
+                case 3:
+                    message.paused = reader.bool();
+                    break;
+                case 4:
+                    message.completed = reader.bool();
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -1165,6 +1179,8 @@ export const MsgClaimRecurringPullResponse = {
         const message = createBaseMsgClaimRecurringPullResponse();
         message.claimNumber = object.claimNumber !== undefined && object.claimNumber !== null ? BigInt(object.claimNumber.toString()) : BigInt(0);
         message.nextClaimTime = object.nextClaimTime !== undefined && object.nextClaimTime !== null ? BigInt(object.nextClaimTime.toString()) : BigInt(0);
+        message.paused = object.paused ?? false;
+        message.completed = object.completed ?? false;
         return message;
     },
     fromAmino(object) {
@@ -1175,12 +1191,20 @@ export const MsgClaimRecurringPullResponse = {
         if (object.next_claim_time !== undefined && object.next_claim_time !== null) {
             message.nextClaimTime = BigInt(object.next_claim_time);
         }
+        if (object.paused !== undefined && object.paused !== null) {
+            message.paused = object.paused;
+        }
+        if (object.completed !== undefined && object.completed !== null) {
+            message.completed = object.completed;
+        }
         return message;
     },
     toAmino(message) {
         const obj = {};
         obj.claim_number = message.claimNumber !== BigInt(0) ? message.claimNumber?.toString() : undefined;
         obj.next_claim_time = message.nextClaimTime !== BigInt(0) ? message.nextClaimTime?.toString() : undefined;
+        obj.paused = message.paused === false ? undefined : message.paused;
+        obj.completed = message.completed === false ? undefined : message.completed;
         return obj;
     },
     fromAminoMsg(object) {
@@ -1315,7 +1339,8 @@ export const MsgPullAllowance = {
 function createBaseMsgPullAllowanceResponse() {
     return {
         transferred: Coin.fromPartial({}),
-        spentInPeriod: Coin.fromPartial({})
+        spentInPeriod: Coin.fromPartial({}),
+        paused: false
     };
 }
 /**
@@ -1332,6 +1357,9 @@ export const MsgPullAllowanceResponse = {
         if (message.spentInPeriod !== undefined) {
             Coin.encode(message.spentInPeriod, writer.uint32(18).fork()).ldelim();
         }
+        if (message.paused === true) {
+            writer.uint32(24).bool(message.paused);
+        }
         return writer;
     },
     decode(input, length) {
@@ -1347,6 +1375,9 @@ export const MsgPullAllowanceResponse = {
                 case 2:
                     message.spentInPeriod = Coin.decode(reader, reader.uint32());
                     break;
+                case 3:
+                    message.paused = reader.bool();
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -1358,6 +1389,7 @@ export const MsgPullAllowanceResponse = {
         const message = createBaseMsgPullAllowanceResponse();
         message.transferred = object.transferred !== undefined && object.transferred !== null ? Coin.fromPartial(object.transferred) : undefined;
         message.spentInPeriod = object.spentInPeriod !== undefined && object.spentInPeriod !== null ? Coin.fromPartial(object.spentInPeriod) : undefined;
+        message.paused = object.paused ?? false;
         return message;
     },
     fromAmino(object) {
@@ -1368,12 +1400,16 @@ export const MsgPullAllowanceResponse = {
         if (object.spent_in_period !== undefined && object.spent_in_period !== null) {
             message.spentInPeriod = Coin.fromAmino(object.spent_in_period);
         }
+        if (object.paused !== undefined && object.paused !== null) {
+            message.paused = object.paused;
+        }
         return message;
     },
     toAmino(message) {
         const obj = {};
         obj.transferred = message.transferred ? Coin.toAmino(message.transferred) : undefined;
         obj.spent_in_period = message.spentInPeriod ? Coin.toAmino(message.spentInPeriod) : undefined;
+        obj.paused = message.paused === false ? undefined : message.paused;
         return obj;
     },
     fromAminoMsg(object) {

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

@@ -1,82 +1,17 @@
 //@ts-nocheck
-// HAND-WRITTEN OVERRIDE — overlaid by scripts/codegen.ts after telescope.
-// See ../../commons/v1/tx.amino.ts for the broader rationale.
+// HAND-WRITTEN OVERRIDE — overlaid on top of the Telescope-generated tx.amino.ts
+// by scripts/codegen.ts after each codegen run. Do not let codegen wipe this.
 //
-// MsgShieldedExec wraps a single `google.protobuf.Any inner_message`. The
-// auto-generated toAmino calls Any.toAmino directly, which attaches raw
-// `{type, value: Uint8Array}` — JSON.stringify renders the Uint8Array as
-// `{"0":N,"1":N,…}` (numeric, unsorted keys), breaking Ledger's amino-JSON
-// validator and producing sign bytes the chain can't reconstruct. Same root
-// cause as MsgSubmitProposal in commons; here we route the inner Any through
-// the consumer-provided AminoTypes so it's expanded into the proper
-// `{type: "<aminoType>", value: <amino-encoded fields>}` shape.
-import { MsgUpdateParams, MsgTriggerDkg, MsgRegisterShieldedOp, MsgDeregisterShieldedOp, } from "./tx";
-import { base64FromBytes, bytesFromBase64 } from "../../../helpers";
-import { anyToAmino, aminoToAny } from "../../../nested-amino";
-export const AminoConverter = {
-    "/sparkdream.shield.v1.MsgUpdateParams": {
-        aminoType: "sparkdream/x/shield/MsgUpdateParams",
-        toAmino: MsgUpdateParams.toAmino,
-        fromAmino: MsgUpdateParams.fromAmino,
-    },
-    "/sparkdream.shield.v1.MsgShieldedExec": {
-        aminoType: "sparkdream/x/shield/MsgShieldedExec",
-        toAmino(message) {
-            const obj = {};
-            obj.submitter = message.submitter === "" ? undefined : message.submitter;
-            obj.inner_message = message.innerMessage ? anyToAmino(message.innerMessage) : undefined;
-            obj.proof = message.proof ? base64FromBytes(message.proof) : undefined;
-            obj.nullifier = message.nullifier ? base64FromBytes(message.nullifier) : undefined;
-            obj.rate_limit_nullifier = message.rateLimitNullifier ? base64FromBytes(message.rateLimitNullifier) : undefined;
-            obj.merkle_root = message.merkleRoot ? base64FromBytes(message.merkleRoot) : undefined;
-            obj.proof_domain = message.proofDomain === 0 ? undefined : message.proofDomain;
-            obj.min_trust_level = message.minTrustLevel === 0 ? undefined : message.minTrustLevel;
-            obj.exec_mode = message.execMode === 0 ? undefined : message.execMode;
-            obj.encrypted_payload = message.encryptedPayload ? base64FromBytes(message.encryptedPayload) : undefined;
-            obj.target_epoch = message.targetEpoch !== BigInt(0) ? message.targetEpoch?.toString() : undefined;
-            return obj;
-        },
-        fromAmino(object) {
-            return {
-                submitter: object.submitter ?? "",
-                innerMessage: object.inner_message ? aminoToAny(object.inner_message) : undefined,
-                proof: object.proof !== undefined && object.proof !== null
-                    ? bytesFromBase64(object.proof)
-                    : new Uint8Array(),
-                nullifier: object.nullifier !== undefined && object.nullifier !== null
-                    ? bytesFromBase64(object.nullifier)
-                    : new Uint8Array(),
-                rateLimitNullifier: object.rate_limit_nullifier !== undefined && object.rate_limit_nullifier !== null
-                    ? bytesFromBase64(object.rate_limit_nullifier)
-                    : new Uint8Array(),
-                merkleRoot: object.merkle_root !== undefined && object.merkle_root !== null
-                    ? bytesFromBase64(object.merkle_root)
-                    : new Uint8Array(),
-                proofDomain: object.proof_domain ?? 0,
-                minTrustLevel: object.min_trust_level ?? 0,
-                execMode: object.exec_mode ?? 0,
-                encryptedPayload: object.encrypted_payload !== undefined && object.encrypted_payload !== null
-                    ? bytesFromBase64(object.encrypted_payload)
-                    : new Uint8Array(),
-                targetEpoch: object.target_epoch !== undefined && object.target_epoch !== null
-                    ? BigInt(object.target_epoch)
-                    : BigInt(0),
-            };
-        },
-    },
-    "/sparkdream.shield.v1.MsgTriggerDkg": {
-        aminoType: "sparkdream/x/shield/MsgTriggerDkg",
-        toAmino: MsgTriggerDkg.toAmino,
-        fromAmino: MsgTriggerDkg.fromAmino,
-    },
-    "/sparkdream.shield.v1.MsgRegisterShieldedOp": {
-        aminoType: "sparkdream/x/shield/MsgRegisterShieldedOp",
-        toAmino: MsgRegisterShieldedOp.toAmino,
-        fromAmino: MsgRegisterShieldedOp.fromAmino,
-    },
-    "/sparkdream.shield.v1.MsgDeregisterShieldedOp": {
-        aminoType: "sparkdream/x/shield/MsgDeregisterShieldedOp",
-        toAmino: MsgDeregisterShieldedOp.toAmino,
-        fromAmino: MsgDeregisterShieldedOp.fromAmino,
-    },
-};
+// Why: Telescope's generated converters (and the per-message overrides that
+// used to patch them) disagree with the chain's aminojson on empty lists,
+// empty bytes, Dec strings, oneofs and non-nullable messages, and went stale
+// whenever a proto changed. Every Msg of x/shield is converted by the
+// schema-driven engine in chain-amino.ts instead, which renders amino JSON
+// from the protobuf bytes exactly as the chain does.
+//
+// MAINTENANCE: none per message. The schema (amino-schema.ts, regenerated from
+// the chain on every proto sync) lists every Msg; __tests__/amino-golden.test.ts
+// checks them all against the chain's encoder.
+import * as tx from "./tx";
+import { chainAminoConverters } from "../../../chain-amino";
+export const AminoConverter = chainAminoConverters("sparkdream.shield.v1", tx);

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

@@ -1,9 +1,17 @@
 //@ts-nocheck
-import { MsgUpdateParams } from "./tx";
-export const AminoConverter = {
-    "/sparkdream.sparkdream.v1.MsgUpdateParams": {
-        aminoType: "sparkdream/x/sparkdream/MsgUpdateParams",
-        toAmino: MsgUpdateParams.toAmino,
-        fromAmino: MsgUpdateParams.fromAmino
-    }
-};
+// HAND-WRITTEN OVERRIDE — overlaid on top of the Telescope-generated tx.amino.ts
+// by scripts/codegen.ts after each codegen run. Do not let codegen wipe this.
+//
+// Why: Telescope's generated converters (and the per-message overrides that
+// used to patch them) disagree with the chain's aminojson on empty lists,
+// empty bytes, Dec strings, oneofs and non-nullable messages, and went stale
+// whenever a proto changed. Every Msg of x/sparkdream is converted by the
+// schema-driven engine in chain-amino.ts instead, which renders amino JSON
+// from the protobuf bytes exactly as the chain does.
+//
+// MAINTENANCE: none per message. The schema (amino-schema.ts, regenerated from
+// the chain on every proto sync) lists every Msg; __tests__/amino-golden.test.ts
+// checks them all against the chain's encoder.
+import * as tx from "./tx";
+import { chainAminoConverters } from "../../../chain-amino";
+export const AminoConverter = chainAminoConverters("sparkdream.sparkdream.v1", tx);

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

@@ -1,9 +1,17 @@
 //@ts-nocheck
-import { MsgUpdateParams } from "./tx";
-export const AminoConverter = {
-    "/sparkdream.split.v1.MsgUpdateParams": {
-        aminoType: "sparkdream/x/split/MsgUpdateParams",
-        toAmino: MsgUpdateParams.toAmino,
-        fromAmino: MsgUpdateParams.fromAmino
-    }
-};
+// HAND-WRITTEN OVERRIDE — overlaid on top of the Telescope-generated tx.amino.ts
+// by scripts/codegen.ts after each codegen run. Do not let codegen wipe this.
+//
+// Why: Telescope's generated converters (and the per-message overrides that
+// used to patch them) disagree with the chain's aminojson on empty lists,
+// empty bytes, Dec strings, oneofs and non-nullable messages, and went stale
+// whenever a proto changed. Every Msg of x/split is converted by the
+// schema-driven engine in chain-amino.ts instead, which renders amino JSON
+// from the protobuf bytes exactly as the chain does.
+//
+// MAINTENANCE: none per message. The schema (amino-schema.ts, regenerated from
+// the chain on every proto sync) lists every Msg; __tests__/amino-golden.test.ts
+// checks them all against the chain's encoder.
+import * as tx from "./tx";
+import { chainAminoConverters } from "../../../chain-amino";
+export const AminoConverter = chainAminoConverters("sparkdream.split.v1", tx);

package/esm/sparkdream/vault/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.vault.module.v1
+ * @see proto type: sparkdream.vault.module.v1.Module
+ */
+export const Module = {
+    typeUrl: "/sparkdream.vault.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.vault.module.v1.Module",
+            value: Module.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,104 @@
+//@ts-nocheck
+import { Params } from "./params";
+import { Vault } from "./vault";
+import { VaultProposal } from "./vault_proposal";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseGenesisState() {
+    return {
+        params: Params.fromPartial({}),
+        vaultMap: [],
+        vaultProposalMap: []
+    };
+}
+/**
+ * GenesisState defines the vault module's genesis state.
+ * @name GenesisState
+ * @package sparkdream.vault.v1
+ * @see proto type: sparkdream.vault.v1.GenesisState
+ */
+export const GenesisState = {
+    typeUrl: "/sparkdream.vault.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.vaultMap) {
+            Vault.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.vaultProposalMap) {
+            VaultProposal.encode(v, writer.uint32(26).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.vaultMap.push(Vault.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.vaultProposalMap.push(VaultProposal.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.vaultMap = object.vaultMap?.map(e => Vault.fromPartial(e)) || [];
+        message.vaultProposalMap = object.vaultProposalMap?.map(e => VaultProposal.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
+        }
+        message.vaultMap = object.vault_map?.map(e => Vault.fromAmino(e)) || [];
+        message.vaultProposalMap = object.vault_proposal_map?.map(e => VaultProposal.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
+        if (message.vaultMap) {
+            obj.vault_map = message.vaultMap.map(e => e ? Vault.toAmino(e) : undefined);
+        }
+        else {
+            obj.vault_map = message.vaultMap;
+        }
+        if (message.vaultProposalMap) {
+            obj.vault_proposal_map = message.vaultProposalMap.map(e => e ? VaultProposal.toAmino(e) : undefined);
+        }
+        else {
+            obj.vault_proposal_map = message.vaultProposalMap;
+        }
+        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.vault.v1.GenesisState",
+            value: GenesisState.encode(message).finish()
+        };
+    }
+};

package/esm/sparkdream/vault/v1/params.js

@@ -0,0 +1,90 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseParams() {
+    return {
+        creationEnabled: false,
+        creationFeeAmount: ""
+    };
+}
+/**
+ * Params defines the parameters for the module.
+ * @name Params
+ * @package sparkdream.vault.v1
+ * @see proto type: sparkdream.vault.v1.Params
+ */
+export const Params = {
+    typeUrl: "/sparkdream.vault.v1.Params",
+    aminoType: "sparkdream/x/vault/Params",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.creationEnabled === true) {
+            writer.uint32(8).bool(message.creationEnabled);
+        }
+        if (message.creationFeeAmount !== "") {
+            writer.uint32(18).string(message.creationFeeAmount);
+        }
+        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 = createBaseParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.creationEnabled = reader.bool();
+                    break;
+                case 2:
+                    message.creationFeeAmount = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseParams();
+        message.creationEnabled = object.creationEnabled ?? false;
+        message.creationFeeAmount = object.creationFeeAmount ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseParams();
+        if (object.creation_enabled !== undefined && object.creation_enabled !== null) {
+            message.creationEnabled = object.creation_enabled;
+        }
+        if (object.creation_fee_amount !== undefined && object.creation_fee_amount !== null) {
+            message.creationFeeAmount = object.creation_fee_amount;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.creation_enabled = message.creationEnabled === false ? undefined : message.creationEnabled;
+        obj.creation_fee_amount = message.creationFeeAmount === "" ? undefined : message.creationFeeAmount;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Params.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/vault/Params",
+            value: Params.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return Params.decode(message.value);
+    },
+    toProto(message) {
+        return Params.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.vault.v1.Params",
+            value: Params.encode(message).finish()
+        };
+    }
+};