@sparkdreamnft/sparkdreamjs 0.0.40 → 0.0.41

package/esm/sparkdream/federation/v1/types.js

@@ -176,6 +176,30 @@ export var FederatedContentStatus;
     FederatedContentStatus[FederatedContentStatus["FEDERATED_CONTENT_STATUS_DISPUTED"] = 4] = "FEDERATED_CONTENT_STATUS_DISPUTED";
     FederatedContentStatus[FederatedContentStatus["FEDERATED_CONTENT_STATUS_CHALLENGED"] = 5] = "FEDERATED_CONTENT_STATUS_CHALLENGED";
     FederatedContentStatus[FederatedContentStatus["FEDERATED_CONTENT_STATUS_REJECTED"] = 6] = "FEDERATED_CONTENT_STATUS_REJECTED";
+    /**
+     * FEDERATED_CONTENT_STATUS_UNRESOLVED - UNRESOLVED is system-assigned: the arbiter resolution window expired
+     * without quorum, so no finding was ever made about the content. It is
+     * terminal, deliberately excluded from MsgModerateContent (OpsComm
+     * moderates HIDDEN/ACTIVE/VERIFIED/REJECTED, not system states), and
+     * was chosen over reverting to PENDING_VERIFICATION because a revived
+     * record would have no VerificationWindow queue entry and a verification
+     * deadline already in the past — unverifiable and unreapable until
+     * content_ttl. Local state only: FederatedContentStatus never crosses
+     * the IBC wire (see packet_wire_compat_test.go).
+     */
+    FederatedContentStatus[FederatedContentStatus["FEDERATED_CONTENT_STATUS_UNRESOLVED"] = 7] = "FEDERATED_CONTENT_STATUS_UNRESOLVED";
+    /**
+     * FEDERATED_CONTENT_STATUS_SUPERSEDED - SUPERSEDED is system-assigned: the submitting operator anchored a newer
+     * version of the same content_uri (an edit) while this record was still
+     * PENDING_VERIFICATION. The anchored version no longer exists at the
+     * source, so no verifier can ever confirm it; retiring it here keeps it
+     * out of the verification-expiry sweep, which would otherwise count it
+     * against an honest operator as unverified. Terminal and excluded from
+     * MsgModerateContent for the same reason as UNRESOLVED: moderating it
+     * could manufacture a VERIFIED status for bytes nobody verified. Local
+     * state only; never crosses the IBC wire.
+     */
+    FederatedContentStatus[FederatedContentStatus["FEDERATED_CONTENT_STATUS_SUPERSEDED"] = 8] = "FEDERATED_CONTENT_STATUS_SUPERSEDED";
     FederatedContentStatus[FederatedContentStatus["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(FederatedContentStatus || (FederatedContentStatus = {}));
 export const FederatedContentStatusAmino = FederatedContentStatus;
@@ -202,6 +226,12 @@ export function federatedContentStatusFromJSON(object) {
         case 6:
         case "FEDERATED_CONTENT_STATUS_REJECTED":
             return FederatedContentStatus.FEDERATED_CONTENT_STATUS_REJECTED;
+        case 7:
+        case "FEDERATED_CONTENT_STATUS_UNRESOLVED":
+            return FederatedContentStatus.FEDERATED_CONTENT_STATUS_UNRESOLVED;
+        case 8:
+        case "FEDERATED_CONTENT_STATUS_SUPERSEDED":
+            return FederatedContentStatus.FEDERATED_CONTENT_STATUS_SUPERSEDED;
         case -1:
         case "UNRECOGNIZED":
         default:
@@ -224,6 +254,10 @@ export function federatedContentStatusToJSON(object) {
             return "FEDERATED_CONTENT_STATUS_CHALLENGED";
         case FederatedContentStatus.FEDERATED_CONTENT_STATUS_REJECTED:
             return "FEDERATED_CONTENT_STATUS_REJECTED";
+        case FederatedContentStatus.FEDERATED_CONTENT_STATUS_UNRESOLVED:
+            return "FEDERATED_CONTENT_STATUS_UNRESOLVED";
+        case FederatedContentStatus.FEDERATED_CONTENT_STATUS_SUPERSEDED:
+            return "FEDERATED_CONTENT_STATUS_SUPERSEDED";
         case FederatedContentStatus.UNRECOGNIZED:
         default:
             return "UNRECOGNIZED";
@@ -629,7 +663,8 @@ function createBasePeerPolicy() {
         allowReputationQueries: false,
         acceptReputationAttestations: false,
         requireReview: false,
-        blockedIdentities: []
+        blockedIdentities: [],
+        contentHosts: []
     };
 }
 /**
@@ -671,6 +706,9 @@ export const PeerPolicy = {
         for (const v of message.blockedIdentities) {
             writer.uint32(74).string(v);
         }
+        for (const v of message.contentHosts) {
+            writer.uint32(90).string(v);
+        }
         return writer;
     },
     decode(input, length) {
@@ -710,6 +748,9 @@ export const PeerPolicy = {
                 case 9:
                     message.blockedIdentities.push(reader.string());
                     break;
+                case 11:
+                    message.contentHosts.push(reader.string());
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -729,6 +770,7 @@ export const PeerPolicy = {
         message.acceptReputationAttestations = object.acceptReputationAttestations ?? false;
         message.requireReview = object.requireReview ?? false;
         message.blockedIdentities = object.blockedIdentities?.map(e => e) || [];
+        message.contentHosts = object.contentHosts?.map(e => e) || [];
         return message;
     },
     fromAmino(object) {
@@ -757,6 +799,7 @@ export const PeerPolicy = {
             message.requireReview = object.require_review;
         }
         message.blockedIdentities = object.blocked_identities?.map(e => e) || [];
+        message.contentHosts = object.content_hosts?.map(e => e) || [];
         return message;
     },
     toAmino(message) {
@@ -786,6 +829,12 @@ export const PeerPolicy = {
         else {
             obj.blocked_identities = message.blockedIdentities;
         }
+        if (message.contentHosts) {
+            obj.content_hosts = message.contentHosts.map(e => e);
+        }
+        else {
+            obj.content_hosts = message.contentHosts;
+        }
         return obj;
     },
     fromAminoMsg(object) {
@@ -1090,7 +1139,8 @@ function createBaseVerificationRecord() {
         lastChallengeResolvedAt: BigInt(0),
         challenger: "",
         escrowedChallengeFee: "",
-        pendingVerifierVerdict: 0
+        pendingVerifierVerdict: 0,
+        commitmentReleased: false
     };
 }
 /**
@@ -1141,6 +1191,9 @@ export const VerificationRecord = {
         if (message.pendingVerifierVerdict !== 0) {
             writer.uint32(104).int32(message.pendingVerifierVerdict);
         }
+        if (message.commitmentReleased === true) {
+            writer.uint32(112).bool(message.commitmentReleased);
+        }
         return writer;
     },
     decode(input, length) {
@@ -1189,6 +1242,9 @@ export const VerificationRecord = {
                 case 13:
                     message.pendingVerifierVerdict = reader.int32();
                     break;
+                case 14:
+                    message.commitmentReleased = reader.bool();
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -1211,6 +1267,7 @@ export const VerificationRecord = {
         message.challenger = object.challenger ?? "";
         message.escrowedChallengeFee = object.escrowedChallengeFee ?? "";
         message.pendingVerifierVerdict = object.pendingVerifierVerdict ?? 0;
+        message.commitmentReleased = object.commitmentReleased ?? false;
         return message;
     },
     fromAmino(object) {
@@ -1254,6 +1311,9 @@ export const VerificationRecord = {
         if (object.pending_verifier_verdict !== undefined && object.pending_verifier_verdict !== null) {
             message.pendingVerifierVerdict = object.pending_verifier_verdict;
         }
+        if (object.commitment_released !== undefined && object.commitment_released !== null) {
+            message.commitmentReleased = object.commitment_released;
+        }
         return message;
     },
     toAmino(message) {
@@ -1271,6 +1331,7 @@ export const VerificationRecord = {
         obj.challenger = message.challenger === "" ? undefined : message.challenger;
         obj.escrowed_challenge_fee = message.escrowedChallengeFee === "" ? undefined : message.escrowedChallengeFee;
         obj.pending_verifier_verdict = message.pendingVerifierVerdict === 0 ? undefined : message.pendingVerifierVerdict;
+        obj.commitment_released = message.commitmentReleased === false ? undefined : message.commitmentReleased;
         return obj;
     },
     fromAminoMsg(object) {
@@ -1547,7 +1608,9 @@ function createBaseFederatedContent() {
         submittedBy: "",
         status: 0,
         expiresAt: BigInt(0),
-        contentHash: new Uint8Array()
+        contentHash: new Uint8Array(),
+        supersedes: undefined,
+        supersededBy: BigInt(0)
     };
 }
 /**
@@ -1607,6 +1670,12 @@ export const FederatedContent = {
         if (message.contentHash.length !== 0) {
             writer.uint32(130).bytes(message.contentHash);
         }
+        if (message.supersedes !== undefined) {
+            ContentRef.encode(message.supersedes, writer.uint32(138).fork()).ldelim();
+        }
+        if (message.supersededBy !== BigInt(0)) {
+            writer.uint32(144).uint64(message.supersededBy);
+        }
         return writer;
     },
     decode(input, length) {
@@ -1664,6 +1733,12 @@ export const FederatedContent = {
                 case 16:
                     message.contentHash = reader.bytes();
                     break;
+                case 17:
+                    message.supersedes = ContentRef.decode(reader, reader.uint32());
+                    break;
+                case 18:
+                    message.supersededBy = reader.uint64();
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -1689,6 +1764,8 @@ export const FederatedContent = {
         message.status = object.status ?? 0;
         message.expiresAt = object.expiresAt !== undefined && object.expiresAt !== null ? BigInt(object.expiresAt.toString()) : BigInt(0);
         message.contentHash = object.contentHash ?? new Uint8Array();
+        message.supersedes = object.supersedes !== undefined && object.supersedes !== null ? ContentRef.fromPartial(object.supersedes) : undefined;
+        message.supersededBy = object.supersededBy !== undefined && object.supersededBy !== null ? BigInt(object.supersededBy.toString()) : BigInt(0);
         return message;
     },
     fromAmino(object) {
@@ -1741,6 +1818,12 @@ export const FederatedContent = {
         if (object.content_hash !== undefined && object.content_hash !== null) {
             message.contentHash = bytesFromBase64(object.content_hash);
         }
+        if (object.supersedes !== undefined && object.supersedes !== null) {
+            message.supersedes = ContentRef.fromAmino(object.supersedes);
+        }
+        if (object.superseded_by !== undefined && object.superseded_by !== null) {
+            message.supersededBy = BigInt(object.superseded_by);
+        }
         return message;
     },
     toAmino(message) {
@@ -1761,6 +1844,8 @@ export const FederatedContent = {
         obj.status = message.status === 0 ? undefined : message.status;
         obj.expires_at = message.expiresAt !== BigInt(0) ? message.expiresAt?.toString() : undefined;
         obj.content_hash = message.contentHash ? base64FromBytes(message.contentHash) : undefined;
+        obj.supersedes = message.supersedes ? ContentRef.toAmino(message.supersedes) : undefined;
+        obj.superseded_by = message.supersededBy !== BigInt(0) ? message.supersededBy?.toString() : undefined;
         return obj;
     },
     fromAminoMsg(object) {
@@ -1779,6 +1864,77 @@ export const FederatedContent = {
         };
     }
 };
+function createBaseContentRef() {
+    return {
+        contentId: BigInt(0)
+    };
+}
+/**
+ * ContentRef points at a FederatedContent record. A message rather than a
+ * bare uint64 because content ids start at 0: a nil ref is "none", which
+ * a zero id could not express.
+ * @name ContentRef
+ * @package sparkdream.federation.v1
+ * @see proto type: sparkdream.federation.v1.ContentRef
+ */
+export const ContentRef = {
+    typeUrl: "/sparkdream.federation.v1.ContentRef",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.contentId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.contentId);
+        }
+        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 = createBaseContentRef();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.contentId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseContentRef();
+        message.contentId = object.contentId !== undefined && object.contentId !== null ? BigInt(object.contentId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseContentRef();
+        if (object.content_id !== undefined && object.content_id !== null) {
+            message.contentId = BigInt(object.content_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.content_id = message.contentId !== BigInt(0) ? message.contentId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ContentRef.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ContentRef.decode(message.value);
+    },
+    toProto(message) {
+        return ContentRef.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.federation.v1.ContentRef",
+            value: ContentRef.encode(message).finish()
+        };
+    }
+};
 function createBaseIdentityLink() {
     return {
         localAddress: "",

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

@@ -2,13 +2,155 @@
 // HAND-WRITTEN OVERRIDE — overlaid by scripts/codegen.ts after telescope.
 // See ../../commons/v1/tx.amino.ts for rationale.
 //
-// MsgExecSession has `repeated google.protobuf.Any msgs = 3` (note the
-// shorter field name `msgs`, not `messages`). Same recursive-Any problem.
+// Because this file replaces the generated one wholesale, EVERY Msg in
+// session/v1/tx.proto must have an entry here — a message added to the proto
+// but not to this map ships in the registry with no amino converter, and
+// Keplr/Ledger (amino-json) signing of it fails.
+//
+// Three shapes telescope gets wrong for this module:
+//
+//   1. MsgExecSession / OneshotExec carry google.protobuf.Any, which needs the
+//      recursive conversion in ../../../nested-amino.
+//   2. MsgCreateGrant.payload and ScheduledOneshotPayload.action are oneofs
+//      with (amino.oneof_name). cosmossdk.io/x/tx/signing/aminojson renders a
+//      set oneof member as
+//
+//        "<CamelCase oneof name>": {"type": "<oneof_name>", "value": {"<field>": {...}}}
+//
+//      e.g. "Payload": {"type": "sparkdream/session/RecurringPullPayload",
+//                        "value": {"recurring_pull": {...}}}
+//
+//      while telescope emits the bare member ("recurring_pull": {...}).
+//   3. Repeated fields must be omitted when empty (omitempty), never `[]`.
+//
+// cosmjs rebuilds the TxBody from fromAmino(signed msgs), so each fromAmino
+// below must exactly invert its toAmino.
+//
+// 64-bit ints are coerced here rather than trusting callers to pass BigInt:
+// cosmjs hands toAmino the caller's raw value (no fromPartial), and a Number
+// 0 would otherwise sign a key the chain omits.
 import { MsgUpdateParams, MsgUpdateOperationalParams, MsgCreateSession, MsgRevokeSession, } from "./tx";
 import { Coin } from "../../../cosmos/base/v1beta1/coin";
 import { Timestamp } from "../../../google/protobuf/timestamp";
-import { toTimestamp } from "../../../helpers";
+import { toTimestamp, fromTimestamp } from "../../../helpers";
 import { anyToAmino, aminoToAny } from "../../../nested-amino";
+const str = (v) => (v === "" || v === undefined || v === null ? undefined : v);
+const int64 = (v) => {
+    if (v === undefined || v === null || v === "")
+        return undefined;
+    const b = BigInt(v);
+    return b === BigInt(0) ? undefined : b.toString();
+};
+const bool = (v) => (v ? true : undefined);
+const list = (v) => ((v?.length ?? 0) > 0 ? v.map((e) => e) : undefined);
+const coin = (v) => (v ? Coin.toAmino(Coin.fromPartial(v)) : undefined);
+const time = (v) => (v ? Timestamp.toAmino(toTimestamp(v)) : undefined);
+const toBig = (v) => (v === undefined || v === null ? BigInt(0) : BigInt(v));
+const fromCoin = (v) => (v ? Coin.fromAmino(v) : undefined);
+const fromTime = (v) => (v ? fromTimestamp(Timestamp.fromAmino(v)) : undefined);
+// ── Payloads ────────────────────────────────────────────────────────────
+const sessionKeyToAmino = (p) => ({
+    allowed_msg_types: list(p.allowedMsgTypes),
+    spend_limit: coin(p.spendLimit),
+    spent: coin(p.spent),
+    max_exec_count: int64(p.maxExecCount),
+    exec_count: int64(p.execCount),
+    last_used_at: time(p.lastUsedAt),
+    allow_self_revoke: bool(p.allowSelfRevoke),
+});
+const sessionKeyFromAmino = (o) => ({
+    allowedMsgTypes: o.allowed_msg_types ?? [],
+    spendLimit: fromCoin(o.spend_limit),
+    spent: fromCoin(o.spent),
+    maxExecCount: toBig(o.max_exec_count),
+    execCount: toBig(o.exec_count),
+    lastUsedAt: fromTime(o.last_used_at),
+    allowSelfRevoke: o.allow_self_revoke ?? false,
+});
+const recurringPullToAmino = (p) => ({
+    amount_per_period: coin(p.amountPerPeriod),
+    period_seconds: int64(p.periodSeconds),
+    start_time: int64(p.startTime),
+    last_claim_advance: int64(p.lastClaimAdvance),
+    claims_made: int64(p.claimsMade),
+    max_per_epoch: str(p.maxPerEpoch),
+});
+const recurringPullFromAmino = (o) => ({
+    amountPerPeriod: fromCoin(o.amount_per_period),
+    periodSeconds: toBig(o.period_seconds),
+    startTime: toBig(o.start_time),
+    lastClaimAdvance: toBig(o.last_claim_advance),
+    claimsMade: toBig(o.claims_made),
+    maxPerEpoch: o.max_per_epoch ?? "",
+});
+const spendingAllowanceToAmino = (p) => ({
+    max_per_period: coin(p.maxPerPeriod),
+    period_seconds: int64(p.periodSeconds),
+    current_period_start: int64(p.currentPeriodStart),
+    spent_in_current_period: coin(p.spentInCurrentPeriod),
+    allowed_recipients: list(p.allowedRecipients),
+    denom: str(p.denom),
+});
+const spendingAllowanceFromAmino = (o) => ({
+    maxPerPeriod: fromCoin(o.max_per_period),
+    periodSeconds: toBig(o.period_seconds),
+    currentPeriodStart: toBig(o.current_period_start),
+    spentInCurrentPeriod: fromCoin(o.spent_in_current_period),
+    allowedRecipients: o.allowed_recipients ?? [],
+    denom: o.denom ?? "",
+});
+const scheduledOneshotToAmino = (p) => {
+    let action = undefined;
+    if (p.transfer) {
+        action = {
+            type: "sparkdream/session/OneshotTransfer",
+            value: { transfer: { recipient: str(p.transfer.recipient), amount: coin(p.transfer.amount) } },
+        };
+    }
+    else if (p.exec) {
+        action = {
+            type: "sparkdream/session/OneshotExec",
+            value: {
+                exec: {
+                    msg: p.exec.msg ? anyToAmino(p.exec.msg) : undefined,
+                    gas_limit: int64(p.exec.gasLimit),
+                },
+            },
+        };
+    }
+    return {
+        // aminojson writes `null` for an unset oneof rather than omitting it.
+        Action: action ?? null,
+        fire_at: int64(p.fireAt),
+        fire_error: str(p.fireError),
+    };
+};
+const scheduledOneshotFromAmino = (o) => {
+    const v = o.Action?.value ?? {};
+    return {
+        transfer: v.transfer
+            ? { recipient: v.transfer.recipient ?? "", amount: fromCoin(v.transfer.amount) }
+            : undefined,
+        exec: v.exec
+            ? { msg: v.exec.msg ? aminoToAny(v.exec.msg) : undefined, gasLimit: toBig(v.exec.gas_limit) }
+            : undefined,
+        fireAt: toBig(o.fire_at),
+        fireError: o.fire_error ?? "",
+    };
+};
+const PAYLOADS = [
+    ["sessionKey", "session_key", "sparkdream/session/SessionKeyPayload", sessionKeyToAmino, sessionKeyFromAmino],
+    ["recurringPull", "recurring_pull", "sparkdream/session/RecurringPullPayload", recurringPullToAmino, recurringPullFromAmino],
+    ["spendingAllowance", "spending_allowance", "sparkdream/session/SpendingAllowancePayload", spendingAllowanceToAmino, spendingAllowanceFromAmino],
+    ["scheduledOneshot", "scheduled_oneshot", "sparkdream/session/ScheduledOneshotPayload", scheduledOneshotToAmino, scheduledOneshotFromAmino],
+];
+// ── Messages ────────────────────────────────────────────────────────────
+// {<signer>, grant_id} messages; each signer field name is a single word, so
+// the proto and amino spellings coincide.
+const grantIdMsg = (signer) => ({
+    toAmino: (m) => ({ [signer]: str(m[signer]), grant_id: int64(m.grantId) }),
+    fromAmino: (o) => ({ [signer]: o[signer] ?? "", grantId: toBig(o.grant_id) }),
+});
 export const AminoConverter = {
     "/sparkdream.session.v1.MsgUpdateParams": {
         aminoType: "sparkdream/x/session/MsgUpdateParams",
@@ -64,4 +206,64 @@ export const AminoConverter = {
             };
         },
     },
+    "/sparkdream.session.v1.MsgCreateGrant": {
+        aminoType: "sparkdream/x/session/MsgCreateGrant",
+        toAmino(message) {
+            const set = PAYLOADS.find(([key]) => message[key]);
+            return {
+                granter: str(message.granter),
+                grantee: str(message.grantee),
+                expires_at: time(message.expiresAt),
+                note: str(message.note),
+                Payload: set
+                    ? { type: set[2], value: { [set[1]]: set[3](message[set[0]]) } }
+                    : null,
+            };
+        },
+        fromAmino(object) {
+            const out = {
+                granter: object.granter ?? "",
+                grantee: object.grantee ?? "",
+                expiresAt: fromTime(object.expires_at),
+                note: object.note ?? "",
+            };
+            const inner = object.Payload?.value ?? {};
+            for (const [key, field, , , fromAmino] of PAYLOADS) {
+                if (inner[field])
+                    out[key] = fromAmino(inner[field]);
+            }
+            return out;
+        },
+    },
+    "/sparkdream.session.v1.MsgClaimRecurringPull": {
+        aminoType: "sparkdream/x/session/MsgClaimRecurringPull",
+        ...grantIdMsg("grantee"),
+    },
+    "/sparkdream.session.v1.MsgPullAllowance": {
+        aminoType: "sparkdream/x/session/MsgPullAllowance",
+        toAmino: (m) => ({
+            grantee: str(m.grantee),
+            grant_id: int64(m.grantId),
+            recipient: str(m.recipient),
+            amount: coin(m.amount),
+        }),
+        fromAmino: (o) => ({
+            grantee: o.grantee ?? "",
+            grantId: toBig(o.grant_id),
+            recipient: o.recipient ?? "",
+            amount: fromCoin(o.amount),
+        }),
+    },
+    "/sparkdream.session.v1.MsgRetryScheduledOneshot": {
+        aminoType: "sparkdream/x/session/MsgRetryScheduledOneshot",
+        ...grantIdMsg("caller"),
+    },
+    "/sparkdream.session.v1.MsgRevokeGrant": {
+        aminoType: "sparkdream/x/session/MsgRevokeGrant",
+        ...grantIdMsg("granter"),
+    },
+    "/sparkdream.session.v1.MsgDeclineGrant": {
+        aminoType: "sparkdream/x/session/MsgDeclineGrant",
+        ...grantIdMsg("grantee"),
+    },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sparkdreamnft/sparkdreamjs",
-  "version": "0.0.40",
+  "version": "0.0.41",
   "author": "kob <kob@sparkdream.io>",
   "description": "Spark Dream blockchain TypeScript library",
   "main": "index.js",