@sparkdreamnft/sparkdreamjs 0.0.43 → 0.0.44

package/sparkdream/rep/v1/initiative_bounty.d.ts

@@ -0,0 +1,143 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * InitiativeBounty is DREAM escrowed against one initiative by members who
+ * want the work done, paid to the assignee only if the initiative completes.
+ *
+ * The budget is minted; a bounty moves DREAM that already exists, so it is the
+ * non-inflationary way to signal demand. Because it is contingent on completion
+ * it is also a route for DREAM between members, which is why it is capped
+ * against the budget and per funder, barred to anyone affiliated with the work,
+ * taxed on release, and counted against the assignee's recipient-side transfer
+ * limits. Distinct from ReviewBounty, which pays reviewers per verdict filed
+ * and is never contingent on approval.
+ * @name InitiativeBounty
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.InitiativeBounty
+ */
+export interface InitiativeBounty {
+    initiativeId: bigint;
+    /**
+     * Total DREAM currently escrowed and unpaid.
+     */
+    amount: string;
+    /**
+     * Per-funder contributions, so refunds return each funder's own DREAM.
+     */
+    contributions: InitiativeBountyContribution[];
+}
+export interface InitiativeBountyProtoMsg {
+    typeUrl: "/sparkdream.rep.v1.InitiativeBounty";
+    value: Uint8Array;
+}
+/**
+ * InitiativeBounty is DREAM escrowed against one initiative by members who
+ * want the work done, paid to the assignee only if the initiative completes.
+ *
+ * The budget is minted; a bounty moves DREAM that already exists, so it is the
+ * non-inflationary way to signal demand. Because it is contingent on completion
+ * it is also a route for DREAM between members, which is why it is capped
+ * against the budget and per funder, barred to anyone affiliated with the work,
+ * taxed on release, and counted against the assignee's recipient-side transfer
+ * limits. Distinct from ReviewBounty, which pays reviewers per verdict filed
+ * and is never contingent on approval.
+ * @name InitiativeBountyAmino
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.InitiativeBounty
+ */
+export interface InitiativeBountyAmino {
+    initiative_id?: string;
+    /**
+     * Total DREAM currently escrowed and unpaid.
+     */
+    amount?: string;
+    /**
+     * Per-funder contributions, so refunds return each funder's own DREAM.
+     */
+    contributions?: InitiativeBountyContributionAmino[];
+}
+export interface InitiativeBountyAminoMsg {
+    type: "/sparkdream.rep.v1.InitiativeBounty";
+    value: InitiativeBountyAmino;
+}
+/**
+ * InitiativeBountyContribution is one funder's stake in an initiative bounty.
+ * @name InitiativeBountyContribution
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.InitiativeBountyContribution
+ */
+export interface InitiativeBountyContribution {
+    funder: string;
+    amount: string;
+    /**
+     * Block height, for initiative_bounty_reclaim_delay.
+     */
+    fundedAt: bigint;
+}
+export interface InitiativeBountyContributionProtoMsg {
+    typeUrl: "/sparkdream.rep.v1.InitiativeBountyContribution";
+    value: Uint8Array;
+}
+/**
+ * InitiativeBountyContribution is one funder's stake in an initiative bounty.
+ * @name InitiativeBountyContributionAmino
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.InitiativeBountyContribution
+ */
+export interface InitiativeBountyContributionAmino {
+    funder?: string;
+    amount?: string;
+    /**
+     * Block height, for initiative_bounty_reclaim_delay.
+     */
+    funded_at?: string;
+}
+export interface InitiativeBountyContributionAminoMsg {
+    type: "/sparkdream.rep.v1.InitiativeBountyContribution";
+    value: InitiativeBountyContributionAmino;
+}
+/**
+ * InitiativeBounty is DREAM escrowed against one initiative by members who
+ * want the work done, paid to the assignee only if the initiative completes.
+ *
+ * The budget is minted; a bounty moves DREAM that already exists, so it is the
+ * non-inflationary way to signal demand. Because it is contingent on completion
+ * it is also a route for DREAM between members, which is why it is capped
+ * against the budget and per funder, barred to anyone affiliated with the work,
+ * taxed on release, and counted against the assignee's recipient-side transfer
+ * limits. Distinct from ReviewBounty, which pays reviewers per verdict filed
+ * and is never contingent on approval.
+ * @name InitiativeBounty
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.InitiativeBounty
+ */
+export declare const InitiativeBounty: {
+    typeUrl: string;
+    encode(message: InitiativeBounty, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): InitiativeBounty;
+    fromPartial(object: DeepPartial<InitiativeBounty>): InitiativeBounty;
+    fromAmino(object: InitiativeBountyAmino): InitiativeBounty;
+    toAmino(message: InitiativeBounty): InitiativeBountyAmino;
+    fromAminoMsg(object: InitiativeBountyAminoMsg): InitiativeBounty;
+    fromProtoMsg(message: InitiativeBountyProtoMsg): InitiativeBounty;
+    toProto(message: InitiativeBounty): Uint8Array;
+    toProtoMsg(message: InitiativeBounty): InitiativeBountyProtoMsg;
+};
+/**
+ * InitiativeBountyContribution is one funder's stake in an initiative bounty.
+ * @name InitiativeBountyContribution
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.InitiativeBountyContribution
+ */
+export declare const InitiativeBountyContribution: {
+    typeUrl: string;
+    encode(message: InitiativeBountyContribution, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): InitiativeBountyContribution;
+    fromPartial(object: DeepPartial<InitiativeBountyContribution>): InitiativeBountyContribution;
+    fromAmino(object: InitiativeBountyContributionAmino): InitiativeBountyContribution;
+    toAmino(message: InitiativeBountyContribution): InitiativeBountyContributionAmino;
+    fromAminoMsg(object: InitiativeBountyContributionAminoMsg): InitiativeBountyContribution;
+    fromProtoMsg(message: InitiativeBountyContributionProtoMsg): InitiativeBountyContribution;
+    toProto(message: InitiativeBountyContribution): Uint8Array;
+    toProtoMsg(message: InitiativeBountyContribution): InitiativeBountyContributionProtoMsg;
+};

package/sparkdream/rep/v1/initiative_bounty.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitiativeBountyContribution = exports.InitiativeBounty = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../binary");
+function createBaseInitiativeBounty() {
+    return {
+        initiativeId: BigInt(0),
+        amount: "",
+        contributions: []
+    };
+}
+/**
+ * InitiativeBounty is DREAM escrowed against one initiative by members who
+ * want the work done, paid to the assignee only if the initiative completes.
+ *
+ * The budget is minted; a bounty moves DREAM that already exists, so it is the
+ * non-inflationary way to signal demand. Because it is contingent on completion
+ * it is also a route for DREAM between members, which is why it is capped
+ * against the budget and per funder, barred to anyone affiliated with the work,
+ * taxed on release, and counted against the assignee's recipient-side transfer
+ * limits. Distinct from ReviewBounty, which pays reviewers per verdict filed
+ * and is never contingent on approval.
+ * @name InitiativeBounty
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.InitiativeBounty
+ */
+exports.InitiativeBounty = {
+    typeUrl: "/sparkdream.rep.v1.InitiativeBounty",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.initiativeId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.initiativeId);
+        }
+        if (message.amount !== "") {
+            writer.uint32(18).string(message.amount);
+        }
+        for (const v of message.contributions) {
+            exports.InitiativeBountyContribution.encode(v, writer.uint32(26).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 = createBaseInitiativeBounty();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.initiativeId = reader.uint64();
+                    break;
+                case 2:
+                    message.amount = reader.string();
+                    break;
+                case 3:
+                    message.contributions.push(exports.InitiativeBountyContribution.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseInitiativeBounty();
+        message.initiativeId = object.initiativeId !== undefined && object.initiativeId !== null ? BigInt(object.initiativeId.toString()) : BigInt(0);
+        message.amount = object.amount ?? "";
+        message.contributions = object.contributions?.map(e => exports.InitiativeBountyContribution.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseInitiativeBounty();
+        if (object.initiative_id !== undefined && object.initiative_id !== null) {
+            message.initiativeId = BigInt(object.initiative_id);
+        }
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = object.amount;
+        }
+        message.contributions = object.contributions?.map(e => exports.InitiativeBountyContribution.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.initiative_id = message.initiativeId !== BigInt(0) ? message.initiativeId?.toString() : undefined;
+        obj.amount = message.amount === "" ? undefined : message.amount;
+        if (message.contributions) {
+            obj.contributions = message.contributions.map(e => e ? exports.InitiativeBountyContribution.toAmino(e) : undefined);
+        }
+        else {
+            obj.contributions = message.contributions;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.InitiativeBounty.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.InitiativeBounty.decode(message.value);
+    },
+    toProto(message) {
+        return exports.InitiativeBounty.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.InitiativeBounty",
+            value: exports.InitiativeBounty.encode(message).finish()
+        };
+    }
+};
+function createBaseInitiativeBountyContribution() {
+    return {
+        funder: "",
+        amount: "",
+        fundedAt: BigInt(0)
+    };
+}
+/**
+ * InitiativeBountyContribution is one funder's stake in an initiative bounty.
+ * @name InitiativeBountyContribution
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.InitiativeBountyContribution
+ */
+exports.InitiativeBountyContribution = {
+    typeUrl: "/sparkdream.rep.v1.InitiativeBountyContribution",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.funder !== "") {
+            writer.uint32(10).string(message.funder);
+        }
+        if (message.amount !== "") {
+            writer.uint32(18).string(message.amount);
+        }
+        if (message.fundedAt !== BigInt(0)) {
+            writer.uint32(24).int64(message.fundedAt);
+        }
+        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 = createBaseInitiativeBountyContribution();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.funder = reader.string();
+                    break;
+                case 2:
+                    message.amount = reader.string();
+                    break;
+                case 3:
+                    message.fundedAt = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseInitiativeBountyContribution();
+        message.funder = object.funder ?? "";
+        message.amount = object.amount ?? "";
+        message.fundedAt = object.fundedAt !== undefined && object.fundedAt !== null ? BigInt(object.fundedAt.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseInitiativeBountyContribution();
+        if (object.funder !== undefined && object.funder !== null) {
+            message.funder = object.funder;
+        }
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = object.amount;
+        }
+        if (object.funded_at !== undefined && object.funded_at !== null) {
+            message.fundedAt = BigInt(object.funded_at);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.funder = message.funder === "" ? undefined : message.funder;
+        obj.amount = message.amount === "" ? undefined : message.amount;
+        obj.funded_at = message.fundedAt !== BigInt(0) ? message.fundedAt?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.InitiativeBountyContribution.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.InitiativeBountyContribution.decode(message.value);
+    },
+    toProto(message) {
+        return exports.InitiativeBountyContribution.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.InitiativeBountyContribution",
+            value: exports.InitiativeBountyContribution.encode(message).finish()
+        };
+    }
+};

package/sparkdream/rep/v1/member.d.ts

@@ -200,7 +200,11 @@ export interface Member {
     zeroedAt: bigint;
     zeroedCount: number;
     lastDecayEpoch: bigint;
-    tipsGivenThisEpoch: number;
+    /**
+     * DREAM tipped this epoch (amount, not count), reset lazily when
+     * last_tip_epoch falls behind. Nil on records written before it existed.
+     */
+    tipsSentThisEpoch: string;
     lastTipEpoch: bigint;
     /**
      * Cached counts for performance (avoid full table scans)
@@ -211,13 +215,14 @@ export interface Member {
      */
     completedInitiativesCount: number;
     /**
-     * Gift tracking for rate limiting
-     */
-    giftsSentThisEpoch: string;
-    /**
-     * Epoch when gift counter was last reset
+     * DREAM received through member-to-member transfers (tips and initiative
+     * bounty payouts) in the current epoch, bounded by
+     * max_transfer_received_per_epoch. The binding transfer limit sits on the
+     * recipient: a buyer can collect from any number of senders, so only a cap
+     * on what one account takes in bounds how fast a position can be bought.
      */
-    lastGiftEpoch: bigint;
+    transferReceivedThisEpoch: string;
+    lastTransferReceivedEpoch: bigint;
     /**
      * Invitation credit tracking for lazy seasonal reset
      */
@@ -300,6 +305,28 @@ export interface Member {
      * readers must treat nil as zero.
      */
     contentStakedDream: string;
+    /**
+     * Season-scale counterpart of transfer_received_this_epoch, bounded by
+     * max_transfer_received_per_season.
+     */
+    transferReceivedThisSeason: string;
+    lastTransferReceivedSeason: bigint;
+    /**
+     * DREAM this member escrowed into initiative bounties this epoch, bounded by
+     * max_initiative_bounty_per_funder_epoch.
+     */
+    initiativeBountyFundedThisEpoch: string;
+    lastInitiativeBountyEpoch: bigint;
+    /**
+     * The content license this member agreed to publish under
+     * (docs/content-license.md). Set from MsgAcceptInvitation's signed
+     * accepted_content_license, or for genesis members from the genesis file,
+     * where GenesisState.Validate requires it. Never changed afterwards: a CC0
+     * dedication cannot be revoked, so zeroing and status changes leave it
+     * alone. An address joins only once, so the agreement was made at
+     * joined_at / joined_at_height.
+     */
+    contentLicense: string;
 }
 export interface MemberProtoMsg {
     typeUrl: "/sparkdream.rep.v1.Member";
@@ -355,7 +382,11 @@ export interface MemberAmino {
     zeroed_at?: string;
     zeroed_count?: number;
     last_decay_epoch?: string;
-    tips_given_this_epoch?: number;
+    /**
+     * DREAM tipped this epoch (amount, not count), reset lazily when
+     * last_tip_epoch falls behind. Nil on records written before it existed.
+     */
+    tips_sent_this_epoch?: string;
     last_tip_epoch?: string;
     /**
      * Cached counts for performance (avoid full table scans)
@@ -366,13 +397,14 @@ export interface MemberAmino {
      */
     completed_initiatives_count?: number;
     /**
-     * Gift tracking for rate limiting
+     * DREAM received through member-to-member transfers (tips and initiative
+     * bounty payouts) in the current epoch, bounded by
+     * max_transfer_received_per_epoch. The binding transfer limit sits on the
+     * recipient: a buyer can collect from any number of senders, so only a cap
+     * on what one account takes in bounds how fast a position can be bought.
      */
-    gifts_sent_this_epoch?: string;
-    /**
-     * Epoch when gift counter was last reset
-     */
-    last_gift_epoch?: string;
+    transfer_received_this_epoch?: string;
+    last_transfer_received_epoch?: string;
     /**
      * Invitation credit tracking for lazy seasonal reset
      */
@@ -455,14 +487,38 @@ export interface MemberAmino {
      * readers must treat nil as zero.
      */
     content_staked_dream?: string;
+    /**
+     * Season-scale counterpart of transfer_received_this_epoch, bounded by
+     * max_transfer_received_per_season.
+     */
+    transfer_received_this_season?: string;
+    last_transfer_received_season?: string;
+    /**
+     * DREAM this member escrowed into initiative bounties this epoch, bounded by
+     * max_initiative_bounty_per_funder_epoch.
+     */
+    initiative_bounty_funded_this_epoch?: string;
+    last_initiative_bounty_epoch?: string;
+    /**
+     * The content license this member agreed to publish under
+     * (docs/content-license.md). Set from MsgAcceptInvitation's signed
+     * accepted_content_license, or for genesis members from the genesis file,
+     * where GenesisState.Validate requires it. Never changed afterwards: a CC0
+     * dedication cannot be revoked, so zeroing and status changes leave it
+     * alone. An address joins only once, so the agreement was made at
+     * joined_at / joined_at_height.
+     */
+    content_license?: string;
 }
 export interface MemberAminoMsg {
     type: "/sparkdream.rep.v1.Member";
     value: MemberAmino;
 }
 /**
- * GiftRecord tracks the last time a sender gifted a specific recipient
- * Used to enforce per-recipient cooldown periods
+ * GiftRecord is the lifetime ledger of what a sender has gifted one of their
+ * invitees, bounded by max_gift_per_invitee. A gift is a one-time seed to help
+ * an invitee get started, so the cap is per invitee for life rather than per
+ * epoch.
  * @name GiftRecord
  * @package sparkdream.rep.v1
  * @see proto type: sparkdream.rep.v1.GiftRecord
@@ -470,18 +526,17 @@ export interface MemberAminoMsg {
 export interface GiftRecord {
     sender: string;
     recipient: string;
-    /**
-     * Block height when last gift was sent
-     */
-    lastGiftBlock: bigint;
+    totalGifted: string;
 }
 export interface GiftRecordProtoMsg {
     typeUrl: "/sparkdream.rep.v1.GiftRecord";
     value: Uint8Array;
 }
 /**
- * GiftRecord tracks the last time a sender gifted a specific recipient
- * Used to enforce per-recipient cooldown periods
+ * GiftRecord is the lifetime ledger of what a sender has gifted one of their
+ * invitees, bounded by max_gift_per_invitee. A gift is a one-time seed to help
+ * an invitee get started, so the cap is per invitee for life rather than per
+ * epoch.
  * @name GiftRecordAmino
  * @package sparkdream.rep.v1
  * @see proto type: sparkdream.rep.v1.GiftRecord
@@ -489,10 +544,7 @@ export interface GiftRecordProtoMsg {
 export interface GiftRecordAmino {
     sender?: string;
     recipient?: string;
-    /**
-     * Block height when last gift was sent
-     */
-    last_gift_block?: string;
+    total_gifted?: string;
 }
 export interface GiftRecordAminoMsg {
     type: "/sparkdream.rep.v1.GiftRecord";
@@ -592,8 +644,10 @@ export declare const Member: {
     toProtoMsg(message: Member): MemberProtoMsg;
 };
 /**
- * GiftRecord tracks the last time a sender gifted a specific recipient
- * Used to enforce per-recipient cooldown periods
+ * GiftRecord is the lifetime ledger of what a sender has gifted one of their
+ * invitees, bounded by max_gift_per_invitee. A gift is a one-time seed to help
+ * an invitee get started, so the cap is per invitee for life rather than per
+ * epoch.
  * @name GiftRecord
  * @package sparkdream.rep.v1
  * @see proto type: sparkdream.rep.v1.GiftRecord