@dignetwork/chip35-dl-coin-wasm 0.6.0 → 0.8.0

package/chip35_dl_coin_wasm.d.ts

@@ -1,40 +1,398 @@
 /* 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`. */
+export interface Cat {
+    coin: Coin;
+    lineageProof?: LineageProof | null;
+    info: CatInfo;
+}
+
+/** 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.
+ * DIG) (#46 payment). `selected_cats` is the buyer's `Cat[]` of ONE asset id (as
+ * `chip0002_getAssetCoins` returns them); `nonce` is the 32-byte unlock nonce. The CAT ring nets to
+ * 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: 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 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: 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
@@ -43,12 +401,12 @@ 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;
 
 /**
  * Derive the digstore-scoped owner discovery hint for a 32-byte owner puzzle hash. The app
@@ -60,20 +418,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
@@ -84,40 +442,69 @@ 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`).
+ * A dapp issues one nonce per unlock request, embeds it in the payment, and verifies it later. The
+ * dapp may instead use any random 32 bytes — this is a deterministic convenience. Returns 32 bytes.
+ */
+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: 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
+ * owned by `claimed_owner_puzzle_hash`, optionally gating on a specific NFT launcher id (#46 NFT-
+ * 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.
+ */
+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: CoinSpend): GatingResult;
 
 /**
  * SHA-256 of arbitrary bytes → 32-byte hash (the one true primitive for `data_hash`/
@@ -129,14 +516,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
@@ -144,7 +531,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
@@ -152,7 +539,22 @@ 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`,
+ * in `required_asset`, at least `min_amount`, and (when `require_nonce` is a 32-byte value) carry
+ * 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.
+ */
+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
@@ -161,4 +563,4 @@ export function validateChip0007(metadata: any, assets: any): any;
  * 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, buildChip0007Metadata, bulkMint, createDid, dataStoreFromSpend, decodeOffer, digstoreOwnerHint, encodeOffer, generateItemMetadata, hexSpendBundleToCoinSpends, init, issueCat, meltStore, mintNft, mintStore, oracleDelegatedPuzzle, oracleSpend, sha256, spendBundleToHex, updateStoreMetadata, updateStoreOwnership, validateChip0007, writerDelegatedPuzzleFromKey
+    addFee, adminDelegatedPuzzleFromKey, buildCatPayment, buildChip0007Metadata, buildPayment, bulkMint, capabilities, createDid, dataStoreFromSpend, decodeOffer, 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 {
@@ -52,12 +52,47 @@ export function adminDelegatedPuzzleFromKey(synthetic_key) {
     }
 }
 
+/**
+ * Build the coin spends for a buyer to pay the dapp owner `amount` base units of a **CAT** (incl.
+ * DIG) (#46 payment). `selected_cats` is the buyer's `Cat[]` of ONE asset id (as
+ * `chip0002_getAssetCoins` returns them); `nonce` is the 32-byte unlock nonce. The CAT ring nets to
+ * 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 {Cat[]} selected_cats
+ * @param {Uint8Array} owner_puzzle_hash
+ * @param {bigint} amount
+ * @param {Uint8Array} nonce
+ * @returns {PaymentResponse}
+ */
+export function buildCatPayment(buyer_synthetic_key, selected_cats, owner_puzzle_hash, amount, nonce) {
+    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(owner_puzzle_hash, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(nonce, wasm.__wbindgen_export);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.buildCatPayment(retptr, ptr0, len0, addHeapObject(selected_cats), ptr1, len1, amount, ptr2, len2);
+        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 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 {
@@ -75,16 +110,50 @@ export function buildChip0007Metadata(metadata) {
     }
 }
 
+/**
+ * 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 {Coin[]} selected_coins
+ * @param {Uint8Array} owner_puzzle_hash
+ * @param {bigint} amount
+ * @param {Uint8Array} nonce
+ * @param {bigint} fee
+ * @returns {PaymentResponse}
+ */
+export function buildPayment(buyer_synthetic_key, selected_coins, owner_puzzle_hash, amount, nonce, fee) {
+    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(owner_puzzle_hash, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(nonce, wasm.__wbindgen_export);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.buildPayment(retptr, ptr0, len0, addHeapObject(selected_coins), ptr1, len1, amount, ptr2, len2, fee);
+        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);
+    }
+}
+
 /**
  * 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 }`.
  * @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 {
@@ -106,13 +175,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 {
@@ -138,9 +220,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 {
@@ -161,7 +243,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 {
@@ -211,7 +293,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) {
@@ -243,9 +325,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 {
@@ -267,7 +349,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 {
@@ -298,10 +380,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 {
@@ -324,9 +406,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 {
@@ -351,10 +433,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 {
@@ -379,16 +461,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 {
@@ -424,7 +506,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 {
@@ -448,10 +530,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 {
@@ -471,6 +553,111 @@ export function oracleSpend(spender_synthetic_key, selected_coins, store, fee) {
     }
 }
 
+/**
+ * SHA-256-derive a 32-byte unlock nonce from arbitrary request bytes (`dappId||resource||user`).
+ * A dapp issues one nonce per unlock request, embeds it in the payment, and verifies it later. The
+ * dapp may instead use any random 32 bytes — this is a deterministic convenience. Returns 32 bytes.
+ * @param {Uint8Array} request_bytes
+ * @returns {Uint8Array}
+ */
+export function paymentNonce(request_bytes) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(request_bytes, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.paymentNonce(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var v2 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * 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 {CoinSpend} parent_spend
+ * @param {Uint8Array} claimed_owner_puzzle_hash
+ * @param {Uint8Array} required_did
+ * @returns {GatingResult}
+ */
+export function proveCollectionMembership(parent_spend, claimed_owner_puzzle_hash, required_did) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(claimed_owner_puzzle_hash, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(required_did, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.proveCollectionMembership(retptr, addHeapObject(parent_spend), ptr0, len0, ptr1, len1);
+        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);
+    }
+}
+
+/**
+ * Prove an NFT (reconstructed from `parent_spend`, the coin spend that created its current coin) is
+ * owned by `claimed_owner_puzzle_hash`, optionally gating on a specific NFT launcher id (#46 NFT-
+ * 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 {CoinSpend} parent_spend
+ * @param {Uint8Array} claimed_owner_puzzle_hash
+ * @param {Uint8Array | null} [required_nft]
+ * @returns {GatingResult}
+ */
+export function proveNftOwnership(parent_spend, claimed_owner_puzzle_hash, required_nft) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(claimed_owner_puzzle_hash, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(required_nft) ? 0 : passArray8ToWasm0(required_nft, wasm.__wbindgen_export);
+        var len1 = WASM_VECTOR_LEN;
+        wasm.proveNftOwnership(retptr, addHeapObject(parent_spend), ptr0, len0, ptr1, len1);
+        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);
+    }
+}
+
+/**
+ * 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 {CoinSpend} parent_spend
+ * @returns {GatingResult}
+ */
+export function readNftOwnership(parent_spend) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.readNftOwnership(retptr, addHeapObject(parent_spend));
+        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);
+    }
+}
+
 /**
  * SHA-256 of arbitrary bytes → 32-byte hash (the one true primitive for `data_hash`/
  * `metadata_hash`/`license_hash`). Returns the raw 32 bytes (`Uint8Array`).
@@ -496,7 +683,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) {
@@ -528,7 +715,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]
@@ -537,7 +724,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 {
@@ -574,12 +761,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 {
@@ -608,9 +795,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 {
@@ -628,6 +815,61 @@ export function validateChip0007(metadata, assets) {
     }
 }
 
+/**
+ * Verify an observed payment unlocks a paywall (#46 pay-to-unlock): it must pay `owner_puzzle_hash`,
+ * in `required_asset`, at least `min_amount`, and (when `require_nonce` is a 32-byte value) carry
+ * 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 {ObservedPayment} observed
+ * @param {Uint8Array} owner_puzzle_hash
+ * @param {bigint} min_amount
+ * @param {PaymentAsset} required_asset
+ * @param {Uint8Array | null} [require_nonce]
+ * @returns {PaywallResult}
+ */
+export function verifyPaymentReceipt(observed, owner_puzzle_hash, min_amount, required_asset, require_nonce) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(owner_puzzle_hash, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(require_nonce) ? 0 : passArray8ToWasm0(require_nonce, wasm.__wbindgen_export);
+        var len1 = WASM_VECTOR_LEN;
+        wasm.verifyPaymentReceipt(retptr, addHeapObject(observed), ptr0, len0, min_amount, addHeapObject(required_asset), ptr1, len1);
+        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);
+    }
+}
+
+/**
+ * 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)
@@ -635,7 +877,7 @@ export function validateChip0007(metadata, assets) {
  * 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 {
@@ -842,6 +1084,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.6.0",
+  "version": "0.8.0",
   "license": "MIT",
   "repository": {
     "type": "git",