@sparkdreamnft/sparkdreamjs 0.0.43 → 0.0.45

package/esm/sparkdream/sparkdream/v1/query.js

@@ -126,3 +126,179 @@ export const QueryParamsResponse = {
         };
     }
 };
+function createBaseQueryContentLicenseRequest() {
+    return {};
+}
+/**
+ * QueryContentLicenseRequest is the request type for Query/ContentLicense.
+ * @name QueryContentLicenseRequest
+ * @package sparkdream.sparkdream.v1
+ * @see proto type: sparkdream.sparkdream.v1.QueryContentLicenseRequest
+ */
+export const QueryContentLicenseRequest = {
+    typeUrl: "/sparkdream.sparkdream.v1.QueryContentLicenseRequest",
+    encode(_, writer = BinaryWriter.create()) {
+        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 = createBaseQueryContentLicenseRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryContentLicenseRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryContentLicenseRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryContentLicenseRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryContentLicenseRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryContentLicenseRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.sparkdream.v1.QueryContentLicenseRequest",
+            value: QueryContentLicenseRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryContentLicenseResponse() {
+    return {
+        license: "",
+        name: "",
+        url: "",
+        dedication: "",
+        acceptedFederatedLicenses: []
+    };
+}
+/**
+ * QueryContentLicenseResponse is the response type for Query/ContentLicense.
+ * @name QueryContentLicenseResponse
+ * @package sparkdream.sparkdream.v1
+ * @see proto type: sparkdream.sparkdream.v1.QueryContentLicenseResponse
+ */
+export const QueryContentLicenseResponse = {
+    typeUrl: "/sparkdream.sparkdream.v1.QueryContentLicenseResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.license !== "") {
+            writer.uint32(10).string(message.license);
+        }
+        if (message.name !== "") {
+            writer.uint32(18).string(message.name);
+        }
+        if (message.url !== "") {
+            writer.uint32(26).string(message.url);
+        }
+        if (message.dedication !== "") {
+            writer.uint32(34).string(message.dedication);
+        }
+        for (const v of message.acceptedFederatedLicenses) {
+            writer.uint32(42).string(v);
+        }
+        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 = createBaseQueryContentLicenseResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.license = reader.string();
+                    break;
+                case 2:
+                    message.name = reader.string();
+                    break;
+                case 3:
+                    message.url = reader.string();
+                    break;
+                case 4:
+                    message.dedication = reader.string();
+                    break;
+                case 5:
+                    message.acceptedFederatedLicenses.push(reader.string());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryContentLicenseResponse();
+        message.license = object.license ?? "";
+        message.name = object.name ?? "";
+        message.url = object.url ?? "";
+        message.dedication = object.dedication ?? "";
+        message.acceptedFederatedLicenses = object.acceptedFederatedLicenses?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryContentLicenseResponse();
+        if (object.license !== undefined && object.license !== null) {
+            message.license = object.license;
+        }
+        if (object.name !== undefined && object.name !== null) {
+            message.name = object.name;
+        }
+        if (object.url !== undefined && object.url !== null) {
+            message.url = object.url;
+        }
+        if (object.dedication !== undefined && object.dedication !== null) {
+            message.dedication = object.dedication;
+        }
+        message.acceptedFederatedLicenses = object.accepted_federated_licenses?.map(e => e) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.license = message.license === "" ? undefined : message.license;
+        obj.name = message.name === "" ? undefined : message.name;
+        obj.url = message.url === "" ? undefined : message.url;
+        obj.dedication = message.dedication === "" ? undefined : message.dedication;
+        if (message.acceptedFederatedLicenses) {
+            obj.accepted_federated_licenses = message.acceptedFederatedLicenses.map(e => e);
+        }
+        else {
+            obj.accepted_federated_licenses = message.acceptedFederatedLicenses;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryContentLicenseResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryContentLicenseResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryContentLicenseResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.sparkdream.v1.QueryContentLicenseResponse",
+            value: QueryContentLicenseResponse.encode(message).finish()
+        };
+    }
+};

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

@@ -8,4 +8,13 @@ export class LCDQueryClient {
         const endpoint = `sparkdream/sparkdream/v1/params`;
         return await this.req.get(endpoint);
     };
+    /* ContentLicense returns the license every piece of content on this chain
+     is published under (CC0 1.0: dedicated to the public domain), the
+     dedication participants make by submitting content, and the licenses
+     content bridged in from other networks must carry. Fixed in code, not a
+     parameter: see docs/content-license.md. */
+    contentLicense = async (_params = {}) => {
+        const endpoint = `sparkdream/sparkdream/v1/content_license`;
+        return await this.req.get(endpoint);
+    };
 }

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

@@ -1,6 +1,6 @@
 import { BinaryReader } from "../../../binary";
 import { createProtobufRpcClient } from "@cosmjs/stargate";
-import { QueryParamsRequest, QueryParamsResponse } from "./query";
+import { QueryParamsRequest, QueryParamsResponse, QueryContentLicenseRequest, QueryContentLicenseResponse } from "./query";
 export class QueryClientImpl {
     rpc;
     constructor(rpc) {
@@ -12,6 +12,16 @@ export class QueryClientImpl {
         const promise = this.rpc.request("sparkdream.sparkdream.v1.Query", "Params", data);
         return promise.then(data => QueryParamsResponse.decode(new BinaryReader(data)));
     };
+    /* ContentLicense returns the license every piece of content on this chain
+     is published under (CC0 1.0: dedicated to the public domain), the
+     dedication participants make by submitting content, and the licenses
+     content bridged in from other networks must carry. Fixed in code, not a
+     parameter: see docs/content-license.md. */
+    contentLicense = async (request = {}) => {
+        const data = QueryContentLicenseRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.sparkdream.v1.Query", "ContentLicense", data);
+        return promise.then(data => QueryContentLicenseResponse.decode(new BinaryReader(data)));
+    };
 }
 export const createRpcQueryExtension = (base) => {
     const rpc = createProtobufRpcClient(base);
@@ -19,6 +29,9 @@ export const createRpcQueryExtension = (base) => {
     return {
         params(request) {
             return queryService.params(request);
+        },
+        contentLicense(request) {
+            return queryService.contentLicense(request);
         }
     };
 };

package/esm/tendermint/bundle.js

@@ -1,34 +1,34 @@
 //@ts-nocheck
-import * as _538 from "./abci/types";
-import * as _539 from "./crypto/keys";
-import * as _540 from "./crypto/proof";
-import * as _541 from "./p2p/types";
-import * as _542 from "./types/block";
-import * as _543 from "./types/evidence";
-import * as _544 from "./types/params";
-import * as _545 from "./types/types";
-import * as _546 from "./types/validator";
-import * as _547 from "./version/types";
+import * as _547 from "./abci/types";
+import * as _548 from "./crypto/keys";
+import * as _549 from "./crypto/proof";
+import * as _550 from "./p2p/types";
+import * as _551 from "./types/block";
+import * as _552 from "./types/evidence";
+import * as _553 from "./types/params";
+import * as _554 from "./types/types";
+import * as _555 from "./types/validator";
+import * as _556 from "./version/types";
 export var tendermint;
 (function (tendermint) {
     tendermint.abci = {
-        ..._538
+        ..._547
     };
     tendermint.crypto = {
-        ..._539,
-        ..._540
+        ..._548,
+        ..._549
     };
     tendermint.p2p = {
-        ..._541
+        ..._550
     };
     tendermint.types = {
-        ..._542,
-        ..._543,
-        ..._544,
-        ..._545,
-        ..._546
+        ..._551,
+        ..._552,
+        ..._553,
+        ..._554,
+        ..._555
     };
     tendermint.version = {
-        ..._547
+        ..._556
     };
 })(tendermint || (tendermint = {}));