@chironbuilder/ootle-sdk 0.1.10 → 0.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chironbuilder/ootle-sdk",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Shared TypeScript client for Tari Ootle (L2): account derivation, balances, transactions, HTLCs, and stealth/confidential transfers — the account core behind Sapient and the Tari L1 web wallet's Ootle support.",
   "type": "module",
   "license": "MIT",

package/vendor/ootle-patched/package.json

@@ -18,6 +18,6 @@
   },
   "dependencies": {
     "@tari-project/ootle-ts-bindings": "^1.49.1",
-    "@tari-project/ootle-wasm": "^0.39.1"
+    "@tari-project/ootle-wasm": "^0.41.0"
   }
 }

package/vendor/ootle-wasm-patched/README.md

@@ -1,128 +1,97 @@
 # ootle-wasm
 
-Client-side WebAssembly crypto for [Tari Ootle](https://www.tari.com/) L2. Handles BOR encoding, transaction hashing, Schnorr signing, and key management — with output byte-identical to the native Rust implementation.
+Rust → WASM library providing client-side crypto operations for Tari Ootle L2.
 
-## Installation
+## Architecture
 
-```bash
-npm install @tari-project/ootle-wasm
-```
-
-## API
-
-All keys and signatures are **`Uint8Array`** (raw 32-byte values).
-
-### `generateKeypair()`
+- `core/` — Pure Rust library. All crypto/encoding logic lives here. Testable natively with `cargo test`.
+- `wasm/` — Thin `wasm-bindgen` shell. Accepts JSON strings, calls core, returns results.
 
-Generate a new random Ristretto255 keypair.
+## Prerequisites
 
-```typescript
-import { generateKeypair } from "@tari-project/ootle-wasm";
-
-const { secret_key, public_key } = generateKeypair();
-// secret_key: Uint8Array (32 bytes)
-// public_key: Uint8Array (32 bytes)
+```bash
+# Install wasm-pack
+cargo install wasm-pack
+
+# (Optional) Install wasm-opt for size optimisation
+# macOS:
+brew install binaryen
+# or via cargo:
+cargo install wasm-opt
 ```
 
-### `publicKeyFromSecretKey(secretKey)`
+## Build
 
-Derive the public key from a secret key.
+### Native (tests only)
 
-```typescript
-import { publicKeyFromSecretKey } from "@tari-project/ootle-wasm";
-
-const publicKey = publicKeyFromSecretKey(secretKey);
-// publicKey: Uint8Array (32 bytes)
+```bash
+cargo test -p ootle-wasm-core
 ```
 
-### `hashUnsignedTransaction(unsignedTxJson, sealSignerPublicKey)`
+### WASM
 
-Hash an `UnsignedTransactionV1` for signing. Returns a 64-byte `Uint8Array` that should be passed to `schnorrSign`.
+```bash
+# Build for bundler (webpack, vite, rollup, esbuild)
+wasm-pack build crates/ootle_wasm/wasm --target bundler --release --out-dir ../../../pkg
 
-- `unsignedTxJson` — JSON-serialised `UnsignedTransactionV1`
-- `sealSignerPublicKey` — raw public key bytes of the account owner (seal signer)
+# Build for Node.js
+wasm-pack build crates/ootle_wasm/wasm --target nodejs --release --out-dir ../../../pkg
 
-```typescript
-import { hashUnsignedTransaction } from "@tari-project/ootle-wasm";
-
-const hash = hashUnsignedTransaction(
-  JSON.stringify(unsignedTransaction),
-  sealSignerPublicKey,
-);
+# Build for web (no bundler)
+wasm-pack build crates/ootle_wasm/wasm --target web --release --out-dir ../../../pkg
 ```
 
-### `schnorrSign(secretKey, message)`
+The output goes to `pkg/` at the repo root containing:
 
-Schnorr-sign a message (typically the hash from `hashUnsignedTransaction`).
+- `ootle_wasm_bg.wasm` — the WASM binary
+- `ootle_wasm.js` — JS glue code
+- `ootle_wasm.d.ts` — TypeScript type definitions
 
-```typescript
-import { schnorrSign } from "@tari-project/ootle-wasm";
+### Size optimisation (optional)
 
-const { public_nonce, signature } = schnorrSign(secretKey, hash);
-// public_nonce: Uint8Array (32 bytes)
-// signature:    Uint8Array (32 bytes)
+```bash
+wasm-opt -Oz --strip-debug --strip-producers pkg/ootle_wasm_bg.wasm -o pkg/ootle_wasm_bg.wasm
 ```
 
-### `borEncodeTransaction(transactionJson)`
-
-BOR-encode a signed `Transaction` into a base64 `TransactionEnvelope` string, ready to submit to the network.
+### Debug build (with panic hook)
 
-```typescript
-import { borEncodeTransaction } from "@tari-project/ootle-wasm";
-
-const envelope = borEncodeTransaction(JSON.stringify(transaction));
+```bash
+wasm-pack build crates/ootle_wasm/wasm --target bundler --dev --out-dir ../../../pkg -- --features debug
 ```
 
-## Working with keys
+## WASM Exports
 
-Keys and signatures are raw `Uint8Array` bytes. Convert to and from hex strings using the built-in methods (Node 22+, modern browsers):
+| Function                  | Signature                                                                   | Description                                         |
+|---------------------------|-----------------------------------------------------------------------------|-----------------------------------------------------|
+| `borEncodeTransaction`    | `(transactionJson: string) → string`                                        | BOR-encode a Transaction JSON → base64 envelope     |
+| `hashUnsignedTransaction` | `(unsignedTxJson: string, sealSignerPubKeyHex: string) → Uint8Array`        | Hash an unsigned transaction for signing (64 bytes) |
+| `schnorrSign`             | `(secretKeyHex: string, message: Uint8Array) → { public_nonce, signature }` | Schnorr-sign a message                              |
+| `generateKeypair`         | `() → { secret_key, public_key }`                                           | Generate a random Ristretto keypair                 |
+| `publicKeyFromSecretKey`  | `(secretKeyHex: string) → string`                                           | Derive public key from secret key                   |
 
-```typescript
-import { generateKeypair, publicKeyFromSecretKey } from "@tari-project/ootle-wasm";
+All keys and signatures are lowercase hex-encoded strings.
 
-// Generate a keypair and display as hex
-const { secret_key, public_key } = generateKeypair();
-console.log("Public key:", public_key.toHex());
-
-// Load a key from a hex string
-const restored = Uint8Array.fromHex("a1b2c3...");
-const derivedPublicKey = publicKeyFromSecretKey(restored);
-```
-
-## Full example
+## Usage from JS/TS
 
 ```typescript
-import {
+import init, {
   generateKeypair,
-  publicKeyFromSecretKey,
-  hashUnsignedTransaction,
   schnorrSign,
+  hashUnsignedTransaction,
   borEncodeTransaction,
-} from "@tari-project/ootle-wasm";
+  publicKeyFromSecretKey,
+} from './pkg/ootle_wasm.js';
 
-// 1. Generate or load a keypair
-const { secret_key, public_key } = generateKeypair();
+// Initialise the WASM module
+await init();
 
-// 2. Build an unsigned transaction (application-specific)
-const unsignedTx = {
-  /* ... UnsignedTransactionV1 fields ... */
-};
+// Generate a keypair
+const { secret_key, public_key } = generateKeypair();
 
-// 3. Hash for signing
-const hash = hashUnsignedTransaction(JSON.stringify(unsignedTx), public_key);
+// Hash an unsigned transaction for signing
+const unsignedTxJson = JSON.stringify(unsignedTransaction);
+const hash = hashUnsignedTransaction(unsignedTxJson, sealSignerPublicKeyHex);
 
-// 4. Sign
+// Sign the hash
 const { public_nonce, signature } = schnorrSign(secret_key, hash);
-
-// 5. Assemble the signed transaction and BOR-encode
-const signedTx = {
-  /* ... Transaction with signature attached ... */
-};
-const envelope = borEncodeTransaction(JSON.stringify(signedTx));
-
-// 6. Submit envelope to the Ootle network
 ```
-
-## License
-
-BSD-3-Clause

package/vendor/ootle-wasm-patched/ootle_wasm.js

@@ -1,7 +1,7 @@
 /* @ts-self-types="./ootle_wasm.d.ts" */
-
 import * as wasm from "./ootle_wasm_bg.wasm";
 import { __wbg_set_wasm } from "./ootle_wasm_bg.js";
+
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {

package/vendor/ootle-wasm-patched/ootle_wasm_bg.js

@@ -3,7 +3,6 @@
  */
 export class DecryptedOutputResult {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(DecryptedOutputResult.prototype);
         obj.__wbg_ptr = ptr;
         DecryptedOutputResultFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -38,7 +37,7 @@ export class DecryptedOutputResult {
         const ret = wasm.__wbg_get_decryptedoutputresult_memo_json(this.__wbg_ptr);
         let v1;
         if (ret[0] !== 0) {
-            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            v1 = getStringFromWasm0(ret[0], ret[1]);
             wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         }
         return v1;
@@ -85,7 +84,6 @@ if (Symbol.dispose) DecryptedOutputResult.prototype[Symbol.dispose] = DecryptedO
  */
 export class KeypairResult {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(KeypairResult.prototype);
         obj.__wbg_ptr = ptr;
         KeypairResultFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -143,7 +141,6 @@ if (Symbol.dispose) KeypairResult.prototype[Symbol.dispose] = KeypairResult.prot
  */
 export class OotlePublicKey {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(OotlePublicKey.prototype);
         obj.__wbg_ptr = ptr;
         OotlePublicKeyFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -186,7 +183,7 @@ export class OotlePublicKey {
     set owner_key(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_keypairresult_secret_key(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_ootlepublickey_owner_key(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * The view-only public key bytes.
@@ -195,7 +192,7 @@ export class OotlePublicKey {
     set view_key(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_keypairresult_public_key(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_ootlepublickey_view_key(this.__wbg_ptr, ptr0, len0);
     }
 }
 if (Symbol.dispose) OotlePublicKey.prototype[Symbol.dispose] = OotlePublicKey.prototype.free;
@@ -205,7 +202,6 @@ if (Symbol.dispose) OotlePublicKey.prototype[Symbol.dispose] = OotlePublicKey.pr
  */
 export class OotleSecretKey {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(OotleSecretKey.prototype);
         obj.__wbg_ptr = ptr;
         OotleSecretKeyFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -248,7 +244,7 @@ export class OotleSecretKey {
     set owner_key(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_keypairresult_secret_key(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_ootlesecretkey_owner_key(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * The view-only secret key bytes.
@@ -257,7 +253,7 @@ export class OotleSecretKey {
     set view_key(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_keypairresult_public_key(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_ootlesecretkey_view_key(this.__wbg_ptr, ptr0, len0);
     }
 }
 if (Symbol.dispose) OotleSecretKey.prototype[Symbol.dispose] = OotleSecretKey.prototype.free;
@@ -267,7 +263,6 @@ if (Symbol.dispose) OotleSecretKey.prototype[Symbol.dispose] = OotleSecretKey.pr
  */
 export class ParsedOotleAddress {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(ParsedOotleAddress.prototype);
         obj.__wbg_ptr = ptr;
         ParsedOotleAddressFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -347,7 +342,7 @@ export class ParsedOotleAddress {
     set owner_key(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_keypairresult_secret_key(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_parsedootleaddress_owner_key(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * The view-only public key bytes.
@@ -356,7 +351,7 @@ export class ParsedOotleAddress {
     set view_key(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_keypairresult_public_key(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_parsedootleaddress_view_key(this.__wbg_ptr, ptr0, len0);
     }
 }
 if (Symbol.dispose) ParsedOotleAddress.prototype[Symbol.dispose] = ParsedOotleAddress.prototype.free;
@@ -367,7 +362,6 @@ if (Symbol.dispose) ParsedOotleAddress.prototype[Symbol.dispose] = ParsedOotleAd
  */
 export class SchnorrSignatureResult {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(SchnorrSignatureResult.prototype);
         obj.__wbg_ptr = ptr;
         SchnorrSignatureResultFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -407,7 +401,7 @@ export class SchnorrSignatureResult {
     set public_nonce(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_keypairresult_secret_key(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_schnorrsignatureresult_public_nonce(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * @param {Uint8Array} arg0
@@ -415,7 +409,7 @@ export class SchnorrSignatureResult {
     set signature(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_keypairresult_public_key(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_schnorrsignatureresult_signature(this.__wbg_ptr, ptr0, len0);
     }
 }
 if (Symbol.dispose) SchnorrSignatureResult.prototype[Symbol.dispose] = SchnorrSignatureResult.prototype.free;
@@ -425,7 +419,6 @@ if (Symbol.dispose) SchnorrSignatureResult.prototype[Symbol.dispose] = SchnorrSi
  */
 export class StealthOutputsResult {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(StealthOutputsResult.prototype);
         obj.__wbg_ptr = ptr;
         StealthOutputsResultFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -476,7 +469,7 @@ export class StealthOutputsResult {
     set aggregated_output_mask(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_keypairresult_public_key(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_stealthoutputsresult_aggregated_output_mask(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * JSON-serialized `StealthOutputsStatement` (the wire-format payload).
@@ -485,7 +478,7 @@ export class StealthOutputsResult {
     set statement_json(arg0) {
         const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_keypairresult_secret_key(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_stealthoutputsresult_statement_json(this.__wbg_ptr, ptr0, len0);
     }
 }
 if (Symbol.dispose) StealthOutputsResult.prototype[Symbol.dispose] = StealthOutputsResult.prototype.free;
@@ -1321,14 +1314,14 @@ export function validateStealthTransfer(transfer_json, view_key) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
-export function __wbg_Error_8c4e43fe74559d73(arg0, arg1) {
+export function __wbg_Error_67e7344beaa85059(arg0, arg1) {
     const ret = Error(getStringFromWasm0(arg0, arg1));
     return ret;
 }
-export function __wbg___wbindgen_throw_be289d5034ed271b(arg0, arg1) {
+export function __wbg___wbindgen_throw_5d9e815e6fdf150f(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }
-export function __wbg_getRandomValues_e9de607763a970bd() { return handleError(function (arg0, arg1) {
+export function __wbg_getRandomValues_47873ea553f6780e() { return handleError(function (arg0, arg1) {
     globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
 }, arguments); }
 export function __wbindgen_init_externref_table() {
@@ -1342,25 +1335,25 @@ export function __wbindgen_init_externref_table() {
 }
 const DecryptedOutputResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_decryptedoutputresult_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_decryptedoutputresult_free(ptr, 1));
 const KeypairResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_keypairresult_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_keypairresult_free(ptr, 1));
 const OotlePublicKeyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_ootlepublickey_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_ootlepublickey_free(ptr, 1));
 const OotleSecretKeyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_ootlesecretkey_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_ootlesecretkey_free(ptr, 1));
 const ParsedOotleAddressFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_parsedootleaddress_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_parsedootleaddress_free(ptr, 1));
 const SchnorrSignatureResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_schnorrsignatureresult_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_schnorrsignatureresult_free(ptr, 1));
 const StealthOutputsResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_stealthoutputsresult_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_stealthoutputsresult_free(ptr, 1));
 
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();
@@ -1374,8 +1367,7 @@ function getArrayU8FromWasm0(ptr, len) {
 }
 
 function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return decodeText(ptr, len);
+    return decodeText(ptr >>> 0, len);
 }
 
 let cachedUint8ArrayMemory0 = null;

package/vendor/ootle-wasm-patched/ootle_wasm_bg.wasm.d.ts

@@ -5,9 +5,19 @@ export const __wbg_decryptedoutputresult_free: (a: number, b: number) => void;
 export const __wbg_get_decryptedoutputresult_mask: (a: number) => [number, number];
 export const __wbg_get_decryptedoutputresult_memo_json: (a: number) => [number, number];
 export const __wbg_get_decryptedoutputresult_value: (a: number) => bigint;
+export const __wbg_get_keypairresult_public_key: (a: number) => [number, number];
 export const __wbg_get_keypairresult_secret_key: (a: number) => [number, number];
+export const __wbg_get_ootlepublickey_owner_key: (a: number) => [number, number];
+export const __wbg_get_ootlepublickey_view_key: (a: number) => [number, number];
+export const __wbg_get_ootlesecretkey_owner_key: (a: number) => [number, number];
+export const __wbg_get_ootlesecretkey_view_key: (a: number) => [number, number];
 export const __wbg_get_parsedootleaddress_memo: (a: number) => [number, number];
 export const __wbg_get_parsedootleaddress_network: (a: number) => number;
+export const __wbg_get_parsedootleaddress_owner_key: (a: number) => [number, number];
+export const __wbg_get_parsedootleaddress_view_key: (a: number) => [number, number];
+export const __wbg_get_schnorrsignatureresult_public_nonce: (a: number) => [number, number];
+export const __wbg_get_schnorrsignatureresult_signature: (a: number) => [number, number];
+export const __wbg_get_stealthoutputsresult_aggregated_output_mask: (a: number) => [number, number];
 export const __wbg_get_stealthoutputsresult_statement_json: (a: number) => [number, number];
 export const __wbg_keypairresult_free: (a: number, b: number) => void;
 export const __wbg_ootlepublickey_free: (a: number, b: number) => void;
@@ -19,8 +29,18 @@ export const __wbg_set_decryptedoutputresult_memo_json: (a: number, b: number, c
 export const __wbg_set_decryptedoutputresult_value: (a: number, b: bigint) => void;
 export const __wbg_set_keypairresult_public_key: (a: number, b: number, c: number) => void;
 export const __wbg_set_keypairresult_secret_key: (a: number, b: number, c: number) => void;
+export const __wbg_set_ootlepublickey_owner_key: (a: number, b: number, c: number) => void;
+export const __wbg_set_ootlepublickey_view_key: (a: number, b: number, c: number) => void;
+export const __wbg_set_ootlesecretkey_owner_key: (a: number, b: number, c: number) => void;
+export const __wbg_set_ootlesecretkey_view_key: (a: number, b: number, c: number) => void;
 export const __wbg_set_parsedootleaddress_memo: (a: number, b: number, c: number) => void;
 export const __wbg_set_parsedootleaddress_network: (a: number, b: number) => void;
+export const __wbg_set_parsedootleaddress_owner_key: (a: number, b: number, c: number) => void;
+export const __wbg_set_parsedootleaddress_view_key: (a: number, b: number, c: number) => void;
+export const __wbg_set_schnorrsignatureresult_public_nonce: (a: number, b: number, c: number) => void;
+export const __wbg_set_schnorrsignatureresult_signature: (a: number, b: number, c: number) => void;
+export const __wbg_set_stealthoutputsresult_aggregated_output_mask: (a: number, b: number, c: number) => void;
+export const __wbg_set_stealthoutputsresult_statement_json: (a: number, b: number, c: number) => void;
 export const __wbg_stealthoutputsresult_free: (a: number, b: number) => void;
 export const addTransactionSigner: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];
 export const aggregateInputMasks: (a: number, b: number) => [number, number, number, number];
@@ -51,26 +71,6 @@ export const stealthDhSecret: (a: number, b: number, c: number, d: number, e: nu
 export const unblindOutput: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
 export const validateBalanceProofSignature: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number];
 export const validateStealthTransfer: (a: number, b: number, c: number, d: number) => [number, number];
-export const __wbg_get_keypairresult_public_key: (a: number) => [number, number];
-export const __wbg_get_ootlepublickey_owner_key: (a: number) => [number, number];
-export const __wbg_get_ootlepublickey_view_key: (a: number) => [number, number];
-export const __wbg_get_ootlesecretkey_owner_key: (a: number) => [number, number];
-export const __wbg_get_ootlesecretkey_view_key: (a: number) => [number, number];
-export const __wbg_get_parsedootleaddress_owner_key: (a: number) => [number, number];
-export const __wbg_get_parsedootleaddress_view_key: (a: number) => [number, number];
-export const __wbg_get_schnorrsignatureresult_public_nonce: (a: number) => [number, number];
-export const __wbg_get_schnorrsignatureresult_signature: (a: number) => [number, number];
-export const __wbg_get_stealthoutputsresult_aggregated_output_mask: (a: number) => [number, number];
-export const __wbg_set_ootlepublickey_owner_key: (a: number, b: number, c: number) => void;
-export const __wbg_set_ootlepublickey_view_key: (a: number, b: number, c: number) => void;
-export const __wbg_set_ootlesecretkey_owner_key: (a: number, b: number, c: number) => void;
-export const __wbg_set_ootlesecretkey_view_key: (a: number, b: number, c: number) => void;
-export const __wbg_set_parsedootleaddress_owner_key: (a: number, b: number, c: number) => void;
-export const __wbg_set_parsedootleaddress_view_key: (a: number, b: number, c: number) => void;
-export const __wbg_set_schnorrsignatureresult_public_nonce: (a: number, b: number, c: number) => void;
-export const __wbg_set_schnorrsignatureresult_signature: (a: number, b: number, c: number) => void;
-export const __wbg_set_stealthoutputsresult_aggregated_output_mask: (a: number, b: number, c: number) => void;
-export const __wbg_set_stealthoutputsresult_statement_json: (a: number, b: number, c: number) => void;
 export const tari_free: (a: number) => void;
 export const tari_alloc: (a: number) => number;
 export const __wbindgen_exn_store: (a: number) => void;

package/vendor/ootle-wasm-patched/package.json

@@ -4,8 +4,8 @@
   "collaborators": [
     "The Tari Development Community"
   ],
-  "description": "WASM bindings for Tari Ootle client-side crypto — thin wasm-bindgen shell over ootle-wasm-core. LOCAL VENDOR PATCH: adds createConfidentialWithdrawProofLiteral, built from tari-dan crates/ootle_wasm at commit 472794e plus the confidential.rs module added on top -- not yet in an upstream release.",
-  "version": "0.39.4",
+  "description": "WASM bindings for Tari Ootle client-side crypto — thin wasm-bindgen shell over ootle-wasm-core. LOCAL VENDOR PATCH: adds createConfidentialWithdrawProofLiteral, built from tari-dan crates/ootle_wasm at commit ac73128 (v0.41.0, esmeralda V1 activation) plus the confidential.rs module added on top -- not yet in an upstream release.",
+  "version": "0.41.0",
   "license": "BSD-3-Clause",
   "repository": {
     "type": "git",
@@ -18,6 +18,9 @@
     "ootle_wasm.d.ts",
     "README.md"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
   "main": "ootle_wasm.js",
   "types": "ootle_wasm.d.ts",
   "sideEffects": [