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

package/chip35_dl_coin_wasm.d.ts

@@ -1,23 +1,40 @@
 /* tslint:disable */
 /* eslint-disable */
 
+/**
+ * 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;
 
 /**
- * Build the (UNSIGNED) DIG CAT coin spends paying `amount` base units of DIG to the treasury
- * (100 DIG = 100000n to mint, 10 DIG = 10000n per update), returning change to the owner. The
- * app concatenates these with the singleton mint/update spends and has the wallet sign the WHOLE
- * bundle in ONE call — the single aggregated signature makes the store creation and the DIG
- * payment atomic (all-or-nothing in the mempool).
- *
- * `owner_synthetic_key` (48 bytes) is the wallet's synthetic public key — the SAME key used for
- * mintStore (the CAT inner puzzle is its standard puzzle). `owner_puzzle_hash` (32) is that key's
- * standard puzzle hash. `parent_spends` are the spends that created the candidate DIG coins (wasm
- * CoinSpend shape), and `child_coin_ids` (Uint8Array[] of 32 bytes) are those coins' ids in the
- * SAME order — each parent spend is parsed to reconstruct its DIG child's lineage proof.
- * `store_id` (32) is the launcher id, carried as a memo. Returns CoinSpend[] (UNSIGNED).
+ * 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 buildDigPayment(owner_synthetic_key: Uint8Array, owner_puzzle_hash: Uint8Array, parent_spends: any, child_coin_ids: any, amount: bigint, store_id: Uint8Array): any;
+export function adminDelegatedPuzzleFromKey(synthetic_key: Uint8Array): any;
+
+/**
+ * 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;
+
+/**
+ * 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;
+
+/**
+ * Create a DID (creator identity) singleton. Returns
+ * `{ coinSpends, launcherId, innerPuzzleHash, didCoin }`.
+ */
+export function createDid(minter_synthetic_key: Uint8Array, selected_coins: any, fee: bigint): any;
 
 /**
  * Reconstruct a DataStore from the coin spend that created its current coin (the launcher
@@ -29,16 +46,9 @@ export function buildDigPayment(owner_synthetic_key: Uint8Array, owner_puzzle_ha
 export function dataStoreFromSpend(coin_spend: any, prev_delegated_puzzles: any): any;
 
 /**
- * The DIG CAT outer puzzle hash for a 32-byte owner puzzle hash — where the wallet's DIG
- * coins live on-chain. The app uses it to read DIG balance + select DIG coins. 32 bytes.
- */
-export function digCatPuzzleHash(owner_puzzle_hash: Uint8Array): Uint8Array;
-
-/**
- * The DIG treasury inner (standard) puzzle hash — the fixed recipient of every DIG payment.
- * Returned so the app can pin it as a golden constant. 32 bytes.
+ * Decode canonical offer text into its spend bundle `{ coinSpends, aggregatedSignature }`.
  */
-export function digTreasuryInnerPuzzleHash(): Uint8Array;
+export function decodeOffer(text: string): any;
 
 /**
  * Derive the digstore-scoped owner discovery hint for a 32-byte owner puzzle hash. The app
@@ -47,6 +57,22 @@ export function digTreasuryInnerPuzzleHash(): Uint8Array;
  */
 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;
+
+/**
+ * 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;
+
+/**
+ * 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;
 
 /**
@@ -55,14 +81,84 @@ export function hexSpendBundleToCoinSpends(hex: string): any;
  */
 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;
+
+/**
+ * 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;
 
+/**
+ * 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;
+
+/**
+ * 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;
 
+/**
+ * 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;
+
+/**
+ * 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;
 
+/**
+ * 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`).
+ */
+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;
 
+/**
+ * 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;
 
+/**
+ * Transfer ownership and/or replace the delegated-puzzle set (see
+ * [`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`.
+ */
 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;
+
+/**
+ * Validate a CHIP-0007 document's schema, and (when the actual bytes are provided) that each
+ * 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[] }`.
+ */
+export function validateChip0007(metadata: any, assets: any): any;
+
+/**
+ * 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)
+ * WITHOUT the owner seed, but may NOT change delegation or transfer ownership. Add it to a store
+ * to issue the token; replace the store's delegated set to revoke it. Returns a `DelegatedPuzzle`
+ * (`{ writerInnerPuzzleHash }`).
+ */
+export function writerDelegatedPuzzleFromKey(synthetic_key: Uint8Array): any;

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, buildDigPayment, dataStoreFromSpend, digCatPuzzleHash, digTreasuryInnerPuzzleHash, digstoreOwnerHint, hexSpendBundleToCoinSpends, init, meltStore, mintStore, oracleSpend, spendBundleToHex, updateStoreMetadata, updateStoreOwnership
+    addFee, adminDelegatedPuzzleFromKey, buildChip0007Metadata, bulkMint, createDid, dataStoreFromSpend, decodeOffer, digstoreOwnerHint, encodeOffer, generateItemMetadata, hexSpendBundleToCoinSpends, init, issueCat, meltStore, mintNft, mintStore, oracleDelegatedPuzzle, oracleSpend, sha256, spendBundleToHex, updateStoreMetadata, updateStoreOwnership, validateChip0007, writerDelegatedPuzzleFromKey
 } from "./chip35_dl_coin_wasm_bg.js";

package/chip35_dl_coin_wasm_bg.js

@@ -1,4 +1,8 @@
 /**
+ * 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[]`.
  * @param {Uint8Array} spender_synthetic_key
  * @param {any} selected_coins
  * @param {any} assert_coin_ids
@@ -24,36 +28,98 @@ export function addFee(spender_synthetic_key, selected_coins, assert_coin_ids, f
 }
 
 /**
- * Build the (UNSIGNED) DIG CAT coin spends paying `amount` base units of DIG to the treasury
- * (100 DIG = 100000n to mint, 10 DIG = 10000n per update), returning change to the owner. The
- * app concatenates these with the singleton mint/update spends and has the wallet sign the WHOLE
- * bundle in ONE call — the single aggregated signature makes the store creation and the DIG
- * payment atomic (all-or-nothing in the mempool).
- *
- * `owner_synthetic_key` (48 bytes) is the wallet's synthetic public key — the SAME key used for
- * mintStore (the CAT inner puzzle is its standard puzzle). `owner_puzzle_hash` (32) is that key's
- * standard puzzle hash. `parent_spends` are the spends that created the candidate DIG coins (wasm
- * CoinSpend shape), and `child_coin_ids` (Uint8Array[] of 32 bytes) are those coins' ids in the
- * SAME order — each parent spend is parsed to reconstruct its DIG child's lineage proof.
- * `store_id` (32) is the launcher id, carried as a memo. Returns CoinSpend[] (UNSIGNED).
- * @param {Uint8Array} owner_synthetic_key
- * @param {Uint8Array} owner_puzzle_hash
- * @param {any} parent_spends
- * @param {any} child_coin_ids
- * @param {bigint} amount
- * @param {Uint8Array} store_id
+ * 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 }`).
+ * @param {Uint8Array} synthetic_key
+ * @returns {any}
+ */
+export function adminDelegatedPuzzleFromKey(synthetic_key) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(synthetic_key, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.adminDelegatedPuzzleFromKey(retptr, ptr0, len0);
+        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}
+ */
+export function buildChip0007Metadata(metadata) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.buildChip0007Metadata(retptr, addHeapObject(metadata));
+        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 {Uint8Array} recipient_puzzle_hash
  * @returns {any}
  */
-export function buildDigPayment(owner_synthetic_key, owner_puzzle_hash, parent_spends, child_coin_ids, amount, store_id) {
+export function bulkMint(minter_synthetic_key, did, collection, items, recipient_puzzle_hash) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passArray8ToWasm0(owner_synthetic_key, wasm.__wbindgen_export);
+        const ptr0 = passArray8ToWasm0(minter_synthetic_key, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray8ToWasm0(owner_puzzle_hash, wasm.__wbindgen_export);
+        const ptr1 = passArray8ToWasm0(recipient_puzzle_hash, wasm.__wbindgen_export);
         const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passArray8ToWasm0(store_id, wasm.__wbindgen_export);
-        const len2 = WASM_VECTOR_LEN;
-        wasm.buildDigPayment(retptr, ptr0, len0, ptr1, len1, addHeapObject(parent_spends), addHeapObject(child_coin_ids), amount, ptr2, len2);
+        wasm.bulkMint(retptr, ptr0, len0, addHeapObject(did), addHeapObject(collection), addHeapObject(items), 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);
+    }
+}
+
+/**
+ * Create a DID (creator identity) singleton. Returns
+ * `{ coinSpends, launcherId, innerPuzzleHash, didCoin }`.
+ * @param {Uint8Array} minter_synthetic_key
+ * @param {any} selected_coins
+ * @param {bigint} fee
+ * @returns {any}
+ */
+export function createDid(minter_synthetic_key, selected_coins, fee) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(minter_synthetic_key, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.createDid(retptr, ptr0, len0, addHeapObject(selected_coins), 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);
@@ -93,17 +159,41 @@ export function dataStoreFromSpend(coin_spend, prev_delegated_puzzles) {
 }
 
 /**
- * The DIG CAT outer puzzle hash for a 32-byte owner puzzle hash — where the wallet's DIG
- * coins live on-chain. The app uses it to read DIG balance + select DIG coins. 32 bytes.
+ * Decode canonical offer text into its spend bundle `{ coinSpends, aggregatedSignature }`.
+ * @param {string} text
+ * @returns {any}
+ */
+export function decodeOffer(text) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.decodeOffer(retptr, ptr0, len0);
+        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
+ * get_coin_records_by_hint — it MUST match the hint mint_store emits. Returns 32 bytes.
  * @param {Uint8Array} owner_puzzle_hash
  * @returns {Uint8Array}
  */
-export function digCatPuzzleHash(owner_puzzle_hash) {
+export function digstoreOwnerHint(owner_puzzle_hash) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
         const ptr0 = passArray8ToWasm0(owner_puzzle_hash, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
-        wasm.digCatPuzzleHash(retptr, ptr0, len0);
+        wasm.digstoreOwnerHint(retptr, ptr0, len0);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -120,53 +210,62 @@ export function digCatPuzzleHash(owner_puzzle_hash) {
 }
 
 /**
- * The DIG treasury inner (standard) puzzle hash — the fixed recipient of every DIG payment.
- * Returned so the app can pin it as a golden constant. 32 bytes.
- * @returns {Uint8Array}
+ * Encode a spend bundle (`{coinSpends, aggregatedSignature}`) into canonical offer text.
+ * @param {any} spend_bundle
+ * @returns {string}
  */
-export function digTreasuryInnerPuzzleHash() {
+export function encodeOffer(spend_bundle) {
+    let deferred2_0;
+    let deferred2_1;
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.digTreasuryInnerPuzzleHash(retptr);
+        wasm.encodeOffer(retptr, addHeapObject(spend_bundle));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        var v1 = getArrayU8FromWasm0(r0, r1).slice();
-        wasm.__wbindgen_export4(r0, r1 * 1, 1);
-        return v1;
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr1 = r0;
+        var len1 = r1;
+        if (r3) {
+            ptr1 = 0; len1 = 0;
+            throw takeObject(r2);
+        }
+        deferred2_0 = ptr1;
+        deferred2_1 = len1;
+        return getStringFromWasm0(ptr1, len1);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
     }
 }
 
 /**
- * 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
- * get_coin_records_by_hint — it MUST match the hint mint_store emits. Returns 32 bytes.
- * @param {Uint8Array} owner_puzzle_hash
- * @returns {Uint8Array}
+ * 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}
  */
-export function digstoreOwnerHint(owner_puzzle_hash) {
+export function generateItemMetadata(collection, items) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passArray8ToWasm0(owner_puzzle_hash, wasm.__wbindgen_export);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.digstoreOwnerHint(retptr, ptr0, len0);
+        wasm.generateItemMetadata(retptr, addHeapObject(collection), addHeapObject(items));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-        if (r3) {
-            throw takeObject(r2);
+        if (r2) {
+            throw takeObject(r1);
         }
-        var v2 = getArrayU8FromWasm0(r0, r1).slice();
-        wasm.__wbindgen_export4(r0, r1 * 1, 1);
-        return v2;
+        return takeObject(r0);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
 
 /**
+ * Decode a hex-encoded spend bundle into its `CoinSpend[]` (see
+ * [`chip35_dl_coin::hex_spend_bundle_to_coin_spends`]).
  * @param {string} hex
  * @returns {any}
  */
@@ -197,6 +296,34 @@ export function init() {
 }
 
 /**
+ * Issue a single-issuance (fixed-supply) CAT. Returns `{ coinSpends, assetId, catCoins }`.
+ * @param {Uint8Array} issuer_synthetic_key
+ * @param {any} selected_coins
+ * @param {bigint} amount
+ * @param {bigint} fee
+ * @returns {any}
+ */
+export function issueCat(issuer_synthetic_key, selected_coins, amount, fee) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(issuer_synthetic_key, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.issueCat(retptr, ptr0, len0, addHeapObject(selected_coins), amount, 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);
+    }
+}
+
+/**
+ * Burn (melt) a store singleton (see [`chip35_dl_coin::melt_store`]). Owner-authorized only.
+ * Returns the melt `CoinSpend[]`.
  * @param {any} store
  * @param {Uint8Array} owner_public_key
  * @returns {any}
@@ -220,6 +347,37 @@ export function meltStore(store, owner_public_key) {
 }
 
 /**
+ * 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 }`.
+ * @param {Uint8Array} minter_synthetic_key
+ * @param {any} selected_coins
+ * @param {any} params
+ * @param {bigint} fee
+ * @returns {any}
+ */
+export function mintNft(minter_synthetic_key, selected_coins, params, fee) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(minter_synthetic_key, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.mintNft(retptr, ptr0, len0, addHeapObject(selected_coins), addHeapObject(params), 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);
+    }
+}
+
+/**
+ * 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`).
  * @param {Uint8Array} minter_synthetic_key
  * @param {any} selected_coins
  * @param {Uint8Array} root_hash
@@ -261,6 +419,34 @@ export function mintStore(minter_synthetic_key, selected_coins, root_hash, label
 }
 
 /**
+ * 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 }`).
+ * @param {Uint8Array} oracle_puzzle_hash
+ * @param {bigint} oracle_fee
+ * @returns {any}
+ */
+export function oracleDelegatedPuzzle(oracle_puzzle_hash, oracle_fee) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(oracle_puzzle_hash, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.oracleDelegatedPuzzle(retptr, ptr0, len0, oracle_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);
+    }
+}
+
+/**
+ * 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
@@ -286,6 +472,30 @@ export function oracleSpend(spender_synthetic_key, selected_coins, store, fee) {
 }
 
 /**
+ * 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`).
+ * @param {Uint8Array} bytes
+ * @returns {Uint8Array}
+ */
+export function sha256(bytes) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.sha256(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);
+    }
+}
+
+/**
+ * Serialize a spend bundle (`{coinSpends, aggregatedSignature}`) to its hex wire encoding
+ * (see [`chip35_dl_coin::spend_bundle_to_hex`]).
  * @param {any} spend_bundle
  * @returns {string}
  */
@@ -315,6 +525,9 @@ 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 {Uint8Array} new_root_hash
  * @param {string | null} [new_label]
@@ -357,6 +570,10 @@ export function updateStoreMetadata(store, new_root_hash, new_label, new_descrip
 }
 
 /**
+ * Transfer ownership and/or replace the delegated-puzzle set (see
+ * [`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 {Uint8Array | null | undefined} new_owner_puzzle_hash
  * @param {any} new_delegated_puzzles
@@ -385,6 +602,58 @@ export function updateStoreOwnership(store, new_owner_puzzle_hash, new_delegated
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
+
+/**
+ * Validate a CHIP-0007 document's schema, and (when the actual bytes are provided) that each
+ * 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}
+ */
+export function validateChip0007(metadata, assets) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.validateChip0007(retptr, addHeapObject(metadata), addHeapObject(assets));
+        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 **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)
+ * WITHOUT the owner seed, but may NOT change delegation or transfer ownership. Add it to a store
+ * to issue the token; replace the store's delegated set to revoke it. Returns a `DelegatedPuzzle`
+ * (`{ writerInnerPuzzleHash }`).
+ * @param {Uint8Array} synthetic_key
+ * @returns {any}
+ */
+export function writerDelegatedPuzzleFromKey(synthetic_key) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(synthetic_key, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.writerDelegatedPuzzleFromKey(retptr, ptr0, len0);
+        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);
+    }
+}
 export function __wbg_Error_ef53bc310eb298a0(arg0, arg1) {
     const ret = Error(getStringFromWasm0(arg0, arg1));
     return addHeapObject(ret);
@@ -430,15 +699,15 @@ export function __wbg___wbindgen_is_function_754e9f305ff6029e(arg0) {
     const ret = typeof(getObject(arg0)) === 'function';
     return ret;
 }
+export function __wbg___wbindgen_is_null_87c3bfe968c6a5ad(arg0) {
+    const ret = getObject(arg0) === null;
+    return ret;
+}
 export function __wbg___wbindgen_is_object_56732c2bc353f41d(arg0) {
     const val = getObject(arg0);
     const ret = typeof(val) === 'object' && val !== null;
     return ret;
 }
-export function __wbg___wbindgen_is_string_c236cabd84a4d769(arg0) {
-    const ret = typeof(getObject(arg0)) === 'string';
-    return ret;
-}
 export function __wbg___wbindgen_is_undefined_67b456be8673d3d7(arg0) {
     const ret = getObject(arg0) === undefined;
     return ret;
@@ -472,14 +741,6 @@ export function __wbg_call_8a89609d89f6608a() { return handleError(function (arg
     const ret = getObject(arg0).call(getObject(arg1));
     return addHeapObject(ret);
 }, arguments); }
-export function __wbg_call_9c758de292015997() { return handleError(function (arg0, arg1, arg2) {
-    const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
-    return addHeapObject(ret);
-}, arguments); }
-export function __wbg_crypto_38df2bab126b63dc(arg0) {
-    const ret = getObject(arg0).crypto;
-    return addHeapObject(ret);
-}
 export function __wbg_done_60cf307fcc680536(arg0) {
     const ret = getObject(arg0).done;
     return ret;
@@ -499,9 +760,6 @@ export function __wbg_from_d300fe49deab18f5(arg0) {
     const ret = Array.from(getObject(arg0));
     return addHeapObject(ret);
 }
-export function __wbg_getRandomValues_c44a50d8cfdaebeb() { return handleError(function (arg0, arg1) {
-    getObject(arg0).getRandomValues(getObject(arg1));
-}, arguments); }
 export function __wbg_get_1f8f054ddbaa7db2() { return handleError(function (arg0, arg1) {
     const ret = Reflect.get(getObject(arg0), getObject(arg1));
     return addHeapObject(ret);
@@ -554,10 +812,6 @@ export function __wbg_length_66f1a4b2e9026940(arg0) {
     const ret = getObject(arg0).length;
     return ret;
 }
-export function __wbg_msCrypto_bd5a034af96bcba6(arg0) {
-    const ret = getObject(arg0).msCrypto;
-    return addHeapObject(ret);
-}
 export function __wbg_new_227d7c05414eb861() {
     const ret = new Error();
     return addHeapObject(ret);
@@ -574,10 +828,6 @@ export function __wbg_new_d90091b82fdf5b91() {
     const ret = new Array();
     return addHeapObject(ret);
 }
-export function __wbg_new_with_length_36a4998e27b014c5(arg0) {
-    const ret = new Uint8Array(arg0 >>> 0);
-    return addHeapObject(ret);
-}
 export function __wbg_next_9e03acdf51c4960d(arg0) {
     const ret = getObject(arg0).next;
     return addHeapObject(ret);
@@ -586,24 +836,9 @@ export function __wbg_next_eb8ca7351fa27906() { return handleError(function (arg
     const ret = getObject(arg0).next();
     return addHeapObject(ret);
 }, arguments); }
-export function __wbg_node_84ea875411254db1(arg0) {
-    const ret = getObject(arg0).node;
-    return addHeapObject(ret);
-}
-export function __wbg_process_44c7a14e11e9f69e(arg0) {
-    const ret = getObject(arg0).process;
-    return addHeapObject(ret);
-}
 export function __wbg_prototypesetcall_3249fc62a0fafa30(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
 }
-export function __wbg_randomFillSync_6c25eac9869eb53c() { return handleError(function (arg0, arg1) {
-    getObject(arg0).randomFillSync(takeObject(arg1));
-}, arguments); }
-export function __wbg_require_b4edbdcf3e2a1ef0() { return handleError(function () {
-    const ret = module.require;
-    return addHeapObject(ret);
-}, arguments); }
 export function __wbg_set_6be42768c690e380(arg0, arg1, arg2) {
     getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
 }
@@ -617,34 +852,10 @@ export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg_static_accessor_GLOBAL_9d53f2689e622ca1() {
-    const ret = typeof global === 'undefined' ? null : global;
-    return isLikeNone(ret) ? 0 : addHeapObject(ret);
-}
-export function __wbg_static_accessor_GLOBAL_THIS_a1a35cec07001a8a() {
-    const ret = typeof globalThis === 'undefined' ? null : globalThis;
-    return isLikeNone(ret) ? 0 : addHeapObject(ret);
-}
-export function __wbg_static_accessor_SELF_4c59f6c7ea29a144() {
-    const ret = typeof self === 'undefined' ? null : self;
-    return isLikeNone(ret) ? 0 : addHeapObject(ret);
-}
-export function __wbg_static_accessor_WINDOW_e70ae9f2eb052253() {
-    const ret = typeof window === 'undefined' ? null : window;
-    return isLikeNone(ret) ? 0 : addHeapObject(ret);
-}
-export function __wbg_subarray_4aa221f6a4f5ab22(arg0, arg1, arg2) {
-    const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
-    return addHeapObject(ret);
-}
 export function __wbg_value_f3625092ee4b37f4(arg0) {
     const ret = getObject(arg0).value;
     return addHeapObject(ret);
 }
-export function __wbg_versions_276b2795b1c6a219(arg0) {
-    const ret = getObject(arg0).versions;
-    return addHeapObject(ret);
-}
 export function __wbindgen_cast_0000000000000001(arg0) {
     // Cast intrinsic for `F64 -> Externref`.
     const ret = arg0;

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.4.0",
+  "version": "0.6.0",
   "license": "MIT",
   "repository": {
     "type": "git",