From f9349d46b8e5a9dc20322075cb82d591d60118da Mon Sep 17 00:00:00 2001 From: Hokuto Morita Date: Tue, 10 Oct 2023 15:51:21 +0900 Subject: [PATCH 1/6] =?UTF-8?q?[add]README=E3=81=AE=E8=BF=BD=E8=A8=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/README.md b/README.md index 9197fbc2..4356ad01 100644 --- a/README.md +++ b/README.md @@ -76,3 +76,23 @@ DIDKit can be used in any of the following ways: [rustup]: https://rustup.rs/ [Cargo]: https://doc.rust-lang.org/cargo/ [ssi]: https://github.com/spruceid/ssi + +## build +``` +sh build.sh +``` +`didkit-wasm-node`, `didkit-wasm` ディレクトリの中にbuildの成果物が出力される。 + +それぞれ、`.gitignore`も出力されるので削除して、成果物をpushする。 + +## 使用例 +```json +"dependencies": { + "@dig-dao/didkit": "https://github.com/Dig-DAO/didkit.git" +} +``` + +```js +import { verifyCredential } from "@dig-dao/didkit/didkit-wasm-node" +import { issueCredential } from "@dig-dao/didkit/didkit-wasm" +``` From e5164fb1ed564e84aeedb2c9c42975e04dcfcad3 Mon Sep 17 00:00:00 2001 From: Hokuto Morita Date: Tue, 10 Oct 2023 17:07:25 +0900 Subject: [PATCH 2/6] =?UTF-8?q?[add]build=E3=82=B9=E3=82=AF=E3=83=AA?= =?UTF-8?q?=E3=83=97=E3=83=88?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- build.sh | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 build.sh diff --git a/build.sh b/build.sh new file mode 100644 index 00000000..59731221 --- /dev/null +++ b/build.sh @@ -0,0 +1,2 @@ +docker run -v $PWD:/didkit -it --rm rust bash -c "cargo install wasm-pack && git clone https://github.com/Dig-DAO/ssi --recurse-submodules && cd didkit/lib/web && wasm-pack build --out-dir /didkit/didkit-wasm-node --target nodejs" +docker run -v $PWD:/didkit -it --rm rust bash -c "cargo install wasm-pack && git clone https://github.com/Dig-DAO/ssi --recurse-submodules && cd didkit/lib/web && wasm-pack build --out-dir /didkit/didkit-wasm" From f1fb9ab4499b7f51f8ed60271eca9582815b2e3b Mon Sep 17 00:00:00 2001 From: Hokuto Morita Date: Tue, 10 Oct 2023 18:31:49 +0900 Subject: [PATCH 3/6] =?UTF-8?q?[add]build=E3=81=97=E3=81=9Fwasm?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- didkit-wasm-node/.gitignore | 0 didkit-wasm-node/README.md | 89 ++ didkit-wasm-node/didkit_wasm.d.ts | 156 +++ didkit-wasm-node/didkit_wasm.js | 1042 +++++++++++++++++++++ didkit-wasm-node/didkit_wasm_bg.wasm | Bin 0 -> 10267465 bytes didkit-wasm-node/didkit_wasm_bg.wasm.d.ts | 37 + didkit-wasm-node/package.json | 14 + didkit-wasm/.gitignore | 0 didkit-wasm/README.md | 89 ++ didkit-wasm/didkit_wasm.d.ts | 156 +++ didkit-wasm/didkit_wasm.js | 4 + didkit-wasm/didkit_wasm_bg.js | 1039 ++++++++++++++++++++ didkit-wasm/didkit_wasm_bg.wasm | Bin 0 -> 10267105 bytes didkit-wasm/didkit_wasm_bg.wasm.d.ts | 37 + didkit-wasm/package.json | 19 + 15 files changed, 2682 insertions(+) create mode 100644 didkit-wasm-node/.gitignore create mode 100644 didkit-wasm-node/README.md create mode 100644 didkit-wasm-node/didkit_wasm.d.ts create mode 100644 didkit-wasm-node/didkit_wasm.js create mode 100644 didkit-wasm-node/didkit_wasm_bg.wasm create mode 100644 didkit-wasm-node/didkit_wasm_bg.wasm.d.ts create mode 100644 didkit-wasm-node/package.json create mode 100644 didkit-wasm/.gitignore create mode 100644 didkit-wasm/README.md create mode 100644 didkit-wasm/didkit_wasm.d.ts create mode 100644 didkit-wasm/didkit_wasm.js create mode 100644 didkit-wasm/didkit_wasm_bg.js create mode 100644 didkit-wasm/didkit_wasm_bg.wasm create mode 100644 didkit-wasm/didkit_wasm_bg.wasm.d.ts create mode 100644 didkit-wasm/package.json diff --git a/didkit-wasm-node/.gitignore b/didkit-wasm-node/.gitignore new file mode 100644 index 00000000..e69de29b diff --git a/didkit-wasm-node/README.md b/didkit-wasm-node/README.md new file mode 100644 index 00000000..e32a3845 --- /dev/null +++ b/didkit-wasm-node/README.md @@ -0,0 +1,89 @@ +[![](https://img.shields.io/npm/v/@spruceid/didkit-wasm?label=%40spruceid%2Fdidkit-wasm&logo=npm)](https://www.npmjs.com/package/@spruceid/didkit-wasm) [![](https://img.shields.io/npm/v/@spruceid/didkit-wasm-node?label=%40spruceid%2Fdidkit-wasm-node&logo=npm)](https://www.npmjs.com/package/@spruceid/didkit-wasm-node) + + +# DIDKit WASM + +## Prerequisites to Build from Source + +NPM packages are available but if you would like to compile DIDKit yourself +(e.g. to enable different cryptographic backends) you will need the WASM +compiler toolchain as well as a specific build tool: + +```bash +$ rustup target add wasm32-unknown-unknown +$ cargo install wasm-pack +# OR +# $ curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh +``` + +## Installation and Usage + +### Node + +WASM can be used in Node.js (any recent version): +```bash +$ npm i @spruceid/didkit-wasm-node +``` + +Or build it from source: +```bash +$ wasm-pack build --target nodejs +``` + +### Web Frameworks (Bundled) + +WASM can be used with web frameworks and bundlers like Webpack: +```bash +$ npm i @spruceid/didkit-wasm +``` + +Or build it from source: +```bash +$ wasm-pack build +``` + +> If Webpack doesn't work with the default configuration, you can have a look at +> our configuration for +> [tzprofiles](https://github.com/spruceid/tzprofiles/blob/main/dapp/webpack.config.js). + +### Vanilla Javascript + +WASM can be used with plain Javascript with newer browsers. As it cannot be used +as a NPM package you have to build it manually: +```bash +$ wasm-pack build --target web +``` + +The manual tests in `test/` serve as an example on how to import DIDKit. + +## Tests + +The `test/` directory contains manual tests to run in the browser. Instructions +are in the README of the directory. + +## Non-Default Compilation + +_**The current version of the `ring` crate does not provide all the symbols +needed to run on the browser, see DEPS.md**_ + +To compile all features plus `wasm32_c` on `ring`, a C compiler is needed, see +[spruceid/ssi](https://github.com/spruceid/didkit/tree/wasm): + +On Ubuntu this one option is to install `clang` and `llvm`: +```bash +sudo apt install clang-10 llvm-10 +``` + +Then to compile with all features: +```bash +TARGET_CC=clang-10 TARGET_AR=llvm-ar-10 wasm-pack build --out-dir pkg +``` + +To use a custom subset of features: +```bash +wasm-pack build --out-dir pkg -- --no-default-features --features=issue # issue credential/presentation +wasm-pack build --out-dir pkg -- --no-default-features --features=verify # verify credential/presentation +wasm-pack build --out-dir pkg -- --no-default-features --features=credential # issue/verify credential +wasm-pack build --out-dir pkg -- --no-default-features --features=presentation # issue/verify presentation +``` +*don't forget to add `TARGET_CC` and `TARGET_AR` if using `ring` with `wasm32_c`* diff --git a/didkit-wasm-node/didkit_wasm.d.ts b/didkit-wasm-node/didkit_wasm.d.ts new file mode 100644 index 00000000..11184ad6 --- /dev/null +++ b/didkit-wasm-node/didkit_wasm.d.ts @@ -0,0 +1,156 @@ +/* tslint:disable */ +/* eslint-disable */ +/** +* @returns {string} +*/ +export function getVersion(): string; +/** +* @param {string} did +* @param {string} input_metadata +* @returns {Promise} +*/ +export function resolveDID(did: string, input_metadata: string): Promise; +/** +* @returns {string} +*/ +export function generateEd25519Key(): string; +/** +* @param {string} method_pattern +* @param {string} jwk +* @returns {string} +*/ +export function keyToDID(method_pattern: string, jwk: string): string; +/** +* @param {string} method_pattern +* @param {string} jwk +* @returns {Promise} +*/ +export function keyToVerificationMethod(method_pattern: string, jwk: string): Promise; +/** +* @param {string} credential +* @param {string} proof_options +* @param {string} key +* @returns {Promise} +*/ +export function issueCredential(credential: string, proof_options: string, key: string): Promise; +/** +* @param {string} credential +* @param {string} linked_data_proof_options +* @param {string} public_key +* @returns {Promise} +*/ +export function prepareIssueCredential(credential: string, linked_data_proof_options: string, public_key: string): Promise; +/** +* @param {string} credential +* @param {string} preparation +* @param {string} signature +* @returns {Promise} +*/ +export function completeIssueCredential(credential: string, preparation: string, signature: string): Promise; +/** +* @param {string} vc +* @param {string} proof_options +* @returns {Promise} +*/ +export function verifyCredential(vc: string, proof_options: string): Promise; +/** +* @param {string} presentation +* @param {string} proof_options +* @param {string} key +* @returns {Promise} +*/ +export function issuePresentation(presentation: string, proof_options: string, key: string): Promise; +/** +* @param {string} presentation +* @param {string} linked_data_proof_options +* @param {string} public_key +* @returns {Promise} +*/ +export function prepareIssuePresentation(presentation: string, linked_data_proof_options: string, public_key: string): Promise; +/** +* @param {string} presentation +* @param {string} preparation +* @param {string} signature +* @returns {Promise} +*/ +export function completeIssuePresentation(presentation: string, preparation: string, signature: string): Promise; +/** +* @param {string} vp +* @param {string} proof_options +* @returns {Promise} +*/ +export function verifyPresentation(vp: string, proof_options: string): Promise; +/** +* @param {string} holder +* @param {string} linked_data_proof_options +* @param {string} key +* @returns {Promise} +*/ +export function DIDAuth(holder: string, linked_data_proof_options: string, key: string): Promise; +/** +* @param {string} tz +* @returns {Promise} +*/ +export function JWKFromTezos(tz: string): Promise; +/** +* @param {string} capability +* @param {string} linked_data_proof_options +* @param {string} parents +* @param {string} key +* @returns {Promise} +*/ +export function delegateCapability(capability: string, linked_data_proof_options: string, parents: string, key: string): Promise; +/** +* @param {string} capability +* @param {string} linked_data_proof_options +* @param {string} parents +* @param {string} public_key +* @returns {Promise} +*/ +export function prepareDelegateCapability(capability: string, linked_data_proof_options: string, parents: string, public_key: string): Promise; +/** +* @param {string} capability +* @param {string} preparation +* @param {string} signature +* @returns {Promise} +*/ +export function completeDelegateCapability(capability: string, preparation: string, signature: string): Promise; +/** +* @param {string} delegation +* @returns {Promise} +*/ +export function verifyDelegation(delegation: string): Promise; +/** +* @param {string} invocation +* @param {string} target_id +* @param {string} linked_data_proof_options +* @param {string} key +* @returns {Promise} +*/ +export function invokeCapability(invocation: string, target_id: string, linked_data_proof_options: string, key: string): Promise; +/** +* @param {string} invocation +* @param {string} target_id +* @param {string} linked_data_proof_options +* @param {string} public_key +* @returns {Promise} +*/ +export function prepareInvokeCapability(invocation: string, target_id: string, linked_data_proof_options: string, public_key: string): Promise; +/** +* @param {string} invocation +* @param {string} preparation +* @param {string} signature +* @returns {Promise} +*/ +export function completeInvokeCapability(invocation: string, preparation: string, signature: string): Promise; +/** +* @param {string} invocation +* @returns {Promise} +*/ +export function verifyInvocationSignature(invocation: string): Promise; +/** +* @param {string} invocation +* @param {string} delegation +* @returns {Promise} +*/ +export function verifyInvocation(invocation: string, delegation: string): Promise; diff --git a/didkit-wasm-node/didkit_wasm.js b/didkit-wasm-node/didkit_wasm.js new file mode 100644 index 00000000..1e332338 --- /dev/null +++ b/didkit-wasm-node/didkit_wasm.js @@ -0,0 +1,1042 @@ +let imports = {}; +imports['__wbindgen_placeholder__'] = module.exports; +let wasm; +const { TextDecoder, TextEncoder } = require(`util`); + +let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }); + +cachedTextDecoder.decode(); + +let cachedUint8Memory0 = null; + +function getUint8Memory0() { + if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) { + cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer); + } + return cachedUint8Memory0; +} + +function getStringFromWasm0(ptr, len) { + ptr = ptr >>> 0; + return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len)); +} + +const heap = new Array(128).fill(undefined); + +heap.push(undefined, null, true, false); + +let heap_next = heap.length; + +function addHeapObject(obj) { + if (heap_next === heap.length) heap.push(heap.length + 1); + const idx = heap_next; + heap_next = heap[idx]; + + heap[idx] = obj; + return idx; +} + +function getObject(idx) { return heap[idx]; } + +function dropObject(idx) { + if (idx < 132) return; + heap[idx] = heap_next; + heap_next = idx; +} + +function takeObject(idx) { + const ret = getObject(idx); + dropObject(idx); + return ret; +} + +let WASM_VECTOR_LEN = 0; + +let cachedTextEncoder = new TextEncoder('utf-8'); + +const encodeString = (typeof cachedTextEncoder.encodeInto === 'function' + ? function (arg, view) { + return cachedTextEncoder.encodeInto(arg, view); +} + : function (arg, view) { + const buf = cachedTextEncoder.encode(arg); + view.set(buf); + return { + read: arg.length, + written: buf.length + }; +}); + +function passStringToWasm0(arg, malloc, realloc) { + + if (realloc === undefined) { + const buf = cachedTextEncoder.encode(arg); + const ptr = malloc(buf.length, 1) >>> 0; + getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf); + WASM_VECTOR_LEN = buf.length; + return ptr; + } + + let len = arg.length; + let ptr = malloc(len, 1) >>> 0; + + const mem = getUint8Memory0(); + + let offset = 0; + + for (; offset < len; offset++) { + const code = arg.charCodeAt(offset); + if (code > 0x7F) break; + mem[ptr + offset] = code; + } + + if (offset !== len) { + if (offset !== 0) { + arg = arg.slice(offset); + } + ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0; + const view = getUint8Memory0().subarray(ptr + offset, ptr + len); + const ret = encodeString(arg, view); + + offset += ret.written; + } + + WASM_VECTOR_LEN = offset; + return ptr; +} + +function isLikeNone(x) { + return x === undefined || x === null; +} + +let cachedInt32Memory0 = null; + +function getInt32Memory0() { + if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) { + cachedInt32Memory0 = new Int32Array(wasm.memory.buffer); + } + return cachedInt32Memory0; +} + +function debugString(val) { + // primitive types + const type = typeof val; + if (type == 'number' || type == 'boolean' || val == null) { + return `${val}`; + } + if (type == 'string') { + return `"${val}"`; + } + if (type == 'symbol') { + const description = val.description; + if (description == null) { + return 'Symbol'; + } else { + return `Symbol(${description})`; + } + } + if (type == 'function') { + const name = val.name; + if (typeof name == 'string' && name.length > 0) { + return `Function(${name})`; + } else { + return 'Function'; + } + } + // objects + if (Array.isArray(val)) { + const length = val.length; + let debug = '['; + if (length > 0) { + debug += debugString(val[0]); + } + for(let i = 1; i < length; i++) { + debug += ', ' + debugString(val[i]); + } + debug += ']'; + return debug; + } + // Test for built-in + const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val)); + let className; + if (builtInMatches.length > 1) { + className = builtInMatches[1]; + } else { + // Failed to match the standard '[object ClassName]' + return toString.call(val); + } + if (className == 'Object') { + // we're a user defined class or Object + // JSON.stringify avoids problems with cycles, and is generally much + // easier than looping through ownProperties of `val`. + try { + return 'Object(' + JSON.stringify(val) + ')'; + } catch (_) { + return 'Object'; + } + } + // errors + if (val instanceof Error) { + return `${val.name}: ${val.message}\n${val.stack}`; + } + // TODO we could test for more things here, like `Set`s and `Map`s. + return className; +} + +function makeMutClosure(arg0, arg1, dtor, f) { + const state = { a: arg0, b: arg1, cnt: 1, dtor }; + const real = (...args) => { + // First up with a closure we increment the internal reference + // count. This ensures that the Rust closure environment won't + // be deallocated while we're invoking it. + state.cnt++; + const a = state.a; + state.a = 0; + try { + return f(a, state.b, ...args); + } finally { + if (--state.cnt === 0) { + wasm.__wbindgen_export_2.get(state.dtor)(a, state.b); + + } else { + state.a = a; + } + } + }; + real.original = state; + + return real; +} +function __wbg_adapter_26(arg0, arg1, arg2) { + wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__ha6fd15ca33f50672(arg0, arg1, addHeapObject(arg2)); +} + +/** +* @returns {string} +*/ +module.exports.getVersion = function() { + let deferred1_0; + let deferred1_1; + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.getVersion(retptr); + var r0 = getInt32Memory0()[retptr / 4 + 0]; + var r1 = getInt32Memory0()[retptr / 4 + 1]; + deferred1_0 = r0; + deferred1_1 = r1; + return getStringFromWasm0(r0, r1); + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + wasm.__wbindgen_free(deferred1_0, deferred1_1, 1); + } +}; + +/** +* @param {string} did +* @param {string} input_metadata +* @returns {Promise} +*/ +module.exports.resolveDID = function(did, input_metadata) { + const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(input_metadata, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ret = wasm.resolveDID(ptr0, len0, ptr1, len1); + return takeObject(ret); +}; + +/** +* @returns {string} +*/ +module.exports.generateEd25519Key = function() { + let deferred2_0; + let deferred2_1; + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.generateEd25519Key(retptr); + var r0 = getInt32Memory0()[retptr / 4 + 0]; + var r1 = getInt32Memory0()[retptr / 4 + 1]; + var r2 = getInt32Memory0()[retptr / 4 + 2]; + var r3 = getInt32Memory0()[retptr / 4 + 3]; + 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_free(deferred2_0, deferred2_1, 1); + } +}; + +/** +* @param {string} method_pattern +* @param {string} jwk +* @returns {string} +*/ +module.exports.keyToDID = function(method_pattern, jwk) { + let deferred4_0; + let deferred4_1; + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + const ptr0 = passStringToWasm0(method_pattern, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(jwk, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + wasm.keyToDID(retptr, ptr0, len0, ptr1, len1); + var r0 = getInt32Memory0()[retptr / 4 + 0]; + var r1 = getInt32Memory0()[retptr / 4 + 1]; + var r2 = getInt32Memory0()[retptr / 4 + 2]; + var r3 = getInt32Memory0()[retptr / 4 + 3]; + var ptr3 = r0; + var len3 = r1; + if (r3) { + ptr3 = 0; len3 = 0; + throw takeObject(r2); + } + deferred4_0 = ptr3; + deferred4_1 = len3; + return getStringFromWasm0(ptr3, len3); + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + wasm.__wbindgen_free(deferred4_0, deferred4_1, 1); + } +}; + +/** +* @param {string} method_pattern +* @param {string} jwk +* @returns {Promise} +*/ +module.exports.keyToVerificationMethod = function(method_pattern, jwk) { + const ptr0 = passStringToWasm0(method_pattern, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(jwk, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ret = wasm.keyToVerificationMethod(ptr0, len0, ptr1, len1); + return takeObject(ret); +}; + +/** +* @param {string} credential +* @param {string} proof_options +* @param {string} key +* @returns {Promise} +*/ +module.exports.issueCredential = function(credential, proof_options, key) { + const ptr0 = passStringToWasm0(credential, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ptr2 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len2 = WASM_VECTOR_LEN; + const ret = wasm.issueCredential(ptr0, len0, ptr1, len1, ptr2, len2); + return takeObject(ret); +}; + +/** +* @param {string} credential +* @param {string} linked_data_proof_options +* @param {string} public_key +* @returns {Promise} +*/ +module.exports.prepareIssueCredential = function(credential, linked_data_proof_options, public_key) { + const ptr0 = passStringToWasm0(credential, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ptr2 = passStringToWasm0(public_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len2 = WASM_VECTOR_LEN; + const ret = wasm.prepareIssueCredential(ptr0, len0, ptr1, len1, ptr2, len2); + return takeObject(ret); +}; + +/** +* @param {string} credential +* @param {string} preparation +* @param {string} signature +* @returns {Promise} +*/ +module.exports.completeIssueCredential = function(credential, preparation, signature) { + const ptr0 = passStringToWasm0(credential, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(preparation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ptr2 = passStringToWasm0(signature, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len2 = WASM_VECTOR_LEN; + const ret = wasm.completeIssueCredential(ptr0, len0, ptr1, len1, ptr2, len2); + return takeObject(ret); +}; + +/** +* @param {string} vc +* @param {string} proof_options +* @returns {Promise} +*/ +module.exports.verifyCredential = function(vc, proof_options) { + const ptr0 = passStringToWasm0(vc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ret = wasm.verifyCredential(ptr0, len0, ptr1, len1); + return takeObject(ret); +}; + +/** +* @param {string} presentation +* @param {string} proof_options +* @param {string} key +* @returns {Promise} +*/ +module.exports.issuePresentation = function(presentation, proof_options, key) { + const ptr0 = passStringToWasm0(presentation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ptr2 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len2 = WASM_VECTOR_LEN; + const ret = wasm.issuePresentation(ptr0, len0, ptr1, len1, ptr2, len2); + return takeObject(ret); +}; + +/** +* @param {string} presentation +* @param {string} linked_data_proof_options +* @param {string} public_key +* @returns {Promise} +*/ +module.exports.prepareIssuePresentation = function(presentation, linked_data_proof_options, public_key) { + const ptr0 = passStringToWasm0(presentation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ptr2 = passStringToWasm0(public_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len2 = WASM_VECTOR_LEN; + const ret = wasm.prepareIssuePresentation(ptr0, len0, ptr1, len1, ptr2, len2); + return takeObject(ret); +}; + +/** +* @param {string} presentation +* @param {string} preparation +* @param {string} signature +* @returns {Promise} +*/ +module.exports.completeIssuePresentation = function(presentation, preparation, signature) { + const ptr0 = passStringToWasm0(presentation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(preparation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ptr2 = passStringToWasm0(signature, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len2 = WASM_VECTOR_LEN; + const ret = wasm.completeIssuePresentation(ptr0, len0, ptr1, len1, ptr2, len2); + return takeObject(ret); +}; + +/** +* @param {string} vp +* @param {string} proof_options +* @returns {Promise} +*/ +module.exports.verifyPresentation = function(vp, proof_options) { + const ptr0 = passStringToWasm0(vp, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ret = wasm.verifyPresentation(ptr0, len0, ptr1, len1); + return takeObject(ret); +}; + +/** +* @param {string} holder +* @param {string} linked_data_proof_options +* @param {string} key +* @returns {Promise} +*/ +module.exports.DIDAuth = function(holder, linked_data_proof_options, key) { + const ptr0 = passStringToWasm0(holder, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ptr2 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len2 = WASM_VECTOR_LEN; + const ret = wasm.DIDAuth(ptr0, len0, ptr1, len1, ptr2, len2); + return takeObject(ret); +}; + +/** +* @param {string} tz +* @returns {Promise} +*/ +module.exports.JWKFromTezos = function(tz) { + const ptr0 = passStringToWasm0(tz, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.JWKFromTezos(ptr0, len0); + return takeObject(ret); +}; + +/** +* @param {string} capability +* @param {string} linked_data_proof_options +* @param {string} parents +* @param {string} key +* @returns {Promise} +*/ +module.exports.delegateCapability = function(capability, linked_data_proof_options, parents, key) { + const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ptr2 = passStringToWasm0(parents, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len2 = WASM_VECTOR_LEN; + const ptr3 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len3 = WASM_VECTOR_LEN; + const ret = wasm.delegateCapability(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3); + return takeObject(ret); +}; + +/** +* @param {string} capability +* @param {string} linked_data_proof_options +* @param {string} parents +* @param {string} public_key +* @returns {Promise} +*/ +module.exports.prepareDelegateCapability = function(capability, linked_data_proof_options, parents, public_key) { + const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ptr2 = passStringToWasm0(parents, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len2 = WASM_VECTOR_LEN; + const ptr3 = passStringToWasm0(public_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len3 = WASM_VECTOR_LEN; + const ret = wasm.prepareDelegateCapability(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3); + return takeObject(ret); +}; + +/** +* @param {string} capability +* @param {string} preparation +* @param {string} signature +* @returns {Promise} +*/ +module.exports.completeDelegateCapability = function(capability, preparation, signature) { + const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(preparation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ptr2 = passStringToWasm0(signature, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len2 = WASM_VECTOR_LEN; + const ret = wasm.completeDelegateCapability(ptr0, len0, ptr1, len1, ptr2, len2); + return takeObject(ret); +}; + +/** +* @param {string} delegation +* @returns {Promise} +*/ +module.exports.verifyDelegation = function(delegation) { + const ptr0 = passStringToWasm0(delegation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.verifyDelegation(ptr0, len0); + return takeObject(ret); +}; + +/** +* @param {string} invocation +* @param {string} target_id +* @param {string} linked_data_proof_options +* @param {string} key +* @returns {Promise} +*/ +module.exports.invokeCapability = function(invocation, target_id, linked_data_proof_options, key) { + const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(target_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ptr2 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len2 = WASM_VECTOR_LEN; + const ptr3 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len3 = WASM_VECTOR_LEN; + const ret = wasm.invokeCapability(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3); + return takeObject(ret); +}; + +/** +* @param {string} invocation +* @param {string} target_id +* @param {string} linked_data_proof_options +* @param {string} public_key +* @returns {Promise} +*/ +module.exports.prepareInvokeCapability = function(invocation, target_id, linked_data_proof_options, public_key) { + const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(target_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ptr2 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len2 = WASM_VECTOR_LEN; + const ptr3 = passStringToWasm0(public_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len3 = WASM_VECTOR_LEN; + const ret = wasm.prepareInvokeCapability(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3); + return takeObject(ret); +}; + +/** +* @param {string} invocation +* @param {string} preparation +* @param {string} signature +* @returns {Promise} +*/ +module.exports.completeInvokeCapability = function(invocation, preparation, signature) { + const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(preparation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ptr2 = passStringToWasm0(signature, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len2 = WASM_VECTOR_LEN; + const ret = wasm.completeInvokeCapability(ptr0, len0, ptr1, len1, ptr2, len2); + return takeObject(ret); +}; + +/** +* @param {string} invocation +* @returns {Promise} +*/ +module.exports.verifyInvocationSignature = function(invocation) { + const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.verifyInvocationSignature(ptr0, len0); + return takeObject(ret); +}; + +/** +* @param {string} invocation +* @param {string} delegation +* @returns {Promise} +*/ +module.exports.verifyInvocation = function(invocation, delegation) { + const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(delegation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ret = wasm.verifyInvocation(ptr0, len0, ptr1, len1); + return takeObject(ret); +}; + +function handleError(f, args) { + try { + return f.apply(this, args); + } catch (e) { + wasm.__wbindgen_exn_store(addHeapObject(e)); + } +} + +function getArrayU8FromWasm0(ptr, len) { + ptr = ptr >>> 0; + return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len); +} +function __wbg_adapter_131(arg0, arg1, arg2, arg3) { + wasm.wasm_bindgen__convert__closures__invoke2_mut__h4f86476904f6b069(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3)); +} + +module.exports.__wbindgen_string_new = function(arg0, arg1) { + const ret = getStringFromWasm0(arg0, arg1); + return addHeapObject(ret); +}; + +module.exports.__wbindgen_object_drop_ref = function(arg0) { + takeObject(arg0); +}; + +module.exports.__wbindgen_cb_drop = function(arg0) { + const obj = takeObject(arg0).original; + if (obj.cnt-- == 1) { + obj.a = 0; + return true; + } + const ret = false; + return ret; +}; + +module.exports.__wbindgen_object_clone_ref = function(arg0) { + const ret = getObject(arg0); + return addHeapObject(ret); +}; + +module.exports.__wbg_fetch_b5d6bebed1e6c2d2 = function(arg0) { + const ret = fetch(getObject(arg0)); + return addHeapObject(ret); +}; + +module.exports.__wbg_fetch_8eaf01857a5bb21f = function(arg0, arg1) { + const ret = getObject(arg0).fetch(getObject(arg1)); + return addHeapObject(ret); +}; + +module.exports.__wbg_new_1eead62f64ca15ce = function() { return handleError(function () { + const ret = new Headers(); + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_append_fda9e3432e3e88da = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) { + getObject(arg0).append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4)); +}, arguments) }; + +module.exports.__wbindgen_string_get = function(arg0, arg1) { + const obj = getObject(arg1); + const ret = typeof(obj) === 'string' ? obj : undefined; + var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + var len1 = WASM_VECTOR_LEN; + getInt32Memory0()[arg0 / 4 + 1] = len1; + getInt32Memory0()[arg0 / 4 + 0] = ptr1; +}; + +module.exports.__wbg_instanceof_Response_fc4327dbfcdf5ced = function(arg0) { + let result; + try { + result = getObject(arg0) instanceof Response; + } catch { + result = false; + } + const ret = result; + return ret; +}; + +module.exports.__wbg_url_8503de97f69da463 = function(arg0, arg1) { + const ret = getObject(arg1).url; + const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + getInt32Memory0()[arg0 / 4 + 1] = len1; + getInt32Memory0()[arg0 / 4 + 0] = ptr1; +}; + +module.exports.__wbg_status_ac85a3142a84caa2 = function(arg0) { + const ret = getObject(arg0).status; + return ret; +}; + +module.exports.__wbg_headers_b70de86b8e989bc0 = function(arg0) { + const ret = getObject(arg0).headers; + return addHeapObject(ret); +}; + +module.exports.__wbg_arrayBuffer_288fb3538806e85c = function() { return handleError(function (arg0) { + const ret = getObject(arg0).arrayBuffer(); + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_newwithstrandinit_cad5cd6038c7ff5d = function() { return handleError(function (arg0, arg1, arg2) { + const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2)); + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_signal_4bd18fb489af2d4c = function(arg0) { + const ret = getObject(arg0).signal; + return addHeapObject(ret); +}; + +module.exports.__wbg_new_55c9955722952374 = function() { return handleError(function () { + const ret = new AbortController(); + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_abort_654b796176d117aa = function(arg0) { + getObject(arg0).abort(); +}; + +module.exports.__wbg_randomFillSync_85b3f4c52c56c313 = function(arg0, arg1, arg2) { + getObject(arg0).randomFillSync(getArrayU8FromWasm0(arg1, arg2)); +}; + +module.exports.__wbg_getRandomValues_cd175915511f705e = function(arg0, arg1) { + getObject(arg0).getRandomValues(getObject(arg1)); +}; + +module.exports.__wbg_self_7eede1f4488bf346 = function() { return handleError(function () { + const ret = self.self; + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_crypto_c909fb428dcbddb6 = function(arg0) { + const ret = getObject(arg0).crypto; + return addHeapObject(ret); +}; + +module.exports.__wbg_msCrypto_511eefefbfc70ae4 = function(arg0) { + const ret = getObject(arg0).msCrypto; + return addHeapObject(ret); +}; + +module.exports.__wbindgen_is_undefined = function(arg0) { + const ret = getObject(arg0) === undefined; + return ret; +}; + +module.exports.__wbg_static_accessor_MODULE_ef3aa2eb251158a5 = function() { + const ret = module; + return addHeapObject(ret); +}; + +module.exports.__wbg_require_900d5c3984fe7703 = function(arg0, arg1, arg2) { + const ret = getObject(arg0).require(getStringFromWasm0(arg1, arg2)); + return addHeapObject(ret); +}; + +module.exports.__wbg_getRandomValues_307049345d0bd88c = function(arg0) { + const ret = getObject(arg0).getRandomValues; + return addHeapObject(ret); +}; + +module.exports.__wbg_crypto_c48a774b022d20ac = function(arg0) { + const ret = getObject(arg0).crypto; + return addHeapObject(ret); +}; + +module.exports.__wbindgen_is_object = function(arg0) { + const val = getObject(arg0); + const ret = typeof(val) === 'object' && val !== null; + return ret; +}; + +module.exports.__wbg_process_298734cf255a885d = function(arg0) { + const ret = getObject(arg0).process; + return addHeapObject(ret); +}; + +module.exports.__wbg_versions_e2e78e134e3e5d01 = function(arg0) { + const ret = getObject(arg0).versions; + return addHeapObject(ret); +}; + +module.exports.__wbg_node_1cd7a5d853dbea79 = function(arg0) { + const ret = getObject(arg0).node; + return addHeapObject(ret); +}; + +module.exports.__wbindgen_is_string = function(arg0) { + const ret = typeof(getObject(arg0)) === 'string'; + return ret; +}; + +module.exports.__wbg_msCrypto_bcb970640f50a1e8 = function(arg0) { + const ret = getObject(arg0).msCrypto; + return addHeapObject(ret); +}; + +module.exports.__wbg_require_8f08ceecec0f4fee = function() { return handleError(function () { + const ret = module.require; + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbindgen_is_function = function(arg0) { + const ret = typeof(getObject(arg0)) === 'function'; + return ret; +}; + +module.exports.__wbg_getRandomValues_37fa2ca9e4e07fab = function() { return handleError(function (arg0, arg1) { + getObject(arg0).getRandomValues(getObject(arg1)); +}, arguments) }; + +module.exports.__wbg_randomFillSync_dc1e9a60c158336d = function() { return handleError(function (arg0, arg1) { + getObject(arg0).randomFillSync(takeObject(arg1)); +}, arguments) }; + +module.exports.__wbg_newnoargs_581967eacc0e2604 = function(arg0, arg1) { + const ret = new Function(getStringFromWasm0(arg0, arg1)); + return addHeapObject(ret); +}; + +module.exports.__wbg_next_526fc47e980da008 = function(arg0) { + const ret = getObject(arg0).next; + return addHeapObject(ret); +}; + +module.exports.__wbg_next_ddb3312ca1c4e32a = function() { return handleError(function (arg0) { + const ret = getObject(arg0).next(); + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_done_5c1f01fb660d73b5 = function(arg0) { + const ret = getObject(arg0).done; + return ret; +}; + +module.exports.__wbg_value_1695675138684bd5 = function(arg0) { + const ret = getObject(arg0).value; + return addHeapObject(ret); +}; + +module.exports.__wbg_iterator_97f0c81209c6c35a = function() { + const ret = Symbol.iterator; + return addHeapObject(ret); +}; + +module.exports.__wbg_get_97b561fb56f034b5 = function() { return handleError(function (arg0, arg1) { + const ret = Reflect.get(getObject(arg0), getObject(arg1)); + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_call_cb65541d95d71282 = function() { return handleError(function (arg0, arg1) { + const ret = getObject(arg0).call(getObject(arg1)); + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_new_b51585de1b234aff = function() { + const ret = new Object(); + return addHeapObject(ret); +}; + +module.exports.__wbg_self_1ff1d729e9aae938 = function() { return handleError(function () { + const ret = self.self; + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_window_5f4faef6c12b79ec = function() { return handleError(function () { + const ret = window.window; + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_globalThis_1d39714405582d3c = function() { return handleError(function () { + const ret = globalThis.globalThis; + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_global_651f05c6a0944d1c = function() { return handleError(function () { + const ret = global.global; + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_call_01734de55d61e11d = function() { return handleError(function (arg0, arg1, arg2) { + const ret = getObject(arg0).call(getObject(arg1), getObject(arg2)); + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_getTime_5e2054f832d82ec9 = function(arg0) { + const ret = getObject(arg0).getTime(); + return ret; +}; + +module.exports.__wbg_new0_c0be7df4b6bd481f = function() { + const ret = new Date(); + return addHeapObject(ret); +}; + +module.exports.__wbg_new_43f1b47c28813cbd = function(arg0, arg1) { + try { + var state0 = {a: arg0, b: arg1}; + var cb0 = (arg0, arg1) => { + const a = state0.a; + state0.a = 0; + try { + return __wbg_adapter_131(a, state0.b, arg0, arg1); + } finally { + state0.a = a; + } + }; + const ret = new Promise(cb0); + return addHeapObject(ret); + } finally { + state0.a = state0.b = 0; + } +}; + +module.exports.__wbg_resolve_53698b95aaf7fcf8 = function(arg0) { + const ret = Promise.resolve(getObject(arg0)); + return addHeapObject(ret); +}; + +module.exports.__wbg_then_f7e06ee3c11698eb = function(arg0, arg1) { + const ret = getObject(arg0).then(getObject(arg1)); + return addHeapObject(ret); +}; + +module.exports.__wbg_then_b2267541e2a73865 = function(arg0, arg1, arg2) { + const ret = getObject(arg0).then(getObject(arg1), getObject(arg2)); + return addHeapObject(ret); +}; + +module.exports.__wbg_buffer_085ec1f694018c4f = function(arg0) { + const ret = getObject(arg0).buffer; + return addHeapObject(ret); +}; + +module.exports.__wbg_newwithbyteoffsetandlength_6da8e527659b86aa = function(arg0, arg1, arg2) { + const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0); + return addHeapObject(ret); +}; + +module.exports.__wbg_new_8125e318e6245eed = function(arg0) { + const ret = new Uint8Array(getObject(arg0)); + return addHeapObject(ret); +}; + +module.exports.__wbg_set_5cf90238115182c3 = function(arg0, arg1, arg2) { + getObject(arg0).set(getObject(arg1), arg2 >>> 0); +}; + +module.exports.__wbg_length_72e2208bbc0efc61 = function(arg0) { + const ret = getObject(arg0).length; + return ret; +}; + +module.exports.__wbg_newwithlength_e5d69174d6984cd7 = function(arg0) { + const ret = new Uint8Array(arg0 >>> 0); + return addHeapObject(ret); +}; + +module.exports.__wbg_subarray_13db269f57aa838d = function(arg0, arg1, arg2) { + const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0); + return addHeapObject(ret); +}; + +module.exports.__wbg_has_c5fcd020291e56b8 = function() { return handleError(function (arg0, arg1) { + const ret = Reflect.has(getObject(arg0), getObject(arg1)); + return ret; +}, arguments) }; + +module.exports.__wbg_set_092e06b0f9d71865 = function() { return handleError(function (arg0, arg1, arg2) { + const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2)); + return ret; +}, arguments) }; + +module.exports.__wbg_stringify_e25465938f3f611f = function() { return handleError(function (arg0) { + const ret = JSON.stringify(getObject(arg0)); + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbindgen_debug_string = function(arg0, arg1) { + const ret = debugString(getObject(arg1)); + const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + getInt32Memory0()[arg0 / 4 + 1] = len1; + getInt32Memory0()[arg0 / 4 + 0] = ptr1; +}; + +module.exports.__wbindgen_throw = function(arg0, arg1) { + throw new Error(getStringFromWasm0(arg0, arg1)); +}; + +module.exports.__wbindgen_memory = function() { + const ret = wasm.memory; + return addHeapObject(ret); +}; + +module.exports.__wbindgen_closure_wrapper12126 = function(arg0, arg1, arg2) { + const ret = makeMutClosure(arg0, arg1, 3217, __wbg_adapter_26); + return addHeapObject(ret); +}; + +const path = require('path').join(__dirname, 'didkit_wasm_bg.wasm'); +const bytes = require('fs').readFileSync(path); + +const wasmModule = new WebAssembly.Module(bytes); +const wasmInstance = new WebAssembly.Instance(wasmModule, imports); +wasm = wasmInstance.exports; +module.exports.__wasm = wasm; + diff --git a/didkit-wasm-node/didkit_wasm_bg.wasm b/didkit-wasm-node/didkit_wasm_bg.wasm new file mode 100644 index 0000000000000000000000000000000000000000..39a5361a243eedbebe8887bf68322b3989206810 GIT binary patch literal 10267465 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