@inversealtruism/cairn-sdk 0.1.2 → 0.1.3

package/dist/react.cjs

@@ -0,0 +1,353 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react.ts
+var react_exports = {};
+__export(react_exports, {
+  CairnController: () => CairnController,
+  createCairnHooks: () => createCairnHooks
+});
+module.exports = __toCommonJS(react_exports);
+
+// src/errors.ts
+var SDK_VERSION = "0.1.2";
+var DOCS_BASE = "https://cairn-substrate.com/docs/sdk";
+var CairnError = class extends Error {
+  /** Stable machine code for programmatic branching. */
+  code;
+  /** The human message without the appended docs/version footer. */
+  shortMessage;
+  /** Relative docs path (under the SDK docs base), if any. */
+  docsPath;
+  /** The cairn-sdk version that produced this error. */
+  version = SDK_VERSION;
+  constructor(shortMessage, opts = {}) {
+    const docs = opts.docsPath;
+    super(
+      [shortMessage, docs ? `Docs: ${DOCS_BASE}${docs}` : "", `Version: cairn-sdk@${SDK_VERSION}`].filter(Boolean).join("\n"),
+      { cause: opts.cause }
+    );
+    this.name = new.target.name;
+    this.code = opts.code ?? "UNKNOWN";
+    this.shortMessage = shortMessage;
+    this.docsPath = docs;
+  }
+  /**
+   * Walk the `cause` chain. With a predicate, returns the FIRST matching error (or null). Without one,
+   * returns the DEEPEST cause (the root). Mirrors viem's `BaseError.walk()`.
+   */
+  walk(fn) {
+    let current = this;
+    let last = this;
+    while (current != null) {
+      if (fn && fn(current)) return current;
+      last = current;
+      current = current?.cause;
+    }
+    return fn ? null : last;
+  }
+};
+var NotInstalledError = class extends CairnError {
+  constructor(message = "Cairn Wallet not detected. Install it from cairn-substrate.com.") {
+    super(message, { code: "NOT_INSTALLED", docsPath: "/install" });
+  }
+};
+var UserRejectedError = class extends CairnError {
+  constructor(message = "Request rejected by user.") {
+    super(message, { code: "USER_REJECTED", docsPath: "/errors#user-rejected" });
+  }
+};
+var WalletLockedError = class extends CairnError {
+  constructor(message = "Wallet is locked.") {
+    super(message, { code: "WALLET_LOCKED", docsPath: "/errors#wallet-locked" });
+  }
+};
+var UnsupportedMethodError = class extends CairnError {
+  constructor(message = "Method not supported by the wallet.") {
+    super(message, { code: "UNSUPPORTED_METHOD", docsPath: "/errors#unsupported-method" });
+  }
+};
+function mapProviderError(error) {
+  const e = String(error || "").toLowerCase();
+  if (e.includes("rejected by user")) return new UserRejectedError(error);
+  if (e.includes("wallet locked")) return new WalletLockedError(error);
+  if (e.includes("unsupported dapp method") || e.includes("predates") || e.includes("too old")) return new UnsupportedMethodError(error);
+  return new CairnError(error || "Unknown wallet error");
+}
+
+// src/connect.ts
+function detectProvider(opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 3e3;
+  return new Promise((resolve, reject) => {
+    if (typeof window === "undefined") {
+      reject(new NotInstalledError("Not running in a browser \u2014 `window.cairn` is unavailable."));
+      return;
+    }
+    let done = false;
+    const finish = (p) => {
+      if (done) return;
+      done = true;
+      cleanup();
+      resolve(p);
+    };
+    const onInit = () => {
+      if (!done && window.cairn?.isCairn) finish(window.cairn);
+    };
+    const onAnnounce = (ev) => {
+      const p = ev?.detail?.provider;
+      if (p?.isCairn) finish(p);
+    };
+    const timer = setTimeout(() => {
+      if (done) return;
+      done = true;
+      cleanup();
+      reject(new NotInstalledError());
+    }, timeoutMs);
+    const cleanup = () => {
+      clearTimeout(timer);
+      window.removeEventListener("cairn#initialized", onInit);
+      window.removeEventListener("csd:announceProvider", onAnnounce);
+    };
+    window.addEventListener("cairn#initialized", onInit);
+    window.addEventListener("csd:announceProvider", onAnnounce);
+    if (window.cairn?.isCairn) {
+      finish(window.cairn);
+      return;
+    }
+    window.dispatchEvent(new CustomEvent("csd:requestProvider"));
+    onInit();
+  });
+}
+function unwrap(reply) {
+  if (reply && reply.ok) return reply.result;
+  throw mapProviderError(reply?.error ?? "Unknown wallet error");
+}
+var WalletConnection = class {
+  provider;
+  _addr = null;
+  constructor(provider) {
+    this.provider = provider;
+  }
+  /** The wallet's version string (e.g. "0.2.x"). */
+  get version() {
+    return this.provider.version;
+  }
+  /** The connected address, if `connect()`/`getAddress()` has resolved. */
+  get address() {
+    return this._addr;
+  }
+  /** Request connection. First time per origin prompts the user; afterwards may be silent. */
+  async connect() {
+    const { addr } = unwrap(await this.provider.connect());
+    this._addr = addr;
+    return addr;
+  }
+  /** Get the connected address (does not force a new connection prompt if already consented). */
+  async getAddress() {
+    const { addr } = unwrap(await this.provider.getAddress());
+    this._addr = addr;
+    return addr;
+  }
+  /**
+   * @deprecated First-party-only legacy login (it authenticates against the wallet's own configured
+   * server and is rejected from third-party origins). Use {@link signInWithCsd} for any site.
+   * Passwordless sign-in: a signature over a login nonce (always prompts; structurally cannot sign a tx).
+   */
+  signIn() {
+    return Promise.resolve(this.provider.signIn()).then(unwrap);
+  }
+  /**
+   * Audience-bound "Sign in with CSD" (SIWC) — the secure, replay-resistant third-party login.
+   * The wallet binds the REAL requesting origin + your single-use server `nonce` into the signed
+   * message and returns the artifact; it never mints a session. VERIFY the result SERVER-SIDE with
+   * `verifySiwc` from `@inversealtruism/csd-siwc` (domain/nonce/chain/time/signature/account), then
+   * issue your OWN session. The signature is proof-of-control, NOT a bearer token. Always prompts.
+   */
+  signInWithCsd(params) {
+    if (!params || typeof params.nonce !== "string" || !params.nonce) {
+      return Promise.reject(new UnsupportedMethodError("signInWithCsd requires a server-issued { nonce }"));
+    }
+    if (typeof this.provider.signInWithCsd !== "function") {
+      return Promise.reject(new UnsupportedMethodError("this wallet predates Sign-in-with-CSD \u2014 ask the user to update the Cairn Wallet"));
+    }
+    return Promise.resolve(this.provider.signInWithCsd(params)).then(unwrap);
+  }
+  /** True if this wallet supports audience-bound SIWC (safe to call `signInWithCsd`). */
+  get supportsSiwc() {
+    return typeof this.provider.signInWithCsd === "function";
+  }
+  /** Feature/capability detection. Returns null if the wallet predates `getCapabilities`. */
+  async getCapabilities() {
+    if (typeof this.provider.getCapabilities !== "function") return null;
+    try {
+      return await this.provider.getCapabilities();
+    } catch {
+      return null;
+    }
+  }
+  /** Atomic fill (CairnX DvP): pay + attest in ONE tx. Always prompts with clear-signing. */
+  fillOffer(params) {
+    return Promise.resolve(this.provider.fillOffer(params)).then(unwrap);
+  }
+  /** This origin's current permission grant (EIP-2255-style). Silent; [] if none / unsupported. */
+  async getPermissions() {
+    if (typeof this.provider.getPermissions !== "function") return [];
+    return unwrap(await this.provider.getPermissions());
+  }
+  /** Explicitly request permission to see the address (prompts, like connect). */
+  requestPermissions() {
+    if (typeof this.provider.requestPermissions !== "function") {
+      return Promise.reject(new UnsupportedMethodError("this wallet predates requestPermissions \u2014 use connect()"));
+    }
+    return Promise.resolve(this.provider.requestPermissions()).then(unwrap);
+  }
+  /** Revoke THIS origin's own access (silent). Returns { revoked }. Safe no-op on older wallets. */
+  async revokePermissions() {
+    if (typeof this.provider.revokePermissions !== "function") return { revoked: false };
+    return unwrap(await this.provider.revokePermissions());
+  }
+  /**
+   * Subscribe to provider events. `accountsChanged` fires with `[]` when this site loses access
+   * (wallet lock / account switch / revoke) — re-call connect() to (re)share; `disconnect` likewise.
+   * No-op if the wallet predates events. Use the SAME handler reference with off() to unsubscribe.
+   */
+  on(event, handler) {
+    this.provider.on?.(event, handler);
+  }
+  /** Remove a previously-added event handler (must be the same reference passed to on()). */
+  off(event, handler) {
+    this.provider.removeListener?.(event, handler);
+  }
+  /** Send CSD (always prompts with clear-signing; wallet picks inputs + returns change to itself). */
+  send(params) {
+    return Promise.resolve(this.provider.send(params)).then(unwrap);
+  }
+  /** Low-level Propose (always prompts). Prefer `cairn.board.propose()` which computes the hash/uri/expiry. */
+  propose(params) {
+    return Promise.resolve(this.provider.propose(params)).then(unwrap);
+  }
+  /** Attest/support a proposal (always prompts). */
+  attest(params) {
+    return Promise.resolve(this.provider.attest(params)).then(unwrap);
+  }
+  /** Seal a commit-reveal claim (always prompts; salt stays inside the wallet). */
+  sealClaim(params) {
+    return Promise.resolve(this.provider.sealClaim(params)).then(unwrap);
+  }
+  /** Reveal a previously sealed claim by its sealing txid (always prompts). */
+  revealClaim(txid) {
+    if (typeof txid !== "string" || !txid) {
+      return Promise.reject(new UnsupportedMethodError("revealClaim requires the sealing txid"));
+    }
+    return Promise.resolve(this.provider.revealClaim(txid)).then(unwrap);
+  }
+};
+async function getWallet(opts = {}) {
+  return new WalletConnection(await detectProvider(opts));
+}
+
+// src/controller.ts
+var DISCONNECTED = Object.freeze({ status: "disconnected", account: null, error: null });
+var CairnController = class {
+  state = DISCONNECTED;
+  conn = null;
+  listeners = /* @__PURE__ */ new Set();
+  getWalletFn;
+  detectOpts;
+  constructor(opts = {}) {
+    const { getWallet: gw, ...detect } = opts;
+    this.getWalletFn = gw ?? getWallet;
+    this.detectOpts = detect;
+  }
+  /** useSyncExternalStore-compatible. Returns an unsubscribe fn. */
+  subscribe = (cb) => {
+    this.listeners.add(cb);
+    return () => {
+      this.listeners.delete(cb);
+    };
+  };
+  /** useSyncExternalStore-compatible snapshot — stable reference until the state actually changes. */
+  getSnapshot = () => this.state;
+  /** The underlying WalletConnection (for advanced use: send/propose/permissions/…). Null until connect(). */
+  get connection() {
+    return this.conn;
+  }
+  setState(patch) {
+    const next = { ...this.state, ...patch };
+    if (next.status === this.state.status && next.account === this.state.account && next.error === this.state.error) return;
+    this.state = Object.freeze(next);
+    for (const l of [...this.listeners]) l();
+  }
+  onAccounts = (accounts) => {
+    if (!Array.isArray(accounts) || accounts.length === 0) this.setState({ status: "disconnected", account: null });
+    else this.setState({ status: "connected", account: String(accounts[0]), error: null });
+  };
+  onDisconnect = () => {
+    this.setState({ status: "disconnected", account: null });
+  };
+  /** Detect + connect (prompts the user the first time per origin). Resolves the connected address. */
+  connect = async () => {
+    this.setState({ status: "connecting", error: null });
+    try {
+      if (!this.conn) {
+        this.conn = await this.getWalletFn(this.detectOpts);
+        this.conn.on("accountsChanged", this.onAccounts);
+        this.conn.on("disconnect", this.onDisconnect);
+      }
+      const addr = await this.conn.connect();
+      this.setState({ status: "connected", account: addr, error: null });
+      return addr;
+    } catch (e) {
+      this.setState({ status: "disconnected", account: null, error: e?.message ?? String(e) });
+      throw e;
+    }
+  };
+  /** Forget the connection locally AND revoke this origin's wallet-side permission (best-effort). */
+  disconnect = async () => {
+    try {
+      await this.conn?.revokePermissions();
+    } catch {
+    }
+    this.setState({ status: "disconnected", account: null, error: null });
+  };
+  /** Audience-bound sign-in (must connect() first). Returns the signed artifact to verify server-side. */
+  signInWithCsd = (params) => {
+    if (!this.conn) return Promise.reject(new Error("call connect() before signInWithCsd()"));
+    return this.conn.signInWithCsd(params);
+  };
+};
+
+// src/react.ts
+function createCairnHooks(React, controllerOrOpts) {
+  const controller = controllerOrOpts instanceof CairnController ? controllerOrOpts : new CairnController(controllerOrOpts);
+  const useCairnState = () => React.useSyncExternalStore(controller.subscribe, controller.getSnapshot, controller.getSnapshot);
+  const useCairnAccount = () => useCairnState().account;
+  const useCairn = () => ({
+    ...useCairnState(),
+    connect: controller.connect,
+    disconnect: controller.disconnect,
+    signInWithCsd: controller.signInWithCsd
+  });
+  return { controller, useCairnState, useCairnAccount, useCairn };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CairnController,
+  createCairnHooks
+});

package/dist/react.d.cts

@@ -0,0 +1,30 @@
+import { CairnController, CairnState, CairnControllerOptions } from './controller.cjs';
+import { SiwcParams, SiwcResult } from './connect.cjs';
+
+/** The minimal slice of React this adapter uses (so it needs no react dependency / @types/react). */
+interface ReactLike {
+    useSyncExternalStore<T>(subscribe: (cb: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T): T;
+}
+/** Reactive state + bound actions returned by useCairn(). */
+type UseCairnResult = CairnState & {
+    connect: () => Promise<string>;
+    disconnect: () => Promise<void>;
+    signInWithCsd: (params: SiwcParams) => Promise<SiwcResult>;
+};
+interface CairnHooks {
+    /** The bound controller (for advanced use outside hooks). */
+    controller: CairnController;
+    /** Reactive full state: { status, account, error }. */
+    useCairnState(): CairnState;
+    /** Reactive account (null when disconnected / locked). */
+    useCairnAccount(): string | null;
+    /** Reactive state + bound actions. */
+    useCairn(): UseCairnResult;
+}
+/**
+ * Build React hooks bound to a CairnController. Pass your app's `React` (or `{ useSyncExternalStore }`).
+ * Optionally pass an existing controller; otherwise one is created from `opts`.
+ */
+declare function createCairnHooks(React: ReactLike, controllerOrOpts?: CairnController | CairnControllerOptions): CairnHooks;
+
+export { CairnController, CairnControllerOptions, type CairnHooks, CairnState, type ReactLike, type UseCairnResult, createCairnHooks };

package/dist/react.d.ts

@@ -0,0 +1,30 @@
+import { CairnController, CairnState, CairnControllerOptions } from './controller.js';
+import { SiwcParams, SiwcResult } from './connect.js';
+
+/** The minimal slice of React this adapter uses (so it needs no react dependency / @types/react). */
+interface ReactLike {
+    useSyncExternalStore<T>(subscribe: (cb: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T): T;
+}
+/** Reactive state + bound actions returned by useCairn(). */
+type UseCairnResult = CairnState & {
+    connect: () => Promise<string>;
+    disconnect: () => Promise<void>;
+    signInWithCsd: (params: SiwcParams) => Promise<SiwcResult>;
+};
+interface CairnHooks {
+    /** The bound controller (for advanced use outside hooks). */
+    controller: CairnController;
+    /** Reactive full state: { status, account, error }. */
+    useCairnState(): CairnState;
+    /** Reactive account (null when disconnected / locked). */
+    useCairnAccount(): string | null;
+    /** Reactive state + bound actions. */
+    useCairn(): UseCairnResult;
+}
+/**
+ * Build React hooks bound to a CairnController. Pass your app's `React` (or `{ useSyncExternalStore }`).
+ * Optionally pass an existing controller; otherwise one is created from `opts`.
+ */
+declare function createCairnHooks(React: ReactLike, controllerOrOpts?: CairnController | CairnControllerOptions): CairnHooks;
+
+export { CairnController, CairnControllerOptions, type CairnHooks, CairnState, type ReactLike, type UseCairnResult, createCairnHooks };

package/dist/react.js

@@ -0,0 +1,23 @@
+import {
+  CairnController
+} from "./chunk-ZAE2BIH5.js";
+import "./chunk-G4OZKZSJ.js";
+import "./chunk-UMGWVOOT.js";
+
+// src/react.ts
+function createCairnHooks(React, controllerOrOpts) {
+  const controller = controllerOrOpts instanceof CairnController ? controllerOrOpts : new CairnController(controllerOrOpts);
+  const useCairnState = () => React.useSyncExternalStore(controller.subscribe, controller.getSnapshot, controller.getSnapshot);
+  const useCairnAccount = () => useCairnState().account;
+  const useCairn = () => ({
+    ...useCairnState(),
+    connect: controller.connect,
+    disconnect: controller.disconnect,
+    signInWithCsd: controller.signInWithCsd
+  });
+  return { controller, useCairnState, useCairnAccount, useCairn };
+}
+export {
+  CairnController,
+  createCairnHooks
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inversealtruism/cairn-sdk",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "The Compute Substrate dApp kit — one cohesive toolkit to connect the Cairn Wallet, read the chain/board, publish self-certifying content, and resolve registries. Composes the published csd-* primitives.",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -41,6 +41,16 @@
       "types": "./dist/chain.d.ts",
       "import": "./dist/chain.js",
       "require": "./dist/chain.cjs"
+    },
+    "./controller": {
+      "types": "./dist/controller.d.ts",
+      "import": "./dist/controller.js",
+      "require": "./dist/controller.cjs"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js",
+      "require": "./dist/react.cjs"
     }
   },
   "files": [
@@ -48,25 +58,13 @@
     "LICENSE",
     "README.md"
   ],
-  "scripts": {
-    "build": "tsup src/index.ts src/connect.ts src/board.ts src/indexer.ts src/content.ts src/registry.ts src/chain.ts --format esm,cjs --dts --clean",
-    "test": "tsx test/sdk.test.ts && tsx test/connect.test.ts",
-    "test:live": "node examples/read-only.mjs",
-    "build:example": "node scripts/build-example.mjs",
-    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
-    "test:e2e:read": "node test/e2e/e2e-read.mjs",
-    "test:e2e:wallet": "xvfb-run -a node test/e2e/e2e-wallet-connect.mjs",
-    "test:e2e:write": "node test/e2e/e2e-write.mjs",
-    "test:e2e": "node test/e2e/e2e-read.mjs && xvfb-run -a node test/e2e/e2e-wallet-connect.mjs",
-    "test:all": "pnpm test && pnpm test:e2e"
-  },
   "dependencies": {
-    "@inversealtruism/csd-client": "^0.1.5",
-    "@inversealtruism/csd-codec": "^0.1.5",
-    "@inversealtruism/csd-crypto": "^0.1.5",
-    "@inversealtruism/csd-light": "^0.1.5",
-    "@inversealtruism/csd-registry": "^0.1.5",
-    "@inversealtruism/csd-tx": "^0.1.5"
+    "@inversealtruism/csd-client": "0.1.13",
+    "@inversealtruism/csd-codec": "0.1.13",
+    "@inversealtruism/csd-crypto": "0.1.13",
+    "@inversealtruism/csd-light": "0.1.13",
+    "@inversealtruism/csd-registry": "0.1.13",
+    "@inversealtruism/csd-tx": "0.1.13"
   },
   "devDependencies": {
     "esbuild": "^0.27.0",
@@ -76,12 +74,6 @@
     "typescript": "^5.6.0"
   },
   "sideEffects": false,
-  "packageManager": "pnpm@10.32.1",
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "esbuild"
-    ]
-  },
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -99,5 +91,17 @@
     "dapp",
     "sdk",
     "blockchain"
-  ]
-}
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/connect.ts src/board.ts src/indexer.ts src/content.ts src/registry.ts src/chain.ts src/controller.ts src/react.ts --format esm,cjs --dts --clean",
+    "test": "tsx test/sdk.test.ts && tsx test/connect.test.ts && tsx test/errors.test.ts && tsx test/controller.test.ts && tsx test/react.test.ts",
+    "test:live": "node examples/read-only.mjs",
+    "build:example": "node scripts/build-example.mjs",
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "test:e2e:read": "node test/e2e/e2e-read.mjs",
+    "test:e2e:wallet": "xvfb-run -a node test/e2e/e2e-wallet-connect.mjs",
+    "test:e2e:write": "node test/e2e/e2e-write.mjs",
+    "test:e2e": "node test/e2e/e2e-read.mjs && xvfb-run -a node test/e2e/e2e-wallet-connect.mjs",
+    "test:all": "pnpm test && pnpm test:e2e"
+  }
+}

package/dist/chunk-PHMU3CG5.js

@@ -1,63 +0,0 @@
-// src/errors.ts
-var CairnError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = new.target.name;
-  }
-};
-var NotInstalledError = class extends CairnError {
-  constructor(message = "Cairn Wallet not detected. Install it from cairn-substrate.com.") {
-    super(message);
-  }
-};
-var UserRejectedError = class extends CairnError {
-  constructor(message = "Request rejected by user.") {
-    super(message);
-  }
-};
-var WalletLockedError = class extends CairnError {
-  constructor(message = "Wallet is locked.") {
-    super(message);
-  }
-};
-var UnsupportedMethodError = class extends CairnError {
-  constructor(message = "Method not supported by the wallet.") {
-    super(message);
-  }
-};
-var HttpError = class extends CairnError {
-  status;
-  url;
-  body;
-  constructor(status, url, body) {
-    super(`HTTP ${status} for ${url}${body ? `: ${String(body).slice(0, 200)}` : ""}`);
-    this.status = status;
-    this.url = url;
-    this.body = body;
-  }
-};
-var ContentVerificationError = class extends CairnError {
-  expected;
-  constructor(expected) {
-    super(`Content does not match its payload hash ${expected} \u2014 bytes were tampered with in transit.`);
-    this.expected = expected;
-  }
-};
-function mapProviderError(error) {
-  const e = String(error || "").toLowerCase();
-  if (e.includes("rejected by user")) return new UserRejectedError(error);
-  if (e.includes("wallet locked")) return new WalletLockedError(error);
-  if (e.includes("unsupported dapp method")) return new UnsupportedMethodError(error);
-  return new CairnError(error || "Unknown wallet error");
-}
-
-export {
-  CairnError,
-  NotInstalledError,
-  UserRejectedError,
-  WalletLockedError,
-  UnsupportedMethodError,
-  HttpError,
-  ContentVerificationError,
-  mapProviderError
-};