ping-openmls-sdk 0.6.5 → 0.6.6

package/wasm/ping_wasm.d.ts

@@ -195,6 +195,28 @@ export function _start(): void;
  */
 export function decodeCatchupSnapshot(snapshot_bytes: Uint8Array): any;
 
+/**
+ * Decrypt a recovery blob. Returns `{ v, account_id, identity_export, device_group_snapshot,
+ * created_at_ms }`. A wrong mnemonic or tampered blob throws a generic error.
+ */
+export function decryptBackup(blob: Uint8Array, mnemonic_phrase: string): any;
+
+/**
+ * Encrypt an IdentityBackup blob for `POST /v1/recovery/blobs`. `account_id` is 16 bytes,
+ * `identity_export` is `generateIdentity()` output, `device_group_snapshot` may be empty.
+ */
+export function encryptBackup(mnemonic_phrase: string, account_id: Uint8Array, identity_export: Uint8Array, device_group_snapshot: Uint8Array, created_at_ms: number): Uint8Array;
+
+/**
+ * Generate a fresh 12-word BIP39 mnemonic, returned as its canonical phrase string.
+ */
+export function generateMnemonicPhrase(): string;
+
+/**
+ * Validate + canonicalise a user-entered phrase (BIP39 wordlist + checksum).
+ */
+export function normalizeMnemonicPhrase(phrase: string): string;
+
 export function openLinkingTicket(sealed: Uint8Array, new_device_priv: Uint8Array): any;
 
 /**
@@ -212,6 +234,10 @@ export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_pingclient_free: (a: number, b: number) => void;
     readonly decodeCatchupSnapshot: (a: number, b: number, c: number) => void;
+    readonly decryptBackup: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly encryptBackup: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+    readonly generateMnemonicPhrase: (a: number) => void;
+    readonly normalizeMnemonicPhrase: (a: number, b: number, c: number) => void;
     readonly openLinkingTicket: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly pingclient_addMembers: (a: number, b: number, c: number, d: number, e: number) => number;
     readonly pingclient_admitDeviceToChats: (a: number, b: number, c: number, d: number, e: number) => number;
@@ -251,9 +277,9 @@ export interface InitOutput {
     readonly wasmbindgentestcontext_include_ignored: (a: number, b: number) => void;
     readonly wasmbindgentestcontext_new: (a: number) => number;
     readonly wasmbindgentestcontext_run: (a: number, b: number, c: number) => number;
-    readonly __wasm_bindgen_func_elem_2676: (a: number, b: number, c: number, d: number, e: number) => void;
-    readonly __wasm_bindgen_func_elem_2666: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_2675: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_2766: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly __wasm_bindgen_func_elem_2752: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_2776: (a: number, b: number, c: number, d: number) => void;
     readonly __wbindgen_export: (a: number, b: number) => number;
     readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_export3: (a: number) => void;

package/wasm/ping_wasm.js

@@ -625,6 +625,128 @@ export function decodeCatchupSnapshot(snapshot_bytes) {
     }
 }
 
+/**
+ * Decrypt a recovery blob. Returns `{ v, account_id, identity_export, device_group_snapshot,
+ * created_at_ms }`. A wrong mnemonic or tampered blob throws a generic error.
+ * @param {Uint8Array} blob
+ * @param {string} mnemonic_phrase
+ * @returns {any}
+ */
+export function decryptBackup(blob, mnemonic_phrase) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(blob, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(mnemonic_phrase, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.decryptBackup(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Encrypt an IdentityBackup blob for `POST /v1/recovery/blobs`. `account_id` is 16 bytes,
+ * `identity_export` is `generateIdentity()` output, `device_group_snapshot` may be empty.
+ * @param {string} mnemonic_phrase
+ * @param {Uint8Array} account_id
+ * @param {Uint8Array} identity_export
+ * @param {Uint8Array} device_group_snapshot
+ * @param {number} created_at_ms
+ * @returns {Uint8Array}
+ */
+export function encryptBackup(mnemonic_phrase, account_id, identity_export, device_group_snapshot, created_at_ms) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(mnemonic_phrase, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(account_id, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(identity_export, wasm.__wbindgen_export);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArray8ToWasm0(device_group_snapshot, wasm.__wbindgen_export);
+        const len3 = WASM_VECTOR_LEN;
+        wasm.encryptBackup(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, created_at_ms);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Generate a fresh 12-word BIP39 mnemonic, returned as its canonical phrase string.
+ * @returns {string}
+ */
+export function generateMnemonicPhrase() {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.generateMnemonicPhrase(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr1 = r0;
+        var len1 = r1;
+        if (r3) {
+            ptr1 = 0; len1 = 0;
+            throw takeObject(r2);
+        }
+        deferred2_0 = ptr1;
+        deferred2_1 = len1;
+        return getStringFromWasm0(ptr1, len1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Validate + canonicalise a user-entered phrase (BIP39 wordlist + checksum).
+ * @param {string} phrase
+ * @returns {string}
+ */
+export function normalizeMnemonicPhrase(phrase) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(phrase, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.normalizeMnemonicPhrase(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * @param {Uint8Array} sealed
  * @param {Uint8Array} new_device_priv
@@ -803,11 +925,11 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).crypto;
             return addHeapObject(ret);
         },
-        __wbg_del_0c23259b4f1e1a35: function(arg0, arg1, arg2, arg3, arg4) {
+        __wbg_del_eafff9965c23bbac: function(arg0, arg1, arg2, arg3, arg4) {
             const ret = getObject(arg0).del(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
             return addHeapObject(ret);
         },
-        __wbg_discoverDevices_6602e7a0e4eb5dca: function(arg0, arg1) {
+        __wbg_discoverDevices_edb837429e2af7b3: function(arg0, arg1) {
             const ret = getObject(arg0).discoverDevices(takeObject(arg1));
             return addHeapObject(ret);
         },
@@ -833,7 +955,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_export4(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_fetchSince_9ab9ab87545120a6: function(arg0, arg1, arg2, arg3) {
+        __wbg_fetchSince_a4a945f4063994a7: function(arg0, arg1, arg2, arg3) {
             const ret = getObject(arg0).fetchSince(takeObject(arg1), takeObject(arg2), arg3 >>> 0);
             return addHeapObject(ret);
         },
@@ -844,7 +966,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_2676(a, state0.b, arg0, arg1, arg2);
+                        return __wasm_bindgen_func_elem_2766(a, state0.b, arg0, arg1, arg2);
                     } finally {
                         state0.a = a;
                     }
@@ -868,10 +990,6 @@ function __wbg_get_imports() {
         __wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
             getObject(arg0).getRandomValues(getObject(arg1));
         }, arguments); },
-        __wbg_get_42b374e8c2a74c5e: function(arg0, arg1, arg2, arg3, arg4) {
-            const ret = getObject(arg0).get(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
-            return addHeapObject(ret);
-        },
         __wbg_get_652f640b3b0b6e3e: function(arg0, arg1) {
             const ret = getObject(arg0)[arg1 >>> 0];
             return addHeapObject(ret);
@@ -880,6 +998,10 @@ function __wbg_get_imports() {
             const ret = Reflect.get(getObject(arg0), getObject(arg1));
             return addHeapObject(ret);
         }, arguments); },
+        __wbg_get_cb2eaaeb44a2843d: function(arg0, arg1, arg2, arg3, arg4) {
+            const ret = getObject(arg0).get(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+            return addHeapObject(ret);
+        },
         __wbg_get_unchecked_be562b1421656321: function(arg0, arg1) {
             const ret = getObject(arg0)[arg1 >>> 0];
             return addHeapObject(ret);
@@ -928,7 +1050,7 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).length;
             return ret;
         },
-        __wbg_listKeys_22139ea835278f2e: function(arg0, arg1, arg2, arg3, arg4) {
+        __wbg_listKeys_8ea9db09d145e5f2: function(arg0, arg1, arg2, arg3, arg4) {
             const ret = getObject(arg0).listKeys(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
             return addHeapObject(ret);
         },
@@ -985,7 +1107,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_2675(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_2776(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -1035,7 +1157,7 @@ function __wbg_get_imports() {
         __wbg_prototypesetcall_fd4050e806e1d519: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
         },
-        __wbg_put_ebb52697bcf9189a: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_put_92ce60d3b8bc7b85: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             const ret = getObject(arg0).put(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4), takeObject(arg5));
             return addHeapObject(ret);
         },
@@ -1061,11 +1183,11 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).self;
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
         },
-        __wbg_send_a5e0c4c86eab668f: function(arg0, arg1) {
+        __wbg_send_491ff43c78019f2d: function(arg0, arg1) {
             const ret = getObject(arg0).send(takeObject(arg1));
             return addHeapObject(ret);
         },
-        __wbg_setNextWelcomeRecipients_7d5369b904c404dd: function(arg0, arg1, arg2) {
+        __wbg_setNextWelcomeRecipients_837f72290c599dcc: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).setNextWelcomeRecipients(takeObject(arg1), takeObject(arg2));
             return addHeapObject(ret);
         },
@@ -1162,8 +1284,8 @@ function __wbg_get_imports() {
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 749, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2666);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 774, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2752);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0) {
@@ -1207,10 +1329,10 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_2666(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_2752(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_2666(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_2752(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {
@@ -1221,12 +1343,12 @@ function __wasm_bindgen_func_elem_2666(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_2675(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_2675(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_2776(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_2776(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
-function __wasm_bindgen_func_elem_2676(arg0, arg1, arg2, arg3, arg4) {
-    wasm.__wasm_bindgen_func_elem_2676(arg0, arg1, addHeapObject(arg2), arg3, addHeapObject(arg4));
+function __wasm_bindgen_func_elem_2766(arg0, arg1, arg2, arg3, arg4) {
+    wasm.__wasm_bindgen_func_elem_2766(arg0, arg1, addHeapObject(arg2), arg3, addHeapObject(arg4));
 }
 
 const WasmBindgenTestContextFinalization = (typeof FinalizationRegistry === 'undefined')

package/wasm/ping_wasm_bg.wasm.d.ts

@@ -3,6 +3,10 @@
 export const memory: WebAssembly.Memory;
 export const __wbg_pingclient_free: (a: number, b: number) => void;
 export const decodeCatchupSnapshot: (a: number, b: number, c: number) => void;
+export const decryptBackup: (a: number, b: number, c: number, d: number, e: number) => void;
+export const encryptBackup: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+export const generateMnemonicPhrase: (a: number) => void;
+export const normalizeMnemonicPhrase: (a: number, b: number, c: number) => void;
 export const openLinkingTicket: (a: number, b: number, c: number, d: number, e: number) => void;
 export const pingclient_addMembers: (a: number, b: number, c: number, d: number, e: number) => number;
 export const pingclient_admitDeviceToChats: (a: number, b: number, c: number, d: number, e: number) => number;
@@ -42,9 +46,9 @@ export const wasmbindgentestcontext_filtered_count: (a: number, b: number) => vo
 export const wasmbindgentestcontext_include_ignored: (a: number, b: number) => void;
 export const wasmbindgentestcontext_new: (a: number) => number;
 export const wasmbindgentestcontext_run: (a: number, b: number, c: number) => number;
-export const __wasm_bindgen_func_elem_2676: (a: number, b: number, c: number, d: number, e: number) => void;
-export const __wasm_bindgen_func_elem_2666: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_2675: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_2766: (a: number, b: number, c: number, d: number, e: number) => void;
+export const __wasm_bindgen_func_elem_2752: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_2776: (a: number, b: number, c: number, d: number) => void;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_export3: (a: number) => void;