@nockbox/iris-wasm 0.1.2 → 0.2.0-alpha.0

package/iris_wasm.d.ts

@@ -5,29 +5,29 @@
  */
 export function hashNoun(noun: Uint8Array): string;
 /**
- * Verify a signature with a public key
+ * Sign a message string with a private key
  */
-export function verifySignature(public_key_bytes: Uint8Array, signature: Signature, message: string): boolean;
+export function signMessage(private_key_bytes: Uint8Array, message: string): Signature;
 /**
- * Hash a public key to get its digest (for use in PKH)
+ * Hash a u64 value
  */
-export function hashPublicKey(public_key_bytes: Uint8Array): string;
+export function hashU64(value: bigint): string;
 /**
  * Derive master key from seed bytes
  */
 export function deriveMasterKey(seed: Uint8Array): ExtendedKey;
 /**
- * Sign a message string with a private key
+ * Verify a signature with a public key
  */
-export function signMessage(private_key_bytes: Uint8Array, message: string): Signature;
+export function verifySignature(public_key_bytes: Uint8Array, signature: Signature, message: string): boolean;
 /**
  * Derive master key from BIP39 mnemonic phrase
  */
 export function deriveMasterKeyFromMnemonic(mnemonic: string, passphrase?: string | null): ExtendedKey;
 /**
- * Hash a u64 value
+ * Hash a public key to get its digest (for use in PKH)
  */
-export function hashU64(value: bigint): string;
+export function hashPublicKey(public_key_bytes: Uint8Array): string;
 /**
  * The `ReadableStreamType` enum.
  *
@@ -172,12 +172,39 @@ export class Note {
    * Expects response.notes[i].note (handles version internally)
    */
   static fromProtobuf(pb_note: any): Note;
+  /**
+   * Create a new V1 note (the default for new notes)
+   */
   constructor(version: Version, origin_page: bigint, name: Name, note_data: NoteData, assets: bigint);
   hash(): Digest;
+  /**
+   * Create a new V0 (legacy) note
+   *
+   * V0 notes are legacy notes that use public keys directly instead of spend conditions.
+   * - `origin_page`: Block height where the note originated
+   * - `sig_m`: Number of required signatures (m-of-n)
+   * - `sig_pubkeys`: Public keys as 97-byte arrays (big-endian format)
+   * - `source_hash`: Hash of the source (seeds that created this note)
+   * - `is_coinbase`: Whether this is a coinbase note
+   * - `timelock`: Optional timelock constraints (must have at least one constraint if provided)
+   * - `assets`: Amount of nicks in this note
+   */
+  static newV0(origin_page: bigint, sig_m: bigint, sig_pubkeys: Uint8Array[], source_hash: Digest, is_coinbase: boolean, timelock: Timelock | null | undefined, assets: bigint): Note;
   readonly originPage: bigint;
   readonly name: Name;
+  /**
+   * Check if this is a V0 (legacy) note
+   */
+  readonly isV0: boolean;
+  /**
+   * Check if this is a V1 note
+   */
+  readonly isV1: boolean;
   readonly assets: bigint;
   readonly version: Version;
+  /**
+   * Returns note data. For V0 notes this returns empty NoteData since V0 doesn't have this field.
+   */
   readonly noteData: NoteData;
 }
 export class NoteData {
@@ -314,7 +341,7 @@ export class SpendBuilder {
   /**
    * Create a new `SpendBuilder` with a given note and spend condition
    */
-  constructor(note: Note, spend_condition: SpendCondition, refund_lock?: SpendCondition | null);
+  constructor(note: Note, spend_condition?: SpendCondition | null, refund_lock?: SpendCondition | null);
   /**
    * Add seed to this spend
    *
@@ -339,6 +366,19 @@ export class SpendCondition {
   hash(): Digest;
   static newPkh(pkh: Pkh): SpendCondition;
 }
+/**
+ * Timelock for V0 (legacy) notes
+ *
+ * This is similar to LockTim but used for v0 notes' timelock constraints.
+ * At least one constraint (min or max in either rel or abs) must be set.
+ */
+export class Timelock {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(rel: TimelockRange, abs: TimelockRange);
+  readonly abs: TimelockRange;
+  readonly rel: TimelockRange;
+}
 export class TimelockRange {
   free(): void;
   [Symbol.dispose](): void;
@@ -483,6 +523,7 @@ export interface InitOutput {
   readonly __wbg_source_free: (a: number, b: number) => void;
   readonly __wbg_spendbuilder_free: (a: number, b: number) => void;
   readonly __wbg_spendcondition_free: (a: number, b: number) => void;
+  readonly __wbg_timelock_free: (a: number, b: number) => void;
   readonly __wbg_timelockrange_free: (a: number, b: number) => void;
   readonly __wbg_txbuilder_free: (a: number, b: number) => void;
   readonly __wbg_txnotes_free: (a: number, b: number) => void;
@@ -523,9 +564,12 @@ export interface InitOutput {
   readonly nockchaintx_version: (a: number) => number;
   readonly note_assets: (a: number) => bigint;
   readonly note_fromProtobuf: (a: any) => [number, number, number];
-  readonly note_hash: (a: number) => [number, number, number];
+  readonly note_hash: (a: number) => number;
+  readonly note_isV0: (a: number) => number;
+  readonly note_isV1: (a: number) => number;
   readonly note_name: (a: number) => number;
-  readonly note_new: (a: number, b: bigint, c: number, d: number, e: bigint) => number;
+  readonly note_new: (a: number, b: bigint, c: number, d: number, e: bigint) => [number, number, number];
+  readonly note_newV0: (a: bigint, b: bigint, c: number, d: number, e: number, f: number, g: number, h: bigint) => [number, number, number];
   readonly note_noteData: (a: number) => number;
   readonly note_originPage: (a: number) => bigint;
   readonly note_toProtobuf: (a: number) => [number, number, number];
@@ -553,7 +597,7 @@ export interface InitOutput {
   readonly rawtx_name: (a: number) => [number, number];
   readonly rawtx_outputs: (a: number) => [number, number];
   readonly rawtx_toJam: (a: number) => any;
-  readonly rawtx_toNockchainTx: (a: number) => number;
+  readonly rawtx_toNockchainTx: (a: number) => [number, number, number];
   readonly rawtx_toProtobuf: (a: number) => [number, number, number];
   readonly rawtx_version: (a: number) => number;
   readonly seed_gift: (a: number) => bigint;
@@ -586,11 +630,12 @@ export interface InitOutput {
   readonly spendcondition_new: (a: number, b: number) => number;
   readonly spendcondition_newPkh: (a: number) => number;
   readonly spendcondition_toProtobuf: (a: number) => [number, number, number];
+  readonly timelock_new: (a: number, b: number) => [number, number, number];
   readonly timelockrange_max: (a: number) => [number, bigint];
   readonly timelockrange_min: (a: number) => [number, bigint];
   readonly timelockrange_new: (a: number, b: bigint, c: number, d: bigint) => number;
   readonly txbuilder_addPreimage: (a: number, b: number, c: number) => [number, number, number];
-  readonly txbuilder_allNotes: (a: number) => number;
+  readonly txbuilder_allNotes: (a: number) => [number, number, number];
   readonly txbuilder_allSpends: (a: number) => [number, number];
   readonly txbuilder_build: (a: number) => [number, number, number];
   readonly txbuilder_calcFee: (a: number) => bigint;
@@ -611,18 +656,11 @@ 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 timelock_abs: (a: number) => number;
+  readonly timelock_rel: (a: number) => number;
+  readonly __wbg_extendedkey_free: (a: number, b: number) => void;
   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;
   readonly deriveMasterKeyFromMnemonic: (a: number, b: number, c: number, d: number) => [number, number, number];
@@ -630,9 +668,18 @@ export interface InitOutput {
   readonly extendedkey_deriveChild: (a: number, b: number) => [number, number, number];
   readonly extendedkey_privateKey: (a: number) => [number, number];
   readonly extendedkey_publicKey: (a: number) => [number, number];
+  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 hashNoun: (a: number, b: number) => [number, number, number, number];
   readonly hashPublicKey: (a: number, b: number) => [number, number, number, number];
   readonly hashU64: (a: bigint) => [number, number];
+  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 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;

package/iris_wasm.js

@@ -280,48 +280,38 @@ export function hashNoun(noun) {
 }
 
 /**
- * Verify a signature with a public key
- * @param {Uint8Array} public_key_bytes
- * @param {Signature} signature
+ * Sign a message string with a private key
+ * @param {Uint8Array} private_key_bytes
  * @param {string} message
- * @returns {boolean}
+ * @returns {Signature}
  */
-export function verifySignature(public_key_bytes, signature, message) {
-    const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_malloc);
+export function signMessage(private_key_bytes, message) {
+    const ptr0 = passArray8ToWasm0(private_key_bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    _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);
+    const ret = wasm.signMessage(ptr0, len0, ptr1, len1);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return ret[0] !== 0;
+    return Signature.__wrap(ret[0]);
 }
 
 /**
- * Hash a public key to get its digest (for use in PKH)
- * @param {Uint8Array} public_key_bytes
+ * Hash a u64 value
+ * @param {bigint} value
  * @returns {string}
  */
-export function hashPublicKey(public_key_bytes) {
-    let deferred3_0;
-    let deferred3_1;
+export function hashU64(value) {
+    let deferred1_0;
+    let deferred1_1;
     try {
-        const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.hashPublicKey(ptr0, len0);
-        var ptr2 = ret[0];
-        var len2 = ret[1];
-        if (ret[3]) {
-            ptr2 = 0; len2 = 0;
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        deferred3_0 = ptr2;
-        deferred3_1 = len2;
-        return getStringFromWasm0(ptr2, len2);
+        const ret = wasm.hashU64(value);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
 }
 
@@ -338,21 +328,23 @@ export function deriveMasterKey(seed) {
 }
 
 /**
- * Sign a message string with a private key
- * @param {Uint8Array} private_key_bytes
+ * Verify a signature with a public key
+ * @param {Uint8Array} public_key_bytes
+ * @param {Signature} signature
  * @param {string} message
- * @returns {Signature}
+ * @returns {boolean}
  */
-export function signMessage(private_key_bytes, message) {
-    const ptr0 = passArray8ToWasm0(private_key_bytes, 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;
+    _assertClass(signature, Signature);
     const ptr1 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.signMessage(ptr0, len0, ptr1, len1);
+    const ret = wasm.verifySignature(ptr0, len0, signature.__wbg_ptr, ptr1, len1);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return Signature.__wrap(ret[0]);
+    return ret[0] !== 0;
 }
 
 /**
@@ -374,20 +366,28 @@ export function deriveMasterKeyFromMnemonic(mnemonic, passphrase) {
 }
 
 /**
- * Hash a u64 value
- * @param {bigint} value
+ * Hash a public key to get its digest (for use in PKH)
+ * @param {Uint8Array} public_key_bytes
  * @returns {string}
  */
-export function hashU64(value) {
-    let deferred1_0;
-    let deferred1_1;
+export function hashPublicKey(public_key_bytes) {
+    let deferred3_0;
+    let deferred3_1;
     try {
-        const ret = wasm.hashU64(value);
-        deferred1_0 = ret[0];
-        deferred1_1 = ret[1];
-        return getStringFromWasm0(ret[0], ret[1]);
+        const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hashPublicKey(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
     } finally {
-        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
     }
 }
 
@@ -1304,6 +1304,7 @@ export class Note {
         return Note.__wrap(ret[0]);
     }
     /**
+     * Create a new V1 note (the default for new notes)
      * @param {Version} version
      * @param {bigint} origin_page
      * @param {Name} name
@@ -1318,7 +1319,10 @@ export class Note {
         _assertClass(note_data, NoteData);
         var ptr2 = note_data.__destroy_into_raw();
         const ret = wasm.note_new(ptr0, origin_page, ptr1, ptr2, assets);
-        this.__wbg_ptr = ret >>> 0;
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
         NoteFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -1327,10 +1331,7 @@ export class Note {
      */
     hash() {
         const ret = wasm.note_hash(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Digest.__wrap(ret[0]);
+        return Digest.__wrap(ret);
     }
     /**
      * @returns {Name}
@@ -1339,6 +1340,22 @@ export class Note {
         const ret = wasm.note_name(this.__wbg_ptr);
         return Name.__wrap(ret);
     }
+    /**
+     * Check if this is a V0 (legacy) note
+     * @returns {boolean}
+     */
+    get isV0() {
+        const ret = wasm.note_isV0(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Check if this is a V1 note
+     * @returns {boolean}
+     */
+    get isV1() {
+        const ret = wasm.note_isV1(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * @returns {bigint}
      */
@@ -1346,6 +1363,42 @@ export class Note {
         const ret = wasm.note_assets(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
+    /**
+     * Create a new V0 (legacy) note
+     *
+     * V0 notes are legacy notes that use public keys directly instead of spend conditions.
+     * - `origin_page`: Block height where the note originated
+     * - `sig_m`: Number of required signatures (m-of-n)
+     * - `sig_pubkeys`: Public keys as 97-byte arrays (big-endian format)
+     * - `source_hash`: Hash of the source (seeds that created this note)
+     * - `is_coinbase`: Whether this is a coinbase note
+     * - `timelock`: Optional timelock constraints (must have at least one constraint if provided)
+     * - `assets`: Amount of nicks in this note
+     * @param {bigint} origin_page
+     * @param {bigint} sig_m
+     * @param {Uint8Array[]} sig_pubkeys
+     * @param {Digest} source_hash
+     * @param {boolean} is_coinbase
+     * @param {Timelock | null | undefined} timelock
+     * @param {bigint} assets
+     * @returns {Note}
+     */
+    static newV0(origin_page, sig_m, sig_pubkeys, source_hash, is_coinbase, timelock, assets) {
+        const ptr0 = passArrayJsValueToWasm0(sig_pubkeys, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(source_hash, Digest);
+        var ptr1 = source_hash.__destroy_into_raw();
+        let ptr2 = 0;
+        if (!isLikeNone(timelock)) {
+            _assertClass(timelock, Timelock);
+            ptr2 = timelock.__destroy_into_raw();
+        }
+        const ret = wasm.note_newV0(origin_page, sig_m, ptr0, len0, ptr1, is_coinbase, ptr2, assets);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Note.__wrap(ret[0]);
+    }
     /**
      * @returns {Version}
      */
@@ -1354,6 +1407,7 @@ export class Note {
         return Version.__wrap(ret);
     }
     /**
+     * Returns note data. For V0 notes this returns empty NoteData since V0 doesn't have this field.
      * @returns {NoteData}
      */
     get noteData() {
@@ -1759,7 +1813,10 @@ export class RawTx {
      */
     toNockchainTx() {
         const ret = wasm.rawtx_toNockchainTx(this.__wbg_ptr);
-        return NockchainTx.__wrap(ret);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return NockchainTx.__wrap(ret[0]);
     }
     /**
      * @returns {Digest}
@@ -2176,14 +2233,17 @@ export class SpendBuilder {
     /**
      * Create a new `SpendBuilder` with a given note and spend condition
      * @param {Note} note
-     * @param {SpendCondition} spend_condition
+     * @param {SpendCondition | null} [spend_condition]
      * @param {SpendCondition | null} [refund_lock]
      */
     constructor(note, spend_condition, refund_lock) {
         _assertClass(note, Note);
         var ptr0 = note.__destroy_into_raw();
-        _assertClass(spend_condition, SpendCondition);
-        var ptr1 = spend_condition.__destroy_into_raw();
+        let ptr1 = 0;
+        if (!isLikeNone(spend_condition)) {
+            _assertClass(spend_condition, SpendCondition);
+            ptr1 = spend_condition.__destroy_into_raw();
+        }
         let ptr2 = 0;
         if (!isLikeNone(refund_lock)) {
             _assertClass(refund_lock, SpendCondition);
@@ -2328,6 +2388,62 @@ export class SpendCondition {
 }
 if (Symbol.dispose) SpendCondition.prototype[Symbol.dispose] = SpendCondition.prototype.free;
 
+const TimelockFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_timelock_free(ptr >>> 0, 1));
+/**
+ * Timelock for V0 (legacy) notes
+ *
+ * This is similar to LockTim but used for v0 notes' timelock constraints.
+ * At least one constraint (min or max in either rel or abs) must be set.
+ */
+export class Timelock {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TimelockFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_timelock_free(ptr, 0);
+    }
+    /**
+     * @returns {TimelockRange}
+     */
+    get abs() {
+        const ret = wasm.locktim_abs(this.__wbg_ptr);
+        return TimelockRange.__wrap(ret);
+    }
+    /**
+     * @param {TimelockRange} rel
+     * @param {TimelockRange} abs
+     */
+    constructor(rel, abs) {
+        _assertClass(rel, TimelockRange);
+        var ptr0 = rel.__destroy_into_raw();
+        _assertClass(abs, TimelockRange);
+        var ptr1 = abs.__destroy_into_raw();
+        const ret = wasm.timelock_new(ptr0, ptr1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        TimelockFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {TimelockRange}
+     */
+    get rel() {
+        const ret = wasm.locktim_rel(this.__wbg_ptr);
+        return TimelockRange.__wrap(ret);
+    }
+}
+if (Symbol.dispose) Timelock.prototype[Symbol.dispose] = Timelock.prototype.free;
+
 const TimelockRangeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_timelockrange_free(ptr >>> 0, 1));
@@ -2617,7 +2733,10 @@ export class TxBuilder {
      */
     allNotes() {
         const ret = wasm.txbuilder_allNotes(this.__wbg_ptr);
-        return TxNotes.__wrap(ret);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TxNotes.__wrap(ret[0]);
     }
 }
 if (Symbol.dispose) TxBuilder.prototype[Symbol.dispose] = TxBuilder.prototype.free;
@@ -3252,8 +3371,8 @@ function __wbg_get_imports() {
         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`.
+    imports.wbg.__wbindgen_cast_8b855ba391b91225 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 285, function: Function { arguments: [Externref], shim_idx: 286, 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;
     };

package/package.json

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