@parity/product-sdk-signer 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,5 +1,9 @@
+import { createLogger } from '@parity/product-sdk-logger';
+import { getHostLocalStorage } from '@parity/product-sdk-host';
+import { seedToAccount } from '@parity/product-sdk-keys';
+import { ss58Encode, deriveH160 } from '@parity/product-sdk-address';
+
 // src/signer-manager.ts
-import { createLogger as createLogger3 } from "@parity/product-sdk-logger";
 
 // src/errors.ts
 var SignerError = class extends Error {
@@ -70,103 +74,6 @@ var DestroyedError = class extends SignerError {
 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) {
@@ -175,66 +82,6 @@ function ok(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");
@@ -284,184 +131,6 @@ var DevProvider = class {
     };
   }
 };
-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) {
@@ -479,67 +148,6 @@ function sleep(ms, signal) {
     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;
@@ -569,135 +177,14 @@ async function withRetry(fn, options) {
   }
   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");
+var log2 = createLogger("signer:host");
 async function defaultLoadSdk() {
-  return await import("@novasamatech/product-sdk");
+  return await import('@novasamatech/product-sdk');
 }
 async function defaultLoadHostApiEnum() {
-  return await import("@novasamatech/host-api");
+  return await import('@novasamatech/host-api');
 }
 var HostProvider = class {
   type = "host";
@@ -897,7 +384,7 @@ var HostProvider = class {
     this.accountsProvider = provider;
     let rawAccounts;
     try {
-      rawAccounts = await provider.getNonProductAccounts().match(
+      rawAccounts = await provider.getLegacyAccounts().match(
         (accounts2) => accounts2,
         (error) => {
           throw new Error(`Host rejected account request: ${formatError(error)}`);
@@ -961,7 +448,7 @@ var HostProvider = class {
           if (!this.accountsProvider) {
             throw new Error("Host provider is disconnected");
           }
-          return this.accountsProvider.getNonProductAccountSigner({
+          return this.accountsProvider.getLegacyAccountSigner({
             dotNsIdentifier: "",
             derivationIndex: 0,
             publicKey: raw.publicKey
@@ -977,157 +464,9 @@ function formatError(error) {
   }
   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 log3 = createLogger("signer");
 var DEFAULT_HOST_TIMEOUT = 1e4;
 var DEFAULT_MAX_RETRIES = 3;
 var DEFAULT_SS58_PREFIX = 42;
@@ -1556,23 +895,7 @@ var SignerManager = class {
     }
   }
 };
-export {
-  AccountNotFoundError,
-  DestroyedError,
-  DevProvider,
-  HostDisconnectedError,
-  HostProvider,
-  HostRejectedError,
-  HostUnavailableError,
-  NoAccountsError,
-  SignerError,
-  SignerManager,
-  SigningFailedError,
-  TimeoutError,
-  err,
-  isHostError,
-  ok,
-  sleep,
-  withRetry
-};
+
+export { AccountNotFoundError, DestroyedError, DevProvider, HostDisconnectedError, HostProvider, HostRejectedError, HostUnavailableError, NoAccountsError, SignerError, SignerManager, SigningFailedError, TimeoutError, err, isHostError, ok, sleep, withRetry };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map