@nockbox/iris-wasm 0.1.1 → 0.1.2

package/iris_wasm.d.ts

@@ -1,5 +1,13 @@
 /* tslint:disable */
 /* eslint-disable */
+/**
+ * Hash a noun (jam as input)
+ */
+export function hashNoun(noun: Uint8Array): string;
+/**
+ * Verify a signature with a public key
+ */
+export function verifySignature(public_key_bytes: Uint8Array, signature: Signature, message: string): boolean;
 /**
  * Hash a public key to get its digest (for use in PKH)
  */
@@ -9,21 +17,17 @@ export function hashPublicKey(public_key_bytes: Uint8Array): string;
  */
 export function deriveMasterKey(seed: Uint8Array): ExtendedKey;
 /**
- * Hash a noun (jam as input)
- */
-export function hashNoun(noun: Uint8Array): string;
-/**
- * Hash a u64 value
+ * Sign a message string with a private key
  */
-export function hashU64(value: bigint): string;
+export function signMessage(private_key_bytes: Uint8Array, message: string): Signature;
 /**
  * Derive master key from BIP39 mnemonic phrase
  */
 export function deriveMasterKeyFromMnemonic(mnemonic: string, passphrase?: string | null): ExtendedKey;
 /**
- * Sign a message string with a private key
+ * Hash a u64 value
  */
-export function signMessage(private_key_bytes: Uint8Array, message: string): Signature;
+export function hashU64(value: bigint): string;
 /**
  * The `ReadableStreamType` enum.
  *
@@ -195,6 +199,15 @@ export class NoteDataEntry {
   readonly key: string;
   readonly blob: Uint8Array;
 }
+export class Noun {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static cue(jam: Uint8Array): Noun;
+  jam(): Uint8Array;
+  static fromJs(value: any): Noun;
+  toJs(): any;
+}
 export class Pkh {
   free(): void;
   [Symbol.dispose](): void;
@@ -241,9 +254,9 @@ export class Seed {
   gift: bigint;
 }
 export class Signature {
-  private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  constructor(c: Uint8Array, s: Uint8Array);
   readonly c: Uint8Array;
   readonly s: Uint8Array;
 }
@@ -598,6 +611,17 @@ export interface InitOutput {
   readonly wasmseed_fromProtobuf: (a: any) => [number, number, number];
   readonly wasmseed_toProtobuf: (a: number) => [number, number, number];
   readonly version_new: (a: number) => number;
+  readonly __wbg_grpcclient_free: (a: number, b: number) => void;
+  readonly __wbg_noun_free: (a: number, b: number) => void;
+  readonly grpcclient_getBalanceByAddress: (a: number, b: number, c: number) => any;
+  readonly grpcclient_getBalanceByFirstName: (a: number, b: number, c: number) => any;
+  readonly grpcclient_new: (a: number, b: number) => number;
+  readonly grpcclient_sendTransaction: (a: number, b: any) => any;
+  readonly grpcclient_transactionAccepted: (a: number, b: number, c: number) => any;
+  readonly noun_cue: (a: number, b: number) => [number, number, number];
+  readonly noun_fromJs: (a: any) => [number, number, number];
+  readonly noun_jam: (a: number) => [number, number, number, number];
+  readonly noun_toJs: (a: number) => [number, number, number];
   readonly __wbg_extendedkey_free: (a: number, b: number) => void;
   readonly __wbg_signature_free: (a: number, b: number) => void;
   readonly deriveMasterKey: (a: number, b: number) => number;
@@ -611,13 +635,9 @@ export interface InitOutput {
   readonly hashU64: (a: bigint) => [number, number];
   readonly signMessage: (a: number, b: number, c: number, d: number) => [number, number, number];
   readonly signature_c: (a: number) => [number, number];
+  readonly signature_new: (a: number, b: number, c: number, d: number) => number;
   readonly signature_s: (a: number) => [number, number];
-  readonly __wbg_grpcclient_free: (a: number, b: number) => void;
-  readonly grpcclient_getBalanceByAddress: (a: number, b: number, c: number) => any;
-  readonly grpcclient_getBalanceByFirstName: (a: number, b: number, c: number) => any;
-  readonly grpcclient_new: (a: number, b: number) => number;
-  readonly grpcclient_sendTransaction: (a: number, b: any) => any;
-  readonly grpcclient_transactionAccepted: (a: number, b: number, c: number) => any;
+  readonly verifySignature: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
   readonly __wbg_intounderlyingsource_free: (a: number, b: number) => void;
   readonly intounderlyingsource_cancel: (a: number) => void;
   readonly intounderlyingsource_pull: (a: number, b: any) => any;

package/iris_wasm.js

@@ -254,17 +254,17 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 /**
- * Hash a public key to get its digest (for use in PKH)
- * @param {Uint8Array} public_key_bytes
+ * Hash a noun (jam as input)
+ * @param {Uint8Array} noun
  * @returns {string}
  */
-export function hashPublicKey(public_key_bytes) {
+export function hashNoun(noun) {
     let deferred3_0;
     let deferred3_1;
     try {
-        const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_malloc);
+        const ptr0 = passArray8ToWasm0(noun, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.hashPublicKey(ptr0, len0);
+        const ret = wasm.hashNoun(ptr0, len0);
         var ptr2 = ret[0];
         var len2 = ret[1];
         if (ret[3]) {
@@ -280,29 +280,37 @@ export function hashPublicKey(public_key_bytes) {
 }
 
 /**
- * Derive master key from seed bytes
- * @param {Uint8Array} seed
- * @returns {ExtendedKey}
+ * Verify a signature with a public key
+ * @param {Uint8Array} public_key_bytes
+ * @param {Signature} signature
+ * @param {string} message
+ * @returns {boolean}
  */
-export function deriveMasterKey(seed) {
-    const ptr0 = passArray8ToWasm0(seed, wasm.__wbindgen_malloc);
+export function verifySignature(public_key_bytes, signature, message) {
+    const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.deriveMasterKey(ptr0, len0);
-    return ExtendedKey.__wrap(ret);
+    _assertClass(signature, Signature);
+    const ptr1 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.verifySignature(ptr0, len0, signature.__wbg_ptr, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0] !== 0;
 }
 
 /**
- * Hash a noun (jam as input)
- * @param {Uint8Array} noun
+ * Hash a public key to get its digest (for use in PKH)
+ * @param {Uint8Array} public_key_bytes
  * @returns {string}
  */
-export function hashNoun(noun) {
+export function hashPublicKey(public_key_bytes) {
     let deferred3_0;
     let deferred3_1;
     try {
-        const ptr0 = passArray8ToWasm0(noun, wasm.__wbindgen_malloc);
+        const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.hashNoun(ptr0, len0);
+        const ret = wasm.hashPublicKey(ptr0, len0);
         var ptr2 = ret[0];
         var len2 = ret[1];
         if (ret[3]) {
@@ -318,21 +326,33 @@ export function hashNoun(noun) {
 }
 
 /**
- * Hash a u64 value
- * @param {bigint} value
- * @returns {string}
+ * Derive master key from seed bytes
+ * @param {Uint8Array} seed
+ * @returns {ExtendedKey}
  */
-export function hashU64(value) {
-    let deferred1_0;
-    let deferred1_1;
-    try {
-        const ret = wasm.hashU64(value);
-        deferred1_0 = ret[0];
-        deferred1_1 = ret[1];
-        return getStringFromWasm0(ret[0], ret[1]);
-    } finally {
-        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+export function deriveMasterKey(seed) {
+    const ptr0 = passArray8ToWasm0(seed, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.deriveMasterKey(ptr0, len0);
+    return ExtendedKey.__wrap(ret);
+}
+
+/**
+ * Sign a message string with a private key
+ * @param {Uint8Array} private_key_bytes
+ * @param {string} message
+ * @returns {Signature}
+ */
+export function signMessage(private_key_bytes, message) {
+    const ptr0 = passArray8ToWasm0(private_key_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.signMessage(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
     }
+    return Signature.__wrap(ret[0]);
 }
 
 /**
@@ -354,21 +374,21 @@ export function deriveMasterKeyFromMnemonic(mnemonic, passphrase) {
 }
 
 /**
- * Sign a message string with a private key
- * @param {Uint8Array} private_key_bytes
- * @param {string} message
- * @returns {Signature}
+ * Hash a u64 value
+ * @param {bigint} value
+ * @returns {string}
  */
-export function signMessage(private_key_bytes, message) {
-    const ptr0 = passArray8ToWasm0(private_key_bytes, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.signMessage(ptr0, len0, ptr1, len1);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
+export function hashU64(value) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.hashU64(value);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
-    return Signature.__wrap(ret[0]);
 }
 
 function wasm_bindgen__convert__closures_____invoke__hbf186e27576c509b(arg0, arg1, arg2) {
@@ -1526,6 +1546,80 @@ export class NoteDataEntry {
 }
 if (Symbol.dispose) NoteDataEntry.prototype[Symbol.dispose] = NoteDataEntry.prototype.free;
 
+const NounFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_noun_free(ptr >>> 0, 1));
+
+export class Noun {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Noun.prototype);
+        obj.__wbg_ptr = ptr;
+        NounFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        NounFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_noun_free(ptr, 0);
+    }
+    /**
+     * @param {Uint8Array} jam
+     * @returns {Noun}
+     */
+    static cue(jam) {
+        const ptr0 = passArray8ToWasm0(jam, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.noun_cue(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Noun.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    jam() {
+        const ret = wasm.noun_jam(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @param {any} value
+     * @returns {Noun}
+     */
+    static fromJs(value) {
+        const ret = wasm.noun_fromJs(value);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Noun.__wrap(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    toJs() {
+        const ret = wasm.noun_toJs(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) Noun.prototype[Symbol.dispose] = Noun.prototype.free;
+
 const PkhFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_pkh_free(ptr >>> 0, 1));
@@ -1919,6 +2013,20 @@ export class Signature {
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * @param {Uint8Array} c
+     * @param {Uint8Array} s
+     */
+    constructor(c, s) {
+        const ptr0 = passArray8ToWasm0(c, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(s, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.signature_new(ptr0, len0, ptr1, len1);
+        this.__wbg_ptr = ret >>> 0;
+        SignatureFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
 }
 if (Symbol.dispose) Signature.prototype[Symbol.dispose] = Signature.prototype.free;
 
@@ -2897,6 +3005,16 @@ function __wbg_get_imports() {
         const ret = result;
         return ret;
     };
+    imports.wbg.__wbg_instanceof_Map_8579b5e2ab5437c7 = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof Map;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
     imports.wbg.__wbg_instanceof_Uint8Array_20c8e73002f7af98 = function(arg0) {
         let result;
         try {
@@ -3129,16 +3247,21 @@ function __wbg_get_imports() {
         const ret = getStringFromWasm0(arg0, arg1);
         return ret;
     };
-    imports.wbg.__wbindgen_cast_23e23d31be9a5d3c = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 252, function: Function { arguments: [Externref], shim_idx: 253, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h20e54f17b0de8c43, wasm_bindgen__convert__closures_____invoke__hbf186e27576c509b);
-        return ret;
-    };
     imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
         // Cast intrinsic for `U64 -> Externref`.
         const ret = BigInt.asUintN(64, arg0);
         return ret;
     };
+    imports.wbg.__wbindgen_cast_726db96c89a75f21 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 277, function: Function { arguments: [Externref], shim_idx: 278, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h20e54f17b0de8c43, wasm_bindgen__convert__closures_____invoke__hbf186e27576c509b);
+        return ret;
+    };
+    imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
+        // Cast intrinsic for `I64 -> Externref`.
+        const ret = arg0;
+        return ret;
+    };
     imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
         // Cast intrinsic for `F64 -> Externref`.
         const ret = arg0;

package/package.json

@@ -5,7 +5,7 @@
     "NockBox inc. <tech@nockbox.org>"
   ],
   "description": "WASM bindings for Iris wallet",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "license": "MIT",
   "repository": {
     "type": "git",