@parity/product-sdk-tx 0.1.0

package/dist/index.js

@@ -0,0 +1,1650 @@
+// src/submit.ts
+import { createLogger } from "@parity/product-sdk-logger";
+
+// src/errors.ts
+var TxError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "TxError";
+  }
+};
+var TxTimeoutError = class extends TxError {
+  timeoutMs;
+  constructor(timeoutMs) {
+    super(
+      `Transaction timed out after ${timeoutMs / 1e3}s. The transaction may still be processing on-chain.`
+    );
+    this.name = "TxTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+var TxDispatchError = class extends TxError {
+  /** Raw dispatch error from polkadot-api. */
+  dispatchError;
+  /** Human-readable error string (e.g., "Revive.ContractReverted"). */
+  formatted;
+  constructor(dispatchError, formatted) {
+    super(`Transaction dispatch failed: ${formatted}`);
+    this.name = "TxDispatchError";
+    this.dispatchError = dispatchError;
+    this.formatted = formatted;
+  }
+};
+var TxSigningRejectedError = class extends TxError {
+  constructor() {
+    super("Transaction signing was rejected.");
+    this.name = "TxSigningRejectedError";
+  }
+};
+function formatDispatchError(result) {
+  if (result.ok) return "";
+  try {
+    const err = result.dispatchError;
+    if (!err) return "unknown error";
+    if (err.type === "Module" && err.value && typeof err.value === "object") {
+      const palletErr = err.value;
+      const palletName = palletErr.type ?? "Unknown";
+      if (palletErr.value && typeof palletErr.value === "object") {
+        const innerErr = palletErr.value;
+        if (innerErr.type) {
+          return `${palletName}.${innerErr.type}`;
+        }
+      }
+      return palletName;
+    }
+    return err.type ?? "unknown error";
+  } catch {
+    return "unknown error";
+  }
+}
+var TxBatchError = class extends TxError {
+  constructor(message) {
+    super(message);
+    this.name = "TxBatchError";
+  }
+};
+var TxDryRunError = class extends TxError {
+  /** The raw dry-run result for programmatic inspection. */
+  raw;
+  /** Human-readable error string derived from the dry-run result. */
+  formatted;
+  /** Solidity revert reason, if the contract provided one. */
+  revertReason;
+  constructor(raw, formatted, revertReason) {
+    super(revertReason ? `Dry run failed: ${revertReason}` : `Dry run failed: ${formatted}`);
+    this.name = "TxDryRunError";
+    this.raw = raw;
+    this.formatted = formatted;
+    this.revertReason = revertReason;
+  }
+};
+function formatDryRunError(result) {
+  if (result.success) return "";
+  const formatted = extractErrorFromValue(result.value);
+  if (formatted) return formatted;
+  if (result.error != null && typeof result.error === "object") {
+    const err = result.error;
+    if (typeof err.type === "string") return err.type;
+    if (typeof err.name === "string") return err.name;
+  }
+  return "unknown error";
+}
+function extractErrorFromValue(value) {
+  if (value == null || typeof value !== "object") return void 0;
+  const v = value;
+  if (typeof v.revertReason === "string" && v.revertReason) {
+    return v.revertReason;
+  }
+  if (typeof v.type === "string") {
+    if (v.type === "Module") {
+      const asDispatch = formatDispatchError({ ok: false, dispatchError: value });
+      if (asDispatch !== "unknown error") return asDispatch;
+    }
+    if (v.type === "Message" && typeof v.value === "string") {
+      return v.value;
+    }
+    if (v.type === "Data") {
+      const hex = v.value != null && typeof v.value === "object" && typeof v.value.asHex === "function" ? String(v.value.asHex()) : typeof v.value === "string" ? v.value : void 0;
+      return hex ? `contract reverted with data: ${hex}` : "contract reverted";
+    }
+    return v.type;
+  }
+  if ("raw" in v && v.raw != null && typeof v.raw === "object") {
+    return extractErrorFromValue(v.raw);
+  }
+  return void 0;
+}
+function isSigningRejection(error) {
+  if (!(error instanceof Error)) return false;
+  const msg = error.message.toLowerCase();
+  return msg.includes("cancelled") || msg.includes("rejected") || msg.includes("denied") || msg.includes("user refused");
+}
+if (void 0) {
+  const { describe, test, expect } = void 0;
+  describe("TxError hierarchy", () => {
+    test("TxTimeoutError", () => {
+      const err = new TxTimeoutError(3e5);
+      expect(err).toBeInstanceOf(TxError);
+      expect(err).toBeInstanceOf(Error);
+      expect(err.name).toBe("TxTimeoutError");
+      expect(err.timeoutMs).toBe(3e5);
+      expect(err.message).toContain("300s");
+    });
+    test("TxDispatchError", () => {
+      const raw = {
+        type: "Module",
+        value: { type: "Balances", value: { type: "InsufficientBalance" } }
+      };
+      const err = new TxDispatchError(raw, "Balances.InsufficientBalance");
+      expect(err).toBeInstanceOf(TxError);
+      expect(err.name).toBe("TxDispatchError");
+      expect(err.dispatchError).toBe(raw);
+      expect(err.formatted).toBe("Balances.InsufficientBalance");
+      expect(err.message).toContain("Balances.InsufficientBalance");
+    });
+    test("TxSigningRejectedError", () => {
+      const err = new TxSigningRejectedError();
+      expect(err).toBeInstanceOf(TxError);
+      expect(err.name).toBe("TxSigningRejectedError");
+    });
+    test("TxBatchError", () => {
+      const err = new TxBatchError("Cannot batch zero calls");
+      expect(err).toBeInstanceOf(TxError);
+      expect(err).toBeInstanceOf(Error);
+      expect(err.name).toBe("TxBatchError");
+      expect(err.message).toBe("Cannot batch zero calls");
+    });
+  });
+  describe("formatDispatchError", () => {
+    test("returns empty string for ok result", () => {
+      expect(formatDispatchError({ ok: true })).toBe("");
+    });
+    test("walks Module.Pallet.Error chain", () => {
+      const result = {
+        ok: false,
+        dispatchError: {
+          type: "Module",
+          value: { type: "Revive", value: { type: "ContractReverted" } }
+        }
+      };
+      expect(formatDispatchError(result)).toBe("Revive.ContractReverted");
+    });
+    test("returns pallet name when inner error has no type", () => {
+      const result = {
+        ok: false,
+        dispatchError: {
+          type: "Module",
+          value: { type: "Balances", value: {} }
+        }
+      };
+      expect(formatDispatchError(result)).toBe("Balances");
+    });
+    test("returns error type for non-Module errors", () => {
+      const result = {
+        ok: false,
+        dispatchError: { type: "BadOrigin" }
+      };
+      expect(formatDispatchError(result)).toBe("BadOrigin");
+    });
+    test("returns unknown error when dispatchError is missing", () => {
+      expect(formatDispatchError({ ok: false })).toBe("unknown error");
+    });
+    test("returns unknown error when dispatchError has no type", () => {
+      expect(formatDispatchError({ ok: false, dispatchError: {} })).toBe("unknown error");
+    });
+  });
+  describe("TxDryRunError", () => {
+    test("with revert reason", () => {
+      const err = new TxDryRunError(
+        { success: false },
+        "Module.Error",
+        "InsufficientBalance"
+      );
+      expect(err).toBeInstanceOf(TxError);
+      expect(err.name).toBe("TxDryRunError");
+      expect(err.formatted).toBe("Module.Error");
+      expect(err.revertReason).toBe("InsufficientBalance");
+      expect(err.message).toContain("InsufficientBalance");
+    });
+    test("without revert reason uses formatted", () => {
+      const err = new TxDryRunError({ success: false }, "BadOrigin");
+      expect(err.message).toContain("BadOrigin");
+      expect(err.revertReason).toBeUndefined();
+    });
+    test("preserves raw result for inspection", () => {
+      const raw = { success: false, value: { type: "Module" } };
+      const err = new TxDryRunError(raw, "Module");
+      expect(err.raw).toBe(raw);
+    });
+  });
+  describe("formatDryRunError", () => {
+    test("returns empty string for successful result", () => {
+      expect(formatDryRunError({ success: true })).toBe("");
+    });
+    test("extracts revert reason", () => {
+      expect(
+        formatDryRunError({
+          success: false,
+          value: { revertReason: "InsufficientBalance" }
+        })
+      ).toBe("InsufficientBalance");
+    });
+    test("walks Module.Pallet.Error chain", () => {
+      expect(
+        formatDryRunError({
+          success: false,
+          value: {
+            type: "Module",
+            value: { type: "Revive", value: { type: "StorageDepositNotEnoughFunds" } }
+          }
+        })
+      ).toBe("Revive.StorageDepositNotEnoughFunds");
+    });
+    test("returns pallet name when inner error has no type", () => {
+      expect(
+        formatDryRunError({
+          success: false,
+          value: { type: "Module", value: { type: "Balances", value: {} } }
+        })
+      ).toBe("Balances");
+    });
+    test("extracts ReviveApi Message string", () => {
+      expect(
+        formatDryRunError({
+          success: false,
+          value: {
+            type: "Message",
+            value: "Insufficient balance for gas * price + value"
+          }
+        })
+      ).toBe("Insufficient balance for gas * price + value");
+    });
+    test("handles ReviveApi Data with string hex", () => {
+      expect(
+        formatDryRunError({
+          success: false,
+          value: { type: "Data", value: "0x08c379a0" }
+        })
+      ).toBe("contract reverted with data: 0x08c379a0");
+    });
+    test("handles ReviveApi Data with Binary-like object", () => {
+      const binary = { asHex: () => "0xdeadbeef" };
+      expect(
+        formatDryRunError({ success: false, value: { type: "Data", value: binary } })
+      ).toBe("contract reverted with data: 0xdeadbeef");
+    });
+    test("handles ReviveApi Data with no extractable hex", () => {
+      expect(formatDryRunError({ success: false, value: { type: "Data", value: 42 } })).toBe(
+        "contract reverted"
+      );
+    });
+    test("returns non-Module/Message type directly", () => {
+      expect(formatDryRunError({ success: false, value: { type: "BadOrigin" } })).toBe(
+        "BadOrigin"
+      );
+    });
+    test("extracts from nested raw field (patched SDK)", () => {
+      expect(
+        formatDryRunError({
+          success: false,
+          value: { raw: { type: "Message", value: "out of gas" } }
+        })
+      ).toBe("out of gas");
+    });
+    test("extracts revertReason from nested raw", () => {
+      expect(
+        formatDryRunError({
+          success: false,
+          value: { raw: { revertReason: "Unauthorized" } }
+        })
+      ).toBe("Unauthorized");
+    });
+    test("falls back to error.type", () => {
+      expect(formatDryRunError({ success: false, error: { type: "ContractTrapped" } })).toBe(
+        "ContractTrapped"
+      );
+    });
+    test("falls back to error.name", () => {
+      expect(formatDryRunError({ success: false, error: { name: "ExecutionFailed" } })).toBe(
+        "ExecutionFailed"
+      );
+    });
+    test("returns unknown error when nothing is extractable", () => {
+      expect(formatDryRunError({ success: false })).toBe("unknown error");
+    });
+    test("returns unknown error for empty value and error", () => {
+      expect(formatDryRunError({ success: false, value: {}, error: {} })).toBe(
+        "unknown error"
+      );
+    });
+    test("returns unknown error for null value", () => {
+      expect(formatDryRunError({ success: false, value: null })).toBe("unknown error");
+    });
+    test("prefers revertReason over Module error", () => {
+      expect(
+        formatDryRunError({
+          success: false,
+          value: {
+            revertReason: "OwnableUnauthorizedAccount",
+            type: "Module",
+            value: {}
+          }
+        })
+      ).toBe("OwnableUnauthorizedAccount");
+    });
+  });
+  describe("isSigningRejection", () => {
+    test("detects common rejection messages", () => {
+      expect(isSigningRejection(new Error("Cancelled"))).toBe(true);
+      expect(isSigningRejection(new Error("User rejected the request"))).toBe(true);
+      expect(isSigningRejection(new Error("Transaction was rejected by user"))).toBe(true);
+      expect(isSigningRejection(new Error("User denied"))).toBe(true);
+      expect(isSigningRejection(new Error("Signing was denied by user"))).toBe(true);
+      expect(isSigningRejection(new Error("User refused to sign"))).toBe(true);
+    });
+    test("returns false for non-rejection errors", () => {
+      expect(isSigningRejection(new Error("Network timeout"))).toBe(false);
+      expect(isSigningRejection(new Error("Insufficient balance"))).toBe(false);
+    });
+    test("returns false for non-Error values", () => {
+      expect(isSigningRejection("cancelled")).toBe(false);
+      expect(isSigningRejection(null)).toBe(false);
+    });
+  });
+}
+
+// src/submit.ts
+var DEFAULT_TIMEOUT_MS = 3e5;
+var DEFAULT_MORTALITY_PERIOD = 256;
+var log = createLogger("tx");
+async function resolveTransaction(tx) {
+  if (tx.waited && typeof tx.waited.then === "function") {
+    log.debug("Resolving Ink SDK AsyncTransaction");
+    return tx.waited;
+  }
+  return tx;
+}
+function buildTxResult(event) {
+  return {
+    txHash: event.txHash,
+    ok: event.ok,
+    block: event.block,
+    events: event.events,
+    dispatchError: "dispatchError" in event ? event.dispatchError : void 0
+  };
+}
+async function submitAndWatch(tx, signer, options) {
+  const waitFor = options?.waitFor ?? "best-block";
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const mortalityPeriod = options?.mortalityPeriod ?? DEFAULT_MORTALITY_PERIOD;
+  const onStatus = options?.onStatus;
+  const resolvedTx = await resolveTransaction(tx);
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let subscription = null;
+    const timer = setTimeout(() => {
+      subscription?.unsubscribe();
+      if (!settled) {
+        settled = true;
+        onStatus?.("error");
+        reject(new TxTimeoutError(timeoutMs));
+      }
+    }, timeoutMs);
+    function teardown() {
+      clearTimeout(timer);
+      subscription?.unsubscribe();
+    }
+    function settleReject(error) {
+      if (settled) return;
+      settled = true;
+      teardown();
+      onStatus?.("error");
+      reject(error);
+    }
+    try {
+      const observable = resolvedTx.signSubmitAndWatch(signer, {
+        mortality: { mortal: true, period: mortalityPeriod }
+      });
+      subscription = observable.subscribe({
+        next: (event) => {
+          switch (event.type) {
+            case "signed": {
+              log.info("Transaction signed", { txHash: event.txHash });
+              onStatus?.("signing");
+              break;
+            }
+            case "broadcasted": {
+              log.info("Transaction broadcasted", { txHash: event.txHash });
+              onStatus?.("broadcasting");
+              break;
+            }
+            case "txBestBlocksState": {
+              if (!event.found) break;
+              if (event.ok === false) {
+                const formatted = formatDispatchError({
+                  ok: false,
+                  dispatchError: event.dispatchError
+                });
+                log.error("Transaction failed in best block", {
+                  formatted,
+                  block: event.block
+                });
+                settleReject(new TxDispatchError(event.dispatchError, formatted));
+                return;
+              }
+              log.info("Transaction in best block", { block: event.block });
+              onStatus?.("in-block");
+              if (waitFor === "best-block" && event.ok === true && event.block && event.events) {
+                settled = true;
+                clearTimeout(timer);
+                resolve(
+                  buildTxResult(
+                    event
+                  )
+                );
+              }
+              break;
+            }
+            case "finalized": {
+              log.info("Transaction finalized", { ok: event.ok, block: event.block });
+              if (!event.ok) {
+                const formatted = formatDispatchError({
+                  ok: false,
+                  dispatchError: event.dispatchError
+                });
+                if (settled) {
+                  log.warn(
+                    "Transaction failed after being in best block (reorg). The consumer received a success result that is no longer valid.",
+                    { formatted, block: event.block }
+                  );
+                } else {
+                  settleReject(
+                    new TxDispatchError(event.dispatchError, formatted)
+                  );
+                }
+                subscription?.unsubscribe();
+                return;
+              }
+              onStatus?.("finalized");
+              if (!settled) {
+                settled = true;
+                teardown();
+                resolve(buildTxResult(event));
+              } else {
+                subscription?.unsubscribe();
+              }
+              break;
+            }
+          }
+        },
+        error: (err) => {
+          log.error("Transaction subscription error", { error: err.message });
+          if (isSigningRejection(err)) {
+            settleReject(new TxSigningRejectedError());
+          } else {
+            settleReject(err);
+          }
+        }
+      });
+    } catch (err) {
+      log.error("Failed to start transaction", { error: err.message });
+      teardown();
+      if (isSigningRejection(err)) {
+        settleReject(new TxSigningRejectedError());
+      } else {
+        settleReject(err);
+      }
+    }
+  });
+}
+if (void 0) {
+  let createMockTx = function(emitFn) {
+    return {
+      signSubmitAndWatch: (_signer, _options) => ({
+        subscribe: (handlers) => {
+          const unsub = vi.fn();
+          queueMicrotask(() => emitFn(handlers));
+          return { unsubscribe: unsub };
+        }
+      })
+    };
+  };
+  createMockTx2 = createMockTx;
+  const { describe, test, expect, vi, beforeEach } = void 0;
+  const { configure } = await null;
+  beforeEach(() => {
+    configure({ handler: () => {
+    } });
+  });
+  const mockSigner = {};
+  const signedEvent = { type: "signed", txHash: "0xabc" };
+  const broadcastedEvent = { type: "broadcasted", txHash: "0xabc" };
+  const bestBlockOk = {
+    type: "txBestBlocksState",
+    txHash: "0xabc",
+    found: true,
+    ok: true,
+    events: [{ id: 1 }],
+    block: { hash: "0xblock1", number: 100, index: 0 }
+  };
+  const bestBlockFail = {
+    type: "txBestBlocksState",
+    txHash: "0xabc",
+    found: true,
+    ok: false,
+    events: [],
+    block: { hash: "0xblock1", number: 100, index: 0 },
+    dispatchError: {
+      type: "Module",
+      value: { type: "Balances", value: { type: "InsufficientBalance" } }
+    }
+  };
+  const finalizedOk = {
+    type: "finalized",
+    txHash: "0xabc",
+    ok: true,
+    events: [{ id: 1 }],
+    block: { hash: "0xblock2", number: 101, index: 0 }
+  };
+  const finalizedFail = {
+    type: "finalized",
+    txHash: "0xabc",
+    ok: false,
+    events: [],
+    block: { hash: "0xblock2", number: 101, index: 0 },
+    dispatchError: { type: "BadOrigin" }
+  };
+  describe("submitAndWatch", () => {
+    test("resolves at best-block by default", async () => {
+      const tx = createMockTx((h) => {
+        h.next(signedEvent);
+        h.next(broadcastedEvent);
+        h.next(bestBlockOk);
+        h.next(finalizedOk);
+      });
+      const result = await submitAndWatch(tx, mockSigner);
+      expect(result.ok).toBe(true);
+      expect(result.block.number).toBe(100);
+    });
+    test("resolves at finalized when configured", async () => {
+      const tx = createMockTx((h) => {
+        h.next(signedEvent);
+        h.next(bestBlockOk);
+        h.next(finalizedOk);
+      });
+      const result = await submitAndWatch(tx, mockSigner, { waitFor: "finalized" });
+      expect(result.ok).toBe(true);
+      expect(result.block.number).toBe(101);
+    });
+    test("rejects with TxDispatchError on best-block failure", async () => {
+      const tx = createMockTx((h) => {
+        h.next(signedEvent);
+        h.next(bestBlockFail);
+      });
+      await expect(submitAndWatch(tx, mockSigner)).rejects.toThrow(TxDispatchError);
+    });
+    test("rejects with TxDispatchError on finalized failure", async () => {
+      const tx = createMockTx((h) => {
+        h.next(signedEvent);
+        h.next(finalizedFail);
+      });
+      await expect(submitAndWatch(tx, mockSigner, { waitFor: "finalized" })).rejects.toThrow(
+        TxDispatchError
+      );
+    });
+    test("rejects with TxTimeoutError after timeout", async () => {
+      const tx = createMockTx(() => {
+      });
+      const error = await submitAndWatch(tx, mockSigner, { timeoutMs: 50 }).catch(
+        (e) => e
+      );
+      expect(error).toBeInstanceOf(TxTimeoutError);
+      expect(error.timeoutMs).toBe(50);
+    });
+    test("calls onStatus callbacks in order", async () => {
+      const statuses = [];
+      const tx = createMockTx((h) => {
+        h.next(signedEvent);
+        h.next(broadcastedEvent);
+        h.next(bestBlockOk);
+      });
+      await submitAndWatch(tx, mockSigner, {
+        onStatus: (s) => statuses.push(s)
+      });
+      expect(statuses).toEqual(["signing", "broadcasting", "in-block"]);
+    });
+    test("resolves Ink SDK AsyncTransaction", async () => {
+      const innerTx = createMockTx((h) => {
+        h.next(signedEvent);
+        h.next(bestBlockOk);
+      });
+      const wrappedTx = {
+        signSubmitAndWatch: () => {
+          throw new Error("Should not be called on outer tx");
+        },
+        waited: Promise.resolve(innerTx)
+      };
+      const result = await submitAndWatch(wrappedTx, mockSigner);
+      expect(result.ok).toBe(true);
+    });
+    test("passes mortality options", async () => {
+      let capturedOptions;
+      const tx = {
+        signSubmitAndWatch: (_signer, options) => {
+          capturedOptions = options;
+          return {
+            subscribe: (handlers) => {
+              queueMicrotask(() => {
+                handlers.next(signedEvent);
+                handlers.next(bestBlockOk);
+              });
+              return { unsubscribe: vi.fn() };
+            }
+          };
+        }
+      };
+      await submitAndWatch(tx, mockSigner, { mortalityPeriod: 512 });
+      expect(capturedOptions).toEqual({ mortality: { mortal: true, period: 512 } });
+    });
+    test("wraps signing rejection in TxSigningRejectedError", async () => {
+      const tx = createMockTx((h) => {
+        h.error(new Error("User rejected the request"));
+      });
+      await expect(submitAndWatch(tx, mockSigner)).rejects.toThrow(TxSigningRejectedError);
+    });
+    test("skips txBestBlocksState with found=false", async () => {
+      const tx = createMockTx((h) => {
+        h.next(signedEvent);
+        h.next({
+          type: "txBestBlocksState",
+          txHash: "0xabc",
+          found: false
+        });
+        h.next(bestBlockOk);
+      });
+      const result = await submitAndWatch(tx, mockSigner);
+      expect(result.ok).toBe(true);
+    });
+    test("rejects with original error for non-rejection Observable errors", async () => {
+      const tx = createMockTx((h) => {
+        h.error(new Error("WebSocket disconnected"));
+      });
+      const err = await submitAndWatch(tx, mockSigner).catch((e) => e);
+      expect(err.message).toBe("WebSocket disconnected");
+      expect(err).not.toBeInstanceOf(TxSigningRejectedError);
+    });
+    test("handles synchronous throw from signSubmitAndWatch", async () => {
+      const tx = {
+        signSubmitAndWatch: () => {
+          throw new Error("Signer not available");
+        }
+      };
+      await expect(submitAndWatch(tx, mockSigner)).rejects.toThrow("Signer not available");
+    });
+    test("calls onStatus error on dispatch failure", async () => {
+      const statuses = [];
+      const tx = createMockTx((h) => {
+        h.next(bestBlockFail);
+      });
+      await submitAndWatch(tx, mockSigner, {
+        onStatus: (s) => statuses.push(s)
+      }).catch(() => {
+      });
+      expect(statuses).toContain("error");
+    });
+    test("logs warning on reorg (best-block ok, finalized fail)", async () => {
+      const warnings = [];
+      const { configure: configureLogs } = await null;
+      configureLogs({
+        level: "debug",
+        handler: (entry) => {
+          if (entry.level === "warn") warnings.push(entry.message);
+        }
+      });
+      const tx = createMockTx((h) => {
+        h.next(signedEvent);
+        h.next(bestBlockOk);
+        h.next(finalizedFail);
+      });
+      const result = await submitAndWatch(tx, mockSigner);
+      expect(result.ok).toBe(true);
+      await new Promise((r) => setTimeout(r, 10));
+      expect(warnings.some((w) => typeof w === "string" && w.includes("reorg"))).toBe(true);
+      configureLogs({ handler: () => {
+      } });
+    });
+    test("does not resolve when txBestBlocksState ok is undefined", async () => {
+      const tx = createMockTx((h) => {
+        h.next(signedEvent);
+        h.next({
+          type: "txBestBlocksState",
+          txHash: "0xabc",
+          found: true,
+          events: [{ id: 1 }],
+          block: { hash: "0xblock1", number: 100, index: 0 }
+          // ok intentionally omitted
+        });
+        h.next(finalizedOk);
+      });
+      const result = await submitAndWatch(tx, mockSigner);
+      expect(result.block.number).toBe(101);
+    });
+  });
+}
+var createMockTx2;
+
+// src/batch.ts
+import { createLogger as createLogger2 } from "@parity/product-sdk-logger";
+var log2 = createLogger2("tx:batch");
+async function resolveDecodedCall(call) {
+  if (call != null && typeof call === "object") {
+    const obj = call;
+    if ("waited" in obj && obj.waited && typeof obj.waited.then === "function") {
+      log2.debug("Resolving Ink SDK AsyncTransaction in batch");
+      const resolved = await obj.waited;
+      if (resolved.decodedCall !== void 0) return resolved.decodedCall;
+      throw new TxBatchError("Resolved AsyncTransaction has no decodedCall property");
+    }
+    if ("decodedCall" in obj && obj.decodedCall !== void 0) {
+      return obj.decodedCall;
+    }
+  }
+  if (call == null || typeof call !== "object") {
+    throw new TxBatchError(
+      `Invalid batch call: expected a transaction or decoded call object, got ${call === null ? "null" : typeof call}`
+    );
+  }
+  return call;
+}
+async function batchSubmitAndWatch(calls, api, signer, options) {
+  if (calls.length === 0) {
+    throw new TxBatchError("Cannot batch zero calls");
+  }
+  const mode = options?.mode ?? "batch_all";
+  log2.info("Resolving batch calls", { count: calls.length, mode });
+  const decodedCalls = await Promise.all(calls.map(resolveDecodedCall));
+  log2.info("Constructing batch transaction", { mode, callCount: decodedCalls.length });
+  const batchTx = api.tx.Utility[mode]({ calls: decodedCalls });
+  return submitAndWatch(batchTx, signer, options);
+}
+if (void 0) {
+  let createMockTx = function(emitFn, decodedCall) {
+    return {
+      signSubmitAndWatch: (_signer, _options) => ({
+        subscribe: (handlers) => {
+          const unsub = vi.fn();
+          queueMicrotask(() => emitFn(handlers));
+          return { unsubscribe: unsub };
+        }
+      }),
+      decodedCall
+    };
+  }, createMockBatchApi = function(emitFn) {
+    const capturedCalls = [];
+    const api = {
+      tx: {
+        Utility: {
+          batch: vi.fn((args) => {
+            capturedCalls.push(args.calls);
+            return createMockTx(emitFn);
+          }),
+          batch_all: vi.fn((args) => {
+            capturedCalls.push(args.calls);
+            return createMockTx(emitFn);
+          }),
+          force_batch: vi.fn((args) => {
+            capturedCalls.push(args.calls);
+            return createMockTx(emitFn);
+          })
+        }
+      }
+    };
+    return { api, getCapturedCalls: () => capturedCalls };
+  };
+  createMockTx2 = createMockTx, createMockBatchApi2 = createMockBatchApi;
+  const { describe, test, expect, vi, beforeEach } = void 0;
+  const { configure } = await null;
+  const { TxDispatchError: TxDispatchError2, TxSigningRejectedError: TxSigningRejectedError2 } = await null;
+  beforeEach(() => {
+    configure({ handler: () => {
+    } });
+  });
+  const mockSigner = {};
+  const signedEvent = { type: "signed", txHash: "0xbatch" };
+  const bestBlockOk = {
+    type: "txBestBlocksState",
+    txHash: "0xbatch",
+    found: true,
+    ok: true,
+    events: [{ id: 1 }],
+    block: { hash: "0xblock1", number: 100, index: 0 }
+  };
+  const successEmit = (h) => {
+    h.next(signedEvent);
+    h.next(bestBlockOk);
+  };
+  describe("batchSubmitAndWatch", () => {
+    test("batches multiple transactions with decodedCall", async () => {
+      const { api, getCapturedCalls } = createMockBatchApi(successEmit);
+      const calls = [
+        { decodedCall: { pallet: "Balances", method: "transfer", args: { value: 1 } } },
+        { decodedCall: { pallet: "Balances", method: "transfer", args: { value: 2 } } }
+      ];
+      const result = await batchSubmitAndWatch(calls, api, mockSigner);
+      expect(result.ok).toBe(true);
+      expect(getCapturedCalls()).toHaveLength(1);
+      expect(getCapturedCalls()[0]).toEqual([
+        { pallet: "Balances", method: "transfer", args: { value: 1 } },
+        { pallet: "Balances", method: "transfer", args: { value: 2 } }
+      ]);
+      expect(api.tx.Utility.batch_all).toHaveBeenCalledOnce();
+    });
+    test("handles Ink SDK AsyncTransaction wrappers", async () => {
+      const { api, getCapturedCalls } = createMockBatchApi(successEmit);
+      const asyncCall = {
+        waited: Promise.resolve({ decodedCall: { pallet: "Contracts", method: "call" } }),
+        signSubmitAndWatch: () => {
+          throw new Error("Should not be called");
+        }
+      };
+      const result = await batchSubmitAndWatch([asyncCall], api, mockSigner);
+      expect(result.ok).toBe(true);
+      expect(getCapturedCalls()[0]).toEqual([{ pallet: "Contracts", method: "call" }]);
+    });
+    test("accepts raw decoded calls (pass-through)", async () => {
+      const { api, getCapturedCalls } = createMockBatchApi(successEmit);
+      const rawCall = { pallet: "System", method: "remark" };
+      const result = await batchSubmitAndWatch([rawCall], api, mockSigner);
+      expect(result.ok).toBe(true);
+      expect(getCapturedCalls()[0]).toEqual([{ pallet: "System", method: "remark" }]);
+    });
+    test("mixes transaction types in a single batch", async () => {
+      const { api, getCapturedCalls } = createMockBatchApi(successEmit);
+      const txWithDecoded = { decodedCall: "call1" };
+      const asyncTx = {
+        waited: Promise.resolve({ decodedCall: "call2" }),
+        signSubmitAndWatch: () => {
+          throw new Error("Should not be called");
+        }
+      };
+      const rawCall = { pallet: "System", method: "remark" };
+      const result = await batchSubmitAndWatch(
+        [txWithDecoded, asyncTx, rawCall],
+        api,
+        mockSigner
+      );
+      expect(result.ok).toBe(true);
+      expect(getCapturedCalls()[0]).toEqual([
+        "call1",
+        "call2",
+        { pallet: "System", method: "remark" }
+      ]);
+    });
+    test("throws TxBatchError for empty calls array", async () => {
+      const { api } = createMockBatchApi(successEmit);
+      await expect(batchSubmitAndWatch([], api, mockSigner)).rejects.toThrow(TxBatchError);
+      await expect(batchSubmitAndWatch([], api, mockSigner)).rejects.toThrow(
+        "Cannot batch zero calls"
+      );
+    });
+    test("throws TxBatchError when AsyncTransaction resolves without decodedCall", async () => {
+      const { api } = createMockBatchApi(successEmit);
+      const badAsync = {
+        waited: Promise.resolve({ noDecodedCall: true }),
+        signSubmitAndWatch: () => {
+          throw new Error("Should not be called");
+        }
+      };
+      await expect(
+        batchSubmitAndWatch([badAsync], api, mockSigner)
+      ).rejects.toThrow(TxBatchError);
+    });
+    test("throws TxBatchError for null call", async () => {
+      const { api } = createMockBatchApi(successEmit);
+      await expect(
+        batchSubmitAndWatch([null], api, mockSigner)
+      ).rejects.toThrow(TxBatchError);
+      await expect(
+        batchSubmitAndWatch([null], api, mockSigner)
+      ).rejects.toThrow("Invalid batch call");
+    });
+    test("throws TxBatchError for primitive call", async () => {
+      const { api } = createMockBatchApi(successEmit);
+      await expect(
+        batchSubmitAndWatch([42], api, mockSigner)
+      ).rejects.toThrow(TxBatchError);
+      await expect(
+        batchSubmitAndWatch(["oops"], api, mockSigner)
+      ).rejects.toThrow("Invalid batch call");
+    });
+    test("treats { decodedCall: undefined } as raw pass-through object", async () => {
+      const { api, getCapturedCalls } = createMockBatchApi(successEmit);
+      const edgeCase = { decodedCall: void 0, other: "data" };
+      const result = await batchSubmitAndWatch([edgeCase], api, mockSigner);
+      expect(result.ok).toBe(true);
+      expect(getCapturedCalls()[0]).toEqual([{ decodedCall: void 0, other: "data" }]);
+    });
+    test("defaults to batch_all mode", async () => {
+      const { api } = createMockBatchApi(successEmit);
+      await batchSubmitAndWatch([{ decodedCall: "call1" }], api, mockSigner);
+      expect(api.tx.Utility.batch_all).toHaveBeenCalledOnce();
+      expect(api.tx.Utility.batch).not.toHaveBeenCalled();
+      expect(api.tx.Utility.force_batch).not.toHaveBeenCalled();
+    });
+    test("respects mode: batch", async () => {
+      const { api } = createMockBatchApi(successEmit);
+      await batchSubmitAndWatch([{ decodedCall: "call1" }], api, mockSigner, {
+        mode: "batch"
+      });
+      expect(api.tx.Utility.batch).toHaveBeenCalledOnce();
+      expect(api.tx.Utility.batch_all).not.toHaveBeenCalled();
+    });
+    test("respects mode: force_batch", async () => {
+      const { api } = createMockBatchApi(successEmit);
+      await batchSubmitAndWatch([{ decodedCall: "call1" }], api, mockSigner, {
+        mode: "force_batch"
+      });
+      expect(api.tx.Utility.force_batch).toHaveBeenCalledOnce();
+      expect(api.tx.Utility.batch_all).not.toHaveBeenCalled();
+    });
+    test("forwards SubmitOptions to submitAndWatch", async () => {
+      const statuses = [];
+      const { api } = createMockBatchApi(successEmit);
+      await batchSubmitAndWatch([{ decodedCall: "call1" }], api, mockSigner, {
+        onStatus: (s) => statuses.push(s)
+      });
+      expect(statuses).toContain("signing");
+      expect(statuses).toContain("in-block");
+    });
+    test("propagates TxDispatchError", async () => {
+      const { api } = createMockBatchApi((h) => {
+        h.next(signedEvent);
+        h.next({
+          type: "txBestBlocksState",
+          txHash: "0xbatch",
+          found: true,
+          ok: false,
+          events: [],
+          block: { hash: "0xblock1", number: 100, index: 0 },
+          dispatchError: {
+            type: "Module",
+            value: { type: "Utility", value: { type: "TooManyCalls" } }
+          }
+        });
+      });
+      await expect(
+        batchSubmitAndWatch([{ decodedCall: "call1" }], api, mockSigner)
+      ).rejects.toThrow(TxDispatchError2);
+    });
+    test("propagates TxSigningRejectedError", async () => {
+      const { api } = createMockBatchApi((h) => {
+        h.error(new Error("User rejected the request"));
+      });
+      await expect(
+        batchSubmitAndWatch([{ decodedCall: "call1" }], api, mockSigner)
+      ).rejects.toThrow(TxSigningRejectedError2);
+    });
+    test("resolves all calls in parallel", async () => {
+      const { api } = createMockBatchApi(successEmit);
+      const resolveOrder = [];
+      const asyncCall1 = {
+        waited: new Promise((resolve) => {
+          setTimeout(() => {
+            resolveOrder.push(1);
+            resolve({ decodedCall: "call1" });
+          }, 10);
+        }),
+        signSubmitAndWatch: () => {
+          throw new Error("Should not be called");
+        }
+      };
+      const asyncCall2 = {
+        waited: new Promise((resolve) => {
+          setTimeout(() => {
+            resolveOrder.push(2);
+            resolve({ decodedCall: "call2" });
+          }, 5);
+        }),
+        signSubmitAndWatch: () => {
+          throw new Error("Should not be called");
+        }
+      };
+      await batchSubmitAndWatch([asyncCall1, asyncCall2], api, mockSigner);
+      expect(resolveOrder).toContain(1);
+      expect(resolveOrder).toContain(2);
+    });
+  });
+}
+var createMockTx2;
+var createMockBatchApi2;
+
+// src/retry.ts
+import { createLogger as createLogger3 } from "@parity/product-sdk-logger";
+var log3 = createLogger3("tx:retry");
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isNonRetryable(error) {
+  return error instanceof TxBatchError || error instanceof TxDispatchError || error instanceof TxSigningRejectedError || error instanceof TxTimeoutError;
+}
+function calculateDelay(attempt, baseDelayMs, maxDelayMs) {
+  const exponential = Math.min(baseDelayMs * 2 ** attempt, maxDelayMs);
+  const jitter = 0.5 + Math.random() * 0.5;
+  return Math.round(exponential * jitter);
+}
+async function withRetry(fn, options) {
+  const maxAttempts = options?.maxAttempts ?? 3;
+  const baseDelayMs = options?.baseDelayMs ?? 1e3;
+  const maxDelayMs = options?.maxDelayMs ?? 15e3;
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (isNonRetryable(error)) {
+        throw error;
+      }
+      if (attempt + 1 >= maxAttempts) {
+        break;
+      }
+      const delay = calculateDelay(attempt, baseDelayMs, maxDelayMs);
+      log3.warn(`Attempt ${attempt + 1}/${maxAttempts} failed, retrying in ${delay}ms`, {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+if (void 0) {
+  const { describe, test, expect, vi, beforeEach } = void 0;
+  const { configure } = await null;
+  beforeEach(() => {
+    configure({ handler: () => {
+    } });
+    vi.useRealTimers();
+  });
+  describe("withRetry", () => {
+    test("returns on first success", async () => {
+      const result = await withRetry(() => Promise.resolve("ok"));
+      expect(result).toBe("ok");
+    });
+    test("retries transient error then succeeds", async () => {
+      let calls = 0;
+      const result = await withRetry(
+        () => {
+          calls++;
+          if (calls < 2) return Promise.reject(new Error("Network error"));
+          return Promise.resolve("recovered");
+        },
+        { baseDelayMs: 1 }
+      );
+      expect(result).toBe("recovered");
+      expect(calls).toBe(2);
+    });
+    test("gives up after maxAttempts", async () => {
+      let calls = 0;
+      await expect(
+        withRetry(
+          () => {
+            calls++;
+            return Promise.reject(new Error("Persistent failure"));
+          },
+          { maxAttempts: 3, baseDelayMs: 1 }
+        )
+      ).rejects.toThrow("Persistent failure");
+      expect(calls).toBe(3);
+    });
+    test("does NOT retry TxDispatchError", async () => {
+      let calls = 0;
+      await expect(
+        withRetry(
+          () => {
+            calls++;
+            return Promise.reject(
+              new TxDispatchError({}, "Balances.InsufficientBalance")
+            );
+          },
+          { maxAttempts: 3, baseDelayMs: 1 }
+        )
+      ).rejects.toThrow(TxDispatchError);
+      expect(calls).toBe(1);
+    });
+    test("does NOT retry TxSigningRejectedError", async () => {
+      let calls = 0;
+      await expect(
+        withRetry(
+          () => {
+            calls++;
+            return Promise.reject(new TxSigningRejectedError());
+          },
+          { maxAttempts: 3, baseDelayMs: 1 }
+        )
+      ).rejects.toThrow(TxSigningRejectedError);
+      expect(calls).toBe(1);
+    });
+    test("does NOT retry TxBatchError", async () => {
+      let calls = 0;
+      await expect(
+        withRetry(
+          () => {
+            calls++;
+            return Promise.reject(new TxBatchError("Cannot batch zero calls"));
+          },
+          { maxAttempts: 3, baseDelayMs: 1 }
+        )
+      ).rejects.toThrow(TxBatchError);
+      expect(calls).toBe(1);
+    });
+    test("does NOT retry TxTimeoutError", async () => {
+      let calls = 0;
+      await expect(
+        withRetry(
+          () => {
+            calls++;
+            return Promise.reject(new TxTimeoutError(3e5));
+          },
+          { maxAttempts: 3, baseDelayMs: 1 }
+        )
+      ).rejects.toThrow(TxTimeoutError);
+      expect(calls).toBe(1);
+    });
+    test("respects maxDelayMs cap", () => {
+      const delay = calculateDelay(10, 1e3, 15e3);
+      expect(delay).toBeLessThanOrEqual(15e3);
+      expect(delay).toBeGreaterThan(0);
+    });
+    test("applies jitter (delay varies between calls)", () => {
+      const delays = Array.from({ length: 20 }, () => calculateDelay(2, 1e3, 15e3));
+      const unique = new Set(delays);
+      expect(unique.size).toBeGreaterThan(1);
+    });
+    test("exponential backoff increases delay", () => {
+      const base = 1e3;
+      const minDelay2 = base * 4 * 0.5;
+      const maxDelay0 = base * 1;
+      expect(minDelay2).toBeGreaterThan(maxDelay0);
+    });
+  });
+}
+
+// src/dev-signers.ts
+import { DEV_PHRASE } from "@polkadot-labs/hdkd-helpers";
+import { seedToAccount } from "@parity/product-sdk-keys";
+function createDevSigner(name) {
+  return seedToAccount(DEV_PHRASE, `//${name}`).signer;
+}
+function getDevPublicKey(name) {
+  return seedToAccount(DEV_PHRASE, `//${name}`).publicKey;
+}
+if (void 0) {
+  const { describe, test, expect } = void 0;
+  const ALICE_PUBKEY = new Uint8Array([
+    212,
+    53,
+    147,
+    199,
+    21,
+    253,
+    211,
+    28,
+    97,
+    20,
+    26,
+    189,
+    4,
+    169,
+    159,
+    214,
+    130,
+    44,
+    133,
+    88,
+    133,
+    76,
+    205,
+    227,
+    154,
+    86,
+    132,
+    231,
+    165,
+    109,
+    162,
+    125
+  ]);
+  describe("createDevSigner", () => {
+    test("creates a signer for Alice with known public key", () => {
+      const signer = createDevSigner("Alice");
+      expect(signer).toBeDefined();
+      expect(signer.publicKey).toEqual(ALICE_PUBKEY);
+    });
+    test("different names produce different signers", () => {
+      const alice = createDevSigner("Alice");
+      const bob = createDevSigner("Bob");
+      expect(alice.publicKey).not.toEqual(bob.publicKey);
+    });
+    test("all dev account names produce valid signers", () => {
+      const names = ["Alice", "Bob", "Charlie", "Dave", "Eve", "Ferdie"];
+      const keys = /* @__PURE__ */ new Set();
+      for (const name of names) {
+        const signer = createDevSigner(name);
+        expect(signer).toBeDefined();
+        expect(signer.publicKey).toBeInstanceOf(Uint8Array);
+        expect(signer.publicKey.length).toBe(32);
+        const hex = Array.from(signer.publicKey).map((b) => b.toString(16).padStart(2, "0")).join("");
+        expect(keys.has(hex)).toBe(false);
+        keys.add(hex);
+      }
+    });
+  });
+  describe("getDevPublicKey", () => {
+    test("returns Alice's known public key", () => {
+      expect(getDevPublicKey("Alice")).toEqual(ALICE_PUBKEY);
+    });
+    test("matches the signer's public key", () => {
+      const signer = createDevSigner("Bob");
+      const pubkey = getDevPublicKey("Bob");
+      expect(pubkey).toEqual(signer.publicKey);
+    });
+  });
+}
+
+// src/dry-run.ts
+function extractTransaction(result) {
+  if (!result.success) {
+    const formatted = formatDryRunError(result);
+    const revertReason = extractRevertReason(result.value);
+    throw new TxDryRunError(result, formatted, revertReason);
+  }
+  const value = result.value;
+  if (value == null || typeof value !== "object") {
+    throw new TxDryRunError(result, "dry run returned no value");
+  }
+  const v = value;
+  if (typeof v.send !== "function") {
+    throw new TxDryRunError(result, "not a write query (no send())");
+  }
+  return v.send();
+}
+function extractRevertReason(value) {
+  if (value == null || typeof value !== "object") return void 0;
+  const v = value;
+  if (typeof v.revertReason === "string" && v.revertReason) {
+    return v.revertReason;
+  }
+  if ("raw" in v && v.raw != null && typeof v.raw === "object") {
+    return extractRevertReason(v.raw);
+  }
+  return void 0;
+}
+function applyWeightBuffer(weight, options) {
+  const percent = options?.percent ?? 25;
+  const multiplier = 100n + BigInt(percent);
+  return {
+    ref_time: weight.ref_time * multiplier / 100n,
+    proof_size: weight.proof_size * multiplier / 100n
+  };
+}
+if (void 0) {
+  const { describe, test, expect } = void 0;
+  describe("extractTransaction", () => {
+    test("returns tx from successful dry-run with send()", () => {
+      const mockTx = {
+        signSubmitAndWatch: () => ({ subscribe: () => ({ unsubscribe: () => {
+        } }) })
+      };
+      const result = {
+        success: true,
+        value: { response: "ok", send: () => mockTx }
+      };
+      expect(extractTransaction(result)).toBe(mockTx);
+    });
+    test("throws TxDryRunError on failed dry-run", () => {
+      const result = {
+        success: false,
+        value: { revertReason: "InsufficientBalance" }
+      };
+      try {
+        extractTransaction(result);
+        expect.unreachable("should have thrown");
+      } catch (e) {
+        expect(e).toBeInstanceOf(TxDryRunError);
+        const err = e;
+        expect(err.revertReason).toBe("InsufficientBalance");
+        expect(err.formatted).toBe("InsufficientBalance");
+        expect(err.message).toContain("InsufficientBalance");
+        expect(err.raw).toBe(result);
+      }
+    });
+    test("throws TxDryRunError with Module error formatting", () => {
+      const result = {
+        success: false,
+        value: {
+          type: "Module",
+          value: { type: "Revive", value: { type: "StorageDepositNotEnoughFunds" } }
+        }
+      };
+      try {
+        extractTransaction(result);
+        expect.unreachable("should have thrown");
+      } catch (e) {
+        const err = e;
+        expect(err.formatted).toBe("Revive.StorageDepositNotEnoughFunds");
+        expect(err.revertReason).toBeUndefined();
+      }
+    });
+    test("throws TxDryRunError with error field", () => {
+      const result = {
+        success: false,
+        value: {},
+        error: { type: "ContractTrapped" }
+      };
+      try {
+        extractTransaction(result);
+        expect.unreachable("should have thrown");
+      } catch (e) {
+        const err = e;
+        expect(err.formatted).toBe("ContractTrapped");
+      }
+    });
+    test("throws when value is missing", () => {
+      const result = { success: true };
+      expect(() => extractTransaction(result)).toThrow(TxDryRunError);
+    });
+    test("throws when send is not a function", () => {
+      const result = { success: true, value: { response: "ok" } };
+      expect(() => extractTransaction(result)).toThrow("not a write query");
+    });
+    test("throws with revertReason from nested raw (patched SDK)", () => {
+      const result = {
+        success: false,
+        value: { raw: { revertReason: "Unauthorized" } }
+      };
+      try {
+        extractTransaction(result);
+        expect.unreachable("should have thrown");
+      } catch (e) {
+        const err = e;
+        expect(err.revertReason).toBe("Unauthorized");
+      }
+    });
+    test("throws with ReviveApi Message error", () => {
+      const result = {
+        success: false,
+        value: { type: "Message", value: "Insufficient balance for gas * price + value" }
+      };
+      try {
+        extractTransaction(result);
+        expect.unreachable("should have thrown");
+      } catch (e) {
+        const err = e;
+        expect(err.formatted).toBe("Insufficient balance for gas * price + value");
+      }
+    });
+  });
+  describe("applyWeightBuffer", () => {
+    test("applies default 25% buffer", () => {
+      const weight = { ref_time: 1000n, proof_size: 500n };
+      const buffered = applyWeightBuffer(weight);
+      expect(buffered.ref_time).toBe(1250n);
+      expect(buffered.proof_size).toBe(625n);
+    });
+    test("applies custom buffer percentage", () => {
+      const weight = { ref_time: 1000n, proof_size: 1000n };
+      const buffered = applyWeightBuffer(weight, { percent: 50 });
+      expect(buffered.ref_time).toBe(1500n);
+      expect(buffered.proof_size).toBe(1500n);
+    });
+    test("zero buffer returns same values", () => {
+      const weight = { ref_time: 1000n, proof_size: 500n };
+      const buffered = applyWeightBuffer(weight, { percent: 0 });
+      expect(buffered.ref_time).toBe(1000n);
+      expect(buffered.proof_size).toBe(500n);
+    });
+    test("does not mutate original weight", () => {
+      const weight = { ref_time: 1000n, proof_size: 500n };
+      const buffered = applyWeightBuffer(weight);
+      expect(weight.ref_time).toBe(1000n);
+      expect(weight.proof_size).toBe(500n);
+      expect(buffered).not.toBe(weight);
+    });
+    test("works with realistic weight values", () => {
+      const weight = { ref_time: 4500000000n, proof_size: 1000000n };
+      const buffered = applyWeightBuffer(weight);
+      expect(buffered.ref_time).toBe(5625000000n);
+      expect(buffered.proof_size).toBe(1250000n);
+    });
+  });
+}
+
+// src/account-mapping.ts
+import { createLogger as createLogger4 } from "@parity/product-sdk-logger";
+var log4 = createLogger4("tx:mapping");
+var TxAccountMappingError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "TxAccountMappingError";
+  }
+};
+async function ensureAccountMapped(address, signer, checker, api, options) {
+  const timeoutMs = options?.timeoutMs ?? 6e4;
+  const onStatus = options?.onStatus;
+  onStatus?.("checking");
+  let isMapped;
+  try {
+    isMapped = await checker.addressIsMapped(address);
+  } catch (cause) {
+    throw new TxAccountMappingError(`Failed to check mapping status for ${address}`, { cause });
+  }
+  if (isMapped) {
+    log4.debug("account already mapped", { address });
+    onStatus?.("already-mapped");
+    return null;
+  }
+  log4.info("mapping account", { address });
+  onStatus?.("mapping");
+  const tx = api.tx.Revive.map_account();
+  const result = await submitAndWatch(tx, signer, {
+    waitFor: "best-block",
+    timeoutMs
+  });
+  log4.info("account mapped successfully", { address, block: result.block });
+  onStatus?.("mapped");
+  return result;
+}
+async function isAccountMapped(address, checker) {
+  try {
+    return await checker.addressIsMapped(address);
+  } catch (cause) {
+    throw new TxAccountMappingError(`Failed to check mapping status for ${address}`, { cause });
+  }
+}
+if (void 0) {
+  const { describe, test, expect, vi } = void 0;
+  describe("ensureAccountMapped", () => {
+    const mockSigner = {};
+    test("returns null when already mapped", async () => {
+      const checker = {
+        addressIsMapped: vi.fn().mockResolvedValue(true)
+      };
+      const api = {};
+      const result = await ensureAccountMapped("5Alice", mockSigner, checker, api);
+      expect(result).toBeNull();
+      expect(checker.addressIsMapped).toHaveBeenCalledWith("5Alice");
+    });
+    test("calls onStatus with already-mapped when mapped", async () => {
+      const statuses = [];
+      const checker = {
+        addressIsMapped: vi.fn().mockResolvedValue(true)
+      };
+      await ensureAccountMapped("5Alice", mockSigner, checker, {}, {
+        onStatus: (s) => statuses.push(s)
+      });
+      expect(statuses).toEqual(["checking", "already-mapped"]);
+    });
+    test("throws TxAccountMappingError when check fails", async () => {
+      const checker = {
+        addressIsMapped: vi.fn().mockRejectedValue(new Error("network error"))
+      };
+      await expect(
+        ensureAccountMapped("5Alice", mockSigner, checker, {})
+      ).rejects.toThrow(TxAccountMappingError);
+    });
+    test("submits map_account when not mapped", async () => {
+      const checker = {
+        addressIsMapped: vi.fn().mockResolvedValue(false)
+      };
+      const mockTx = {
+        signSubmitAndWatch: (_signer, _options) => ({
+          subscribe: (handlers) => {
+            queueMicrotask(() => {
+              handlers.next({ type: "signed", txHash: "0xabc" });
+              handlers.next({
+                type: "txBestBlocksState",
+                txHash: "0xabc",
+                found: true,
+                ok: true,
+                events: [],
+                block: { hash: "0xblock", number: 1, index: 0 }
+              });
+            });
+            return { unsubscribe: () => {
+            } };
+          }
+        })
+      };
+      const api = {
+        tx: { Revive: { map_account: () => mockTx } }
+      };
+      const result = await ensureAccountMapped("5Alice", mockSigner, checker, api);
+      expect(result).not.toBeNull();
+      expect(result.ok).toBe(true);
+    });
+    test("calls onStatus through full mapping flow", async () => {
+      const statuses = [];
+      const checker = {
+        addressIsMapped: vi.fn().mockResolvedValue(false)
+      };
+      const mockTx = {
+        signSubmitAndWatch: (_signer, _options) => ({
+          subscribe: (handlers) => {
+            queueMicrotask(() => {
+              handlers.next({ type: "signed", txHash: "0xabc" });
+              handlers.next({
+                type: "txBestBlocksState",
+                txHash: "0xabc",
+                found: true,
+                ok: true,
+                events: [],
+                block: { hash: "0xblock", number: 1, index: 0 }
+              });
+            });
+            return { unsubscribe: () => {
+            } };
+          }
+        })
+      };
+      const api = {
+        tx: { Revive: { map_account: () => mockTx } }
+      };
+      await ensureAccountMapped("5Alice", mockSigner, checker, api, {
+        onStatus: (s) => statuses.push(s)
+      });
+      expect(statuses).toEqual(["checking", "mapping", "mapped"]);
+    });
+    test("propagates TxDispatchError from submitAndWatch", async () => {
+      const { TxDispatchError: TxDispatchError2 } = await null;
+      const checker = {
+        addressIsMapped: vi.fn().mockResolvedValue(false)
+      };
+      const mockTx = {
+        signSubmitAndWatch: (_signer, _options) => ({
+          subscribe: (handlers) => {
+            queueMicrotask(() => {
+              handlers.next({
+                type: "txBestBlocksState",
+                txHash: "0xabc",
+                found: true,
+                ok: false,
+                events: [],
+                block: { hash: "0xblock", number: 1, index: 0 },
+                dispatchError: { type: "BadOrigin" }
+              });
+            });
+            return { unsubscribe: () => {
+            } };
+          }
+        })
+      };
+      const api = {
+        tx: { Revive: { map_account: () => mockTx } }
+      };
+      await expect(ensureAccountMapped("5Alice", mockSigner, checker, api)).rejects.toThrow(
+        TxDispatchError2
+      );
+    });
+    test("propagates TxTimeoutError from submitAndWatch", async () => {
+      const { TxTimeoutError: TxTimeoutError2 } = await null;
+      const checker = {
+        addressIsMapped: vi.fn().mockResolvedValue(false)
+      };
+      const mockTx = {
+        signSubmitAndWatch: (_signer, _options) => ({
+          subscribe: () => ({ unsubscribe: () => {
+          } })
+        })
+      };
+      const api = {
+        tx: { Revive: { map_account: () => mockTx } }
+      };
+      await expect(
+        ensureAccountMapped("5Alice", mockSigner, checker, api, { timeoutMs: 50 })
+      ).rejects.toThrow(TxTimeoutError2);
+    });
+  });
+  describe("isAccountMapped", () => {
+    test("returns true when mapped", async () => {
+      const checker = {
+        addressIsMapped: vi.fn().mockResolvedValue(true)
+      };
+      expect(await isAccountMapped("5Alice", checker)).toBe(true);
+    });
+    test("returns false when not mapped", async () => {
+      const checker = {
+        addressIsMapped: vi.fn().mockResolvedValue(false)
+      };
+      expect(await isAccountMapped("5Alice", checker)).toBe(false);
+    });
+    test("throws TxAccountMappingError on failure", async () => {
+      const checker = {
+        addressIsMapped: vi.fn().mockRejectedValue(new Error("timeout"))
+      };
+      await expect(isAccountMapped("5Alice", checker)).rejects.toThrow(TxAccountMappingError);
+    });
+  });
+}
+export {
+  TxAccountMappingError,
+  TxBatchError,
+  TxDispatchError,
+  TxDryRunError,
+  TxError,
+  TxSigningRejectedError,
+  TxTimeoutError,
+  applyWeightBuffer,
+  batchSubmitAndWatch,
+  calculateDelay,
+  createDevSigner,
+  ensureAccountMapped,
+  extractTransaction,
+  formatDispatchError,
+  formatDryRunError,
+  getDevPublicKey,
+  isAccountMapped,
+  isSigningRejection,
+  submitAndWatch,
+  withRetry
+};
+//# sourceMappingURL=index.js.map