@fedimint/core-web 0.0.0-canary-20240910231647

package/README.md

@@ -0,0 +1,38 @@
+# @fedimint/core-web
+
+### THIS IS A WORK IN PROGRESS AND NOT READY FOR USE
+
+This package provides a typescript interface for the Fedimint client in the browser
+
+## Installation
+
+```sh
+pnpm add @fedimint/core-web
+```
+
+## Usage
+
+```ts
+import { FedimintWallet } from '@fedimint/core-web'
+
+// federation invite code
+const inviteCode = 'fed11qgqpw9thwvaz7t...'
+
+// This should be called only once
+await FedimintWallet.initFedimint()
+
+const wallet = await FedimintWallet.joinFederation(inviteCode)
+
+// Get Wallet Balance
+const balance = await wallet.getBalance()
+
+// Receive Ecash Payments
+await wallet.reissueNotes('A11qgqpw9thwvaz7t...')
+
+// Pay Lightning Invoice
+await wallet.payInvoice('lnbc...')
+```
+
+## Check out the example
+
+[`examples/vite-core`](../examples/vite-core/README.md)

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@fedimint/core-web",
+  "description": "Library for building web apps with a fedimint client",
+  "version": "0.0.0-canary-20240910231647",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fedimint/fedimint-web-sdk.git",
+    "directory": "packages/core-web"
+  },
+  "files": [
+    "dist",
+    "wasm",
+    "src"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "devDependencies": {
+    "@types/node": "^20.14.8",
+    "typescript": "^5.2.2"
+  },
+  "scripts": {
+    "build": "pnpm run clean && tsc --project tsconfig.json",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "clean:deep": "pnpm run clean && rm -rf node_modules",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/FedimintWallet.ts

@@ -0,0 +1,163 @@
+import init, { RpcHandle, WasmClient } from '../wasm/fedimint_client_wasm.js'
+
+type StreamError = {
+  error: string
+  data: never
+}
+
+type StreamSuccess = {
+  data: {} | [] | null | undefined | number | string | boolean
+  error: never
+}
+
+type StreamResult = StreamSuccess | StreamError
+
+type Body = string | null | Record<string, string | null>
+
+const DEFAULT_CLIENT_NAME = 'fm-default' as const
+
+export class FedimintWallet {
+  private _fed: WasmClient | null = null
+  private initPromise: Promise<void> | null = null
+  private openPromise: Promise<void> | null = null
+  private resolveOpen: () => void = () => {}
+
+  constructor(lazy: boolean = false) {
+    if (lazy) return
+    this.initialize()
+    this.openPromise = new Promise((resolve) => {
+      this.resolveOpen = resolve
+    })
+  }
+
+  // Setup
+  async initialize() {
+    if (this.initPromise) return this.initPromise
+    // this.worker = new Worker(new URL('./wasm.worker.ts', import.meta.url))
+    this.initPromise = init().then(() => {
+      console.trace('Fedimint Client Wasm Initialization complete')
+    })
+    return this.initPromise
+  }
+
+  async open(clientName: string = DEFAULT_CLIENT_NAME) {
+    await this.initialize()
+    const wasm = await WasmClient.open(clientName)
+
+    if (wasm === undefined) return false
+    this._fed = wasm
+    this.resolveOpen()
+    return true
+  }
+
+  async joinFederation(
+    inviteCode: string,
+    clientName: string = DEFAULT_CLIENT_NAME,
+  ) {
+    await this.initialize()
+    this._fed = await WasmClient.join_federation(clientName, inviteCode)
+    this.resolveOpen()
+  }
+
+  // RPC
+  private async _rpcStream(
+    module: string,
+    method: string,
+    body: Body = {},
+    onSuccess: (res: StreamSuccess['data']) => void,
+    onError: (res: StreamError['error']) => void,
+  ): Promise<RpcHandle> {
+    await this.openPromise
+    if (!this._fed) throw new Error('FedimintWallet is not open')
+    const unsubscribe = await this._fed.rpc(
+      module,
+      method,
+      JSON.stringify(body),
+      (res: string) => {
+        const parsed = JSON.parse(res) as StreamResult
+        if (parsed.error) {
+          onError(parsed.error)
+        } else {
+          onSuccess(parsed.data)
+        }
+      },
+    )
+    return unsubscribe
+  }
+
+  private async _rpcSingle(module: string, method: string, body: Body = {}) {
+    return new Promise((resolve, reject) => {
+      if (!this._fed) return reject('FedimintWallet is not open')
+      this._fed.rpc(module, method, JSON.stringify(body), (res: string) => {
+        const parsed = JSON.parse(res) as StreamResult
+        if (parsed.error) {
+          reject(parsed.error)
+        } else {
+          resolve(parsed.data)
+        }
+      })
+    })
+  }
+
+  // Client
+
+  async getBalance(): Promise<number> {
+    return (await this._rpcSingle('', 'get_balance')) as number
+  }
+
+  // LN
+
+  async payInvoice(invoice: string): Promise<void> {
+    await this._rpcSingle('ln', 'pay_bolt11_invoice', {
+      invoice,
+    })
+  }
+
+  // async listGateways() {
+  //   return await this._rpcSingle("ln", "list_gateways");
+  // }
+  //
+  // async verifyGateways() {
+  //   return await this._rpcSingle("ln", "verify_gateway_availability");
+  // }
+
+  // Mint
+
+  async redeemEcash(notes: string): Promise<void> {
+    await this._rpcSingle('mint', 'reissue_external_notes', {
+      oob_notes: notes, // "out of band notes"
+      extra_meta: null,
+    })
+  }
+
+  // Teardown
+  async cleanup() {
+    await this._fed?.free()
+  }
+
+  isOpen() {
+    return this._fed !== null
+  }
+
+  // Streaming
+
+  subscribeBalance(
+    onSuccess: (balance: number) => void = () => {},
+    onError: (error: string) => void = () => {},
+  ) {
+    const unsubscribe = this._rpcStream(
+      '',
+      'subscribe_balance_changes',
+      {},
+      (res) => onSuccess(parseInt(res as string)),
+      onError,
+    )
+
+    return () => {
+      unsubscribe.then((unsub) => {
+        unsub.cancel()
+        unsub.free()
+      })
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+import { FedimintWallet } from './FedimintWallet.js'
+
+export { FedimintWallet }

package/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/src/wasm.worker.ts

@@ -0,0 +1,41 @@
+// import init, { InitOutput, WasmClient } from '../wasm/fedimint_client_wasm.js'
+
+// let client: WasmClient | undefined
+
+// async function workerInit() {
+//   await init(new URL('@fedi/common/wasm/fedi_wasm_bg.wasm', import.meta.url))
+// }
+
+// const initPromise = workerInit().catch((error) =>
+//   postMessage({ error: String(error) }),
+// )
+
+// async function rpcRequest(method: string, data: string): Promise<string> {
+//   await initPromise
+//   return await fedimint_rpc(method, data)
+// }
+
+// const handleMessage = async (token: string, method: string, data: string) => {
+//   if (method === 'open') {
+//     await initPromise
+//     client = await WasmClient.open(data)
+//     if (client !== undefined) {
+//       postMessage({ token, result: true })
+//     } else {
+//       postMessage({ token, result: false })
+//     }
+//   } else if (method === 'join_federation') {
+//     await initPromise
+//     const result = await WasmClient.join_federation(data)
+//     postMessage({ token, result })
+//   }
+// }
+
+// // Handles worker.postMessage calls
+// addEventListener('message', (e) => {
+//   const { token, method, data } = e.data
+//   handleMessage(token, method, data)
+//   // rpcRequest(method, data)
+//   //   .then((result) => postMessage({ token, result }))
+//   //   .catch((error) => postMessage({ error: String(error) }))
+// })

package/wasm/fedimint_client_wasm.d.ts

@@ -0,0 +1,104 @@
+/* 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;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly __wbg_wasmclient_free: (a: number) => void;
+  readonly __wbg_rpchandle_free: (a: number) => void;
+  readonly rpchandle_cancel: (a: number) => void;
+  readonly wasmclient_open: (a: number, b: number) => number;
+  readonly wasmclient_join_federation: (a: number, b: number, c: number, d: number) => number;
+  readonly wasmclient_rpc: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+  readonly ring_core_0_17_8_bn_mul_mont: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly rustsecp256k1zkp_v0_8_0_default_illegal_callback_fn: (a: number, b: number) => void;
+  readonly rustsecp256k1zkp_v0_8_0_default_error_callback_fn: (a: number, b: number) => void;
+  readonly rustsecp256k1_v0_6_1_context_create: (a: number) => number;
+  readonly rustsecp256k1_v0_6_1_context_destroy: (a: number) => void;
+  readonly rustsecp256k1_v0_6_1_default_illegal_callback_fn: (a: number, b: number) => void;
+  readonly rustsecp256k1_v0_6_1_default_error_callback_fn: (a: number, b: number) => void;
+  readonly rustsecp256k1_v0_8_1_context_create: (a: number) => number;
+  readonly rustsecp256k1_v0_8_1_context_destroy: (a: number) => void;
+  readonly rustsecp256k1_v0_8_1_default_illegal_callback_fn: (a: number, b: number) => void;
+  readonly rustsecp256k1_v0_8_1_default_error_callback_fn: (a: number, b: number) => void;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_export_2: WebAssembly.Table;
+  readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+  readonly _dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h8697e16cd1c64495: (a: number, b: number, c: number, d: number) => void;
+  readonly _dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h31a94cc9a05d5ca0: (a: number, b: number, c: number) => void;
+  readonly _dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h4d11ec113460b95d: (a: number, b: number) => void;
+  readonly _dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__he7056307c6986185: (a: number, b: number, c: number, d: number) => void;
+  readonly _dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h5b16159cdfa166b0: (a: number, b: number) => void;
+  readonly _dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hebf1bd391d12b3cb: (a: number, b: number, c: number) => void;
+  readonly _dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h09ee3e3abd173580: (a: number, b: number) => void;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly wasm_bindgen__convert__closures__invoke2_mut__h8bdaa9faeb7d5075: (a: number, b: number, c: number, d: number) => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {SyncInitInput} module
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {InitInput | Promise<InitInput>} module_or_path
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: InitInput | Promise<InitInput>): Promise<InitOutput>;