@parity/product-sdk-terminal 0.0.0-dev.312.0 → 0.0.0-dev.421.0

package/dist/chunk-YS3GW2XW.js

@@ -1,1508 +0,0 @@
-// src/host.ts
-import { createLogger as createLogger2 } from "@parity/product-sdk-logger";
-
-// src/host-cache.ts
-import { createLogger } from "@parity/product-sdk-logger";
-import { toHex } from "@polkadot-api/utils";
-import { mkdir, readFile, rename, writeFile } from "fs/promises";
-import { homedir } from "os";
-import { dirname, join } from "path";
-var log = createLogger("terminal");
-var DEFAULT_STORAGE_DIR = join(homedir(), ".polkadot-apps");
-var CACHE_FILE_MODE = 384;
-function sanitizeAppId(appId) {
-  return appId.replace(/[^a-zA-Z0-9_.-]/g, "_");
-}
-function cachePath(appId, storageDir) {
-  return join(storageDir ?? DEFAULT_STORAGE_DIR, `${sanitizeAppId(appId)}_AllowanceKeys.json`);
-}
-function emptyCache() {
-  return { version: 1, entries: {} };
-}
-async function loadCache(appId, storageDir) {
-  const path = cachePath(appId, storageDir);
-  let raw;
-  try {
-    raw = await readFile(path, "utf-8");
-  } catch (e) {
-    if (e?.code === "ENOENT") return emptyCache();
-    throw e;
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed?.version !== 1 || typeof parsed.entries !== "object" || parsed.entries === null) {
-      log.warn("allowance cache schema mismatch; starting fresh", { appId, path });
-      return emptyCache();
-    }
-    return parsed;
-  } catch (e) {
-    log.warn("allowance cache parse failed; starting fresh", { appId, path, error: String(e) });
-    return emptyCache();
-  }
-}
-async function saveCache(appId, cache, storageDir) {
-  const path = cachePath(appId, storageDir);
-  await mkdir(dirname(path), { recursive: true });
-  const tmp = `${path}.tmp`;
-  await writeFile(tmp, JSON.stringify(cache, null, 2), { mode: CACHE_FILE_MODE });
-  await rename(tmp, path);
-}
-function cacheKey(resource) {
-  if (resource.tag === "SmartContractAllowance") {
-    return `${resource.tag}::${resource.value}`;
-  }
-  return resource.tag;
-}
-function pickOnExistingPolicy(cache, resources) {
-  if (resources.length === 0) return "Ignore";
-  const allSlotTableAndCached = resources.every((r) => {
-    if (r.tag !== "BulletInAllowance" && r.tag !== "StatementStoreAllowance") return false;
-    return Object.hasOwn(cache.entries, cacheKey(r));
-  });
-  return allSlotTableAndCached ? "Increase" : "Ignore";
-}
-function mergeOutcomes(cache, requested, outcomes) {
-  if (requested.length !== outcomes.length) {
-    throw new Error(
-      `mergeOutcomes: length mismatch \u2014 requested ${requested.length}, got ${outcomes.length}`
-    );
-  }
-  const entries = { ...cache.entries };
-  let mutated = false;
-  for (let i = 0; i < outcomes.length; i++) {
-    const req = requested[i];
-    const out = outcomes[i];
-    if (out.tag !== "Allocated") continue;
-    const inner = out.value;
-    if (inner.tag !== req.tag) {
-      throw new Error(
-        `mergeOutcomes: variant mismatch at index ${i} \u2014 requested ${req.tag}, got Allocated<${inner.tag}>`
-      );
-    }
-    const key = cacheKey(req);
-    switch (inner.tag) {
-      case "BulletInAllowance":
-      case "StatementStoreAllowance":
-        entries[key] = {
-          tag: inner.tag,
-          slotAccountKey: toHex(inner.value.slotAccountKey)
-        };
-        mutated = true;
-        break;
-      case "SmartContractAllowance":
-        if (req.tag === "SmartContractAllowance") {
-          entries[key] = { tag: "SmartContractAllowance", dest: req.value };
-          mutated = true;
-        }
-        break;
-      case "AutoSigning":
-        entries[key] = {
-          tag: "AutoSigning",
-          productDerivationSecret: inner.value.productDerivationSecret,
-          productRootPrivateKey: toHex(inner.value.productRootPrivateKey)
-        };
-        mutated = true;
-        break;
-    }
-  }
-  return mutated ? { version: 1, entries } : cache;
-}
-function readCacheEntry(cache, resource) {
-  return cache.entries[cacheKey(resource)] ?? null;
-}
-var cacheLocks = /* @__PURE__ */ new Map();
-function withCacheLock(appId, storageDir, fn) {
-  const key = cachePath(appId, storageDir);
-  const prev = cacheLocks.get(key) ?? Promise.resolve();
-  const next = prev.catch(() => {
-  }).then(fn);
-  cacheLocks.set(
-    key,
-    next.catch(() => {
-    })
-  );
-  return next;
-}
-if (void 0) {
-  const { describe, test, expect, beforeEach } = void 0;
-  const { mkdtempSync, rmSync } = await null;
-  const { tmpdir } = await null;
-  let storageDir;
-  beforeEach(() => {
-    storageDir = mkdtempSync(join(tmpdir(), "host-cache-test-"));
-    return () => rmSync(storageDir, { recursive: true, force: true });
-  });
-  describe("cacheKey", () => {
-    test("returns the variant tag for slot-table resources and AutoSigning", () => {
-      expect(cacheKey({ tag: "BulletInAllowance", value: void 0 })).toBe(
-        "BulletInAllowance"
-      );
-      expect(cacheKey({ tag: "StatementStoreAllowance", value: void 0 })).toBe(
-        "StatementStoreAllowance"
-      );
-      expect(cacheKey({ tag: "AutoSigning", value: void 0 })).toBe("AutoSigning");
-    });
-    test("disambiguates SmartContractAllowance by dest", () => {
-      expect(cacheKey({ tag: "SmartContractAllowance", value: 0 })).toBe(
-        "SmartContractAllowance::0"
-      );
-      expect(cacheKey({ tag: "SmartContractAllowance", value: 7 })).toBe(
-        "SmartContractAllowance::7"
-      );
-    });
-  });
-  describe("loadCache / saveCache round-trip", () => {
-    test("loadCache on missing file returns empty cache, not an error", async () => {
-      const cache = await loadCache("my-app", storageDir);
-      expect(cache).toEqual({ version: 1, entries: {} });
-    });
-    test("saveCache then loadCache returns the same content", async () => {
-      const original = {
-        version: 1,
-        entries: {
-          BulletInAllowance: { tag: "BulletInAllowance", slotAccountKey: "0xdeadbeef" }
-        }
-      };
-      await saveCache("my-app", original, storageDir);
-      const reloaded = await loadCache("my-app", storageDir);
-      expect(reloaded).toEqual(original);
-    });
-    test("two appIds in the same storageDir don't collide", async () => {
-      const a = {
-        version: 1,
-        entries: {
-          BulletInAllowance: { tag: "BulletInAllowance", slotAccountKey: "0x01" }
-        }
-      };
-      const b = {
-        version: 1,
-        entries: {
-          BulletInAllowance: { tag: "BulletInAllowance", slotAccountKey: "0x02" }
-        }
-      };
-      await saveCache("app-a", a, storageDir);
-      await saveCache("app-b", b, storageDir);
-      expect((await loadCache("app-a", storageDir)).entries.BulletInAllowance).toEqual(
-        a.entries.BulletInAllowance
-      );
-      expect((await loadCache("app-b", storageDir)).entries.BulletInAllowance).toEqual(
-        b.entries.BulletInAllowance
-      );
-    });
-    test("appId with non-alphanumeric characters sanitizes to a safe path", async () => {
-      const cache = { version: 1, entries: {} };
-      await expect(saveCache("../escape", cache, storageDir)).resolves.toBeUndefined();
-      const reloaded = await loadCache("../escape", storageDir);
-      expect(reloaded).toEqual(cache);
-    });
-    test("malformed cache file is treated as empty, not thrown", async () => {
-      await writeFile(cachePath("my-app", storageDir), "{ not valid json", "utf-8");
-      const cache = await loadCache("my-app", storageDir);
-      expect(cache).toEqual({ version: 1, entries: {} });
-    });
-    test("version mismatch is treated as empty, not thrown", async () => {
-      await writeFile(
-        cachePath("my-app", storageDir),
-        JSON.stringify({ version: 99, entries: {} }),
-        "utf-8"
-      );
-      const cache = await loadCache("my-app", storageDir);
-      expect(cache).toEqual({ version: 1, entries: {} });
-    });
-    test("file is written with 0o600 permissions (defense-in-depth)", async () => {
-      const { stat } = await null;
-      const cache = { version: 1, entries: {} };
-      await saveCache("my-app", cache, storageDir);
-      const s = await stat(cachePath("my-app", storageDir));
-      expect(s.mode & 511).toBe(384);
-    });
-  });
-  describe("pickOnExistingPolicy", () => {
-    test("empty request resolves to Ignore", () => {
-      const cache = emptyCache();
-      expect(pickOnExistingPolicy(cache, [])).toBe("Ignore");
-    });
-    test("no cached entries \u2192 Ignore", () => {
-      const cache = emptyCache();
-      expect(
-        pickOnExistingPolicy(cache, [{ tag: "BulletInAllowance", value: void 0 }])
-      ).toBe("Ignore");
-    });
-    test("all slot-table resources cached \u2192 Increase", () => {
-      const cache = {
-        version: 1,
-        entries: {
-          BulletInAllowance: { tag: "BulletInAllowance", slotAccountKey: "0x01" },
-          StatementStoreAllowance: {
-            tag: "StatementStoreAllowance",
-            slotAccountKey: "0x02"
-          }
-        }
-      };
-      expect(
-        pickOnExistingPolicy(cache, [
-          { tag: "BulletInAllowance", value: void 0 },
-          { tag: "StatementStoreAllowance", value: void 0 }
-        ])
-      ).toBe("Increase");
-    });
-    test("mixed cached + uncached \u2192 Ignore (conservative)", () => {
-      const cache = {
-        version: 1,
-        entries: {
-          BulletInAllowance: { tag: "BulletInAllowance", slotAccountKey: "0x01" }
-        }
-      };
-      expect(
-        pickOnExistingPolicy(cache, [
-          { tag: "BulletInAllowance", value: void 0 },
-          { tag: "StatementStoreAllowance", value: void 0 }
-        ])
-      ).toBe("Ignore");
-    });
-    test("AutoSigning in the request \u2192 Ignore even if cached (not slot-additive)", () => {
-      const cache = {
-        version: 1,
-        entries: {
-          AutoSigning: {
-            tag: "AutoSigning",
-            productDerivationSecret: "x",
-            productRootPrivateKey: "0xaa"
-          }
-        }
-      };
-      expect(pickOnExistingPolicy(cache, [{ tag: "AutoSigning", value: void 0 }])).toBe(
-        "Ignore"
-      );
-    });
-    test("SC in the request \u2192 Ignore (not slot-additive; PGAS claim is per-call)", () => {
-      const cache = {
-        version: 1,
-        entries: {
-          "SmartContractAllowance::5": { tag: "SmartContractAllowance", dest: 5 }
-        }
-      };
-      expect(pickOnExistingPolicy(cache, [{ tag: "SmartContractAllowance", value: 5 }])).toBe(
-        "Ignore"
-      );
-    });
-  });
-  describe("mergeOutcomes", () => {
-    test("ignores Rejected and NotAvailable", () => {
-      const cache = emptyCache();
-      const requested = [
-        { tag: "BulletInAllowance", value: void 0 },
-        { tag: "StatementStoreAllowance", value: void 0 }
-      ];
-      const outcomes = [
-        { tag: "Rejected", value: void 0 },
-        { tag: "NotAvailable", value: void 0 }
-      ];
-      const merged = mergeOutcomes(cache, requested, outcomes);
-      expect(merged.entries).toEqual({});
-    });
-    test("stores Allocated Bulletin/SSS keys with hex encoding", () => {
-      const cache = emptyCache();
-      const requested = [
-        { tag: "BulletInAllowance", value: void 0 }
-      ];
-      const outcomes = [
-        {
-          tag: "Allocated",
-          value: {
-            tag: "BulletInAllowance",
-            value: { slotAccountKey: new Uint8Array([222, 173, 190, 239]) }
-          }
-        }
-      ];
-      const merged = mergeOutcomes(cache, requested, outcomes);
-      expect(merged.entries.BulletInAllowance).toEqual({
-        tag: "BulletInAllowance",
-        slotAccountKey: "0xdeadbeef"
-      });
-    });
-    test("stores SmartContractAllowance with dest from the request", () => {
-      const cache = emptyCache();
-      const requested = [{ tag: "SmartContractAllowance", value: 7 }];
-      const outcomes = [
-        {
-          tag: "Allocated",
-          value: { tag: "SmartContractAllowance", value: void 0 }
-        }
-      ];
-      const merged = mergeOutcomes(cache, requested, outcomes);
-      expect(merged.entries["SmartContractAllowance::7"]).toEqual({
-        tag: "SmartContractAllowance",
-        dest: 7
-      });
-    });
-    test("stores AutoSigning subtree key + secret", () => {
-      const cache = emptyCache();
-      const requested = [{ tag: "AutoSigning", value: void 0 }];
-      const outcomes = [
-        {
-          tag: "Allocated",
-          value: {
-            tag: "AutoSigning",
-            value: {
-              productDerivationSecret: "secret-hex",
-              productRootPrivateKey: new Uint8Array([171, 205])
-            }
-          }
-        }
-      ];
-      const merged = mergeOutcomes(cache, requested, outcomes);
-      expect(merged.entries.AutoSigning).toEqual({
-        tag: "AutoSigning",
-        productDerivationSecret: "secret-hex",
-        productRootPrivateKey: "0xabcd"
-      });
-    });
-    test("returns the same cache reference when no Allocated outcomes (no-op)", () => {
-      const cache = {
-        version: 1,
-        entries: {
-          BulletInAllowance: { tag: "BulletInAllowance", slotAccountKey: "0xaa" }
-        }
-      };
-      const requested = [
-        { tag: "BulletInAllowance", value: void 0 },
-        { tag: "StatementStoreAllowance", value: void 0 }
-      ];
-      const outcomes = [
-        { tag: "Rejected", value: void 0 },
-        { tag: "NotAvailable", value: void 0 }
-      ];
-      expect(mergeOutcomes(cache, requested, outcomes)).toBe(cache);
-    });
-    test("empty inputs return the same cache reference", () => {
-      const cache = emptyCache();
-      expect(mergeOutcomes(cache, [], [])).toBe(cache);
-    });
-    test("returns a new object reference when at least one entry is added", () => {
-      const cache = emptyCache();
-      const requested = [
-        { tag: "BulletInAllowance", value: void 0 }
-      ];
-      const outcomes = [
-        {
-          tag: "Allocated",
-          value: {
-            tag: "BulletInAllowance",
-            value: { slotAccountKey: new Uint8Array([1]) }
-          }
-        }
-      ];
-      expect(mergeOutcomes(cache, requested, outcomes)).not.toBe(cache);
-    });
-    test("throws when outcomes do not length-match requested", () => {
-      const cache = emptyCache();
-      const requested = [
-        { tag: "BulletInAllowance", value: void 0 },
-        { tag: "StatementStoreAllowance", value: void 0 }
-      ];
-      const outcomes = [{ tag: "Rejected", value: void 0 }];
-      expect(() => mergeOutcomes(cache, requested, outcomes)).toThrow(/length mismatch/);
-    });
-    test("throws when an Allocated outcome's variant does not match the requested variant", () => {
-      const cache = emptyCache();
-      const requested = [
-        { tag: "StatementStoreAllowance", value: void 0 }
-      ];
-      const outcomes = [
-        {
-          tag: "Allocated",
-          value: {
-            tag: "BulletInAllowance",
-            value: { slotAccountKey: new Uint8Array([170]) }
-          }
-        }
-      ];
-      expect(() => mergeOutcomes(cache, requested, outcomes)).toThrow(
-        /variant mismatch at index 0 — requested StatementStoreAllowance, got Allocated<BulletInAllowance>/
-      );
-    });
-    test("preserves existing entries when merging new ones", () => {
-      const cache = {
-        version: 1,
-        entries: {
-          StatementStoreAllowance: {
-            tag: "StatementStoreAllowance",
-            slotAccountKey: "0xaa"
-          }
-        }
-      };
-      const requested = [
-        { tag: "BulletInAllowance", value: void 0 }
-      ];
-      const outcomes = [
-        {
-          tag: "Allocated",
-          value: {
-            tag: "BulletInAllowance",
-            value: { slotAccountKey: new Uint8Array([187]) }
-          }
-        }
-      ];
-      const merged = mergeOutcomes(cache, requested, outcomes);
-      expect(Object.keys(merged.entries).sort()).toEqual([
-        "BulletInAllowance",
-        "StatementStoreAllowance"
-      ]);
-      expect(merged.entries.StatementStoreAllowance).toEqual({
-        tag: "StatementStoreAllowance",
-        slotAccountKey: "0xaa"
-      });
-    });
-  });
-  describe("readCacheEntry", () => {
-    test("returns the cached entry by resource discriminator", () => {
-      const cache = {
-        version: 1,
-        entries: {
-          "SmartContractAllowance::5": {
-            tag: "SmartContractAllowance",
-            dest: 5
-          }
-        }
-      };
-      expect(readCacheEntry(cache, { tag: "SmartContractAllowance", value: 5 })).toEqual({
-        tag: "SmartContractAllowance",
-        dest: 5
-      });
-      expect(readCacheEntry(cache, { tag: "SmartContractAllowance", value: 6 })).toBeNull();
-    });
-    test("returns null when nothing cached", () => {
-      const cache = emptyCache();
-      expect(
-        readCacheEntry(cache, { tag: "BulletInAllowance", value: void 0 })
-      ).toBeNull();
-    });
-  });
-  describe("withCacheLock", () => {
-    test("serializes calls for the same (appId, storageDir)", async () => {
-      const order = [];
-      const a = withCacheLock("app", storageDir, async () => {
-        order.push("a-start");
-        await new Promise((r) => setTimeout(r, 10));
-        order.push("a-end");
-      });
-      const b = withCacheLock("app", storageDir, async () => {
-        order.push("b-start");
-        order.push("b-end");
-      });
-      await Promise.all([a, b]);
-      expect(order).toEqual(["a-start", "a-end", "b-start", "b-end"]);
-    });
-    test("different (appId, storageDir) keys do not block each other", async () => {
-      let bRan = false;
-      const a = withCacheLock("app-a", storageDir, async () => {
-        await new Promise((r) => setTimeout(r, 20));
-        expect(bRan).toBe(true);
-      });
-      const b = withCacheLock("app-b", storageDir, async () => {
-        bRan = true;
-      });
-      await Promise.all([a, b]);
-    });
-    test("a rejection in one call does not block subsequent calls on the same key", async () => {
-      const a = withCacheLock("app", storageDir, async () => {
-        throw new Error("boom");
-      });
-      await expect(a).rejects.toThrow("boom");
-      const b = await withCacheLock("app", storageDir, async () => "ok");
-      expect(b).toBe("ok");
-    });
-  });
-}
-
-// src/host-signer.ts
-import { bytesToNumberLE, numberToBytesLE } from "@noble/curves/utils.js";
-import { fromHex } from "@polkadot-api/utils";
-import { createDerive, sr25519, sr25519Derive } from "@polkadot-labs/hdkd-helpers";
-import { getPolkadotSigner } from "polkadot-api/signer";
-function canonicalSr25519SecretToEd25519Bytes(secret) {
-  const ed25519Scalar = numberToBytesLE(bytesToNumberLE(secret.subarray(0, 32)) << 3n, 32);
-  const out = new Uint8Array(64);
-  out.set(ed25519Scalar, 0);
-  out.set(secret.subarray(32, 64), 32);
-  return out;
-}
-function buildKeypair(secret) {
-  if (secret.length === 32) {
-    const derive = createDerive({ seed: secret, curve: sr25519, derive: sr25519Derive });
-    const keypair = derive("");
-    return { publicKey: keypair.publicKey, sign: (data) => keypair.sign(data) };
-  }
-  if (secret.length === 64) {
-    const ed25519Secret = canonicalSr25519SecretToEd25519Bytes(secret);
-    return {
-      publicKey: sr25519.getPublicKey(ed25519Secret),
-      sign: (data) => sr25519.sign(data, ed25519Secret)
-    };
-  }
-  throw new Error(
-    `createSlotAccountSigner: unexpected slotAccountKey length ${secret.length}. Expected 32 (mini-secret) or 64 (expanded secret).`
-  );
-}
-function buildSignerFromEntry(entry) {
-  if (entry.tag !== "BulletInAllowance" && entry.tag !== "StatementStoreAllowance") {
-    throw new Error(
-      `createSlotAccountSigner: ${entry.tag} does not carry a slot account key. Slot-table signing is defined for BulletInAllowance and StatementStoreAllowance only.`
-    );
-  }
-  const secret = fromHex(entry.slotAccountKey);
-  const { publicKey, sign } = buildKeypair(secret);
-  return getPolkadotSigner(publicKey, "Sr25519", async (data) => sign(data));
-}
-async function createSlotAccountSigner(adapter, resource, productId) {
-  const cache = await loadCache(productId ?? adapter.appId, adapter.storageDir);
-  const entry = readCacheEntry(cache, resource);
-  if (!entry) return null;
-  return buildSignerFromEntry(entry);
-}
-if (void 0) {
-  let fakeAdapter = function(appId) {
-    return { appId, storageDir };
-  }, knownSecret = function() {
-    const secret = mnemonicToMiniSecret(DEV_PHRASE);
-    const derive = createDerive({ seed: secret, curve: sr25519, derive: sr25519Derive });
-    const keypair = derive("");
-    return {
-      secret,
-      publicKey: keypair.publicKey,
-      hex: toHex2(secret),
-      sign: (msg) => keypair.sign(msg)
-    };
-  };
-  fakeAdapter2 = fakeAdapter, knownSecret2 = knownSecret;
-  const { describe, test, expect, beforeEach } = void 0;
-  const { mkdtempSync, rmSync } = await null;
-  const { tmpdir } = await null;
-  const { join: pathJoin } = await null;
-  const { saveCache: saveCache2 } = await null;
-  const { DEV_PHRASE, mnemonicToMiniSecret } = await null;
-  const { toHex: toHex2 } = await null;
-  let storageDir;
-  beforeEach(() => {
-    storageDir = mkdtempSync(pathJoin(tmpdir(), "host-signer-test-"));
-    return () => rmSync(storageDir, { recursive: true, force: true });
-  });
-  describe("createSlotAccountSigner", () => {
-    test("returns null when no allocation is cached", async () => {
-      const adapter = fakeAdapter("p");
-      const signer = await createSlotAccountSigner(adapter, {
-        tag: "BulletInAllowance",
-        value: void 0
-      });
-      expect(signer).toBeNull();
-    });
-    test("returns a signer with the sr25519 public key derived from the cached secret", async () => {
-      const { hex, publicKey } = knownSecret();
-      await saveCache2(
-        "p",
-        {
-          version: 1,
-          entries: {
-            BulletInAllowance: { tag: "BulletInAllowance", slotAccountKey: hex }
-          }
-        },
-        storageDir
-      );
-      const signer = await createSlotAccountSigner(fakeAdapter("p"), {
-        tag: "BulletInAllowance",
-        value: void 0
-      });
-      expect(signer).not.toBeNull();
-      expect(signer?.publicKey).toEqual(publicKey);
-    });
-    test("signs locally and the signature verifies against the cached account", async () => {
-      const { hex, publicKey } = knownSecret();
-      await saveCache2(
-        "p",
-        {
-          version: 1,
-          entries: {
-            BulletInAllowance: { tag: "BulletInAllowance", slotAccountKey: hex }
-          }
-        },
-        storageDir
-      );
-      const signer = await createSlotAccountSigner(fakeAdapter("p"), {
-        tag: "BulletInAllowance",
-        value: void 0
-      });
-      const payload = new TextEncoder().encode("hello slot");
-      const wrapped = new Uint8Array([
-        ...new TextEncoder().encode("<Bytes>"),
-        ...payload,
-        ...new TextEncoder().encode("</Bytes>")
-      ]);
-      const signature = await signer.signBytes(payload);
-      expect(sr25519.verify(signature, wrapped, publicKey)).toBe(true);
-    });
-    test("64-byte expanded-secret form produces a valid signer", async () => {
-      const SECRET_64_HEX = "0x05d65584630d16cd4af6d0bec10f34bb504a5dcb62dba2122d49f5a663763d0afd190cce74df356432b410bd64682309d6dedb27c76845daf388557cbac3ca34";
-      await saveCache2(
-        "p",
-        {
-          version: 1,
-          entries: {
-            BulletInAllowance: {
-              tag: "BulletInAllowance",
-              slotAccountKey: SECRET_64_HEX
-            }
-          }
-        },
-        storageDir
-      );
-      const signer = await createSlotAccountSigner(fakeAdapter("p"), {
-        tag: "BulletInAllowance",
-        value: void 0
-      });
-      expect(signer).not.toBeNull();
-      const { publicKey: pubFrom32Bytes } = knownSecret();
-      expect(signer?.publicKey).toEqual(pubFrom32Bytes);
-      const payload = new TextEncoder().encode("hello 64-byte path");
-      const wrapped = new Uint8Array([
-        ...new TextEncoder().encode("<Bytes>"),
-        ...payload,
-        ...new TextEncoder().encode("</Bytes>")
-      ]);
-      const sig = await signer.signBytes(payload);
-      expect(sr25519.verify(sig, wrapped, pubFrom32Bytes)).toBe(true);
-    });
-    test("works for StatementStoreAllowance the same way", async () => {
-      const { hex, publicKey } = knownSecret();
-      await saveCache2(
-        "p",
-        {
-          version: 1,
-          entries: {
-            StatementStoreAllowance: {
-              tag: "StatementStoreAllowance",
-              slotAccountKey: hex
-            }
-          }
-        },
-        storageDir
-      );
-      const signer = await createSlotAccountSigner(fakeAdapter("p"), {
-        tag: "StatementStoreAllowance",
-        value: void 0
-      });
-      expect(signer?.publicKey).toEqual(publicKey);
-    });
-    test("throws for SmartContractAllowance (no slot account key)", async () => {
-      await saveCache2(
-        "p",
-        {
-          version: 1,
-          entries: {
-            "SmartContractAllowance::5": { tag: "SmartContractAllowance", dest: 5 }
-          }
-        },
-        storageDir
-      );
-      await expect(
-        createSlotAccountSigner(fakeAdapter("p"), {
-          tag: "SmartContractAllowance",
-          value: 5
-        })
-      ).rejects.toThrow(/SmartContractAllowance does not carry a slot account key/);
-    });
-    test("throws for AutoSigning (subtree key, not slot account)", async () => {
-      await saveCache2(
-        "p",
-        {
-          version: 1,
-          entries: {
-            AutoSigning: {
-              tag: "AutoSigning",
-              productDerivationSecret: "secret",
-              productRootPrivateKey: "0xabcd"
-            }
-          }
-        },
-        storageDir
-      );
-      await expect(
-        createSlotAccountSigner(fakeAdapter("p"), {
-          tag: "AutoSigning",
-          value: void 0
-        })
-      ).rejects.toThrow(/AutoSigning does not carry a slot account key/);
-    });
-    test("explicit productId reads that cache namespace instead of adapter.appId", async () => {
-      const { hex, publicKey } = knownSecret();
-      await saveCache2(
-        "my-product.dot",
-        {
-          version: 1,
-          entries: {
-            BulletInAllowance: { tag: "BulletInAllowance", slotAccountKey: hex }
-          }
-        },
-        storageDir
-      );
-      const adapter = fakeAdapter("my-cli");
-      expect(
-        await createSlotAccountSigner(adapter, {
-          tag: "BulletInAllowance",
-          value: void 0
-        })
-      ).toBeNull();
-      const signer = await createSlotAccountSigner(
-        adapter,
-        { tag: "BulletInAllowance", value: void 0 },
-        "my-product.dot"
-      );
-      expect(signer?.publicKey).toEqual(publicKey);
-    });
-    test("different appIds yield different signers from disjoint caches", async () => {
-      const a = knownSecret();
-      const otherMiniSecret = new Uint8Array(32).fill(7);
-      const otherKeypair = createDerive({
-        seed: otherMiniSecret,
-        curve: sr25519,
-        derive: sr25519Derive
-      })("");
-      await saveCache2(
-        "app-a",
-        {
-          version: 1,
-          entries: {
-            BulletInAllowance: { tag: "BulletInAllowance", slotAccountKey: a.hex }
-          }
-        },
-        storageDir
-      );
-      await saveCache2(
-        "app-b",
-        {
-          version: 1,
-          entries: {
-            BulletInAllowance: {
-              tag: "BulletInAllowance",
-              slotAccountKey: toHex2(otherMiniSecret)
-            }
-          }
-        },
-        storageDir
-      );
-      const signerA = await createSlotAccountSigner(fakeAdapter("app-a"), {
-        tag: "BulletInAllowance",
-        value: void 0
-      });
-      const signerB = await createSlotAccountSigner(fakeAdapter("app-b"), {
-        tag: "BulletInAllowance",
-        value: void 0
-      });
-      expect(signerA?.publicKey).toEqual(a.publicKey);
-      expect(signerB?.publicKey).toEqual(otherKeypair.publicKey);
-      expect(signerA?.publicKey).not.toEqual(signerB?.publicKey);
-    });
-    test("rejects an unexpected slotAccountKey length", async () => {
-      await saveCache2(
-        "p",
-        {
-          version: 1,
-          entries: {
-            BulletInAllowance: {
-              tag: "BulletInAllowance",
-              slotAccountKey: toHex2(new Uint8Array(48).fill(1))
-            }
-          }
-        },
-        storageDir
-      );
-      await expect(
-        createSlotAccountSigner(fakeAdapter("p"), {
-          tag: "BulletInAllowance",
-          value: void 0
-        })
-      ).rejects.toThrow(/unexpected slotAccountKey length 48/);
-    });
-  });
-}
-var fakeAdapter2;
-var knownSecret2;
-
-// src/host.ts
-var log2 = createLogger2("terminal");
-async function requestResourceAllocation(session, adapter, resources, options = {}) {
-  const productId = options.productId ?? adapter.appId;
-  return withCacheLock(productId, adapter.storageDir, async () => {
-    const cache = await loadCache(productId, adapter.storageDir);
-    const onExisting = options.onExisting ?? pickOnExistingPolicy(cache, resources);
-    log2.debug("requestResourceAllocation", {
-      productId,
-      resources: resources.map((r) => r.tag),
-      onExisting,
-      autoPolicy: options.onExisting === void 0
-    });
-    const outcomes = await sendResourceAllocation(session, productId, resources, onExisting);
-    const next = mergeOutcomes(cache, resources, outcomes);
-    if (next !== cache) {
-      await saveCache(productId, next, adapter.storageDir);
-    }
-    return outcomes;
-  });
-}
-async function sendResourceAllocation(session, productId, resources, onExisting) {
-  const result = await session.requestResourceAllocation({
-    callingProductId: productId,
-    resources,
-    onExisting
-  });
-  if (result.isErr()) {
-    throw new Error(`requestResourceAllocation failed: ${result.error.message}`);
-  }
-  return result.value;
-}
-async function getCachedAllocation(adapter, resource, productId) {
-  const cache = await loadCache(productId ?? adapter.appId, adapter.storageDir);
-  return readCacheEntry(cache, resource);
-}
-async function ensureSlotAccountSigner(session, adapter, resource, productId) {
-  const resolvedProductId = productId ?? adapter.appId;
-  return withCacheLock(resolvedProductId, adapter.storageDir, async () => {
-    const cache = await loadCache(resolvedProductId, adapter.storageDir);
-    const hit = readCacheEntry(cache, resource);
-    if (hit) return buildSignerFromEntry(hit);
-    log2.debug("ensureSlotAccountSigner: cache miss, allocating", { resource: resource.tag });
-    const onExisting = pickOnExistingPolicy(cache, [resource]);
-    const outcomes = await sendResourceAllocation(
-      session,
-      resolvedProductId,
-      [resource],
-      onExisting
-    );
-    const next = mergeOutcomes(cache, [resource], outcomes);
-    if (next !== cache) {
-      await saveCache(resolvedProductId, next, adapter.storageDir);
-    }
-    const outcome = outcomes[0];
-    if (!outcome) {
-      throw new Error(
-        `ensureSlotAccountSigner: protocol violation \u2014 empty outcomes for ${resource.tag}`
-      );
-    }
-    if (outcome.tag !== "Allocated") {
-      throw new Error(
-        `ensureSlotAccountSigner: allocation ${outcome.tag} for ${resource.tag}`
-      );
-    }
-    const freshEntry = readCacheEntry(next, resource);
-    if (!freshEntry) {
-      throw new Error(
-        `ensureSlotAccountSigner: allocation succeeded but cache lookup returned null for ${resource.tag}`
-      );
-    }
-    return buildSignerFromEntry(freshEntry);
-  });
-}
-if (void 0) {
-  let fakeAdapter = function(appId) {
-    return { appId, storageDir: testStorageDir };
-  }, makeSession = function(opts) {
-    return {
-      requestResourceAllocation: vi.fn(
-        opts.requestResourceAllocation ?? (async () => {
-          throw new Error("requestResourceAllocation not stubbed in this test");
-        })
-      )
-    };
-  };
-  fakeAdapter2 = fakeAdapter, makeSession2 = makeSession;
-  const { describe, test, expect, vi, beforeEach } = void 0;
-  const { ok, err } = await null;
-  const { mkdtempSync, rmSync } = await null;
-  const { tmpdir } = await null;
-  const { join: pathJoin } = await null;
-  const { mnemonicToMiniSecret, DEV_PHRASE } = await null;
-  const { toHex: toHex2 } = await null;
-  let testStorageDir;
-  beforeEach(() => {
-    testStorageDir = mkdtempSync(pathJoin(tmpdir(), "host-test-"));
-    return () => rmSync(testStorageDir, { recursive: true, force: true });
-  });
-  describe("requestResourceAllocation", () => {
-    test("forwards resources verbatim and returns outcomes in order", async () => {
-      const captured = [];
-      const stubbed = [
-        {
-          tag: "Allocated",
-          value: {
-            tag: "BulletInAllowance",
-            value: { slotAccountKey: new Uint8Array([1, 2, 3]) }
-          }
-        },
-        { tag: "Rejected", value: void 0 }
-      ];
-      const session = makeSession({
-        requestResourceAllocation: async (req) => {
-          captured.push(req);
-          return ok(stubbed);
-        }
-      });
-      const outcomes = await requestResourceAllocation(session, fakeAdapter("my-app"), [
-        { tag: "BulletInAllowance", value: void 0 },
-        { tag: "StatementStoreAllowance", value: void 0 }
-      ]);
-      expect(captured).toHaveLength(1);
-      expect(captured[0].callingProductId).toBe("my-app");
-      expect(captured[0].resources.map((r) => r.tag)).toEqual([
-        "BulletInAllowance",
-        "StatementStoreAllowance"
-      ]);
-      expect(outcomes).toEqual(stubbed);
-    });
-    test("uses adapter.appId as callingProductId by default", async () => {
-      const captured = [];
-      const session = makeSession({
-        requestResourceAllocation: async (req) => {
-          captured.push(req);
-          return ok([]);
-        }
-      });
-      await requestResourceAllocation(session, fakeAdapter("alt-product.dot"), []);
-      expect(captured[0].callingProductId).toBe("alt-product.dot");
-    });
-    test("options.productId overrides adapter.appId as callingProductId", async () => {
-      const captured = [];
-      const session = makeSession({
-        requestResourceAllocation: async (req) => {
-          captured.push(req);
-          return ok([]);
-        }
-      });
-      await requestResourceAllocation(session, fakeAdapter("my-cli"), [], {
-        productId: "my-product.dot"
-      });
-      expect(captured[0].callingProductId).toBe("my-product.dot");
-    });
-    test("auto-picks Ignore for an empty resources array", async () => {
-      const captured = [];
-      const session = makeSession({
-        requestResourceAllocation: async (req) => {
-          captured.push(req);
-          return ok([]);
-        }
-      });
-      await requestResourceAllocation(session, fakeAdapter("p"), []);
-      expect(captured[0].onExisting).toBe("Ignore");
-    });
-    test("forwards onExisting when explicitly set to 'Increase'", async () => {
-      const captured = [];
-      const session = makeSession({
-        requestResourceAllocation: async (req) => {
-          captured.push(req);
-          return ok([{ tag: "Rejected", value: void 0 }]);
-        }
-      });
-      await requestResourceAllocation(
-        session,
-        fakeAdapter("p"),
-        [{ tag: "BulletInAllowance", value: void 0 }],
-        { onExisting: "Increase" }
-      );
-      expect(captured[0].onExisting).toBe("Increase");
-    });
-    test("forwards SmartContractAllowance derivation index", async () => {
-      const captured = [];
-      const session = makeSession({
-        requestResourceAllocation: async (req) => {
-          captured.push(req);
-          return ok([{ tag: "Rejected", value: void 0 }]);
-        }
-      });
-      await requestResourceAllocation(session, fakeAdapter("p"), [
-        { tag: "SmartContractAllowance", value: 7 }
-      ]);
-      const sent = captured[0].resources[0];
-      expect(sent.tag).toBe("SmartContractAllowance");
-      if (sent.tag === "SmartContractAllowance") {
-        expect(sent.value).toBe(7);
-      }
-    });
-    test("throws a clear error when the session call fails", async () => {
-      const session = makeSession({
-        requestResourceAllocation: async () => err(new Error("mobile disconnected"))
-      });
-      await expect(
-        requestResourceAllocation(session, fakeAdapter("p"), [
-          { tag: "BulletInAllowance", value: void 0 }
-        ])
-      ).rejects.toThrow("requestResourceAllocation failed: mobile disconnected");
-    });
-    test("forwards AutoSigning and returns NotAvailable verbatim (mobile-default path)", async () => {
-      const captured = [];
-      const stubbed = [{ tag: "NotAvailable", value: void 0 }];
-      const session = makeSession({
-        requestResourceAllocation: async (req) => {
-          captured.push(req);
-          return ok(stubbed);
-        }
-      });
-      const outcomes = await requestResourceAllocation(session, fakeAdapter("p"), [
-        { tag: "AutoSigning", value: void 0 }
-      ]);
-      const sent = captured[0].resources[0];
-      expect(sent.tag).toBe("AutoSigning");
-      expect(outcomes).toEqual(stubbed);
-    });
-    test("passes empty resources through (no-op request still hits the wire)", async () => {
-      const captured = [];
-      const session = makeSession({
-        requestResourceAllocation: async (req) => {
-          captured.push(req);
-          return ok([]);
-        }
-      });
-      const outcomes = await requestResourceAllocation(session, fakeAdapter("p"), []);
-      expect(captured).toHaveLength(1);
-      expect(captured[0].resources).toEqual([]);
-      expect(outcomes).toEqual([]);
-    });
-  });
-  describe("requestResourceAllocation \u2014 cache integration", () => {
-    function bulletinAllocated(slotKey) {
-      return ok([
-        {
-          tag: "Allocated",
-          value: {
-            tag: "BulletInAllowance",
-            value: { slotAccountKey: slotKey }
-          }
-        }
-      ]);
-    }
-    test("first call sends Ignore when cache is empty", async () => {
-      const captured = [];
-      const session = makeSession({
-        requestResourceAllocation: async (req) => {
-          captured.push(req);
-          return bulletinAllocated(new Uint8Array([1, 2, 3]));
-        }
-      });
-      await requestResourceAllocation(session, fakeAdapter("p"), [
-        { tag: "BulletInAllowance", value: void 0 }
-      ]);
-      expect(captured[0].onExisting).toBe("Ignore");
-    });
-    test("second call for same slot-table resource auto-picks Increase", async () => {
-      const captured = [];
-      const session = makeSession({
-        requestResourceAllocation: async (req2) => {
-          captured.push(req2);
-          return bulletinAllocated(new Uint8Array([1, 2, 3]));
-        }
-      });
-      const adapter = fakeAdapter("p");
-      const req = [{ tag: "BulletInAllowance", value: void 0 }];
-      await requestResourceAllocation(session, adapter, req);
-      await requestResourceAllocation(session, adapter, req);
-      expect(captured.map((c) => c.onExisting)).toEqual(["Ignore", "Increase"]);
-    });
-    test("explicit options.onExisting overrides the auto-pick", async () => {
-      const captured = [];
-      const session = makeSession({
-        requestResourceAllocation: async (req2) => {
-          captured.push(req2);
-          return bulletinAllocated(new Uint8Array([1, 2, 3]));
-        }
-      });
-      const adapter = fakeAdapter("p");
-      const req = [{ tag: "BulletInAllowance", value: void 0 }];
-      await requestResourceAllocation(session, adapter, req);
-      await requestResourceAllocation(session, adapter, req, { onExisting: "Ignore" });
-      expect(captured.map((c) => c.onExisting)).toEqual(["Ignore", "Ignore"]);
-    });
-    test("populates cache on Allocated and survives across separate calls", async () => {
-      const slotKey = new Uint8Array([222, 173, 190, 239]);
-      const session = makeSession({
-        requestResourceAllocation: async () => bulletinAllocated(slotKey)
-      });
-      const adapter = fakeAdapter("p");
-      await requestResourceAllocation(session, adapter, [
-        { tag: "BulletInAllowance", value: void 0 }
-      ]);
-      const cached = await getCachedAllocation(adapter, {
-        tag: "BulletInAllowance",
-        value: void 0
-      });
-      expect(cached).toEqual({
-        tag: "BulletInAllowance",
-        slotAccountKey: "0xdeadbeef"
-      });
-    });
-    test("does not cache Rejected or NotAvailable outcomes", async () => {
-      const session = makeSession({
-        requestResourceAllocation: async () => ok([
-          { tag: "Rejected", value: void 0 },
-          { tag: "NotAvailable", value: void 0 }
-        ])
-      });
-      const adapter = fakeAdapter("p");
-      await requestResourceAllocation(session, adapter, [
-        { tag: "BulletInAllowance", value: void 0 },
-        { tag: "StatementStoreAllowance", value: void 0 }
-      ]);
-      expect(
-        await getCachedAllocation(adapter, { tag: "BulletInAllowance", value: void 0 })
-      ).toBeNull();
-      expect(
-        await getCachedAllocation(adapter, {
-          tag: "StatementStoreAllowance",
-          value: void 0
-        })
-      ).toBeNull();
-    });
-    test("mixed cached + uncached request stays on Ignore (conservative)", async () => {
-      const captured = [];
-      const session = makeSession({
-        requestResourceAllocation: async (req) => {
-          captured.push(req);
-          return ok(
-            req.resources.map(
-              (_r, i) => i === 0 ? {
-                tag: "Allocated",
-                value: {
-                  tag: "BulletInAllowance",
-                  value: { slotAccountKey: new Uint8Array([1]) }
-                }
-              } : { tag: "Rejected", value: void 0 }
-            )
-          );
-        }
-      });
-      const adapter = fakeAdapter("p");
-      await requestResourceAllocation(session, adapter, [
-        { tag: "BulletInAllowance", value: void 0 }
-      ]);
-      await requestResourceAllocation(session, adapter, [
-        { tag: "BulletInAllowance", value: void 0 },
-        { tag: "StatementStoreAllowance", value: void 0 }
-      ]);
-      expect(captured[captured.length - 1].onExisting).toBe("Ignore");
-    });
-    test("AutoSigning never auto-Increases even when cached", async () => {
-      const captured = [];
-      const session = makeSession({
-        requestResourceAllocation: async (req2) => {
-          captured.push(req2);
-          return ok([
-            {
-              tag: "Allocated",
-              value: {
-                tag: "AutoSigning",
-                value: {
-                  productDerivationSecret: "secret",
-                  productRootPrivateKey: new Uint8Array([171])
-                }
-              }
-            }
-          ]);
-        }
-      });
-      const adapter = fakeAdapter("p");
-      const req = [{ tag: "AutoSigning", value: void 0 }];
-      await requestResourceAllocation(session, adapter, req);
-      await requestResourceAllocation(session, adapter, req);
-      expect(captured.map((c) => c.onExisting)).toEqual(["Ignore", "Ignore"]);
-    });
-    test("parallel calls for different resources both persist their keys (no last-writer-wins)", async () => {
-      const session = makeSession({
-        requestResourceAllocation: async (req) => {
-          await new Promise((r) => setTimeout(r, 5));
-          const tag = req.resources[0]?.tag;
-          return ok([
-            {
-              tag: "Allocated",
-              value: tag === "BulletInAllowance" ? {
-                tag: "BulletInAllowance",
-                value: { slotAccountKey: new Uint8Array([170]) }
-              } : {
-                tag: "StatementStoreAllowance",
-                value: { slotAccountKey: new Uint8Array([187]) }
-              }
-            }
-          ]);
-        }
-      });
-      const adapter = fakeAdapter("p");
-      await Promise.all([
-        requestResourceAllocation(session, adapter, [
-          { tag: "BulletInAllowance", value: void 0 }
-        ]),
-        requestResourceAllocation(session, adapter, [
-          { tag: "StatementStoreAllowance", value: void 0 }
-        ])
-      ]);
-      expect(
-        await getCachedAllocation(adapter, {
-          tag: "BulletInAllowance",
-          value: void 0
-        })
-      ).not.toBeNull();
-      expect(
-        await getCachedAllocation(adapter, {
-          tag: "StatementStoreAllowance",
-          value: void 0
-        })
-      ).not.toBeNull();
-    });
-    test("options.productId scopes the cache namespace, not adapter.appId", async () => {
-      const session = makeSession({
-        requestResourceAllocation: async () => bulletinAllocated(new Uint8Array([1, 2, 3]))
-      });
-      const adapter = fakeAdapter("my-cli");
-      await requestResourceAllocation(
-        session,
-        adapter,
-        [{ tag: "BulletInAllowance", value: void 0 }],
-        { productId: "my-product.dot" }
-      );
-      expect(
-        await getCachedAllocation(
-          adapter,
-          { tag: "BulletInAllowance", value: void 0 },
-          "my-product.dot"
-        )
-      ).not.toBeNull();
-      expect(
-        await getCachedAllocation(adapter, { tag: "BulletInAllowance", value: void 0 })
-      ).toBeNull();
-    });
-    test("two appIds maintain independent caches in the same storageDir", async () => {
-      const session = makeSession({
-        requestResourceAllocation: async () => bulletinAllocated(new Uint8Array([1, 2, 3]))
-      });
-      const adapterA = fakeAdapter("app-a");
-      const adapterB = fakeAdapter("app-b");
-      await requestResourceAllocation(session, adapterA, [
-        { tag: "BulletInAllowance", value: void 0 }
-      ]);
-      expect(
-        await getCachedAllocation(adapterB, {
-          tag: "BulletInAllowance",
-          value: void 0
-        })
-      ).toBeNull();
-      expect(
-        await getCachedAllocation(adapterA, {
-          tag: "BulletInAllowance",
-          value: void 0
-        })
-      ).not.toBeNull();
-    });
-  });
-  describe("getCachedAllocation", () => {
-    test("returns null when nothing is cached", async () => {
-      const adapter = fakeAdapter("p");
-      const cached = await getCachedAllocation(adapter, {
-        tag: "BulletInAllowance",
-        value: void 0
-      });
-      expect(cached).toBeNull();
-    });
-    test("disambiguates SmartContractAllowance entries by dest", async () => {
-      const session = makeSession({
-        requestResourceAllocation: async () => ok([
-          {
-            tag: "Allocated",
-            value: {
-              tag: "SmartContractAllowance",
-              value: void 0
-            }
-          }
-        ])
-      });
-      const adapter = fakeAdapter("p");
-      await requestResourceAllocation(session, adapter, [
-        { tag: "SmartContractAllowance", value: 5 }
-      ]);
-      expect(
-        await getCachedAllocation(adapter, { tag: "SmartContractAllowance", value: 5 })
-      ).toEqual({ tag: "SmartContractAllowance", dest: 5 });
-      expect(
-        await getCachedAllocation(adapter, { tag: "SmartContractAllowance", value: 6 })
-      ).toBeNull();
-    });
-  });
-  describe("ensureSlotAccountSigner", () => {
-    const slotKey = mnemonicToMiniSecret(DEV_PHRASE);
-    function bulletinAllocatedResponse() {
-      return ok([
-        {
-          tag: "Allocated",
-          value: {
-            tag: "BulletInAllowance",
-            value: { slotAccountKey: slotKey }
-          }
-        }
-      ]);
-    }
-    test("cache hit returns a signer without invoking the AP wire", async () => {
-      const captured = [];
-      const session = makeSession({
-        requestResourceAllocation: async (req) => {
-          captured.push(req);
-          return bulletinAllocatedResponse();
-        }
-      });
-      const adapter = fakeAdapter("p");
-      await requestResourceAllocation(session, adapter, [
-        { tag: "BulletInAllowance", value: void 0 }
-      ]);
-      expect(captured).toHaveLength(1);
-      const signer = await ensureSlotAccountSigner(session, adapter, {
-        tag: "BulletInAllowance",
-        value: void 0
-      });
-      expect(signer.publicKey).toBeInstanceOf(Uint8Array);
-      expect(captured).toHaveLength(1);
-    });
-    test("cache miss triggers allocation and returns a fresh signer", async () => {
-      const captured = [];
-      const session = makeSession({
-        requestResourceAllocation: async (req) => {
-          captured.push(req);
-          return bulletinAllocatedResponse();
-        }
-      });
-      const adapter = fakeAdapter("p");
-      const signer = await ensureSlotAccountSigner(session, adapter, {
-        tag: "BulletInAllowance",
-        value: void 0
-      });
-      expect(signer.publicKey).toBeInstanceOf(Uint8Array);
-      expect(captured).toHaveLength(1);
-      expect(captured[0].resources.map((r) => r.tag)).toEqual(["BulletInAllowance"]);
-    });
-    test("Rejected outcome surfaces as a throw \u2014 no signer to return", async () => {
-      const session = makeSession({
-        requestResourceAllocation: async () => ok([{ tag: "Rejected", value: void 0 }])
-      });
-      await expect(
-        ensureSlotAccountSigner(session, fakeAdapter("p"), {
-          tag: "BulletInAllowance",
-          value: void 0
-        })
-      ).rejects.toThrow(/allocation Rejected for BulletInAllowance/);
-    });
-    test("empty outcomes array from the wire surfaces as a length-mismatch throw", async () => {
-      const session = makeSession({
-        requestResourceAllocation: async () => ok([])
-      });
-      await expect(
-        ensureSlotAccountSigner(session, fakeAdapter("p"), {
-          tag: "BulletInAllowance",
-          value: void 0
-        })
-      ).rejects.toThrow(/length mismatch — requested 1, got 0/);
-    });
-    test("NotAvailable outcome surfaces as a throw", async () => {
-      const session = makeSession({
-        requestResourceAllocation: async () => ok([{ tag: "NotAvailable", value: void 0 }])
-      });
-      await expect(
-        ensureSlotAccountSigner(session, fakeAdapter("p"), {
-          tag: "StatementStoreAllowance",
-          value: void 0
-        })
-      ).rejects.toThrow(/allocation NotAvailable for StatementStoreAllowance/);
-    });
-    test("transport error propagates from the underlying allocation call", async () => {
-      const session = makeSession({
-        requestResourceAllocation: async () => err(new Error("mobile timed out"))
-      });
-      await expect(
-        ensureSlotAccountSigner(session, fakeAdapter("p"), {
-          tag: "BulletInAllowance",
-          value: void 0
-        })
-      ).rejects.toThrow(/mobile timed out/);
-    });
-    test("explicit productId scopes the wire id and the cache namespace", async () => {
-      const captured = [];
-      const session = makeSession({
-        requestResourceAllocation: async (req) => {
-          captured.push(req);
-          return bulletinAllocatedResponse();
-        }
-      });
-      const adapter = fakeAdapter("my-cli");
-      const signer = await ensureSlotAccountSigner(
-        session,
-        adapter,
-        { tag: "BulletInAllowance", value: void 0 },
-        "my-product.dot"
-      );
-      expect(signer.publicKey).toBeInstanceOf(Uint8Array);
-      expect(captured[0].callingProductId).toBe("my-product.dot");
-      await ensureSlotAccountSigner(
-        session,
-        adapter,
-        { tag: "BulletInAllowance", value: void 0 },
-        "my-product.dot"
-      );
-      expect(captured).toHaveLength(1);
-      expect(
-        await getCachedAllocation(adapter, { tag: "BulletInAllowance", value: void 0 })
-      ).toBeNull();
-    });
-    test("populates the cache so a later call is a hit", async () => {
-      const session = makeSession({
-        requestResourceAllocation: async () => bulletinAllocatedResponse()
-      });
-      const adapter = fakeAdapter("p");
-      await ensureSlotAccountSigner(session, adapter, {
-        tag: "BulletInAllowance",
-        value: void 0
-      });
-      const cached = await getCachedAllocation(adapter, {
-        tag: "BulletInAllowance",
-        value: void 0
-      });
-      expect(cached?.tag).toBe("BulletInAllowance");
-    });
-    test("parallel calls for the SAME resource share one allocation (no double-prompt)", async () => {
-      const captured = [];
-      const session = makeSession({
-        requestResourceAllocation: async (req) => {
-          captured.push(req);
-          await new Promise((r) => setTimeout(r, 5));
-          return bulletinAllocatedResponse();
-        }
-      });
-      const adapter = fakeAdapter("p");
-      const [signerA, signerB] = await Promise.all([
-        ensureSlotAccountSigner(session, adapter, {
-          tag: "BulletInAllowance",
-          value: void 0
-        }),
-        ensureSlotAccountSigner(session, adapter, {
-          tag: "BulletInAllowance",
-          value: void 0
-        })
-      ]);
-      expect(captured).toHaveLength(1);
-      expect(signerA.publicKey).toBeInstanceOf(Uint8Array);
-      expect(signerB.publicKey).toBeInstanceOf(Uint8Array);
-      expect(toHex2(signerA.publicKey)).toBe(toHex2(signerB.publicKey));
-    });
-  });
-}
-var fakeAdapter2;
-var makeSession2;
-
-export {
-  createSlotAccountSigner,
-  requestResourceAllocation,
-  sendResourceAllocation,
-  getCachedAllocation,
-  ensureSlotAccountSigner
-};
-//# sourceMappingURL=chunk-YS3GW2XW.js.map