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

package/iris_wasm.d.ts

@@ -1,29 +1,33 @@
 /* tslint:disable */
 /* eslint-disable */
-/**
- * Hash a public key to get its digest (for use in PKH)
- */
-export function hashPublicKey(public_key_bytes: Uint8Array): string;
-/**
- * Derive master key from seed bytes
- */
-export function deriveMasterKey(seed: Uint8Array): ExtendedKey;
 /**
  * Hash a noun (jam as input)
  */
 export function hashNoun(noun: Uint8Array): string;
+/**
+ * Sign a message string with a private key
+ */
+export function signMessage(private_key_bytes: Uint8Array, message: string): Signature;
 /**
  * Hash a u64 value
  */
 export function hashU64(value: bigint): string;
+/**
+ * Derive master key from seed bytes
+ */
+export function deriveMasterKey(seed: Uint8Array): ExtendedKey;
+/**
+ * Verify a signature with a public key
+ */
+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;
 /**
- * Sign a message string with a private key
+ * Hash a public key to get its digest (for use in PKH)
  */
-export function signMessage(private_key_bytes: Uint8Array, message: string): Signature;
+export function hashPublicKey(public_key_bytes: Uint8Array): string;
 /**
  * The `ReadableStreamType` enum.
  *
@@ -168,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 {
@@ -195,6 +226,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 +281,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;
 }
@@ -301,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
    *
@@ -326,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;
@@ -470,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;
@@ -510,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];
@@ -540,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;
@@ -573,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;
@@ -598,7 +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 __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];
@@ -606,18 +668,23 @@ 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;
   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,41 +280,21 @@ export function hashPublicKey(public_key_bytes) {
 }
 
 /**
- * Derive master key from seed bytes
- * @param {Uint8Array} seed
- * @returns {ExtendedKey}
+ * Sign a message string with a private key
+ * @param {Uint8Array} private_key_bytes
+ * @param {string} message
+ * @returns {Signature}
  */
-export function deriveMasterKey(seed) {
-    const ptr0 = passArray8ToWasm0(seed, wasm.__wbindgen_malloc);
+export function signMessage(private_key_bytes, message) {
+    const ptr0 = passArray8ToWasm0(private_key_bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.deriveMasterKey(ptr0, len0);
-    return ExtendedKey.__wrap(ret);
-}
-
-/**
- * Hash a noun (jam as input)
- * @param {Uint8Array} noun
- * @returns {string}
- */
-export function hashNoun(noun) {
-    let deferred3_0;
-    let deferred3_1;
-    try {
-        const ptr0 = passArray8ToWasm0(noun, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.hashNoun(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(deferred3_0, deferred3_1, 1);
+    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]);
 }
 
 /**
@@ -335,6 +315,38 @@ export function hashU64(value) {
     }
 }
 
+/**
+ * Derive master key from seed bytes
+ * @param {Uint8Array} seed
+ * @returns {ExtendedKey}
+ */
+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);
+}
+
+/**
+ * Verify a signature with a public key
+ * @param {Uint8Array} public_key_bytes
+ * @param {Signature} signature
+ * @param {string} message
+ * @returns {boolean}
+ */
+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.verifySignature(ptr0, len0, signature.__wbg_ptr, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0] !== 0;
+}
+
 /**
  * Derive master key from BIP39 mnemonic phrase
  * @param {string} mnemonic
@@ -354,21 +366,29 @@ 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 public key to get its digest (for use in PKH)
+ * @param {Uint8Array} public_key_bytes
+ * @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 hashPublicKey(public_key_bytes) {
+    let deferred3_0;
+    let deferred3_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);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
     }
-    return Signature.__wrap(ret[0]);
 }
 
 function wasm_bindgen__convert__closures_____invoke__hbf186e27576c509b(arg0, arg1, arg2) {
@@ -1284,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
@@ -1298,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;
     }
@@ -1307,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}
@@ -1319,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}
      */
@@ -1326,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}
      */
@@ -1334,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() {
@@ -1526,6 +1600,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));
@@ -1665,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}
@@ -1919,6 +2070,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;
 
@@ -2068,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);
@@ -2220,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));
@@ -2509,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;
@@ -2897,6 +3124,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 +3366,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_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;
+    };
+    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.2.0-alpha.0",
   "license": "MIT",
   "repository": {
     "type": "git",