@sparkdreamnft/sparkdreamjs 0.0.44 → 0.0.46

package/sparkdream/artifact/v1/types.d.ts

@@ -15,13 +15,18 @@ export declare function contentStatusToJSON(object: ContentStatus): string;
 /**
  * TokenLock is the single lock a token can hold at a time. Every lock is
  * exclusive: a locked token cannot be transferred, listed, burned or take a
- * second lock. Future locks (rentals, nesting) are appended here; see
- * docs/x-artifact-spec.md §16.2.
+ * second lock (docs/x-artifact-spec.md §7.2, §16.2).
  */
 export declare enum TokenLock {
     TOKEN_LOCK_NONE = 0,
     TOKEN_LOCK_LISTED = 1,
     TOKEN_LOCK_PENDING_TRANSFER = 2,
+    /** TOKEN_LOCK_RENTED - A renter holds the token's user right until the rental ends. */
+    TOKEN_LOCK_RENTED = 3,
+    /** TOKEN_LOCK_NESTED - The token sits inside another token (Token.parent) and moves with it. */
+    TOKEN_LOCK_NESTED = 4,
+    /** TOKEN_LOCK_AUCTION - The token is up for an English auction (Auction). */
+    TOKEN_LOCK_AUCTION = 5,
     UNRECOGNIZED = -1
 }
 export declare const TokenLockAmino: typeof TokenLock;
@@ -53,6 +58,9 @@ export declare enum InboxKind {
     INBOX_KIND_UNSPECIFIED = 0,
     INBOX_KIND_TRANSFER = 1,
     INBOX_KIND_MINT = 2,
+    /** INBOX_KIND_UNIT_TRANSFER - Edition units (PendingUnits); inbox ref (0, pending_id). */
+    INBOX_KIND_UNIT_TRANSFER = 3,
+    INBOX_KIND_UNIT_MINT = 4,
     UNRECOGNIZED = -1
 }
 export declare const InboxKindAmino: typeof InboxKind;
@@ -63,6 +71,8 @@ export declare enum HideTargetKind {
     HIDE_TARGET_KIND_UNSPECIFIED = 0,
     HIDE_TARGET_KIND_CLASS = 1,
     HIDE_TARGET_KIND_TOKEN = 2,
+    /** HIDE_TARGET_KIND_EDITION - An edition of an EDITIONS class; token_id is the edition id. */
+    HIDE_TARGET_KIND_EDITION = 3,
     UNRECOGNIZED = -1
 }
 export declare const HideTargetKindAmino: typeof HideTargetKind;
@@ -101,11 +111,321 @@ export declare enum BurnAuthorization {
     BURN_AUTHORIZATION_ISSUER = 1,
     /** BURN_AUTHORIZATION_HOLDER_OR_ISSUER - Either the holder (MsgBurn) or the class owner (MsgRevoke), alone. */
     BURN_AUTHORIZATION_HOLDER_OR_ISSUER = 2,
+    /**
+     * BURN_AUTHORIZATION_NEITHER - Nobody: the token is permanent. Its deposit is burned as a fee, and it
+     * reaches nobody without their acceptance.
+     */
+    BURN_AUTHORIZATION_NEITHER = 3,
     UNRECOGNIZED = -1
 }
 export declare const BurnAuthorizationAmino: typeof BurnAuthorization;
 export declare function burnAuthorizationFromJSON(object: any): BurnAuthorization;
 export declare function burnAuthorizationToJSON(object: BurnAuthorization): string;
+/** ExpiryMode says what happens to a token whose expires_at has passed. */
+export declare enum ExpiryMode {
+    /** EXPIRY_MODE_NONE - Tokens never expire. The default. */
+    EXPIRY_MODE_NONE = 0,
+    /**
+     * EXPIRY_MODE_MARK - The token stays with its holder, marked expired: it cannot be redeemed,
+     * listed or bought until renewed, but may be held or given away.
+     */
+    EXPIRY_MODE_MARK = 1,
+    /** EXPIRY_MODE_BURN - The EndBlocker burns the token and refunds its deposit to the holder. */
+    EXPIRY_MODE_BURN = 2,
+    UNRECOGNIZED = -1
+}
+export declare const ExpiryModeAmino: typeof ExpiryMode;
+export declare function expiryModeFromJSON(object: any): ExpiryMode;
+export declare function expiryModeToJSON(object: ExpiryMode): string;
+/** MintPricing is how the public mint price is derived. */
+export declare enum MintPricing {
+    /** MINT_PRICING_FIXED - Every token costs mint_policy.price. */
+    MINT_PRICING_FIXED = 0,
+    /** MINT_PRICING_LINEAR_SUPPLY - The k-th public mint (0-based) costs price + k * price_step. */
+    MINT_PRICING_LINEAR_SUPPLY = 1,
+    /**
+     * MINT_PRICING_DUTCH - Dutch auction: price falls linearly from price at start_time to
+     * floor_price at end_time. Both times are required.
+     */
+    MINT_PRICING_DUTCH = 2,
+    UNRECOGNIZED = -1
+}
+export declare const MintPricingAmino: typeof MintPricing;
+export declare function mintPricingFromJSON(object: any): MintPricing;
+export declare function mintPricingToJSON(object: MintPricing): string;
+/** RevealKind is the commit-reveal scheme a class uses. */
+export declare enum RevealKind {
+    /** REVEAL_KIND_NONE - Metadata is set at mint. The default. */
+    REVEAL_KIND_NONE = 0,
+    /**
+     * REVEAL_KIND_BLIND_METADATA - Blind mint: every token's metadata is committed in a Merkle root at
+     * class creation and revealed per token (MsgReveal).
+     */
+    REVEAL_KIND_BLIND_METADATA = 1,
+    /**
+     * REVEAL_KIND_GENERATIVE_SEED - Generative: the class commits SHA-256(seed) at creation and reveals the
+     * seed once (MsgRevealSeed); each token's seed derives from it.
+     */
+    REVEAL_KIND_GENERATIVE_SEED = 2,
+    UNRECOGNIZED = -1
+}
+export declare const RevealKindAmino: typeof RevealKind;
+export declare function revealKindFromJSON(object: any): RevealKind;
+export declare function revealKindToJSON(object: RevealKind): string;
+/** TokenModel is how a class holds its tokens. Fixed at creation. */
+export declare enum TokenModel {
+    /** TOKEN_MODEL_UNIQUE - One owner per token id (Token). The default. */
+    TOKEN_MODEL_UNIQUE = 0,
+    /**
+     * TOKEN_MODEL_EDITIONS - Semi-fungible: the class issues editions, and each edition id is held
+     * as per-address balances of identical units (Edition, Balance).
+     */
+    TOKEN_MODEL_EDITIONS = 1,
+    UNRECOGNIZED = -1
+}
+export declare const TokenModelAmino: typeof TokenModel;
+export declare function tokenModelFromJSON(object: any): TokenModel;
+export declare function tokenModelToJSON(object: TokenModel): string;
+/**
+ * ExpiryPolicy is a class's token expiry rule, fixed at creation.
+ * @name ExpiryPolicy
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.ExpiryPolicy
+ */
+export interface ExpiryPolicy {
+    mode: ExpiryMode;
+    /**
+     * Seconds a token lives from mint (and per renewal). Required when mode
+     * is not NONE.
+     */
+    term: bigint;
+    /**
+     * What a holder pays the class per renewal; denom must be the bond denom.
+     * May be zero. Issuer renewals are free.
+     */
+    renewalPrice: Coin;
+}
+export interface ExpiryPolicyProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.ExpiryPolicy";
+    value: Uint8Array;
+}
+/**
+ * ExpiryPolicy is a class's token expiry rule, fixed at creation.
+ * @name ExpiryPolicyAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.ExpiryPolicy
+ */
+export interface ExpiryPolicyAmino {
+    mode?: ExpiryMode;
+    /**
+     * Seconds a token lives from mint (and per renewal). Required when mode
+     * is not NONE.
+     */
+    term?: string;
+    /**
+     * What a holder pays the class per renewal; denom must be the bond denom.
+     * May be zero. Issuer renewals are free.
+     */
+    renewal_price: CoinAmino;
+}
+export interface ExpiryPolicyAminoMsg {
+    type: "/sparkdream.artifact.v1.ExpiryPolicy";
+    value: ExpiryPolicyAmino;
+}
+/**
+ * RevealPolicy is a class's commit-reveal state.
+ * @name RevealPolicy
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.RevealPolicy
+ */
+export interface RevealPolicy {
+    kind: RevealKind;
+    /**
+     * Lowercase hex SHA-256: the Merkle root (BLIND_METADATA) or the seed
+     * hash (GENERATIVE_SEED). Fixed at creation.
+     */
+    commitment: string;
+    /**
+     * Unix seconds. After it, the holder of an unrevealed token may burn it
+     * for a full refund of the mint price and deposit. Fixed at creation.
+     */
+    deadline: bigint;
+    /**
+     * GENERATIVE_SEED only: block time of MsgRevealSeed, 0 until revealed.
+     */
+    revealedAt: bigint;
+    /**
+     * GENERATIVE_SEED only: the revealed seed (lowercase hex).
+     */
+    seed: string;
+}
+export interface RevealPolicyProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.RevealPolicy";
+    value: Uint8Array;
+}
+/**
+ * RevealPolicy is a class's commit-reveal state.
+ * @name RevealPolicyAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.RevealPolicy
+ */
+export interface RevealPolicyAmino {
+    kind?: RevealKind;
+    /**
+     * Lowercase hex SHA-256: the Merkle root (BLIND_METADATA) or the seed
+     * hash (GENERATIVE_SEED). Fixed at creation.
+     */
+    commitment?: string;
+    /**
+     * Unix seconds. After it, the holder of an unrevealed token may burn it
+     * for a full refund of the mint price and deposit. Fixed at creation.
+     */
+    deadline?: string;
+    /**
+     * GENERATIVE_SEED only: block time of MsgRevealSeed, 0 until revealed.
+     */
+    revealed_at?: string;
+    /**
+     * GENERATIVE_SEED only: the revealed seed (lowercase hex).
+     */
+    seed?: string;
+}
+export interface RevealPolicyAminoMsg {
+    type: "/sparkdream.artifact.v1.RevealPolicy";
+    value: RevealPolicyAmino;
+}
+/**
+ * Renderer names the pure Gno package x/gnovm evaluates at query time to
+ * produce a token's displayed metadata. Fixed at creation.
+ * @name Renderer
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Renderer
+ */
+export interface Renderer {
+    /**
+     * Pure package path (gno.land/p/...); "" = no renderer.
+     */
+    pkgPath: string;
+    /**
+     * Lowercase hex SHA-256 over the package's source files (see
+     * RendererSourceHash); must match the stored package.
+     */
+    sourceHash: string;
+    /**
+     * 0 = Render(classID, tokenID, seed, blockTime, height); 1 or 2 =
+     * RenderState with the token's state document of that version as a
+     * sixth argument (v2 adds x/season state and the nested contents).
+     */
+    stateVersion: number;
+}
+export interface RendererProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.Renderer";
+    value: Uint8Array;
+}
+/**
+ * Renderer names the pure Gno package x/gnovm evaluates at query time to
+ * produce a token's displayed metadata. Fixed at creation.
+ * @name RendererAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Renderer
+ */
+export interface RendererAmino {
+    /**
+     * Pure package path (gno.land/p/...); "" = no renderer.
+     */
+    pkg_path?: string;
+    /**
+     * Lowercase hex SHA-256 over the package's source files (see
+     * RendererSourceHash); must match the stored package.
+     */
+    source_hash?: string;
+    /**
+     * 0 = Render(classID, tokenID, seed, blockTime, height); 1 or 2 =
+     * RenderState with the token's state document of that version as a
+     * sixth argument (v2 adds x/season state and the nested contents).
+     */
+    state_version?: number;
+}
+export interface RendererAminoMsg {
+    type: "/sparkdream.artifact.v1.Renderer";
+    value: RendererAmino;
+}
+/**
+ * MetadataStage is one step of a token's metadata schedule.
+ * @name MetadataStage
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.MetadataStage
+ */
+export interface MetadataStage {
+    /**
+     * Unix seconds from which this stage is displayed.
+     */
+    fromTime: bigint;
+    metadata: TokenMetadata;
+}
+export interface MetadataStageProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.MetadataStage";
+    value: Uint8Array;
+}
+/**
+ * MetadataStage is one step of a token's metadata schedule.
+ * @name MetadataStageAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.MetadataStage
+ */
+export interface MetadataStageAmino {
+    /**
+     * Unix seconds from which this stage is displayed.
+     */
+    from_time?: string;
+    metadata: TokenMetadataAmino;
+}
+export interface MetadataStageAminoMsg {
+    type: "/sparkdream.artifact.v1.MetadataStage";
+    value: MetadataStageAmino;
+}
+/**
+ * MediaProposal is a media version the class owner offered a token's holder.
+ * @name MediaProposal
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.MediaProposal
+ */
+export interface MediaProposal {
+    classId: bigint;
+    tokenId: bigint;
+    /**
+     * Per token, from Token.next_media_proposal_id.
+     */
+    id: bigint;
+    proposer: string;
+    metadata: TokenMetadata;
+    createdAt: bigint;
+}
+export interface MediaProposalProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.MediaProposal";
+    value: Uint8Array;
+}
+/**
+ * MediaProposal is a media version the class owner offered a token's holder.
+ * @name MediaProposalAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.MediaProposal
+ */
+export interface MediaProposalAmino {
+    class_id?: string;
+    token_id?: string;
+    /**
+     * Per token, from Token.next_media_proposal_id.
+     */
+    id?: string;
+    proposer?: string;
+    metadata: TokenMetadataAmino;
+    created_at?: string;
+}
+export interface MediaProposalAminoMsg {
+    type: "/sparkdream.artifact.v1.MediaProposal";
+    value: MediaProposalAmino;
+}
 /**
  * ClassFlags are fixed at class creation and never change.
  * @name ClassFlags
@@ -126,6 +446,23 @@ export interface ClassFlags {
      * true = the class owner may edit token metadata until frozen.
      */
     tokenMetadataMutable: boolean;
+    /**
+     * true = mutual attestation: every mint waits for the recipient's
+     * acceptance and either party may burn. Requires
+     * burn_authorization == HOLDER_OR_ISSUER (hence non-transferable) and a
+     * recipient other than the minter.
+     */
+    mutual: boolean;
+    /**
+     * true = the class owner or a listed minter may redeem tokens (MsgRedeem).
+     */
+    redeemable: boolean;
+    /**
+     * true = redeemed tokens stay transferable as souvenirs; false = a
+     * redeemed token can no longer be transferred or listed. Requires
+     * redeemable and transferable.
+     */
+    redeemedTransferable: boolean;
 }
 export interface ClassFlagsProtoMsg {
     typeUrl: "/sparkdream.artifact.v1.ClassFlags";
@@ -151,6 +488,23 @@ export interface ClassFlagsAmino {
      * true = the class owner may edit token metadata until frozen.
      */
     token_metadata_mutable?: boolean;
+    /**
+     * true = mutual attestation: every mint waits for the recipient's
+     * acceptance and either party may burn. Requires
+     * burn_authorization == HOLDER_OR_ISSUER (hence non-transferable) and a
+     * recipient other than the minter.
+     */
+    mutual?: boolean;
+    /**
+     * true = the class owner or a listed minter may redeem tokens (MsgRedeem).
+     */
+    redeemable?: boolean;
+    /**
+     * true = redeemed tokens stay transferable as souvenirs; false = a
+     * redeemed token can no longer be transferred or listed. Requires
+     * redeemable and transferable.
+     */
+    redeemed_transferable?: boolean;
 }
 export interface ClassFlagsAminoMsg {
     type: "/sparkdream.artifact.v1.ClassFlags";
@@ -180,6 +534,18 @@ export interface MintPolicy {
      * 0 = unlimited; counted per (class, address) over the class's life.
      */
     perAddressLimit: number;
+    /**
+     * Price curve. Fixed once public minting has opened.
+     */
+    pricing: MintPricing;
+    /**
+     * LINEAR_SUPPLY: bond-denom amount added per public mint so far.
+     */
+    priceStep: string;
+    /**
+     * DUTCH: bond-denom amount the price falls to at end_time (<= price).
+     */
+    floorPrice: string;
 }
 export interface MintPolicyProtoMsg {
     typeUrl: "/sparkdream.artifact.v1.MintPolicy";
@@ -209,6 +575,18 @@ export interface MintPolicyAmino {
      * 0 = unlimited; counted per (class, address) over the class's life.
      */
     per_address_limit?: number;
+    /**
+     * Price curve. Fixed once public minting has opened.
+     */
+    pricing?: MintPricing;
+    /**
+     * LINEAR_SUPPLY: bond-denom amount added per public mint so far.
+     */
+    price_step?: string;
+    /**
+     * DUTCH: bond-denom amount the price falls to at end_time (<= price).
+     */
+    floor_price?: string;
 }
 export interface MintPolicyAminoMsg {
     type: "/sparkdream.artifact.v1.MintPolicy";
@@ -254,6 +632,43 @@ export interface Class {
     mediaRulesVersion: number;
     createdAt: bigint;
     updatedAt: bigint;
+    /**
+     * Fixed at creation.
+     */
+    expiry: ExpiryPolicy;
+    /**
+     * Kind, commitment and deadline fixed at creation; seed set by reveal.
+     */
+    reveal: RevealPolicy;
+    /**
+     * Fixed at creation.
+     */
+    renderer: Renderer;
+    /**
+     * One-way: false -> true. Freezes royalty_bps and royalty_recipients.
+     */
+    royaltyLocked: boolean;
+    /**
+     * Tokens sold through MsgPublicMint so far; drives LINEAR_SUPPLY pricing.
+     */
+    publicMinted: bigint;
+    /**
+     * Fixed at creation.
+     */
+    tokenModel: TokenModel;
+    /**
+     * Fixed at creation; tax_bps_per_year 0 = plain class.
+     */
+    harberger: HarbergerPolicy;
+    /**
+     * Set by the first craft into the class: recipes can then only be
+     * removed.
+     */
+    craftingLocked: boolean;
+    /**
+     * Last assigned recipe id.
+     */
+    nextRecipeId: bigint;
 }
 export interface ClassProtoMsg {
     typeUrl: "/sparkdream.artifact.v1.Class";
@@ -299,6 +714,43 @@ export interface ClassAmino {
     media_rules_version?: number;
     created_at?: string;
     updated_at?: string;
+    /**
+     * Fixed at creation.
+     */
+    expiry: ExpiryPolicyAmino;
+    /**
+     * Kind, commitment and deadline fixed at creation; seed set by reveal.
+     */
+    reveal: RevealPolicyAmino;
+    /**
+     * Fixed at creation.
+     */
+    renderer: RendererAmino;
+    /**
+     * One-way: false -> true. Freezes royalty_bps and royalty_recipients.
+     */
+    royalty_locked?: boolean;
+    /**
+     * Tokens sold through MsgPublicMint so far; drives LINEAR_SUPPLY pricing.
+     */
+    public_minted?: string;
+    /**
+     * Fixed at creation.
+     */
+    token_model?: TokenModel;
+    /**
+     * Fixed at creation; tax_bps_per_year 0 = plain class.
+     */
+    harberger: HarbergerPolicyAmino;
+    /**
+     * Set by the first craft into the class: recipes can then only be
+     * removed.
+     */
+    crafting_locked?: boolean;
+    /**
+     * Last assigned recipe id.
+     */
+    next_recipe_id?: string;
 }
 export interface ClassAminoMsg {
     type: "/sparkdream.artifact.v1.Class";
@@ -426,6 +878,50 @@ export interface Token {
     mediaFlags: number;
     mediaRulesVersion: number;
     mintedAt: bigint;
+    /**
+     * Unix seconds; 0 = never expires.
+     */
+    expiresAt: bigint;
+    /**
+     * Unix seconds of MsgRedeem; 0 = not redeemed.
+     */
+    redeemedAt: bigint;
+    /**
+     * Metadata schedule fixed at mint; metadata is the stage before the
+     * first from_time.
+     */
+    schedule: MetadataStage[];
+    /**
+     * Media versions the holder accepted, in acceptance order.
+     */
+    mediaVersions: TokenMetadata[];
+    /**
+     * 0 = metadata (or schedule); n = media_versions[n-1].
+     */
+    displayedVersion: number;
+    /**
+     * true until a BLIND_METADATA class reveals this token.
+     */
+    unrevealed: boolean;
+    /**
+     * Public-mint price held in the module account until the class or token
+     * is revealed; refunded with the deposit if the holder burns an
+     * unrevealed token after the reveal deadline. 0 otherwise.
+     */
+    paid: string;
+    nextMediaProposalId: bigint;
+    /**
+     * Harberger classes only: the self-assessment and tax status.
+     */
+    harberger?: HarbergerState;
+    /**
+     * Set while nested (lock = NESTED): the token this one sits in.
+     */
+    parent?: TokenRef;
+    /**
+     * Tokens nested under this one, at any depth.
+     */
+    descendants: number;
 }
 export interface TokenProtoMsg {
     typeUrl: "/sparkdream.artifact.v1.Token";
@@ -457,6 +953,50 @@ export interface TokenAmino {
     media_flags?: number;
     media_rules_version?: number;
     minted_at?: string;
+    /**
+     * Unix seconds; 0 = never expires.
+     */
+    expires_at?: string;
+    /**
+     * Unix seconds of MsgRedeem; 0 = not redeemed.
+     */
+    redeemed_at?: string;
+    /**
+     * Metadata schedule fixed at mint; metadata is the stage before the
+     * first from_time.
+     */
+    schedule?: MetadataStageAmino[];
+    /**
+     * Media versions the holder accepted, in acceptance order.
+     */
+    media_versions?: TokenMetadataAmino[];
+    /**
+     * 0 = metadata (or schedule); n = media_versions[n-1].
+     */
+    displayed_version?: number;
+    /**
+     * true until a BLIND_METADATA class reveals this token.
+     */
+    unrevealed?: boolean;
+    /**
+     * Public-mint price held in the module account until the class or token
+     * is revealed; refunded with the deposit if the holder burns an
+     * unrevealed token after the reveal deadline. 0 otherwise.
+     */
+    paid?: string;
+    next_media_proposal_id?: string;
+    /**
+     * Harberger classes only: the self-assessment and tax status.
+     */
+    harberger?: HarbergerStateAmino;
+    /**
+     * Set while nested (lock = NESTED): the token this one sits in.
+     */
+    parent?: TokenRefAmino;
+    /**
+     * Tokens nested under this one, at any depth.
+     */
+    descendants?: number;
 }
 export interface TokenAminoMsg {
     type: "/sparkdream.artifact.v1.Token";
@@ -542,6 +1082,8 @@ export interface PendingMint {
     deposit: string;
     createdAt: bigint;
     expiresAt: bigint;
+    schedule: MetadataStage[];
+    unrevealed: boolean;
 }
 export interface PendingMintProtoMsg {
     typeUrl: "/sparkdream.artifact.v1.PendingMint";
@@ -563,6 +1105,8 @@ export interface PendingMintAmino {
     deposit?: string;
     created_at?: string;
     expires_at?: string;
+    schedule?: MetadataStageAmino[];
+    unrevealed?: boolean;
 }
 export interface PendingMintAminoMsg {
     type: "/sparkdream.artifact.v1.PendingMint";
@@ -849,31 +1393,988 @@ export interface SentinelDailyHideEntryAminoMsg {
     value: SentinelDailyHideEntryAmino;
 }
 /**
- * ClassFlags are fixed at class creation and never change.
- * @name ClassFlags
- * @package sparkdream.artifact.v1
- * @see proto type: sparkdream.artifact.v1.ClassFlags
- */
-export declare const ClassFlags: {
-    typeUrl: string;
-    encode(message: ClassFlags, writer?: BinaryWriter): BinaryWriter;
-    decode(input: BinaryReader | Uint8Array, length?: number): ClassFlags;
-    fromPartial(object: DeepPartial<ClassFlags>): ClassFlags;
-    fromAmino(object: ClassFlagsAmino): ClassFlags;
-    toAmino(message: ClassFlags): ClassFlagsAmino;
-    fromAminoMsg(object: ClassFlagsAminoMsg): ClassFlags;
-    fromProtoMsg(message: ClassFlagsProtoMsg): ClassFlags;
-    toProto(message: ClassFlags): Uint8Array;
-    toProtoMsg(message: ClassFlags): ClassFlagsProtoMsg;
-};
-/**
- * MintPolicy configures public minting (MsgPublicMint).
- * @name MintPolicy
+ * HarbergerPolicy makes a class's tokens partially commonly owned: each
+ * holder self-assesses a price, anyone may buy the token at that price at
+ * any time, and the holder pays a yearly tax on it to the community pool
+ * through an x/session RecurringPull. Fixed at creation; tax_bps_per_year 0
+ * means a plain class.
+ * @name HarbergerPolicy
  * @package sparkdream.artifact.v1
- * @see proto type: sparkdream.artifact.v1.MintPolicy
+ * @see proto type: sparkdream.artifact.v1.HarbergerPolicy
  */
-export declare const MintPolicy: {
-    typeUrl: string;
+export interface HarbergerPolicy {
+    /**
+     * Yearly tax on the assessed price, in basis points.
+     */
+    taxBpsPerYear: number;
+    /**
+     * Seconds between tax pulls; the RecurringPull period must equal it.
+     */
+    taxPeriod: bigint;
+    /**
+     * Seconds over which the price falls linearly to zero after a missed
+     * payment (foreclosure).
+     */
+    foreclosureDuration: bigint;
+}
+export interface HarbergerPolicyProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.HarbergerPolicy";
+    value: Uint8Array;
+}
+/**
+ * HarbergerPolicy makes a class's tokens partially commonly owned: each
+ * holder self-assesses a price, anyone may buy the token at that price at
+ * any time, and the holder pays a yearly tax on it to the community pool
+ * through an x/session RecurringPull. Fixed at creation; tax_bps_per_year 0
+ * means a plain class.
+ * @name HarbergerPolicyAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.HarbergerPolicy
+ */
+export interface HarbergerPolicyAmino {
+    /**
+     * Yearly tax on the assessed price, in basis points.
+     */
+    tax_bps_per_year?: number;
+    /**
+     * Seconds between tax pulls; the RecurringPull period must equal it.
+     */
+    tax_period?: string;
+    /**
+     * Seconds over which the price falls linearly to zero after a missed
+     * payment (foreclosure).
+     */
+    foreclosure_duration?: string;
+}
+export interface HarbergerPolicyAminoMsg {
+    type: "/sparkdream.artifact.v1.HarbergerPolicy";
+    value: HarbergerPolicyAmino;
+}
+/**
+ * HarbergerState is a Harberger token's self-assessment and tax status.
+ * @name HarbergerState
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.HarbergerState
+ */
+export interface HarbergerState {
+    /**
+     * The self-assessed price buyers pay (bond denom).
+     */
+    price: string;
+    /**
+     * The x/session RecurringPull that pays the tax; 0 = none.
+     */
+    grantId: bigint;
+    /**
+     * Unix seconds of the next tax pull; 0 when no grant is set.
+     */
+    nextDue: bigint;
+    /**
+     * Unix seconds until which a holder without a grant is not foreclosed
+     * (one tax period after the token arrived).
+     */
+    graceUntil: bigint;
+    /**
+     * Unix seconds from which the price falls; 0 = not foreclosed.
+     */
+    foreclosedAt: bigint;
+    /**
+     * Tax paid by the current holder so far.
+     */
+    taxPaid: string;
+}
+export interface HarbergerStateProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.HarbergerState";
+    value: Uint8Array;
+}
+/**
+ * HarbergerState is a Harberger token's self-assessment and tax status.
+ * @name HarbergerStateAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.HarbergerState
+ */
+export interface HarbergerStateAmino {
+    /**
+     * The self-assessed price buyers pay (bond denom).
+     */
+    price?: string;
+    /**
+     * The x/session RecurringPull that pays the tax; 0 = none.
+     */
+    grant_id?: string;
+    /**
+     * Unix seconds of the next tax pull; 0 when no grant is set.
+     */
+    next_due?: string;
+    /**
+     * Unix seconds until which a holder without a grant is not foreclosed
+     * (one tax period after the token arrived).
+     */
+    grace_until?: string;
+    /**
+     * Unix seconds from which the price falls; 0 = not foreclosed.
+     */
+    foreclosed_at?: string;
+    /**
+     * Tax paid by the current holder so far.
+     */
+    tax_paid?: string;
+}
+export interface HarbergerStateAminoMsg {
+    type: "/sparkdream.artifact.v1.HarbergerState";
+    value: HarbergerStateAmino;
+}
+/**
+ * Rental is an active time-limited user right on one token. The token is
+ * RENTED-locked: it cannot move, be listed, burned or nested until the
+ * rental ends.
+ * @name Rental
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Rental
+ */
+export interface Rental {
+    classId: bigint;
+    tokenId: bigint;
+    owner: string;
+    /**
+     * The renter.
+     */
+    user: string;
+    startedAt: bigint;
+    expiresAt: bigint;
+    /**
+     * Whether the owner may end the rental before expires_at.
+     */
+    ownerMayEnd: boolean;
+    price: Coin;
+}
+export interface RentalProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.Rental";
+    value: Uint8Array;
+}
+/**
+ * Rental is an active time-limited user right on one token. The token is
+ * RENTED-locked: it cannot move, be listed, burned or nested until the
+ * rental ends.
+ * @name RentalAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Rental
+ */
+export interface RentalAmino {
+    class_id?: string;
+    token_id?: string;
+    owner?: string;
+    /**
+     * The renter.
+     */
+    user?: string;
+    started_at?: string;
+    expires_at?: string;
+    /**
+     * Whether the owner may end the rental before expires_at.
+     */
+    owner_may_end?: boolean;
+    price: CoinAmino;
+}
+export interface RentalAminoMsg {
+    type: "/sparkdream.artifact.v1.Rental";
+    value: RentalAmino;
+}
+/**
+ * RentalOffer is an owner's standing offer to rent a token out. Nothing is
+ * locked or escrowed; MsgAcceptRental settles it atomically.
+ * @name RentalOffer
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.RentalOffer
+ */
+export interface RentalOffer {
+    classId: bigint;
+    tokenId: bigint;
+    owner: string;
+    /**
+     * Who may accept; "" = anyone.
+     */
+    user: string;
+    /**
+     * Paid by the renter at acceptance; may be zero.
+     */
+    price: Coin;
+    /**
+     * Seconds the rental lasts from acceptance.
+     */
+    duration: bigint;
+    ownerMayEnd: boolean;
+    createdAt: bigint;
+    expiresAt: bigint;
+    /**
+     * Equals Token.listing_seq when the offer was made; MsgAcceptRental must
+     * match it.
+     */
+    nonce: bigint;
+}
+export interface RentalOfferProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.RentalOffer";
+    value: Uint8Array;
+}
+/**
+ * RentalOffer is an owner's standing offer to rent a token out. Nothing is
+ * locked or escrowed; MsgAcceptRental settles it atomically.
+ * @name RentalOfferAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.RentalOffer
+ */
+export interface RentalOfferAmino {
+    class_id?: string;
+    token_id?: string;
+    owner?: string;
+    /**
+     * Who may accept; "" = anyone.
+     */
+    user?: string;
+    /**
+     * Paid by the renter at acceptance; may be zero.
+     */
+    price: CoinAmino;
+    /**
+     * Seconds the rental lasts from acceptance.
+     */
+    duration?: string;
+    owner_may_end?: boolean;
+    created_at?: string;
+    expires_at?: string;
+    /**
+     * Equals Token.listing_seq when the offer was made; MsgAcceptRental must
+     * match it.
+     */
+    nonce?: string;
+}
+export interface RentalOfferAminoMsg {
+    type: "/sparkdream.artifact.v1.RentalOffer";
+    value: RentalOfferAmino;
+}
+/**
+ * ImpactClaim describes a piece of work an edition certifies (an impact
+ * certificate). Holders of the edition's units share whatever retroactive
+ * funders pay to it (MsgFundEdition); DREAM never touches a certificate.
+ * @name ImpactClaim
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.ImpactClaim
+ */
+export interface ImpactClaim {
+    /**
+     * What was done.
+     */
+    scope: string;
+    /**
+     * Who did it; at most MaxImpactContributors addresses.
+     */
+    contributors: string[];
+    /**
+     * Unix seconds; 0 = unset. work_start <= work_end when both are set.
+     */
+    workStart: bigint;
+    workEnd: bigint;
+    /**
+     * A completed x/rep initiative this certificate is for; 0 = none. The
+     * initiative's assignee issues it, at most once per initiative.
+     */
+    initiativeId: bigint;
+}
+export interface ImpactClaimProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.ImpactClaim";
+    value: Uint8Array;
+}
+/**
+ * ImpactClaim describes a piece of work an edition certifies (an impact
+ * certificate). Holders of the edition's units share whatever retroactive
+ * funders pay to it (MsgFundEdition); DREAM never touches a certificate.
+ * @name ImpactClaimAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.ImpactClaim
+ */
+export interface ImpactClaimAmino {
+    /**
+     * What was done.
+     */
+    scope?: string;
+    /**
+     * Who did it; at most MaxImpactContributors addresses.
+     */
+    contributors?: string[];
+    /**
+     * Unix seconds; 0 = unset. work_start <= work_end when both are set.
+     */
+    work_start?: string;
+    work_end?: string;
+    /**
+     * A completed x/rep initiative this certificate is for; 0 = none. The
+     * initiative's assignee issues it, at most once per initiative.
+     */
+    initiative_id?: string;
+}
+export interface ImpactClaimAminoMsg {
+    type: "/sparkdream.artifact.v1.ImpactClaim";
+    value: ImpactClaimAmino;
+}
+/**
+ * Edition is one semi-fungible token id of an EDITIONS class: identical
+ * units held as per-address balances.
+ * @name Edition
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Edition
+ */
+export interface Edition {
+    classId: bigint;
+    /**
+     * From Class.next_token_id (editions and tokens share the id space).
+     */
+    id: bigint;
+    creator: string;
+    metadata: TokenMetadata;
+    metadataFrozen: boolean;
+    /**
+     * 0 = unlimited. Counts units ever issued (supply + burned + reserved);
+     * may only be lowered.
+     */
+    maxSupply: bigint;
+    /**
+     * Units in balances (free or locked in listings and pending transfers).
+     */
+    supply: bigint;
+    burned: bigint;
+    /**
+     * Units in pending mints.
+     */
+    reserved: bigint;
+    status: ContentStatus;
+    mediaFlags: number;
+    mediaRulesVersion: number;
+    createdAt: bigint;
+    claim: ImpactClaim;
+    /**
+     * Retro-funding accumulator: SPARK per unit, scaled by RewardScale.
+     */
+    rewardPerUnit: string;
+    /**
+     * Lifetime SPARK paid to the edition's holders by retro funders.
+     */
+    rewardsFunded: string;
+    /**
+     * Addresses holding a balance record.
+     */
+    holders: bigint;
+}
+export interface EditionProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.Edition";
+    value: Uint8Array;
+}
+/**
+ * Edition is one semi-fungible token id of an EDITIONS class: identical
+ * units held as per-address balances.
+ * @name EditionAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Edition
+ */
+export interface EditionAmino {
+    class_id?: string;
+    /**
+     * From Class.next_token_id (editions and tokens share the id space).
+     */
+    id?: string;
+    creator?: string;
+    metadata: TokenMetadataAmino;
+    metadata_frozen?: boolean;
+    /**
+     * 0 = unlimited. Counts units ever issued (supply + burned + reserved);
+     * may only be lowered.
+     */
+    max_supply?: string;
+    /**
+     * Units in balances (free or locked in listings and pending transfers).
+     */
+    supply?: string;
+    burned?: string;
+    /**
+     * Units in pending mints.
+     */
+    reserved?: string;
+    status?: ContentStatus;
+    media_flags?: number;
+    media_rules_version?: number;
+    created_at?: string;
+    claim: ImpactClaimAmino;
+    /**
+     * Retro-funding accumulator: SPARK per unit, scaled by RewardScale.
+     */
+    reward_per_unit?: string;
+    /**
+     * Lifetime SPARK paid to the edition's holders by retro funders.
+     */
+    rewards_funded?: string;
+    /**
+     * Addresses holding a balance record.
+     */
+    holders?: string;
+}
+export interface EditionAminoMsg {
+    type: "/sparkdream.artifact.v1.Edition";
+    value: EditionAmino;
+}
+/**
+ * Balance is one address's units of one edition.
+ * @name Balance
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Balance
+ */
+export interface Balance {
+    classId: bigint;
+    editionId: bigint;
+    owner: string;
+    /**
+     * Units free to move.
+     */
+    amount: bigint;
+    /**
+     * Units locked in listings and pending transfers.
+     */
+    locked: bigint;
+    /**
+     * Storage deposit for this record, refunded to the holder who empties it.
+     */
+    deposit: string;
+    /**
+     * Edition.reward_per_unit when the record was last settled.
+     */
+    rewardDebt: string;
+    /**
+     * Settled retro-funding rewards not yet claimed (bond denom).
+     */
+    unclaimed: string;
+}
+export interface BalanceProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.Balance";
+    value: Uint8Array;
+}
+/**
+ * Balance is one address's units of one edition.
+ * @name BalanceAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Balance
+ */
+export interface BalanceAmino {
+    class_id?: string;
+    edition_id?: string;
+    owner?: string;
+    /**
+     * Units free to move.
+     */
+    amount?: string;
+    /**
+     * Units locked in listings and pending transfers.
+     */
+    locked?: string;
+    /**
+     * Storage deposit for this record, refunded to the holder who empties it.
+     */
+    deposit?: string;
+    /**
+     * Edition.reward_per_unit when the record was last settled.
+     */
+    reward_debt?: string;
+    /**
+     * Settled retro-funding rewards not yet claimed (bond denom).
+     */
+    unclaimed?: string;
+}
+export interface BalanceAminoMsg {
+    type: "/sparkdream.artifact.v1.Balance";
+    value: BalanceAmino;
+}
+/**
+ * EditionRef addresses one edition.
+ * @name EditionRef
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.EditionRef
+ */
+export interface EditionRef {
+    classId: bigint;
+    editionId: bigint;
+}
+export interface EditionRefProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.EditionRef";
+    value: Uint8Array;
+}
+/**
+ * EditionRef addresses one edition.
+ * @name EditionRefAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.EditionRef
+ */
+export interface EditionRefAmino {
+    class_id?: string;
+    edition_id?: string;
+}
+export interface EditionRefAminoMsg {
+    type: "/sparkdream.artifact.v1.EditionRef";
+    value: EditionRefAmino;
+}
+/**
+ * PendingUnits is a unit transfer or mint awaiting the recipient. Its inbox
+ * ref is (class_id 0, token_id = id): class 0 is never a real class.
+ * @name PendingUnits
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.PendingUnits
+ */
+export interface PendingUnits {
+    id: bigint;
+    /**
+     * INBOX_KIND_UNIT_TRANSFER or INBOX_KIND_UNIT_MINT.
+     */
+    kind: InboxKind;
+    classId: bigint;
+    editionId: bigint;
+    /**
+     * Transfer sender, or minter.
+     */
+    from: string;
+    to: string;
+    amount: bigint;
+    /**
+     * Record deposit escrowed for the recipient; refunded to from if the
+     * recipient already holds a record at acceptance, or on rejection.
+     */
+    deposit: string;
+    createdAt: bigint;
+    expiresAt: bigint;
+}
+export interface PendingUnitsProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.PendingUnits";
+    value: Uint8Array;
+}
+/**
+ * PendingUnits is a unit transfer or mint awaiting the recipient. Its inbox
+ * ref is (class_id 0, token_id = id): class 0 is never a real class.
+ * @name PendingUnitsAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.PendingUnits
+ */
+export interface PendingUnitsAmino {
+    id?: string;
+    /**
+     * INBOX_KIND_UNIT_TRANSFER or INBOX_KIND_UNIT_MINT.
+     */
+    kind?: InboxKind;
+    class_id?: string;
+    edition_id?: string;
+    /**
+     * Transfer sender, or minter.
+     */
+    from?: string;
+    to?: string;
+    amount?: string;
+    /**
+     * Record deposit escrowed for the recipient; refunded to from if the
+     * recipient already holds a record at acceptance, or on rejection.
+     */
+    deposit?: string;
+    created_at?: string;
+    expires_at?: string;
+}
+export interface PendingUnitsAminoMsg {
+    type: "/sparkdream.artifact.v1.PendingUnits";
+    value: PendingUnitsAmino;
+}
+/**
+ * UnitListing offers units of an edition at a fixed per-unit price. The
+ * listed units are locked in the seller's balance; buyers may take part.
+ * @name UnitListing
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.UnitListing
+ */
+export interface UnitListing {
+    id: bigint;
+    classId: bigint;
+    editionId: bigint;
+    seller: string;
+    /**
+     * Units still for sale.
+     */
+    quantity: bigint;
+    unitPrice: Coin;
+    createdAt: bigint;
+    expiresAt: bigint;
+}
+export interface UnitListingProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.UnitListing";
+    value: Uint8Array;
+}
+/**
+ * UnitListing offers units of an edition at a fixed per-unit price. The
+ * listed units are locked in the seller's balance; buyers may take part.
+ * @name UnitListingAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.UnitListing
+ */
+export interface UnitListingAmino {
+    id?: string;
+    class_id?: string;
+    edition_id?: string;
+    seller?: string;
+    /**
+     * Units still for sale.
+     */
+    quantity?: string;
+    unit_price: CoinAmino;
+    created_at?: string;
+    expires_at?: string;
+}
+export interface UnitListingAminoMsg {
+    type: "/sparkdream.artifact.v1.UnitListing";
+    value: UnitListingAmino;
+}
+/**
+ * CraftInput is one ingredient of a recipe: quantity tokens of a UNIQUE
+ * class (edition_id 0), or quantity units of an edition.
+ * @name CraftInput
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.CraftInput
+ */
+export interface CraftInput {
+    classId: bigint;
+    editionId: bigint;
+    quantity: bigint;
+}
+export interface CraftInputProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.CraftInput";
+    value: Uint8Array;
+}
+/**
+ * CraftInput is one ingredient of a recipe: quantity tokens of a UNIQUE
+ * class (edition_id 0), or quantity units of an edition.
+ * @name CraftInputAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.CraftInput
+ */
+export interface CraftInputAmino {
+    class_id?: string;
+    edition_id?: string;
+    quantity?: string;
+}
+export interface CraftInputAminoMsg {
+    type: "/sparkdream.artifact.v1.CraftInput";
+    value: CraftInputAmino;
+}
+/**
+ * CraftRecipe burns its inputs to mint into the class it belongs to.
+ * Recipes can be removed at any time but none can be added after the
+ * class's first craft.
+ * @name CraftRecipe
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.CraftRecipe
+ */
+export interface CraftRecipe {
+    classId: bigint;
+    id: bigint;
+    inputs: CraftInput[];
+    /**
+     * UNIQUE target: the crafted token's metadata.
+     */
+    outputMetadata: TokenMetadata;
+    /**
+     * EDITIONS target: the edition and units crafted.
+     */
+    outputEditionId: bigint;
+    outputQuantity: bigint;
+    /**
+     * Times crafted.
+     */
+    crafts: bigint;
+}
+export interface CraftRecipeProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.CraftRecipe";
+    value: Uint8Array;
+}
+/**
+ * CraftRecipe burns its inputs to mint into the class it belongs to.
+ * Recipes can be removed at any time but none can be added after the
+ * class's first craft.
+ * @name CraftRecipeAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.CraftRecipe
+ */
+export interface CraftRecipeAmino {
+    class_id?: string;
+    id?: string;
+    inputs?: CraftInputAmino[];
+    /**
+     * UNIQUE target: the crafted token's metadata.
+     */
+    output_metadata: TokenMetadataAmino;
+    /**
+     * EDITIONS target: the edition and units crafted.
+     */
+    output_edition_id?: string;
+    output_quantity?: string;
+    /**
+     * Times crafted.
+     */
+    crafts?: string;
+}
+export interface CraftRecipeAminoMsg {
+    type: "/sparkdream.artifact.v1.CraftRecipe";
+    value: CraftRecipeAmino;
+}
+/**
+ * Offer is an escrowed SPARK bid to buy a token (token_id set) or any
+ * token of a class (token_id 0, a collection offer). The price waits in the
+ * module account until the offer is accepted, cancelled or expires.
+ * @name Offer
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Offer
+ */
+export interface Offer {
+    id: bigint;
+    bidder: string;
+    classId: bigint;
+    /**
+     * 0 = any token of the class.
+     */
+    tokenId: bigint;
+    price: Coin;
+    createdAt: bigint;
+    expiresAt: bigint;
+    /**
+     * Token offers only, optional: the stored metadata the bidder saw.
+     */
+    expectedMetadataHash: string;
+    /**
+     * Token offers only: the contents hash of a token holding nested
+     * tokens. A collection offer never buys a token holding anything.
+     */
+    expectedContentsHash: string;
+}
+export interface OfferProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.Offer";
+    value: Uint8Array;
+}
+/**
+ * Offer is an escrowed SPARK bid to buy a token (token_id set) or any
+ * token of a class (token_id 0, a collection offer). The price waits in the
+ * module account until the offer is accepted, cancelled or expires.
+ * @name OfferAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Offer
+ */
+export interface OfferAmino {
+    id?: string;
+    bidder?: string;
+    class_id?: string;
+    /**
+     * 0 = any token of the class.
+     */
+    token_id?: string;
+    price: CoinAmino;
+    created_at?: string;
+    expires_at?: string;
+    /**
+     * Token offers only, optional: the stored metadata the bidder saw.
+     */
+    expected_metadata_hash?: string;
+    /**
+     * Token offers only: the contents hash of a token holding nested
+     * tokens. A collection offer never buys a token holding anything.
+     */
+    expected_contents_hash?: string;
+}
+export interface OfferAminoMsg {
+    type: "/sparkdream.artifact.v1.Offer";
+    value: OfferAmino;
+}
+/**
+ * Auction is an English auction of one token: SPARK bids escrowed in the
+ * module, each outbidding the last by min_increment_bps, the highest bid
+ * settled at ends_at. A bid near the end extends it (anti-sniping).
+ * @name Auction
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Auction
+ */
+export interface Auction {
+    id: bigint;
+    classId: bigint;
+    tokenId: bigint;
+    seller: string;
+    /**
+     * The lowest acceptable first bid.
+     */
+    reservePrice: Coin;
+    /**
+     * Each bid must beat the current one by at least this much.
+     */
+    minIncrementBps: number;
+    createdAt: bigint;
+    endsAt: bigint;
+    /**
+     * "" until the first bid.
+     */
+    highBidder: string;
+    highBid: string;
+    bids: number;
+}
+export interface AuctionProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.Auction";
+    value: Uint8Array;
+}
+/**
+ * Auction is an English auction of one token: SPARK bids escrowed in the
+ * module, each outbidding the last by min_increment_bps, the highest bid
+ * settled at ends_at. A bid near the end extends it (anti-sniping).
+ * @name AuctionAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Auction
+ */
+export interface AuctionAmino {
+    id?: string;
+    class_id?: string;
+    token_id?: string;
+    seller?: string;
+    /**
+     * The lowest acceptable first bid.
+     */
+    reserve_price: CoinAmino;
+    /**
+     * Each bid must beat the current one by at least this much.
+     */
+    min_increment_bps?: number;
+    created_at?: string;
+    ends_at?: string;
+    /**
+     * "" until the first bid.
+     */
+    high_bidder?: string;
+    high_bid?: string;
+    bids?: number;
+}
+export interface AuctionAminoMsg {
+    type: "/sparkdream.artifact.v1.Auction";
+    value: AuctionAmino;
+}
+/**
+ * ExpiryPolicy is a class's token expiry rule, fixed at creation.
+ * @name ExpiryPolicy
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.ExpiryPolicy
+ */
+export declare const ExpiryPolicy: {
+    typeUrl: string;
+    encode(message: ExpiryPolicy, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ExpiryPolicy;
+    fromPartial(object: DeepPartial<ExpiryPolicy>): ExpiryPolicy;
+    fromAmino(object: ExpiryPolicyAmino): ExpiryPolicy;
+    toAmino(message: ExpiryPolicy): ExpiryPolicyAmino;
+    fromAminoMsg(object: ExpiryPolicyAminoMsg): ExpiryPolicy;
+    fromProtoMsg(message: ExpiryPolicyProtoMsg): ExpiryPolicy;
+    toProto(message: ExpiryPolicy): Uint8Array;
+    toProtoMsg(message: ExpiryPolicy): ExpiryPolicyProtoMsg;
+};
+/**
+ * RevealPolicy is a class's commit-reveal state.
+ * @name RevealPolicy
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.RevealPolicy
+ */
+export declare const RevealPolicy: {
+    typeUrl: string;
+    encode(message: RevealPolicy, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RevealPolicy;
+    fromPartial(object: DeepPartial<RevealPolicy>): RevealPolicy;
+    fromAmino(object: RevealPolicyAmino): RevealPolicy;
+    toAmino(message: RevealPolicy): RevealPolicyAmino;
+    fromAminoMsg(object: RevealPolicyAminoMsg): RevealPolicy;
+    fromProtoMsg(message: RevealPolicyProtoMsg): RevealPolicy;
+    toProto(message: RevealPolicy): Uint8Array;
+    toProtoMsg(message: RevealPolicy): RevealPolicyProtoMsg;
+};
+/**
+ * Renderer names the pure Gno package x/gnovm evaluates at query time to
+ * produce a token's displayed metadata. Fixed at creation.
+ * @name Renderer
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Renderer
+ */
+export declare const Renderer: {
+    typeUrl: string;
+    encode(message: Renderer, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Renderer;
+    fromPartial(object: DeepPartial<Renderer>): Renderer;
+    fromAmino(object: RendererAmino): Renderer;
+    toAmino(message: Renderer): RendererAmino;
+    fromAminoMsg(object: RendererAminoMsg): Renderer;
+    fromProtoMsg(message: RendererProtoMsg): Renderer;
+    toProto(message: Renderer): Uint8Array;
+    toProtoMsg(message: Renderer): RendererProtoMsg;
+};
+/**
+ * MetadataStage is one step of a token's metadata schedule.
+ * @name MetadataStage
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.MetadataStage
+ */
+export declare const MetadataStage: {
+    typeUrl: string;
+    encode(message: MetadataStage, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MetadataStage;
+    fromPartial(object: DeepPartial<MetadataStage>): MetadataStage;
+    fromAmino(object: MetadataStageAmino): MetadataStage;
+    toAmino(message: MetadataStage): MetadataStageAmino;
+    fromAminoMsg(object: MetadataStageAminoMsg): MetadataStage;
+    fromProtoMsg(message: MetadataStageProtoMsg): MetadataStage;
+    toProto(message: MetadataStage): Uint8Array;
+    toProtoMsg(message: MetadataStage): MetadataStageProtoMsg;
+};
+/**
+ * MediaProposal is a media version the class owner offered a token's holder.
+ * @name MediaProposal
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.MediaProposal
+ */
+export declare const MediaProposal: {
+    typeUrl: string;
+    encode(message: MediaProposal, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MediaProposal;
+    fromPartial(object: DeepPartial<MediaProposal>): MediaProposal;
+    fromAmino(object: MediaProposalAmino): MediaProposal;
+    toAmino(message: MediaProposal): MediaProposalAmino;
+    fromAminoMsg(object: MediaProposalAminoMsg): MediaProposal;
+    fromProtoMsg(message: MediaProposalProtoMsg): MediaProposal;
+    toProto(message: MediaProposal): Uint8Array;
+    toProtoMsg(message: MediaProposal): MediaProposalProtoMsg;
+};
+/**
+ * ClassFlags are fixed at class creation and never change.
+ * @name ClassFlags
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.ClassFlags
+ */
+export declare const ClassFlags: {
+    typeUrl: string;
+    encode(message: ClassFlags, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ClassFlags;
+    fromPartial(object: DeepPartial<ClassFlags>): ClassFlags;
+    fromAmino(object: ClassFlagsAmino): ClassFlags;
+    toAmino(message: ClassFlags): ClassFlagsAmino;
+    fromAminoMsg(object: ClassFlagsAminoMsg): ClassFlags;
+    fromProtoMsg(message: ClassFlagsProtoMsg): ClassFlags;
+    toProto(message: ClassFlags): Uint8Array;
+    toProtoMsg(message: ClassFlags): ClassFlagsProtoMsg;
+};
+/**
+ * MintPolicy configures public minting (MsgPublicMint).
+ * @name MintPolicy
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.MintPolicy
+ */
+export declare const MintPolicy: {
+    typeUrl: string;
     encode(message: MintPolicy, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): MintPolicy;
     fromPartial(object: DeepPartial<MintPolicy>): MintPolicy;
@@ -1155,3 +2656,274 @@ export declare const SentinelDailyHideEntry: {
     toProto(message: SentinelDailyHideEntry): Uint8Array;
     toProtoMsg(message: SentinelDailyHideEntry): SentinelDailyHideEntryProtoMsg;
 };
+/**
+ * HarbergerPolicy makes a class's tokens partially commonly owned: each
+ * holder self-assesses a price, anyone may buy the token at that price at
+ * any time, and the holder pays a yearly tax on it to the community pool
+ * through an x/session RecurringPull. Fixed at creation; tax_bps_per_year 0
+ * means a plain class.
+ * @name HarbergerPolicy
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.HarbergerPolicy
+ */
+export declare const HarbergerPolicy: {
+    typeUrl: string;
+    encode(message: HarbergerPolicy, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): HarbergerPolicy;
+    fromPartial(object: DeepPartial<HarbergerPolicy>): HarbergerPolicy;
+    fromAmino(object: HarbergerPolicyAmino): HarbergerPolicy;
+    toAmino(message: HarbergerPolicy): HarbergerPolicyAmino;
+    fromAminoMsg(object: HarbergerPolicyAminoMsg): HarbergerPolicy;
+    fromProtoMsg(message: HarbergerPolicyProtoMsg): HarbergerPolicy;
+    toProto(message: HarbergerPolicy): Uint8Array;
+    toProtoMsg(message: HarbergerPolicy): HarbergerPolicyProtoMsg;
+};
+/**
+ * HarbergerState is a Harberger token's self-assessment and tax status.
+ * @name HarbergerState
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.HarbergerState
+ */
+export declare const HarbergerState: {
+    typeUrl: string;
+    encode(message: HarbergerState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): HarbergerState;
+    fromPartial(object: DeepPartial<HarbergerState>): HarbergerState;
+    fromAmino(object: HarbergerStateAmino): HarbergerState;
+    toAmino(message: HarbergerState): HarbergerStateAmino;
+    fromAminoMsg(object: HarbergerStateAminoMsg): HarbergerState;
+    fromProtoMsg(message: HarbergerStateProtoMsg): HarbergerState;
+    toProto(message: HarbergerState): Uint8Array;
+    toProtoMsg(message: HarbergerState): HarbergerStateProtoMsg;
+};
+/**
+ * Rental is an active time-limited user right on one token. The token is
+ * RENTED-locked: it cannot move, be listed, burned or nested until the
+ * rental ends.
+ * @name Rental
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Rental
+ */
+export declare const Rental: {
+    typeUrl: string;
+    encode(message: Rental, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Rental;
+    fromPartial(object: DeepPartial<Rental>): Rental;
+    fromAmino(object: RentalAmino): Rental;
+    toAmino(message: Rental): RentalAmino;
+    fromAminoMsg(object: RentalAminoMsg): Rental;
+    fromProtoMsg(message: RentalProtoMsg): Rental;
+    toProto(message: Rental): Uint8Array;
+    toProtoMsg(message: Rental): RentalProtoMsg;
+};
+/**
+ * RentalOffer is an owner's standing offer to rent a token out. Nothing is
+ * locked or escrowed; MsgAcceptRental settles it atomically.
+ * @name RentalOffer
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.RentalOffer
+ */
+export declare const RentalOffer: {
+    typeUrl: string;
+    encode(message: RentalOffer, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RentalOffer;
+    fromPartial(object: DeepPartial<RentalOffer>): RentalOffer;
+    fromAmino(object: RentalOfferAmino): RentalOffer;
+    toAmino(message: RentalOffer): RentalOfferAmino;
+    fromAminoMsg(object: RentalOfferAminoMsg): RentalOffer;
+    fromProtoMsg(message: RentalOfferProtoMsg): RentalOffer;
+    toProto(message: RentalOffer): Uint8Array;
+    toProtoMsg(message: RentalOffer): RentalOfferProtoMsg;
+};
+/**
+ * ImpactClaim describes a piece of work an edition certifies (an impact
+ * certificate). Holders of the edition's units share whatever retroactive
+ * funders pay to it (MsgFundEdition); DREAM never touches a certificate.
+ * @name ImpactClaim
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.ImpactClaim
+ */
+export declare const ImpactClaim: {
+    typeUrl: string;
+    encode(message: ImpactClaim, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ImpactClaim;
+    fromPartial(object: DeepPartial<ImpactClaim>): ImpactClaim;
+    fromAmino(object: ImpactClaimAmino): ImpactClaim;
+    toAmino(message: ImpactClaim): ImpactClaimAmino;
+    fromAminoMsg(object: ImpactClaimAminoMsg): ImpactClaim;
+    fromProtoMsg(message: ImpactClaimProtoMsg): ImpactClaim;
+    toProto(message: ImpactClaim): Uint8Array;
+    toProtoMsg(message: ImpactClaim): ImpactClaimProtoMsg;
+};
+/**
+ * Edition is one semi-fungible token id of an EDITIONS class: identical
+ * units held as per-address balances.
+ * @name Edition
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Edition
+ */
+export declare const Edition: {
+    typeUrl: string;
+    encode(message: Edition, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Edition;
+    fromPartial(object: DeepPartial<Edition>): Edition;
+    fromAmino(object: EditionAmino): Edition;
+    toAmino(message: Edition): EditionAmino;
+    fromAminoMsg(object: EditionAminoMsg): Edition;
+    fromProtoMsg(message: EditionProtoMsg): Edition;
+    toProto(message: Edition): Uint8Array;
+    toProtoMsg(message: Edition): EditionProtoMsg;
+};
+/**
+ * Balance is one address's units of one edition.
+ * @name Balance
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Balance
+ */
+export declare const Balance: {
+    typeUrl: string;
+    encode(message: Balance, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Balance;
+    fromPartial(object: DeepPartial<Balance>): Balance;
+    fromAmino(object: BalanceAmino): Balance;
+    toAmino(message: Balance): BalanceAmino;
+    fromAminoMsg(object: BalanceAminoMsg): Balance;
+    fromProtoMsg(message: BalanceProtoMsg): Balance;
+    toProto(message: Balance): Uint8Array;
+    toProtoMsg(message: Balance): BalanceProtoMsg;
+};
+/**
+ * EditionRef addresses one edition.
+ * @name EditionRef
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.EditionRef
+ */
+export declare const EditionRef: {
+    typeUrl: string;
+    encode(message: EditionRef, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EditionRef;
+    fromPartial(object: DeepPartial<EditionRef>): EditionRef;
+    fromAmino(object: EditionRefAmino): EditionRef;
+    toAmino(message: EditionRef): EditionRefAmino;
+    fromAminoMsg(object: EditionRefAminoMsg): EditionRef;
+    fromProtoMsg(message: EditionRefProtoMsg): EditionRef;
+    toProto(message: EditionRef): Uint8Array;
+    toProtoMsg(message: EditionRef): EditionRefProtoMsg;
+};
+/**
+ * PendingUnits is a unit transfer or mint awaiting the recipient. Its inbox
+ * ref is (class_id 0, token_id = id): class 0 is never a real class.
+ * @name PendingUnits
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.PendingUnits
+ */
+export declare const PendingUnits: {
+    typeUrl: string;
+    encode(message: PendingUnits, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PendingUnits;
+    fromPartial(object: DeepPartial<PendingUnits>): PendingUnits;
+    fromAmino(object: PendingUnitsAmino): PendingUnits;
+    toAmino(message: PendingUnits): PendingUnitsAmino;
+    fromAminoMsg(object: PendingUnitsAminoMsg): PendingUnits;
+    fromProtoMsg(message: PendingUnitsProtoMsg): PendingUnits;
+    toProto(message: PendingUnits): Uint8Array;
+    toProtoMsg(message: PendingUnits): PendingUnitsProtoMsg;
+};
+/**
+ * UnitListing offers units of an edition at a fixed per-unit price. The
+ * listed units are locked in the seller's balance; buyers may take part.
+ * @name UnitListing
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.UnitListing
+ */
+export declare const UnitListing: {
+    typeUrl: string;
+    encode(message: UnitListing, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): UnitListing;
+    fromPartial(object: DeepPartial<UnitListing>): UnitListing;
+    fromAmino(object: UnitListingAmino): UnitListing;
+    toAmino(message: UnitListing): UnitListingAmino;
+    fromAminoMsg(object: UnitListingAminoMsg): UnitListing;
+    fromProtoMsg(message: UnitListingProtoMsg): UnitListing;
+    toProto(message: UnitListing): Uint8Array;
+    toProtoMsg(message: UnitListing): UnitListingProtoMsg;
+};
+/**
+ * CraftInput is one ingredient of a recipe: quantity tokens of a UNIQUE
+ * class (edition_id 0), or quantity units of an edition.
+ * @name CraftInput
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.CraftInput
+ */
+export declare const CraftInput: {
+    typeUrl: string;
+    encode(message: CraftInput, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): CraftInput;
+    fromPartial(object: DeepPartial<CraftInput>): CraftInput;
+    fromAmino(object: CraftInputAmino): CraftInput;
+    toAmino(message: CraftInput): CraftInputAmino;
+    fromAminoMsg(object: CraftInputAminoMsg): CraftInput;
+    fromProtoMsg(message: CraftInputProtoMsg): CraftInput;
+    toProto(message: CraftInput): Uint8Array;
+    toProtoMsg(message: CraftInput): CraftInputProtoMsg;
+};
+/**
+ * CraftRecipe burns its inputs to mint into the class it belongs to.
+ * Recipes can be removed at any time but none can be added after the
+ * class's first craft.
+ * @name CraftRecipe
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.CraftRecipe
+ */
+export declare const CraftRecipe: {
+    typeUrl: string;
+    encode(message: CraftRecipe, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): CraftRecipe;
+    fromPartial(object: DeepPartial<CraftRecipe>): CraftRecipe;
+    fromAmino(object: CraftRecipeAmino): CraftRecipe;
+    toAmino(message: CraftRecipe): CraftRecipeAmino;
+    fromAminoMsg(object: CraftRecipeAminoMsg): CraftRecipe;
+    fromProtoMsg(message: CraftRecipeProtoMsg): CraftRecipe;
+    toProto(message: CraftRecipe): Uint8Array;
+    toProtoMsg(message: CraftRecipe): CraftRecipeProtoMsg;
+};
+/**
+ * Offer is an escrowed SPARK bid to buy a token (token_id set) or any
+ * token of a class (token_id 0, a collection offer). The price waits in the
+ * module account until the offer is accepted, cancelled or expires.
+ * @name Offer
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Offer
+ */
+export declare const Offer: {
+    typeUrl: string;
+    encode(message: Offer, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Offer;
+    fromPartial(object: DeepPartial<Offer>): Offer;
+    fromAmino(object: OfferAmino): Offer;
+    toAmino(message: Offer): OfferAmino;
+    fromAminoMsg(object: OfferAminoMsg): Offer;
+    fromProtoMsg(message: OfferProtoMsg): Offer;
+    toProto(message: Offer): Uint8Array;
+    toProtoMsg(message: Offer): OfferProtoMsg;
+};
+/**
+ * Auction is an English auction of one token: SPARK bids escrowed in the
+ * module, each outbidding the last by min_increment_bps, the highest bid
+ * settled at ends_at. A bid near the end extends it (anti-sniping).
+ * @name Auction
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Auction
+ */
+export declare const Auction: {
+    typeUrl: string;
+    encode(message: Auction, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Auction;
+    fromPartial(object: DeepPartial<Auction>): Auction;
+    fromAmino(object: AuctionAmino): Auction;
+    toAmino(message: Auction): AuctionAmino;
+    fromAminoMsg(object: AuctionAminoMsg): Auction;
+    fromProtoMsg(message: AuctionProtoMsg): Auction;
+    toProto(message: Auction): Uint8Array;
+    toProtoMsg(message: Auction): AuctionProtoMsg;
+};