@tari-project/ootle-wasm 0.2.0 → 0.3.0

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2019, The Tari Developer Community
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/ootle_wasm.d.ts

@@ -12,6 +12,69 @@ export class KeypairResult {
     secret_key: Uint8Array;
 }
 
+/**
+ * A pair of Ootle public keys derived from an OotleSecretKey.
+ */
+export class OotlePublicKey {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The owner (spending) public key bytes.
+     */
+    owner_key: Uint8Array;
+    /**
+     * The view-only public key bytes.
+     */
+    view_key: Uint8Array;
+}
+
+/**
+ * A pair of Ootle secret keys (owner + view).
+ */
+export class OotleSecretKey {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The owner (spending) secret key bytes.
+     */
+    owner_key: Uint8Array;
+    /**
+     * The view-only secret key bytes.
+     */
+    view_key: Uint8Array;
+}
+
+/**
+ * Parsed components of an Ootle address.
+ */
+export class ParsedOotleAddress {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Optional pay reference / memo bytes.
+     */
+    get memo(): Uint8Array | undefined;
+    /**
+     * Optional pay reference / memo bytes.
+     */
+    set memo(value: Uint8Array | null | undefined);
+    /**
+     * The network byte.
+     */
+    network: number;
+    /**
+     * The owner (spending) public key bytes.
+     */
+    owner_key: Uint8Array;
+    /**
+     * The view-only public key bytes.
+     */
+    view_key: Uint8Array;
+}
+
 /**
  * Result of a Schnorr signature operation (raw bytes).
  */
@@ -34,6 +97,20 @@ export function borEncodeTransaction(transaction_json: string): string;
  */
 export function generateKeypair(): KeypairResult;
 
+/**
+ * Generate an Ootle address (bech32m string) from public keys.
+ *
+ * `network` is the network byte (0x00 = MainNet, 0x10 = LocalNet, 0x26 = Esmeralda, etc.).
+ * `memo` is an optional pay reference (max 64 bytes).
+ */
+export function generateOotleAddress(owner_public_key: Uint8Array, view_public_key: Uint8Array, network: number, memo?: Uint8Array | null): string;
+
+/**
+ * Generate a new random pair of Ootle secret keys (owner + view).
+ * Returns { owner_key: Uint8Array, view_key: Uint8Array }.
+ */
+export function generateOotleSecretKey(): OotleSecretKey;
+
 /**
  * Hash an UnsignedTransactionV1 (JSON string) for signing.
  * Returns the 64-byte signing message that must be Schnorr-signed.
@@ -47,6 +124,18 @@ export function hashUnsignedTransaction(unsigned_tx_json: string, seal_signer_pu
  */
 export function on_start(): void;
 
+/**
+ * Derive the Ootle public keys from a pair of secret keys.
+ * Returns { owner_key: Uint8Array, view_key: Uint8Array }.
+ */
+export function ootlePublicKeyFromSecretKey(owner_key: Uint8Array, view_key: Uint8Array): OotlePublicKey;
+
+/**
+ * Parse a bech32m Ootle address string into its components.
+ * Returns { owner_key: Uint8Array, view_key: Uint8Array, network: number, memo: Uint8Array | undefined }.
+ */
+export function parseOotleAddress(address: string): ParsedOotleAddress;
+
 /**
  * Derive the public key from a secret key (both raw bytes).
  */

package/ootle_wasm.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./ootle_wasm_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {
-    KeypairResult, SchnorrSignatureResult, borEncodeTransaction, generateKeypair, hashUnsignedTransaction, on_start, publicKeyFromSecretKey, schnorrSign
+    KeypairResult, OotlePublicKey, OotleSecretKey, ParsedOotleAddress, SchnorrSignatureResult, borEncodeTransaction, generateKeypair, generateOotleAddress, generateOotleSecretKey, hashUnsignedTransaction, on_start, ootlePublicKeyFromSecretKey, parseOotleAddress, publicKeyFromSecretKey, schnorrSign
 } from "./ootle_wasm_bg.js";

package/ootle_wasm_bg.js

@@ -56,6 +56,229 @@ export class KeypairResult {
 }
 if (Symbol.dispose) KeypairResult.prototype[Symbol.dispose] = KeypairResult.prototype.free;
 
+/**
+ * A pair of Ootle public keys derived from an OotleSecretKey.
+ */
+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);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OotlePublicKeyFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ootlepublickey_free(ptr, 0);
+    }
+    /**
+     * The owner (spending) public key bytes.
+     * @returns {Uint8Array}
+     */
+    get owner_key() {
+        const ret = wasm.__wbg_get_ootlepublickey_owner_key(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * The view-only public key bytes.
+     * @returns {Uint8Array}
+     */
+    get view_key() {
+        const ret = wasm.__wbg_get_ootlepublickey_view_key(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * The owner (spending) public key bytes.
+     * @param {Uint8Array} arg0
+     */
+    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);
+    }
+    /**
+     * The view-only public key bytes.
+     * @param {Uint8Array} arg0
+     */
+    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);
+    }
+}
+if (Symbol.dispose) OotlePublicKey.prototype[Symbol.dispose] = OotlePublicKey.prototype.free;
+
+/**
+ * A pair of Ootle secret keys (owner + view).
+ */
+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);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OotleSecretKeyFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ootlesecretkey_free(ptr, 0);
+    }
+    /**
+     * The owner (spending) secret key bytes.
+     * @returns {Uint8Array}
+     */
+    get owner_key() {
+        const ret = wasm.__wbg_get_ootlesecretkey_owner_key(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * The view-only secret key bytes.
+     * @returns {Uint8Array}
+     */
+    get view_key() {
+        const ret = wasm.__wbg_get_ootlesecretkey_view_key(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * The owner (spending) secret key bytes.
+     * @param {Uint8Array} arg0
+     */
+    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);
+    }
+    /**
+     * The view-only secret key bytes.
+     * @param {Uint8Array} arg0
+     */
+    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);
+    }
+}
+if (Symbol.dispose) OotleSecretKey.prototype[Symbol.dispose] = OotleSecretKey.prototype.free;
+
+/**
+ * Parsed components of an Ootle address.
+ */
+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);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ParsedOotleAddressFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_parsedootleaddress_free(ptr, 0);
+    }
+    /**
+     * Optional pay reference / memo bytes.
+     * @returns {Uint8Array | undefined}
+     */
+    get memo() {
+        const ret = wasm.__wbg_get_parsedootleaddress_memo(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * The network byte.
+     * @returns {number}
+     */
+    get network() {
+        const ret = wasm.__wbg_get_parsedootleaddress_network(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * The owner (spending) public key bytes.
+     * @returns {Uint8Array}
+     */
+    get owner_key() {
+        const ret = wasm.__wbg_get_parsedootleaddress_owner_key(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * The view-only public key bytes.
+     * @returns {Uint8Array}
+     */
+    get view_key() {
+        const ret = wasm.__wbg_get_parsedootleaddress_view_key(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Optional pay reference / memo bytes.
+     * @param {Uint8Array | null} [arg0]
+     */
+    set memo(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_parsedootleaddress_memo(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * The network byte.
+     * @param {number} arg0
+     */
+    set network(arg0) {
+        wasm.__wbg_set_parsedootleaddress_network(this.__wbg_ptr, arg0);
+    }
+    /**
+     * The owner (spending) public key bytes.
+     * @param {Uint8Array} arg0
+     */
+    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);
+    }
+    /**
+     * The view-only public key bytes.
+     * @param {Uint8Array} arg0
+     */
+    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);
+    }
+}
+if (Symbol.dispose) ParsedOotleAddress.prototype[Symbol.dispose] = ParsedOotleAddress.prototype.free;
+
 /**
  * Result of a Schnorr signature operation (raw bytes).
  */
@@ -150,6 +373,52 @@ export function generateKeypair() {
     return KeypairResult.__wrap(ret);
 }
 
+/**
+ * Generate an Ootle address (bech32m string) from public keys.
+ *
+ * `network` is the network byte (0x00 = MainNet, 0x10 = LocalNet, 0x26 = Esmeralda, etc.).
+ * `memo` is an optional pay reference (max 64 bytes).
+ * @param {Uint8Array} owner_public_key
+ * @param {Uint8Array} view_public_key
+ * @param {number} network
+ * @param {Uint8Array | null} [memo]
+ * @returns {string}
+ */
+export function generateOotleAddress(owner_public_key, view_public_key, network, memo) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const ptr0 = passArray8ToWasm0(owner_public_key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(view_public_key, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(memo) ? 0 : passArray8ToWasm0(memo, wasm.__wbindgen_malloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.generateOotleAddress(ptr0, len0, ptr1, len1, network, ptr2, len2);
+        var ptr4 = ret[0];
+        var len4 = ret[1];
+        if (ret[3]) {
+            ptr4 = 0; len4 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred5_0 = ptr4;
+        deferred5_1 = len4;
+        return getStringFromWasm0(ptr4, len4);
+    } finally {
+        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+    }
+}
+
+/**
+ * Generate a new random pair of Ootle secret keys (owner + view).
+ * Returns { owner_key: Uint8Array, view_key: Uint8Array }.
+ * @returns {OotleSecretKey}
+ */
+export function generateOotleSecretKey() {
+    const ret = wasm.generateOotleSecretKey();
+    return OotleSecretKey.__wrap(ret);
+}
+
 /**
  * Hash an UnsignedTransactionV1 (JSON string) for signing.
  * Returns the 64-byte signing message that must be Schnorr-signed.
@@ -180,6 +449,41 @@ export function on_start() {
     wasm.on_start();
 }
 
+/**
+ * Derive the Ootle public keys from a pair of secret keys.
+ * Returns { owner_key: Uint8Array, view_key: Uint8Array }.
+ * @param {Uint8Array} owner_key
+ * @param {Uint8Array} view_key
+ * @returns {OotlePublicKey}
+ */
+export function ootlePublicKeyFromSecretKey(owner_key, view_key) {
+    const ptr0 = passArray8ToWasm0(owner_key, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(view_key, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.ootlePublicKeyFromSecretKey(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return OotlePublicKey.__wrap(ret[0]);
+}
+
+/**
+ * Parse a bech32m Ootle address string into its components.
+ * Returns { owner_key: Uint8Array, view_key: Uint8Array, network: number, memo: Uint8Array | undefined }.
+ * @param {string} address
+ * @returns {ParsedOotleAddress}
+ */
+export function parseOotleAddress(address) {
+    const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parseOotleAddress(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ParsedOotleAddress.__wrap(ret[0]);
+}
+
 /**
  * Derive the public key from a secret key (both raw bytes).
  * @param {Uint8Array} secret_key
@@ -334,6 +638,15 @@ export function __wbindgen_init_externref_table() {
 const KeypairResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_keypairresult_free(ptr >>> 0, 1));
+const OotlePublicKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ootlepublickey_free(ptr >>> 0, 1));
+const OotleSecretKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ootlesecretkey_free(ptr >>> 0, 1));
+const ParsedOotleAddressFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_parsedootleaddress_free(ptr >>> 0, 1));
 const SchnorrSignatureResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_schnorrsignatureresult_free(ptr >>> 0, 1));

package/package.json

@@ -5,7 +5,7 @@
     "The Tari Development Community"
   ],
   "description": "WASM bindings for Tari Ootle client-side crypto — thin wasm-bindgen shell over ootle-wasm-core",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "license": "BSD-3-Clause",
   "repository": {
     "type": "git",
@@ -27,4 +27,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}