@parity/product-sdk-signer 0.1.0

package/dist/index.js

@@ -0,0 +1,1578 @@
+// src/signer-manager.ts
+import { createLogger as createLogger3 } from "@parity/product-sdk-logger";
+
+// src/errors.ts
+var SignerError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "SignerError";
+  }
+};
+var HostUnavailableError = class extends SignerError {
+  constructor(message = "Host API is not available") {
+    super(message);
+    this.name = "HostUnavailableError";
+  }
+};
+var HostRejectedError = class extends SignerError {
+  constructor(message = "Host rejected the request") {
+    super(message);
+    this.name = "HostRejectedError";
+  }
+};
+var HostDisconnectedError = class extends SignerError {
+  constructor(message = "Host connection lost") {
+    super(message);
+    this.name = "HostDisconnectedError";
+  }
+};
+var SigningFailedError = class extends SignerError {
+  constructor(cause, message) {
+    super(
+      message ?? `Signing failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+      { cause }
+    );
+    this.name = "SigningFailedError";
+  }
+};
+var NoAccountsError = class extends SignerError {
+  provider;
+  constructor(provider, message) {
+    super(message ?? `No accounts available from ${provider} provider`);
+    this.name = "NoAccountsError";
+    this.provider = provider;
+  }
+};
+var TimeoutError = class extends SignerError {
+  operation;
+  ms;
+  constructor(operation, ms) {
+    super(`Operation "${operation}" timed out after ${ms}ms`);
+    this.name = "TimeoutError";
+    this.operation = operation;
+    this.ms = ms;
+  }
+};
+var AccountNotFoundError = class extends SignerError {
+  address;
+  constructor(address) {
+    super(`Account not found: ${address}`);
+    this.name = "AccountNotFoundError";
+    this.address = address;
+  }
+};
+var DestroyedError = class extends SignerError {
+  constructor() {
+    super("SignerManager has been destroyed");
+    this.name = "DestroyedError";
+  }
+};
+function isHostError(e) {
+  return e instanceof HostUnavailableError || e instanceof HostRejectedError || e instanceof HostDisconnectedError;
+}
+if (void 0) {
+  const { test, expect, describe } = void 0;
+  describe("error classes", () => {
+    test("SignerError is the base class", () => {
+      const e = new HostUnavailableError();
+      expect(e).toBeInstanceOf(SignerError);
+      expect(e).toBeInstanceOf(Error);
+    });
+    test("HostUnavailableError with default message", () => {
+      const e = new HostUnavailableError();
+      expect(e.name).toBe("HostUnavailableError");
+      expect(e.message).toBe("Host API is not available");
+    });
+    test("HostUnavailableError with custom message", () => {
+      const e = new HostUnavailableError("custom");
+      expect(e.message).toBe("custom");
+    });
+    test("HostRejectedError", () => {
+      const e = new HostRejectedError();
+      expect(e).toBeInstanceOf(SignerError);
+      expect(e.message).toContain("rejected");
+    });
+    test("HostDisconnectedError", () => {
+      const e = new HostDisconnectedError();
+      expect(e).toBeInstanceOf(SignerError);
+      expect(e.message).toContain("lost");
+    });
+    test("SigningFailedError with Error cause", () => {
+      const cause = new Error("bad signature");
+      const e = new SigningFailedError(cause);
+      expect(e).toBeInstanceOf(SignerError);
+      expect(e.cause).toBe(cause);
+      expect(e.message).toContain("bad signature");
+    });
+    test("SigningFailedError with string cause", () => {
+      const e = new SigningFailedError("oops");
+      expect(e.message).toContain("oops");
+    });
+    test("SigningFailedError with custom message", () => {
+      const e = new SigningFailedError("oops", "custom msg");
+      expect(e.message).toBe("custom msg");
+    });
+    test("NoAccountsError", () => {
+      const e = new NoAccountsError("host");
+      expect(e).toBeInstanceOf(SignerError);
+      expect(e.provider).toBe("host");
+      expect(e.message).toContain("host");
+    });
+    test("NoAccountsError with custom message", () => {
+      const e = new NoAccountsError("dev", "none found");
+      expect(e.message).toBe("none found");
+    });
+    test("TimeoutError", () => {
+      const e = new TimeoutError("connect", 5e3);
+      expect(e).toBeInstanceOf(SignerError);
+      expect(e.operation).toBe("connect");
+      expect(e.ms).toBe(5e3);
+      expect(e.message).toContain("5000");
+    });
+    test("AccountNotFoundError", () => {
+      const e = new AccountNotFoundError("5GrwvaEF...");
+      expect(e).toBeInstanceOf(SignerError);
+      expect(e.address).toBe("5GrwvaEF...");
+    });
+    test("DestroyedError", () => {
+      const e = new DestroyedError();
+      expect(e).toBeInstanceOf(SignerError);
+      expect(e.message).toContain("destroyed");
+    });
+    test("all errors have stack traces", () => {
+      const e = new HostUnavailableError();
+      expect(e.stack).toBeDefined();
+      expect(e.stack).toContain("HostUnavailableError");
+    });
+  });
+  describe("type guards", () => {
+    test("isHostError returns true for host errors", () => {
+      expect(isHostError(new HostUnavailableError())).toBe(true);
+      expect(isHostError(new HostRejectedError())).toBe(true);
+      expect(isHostError(new HostDisconnectedError())).toBe(true);
+    });
+    test("isHostError returns false for non-host errors", () => {
+      expect(isHostError(new SigningFailedError("x"))).toBe(false);
+      expect(isHostError(new NoAccountsError("dev"))).toBe(false);
+      expect(isHostError(new TimeoutError("op", 100))).toBe(false);
+      expect(isHostError(new AccountNotFoundError("x"))).toBe(false);
+      expect(isHostError(new DestroyedError())).toBe(false);
+    });
+  });
+}
+
+// src/signer-manager.ts
+import { getHostLocalStorage } from "@parity/product-sdk-host";
+
+// src/providers/dev.ts
+import { seedToAccount } from "@parity/product-sdk-keys";
+import { createLogger } from "@parity/product-sdk-logger";
+
+// src/types.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+if (void 0) {
+  const { test, expect, describe } = void 0;
+  describe("ok", () => {
+    test("produces ok result with value", () => {
+      const result = ok(42);
+      expect(result.ok).toBe(true);
+      expect(result).toEqual({ ok: true, value: 42 });
+    });
+    test("works with complex values", () => {
+      const result = ok({ name: "Alice", age: 30 });
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.name).toBe("Alice");
+      }
+    });
+    test("works with null value", () => {
+      const result = ok(null);
+      expect(result).toEqual({ ok: true, value: null });
+    });
+    test("works with undefined value", () => {
+      const result = ok(void 0);
+      expect(result).toEqual({ ok: true, value: void 0 });
+    });
+  });
+  describe("err", () => {
+    test("produces error result", () => {
+      const result = err("something went wrong");
+      expect(result.ok).toBe(false);
+      expect(result).toEqual({ ok: false, error: "something went wrong" });
+    });
+    test("works with typed error objects", () => {
+      const error = { type: "HOST_UNAVAILABLE", message: "no host" };
+      const result = err(error);
+      expect(result.ok).toBe(false);
+      if (!result.ok) {
+        expect(result.error.type).toBe("HOST_UNAVAILABLE");
+      }
+    });
+  });
+  describe("Result type narrowing", () => {
+    test("ok narrows to value access", () => {
+      const result = ok(42);
+      if (result.ok) {
+        const value = result.value;
+        expect(value).toBe(42);
+      } else {
+        expect.unreachable("should be ok");
+      }
+    });
+    test("err narrows to error access", () => {
+      const result = err("fail");
+      if (!result.ok) {
+        const error = result.error;
+        expect(error).toBe("fail");
+      } else {
+        expect.unreachable("should be err");
+      }
+    });
+  });
+}
+
+// src/providers/dev.ts
+var log = createLogger("signer:dev");
+var DEV_PHRASE = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
+var DEFAULT_DEV_NAMES = ["Alice", "Bob", "Charlie", "Dave", "Eve", "Ferdie"];
+var DevProvider = class {
+  type = "dev";
+  names;
+  mnemonic;
+  ss58Prefix;
+  keyType;
+  constructor(options) {
+    this.names = options?.names ?? DEFAULT_DEV_NAMES;
+    this.mnemonic = options?.mnemonic ?? DEV_PHRASE;
+    this.ss58Prefix = options?.ss58Prefix ?? 42;
+    this.keyType = options?.keyType ?? "sr25519";
+  }
+  async connect() {
+    log.debug("creating dev accounts", { names: this.names, keyType: this.keyType });
+    const accounts = this.names.map((name) => {
+      const derived = seedToAccount(
+        this.mnemonic,
+        `//${name}`,
+        this.ss58Prefix,
+        this.keyType
+      );
+      return {
+        address: derived.ss58Address,
+        h160Address: derived.h160Address,
+        publicKey: derived.publicKey,
+        name,
+        source: "dev",
+        getSigner: () => derived.signer
+      };
+    });
+    log.info("dev accounts ready", { count: accounts.length });
+    return ok(accounts);
+  }
+  disconnect() {
+  }
+  onStatusChange(_callback) {
+    return () => {
+    };
+  }
+  onAccountsChange(_callback) {
+    return () => {
+    };
+  }
+};
+if (void 0) {
+  const { test, expect, describe } = void 0;
+  const ALICE_ADDRESS = "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY";
+  describe("DevProvider", () => {
+    test("connect returns 6 accounts by default", async () => {
+      const provider = new DevProvider();
+      const result = await provider.connect();
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value).toHaveLength(6);
+        expect(result.value.map((a) => a.name)).toEqual([
+          "Alice",
+          "Bob",
+          "Charlie",
+          "Dave",
+          "Eve",
+          "Ferdie"
+        ]);
+      }
+    });
+    test("all accounts have source 'dev'", async () => {
+      const provider = new DevProvider();
+      const result = await provider.connect();
+      if (result.ok) {
+        for (const account of result.value) {
+          expect(account.source).toBe("dev");
+        }
+      }
+    });
+    test("Alice has well-known address", async () => {
+      const provider = new DevProvider();
+      const result = await provider.connect();
+      if (result.ok) {
+        expect(result.value[0].address).toBe(ALICE_ADDRESS);
+      }
+    });
+    test("addresses are deterministic", async () => {
+      const a = new DevProvider();
+      const b = new DevProvider();
+      const ra = await a.connect();
+      const rb = await b.connect();
+      if (ra.ok && rb.ok) {
+        expect(ra.value.map((x) => x.address)).toEqual(rb.value.map((x) => x.address));
+      }
+    });
+    test("each account has 32-byte publicKey", async () => {
+      const provider = new DevProvider();
+      const result = await provider.connect();
+      if (result.ok) {
+        for (const account of result.value) {
+          expect(account.publicKey).toBeInstanceOf(Uint8Array);
+          expect(account.publicKey.length).toBe(32);
+        }
+      }
+    });
+    test("getSigner returns signer with matching publicKey", async () => {
+      const provider = new DevProvider();
+      const result = await provider.connect();
+      if (result.ok) {
+        for (const account of result.value) {
+          const signer = account.getSigner();
+          expect(signer.publicKey).toEqual(account.publicKey);
+        }
+      }
+    });
+    test("custom names subset", async () => {
+      const provider = new DevProvider({ names: ["Alice", "Bob"] });
+      const result = await provider.connect();
+      if (result.ok) {
+        expect(result.value).toHaveLength(2);
+        expect(result.value.map((a) => a.name)).toEqual(["Alice", "Bob"]);
+      }
+    });
+    test("custom mnemonic produces different addresses", async () => {
+      const customMnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
+      const defaultProvider = new DevProvider();
+      const customProvider = new DevProvider({ mnemonic: customMnemonic });
+      const defResult = await defaultProvider.connect();
+      const cusResult = await customProvider.connect();
+      if (defResult.ok && cusResult.ok) {
+        expect(defResult.value[0].address).not.toBe(cusResult.value[0].address);
+      }
+    });
+    test("custom ss58Prefix changes address encoding", async () => {
+      const generic = new DevProvider({ ss58Prefix: 42 });
+      const polkadot = new DevProvider({ ss58Prefix: 0 });
+      const rg = await generic.connect();
+      const rp = await polkadot.connect();
+      if (rg.ok && rp.ok) {
+        expect(rg.value[0].address).not.toBe(rp.value[0].address);
+        expect(rg.value[0].publicKey).toEqual(rp.value[0].publicKey);
+      }
+    });
+    test("disconnect is idempotent", () => {
+      const provider = new DevProvider();
+      provider.disconnect();
+      provider.disconnect();
+    });
+    test("onStatusChange returns no-op unsubscribe", () => {
+      const provider = new DevProvider();
+      const callback = () => {
+      };
+      const unsub = provider.onStatusChange(callback);
+      expect(typeof unsub).toBe("function");
+      unsub();
+    });
+    test("onAccountsChange returns no-op unsubscribe", () => {
+      const provider = new DevProvider();
+      const callback = () => {
+      };
+      const unsub = provider.onAccountsChange(callback);
+      expect(typeof unsub).toBe("function");
+      unsub();
+    });
+    test("type is 'dev'", () => {
+      const provider = new DevProvider();
+      expect(provider.type).toBe("dev");
+    });
+    test("empty names array returns zero accounts", async () => {
+      const provider = new DevProvider({ names: [] });
+      const result = await provider.connect();
+      if (result.ok) {
+        expect(result.value).toHaveLength(0);
+      }
+    });
+    test("default keyType is sr25519 (backward compatible)", async () => {
+      const provider = new DevProvider();
+      const result = await provider.connect();
+      if (result.ok) {
+        expect(result.value[0].address).toBe(ALICE_ADDRESS);
+      }
+    });
+  });
+  describe("DevProvider ed25519", () => {
+    test("ed25519 produces different addresses than sr25519", async () => {
+      const sr = new DevProvider({ keyType: "sr25519" });
+      const ed = new DevProvider({ keyType: "ed25519" });
+      const srResult = await sr.connect();
+      const edResult = await ed.connect();
+      if (srResult.ok && edResult.ok) {
+        expect(srResult.value[0].address).not.toBe(edResult.value[0].address);
+      }
+    });
+    test("ed25519 addresses are deterministic", async () => {
+      const a = new DevProvider({ keyType: "ed25519" });
+      const b = new DevProvider({ keyType: "ed25519" });
+      const ra = await a.connect();
+      const rb = await b.connect();
+      if (ra.ok && rb.ok) {
+        expect(ra.value.map((x) => x.address)).toEqual(rb.value.map((x) => x.address));
+      }
+    });
+    test("ed25519 getSigner has matching publicKey", async () => {
+      const provider = new DevProvider({ keyType: "ed25519" });
+      const result = await provider.connect();
+      if (result.ok) {
+        for (const account of result.value) {
+          const signer = account.getSigner();
+          expect(signer.publicKey).toEqual(account.publicKey);
+        }
+      }
+    });
+    test("ed25519 accounts have 32-byte publicKey", async () => {
+      const provider = new DevProvider({ keyType: "ed25519" });
+      const result = await provider.connect();
+      if (result.ok) {
+        for (const account of result.value) {
+          expect(account.publicKey).toBeInstanceOf(Uint8Array);
+          expect(account.publicKey.length).toBe(32);
+        }
+      }
+    });
+  });
+}
+
+// src/providers/host.ts
+import { deriveH160, ss58Encode } from "@parity/product-sdk-address";
+import { createLogger as createLogger2 } from "@parity/product-sdk-logger";
+
+// src/sleep.ts
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal?.aborted) {
+      resolve();
+      return;
+    }
+    const onDone = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onDone);
+      resolve();
+    };
+    const timer = setTimeout(onDone, ms);
+    signal?.addEventListener("abort", onDone, { once: true });
+  });
+}
+if (void 0) {
+  const { test, expect, describe, vi, beforeEach, afterEach } = void 0;
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+  describe("sleep", () => {
+    test("resolves after specified duration", async () => {
+      let resolved = false;
+      sleep(100).then(() => {
+        resolved = true;
+      });
+      expect(resolved).toBe(false);
+      await vi.advanceTimersByTimeAsync(99);
+      expect(resolved).toBe(false);
+      await vi.advanceTimersByTimeAsync(1);
+      expect(resolved).toBe(true);
+    });
+    test("resolves immediately when signal is already aborted", async () => {
+      const controller = new AbortController();
+      controller.abort();
+      let resolved = false;
+      sleep(1e4, controller.signal).then(() => {
+        resolved = true;
+      });
+      await vi.advanceTimersByTimeAsync(0);
+      expect(resolved).toBe(true);
+    });
+    test("resolves early when signal is aborted during sleep", async () => {
+      const controller = new AbortController();
+      let resolved = false;
+      sleep(1e4, controller.signal).then(() => {
+        resolved = true;
+      });
+      await vi.advanceTimersByTimeAsync(50);
+      expect(resolved).toBe(false);
+      controller.abort();
+      await vi.advanceTimersByTimeAsync(0);
+      expect(resolved).toBe(true);
+    });
+    test("works without a signal", async () => {
+      let resolved = false;
+      sleep(50).then(() => {
+        resolved = true;
+      });
+      await vi.advanceTimersByTimeAsync(50);
+      expect(resolved).toBe(true);
+    });
+    test("cleans up abort listener after natural timer expiry", async () => {
+      const controller = new AbortController();
+      const addSpy = vi.spyOn(controller.signal, "addEventListener");
+      const removeSpy = vi.spyOn(controller.signal, "removeEventListener");
+      sleep(50, controller.signal);
+      expect(addSpy).toHaveBeenCalledTimes(1);
+      await vi.advanceTimersByTimeAsync(50);
+      expect(removeSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+}
+
+// src/retry.ts
+var DEFAULT_MAX_ATTEMPTS = 3;
+var DEFAULT_INITIAL_DELAY = 500;
+var DEFAULT_BACKOFF_MULTIPLIER = 2;
+var DEFAULT_MAX_DELAY = 1e4;
+async function withRetry(fn, options) {
+  const maxAttempts = Math.max(1, options?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS);
+  const initialDelay = options?.initialDelay ?? DEFAULT_INITIAL_DELAY;
+  const backoffMultiplier = options?.backoffMultiplier ?? DEFAULT_BACKOFF_MULTIPLIER;
+  const maxDelay = options?.maxDelay ?? DEFAULT_MAX_DELAY;
+  const signal = options?.signal;
+  let lastResult;
+  let delay = initialDelay;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    if (signal?.aborted && lastResult) {
+      return lastResult;
+    }
+    lastResult = await fn(attempt);
+    if (lastResult.ok) {
+      return lastResult;
+    }
+    if (attempt < maxAttempts - 1) {
+      await sleep(delay, signal);
+      delay = Math.min(delay * backoffMultiplier, maxDelay);
+    }
+  }
+  return lastResult;
+}
+if (void 0) {
+  const { test, expect, describe, vi, beforeEach, afterEach } = void 0;
+  const { ok: ok2, err: err2 } = await null;
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+  describe("withRetry", () => {
+    test("succeeds on first attempt with no delay", async () => {
+      const fn = vi.fn().mockResolvedValue(ok2("done"));
+      const promise = withRetry(fn);
+      const result = await promise;
+      expect(result).toEqual(ok2("done"));
+      expect(fn).toHaveBeenCalledTimes(1);
+      expect(fn).toHaveBeenCalledWith(0);
+    });
+    test("retries on failure and succeeds on second attempt", async () => {
+      const fn = vi.fn().mockResolvedValueOnce(err2("fail1")).mockResolvedValueOnce(ok2("success"));
+      const promise = withRetry(fn, { initialDelay: 100 });
+      await vi.advanceTimersByTimeAsync(100);
+      const result = await promise;
+      expect(result).toEqual(ok2("success"));
+      expect(fn).toHaveBeenCalledTimes(2);
+      expect(fn).toHaveBeenNthCalledWith(1, 0);
+      expect(fn).toHaveBeenNthCalledWith(2, 1);
+    });
+    test("exhausts maxAttempts and returns last error", async () => {
+      const fn = vi.fn().mockResolvedValueOnce(err2("fail1")).mockResolvedValueOnce(err2("fail2")).mockResolvedValueOnce(err2("fail3"));
+      const promise = withRetry(fn, {
+        maxAttempts: 3,
+        initialDelay: 100,
+        backoffMultiplier: 2
+      });
+      await vi.advanceTimersByTimeAsync(100);
+      await vi.advanceTimersByTimeAsync(200);
+      const result = await promise;
+      expect(result).toEqual(err2("fail3"));
+      expect(fn).toHaveBeenCalledTimes(3);
+    });
+    test("respects AbortSignal cancellation", async () => {
+      const controller = new AbortController();
+      const fn = vi.fn().mockResolvedValue(err2("fail"));
+      const promise = withRetry(fn, {
+        maxAttempts: 5,
+        initialDelay: 1e3,
+        signal: controller.signal
+      });
+      await vi.advanceTimersByTimeAsync(0);
+      controller.abort();
+      await vi.advanceTimersByTimeAsync(0);
+      const result = await promise;
+      expect(result.ok).toBe(false);
+      expect(fn.mock.calls.length).toBeLessThan(5);
+    });
+    test("backoff delay increases correctly", async () => {
+      const fn = vi.fn().mockResolvedValueOnce(err2("e1")).mockResolvedValueOnce(err2("e2")).mockResolvedValueOnce(err2("e3")).mockResolvedValueOnce(ok2("done"));
+      const promise = withRetry(fn, {
+        maxAttempts: 4,
+        initialDelay: 100,
+        backoffMultiplier: 2
+      });
+      await vi.advanceTimersByTimeAsync(100);
+      await vi.advanceTimersByTimeAsync(200);
+      await vi.advanceTimersByTimeAsync(400);
+      const result = await promise;
+      expect(result).toEqual(ok2("done"));
+      expect(fn).toHaveBeenCalledTimes(4);
+    });
+    test("caps delay at maxDelay", async () => {
+      const fn = vi.fn().mockImplementation(async () => {
+        return err2("fail");
+      });
+      const promise = withRetry(fn, {
+        maxAttempts: 4,
+        initialDelay: 5e3,
+        backoffMultiplier: 3,
+        maxDelay: 8e3
+      });
+      await vi.advanceTimersByTimeAsync(5e3);
+      await vi.advanceTimersByTimeAsync(8e3);
+      await vi.advanceTimersByTimeAsync(8e3);
+      const result = await promise;
+      expect(result.ok).toBe(false);
+      expect(fn).toHaveBeenCalledTimes(4);
+    });
+    test("attempt number is passed correctly to fn", async () => {
+      const attempts = [];
+      const fn = vi.fn().mockImplementation(async (attempt) => {
+        attempts.push(attempt);
+        return attempt < 2 ? err2("retry") : ok2("done");
+      });
+      const promise = withRetry(fn, {
+        maxAttempts: 3,
+        initialDelay: 50
+      });
+      await vi.advanceTimersByTimeAsync(50);
+      await vi.advanceTimersByTimeAsync(100);
+      await promise;
+      expect(attempts).toEqual([0, 1, 2]);
+    });
+    test("single attempt with maxAttempts=1", async () => {
+      const fn = vi.fn().mockResolvedValue(err2("fail"));
+      const result = await withRetry(fn, { maxAttempts: 1 });
+      expect(result).toEqual(err2("fail"));
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+    test("signal already aborted before first attempt \u2014 fn still called once", async () => {
+      const controller = new AbortController();
+      controller.abort();
+      const fn = vi.fn().mockResolvedValue(err2("fail"));
+      const result = await withRetry(fn, {
+        maxAttempts: 3,
+        signal: controller.signal
+      });
+      expect(result.ok).toBe(false);
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+  });
+}
+
+// src/providers/host.ts
+var log2 = createLogger2("signer:host");
+async function defaultLoadSdk() {
+  return await import("@novasamatech/product-sdk");
+}
+async function defaultLoadHostApiEnum() {
+  return await import("@novasamatech/host-api");
+}
+var HostProvider = class {
+  type = "host";
+  ss58Prefix;
+  maxRetries;
+  retryDelay;
+  loadSdk;
+  loadHostApiEnum;
+  requestTxPermission;
+  accountsProvider = null;
+  statusCleanup = null;
+  statusListeners = /* @__PURE__ */ new Set();
+  accountListeners = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.ss58Prefix = options?.ss58Prefix ?? 42;
+    this.maxRetries = options?.maxRetries ?? 3;
+    this.retryDelay = options?.retryDelay ?? 500;
+    this.loadSdk = options?.loadSdk ?? defaultLoadSdk;
+    this.loadHostApiEnum = options?.loadHostApiEnum ?? defaultLoadHostApiEnum;
+    this.requestTxPermission = options?.requestTransactionSubmitPermission ?? true;
+  }
+  async connect(signal) {
+    log2.debug("attempting Host API connection");
+    return withRetry(
+      async () => {
+        if (signal?.aborted) {
+          return err(new HostUnavailableError("Connection aborted"));
+        }
+        return this.tryConnect();
+      },
+      {
+        maxAttempts: this.maxRetries,
+        initialDelay: this.retryDelay,
+        signal
+      }
+    );
+  }
+  disconnect() {
+    if (this.statusCleanup) {
+      this.statusCleanup();
+      this.statusCleanup = null;
+    }
+    this.accountsProvider = null;
+    this.statusListeners.clear();
+    this.accountListeners.clear();
+    log2.debug("host provider disconnected");
+  }
+  onStatusChange(callback) {
+    this.statusListeners.add(callback);
+    return () => {
+      this.statusListeners.delete(callback);
+    };
+  }
+  onAccountsChange(callback) {
+    this.accountListeners.add(callback);
+    return () => {
+      this.accountListeners.delete(callback);
+    };
+  }
+  // ── Product Account API ──────────────────────────────────────────
+  /**
+   * Get an app-scoped product account from the host.
+   *
+   * Product accounts are derived by the host wallet for each app, identified
+   * by `dotNsIdentifier` (e.g., "mark3t.dot"). The user controls these accounts
+   * but they are scoped to the requesting app.
+   *
+   * Requires a prior successful `connect()` call.
+   */
+  async getProductAccount(dotNsIdentifier, derivationIndex = 0) {
+    if (!this.accountsProvider) {
+      return err(new HostUnavailableError("Host provider is not connected"));
+    }
+    try {
+      const raw = await this.accountsProvider.getProductAccount(dotNsIdentifier, derivationIndex).match(
+        (account) => account,
+        (error) => {
+          throw new Error(
+            `Host rejected product account request: ${formatError(error)}`
+          );
+        }
+      );
+      const address = ss58Encode(raw.publicKey, this.ss58Prefix);
+      const productAccount = {
+        dotNsIdentifier,
+        derivationIndex,
+        publicKey: raw.publicKey
+      };
+      return ok({
+        address,
+        h160Address: deriveH160(raw.publicKey),
+        publicKey: raw.publicKey,
+        name: raw.name ?? null,
+        source: "host",
+        getSigner: () => {
+          if (!this.accountsProvider) {
+            throw new Error("Host provider is disconnected");
+          }
+          return this.accountsProvider.getProductAccountSigner(productAccount);
+        }
+      });
+    } catch (cause) {
+      log2.error("failed to get product account", { cause });
+      return err(
+        new HostRejectedError(
+          cause instanceof Error ? cause.message : "Failed to get product account"
+        )
+      );
+    }
+  }
+  /**
+   * Get a PolkadotSigner for a product account.
+   *
+   * Convenience method for when you already have the product account details.
+   * Requires a prior successful `connect()` call.
+   */
+  getProductAccountSigner(account) {
+    if (!this.accountsProvider) {
+      throw new Error("Host provider is not connected");
+    }
+    return this.accountsProvider.getProductAccountSigner(account);
+  }
+  /**
+   * Get a contextual alias for a product account via Ring VRF.
+   *
+   * Aliases prove account membership in a ring without revealing which
+   * account produced the alias.
+   *
+   * Requires a prior successful `connect()` call.
+   */
+  async getProductAccountAlias(dotNsIdentifier, derivationIndex = 0) {
+    if (!this.accountsProvider) {
+      return err(new HostUnavailableError("Host provider is not connected"));
+    }
+    try {
+      const alias = await this.accountsProvider.getProductAccountAlias(dotNsIdentifier, derivationIndex).match(
+        (result) => result,
+        (error) => {
+          throw new Error(`Host rejected alias request: ${formatError(error)}`);
+        }
+      );
+      return ok(alias);
+    } catch (cause) {
+      log2.error("failed to get product account alias", { cause });
+      return err(
+        new HostRejectedError(
+          cause instanceof Error ? cause.message : "Failed to get product account alias"
+        )
+      );
+    }
+  }
+  /**
+   * Create a Ring VRF proof for anonymous operations.
+   *
+   * Proves that the signer is a member of the ring at the given location
+   * without revealing which member. Used for privacy-preserving protocols.
+   *
+   * Requires a prior successful `connect()` call.
+   */
+  async createRingVRFProof(dotNsIdentifier, derivationIndex, location, message) {
+    if (!this.accountsProvider) {
+      return err(new HostUnavailableError("Host provider is not connected"));
+    }
+    try {
+      const proof = await this.accountsProvider.createRingVRFProof(dotNsIdentifier, derivationIndex, location, message).match(
+        (result) => result,
+        (error) => {
+          throw new Error(
+            `Host rejected Ring VRF proof request: ${formatError(error)}`
+          );
+        }
+      );
+      return ok(proof);
+    } catch (cause) {
+      log2.error("failed to create Ring VRF proof", { cause });
+      return err(
+        new HostRejectedError(
+          cause instanceof Error ? cause.message : "Failed to create Ring VRF proof"
+        )
+      );
+    }
+  }
+  // ── Private ──────────────────────────────────────────────────────
+  async tryConnect() {
+    let sdk;
+    try {
+      sdk = await this.loadSdk();
+    } catch (cause) {
+      log2.warn("product-sdk not available", { cause });
+      return err(
+        new HostUnavailableError(
+          cause instanceof Error ? `product-sdk import failed: ${cause.message}` : "product-sdk is not installed"
+        )
+      );
+    }
+    const provider = sdk.createAccountsProvider();
+    this.accountsProvider = provider;
+    let rawAccounts;
+    try {
+      rawAccounts = await provider.getNonProductAccounts().match(
+        (accounts2) => accounts2,
+        (error) => {
+          throw new Error(`Host rejected account request: ${formatError(error)}`);
+        }
+      );
+    } catch (cause) {
+      log2.error("failed to get accounts from host", { cause });
+      return err(
+        new HostRejectedError(
+          cause instanceof Error ? cause.message : "Failed to get accounts from host"
+        )
+      );
+    }
+    if (rawAccounts.length === 0) {
+      log2.warn("host returned no accounts");
+      return err(new NoAccountsError("host"));
+    }
+    if (this.requestTxPermission && sdk.hostApi) {
+      try {
+        const hostApiEnum = await this.loadHostApiEnum();
+        const request = hostApiEnum.enumValue("v1", {
+          tag: "TransactionSubmit"
+        });
+        await sdk.hostApi.permission(request).match(
+          () => {
+            log2.debug("TransactionSubmit permission granted");
+          },
+          (error) => {
+            log2.warn("TransactionSubmit permission rejected by host", {
+              error: formatError(error)
+            });
+          }
+        );
+      } catch (cause) {
+        log2.warn("failed to request TransactionSubmit permission", { cause });
+      }
+    }
+    const accounts = this.mapAccounts(rawAccounts);
+    log2.info("host connected", { accounts: accounts.length });
+    const sub = provider.subscribeAccountConnectionStatus((status) => {
+      const mapped = status === "connected" ? "connected" : "disconnected";
+      log2.debug("host status changed", { status: mapped });
+      for (const listener of this.statusListeners) {
+        listener(mapped);
+      }
+    });
+    this.statusCleanup = typeof sub === "function" ? sub : () => sub.unsubscribe();
+    return ok(accounts);
+  }
+  mapAccounts(rawAccounts) {
+    return rawAccounts.map((raw) => {
+      const address = ss58Encode(raw.publicKey, this.ss58Prefix);
+      const h160Address = deriveH160(raw.publicKey);
+      return {
+        address,
+        h160Address,
+        publicKey: raw.publicKey,
+        name: raw.name ?? null,
+        source: "host",
+        getSigner: () => {
+          if (!this.accountsProvider) {
+            throw new Error("Host provider is disconnected");
+          }
+          return this.accountsProvider.getNonProductAccountSigner({
+            dotNsIdentifier: "",
+            derivationIndex: 0,
+            publicKey: raw.publicKey
+          });
+        }
+      };
+    });
+  }
+};
+function formatError(error) {
+  if (error && typeof error === "object" && "tag" in error) {
+    return error.tag;
+  }
+  return String(error);
+}
+if (void 0) {
+  let createMockProvider = function(options = {}) {
+    const accounts = options.accounts ?? [];
+    const shouldReject = options.shouldReject ?? false;
+    const mockSigner = {
+      publicKey: new Uint8Array(32).fill(187)
+    };
+    return {
+      getNonProductAccounts: vi.fn().mockReturnValue({
+        match: async (onOk, onErr) => {
+          if (shouldReject) {
+            return onErr(options.error ?? "Unknown");
+          }
+          return onOk(accounts);
+        }
+      }),
+      getNonProductAccountSigner: vi.fn().mockReturnValue(mockSigner),
+      getProductAccount: vi.fn().mockReturnValue({
+        match: async (onOk, onErr) => {
+          if (shouldReject) {
+            return onErr(options.error ?? "Unknown");
+          }
+          return onOk(accounts[0] ?? { publicKey: new Uint8Array(32), name: void 0 });
+        }
+      }),
+      getProductAccountSigner: vi.fn().mockReturnValue(mockSigner),
+      getProductAccountAlias: vi.fn().mockReturnValue({
+        match: async (onOk, onErr) => {
+          if (shouldReject) {
+            return onErr(options.error ?? "Unknown");
+          }
+          return onOk({
+            context: new Uint8Array(32).fill(1),
+            alias: new Uint8Array(64).fill(2)
+          });
+        }
+      }),
+      createRingVRFProof: vi.fn().mockReturnValue({
+        match: async (onOk, onErr) => {
+          if (shouldReject) {
+            return onErr(options.error ?? "Unknown");
+          }
+          return onOk(new Uint8Array(128).fill(3));
+        }
+      }),
+      subscribeAccountConnectionStatus: vi.fn().mockReturnValue(() => {
+      })
+    };
+  }, createMockSdk = function(mockProvider, opts) {
+    return {
+      createAccountsProvider: () => mockProvider,
+      ...opts?.hostApi ? { hostApi: opts.hostApi } : {}
+    };
+  }, fakeResult = function(value, error) {
+    return {
+      match: async (onOk, onErr) => {
+        if (error !== void 0) return onErr(error);
+        return onOk(value);
+      }
+    };
+  };
+  createMockProvider2 = createMockProvider, createMockSdk2 = createMockSdk, fakeResult2 = fakeResult;
+  const { test, expect, describe, vi, beforeEach } = void 0;
+  const fakeHostApiEnum = {
+    enumValue: (version, value) => ({ version, value })
+  };
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+  describe("HostProvider", () => {
+    test("returns HOST_UNAVAILABLE when SDK load fails", async () => {
+      const provider = new HostProvider({
+        maxRetries: 1,
+        loadSdk: () => Promise.reject(new Error("Cannot find module"))
+      });
+      const result = await provider.connect();
+      expect(result.ok).toBe(false);
+      if (!result.ok) {
+        expect(result.error).toBeInstanceOf(HostUnavailableError);
+        expect(result.error.message).toContain("Cannot find module");
+      }
+    });
+    test("returns HOST_REJECTED when getNonProductAccounts fails", async () => {
+      const mockProvider = createMockProvider({ shouldReject: true, error: "Rejected" });
+      const provider = new HostProvider({
+        maxRetries: 1,
+        loadSdk: () => Promise.resolve(createMockSdk(mockProvider))
+      });
+      const result = await provider.connect();
+      expect(result.ok).toBe(false);
+      if (!result.ok) {
+        expect(result.error).toBeInstanceOf(HostRejectedError);
+      }
+    });
+    test("returns NO_ACCOUNTS when host returns empty list", async () => {
+      const mockProvider = createMockProvider({ accounts: [] });
+      const provider = new HostProvider({
+        maxRetries: 1,
+        loadSdk: () => Promise.resolve(createMockSdk(mockProvider))
+      });
+      const result = await provider.connect();
+      expect(result.ok).toBe(false);
+      if (!result.ok) {
+        expect(result.error).toBeInstanceOf(NoAccountsError);
+      }
+    });
+    test("maps accounts correctly on success", async () => {
+      const rawAccounts = [
+        { publicKey: new Uint8Array(32).fill(170), name: "Alice" },
+        { publicKey: new Uint8Array(32).fill(187), name: void 0 }
+      ];
+      const mockProvider = createMockProvider({ accounts: rawAccounts });
+      const provider = new HostProvider({
+        maxRetries: 1,
+        loadSdk: () => Promise.resolve(createMockSdk(mockProvider))
+      });
+      const result = await provider.connect();
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value).toHaveLength(2);
+        expect(result.value[0].name).toBe("Alice");
+        expect(result.value[0].source).toBe("host");
+        expect(result.value[0].publicKey).toEqual(rawAccounts[0].publicKey);
+        expect(result.value[1].name).toBeNull();
+      }
+    });
+    test("disconnect is idempotent", () => {
+      const provider = new HostProvider();
+      provider.disconnect();
+      provider.disconnect();
+    });
+    test("type is 'host'", () => {
+      const provider = new HostProvider();
+      expect(provider.type).toBe("host");
+    });
+    test("onAccountsChange adds and removes listener", () => {
+      const provider = new HostProvider();
+      const cb = () => {
+      };
+      const unsub = provider.onAccountsChange(cb);
+      expect(typeof unsub).toBe("function");
+      unsub();
+    });
+  });
+}
+var createMockProvider2;
+var createMockSdk2;
+var fakeResult2;
+
+// src/signer-manager.ts
+var log3 = createLogger3("signer");
+var DEFAULT_HOST_TIMEOUT = 1e4;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_SS58_PREFIX = 42;
+var DEFAULT_DAPP_NAME = "product-sdk";
+var RECONNECT_MAX_ATTEMPTS = 5;
+var RECONNECT_INITIAL_DELAY = 1e3;
+var RECONNECT_MAX_DELAY = 15e3;
+function persistenceStorageKey(dappName) {
+  return `product-sdk:signer:${dappName}:selectedAccount`;
+}
+async function detectPersistence() {
+  try {
+    const hostStorage = await getHostLocalStorage();
+    if (hostStorage) {
+      log3.debug("using hostLocalStorage for persistence");
+      return {
+        getItem: (key) => hostStorage.readString(key),
+        setItem: (key, value) => hostStorage.writeString(key, value),
+        removeItem: (key) => hostStorage.writeString(key, "")
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+function initialState() {
+  return {
+    status: "disconnected",
+    accounts: [],
+    selectedAccount: null,
+    activeProvider: null,
+    error: null
+  };
+}
+var SignerManager = class {
+  state;
+  provider = null;
+  subscribers = /* @__PURE__ */ new Set();
+  cleanups = [];
+  isDestroyed = false;
+  reconnectController = null;
+  connectController = null;
+  ss58Prefix;
+  hostTimeout;
+  maxRetries;
+  providerFactory;
+  dappName;
+  persistenceOption;
+  resolvedPersistence;
+  constructor(options) {
+    this.ss58Prefix = options?.ss58Prefix ?? DEFAULT_SS58_PREFIX;
+    this.hostTimeout = options?.hostTimeout ?? DEFAULT_HOST_TIMEOUT;
+    this.maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.providerFactory = options?.createProvider;
+    this.dappName = options?.dappName ?? DEFAULT_DAPP_NAME;
+    this.persistenceOption = options?.persistence;
+    this.resolvedPersistence = options?.persistence;
+    this.state = initialState();
+  }
+  async getPersistence() {
+    if (this.persistenceOption === null) return null;
+    if (this.persistenceOption !== void 0) return this.persistenceOption;
+    if (this.resolvedPersistence === void 0) {
+      this.resolvedPersistence = await detectPersistence();
+    }
+    return this.resolvedPersistence ?? null;
+  }
+  /** Get a snapshot of the current state. */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Subscribe to state changes. The callback fires on every state mutation.
+   * Returns an unsubscribe function.
+   */
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    return () => {
+      this.subscribers.delete(callback);
+    };
+  }
+  /**
+   * Connect to a provider.
+   *
+   * If no provider type is specified, connects to the Host API.
+   * The SDK is designed to run exclusively inside a host container.
+   *
+   * When connecting to a specific provider type:
+   * - `"host"`: Connect to the Host API (default, recommended)
+   * - `"dev"`: Connect using dev accounts (for testing)
+   */
+  async connect(providerType) {
+    if (this.isDestroyed) {
+      return err(new DestroyedError());
+    }
+    this.cancelConnect();
+    this.cancelReconnect();
+    this.connectController = new AbortController();
+    const signal = this.connectController.signal;
+    this.disconnectInternal();
+    this.setState({ status: "connecting", error: null });
+    const targetProvider = providerType ?? "host";
+    return this.connectToProvider(targetProvider, signal);
+  }
+  /** Disconnect from the current provider and reset state. */
+  disconnect() {
+    this.cancelConnect();
+    this.cancelReconnect();
+    this.disconnectInternal();
+    this.setState(initialState());
+    log3.info("disconnected");
+  }
+  /**
+   * Select an account by address.
+   * Returns the account on success, or ACCOUNT_NOT_FOUND error.
+   */
+  selectAccount(address) {
+    if (this.isDestroyed) {
+      return err(new DestroyedError());
+    }
+    const account = this.state.accounts.find((a) => a.address === address);
+    if (!account) {
+      log3.warn("account not found", { address });
+      return err(new AccountNotFoundError(address));
+    }
+    this.setState({ selectedAccount: account });
+    this.persistAccount(address);
+    log3.debug("account selected", { address });
+    return ok(account);
+  }
+  /**
+   * Get the PolkadotSigner for the currently selected account.
+   * Returns null if no account is selected or manager is disconnected.
+   */
+  getSigner() {
+    return this.state.selectedAccount?.getSigner() ?? null;
+  }
+  /**
+   * Sign arbitrary bytes with the currently selected account.
+   *
+   * Convenience wrapper around `PolkadotSigner.signBytes` — useful for
+   * master key derivation, message signing, and proof generation without
+   * constructing a full transaction.
+   *
+   * Returns a SIGNING_FAILED error if no account is selected or signing fails.
+   */
+  async signRaw(data) {
+    if (this.isDestroyed) {
+      return err(new DestroyedError());
+    }
+    const signer = this.getSigner();
+    if (!signer) {
+      return err(new SigningFailedError(null, "No account selected"));
+    }
+    try {
+      const signature = await signer.signBytes(data);
+      return ok(signature);
+    } catch (cause) {
+      log3.error("signRaw failed", { cause });
+      return err(new SigningFailedError(cause));
+    }
+  }
+  // ── Host-only: Product Account API ─────────────────────────────
+  /**
+   * Get an app-scoped product account from the host.
+   *
+   * Product accounts are derived by the host wallet for each app, identified
+   * by `dotNsIdentifier` (e.g., "mark3t.dot"). Only available when connected
+   * via the host provider — returns HOST_UNAVAILABLE otherwise.
+   *
+   * @example
+   * ```ts
+   * const result = await manager.getProductAccount("myapp.dot");
+   * if (result.ok) {
+   *   const signer = result.value.getSigner();
+   * }
+   * ```
+   */
+  async getProductAccount(dotNsIdentifier, derivationIndex = 0) {
+    if (this.isDestroyed) return err(new DestroyedError());
+    const host = this.getHostProvider();
+    if (!host) {
+      return err(
+        new HostUnavailableError("Product accounts require a host provider connection")
+      );
+    }
+    return host.getProductAccount(dotNsIdentifier, derivationIndex);
+  }
+  /**
+   * Get a contextual alias for a product account via Ring VRF.
+   *
+   * Aliases prove account membership in a ring without revealing which
+   * account produced the alias. Only available when connected via the host
+   * provider — returns HOST_UNAVAILABLE otherwise.
+   */
+  async getProductAccountAlias(dotNsIdentifier, derivationIndex = 0) {
+    if (this.isDestroyed) return err(new DestroyedError());
+    const host = this.getHostProvider();
+    if (!host) {
+      return err(
+        new HostUnavailableError(
+          "Product account aliases require a host provider connection"
+        )
+      );
+    }
+    return host.getProductAccountAlias(dotNsIdentifier, derivationIndex);
+  }
+  /**
+   * Create a Ring VRF proof for anonymous operations.
+   *
+   * Proves that the signer is a member of the ring at the given location
+   * without revealing which member. Only available when connected via the
+   * host provider — returns HOST_UNAVAILABLE otherwise.
+   */
+  async createRingVRFProof(dotNsIdentifier, derivationIndex, location, message) {
+    if (this.isDestroyed) return err(new DestroyedError());
+    const host = this.getHostProvider();
+    if (!host) {
+      return err(
+        new HostUnavailableError("Ring VRF proofs require a host provider connection")
+      );
+    }
+    return host.createRingVRFProof(dotNsIdentifier, derivationIndex, location, message);
+  }
+  /**
+   * Destroy the manager and release all resources.
+   * After calling destroy(), the manager is unusable.
+   */
+  destroy() {
+    if (this.isDestroyed) return;
+    this.isDestroyed = true;
+    this.cancelConnect();
+    this.cancelReconnect();
+    this.disconnectInternal();
+    this.subscribers.clear();
+    this.state = initialState();
+    log3.info("manager destroyed");
+  }
+  // ── Private ──────────────────────────────────────────────────────
+  async connectToProvider(type, signal) {
+    const provider = this.createProvider(type);
+    const result = await provider.connect(signal);
+    if (!result.ok) {
+      provider.disconnect();
+      this.setState({ status: "disconnected", error: result.error });
+      return result;
+    }
+    this.provider = provider;
+    const statusUnsub = provider.onStatusChange((status) => {
+      this.handleProviderStatusChange(status);
+    });
+    this.cleanups.push(statusUnsub);
+    const accountUnsub = provider.onAccountsChange((accounts2) => {
+      this.setState({
+        accounts: accounts2,
+        // Clear selected if no longer in list
+        selectedAccount: accounts2.find((a) => a.address === this.state.selectedAccount?.address) ?? null
+      });
+    });
+    this.cleanups.push(accountUnsub);
+    const accounts = result.value;
+    const persisted = await this.loadPersistedAccount();
+    const restoredAccount = persisted ? accounts.find((a) => a.address === persisted) : null;
+    const selectedAccount = restoredAccount ?? (accounts.length > 0 ? accounts[0] : null);
+    this.setState({
+      status: "connected",
+      accounts,
+      activeProvider: type,
+      selectedAccount,
+      error: null
+    });
+    if (selectedAccount) {
+      this.persistAccount(selectedAccount.address);
+    }
+    log3.info("connected", { provider: type, accounts: accounts.length });
+    return result;
+  }
+  createProvider(type) {
+    if (this.providerFactory) {
+      return this.providerFactory(type);
+    }
+    switch (type) {
+      case "host":
+        return new HostProvider({
+          ss58Prefix: this.ss58Prefix,
+          maxRetries: this.maxRetries,
+          retryDelay: 500
+        });
+      case "dev":
+        return new DevProvider({
+          ss58Prefix: this.ss58Prefix
+        });
+      default:
+        throw new Error(
+          `Unsupported provider type: ${type}. The SDK only supports "host" and "dev" providers.`
+        );
+    }
+  }
+  /* @integration */
+  handleProviderStatusChange(status) {
+    if (status === "disconnected" && this.state.status === "connected") {
+      log3.warn("provider disconnected, attempting reconnect");
+      this.attemptReconnect();
+    }
+  }
+  /* @integration */
+  attemptReconnect() {
+    this.cancelReconnect();
+    const providerType = this.state.activeProvider;
+    if (!providerType) return;
+    this.reconnectController = new AbortController();
+    const signal = this.reconnectController.signal;
+    this.setState({ status: "connecting" });
+    withRetry(
+      async () => {
+        if (signal.aborted) {
+          return err(new HostDisconnectedError("Reconnect cancelled"));
+        }
+        this.disconnectInternal();
+        const provider = this.createProvider(providerType);
+        const connectSignal = providerType === "host" ? AbortSignal.any([signal, AbortSignal.timeout(this.hostTimeout)]) : signal;
+        const result = await provider.connect(connectSignal);
+        if (!result.ok) return result;
+        this.provider = provider;
+        const statusUnsub = provider.onStatusChange(
+          (s) => this.handleProviderStatusChange(s)
+        );
+        this.cleanups.push(statusUnsub);
+        const accountUnsub = provider.onAccountsChange((accounts2) => {
+          this.setState({
+            accounts: accounts2,
+            selectedAccount: accounts2.find(
+              (a) => a.address === this.state.selectedAccount?.address
+            ) ?? null
+          });
+        });
+        this.cleanups.push(accountUnsub);
+        const accounts = result.value;
+        this.setState({
+          status: "connected",
+          accounts,
+          activeProvider: providerType,
+          selectedAccount: accounts.find((a) => a.address === this.state.selectedAccount?.address) ?? (accounts.length > 0 ? accounts[0] : null),
+          error: null
+        });
+        log3.info("reconnected", { provider: providerType });
+        return result;
+      },
+      {
+        maxAttempts: RECONNECT_MAX_ATTEMPTS,
+        initialDelay: RECONNECT_INITIAL_DELAY,
+        maxDelay: RECONNECT_MAX_DELAY,
+        signal
+      }
+    ).then((result) => {
+      if (!result.ok && !signal.aborted) {
+        log3.error("reconnect failed after all retries", { error: result.error });
+        this.setState({
+          status: "disconnected",
+          error: new HostDisconnectedError("Reconnect failed after all retries")
+        });
+      }
+    }).catch((cause) => {
+      log3.error("unexpected reconnect error", { cause });
+      this.setState({
+        status: "disconnected",
+        error: new HostDisconnectedError("Reconnect failed unexpectedly")
+      });
+    });
+  }
+  /** Returns the underlying HostProvider if connected via host, or null otherwise. */
+  getHostProvider() {
+    if (this.provider && this.state.activeProvider === "host") {
+      return this.provider;
+    }
+    return null;
+  }
+  cancelConnect() {
+    if (this.connectController) {
+      this.connectController.abort();
+      this.connectController = null;
+    }
+  }
+  cancelReconnect() {
+    if (this.reconnectController) {
+      this.reconnectController.abort();
+      this.reconnectController = null;
+    }
+  }
+  disconnectInternal() {
+    for (const cleanup of this.cleanups) {
+      cleanup();
+    }
+    this.cleanups = [];
+    if (this.provider) {
+      this.provider.disconnect();
+      this.provider = null;
+    }
+  }
+  persistAccount(address) {
+    void this.getPersistence().then((p) => {
+      if (p) {
+        const key = persistenceStorageKey(this.dappName);
+        return Promise.resolve(p.setItem(key, address));
+      }
+    }).catch(() => {
+      log3.debug("failed to persist selected account");
+    });
+  }
+  async loadPersistedAccount() {
+    try {
+      const p = await this.getPersistence();
+      if (!p) return null;
+      const key = persistenceStorageKey(this.dappName);
+      const value = await Promise.resolve(p.getItem(key));
+      return value || null;
+    } catch {
+      log3.debug("failed to load persisted account");
+      return null;
+    }
+  }
+  setState(patch) {
+    this.state = { ...this.state, ...patch };
+    for (const subscriber of this.subscribers) {
+      subscriber(this.state);
+    }
+  }
+};
+export {
+  AccountNotFoundError,
+  DestroyedError,
+  DevProvider,
+  HostDisconnectedError,
+  HostProvider,
+  HostRejectedError,
+  HostUnavailableError,
+  NoAccountsError,
+  SignerError,
+  SignerManager,
+  SigningFailedError,
+  TimeoutError,
+  err,
+  isHostError,
+  ok,
+  sleep,
+  withRetry
+};
+//# sourceMappingURL=index.js.map