@dignetwork/chip35-dl-coin-wasm 0.7.0 → 0.9.0

package/chip35_dl_coin_wasm.d.ts

@@ -1,20 +1,365 @@
 /* tslint:disable */
 /* eslint-disable */
 
+/** A Chia coin. `amount` is mojos (XCH) or base units (CAT). */
+export interface Coin {
+    parentCoinInfo: Uint8Array;
+    puzzleHash: Uint8Array;
+    amount: bigint;
+}
+
+/** A coin spend: the coin plus its CLVM puzzle reveal + solution (raw program bytes). */
+export interface CoinSpend {
+    coin: Coin;
+    puzzleReveal: Uint8Array;
+    solution: Uint8Array;
+}
+
+/** A singleton lineage proof (the coin descends from a prior singleton coin). */
+export interface LineageProof {
+    parentParentCoinInfo: Uint8Array;
+    parentInnerPuzzleHash: Uint8Array;
+    parentAmount: bigint;
+}
+
+/** An eve proof (the coin descends directly from its launcher). */
+export interface EveProof {
+    parentParentCoinInfo: Uint8Array;
+    parentAmount: bigint;
+}
+
+/**
+ * A singleton proof. Exactly one of `lineageProof` / `eveProof` is set
+ * (a discriminated "exactly one of" pair).
+ */
+export type Proof =
+| { lineageProof: LineageProof; eveProof?: undefined }
+| { lineageProof?: undefined; eveProof: EveProof };
+
+/** A DataStore's metadata (root hash + optional human label/description + size). */
+export interface DataStoreMetadata {
+    rootHash: Uint8Array;
+    label?: string | null;
+    description?: string | null;
+    bytes?: bigint | null;
+    /** 32-byte CLVM program (size-proof) hash, if any. */
+    programHash?: Uint8Array | null;
+}
+
+/**
+ * A delegated puzzle entry on a store's delegated-puzzle set. Exactly one role is populated:
+ * `adminInnerPuzzleHash` (admin), `writerInnerPuzzleHash` (writer / deploy token), or the
+ * `oraclePaymentPuzzleHash` + `oracleFee` pair (oracle).
+ */
+export type DelegatedPuzzle =
+| { adminInnerPuzzleHash: Uint8Array }
+| { writerInnerPuzzleHash: Uint8Array }
+| { oraclePaymentPuzzleHash: Uint8Array; oracleFee: bigint };
+
+/** A CHIP-0035 DataLayer store singleton. */
+export interface DataStore {
+    coin: Coin;
+    launcherId: Uint8Array;
+    proof: Proof;
+    metadata: DataStoreMetadata;
+    ownerPuzzleHash: Uint8Array;
+    delegatedPuzzles: DelegatedPuzzle[];
+}
+
+/** The result of a store spend builder: the coin spends to sign + the resulting store state. */
+export interface SuccessResponse {
+    coinSpends: CoinSpend[];
+    newStore: DataStore;
+}
+
+/** A spend bundle: coin spends + the aggregated BLS signature (96 bytes). */
+export interface SpendBundle {
+    coinSpends: CoinSpend[];
+    aggregatedSignature: Uint8Array;
+}
+
+/** A CHIP-0007 attribute (trait). */
+export interface Attribute {
+    traitType: string;
+    value: string;
+}
+
+/** A CHIP-0007 collection reference embedded in item metadata. */
+export interface CollectionRef {
+    id: string;
+    name: string;
+    attributes?: Attribute[];
+}
+
+/** A CHIP-0007 metadata document (off-chain JSON). */
+export interface Chip0007Metadata {
+    format?: string;
+    name: string;
+    description?: string | null;
+    sensitiveContent?: boolean;
+    collection?: CollectionRef | null;
+    attributes?: Attribute[];
+    seriesNumber?: bigint | null;
+    seriesTotal?: bigint | null;
+    mintingTool?: string | null;
+}
+
+/** Result of `buildChip0007Metadata`. */
+export interface Chip0007MetadataResult {
+    json: string;
+    metadataHash: Uint8Array;
+}
+
+/** The actual bytes (and claimed hashes) `validateChip0007` checks URI↔hash agreement against. */
+export interface Chip0007Assets {
+    dataBytes?: Uint8Array;
+    dataHash?: Uint8Array;
+    metadataBytes?: Uint8Array;
+    metadataHash?: Uint8Array;
+    licenseBytes?: Uint8Array;
+    licenseHash?: Uint8Array;
+}
+
+/** Result of `validateChip0007`. */
+export interface ValidationResult {
+    ok: boolean;
+    errors: string[];
+}
+
+/** A DID attribution (the creator identity a mint is attributed to). */
+export interface DidAttribution {
+    launcherId: Uint8Array;
+    innerPuzzleHash: Uint8Array;
+}
+
+/** On-chain NFT media metadata (dig:// + https fallback URIs + computed hashes). */
+export interface NftMediaMetadata {
+    dataUris?: string[];
+    dataHash?: Uint8Array;
+    metadataUris?: string[];
+    metadataHash?: Uint8Array;
+    licenseUris?: string[];
+    licenseHash?: Uint8Array;
+    editionNumber?: bigint;
+    editionTotal?: bigint;
+}
+
+/** Parameters to mint a single NFT. */
+export interface NftMintParams {
+    metadata: NftMediaMetadata;
+    p2PuzzleHash: Uint8Array;
+    royaltyPuzzleHash: Uint8Array;
+    royaltyBasisPoints: number;
+    did?: DidAttribution | null;
+}
+
+/** Result of `mintNft`. */
+export interface NftMintResult {
+    coinSpends: CoinSpend[];
+    launcherId: Uint8Array;
+    nftCoin: Coin;
+}
+
+/** Result of `createDid`. */
+export interface CreateDidResult {
+    coinSpends: CoinSpend[];
+    launcherId: Uint8Array;
+    innerPuzzleHash: Uint8Array;
+    didCoin: Coin;
+}
+
+/** Result of `issueCat`. */
+export interface IssueCatResult {
+    coinSpends: CoinSpend[];
+    assetId: Uint8Array;
+    catCoins: Coin[];
+}
+
+/** A collection definition (for `generateItemMetadata` / `bulkMint`). */
+export interface Collection {
+    id: string;
+    name: string;
+    attributes?: Attribute[];
+    royaltyPuzzleHash: Uint8Array;
+    royaltyBasisPoints: number;
+}
+
+/** One item's on-chain media in a parsed traits manifest. */
+export interface ManifestMedia {
+    dataUris?: string[];
+    dataHash?: Uint8Array;
+    metadataUris?: string[];
+    metadataHash?: Uint8Array;
+    licenseUris?: string[];
+    licenseHash?: Uint8Array;
+}
+
+/** One item in a parsed traits manifest. */
+export interface ManifestItem {
+    name: string;
+    description?: string | null;
+    attributes?: Attribute[];
+    media: ManifestMedia;
+}
+
+/** A DID coin + identifiers (for `bulkMint`). Simple DIDs use `numVerificationsRequired: 1`. */
+export interface Did {
+    didCoin: Coin;
+    proof: Proof;
+    launcherId: Uint8Array;
+    innerPuzzleHash: Uint8Array;
+    recoveryListHash?: Uint8Array | null;
+    numVerificationsRequired?: bigint;
+}
+
+/** Result of `bulkMint`. */
+export interface BulkMintResult {
+    coinSpends: CoinSpend[];
+    launcherIds: Uint8Array[];
+}
+
+/**
+ * Which asset a payment settles in. Exactly one of `xch` / `assetId` is set
+ * (a discriminated "exactly one of" pair).
+ */
+export type PaymentAsset =
+| { xch: true; assetId?: undefined }
+| { xch?: false; assetId: Uint8Array };
+
+/** A CAT's on-chain info. */
+export interface CatInfo {
+    assetId: Uint8Array;
+    hiddenPuzzleHash?: Uint8Array | null;
+    p2PuzzleHash: Uint8Array;
+}
+
+/** A buyer's CAT coin (as `chip0002_getAssetCoins` returns it) for `buildCatPayment` / `buildDigStorePayment`. */
+export interface Cat {
+    coin: Coin;
+    lineageProof?: LineageProof | null;
+    info: CatInfo;
+}
+
+/**
+ * The cross-system $DIG-payment constants (mainnet), returned by `digConstants()`. Minting a store is
+ * FREE of $DIG; a CAPSULE (commit / root-advance) pays the per-capsule price in $DIG to
+ * `treasuryInnerPuzzleHash`. Byte-identical across the ecosystem (digstore-chain / hub).
+ */
+export interface DigConstants {
+    /** The DIG CAT asset id (TAIL hash), 32 bytes. */
+    assetId: Uint8Array;
+    /** The DIG treasury's inner (standard) puzzle hash every per-capsule payment settles to, 32 bytes. */
+    treasuryInnerPuzzleHash: Uint8Array;
+}
+
+/** The verifiable description of a payment's on-chain commitment. */
+export interface PaymentReceipt {
+    ownerPuzzleHash: Uint8Array;
+    amount: bigint;
+    asset: PaymentAsset;
+    nonce: Uint8Array;
+    paymentCoin: Coin;
+}
+
+/** Result of `buildPayment` / `buildCatPayment`. */
+export interface PaymentResponse {
+    coinSpends: CoinSpend[];
+    receipt: PaymentReceipt;
+}
+
+/** What an observed payment looks like to the paywall after reading the chain (for `verifyPaymentReceipt`). */
+export interface ObservedPayment {
+    paidToPuzzleHash: Uint8Array;
+    amount: bigint;
+    asset: PaymentAsset;
+    nonce?: Uint8Array | null;
+}
+
+/**
+ * Result of `verifyPaymentReceipt`. On denial, `code` is a stable `PaywallError`
+ * code (`WRONG_RECIPIENT` | `INSUFFICIENT_AMOUNT` | `WRONG_ASSET` | `NONCE_MISMATCH`).
+ */
+export interface PaywallResult {
+    ok: boolean;
+    code?: ChipErrorCode;
+    error?: string;
+}
+
+/** The on-chain ownership facts a gating proof establishes about an NFT. */
+export interface NftOwnershipProof {
+    launcherId: Uint8Array;
+    ownerPuzzleHash: Uint8Array;
+    attributedDid?: Uint8Array | null;
+    nftCoinId: Uint8Array;
+}
+
+/**
+ * Result of the NFT-gating helpers (`proveNftOwnership` / `proveCollectionMembership` /
+ * `readNftOwnership`). On failure, `code` is a stable `GatingError` code
+ * (`NOT_AN_NFT` | `WRONG_OWNER` | `WRONG_COLLECTION` | `WRONG_NFT`).
+ */
+export interface GatingResult {
+    ok: boolean;
+    proof?: NftOwnershipProof;
+    code?: ChipErrorCode;
+    error?: string;
+}
+
+/**
+ * Every stable machine error code this module can surface — thrown as `{ code, message }` from a
+ * failing export, or carried as the `code` field of a `{ ok:false, code, error }` result. Branch on
+ * the code, never the human `message`/`error` string.
+ */
+export type ChipErrorCode =
+| "INVALID_ARGUMENT"
+| "SERDE_ERROR"
+| "DRIVER_ERROR"
+| "PARSE_ERROR"
+| "PERMISSION_DENIED"
+| "METADATA_ERROR"
+| "NOT_AN_NFT"
+| "WRONG_OWNER"
+| "WRONG_COLLECTION"
+| "WRONG_NFT"
+| "WRONG_RECIPIENT"
+| "INSUFFICIENT_AMOUNT"
+| "WRONG_ASSET"
+| "NONCE_MISMATCH";
+
+/** The structured error a failing export throws: a stable machine `code` beside the human `message`. */
+export interface ChipError {
+    code: ChipErrorCode;
+    message: string;
+}
+
+/** Runtime self-description returned by `capabilities()`. */
+export interface Capabilities {
+    /** The published npm package name. */
+    name: string;
+    /** The package version (= `version()`). */
+    version: string;
+    /** Every exported builder/helper (camelCase JS names). */
+    builders: string[];
+    /** The catalogue of stable machine error codes (see `ChipErrorCode`). */
+    errorCodes: ChipErrorCode[];
+}
+
+
+
 /**
  * Build coin spends that reserve `fee` mojos from the spender's own coins while asserting
  * concurrent spend of `assert_coin_ids` (see [`chip35_dl_coin::add_fee`]). Lets a fee-less
  * singleton op (update/melt) carry a network fee. `selected_coins` is `Coin[]`,
  * `assert_coin_ids` is `Uint8Array[]` of 32-byte coin ids. Returns `CoinSpend[]`.
  */
-export function addFee(spender_synthetic_key: Uint8Array, selected_coins: any, assert_coin_ids: any, fee: bigint): any;
+export function addFee(spender_synthetic_key: Uint8Array, selected_coins: Coin[], assert_coin_ids: Uint8Array[], fee: bigint): CoinSpend[];
 
 /**
  * Build the **Admin** delegated puzzle for a 48-byte synthetic public key (a hub Teams admin).
  * An admin may update the store AND change delegation (add/remove writers — i.e. revoke a deploy
  * token), but cannot transfer ownership. Returns a `DelegatedPuzzle` (`{ adminInnerPuzzleHash }`).
  */
-export function adminDelegatedPuzzleFromKey(synthetic_key: Uint8Array): any;
+export function adminDelegatedPuzzleFromKey(synthetic_key: Uint8Array): DelegatedPuzzle;
 
 /**
  * Build the coin spends for a buyer to pay the dapp owner `amount` base units of a **CAT** (incl.
@@ -23,34 +368,55 @@ export function adminDelegatedPuzzleFromKey(synthetic_key: Uint8Array): any;
  * zero, so carry any XCH network fee with a separate XCH coin via `addFee` asserting the lead CAT
  * coin id. Returns `{ coinSpends, receipt }`.
  */
-export function buildCatPayment(buyer_synthetic_key: Uint8Array, selected_cats: any, owner_puzzle_hash: Uint8Array, amount: bigint, nonce: Uint8Array): any;
+export function buildCatPayment(buyer_synthetic_key: Uint8Array, selected_cats: Cat[], owner_puzzle_hash: Uint8Array, amount: bigint, nonce: Uint8Array): PaymentResponse;
 
 /**
  * Build a CHIP-0007 metadata document from a JS object and return its canonical JSON + the
  * `metadata_hash` (sha256 of that JSON). De-dupes the hand-computed badge metadata: callers stop
  * hand-rolling SHA-256. Returns `{ json: string, metadataHash: Uint8Array }`. Validates schema.
  */
-export function buildChip0007Metadata(metadata: any): any;
+export function buildChip0007Metadata(metadata: Chip0007Metadata): Chip0007MetadataResult;
+
+/**
+ * Build the (UNSIGNED) DIG-CAT coin spends that pay `amount` base units of $DIG to the DIG treasury
+ * for a capsule (commit) — the canonical per-capsule store payment (see
+ * [`chip35_dl_coin::build_dig_store_payment`]). `dig_cats` is the buyer's `Cat[]` of the DIG asset
+ * (as `chip0002_getAssetCoins` returns them); `store_id` is the capsule's launcher id (= store id);
+ * `amount` is the dynamic, USD-pegged per-capsule price in DIG base units (an INPUT — never
+ * hardcoded). The caller concatenates the returned `CoinSpend[]` with the commit's
+ * `updateStoreMetadata` spends and signs the whole bundle. MINT does NOT call this (mint is free of
+ * $DIG). Returns `CoinSpend[]`.
+ */
+export function buildDigStorePayment(buyer_synthetic_key: Uint8Array, dig_cats: Cat[], store_id: Uint8Array, amount: bigint): CoinSpend[];
 
 /**
  * Build the coin spends for a buyer to pay the dapp owner `amount` mojos of **XCH** (#46 payment).
  * `selected_coins` is the buyer's XCH `Coin[]`; `nonce` is the 32-byte unlock nonce. Returns
  * `{ coinSpends, receipt }` where `receipt` is the `PaymentReceipt` the paywall later verifies.
  */
-export function buildPayment(buyer_synthetic_key: Uint8Array, selected_coins: any, owner_puzzle_hash: Uint8Array, amount: bigint, nonce: Uint8Array, fee: bigint): any;
+export function buildPayment(buyer_synthetic_key: Uint8Array, selected_coins: Coin[], owner_puzzle_hash: Uint8Array, amount: bigint, nonce: Uint8Array, fee: bigint): PaymentResponse;
 
 /**
  * Bulk-mint every item in a parsed traits manifest into a collection, attributed to a DID (#34).
  * `did` is the DID coin + identifiers `{ launcherId, innerPuzzleHash, didCoin }` (e.g. from a prior
  * `createDid`, fetched on-chain). Returns `{ coinSpends, launcherIds }`.
  */
-export function bulkMint(minter_synthetic_key: Uint8Array, did: any, collection: any, items: any, recipient_puzzle_hash: Uint8Array): any;
+export function bulkMint(minter_synthetic_key: Uint8Array, did: Did, collection: Collection, items: ManifestItem[], recipient_puzzle_hash: Uint8Array): BulkMintResult;
+
+/**
+ * A machine-readable descriptor of this module's surface, for runtime introspection by an agent or
+ * consumer: `{ name, version, builders, errorCodes }`. `builders` is every exported builder/helper
+ * (camelCase JS names); `errorCodes` is the catalogue of stable `UPPER_SNAKE` codes a caller may
+ * branch on (thrown as `{ code, message }`, or carried as the `code` field of a `{ ok, code?, error? }`
+ * result). One call yields the version + the full surface with zero out-of-band knowledge.
+ */
+export function capabilities(): Capabilities;
 
 /**
  * Create a DID (creator identity) singleton. Returns
  * `{ coinSpends, launcherId, innerPuzzleHash, didCoin }`.
  */
-export function createDid(minter_synthetic_key: Uint8Array, selected_coins: any, fee: bigint): any;
+export function createDid(minter_synthetic_key: Uint8Array, selected_coins: Coin[], fee: bigint): CreateDidResult;
 
 /**
  * Reconstruct a DataStore from the coin spend that created its current coin (the launcher
@@ -59,12 +425,28 @@ export function createDid(minter_synthetic_key: Uint8Array, selected_coins: any,
  * `coin_spend` is the wasm CoinSpend shape (Uint8Array fields); `prev_delegated_puzzles` is
  * the parent's delegated-puzzle list ([] for an owner-only store).
  */
-export function dataStoreFromSpend(coin_spend: any, prev_delegated_puzzles: any): any;
+export function dataStoreFromSpend(coin_spend: CoinSpend, prev_delegated_puzzles: DelegatedPuzzle[]): DataStore;
 
 /**
  * Decode canonical offer text into its spend bundle `{ coinSpends, aggregatedSignature }`.
  */
-export function decodeOffer(text: string): any;
+export function decodeOffer(text: string): SpendBundle;
+
+/**
+ * The cross-system $DIG-payment constants (mainnet): the DIG CAT `assetId` and the treasury INNER
+ * `puzzleHash` every per-capsule payment settles to. Byte-identical across the ecosystem
+ * (digstore-chain / hub). Lets an agent/consumer read them at runtime instead of hardcoding. Returns
+ * `{ assetId: Uint8Array, treasuryInnerPuzzleHash: Uint8Array }`.
+ */
+export function digConstants(): DigConstants;
+
+/**
+ * The DIG-CAT payment coin a capsule (commit) pays to the treasury — what `buildDigStorePayment`
+ * emits (see [`chip35_dl_coin::dig_treasury_payment_coin`]). `lead_dig_cat` is the lead DIG `Cat`
+ * (its id is the new coin's parent); `amount` is the payment in DIG base units. Lets a caller pin /
+ * verify the exact expected treasury coin without re-deriving the CAT wrap. Returns a `Coin`.
+ */
+export function digTreasuryPaymentCoin(lead_dig_cat: Cat, amount: bigint): Coin;
 
 /**
  * Derive the digstore-scoped owner discovery hint for a 32-byte owner puzzle hash. The app
@@ -76,20 +458,20 @@ export function digstoreOwnerHint(owner_puzzle_hash: Uint8Array): Uint8Array;
 /**
  * Encode a spend bundle (`{coinSpends, aggregatedSignature}`) into canonical offer text.
  */
-export function encodeOffer(spend_bundle: any): string;
+export function encodeOffer(spend_bundle: SpendBundle): string;
 
 /**
  * Generate per-item CHIP-0007 metadata documents for a collection from a parsed traits manifest
  * (#34). `collection` is `Collection`; `items` is `ManifestItem[]`. Returns
  * `Chip0007Metadata[]` (the off-chain JSON docs; the caller hashes + writes them into each capsule).
  */
-export function generateItemMetadata(collection: any, items: any): any;
+export function generateItemMetadata(collection: Collection, items: ManifestItem[]): Chip0007Metadata[];
 
 /**
  * Decode a hex-encoded spend bundle into its `CoinSpend[]` (see
  * [`chip35_dl_coin::hex_spend_bundle_to_coin_spends`]).
  */
-export function hexSpendBundleToCoinSpends(hex: string): any;
+export function hexSpendBundleToCoinSpends(hex: string): CoinSpend[];
 
 /**
  * Initialise the module. Call once at startup. Installs a panic hook (when the
@@ -100,40 +482,40 @@ export function init(): void;
 /**
  * Issue a single-issuance (fixed-supply) CAT. Returns `{ coinSpends, assetId, catCoins }`.
  */
-export function issueCat(issuer_synthetic_key: Uint8Array, selected_coins: any, amount: bigint, fee: bigint): any;
+export function issueCat(issuer_synthetic_key: Uint8Array, selected_coins: Coin[], amount: bigint, fee: bigint): IssueCatResult;
 
 /**
  * Burn (melt) a store singleton (see [`chip35_dl_coin::melt_store`]). Owner-authorized only.
  * Returns the melt `CoinSpend[]`.
  */
-export function meltStore(store: any, owner_public_key: Uint8Array): any;
+export function meltStore(store: DataStore, owner_public_key: Uint8Array): CoinSpend[];
 
 /**
  * Mint a single NFT whose media lives in a DIG capsule (`dig://` URN + https gateway fallback URIs,
  * hashes computed from real bytes). `params` is `NftMintParams`. Returns
  * `{ coinSpends, launcherId, nftCoin }`.
  */
-export function mintNft(minter_synthetic_key: Uint8Array, selected_coins: any, params: any, fee: bigint): any;
+export function mintNft(minter_synthetic_key: Uint8Array, selected_coins: Coin[], params: NftMintParams, fee: bigint): NftMintResult;
 
 /**
  * Build the spend bundle that launches a new DataLayer store singleton (see
  * [`chip35_dl_coin::mint_store`]). `program_hash` is an optional 32-byte size-proof; the rest of
  * the JS values mirror the core builder. Returns a `SuccessResponse` (`coinSpends` + `newStore`).
  */
-export function mintStore(minter_synthetic_key: Uint8Array, selected_coins: any, root_hash: Uint8Array, label: string | null | undefined, description: string | null | undefined, bytes: bigint | null | undefined, program_hash: Uint8Array | null | undefined, owner_puzzle_hash: Uint8Array, delegated_puzzles: any, fee: bigint): any;
+export function mintStore(minter_synthetic_key: Uint8Array, selected_coins: Coin[], root_hash: Uint8Array, label: string | null | undefined, description: string | null | undefined, bytes: bigint | null | undefined, program_hash: Uint8Array | null | undefined, owner_puzzle_hash: Uint8Array, delegated_puzzles: DelegatedPuzzle[], fee: bigint): SuccessResponse;
 
 /**
  * Build the **Oracle** delegated puzzle: anyone may spend the store for the fixed `oracle_fee`
  * (mojos) paid to the 32-byte `oracle_puzzle_hash`. Returns a `DelegatedPuzzle`
  * (`{ oraclePaymentPuzzleHash, oracleFee }`).
  */
-export function oracleDelegatedPuzzle(oracle_puzzle_hash: Uint8Array, oracle_fee: bigint): any;
+export function oracleDelegatedPuzzle(oracle_puzzle_hash: Uint8Array, oracle_fee: bigint): DelegatedPuzzle;
 
 /**
  * Exercise a store's oracle delegated puzzle (see [`chip35_dl_coin::oracle_spend`]). The spender
  * pays the oracle fee plus `fee` from `selected_coins`. Returns a `SuccessResponse`.
  */
-export function oracleSpend(spender_synthetic_key: Uint8Array, selected_coins: any, store: any, fee: bigint): any;
+export function oracleSpend(spender_synthetic_key: Uint8Array, selected_coins: Coin[], store: DataStore, fee: bigint): SuccessResponse;
 
 /**
  * SHA-256-derive a 32-byte unlock nonce from arbitrary request bytes (`dappId||resource||user`).
@@ -146,7 +528,7 @@ export function paymentNonce(request_bytes: Uint8Array): Uint8Array;
  * Prove an NFT held by `claimed_owner_puzzle_hash` is a member of the collection/creator identified
  * by `required_did` (#46 collection-gating). Returns `{ ok, proof?, error? }`.
  */
-export function proveCollectionMembership(parent_spend: any, claimed_owner_puzzle_hash: Uint8Array, required_did: Uint8Array): any;
+export function proveCollectionMembership(parent_spend: CoinSpend, claimed_owner_puzzle_hash: Uint8Array, required_did: Uint8Array): GatingResult;
 
 /**
  * Prove an NFT (reconstructed from `parent_spend`, the coin spend that created its current coin) is
@@ -155,14 +537,14 @@ export function proveCollectionMembership(parent_spend: any, claimed_owner_puzzl
  * success `proof` is the `NftOwnershipProof` (launcher id, owner, attributed DID, current coin id);
  * the caller still confirms `proof.nftCoinId` is unspent on-chain for liveness.
  */
-export function proveNftOwnership(parent_spend: any, claimed_owner_puzzle_hash: Uint8Array, required_nft?: Uint8Array | null): any;
+export function proveNftOwnership(parent_spend: CoinSpend, claimed_owner_puzzle_hash: Uint8Array, required_nft?: Uint8Array | null): GatingResult;
 
 /**
  * Read an NFT's ownership facts (owner, attributed DID, launcher id, current coin id) from
  * `parent_spend` WITHOUT applying a gate — for dapps that want to decide in their own code.
  * Returns `{ ok, proof?, error? }`.
  */
-export function readNftOwnership(parent_spend: any): any;
+export function readNftOwnership(parent_spend: CoinSpend): GatingResult;
 
 /**
  * SHA-256 of arbitrary bytes → 32-byte hash (the one true primitive for `data_hash`/
@@ -174,14 +556,14 @@ export function sha256(bytes: Uint8Array): Uint8Array;
  * Serialize a spend bundle (`{coinSpends, aggregatedSignature}`) to its hex wire encoding
  * (see [`chip35_dl_coin::spend_bundle_to_hex`]).
  */
-export function spendBundleToHex(spend_bundle: any): string;
+export function spendBundleToHex(spend_bundle: SpendBundle): string;
 
 /**
  * Update a store's metadata (see [`chip35_dl_coin::update_store_metadata`]). Exactly one of
  * `owner_public_key`, `admin_public_key`, `writer_public_key` must be provided — it selects the
  * authorizing role. Returns a `SuccessResponse`.
  */
-export function updateStoreMetadata(store: any, new_root_hash: Uint8Array, new_label?: string | null, new_description?: string | null, new_bytes?: bigint | null, new_program_hash?: Uint8Array | null, owner_public_key?: Uint8Array | null, admin_public_key?: Uint8Array | null, writer_public_key?: Uint8Array | null): any;
+export function updateStoreMetadata(store: DataStore, new_root_hash: Uint8Array, new_label?: string | null, new_description?: string | null, new_bytes?: bigint | null, new_program_hash?: Uint8Array | null, owner_public_key?: Uint8Array | null, admin_public_key?: Uint8Array | null, writer_public_key?: Uint8Array | null): SuccessResponse;
 
 /**
  * Transfer ownership and/or replace the delegated-puzzle set (see
@@ -189,7 +571,7 @@ export function updateStoreMetadata(store: any, new_root_hash: Uint8Array, new_l
  * current owner. Exactly one of `owner_public_key`/`admin_public_key` must be provided. Returns
  * a `SuccessResponse`.
  */
-export function updateStoreOwnership(store: any, new_owner_puzzle_hash: Uint8Array | null | undefined, new_delegated_puzzles: any, owner_public_key?: Uint8Array | null, admin_public_key?: Uint8Array | null): any;
+export function updateStoreOwnership(store: DataStore, new_owner_puzzle_hash: Uint8Array | null | undefined, new_delegated_puzzles: DelegatedPuzzle[], owner_public_key?: Uint8Array | null, admin_public_key?: Uint8Array | null): SuccessResponse;
 
 /**
  * Validate a CHIP-0007 document's schema, and (when the actual bytes are provided) that each
@@ -197,7 +579,7 @@ export function updateStoreOwnership(store: any, new_owner_puzzle_hash: Uint8Arr
  * `{ dataBytes?, dataHash?, metadataBytes?, metadataHash?, licenseBytes?, licenseHash? }` (all
  * `Uint8Array`). Returns `{ ok: bool, errors: string[] }`.
  */
-export function validateChip0007(metadata: any, assets: any): any;
+export function validateChip0007(metadata: Chip0007Metadata, assets: Chip0007Assets): ValidationResult;
 
 /**
  * Verify an observed payment unlocks a paywall (#46 pay-to-unlock): it must pay `owner_puzzle_hash`,
@@ -206,7 +588,13 @@ export function validateChip0007(metadata: any, assets: any): any;
  * `required_asset` is a `PaymentAsset` (`{xch:true}` or `{assetId}`). Returns `{ ok, error? }` —
  * `ok:true` grants access, otherwise `error` is the human-readable denial reason.
  */
-export function verifyPaymentReceipt(observed: any, owner_puzzle_hash: Uint8Array, min_amount: bigint, required_asset: any, require_nonce?: Uint8Array | null): any;
+export function verifyPaymentReceipt(observed: ObservedPayment, owner_puzzle_hash: Uint8Array, min_amount: bigint, required_asset: PaymentAsset, require_nonce?: Uint8Array | null): PaywallResult;
+
+/**
+ * The published package version (= the Cargo crate version = the npm package version). Lets a
+ * consumer/agent feature-gate on exactly which build is loaded at runtime.
+ */
+export function version(): string;
 
 /**
  * Build the **Writer** delegated puzzle for a 48-byte synthetic public key — a revocable deploy
@@ -215,4 +603,4 @@ export function verifyPaymentReceipt(observed: any, owner_puzzle_hash: Uint8Arra
  * to issue the token; replace the store's delegated set to revoke it. Returns a `DelegatedPuzzle`
  * (`{ writerInnerPuzzleHash }`).
  */
-export function writerDelegatedPuzzleFromKey(synthetic_key: Uint8Array): any;
+export function writerDelegatedPuzzleFromKey(synthetic_key: Uint8Array): DelegatedPuzzle;

package/chip35_dl_coin_wasm.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./chip35_dl_coin_wasm_bg.js";
 __wbg_set_wasm(wasm);
 
 export {
-    addFee, adminDelegatedPuzzleFromKey, buildCatPayment, buildChip0007Metadata, buildPayment, bulkMint, createDid, dataStoreFromSpend, decodeOffer, digstoreOwnerHint, encodeOffer, generateItemMetadata, hexSpendBundleToCoinSpends, init, issueCat, meltStore, mintNft, mintStore, oracleDelegatedPuzzle, oracleSpend, paymentNonce, proveCollectionMembership, proveNftOwnership, readNftOwnership, sha256, spendBundleToHex, updateStoreMetadata, updateStoreOwnership, validateChip0007, verifyPaymentReceipt, writerDelegatedPuzzleFromKey
+    addFee, adminDelegatedPuzzleFromKey, buildCatPayment, buildChip0007Metadata, buildDigStorePayment, buildPayment, bulkMint, capabilities, createDid, dataStoreFromSpend, decodeOffer, digConstants, digTreasuryPaymentCoin, digstoreOwnerHint, encodeOffer, generateItemMetadata, hexSpendBundleToCoinSpends, init, issueCat, meltStore, mintNft, mintStore, oracleDelegatedPuzzle, oracleSpend, paymentNonce, proveCollectionMembership, proveNftOwnership, readNftOwnership, sha256, spendBundleToHex, updateStoreMetadata, updateStoreOwnership, validateChip0007, verifyPaymentReceipt, version, writerDelegatedPuzzleFromKey
 } from "./chip35_dl_coin_wasm_bg.js";

package/chip35_dl_coin_wasm_bg.js

@@ -4,10 +4,10 @@
  * singleton op (update/melt) carry a network fee. `selected_coins` is `Coin[]`,
  * `assert_coin_ids` is `Uint8Array[]` of 32-byte coin ids. Returns `CoinSpend[]`.
  * @param {Uint8Array} spender_synthetic_key
- * @param {any} selected_coins
- * @param {any} assert_coin_ids
+ * @param {Coin[]} selected_coins
+ * @param {Uint8Array[]} assert_coin_ids
  * @param {bigint} fee
- * @returns {any}
+ * @returns {CoinSpend[]}
  */
 export function addFee(spender_synthetic_key, selected_coins, assert_coin_ids, fee) {
     try {
@@ -32,7 +32,7 @@ export function addFee(spender_synthetic_key, selected_coins, assert_coin_ids, f
  * An admin may update the store AND change delegation (add/remove writers — i.e. revoke a deploy
  * token), but cannot transfer ownership. Returns a `DelegatedPuzzle` (`{ adminInnerPuzzleHash }`).
  * @param {Uint8Array} synthetic_key
- * @returns {any}
+ * @returns {DelegatedPuzzle}
  */
 export function adminDelegatedPuzzleFromKey(synthetic_key) {
     try {
@@ -59,11 +59,11 @@ export function adminDelegatedPuzzleFromKey(synthetic_key) {
  * zero, so carry any XCH network fee with a separate XCH coin via `addFee` asserting the lead CAT
  * coin id. Returns `{ coinSpends, receipt }`.
  * @param {Uint8Array} buyer_synthetic_key
- * @param {any} selected_cats
+ * @param {Cat[]} selected_cats
  * @param {Uint8Array} owner_puzzle_hash
  * @param {bigint} amount
  * @param {Uint8Array} nonce
- * @returns {any}
+ * @returns {PaymentResponse}
  */
 export function buildCatPayment(buyer_synthetic_key, selected_cats, owner_puzzle_hash, amount, nonce) {
     try {
@@ -91,8 +91,8 @@ export function buildCatPayment(buyer_synthetic_key, selected_cats, owner_puzzle
  * Build a CHIP-0007 metadata document from a JS object and return its canonical JSON + the
  * `metadata_hash` (sha256 of that JSON). De-dupes the hand-computed badge metadata: callers stop
  * hand-rolling SHA-256. Returns `{ json: string, metadataHash: Uint8Array }`. Validates schema.
- * @param {any} metadata
- * @returns {any}
+ * @param {Chip0007Metadata} metadata
+ * @returns {Chip0007MetadataResult}
  */
 export function buildChip0007Metadata(metadata) {
     try {
@@ -110,17 +110,52 @@ export function buildChip0007Metadata(metadata) {
     }
 }
 
+/**
+ * Build the (UNSIGNED) DIG-CAT coin spends that pay `amount` base units of $DIG to the DIG treasury
+ * for a capsule (commit) — the canonical per-capsule store payment (see
+ * [`chip35_dl_coin::build_dig_store_payment`]). `dig_cats` is the buyer's `Cat[]` of the DIG asset
+ * (as `chip0002_getAssetCoins` returns them); `store_id` is the capsule's launcher id (= store id);
+ * `amount` is the dynamic, USD-pegged per-capsule price in DIG base units (an INPUT — never
+ * hardcoded). The caller concatenates the returned `CoinSpend[]` with the commit's
+ * `updateStoreMetadata` spends and signs the whole bundle. MINT does NOT call this (mint is free of
+ * $DIG). Returns `CoinSpend[]`.
+ * @param {Uint8Array} buyer_synthetic_key
+ * @param {Cat[]} dig_cats
+ * @param {Uint8Array} store_id
+ * @param {bigint} amount
+ * @returns {CoinSpend[]}
+ */
+export function buildDigStorePayment(buyer_synthetic_key, dig_cats, store_id, amount) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(buyer_synthetic_key, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(store_id, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.buildDigStorePayment(retptr, ptr0, len0, addHeapObject(dig_cats), ptr1, len1, amount);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * Build the coin spends for a buyer to pay the dapp owner `amount` mojos of **XCH** (#46 payment).
  * `selected_coins` is the buyer's XCH `Coin[]`; `nonce` is the 32-byte unlock nonce. Returns
  * `{ coinSpends, receipt }` where `receipt` is the `PaymentReceipt` the paywall later verifies.
  * @param {Uint8Array} buyer_synthetic_key
- * @param {any} selected_coins
+ * @param {Coin[]} selected_coins
  * @param {Uint8Array} owner_puzzle_hash
  * @param {bigint} amount
  * @param {Uint8Array} nonce
  * @param {bigint} fee
- * @returns {any}
+ * @returns {PaymentResponse}
  */
 export function buildPayment(buyer_synthetic_key, selected_coins, owner_puzzle_hash, amount, nonce, fee) {
     try {
@@ -149,11 +184,11 @@ export function buildPayment(buyer_synthetic_key, selected_coins, owner_puzzle_h
  * `did` is the DID coin + identifiers `{ launcherId, innerPuzzleHash, didCoin }` (e.g. from a prior
  * `createDid`, fetched on-chain). Returns `{ coinSpends, launcherIds }`.
  * @param {Uint8Array} minter_synthetic_key
- * @param {any} did
- * @param {any} collection
- * @param {any} items
+ * @param {Did} did
+ * @param {Collection} collection
+ * @param {ManifestItem[]} items
  * @param {Uint8Array} recipient_puzzle_hash
- * @returns {any}
+ * @returns {BulkMintResult}
  */
 export function bulkMint(minter_synthetic_key, did, collection, items, recipient_puzzle_hash) {
     try {
@@ -175,13 +210,26 @@ export function bulkMint(minter_synthetic_key, did, collection, items, recipient
     }
 }
 
+/**
+ * A machine-readable descriptor of this module's surface, for runtime introspection by an agent or
+ * consumer: `{ name, version, builders, errorCodes }`. `builders` is every exported builder/helper
+ * (camelCase JS names); `errorCodes` is the catalogue of stable `UPPER_SNAKE` codes a caller may
+ * branch on (thrown as `{ code, message }`, or carried as the `code` field of a `{ ok, code?, error? }`
+ * result). One call yields the version + the full surface with zero out-of-band knowledge.
+ * @returns {Capabilities}
+ */
+export function capabilities() {
+    const ret = wasm.capabilities();
+    return takeObject(ret);
+}
+
 /**
  * Create a DID (creator identity) singleton. Returns
  * `{ coinSpends, launcherId, innerPuzzleHash, didCoin }`.
  * @param {Uint8Array} minter_synthetic_key
- * @param {any} selected_coins
+ * @param {Coin[]} selected_coins
  * @param {bigint} fee
- * @returns {any}
+ * @returns {CreateDidResult}
  */
 export function createDid(minter_synthetic_key, selected_coins, fee) {
     try {
@@ -207,9 +255,9 @@ export function createDid(minter_synthetic_key, selected_coins, fee) {
  * creating spend from a full node, rebuild the DataStore here, then meltStore() it.
  * `coin_spend` is the wasm CoinSpend shape (Uint8Array fields); `prev_delegated_puzzles` is
  * the parent's delegated-puzzle list ([] for an owner-only store).
- * @param {any} coin_spend
- * @param {any} prev_delegated_puzzles
- * @returns {any}
+ * @param {CoinSpend} coin_spend
+ * @param {DelegatedPuzzle[]} prev_delegated_puzzles
+ * @returns {DataStore}
  */
 export function dataStoreFromSpend(coin_spend, prev_delegated_puzzles) {
     try {
@@ -230,7 +278,7 @@ export function dataStoreFromSpend(coin_spend, prev_delegated_puzzles) {
 /**
  * Decode canonical offer text into its spend bundle `{ coinSpends, aggregatedSignature }`.
  * @param {string} text
- * @returns {any}
+ * @returns {SpendBundle}
  */
 export function decodeOffer(text) {
     try {
@@ -250,6 +298,43 @@ export function decodeOffer(text) {
     }
 }
 
+/**
+ * The cross-system $DIG-payment constants (mainnet): the DIG CAT `assetId` and the treasury INNER
+ * `puzzleHash` every per-capsule payment settles to. Byte-identical across the ecosystem
+ * (digstore-chain / hub). Lets an agent/consumer read them at runtime instead of hardcoding. Returns
+ * `{ assetId: Uint8Array, treasuryInnerPuzzleHash: Uint8Array }`.
+ * @returns {DigConstants}
+ */
+export function digConstants() {
+    const ret = wasm.digConstants();
+    return takeObject(ret);
+}
+
+/**
+ * The DIG-CAT payment coin a capsule (commit) pays to the treasury — what `buildDigStorePayment`
+ * emits (see [`chip35_dl_coin::dig_treasury_payment_coin`]). `lead_dig_cat` is the lead DIG `Cat`
+ * (its id is the new coin's parent); `amount` is the payment in DIG base units. Lets a caller pin /
+ * verify the exact expected treasury coin without re-deriving the CAT wrap. Returns a `Coin`.
+ * @param {Cat} lead_dig_cat
+ * @param {bigint} amount
+ * @returns {Coin}
+ */
+export function digTreasuryPaymentCoin(lead_dig_cat, amount) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.digTreasuryPaymentCoin(retptr, addHeapObject(lead_dig_cat), amount);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * Derive the digstore-scoped owner discovery hint for a 32-byte owner puzzle hash. The app
  * computes the SAME hint to enumerate the wallet's stores via coinset
@@ -280,7 +365,7 @@ export function digstoreOwnerHint(owner_puzzle_hash) {
 
 /**
  * Encode a spend bundle (`{coinSpends, aggregatedSignature}`) into canonical offer text.
- * @param {any} spend_bundle
+ * @param {SpendBundle} spend_bundle
  * @returns {string}
  */
 export function encodeOffer(spend_bundle) {
@@ -312,9 +397,9 @@ export function encodeOffer(spend_bundle) {
  * Generate per-item CHIP-0007 metadata documents for a collection from a parsed traits manifest
  * (#34). `collection` is `Collection`; `items` is `ManifestItem[]`. Returns
  * `Chip0007Metadata[]` (the off-chain JSON docs; the caller hashes + writes them into each capsule).
- * @param {any} collection
- * @param {any} items
- * @returns {any}
+ * @param {Collection} collection
+ * @param {ManifestItem[]} items
+ * @returns {Chip0007Metadata[]}
  */
 export function generateItemMetadata(collection, items) {
     try {
@@ -336,7 +421,7 @@ export function generateItemMetadata(collection, items) {
  * Decode a hex-encoded spend bundle into its `CoinSpend[]` (see
  * [`chip35_dl_coin::hex_spend_bundle_to_coin_spends`]).
  * @param {string} hex
- * @returns {any}
+ * @returns {CoinSpend[]}
  */
 export function hexSpendBundleToCoinSpends(hex) {
     try {
@@ -367,10 +452,10 @@ export function init() {
 /**
  * Issue a single-issuance (fixed-supply) CAT. Returns `{ coinSpends, assetId, catCoins }`.
  * @param {Uint8Array} issuer_synthetic_key
- * @param {any} selected_coins
+ * @param {Coin[]} selected_coins
  * @param {bigint} amount
  * @param {bigint} fee
- * @returns {any}
+ * @returns {IssueCatResult}
  */
 export function issueCat(issuer_synthetic_key, selected_coins, amount, fee) {
     try {
@@ -393,9 +478,9 @@ export function issueCat(issuer_synthetic_key, selected_coins, amount, fee) {
 /**
  * Burn (melt) a store singleton (see [`chip35_dl_coin::melt_store`]). Owner-authorized only.
  * Returns the melt `CoinSpend[]`.
- * @param {any} store
+ * @param {DataStore} store
  * @param {Uint8Array} owner_public_key
- * @returns {any}
+ * @returns {CoinSpend[]}
  */
 export function meltStore(store, owner_public_key) {
     try {
@@ -420,10 +505,10 @@ export function meltStore(store, owner_public_key) {
  * hashes computed from real bytes). `params` is `NftMintParams`. Returns
  * `{ coinSpends, launcherId, nftCoin }`.
  * @param {Uint8Array} minter_synthetic_key
- * @param {any} selected_coins
- * @param {any} params
+ * @param {Coin[]} selected_coins
+ * @param {NftMintParams} params
  * @param {bigint} fee
- * @returns {any}
+ * @returns {NftMintResult}
  */
 export function mintNft(minter_synthetic_key, selected_coins, params, fee) {
     try {
@@ -448,16 +533,16 @@ export function mintNft(minter_synthetic_key, selected_coins, params, fee) {
  * [`chip35_dl_coin::mint_store`]). `program_hash` is an optional 32-byte size-proof; the rest of
  * the JS values mirror the core builder. Returns a `SuccessResponse` (`coinSpends` + `newStore`).
  * @param {Uint8Array} minter_synthetic_key
- * @param {any} selected_coins
+ * @param {Coin[]} selected_coins
  * @param {Uint8Array} root_hash
  * @param {string | null | undefined} label
  * @param {string | null | undefined} description
  * @param {bigint | null | undefined} bytes
  * @param {Uint8Array | null | undefined} program_hash
  * @param {Uint8Array} owner_puzzle_hash
- * @param {any} delegated_puzzles
+ * @param {DelegatedPuzzle[]} delegated_puzzles
  * @param {bigint} fee
- * @returns {any}
+ * @returns {SuccessResponse}
  */
 export function mintStore(minter_synthetic_key, selected_coins, root_hash, label, description, bytes, program_hash, owner_puzzle_hash, delegated_puzzles, fee) {
     try {
@@ -493,7 +578,7 @@ export function mintStore(minter_synthetic_key, selected_coins, root_hash, label
  * (`{ oraclePaymentPuzzleHash, oracleFee }`).
  * @param {Uint8Array} oracle_puzzle_hash
  * @param {bigint} oracle_fee
- * @returns {any}
+ * @returns {DelegatedPuzzle}
  */
 export function oracleDelegatedPuzzle(oracle_puzzle_hash, oracle_fee) {
     try {
@@ -517,10 +602,10 @@ export function oracleDelegatedPuzzle(oracle_puzzle_hash, oracle_fee) {
  * Exercise a store's oracle delegated puzzle (see [`chip35_dl_coin::oracle_spend`]). The spender
  * pays the oracle fee plus `fee` from `selected_coins`. Returns a `SuccessResponse`.
  * @param {Uint8Array} spender_synthetic_key
- * @param {any} selected_coins
- * @param {any} store
+ * @param {Coin[]} selected_coins
+ * @param {DataStore} store
  * @param {bigint} fee
- * @returns {any}
+ * @returns {SuccessResponse}
  */
 export function oracleSpend(spender_synthetic_key, selected_coins, store, fee) {
     try {
@@ -566,10 +651,10 @@ export function paymentNonce(request_bytes) {
 /**
  * Prove an NFT held by `claimed_owner_puzzle_hash` is a member of the collection/creator identified
  * by `required_did` (#46 collection-gating). Returns `{ ok, proof?, error? }`.
- * @param {any} parent_spend
+ * @param {CoinSpend} parent_spend
  * @param {Uint8Array} claimed_owner_puzzle_hash
  * @param {Uint8Array} required_did
- * @returns {any}
+ * @returns {GatingResult}
  */
 export function proveCollectionMembership(parent_spend, claimed_owner_puzzle_hash, required_did) {
     try {
@@ -597,10 +682,10 @@ export function proveCollectionMembership(parent_spend, claimed_owner_puzzle_has
  * gating). `parent_spend` is the wasm `CoinSpend` shape. Returns `{ ok, proof?, error? }` — on
  * success `proof` is the `NftOwnershipProof` (launcher id, owner, attributed DID, current coin id);
  * the caller still confirms `proof.nftCoinId` is unspent on-chain for liveness.
- * @param {any} parent_spend
+ * @param {CoinSpend} parent_spend
  * @param {Uint8Array} claimed_owner_puzzle_hash
  * @param {Uint8Array | null} [required_nft]
- * @returns {any}
+ * @returns {GatingResult}
  */
 export function proveNftOwnership(parent_spend, claimed_owner_puzzle_hash, required_nft) {
     try {
@@ -626,8 +711,8 @@ export function proveNftOwnership(parent_spend, claimed_owner_puzzle_hash, requi
  * Read an NFT's ownership facts (owner, attributed DID, launcher id, current coin id) from
  * `parent_spend` WITHOUT applying a gate — for dapps that want to decide in their own code.
  * Returns `{ ok, proof?, error? }`.
- * @param {any} parent_spend
- * @returns {any}
+ * @param {CoinSpend} parent_spend
+ * @returns {GatingResult}
  */
 export function readNftOwnership(parent_spend) {
     try {
@@ -670,7 +755,7 @@ export function sha256(bytes) {
 /**
  * Serialize a spend bundle (`{coinSpends, aggregatedSignature}`) to its hex wire encoding
  * (see [`chip35_dl_coin::spend_bundle_to_hex`]).
- * @param {any} spend_bundle
+ * @param {SpendBundle} spend_bundle
  * @returns {string}
  */
 export function spendBundleToHex(spend_bundle) {
@@ -702,7 +787,7 @@ export function spendBundleToHex(spend_bundle) {
  * Update a store's metadata (see [`chip35_dl_coin::update_store_metadata`]). Exactly one of
  * `owner_public_key`, `admin_public_key`, `writer_public_key` must be provided — it selects the
  * authorizing role. Returns a `SuccessResponse`.
- * @param {any} store
+ * @param {DataStore} store
  * @param {Uint8Array} new_root_hash
  * @param {string | null} [new_label]
  * @param {string | null} [new_description]
@@ -711,7 +796,7 @@ export function spendBundleToHex(spend_bundle) {
  * @param {Uint8Array | null} [owner_public_key]
  * @param {Uint8Array | null} [admin_public_key]
  * @param {Uint8Array | null} [writer_public_key]
- * @returns {any}
+ * @returns {SuccessResponse}
  */
 export function updateStoreMetadata(store, new_root_hash, new_label, new_description, new_bytes, new_program_hash, owner_public_key, admin_public_key, writer_public_key) {
     try {
@@ -748,12 +833,12 @@ export function updateStoreMetadata(store, new_root_hash, new_label, new_descrip
  * [`chip35_dl_coin::update_store_ownership`]). Omitting `new_owner_puzzle_hash` keeps the
  * current owner. Exactly one of `owner_public_key`/`admin_public_key` must be provided. Returns
  * a `SuccessResponse`.
- * @param {any} store
+ * @param {DataStore} store
  * @param {Uint8Array | null | undefined} new_owner_puzzle_hash
- * @param {any} new_delegated_puzzles
+ * @param {DelegatedPuzzle[]} new_delegated_puzzles
  * @param {Uint8Array | null} [owner_public_key]
  * @param {Uint8Array | null} [admin_public_key]
- * @returns {any}
+ * @returns {SuccessResponse}
  */
 export function updateStoreOwnership(store, new_owner_puzzle_hash, new_delegated_puzzles, owner_public_key, admin_public_key) {
     try {
@@ -782,9 +867,9 @@ export function updateStoreOwnership(store, new_owner_puzzle_hash, new_delegated
  * on-chain hash matches `sha256(bytes)` — the URI↔hash agreement check (#36). `assets` is
  * `{ dataBytes?, dataHash?, metadataBytes?, metadataHash?, licenseBytes?, licenseHash? }` (all
  * `Uint8Array`). Returns `{ ok: bool, errors: string[] }`.
- * @param {any} metadata
- * @param {any} assets
- * @returns {any}
+ * @param {Chip0007Metadata} metadata
+ * @param {Chip0007Assets} assets
+ * @returns {ValidationResult}
  */
 export function validateChip0007(metadata, assets) {
     try {
@@ -808,12 +893,12 @@ export function validateChip0007(metadata, assets) {
  * that nonce. `observed` is an `ObservedPayment` the dapp filled in after reading the owner's coin;
  * `required_asset` is a `PaymentAsset` (`{xch:true}` or `{assetId}`). Returns `{ ok, error? }` —
  * `ok:true` grants access, otherwise `error` is the human-readable denial reason.
- * @param {any} observed
+ * @param {ObservedPayment} observed
  * @param {Uint8Array} owner_puzzle_hash
  * @param {bigint} min_amount
- * @param {any} required_asset
+ * @param {PaymentAsset} required_asset
  * @param {Uint8Array | null} [require_nonce]
- * @returns {any}
+ * @returns {PaywallResult}
  */
 export function verifyPaymentReceipt(observed, owner_puzzle_hash, min_amount, required_asset, require_nonce) {
     try {
@@ -835,6 +920,28 @@ export function verifyPaymentReceipt(observed, owner_puzzle_hash, min_amount, re
     }
 }
 
+/**
+ * The published package version (= the Cargo crate version = the npm package version). Lets a
+ * consumer/agent feature-gate on exactly which build is loaded at runtime.
+ * @returns {string}
+ */
+export function version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.version(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred1_0 = r0;
+        deferred1_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * Build the **Writer** delegated puzzle for a 48-byte synthetic public key — a revocable deploy
  * token (#17) or a hub Teams writer (#43). A writer may advance the root (deploy a new capsule)
@@ -842,7 +949,7 @@ export function verifyPaymentReceipt(observed, owner_puzzle_hash, min_amount, re
  * to issue the token; replace the store's delegated set to revoke it. Returns a `DelegatedPuzzle`
  * (`{ writerInnerPuzzleHash }`).
  * @param {Uint8Array} synthetic_key
- * @returns {any}
+ * @returns {DelegatedPuzzle}
  */
 export function writerDelegatedPuzzleFromKey(synthetic_key) {
     try {
@@ -1049,6 +1156,10 @@ export function __wbg_prototypesetcall_3249fc62a0fafa30(arg0, arg1, arg2) {
 export function __wbg_set_6be42768c690e380(arg0, arg1, arg2) {
     getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
 }
+export function __wbg_set_6e30c9374c26414c() { return handleError(function (arg0, arg1, arg2) {
+    const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+    return ret;
+}, arguments); }
 export function __wbg_set_dca99999bba88a9a(arg0, arg1, arg2) {
     getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@dignetwork/chip35-dl-coin-wasm",
   "type": "module",
   "description": "WebAssembly bindings for the isolated CHIP-0035 DataLayer store coin driver.",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "license": "MIT",
   "repository": {
     "type": "git",