wire-mesh-core 1.58.3 → 1.58.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wire-mesh-core",
-  "version": "1.58.3",
+  "version": "1.58.5",
   "dependencies": {
     "cbor2": "2.3.0",
     "cddl.js": "1.0.1",
@@ -235,6 +235,7 @@
     "generate": "turbo run _generate",
     "lint": "turbo run _lint",
     "mutation": "turbo run _mutation",
+    "prepack": "node scripts/assert-wasm-dist.ts",
     "test": "turbo run _test",
     "typecheck": "turbo run _typecheck"
   },

package/wasm-dist/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/wasm-dist/wire_mesh_threshold_wasm.d.ts

@@ -0,0 +1,204 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class DkgRound1Output {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly package: Uint8Array;
+    readonly secretPackage: Uint8Array;
+}
+
+export class DkgRound2Output {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly packages: Array<any>;
+    readonly recipientIds: Array<any>;
+    readonly secretPackage: Uint8Array;
+}
+
+export class DkgRound3Output {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly groupVerifyingKey: Uint8Array;
+    readonly keyPackage: Uint8Array;
+    readonly publicKeyPackage: Uint8Array;
+}
+
+export class ReshareDerivePublicKeyPackageOutput {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly groupVerifyingKey: Uint8Array;
+    readonly publicKeyPackage: Uint8Array;
+}
+
+export class ReshareRound1Output {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly commitment: Uint8Array;
+    readonly recipientIds: Array<any>;
+    readonly shares: Array<any>;
+}
+
+export class SigningRound1Output {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly commitments: Uint8Array;
+    readonly nonces: Uint8Array;
+}
+
+export class SplitCommitmentsOutput {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly binding: Uint8Array;
+    readonly hiding: Uint8Array;
+}
+
+export class SplitRound1PackageOutput {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly commitment: Array<any>;
+    readonly proofOfKnowledge: Uint8Array;
+}
+
+/**
+ * Reconstructs a serialized `SigningCommitments` (the same combined-blob
+ * shape [`signing_build_package`] and [`signing_round2_sign`] expect) from
+ * the two independently-serialized halves `threshold-commitment` carries
+ * on the wire. The inverse of [`split_commitments`].
+ */
+export function combine_commitments(hiding: Uint8Array, binding: Uint8Array): Uint8Array;
+
+/**
+ * Reconstructs a serialized DKG round-1 `Package` (the same combined-blob
+ * shape `dkg_round2`/`dkg_round3`/`dkg_transcript_digest` expect) from the
+ * two independently-serialized wire fields `threshold-keygen-round1`
+ * carries. The inverse of [`split_round1_package`].
+ */
+export function combine_round1_package(commitment: Array<any>, proof_of_knowledge: Uint8Array): Uint8Array;
+
+export function dkg_confirm_matches(own_digest: Uint8Array, own_group_key: Uint8Array, peer_digest: Uint8Array, peer_group_key: Uint8Array): boolean;
+
+export function dkg_round1(own_device_id: Uint8Array, max_signers: number, min_signers: number): DkgRound1Output;
+
+export function dkg_round2(own_secret_package: Uint8Array, round1_ids: Array<any>, round1_packages: Array<any>): DkgRound2Output;
+
+export function dkg_round3(own_secret_package: Uint8Array, round1_ids: Array<any>, round1_packages: Array<any>, round2_ids: Array<any>, round2_packages: Array<any>): DkgRound3Output;
+
+export function dkg_transcript_digest(all_round1_ids: Array<any>, all_round1_packages: Array<any>, group_verifying_key: Uint8Array): Uint8Array;
+
+/**
+ * Extracts a `KeyPackage`'s own `signing_share` bytes -- what
+ * `reshare_round1` actually needs as `own_old_signing_share`, since a
+ * survivor reshares its share, not its whole key package (which also
+ * carries this device's OWN `verifying_share`/the group's `verifying_key`,
+ * neither of which the resharing computation itself uses as input).
+ */
+export function key_package_signing_share(key_package: Uint8Array): Uint8Array;
+
+/**
+ * Reconstructs a survivor's serialized broadcast commitment (the same
+ * whole-blob shape [`reshare_combine_commitments`] expects each entry of
+ * its own `commitments` array to be) from the wire's own per-coefficient
+ * array. The inverse of [`reshare_split_commitment`].
+ */
+export function reshare_combine_commitment_parts(parts: Array<any>): Uint8Array;
+
+export function reshare_combine_commitments(commitments: Array<any>): Uint8Array;
+
+export function reshare_combine_received_shares(own_device_id: Uint8Array, received_shares: Array<any>, public_key_package: Uint8Array, new_min_signers: number): Uint8Array;
+
+/**
+ * `groupVerifyingKey` is what `threshold-keygen-confirm`'s own `group-key`
+ * field carries and what a reshare's own verifier obligation checks
+ * against `existing-group-key` -- exposed alongside the whole
+ * `PublicKeyPackage` blob (mirroring `DkgRound3Output`'s identical shape
+ * for fresh DKG) rather than requiring a second call to extract it.
+ */
+export function reshare_derive_public_key_package(combined_commitment: Uint8Array, new_participant_device_ids: Array<any>): ReshareDerivePublicKeyPackageOutput;
+
+/**
+ * Survivor side: re-shares this device's own Lagrange-weighted sub-share
+ * of the group secret across a new (possibly different) participant set.
+ * See `wire_mesh_threshold::reshare`'s own module doc comment for the full
+ * design rationale -- this is NOT built on `frost_ed25519::keys::refresh`.
+ */
+export function reshare_round1(own_device_id: Uint8Array, own_old_signing_share: Uint8Array, survivor_device_ids: Array<any>, new_participant_device_ids: Array<any>, new_min_signers: number): ReshareRound1Output;
+
+/**
+ * Splits a survivor's serialized broadcast commitment (`reshare_round1`'s
+ * own `commitment` output, a whole-blob serialization) into
+ * `threshold-keygen-round1`'s own wire shape: an array of independently-
+ * serialized coefficients (`commitment: [* bstr]`). The inverse of
+ * [`reshare_combine_commitment_parts`].
+ */
+export function reshare_split_commitment(commitment: Uint8Array): Array<any>;
+
+/**
+ * The echo-broadcast transcript digest a member of the new participant set
+ * sends on `threshold-keygen-confirm` for a reshare -- the reshare analogue
+ * of `dkg_transcript_digest`, structurally distinct because a reshare's own
+ * survivor commitment (`survivor_commitments`' own entries, each the same
+ * whole-blob shape `reshare_round1`'s own `commitment` output is) carries
+ * no proof-of-knowledge component: deserializing one AS a DKG round-1
+ * `Package` fails outright, since the two are different wire shapes
+ * entirely.
+ */
+export function reshare_transcript_digest(survivor_ids: Array<any>, survivor_commitments: Array<any>, group_verifying_key: Uint8Array): Uint8Array;
+
+/**
+ * Coordinator-side: sums and verifies the collected shares into the final
+ * aggregate signature -- an ordinary 64-byte Ed25519 signature. See
+ * `wire_mesh_threshold::signing::aggregate`'s own doc comment for why a
+ * caller MUST treat any error here as "publish nothing".
+ */
+export function signing_aggregate(signing_package: Uint8Array, ids: Array<any>, shares: Array<any>, public_key_package: Uint8Array): Uint8Array;
+
+/**
+ * Coordinator-side: builds the `SigningPackage` bytes every participant's
+ * round 2 is computed against.
+ */
+export function signing_build_package(ids: Array<any>, commitments: Array<any>, message: Uint8Array): Uint8Array;
+
+/**
+ * The pure-crypto half of round 1: generates a fresh nonce pair and its
+ * commitments. Persisting `nonces` durably before the caller's own
+ * round-1 response leaves the device is the CALLER's own obligation (see
+ * this module's own doc comment) -- this function has no storage
+ * dependency and cannot enforce it.
+ */
+export function signing_round1_commit(own_key_package: Uint8Array): SigningRound1Output;
+
+/**
+ * Round 2: releases this participant's signature share. The CALLER MUST
+ * have already taken (one-shot, never re-readable) `nonces` from its own
+ * durable nonce store before calling this -- exactly as
+ * `wire_mesh_threshold::signing::round2_sign` requires on the Rust side.
+ */
+export function signing_round2_sign(nonces: Uint8Array, signing_package: Uint8Array, own_key_package: Uint8Array): Uint8Array;
+
+/**
+ * Splits a serialized `SigningCommitments` (`signing_round1_commit`'s own
+ * `commitments` output) into the two independently-serialized halves
+ * `threshold-commitment`'s wire shape carries (`hiding: bstr, binding:
+ * bstr`) -- unlike frost-core's own combined-blob serialization, which is
+ * opaque and not spec-shaped. The inverse of [`combine_commitments`].
+ */
+export function split_commitments(commitments: Uint8Array): SplitCommitmentsOutput;
+
+/**
+ * Splits a serialized DKG round-1 `Package` (`dkg_round1`'s own `package`
+ * output) into `threshold-keygen-round1`'s own wire shape: the Feldman
+ * commitment as an array of independently-serialized coefficients
+ * (`commitment: [* bstr]`) and the Schnorr proof of knowledge as a
+ * separate byte string -- unlike frost-core's own combined-blob
+ * serialization. The inverse of [`combine_round1_package`].
+ */
+export function split_round1_package(_package: Uint8Array): SplitRound1PackageOutput;

package/wasm-dist/wire_mesh_threshold_wasm.js

@@ -0,0 +1,1010 @@
+/* @ts-self-types="./wire_mesh_threshold_wasm.d.ts" */
+
+class DkgRound1Output {
+    static __wrap(ptr) {
+        const obj = Object.create(DkgRound1Output.prototype);
+        obj.__wbg_ptr = ptr;
+        DkgRound1OutputFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DkgRound1OutputFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_dkground1output_free(ptr, 0);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get package() {
+        const ret = wasm.dkground1output_package(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get secretPackage() {
+        const ret = wasm.dkground1output_secretPackage(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+if (Symbol.dispose) DkgRound1Output.prototype[Symbol.dispose] = DkgRound1Output.prototype.free;
+exports.DkgRound1Output = DkgRound1Output;
+
+class DkgRound2Output {
+    static __wrap(ptr) {
+        const obj = Object.create(DkgRound2Output.prototype);
+        obj.__wbg_ptr = ptr;
+        DkgRound2OutputFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DkgRound2OutputFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_dkground2output_free(ptr, 0);
+    }
+    /**
+     * @returns {Array<any>}
+     */
+    get packages() {
+        const ret = wasm.dkground2output_packages(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Array<any>}
+     */
+    get recipientIds() {
+        const ret = wasm.dkground2output_recipientIds(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get secretPackage() {
+        const ret = wasm.dkground2output_secretPackage(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+if (Symbol.dispose) DkgRound2Output.prototype[Symbol.dispose] = DkgRound2Output.prototype.free;
+exports.DkgRound2Output = DkgRound2Output;
+
+class DkgRound3Output {
+    static __wrap(ptr) {
+        const obj = Object.create(DkgRound3Output.prototype);
+        obj.__wbg_ptr = ptr;
+        DkgRound3OutputFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DkgRound3OutputFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_dkground3output_free(ptr, 0);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get groupVerifyingKey() {
+        const ret = wasm.dkground3output_groupVerifyingKey(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get keyPackage() {
+        const ret = wasm.dkground3output_keyPackage(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get publicKeyPackage() {
+        const ret = wasm.dkground3output_publicKeyPackage(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+if (Symbol.dispose) DkgRound3Output.prototype[Symbol.dispose] = DkgRound3Output.prototype.free;
+exports.DkgRound3Output = DkgRound3Output;
+
+class ReshareDerivePublicKeyPackageOutput {
+    static __wrap(ptr) {
+        const obj = Object.create(ReshareDerivePublicKeyPackageOutput.prototype);
+        obj.__wbg_ptr = ptr;
+        ReshareDerivePublicKeyPackageOutputFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ReshareDerivePublicKeyPackageOutputFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_resharederivepublickeypackageoutput_free(ptr, 0);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get groupVerifyingKey() {
+        const ret = wasm.resharederivepublickeypackageoutput_groupVerifyingKey(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get publicKeyPackage() {
+        const ret = wasm.resharederivepublickeypackageoutput_publicKeyPackage(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+if (Symbol.dispose) ReshareDerivePublicKeyPackageOutput.prototype[Symbol.dispose] = ReshareDerivePublicKeyPackageOutput.prototype.free;
+exports.ReshareDerivePublicKeyPackageOutput = ReshareDerivePublicKeyPackageOutput;
+
+class ReshareRound1Output {
+    static __wrap(ptr) {
+        const obj = Object.create(ReshareRound1Output.prototype);
+        obj.__wbg_ptr = ptr;
+        ReshareRound1OutputFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ReshareRound1OutputFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_reshareround1output_free(ptr, 0);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get commitment() {
+        const ret = wasm.reshareround1output_commitment(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {Array<any>}
+     */
+    get recipientIds() {
+        const ret = wasm.reshareround1output_recipientIds(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Array<any>}
+     */
+    get shares() {
+        const ret = wasm.reshareround1output_shares(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) ReshareRound1Output.prototype[Symbol.dispose] = ReshareRound1Output.prototype.free;
+exports.ReshareRound1Output = ReshareRound1Output;
+
+class SigningRound1Output {
+    static __wrap(ptr) {
+        const obj = Object.create(SigningRound1Output.prototype);
+        obj.__wbg_ptr = ptr;
+        SigningRound1OutputFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SigningRound1OutputFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signinground1output_free(ptr, 0);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get commitments() {
+        const ret = wasm.signinground1output_commitments(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get nonces() {
+        const ret = wasm.signinground1output_nonces(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+if (Symbol.dispose) SigningRound1Output.prototype[Symbol.dispose] = SigningRound1Output.prototype.free;
+exports.SigningRound1Output = SigningRound1Output;
+
+class SplitCommitmentsOutput {
+    static __wrap(ptr) {
+        const obj = Object.create(SplitCommitmentsOutput.prototype);
+        obj.__wbg_ptr = ptr;
+        SplitCommitmentsOutputFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SplitCommitmentsOutputFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_splitcommitmentsoutput_free(ptr, 0);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get binding() {
+        const ret = wasm.splitcommitmentsoutput_binding(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get hiding() {
+        const ret = wasm.splitcommitmentsoutput_hiding(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+if (Symbol.dispose) SplitCommitmentsOutput.prototype[Symbol.dispose] = SplitCommitmentsOutput.prototype.free;
+exports.SplitCommitmentsOutput = SplitCommitmentsOutput;
+
+class SplitRound1PackageOutput {
+    static __wrap(ptr) {
+        const obj = Object.create(SplitRound1PackageOutput.prototype);
+        obj.__wbg_ptr = ptr;
+        SplitRound1PackageOutputFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SplitRound1PackageOutputFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_splitround1packageoutput_free(ptr, 0);
+    }
+    /**
+     * @returns {Array<any>}
+     */
+    get commitment() {
+        const ret = wasm.splitround1packageoutput_commitment(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get proofOfKnowledge() {
+        const ret = wasm.splitround1packageoutput_proofOfKnowledge(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+if (Symbol.dispose) SplitRound1PackageOutput.prototype[Symbol.dispose] = SplitRound1PackageOutput.prototype.free;
+exports.SplitRound1PackageOutput = SplitRound1PackageOutput;
+
+/**
+ * Reconstructs a serialized `SigningCommitments` (the same combined-blob
+ * shape [`signing_build_package`] and [`signing_round2_sign`] expect) from
+ * the two independently-serialized halves `threshold-commitment` carries
+ * on the wire. The inverse of [`split_commitments`].
+ * @param {Uint8Array} hiding
+ * @param {Uint8Array} binding
+ * @returns {Uint8Array}
+ */
+function combine_commitments(hiding, binding) {
+    const ptr0 = passArray8ToWasm0(hiding, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(binding, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.combine_commitments(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+exports.combine_commitments = combine_commitments;
+
+/**
+ * Reconstructs a serialized DKG round-1 `Package` (the same combined-blob
+ * shape `dkg_round2`/`dkg_round3`/`dkg_transcript_digest` expect) from the
+ * two independently-serialized wire fields `threshold-keygen-round1`
+ * carries. The inverse of [`split_round1_package`].
+ * @param {Array<any>} commitment
+ * @param {Uint8Array} proof_of_knowledge
+ * @returns {Uint8Array}
+ */
+function combine_round1_package(commitment, proof_of_knowledge) {
+    const ptr0 = passArray8ToWasm0(proof_of_knowledge, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.combine_round1_package(commitment, ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+exports.combine_round1_package = combine_round1_package;
+
+/**
+ * @param {Uint8Array} own_digest
+ * @param {Uint8Array} own_group_key
+ * @param {Uint8Array} peer_digest
+ * @param {Uint8Array} peer_group_key
+ * @returns {boolean}
+ */
+function dkg_confirm_matches(own_digest, own_group_key, peer_digest, peer_group_key) {
+    const ptr0 = passArray8ToWasm0(own_digest, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(own_group_key, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArray8ToWasm0(peer_digest, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ptr3 = passArray8ToWasm0(peer_group_key, wasm.__wbindgen_malloc);
+    const len3 = WASM_VECTOR_LEN;
+    const ret = wasm.dkg_confirm_matches(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0] !== 0;
+}
+exports.dkg_confirm_matches = dkg_confirm_matches;
+
+/**
+ * @param {Uint8Array} own_device_id
+ * @param {number} max_signers
+ * @param {number} min_signers
+ * @returns {DkgRound1Output}
+ */
+function dkg_round1(own_device_id, max_signers, min_signers) {
+    const ptr0 = passArray8ToWasm0(own_device_id, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.dkg_round1(ptr0, len0, max_signers, min_signers);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return DkgRound1Output.__wrap(ret[0]);
+}
+exports.dkg_round1 = dkg_round1;
+
+/**
+ * @param {Uint8Array} own_secret_package
+ * @param {Array<any>} round1_ids
+ * @param {Array<any>} round1_packages
+ * @returns {DkgRound2Output}
+ */
+function dkg_round2(own_secret_package, round1_ids, round1_packages) {
+    const ptr0 = passArray8ToWasm0(own_secret_package, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.dkg_round2(ptr0, len0, round1_ids, round1_packages);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return DkgRound2Output.__wrap(ret[0]);
+}
+exports.dkg_round2 = dkg_round2;
+
+/**
+ * @param {Uint8Array} own_secret_package
+ * @param {Array<any>} round1_ids
+ * @param {Array<any>} round1_packages
+ * @param {Array<any>} round2_ids
+ * @param {Array<any>} round2_packages
+ * @returns {DkgRound3Output}
+ */
+function dkg_round3(own_secret_package, round1_ids, round1_packages, round2_ids, round2_packages) {
+    const ptr0 = passArray8ToWasm0(own_secret_package, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.dkg_round3(ptr0, len0, round1_ids, round1_packages, round2_ids, round2_packages);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return DkgRound3Output.__wrap(ret[0]);
+}
+exports.dkg_round3 = dkg_round3;
+
+/**
+ * @param {Array<any>} all_round1_ids
+ * @param {Array<any>} all_round1_packages
+ * @param {Uint8Array} group_verifying_key
+ * @returns {Uint8Array}
+ */
+function dkg_transcript_digest(all_round1_ids, all_round1_packages, group_verifying_key) {
+    const ptr0 = passArray8ToWasm0(group_verifying_key, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.dkg_transcript_digest(all_round1_ids, all_round1_packages, ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+exports.dkg_transcript_digest = dkg_transcript_digest;
+
+/**
+ * Extracts a `KeyPackage`'s own `signing_share` bytes -- what
+ * `reshare_round1` actually needs as `own_old_signing_share`, since a
+ * survivor reshares its share, not its whole key package (which also
+ * carries this device's OWN `verifying_share`/the group's `verifying_key`,
+ * neither of which the resharing computation itself uses as input).
+ * @param {Uint8Array} key_package
+ * @returns {Uint8Array}
+ */
+function key_package_signing_share(key_package) {
+    const ptr0 = passArray8ToWasm0(key_package, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.key_package_signing_share(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+exports.key_package_signing_share = key_package_signing_share;
+
+/**
+ * Reconstructs a survivor's serialized broadcast commitment (the same
+ * whole-blob shape [`reshare_combine_commitments`] expects each entry of
+ * its own `commitments` array to be) from the wire's own per-coefficient
+ * array. The inverse of [`reshare_split_commitment`].
+ * @param {Array<any>} parts
+ * @returns {Uint8Array}
+ */
+function reshare_combine_commitment_parts(parts) {
+    const ret = wasm.reshare_combine_commitment_parts(parts);
+    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;
+}
+exports.reshare_combine_commitment_parts = reshare_combine_commitment_parts;
+
+/**
+ * @param {Array<any>} commitments
+ * @returns {Uint8Array}
+ */
+function reshare_combine_commitments(commitments) {
+    const ret = wasm.reshare_combine_commitments(commitments);
+    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;
+}
+exports.reshare_combine_commitments = reshare_combine_commitments;
+
+/**
+ * @param {Uint8Array} own_device_id
+ * @param {Array<any>} received_shares
+ * @param {Uint8Array} public_key_package
+ * @param {number} new_min_signers
+ * @returns {Uint8Array}
+ */
+function reshare_combine_received_shares(own_device_id, received_shares, public_key_package, new_min_signers) {
+    const ptr0 = passArray8ToWasm0(own_device_id, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(public_key_package, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.reshare_combine_received_shares(ptr0, len0, received_shares, ptr1, len1, new_min_signers);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+exports.reshare_combine_received_shares = reshare_combine_received_shares;
+
+/**
+ * `groupVerifyingKey` is what `threshold-keygen-confirm`'s own `group-key`
+ * field carries and what a reshare's own verifier obligation checks
+ * against `existing-group-key` -- exposed alongside the whole
+ * `PublicKeyPackage` blob (mirroring `DkgRound3Output`'s identical shape
+ * for fresh DKG) rather than requiring a second call to extract it.
+ * @param {Uint8Array} combined_commitment
+ * @param {Array<any>} new_participant_device_ids
+ * @returns {ReshareDerivePublicKeyPackageOutput}
+ */
+function reshare_derive_public_key_package(combined_commitment, new_participant_device_ids) {
+    const ptr0 = passArray8ToWasm0(combined_commitment, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.reshare_derive_public_key_package(ptr0, len0, new_participant_device_ids);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ReshareDerivePublicKeyPackageOutput.__wrap(ret[0]);
+}
+exports.reshare_derive_public_key_package = reshare_derive_public_key_package;
+
+/**
+ * Survivor side: re-shares this device's own Lagrange-weighted sub-share
+ * of the group secret across a new (possibly different) participant set.
+ * See `wire_mesh_threshold::reshare`'s own module doc comment for the full
+ * design rationale -- this is NOT built on `frost_ed25519::keys::refresh`.
+ * @param {Uint8Array} own_device_id
+ * @param {Uint8Array} own_old_signing_share
+ * @param {Array<any>} survivor_device_ids
+ * @param {Array<any>} new_participant_device_ids
+ * @param {number} new_min_signers
+ * @returns {ReshareRound1Output}
+ */
+function reshare_round1(own_device_id, own_old_signing_share, survivor_device_ids, new_participant_device_ids, new_min_signers) {
+    const ptr0 = passArray8ToWasm0(own_device_id, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(own_old_signing_share, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.reshare_round1(ptr0, len0, ptr1, len1, survivor_device_ids, new_participant_device_ids, new_min_signers);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ReshareRound1Output.__wrap(ret[0]);
+}
+exports.reshare_round1 = reshare_round1;
+
+/**
+ * Splits a survivor's serialized broadcast commitment (`reshare_round1`'s
+ * own `commitment` output, a whole-blob serialization) into
+ * `threshold-keygen-round1`'s own wire shape: an array of independently-
+ * serialized coefficients (`commitment: [* bstr]`). The inverse of
+ * [`reshare_combine_commitment_parts`].
+ * @param {Uint8Array} commitment
+ * @returns {Array<any>}
+ */
+function reshare_split_commitment(commitment) {
+    const ptr0 = passArray8ToWasm0(commitment, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.reshare_split_commitment(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.reshare_split_commitment = reshare_split_commitment;
+
+/**
+ * The echo-broadcast transcript digest a member of the new participant set
+ * sends on `threshold-keygen-confirm` for a reshare -- the reshare analogue
+ * of `dkg_transcript_digest`, structurally distinct because a reshare's own
+ * survivor commitment (`survivor_commitments`' own entries, each the same
+ * whole-blob shape `reshare_round1`'s own `commitment` output is) carries
+ * no proof-of-knowledge component: deserializing one AS a DKG round-1
+ * `Package` fails outright, since the two are different wire shapes
+ * entirely.
+ * @param {Array<any>} survivor_ids
+ * @param {Array<any>} survivor_commitments
+ * @param {Uint8Array} group_verifying_key
+ * @returns {Uint8Array}
+ */
+function reshare_transcript_digest(survivor_ids, survivor_commitments, group_verifying_key) {
+    const ptr0 = passArray8ToWasm0(group_verifying_key, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.reshare_transcript_digest(survivor_ids, survivor_commitments, ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+exports.reshare_transcript_digest = reshare_transcript_digest;
+
+/**
+ * Coordinator-side: sums and verifies the collected shares into the final
+ * aggregate signature -- an ordinary 64-byte Ed25519 signature. See
+ * `wire_mesh_threshold::signing::aggregate`'s own doc comment for why a
+ * caller MUST treat any error here as "publish nothing".
+ * @param {Uint8Array} signing_package
+ * @param {Array<any>} ids
+ * @param {Array<any>} shares
+ * @param {Uint8Array} public_key_package
+ * @returns {Uint8Array}
+ */
+function signing_aggregate(signing_package, ids, shares, public_key_package) {
+    const ptr0 = passArray8ToWasm0(signing_package, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(public_key_package, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.signing_aggregate(ptr0, len0, ids, shares, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+exports.signing_aggregate = signing_aggregate;
+
+/**
+ * Coordinator-side: builds the `SigningPackage` bytes every participant's
+ * round 2 is computed against.
+ * @param {Array<any>} ids
+ * @param {Array<any>} commitments
+ * @param {Uint8Array} message
+ * @returns {Uint8Array}
+ */
+function signing_build_package(ids, commitments, message) {
+    const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.signing_build_package(ids, commitments, ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+exports.signing_build_package = signing_build_package;
+
+/**
+ * The pure-crypto half of round 1: generates a fresh nonce pair and its
+ * commitments. Persisting `nonces` durably before the caller's own
+ * round-1 response leaves the device is the CALLER's own obligation (see
+ * this module's own doc comment) -- this function has no storage
+ * dependency and cannot enforce it.
+ * @param {Uint8Array} own_key_package
+ * @returns {SigningRound1Output}
+ */
+function signing_round1_commit(own_key_package) {
+    const ptr0 = passArray8ToWasm0(own_key_package, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.signing_round1_commit(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return SigningRound1Output.__wrap(ret[0]);
+}
+exports.signing_round1_commit = signing_round1_commit;
+
+/**
+ * Round 2: releases this participant's signature share. The CALLER MUST
+ * have already taken (one-shot, never re-readable) `nonces` from its own
+ * durable nonce store before calling this -- exactly as
+ * `wire_mesh_threshold::signing::round2_sign` requires on the Rust side.
+ * @param {Uint8Array} nonces
+ * @param {Uint8Array} signing_package
+ * @param {Uint8Array} own_key_package
+ * @returns {Uint8Array}
+ */
+function signing_round2_sign(nonces, signing_package, own_key_package) {
+    const ptr0 = passArray8ToWasm0(nonces, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(signing_package, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArray8ToWasm0(own_key_package, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.signing_round2_sign(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v4 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v4;
+}
+exports.signing_round2_sign = signing_round2_sign;
+
+/**
+ * Splits a serialized `SigningCommitments` (`signing_round1_commit`'s own
+ * `commitments` output) into the two independently-serialized halves
+ * `threshold-commitment`'s wire shape carries (`hiding: bstr, binding:
+ * bstr`) -- unlike frost-core's own combined-blob serialization, which is
+ * opaque and not spec-shaped. The inverse of [`combine_commitments`].
+ * @param {Uint8Array} commitments
+ * @returns {SplitCommitmentsOutput}
+ */
+function split_commitments(commitments) {
+    const ptr0 = passArray8ToWasm0(commitments, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.split_commitments(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return SplitCommitmentsOutput.__wrap(ret[0]);
+}
+exports.split_commitments = split_commitments;
+
+/**
+ * Splits a serialized DKG round-1 `Package` (`dkg_round1`'s own `package`
+ * output) into `threshold-keygen-round1`'s own wire shape: the Feldman
+ * commitment as an array of independently-serialized coefficients
+ * (`commitment: [* bstr]`) and the Schnorr proof of knowledge as a
+ * separate byte string -- unlike frost-core's own combined-blob
+ * serialization. The inverse of [`combine_round1_package`].
+ * @param {Uint8Array} _package
+ * @returns {SplitRound1PackageOutput}
+ */
+function split_round1_package(_package) {
+    const ptr0 = passArray8ToWasm0(_package, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.split_round1_package(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return SplitRound1PackageOutput.__wrap(ret[0]);
+}
+exports.split_round1_package = split_round1_package;
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_is_function_fcda5e3902d732fe: function(arg0) {
+            const ret = typeof(arg0) === 'function';
+            return ret;
+        },
+        __wbg___wbindgen_is_object_edb6b15aa3afe12e: function(arg0) {
+            const val = arg0;
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
+        __wbg___wbindgen_is_string_c4f7cb494a2a21f1: function(arg0) {
+            const ret = typeof(arg0) === 'string';
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_8c687d0b90d5b524: function(arg0) {
+            const ret = arg0 === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_throw_5d9e815e6fdf150f: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_call_6bcf8d3e20937e46: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.call(arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_crypto_38df2bab126b63dc: function(arg0) {
+            const ret = arg0.crypto;
+            return ret;
+        },
+        __wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
+            arg0.getRandomValues(arg1);
+        }, arguments); },
+        __wbg_get_unchecked_363572bdd397d473: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_instanceof_Uint8Array_598adc0fef426aa8: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Uint8Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_length_31bdaf014f5fbde2: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_length_4e1adc0d42e23620: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
+            const ret = arg0.msCrypto;
+            return ret;
+        },
+        __wbg_new_ffa92086ea89f79c: function() {
+            const ret = new Array();
+            return ret;
+        },
+        __wbg_new_from_slice_4ee02165f9de919e: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_new_with_length_5ffeddb9d9fbb96f: function(arg0) {
+            const ret = new Uint8Array(arg0 >>> 0);
+            return ret;
+        },
+        __wbg_node_84ea875411254db1: function(arg0) {
+            const ret = arg0.node;
+            return ret;
+        },
+        __wbg_process_44c7a14e11e9f69e: function(arg0) {
+            const ret = arg0.process;
+            return ret;
+        },
+        __wbg_prototypesetcall_ae9f5e7459250748: function(arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+        },
+        __wbg_push_bfdf956ba476f65b: function(arg0, arg1) {
+            const ret = arg0.push(arg1);
+            return ret;
+        },
+        __wbg_randomFillSync_6c25eac9869eb53c: function() { return handleError(function (arg0, arg1) {
+            arg0.randomFillSync(arg1);
+        }, arguments); },
+        __wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
+            const ret = module.require;
+            return ret;
+        }, arguments); },
+        __wbg_static_accessor_GLOBAL_8eb4cd83130a11a0: function() {
+            const ret = typeof global === 'undefined' ? null : global;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_GLOBAL_THIS_1e7044f654e934db: function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_SELF_d8b50611246a6d92: function() {
+            const ret = typeof self === 'undefined' ? null : self;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_WINDOW_fd0bc376bf0f8b42: function() {
+            const ret = typeof window === 'undefined' ? null : window;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_subarray_1daff70dde20c145: function(arg0, arg1, arg2) {
+            const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+            return ret;
+        },
+        __wbg_versions_276b2795b1c6a219: function(arg0) {
+            const ret = arg0.versions;
+            return ret;
+        },
+        __wbindgen_generic_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+            const ret = getArrayU8FromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_generic_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./wire_mesh_threshold_wasm_bg.js": import0,
+    };
+}
+
+const DkgRound1OutputFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_dkground1output_free(ptr, 1));
+const DkgRound2OutputFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_dkground2output_free(ptr, 1));
+const DkgRound3OutputFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_dkground3output_free(ptr, 1));
+const ReshareDerivePublicKeyPackageOutputFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_resharederivepublickeypackageoutput_free(ptr, 1));
+const ReshareRound1OutputFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_reshareround1output_free(ptr, 1));
+const SigningRound1OutputFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signinground1output_free(ptr, 1));
+const SplitCommitmentsOutputFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_splitcommitmentsoutput_free(ptr, 1));
+const SplitRound1PackageOutputFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_splitround1packageoutput_free(ptr, 1));
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmPath = `${__dirname}/wire_mesh_threshold_wasm_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+let wasmInstance = new WebAssembly.Instance(wasmModule, __wbg_get_imports());
+let wasm = wasmInstance.exports;
+wasm.__wbindgen_start();

package/wasm-dist/wire_mesh_threshold_wasm_bg.wasm.d.ts

@@ -0,0 +1,58 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_dkground1output_free: (a: number, b: number) => void;
+export const __wbg_dkground2output_free: (a: number, b: number) => void;
+export const __wbg_dkground3output_free: (a: number, b: number) => void;
+export const __wbg_resharederivepublickeypackageoutput_free: (a: number, b: number) => void;
+export const __wbg_reshareround1output_free: (a: number, b: number) => void;
+export const __wbg_signinground1output_free: (a: number, b: number) => void;
+export const __wbg_splitcommitmentsoutput_free: (a: number, b: number) => void;
+export const __wbg_splitround1packageoutput_free: (a: number, b: number) => void;
+export const combine_commitments: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+export const combine_round1_package: (a: any, b: number, c: number) => [number, number, number, number];
+export const dkg_confirm_matches: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number];
+export const dkg_round1: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const dkg_round2: (a: number, b: number, c: any, d: any) => [number, number, number];
+export const dkg_round3: (a: number, b: number, c: any, d: any, e: any, f: any) => [number, number, number];
+export const dkg_transcript_digest: (a: any, b: any, c: number, d: number) => [number, number, number, number];
+export const dkground1output_package: (a: number) => [number, number];
+export const dkground1output_secretPackage: (a: number) => [number, number];
+export const dkground2output_packages: (a: number) => any;
+export const dkground2output_recipientIds: (a: number) => any;
+export const dkground2output_secretPackage: (a: number) => [number, number];
+export const dkground3output_groupVerifyingKey: (a: number) => [number, number];
+export const dkground3output_keyPackage: (a: number) => [number, number];
+export const dkground3output_publicKeyPackage: (a: number) => [number, number];
+export const key_package_signing_share: (a: number, b: number) => [number, number, number, number];
+export const reshare_combine_commitment_parts: (a: any) => [number, number, number, number];
+export const reshare_combine_commitments: (a: any) => [number, number, number, number];
+export const reshare_combine_received_shares: (a: number, b: number, c: any, d: number, e: number, f: number) => [number, number, number, number];
+export const reshare_derive_public_key_package: (a: number, b: number, c: any) => [number, number, number];
+export const reshare_round1: (a: number, b: number, c: number, d: number, e: any, f: any, g: number) => [number, number, number];
+export const reshare_split_commitment: (a: number, b: number) => [number, number, number];
+export const reshare_transcript_digest: (a: any, b: any, c: number, d: number) => [number, number, number, number];
+export const resharederivepublickeypackageoutput_groupVerifyingKey: (a: number) => [number, number];
+export const resharederivepublickeypackageoutput_publicKeyPackage: (a: number) => [number, number];
+export const reshareround1output_commitment: (a: number) => [number, number];
+export const reshareround1output_recipientIds: (a: number) => any;
+export const reshareround1output_shares: (a: number) => any;
+export const signing_aggregate: (a: number, b: number, c: any, d: any, e: number, f: number) => [number, number, number, number];
+export const signing_build_package: (a: any, b: any, c: number, d: number) => [number, number, number, number];
+export const signing_round1_commit: (a: number, b: number) => [number, number, number];
+export const signing_round2_sign: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];
+export const signinground1output_commitments: (a: number) => [number, number];
+export const signinground1output_nonces: (a: number) => [number, number];
+export const split_commitments: (a: number, b: number) => [number, number, number];
+export const split_round1_package: (a: number, b: number) => [number, number, number];
+export const splitcommitmentsoutput_binding: (a: number) => [number, number];
+export const splitcommitmentsoutput_hiding: (a: number) => [number, number];
+export const splitround1packageoutput_commitment: (a: number) => any;
+export const splitround1packageoutput_proofOfKnowledge: (a: number) => [number, number];
+export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;