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

package/chip35_dl_coin_wasm.d.ts

@@ -16,6 +16,15 @@ export function addFee(spender_synthetic_key: Uint8Array, selected_coins: any, a
  */
 export function adminDelegatedPuzzleFromKey(synthetic_key: Uint8Array): any;
 
+/**
+ * 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: any, owner_puzzle_hash: Uint8Array, amount: bigint, nonce: 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
@@ -23,6 +32,13 @@ export function adminDelegatedPuzzleFromKey(synthetic_key: Uint8Array): any;
  */
 export function buildChip0007Metadata(metadata: any): any;
 
+/**
+ * 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;
+
 /**
  * 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
@@ -119,6 +135,35 @@ export function oracleDelegatedPuzzle(oracle_puzzle_hash: Uint8Array, oracle_fee
  */
 export function oracleSpend(spender_synthetic_key: Uint8Array, selected_coins: any, store: any, fee: bigint): any;
 
+/**
+ * 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: any, claimed_owner_puzzle_hash: Uint8Array, required_did: Uint8Array): any;
+
+/**
+ * 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: any, claimed_owner_puzzle_hash: Uint8Array, required_nft?: Uint8Array | null): any;
+
+/**
+ * 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;
+
 /**
  * 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`).
@@ -154,6 +199,15 @@ export function updateStoreOwnership(store: any, new_owner_puzzle_hash: Uint8Arr
  */
 export function validateChip0007(metadata: any, assets: any): any;
 
+/**
+ * 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: any, owner_puzzle_hash: Uint8Array, min_amount: bigint, required_asset: any, require_nonce?: Uint8Array | null): 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)

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, 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
 } from "./chip35_dl_coin_wasm_bg.js";

package/chip35_dl_coin_wasm_bg.js

@@ -52,6 +52,41 @@ 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 {any} selected_cats
+ * @param {Uint8Array} owner_puzzle_hash
+ * @param {bigint} amount
+ * @param {Uint8Array} nonce
+ * @returns {any}
+ */
+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
@@ -75,6 +110,40 @@ 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 {any} selected_coins
+ * @param {Uint8Array} owner_puzzle_hash
+ * @param {bigint} amount
+ * @param {Uint8Array} nonce
+ * @param {bigint} fee
+ * @returns {any}
+ */
+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
@@ -471,6 +540,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 {any} parent_spend
+ * @param {Uint8Array} claimed_owner_puzzle_hash
+ * @param {Uint8Array} required_did
+ * @returns {any}
+ */
+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 {any} parent_spend
+ * @param {Uint8Array} claimed_owner_puzzle_hash
+ * @param {Uint8Array | null} [required_nft]
+ * @returns {any}
+ */
+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 {any} parent_spend
+ * @returns {any}
+ */
+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`).
@@ -628,6 +802,39 @@ 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 {any} observed
+ * @param {Uint8Array} owner_puzzle_hash
+ * @param {bigint} min_amount
+ * @param {any} required_asset
+ * @param {Uint8Array | null} [require_nonce]
+ * @returns {any}
+ */
+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);
+    }
+}
+
 /**
  * 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)

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.7.0",
   "license": "MIT",
   "repository": {
     "type": "git",