@parity/product-sdk-tx 0.1.0 → 0.2.1

package/dist/index.js

@@ -1,5 +1,8 @@
+import { createLogger } from '@parity/product-sdk-logger';
+import { DEV_PHRASE } from '@polkadot-labs/hdkd-helpers';
+import { seedToAccount } from '@parity/product-sdk-keys';
+
 // src/submit.ts
-import { createLogger } from "@parity/product-sdk-logger";
 
 // src/errors.ts
 var TxError = class extends Error {
@@ -119,239 +122,6 @@ function isSigningRejection(error) {
   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;
@@ -497,245 +267,7 @@ async function submitAndWatch(tx, signer, options) {
     }
   });
 }
-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");
+var log2 = createLogger("tx:batch");
 async function resolveDecodedCall(call) {
   if (call != null && typeof call === "object") {
     const obj = call;
@@ -767,260 +299,7 @@ async function batchSubmitAndWatch(calls, api, signer, options) {
   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");
+var log3 = createLogger("tx:retry");
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -1057,199 +336,12 @@ async function withRetry(fn, options) {
   }
   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) {
@@ -1287,141 +379,7 @@ function applyWeightBuffer(weight, options) {
     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 log4 = createLogger("tx:mapping");
 var TxAccountMappingError = class extends Error {
   constructor(message, options) {
     super(message, options);
@@ -1461,190 +419,7 @@ async function isAccountMapped(address, checker) {
     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
-};
+
+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
 //# sourceMappingURL=index.js.map