@spacesprotocol/libveritas 0.0.0-dev.20260320120512 → 0.0.0-dev.20260320153157

package/libveritas.d.ts

@@ -8,6 +8,31 @@ export class Anchors {
     constructor(json: string);
 }
 
+/**
+ * Batched iterative resolver for nested handle names.
+ */
+export class Lookup {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Feed zones from a resolveAll response.
+     * Returns the next batch of handles to look up (empty = done).
+     */
+    advance(zones: any): string[];
+    /**
+     * Expand zone handles using the alias map accumulated during resolution.
+     */
+    expandZones(zones: any): any;
+    /**
+     * Create a lookup from an array of handle name strings.
+     */
+    constructor(names: string[]);
+    /**
+     * Returns the first batch of handles to look up.
+     */
+    start(): string[];
+}
+
 /**
  * A message containing chain proofs and handle data.
  */
@@ -52,6 +77,10 @@ export class MessageBuilder {
      * Add all certificates from a .spacecert chain.
      */
     addChain(chain_bytes: Uint8Array): void;
+    /**
+     * Add a .spacecert chain with records.
+     */
+    addHandle(chain_bytes: Uint8Array, records_bytes: Uint8Array): void;
     /**
      * Add records for a handle.
      */
@@ -218,10 +247,13 @@ export class Veritas {
     oldest_anchor(): number;
     sovereignty_for(commitment_height: number): string;
     /**
-     * Verify a message against a query context.
+     * Verify a message with default options (expand_names: true, dev_mode: false).
+     */
+    verify(ctx: QueryContext, msg: Message): VerifiedMessage;
+    /**
+     * Verify a message with explicit options.
      */
-    verify_message(ctx: QueryContext, msg: Message): VerifiedMessage;
-    static withOptions(anchors: Anchors, expand_names: boolean, dev_mode: boolean): Veritas;
+    verifyWithOptions(ctx: QueryContext, msg: Message, expand_names: boolean, dev_mode: boolean): VerifiedMessage;
 }
 
 /**

package/libveritas.js

@@ -38,6 +38,76 @@ class Anchors {
 if (Symbol.dispose) Anchors.prototype[Symbol.dispose] = Anchors.prototype.free;
 exports.Anchors = Anchors;
 
+/**
+ * Batched iterative resolver for nested handle names.
+ */
+class Lookup {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LookupFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_lookup_free(ptr, 0);
+    }
+    /**
+     * Feed zones from a resolveAll response.
+     * Returns the next batch of handles to look up (empty = done).
+     * @param {any} zones
+     * @returns {string[]}
+     */
+    advance(zones) {
+        const ret = wasm.lookup_advance(this.__wbg_ptr, zones);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Expand zone handles using the alias map accumulated during resolution.
+     * @param {any} zones
+     * @returns {any}
+     */
+    expandZones(zones) {
+        const ret = wasm.lookup_expandZones(this.__wbg_ptr, zones);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Create a lookup from an array of handle name strings.
+     * @param {string[]} names
+     */
+    constructor(names) {
+        const ptr0 = passArrayJsValueToWasm0(names, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.lookup_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        LookupFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Returns the first batch of handles to look up.
+     * @returns {string[]}
+     */
+    start() {
+        const ret = wasm.lookup_start(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+if (Symbol.dispose) Lookup.prototype[Symbol.dispose] = Lookup.prototype.free;
+exports.Lookup = Lookup;
+
 /**
  * A message containing chain proofs and handle data.
  */
@@ -146,6 +216,21 @@ class MessageBuilder {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * Add a .spacecert chain with records.
+     * @param {Uint8Array} chain_bytes
+     * @param {Uint8Array} records_bytes
+     */
+    addHandle(chain_bytes, records_bytes) {
+        const ptr0 = passArray8ToWasm0(chain_bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(records_bytes, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.messagebuilder_addHandle(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * Add records for a handle.
      * @param {string} handle
@@ -556,13 +641,6 @@ if (Symbol.dispose) VerifiedMessage.prototype[Symbol.dispose] = VerifiedMessage.
 exports.VerifiedMessage = VerifiedMessage;
 
 class Veritas {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Veritas.prototype);
-        obj.__wbg_ptr = ptr;
-        VeritasFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -634,33 +712,36 @@ class Veritas {
         }
     }
     /**
-     * Verify a message against a query context.
+     * Verify a message with default options (expand_names: true, dev_mode: false).
      * @param {QueryContext} ctx
      * @param {Message} msg
      * @returns {VerifiedMessage}
      */
-    verify_message(ctx, msg) {
+    verify(ctx, msg) {
         _assertClass(ctx, QueryContext);
         _assertClass(msg, Message);
-        const ret = wasm.veritas_verify_message(this.__wbg_ptr, ctx.__wbg_ptr, msg.__wbg_ptr);
+        const ret = wasm.veritas_verify(this.__wbg_ptr, ctx.__wbg_ptr, msg.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return VerifiedMessage.__wrap(ret[0]);
     }
     /**
-     * @param {Anchors} anchors
+     * Verify a message with explicit options.
+     * @param {QueryContext} ctx
+     * @param {Message} msg
      * @param {boolean} expand_names
      * @param {boolean} dev_mode
-     * @returns {Veritas}
+     * @returns {VerifiedMessage}
      */
-    static withOptions(anchors, expand_names, dev_mode) {
-        _assertClass(anchors, Anchors);
-        const ret = wasm.veritas_withOptions(anchors.__wbg_ptr, expand_names, dev_mode);
+    verifyWithOptions(ctx, msg, expand_names, dev_mode) {
+        _assertClass(ctx, QueryContext);
+        _assertClass(msg, Message);
+        const ret = wasm.veritas_verifyWithOptions(this.__wbg_ptr, ctx.__wbg_ptr, msg.__wbg_ptr, expand_names, dev_mode);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return Veritas.__wrap(ret[0]);
+        return VerifiedMessage.__wrap(ret[0]);
     }
 }
 if (Symbol.dispose) Veritas.prototype[Symbol.dispose] = Veritas.prototype.free;
@@ -909,6 +990,9 @@ function __wbg_get_imports() {
 const AnchorsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_anchors_free(ptr >>> 0, 1));
+const LookupFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_lookup_free(ptr >>> 0, 1));
 const MessageFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_message_free(ptr >>> 0, 1));
@@ -1011,6 +1095,17 @@ function debugString(val) {
     return className;
 }
 
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
@@ -1057,6 +1152,16 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spacesprotocol/libveritas",
-  "version": "0.0.0-dev.20260320120512",
+  "version": "0.0.0-dev.20260320153157",
   "files": [
     "libveritas_bg.wasm",
     "libveritas.js",