@btc-vision/transaction 1.7.19 → 1.7.23

package/browser/scure-base.js

@@ -0,0 +1,410 @@
+import { a as ue } from "./bip39.js";
+function A(e) {
+  return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
+}
+function H(e) {
+  if (!A(e))
+    throw new Error("Uint8Array expected");
+}
+function K(e, r) {
+  return Array.isArray(r) ? r.length === 0 ? !0 : e ? r.every((n) => typeof n == "string") : r.every((n) => Number.isSafeInteger(n)) : !1;
+}
+function D(e) {
+  if (typeof e != "function")
+    throw new Error("function expected");
+  return !0;
+}
+function b(e, r) {
+  if (typeof r != "string")
+    throw new Error(`${e}: string expected`);
+  return !0;
+}
+function m(e) {
+  if (!Number.isSafeInteger(e))
+    throw new Error(`invalid integer: ${e}`);
+}
+function k(e) {
+  if (!Array.isArray(e))
+    throw new Error("array expected");
+}
+function R(e, r) {
+  if (!K(!0, r))
+    throw new Error(`${e}: array of strings expected`);
+}
+function M(e, r) {
+  if (!K(!1, r))
+    throw new Error(`${e}: array of numbers expected`);
+}
+// @__NO_SIDE_EFFECTS__
+function f(...e) {
+  const r = (o) => o, n = (o, s) => (i) => o(s(i)), c = e.map((o) => o.encode).reduceRight(n, r), t = e.map((o) => o.decode).reduce(n, r);
+  return { encode: c, decode: t };
+}
+// @__NO_SIDE_EFFECTS__
+function u(e) {
+  const r = typeof e == "string" ? e.split("") : e, n = r.length;
+  R("alphabet", r);
+  const c = new Map(r.map((t, o) => [t, o]));
+  return {
+    encode: (t) => (k(t), t.map((o) => {
+      if (!Number.isSafeInteger(o) || o < 0 || o >= n)
+        throw new Error(`alphabet.encode: digit index outside alphabet "${o}". Allowed: ${e}`);
+      return r[o];
+    })),
+    decode: (t) => (k(t), t.map((o) => {
+      b("alphabet.decode", o);
+      const s = c.get(o);
+      if (s === void 0)
+        throw new Error(`Unknown letter: "${o}". Allowed: ${e}`);
+      return s;
+    }))
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function l(e = "") {
+  return b("join", e), {
+    encode: (r) => (R("join.decode", r), r.join(e)),
+    decode: (r) => (b("join.decode", r), r.split(e))
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function T(e, r = "=") {
+  return m(e), b("padding", r), {
+    encode(n) {
+      for (R("padding.encode", n); n.length * e % 8; )
+        n.push(r);
+      return n;
+    },
+    decode(n) {
+      R("padding.decode", n);
+      let c = n.length;
+      if (c * e % 8)
+        throw new Error("padding: invalid, string should have whole number of bytes");
+      for (; c > 0 && n[c - 1] === r; c--)
+        if ((c - 1) * e % 8 === 0)
+          throw new Error("padding: invalid, string has too much padding");
+      return n.slice(0, c);
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function V(e) {
+  return D(e), { encode: (r) => r, decode: (r) => e(r) };
+}
+function O(e, r, n) {
+  if (r < 2)
+    throw new Error(`convertRadix: invalid from=${r}, base cannot be less than 2`);
+  if (n < 2)
+    throw new Error(`convertRadix: invalid to=${n}, base cannot be less than 2`);
+  if (k(e), !e.length)
+    return [];
+  let c = 0;
+  const t = [], o = Array.from(e, (i) => {
+    if (m(i), i < 0 || i >= r)
+      throw new Error(`invalid integer: ${i}`);
+    return i;
+  }), s = o.length;
+  for (; ; ) {
+    let i = 0, g = !0;
+    for (let p = c; p < s; p++) {
+      const x = o[p], d = r * i, a = d + x;
+      if (!Number.isSafeInteger(a) || d / r !== i || a - x !== d)
+        throw new Error("convertRadix: carry overflow");
+      const y = a / n;
+      i = a % n;
+      const h = Math.floor(y);
+      if (o[p] = h, !Number.isSafeInteger(h) || h * n + i !== a)
+        throw new Error("convertRadix: carry overflow");
+      if (g)
+        h ? g = !1 : c = p;
+      else continue;
+    }
+    if (t.push(i), g)
+      break;
+  }
+  for (let i = 0; i < e.length - 1 && e[i] === 0; i++)
+    t.push(0);
+  return t.reverse();
+}
+const J = (e, r) => r === 0 ? e : J(r, e % r), S = /* @__NO_SIDE_EFFECTS__ */ (e, r) => e + (r - J(e, r)), C = /* @__PURE__ */ (() => {
+  let e = [];
+  for (let r = 0; r < 40; r++)
+    e.push(2 ** r);
+  return e;
+})();
+function N(e, r, n, c) {
+  if (k(e), r <= 0 || r > 32)
+    throw new Error(`convertRadix2: wrong from=${r}`);
+  if (n <= 0 || n > 32)
+    throw new Error(`convertRadix2: wrong to=${n}`);
+  if (/* @__PURE__ */ S(r, n) > 32)
+    throw new Error(`convertRadix2: carry overflow from=${r} to=${n} carryBits=${/* @__PURE__ */ S(r, n)}`);
+  let t = 0, o = 0;
+  const s = C[r], i = C[n] - 1, g = [];
+  for (const p of e) {
+    if (m(p), p >= s)
+      throw new Error(`convertRadix2: invalid data word=${p} from=${r}`);
+    if (t = t << r | p, o + r > 32)
+      throw new Error(`convertRadix2: carry overflow pos=${o} from=${r}`);
+    for (o += r; o >= n; o -= n)
+      g.push((t >> o - n & i) >>> 0);
+    const x = C[o];
+    if (x === void 0)
+      throw new Error("invalid carry");
+    t &= x - 1;
+  }
+  if (t = t << n - o & i, !c && o >= r)
+    throw new Error("Excess padding");
+  if (!c && t > 0)
+    throw new Error(`Non-zero padding: ${t}`);
+  return c && o > 0 && g.push(t >>> 0), g;
+}
+// @__NO_SIDE_EFFECTS__
+function Q(e) {
+  m(e);
+  const r = 2 ** 8;
+  return {
+    encode: (n) => {
+      if (!A(n))
+        throw new Error("radix.encode input should be Uint8Array");
+      return O(Array.from(n), r, e);
+    },
+    decode: (n) => (M("radix.decode", n), Uint8Array.from(O(n, e, r)))
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function w(e, r = !1) {
+  if (m(e), e <= 0 || e > 32)
+    throw new Error("radix2: bits should be in (0..32]");
+  if (/* @__PURE__ */ S(8, e) > 32 || /* @__PURE__ */ S(e, 8) > 32)
+    throw new Error("radix2: carry overflow");
+  return {
+    encode: (n) => {
+      if (!A(n))
+        throw new Error("radix2.encode input should be Uint8Array");
+      return N(Array.from(n), 8, e, !r);
+    },
+    decode: (n) => (M("radix2.decode", n), Uint8Array.from(N(n, e, 8, r)))
+  };
+}
+function F(e) {
+  return D(e), function(...r) {
+    try {
+      return e.apply(null, r);
+    } catch {
+    }
+  };
+}
+function Z(e, r) {
+  return m(e), D(r), {
+    encode(n) {
+      if (!A(n))
+        throw new Error("checksum.encode: input should be Uint8Array");
+      const c = r(n).slice(0, e), t = new Uint8Array(n.length + e);
+      return t.set(n), t.set(c, n.length), t;
+    },
+    decode(n) {
+      if (!A(n))
+        throw new Error("checksum.decode: input should be Uint8Array");
+      const c = n.slice(0, -e), t = n.slice(-e), o = r(c).slice(0, e);
+      for (let s = 0; s < e; s++)
+        if (o[s] !== t[s])
+          throw new Error("Invalid checksum");
+      return c;
+    }
+  };
+}
+const le = {
+  alphabet: u,
+  chain: f,
+  checksum: Z,
+  convertRadix: O,
+  convertRadix2: N,
+  radix: Q,
+  radix2: w,
+  join: l,
+  padding: T
+}, X = /* @__PURE__ */ f(/* @__PURE__ */ w(4), /* @__PURE__ */ u("0123456789ABCDEF"), /* @__PURE__ */ l("")), Y = /* @__PURE__ */ f(/* @__PURE__ */ w(5), /* @__PURE__ */ u("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), /* @__PURE__ */ T(5), /* @__PURE__ */ l("")), he = /* @__PURE__ */ f(/* @__PURE__ */ w(5), /* @__PURE__ */ u("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), /* @__PURE__ */ l("")), we = /* @__PURE__ */ f(/* @__PURE__ */ w(5), /* @__PURE__ */ u("0123456789ABCDEFGHIJKLMNOPQRSTUV"), /* @__PURE__ */ T(5), /* @__PURE__ */ l("")), pe = /* @__PURE__ */ f(/* @__PURE__ */ w(5), /* @__PURE__ */ u("0123456789ABCDEFGHIJKLMNOPQRSTUV"), /* @__PURE__ */ l("")), ye = /* @__PURE__ */ f(/* @__PURE__ */ w(5), /* @__PURE__ */ u("0123456789ABCDEFGHJKMNPQRSTVWXYZ"), /* @__PURE__ */ l(""), /* @__PURE__ */ V((e) => e.toUpperCase().replace(/O/g, "0").replace(/[IL]/g, "1"))), q = typeof Uint8Array.from([]).toBase64 == "function" && typeof Uint8Array.fromBase64 == "function", ee = (e, r) => {
+  b("base64", e);
+  const n = r ? /^[A-Za-z0-9=_-]+$/ : /^[A-Za-z0-9=+/]+$/, c = r ? "base64url" : "base64";
+  if (e.length > 0 && !n.test(e))
+    throw new Error("invalid base64");
+  return Uint8Array.fromBase64(e, { alphabet: c, lastChunkHandling: "strict" });
+}, re = q ? {
+  encode(e) {
+    return H(e), e.toBase64();
+  },
+  decode(e) {
+    return ee(e, !1);
+  }
+} : /* @__PURE__ */ f(/* @__PURE__ */ w(6), /* @__PURE__ */ u("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), /* @__PURE__ */ T(6), /* @__PURE__ */ l("")), ge = /* @__PURE__ */ f(/* @__PURE__ */ w(6), /* @__PURE__ */ u("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), /* @__PURE__ */ l("")), ne = q ? {
+  encode(e) {
+    return H(e), e.toBase64({ alphabet: "base64url" });
+  },
+  decode(e) {
+    return ee(e, !0);
+  }
+} : /* @__PURE__ */ f(/* @__PURE__ */ w(6), /* @__PURE__ */ u("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), /* @__PURE__ */ T(6), /* @__PURE__ */ l("")), be = /* @__PURE__ */ f(/* @__PURE__ */ w(6), /* @__PURE__ */ u("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), /* @__PURE__ */ l("")), P = /* @__NO_SIDE_EFFECTS__ */ (e) => /* @__PURE__ */ f(/* @__PURE__ */ Q(58), /* @__PURE__ */ u(e), /* @__PURE__ */ l("")), U = /* @__PURE__ */ P("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"), xe = /* @__PURE__ */ P("123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"), Ee = /* @__PURE__ */ P("rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz"), G = [0, 2, 3, 5, 6, 7, 9, 10, 11], oe = {
+  encode(e) {
+    let r = "";
+    for (let n = 0; n < e.length; n += 8) {
+      const c = e.subarray(n, n + 8);
+      r += U.encode(c).padStart(G[c.length], "1");
+    }
+    return r;
+  },
+  decode(e) {
+    let r = [];
+    for (let n = 0; n < e.length; n += 11) {
+      const c = e.slice(n, n + 11), t = G.indexOf(c.length), o = U.decode(c);
+      for (let s = 0; s < o.length - t; s++)
+        if (o[s] !== 0)
+          throw new Error("base58xmr: wrong padding");
+      r = r.concat(Array.from(o.slice(o.length - t)));
+    }
+    return Uint8Array.from(r);
+  }
+}, te = (e) => /* @__PURE__ */ f(Z(4, (r) => e(e(r))), U), Ae = te, I = /* @__PURE__ */ f(/* @__PURE__ */ u("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), /* @__PURE__ */ l("")), _ = [996825010, 642813549, 513874426, 1027748829, 705979059];
+function B(e) {
+  const r = e >> 25;
+  let n = (e & 33554431) << 5;
+  for (let c = 0; c < _.length; c++)
+    (r >> c & 1) === 1 && (n ^= _[c]);
+  return n;
+}
+function z(e, r, n = 1) {
+  const c = e.length;
+  let t = 1;
+  for (let o = 0; o < c; o++) {
+    const s = e.charCodeAt(o);
+    if (s < 33 || s > 126)
+      throw new Error(`Invalid prefix (${e})`);
+    t = B(t) ^ s >> 5;
+  }
+  t = B(t);
+  for (let o = 0; o < c; o++)
+    t = B(t) ^ e.charCodeAt(o) & 31;
+  for (let o of r)
+    t = B(t) ^ o;
+  for (let o = 0; o < 6; o++)
+    t = B(t);
+  return t ^= n, I.encode(N([t % C[30]], 30, 5, !1));
+}
+// @__NO_SIDE_EFFECTS__
+function ce(e) {
+  const r = e === "bech32" ? 1 : 734539939, n = /* @__PURE__ */ w(5), c = n.decode, t = n.encode, o = F(c);
+  function s(d, a, y = 90) {
+    b("bech32.encode prefix", d), A(a) && (a = Array.from(a)), M("bech32.encode", a);
+    const h = d.length;
+    if (h === 0)
+      throw new TypeError(`Invalid prefix length ${h}`);
+    const E = h + 7 + a.length;
+    if (y !== !1 && E > y)
+      throw new TypeError(`Length ${E} exceeds limit ${y}`);
+    const v = d.toLowerCase(), $ = z(v, a, r);
+    return `${v}1${I.encode(a)}${$}`;
+  }
+  function i(d, a = 90) {
+    b("bech32.decode input", d);
+    const y = d.length;
+    if (y < 8 || a !== !1 && y > a)
+      throw new TypeError(`invalid string length: ${y} (${d}). Expected (8..${a})`);
+    const h = d.toLowerCase();
+    if (d !== h && d !== d.toUpperCase())
+      throw new Error("String must be lowercase or uppercase");
+    const E = h.lastIndexOf("1");
+    if (E === 0 || E === -1)
+      throw new Error('Letter "1" must be present between prefix and data only');
+    const v = h.slice(0, E), $ = h.slice(E + 1);
+    if ($.length < 6)
+      throw new Error("Data must be at least 6 characters long");
+    const j = I.decode($).slice(0, -6), W = z(v, j, r);
+    if (!$.endsWith(W))
+      throw new Error(`Invalid checksum in ${d}: expected "${W}"`);
+    return { prefix: v, words: j };
+  }
+  const g = F(i);
+  function p(d) {
+    const { prefix: a, words: y } = i(d, !1);
+    return { prefix: a, words: y, bytes: c(y) };
+  }
+  function x(d, a) {
+    return s(d, t(a));
+  }
+  return {
+    encode: s,
+    decode: i,
+    encodeFromBytes: x,
+    decodeToBytes: p,
+    decodeUnsafe: g,
+    fromWords: c,
+    fromWordsUnsafe: o,
+    toWords: t
+  };
+}
+const me = /* @__PURE__ */ ce("bech32"), ve = /* @__PURE__ */ ce("bech32m"), se = {
+  encode: (e) => new TextDecoder().decode(e),
+  decode: (e) => new TextEncoder().encode(e)
+}, $e = typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", Be = {
+  encode(e) {
+    return H(e), e.toHex();
+  },
+  decode(e) {
+    return b("hex", e), Uint8Array.fromHex(e);
+  }
+}, ie = $e ? Be : /* @__PURE__ */ f(/* @__PURE__ */ w(4), /* @__PURE__ */ u("0123456789abcdef"), /* @__PURE__ */ l(""), /* @__PURE__ */ V((e) => {
+  if (typeof e != "string" || e.length % 2 !== 0)
+    throw new TypeError(`hex.decode: expected string, got ${typeof e} with length ${e.length}`);
+  return e.toLowerCase();
+})), L = {
+  utf8: se,
+  hex: ie,
+  base16: X,
+  base32: Y,
+  base64: re,
+  base64url: ne,
+  base58: U,
+  base58xmr: oe
+}, ae = "Invalid encoding type. Available types: utf8, hex, base16, base32, base64, base64url, base58, base58xmr", de = (e, r) => {
+  if (typeof e != "string" || !L.hasOwnProperty(e))
+    throw new TypeError(ae);
+  if (!A(r))
+    throw new TypeError("bytesToString() expects Uint8Array");
+  return L[e].encode(r);
+}, Ue = de, fe = (e, r) => {
+  if (!L.hasOwnProperty(e))
+    throw new TypeError(ae);
+  if (typeof r != "string")
+    throw new TypeError("stringToBytes() expects string");
+  return L[e].decode(r);
+}, Te = fe, Ce = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  base16: X,
+  base32: Y,
+  base32crockford: ye,
+  base32hex: we,
+  base32hexnopad: pe,
+  base32nopad: he,
+  base58: U,
+  base58check: Ae,
+  base58flickr: xe,
+  base58xmr: oe,
+  base58xrp: Ee,
+  base64: re,
+  base64nopad: ge,
+  base64url: ne,
+  base64urlnopad: be,
+  bech32: me,
+  bech32m: ve,
+  bytes: Te,
+  bytesToString: de,
+  createBase58check: te,
+  hex: ie,
+  str: Ue,
+  stringToBytes: fe,
+  utf8: se,
+  utils: le
+}, Symbol.toStringTag, { value: "Module" })), Re = /* @__PURE__ */ ue(Ce);
+export {
+  Re as r
+};

package/browser/signer/AddressRotation.d.ts

@@ -0,0 +1,12 @@
+import { Signer } from '../../node_modules/@btc-vision/bitcoin/build/index.js';
+import { ECPairInterface } from 'ecpair';
+import { UnisatSigner } from '../transaction/browser/extensions/UnisatSigner.js';
+export type RotationSigner = Signer | ECPairInterface | UnisatSigner;
+export type SignerMap = Map<string, RotationSigner>;
+export interface AddressRotationConfig {
+    readonly enabled: boolean;
+    readonly signerMap: SignerMap;
+}
+export declare function createSignerMap(pairs: ReadonlyArray<readonly [string, RotationSigner]>): SignerMap;
+export declare function createAddressRotation(signers: SignerMap | ReadonlyArray<readonly [string, RotationSigner]>): AddressRotationConfig;
+export declare function disabledAddressRotation(): AddressRotationConfig;

package/browser/signer/SignerUtils.d.ts

@@ -1,4 +1,4 @@
-import { PsbtInput } from '@btc-vision/bitcoin';
+import { PsbtInput } from '../../node_modules/@btc-vision/bitcoin/build/index.js';
 export declare function isTaprootInput(input: PsbtInput): boolean;
 export declare function getInputRelevantScript(input: PsbtInput): Buffer | null;
 export declare function canSignNonTaprootInput(input: PsbtInput, publicKey: Buffer): boolean;

package/browser/signer/TweakedSigner.d.ts

@@ -1,4 +1,4 @@
-import { Network } from '@btc-vision/bitcoin';
+import { Network } from '../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { ECPairInterface } from 'ecpair';
 export interface TweakSettings {
     readonly network?: Network;

package/browser/transaction/TransactionFactory.d.ts

@@ -1,4 +1,4 @@
-import { Transaction } from '@btc-vision/bitcoin';
+import { Transaction } from '../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { UTXO } from '../utxo/interfaces/IUTXO.js';
 import { ICustomTransactionParameters } from './builders/CustomScriptTransaction.js';
 import { FundingTransaction } from './builders/FundingTransaction.js';
@@ -8,6 +8,7 @@ import { IDeploymentParameters, IFundingTransactionParameters, IInteractionParam
 import { ICancelTransactionParametersWithoutSigner, ICustomTransactionWithoutSigner, InteractionParametersWithoutSigner } from './browser/Web3Provider.js';
 import { RawChallenge } from '../epoch/interfaces/IChallengeSolution.js';
 import { ICancelTransactionParameters } from './builders/CancelTransaction.js';
+import { IConsolidatedInteractionParameters } from './interfaces/IConsolidatedTransactionParameters.js';
 export interface DeploymentResult {
     readonly transaction: [string, string];
     readonly contractAddress: string;
@@ -48,6 +49,18 @@ export interface CancelledTransaction {
     readonly nextUTXOs: UTXO[];
     readonly inputUtxos: UTXO[];
 }
+export interface ConsolidatedInteractionResponse {
+    readonly setupTransaction: string;
+    readonly revealTransaction: string;
+    readonly setupTxId: string;
+    readonly revealTxId: string;
+    readonly totalFees: bigint;
+    readonly chunkCount: number;
+    readonly dataSize: number;
+    readonly challenge: RawChallenge;
+    readonly inputUtxos: UTXO[];
+    readonly compiledTargetScript: string;
+}
 export declare class TransactionFactory {
     debug: boolean;
     private readonly DUMMY_PUBKEY;
@@ -57,6 +70,7 @@ export declare class TransactionFactory {
     createCancellableTransaction(params: ICancelTransactionParameters | ICancelTransactionParametersWithoutSigner): Promise<CancelledTransaction>;
     createCustomScriptTransaction(interactionParameters: ICustomTransactionParameters | ICustomTransactionWithoutSigner): Promise<[string, string, UTXO[], UTXO[]]>;
     signInteraction(interactionParameters: IInteractionParameters | InteractionParametersWithoutSigner): Promise<InteractionResponse>;
+    signConsolidatedInteraction(interactionParameters: IConsolidatedInteractionParameters): Promise<ConsolidatedInteractionResponse>;
     signDeployment(deploymentParameters: IDeploymentParameters): Promise<DeploymentResult>;
     createBTCTransfer(parameters: IFundingTransactionParameters): Promise<BitcoinTransferResponse>;
     getAllNewUTXOs(original: TransactionBuilder<TransactionType>, tx: Transaction, to: string): UTXO[];

package/browser/transaction/browser/BrowserSignerBase.d.ts

@@ -1,4 +1,4 @@
-import { Network, Psbt, Signer } from '@btc-vision/bitcoin';
+import { Network, Psbt, Signer } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 export declare abstract class CustomKeypair implements Signer {
     abstract network: Network;
     abstract publicKey: Buffer;

package/browser/transaction/browser/Web3Provider.d.ts

@@ -3,7 +3,7 @@ import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { CancelledTransaction, DeploymentResult, InteractionResponse } from '../TransactionFactory';
 import { ICustomTransactionParameters } from '../builders/CustomScriptTransaction.js';
 import { ICancelTransactionParameters } from '../builders/CancelTransaction.js';
-import { MLDSASecurityLevel } from '@btc-vision/bip32';
+import { MLDSASecurityLevel } from '../../../node_modules/@btc-vision/bip32/src/cjs/index.cjs';
 export type InteractionParametersWithoutSigner = Omit<IInteractionParameters, 'signer' | 'challenge' | 'mldsaSigner'>;
 export type IDeploymentParametersWithoutSigner = Omit<IDeploymentParameters, 'signer' | 'network' | 'challenge' | 'mldsaSigner'>;
 export type ICustomTransactionWithoutSigner = Omit<ICustomTransactionParameters, 'signer' | 'challenge' | 'mldsaSigner'>;

package/browser/transaction/browser/extensions/UnisatSigner.d.ts

@@ -1,4 +1,4 @@
-import { Network, Psbt } from '@btc-vision/bitcoin';
+import { Network, Psbt } from '../../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { CustomKeypair } from '../BrowserSignerBase.js';
 import { SignatureType, Unisat } from '../types/Unisat.js';
 export interface WindowWithWallets {

package/browser/transaction/browser/extensions/XverseSigner.d.ts

@@ -1,4 +1,4 @@
-import { Network, Psbt } from '@btc-vision/bitcoin';
+import { Network, Psbt } from '../../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { CustomKeypair } from '../BrowserSignerBase.js';
 import { SigningProtocol, Xverse } from '../types/Xverse.js';
 declare global {

package/browser/transaction/builders/CancelTransaction.d.ts

@@ -1,5 +1,5 @@
 import { TransactionType } from '../enums/TransactionType.js';
-import { P2TRPayment, Psbt, PsbtInput, Taptree } from '@btc-vision/bitcoin';
+import { P2TRPayment, Psbt, PsbtInput, Taptree } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { ITransactionParameters } from '../interfaces/ITransactionParameters.js';

package/browser/transaction/builders/ConsolidatedInteractionTransaction.d.ts

@@ -0,0 +1,44 @@
+import { Buffer } from '../../../buffer';
+import { ECPairInterface } from 'ecpair';
+import { TransactionType } from '../enums/TransactionType.js';
+import { TransactionBuilder } from './TransactionBuilder.js';
+import { HashCommitmentGenerator } from '../../generators/builders/HashCommitmentGenerator.js';
+import { CalldataGenerator } from '../../generators/builders/CalldataGenerator.js';
+import { IConsolidatedInteractionParameters, IConsolidatedInteractionResult, IHashCommittedP2WSH, IRevealTransactionResult } from '../interfaces/IConsolidatedTransactionParameters.js';
+import { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
+import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
+export declare class ConsolidatedInteractionTransaction extends TransactionBuilder<TransactionType.INTERACTION> {
+    readonly type: TransactionType.INTERACTION;
+    readonly randomBytes: Buffer;
+    protected readonly contractAddress: string;
+    protected readonly contractSecret: Buffer;
+    protected readonly calldata: Buffer;
+    protected readonly challenge: ChallengeSolution;
+    protected readonly epochChallenge: IP2WSHAddress;
+    protected readonly scriptSigner: ECPairInterface;
+    protected readonly calldataGenerator: CalldataGenerator;
+    protected readonly hashCommitmentGenerator: HashCommitmentGenerator;
+    protected readonly compiledTargetScript: Buffer;
+    protected readonly commitmentOutputs: IHashCommittedP2WSH[];
+    protected readonly disableAutoRefund: boolean;
+    protected readonly maxChunkSize: number;
+    private cachedValuePerOutput;
+    constructor(parameters: IConsolidatedInteractionParameters);
+    exportCompiledTargetScript(): Buffer;
+    getContractSecret(): Buffer;
+    getRndBytes(): Buffer;
+    getChallenge(): ChallengeSolution;
+    getCommitmentOutputs(): IHashCommittedP2WSH[];
+    getOutputCount(): number;
+    getTotalChunkCount(): number;
+    build(): Promise<IConsolidatedInteractionResult>;
+    buildRevealTransaction(setupTxId: string): IRevealTransactionResult;
+    getValuePerOutput(): bigint;
+    protected buildTransaction(): Promise<void>;
+    private finalizeCommitmentInput;
+    private estimateRevealVBytes;
+    private calculateValuePerOutput;
+    private getRefundAddress;
+    private generateFeatures;
+    private validateOutputCount;
+}

package/browser/transaction/builders/CustomScriptTransaction.d.ts

@@ -1,4 +1,4 @@
-import { P2TRPayment, Psbt, PsbtInput, Stack } from '@btc-vision/bitcoin';
+import { P2TRPayment, Psbt, PsbtInput, Stack } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { TransactionType } from '../enums/TransactionType.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { SharedInteractionParameters } from '../interfaces/ITransactionParameters.js';

package/browser/transaction/builders/DeploymentTransaction.d.ts

@@ -1,6 +1,6 @@
 import { TransactionType } from '../enums/TransactionType.js';
 import { IDeploymentParameters } from '../interfaces/ITransactionParameters.js';
-import { P2TRPayment, Psbt } from '@btc-vision/bitcoin';
+import { P2TRPayment, Psbt } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { Address } from '../../keypair/Address.js';

package/browser/transaction/builders/FundingTransaction.d.ts

@@ -1,6 +1,6 @@
 import { TransactionType } from '../enums/TransactionType.js';
 import { IFundingTransactionParameters } from '../interfaces/ITransactionParameters.js';
-import { Signer } from '@btc-vision/bitcoin';
+import { Signer } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { ECPairInterface } from 'ecpair';
 export declare class FundingTransaction extends TransactionBuilder<TransactionType.FUNDING> {

package/browser/transaction/builders/InteractionTransaction.d.ts

@@ -1,4 +1,4 @@
-import { Taptree } from '@btc-vision/bitcoin';
+import { Taptree } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { TransactionType } from '../enums/TransactionType.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { IInteractionParameters } from '../interfaces/ITransactionParameters.js';

package/browser/transaction/builders/InteractionTransactionP2WDA.d.ts

@@ -1,5 +1,5 @@
-import { Buffer } from 'buffer';
-import { Psbt } from '@btc-vision/bitcoin';
+import { Buffer } from '../../../buffer';
+import { Psbt } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { TransactionType } from '../enums/TransactionType.js';
 import { IInteractionParameters } from '../interfaces/ITransactionParameters.js';
 import { TransactionBuilder } from './TransactionBuilder.js';

package/browser/transaction/builders/MultiSignTransaction.d.ts

@@ -1,4 +1,4 @@
-import { P2TRPayment, Psbt, PsbtInput, Signer, TapScriptSig, Taptree } from '@btc-vision/bitcoin';
+import { P2TRPayment, Psbt, PsbtInput, Signer, TapScriptSig, Taptree } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { TransactionType } from '../enums/TransactionType.js';
 import { ITransactionParameters } from '../interfaces/ITransactionParameters.js';

package/browser/transaction/builders/SharedInteractionTransaction.d.ts

@@ -1,4 +1,4 @@
-import { P2TRPayment, Psbt, PsbtInput, Signer, Taptree } from '@btc-vision/bitcoin';
+import { P2TRPayment, Psbt, PsbtInput, Signer, Taptree } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { ECPairInterface } from 'ecpair';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { TransactionType } from '../enums/TransactionType.js';

package/browser/transaction/builders/TransactionBuilder.d.ts

@@ -1,4 +1,4 @@
-import { Network, Psbt, PsbtInputExtended, PsbtOutputExtended, Signer, Transaction } from '@btc-vision/bitcoin';
+import { Network, Psbt, PsbtInputExtended, PsbtOutputExtended, Signer, Transaction } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { UpdateInput } from '../interfaces/Tap.js';
 import { TransactionType } from '../enums/TransactionType.js';
 import { IFundingTransactionParameters, ITransactionParameters } from '../interfaces/ITransactionParameters.js';

package/browser/transaction/enums/TransactionType.d.ts

@@ -5,5 +5,7 @@ export declare enum TransactionType {
     INTERACTION = 3,
     MULTI_SIG = 4,
     CUSTOM_CODE = 5,
-    CANCEL = 6
+    CANCEL = 6,
+    CONSOLIDATED_SETUP = 7,
+    CONSOLIDATED_REVEAL = 8
 }