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

package/chip35_dl_coin_wasm.d.ts

@@ -3,6 +3,22 @@
 
 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).
+ */
+export function buildDigPayment(owner_synthetic_key: Uint8Array, owner_puzzle_hash: Uint8Array, parent_spends: any, child_coin_ids: any, amount: bigint, store_id: Uint8Array): any;
+
 /**
  * Reconstruct a DataStore from the coin spend that created its current coin (the launcher
  * spend for an eve store). Lets the app MELT a store it did not mint in-session: fetch the
@@ -12,6 +28,18 @@ export function addFee(spender_synthetic_key: Uint8Array, selected_coins: any, a
  */
 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.
+ */
+export function digTreasuryInnerPuzzleHash(): Uint8Array;
+
 /**
  * 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

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, dataStoreFromSpend, digstoreOwnerHint, hexSpendBundleToCoinSpends, init, meltStore, mintStore, oracleSpend, spendBundleToHex, updateStoreMetadata, updateStoreOwnership
+    addFee, buildDigPayment, dataStoreFromSpend, digCatPuzzleHash, digTreasuryInnerPuzzleHash, digstoreOwnerHint, hexSpendBundleToCoinSpends, init, meltStore, mintStore, oracleSpend, spendBundleToHex, updateStoreMetadata, updateStoreOwnership
 } from "./chip35_dl_coin_wasm_bg.js";

package/chip35_dl_coin_wasm_bg.js

@@ -23,6 +23,49 @@ 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
+ * @returns {any}
+ */
+export function buildDigPayment(owner_synthetic_key, owner_puzzle_hash, parent_spends, child_coin_ids, amount, store_id) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(owner_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(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);
+        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);
+    }
+}
+
 /**
  * Reconstruct a DataStore from the coin spend that created its current coin (the launcher
  * spend for an eve store). Lets the app MELT a store it did not mint in-session: fetch the
@@ -49,6 +92,52 @@ 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.
+ * @param {Uint8Array} owner_puzzle_hash
+ * @returns {Uint8Array}
+ */
+export function digCatPuzzleHash(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);
+        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);
+        }
+        var v2 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * 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}
+ */
+export function digTreasuryInnerPuzzleHash() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.digTreasuryInnerPuzzleHash(retptr);
+        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;
+    } 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
@@ -346,6 +435,10 @@ export function __wbg___wbindgen_is_object_56732c2bc353f41d(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;
@@ -379,6 +472,14 @@ 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;
@@ -398,6 +499,9 @@ 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);
@@ -450,6 +554,10 @@ 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);
@@ -466,6 +574,10 @@ 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);
@@ -474,9 +586,24 @@ 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);
 }
@@ -490,10 +617,34 @@ 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,11 +2,8 @@
   "name": "@dignetwork/chip35-dl-coin-wasm",
   "type": "module",
   "description": "WebAssembly bindings for the isolated CHIP-0035 DataLayer store coin driver.",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
   "repository": {
     "type": "git",
     "url": "https://github.com/DIG-Network/chip35_dl_coin"
@@ -22,5 +19,8 @@
   "sideEffects": [
     "./chip35_dl_coin_wasm.js",
     "./snippets/*"
-  ]
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
 }