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

package/chip35_dl_coin_wasm.d.ts

@@ -9,6 +9,22 @@
  */
 export function addFee(spender_synthetic_key: Uint8Array, selected_coins: any, assert_coin_ids: any, fee: bigint): any;
 
+/**
+ * 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;
+
+/**
+ * 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
@@ -16,6 +32,13 @@ export function addFee(spender_synthetic_key: Uint8Array, selected_coins: any, a
  */
 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
@@ -99,12 +122,48 @@ export function mintNft(minter_synthetic_key: Uint8Array, selected_coins: any, p
  */
 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-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`).
@@ -139,3 +198,21 @@ export function updateStoreOwnership(store: any, new_owner_puzzle_hash: Uint8Arr
  * `Uint8Array`). Returns `{ ok: bool, errors: string[] }`.
  */
 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)
+ * 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, buildChip0007Metadata, bulkMint, createDid, dataStoreFromSpend, decodeOffer, digstoreOwnerHint, encodeOffer, generateItemMetadata, hexSpendBundleToCoinSpends, init, issueCat, meltStore, mintNft, mintStore, oracleSpend, sha256, spendBundleToHex, updateStoreMetadata, updateStoreOwnership, validateChip0007
+    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

@@ -27,6 +27,66 @@ export function addFee(spender_synthetic_key, selected_coins, assert_coin_ids, f
     }
 }
 
+/**
+ * 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 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
@@ -50,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
@@ -393,6 +487,32 @@ 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`.
@@ -420,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`).
@@ -576,6 +801,66 @@ export function validateChip0007(metadata, assets) {
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
+
+/**
+ * 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)
+ * 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);

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