@sparkdreamnft/sparkdreamjs 0.0.28 → 0.0.29

package/esm/cosmos/crypto/bls12_381/keys.js

@@ -0,0 +1,159 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+function createBasePubKey() {
+    return {
+        key: new Uint8Array()
+    };
+}
+/**
+ * PubKey is an bls12_381 public key for handling CometBFT keys in SDK.
+ * It's needed for Any serialization and SDK compatibility.
+ * It must not be used in a non Tendermint key context because it doesn't implement
+ * ADR-28. Nevertheless, you will like to use bls12_381 in app user level
+ * then you must create a new proto message and follow ADR-28 for Address construction.
+ * @name PubKey
+ * @package cosmos.crypto.bls12_381
+ * @see proto type: cosmos.crypto.bls12_381.PubKey
+ */
+export const PubKey = {
+    typeUrl: "/cosmos.crypto.bls12_381.PubKey",
+    aminoType: "cometbft/PubKeyBls12_381",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        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 = createBasePubKey();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePubKey();
+        message.key = object.key ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePubKey();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = bytesFromBase64(object.key);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key ? base64FromBytes(message.key) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return PubKey.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cometbft/PubKeyBls12_381",
+            value: PubKey.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return PubKey.decode(message.value);
+    },
+    toProto(message) {
+        return PubKey.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.crypto.bls12_381.PubKey",
+            value: PubKey.encode(message).finish()
+        };
+    }
+};
+function createBasePrivKey() {
+    return {
+        key: new Uint8Array()
+    };
+}
+/**
+ * PrivKey defines a bls12_381 private key.
+ * @name PrivKey
+ * @package cosmos.crypto.bls12_381
+ * @see proto type: cosmos.crypto.bls12_381.PrivKey
+ */
+export const PrivKey = {
+    typeUrl: "/cosmos.crypto.bls12_381.PrivKey",
+    aminoType: "cometbft/PrivKeyBls12_381",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        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 = createBasePrivKey();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePrivKey();
+        message.key = object.key ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePrivKey();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = bytesFromBase64(object.key);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key ? base64FromBytes(message.key) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return PrivKey.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cometbft/PrivKeyBls12_381",
+            value: PrivKey.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return PrivKey.decode(message.value);
+    },
+    toProto(message) {
+        return PrivKey.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.crypto.bls12_381.PrivKey",
+            value: PrivKey.encode(message).finish()
+        };
+    }
+};

package/esm/cosmos/crypto/mldsa65/keys.js

@@ -0,0 +1,159 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+function createBasePubKey() {
+    return {
+        key: new Uint8Array()
+    };
+}
+/**
+ * PubKey is an ML-DSA-65 (FIPS 204) public key for handling CometBFT keys in
+ * the SDK. It is intended for validator-key use and must not be used in
+ * application-level account contexts because it does not implement ADR-28
+ * address derivation. If you want to use ML-DSA-65 at the user/account level,
+ * define a new proto message and follow ADR-28 for address construction.
+ * @name PubKey
+ * @package cosmos.crypto.mldsa65
+ * @see proto type: cosmos.crypto.mldsa65.PubKey
+ */
+export const PubKey = {
+    typeUrl: "/cosmos.crypto.mldsa65.PubKey",
+    aminoType: "cometbft/PubKeyMlDsa65",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        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 = createBasePubKey();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePubKey();
+        message.key = object.key ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePubKey();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = bytesFromBase64(object.key);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key ? base64FromBytes(message.key) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return PubKey.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cometbft/PubKeyMlDsa65",
+            value: PubKey.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return PubKey.decode(message.value);
+    },
+    toProto(message) {
+        return PubKey.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.crypto.mldsa65.PubKey",
+            value: PubKey.encode(message).finish()
+        };
+    }
+};
+function createBasePrivKey() {
+    return {
+        key: new Uint8Array()
+    };
+}
+/**
+ * PrivKey defines an ML-DSA-65 private key (FIPS 204 packed form).
+ * @name PrivKey
+ * @package cosmos.crypto.mldsa65
+ * @see proto type: cosmos.crypto.mldsa65.PrivKey
+ */
+export const PrivKey = {
+    typeUrl: "/cosmos.crypto.mldsa65.PrivKey",
+    aminoType: "cometbft/PrivKeyMlDsa65",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        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 = createBasePrivKey();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePrivKey();
+        message.key = object.key ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePrivKey();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = bytesFromBase64(object.key);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key ? base64FromBytes(message.key) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return PrivKey.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cometbft/PrivKeyMlDsa65",
+            value: PrivKey.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return PrivKey.decode(message.value);
+    },
+    toProto(message) {
+        return PrivKey.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.crypto.mldsa65.PrivKey",
+            value: PrivKey.encode(message).finish()
+        };
+    }
+};

package/esm/cosmos_proto/bundle.js

@@ -1,5 +1,5 @@
 //@ts-nocheck
-import * as _1 from "./cosmos";
+import * as _113 from "./cosmos";
 export const cosmos_proto = {
-    ..._1
+    ..._113
 };

package/esm/gogoproto/bundle.js

@@ -1,5 +1,5 @@
 //@ts-nocheck
-import * as _117 from "./gogo";
+import * as _231 from "./gogo";
 export const gogoproto = {
-    ..._117
+    ..._231
 };

package/esm/google/bundle.js

@@ -1,14 +1,14 @@
 //@ts-nocheck
-import * as _118 from "./protobuf/any";
-import * as _119 from "./protobuf/descriptor";
-import * as _120 from "./protobuf/duration";
-import * as _121 from "./protobuf/timestamp";
+import * as _232 from "./protobuf/any";
+import * as _233 from "./protobuf/descriptor";
+import * as _234 from "./protobuf/duration";
+import * as _235 from "./protobuf/timestamp";
 export var google;
 (function (google) {
     google.protobuf = {
-        ..._118,
-        ..._119,
-        ..._120,
-        ..._121
+        ..._232,
+        ..._233,
+        ..._234,
+        ..._235
     };
 })(google || (google = {}));

package/esm/google/protobuf/any.js

@@ -10,88 +10,33 @@ function createBaseAny() {
  * `Any` contains an arbitrary serialized protocol buffer message along with a
  * URL that describes the type of the serialized message.
  *
- * Protobuf library provides support to pack/unpack Any values in the form
- * of utility functions or additional generated methods of the Any type.
+ * In its binary encoding, an `Any` is an ordinary message; but in other wire
+ * forms like JSON, it has a special encoding. The format of the type URL is
+ * described on the `type_url` field.
  *
- * Example 1: Pack and unpack a message in C++.
+ * Protobuf APIs provide utilities to interact with `Any` values:
  *
- *     Foo foo = ...;
- *     Any any;
- *     any.PackFrom(foo);
- *     ...
- *     if (any.UnpackTo(&foo)) {
- *       ...
- *     }
+ * - A 'pack' operation accepts a message and constructs a generic `Any` wrapper
+ *   around it.
+ * - An 'unpack' operation reads the content of an `Any` message, either into an
+ *   existing message or a new one. Unpack operations must check the type of the
+ *   value they unpack against the declared `type_url`.
+ * - An 'is' operation decides whether an `Any` contains a message of the given
+ *   type, i.e. whether it can 'unpack' that type.
  *
- * Example 2: Pack and unpack a message in Java.
+ * The JSON format representation of an `Any` follows one of these cases:
  *
- *     Foo foo = ...;
- *     Any any = Any.pack(foo);
- *     ...
- *     if (any.is(Foo.class)) {
- *       foo = any.unpack(Foo.class);
- *     }
- *     // or ...
- *     if (any.isSameTypeAs(Foo.getDefaultInstance())) {
- *       foo = any.unpack(Foo.getDefaultInstance());
- *     }
+ * - For types without special-cased JSON encodings, the JSON format
+ *   representation of the `Any` is the same as that of the message, with an
+ *   additional `@type` field which contains the type URL.
+ * - For types with special-cased JSON encodings (typically called 'well-known'
+ *   types, listed in https://protobuf.dev/programming-guides/json/#any), the
+ *   JSON format representation has a key `@type` which contains the type URL
+ *   and a key `value` which contains the JSON-serialized value.
  *
- *  Example 3: Pack and unpack a message in Python.
- *
- *     foo = Foo(...)
- *     any = Any()
- *     any.Pack(foo)
- *     ...
- *     if any.Is(Foo.DESCRIPTOR):
- *       any.Unpack(foo)
- *       ...
- *
- *  Example 4: Pack and unpack a message in Go
- *
- *      foo := &pb.Foo{...}
- *      any, err := anypb.New(foo)
- *      if err != nil {
- *        ...
- *      }
- *      ...
- *      foo := &pb.Foo{}
- *      if err := any.UnmarshalTo(foo); err != nil {
- *        ...
- *      }
- *
- * The pack methods provided by protobuf library will by default use
- * 'type.googleapis.com/full.type.name' as the type URL and the unpack
- * methods only use the fully qualified type name after the last '/'
- * in the type URL, for example "foo.bar.com/x/y.z" will yield type
- * name "y.z".
- *
- * JSON
- * ====
- * The JSON representation of an `Any` value uses the regular
- * representation of the deserialized, embedded message, with an
- * additional field `@type` which contains the type URL. Example:
- *
- *     package google.profile;
- *     message Person {
- *       string first_name = 1;
- *       string last_name = 2;
- *     }
- *
- *     {
- *       "@type": "type.googleapis.com/google.profile.Person",
- *       "firstName": <string>,
- *       "lastName": <string>
- *     }
- *
- * If the embedded message type is well-known and has a custom JSON
- * representation, that representation will be embedded adding a field
- * `value` which holds the custom JSON in addition to the `@type`
- * field. Example (for message [google.protobuf.Duration][]):
- *
- *     {
- *       "@type": "type.googleapis.com/google.protobuf.Duration",
- *       "value": "1.212s"
- *     }
+ * The text format representation of an `Any` is like a message with one field
+ * whose name is the type URL in brackets. For example, an `Any` containing a
+ * `foo.Bar` message may be written `[type.googleapis.com/foo.Bar] { a: 2 }`.
  * @name Any
  * @package google.protobuf
  * @see proto type: google.protobuf.Any