@fedimint/core-web 0.0.3 → 0.0.5

package/node_modules/fedimint-client-wasm/package.json

@@ -1,26 +0,0 @@
-{
-  "name": "fedimint-client-wasm",
-  "type": "module",
-  "collaborators": [
-    "The Fedimint Developers"
-  ],
-  "description": "fedimint client for wasm",
-  "version": "0.5.0-alpha",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/fedimint/fedimint"
-  },
-  "files": [
-    "fedimint_client_wasm_bg.wasm",
-    "fedimint_client_wasm.js",
-    "fedimint_client_wasm_bg.js",
-    "fedimint_client_wasm.d.ts"
-  ],
-  "main": "fedimint_client_wasm.js",
-  "types": "fedimint_client_wasm.d.ts",
-  "sideEffects": [
-    "./fedimint_client_wasm.js",
-    "./snippets/*"
-  ]
-}

package/src/worker.js

@@ -1,80 +0,0 @@
-// import { WasmClient } from '../wasm/fedimint_client_wasm.js'
-// import { WasmClient } from 'fedimint-client-wasm'
-// import wasm from '../wasm/fedimint_client_wasm_bg.wasm'
-
-let WasmClient = null
-let client = null
-
-const streamCancelMap = new Map()
-
-const handleFree = (requestId) => {
-  streamCancelMap.delete(requestId)
-}
-
-self.onmessage = async (event) => {
-  const { type, payload, requestId } = event.data
-
-  if (type === 'init') {
-    WasmClient = (await import('fedimint-client-wasm')).WasmClient
-    self.postMessage({ type: 'initialized', data: {}, requestId })
-  } else if (type === 'open') {
-    const { clientName } = payload
-    client = (await WasmClient.open(clientName)) || null
-    self.postMessage({
-      type: 'open',
-      data: { success: !!client },
-      requestId,
-    })
-  } else if (type === 'join') {
-    const { inviteCode, clientName: joinClientName } = payload
-    try {
-      client = await WasmClient.join_federation(joinClientName, inviteCode)
-      self.postMessage({
-        type: 'join',
-        data: { success: !!client },
-        requestId,
-      })
-    } catch (e) {
-      self.postMessage({ type: 'error', error: e.message, requestId })
-    }
-  } else if (type === 'rpc') {
-    const { module, method, body } = payload
-    if (!client) {
-      self.postMessage({
-        type: 'error',
-        error: 'WasmClient not initialized',
-        requestId,
-      })
-      return
-    }
-    const rpcHandle = await client.rpc(
-      module,
-      method,
-      JSON.stringify(body),
-      (res) => {
-        const data = JSON.parse(res)
-        self.postMessage({ type: 'rpcResponse', requestId, ...data })
-
-        if (data.end === undefined) return
-
-        // Handle stream ending
-        const handle = streamCancelMap.get(requestId)
-        handle?.free()
-      },
-    )
-    streamCancelMap.set(requestId, rpcHandle)
-  } else if (type === 'unsubscribe') {
-    const rpcHandle = streamCancelMap.get(requestId)
-    if (rpcHandle) {
-      rpcHandle.cancel()
-      rpcHandle.free()
-      streamCancelMap.delete(requestId)
-    }
-  } else {
-    self.postMessage({
-      type: 'error',
-      error: 'Unknown message type',
-      requestId,
-    })
-  }
-}

package/wasm/fedimint_client_wasm.d.ts

@@ -1,49 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-/**
- */
-export class RpcHandle {
-  free(): void
-  /**
-   */
-  cancel(): void
-}
-/**
- */
-export class WasmClient {
-  free(): void
-  /**
-   * Open fedimint client with already joined federation.
-   *
-   * After you have joined a federation, you can reopen the fedimint client
-   * with same client_name. Opening client with same name at same time is
-   * not supported. You can close the current client by calling
-   * `client.free()`. NOTE: The client will remain active until all the
-   * running rpc calls have finished.
-   * @param {string} client_name
-   * @returns {Promise<WasmClient | undefined>}
-   */
-  static open(client_name: string): Promise<WasmClient | undefined>
-  /**
-   * Open a fedimint client by join a federation.
-   * @param {string} client_name
-   * @param {string} invite_code
-   * @returns {Promise<WasmClient>}
-   */
-  static join_federation(
-    client_name: string,
-    invite_code: string,
-  ): Promise<WasmClient>
-  /**
-   * Call a fedimint client rpc the responses are returned using `cb`
-   * callback. Each rpc call *can* return multiple responses by calling
-   * `cb` multiple times. The returned RpcHandle can be used to cancel the
-   * operation.
-   * @param {string} module
-   * @param {string} method
-   * @param {string} payload
-   * @param {Function} cb
-   * @returns {RpcHandle}
-   */
-  rpc(module: string, method: string, payload: string, cb: Function): RpcHandle
-}

package/wasm/fedimint_client_wasm.js

@@ -1,4 +0,0 @@
-import * as wasm from './fedimint_client_wasm_bg.wasm'
-import { __wbg_set_wasm } from './fedimint_client_wasm_bg.js'
-__wbg_set_wasm(wasm)
-export * from './fedimint_client_wasm_bg.js'